Load CTP lumi by default, even if it is not used for corrections scaling

shahor02 · chiarazampolli · commit b9eeed68b14b · 2024-02-07T16:02:16.000+01:00
CTP Lumi is loaded (unless --disable-ctp-lumi-request explicitly passed) even
if TPC IDC scaler is used for distortions rescaling.
Can be extracted as CorrectionMapsHelper::getInstLumiCTP(), while the
getInstLumi() will return whathever instantaneous rate is used for the
corrections scaling (e.g. the same CTPLumi or IDC scaler for
mLumiScaleType == 1 and 2 respectively).

The TPCCorrMap.lumiInst now overrides only the CTP Lumi (if !=0) but does not
affect IDC scaler. Therefore it cannot be used anymore to disable the corrections
via negative value. Instead, TPCCorrMap.meanLumi &lt; 0 will disable all corrections.
Similarly, the TPCCorrMap.lumiInstFactor is now applied only to CTP Lumi but not to
IDC scaler. Note that the TPCCorrMap.lumiInstFactor will be used as a multiplier
also in the case of the overridden inst. CTP lumi, i.e.
TPCCorrMap.lumiInst*TPCCorrMap.lumiInstFactor will be used as overridden CTP lumi.
diff --git a/Detectors/TPC/calibration/include/TPCCalibration/CorrMapParam.h b/Detectors/TPC/calibration/include/TPCCalibration/CorrMapParam.h
@@ -28,7 +28,7 @@ struct CorrMapParam : public o2::conf::ConfigurableParamHelper<CorrMapParam> {
   float lumiInst = 0.;       // override instantaneous lumi (if > 0) for TPC corr.map scaling, disable corrections if < 0"
   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 corrmap-lumi-inst)
+  float lumiInstFactor = 1.; // scaling to apply to instantaneous lumi from CTP (but not to IDC scaler)
   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
@@ -38,9 +38,10 @@ namespace tpc
 {
 
 struct CorrectionMapsLoaderGloOpts {
-  int lumiType = 0; ///< 0: no scaling, 1: CTP, 2: IDC
-  int lumiMode = 0; ///< 0: classical scaling, 1: Using of the derivative map, 2: Using of the derivative map for MC
+  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 needTPCScalersWorkflow() const
   {
@@ -72,8 +73,8 @@ class CorrectionMapsLoader : public o2::gpu::CorrectionMapsHelper
   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 mInstLumiFactor = 1.0; // multiplicative factor for inst. lumi
-  int mCTPLumiSource = 0;      // 0: main, 1: alternative CTP lumi source
+  float mInstLumiCTPFactor = 1.0; // multiplicative factor for inst. lumi
+  int mLumiCTPSource = 0;         // 0: main, 1: alternative CTP lumi source
   std::unique_ptr<GPUCA_NAMESPACE::gpu::TPCFastTransform> mCorrMapMShape{nullptr};
 #endif
 };
diff --git a/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx b/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
@@ -52,7 +52,8 @@ void CorrectionMapsLoader::extractCCDBInputs(ProcessingContext& pc)
   int dumRep = 0;
   o2::ctp::LumiInfo lumiObj;
   static o2::ctp::LumiInfo lumiPrev;
-  if (getLumiScaleType() == 1 && mInstLumiOverride <= 0.) {
+
+  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 {
@@ -61,10 +62,14 @@ void CorrectionMapsLoader::extractCCDBInputs(ProcessingContext& pc)
       }
       lumiObj = lumiPrev;
     }
-    setInstLumi(mInstLumiFactor * (mCTPLumiSource == 0 ? lumiObj.getLumi() : lumiObj.getLumiAlt()));
-  } else if (getLumiScaleType() == 2 && mInstLumiOverride <= 0.) {
+    setInstLumiCTP(mInstLumiCTPFactor * (mLumiCTPSource == 0 ? lumiObj.getLumi() : lumiObj.getLumiAlt()));
+    if (getLumiScaleType() == 1) {
+      setInstLumi(getInstLumiCTP());
+    }
+  }
+  if (getLumiScaleType() == 2) {
     float tpcScaler = pc.inputs().get<float>("tpcscaler");
-    setInstLumi(mInstLumiFactor * tpcScaler);
+    setInstLumi(tpcScaler);
   }
   if (getUseMShapeCorrection()) {
     LOGP(info, "Setting M-Shape map");
@@ -80,6 +85,7 @@ void CorrectionMapsLoader::extractCCDBInputs(ProcessingContext& pc)
   if (!mScaleInverse) {
     updateInverse();
   }
+  reportScaling();
 }
 
 //________________________________________________________
@@ -99,9 +105,11 @@ void CorrectionMapsLoader::requestCCDBInputs(std::vector<InputSpec>& inputs, std
     LOG(fatal) << "Correction mode unknown! Choose either 0 (default) or 1 (derivative map) for flag corrmap-lumi-mode.";
   }
 
-  if (gloOpts.lumiType == 1) {
+  if (gloOpts.requestCTPLumi) {
     addInput(inputs, {"CTPLumi", "CTP", "LUMI", 0, Lifetime::Timeframe});
-  } else if (gloOpts.lumiType == 2) {
+  }
+
+  if (gloOpts.lumiType == 2) {
     addInput(inputs, {"tpcscaler", o2::header::gDataOriginTPC, "TPCSCALER", 0, Lifetime::Timeframe});
   }
 
@@ -126,9 +134,10 @@ void CorrectionMapsLoader::addOptions(std::vector<ConfigParamSpec>& options)
 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 = require CTP lumi for TPC correction scaling, 2 = require TPC scalers for TPC correction scaling"}});
+  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)"}});
 }
 
 //________________________________________________________
@@ -138,6 +147,10 @@ CorrectionMapsLoaderGloOpts CorrectionMapsLoader::parseGlobalOptions(const o2::f
   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");
+  if (!tpcopt.requestCTPLumi && tpcopt.lumiType == 1) {
+    LOGP(fatal, "Scaling with CTP Lumi is requested but this input is disabled");
+  }
   return tpcopt;
 }
 
@@ -164,7 +177,7 @@ bool CorrectionMapsLoader::accountCCDBInputs(const ConcreteDataMatcher& matcher,
     setCorrMap((o2::gpu::TPCFastTransform*)obj);
     mCorrMap->rectifyAfterReadingFromFile();
     if (getMeanLumiOverride() == 0 && mCorrMap->getLumi() > 0.) {
-      setMeanLumi(mCorrMap->getLumi());
+      setMeanLumi(mCorrMap->getLumi(), false);
     }
     LOGP(debug, "MeanLumiOverride={} MeanLumiMap={} -> meanLumi = {}", getMeanLumiOverride(), mCorrMap->getLumi(), getMeanLumi());
     setUpdatedMap();
@@ -182,29 +195,34 @@ bool CorrectionMapsLoader::accountCCDBInputs(const ConcreteDataMatcher& matcher,
   }
   if (matcher == ConcreteDataMatcher("TPC", "CorrMapParam", 0)) {
     const auto& par = o2::tpc::CorrMapParam::Instance();
-    mMeanLumiOverride = par.lumiMean;
+    mMeanLumiOverride = par.lumiMean; // negative value switches off corrections !!!
     mMeanLumiRefOverride = par.lumiMeanRef;
-    mInstLumiOverride = par.lumiInst;
-    mInstLumiFactor = par.lumiInstFactor;
-    mCTPLumiSource = par.ctpLumiSource;
+    mInstCTPLumiOverride = par.lumiInst;
+    mInstLumiCTPFactor = par.lumiInstFactor;
+    mLumiCTPSource = par.ctpLumiSource;
 
     if (mMeanLumiOverride != 0.) {
       setMeanLumi(mMeanLumiOverride, false);
     }
     if (mMeanLumiRefOverride != 0.) {
       setMeanLumiRef(mMeanLumiRefOverride);
     }
-    if (mInstLumiOverride != 0.) {
-      setInstLumi(mInstLumiOverride, false);
+    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 lumi-scale-type provided!");
     }
-    LOGP(info, "TPC correction map params updated (corr.map scaling type={}): override values: lumiMean={} lumiRefMean={} lumiInst={} lumiScaleMode={}, LumiInst scale={}, CTP Lumi source={}",
-         lumiS[scaleType], mMeanLumiOverride, mMeanLumiRefOverride, mInstLumiOverride, mLumiScaleMode, mInstLumiFactor, mCTPLumiSource);
+
+    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;
 }
@@ -216,20 +234,22 @@ void CorrectionMapsLoader::init(o2::framework::InitContext& ic)
     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}) {
-      if (getLumiScaleType() != 1) {
-        LOGP(fatal, "Lumi scaling source CTP is not compatible with TPC correction lumi scaler type {}", getLumiScaleType());
-      }
+      foundCTP = true;
     } else if (route.matcher == InputSpec{"tpcscaler", o2::header::gDataOriginTPC, "TPCSCALER", 0, Lifetime::Timeframe}) {
-      if (getLumiScaleType() != 2) {
-        LOGP(fatal, "Lumi scaling source TPCScaler is not compatible with TPC correction lumi scaler type {}", getLumiScaleType());
-      }
-      setLumiScaleType(2);
+      foundTPCScl = true;
     } else if (route.matcher == InputSpec{"mshape", o2::header::gDataOriginTPC, "TPCMSHAPE", 0, Lifetime::Timeframe}) {
-      enableMShapeCorrection(true);
+      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>("do-not-recalculate-inverse-correction");
   } else {
@@ -243,16 +263,18 @@ void CorrectionMapsLoader::init(o2::framework::InitContext& ic)
 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());
-  setInstLumiOverride(src.getInstLumiOverride());
+  setInstCTPLumiOverride(src.getInstCTPLumiOverride());
   setLumiScaleMode(src.getLumiScaleMode());
   enableMShapeCorrection(src.getUseMShapeCorrection());
-  mInstLumiFactor = src.mInstLumiFactor;
-  mCTPLumiSource = src.mCTPLumiSource;
+  mInstLumiCTPFactor = src.mInstLumiCTPFactor;
+  mLumiCTPSource = src.mLumiCTPSource;
   mLumiScaleMode = src.mLumiScaleMode;
   mScaleInverse = src.getScaleInverse();
 }
diff --git a/GPU/TPCFastTransformation/CorrectionMapsHelper.cxx b/GPU/TPCFastTransformation/CorrectionMapsHelper.cxx
@@ -22,10 +22,12 @@ void CorrectionMapsHelper::clear()
     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;
@@ -95,8 +97,26 @@ void CorrectionMapsHelper::setCorrMapMShape(std::unique_ptr<TPCFastTransform>&&
   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: InstLumiOverride={}, LumiScaleType={} -> instLumi={}, meanLumiRef={}, meanLumi={} -> LumiScale={}, lumiScaleMode={}, is M-Shape map valid: {}, is M-Shape default: {}", getInstLumiOverride(), getLumiScaleType(), getInstLumi(), getMeanLumiRef(), getMeanLumi(), getLumiScale(), getLumiScaleMode(), (mCorrMapMShape != nullptr), isCorrMapMShapeDummy());
+  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());
 }
diff --git a/GPU/TPCFastTransformation/CorrectionMapsHelper.h b/GPU/TPCFastTransformation/CorrectionMapsHelper.h
@@ -34,6 +34,7 @@ class CorrectionMapsHelper
   CorrectionMapsHelper() = default;
   ~CorrectionMapsHelper() { clear(); }
   CorrectionMapsHelper(const CorrectionMapsHelper&) = delete;
+  void updateLumiScale(bool report = false);
   void clear();
 
   GPUd() void Transform(int slice, int row, float pad, float time, float& x, float& y, float& z, float vertexTime = 0) const
@@ -66,15 +67,22 @@ class CorrectionMapsHelper
   void setCorrMapRef(GPUCA_NAMESPACE::gpu::TPCFastTransform* m);
   void setCorrMapMShape(GPUCA_NAMESPACE::gpu::TPCFastTransform* m);
   void reportScaling();
-  void setInstLumi(float v, bool report = true)
+  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 = true)
+  void setMeanLumi(float v, bool report = false)
   {
     if (v != mMeanLumi) {
       mMeanLumi = v;
@@ -93,26 +101,11 @@ class CorrectionMapsHelper
   {
     if (v != mLumiScaleMode) {
       mLumiScaleMode = v;
-      updateLumiScale();
-    }
-  }
-
-  void updateLumiScale(bool report = true)
-  {
-    if (mMeanLumi < 0.f || mInstLumi < 0.f) {
-      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();
+      updateLumiScale(false);
     }
   }
 
+  GPUd() float getInstLumiCTP() const { return mInstLumiCTP; }
   GPUd() float getInstLumi() const { return mInstLumi; }
   GPUd() float getMeanLumi() const { return mMeanLumi; }
   GPUd() float getMeanLumiRef() const { return mMeanLumiRef; }
@@ -137,19 +130,20 @@ class CorrectionMapsHelper
 #endif
   void setOwner(bool v);
   void acknowledgeUpdate() { mUpdatedFlags = 0; }
-
+  void setLumiCTPAvailable(bool v) { mLumiCTPAvailable = v; }
+  bool getLumiCTPAvailable() const { return mLumiCTPAvailable; }
   void setLumiScaleType(int v) { mLumiScaleType = v; }
   int 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 setInstLumiOverride(float f) { mInstLumiOverride = f; }
-  float getInstLumiOverride() const { return mInstLumiOverride; }
+  void setInstCTPLumiOverride(float f) { mInstCTPLumiOverride = f; }
+  float getInstCTPLumiOverride() const { return mInstCTPLumiOverride; }
 
   int getUpdateFlags() const { return mUpdatedFlags; }
 
@@ -171,24 +165,26 @@ class CorrectionMapsHelper
                      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
-  int mLumiScaleType = -1; // require CTP Lumi for mInstLumi
+  int mLumiScaleType = -1; // use CTP Lumi (1) or TPCScaler (2) for the correction scaling, 0 - no scaling
   int mLumiScaleMode = -1; // scaling-mode of the correciton maps
   int mUpdatedFlags = 0;
-  float mInstLumi = 0.;                                            // instanteneous luminosity (a.u)
-  float mMeanLumi = 0.;                                            // mean luminosity of the map (a.u)
-  float mMeanLumiRef = 0.;                                         // mean luminosity of the ref map (a.u)
+  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 mInstLumiOverride = -1.f;                                  // optional value to override inst 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
   GPUCA_NAMESPACE::gpu::TPCFastTransform* mCorrMap{nullptr};       // current transform
   GPUCA_NAMESPACE::gpu::TPCFastTransform* mCorrMapRef{nullptr};    // reference transform
   GPUCA_NAMESPACE::gpu::TPCFastTransform* mCorrMapMShape{nullptr}; // correction map for v-shape distortions on A-side
 #ifndef GPUCA_ALIROOT_LIB
-  ClassDefNV(CorrectionMapsHelper, 5);
+  ClassDefNV(CorrectionMapsHelper, 6);
 #endif
 };
 
