Optimize V0 finder loops, add multithreading

* Move some boiler-plate code to RecoContainer

* Checker if track or match was loaded

* Use RecoContainer in SVertexer

* Build Track->Vertex table from external Vertex->Tracks references

* OMP multithreading added

Author: shahor02

DataFormats/Reconstruction/include/ReconstructionDataFormats/GlobalTrackID.h

@@ -87,7 +87,7 @@ class GlobalTrackID : public AbstractRef<25, 5, 2>
   auto getSourceName() const { return getSourceName(getSource()); }
   static mask_t getSourcesMask(const std::string_view srcList);
   static bool includesSource(int s, mask_t srcm) { return srcm[s]; }
-
+  static std::string getSourcesNames(mask_t srcm);
   operator int() const { return int(getIndex()); }
 
   std::string asString() const;

DataFormats/Reconstruction/include/ReconstructionDataFormats/VtxTrackIndex.h

@@ -51,4 +51,18 @@ class VtxTrackIndex : public GlobalTrackID
 } // namespace dataformats
 } // namespace o2
 
+namespace std
+{
+// defining std::hash for VtxTrackIndex to be used with std containers
+template <>
+struct hash<o2::dataformats::VtxTrackIndex> {
+ public:
+  size_t operator()(const o2::dataformats::VtxTrackIndex& id) const
+  {
+    return std::hash<o2::dataformats::GlobalTrackID>{}(id);
+    //return id.getRawWOFlags();
+  }
+};
+} // namespace std
+
 #endif

DataFormats/Reconstruction/src/GlobalTrackID.cxx

@@ -101,3 +101,17 @@ void GlobalTrackID::print() const
 {
   LOG(INFO) << asString();
 }
+
+std::string GlobalTrackID::getSourcesNames(GlobalTrackID::mask_t srcm)
+{
+  std::string s = "[";
+  for (int i = 0; i < NSources; i++) {
+    if (srcm[i]) {
+      if (s.size() > 1) {
+        s += ',';
+      }
+      s += getSourceName(i);
+    }
+  }
+  return std::move(s);
+}

DataFormats/Reconstruction/src/V0.cxx

@@ -15,7 +15,7 @@ using namespace o2::dataformats;
 V0::V0(const std::array<float, 3>& xyz, const std::array<float, 3>& pxyz,
        const o2::track::TrackParCov& trPos, const o2::track::TrackParCov& trNeg,
        GIndex trPosID, GIndex trNegID)
-  : o2::track::TrackParCov{xyz, pxyz, 0, false}, mProngIDs{trPosID, trNegID}, mProngs{trPos, trNeg}
+  : o2::track::TrackParCov{xyz, pxyz, 0, true}, mProngIDs{trPosID, trNegID}, mProngs{trPos, trNeg}
 {
 }
 

DataFormats/common/include/CommonDataFormat/AbstractRefAccessor.h

@@ -42,6 +42,11 @@ class AbstractRefAccessor
     mContainerPtr[src] = reinterpret_cast<const char*>(cont.data());
   }
 
+  bool isLoaded(int src) const
+  {
+    return mContainerPtr[src] != nullptr;
+  }
+
   /// get object as user provided type from explicitly provided source, index
   template <typename U>
   const U& get_as(int src, int idx) const

Detectors/GlobalTracking/include/GlobalTracking/RecoContainer.h

@@ -35,6 +35,10 @@ struct DataRequest {
   std::vector<o2::framework::InputSpec> inputs;
   std::unordered_map<std::string, bool> requestMap;
   void addInput(const o2::framework::InputSpec&& isp);
+
+  void requestTracks(o2::dataformats::GlobalTrackID::mask_t src, bool mc);
+  void requestClusters(o2::dataformats::GlobalTrackID::mask_t src, bool useMC);
+
   void requestITSTracks(bool mc);
   void requestTPCTracks(bool mc);
   void requestITSTPCTracks(bool mc);
@@ -94,6 +98,15 @@ struct RecoContainer {
   // get contributors from single detectors
   GlobalIDSet getSingleDetectorRefs(GTrackID gidx) const;
 
+  // check if track source attached
+  bool isTrackSourceLoaded(int src) const;
+
+  // check if match source attached
+  bool isMatchSourceLoaded(int src) const
+  {
+    return miscPool.isLoaded(src);
+  }
+
   // fetch track param
   const o2::track::TrackParCov& getTrack(GTrackID gidx) const;
 

Detectors/GlobalTracking/src/RecoContainer.cxx

@@ -13,6 +13,8 @@
 /// \author ruben.shahoyan@cern.ch
 
 #include <fmt/format.h>
+#include <chrono>
+#include "DetectorsCommonDataFormats/DetID.h"
 #include "GlobalTracking/RecoContainer.h"
 #include "DataFormatsITSMFT/CompCluster.h"
 #include "DataFormatsITS/TrackITS.h"
@@ -31,6 +33,7 @@ using namespace o2::framework;
 namespace o2d = o2::dataformats;
 
 using GTrackID = o2d::GlobalTrackID;
+using DetID = o2::detectors::DetID;
 
 void DataRequest::addInput(const InputSpec&& isp)
 {
@@ -127,6 +130,43 @@ void DataRequest::requestFT0RecPoints(bool mc)
   requestMap["FT0"] = false;
 }
 
+void DataRequest::requestTracks(GTrackID::mask_t src, bool useMC)
+{
+  // request tracks for sources probided by the mask
+  if (src[GTrackID::ITS]) {
+    requestITSTracks(useMC);
+  }
+  if (src[GTrackID::TPC]) {
+    requestTPCTracks(useMC);
+  }
+  if (src[GTrackID::ITSTPC] || src[GTrackID::ITSTPCTOF]) {
+    requestITSTPCTracks(useMC);
+  }
+  if (src[GTrackID::TPCTOF]) {
+    requestTPCTOFTracks(useMC);
+  }
+  if (src[GTrackID::ITSTPCTOF]) {
+    requestTOFMatches(useMC);
+    requestTOFClusters(false); // RSTODO Needed just to set the time of ITSTPC track, consider moving to MatchInfoTOF
+  }
+}
+
+void DataRequest::requestClusters(GTrackID::mask_t src, bool useMC)
+{
+  // request clusters for detectors of the sources probided by the mask
+
+  // clusters needed for refits
+  if (GTrackID::includesDet(DetID::ITS, src)) {
+    requestITSClusters(useMC);
+  }
+  if (GTrackID::includesDet(DetID::TPC, src)) {
+    requestTPCClusters(useMC);
+  }
+  if (GTrackID::includesDet(DetID::TOF, src)) {
+    requestTOFClusters(useMC);
+  }
+}
+
 //__________________________________________________________________
 void RecoContainer::collectData(ProcessingContext& pc, const DataRequest& requests)
 {
@@ -292,6 +332,15 @@ const o2::track::TrackParCov& RecoContainer::getTrackParamOut(GTrackID gidx) con
   }
 }
 
+//__________________________________________________________
+bool RecoContainer::isTrackSourceLoaded(int src) const
+{
+  if (src == GTrackID::ITSTPCTOF && isMatchSourceLoaded(src)) { // the physical tracks are in ITS-TPC, need to get reference from match info
+    src = GTrackID::ITSTPC;
+  }
+  return tracksPool.isLoaded(src);
+}
+
 //__________________________________________________________
 const o2::track::TrackParCov& RecoContainer::getTrack(GTrackID gidx) const
 {
@@ -320,6 +369,8 @@ void RecoContainer::createTracks(std::function<void(const o2::track::TrackParCov
   // We go from most complete tracks to least complete ones, taking into account that some track times
   // do not bear their own kinematics but just constrain the time
   // As we get more track types functional, this method should be completed
+
+  auto start_time = std::chrono::high_resolution_clock::now();
   constexpr float PS2MUS = 1e-6;
   std::array<std::vector<uint8_t>, GTrackID::NSources> usedData;
   auto flagUsed = [&usedData](const GTrackID gidx) { auto src = gidx.getSource();
@@ -419,6 +470,8 @@ void RecoContainer::createTracks(std::function<void(const o2::track::TrackParCov
       }
     }
   }
+  auto current_time = std::chrono::high_resolution_clock::now();
+  LOG(INFO) << "RecoContainer::createTracks took " << std::chrono::duration_cast<std::chrono::microseconds>(current_time - start_time).count() * 1e-6 << " CPU s.";
 }
 
 // get contributors from single detectors

Detectors/GlobalTrackingWorkflow/CMakeLists.txt

@@ -62,7 +62,7 @@ o2_add_executable(vertex-reader-workflow
 o2_add_executable(vertexing-workflow
                   COMPONENT_NAME secondary
                   SOURCES src/secondary-vertexing-workflow.cxx
-                  PUBLIC_LINK_LIBRARIES O2::GlobalTrackingWorkflow )
+                  PUBLIC_LINK_LIBRARIES O2::GlobalTrackingWorkflow  O2::TOFWorkflow O2::TOFWorkflowUtils)
 
 
 add_subdirectory(tofworkflow)

Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/SecondaryVertexingSpec.h

@@ -40,7 +40,7 @@ class SecondaryVertexingSpec : public Task
 };
 
 /// create a processor spec
-DataProcessorSpec getSecondaryVertexingSpec();
+DataProcessorSpec getSecondaryVertexingSpec(o2::dataformats::GlobalTrackID::mask_t src);
 
 } // namespace vertexing
 } // namespace o2

Detectors/GlobalTrackingWorkflow/src/CosmicsMatchingSpec.cxx

@@ -51,7 +51,7 @@ namespace o2
 namespace globaltracking
 {
 
-DataRequest dataRequest;
+DataRequest dataRequestCosm;
 
 void CosmicsMatchingSpec::init(InitContext& ic)
 {
@@ -100,7 +100,7 @@ void CosmicsMatchingSpec::run(ProcessingContext& pc)
   mTimer.Start(false);
 
   RecoContainer recoData;
-  recoData.collectData(pc, dataRequest);
+  recoData.collectData(pc, dataRequestCosm);
   mMatching.process(recoData);
   pc.outputs().snapshot(Output{"GLO", "COSMICTRC", 0, Lifetime::Timeframe}, mMatching.getCosmicTracks());
   if (mUseMC) {
@@ -121,30 +121,8 @@ DataProcessorSpec getCosmicsMatchingSpec(GTrackID::mask_t src, bool useMC)
   std::vector<InputSpec> inputs;
   std::vector<OutputSpec> outputs;
 
-  if (src[GTrackID::ITS]) {
-    dataRequest.requestITSTracks(useMC);
-  }
-  if (src[GTrackID::TPC]) {
-    dataRequest.requestTPCTracks(useMC);
-  }
-  if (src[GTrackID::ITSTPC]) {
-    dataRequest.requestITSTPCTracks(useMC);
-  }
-  if (src[GTrackID::TPCTOF]) {
-    dataRequest.requestTPCTOFTracks(useMC);
-  }
-  if (src[GTrackID::ITSTPCTOF]) {
-    dataRequest.requestTOFMatches(useMC);
-    dataRequest.requestTOFClusters(false); // RSTODO Needed just to set the time of ITSTPC track, consider moving to MatchInfoTOF
-  }
-
-  // clusters needed for refits
-  if (GTrackID::includesDet(DetID::ITS, src)) {
-    dataRequest.requestITSClusters(false);
-  }
-  if (GTrackID::includesDet(DetID::TPC, src)) {
-    dataRequest.requestTPCClusters(false);
-  }
+  dataRequestCosm.requestTracks(src, useMC);
+  dataRequestCosm.requestClusters(src, false); // no MC labels for clusters needed for refit only
 
   outputs.emplace_back("GLO", "COSMICTRC", 0, Lifetime::Timeframe);
   if (useMC) {
@@ -153,7 +131,7 @@ DataProcessorSpec getCosmicsMatchingSpec(GTrackID::mask_t src, bool useMC)
 
   return DataProcessorSpec{
     "cosmics-matcher",
-    dataRequest.inputs,
+    dataRequestCosm.inputs,
     outputs,
     AlgorithmSpec{adaptFromTask<CosmicsMatchingSpec>(useMC)},
     Options{