[PWGDQ] make matching QA table filling more flexible

Instead of using an hard-coded list of matching methods and corresponding
indexes when filling the derived tables, the filling is done using a
dynamic list of methods and correspoding indexes that is based on what
is actually requested in the configuration.

The horizontal bin labels of a dedicated TH1 histogram provide the
correspondance between method labels and their indexes, to be used when
reading back the derived tables to generate final histograms.

Author: aferrero2707

PWGDQ/Tasks/qaMatching.cxx

@@ -422,6 +422,8 @@ struct QaMatching {
 
   struct CollisionInfo {
     int64_t index{0};
+    // internal index of this collision in the derived table
+    int64_t reducedEventId{0};
     uint64_t bc{0};
     // z position of the collision
     double zVertex{0};
@@ -778,7 +780,7 @@ struct QaMatching {
       AxisSpec chi2Axis = {100, 0, 100, "matching #chi^{2}/NDF"};
       AxisSpec scoreAxis = {100, 0, 1, "matching score"};
       int matchTypeMax = static_cast<int>(kMatchTypeUndefined) + 1;
-      AxisSpec matchTypeAxis = {matchTypeMax, 0, static_cast<double>(matchTypeMax), "match type"};
+      AxisSpec matchTypeAxis = {matchTypeMax, 0, static_cast<double>(matchTypeMax), ""};
       histName = path + "matchType";
       histTitle = "Match type";
       fMatchType = registry->add(histName.c_str(), histTitle.c_str(), {HistType::kTH1F, {matchTypeAxis}});
@@ -1127,6 +1129,8 @@ struct QaMatching {
       ccdbManager->get<TGeoManager>(geoPath);
     }
 
+    std::vector<std::string> matchMethodLabels{"Prod", "Tagged"};
+
     // Matching functions
     initMatchingFunctions();
     for (size_t funcId = 0; funcId < Chi2FunctionsNum; funcId++) {
@@ -1137,13 +1141,15 @@ struct QaMatching {
       auto extrapMethod = configChi2MatchingOptions.matchingExtrapMethods[funcId]->value;
 
       if (label == "" || funcName == "")
-        break;
+        continue;
 
       matchingChi2Functions[label] = funcName;
 
       matchingScoreCuts[label] = scoreMin;
       matchingPlanesZ[label] = matchingPlaneZ;
       matchingExtrapMethod[label] = extrapMethod;
+
+      matchMethodLabels.push_back(label);
     }
 
     // Matching ML models
@@ -1163,7 +1169,7 @@ struct QaMatching {
       auto extrapMethod = configMlOptions.matchingExtrapMethods[modelId]->value;
 
       if (label == "" || modelPath == "" || inputFeatures.empty() || modelName == "")
-        break;
+        continue;
 
       matchingMlResponses[label].configure(binsPtMl, mycutsMl, cutDirMl, 1);
       matchingMlResponses[label].setModelPathsCCDB(std::vector<std::string>{modelName}, fCCDBApi, std::vector<std::string>{modelPath}, configCcdb.cfgCcdbNoLaterThan.value);
@@ -1173,6 +1179,8 @@ struct QaMatching {
       matchingScoreCuts[label] = scoreMin;
       matchingPlanesZ[label] = matchingPlaneZ;
       matchingExtrapMethod[label] = extrapMethod;
+
+      matchMethodLabels.push_back(label);
     }
 
     int nTrackTypes = static_cast<int>(o2::aod::fwdtrack::ForwardTrackTypeEnum::MCHStandaloneTrack) + 1;
@@ -1183,6 +1191,14 @@ struct QaMatching {
     registry.add("tracksMultiplicityMFT", "MFT tracks multiplicity", {HistType::kTH1F, {tracksMultiplicityAxis}});
     registry.add("tracksMultiplicityMCH", "MCH tracks multiplicity", {HistType::kTH1F, {tracksMultiplicityAxis}});
 
+    // Histogram for storing the index and label of the matching methods in the horizontal axis.
+    // This is needed in order to associate the proper label to the match method index in the derived tables.
+    AxisSpec matchMethodAxis = {static_cast<int>(matchMethodLabels.size()), 0.0, static_cast<double>(matchMethodLabels.size()), ""};
+    auto matchMethodsHist = registry.add("matchMethods", "Match methods", {HistType::kTH1F, {matchMethodAxis}});
+    for (size_t iLabel = 0; iLabel <= matchMethodLabels.size(); iLabel++) {
+      std::get<std::shared_ptr<TH1>>(matchMethodsHist)->GetXaxis()->SetBinLabel(iLabel + 1, matchMethodLabels[iLabel].c_str());
+    }
+
     createMatchingHistosMc();
     createDimuonHistos();
   }
@@ -1726,7 +1742,7 @@ struct QaMatching {
   }
 
   template <class TMCH, class TMFT>
-  bool IsMuon(const TMCH& mchTrack,
+  bool isMuon(const TMCH& mchTrack,
               const TMFT& mftTrack)
   {
     // skip tracks that do not have an associated MC particle
@@ -1748,7 +1764,7 @@ struct QaMatching {
   }
 
   template <class TMUON, class TMUONS, class TMFTS>
-  bool IsMuon(const TMUON& muonTrack,
+  bool isMuon(const TMUON& muonTrack,
               TMUONS const& /*muonTracks*/,
               TMFTS const& /*mftTracks*/)
   {
@@ -1758,7 +1774,7 @@ struct QaMatching {
     auto const& mchTrack = muonTrack.template matchMCHTrack_as<TMUONS>();
     auto const& mftTrack = muonTrack.template matchMFTTrack_as<TMFTS>();
 
-    return IsMuon(mchTrack, mftTrack);
+    return isMuon(mchTrack, mftTrack);
   }
 
   template <class TMUON, class TMUONS, class TMFTS>
@@ -2103,18 +2119,18 @@ struct QaMatching {
       return (track1.matchChi2 < track2.matchChi2);
     };
 
-    for (auto collisionInfoIt = collisionInfos.begin(); collisionInfoIt != collisionInfos.end(); ++collisionInfoIt) {
-      auto& collisionInfo = collisionInfoIt->second;
-      for (auto matchingCandidatesIt = collisionInfo.matchingCandidates.begin(); matchingCandidatesIt != collisionInfo.matchingCandidates.end(); ++matchingCandidatesIt) {
-        auto& mchIndex = matchingCandidatesIt->first;
-        auto& globalTracksVector = matchingCandidatesIt->second;
+    int64_t reducedEventCounter{0};
+    for (auto& [collisionIndex, collisionInfo] : collisionInfos) { // o2-linter: disable=const-ref-in-for-loop (object is modified in loop)
+      // set the internal collision index
+      collisionInfo.reducedEventId = reducedEventCounter;
+      reducedEventCounter += 1;
+      for (auto& [mchIndex, globalTracksVector] : collisionInfo.matchingCandidates) { // o2-linter: disable=const-ref-in-for-loop (object is modified in loop)
         std::sort(globalTracksVector.begin(), globalTracksVector.end(), compareMatchingChi2);
 
         const auto& mchTrack = muonTracks.rawIteratorAt(mchIndex);
         auto mftMchMatchAttempts = getMftMchMatchAttempts(collisions, bcs, mchTrack, mftTracks);
         int ranking = 1;
-        for (auto candidateIt = globalTracksVector.begin(); candidateIt != globalTracksVector.end(); ++candidateIt) {
-          auto& candidate = *candidateIt;
+        for (auto& candidate : globalTracksVector) { // o2-linter: disable=const-ref-in-for-loop (object is modified in loop)
           const auto& muonTrack = muonTracks.rawIteratorAt(candidate.globalTrackId);
 
           candidate.matchRanking = ranking;
@@ -2635,16 +2651,13 @@ struct QaMatching {
       return (track1.matchChi2 < track2.matchChi2);
     };
 
-    for (auto matchingCandidatesIt = newMatchingCandidates.begin(); matchingCandidatesIt != newMatchingCandidates.end(); ++matchingCandidatesIt) {
-      auto& mchIndex = matchingCandidatesIt->first;
-      auto& globalTracksVector = matchingCandidatesIt->second;
+    for (auto& [mchIndex, globalTracksVector] : newMatchingCandidates) { // o2-linter: disable=const-ref-in-for-loop (object is modified in loop)
       std::sort(globalTracksVector.begin(), globalTracksVector.end(), compareMatchingChi2);
 
       const auto& mchTrack = muonTracks.rawIteratorAt(mchIndex);
       auto mftMchMatchAttempts = getMftMchMatchAttempts(collisions, bcs, mchTrack, mftTracks);
       int ranking = 1;
-      for (auto candidateIt = globalTracksVector.begin(); candidateIt != globalTracksVector.end(); ++candidateIt) {
-        auto& candidate = *candidateIt;
+      for (auto& candidate : globalTracksVector) { // o2-linter: disable=const-ref-in-for-loop (object is modified in loop)
         const auto& muonTrack = muonTracks.rawIteratorAt(candidate.globalTrackId);
 
         candidate.matchRanking = ranking;
@@ -2783,16 +2796,13 @@ struct QaMatching {
       return (track1.matchScore > track2.matchScore);
     };
 
-    for (auto matchingCandidatesIt = newMatchingCandidates.begin(); matchingCandidatesIt != newMatchingCandidates.end(); ++matchingCandidatesIt) {
-      auto& mchIndex = matchingCandidatesIt->first;
-      auto& globalTracksVector = matchingCandidatesIt->second;
+    for (auto& [mchIndex, globalTracksVector] : newMatchingCandidates) { // o2-linter: disable=const-ref-in-for-loop (object is modified in loop)
       std::sort(globalTracksVector.begin(), globalTracksVector.end(), compareMatchingScore);
 
       const auto& mchTrack = muonTracks.rawIteratorAt(mchIndex);
       auto mftMchMatchAttempts = getMftMchMatchAttempts(collisions, bcs, mchTrack, mftTracks);
       int ranking = 1;
-      for (auto candidateIt = globalTracksVector.begin(); candidateIt != globalTracksVector.end(); ++candidateIt) {
-        auto& candidate = *candidateIt;
+      for (auto& candidate : globalTracksVector) { // o2-linter: disable=const-ref-in-for-loop (object is modified in loop)
         const auto& muonTrack = muonTracks.rawIteratorAt(candidate.globalTrackId);
 
         candidate.matchRanking = ranking;
@@ -2813,31 +2823,17 @@ struct QaMatching {
   {
     auto collision = collisions.rawIteratorAt(collisionInfo.index);
 
+    int debugCounter{0};
+    fillQaMatchingAodEventForCollision(collisionInfo, collision, collisionInfo.reducedEventId, debugCounter);
+    fillQaMatchingMchTracksForCollision(collisionInfo, collisions, collision, muonTracks, mftTracks, bcs, collisionInfo.reducedEventId);
+
     registry.get<TH1>(HIST("tracksMultiplicityMFT"))->Fill(collisionInfo.mftTracks.size());
     registry.get<TH1>(HIST("tracksMultiplicityMCH"))->Fill(collisionInfo.mchTracks.size());
 
+    int matchingMethodCounter{0};
     // Chi2-based matching analysis
+    fillQaMatchingAodTablesForCollision(collision, muonTracks, collisionInfo.matchingCandidates, matchingMethodCounter, collisionInfo.reducedEventId);
     fillMatchingPlotsMc(collision, collisionInfo, muonTracks, mftTracks, collisionInfo.matchingCandidates, collisionInfo.matchingCandidates, collisionInfo.matchablePairs, cfgMatchingChi2ScoreMftMchLow, fChi2MatchingPlotter.get(), false);
-    for (const auto& [label, func] : matchingChi2Functions) {
-      MatchingCandidates matchingCandidates;
-      runChi2Matching(collisions, bcs, muonTracks, mftTracks, mftCovs, label, collisionInfo.matchablePairs, collisionInfo.matchingCandidates, matchingCandidates);
-
-      auto* plotter = fMatchingPlotters.at(label).get();
-      double matchingScoreCut = matchingScoreCuts.at(label);
-
-      fillMatchingPlotsMc(collision, collisionInfo, muonTracks, mftTracks, matchingCandidates, collisionInfo.matchingCandidates, collisionInfo.matchablePairs, matchingScoreCut, plotter, false);
-    }
-
-    // ML-based matching analysis
-    for (const auto& [label, mlResponse] : matchingMlResponses) {
-      MatchingCandidates matchingCandidates;
-      runMlMatching(collisions, bcs, muonTracks, mftTracks, mftCovs, label, collisionInfo.matchablePairs, collisionInfo.matchingCandidates, matchingCandidates);
-
-      auto* plotter = fMatchingPlotters.at(label).get();
-      double matchingScoreCut = matchingScoreCuts.at(label);
-
-      fillMatchingPlotsMc(collision, collisionInfo, muonTracks, mftTracks, matchingCandidates, collisionInfo.matchingCandidates, collisionInfo.matchablePairs, matchingScoreCut, plotter);
-    }
 
     // Muons tagging
     for (const auto& [mchIndex, mftIndex] : collisionInfo.matchablePairs) {
@@ -2883,8 +2879,38 @@ struct QaMatching {
         taggedMatchingCandidates[mchIndex] = globalTracksVector;
       }
     }
+    matchingMethodCounter += 1;
+    fillQaMatchingAodTablesForCollision(collision, muonTracks, collisionInfo.matchingCandidates, matchingMethodCounter, collisionInfo.reducedEventId);
     fillMatchingPlotsMc(collision, collisionInfo, muonTracks, mftTracks, taggedMatchingCandidates, collisionInfo.matchingCandidates, collisionInfo.matchablePairs, cfgMatchingChi2ScoreMftMchLow, fTaggedMuonsMatchingPlotter.get());
 
+    //-------------------------------
+    // Custom chi2-based matching methods
+    for (const auto& [label, func] : matchingChi2Functions) {
+      MatchingCandidates matchingCandidates;
+      runChi2Matching(collisions, bcs, muonTracks, mftTracks, mftCovs, label, collisionInfo.matchablePairs, collisionInfo.matchingCandidates, matchingCandidates);
+
+      auto* plotter = fMatchingPlotters.at(label).get();
+      double matchingScoreCut = matchingScoreCuts.at(label);
+
+      matchingMethodCounter += 1;
+      fillQaMatchingAodTablesForCollision(collision, muonTracks, matchingCandidates, matchingMethodCounter, collisionInfo.reducedEventId);
+      fillMatchingPlotsMc(collision, collisionInfo, muonTracks, mftTracks, matchingCandidates, collisionInfo.matchingCandidates, collisionInfo.matchablePairs, matchingScoreCut, plotter, false);
+    }
+
+    // ML-based matching analysis
+    for (const auto& [label, mlResponse] : matchingMlResponses) {
+      MatchingCandidates matchingCandidates;
+      runMlMatching(collisions, bcs, muonTracks, mftTracks, mftCovs, label, collisionInfo.matchablePairs, collisionInfo.matchingCandidates, matchingCandidates);
+
+      auto* plotter = fMatchingPlotters.at(label).get();
+      double matchingScoreCut = matchingScoreCuts.at(label);
+
+      matchingMethodCounter += 1;
+      fillQaMatchingAodTablesForCollision(collision, muonTracks, matchingCandidates, matchingMethodCounter, collisionInfo.reducedEventId);
+      fillMatchingPlotsMc(collision, collisionInfo, muonTracks, mftTracks, matchingCandidates, collisionInfo.matchingCandidates, collisionInfo.matchablePairs, matchingScoreCut, plotter);
+    }
+
+    //-------------------------------
     // Di-muon analysis
     fillDimuonPlotsMc(collisionInfo, collisions, muonTracks, mftTracks);
   }
@@ -3007,55 +3033,12 @@ struct QaMatching {
       registry.get<TH1>(HIST("nTracksPerType"))->Fill(static_cast<int>(muon.trackType()));
     }
 
-    fillCollisions(collisions, bcs, muonTracks, mftTracks, fCollisionInfos);
-
     mftTrackCovs.clear();
     for (const auto& mftTrackCov : mftCovs) {
       mftTrackCovs[mftTrackCov.matchMFTTrackId()] = mftTrackCov.globalIndex();
     }
 
-    std::unordered_map<int64_t, int32_t> reducedEventIds;
-    int32_t reducedEventCounter = 0;
-    for (auto const& [collisionIndex, collisionInfo] : fCollisionInfos) {
-      reducedEventIds.emplace(collisionInfo.index, reducedEventCounter);
-      reducedEventCounter += 1;
-    }
-
-    int debugCounter = 0;
-    for (auto const& [collisionIndex, collisionInfo] : fCollisionInfos) {
-      auto it = reducedEventIds.find(collisionInfo.index);
-      if (it == reducedEventIds.end()) {
-        continue;
-      }
-      int32_t reducedEventId = it->second;
-      auto collision = collisions.rawIteratorAt(collisionInfo.index);
-      fillQaMatchingAodEventForCollision(collisionInfo, collision, reducedEventId, debugCounter);
-      fillQaMatchingMchTracksForCollision(collisionInfo, collisions, collision, muonTracks, mftTracks, bcs, reducedEventId);
-    }
-
-    struct AodLabel {
-      const char* name;
-      int8_t id;
-    };
-    std::array<AodLabel, 3> aodLabels{{{"ProdAll", 0}, {"MatchXYPhiTanl", 1}, {"MatchXYPhiTanlMom", 2}}};
-    for (const auto& aodLabel : aodLabels) {
-      if (matchingChi2Functions.find(aodLabel.name) == matchingChi2Functions.end()) {
-        LOGF(warn, "[AO2D] Chi2 label not found: %s", aodLabel.name);
-        continue;
-      }
-      debugCounter = 0;
-      for (auto const& [collisionIndex, collisionInfo] : fCollisionInfos) {
-        auto it = reducedEventIds.find(collisionInfo.index);
-        if (it == reducedEventIds.end()) {
-          continue;
-        }
-        int32_t reducedEventId = it->second;
-        MatchingCandidates matchingCandidates;
-        runChi2Matching(collisions, bcs, muonTracks, mftTracks, mftCovs, aodLabel.name, collisionInfo.matchablePairs, collisionInfo.matchingCandidates, matchingCandidates);
-        auto collision = collisions.rawIteratorAt(collisionInfo.index);
-        fillQaMatchingAodTablesForCollision(collision, muonTracks, matchingCandidates, aodLabel.id, reducedEventId);
-      }
-    }
+    fillCollisions(collisions, bcs, muonTracks, mftTracks, fCollisionInfos);
 
     for (auto const& [collisionIndex, collisionInfo] : fCollisionInfos) {
       processCollisionMc(collisionInfo, collisions, bcs, muonTracks, mftTracks, mftCovs);