TPC: Add lumi source to CorrMapParam

Author: matthias-kleiner

DataFormats/Detectors/TPC/include/DataFormatsTPC/Defs.h

@@ -114,6 +114,13 @@ inline PadFlags operator&(PadFlags a, PadFlags b) { return static_cast<PadFlags>
 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)); }
 
+/// luminosity type used for scaling of the correction or distortions
+enum LumiType {
+  None = 0, ///< default undefined
+  CTP = 1,  ///< CTP
+  IDC = 2   ///< IDCs from TPC
+};
+
 // default point definitions for PointND, PointNDlocal, PointNDglobal are in
 // MathUtils/CartesianND.h
 

Detectors/TPC/calibration/include/TPCCalibration/CorrMapParam.h

@@ -18,6 +18,7 @@
 
 #include "CommonUtils/ConfigurableParam.h"
 #include "CommonUtils/ConfigurableParamHelper.h"
+#include "DataFormatsTPC/Defs.h"
 
 namespace o2
 {
@@ -30,6 +31,7 @@ struct CorrMapParam : public o2::conf::ConfigurableParamHelper<CorrMapParam> {
   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)
   int ctpLumiSource = 0;     // CTP lumi source: 0 = LumiInfo.getLumi(), 1 = LumiInfo.getLumiAlt()
+  LumiType lumiSource{};     // source of luminosity
 
   O2ParamDef(CorrMapParam, "TPCCorrMap");
 };

Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx

@@ -139,6 +139,12 @@ bool CorrectionMapsLoader::accountCCDBInputs(const ConcreteDataMatcher& matcher,
     setCorrMap((o2::gpu::TPCFastTransform*)obj);
     mCorrMap->rectifyAfterReadingFromFile();
     if (getMeanLumiOverride() == 0 && mCorrMap->getLumi() > 0.) {
+      // check if the specified scale type is the same as the lumi from the provided map
+      if (mCorrMap->getLumiSource() == LumiType::None) {
+        LOGP(warning, "Lumi type not set in correction map");
+      } else if (mCorrMap->getLumiSource() != getLumiScaleType()) {
+        LOGP(error, "Lumi scale type {} and lumi source {} for correction map do not match", getLumiScaleType(), int(mCorrMap->getLumiSource()));
+      }
       setMeanLumi(mCorrMap->getLumi());
     }
     LOGP(debug, "MeanLumiOverride={} MeanLumiMap={} -> meanLumi = {}", getMeanLumiOverride(), mCorrMap->getLumi(), getMeanLumi());
@@ -149,6 +155,13 @@ bool CorrectionMapsLoader::accountCCDBInputs(const ConcreteDataMatcher& matcher,
     setCorrMapRef((o2::gpu::TPCFastTransform*)obj);
     mCorrMapRef->rectifyAfterReadingFromFile();
     if (getMeanLumiRefOverride() == 0 && mCorrMapRef->getLumi() > 0.) {
+      // check if the specified scale type is the same as the lumi from the provided map
+      if (mCorrMapRef->getLumiSource() == LumiType::None) {
+        LOGP(warning, "Lumi type not set in reference correction map");
+      } else if ((getLumiScaleMode() != 0) && (mCorrMapRef->getLumiSource() != getLumiScaleType())) {
+        // check only when using derivative map, since for scalemode=0 the lumi of the reference map is not used for scaling
+        LOGP(error, "Lumi scale type {} and lumi source {} for reference correction map do not match", getLumiScaleType(), int(mCorrMapRef->getLumiSource()));
+      }
       setMeanLumiRef(mCorrMapRef->getLumi());
     }
     LOGP(debug, "MeanLumiRefOverride={} MeanLumiMap={} -> meanLumi = {}", getMeanLumiRefOverride(), mCorrMapRef->getLumi(), getMeanLumiRef());
@@ -175,6 +188,12 @@ bool CorrectionMapsLoader::accountCCDBInputs(const ConcreteDataMatcher& matcher,
     setUpdatedLumi();
     int scaleType = getLumiScaleType();
     const std::array<std::string, 3> lumiS{"OFF", "CTP", "TPC scaler"};
+    const auto lumiSource = par.lumiSource;
+    if (lumiSource == LumiType::None) {
+      LOGP(warning, "Lumi type not set in CorrMapParam");
+    } else if (lumiSource != scaleType) {
+      LOGP(error, "Lumi scale type {} and lumi source {} from CorrMapParam do not match", scaleType, int(lumiSource));
+    }
     if (scaleType >= lumiS.size()) {
       LOGP(fatal, "Wrong lumi-scale-type provided!");
     }

Detectors/TPC/spacecharge/include/TPCSpaceCharge/SpaceChargeHelpers.h

@@ -31,12 +31,6 @@ namespace tpc
 {
 
 struct SCMetaData {
-
-  enum LumiType {
-    CTP = 0,
-    IDC = 1
-  };
-
   void print() const
   {
     const std::array<std::string, 2> collisionTypes{"PP", "Pb-Pb"};

GPU/TPCFastTransformation/TPCFastTransform.cxx

@@ -61,6 +61,7 @@ void TPCFastTransform::cloneFromObject(const TPCFastTransform& obj, char* newFla
   mLumi = obj.mLumi;
   mLumiError = obj.mLumiError;
   mLumiScaleFactor = obj.mLumiScaleFactor;
+  mLumiSource = obj.mLumiSource;
   // variable-size data
 
   char* distBuffer = FlatObject::relocatePointer(oldFlatBufferPtr, mFlatBufferPtr, obj.mCorrection.getFlatBufferPtr());

GPU/TPCFastTransformation/TPCFastTransform.h

@@ -22,6 +22,7 @@
 #include "TPCFastSpaceChargeCorrection.h"
 #include "GPUCommonMath.h"
 #include "GPUDebugStreamer.h"
+#include "DataFormatsTPC/Defs.h"
 
 #if !defined(GPUCA_GPUCODE)
 #include <string>
@@ -158,6 +159,7 @@ class TPCFastTransform : public FlatObject
   void setLumi(float l) { mLumi = l; }
   void setLumiError(float e) { mLumiError = e; }
   void setLumiScaleFactor(float s) { mLumiScaleFactor = s; }
+  void setLumiSource(o2::tpc::LumiType l) { mLumiSource = l; }
 
   /// Sets the time stamp of the current calibaration
   void setTimeStamp(long int v) { mTimeStamp = v; }
@@ -253,6 +255,9 @@ class TPCFastTransform : public FlatObject
   /// Return map user defined lumi scale factor
   GPUd() float getLumiScaleFactor() const { return mLumiScaleFactor; }
 
+  /// Return map lumi source type
+  o2::tpc::LumiType getLumiSource() const { return mLumiSource; }
+
   /// maximal possible drift time of the active area
   GPUd() float getMaxDriftTime(int slice, int row, float pad) const;
 
@@ -330,13 +335,15 @@ class TPCFastTransform : public FlatObject
   float mLumiError;       ///< error on luminosity
   float mLumiScaleFactor; ///< user correction factor for lumi (e.g. normalization, efficiency correction etc.)
 
+  o2::tpc::LumiType mLumiSource{o2::tpc::LumiType::CTP}; ///< source of luminosity
+
   /// Correction of (x,u,v) with tricubic interpolator on a regular grid
   TPCSlowSpaceChargeCorrection* mCorrectionSlow{nullptr}; ///< reference space charge corrections
 
   GPUd() void TransformInternal(int slice, int row, float& u, float& v, float& x, const TPCFastTransform* ref, float scale, int scaleMode) const;
 
 #ifndef GPUCA_ALIROOT_LIB
-  ClassDefNV(TPCFastTransform, 3);
+  ClassDefNV(TPCFastTransform, 4);
 #endif
 };