Prepare settings and cleanup interface

Author: mconcas

Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h

@@ -34,11 +34,9 @@ class ITSTrackingInterface
  public:
   ITSTrackingInterface(bool isMC,
                        int trgType,
-                       const TrackingMode trMode,
                        const bool overrBeamEst)
     : mIsMC{isMC},
       mUseTriggers{trgType},
-      mMode{trMode},
       mOverrideBeamEstimation{overrBeamEst}
   {
   }
@@ -47,6 +45,7 @@ class ITSTrackingInterface
   void setMeanVertex(const o2::dataformats::MeanVertexObject* v)
   {
     if (!v) {
+      LOGP(error, "Mean Vertex Object is nullptr");
       return;
     }
     mMeanVertex = v;
@@ -61,6 +60,13 @@ class ITSTrackingInterface
 
   // Custom
   void setTraitsFromProvider(VertexerTraits*, TrackerTraits*, TimeFrame*);
+  void setTrackingMode(TrackingMode mode = TrackingMode::Unset)
+  {
+    if (mode == TrackingMode::Unset) {
+      LOGP(fatal, "ITS Tracking mode Unset is meant to be a default. Specify the mode");
+    }
+    mMode = mode;
+  }
 
  private:
   bool mIsMC = false;

Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx

@@ -455,6 +455,7 @@ void Tracker::rectifyClusterIndices()
 void Tracker::getGlobalConfiguration()
 {
   auto& tc = o2::its::TrackerParamConfig::Instance();
+  tc.printKeyValues(true, true);
   if (tc.useMatCorrTGeo) {
     mTraits->setCorrType(o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrTGeo);
   } else if (tc.useFastMaterial) {

Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx

@@ -22,6 +22,7 @@
 #include "DataFormatsTRD/TriggerRecord.h"
 #include "CommonDataFormat/IRFrame.h"
 #include "DetectorsBase/GRPGeomHelper.h"
+#include "ITStracking/TrackingConfigParam.h"
 
 namespace o2
 {
@@ -33,9 +34,11 @@ void ITSTrackingInterface::initialise()
   mRunVertexer = true;
   mCosmicsProcessing = false;
   std::vector<TrackingParameters> trackParams;
-
+  if (mMode == TrackingMode::Unset) {
+    mMode = (TrackingMode)(o2::its::TrackerParamConfig::Instance().trackingMode);
+    LOGP(info, "Tracking mode not set, trying to fetch it from configurable params to: {}", asString(mMode));
+  }
   if (mMode == TrackingMode::Async) {
-
     trackParams.resize(3);
     for (auto& param : trackParams) {
       param.ZBins = 64;
@@ -49,7 +52,6 @@ void ITSTrackingInterface::initialise()
     trackParams[2].CellDeltaTanLambdaSigma *= 4.;
     trackParams[2].MinTrackLength = 4;
     LOG(info) << "Initializing tracker in async. phase reconstruction with " << trackParams.size() << " passes";
-
   } else if (mMode == TrackingMode::Sync) {
     trackParams.resize(1);
     trackParams[0].ZBins = 64;
@@ -322,7 +324,7 @@ void ITSTrackingInterface::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
     return;
   }
   if (matcher == ConcreteDataMatcher("GLO", "MEANVERTEX", 0)) {
-    LOGP(info, "mean vertex acquired");
+    LOGP(info, "Mean vertex acquired");
     setMeanVertex((const o2::dataformats::MeanVertexObject*)obj);
     return;
   }

Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx

@@ -67,6 +67,7 @@ float Vertexer::clustersToVerticesHybrid(std::function<void(std::string s)> logg
 void Vertexer::getGlobalConfiguration()
 {
   auto& vc = o2::its::VertexerParamConfig::Instance();
+  vc.printKeyValues(true, true);
   auto& grc = o2::its::GpuRecoParamConfig::Instance();
 
   VertexingParameters verPar;
@@ -90,8 +91,7 @@ void Vertexer::getGlobalConfiguration()
   verPar.PhiBins = vc.PhiBins;
 
   TimeFrameGPUParameters tfGPUpar;
-  tfGPUpar.maxGPUMemoryGB = grc.maxGPUMemoryGB;
-  tfGPUpar.maxVerticesCapacity = grc.maxVerticesCapacity;
+  tfGPUpar.nROFsPerChunk = grc.nROFsPerChunk;
 
   mTraits->updateVertexingParameters(verPar, tfGPUpar);
 }

Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackerSpec.h

@@ -23,13 +23,11 @@
 
 #include "ITStracking/TrackingInterface.h"
 
-#include "GPUO2Interface.h"
-#include "GPUReconstruction.h"
-#include "GPUChainITS.h"
-#include "CommonUtils/StringUtils.h"
-#include "TStopwatch.h"
+#include "GPUDataTypes.h"
 #include "DetectorsBase/GRPGeomHelper.h"
 
+#include "TStopwatch.h"
+
 namespace o2
 {
 namespace its
@@ -41,9 +39,9 @@ class TrackerDPL : public framework::Task
   TrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr,
              bool isMC,
              int trgType,
-             const TrackingMode& trMode,
+             const TrackingMode& trMode = TrackingMode::Unset,
              const bool overrBeamEst = false,
-             o2::gpu::GPUDataTypes::DeviceType dType = o2::gpu::GPUDataTypes::DeviceType::CPU);
+             gpu::GPUDataTypes::DeviceType dType = gpu::GPUDataTypes::DeviceType::CPU);
   ~TrackerDPL() override = default;
   void init(framework::InitContext& ic) final;
   void run(framework::ProcessingContext& pc) final;
@@ -60,7 +58,8 @@ class TrackerDPL : public framework::Task
   TStopwatch mTimer;
 };
 
-framework::DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int useTrig, const std::string& trModeS, const bool overrBeamEst, o2::gpu::GPUDataTypes::DeviceType dType);
+using o2::its::TrackingMode;
+framework::DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int useTrig, const std::string& trMode, const bool overrBeamEst = false, gpu::GPUDataTypes::DeviceType dType = gpu::GPUDataTypes::DeviceType::CPU);
 
 } // namespace its
 } // namespace o2

Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx

@@ -31,8 +31,6 @@ namespace o2
 {
 namespace its
 {
-// using ITSTrackReconstruction::TrackingMode;
-
 namespace reco_workflow
 {
 
@@ -60,36 +58,7 @@ framework::WorkflowSpec getWorkflow(bool useMC,
   }
   if (!trmode.empty()) {
     if (useCAtracker) {
-      if (useGPUWF) {
-        o2::gpu::GPURecoWorkflowSpec::Config cfg;
-        cfg.runITSTracking = true;
-        cfg.itsTriggerType = useTrig;
-        cfg.itsOverrBeamEst = overrideBeamPosition;
-        cfg.itsTrackingMode = trmode == "sync" ? (int)TrackingMode::Sync : (trmode == "async" ? (int)TrackingMode::Async : (int)TrackingMode::Cosmics);
-
-        Inputs ggInputs;
-        auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false, true, false, true, true,
-                                                                    useGeom ? o2::base::GRPGeomRequest::Aligned : o2::base::GRPGeomRequest::None,
-                                                                    ggInputs, true);
-        if (!useGeom) {
-          ggRequest->addInput({"itsTGeo", "ITS", "GEOMTGEO", 0, Lifetime::Condition, framework::ccdbParamSpec("ITS/Config/Geometry")}, ggInputs);
-        }
-
-        auto task = std::make_shared<o2::gpu::GPURecoWorkflowSpec>(&gPolicyData, cfg, std::vector<int>(), 0, ggRequest);
-        gTask = task;
-        Inputs taskInputs = task->inputs();
-        Options taskOptions = task->options();
-        std::move(ggInputs.begin(), ggInputs.end(), std::back_inserter(taskInputs));
-
-        specs.emplace_back(DataProcessorSpec{
-          "its-tracker",
-          taskInputs,
-          task->outputs(),
-          AlgorithmSpec{adoptTask<o2::gpu::GPURecoWorkflowSpec>(task)},
-          taskOptions});
-      } else {
-        specs.emplace_back(o2::its::getTrackerSpec(useMC, useGeom, useTrig, trmode, overrideBeamPosition, dtype));
-      }
+      specs.emplace_back(o2::its::getTrackerSpec(useMC, useGeom, useTrig, trmode, overrideBeamPosition, dtype));
     } else {
       specs.emplace_back(o2::its::getCookedTrackerSpec(useMC, useGeom, useTrig, trmode));
     }

Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx

@@ -30,8 +30,9 @@ TrackerDPL::TrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr,
                        const bool overrBeamEst,
                        o2::gpu::GPUDataTypes::DeviceType dType) : mGGCCDBRequest(gr),
                                                                   mRecChain{o2::gpu::GPUReconstruction::CreateInstance(dType, true)},
-                                                                  mITSTrackingInterface{isMC, trgType, trMode, overrBeamEst}
+                                                                  mITSTrackingInterface{isMC, trgType, overrBeamEst}
 {
+  mITSTrackingInterface.setTrackingMode(trMode);
 }
 
 void TrackerDPL::init(InitContext& ic)

GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h

@@ -127,7 +127,6 @@ class GPURecoWorkflowSpec : public o2::framework::Task
     int lumiScaleType = 0; // 0=off, 1=CTP, 2=TPC scalers
     bool outputErrorQA = false;
     bool runITSTracking = false;
-    int itsTrackingMode = 0; // 0=sync, 1=async, 2=cosmics
     bool itsOverrBeamEst = false;
     bool tpcTriggerHandling = false;
   };

GPU/Workflow/src/GPUWorkflowITS.cxx

@@ -37,7 +37,6 @@ void GPURecoWorkflowSpec::initFunctionITS(o2::framework::InitContext& ic)
   o2::its::TrackerTraits* trkTraits = nullptr;
   mITSTrackingInterface = std::make_unique<o2::its::ITSTrackingInterface>(mSpecConfig.processMC,
                                                                           mSpecConfig.itsTriggerType,
-                                                                          static_cast<o2::its::TrackingMode>(mSpecConfig.itsTrackingMode),
                                                                           mSpecConfig.itsOverrBeamEst);
   mGPUReco->GetITSTraits(trkTraits, vtxTraits, mITSTimeFrame);
   mITSTrackingInterface->setTraitsFromProvider(vtxTraits, trkTraits, mITSTimeFrame);

GPU/Workflow/src/gpu-reco-workflow.cxx

@@ -107,6 +107,7 @@ enum struct ioType { Digits,
                      SendClustersPerSector,
                      ITSClusters,
                      ITSTracks,
+                     MeanVertex,
                      TPCTriggers };
 
 static const std::unordered_map<std::string, ioType> InputMap{
@@ -117,7 +118,9 @@ static const std::unordered_map<std::string, ioType> InputMap{
   {"compressed-clusters-root", ioType::CompClustROOT},
   {"compressed-clusters-ctf", ioType::CompClustCTF},
   {"trd-tracklets", ioType::TRDTracklets},
-  {"its-clusters", ioType::ITSClusters}};
+  {"its-clusters", ioType::ITSClusters},
+  {"its-mean-vertex", ioType::MeanVertex},
+};
 
 static const std::unordered_map<std::string, ioType> OutputMap{
   {"clusters", ioType::Clusters},
@@ -183,6 +186,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   cfg.enableDoublePipeline = cfgc.options().get<bool>("enableDoublePipeline");
   cfg.tpcDeadMapSources = cfgc.options().get<int>("tpc-deadMap-sources");
   cfg.runITSTracking = isEnabled(outputTypes, ioType::ITSTracks);
+  cfg.itsOverrBeamEst = isEnabled(inputTypes, ioType::MeanVertex);
 
   Inputs ggInputs;
   auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false, true, false, true, true, o2::base::GRPGeomRequest::Aligned, ggInputs, true);