diff --git a/Detectors/TPC/base/include/TPCBase/CDBTypes.h b/Detectors/TPC/base/include/TPCBase/CDBTypes.h
index 4e084d129ac79..bca041b9c8956 100644
--- a/Detectors/TPC/base/include/TPCBase/CDBTypes.h
+++ b/Detectors/TPC/base/include/TPCBase/CDBTypes.h
@@ -73,6 +73,7 @@ enum class CDBType {
   CalCorrMapRef,       ///< Cluster correction reference map (static distortions)
   CalCorrMapMC,        ///< Cluster correction map (high IR rate distortions) for MC
   CalCorrDerivMapMC,   ///< Cluster correction reference map (static distortions) for MC
+  CalCorrMapVShape,   ///< Cluster correction map for V-shape distortions
                        ///
   CalCorrDerivMap,     ///< Cluster correction map (derivative map)
                        ///
@@ -135,6 +136,7 @@ const std::unordered_map<CDBType, const std::string> CDBTypeMap{
   // correction maps
   {CDBType::CalCorrMap, "TPC/Calib/CorrectionMapV2"},
   {CDBType::CalCorrMapRef, "TPC/Calib/CorrectionMapRefV2"},
+  {CDBType::CalCorrMapVShape, "TPC/Calib/CorrectionMapVShapeV2"},
   // correction maps for MC
   {CDBType::CalCorrMapMC, "TPC/Calib/CorrectionMapMCV2"},
   {CDBType::CalCorrDerivMapMC, "TPC/Calib/CorrectionMapDerivativeMCV2"},
diff --git a/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx b/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
index 4e7fadcbd288d..988035397a229 100644
--- a/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
+++ b/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
@@ -36,6 +36,9 @@ void CorrectionMapsLoader::updateVDrift(float vdriftCorr, float vdrifRef, float
   if (mCorrMapRef) {
     o2::tpc::TPCFastTransformHelperO2::instance()->updateCalibration(*mCorrMapRef, 0, vdriftCorr, vdrifRef, driftTimeOffset);
   }
+  if (mCorrMapVShape) {
+    o2::tpc::TPCFastTransformHelperO2::instance()->updateCalibration(*mCorrMapVShape, 0, vdriftCorr, vdrifRef, driftTimeOffset);
+  }
 }
 
 //________________________________________________________
@@ -57,10 +60,15 @@ void CorrectionMapsLoader::extractCCDBInputs(ProcessingContext& pc)
       }
       lumiObj = lumiPrev;
     }
-    setInstLumi(mInstLumiFactor * (mCTPLumiSource == 0 ? lumiObj.getLumi() : lumiObj.getLumiAlt()));
+    setInstLumi(mInstLumiFactor * (mCTPLumiSource == 0 ? lumiObj.getLumi() : lumiObj.getLumiAlt()), !getUseVShapeCorrection());
   } else if (getLumiScaleType() == 2 && mInstLumiOverride <= 0.) {
     float tpcScaler = pc.inputs().get<float>("tpcscaler");
-    setInstLumi(mInstLumiFactor * tpcScaler);
+    setInstLumi(mInstLumiFactor * tpcScaler, !getUseVShapeCorrection());
+  }
+  if (getUseVShapeCorrection()) {
+    float vshapescaler = pc.inputs().get<float>("vshape");
+    setVShapeScaler(vshapescaler);
+    pc.inputs().get<o2::gpu::TPCFastTransform*>("tpcCorrMapVShape");
   }
 }
 
@@ -87,6 +95,11 @@ void CorrectionMapsLoader::requestCCDBInputs(std::vector<InputSpec>& inputs, std
     addInput(inputs, {"tpcscaler", o2::header::gDataOriginTPC, "TPCSCALER", 0, Lifetime::Timeframe});
   }
 
+  if (gloOpts.enableVShapeCorrection) {
+    addInput(inputs, {"vshape", o2::header::gDataOriginTPC, "TPCVShapeScaler", 0, Lifetime::Timeframe});
+    addInput(inputs, {"tpcCorrMapVShape", o2::header::gDataOriginTPC, "CorrMapVShape", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrMapVShape), {}, 0)}); // load once
+  }
+
   addInput(inputs, {"tpcCorrPar", "TPC", "CorrMapParam", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CorrMapParam), {}, 0)}); // load once
 
   addOptions(options);
@@ -157,6 +170,13 @@ bool CorrectionMapsLoader::accountCCDBInputs(const ConcreteDataMatcher& matcher,
     setUpdatedMapRef();
     return true;
   }
+  if (matcher == ConcreteDataMatcher("TPC", "CorrMapVShape", 0)) {
+    LOGP(info, "Loading V-shape corrections from CCDB");
+    setCorrMapVShape((o2::gpu::TPCFastTransform*)obj);
+    mCorrMapVShape->rectifyAfterReadingFromFile();
+    setUpdatedMapVShape();
+    return true;
+  }
   if (matcher == ConcreteDataMatcher("TPC", "CorrMapParam", 0)) {
     const auto& par = o2::tpc::CorrMapParam::Instance();
     mMeanLumiOverride = par.lumiMean;
@@ -196,6 +216,8 @@ void CorrectionMapsLoader::init(o2::framework::InitContext& ic)
       break;
     } else if (route.matcher == InputSpec{"tpcscaler", o2::header::gDataOriginTPC, "TPCSCALER", 0, Lifetime::Timeframe}) {
       setLumiScaleType(2);
+    } else if (route.matcher == InputSpec{"vshape", o2::header::gDataOriginTPC, "TPCVShapeScaler", 0, Lifetime::Timeframe}) {
+      enableVShapeCorrection(true);
     }
   }
 }
@@ -211,6 +233,8 @@ void CorrectionMapsLoader::copySettings(const CorrectionMapsLoader& src)
   setMeanLumiRefOverride(src.getMeanLumiRefOverride());
   setInstLumiOverride(src.getInstLumiOverride());
   setLumiScaleMode(src.getLumiScaleMode());
+  enableVShapeCorrection(src.getUseVShapeCorrection());
+  setVShapeScaler(src.getVShapeScaler(), false);
   mInstLumiFactor = src.mInstLumiFactor;
   mCTPLumiSource = src.mCTPLumiSource;
   mLumiScaleMode = src.mLumiScaleMode;
diff --git a/Detectors/TPC/calibration/src/TPCVShapeScaler.cxx b/Detectors/TPC/calibration/src/TPCVShapeScaler.cxx
index 66394b5dc3ceb..434718e4fef10 100644
--- a/Detectors/TPC/calibration/src/TPCVShapeScaler.cxx
+++ b/Detectors/TPC/calibration/src/TPCVShapeScaler.cxx
@@ -39,17 +39,17 @@ void TPCVShapeScaler::loadFromFile(const char* inpf, const char* name)
   setFromTree(*tree);
 }
 
-void TPCVShapeScaler::setFromTree(TTree& TPCVShapeScalerTree)
+void TPCVShapeScaler::setFromTree(TTree& tpcScalerTree)
 {
   TPCVShapeScaler* scalerTmp = this;
-  TPCVShapeScalerTree.SetBranchAddress("TPCVShapeScaler", &scalerTmp);
-  const int entries = TPCVShapeScalerTree.GetEntries();
+  tpcScalerTree.SetBranchAddress("TPCVShapeScaler", &scalerTmp);
+  const int entries = tpcScalerTree.GetEntries();
   if (entries > 0) {
-    TPCVShapeScalerTree.GetEntry(0);
+    tpcScalerTree.GetEntry(0);
   } else {
     LOGP(error, "TPCVShapeScaler not found in input file");
   }
-  TPCVShapeScalerTree.SetBranchAddress("TPCVShapeScaler", nullptr);
+  tpcScalerTree.SetBranchAddress("TPCVShapeScaler", nullptr);
 }
 
 float TPCVShapeScaler::getScaler(const double timestamp) const
@@ -72,11 +72,12 @@ float TPCVShapeScaler::getScaler(const double timestamp) const
     const double deltaTimeLow = std::abs(mScalerA[idx - 1].first - timestamp);
     const double deltaTimeUp = std::abs(mScalerA[idx].first - timestamp);
 
+    // TODO if both are OK do linear interpolation
     // return closes value
     if ((deltaTimeLow < deltaTimeUp) && checkDeltaTime(deltaTimeLow)) {
       return mScalerA[idx - 1].second;
     } else if (checkDeltaTime(deltaTimeUp)) {
-      return mScalerA[idx - 1].second;
+      return mScalerA[idx].second;
     }
   }
 
diff --git a/Detectors/TPC/workflow/src/RecoWorkflow.cxx b/Detectors/TPC/workflow/src/RecoWorkflow.cxx
index fd77845ff844b..610573d609e1b 100644
--- a/Detectors/TPC/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/TPC/workflow/src/RecoWorkflow.cxx
@@ -446,6 +446,7 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData, std::vecto
     cfg.runTPCTracking = true;
     cfg.lumiScaleType = sclOpts.lumiType;
     cfg.lumiScaleMode = sclOpts.lumiMode;
+    cfg.enableVShape = sclOpts.enableVShapeCorrection;
     cfg.decompressTPC = decompressTPC;
     cfg.decompressTPCFromROOT = decompressTPC && inputType == InputType::CompClusters;
     cfg.caClusterer = caClusterer;
diff --git a/Detectors/TPC/workflow/src/TPCScalerSpec.cxx b/Detectors/TPC/workflow/src/TPCScalerSpec.cxx
index cceafb62400b5..0dd6dc6591595 100644
--- a/Detectors/TPC/workflow/src/TPCScalerSpec.cxx
+++ b/Detectors/TPC/workflow/src/TPCScalerSpec.cxx
@@ -41,6 +41,7 @@ class TPCScalerSpec : public Task
   {
     o2::base::GRPGeomHelper::instance().setRequest(mCCDBRequest);
     mIonDriftTimeMS = ic.options().get<float>("ion-drift-time");
+    mVShapeScalingFac = ic.options().get<float>("v-shape-scaling-factor");
   }
 
   void run(ProcessingContext& pc) final
@@ -70,7 +71,9 @@ class TPCScalerSpec : public Task
     pc.outputs().snapshot(Output{header::gDataOriginTPC, "TPCSCALER"}, meanScaler);
 
     if (mEnableVShape) {
-      float vshapescaler = 123;
+      double tsMiddleTF = timestamp + o2::base::GRPGeomHelper::instance().getNHBFPerTF() / 2 * o2::constants::lhc::LHCOrbitMUS * 0.001;
+      float vshapescaler = mVShapeScalingFac * mVShapeTPCScaler.getScaler(tsMiddleTF);
+      LOGP(info, "Publishing TPC V-shape scaler: {} for timestamp {} firstTFOrbit: {}", vshapescaler, long(timestamp), firstTFOrbit);
       pc.outputs().snapshot(Output{header::gDataOriginTPC, "TPCVShapeScaler"}, vshapescaler);
     }
   }
@@ -95,6 +98,7 @@ class TPCScalerSpec : public Task
   std::shared_ptr<o2::base::GRPGeomRequest> mCCDBRequest; ///< info for CCDB request
   const bool mEnableVShape{};                             ///< enable v shape scalers
   float mIonDriftTimeMS{-1};                              ///< ion drift time
+  float mVShapeScalingFac{0};                             ///< scale v-shape scalers with this value
   TPCScaler mTPCScaler;                                   ///< tpc scaler
   TPCVShapeScaler mVShapeTPCScaler;                       ///< TPC V-shape scalers
 };
@@ -108,7 +112,7 @@ o2::framework::DataProcessorSpec getTPCScalerSpec(bool enableVShape)
   }
 
   auto ccdbRequest = std::make_shared<o2::base::GRPGeomRequest>(true,                           // orbitResetTime
-                                                                false,                          // GRPECS=true for nHBF per TF
+                                                                enableVShape,                   // GRPECS=true for nHBF per TF
                                                                 false,                          // GRPLHCIF
                                                                 false,                          // GRPMagField
                                                                 false,                          // askMatLUT
@@ -117,6 +121,9 @@ o2::framework::DataProcessorSpec getTPCScalerSpec(bool enableVShape)
 
   std::vector<OutputSpec> outputs;
   outputs.emplace_back(o2::header::gDataOriginTPC, "TPCSCALER", 0, Lifetime::Timeframe);
+  if (enableVShape) {
+    outputs.emplace_back(o2::header::gDataOriginTPC, "TPCVShapeScaler", 0, Lifetime::Timeframe);
+  }
 
   return DataProcessorSpec{
     "tpc-scaler",
@@ -124,7 +131,8 @@ o2::framework::DataProcessorSpec getTPCScalerSpec(bool enableVShape)
     outputs,
     AlgorithmSpec{adaptFromTask<TPCScalerSpec>(ccdbRequest, enableVShape)},
     Options{
-      {"ion-drift-time", VariantType::Float, -1.f, {"Overwrite ion drift time if a value >0 is provided"}}}};
+      {"ion-drift-time", VariantType::Float, -1.f, {"Overwrite ion drift time if a value >0 is provided"}},
+      {"v-shape-scaling-factor", VariantType::Float, 1.f, {"Scale V-shape scaler with this value"}}}};
 }
 
 } // namespace tpc
diff --git a/Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx b/Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx
index 4dfa67a7b826b..205234770bd28 100644
--- a/Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx
+++ b/Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx
@@ -1288,14 +1288,15 @@ class TPCTimeSeries : public Task
 
   void sendOutput(ProcessingContext& pc)
   {
+    const long timeMS = o2::base::GRPGeomHelper::instance().getOrbitResetTimeMS() + processing_helpers::getFirstTForbit(pc) * o2::constants::lhc::LHCOrbitMUS / 1000;
+    mBufferDCA.mTSTPC.setStartTime(timeMS);
+    mBufferDCA.mTSITSTPC.setStartTime(timeMS);
+
     pc.outputs().snapshot(Output{header::gDataOriginTPC, getDataDescriptionTimeSeries()}, mBufferDCA);
     // in case of ROOT output also store the TFinfo in the TTree
     if (!mDisableWriter) {
       o2::dataformats::TFIDInfo tfinfo;
       o2::base::TFIDInfoHelper::fillTFIDInfo(pc, tfinfo);
-      const long timeMS = o2::base::GRPGeomHelper::instance().getOrbitResetTimeMS() + processing_helpers::getFirstTForbit(pc) * o2::constants::lhc::LHCOrbitMUS / 1000;
-      mBufferDCA.mTSTPC.setStartTime(timeMS);
-      mBufferDCA.mTSITSTPC.setStartTime(timeMS);
       pc.outputs().snapshot(Output{header::gDataOriginTPC, getDataDescriptionTPCTimeSeriesTFId()}, tfinfo);
     }
   }
diff --git a/GPU/GPUTracking/DataTypes/GPUDataTypes.h b/GPU/GPUTracking/DataTypes/GPUDataTypes.h
index c00796e3fd7df..c10bb612ef7c8 100644
--- a/GPU/GPUTracking/DataTypes/GPUDataTypes.h
+++ b/GPU/GPUTracking/DataTypes/GPUDataTypes.h
@@ -216,6 +216,7 @@ template <template <typename T> class S>
 struct GPUCalibObjectsTemplate { // use only pointers on PODs or flat objects here
   typename S<TPCFastTransform>::type* fastTransform = nullptr;
   typename S<TPCFastTransform>::type* fastTransformRef = nullptr;
+  typename S<TPCFastTransform>::type* fastTransformVShape = nullptr;
   typename S<CorrectionMapsHelper>::type* fastTransformHelper = nullptr;
   typename S<o2::base::MatLayerCylSet>::type* matLUT = nullptr;
   typename S<o2::trd::GeometryFlat>::type* trdGeometry = nullptr;
diff --git a/GPU/TPCFastTransformation/CorrectionMapsHelper.cxx b/GPU/TPCFastTransformation/CorrectionMapsHelper.cxx
index 3a12d7154502d..bbc511d7717d9 100644
--- a/GPU/TPCFastTransformation/CorrectionMapsHelper.cxx
+++ b/GPU/TPCFastTransformation/CorrectionMapsHelper.cxx
@@ -29,6 +29,7 @@ void CorrectionMapsHelper::clear()
   mInstLumi = 0.f;
   mMeanLumi = 0.f;
   mMeanLumiRef = 0.f;
+  mVShapeScaler = 0.f;
 }
 
 void CorrectionMapsHelper::setOwner(bool v)
@@ -97,5 +98,5 @@ void CorrectionMapsHelper::setCorrMapVShape(std::unique_ptr<TPCFastTransform>&&
 //________________________________________________________
 void CorrectionMapsHelper::reportScaling()
 {
-  LOGP(info, "Map scaling update: InstLumiOverride={}, LumiScaleType={} -> instLumi={}, meanLumi={} -> LumiScale={}, lumiScaleMode={}", getInstLumiOverride(), getLumiScaleType(), getInstLumi(), getMeanLumi(), getLumiScale(), getLumiScaleMode());
+  LOGP(info, "Map scaling update: InstLumiOverride={}, LumiScaleType={} -> instLumi={}, meanLumi={} -> LumiScale={}, lumiScaleMode={}, mVShapeScaler={}", getInstLumiOverride(), getLumiScaleType(), getInstLumi(), getMeanLumi(), getLumiScale(), getLumiScaleMode(), getVShapeScaler());
 }
diff --git a/GPU/TPCFastTransformation/CorrectionMapsHelper.h b/GPU/TPCFastTransformation/CorrectionMapsHelper.h
index 9445810bf3091..0e2a66b57ac3a 100644
--- a/GPU/TPCFastTransformation/CorrectionMapsHelper.h
+++ b/GPU/TPCFastTransformation/CorrectionMapsHelper.h
@@ -38,26 +38,27 @@ class CorrectionMapsHelper
 
   GPUd() void Transform(int slice, int row, float pad, float time, float& x, float& y, float& z, float vertexTime = 0) const
   {
-    mCorrMap->Transform(slice, row, pad, time, x, y, z, vertexTime, mCorrMapRef, mLumiScale, mLumiScaleMode);
+    mCorrMap->Transform(slice, row, pad, time, x, y, z, vertexTime, mCorrMapRef, mCorrMapVShape, mLumiScale, mVShapeScaler, mLumiScaleMode);
   }
 
   GPUd() void TransformXYZ(int slice, int row, float& x, float& y, float& z) const
   {
-    mCorrMap->TransformXYZ(slice, row, x, y, z, mCorrMapRef, mLumiScale, mLumiScaleMode);
+    mCorrMap->TransformXYZ(slice, row, x, y, z, mCorrMapRef, mCorrMapVShape, mLumiScale, mVShapeScaler, mLumiScaleMode);
   }
 
   GPUd() void InverseTransformYZtoX(int slice, int row, float y, float z, float& x) const
   {
-    mCorrMap->InverseTransformYZtoX(slice, row, y, z, x, mCorrMapRef, mLumiScale, mLumiScaleMode);
+    mCorrMap->InverseTransformYZtoX(slice, row, y, z, x, mCorrMapRef, mCorrMapVShape, mLumiScale, mVShapeScaler, mLumiScaleMode);
   }
 
   GPUd() void InverseTransformYZtoNominalYZ(int slice, int row, float y, float z, float& ny, float& nz) const
   {
-    mCorrMap->InverseTransformYZtoNominalYZ(slice, row, y, z, ny, nz, mCorrMapRef, mLumiScale, mLumiScaleMode);
+    mCorrMap->InverseTransformYZtoNominalYZ(slice, row, y, z, ny, nz, mCorrMapRef, mCorrMapVShape, mLumiScale, mVShapeScaler, mLumiScaleMode);
   }
 
   GPUd() const GPUCA_NAMESPACE::gpu::TPCFastTransform* getCorrMap() const { return mCorrMap; }
   GPUd() const GPUCA_NAMESPACE::gpu::TPCFastTransform* getCorrMapRef() const { return mCorrMapRef; }
+  GPUd() const GPUCA_NAMESPACE::gpu::TPCFastTransform* getCorrMapVShape() const { return mCorrMapVShape; }
 
   bool getOwner() const { return mOwner; }
 
@@ -112,6 +113,14 @@ class CorrectionMapsHelper
     }
   }
 
+  void setVShapeScaler(float v, bool report = true)
+  {
+    mVShapeScaler = v;
+    if (report) {
+      reportScaling();
+    }
+  }
+
   GPUd() float getInstLumi() const { return mInstLumi; }
   GPUd() float getMeanLumi() const { return mMeanLumi; }
   GPUd() float getMeanLumiRef() const { return mMeanLumiRef; }
@@ -119,12 +128,16 @@ class CorrectionMapsHelper
   GPUd() float getLumiScale() const { return mLumiScale; }
   GPUd() int getLumiScaleMode() const { return mLumiScaleMode; }
 
+  GPUd() float getVShapeScaler() const { return mVShapeScaler; }
+
   bool isUpdated() const { return mUpdatedFlags != 0; }
   bool isUpdatedMap() const { return (mUpdatedFlags & UpdateFlags::MapBit) != 0; }
   bool isUpdatedMapRef() const { return (mUpdatedFlags & UpdateFlags::MapRefBit) != 0; }
+  bool isUpdatedMapVShape() const { return (mUpdatedFlags & UpdateFlags::MapVShapeBit) != 0; }
   bool isUpdatedLumi() const { return (mUpdatedFlags & UpdateFlags::LumiBit) != 0; }
   void setUpdatedMap() { mUpdatedFlags |= UpdateFlags::MapBit; }
   void setUpdatedMapRef() { mUpdatedFlags |= UpdateFlags::MapRefBit; }
+  void setUpdatedMapVShape() { mUpdatedFlags |= UpdateFlags::MapVShapeBit; }
   void setUpdatedLumi() { mUpdatedFlags |= UpdateFlags::LumiBit; }
 
 #if !defined(GPUCA_GPUCODE_DEVICE) && defined(GPUCA_NOCOMPAT)
@@ -137,6 +150,8 @@ class CorrectionMapsHelper
 
   void setLumiScaleType(int v) { mLumiScaleType = v; }
   int getLumiScaleType() const { return mLumiScaleType; }
+  void enableVShapeCorrection(bool v) { mEnableVShape = v; }
+  bool getUseVShapeCorrection() const { return mEnableVShape; }
 
   void setMeanLumiOverride(float f) { mMeanLumiOverride = f; }
   void setMeanLumiRefOverride(float f) { mMeanLumiRefOverride = f; }
@@ -151,7 +166,8 @@ class CorrectionMapsHelper
  protected:
   enum UpdateFlags { MapBit = 0x1,
                      MapRefBit = 0x2,
-                     LumiBit = 0x4 };
+                     LumiBit = 0x4,
+                     MapVShapeBit = 0x10 };
   bool mOwner = false;    // is content of pointers owned by the helper
   int mLumiScaleType = 0; // require CTP Lumi for mInstLumi
   int mUpdatedFlags = 0;
@@ -163,6 +179,8 @@ class CorrectionMapsHelper
   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
+  bool mEnableVShape = false;                                      ///< use v shape correction
+  float mVShapeScaler = 0;                                         // scaling value for V-shape distortions
   GPUCA_NAMESPACE::gpu::TPCFastTransform* mCorrMap{nullptr};       // current transform
   GPUCA_NAMESPACE::gpu::TPCFastTransform* mCorrMapRef{nullptr};    // reference transform
   GPUCA_NAMESPACE::gpu::TPCFastTransform* mCorrMapVShape{nullptr}; // correction map for v-shape distortions on A-side
diff --git a/GPU/TPCFastTransformation/TPCFastTransform.h b/GPU/TPCFastTransformation/TPCFastTransform.h
index 1936ae4f19a99..c6ebffebc2913 100644
--- a/GPU/TPCFastTransformation/TPCFastTransform.h
+++ b/GPU/TPCFastTransformation/TPCFastTransform.h
@@ -176,8 +176,8 @@ class TPCFastTransform : public FlatObject
   /// Transforms raw TPC coordinates to local XYZ withing a slice
   /// taking calibration + alignment into account.
   ///
-  GPUd() void Transform(int slice, int row, float pad, float time, float& x, float& y, float& z, float vertexTime = 0, const TPCFastTransform* ref = nullptr, float scale = 0.f, int scaleMode = 0) const;
-  GPUd() void TransformXYZ(int slice, int row, float& x, float& y, float& z, const TPCFastTransform* ref = nullptr, float scale = 0.f, int scaleMode = 0) const;
+  GPUd() void Transform(int slice, int row, float pad, float time, float& x, float& y, float& z, float vertexTime = 0, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int scaleMode = 0) const;
+  GPUd() void TransformXYZ(int slice, int row, float& x, float& y, float& z, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int scaleMode = 0) const;
 
   /// Transformation in the time frame
   GPUd() void TransformInTimeFrame(int slice, int row, float pad, float time, float& x, float& y, float& z, float maxTimeBin) const;
@@ -187,13 +187,13 @@ class TPCFastTransform : public FlatObject
   GPUd() void InverseTransformInTimeFrame(int slice, int row, float /*x*/, float y, float z, float& pad, float& time, float maxTimeBin) const;
 
   /// Inverse transformation: Transformed Y and Z -> transformed X
-  GPUd() void InverseTransformYZtoX(int slice, int row, float y, float z, float& x, const TPCFastTransform* ref = nullptr, float scale = 0.f, int scaleMode = 0) const;
+  GPUd() void InverseTransformYZtoX(int slice, int row, float y, float z, float& x, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int scaleMode = 0) const;
 
   /// Inverse transformation: Transformed Y and Z -> Y and Z, transformed w/o space charge correction
-  GPUd() void InverseTransformYZtoNominalYZ(int slice, int row, float y, float z, float& ny, float& nz, const TPCFastTransform* ref = nullptr, float scale = 0.f, int scaleMode = 0) const;
+  GPUd() void InverseTransformYZtoNominalYZ(int slice, int row, float y, float z, float& ny, float& nz, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int scaleMode = 0) const;
 
   /// Inverse transformation: Transformed X, Y and Z -> X, Y and Z, transformed w/o space charge correction
-  GPUd() void InverseTransformXYZtoNominalXYZ(int slice, int row, float x, float y, float z, float& nx, float& ny, float& nz, const TPCFastTransform* ref = nullptr, float scale = 0.f, int scaleMode = 0) const;
+  GPUd() void InverseTransformXYZtoNominalXYZ(int slice, int row, float x, float y, float z, float& nx, float& ny, float& nz, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int scaleMode = 0) const;
 
   /// Ideal transformation with Vdrift only - without calibration
   GPUd() void TransformIdeal(int slice, int row, float pad, float time, float& x, float& y, float& z, float vertexTime) const;
@@ -333,7 +333,7 @@ class TPCFastTransform : public FlatObject
   /// 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;
+  GPUd() void TransformInternal(int slice, int row, float& u, float& v, float& x, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int scaleMode) const;
 
 #ifndef GPUCA_ALIROOT_LIB
   ClassDefNV(TPCFastTransform, 3);
@@ -438,7 +438,7 @@ GPUdi() void TPCFastTransform::getTOFcorrection(int slice, int /*row*/, float x,
   dz = sideC ? dv : -dv;
 }
 
-GPUdi() void TPCFastTransform::TransformInternal(int slice, int row, float& u, float& v, float& x, const TPCFastTransform* ref, float scale, int scaleMode) const
+GPUdi() void TPCFastTransform::TransformInternal(int slice, int row, float& u, float& v, float& x, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int scaleMode) const
 {
   if (mApplyCorrection) {
     float dx = 0.f, du = 0.f, dv = 0.f;
@@ -478,6 +478,13 @@ GPUdi() void TPCFastTransform::TransformInternal(int slice, int row, float& u, f
             dv = dvRef * scale + dv;
           }
         }
+        if (ref2) {
+          float dxRef, duRef, dvRef;
+          ref2->mCorrection.getCorrection(slice, row, u, v, dxRef, duRef, dvRef);
+          dx = dxRef * scale2 + dx;
+          du = duRef * scale2 + du;
+          dv = dvRef * scale2 + dv;
+        }
       }
     }
     GPUCA_DEBUG_STREAMER_CHECK(if (o2::utils::DebugStreamer::checkStream(o2::utils::StreamFlags::streamFastTransform)) {
@@ -494,14 +501,21 @@ GPUdi() void TPCFastTransform::TransformInternal(int slice, int row, float& u, f
       getGeometry().convUVtoLocal(slice, uCorr, vCorr, lyT, lzT);
 
       float invYZtoX;
-      InverseTransformYZtoX(slice, row, lyT, lzT, invYZtoX, ref, scale, scaleMode);
+      InverseTransformYZtoX(slice, row, lyT, lzT, invYZtoX, ref, ref2, scale, scale2, scaleMode);
 
       float YZtoNominalY;
       float YZtoNominalZ;
-      InverseTransformYZtoNominalYZ(slice, row, lyT, lzT, YZtoNominalY, YZtoNominalZ, ref, scale, scaleMode);
+      InverseTransformYZtoNominalYZ(slice, row, lyT, lzT, YZtoNominalY, YZtoNominalZ, ref, ref2, scale, scale2, scaleMode);
 
       float dxRef, duRef, dvRef;
-      ref->mCorrection.getCorrection(slice, row, u, v, dxRef, duRef, dvRef);
+      if (ref) {
+        ref->mCorrection.getCorrection(slice, row, u, v, dxRef, duRef, dvRef);
+      }
+
+      float dxRef2, duRef2, dvRef2;
+      if (ref2) {
+        ref2->mCorrection.getCorrection(slice, row, u, v, dxRef2, duRef2, dvRef2);
+      }
 
       float dxOrig, duOrig, dvOrig;
       mCorrection.getCorrection(slice, row, u, v, dxOrig, duOrig, dvOrig);
@@ -514,6 +528,9 @@ GPUdi() void TPCFastTransform::TransformInternal(int slice, int row, float& u, f
                                                                                          << "dxRef=" << dxRef
                                                                                          << "duRef=" << duRef
                                                                                          << "dvRef=" << dvRef
+                                                                                         << "dxRef2=" << dxRef2
+                                                                                         << "duRef2=" << duRef2
+                                                                                         << "dvRef2=" << dvRef2
                                                                                          << "dx=" << dx
                                                                                          << "du=" << du
                                                                                          << "dv=" << dv
@@ -522,6 +539,7 @@ GPUdi() void TPCFastTransform::TransformInternal(int slice, int row, float& u, f
                                                                                          << "row=" << row
                                                                                          << "slice=" << slice
                                                                                          << "scale=" << scale
+                                                                                         << "scale2=" << scale2
                                                                                          // original local coordinates
                                                                                          << "ly=" << ly
                                                                                          << "lz=" << lz
@@ -548,18 +566,18 @@ GPUdi() void TPCFastTransform::TransformInternal(int slice, int row, float& u, f
   }
 }
 
-GPUdi() void TPCFastTransform::TransformXYZ(int slice, int row, float& x, float& y, float& z, const TPCFastTransform* ref, float scale, int scaleMode) const
+GPUdi() void TPCFastTransform::TransformXYZ(int slice, int row, float& x, float& y, float& z, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int scaleMode) const
 {
   float u, v;
   getGeometry().convLocalToUV(slice, y, z, u, v);
-  TransformInternal(slice, row, u, v, x, ref, scale, scaleMode);
+  TransformInternal(slice, row, u, v, x, ref, ref2, scale, scale2, scaleMode);
   getGeometry().convUVtoLocal(slice, u, v, y, z);
   float dzTOF = 0;
   getTOFcorrection(slice, row, x, y, z, dzTOF);
   z += dzTOF;
 }
 
-GPUdi() void TPCFastTransform::Transform(int slice, int row, float pad, float time, float& x, float& y, float& z, float vertexTime, const TPCFastTransform* ref, float scale, int scaleMode) const
+GPUdi() void TPCFastTransform::Transform(int slice, int row, float pad, float time, float& x, float& y, float& z, float vertexTime, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int scaleMode) const
 {
   /// _______________ The main method: cluster transformation _______________________
   ///
@@ -576,7 +594,7 @@ GPUdi() void TPCFastTransform::Transform(int slice, int row, float pad, float ti
   float u = 0, v = 0;
   convPadTimeToUV(slice, row, pad, time, u, v, vertexTime);
 
-  TransformInternal(slice, row, u, v, x, ref, scale, scaleMode);
+  TransformInternal(slice, row, u, v, x, ref, ref2, scale, scale2, scaleMode);
 
   getGeometry().convUVtoLocal(slice, u, v, y, z);
 
@@ -740,7 +758,7 @@ GPUdi() float TPCFastTransform::getMaxDriftTime(int slice) const
   return maxTime;
 }
 
-GPUdi() void TPCFastTransform::InverseTransformYZtoX(int slice, int row, float y, float z, float& x, const TPCFastTransform* ref, float scale, int scaleMode) const
+GPUdi() void TPCFastTransform::InverseTransformYZtoX(int slice, int row, float y, float z, float& x, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int scaleMode) const
 {
   /// Transformation y,z -> x
   float u = 0, v = 0;
@@ -758,6 +776,11 @@ GPUdi() void TPCFastTransform::InverseTransformYZtoX(int slice, int row, float y
         x = (xr - getGeometry().getRowInfo(row).x) * scale + x; // xr=mGeo.getRowInfo(row).x + dx;
       }
     }
+    if (ref2 && (scale2 != 0)) {
+      float xr;
+      ref2->mCorrection.getCorrectionInvCorrectedX(slice, row, u, v, xr);
+      x = (xr - getGeometry().getRowInfo(row).x) * scale + x; // xr=mGeo.getRowInfo(row).x + dx;
+    }
   } else {
     x = mCorrection.getGeometry().getRowInfo(row).x; // corrections are disabled
   }
@@ -775,7 +798,7 @@ GPUdi() void TPCFastTransform::InverseTransformYZtoX(int slice, int row, float y
   })
 }
 
-GPUdi() void TPCFastTransform::InverseTransformYZtoNominalYZ(int slice, int row, float y, float z, float& ny, float& nz, const TPCFastTransform* ref, float scale, int scaleMode) const
+GPUdi() void TPCFastTransform::InverseTransformYZtoNominalYZ(int slice, int row, float y, float z, float& ny, float& nz, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int scaleMode) const
 {
   /// Transformation y,z -> x
   float u = 0, v = 0, un = 0, vn = 0;
@@ -794,6 +817,12 @@ GPUdi() void TPCFastTransform::InverseTransformYZtoNominalYZ(int slice, int row,
         un = (unr - u) * scale + un; // unr = u - duv[0];
         vn = (vnr - v) * scale + vn;
       }
+      if (ref2 && (scale != 0)) {
+        float unr = 0, vnr = 0;
+        ref2->mCorrection.getCorrectionInvUV(slice, row, u, v, unr, vnr);
+        un = (unr - u) * scale + un; // unr = u - duv[0];
+        vn = (vnr - v) * scale + vn;
+      }
     }
   } else {
     un = u;
@@ -818,7 +847,7 @@ GPUdi() void TPCFastTransform::InverseTransformYZtoNominalYZ(int slice, int row,
   })
 }
 
-GPUdi() void TPCFastTransform::InverseTransformXYZtoNominalXYZ(int slice, int row, float x, float y, float z, float& nx, float& ny, float& nz, const TPCFastTransform* ref, float scale, int scaleMode) const
+GPUdi() void TPCFastTransform::InverseTransformXYZtoNominalXYZ(int slice, int row, float x, float y, float z, float& nx, float& ny, float& nz, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int scaleMode) const
 {
   /// Inverse transformation: Transformed X, Y and Z -> X, Y and Z, transformed w/o space charge correction
   int row2 = row + 1;
@@ -829,8 +858,8 @@ GPUdi() void TPCFastTransform::InverseTransformXYZtoNominalXYZ(int slice, int ro
   float nx2, ny2, nz2; // nominal coordinates for row2
   nx1 = getGeometry().getRowInfo(row).x;
   nx2 = getGeometry().getRowInfo(row2).x;
-  InverseTransformYZtoNominalYZ(slice, row, y, z, ny1, nz1, ref, scale, scaleMode);
-  InverseTransformYZtoNominalYZ(slice, row2, y, z, ny2, nz2, ref, scale, scaleMode);
+  InverseTransformYZtoNominalYZ(slice, row, y, z, ny1, nz1, ref, ref2, scale, scale2, scaleMode);
+  InverseTransformYZtoNominalYZ(slice, row2, y, z, ny2, nz2, ref, ref2, scale, scale2, scaleMode);
   float c1 = (nx2 - nx) / (nx2 - nx1);
   float c2 = (nx - nx1) / (nx2 - nx1);
   nx = x;
diff --git a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
index 351ae9d2ab967..c29c5f9bf0361 100644
--- a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
+++ b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
@@ -104,6 +104,7 @@ class GPURecoWorkflowSpec : public o2::framework::Task
   struct Config {
     int itsTriggerType = 0;
     int lumiScaleMode = 0;
+    bool enableVShape = false;
     int enableDoublePipeline = 0;
     int tpcDeadMapSources = -1;
     bool decompressTPC = false;
@@ -147,6 +148,7 @@ class GPURecoWorkflowSpec : public o2::framework::Task
   struct calibObjectStruct {
     std::unique_ptr<TPCFastTransform> mFastTransform;
     std::unique_ptr<TPCFastTransform> mFastTransformRef;
+    std::unique_ptr<TPCFastTransform> mFastTransformVShape;
     std::unique_ptr<o2::tpc::CorrectionMapsLoader> mFastTransformHelper;
     std::unique_ptr<TPCPadGainCalib> mTPCPadGainCalib;
     std::unique_ptr<o2::tpc::CalibdEdxContainer> mdEdxCalibContainer;
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index 40b6c13495a66..9cfd1ad8ce982 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -250,6 +250,7 @@ void GPURecoWorkflowSpec::init(InitContext& ic)
 
     mConfig->configCalib.fastTransform = mCalibObjects.mFastTransformHelper->getCorrMap();
     mConfig->configCalib.fastTransformRef = mCalibObjects.mFastTransformHelper->getCorrMapRef();
+    mConfig->configCalib.fastTransformVShape = mCalibObjects.mFastTransformHelper->getCorrMapVShape();
     mConfig->configCalib.fastTransformHelper = mCalibObjects.mFastTransformHelper.get();
     if (mConfig->configCalib.fastTransform == nullptr) {
       throw std::invalid_argument("GPU workflow: initialization of the TPC transformation failed");
@@ -1088,7 +1089,7 @@ Inputs GPURecoWorkflowSpec::inputs()
     inputs.emplace_back("tpcthreshold", gDataOriginTPC, "PADTHRESHOLD", 0, Lifetime::Condition, ccdbParamSpec("TPC/Config/FEEPad"));
     o2::tpc::VDriftHelper::requestCCDBInputs(inputs);
     Options optsDummy;
-    o2::tpc::CorrectionMapsLoaderGloOpts gloOpts{mSpecConfig.lumiScaleType, mSpecConfig.lumiScaleMode};
+    o2::tpc::CorrectionMapsLoaderGloOpts gloOpts{mSpecConfig.lumiScaleType, mSpecConfig.lumiScaleMode, mSpecConfig.enableVShape};
     mCalibObjects.mFastTransformHelper->requestCCDBInputs(inputs, optsDummy, gloOpts); // option filled here is lost
   }
   if (mSpecConfig.decompressTPC) {
diff --git a/GPU/Workflow/src/GPUWorkflowTPC.cxx b/GPU/Workflow/src/GPUWorkflowTPC.cxx
index 4dabb9489eba4..7248fde42c186 100644
--- a/GPU/Workflow/src/GPUWorkflowTPC.cxx
+++ b/GPU/Workflow/src/GPUWorkflowTPC.cxx
@@ -110,9 +110,12 @@ void GPURecoWorkflowSpec::initFunctionTPCCalib(InitContext& ic)
   mCalibObjects.mFastTransformHelper.reset(new o2::tpc::CorrectionMapsLoader());
   mCalibObjects.mFastTransform = std::move(o2::tpc::TPCFastTransformHelperO2::instance()->create(0));
   mCalibObjects.mFastTransformRef = std::move(o2::tpc::TPCFastTransformHelperO2::instance()->create(0));
+  mCalibObjects.mFastTransformVShape = std::move(o2::tpc::TPCFastTransformHelperO2::instance()->create(0));
   mCalibObjects.mFastTransformHelper->setCorrMap(mCalibObjects.mFastTransform.get()); // just to reserve the space
   mCalibObjects.mFastTransformHelper->setCorrMapRef(mCalibObjects.mFastTransformRef.get());
+  mCalibObjects.mFastTransformHelper->setCorrMapVShape(mCalibObjects.mFastTransformVShape.get());
   mCalibObjects.mFastTransformHelper->setLumiScaleMode(mSpecConfig.lumiScaleMode);
+  mCalibObjects.mFastTransformHelper->enableVShapeCorrection(mSpecConfig.enableVShape);
   if (mSpecConfig.outputTracks) {
     mCalibObjects.mFastTransformHelper->init(ic);
   }
@@ -357,12 +360,21 @@ bool GPURecoWorkflowSpec::fetchCalibsCCDBTPC<GPUCalibObjectsConst>(ProcessingCon
           newCalibObjects.fastTransformRef = mCalibObjects.mFastTransformRef.get();
           mustUpdateHelper = true;
         }
+        if (mTPCVDriftHelper->isUpdated() || mCalibObjects.mFastTransformHelper->isUpdatedMapVShape()) {
+          oldCalibObjects.mFastTransformVShape = std::move(mCalibObjects.mFastTransformVShape);
+          mCalibObjects.mFastTransformVShape.reset(new TPCFastTransform);
+          mCalibObjects.mFastTransformVShape->cloneFromObject(*mCalibObjects.mFastTransformHelper->getCorrMapVShape(), nullptr);
+          o2::tpc::TPCFastTransformHelperO2::instance()->updateCalibration(*mCalibObjects.mFastTransformVShape, 0, vd.corrFact, vd.refVDrift, vd.getTimeOffset());
+          newCalibObjects.fastTransformVShape = mCalibObjects.mFastTransformVShape.get();
+          mustUpdateHelper = true;
+        }
         if (mustUpdateHelper || mCalibObjects.mFastTransformHelper->isUpdatedLumi()) {
           oldCalibObjects.mFastTransformHelper = std::move(mCalibObjects.mFastTransformHelper);
           mCalibObjects.mFastTransformHelper.reset(new o2::tpc::CorrectionMapsLoader);
           mCalibObjects.mFastTransformHelper->copySettings(*oldCalibObjects.mFastTransformHelper);
           mCalibObjects.mFastTransformHelper->setCorrMap(mCalibObjects.mFastTransform.get());
           mCalibObjects.mFastTransformHelper->setCorrMapRef(mCalibObjects.mFastTransformRef.get());
+          mCalibObjects.mFastTransformHelper->setCorrMapVShape(mCalibObjects.mFastTransformVShape.get());
           mCalibObjects.mFastTransformHelper->acknowledgeUpdate();
           newCalibObjects.fastTransformHelper = mCalibObjects.mFastTransformHelper.get();
         }
diff --git a/GPU/Workflow/src/gpu-reco-workflow.cxx b/GPU/Workflow/src/gpu-reco-workflow.cxx
index d3572f1e6873a..ff6bf4a9dba2a 100644
--- a/GPU/Workflow/src/gpu-reco-workflow.cxx
+++ b/GPU/Workflow/src/gpu-reco-workflow.cxx
@@ -160,6 +160,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   cfg.runTPCTracking = true;
   cfg.lumiScaleType = sclOpt.lumiType;
   cfg.lumiScaleMode = sclOpt.lumiMode;
+  cfg.enableVShape = sclOpt.enableVShapeCorrection;
   cfg.decompressTPC = isEnabled(inputTypes, ioType::CompClustCTF);
   cfg.decompressTPCFromROOT = isEnabled(inputTypes, ioType::CompClustROOT);
   cfg.zsDecoder = isEnabled(inputTypes, ioType::ZSRaw);