[Common] Index tables for Tracks, TracksQA and TrackMeanOccupancies (#11602)

Co-authored-by: Anton Alkin <anton.alkin@cern.ch>

Author: rahulverma012

Common/DataModel/OccupancyTables.h

@@ -209,6 +209,8 @@ namespace trackmeanocc
 {
 DECLARE_SOA_INDEX_COLUMN(Track, track);
 
+// DECLARE_SOA_INDEX_COLUMN(TracksQA, tracksQA);// this is not working
+
 DECLARE_SOA_COLUMN(TmoPrimUnfm80, tmoPrimUnfm80, float);
 DECLARE_SOA_COLUMN(TmoFV0AUnfm80, tmoFV0AUnfm80, float);
 DECLARE_SOA_COLUMN(TmoFV0CUnfm80, tmoFV0CUnfm80, float);
@@ -281,7 +283,7 @@ DECLARE_SOA_COLUMN(TwmoRobustMultExtraTableUnfm80, twmoRobustMultExtraTableUnfm8
 // using Tracks = aod::Tracks;
 // DECLARE_SOA_INDEX_TABLE_USER(TrackMeanOccs0, Tracks, "TRACKMEANOCCS0", o2::aod::trackmeanocc::TrackId);
 
-DECLARE_SOA_TABLE(TmoTrackId, "AOD", "TMOTRACKID", o2::aod::trackmeanocc::TrackId);
+DECLARE_SOA_TABLE(TmoTrackIds, "AOD", "TMOTRACKIDS", o2::aod::trackmeanocc::TrackId);
 
 DECLARE_SOA_TABLE(TmoPrim, "AOD", "TMOPRIM", o2::soa::Index<>, // TrackMeanOccDet
                   o2::aod::trackmeanocc::TmoPrimUnfm80);
@@ -377,5 +379,21 @@ DECLARE_SOA_TABLE(TwmoRNtrackDet, "AOD", "TWMORNTRACKDET", o2::soa::Index<>,
 DECLARE_SOA_TABLE(TwmoRMultExtra, "AOD", "TWMORMULTEXTRA", o2::soa::Index<>,
                   o2::aod::trackmeanocc::TwmoRobustMultExtraTableUnfm80);
 
+using Tmo = aod::TmoTrackIds::iterator;
+
+using TrackQA = TracksQAVersion::iterator;
+
+namespace trackmeanocc
+{
+DECLARE_SOA_INDEX_COLUMN_FULL(Tmo, tmo, int64_t, TmoTrackIds, "");
+DECLARE_SOA_INDEX_COLUMN_FULL(TrackQA, trackQA, int64_t, TracksQAVersion, "");
+} // namespace trackmeanocc
+
+DECLARE_SOA_TABLE(TrackToTracksQA, "AOD", "TRACKTOTRACKSQA", o2::aod::trackmeanocc::TrackQAId);
+DECLARE_SOA_TABLE(TrackToTmo, "AOD", "TRACKTOTMO", o2::aod::trackmeanocc::TmoId);
+
+DECLARE_SOA_TABLE(TrackQAToTmo, "AOD", "TRACKQATOTMO", o2::aod::trackmeanocc::TmoId);
+DECLARE_SOA_TABLE(TmoToTrackQA, "AOD", "TMOTOTRACKQA", o2::aod::trackmeanocc::TrackQAId);
+
 } // namespace o2::aod
 #endif // COMMON_DATAMODEL_OCCUPANCYTABLES_H_

Common/TableProducer/occupancyTableProducer.cxx

@@ -52,6 +52,24 @@ int32_t nBCsPerOrbit = o2::constants::lhc::LHCMaxBunches;
 // const int nBCinTF = 114048;         /// CCDB value // to be obtained from CCDB in future
 const int nBCinDrift = 114048 / 32; /// to get from ccdb in future
 
+template <typename T, std::size_t N>
+void sortVectorOfArray(std::vector<std::array<T, N>>& myVector, const int& myIDX)
+{
+  std::sort(myVector.begin(), myVector.end(), [myIDX](const std::array<T, N>& a, const std::array<T, N>& b) {
+    return a[myIDX] < b[myIDX]; // sort at the required index
+  });
+}
+
+template <typename T, std::size_t N>
+void checkUniqueness(const std::vector<std::array<T, N>>& myVector, const int& myIDX)
+{
+  for (size_t i = 1; i < myVector.size(); i++) {
+    if (myVector[i][myIDX] <= myVector[i - 1][myIDX]) {
+      LOG(error) << "Duplicate Entries while creating Index tables :: (vec[" << i << "][" << myIDX << "]) " << myVector[i][myIDX] << " >= " << myVector[i - 1][myIDX] << " (vec[" << i - 1 << "][" << myIDX << "])";
+    }
+  }
+}
+
 struct OccupancyTableProducer {
 
   Service<o2::ccdb::BasicCCDBManager> ccdb;
@@ -1208,7 +1226,9 @@ struct OccupancyTableProducer {
 struct TrackMeanOccTableProducer {
 
   // //declare production of tables
-  Produces<aod::TmoTrackId> genTmoTrackId;
+  Produces<aod::TmoTrackIds> genTmoTrackId;
+  Produces<aod::TmoToTrackQA> genTmoToTrackQA;
+  Produces<aod::TrackQAToTmo> genTrackQAToTmo;
 
   Produces<aod::TmoPrim> genTmoPrim;
   Produces<aod::TmoT0V0> genTmoT0V0;
@@ -1262,6 +1282,9 @@ struct TrackMeanOccTableProducer {
   Configurable<bool> fillQA1{"fillQA1", true, "fill QA LOG Ratios"};
   Configurable<bool> fillQA2{"fillQA2", true, "fill QA condition dependent QAs"};
 
+  Configurable<bool> buildPointerTrackQAToTMOTable{"buildPointerTrackQAToTMOTable", true, "buildPointerTrackQAToTMOTable"};
+  Configurable<bool> buildPointerTMOToTrackQATable{"buildPointerTMOToTrackQATable", true, "buildPointerTMOToTrackQATable"};
+
   // vectors to be used for occupancy estimation
   std::vector<float> occPrimUnfm80;
 
@@ -1727,6 +1750,7 @@ struct TrackMeanOccTableProducer {
     fillWeightMeanOccTable
   };
 
+  std::vector<std::array<int64_t, 2>> trackQAGIListforTMOList;
   template <int processMode, int meanTableMode, int weightMeanTableMode, int qaMode, typename B, typename C, typename T, typename U, typename O, typename V>
   void executeTrackOccProducerProcessing(B const& BCs, C const& collisions, T const& tracks, U const& tracksQA, O const& occsRobustT0V0Prim, V const& occs, bool const& executeInThisBlock)
   {
@@ -1871,6 +1895,9 @@ struct TrackMeanOccTableProducer {
       float weightMeanOccRobustNtrackDetUnfm80 = 0;
       float weightMeanOccRobustMultTableUnfm80 = 0;
 
+      int trackTMOcounter = -1;
+      trackQAGIListforTMOList.clear();
+
       for (const auto& trackQA : tracksQA) {
         auto const& track = trackQA.template track_as<T>();
         auto collision = collisions.begin();
@@ -2034,7 +2061,9 @@ struct TrackMeanOccTableProducer {
 
         // If multiple process are on, fill this table only once
         if (executeInThisBlock) {
+          trackTMOcounter++;
           genTmoTrackId(track.globalIndex());
+          trackQAGIListforTMOList.push_back({trackQA.globalIndex(), trackTMOcounter});
         }
 
         if constexpr (qaMode == fillOccRobustT0V0dependentQA) {
@@ -2320,6 +2349,52 @@ struct TrackMeanOccTableProducer {
           }
         }
       } // end of trackQA loop
+
+      // build the IndexTables here
+      if (executeInThisBlock) {
+        if (buildPointerTrackQAToTMOTable) {
+          // create pointer table from trackQA to TrackMeanOcc
+          sortVectorOfArray(trackQAGIListforTMOList, 0); // sort the list //Its easy to search in a sorted list
+          checkUniqueness(trackQAGIListforTMOList, 0);   // check the uniqueness of track.globalIndex()
+
+          int currentIDXforCheck = 0;
+          int listSize = trackQAGIListforTMOList.size();
+          for (const auto& trackQA : tracksQA) {
+            while (trackQA.globalIndex() > trackQAGIListforTMOList[currentIDXforCheck][0]) {
+              currentIDXforCheck++; // increment the currentIDXforCheck for missing or invalid cases e.g. value = -1;
+              if (currentIDXforCheck >= listSize) {
+                break;
+              }
+            }
+            if (trackQA.globalIndex() == trackQAGIListforTMOList[currentIDXforCheck][0]) {
+              genTrackQAToTmo(trackQAGIListforTMOList[currentIDXforCheck][1]);
+            } else {
+              genTrackQAToTmo(-1); // put a dummy index when track is not found in trackQA
+            }
+          }
+        }
+        if (buildPointerTMOToTrackQATable) {
+          // create pointer table from TrackMeanOcc to trackQA
+          sortVectorOfArray(trackQAGIListforTMOList, 1); // sort the list //Its easy to search in a sorted list
+          checkUniqueness(trackQAGIListforTMOList, 1);   // check the uniqueness of track.globalIndex()
+
+          int currentIDXforCheck = 0;
+          int listSize = trackQAGIListforTMOList.size();
+          for (int iCounter = 0; iCounter <= trackTMOcounter; iCounter++) {
+            while (iCounter > trackQAGIListforTMOList[currentIDXforCheck][1]) {
+              currentIDXforCheck++; // increment the currentIDXforCheck for missing or invalid cases e.g. value = -1;
+              if (currentIDXforCheck >= listSize) {
+                break;
+              }
+            }
+            if (iCounter == trackQAGIListforTMOList[currentIDXforCheck][1]) {
+              genTmoToTrackQA(trackQAGIListforTMOList[currentIDXforCheck][0]);
+            } else {
+              genTmoToTrackQA(-1); // put a dummy index when track is not found in trackQA
+            }
+          }
+        }
+      } // end of executeInThisBlock
     } // end of else block of constexpr
   }
 
@@ -2602,9 +2677,88 @@ struct TrackMeanOccTableProducer {
   PROCESS_SWITCH(TrackMeanOccTableProducer, processFullOccTableProduer, "processFullOccTableProduer", false);
 };
 
+struct CreatePointerTables {
+
+  Produces<aod::TrackToTracksQA> genTrackToTracksQA;
+  Produces<aod::TrackToTmo> genTrackToTmo;
+
+  void processNothing(aod::Collisions const&)
+  {
+    return;
+  }
+  PROCESS_SWITCH(CreatePointerTables, processNothing, "process Nothing", true);
+
+  std::vector<std::array<int64_t, 2>> trackGIForTrackQAIndexList;
+  using MyTracksQA = aod::TracksQAVersion;
+  void processTrackToTrackQAPointer(aod::Tracks const& tracks, MyTracksQA const& tracksQA)
+  {
+    trackGIForTrackQAIndexList.clear();
+    for (const auto& trackQA : tracksQA) {
+      auto const& track = trackQA.template track_as<aod::Tracks>();
+      trackGIForTrackQAIndexList.push_back({track.globalIndex(), trackQA.globalIndex()});
+    }
+
+    sortVectorOfArray(trackGIForTrackQAIndexList, 0); // sort the list //Its easy to search in a sorted list
+    checkUniqueness(trackGIForTrackQAIndexList, 0);   // check the uniqueness of track.globalIndex()
+
+    // create pointer table
+    int currentIDXforCheck = 0;
+    int listSize = trackGIForTrackQAIndexList.size();
+
+    for (const auto& track : tracks) {
+      while (track.globalIndex() > trackGIForTrackQAIndexList[currentIDXforCheck][0]) {
+        currentIDXforCheck++; // increment the currentIDXforCheck for missing or invalid cases e.g. value = -1;
+        if (currentIDXforCheck >= listSize) {
+          break;
+        }
+      }
+      if (track.globalIndex() == trackGIForTrackQAIndexList[currentIDXforCheck][0]) {
+        genTrackToTracksQA(trackGIForTrackQAIndexList[currentIDXforCheck][1]);
+      } else {
+        genTrackToTracksQA(-1); // put a dummy index when track is not found in trackQA
+      }
+    }
+  }
+  PROCESS_SWITCH(CreatePointerTables, processTrackToTrackQAPointer, "processTrackToTrackQAPointer", false);
+
+  std::vector<std::array<int64_t, 2>> trackGIForTMOIndexList;
+  void processTrackToTrackMeanOccsPointer(aod::Tracks const& tracks, aod::TmoTrackIds const& tmoTrackIds)
+  {
+    trackGIForTMOIndexList.clear();
+    int tmoCounter = -1;
+    for (const auto& tmoTrackId : tmoTrackIds) {
+      tmoCounter++;
+      auto const& track = tmoTrackId.template track_as<aod::Tracks>();
+      trackGIForTMOIndexList.push_back({track.globalIndex(), tmoCounter}); // tmoTrackId Global Index is not working :: tmoTrackId.globalIndex()});
+    }
+    sortVectorOfArray(trackGIForTMOIndexList, 0); // sort the list //Its easy to search in a sorted list
+    checkUniqueness(trackGIForTMOIndexList, 0);   // check the uniqueness of track.globalIndex()
+
+    // create pointer table
+    int currentIDXforCheck = 0;
+    int listSize = trackGIForTMOIndexList.size();
+
+    for (const auto& track : tracks) {
+      while (track.globalIndex() > trackGIForTMOIndexList[currentIDXforCheck][0]) {
+        currentIDXforCheck++; // increment the currentIDXforCheck for missing or invalid cases e.g. value = -1;
+        if (currentIDXforCheck >= listSize) {
+          break;
+        }
+      }
+      if (track.globalIndex() == trackGIForTMOIndexList[currentIDXforCheck][0]) {
+        genTrackToTmo(trackGIForTMOIndexList[currentIDXforCheck][1]);
+      } else {
+        genTrackToTmo(-1); // put a dummy index when track is not found in trackQA
+      }
+    }
+  }
+  PROCESS_SWITCH(CreatePointerTables, processTrackToTrackMeanOccsPointer, "processTrackToTrackMeanOccsPointer", false);
+};
+
 WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
 {
   return WorkflowSpec{
     adaptAnalysisTask<OccupancyTableProducer>(cfgc),
-    adaptAnalysisTask<TrackMeanOccTableProducer>(cfgc)};
+    adaptAnalysisTask<TrackMeanOccTableProducer>(cfgc),
+    adaptAnalysisTask<CreatePointerTables>(cfgc)};
 }