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.

Author: shahor02

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");

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) 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);

Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx

@@ -176,20 +176,22 @@ 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);
+    float mapMeanRate = getMapMeanRate(mCorrMap); // instead of mCorrMap->getLumi()
+    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();
+    float mapRefMeanRate = getMapMeanRate(mCorrMapRef); // instead of mCorrMapRef->getLumi()
     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;
   }
@@ -296,4 +298,27 @@ void CorrectionMapsLoader::updateInverse()
   }
 }
 
+float CorrectionMapsLoader::getMapMeanRate(const o2::gpu::TPCFastTransform* mp) const
+{
+  float val = 0;
+  if (getLumiScaleType() == 1) { // CTP Lumi
+    val = mp->getLumi();
+  } else if (getLumiScaleType() == 2) { // TPC Scaler (IDC)
+    val = mp->getIDC();
+    if (val < 0. && mp->getLumi() >= 0.) {
+      if (mp->getLumi() < o2::tpc::CorrMapParam::Instance().CTP2IDCFallBackThreshold) {
+        val = mp->getLumi();
+        static bool reportFallBack = true;
+        if (reportFallBack) {
+          reportFallBack = false;
+          LOGP(warn, "IDC scaling is requested but map IDC record is empty. Since map Lumi={} is less than fall-back threshold {}, interpret Lumi record as IDC",
+               val, o2::tpc::CorrMapParam::Instance().CTP2IDCFallBackThreshold);
+        }
+      } else {
+        LOGP(fatal, "IDC scaling is requested but map IDC record is empty. The map Lumi={} exceeds Lumi->IDC fall-back threshold {}", mp->getLumi(), o2::tpc::CorrMapParam::Instance().CTP2IDCFallBackThreshold);
+      }
+    }
+  }
+  return val;
+}
 #endif // #ifndef GPUCA_GPUCODE_DEVICE

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(-1.0f), mLumiError(0.f), mLumiScaleFactor(1.0f), mIDC(-1.f), mIDCError(0.f)
 {
   // Default Constructor: creates an empty uninitialized object
 }
@@ -60,6 +60,8 @@ void TPCFastTransform::cloneFromObject(const TPCFastTransform& obj, char* newFla
   mPrimVtxZ = obj.mPrimVtxZ;
   mLumi = obj.mLumi;
   mLumiError = obj.mLumiError;
+  mIDC = obj.mIDC;
+  mIDCError = obj.mIDCError;
   mLumiScaleFactor = obj.mLumiScaleFactor;
   // variable-size data
 
@@ -108,8 +110,10 @@ void TPCFastTransform::startConstruction(const TPCFastSpaceChargeCorrection& cor
   mLdriftCorr = 0.f;
   mTOFcorr = 0.f;
   mPrimVtxZ = 0.f;
-  mLumi = 0.f;
+  mLumi = -1.0f;
   mLumiError = 0.f;
+  mIDC = -1.0f;
+  mIDCError = 0.f;
   mLumiScaleFactor = 1.f;
 
   // variable-size data
@@ -160,6 +164,8 @@ 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) << "mLumiScaleFactor = " << mLumiScaleFactor;
   mCorrection.print();
 #endif

GPU/TPCFastTransformation/TPCFastTransform.h

@@ -162,6 +162,8 @@ 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; }
 
   /// Sets the time stamp of the current calibaration
   void setTimeStamp(int64_t v) { mTimeStamp = v; }
@@ -254,6 +256,12 @@ class TPCFastTransform : public FlatObject
   /// Return map lumi error
   GPUd() float getLumiError() const { return mLumiError; }
 
+  /// Return map lumi
+  GPUd() float getIDC() const { return mIDC; }
+
+  /// Return map lumi error
+  GPUd() float getIDCError() const { return mIDCError; }
+
   /// Return map user defined lumi scale factor
   GPUd() float getLumiScaleFactor() const { return mLumiScaleFactor; }
 
@@ -334,12 +342,15 @@ 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
+
   /// 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);
 };
 
 // =======================================================================