Revert "TPC: Derivative map implementation (#11585)"

Detectors/TPC/base/include/TPCBase/CDBInterface.h

@@ -82,10 +82,8 @@ enum class CDBType {
   CalITPC0,            ///< 2D average TPC clusters for longer time interval
   CalITPC1,            ///< 1D integrated TPC clusters
                        ///
-  CalCorrMap,          ///< Cluster correction map (high IR rate distortions)
+  CalCorrMap,          ///< Cluster correction map
   CalCorrMapRef,       ///< Cluster correction reference map (static distortions)
-                       ///
-  CalCorrDerivMap,     ///< Cluster correction map (derivative map)
 };
 
 /// Upload intervention type
@@ -143,8 +141,6 @@ const std::unordered_map<CDBType, const std::string> CDBTypeMap{
   // correction maps
   {CDBType::CalCorrMap, "TPC/Calib/CorrectionMap"},
   {CDBType::CalCorrMapRef, "TPC/Calib/CorrectionMapRef"},
-  // derivative map correction
-  {CDBType::CalCorrDerivMap, "TPC/Calib/CorrectionMapDerivative"},
 };
 
 /// Poor enum reflection ...

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

@@ -48,7 +48,7 @@ class CorrectionMapsLoader : public o2::gpu::CorrectionMapsHelper
   void extractCCDBInputs(o2::framework::ProcessingContext& pc);
   void updateVDrift(float vdriftCorr, float vdrifRef, float driftTimeOffset = 0);
   void init(o2::framework::InitContext& ic);
-  static void requestCCDBInputs(std::vector<o2::framework::InputSpec>& inputs, std::vector<o2::framework::ConfigParamSpec>& options, bool requestCTPLumi = false, int lumiScaleMode = 0);
+  static void requestCCDBInputs(std::vector<o2::framework::InputSpec>& inputs, std::vector<o2::framework::ConfigParamSpec>& options, bool requestCTPLumi = false);
   static void addOptions(std::vector<o2::framework::ConfigParamSpec>& options);
 
  protected:

Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx

@@ -49,17 +49,10 @@ void CorrectionMapsLoader::extractCCDBInputs(ProcessingContext& pc)
 }
 
 //________________________________________________________
-void CorrectionMapsLoader::requestCCDBInputs(std::vector<InputSpec>& inputs, std::vector<o2::framework::ConfigParamSpec>& options, bool requestCTPLumi, int lumiScaleMode)
+void CorrectionMapsLoader::requestCCDBInputs(std::vector<InputSpec>& inputs, std::vector<o2::framework::ConfigParamSpec>& options, bool requestCTPLumi)
 {
   addInput(inputs, {"tpcCorrMap", "TPC", "CorrMap", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrMap), {}, 1)});          // time-dependent
-  if (lumiScaleMode == 0) {
-    addInput(inputs, {"tpcCorrMapRef", "TPC", "CorrMapRef", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrMapRef), {}, 0)}); // load once
-  } else if (lumiScaleMode == 1) {
-    addInput(inputs, {"tpcCorrMapRef", "TPC", "CorrMapRef", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrDerivMap), {}, 1)}); // time-dependent
-  } else {
-    LOG(fatal) << "Correction mode unknown! Choose either 0 (default) or 1 (derivative map) for flag corrmap-lumi-mode.";
-  }
-
+  addInput(inputs, {"tpcCorrMapRef", "TPC", "CorrMapRef", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrMapRef), {}, 0)}); // load once
   if (requestCTPLumi) {
     addInput(inputs, {"CTPLumi", "CTP", "LUMI", 0, Lifetime::Timeframe});
   }
@@ -98,7 +91,6 @@ bool CorrectionMapsLoader::accountCCDBInputs(const ConcreteDataMatcher& matcher,
     if (getMeanLumiOverride() <= 0 && mCorrMap->getLumi() > 0.) {
       setMeanLumi(mCorrMap->getLumi());
     }
-    mCorrMap->setLumiScaleMode(getLumiScaleMode());
     LOGP(debug, "MeanLumiOverride={} MeanLumiMap={} -> meanLumi = {}", getMeanLumiOverride(), mCorrMap->getLumi(), getMeanLumi());
     setUpdatedMap();
     return true;
@@ -130,6 +122,6 @@ void CorrectionMapsLoader::init(o2::framework::InitContext& ic)
   if (mInstLumiOverride != 0.) {
     setInstLumi(mInstLumiOverride);
   }
-  LOGP(info, "CTP Lumi request for TPC corr.map scaling={}, override values: lumiMean={} lumiInst={} lumiScaleMode={}", getUseCTPLumi() ? "ON" : "OFF", mMeanLumiOverride, mInstLumiOverride, mLumiScaleMode);
+  LOGP(info, "CTP Lumi request for TPC corr.map scaling={}, override values: lumiMean={} lumiInst={}", getUseCTPLumi() ? "ON" : "OFF", mMeanLumiOverride, mInstLumiOverride);
 }
 #endif // #ifndef GPUCA_GPUCODE_DEVICE

Detectors/TPC/workflow/include/TPCWorkflow/RecoWorkflow.h

@@ -83,8 +83,7 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData,
                                     bool askDISTSTF = true,
                                     bool selIR = false,
                                     bool filteredInp = false,
-                                    bool requireCTPLumi = false,
-                                    int lumiScaleMode = 0);
+                                    bool requireCTPLumi = false);
 
 void cleanupCallback();
 

Detectors/TPC/workflow/src/RecoWorkflow.cxx

@@ -95,7 +95,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,
                                     bool propagateMC, unsigned nLanes, std::string const& cfgInput, std::string const& cfgOutput, bool disableRootInput,
-                                    int caClusterer, int zsOnTheFly, bool askDISTSTF, bool selIR, bool filteredInp, bool requireCTPLumi, int lumiScaleMode)
+                                    int caClusterer, int zsOnTheFly, bool askDISTSTF, bool selIR, bool filteredInp, bool requireCTPLumi)
 {
   InputType inputType;
   try {
@@ -431,7 +431,6 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData, std::vecto
     o2::gpu::GPURecoWorkflowSpec::Config cfg;
     cfg.runTPCTracking = true;
     cfg.requireCTPLumi = requireCTPLumi;
-    cfg.lumiScaleMode = lumiScaleMode;
     cfg.decompressTPC = decompressTPC;
     cfg.decompressTPCFromROOT = decompressTPC && inputType == InputType::CompClusters;
     cfg.caClusterer = caClusterer;

Detectors/TPC/workflow/src/tpc-reco-workflow.cxx

@@ -69,7 +69,6 @@ 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"}},
     {"require-ctp-lumi", o2::framework::VariantType::Bool, false, {"require CTP lumi for TPC correction scaling"}},
-    {"corrmap-lumi-mode", VariantType::Int, 0, {"scaling mode: (default) 0  = static + scale * full; 1 = full + scale * derivative"}},
     {"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
@@ -140,7 +139,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   auto nLanes = cfgc.options().get<int>("tpc-lanes");
   auto inputType = cfgc.options().get<std::string>("input-type");
   auto requireCTPLumi = cfgc.options().get<bool>("require-ctp-lumi");
-  auto lumiScaleMode = cfgc.options().get<int>("corrmap-lumi-mode");
   // depending on whether to dispatch early (prompt) and on the input type, we
   // set the matcher. Note that this has to be in accordance with the OutputSpecs
   // configured for the PublisherSpec
@@ -181,8 +179,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
                                                 !cfgc.options().get<bool>("ignore-dist-stf"),      //
                                                 cfgc.options().get<bool>("select-ir-frames"),
                                                 cfgc.options().get<bool>("filtered-input"),
-                                                requireCTPLumi,
-                                                lumiScaleMode);
+                                                requireCTPLumi);
 
   // configure dpl timer to inject correct firstTForbit: start from the 1st orbit of TF containing 1st sampled orbit
   o2::raw::HBFUtilsInitializer hbfIni(cfgc, wf);

GPU/TPCFastTransformation/CorrectionMapsHelper.cxx

@@ -77,5 +77,5 @@ void CorrectionMapsHelper::setCorrMapRef(std::unique_ptr<TPCFastTransform>&& m)
 //________________________________________________________
 void CorrectionMapsHelper::reportScaling()
 {
-  LOGP(info, "InstLumiOverride={}, UseCTPLumi={} -> instLumi={}, meanLumi={} -> LumiScale={}, lumiScaleMode={}", getInstLumiOverride(), getUseCTPLumi(), getInstLumi(), getMeanLumi(), getLumiScale(), getLumiScaleMode());
+  LOGP(info, "InstLumiOverride={}, UseCTPLumi={} -> instLumi={}, meanLumi={} -> LumiScale={}", getInstLumiOverride(), getUseCTPLumi(), getInstLumi(), getMeanLumi(), getLumiScale());
 }

GPU/TPCFastTransformation/CorrectionMapsHelper.h

@@ -80,20 +80,10 @@ class CorrectionMapsHelper
     }
   }
 
-  void setLumiScaleMode(int v)
-  {
-    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) {
-      mLumiScale = mMeanLumi ? mInstLumi / mMeanLumi - 1. : 0.f;
     } else {
       mLumiScale = mMeanLumi ? mInstLumi / mMeanLumi : 0.f;
     }
@@ -106,7 +96,6 @@ class CorrectionMapsHelper
   GPUd() float getInstLumi() const { return mInstLumi; }
   GPUd() float getMeanLumi() const { return mMeanLumi; }
   GPUd() float getLumiScale() const { return mLumiScale; }
-  GPUd() int getLumiScaleMode() const { return mLumiScaleMode; }
 
   bool isUpdated() const { return mUpdatedFlags != 0; }
   bool isUpdatedMap() const { return (mUpdatedFlags & UpdateFlags::MapBit) != 0; }
@@ -143,14 +132,13 @@ class CorrectionMapsHelper
   int mUpdatedFlags = 0;
   float mInstLumi = 0.;                                         // instanteneous luminosity (a.u)
   float mMeanLumi = 0.;                                         // mean luminosity of the map (a.u)
-  float mLumiScale = 0.;                                        // precalculated lumi scaling
-  int mLumiScaleMode = 0;                                       // scaling-mode of the correciton maps
+  float mLumiScale = 0.;                                        // precalculated mInstLumi/mMeanLumi
   float mMeanLumiOverride = -1.f;                               // optional value to override mean lumi
   float mInstLumiOverride = -1.f;                               // optional value to override inst lumi
   GPUCA_NAMESPACE::gpu::TPCFastTransform* mCorrMap{nullptr};    // current transform
   GPUCA_NAMESPACE::gpu::TPCFastTransform* mCorrMapRef{nullptr}; // reference transform
 #ifndef GPUCA_ALIROOT_LIB
-  ClassDefNV(CorrectionMapsHelper, 2);
+  ClassDefNV(CorrectionMapsHelper, 1);
 #endif
 };
 

GPU/TPCFastTransformation/TPCFastTransform.cxx

@@ -37,7 +37,7 @@
 using namespace GPUCA_NAMESPACE::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), mLumiScaleMode(0)
+  : 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)
 {
   // Default Constructor: creates an empty uninitialized object
 }
@@ -61,7 +61,6 @@ void TPCFastTransform::cloneFromObject(const TPCFastTransform& obj, char* newFla
   mLumi = obj.mLumi;
   mLumiError = obj.mLumiError;
   mLumiScaleFactor = obj.mLumiScaleFactor;
-  mLumiScaleMode = obj.mLumiScaleMode;
   // variable-size data
 
   char* distBuffer = FlatObject::relocatePointer(oldFlatBufferPtr, mFlatBufferPtr, obj.mCorrection.getFlatBufferPtr());
@@ -112,7 +111,6 @@ void TPCFastTransform::startConstruction(const TPCFastSpaceChargeCorrection& cor
   mLumi = 0.f;
   mLumiError = 0.f;
   mLumiScaleFactor = 1.f;
-  mLumiScaleMode = 0;
 
   // variable-size data
 
@@ -163,7 +161,6 @@ void TPCFastTransform::print() const
   LOG(info) << "mLumi = " << mLumi;
   LOG(info) << "mLumiError = " << mLumiError;
   LOG(info) << "mLumiScaleFactor = " << mLumiScaleFactor;
-  LOG(info) << "mLumiScaleMode = " << mLumiScaleMode;
   mCorrection.print();
 #endif
 }

GPU/TPCFastTransformation/TPCFastTransform.h

@@ -158,7 +158,6 @@ class TPCFastTransform : public FlatObject
   void setLumi(float l) { mLumi = l; }
   void setLumiError(float e) { mLumiError = e; }
   void setLumiScaleFactor(float s) { mLumiScaleFactor = s; }
-  void setLumiScaleMode(int m) { mLumiScaleMode = m; }
 
   /// Sets the time stamp of the current calibaration
   void setTimeStamp(long int v) { mTimeStamp = v; }
@@ -254,9 +253,6 @@ class TPCFastTransform : public FlatObject
   /// Return map user defined lumi scale factor
   GPUd() float getLumiScaleFactor() const { return mLumiScaleFactor; }
 
-  /// Return map user defined lumi scale mode
-  GPUd() int getLumiScaleMode() const { return mLumiScaleMode; }
-
   /// maximal possible drift time of the active area
   GPUd() float getMaxDriftTime(int slice, int row, float pad) const;
 
@@ -333,15 +329,14 @@ class TPCFastTransform : public FlatObject
   float mLumi;            ///< luminosity estimator
   float mLumiError;       ///< error on luminosity
   float mLumiScaleFactor; ///< user correction factor for lumi (e.g. normalization, efficiency correction etc.)
-  int mLumiScaleMode;     ///< scale mode for the derivative or reference luminosity map
 
   /// 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) const;
 
 #ifndef GPUCA_ALIROOT_LIB
-  ClassDefNV(TPCFastTransform, 4);
+  ClassDefNV(TPCFastTransform, 3);
 #endif
 };
 
@@ -469,19 +464,11 @@ GPUdi() void TPCFastTransform::TransformInternal(int slice, int row, float& u, f
       {
         mCorrection.getCorrection(slice, row, u, v, dx, du, dv);
         if (ref && scale > 0.f) { // scaling was requested
-          if (mLumiScaleMode == 0) {
-            float dxRef, duRef, dvRef;
-            ref->mCorrection.getCorrection(slice, row, u, v, dxRef, duRef, dvRef);
-            dx = (dx - dxRef) * scale + dxRef;
-            du = (du - duRef) * scale + duRef;
-            dv = (dv - dvRef) * scale + dvRef;
-          } else if (mLumiScaleMode == 1) {
-            float dxRef, duRef, dvRef;
-            ref->mCorrection.getCorrection(slice, row, u, v, dxRef, duRef, dvRef);
-            dx = dxRef * scale + dx;
-            du = duRef * scale + du;
-            dv = dvRef * scale + dv;
-          }
+          float dxRef, duRef, dvRef;
+          ref->mCorrection.getCorrection(slice, row, u, v, dxRef, duRef, dvRef);
+          dx = (dx - dxRef) * scale + dxRef;
+          du = (du - duRef) * scale + duRef;
+          dv = (dv - dvRef) * scale + dvRef;
         }
       }
     }
@@ -739,15 +726,9 @@ GPUdi() void TPCFastTransform::InverseTransformYZtoX(int slice, int row, float y
   if (scale >= 0.f) {
     mCorrection.getCorrectionInvCorrectedX(slice, row, u, v, x);
     if (ref && scale > 0.f) { // scaling was requested
-      if (mLumiScaleMode == 0) {
-        float xr;
-        ref->mCorrection.getCorrectionInvCorrectedX(slice, row, u, v, xr);
-        x = (x - xr) * scale + xr;
-      } else if (mLumiScaleMode == 1) {
-        float xr;
-        ref->mCorrection.getCorrectionInvCorrectedX(slice, row, u, v, xr);
-        x = xr * scale + x;
-      }
+      float xr;
+      ref->mCorrection.getCorrectionInvCorrectedX(slice, row, u, v, xr);
+      x = (x - xr) * scale + xr;
     }
   }
   GPUCA_DEBUG_STREAMER_CHECK(if (o2::utils::DebugStreamer::checkStream(o2::utils::StreamFlags::streamFastTransform)) {
@@ -772,17 +753,10 @@ GPUdi() void TPCFastTransform::InverseTransformYZtoNominalYZ(int slice, int row,
   if (scale >= 0.f) {
     mCorrection.getCorrectionInvUV(slice, row, u, v, un, vn);
     if (ref && scale > 0.f) { // scaling was requested
-      if (mLumiScaleMode == 0) {
-        float unr = 0, vnr = 0;
-        ref->mCorrection.getCorrectionInvUV(slice, row, u, v, unr, vnr);
-        un = (un - unr) * scale + unr;
-        vn = (vn - vnr) * scale + vnr;
-      } else if (mLumiScaleMode == 1) {
-        float unr = 0, vnr = 0;
-        ref->mCorrection.getCorrectionInvUV(slice, row, u, v, unr, vnr);
-        un = unr * scale + un;
-        vn = vnr * scale + vn;
-      }
+      float unr = 0, vnr = 0;
+      ref->mCorrection.getCorrectionInvUV(slice, row, u, v, unr, vnr);
+      un = (un - unr) * scale + unr;
+      vn = (vn - vnr) * scale + vnr;
     }
   }
   getGeometry().convUVtoLocal(slice, un, vn, ny, nz);

GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h

@@ -106,7 +106,6 @@ class GPURecoWorkflowSpec : public o2::framework::Task
     bool runITSTracking = false;
     int itsTriggerType = 0;
     bool itsOverrBeamEst = false;
-    int lumiScaleMode = 0;
   };
 
   GPURecoWorkflowSpec(CompletionPolicyData* policyData, Config const& specconfig, std::vector<int> const& tpcsectors, unsigned long tpcSectorMask, std::shared_ptr<o2::base::GRPGeomRequest>& ggr);

GPU/Workflow/src/GPUWorkflowSpec.cxx

@@ -1144,7 +1144,7 @@ Inputs GPURecoWorkflowSpec::inputs()
     inputs.emplace_back("tpcthreshold", gDataOriginTPC, "PADTHRESHOLD", 0, Lifetime::Condition, ccdbParamSpec("TPC/Config/FEEPad"));
     o2::tpc::VDriftHelper::requestCCDBInputs(inputs);
     Options optsDummy;
-    mFastTransformHelper->requestCCDBInputs(inputs, optsDummy, mSpecConfig.requireCTPLumi, mSpecConfig.lumiScaleMode); // option filled here is lost
+    mFastTransformHelper->requestCCDBInputs(inputs, optsDummy, mSpecConfig.requireCTPLumi); // 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});
@@ -1350,7 +1350,6 @@ void GPURecoWorkflowSpec::initFunctionTPCCalib(InitContext& ic)
   mFastTransformRef = std::move(o2::tpc::TPCFastTransformHelperO2::instance()->create(0));
   mFastTransformHelper->setCorrMap(mFastTransform.get()); // just to reserve the space
   mFastTransformHelper->setCorrMapRef(mFastTransformRef.get());
-  mFastTransformHelper->setLumiScaleMode(mSpecConfig.lumiScaleMode);
   if (mSpecConfig.outputTracks) {
     mFastTransformHelper->init(ic);
   }
@@ -1612,7 +1611,6 @@ bool GPURecoWorkflowSpec::fetchCalibsCCDBTPC(ProcessingContext& pc, T& newCalibO
           mFastTransformHelperNew->setUseCTPLumi(mFastTransformHelper->getUseCTPLumi());
           mFastTransformHelperNew->setMeanLumiOverride(mFastTransformHelper->getMeanLumiOverride());
           mFastTransformHelperNew->setInstLumiOverride(mFastTransformHelper->getInstLumiOverride());
-          mFastTransformHelperNew->setLumiScaleMode(mFastTransformHelper->getLumiScaleMode());
           mFastTransformHelperNew->setCorrMap(mFastTransformNew ? mFastTransformNew.get() : mFastTransform.get());
           mFastTransformHelperNew->setCorrMapRef(mFastTransformRefNew ? mFastTransformRefNew.get() : mFastTransformRef.get());
           mFastTransformHelperNew->acknowledgeUpdate();