GPU TPC: Add option to apply timebin cut to CTF cluster decoding CPU-only version

GPU/GPUTracking/Base/GPUParam.cxx

@@ -120,18 +120,20 @@ void GPUParam::SetDefaults(float solenoidBz)
   par.toyMCEventsFlag = false;
   par.continuousTracking = false;
   continuousMaxTimeBin = 0;
+  tpcCutTimeBin = 0;
   par.debugLevel = 0;
   par.earlyTpcTransform = false;
 }
 
-void GPUParam::UpdateSettings(const GPUSettingsGRP* g, const GPUSettingsProcessing* p, const GPURecoStepConfiguration* w)
+void GPUParam::UpdateSettings(const GPUSettingsGRP* g, const GPUSettingsProcessing* p, const GPURecoStepConfiguration* w, const GPUSettingsRecDynamic* d)
 {
   if (g) {
     UpdateBzOnly(g->solenoidBzNominalGPU);
     par.assumeConstantBz = g->constBz;
     par.toyMCEventsFlag = g->homemadeEvents;
     par.continuousTracking = g->grpContinuousMaxTimeBin != 0;
     continuousMaxTimeBin = g->grpContinuousMaxTimeBin == -1 ? GPUSettings::TPC_MAX_TF_TIME_BIN : g->grpContinuousMaxTimeBin;
+    tpcCutTimeBin = g->tpcCutTimeBin;
   }
   par.earlyTpcTransform = rec.tpc.forceEarlyTransform == -1 ? (!par.continuousTracking) : rec.tpc.forceEarlyTransform;
   qptB5Scaler = CAMath::Abs(bzkG) > 0.1f ? CAMath::Abs(bzkG) / 5.006680f : 1.f; // Repeat here, since passing in g is optional
@@ -145,6 +147,9 @@ void GPUParam::UpdateSettings(const GPUSettingsGRP* g, const GPUSettingsProcessi
       dodEdxDownscaled = (rand() % 100) < p->tpcDownscaledEdx;
     }
   }
+  if (d) {
+    rec.dyn = *d;
+  }
 }
 
 void GPUParam::UpdateBzOnly(float newSolenoidBz)

GPU/GPUTracking/Base/GPUParam.h

@@ -59,6 +59,7 @@ struct GPUParam_t {
 
   int8_t dodEdxDownscaled;
   int32_t continuousMaxTimeBin;
+  int32_t tpcCutTimeBin;
 
   GPUTPCGeometry tpcGeometry;                       // TPC Geometry
   GPUTPCGMPolynomialField polynomialField;          // Polynomial approx. of magnetic field for TPC GM
@@ -84,7 +85,7 @@ struct GPUParam : public internal::GPUParam_t<GPUSettingsRec, GPUSettingsParam>
 #ifndef GPUCA_GPUCODE
   void SetDefaults(float solenoidBz);
   void SetDefaults(const GPUSettingsGRP* g, const GPUSettingsRec* r = nullptr, const GPUSettingsProcessing* p = nullptr, const GPURecoStepConfiguration* w = nullptr);
-  void UpdateSettings(const GPUSettingsGRP* g, const GPUSettingsProcessing* p = nullptr, const GPURecoStepConfiguration* w = nullptr);
+  void UpdateSettings(const GPUSettingsGRP* g, const GPUSettingsProcessing* p = nullptr, const GPURecoStepConfiguration* w = nullptr, const GPUSettingsRecDynamic* d = nullptr);
   void UpdateBzOnly(float newSolenoidBz);
   void LoadClusterErrors(bool Print = 0);
   void UpdateRun3ClusterErrors(const float* yErrorParam, const float* zErrorParam);

GPU/GPUTracking/Base/GPUReconstruction.cxx

@@ -427,7 +427,7 @@ int32_t GPUReconstruction::InitPhaseAfterDevice()
     (mProcessors[i].proc->*(mProcessors[i].InitializeProcessor))();
   }
 
-  WriteConstantParams(); // First initialization, if the user doesn't use RunChains
+  WriteConstantParams(); // Initialize with initial values, can optionally be updated later
 
   mInitialized = true;
   return 0;
@@ -1105,7 +1105,12 @@ void GPUReconstruction::DumpSettings(const char* dir)
   }
 }
 
-void GPUReconstruction::UpdateSettings(const GPUSettingsGRP* g, const GPUSettingsProcessing* p)
+void GPUReconstruction::UpdateDynamicSettings(const GPUSettingsRecDynamic* d)
+{
+  UpdateSettings(nullptr, nullptr, d);
+}
+
+void GPUReconstruction::UpdateSettings(const GPUSettingsGRP* g, const GPUSettingsProcessing* p, const GPUSettingsRecDynamic* d)
 {
   if (g) {
     mGRPSettings = *g;
@@ -1114,8 +1119,11 @@ void GPUReconstruction::UpdateSettings(const GPUSettingsGRP* g, const GPUSetting
     mProcessingSettings.debugLevel = p->debugLevel;
     mProcessingSettings.resetTimers = p->resetTimers;
   }
-  GPURecoStepConfiguration w = mRecoSteps;
-  param().UpdateSettings(g, p, &w);
+  GPURecoStepConfiguration* w = nullptr;
+  if (mRecoSteps.steps.isSet(GPUDataTypes::RecoStep::TPCdEdx)) {
+    w = &mRecoSteps;
+  }
+  param().UpdateSettings(g, p, w, d);
   if (mInitialized) {
     WriteConstantParams();
   }

GPU/GPUTracking/Base/GPUReconstruction.h

@@ -200,7 +200,8 @@ class GPUReconstruction
   void SetSettings(const GPUSettingsGRP* grp, const GPUSettingsRec* rec = nullptr, const GPUSettingsProcessing* proc = nullptr, const GPURecoStepConfiguration* workflow = nullptr);
   void SetResetTimers(bool reset) { mProcessingSettings.resetTimers = reset; } // May update also after Init()
   void SetDebugLevelTmp(int32_t level) { mProcessingSettings.debugLevel = level; } // Temporarily, before calling SetSettings()
-  void UpdateSettings(const GPUSettingsGRP* g, const GPUSettingsProcessing* p = nullptr);
+  void UpdateSettings(const GPUSettingsGRP* g, const GPUSettingsProcessing* p = nullptr, const GPUSettingsRecDynamic* d = nullptr);
+  void UpdateDynamicSettings(const GPUSettingsRecDynamic* d);
   void SetOutputControl(const GPUOutputControl& v) { mOutputControl = v; }
   void SetOutputControl(void* ptr, size_t size);
   void SetInputControl(void* ptr, size_t size);

GPU/GPUTracking/Base/GPUReconstructionCPU.cxx

@@ -228,7 +228,7 @@ int32_t GPUReconstructionCPU::RunChains()
       mThreadId = GetThread();
     }
     if (mSlaves.size() || mMaster) {
-      WriteConstantParams(); // Reinitialize
+      WriteConstantParams(); // Reinitialize // TODO: Get this in sync with GPUChainTracking::DoQueuedUpdates, and consider the doublePipeline
     }
     for (uint32_t i = 0; i < mChains.size(); i++) {
       int32_t retVal = mChains[i]->RunChain();

GPU/GPUTracking/DataTypes/GPUNewCalibValues.cxx

@@ -24,4 +24,7 @@ void GPUNewCalibValues::updateFrom(const GPUNewCalibValues* from)
   if (from->newContinuousMaxTimeBin) {
     continuousMaxTimeBin = from->continuousMaxTimeBin;
   }
+  if (from->newTPCTimeBinCut) {
+    tpcTimeBinCut = from->tpcTimeBinCut;
+  }
 }

GPU/GPUTracking/DataTypes/GPUNewCalibValues.h

@@ -25,8 +25,10 @@ namespace gpu
 struct GPUNewCalibValues {
   bool newSolenoidField = false;
   bool newContinuousMaxTimeBin = false;
+  bool newTPCTimeBinCut = false;
   float solenoidField = 0.f;
   uint32_t continuousMaxTimeBin = 0;
+  int32_t tpcTimeBinCut = 0;
 
   void updateFrom(const GPUNewCalibValues* from);
 };

GPU/GPUTracking/DataTypes/GPUSettings.h

@@ -60,6 +60,7 @@ struct GPUSettingsGRP {
   int32_t grpContinuousMaxTimeBin = -2;   // 0 for triggered events, -1 for automatic setting, -2 invalid default
   int32_t needsClusterer = 0;             // Set to true if the data requires the clusterizer
   int32_t doCompClusterDecode = 0;        // Set to true if the data contains compressed TPC clusters
+  int32_t tpcCutTimeBin = 0;              // Cut TPC clusters and digits >= this cut
 };
 
 // Parameters of the current time frame

GPU/GPUTracking/Definitions/GPUSettingsList.h

@@ -181,6 +181,11 @@ AddOptionRTC(pileupBwdNBC, uint8_t, 80, "", 0, "Pre-trigger Pile-up integration
 AddHelp("help", 'h')
 EndConfig()
 
+// Dynamic settings, must NOT use AddOptionRTC(...) !!!
+BeginSubConfig(GPUSettingsRecDynamic, dyn, configStandalone.rec, "RECDYN", 0, "Reconstruction settings", rec_dyn)
+AddHelp("help", 'h')
+EndConfig()
+
 BeginSubConfig(GPUSettingsRec, rec, configStandalone, "REC", 0, "Reconstruction settings", rec)
 AddOptionRTC(maxTrackQPtB5, float, 1.f / GPUCA_MIN_TRACK_PTB5_DEFAULT, "", 0, "required max Q/Pt (==min Pt) of tracks")
 AddOptionRTC(nonConsecutiveIDs, int8_t, false, "", 0, "Non-consecutive cluster IDs as in HLT, disables features that need access to slice data in TPC merger")
@@ -193,6 +198,7 @@ AddOptionRTC(trackingRefitGPUModel, int8_t, 1, "", 0, "Use GPU track model for t
 AddCustomCPP(void SetMinTrackPtB5(float v) { maxTrackQPtB5 = v > 0.001f ? (1.f / v) : (1.f / 0.001f); })
 AddSubConfig(GPUSettingsRecTPC, tpc)
 AddSubConfig(GPUSettingsRecTRD, trd)
+AddSubConfig(GPUSettingsRecDynamic, dyn)
 AddHelp("help", 'h')
 EndConfig()
 
@@ -530,6 +536,7 @@ AddOption(solenoidBzNominalGPU, float, -1e6f, "", 0, "Field strength of solenoid
 AddOption(constBz, bool, false, "", 0, "force constant Bz for tests")
 AddOption(setMaxTimeBin, int32_t, -2, "", 0, "maximum time bin of continuous data, 0 for triggered events, -1 for automatic continuous mode, -2 for automatic continuous / triggered")
 AddOption(overrideNHbfPerTF, int32_t, 0, "", 0, "Overrides the number of HBF per TF if != 0")
+AddOption(overrideTPCTimeBinCur, int32_t, 0, "", 0, "Overrides TPC time bin cut if > 0")
 AddOption(deviceType, std::string, "CPU", "", 0, "Device type, CPU | CUDA | HIP | OCL1 | OCL2")
 AddOption(forceDeviceType, bool, true, "", 0, "force device type, otherwise allows fall-back to CPU")
 AddOption(synchronousProcessing, bool, false, "", 0, "Apply performance shortcuts for synchronous processing, disable unneeded steps")

GPU/GPUTracking/GPUTrackingLinkDef_O2_DataTypes.h

@@ -28,6 +28,7 @@
 #pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsRec + ;
 #pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsRecTPC + ;
 #pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsRecTRD + ;
+#pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsRecDynamic + ;
 #pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsProcessing + ;
 #pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsProcessingParam + ;
 #pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsProcessingRTC + ;

GPU/GPUTracking/Global/GPUChainTracking.cxx

@@ -641,6 +641,9 @@ int32_t GPUChainTracking::DoQueuedUpdates(int32_t stream, bool updateSlave)
       if (mNewCalibValues->newContinuousMaxTimeBin) {
         grp->grpContinuousMaxTimeBin = mNewCalibValues->continuousMaxTimeBin;
       }
+      if (mNewCalibValues->newTPCTimeBinCut) {
+        grp->tpcCutTimeBin = mNewCalibValues->tpcTimeBinCut;
+      }
     }
   }
   if (GetProcessingSettings().tpcDownscaledEdx != 0) {

GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx

@@ -18,6 +18,7 @@
 #include "GPUO2DataTypes.h"
 #include "GPUMemorySizeScalers.h"
 #include "GPUTrackingInputProvider.h"
+#include "GPUNewCalibValues.h"
 #include <fstream>
 
 #ifdef GPUCA_O2_LIB
@@ -573,6 +574,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
     return ForwardTPCDigits();
   }
 #ifdef GPUCA_TPC_GEOMETRY_O2
+  int32_t tpcTimeBinCut = mUpdateNewCalibObjects && mNewCalibValues->newTPCTimeBinCut ? mNewCalibValues->tpcTimeBinCut : param().tpcCutTimeBin;
   mRec->PushNonPersistentMemory(qStr2Tag("TPCCLUST"));
   const auto& threadContext = GetThreadContext();
   const bool doGPU = GetRecoStepsGPU() & RecoStep::TPCClusterFinding;
@@ -765,6 +767,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
                                                                                                                                                                                                                    : 0;
           uint32_t nBlocks = doGPU ? clusterer.mPmemory->counters.nPagesSubslice : GPUTrackingInOutZS::NENDPOINTS;
 
+          (void)tpcTimeBinCut; // TODO: To be used in decoding kernels
           switch (mCFContext->zsVersion) {
             default:
               GPUFatal("Data with invalid TPC ZS mode (%d) received", mCFContext->zsVersion);

GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx

@@ -219,14 +219,15 @@ int32_t GPUChainTracking::RunTPCDecompression()
       return ((tmpBuffer = std::make_unique<ClusterNative[]>(size))).get();
     };
     auto& decompressTimer = getTimer<TPCClusterDecompressor>("TPCDecompression", 0);
-    auto allocatorUse = GetProcessingSettings().tpcApplyCFCutsAtDecoding ? std::function<ClusterNative*(size_t)>{allocatorTmp} : std::function<ClusterNative*(size_t)>{allocatorFinal};
+    bool runFiltering = GetProcessingSettings().tpcApplyCFCutsAtDecoding;
+    auto allocatorUse = runFiltering ? std::function<ClusterNative*(size_t)>{allocatorTmp} : std::function<ClusterNative*(size_t)>{allocatorFinal};
     decompressTimer.Start();
     if (decomp.decompress(mIOPtrs.tpcCompressedClusters, *mClusterNativeAccess, allocatorUse, param(), GetProcessingSettings().deterministicGPUReconstruction)) {
       GPUError("Error decompressing clusters");
       return 1;
     }
-    if (GetProcessingSettings().tpcApplyCFCutsAtDecoding) {
-      RunTPCClusterFilter(mClusterNativeAccess.get(), allocatorFinal, true);
+    if (runFiltering) {
+      RunTPCClusterFilter(mClusterNativeAccess.get(), allocatorFinal, GetProcessingSettings().tpcApplyCFCutsAtDecoding);
     }
     decompressTimer.Stop();
     mIOPtrs.clustersNative = mClusterNativeAccess.get();

GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx

@@ -315,6 +315,9 @@ void GPUChainTracking::RunTPCClusterFilter(o2::tpc::ClusterNativeAccess* cluster
             keep = keep && cl.qTot > param().rec.tpc.cfQTotCutoff && cl.qMax > param().rec.tpc.cfQMaxCutoff;
             keep = keep && (!(cl.getFlags() & o2::tpc::ClusterNative::flagSingle) || ((cl.sigmaPadPacked || cl.qMax > param().rec.tpc.cfQMaxCutoffSinglePad) && (cl.sigmaTimePacked || cl.qMax > param().rec.tpc.cfQMaxCutoffSingleTime)));
           }
+          if (param().tpcCutTimeBin > 0) {
+            keep = keep && cl.getTime() < param().tpcCutTimeBin;
+          }
           keep = keep && (!GetProcessingSettings().tpcApplyDebugClusterFilter || clusterFilter.filter(iSector, iRow, cl));
           if (iPhase && keep) {
             outputBuffer[countTotal] = cl;

GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx

@@ -370,7 +370,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
           CADEBUG(printf("Reinit linearization\n"));
           prop.SetTrack(this, prop.GetAlpha());
         }
-        if (param.par.dodEdx && param.dodEdxDownscaled && iWay == nWays - 1 && cluster.leg == clusters[maxN - 1].leg && !(clusterState & GPUTPCGMMergedTrackHit::flagEdge)) {
+        if (param.par.dodEdx && param.dodEdxDownscaled && iWay == nWays - 1 && cluster.leg == clusters[maxN - 1].leg && !(clusterState & GPUTPCGMMergedTrackHit::flagEdge)) { // TODO: Costimize flag to remove, and option to remove double-clusters
           float qtot = 0, qmax = 0, pad = 0, relTime = 0;
           const int32_t clusterCount = (ihit - ihitMergeFirst) * wayDirection + 1;
           for (int32_t iTmp = ihitMergeFirst; iTmp != ihit + wayDirection; iTmp += wayDirection) {
@@ -384,7 +384,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
               relTime += cl.getTime();
             }
           }
-          qtot /= clusterCount;
+          qtot /= clusterCount; // TODO: Weighted Average
           pad /= clusterCount;
           relTime /= clusterCount;
           relTime = relTime - CAMath::Round(relTime);
@@ -528,7 +528,7 @@ GPUd() int32_t GPUTPCGMTrackParam::MergeDoubleRowClusters(int32_t& ihit, int32_t
         }
       } else {
         CADEBUG(printf("\t\tMerging hit row %d X %f Y %f Z %f (dy %f, dz %f, chiY %f, chiZ %f)\n", clusters[ihit].row, clx, cly, clz, dy, dz, sqrtf(maxDistY), sqrtf(maxDistZ)));
-        xx += clx * clamp;
+        xx += clx * clamp; // TODO: Weight in pad/time instead of XYZ
         yy += cly * clamp;
         zz += clz * clamp;
         clusterState |= clusters[ihit].state;

GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h

@@ -233,6 +233,7 @@ class GPURecoWorkflowSpec : public o2::framework::Task
   bool mITSGeometryCreated = false;
   bool mTRDGeometryCreated = false;
   bool mPropagatorInstanceCreated = false;
+  int32_t mTPCCutAtTimeBin = -1;
 };
 
 } // end namespace gpu

GPU/Workflow/src/GPUWorkflowSpec.cxx

@@ -1013,9 +1013,8 @@ void GPURecoWorkflowSpec::doCalibUpdates(o2::framework::ProcessingContext& pc, c
       LOG(info) << "Updating solenoid field " << newCalibValues.solenoidField;
     }
     if (mAutoContinuousMaxTimeBin) {
-      mConfig->configGRP.grpContinuousMaxTimeBin = GPUO2InterfaceUtils::getTpcMaxTimeBinFromNHbf(mTFSettings->nHBFPerTF);
       newCalibValues.newContinuousMaxTimeBin = true;
-      newCalibValues.continuousMaxTimeBin = mConfig->configGRP.grpContinuousMaxTimeBin;
+      newCalibValues.continuousMaxTimeBin = mConfig->configGRP.grpContinuousMaxTimeBin = GPUO2InterfaceUtils::getTpcMaxTimeBinFromNHbf(mTFSettings->nHBFPerTF);
       LOG(info) << "Updating max time bin " << newCalibValues.continuousMaxTimeBin << " (" << mTFSettings->nHBFPerTF << " orbits)";
     }
 
@@ -1050,6 +1049,11 @@ void GPURecoWorkflowSpec::doCalibUpdates(o2::framework::ProcessingContext& pc, c
   if (mSpecConfig.runITSTracking) {
     needCalibUpdate = fetchCalibsCCDBITS(pc) || needCalibUpdate;
   }
+  if (mTPCCutAtTimeBin != mConfig->configGRP.tpcCutTimeBin) {
+    newCalibValues.newTPCTimeBinCut = true;
+    newCalibValues.tpcTimeBinCut = mConfig->configGRP.tpcCutTimeBin = mTPCCutAtTimeBin;
+    needCalibUpdate = true;
+  }
   if (needCalibUpdate) {
     LOG(info) << "Updating GPUReconstruction calibration objects";
     mGPUReco->UpdateCalibration(newCalibObjects, newCalibValues);
@@ -1095,8 +1099,13 @@ Inputs GPURecoWorkflowSpec::inputs()
   } else if (mSpecConfig.enableDoublePipeline == 1) {
     inputs.emplace_back("pipelineprepare", gDataOriginGPU, "PIPELINEPREPARE", 0, Lifetime::Timeframe);
   }
+  if (mSpecConfig.outputTracks || mSpecConfig.caClusterer) {
+    // calibration objects for TPC clusterization
+    inputs.emplace_back("tpcgain", gDataOriginTPC, "PADGAINFULL", 0, Lifetime::Condition, ccdbParamSpec(o2::tpc::CDBTypeMap.at(o2::tpc::CDBType::CalPadGainFull)));
+    inputs.emplace_back("tpcaltrosync", gDataOriginTPC, "ALTROSYNCSIGNAL", 0, Lifetime::Condition, ccdbParamSpec(o2::tpc::CDBTypeMap.at(o2::tpc::CDBType::AltroSyncSignal)));
+  }
   if (mSpecConfig.outputTracks) {
-    // loading calibration objects from the CCDB
+    // calibration objects for TPC tracking
     const auto mapSources = mSpecConfig.tpcDeadMapSources;
     if (mapSources != 0) {
       tpc::SourcesDeadMap sources((mapSources > -1) ? static_cast<tpc::SourcesDeadMap>(mapSources) : tpc::SourcesDeadMap::All);
@@ -1107,7 +1116,7 @@ Inputs GPURecoWorkflowSpec::inputs()
         inputs.emplace_back("tpcruninfo", gDataOriginTPC, "TPCRUNINFO", 0, Lifetime::Condition, ccdbParamSpec(o2::tpc::CDBTypeMap.at(o2::tpc::CDBType::ConfigRunInfo)));
       }
     }
-    inputs.emplace_back("tpcgain", gDataOriginTPC, "PADGAINFULL", 0, Lifetime::Condition, ccdbParamSpec(o2::tpc::CDBTypeMap.at(o2::tpc::CDBType::CalPadGainFull)));
+
     inputs.emplace_back("tpcgainresidual", gDataOriginTPC, "PADGAINRESIDUAL", 0, Lifetime::Condition, ccdbParamSpec(o2::tpc::CDBTypeMap.at(o2::tpc::CDBType::CalPadGainResidual), {}, 1)); // time-dependent
     if (mSpecConfig.tpcUseMCTimeGain) {
       inputs.emplace_back("tpctimegain", gDataOriginTPC, "TIMEGAIN", 0, Lifetime::Condition, ccdbParamSpec(o2::tpc::CDBTypeMap.at(o2::tpc::CDBType::CalTimeGainMC), {}, 1)); // time-dependent
@@ -1124,11 +1133,6 @@ Inputs GPURecoWorkflowSpec::inputs()
   if (mSpecConfig.decompressTPC) {
     inputs.emplace_back(InputSpec{"input", ConcreteDataTypeMatcher{gDataOriginTPC, mSpecConfig.decompressTPCFromROOT ? o2::header::DataDescription("COMPCLUSTERS") : o2::header::DataDescription("COMPCLUSTERSFLAT")}, Lifetime::Timeframe});
   } else if (mSpecConfig.caClusterer) {
-    // if the output type are tracks, then the input spec for the gain map is already defined
-    if (!mSpecConfig.outputTracks) {
-      inputs.emplace_back("tpcgain", gDataOriginTPC, "PADGAINFULL", 0, Lifetime::Condition, ccdbParamSpec(o2::tpc::CDBTypeMap.at(o2::tpc::CDBType::CalPadGainFull)));
-    }
-
     // We accept digits and MC labels also if we run on ZS Raw data, since they are needed for MC label propagation
     if ((!mSpecConfig.zsOnTheFly || mSpecConfig.processMC) && !mSpecConfig.zsDecoder) {
       inputs.emplace_back(InputSpec{"input", ConcreteDataTypeMatcher{gDataOriginTPC, "DIGITS"}, Lifetime::Timeframe});

GPU/Workflow/src/GPUWorkflowTPC.cxx

@@ -65,10 +65,7 @@
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "Algorithm/Parser.h"
 #include "DataFormatsGlobalTracking/RecoContainer.h"
-#include "DataFormatsTRD/RecoInputContainer.h"
-#include "TRDBase/Geometry.h"
-#include "TRDBase/GeometryFlat.h"
-#include "ITSBase/GeometryTGeo.h"
+#include "DataFormatsTPC/AltroSyncSignal.h"
 #include "CommonUtils/VerbosityConfig.h"
 #include "CommonUtils/DebugStreamer.h"
 #include <filesystem>
@@ -308,6 +305,10 @@ bool GPURecoWorkflowSpec::fetchCalibsCCDBTPC<GPUCalibObjectsConst>(ProcessingCon
       pc.inputs().get<o2::tpc::CalDet<float>*>("tpcgain");
     }
 
+    if (mSpecConfig.outputTracks || mSpecConfig.caClusterer) {
+      mTPCCutAtTimeBin = mConfParam->overrideTPCTimeBinCur > 0 ? mConfParam->overrideTPCTimeBinCur : pc.inputs().get<o2::tpc::AltroSyncSignal*>("tpcaltrosync")->getTB2Cut(pc.services().get<o2::framework::TimingInfo>().tfCounter);
+    }
+
     // these calibrations are only defined for the tracking
     if (mSpecConfig.outputTracks) {
       // update the calibration objects in case they changed in the CCDB