diff --git a/Detectors/TPC/base/include/TPCBase/CDBInterface.h b/Detectors/TPC/base/include/TPCBase/CDBInterface.h
index 256a32e7f4277..e3ac85f8c1090 100644
--- a/Detectors/TPC/base/include/TPCBase/CDBInterface.h
+++ b/Detectors/TPC/base/include/TPCBase/CDBInterface.h
@@ -82,8 +82,10 @@ enum class CDBType {
   CalITPC0,            ///< 2D average TPC clusters for longer time interval
   CalITPC1,            ///< 1D integrated TPC clusters
                        ///
-  CalCorrMap,          ///< Cluster correction map
+  CalCorrMap,          ///< Cluster correction map (high IR rate distortions)
   CalCorrMapRef,       ///< Cluster correction reference map (static distortions)
+                       ///
+  CalCorrDerivMap,     ///< Cluster correction map (derivative map)
 };
 
 /// Upload intervention type
@@ -141,6 +143,8 @@ 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 ...
diff --git a/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoader.h b/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoader.h
index a6fb29bb2e8c7..0771b922a19d4 100644
--- a/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoader.h
+++ b/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);
+  static void requestCCDBInputs(std::vector<o2::framework::InputSpec>& inputs, std::vector<o2::framework::ConfigParamSpec>& options, bool requestCTPLumi = false, int lumiScaleMode = 0);
   static void addOptions(std::vector<o2::framework::ConfigParamSpec>& options);
 
  protected:
diff --git a/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx b/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
index 2e557aac67dbf..36d0abbd11229 100644
--- a/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
+++ b/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
@@ -49,10 +49,17 @@ void CorrectionMapsLoader::extractCCDBInputs(ProcessingContext& pc)
 }
 
 //________________________________________________________
-void CorrectionMapsLoader::requestCCDBInputs(std::vector<InputSpec>& inputs, std::vector<o2::framework::ConfigParamSpec>& options, bool requestCTPLumi)
+void CorrectionMapsLoader::requestCCDBInputs(std::vector<InputSpec>& inputs, std::vector<o2::framework::ConfigParamSpec>& options, bool requestCTPLumi, int lumiScaleMode)
 {
   addInput(inputs, {"tpcCorrMap", "TPC", "CorrMap", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrMap), {}, 1)});          // time-dependent
-  addInput(inputs, {"tpcCorrMapRef", "TPC", "CorrMapRef", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrMapRef), {}, 0)}); // load once
+  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.";
+  }
+
   if (requestCTPLumi) {
     addInput(inputs, {"CTPLumi", "CTP", "LUMI", 0, Lifetime::Timeframe});
   }
@@ -91,6 +98,7 @@ 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;
@@ -122,6 +130,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={}", getUseCTPLumi() ? "ON" : "OFF", mMeanLumiOverride, mInstLumiOverride);
+  LOGP(info, "CTP Lumi request for TPC corr.map scaling={}, override values: lumiMean={} lumiInst={} lumiScaleMode={}", getUseCTPLumi() ? "ON" : "OFF", mMeanLumiOverride, mInstLumiOverride, mLumiScaleMode);
 }
 #endif // #ifndef GPUCA_GPUCODE_DEVICE
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/RecoWorkflow.h b/Detectors/TPC/workflow/include/TPCWorkflow/RecoWorkflow.h
index f9f1e3bf70807..b92f50b9ea23d 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/RecoWorkflow.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/RecoWorkflow.h
@@ -83,11 +83,12 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData,
                                     bool askDISTSTF = true,
                                     bool selIR = false,
                                     bool filteredInp = false,
-                                    bool requireCTPLumi = false);
+                                    bool requireCTPLumi = false,
+                                    int lumiScaleMode = 0);
 
 void cleanupCallback();
 
 } // end namespace reco_workflow
 } // end namespace tpc
 } // end namespace o2
-#endif //O2_TPC_RECOWORKFLOW_H
+#endif // O2_TPC_RECOWORKFLOW_H
diff --git a/Detectors/TPC/workflow/src/RecoWorkflow.cxx b/Detectors/TPC/workflow/src/RecoWorkflow.cxx
index 2586af16262d4..9f0475e53da1e 100644
--- a/Detectors/TPC/workflow/src/RecoWorkflow.cxx
+++ b/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 caClusterer, int zsOnTheFly, bool askDISTSTF, bool selIR, bool filteredInp, bool requireCTPLumi, int lumiScaleMode)
 {
   InputType inputType;
   try {
@@ -162,7 +162,7 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData, std::vecto
       auto storedlabels = reinterpret_cast<o2::dataformats::IOMCTruthContainerView const*>(data);
       o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel> flatlabels;
       storedlabels->copyandflatten(flatlabels);
-      //LOG(info) << "PUBLISHING CONST LABELS " << flatlabels.getNElements();
+      // LOG(info) << "PUBLISHING CONST LABELS " << flatlabels.getNElements();
       context.outputs().snapshot(output, flatlabels);
       return true;
     }
@@ -241,7 +241,7 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData, std::vecto
   runGPUReco &= caClusterer || runHWDecoder || inputType == InputType::Clusters || decompressTPC;
 
   bool outRaw = inputType == InputType::Digits && isEnabled(OutputType::ZSRaw) && !isEnabled(OutputType::DisableWriter);
-  //bool runZSDecode = inputType == InputType::ZSRaw;
+  // bool runZSDecode = inputType == InputType::ZSRaw;
   bool zsToDigit = inputType == InputType::ZSRaw && isEnabled(OutputType::Digits);
 
   if (inputType == InputType::PassThrough) {
@@ -366,7 +366,8 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData, std::vecto
   if (isEnabled(OutputType::Digits) && !isEnabled(OutputType::DisableWriter)) {
     using DigitOutputType = std::vector<o2::tpc::Digit>;
     specs.push_back(makeWriterSpec("tpc-digits-writer",
-                                   inputType == InputType::ZSRaw ? "tpc-zs-digits.root" : inputType == InputType::Digits ? "tpc-filtered-digits.root" : "tpcdigits.root",
+                                   inputType == InputType::ZSRaw ? "tpc-zs-digits.root" : inputType == InputType::Digits ? "tpc-filtered-digits.root"
+                                                                                                                         : "tpcdigits.root",
                                    "o2sim",
                                    BranchDefinition<DigitOutputType>{InputSpec{"data", "TPC", "DIGITS", 0},
                                                                      "TPCDigit",
@@ -430,6 +431,7 @@ 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;
@@ -484,7 +486,7 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData, std::vecto
     const char* defaultFileName = filteredInp ? "tpctracks_filtered.root" : "tpctracks.root";
     const char* defaultTreeName = "tpcrec";
 
-    //branch definitions for RootTreeWriter spec
+    // branch definitions for RootTreeWriter spec
     using TrackOutputType = std::vector<o2::tpc::TrackTPC>;
 
     using ClusRefsOutputType = std::vector<o2::tpc::TPCClRefElem>;
@@ -523,13 +525,13 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData, std::vecto
     const char* defaultFileName = "tpc-compclusters.root";
     const char* defaultTreeName = "tpcrec";
 
-    //branch definitions for RootTreeWriter spec
+    // branch definitions for RootTreeWriter spec
     using CCluSerializedType = ROOTSerialized<CompressedClustersROOT>;
     auto ccldef = BranchDefinition<CCluSerializedType>{InputSpec{"inputCompCl", "TPC", "COMPCLUSTERS"}, //
                                                        "TPCCompClusters_0", "compcluster-branch-name"}; //
 
-    specs.push_back(MakeRootTreeWriterSpec(processName, defaultFileName, defaultTreeName,            //
-                                           std::move(ccldef))());                                    //
+    specs.push_back(MakeRootTreeWriterSpec(processName, defaultFileName, defaultTreeName, //
+                                           std::move(ccldef))());                         //
   }
 
   return std::move(specs);
diff --git a/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx b/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx
index 89bd5151faa64..8e873fbfc7851 100644
--- a/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx
+++ b/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx
@@ -69,6 +69,7 @@ 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);
@@ -139,6 +140,7 @@ 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
@@ -179,7 +181,8 @@ 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);
+                                                requireCTPLumi,
+                                                lumiScaleMode);
 
   // configure dpl timer to inject correct firstTForbit: start from the 1st orbit of TF containing 1st sampled orbit
   o2::raw::HBFUtilsInitializer hbfIni(cfgc, wf);
diff --git a/GPU/TPCFastTransformation/CorrectionMapsHelper.cxx b/GPU/TPCFastTransformation/CorrectionMapsHelper.cxx
index 9b837ccb80e7e..0d8dd922dad81 100644
--- a/GPU/TPCFastTransformation/CorrectionMapsHelper.cxx
+++ b/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={}", getInstLumiOverride(), getUseCTPLumi(), getInstLumi(), getMeanLumi(), getLumiScale());
+  LOGP(info, "InstLumiOverride={}, UseCTPLumi={} -> instLumi={}, meanLumi={} -> LumiScale={}, lumiScaleMode={}", getInstLumiOverride(), getUseCTPLumi(), getInstLumi(), getMeanLumi(), getLumiScale(), getLumiScaleMode());
 }
diff --git a/GPU/TPCFastTransformation/CorrectionMapsHelper.h b/GPU/TPCFastTransformation/CorrectionMapsHelper.h
index 52b1e9056a308..332c284f53a27 100644
--- a/GPU/TPCFastTransformation/CorrectionMapsHelper.h
+++ b/GPU/TPCFastTransformation/CorrectionMapsHelper.h
@@ -80,10 +80,20 @@ 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;
     }
@@ -96,6 +106,7 @@ 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; }
@@ -127,18 +138,19 @@ class CorrectionMapsHelper
   enum UpdateFlags { MapBit = 0x1,
                      MapRefBit = 0x2,
                      LumiBit = 0x4 };
-  bool mOwner = false; // is content of pointers owned by the helper
+  bool mOwner = false;      // is content of pointers owned by the helper
   bool mUseCTPLumi = false; // require CTP Lumi for mInstLumi
   int mUpdatedFlags = 0;
-  float mInstLumi = 0.;                            // instanteneous luminosity (a.u)
-  float mMeanLumi = 0.;                            // mean luminosity of the map (a.u)
-  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
+  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 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, 1);
+  ClassDefNV(CorrectionMapsHelper, 2);
 #endif
 };
 
diff --git a/GPU/TPCFastTransformation/TPCFastTransform.cxx b/GPU/TPCFastTransformation/TPCFastTransform.cxx
index 6424292a6035a..bbff90b1a6656 100644
--- a/GPU/TPCFastTransformation/TPCFastTransform.cxx
+++ b/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)
+  : 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)
 {
   // Default Constructor: creates an empty uninitialized object
 }
@@ -61,6 +61,7 @@ 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());
@@ -111,6 +112,7 @@ void TPCFastTransform::startConstruction(const TPCFastSpaceChargeCorrection& cor
   mLumi = 0.f;
   mLumiError = 0.f;
   mLumiScaleFactor = 1.f;
+  mLumiScaleMode = 0;
 
   // variable-size data
 
@@ -161,6 +163,7 @@ void TPCFastTransform::print() const
   LOG(info) << "mLumi = " << mLumi;
   LOG(info) << "mLumiError = " << mLumiError;
   LOG(info) << "mLumiScaleFactor = " << mLumiScaleFactor;
+  LOG(info) << "mLumiScaleMode = " << mLumiScaleMode;
   mCorrection.print();
 #endif
 }
diff --git a/GPU/TPCFastTransformation/TPCFastTransform.h b/GPU/TPCFastTransformation/TPCFastTransform.h
index ed017246d40ba..554cf7b81944c 100644
--- a/GPU/TPCFastTransformation/TPCFastTransform.h
+++ b/GPU/TPCFastTransformation/TPCFastTransform.h
@@ -158,6 +158,7 @@ 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; }
@@ -253,6 +254,9 @@ 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;
 
@@ -329,6 +333,7 @@ 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
@@ -336,7 +341,7 @@ class TPCFastTransform : public FlatObject
   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, 3);
+  ClassDefNV(TPCFastTransform, 4);
 #endif
 };
 
@@ -464,11 +469,19 @@ 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
-          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;
+          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;
+          }
         }
       }
     }
@@ -726,9 +739,15 @@ 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
-      float xr;
-      ref->mCorrection.getCorrectionInvCorrectedX(slice, row, u, v, xr);
-      x = (x - xr) * scale + xr;
+      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;
+      }
     }
   }
   GPUCA_DEBUG_STREAMER_CHECK(if (o2::utils::DebugStreamer::checkStream(o2::utils::StreamFlags::streamFastTransform)) {
@@ -753,10 +772,17 @@ 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
-      float unr = 0, vnr = 0;
-      ref->mCorrection.getCorrectionInvUV(slice, row, u, v, unr, vnr);
-      un = (un - unr) * scale + unr;
-      vn = (vn - vnr) * scale + vnr;
+      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;
+      }
     }
   }
   getGeometry().convUVtoLocal(slice, un, vn, ny, nz);
diff --git a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
index ba40fbdee363a..89b9e03c33ce4 100644
--- a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
+++ b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
@@ -106,6 +106,7 @@ 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);
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index 044e48d3481a7..fd59bc53ec231 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/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); // option filled here is lost
+    mFastTransformHelper->requestCCDBInputs(inputs, optsDummy, mSpecConfig.requireCTPLumi, mSpecConfig.lumiScaleMode); // 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,6 +1350,7 @@ 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);
   }
@@ -1611,6 +1612,7 @@ 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();
diff --git a/GPU/Workflow/src/gpu-reco-workflow.cxx b/GPU/Workflow/src/gpu-reco-workflow.cxx
index 4edbdcfb6c09a..60d21c6ac6d49 100644
--- a/GPU/Workflow/src/gpu-reco-workflow.cxx
+++ b/GPU/Workflow/src/gpu-reco-workflow.cxx
@@ -51,7 +51,8 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
   std::vector<ConfigParamSpec> options{
     {"input-type", VariantType::String, "digits", {"digitizer, digits, zsraw, zsonthefly, clustersnative, compressed-clusters-root, compressed-clusters-ctf, trd-tracklets"}},
     {"output-type", VariantType::String, "tracks", {"clustersnative, tracks, compressed-clusters-ctf, qa, no-shared-cluster-map, send-clusters-per-sector, trd-tracks, error-qa"}},
-    {"require-ctp-lumi", o2::framework::VariantType::Bool, false, {"require CTP lumi for TPC correction scaling"}},
+    {"require-ctp-lumi", 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"}},
     {"disable-root-input", VariantType::Bool, true, {"disable root-files input reader"}},
     {"disable-mc", VariantType::Bool, false, {"disable sending of MC information"}},
     {"ignore-dist-stf", VariantType::Bool, false, {"do not subscribe to FLP/DISTSUBTIMEFRAME/0 message (no lost TF recovery)"}},
@@ -169,6 +170,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   cfg.askDISTSTF = !cfgc.options().get<bool>("ignore-dist-stf");
   cfg.readTRDtracklets = isEnabled(inputTypes, ioType::TRDTracklets);
   cfg.runTRDTracking = isEnabled(outputTypes, ioType::TRDTracks);
+  cfg.lumiScaleMode = cfgc.options().get<int>("corrmap-lumi-mode");
 
   Inputs ggInputs;
   auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false, true, false, true, true, o2::base::GRPGeomRequest::Aligned, ggInputs, true);