GPU: Unify applying settings for sync reco between standalone and GPUWorkflow

Author: davidrohr

GPU/GPUTracking/Global/GPUChainTracking.cxx

@@ -1011,3 +1011,17 @@ void GPUChainTracking::SetO2Propagator(const o2::base::Propagator* prop)
     GPUFatal("GPU magnetic field for propagator requested, but received an O2 propagator without GPU field");
   }
 }
+
+void GPUChainTracking::ApplySyncSettings(GPUSettingsProcessing& proc, GPUSettingsRec& rec, GPUDataTypes::RecoStepField& steps, bool syncMode, int32_t dEdxMode)
+{
+  if (syncMode) {
+    rec.useMatLUT = false;
+    rec.tpc.rebuildTrackMaxNonIntCov = 0.f;
+  }
+  if (proc.rtc.optSpecialCode == -1) {
+    proc.rtc.optSpecialCode = syncMode;
+  }
+  if (dEdxMode != -2) {
+    steps.setBits(GPUDataTypes::RecoStep::TPCdEdx, dEdxMode == -1 ? !syncMode : dEdxMode > 0);
+  }
+}

GPU/GPUTracking/Global/GPUChainTracking.h

@@ -66,6 +66,8 @@ struct GPUNewCalibValues;
 struct GPUTriggerOutputs;
 struct CfFragment;
 class GPUTPCClusterFinder;
+struct GPUSettingsProcessing;
+struct GPUSettingsRec;
 
 class GPUChainTracking : public GPUChain
 {
@@ -86,6 +88,7 @@ class GPUChainTracking : public GPUChain
   void ClearErrorCodes(bool cpuOnly = false);
   int32_t DoQueuedUpdates(int32_t stream, bool updateSlave = true); // Forces doing queue calib updates, don't call when you are not sure you are allowed to do so!
   bool QARanForTF() const { return mFractionalQAEnabled; }
+  static void ApplySyncSettings(GPUSettingsProcessing& proc, GPUSettingsRec& rec, GPUDataTypes::RecoStepField& steps, bool syncMode, int32_t dEdxMode = -2);
 
   // Structures for input and output data
   GPUTrackingInOutPointers& mIOPtrs;

GPU/GPUTracking/Interface/GPUO2Interface.cxx

@@ -268,3 +268,8 @@ void GPUO2Interface::UseGPUPolynomialFieldInPropagator(o2::base::Propagator* pro
 {
   prop->setGPUField(&mCtx[0].mRec->GetParam().polynomialField);
 }
+
+void GPUO2Interface::ApplySyncSettings(GPUSettingsProcessing& proc, GPUSettingsRec& rec, GPUDataTypes::RecoStepField& steps, bool syncMode, int32_t dEdxMode)
+{
+  GPUChainTracking::ApplySyncSettings(proc, rec, steps, syncMode, dEdxMode);
+}

GPU/GPUTracking/Interface/GPUO2Interface.h

@@ -56,6 +56,8 @@ struct GPUInterfaceInputUpdate;
 struct GPUTrackingOutputs;
 struct GPUConstantMem;
 struct GPUNewCalibValues;
+struct GPUSettingsProcessing;
+struct GPUSettingsRec;
 
 struct GPUO2Interface_processingContext;
 struct GPUO2Interface_Internals;
@@ -80,6 +82,7 @@ class GPUO2Interface
 
   // Updates all calibration objects that are != nullptr in newCalib
   int32_t UpdateCalibration(const GPUCalibObjectsConst& newCalib, const GPUNewCalibValues& newVals, uint32_t iThread = 0);
+  static void ApplySyncSettings(GPUSettingsProcessing& proc, GPUSettingsRec& rec, GPUDataTypes::RecoStepField& steps, bool syncMode, int32_t dEdxMode = -2);
 
   int32_t registerMemoryForGPU(const void* ptr, size_t size);
   int32_t unregisterMemoryForGPU(const void* ptr);

GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx

@@ -407,7 +407,7 @@ GPUdii() float GPUTPCGMTrackParam::FindBestInterpolatedHit(GPUTPCGMMerger& GPUre
   GPUglobalref() const cahit2* hits = tracker.HitData(rowData);
   GPUglobalref() const calink* firsthit = tracker.FirstHitInBin(rowData);
   float uncorrectedY = -1e6f, uncorrectedZ;
-  if (rowData.NHits() && (inter.errorY >= (GPUCA_PAR_MERGER_INTERPOLATION_ERROR_TYPE_A)0 || (mC[0] < param.rec.tpc.rebuildTrackMaxNonIntCov && mC[2] < param.rec.tpc.rebuildTrackMaxNonIntCov))) {
+  if (rowData.NHits() && (inter.errorY >= (GPUCA_PAR_MERGER_INTERPOLATION_ERROR_TYPE_A)0 || (param.rec.tpc.rebuildTrackMaxNonIntCov > 0 && mC[0] < param.rec.tpc.rebuildTrackMaxNonIntCov && mC[2] < param.rec.tpc.rebuildTrackMaxNonIntCov))) {
     const float zOffset = param.par.continuousTracking ? merger.GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(sector, mTOffset, param.continuousMaxTimeBin) : 0;
     const float y0 = rowData.Grid().YMin();
     const float stepY = rowData.HstepY();

GPU/GPUTracking/Standalone/Benchmark/standalone.cxx

@@ -374,9 +374,6 @@ int32_t SetupReconstruction()
   } else if (chainTracking->GetTRDGeometry() == nullptr) {
     steps.steps.setBits(GPUDataTypes::RecoStep::TRDTracking, false);
   }
-  if (configStandalone.rundEdx != -1) {
-    steps.steps.setBits(GPUDataTypes::RecoStep::TPCdEdx, configStandalone.rundEdx > 0);
-  }
   if (configStandalone.runCompression != -1) {
     steps.steps.setBits(GPUDataTypes::RecoStep::TPCCompression, configStandalone.runCompression > 0);
   }
@@ -431,23 +428,15 @@ int32_t SetupReconstruction()
     }
   }
 
+  // Set settings for synchronous
+  GPUChainTracking::ApplySyncSettings(procSet, recSet, steps.steps, configStandalone.testSyncAsync || configStandalone.testSync, configStandalone.rundEdx);
   bool runAsyncQA = procSet.runQA && !configStandalone.testSyncAsyncQcInSync;
-  if (configStandalone.testSyncAsync || configStandalone.testSync) {
-    // Set settings for synchronous
-    if (configStandalone.rundEdx == -1) {
-      steps.steps.setBits(GPUDataTypes::RecoStep::TPCdEdx, 0);
-    }
-    recSet.useMatLUT = false;
-    if (configStandalone.testSyncAsync) {
-      procSet.eventDisplay = nullptr;
-      if (!configStandalone.testSyncAsyncQcInSync) {
-        procSet.runQA = false;
-      }
+  if (configStandalone.testSyncAsync) {
+    procSet.eventDisplay = nullptr;
+    if (!configStandalone.testSyncAsyncQcInSync) {
+      procSet.runQA = false;
     }
   }
-  if (configStandalone.proc.rtc.optSpecialCode == -1) {
-    configStandalone.proc.rtc.optSpecialCode = configStandalone.testSyncAsync || configStandalone.testSync;
-  }
 
   rec->SetSettings(&grp, &recSet, &procSet, &steps);
   if (configStandalone.proc.doublePipeline) {
@@ -467,13 +456,12 @@ int32_t SetupReconstruction()
     procSet.runQA = runAsyncQA;
     procSet.eventDisplay = eventDisplay.get();
     procSet.runCompressionStatistics = 0;
-    procSet.rtc.optSpecialCode = 0;
     if (recSet.tpc.rejectionStrategy >= GPUSettings::RejectionStrategyB) {
       procSet.tpcInputWithClusterRejection = 1;
     }
     recSet.tpc.disableRefitAttachment = 0xFF;
     recSet.maxTrackQPtB5 = CAMath::Min(recSet.maxTrackQPtB5, recSet.tpc.rejectQPtB5);
-    recSet.useMatLUT = true;
+    GPUChainTracking::ApplySyncSettings(procSet, recSet, steps.steps, false, configStandalone.rundEdx);
     recAsync->SetSettings(&grp, &recSet, &procSet, &steps);
   }
 

GPU/Workflow/src/GPUWorkflowSpec.cxx

@@ -228,20 +228,15 @@ void GPURecoWorkflowSpec::init(InitContext& ic)
     }
   }
   mConfig->configInterface.outputToExternalBuffers = true;
-  if (mConfParam->synchronousProcessing) {
-    mConfig->configReconstruction.useMatLUT = false;
-  }
-  if (mConfig->configProcessing.rtc.optSpecialCode == -1) {
-    mConfig->configProcessing.rtc.optSpecialCode = mConfParam->synchronousProcessing;
-  }
+  const bool runTracking = mSpecConfig.outputTracks || mSpecConfig.outputCompClustersRoot || mSpecConfig.outputCompClustersFlat;
+  GPUO2Interface::ApplySyncSettings(mConfig->configProcessing, mConfig->configReconstruction, mConfig->configWorkflow.steps, mConfParam->synchronousProcessing, runTracking ? mConfParam->rundEdx : -2);
 
   // Configure the "GPU workflow" i.e. which steps we run on the GPU (or CPU)
-  if (mSpecConfig.outputTracks || mSpecConfig.outputCompClustersRoot || mSpecConfig.outputCompClustersFlat) {
+  if (runTracking) {
     mConfig->configWorkflow.steps.set(GPUDataTypes::RecoStep::TPCConversion,
                                       GPUDataTypes::RecoStep::TPCSectorTracking,
                                       GPUDataTypes::RecoStep::TPCMerging);
     mConfig->configWorkflow.outputs.set(GPUDataTypes::InOutType::TPCMergedTracks);
-    mConfig->configWorkflow.steps.setBits(GPUDataTypes::RecoStep::TPCdEdx, mConfParam->rundEdx == -1 ? !mConfParam->synchronousProcessing : mConfParam->rundEdx);
   }
   if (mSpecConfig.outputCompClustersRoot || mSpecConfig.outputCompClustersFlat) {
     mConfig->configWorkflow.steps.setBits(GPUDataTypes::RecoStep::TPCCompression, true);