Delete debug prints for 2prong code

Author: Marcellocosti

Common/Core/RecoDecay.h

@@ -24,7 +24,6 @@
 #include <cstdio>
 #include <utility> // std::move
 #include <vector>  // std::vector
-#include <iostream>
 
 // ROOT includes
 #include <TMCProcess.h> // for VMC Particle Production Process
@@ -905,20 +904,12 @@ struct RecoDecay {
     }
     // Check the PDG code of the particle.
     auto pdgCandidate = candidate.pdgCode();
-    bool debugPrint = false; // Set to true to enable debug printing.
-    if (std::abs(pdgCandidate) == 413) {
-      // Printf("MC Gen: Candidate PDG: %d", pdgCandidate);
-      debugPrint = true; // Enable debug printing for D*.
-    }
     // Printf("MC Gen: Candidate PDG: %d", pdgCandidate);
     if (pdgCandidate == pdgParticle) { // exact PDG match
       sgn = 1;
     } else if (acceptAntiParticles && pdgCandidate == -pdgParticle) { // antiparticle PDG match
       sgn = -1;
     } else {
-      if (debugPrint) {
-        std::cout << "MC Gen: Rejected: bad particle PDG: " << (acceptAntiParticles ? "abs " : "") << pdgCandidate << " != " << pdgParticle << std::endl;  
-      }
       // Printf("MC Gen: Rejected: bad particle PDG: %s%d != %d", acceptAntiParticles ? "abs " : "", pdgCandidate, std::abs(pdgParticle));
       return false;
     }
@@ -928,42 +919,25 @@ struct RecoDecay {
       std::vector<int> arrAllDaughtersIndex; // vector of indices of all daughters
       // Check the daughter indices.
       if (!candidate.has_daughters()) {
-        if (debugPrint) {
-          std::cout << "MC Gen: Rejected: bad daughter index range: " << candidate.daughtersIds().front() << "-" << candidate.daughtersIds().back() << std::endl;
-        }
         // Printf("MC Gen: Rejected: bad daughter index range: %d-%d", candidate.daughtersIds().front(), candidate.daughtersIds().back());
         return false;
       }
       // Check that the number of direct daughters is not larger than the number of expected final daughters.
       if constexpr (!checkProcess) {
         if (candidate.daughtersIds().back() - candidate.daughtersIds().front() + 1 > static_cast<int>(N)) {
-          if (debugPrint) {
-            std::cout << "MC Gen: Rejected: too many direct daughters: " << candidate.daughtersIds().back() - candidate.daughtersIds().front() + 1
-                      << " (expected " << N << " final)" << std::endl;
-          }
           // Printf("MC Gen: Rejected: too many direct daughters: %d (expected %ld final)", candidate.daughtersIds().back() - candidate.daughtersIds().front() + 1, N);
           return false;
         }
       }
       // Get the list of actual final daughters.
       getDaughters<checkProcess>(candidate, &arrAllDaughtersIndex, arrPdgDaughters, depthMax);
-      if (debugPrint) {
-        std::cout << "MC Gen: Mother " << candidate.globalIndex() << " has " << arrAllDaughtersIndex.size() << " final daughters:";
-        for (auto i : arrAllDaughtersIndex) {
-          std::cout << " " << i;
-        }
-        std::cout << std::endl;
-      }
       // printf("MC Gen: Mother %ld has %ld final daughters:", candidate.globalIndex(), arrAllDaughtersIndex.size());
       // for (auto i : arrAllDaughtersIndex) {
       //   printf(" %d", i);
       // }
       // printf("\n");
       //  Check whether the number of final daughters is equal to the required number.
       if (arrAllDaughtersIndex.size() != N) {
-        if (debugPrint) {
-          std::cout << "MC Gen: Rejected: incorrect number of final daughters: " << arrAllDaughtersIndex.size() << " (expected " << N << ")" << std::endl;
-        }
         // Printf("MC Gen: Rejected: incorrect number of final daughters: %ld (expected %ld)", arrAllDaughtersIndex.size(), N);
         return false;
       }
@@ -981,25 +955,16 @@ struct RecoDecay {
       for (auto indexDaughterI : arrAllDaughtersIndex) {                                            // o2-linter: disable=const-ref-in-for-loop (int elements)
         auto candidateDaughterI = particlesMC.rawIteratorAt(indexDaughterI - particlesMC.offset()); // ith daughter particle
         auto pdgCandidateDaughterI = candidateDaughterI.pdgCode();                                  // PDG code of the ith daughter
-        if (debugPrint) {
-          std::cout << "MC Gen: Daughter " << indexDaughterI << " PDG: " << pdgCandidateDaughterI << std::endl;
-        }
         // Printf("MC Gen: Daughter %d PDG: %d", indexDaughterI, pdgCandidateDaughterI);
         bool isPdgFound = false; // Is the PDG code of this daughter among the remaining expected PDG codes?
         for (std::size_t iProngCp = 0; iProngCp < N; ++iProngCp) {
-          if (debugPrint) {
-            std::cout << "MC Gen: Checking against expected PDG: " << coefFlavourOscillation * sgn * arrPdgDaughters[iProngCp] << std::endl;
-          }
           if (pdgCandidateDaughterI == coefFlavourOscillation * sgn * arrPdgDaughters[iProngCp]) {
             arrPdgDaughters[iProngCp] = 0; // Remove this PDG code from the array of expected ones.
             isPdgFound = true;
             break;
           }
         }
         if (!isPdgFound) {
-          if (debugPrint) {
-            std::cout << "MC Gen: Rejected: bad daughter PDG: " << pdgCandidateDaughterI << std::endl;
-          }
           // Printf("MC Gen: Rejected: bad daughter PDG: %d", pdgCandidateDaughterI);
           return false;
         }
@@ -1008,9 +973,6 @@ struct RecoDecay {
         *listIndexDaughters = arrAllDaughtersIndex;
       }
     }
-    if  (debugPrint) {
-      std::cout << "MC Gen: Accepted: m: " << candidate.globalIndex() << std::endl;
-    }
     // Printf("MC Gen: Accepted: m: %d", candidate.globalIndex());
     if (sign) {
       *sign = sgn;

PWGHF/Core/DecayChannels.h

@@ -152,7 +152,6 @@ enum DecayChannelResonant : int8_t {
   LastChannelResonant
 };
 
-
 std::unordered_map<DecayChannelResonant, std::array<int, 2> > resoStatesDPlus = 
 {
    {DecayChannelResonant::DplusToPhiPi,         std::array<int, 2>{+kPhi,       +kPiPlus}},
@@ -312,108 +311,134 @@ enum DecayChannelResonant : int8_t {
 } // namespace hf_cand_beauty
 } // namespace o2::hf_decay
 
-// using namespace o2::hf_decay;
-
 namespace o2::hf_corrbkg
 {
-  std::unordered_map<o2::hf_decay::hf_cand_3prong::DecayChannelMain, std::vector<int> > getDecayChannel3Prong(int pdgMother) {
+  using namespace o2::hf_decay;
+
+  /// Returns a map of the possible final states for a specific 3-prong particle specie
+  /// \param pdgMother PDG code of the mother particle
+  /// \return a map of final states with their corresponding PDG codes
+  std::unordered_map<hf_cand_3prong::DecayChannelMain, std::vector<int> > getDecayChannel3Prong(int pdgMother) {
     switch (pdgMother) {
       case Pdg::kDPlus:
-        return o2::hf_decay::hf_cand_3prong::finalStatesDPlus;
+        return hf_cand_3prong::finalStatesDPlus;
       case Pdg::kDS:
-        return o2::hf_decay::hf_cand_3prong::finalStatesDs;
+        return hf_cand_3prong::finalStatesDs;
       case Pdg::kDStar:
-        return o2::hf_decay::hf_cand_3prong::finalStatesDstar;
+        return hf_cand_3prong::finalStatesDstar;
       case Pdg::kLambdaCPlus:
-        return o2::hf_decay::hf_cand_3prong::finalStatesLc;
+        return hf_cand_3prong::finalStatesLc;
       case Pdg::kXiCPlus:
-        return o2::hf_decay::hf_cand_3prong::finalStatesXic;
+        return hf_cand_3prong::finalStatesXic;
       default:
         LOG(error) << "Unknown PDG code for 3-prong final states: " << pdgMother;
         return {};
     }
   }
 
-  std::unordered_map<o2::hf_decay::hf_cand_3prong::DecayChannelResonant, std::array<int, 2> > getResoChannels3Prong(int pdgMother) {
+  /// Returns a map of the resonant decay channels for a specific 3-prong particle specie
+  /// \param pdgMother PDG code of the mother particle
+  /// \return a map of resonant decay channels with their corresponding PDG codes
+  std::unordered_map<hf_cand_3prong::DecayChannelResonant, std::array<int, 2> > getResoChannels3Prong(int pdgMother) {
     switch (pdgMother) {
       case Pdg::kDPlus:
-        return o2::hf_decay::hf_cand_3prong::resoStatesDPlus;
+        return hf_cand_3prong::resoStatesDPlus;
       case Pdg::kDS:
-        return o2::hf_decay::hf_cand_3prong::resoStatesDs;
+        return hf_cand_3prong::resoStatesDs;
       case Pdg::kDStar:
-        return o2::hf_decay::hf_cand_3prong::resoStatesDstar;
+        return hf_cand_3prong::resoStatesDstar;
       case Pdg::kLambdaCPlus:
-        return o2::hf_decay::hf_cand_3prong::resoStatesLambdaC;
+        return hf_cand_3prong::resoStatesLambdaC;
       case Pdg::kXiCPlus:
-        return o2::hf_decay::hf_cand_3prong::resoStatesXiC;
+        return hf_cand_3prong::resoStatesXiC;
       default:
         LOG(error) << "Unknown PDG code for 3-prong final states: " << pdgMother;
         return {};
     }
   }
 
+  /// Perform the matching for a single resonant channel
+  /// \tparam N size of the array of daughter PDG codes
+  /// \param arrPdgResoChn array of daughter indices
+  /// \param arrPdgDaugs array of PDG codes for the resonant decay
+  /// \return true if the resonant channel is matched, false otherwise
   template <std::size_t N>
-  bool checkResonantDecay(std::array<int, N> arrDaughIndex, std::array<int, N> arrPDGResonant) {
-      LOG(info) << "Testing: " << arrDaughIndex[0] << ", " << arrDaughIndex[1] << " matching PDG codes: " << arrPDGResonant[0] << ", " << arrPDGResonant[1];
-      for (int i = 0; i < N; i++) {
-        LOG(info) << "Checking daughter index: " << arrDaughIndex[i];
-        bool findDaug = false;
-        for (int j = 0; j < N; j++) {
-          LOG(info) << "Checking daughter PDG: " << arrDaughIndex[i] << " against resonant PDG: " << arrPDGResonant[j];
-          if (std::abs(arrDaughIndex[i]) == std::abs(arrPDGResonant[j])) {
-            arrPDGResonant[j] = -1; // Mark as found
-            LOG(info) << "Matched!";
-            findDaug = true;
-            break;
-          }
-        }
-        if (!findDaug) {
-          LOG(info) << "Returning false";
-          return false;
+  bool checkResonantDecay(std::array<int, N> arrPdgResoChn, std::array<int, N> arrPdgDaugs) {
+    // LOG(info) << "Testing: " << arrPdgResoChn[0] << ", " << arrPdgResoChn[1] << " matching PDG codes: " << arrPdgDaugs[0] << ", " << arrPdgDaugs[1];
+    for (size_t i = 0; i < N; i++) {
+      // LOG(info) << "Checking daughter index: " << arrPdgResoChn[i];
+      bool findDaug = false;
+      for (size_t j = 0; j < N; j++) {
+        // LOG(info) << "Checking daughter PDG: " << arrPdgResoChn[i] << " against resonant PDG: " << arrPdgDaugs[j];
+        if (std::abs(arrPdgResoChn[i]) == std::abs(arrPdgDaugs[j])) {
+          arrPdgDaugs[j] = -1; // Mark as found
+          // LOG(info) << "Matched!";
+          findDaug = true;
+          break;
         }
       }
-      LOG(info) << "Resonant decay found with daughters: " << arrDaughIndex[0] << ", " << arrDaughIndex[1] << " matching PDG codes: " << arrPDGResonant[0] << ", " << arrPDGResonant[1];
-      return true;
+      if (!findDaug) {
+        // LOG(info) << "Returning false";
+        return false;
+      }
     }
+    // LOG(info) << "Resonant decay found with daughters: " << arrPdgResoChn[0] << ", " << arrPdgResoChn[1] << " matching PDG codes: " << arrPdgDaugs[0] << ", " << arrPdgDaugs[1];
+    return true;
+  }
 
-    /// Check if the decay is resonant
-    /// \tparam arrDaughIndex index of the particle daughters at resonance level
-    /// \tparam arrPDGResonant PDG code of the resonant decay
-    /// \return true if the decay is resonant
-    template <bool is3Prong = false, std::size_t N>
-    void flagResonantDecay(int motherPdg, int8_t* channel, std::array<int, N> arrDaughIndex) {
-      if constexpr (is3Prong) {
-        std::unordered_map<o2::hf_decay::hf_cand_3prong::DecayChannelResonant, std::array<int, 2> > resoStates = getResoChannels3Prong(motherPdg);
-        for (const auto& [flag, pdgCodes] : resoStates) {
-          if (abs(motherPdg) == Pdg::kDStar) {
-            std::cout << "Checking Dstar resonant decay with flag: " << flag << ", pdgCodes: " << pdgCodes[0] << ", " << pdgCodes[1] << " vs " << arrDaughIndex[0] << " " << arrDaughIndex[1] << std::endl;
-          }
-          if (checkResonantDecay(arrDaughIndex, pdgCodes)) {
-            *channel = flag;
-            if (abs(motherPdg) == Pdg::kDStar) {
-              LOG(info) << "Dstar resonant decay found with channel: " << static_cast<int>(*channel);
-            }
-            break;
-          }
-        }
-        if (abs(motherPdg) == Pdg::kDStar) {
-          LOG(info) << "Leaving function with channel: " << static_cast<int>(*channel);
-        }
-      } else {
-        if (motherPdg != Pdg::kD0) {
-          LOG(error) << "Resonant decay flagging is only implemented for D0 resonances in 2-prong decays.";
-          return;
+  /// Flag the resonant decays
+  /// Function documentation:
+  /// \tparam is3Prong bool to specify if the mother decays with a 3-prong decay
+  /// \tparam N size of the array of daughter PDG codes
+  /// \param motherPdg PDG code of the mother particle
+  /// \param channel decay channel flag to be set
+  /// \param arrDaughPdgs array of daughter PDG codes
+  template <bool is3Prong = false, std::size_t N>
+  void flagResonantDecay(int motherPdg, int8_t* channel, std::array<int, N> arrDaughPdgs) {
+    if constexpr (is3Prong) {
+      std::unordered_map<hf_cand_3prong::DecayChannelResonant, std::array<int, 2> > resoStates = getResoChannels3Prong(motherPdg);
+      if (abs(motherPdg) == Pdg::kDPlus) {
+        std::cout << "Flagging resonant channel for D+ with daughters: " << arrDaughPdgs[0] << " " << arrDaughPdgs[1] << std::endl;
+      }
+      if (abs(motherPdg) == Pdg::kDS) {
+        std::cout << "Flagging resonant channel for Ds with daughters: " << arrDaughPdgs[0] << " " << arrDaughPdgs[1] << std::endl;
+      }
+      if (abs(motherPdg) == Pdg::kDStar) {
+        std::cout << "Flagging resonant channel for Dstar with daughters: " << arrDaughPdgs[0] << " " << arrDaughPdgs[1] << std::endl;
+      }
+      if (abs(motherPdg) == Pdg::kLambdaCPlus) {
+        std::cout << "Flagging resonant channel for LambdaC with daughters: " << arrDaughPdgs[0] << " " << arrDaughPdgs[1] << std::endl;
+      }
+      if (abs(motherPdg) == Pdg::kXiCPlus) {
+        std::cout << "Flagging resonant channel for XiC with daughters: " << arrDaughPdgs[0] << " " << arrDaughPdgs[1] << std::endl;
+      }
+      for (const auto& [flag, pdgCodes] : resoStates) {
+        if (checkResonantDecay(arrDaughPdgs, pdgCodes)) {
+          *channel = flag;
+          // if (abs(motherPdg) == Pdg::kDStar) {
+          //   LOG(info) << "Dstar resonant decay found with channel: " << static_cast<int>(*channel);
+          // }
+          break;
         }
-        for (const auto& [flag, pdgCodes] : o2::hf_decay::hf_cand_2prong::resoStatesD0) {
-          std::cout << "Checking D0 resonant decay with flag: " << flag << ", pdgCodes: " << pdgCodes[0] << ", " << pdgCodes[1] << " vs " << arrDaughIndex[0] << " " << arrDaughIndex[1] << std::endl;
-          if (checkResonantDecay(arrDaughIndex, pdgCodes)) {
-            *channel = flag;
-            LOG(info) << "D0 resonant decay found with channel: " << static_cast<int>(*channel);
-            break;
-          }
+      }
+      // if (abs(motherPdg) == Pdg::kDStar) {
+      //   LOG(info) << "Leaving function with channel: " << static_cast<int>(*channel);
+      // }
+    } else {
+      if (motherPdg != Pdg::kD0) {
+        // LOG(error) << "Resonant decay flagging is only implemented for D0 resonances in 2-prong decays.";
+        return;
+      }
+      for (const auto& [flag, pdgCodes] : hf_cand_2prong::resoStatesD0) {
+        // std::cout << "Checking D0 resonant decay with flag: " << flag << ", pdgCodes: " << pdgCodes[0] << ", " << pdgCodes[1] << " vs " << arrDaughPdgs[0] << " " << arrDaughPdgs[1] << std::endl;
+        if (checkResonantDecay(arrDaughPdgs, pdgCodes)) {
+          *channel = flag;
+          // LOG(info) << "D0 resonant decay found with channel: " << static_cast<int>(*channel);
+          break;
         }
       }
     }
+  }
 } // namespace o2::hf_corrbkg
 
 #endif // PWGHF_CORE_DECAYCHANNELS_H_

PWGHF/TableProducer/candidateCreator2Prong.cxx

@@ -776,8 +776,6 @@ struct HfCandidateCreator2ProngExpressions {
       std::vector<int> idxBhadMothers{};
 
       if (matchCorrBkgs) {
-        LOG(info) << "--------------------------------------------";
-        LOG(info) << "Matching correlated bkgs";
         indexRec = -1; // Index of the matched reconstructed candidate
         int depth = 2;
         for (const auto& [chn, finalState] : finalStates2Prongs) {
@@ -799,12 +797,12 @@ struct HfCandidateCreator2ProngExpressions {
               if (sign < 0) {
                 for (auto& part : finalStateParts2ProngAll) {
                   if (part == kPi0) {
-                    part = -part; // Ensure all parts are positive for matching
+                    part = -part; // The Pi0 pdg code does not change between particle and antiparticle
                   }
                 }
               }
               if (!RecoDecay::isMatchedMCGen(mcParticles, motherParticle, Pdg::kD0, finalStateParts2ProngAll, false, &sign, depth)) {
-                indexRec = -1; // Reset indexRec if the generated decay
+                indexRec = -1; // Reset indexRec if the generated decay does not match the reconstructed one does not match the reconstructed one
               }
             }
           } else if (finalState.size() == 2) {            // Fully Reco 2-prong decays
@@ -819,12 +817,11 @@ struct HfCandidateCreator2ProngExpressions {
             }
           } else {
             LOG(info) << "Final state size not supported: " << finalStateParts2Prong.size();
-            continue; // Skip unsupported final states
+            continue;
           }
           if (indexRec > -1) {
-            // std::cout << "Matched final state: " << chn << " with PDG code: " << pdg << std::endl;
-            flag = sign * chn;   // Only D0 decay channels are considered here
-            
+            flag = sign * chn;
+
             // Flag the resonant decay channel
             int resoMaxDepth = 1;
             std::vector<int> arrResoDaughIndex = {};
@@ -836,13 +833,10 @@ struct HfCandidateCreator2ProngExpressions {
                 arrPDGDaugh[iProng] = daughI.pdgCode();
               }
               flagResonantDecay(Pdg::kD0, &channel, arrPDGDaugh);
-              // LOG(info) << "[matchFinalStateCorrBkgs] Matched D0 final state: " << chn << ", flag: " << static_cast<int>(flag) << ", &sign: " << static_cast<int>(sign);
-              // LOG(info) << "[matchFinalStateCorrBkgs] Flag set to: " << static_cast<int>(flag) << " sign: " << static_cast<int>(sign) << " for channel: " << static_cast<int>(channel);
             }
-            break; // Exit loop if a match is found
+            break;
           }
         }
-        // LOG(info) << "D0 matching ended with flag " << static_cast<int>(flag) << " and indexRec " << static_cast<int>(indexRec) << ", &sign " << static_cast<int>(sign) << ", channel " << static_cast<int>(channel);
       } else {
         // D0(bar) → π± K∓
         if (matchKinkedDecayTopology && matchInteractionsWithMaterial) {
@@ -890,10 +884,8 @@ struct HfCandidateCreator2ProngExpressions {
       }
       if (origin == RecoDecay::OriginType::NonPrompt) {
         auto bHadMother = mcParticles.rawIteratorAt(idxBhadMothers[0]);
-        LOG(info) << "[MCREC] Filling with flag: " << static_cast<int>(flag) << ", origin: " << static_cast<int>(origin) << ", channel: " << static_cast<int>(channel);
         rowMcMatchRec(flag, origin, channel, bHadMother.pt(), bHadMother.pdgCode(), nKinkedTracks, nInteractionsWithMaterial);
       } else {
-        LOG(info) << "[MCREC] Filling with flag: " << static_cast<int>(flag) << ", origin: " << static_cast<int>(origin) << ", channel: " << static_cast<int>(channel);
         rowMcMatchRec(flag, origin, channel, -1.f, 0, nKinkedTracks, nInteractionsWithMaterial);
       }
     }