GPU: Unify some constants

davidrohr · davidrohr · commit 4415c88db71d · 2026-04-09T15:54:29.000+02:00
diff --git 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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -39,7 +40,7 @@
 
 #define TPC_ROWS_PER_CRU 18
 #define TPC_PADS_PER_ROW_PADDED (TPC_PADS_PER_ROW + GPUCF_PADDING_PAD)
-#define TPC_NUM_OF_PADS (GPUTPCGeometry::NROWS * TPC_PADS_PER_ROW_PADDED + GPUCF_PADDING_PAD)
+#define TPC_NUM_OF_PADS (o2::tpc::constants::MAXGLOBALPADROW * TPC_PADS_PER_ROW_PADDED + GPUCF_PADDING_PAD)
 #define TPC_PADS_IN_SECTOR 14560
 #define TPC_FEC_IDS_IN_SECTOR 23296
 #define TPC_MAX_FRAGMENT_LEN_GPU 4000
diff --git 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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
diff --git a/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h b/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h

Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,7 @@`
`20`	`20`	`#include "GPUCommonMath.h"`
`21`	`21`	`#include "GPUParam.h"`
`22`	`22`	`#include "DataFormatsTPC/CompressedClusters.h"`
	`23`	`+#include "GPUTPCGeometry.h"`
`23`	`24`
`24`	`25`	`namespace o2::gpu`
`25`	`26`	`{`
Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,7 @@`
`21`	`21`	`#include "GPUParam.h"`
`22`	`22`	`#include "GPUO2DataTypes.h"`
`23`	`23`	`#include "DataFormatsTPC/CompressedClusters.h"`
	`24`	`+#include "GPUTPCGeometry.h"`
`24`	`25`
`25`	`26`	`namespace o2::gpu`
`26`	`27`	`{`
Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,7 @@`
`17`	`17`
`18`	`18`	`#include "clusterFinderDefs.h"`
`19`	`19`	`#include "GPUCommonMath.h"`
	`20`	`+#include "DataFormatsTPC/Constants.h"`
`20`	`21`
`21`	`22`	`namespace o2::tpc`
`22`	`23`	`{`
`@@ -81,14 +82,14 @@ struct TPCPadGainCalib {`
`81`	`82`
`82`	`83`	`GPUdi() void setMinCorrectionFactor(const float minCorrectionFactor)`
`83`	`84`	`{`
`84`		`- for (uint32_t sector = 0; sector < GPUTPCGeometry::NSECTORS; sector++) {`
	`85`	`+ for (uint32_t sector = 0; sector < o2::tpc::constants::MAXSECTOR; sector++) {`
`85`	`86`	`mGainCorrection[sector].mMinCorrectionFactor = minCorrectionFactor;`
`86`	`87`	`}`
`87`	`88`	`}`
`88`	`89`
`89`	`90`	`GPUdi() void setMaxCorrectionFactor(const float maxCorrectionFactor)`
`90`	`91`	`{`
`91`		`- for (uint32_t sector = 0; sector < GPUTPCGeometry::NSECTORS; sector++) {`
	`92`	`+ for (uint32_t sector = 0; sector < o2::tpc::constants::MAXSECTOR; sector++) {`
`92`	`93`	`mGainCorrection[sector].mMaxCorrectionFactor = maxCorrectionFactor;`
`93`	`94`	`}`
`94`	`95`	`}`
`@@ -153,8 +154,8 @@ struct TPCPadGainCalib {`
`153`	`154`	`}`
`154`	`155`	`};`
`155`	`156`
`156`		`- uint16_t mPadOffsetPerRow[GPUTPCGeometry::NROWS];`
`157`		`- SectorPadGainCorrection<uint16_t> mGainCorrection[GPUTPCGeometry::NSECTORS];`
	`157`	`+ uint16_t mPadOffsetPerRow[o2::tpc::constants::MAXGLOBALPADROW];`
	`158`	`+ SectorPadGainCorrection<uint16_t> mGainCorrection[o2::tpc::constants::MAXSECTOR];`
`158`	`159`	`};`
`159`	`160`
`160`	`161`	`} // namespace o2::gpu`