[PWGDQ] Implement possibility to specify exclusive decay channels via MCSignal (#8744)

iarsene · Ionut Cristian Arsene · alibuild · web-flow · commit a0b82ce131fa · 2024-11-30T00:30:21.000+01:00
Co-authored-by: Ionut Cristian Arsene &lt;iarsene@cern.ch&gt;
Co-authored-by: ALICE Action Bot &lt;alibuild@cern.ch&gt;
diff --git a/PWGDQ/Core/HistogramsLibrary.cxx b/PWGDQ/Core/HistogramsLibrary.cxx
@@ -1355,6 +1355,7 @@ void o2::aod::dqhistograms::DefineHistograms(HistogramManager* hm, const char* h
       hm->AddHistogram(histClass, "TauzProj", "", false, 4000, -0.5, 0.5, VarManager::kVertexingTauzProjected);
       hm->AddHistogram(histClass, "TauxyProj", "", false, 4000, -0.5, 0.5, VarManager::kVertexingTauxyProjected);
       hm->AddHistogram(histClass, "CosPointingAngle", "", false, 100, 0.0, 1.0, VarManager::kCosPointingAngle);
+      hm->AddHistogram(histClass, "DCAxyzBetweenProngs", "", false, 100, 0.0, 1.0, VarManager::kKFDCAxyzBetweenProngs);
     }
     if (subGroupStr.Contains("multidimentional-vertexing-histograms")) {
       hm->AddHistogram(histClass, "Mass_Tauxy", "", false, 75, 4.0, 7.0, VarManager::kPairMass, 40, -0.0, 0.02, VarManager::kVertexingTauxy);
diff --git a/PWGDQ/Core/MCSignal.cxx b/PWGDQ/Core/MCSignal.cxx
@@ -9,6 +9,9 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
+#include <vector>
+#include <iostream>
+
 #include "PWGDQ/Core/MCSignal.h"
 
 using std::cout;
@@ -22,7 +25,9 @@ MCSignal::MCSignal() : TNamed("", ""),
                        fNProngs(0),
                        fCommonAncestorIdxs({}),
                        fExcludeCommonAncestor(false),
-                       fTempAncestorLabel(-1)
+                       fTempAncestorLabel(-1),
+                       fDecayChannelIsExclusive(false),
+                       fDecayChannelIsNotExclusive(false)
 {
 }
 
@@ -32,31 +37,35 @@ MCSignal::MCSignal(int nProngs, const char* name /*= ""*/, const char* title /*=
                                                                                          fNProngs(nProngs),
                                                                                          fCommonAncestorIdxs({}),
                                                                                          fExcludeCommonAncestor(false),
-                                                                                         fTempAncestorLabel(-1)
+                                                                                         fTempAncestorLabel(-1),
+                                                                                         fDecayChannelIsExclusive(false),
+                                                                                         fDecayChannelIsNotExclusive(false)
 {
   fProngs.reserve(nProngs);
 }
 
 //________________________________________________________________________________________________
-MCSignal::MCSignal(const char* name, const char* title, std::vector<MCProng> prongs, std::vector<short> commonAncestors, bool excludeCommonAncestor) : TNamed(name, title),
-                                                                                                                                                       fProngs(prongs),
-                                                                                                                                                       fNProngs(prongs.size()),
-                                                                                                                                                       fCommonAncestorIdxs(commonAncestors),
-                                                                                                                                                       fExcludeCommonAncestor(excludeCommonAncestor),
-                                                                                                                                                       fTempAncestorLabel(-1)
+MCSignal::MCSignal(const char* name, const char* title, std::vector<MCProng> prongs, std::vector<int8_t> commonAncestors, bool excludeCommonAncestor) : TNamed(name, title),
+                                                                                                                                                        fProngs(prongs),
+                                                                                                                                                        fNProngs(prongs.size()),
+                                                                                                                                                        fCommonAncestorIdxs(commonAncestors),
+                                                                                                                                                        fExcludeCommonAncestor(excludeCommonAncestor),
+                                                                                                                                                        fTempAncestorLabel(-1),
+                                                                                                                                                        fDecayChannelIsExclusive(false),
+                                                                                                                                                        fDecayChannelIsNotExclusive(false)
 {
 }
 
 //________________________________________________________________________________________________
-void MCSignal::SetProngs(std::vector<MCProng> prongs, std::vector<short> commonAncestors)
+void MCSignal::SetProngs(std::vector<MCProng> prongs, std::vector<int8_t> commonAncestors)
 {
   fProngs = prongs;
   fNProngs = fProngs.size();
   fCommonAncestorIdxs = commonAncestors;
 }
 
 //________________________________________________________________________________________________
-void MCSignal::AddProng(MCProng prong, short commonAncestor)
+void MCSignal::AddProng(MCProng prong, int8_t commonAncestor)
 {
   if (fProngs.size() < fNProngs) {
     fProngs.push_back(prong);
@@ -71,6 +80,8 @@ void MCSignal::PrintConfig()
 {
   cout << "Name/Title: " << fName << " / " << fTitle << endl;
   cout << "Exclude common ancestor combinations: " << fExcludeCommonAncestor << endl;
+  cout << "Decay channel is exclusive: " << fDecayChannelIsExclusive << endl;
+  cout << "Decay channel is not exclusive: " << fDecayChannelIsNotExclusive << endl;
   cout << "Printing " << fNProngs << "/" << fProngs.size() << " prongs:" << endl;
   int i = 0;
   for (auto& pr : fProngs) {
diff --git a/PWGDQ/Core/MCSignal.h b/PWGDQ/Core/MCSignal.h
@@ -66,13 +66,21 @@ class MCSignal : public TNamed
 {
  public:
   MCSignal();
-  MCSignal(int nProngs, const char* name = "", const char* title = "");
-  MCSignal(const char* name, const char* title, std::vector<MCProng> prongs, std::vector<short> commonAncestors, bool excludeCommonAncestor = false);
+  MCSignal(int nProngs, const char* name = "", const char* title = ""); // NOLINT
+  MCSignal(const char* name, const char* title, std::vector<MCProng> prongs, std::vector<int8_t> commonAncestors, bool excludeCommonAncestor = false);
   MCSignal(const MCSignal& c) = default;
   ~MCSignal() override = default;
 
-  void SetProngs(std::vector<MCProng> prongs, std::vector<short> commonAncestors);
-  void AddProng(MCProng prong, short commonAncestor = -1);
+  void SetProngs(std::vector<MCProng> prongs, std::vector<int8_t> commonAncestors);
+  void AddProng(MCProng prong, int8_t commonAncestor = -1);
+  void SetDecayChannelIsExclusive(bool option = true)
+  {
+    fDecayChannelIsExclusive = option;
+  }
+  void SetDecayChannelIsNotExclusive(bool option = true)
+  {
+    fDecayChannelIsNotExclusive = option;
+  }
 
   int GetNProngs() const
   {
@@ -82,6 +90,14 @@ class MCSignal : public TNamed
   {
     return fProngs[0].fNGenerations;
   }
+  bool GetDecayChannelIsExclusive() const
+  {
+    return fDecayChannelIsExclusive;
+  }
+  bool GetDecayChannelIsNotExclusive() const
+  {
+    return fDecayChannelIsNotExclusive;
+  }
 
   template <typename... T>
   bool CheckSignal(bool checkSources, const T&... args)
@@ -97,10 +113,12 @@ class MCSignal : public TNamed
   void PrintConfig();
 
  private:
-  std::vector<MCProng> fProngs;
-  unsigned int fNProngs;
-  std::vector<short> fCommonAncestorIdxs;
-  bool fExcludeCommonAncestor;
+  std::vector<MCProng> fProngs;            // vector of MCProng
+  unsigned int fNProngs;                   // number of prongs
+  std::vector<int8_t> fCommonAncestorIdxs; // index of the most recent ancestor, relative to each prong's history
+  bool fExcludeCommonAncestor;             // explicitly request that there is no common ancestor
+  bool fDecayChannelIsExclusive;           // if true, then the indicated mother particle has a number of daughters which is equal to the number of prongs defined in this MC signal
+  bool fDecayChannelIsNotExclusive;        // if true, then the indicated mother particle has a number of daughters which is larger than the number of prongs defined in this MC signal
   int fTempAncestorLabel;
 
   template <typename T>
@@ -139,6 +157,18 @@ bool MCSignal::CheckProng(int i, bool checkSources, const T& track)
     if (fNProngs > 1 && fCommonAncestorIdxs[i] == j) {
       if (i == 0) {
         fTempAncestorLabel = currentMCParticle.globalIndex();
+        // In the case of decay channels marked as being "exclusive", check how many decay daughters this mother has registered
+        //   in the stack and compare to the number of prongs defined for this MCSignal.
+        //  If these numbers are equal, it means this decay MCSignal match is exclusive (there are no additional prongs for this mother besides the
+        //     prongs defined here).
+        if (currentMCParticle.has_daughters()) {
+          if (fDecayChannelIsExclusive && currentMCParticle.daughtersIds()[1] - currentMCParticle.daughtersIds()[0] + 1 != fNProngs) {
+            return false;
+          }
+          if (fDecayChannelIsNotExclusive && currentMCParticle.daughtersIds()[1] - currentMCParticle.daughtersIds()[0] + 1 == fNProngs) {
+            return false;
+          }
+        }
       } else {
         if (currentMCParticle.globalIndex() != fTempAncestorLabel && !fExcludeCommonAncestor)
           return false;
@@ -185,27 +215,27 @@ bool MCSignal::CheckProng(int i, bool checkSources, const T& track)
       // check each source
       uint64_t sourcesDecision = 0;
       // Check kPhysicalPrimary
-      if (fProngs[i].fSourceBits[j] & (uint64_t(1) << MCProng::kPhysicalPrimary)) {
-        if ((fProngs[i].fExcludeSource[j] & (uint64_t(1) << MCProng::kPhysicalPrimary)) != currentMCParticle.isPhysicalPrimary()) {
-          sourcesDecision |= (uint64_t(1) << MCProng::kPhysicalPrimary);
+      if (fProngs[i].fSourceBits[j] & (static_cast<uint64_t>(1) << MCProng::kPhysicalPrimary)) {
+        if ((fProngs[i].fExcludeSource[j] & (static_cast<uint64_t>(1) << MCProng::kPhysicalPrimary)) != currentMCParticle.isPhysicalPrimary()) {
+          sourcesDecision |= (static_cast<uint64_t>(1) << MCProng::kPhysicalPrimary);
         }
       }
       // Check kProducedInTransport
-      if (fProngs[i].fSourceBits[j] & (uint64_t(1) << MCProng::kProducedInTransport)) {
-        if ((fProngs[i].fExcludeSource[j] & (uint64_t(1) << MCProng::kProducedInTransport)) != (!currentMCParticle.producedByGenerator())) {
-          sourcesDecision |= (uint64_t(1) << MCProng::kProducedInTransport);
+      if (fProngs[i].fSourceBits[j] & (static_cast<uint64_t>(1) << MCProng::kProducedInTransport)) {
+        if ((fProngs[i].fExcludeSource[j] & (static_cast<uint64_t>(1) << MCProng::kProducedInTransport)) != (!currentMCParticle.producedByGenerator())) {
+          sourcesDecision |= (static_cast<uint64_t>(1) << MCProng::kProducedInTransport);
         }
       }
       // Check kProducedByGenerator
-      if (fProngs[i].fSourceBits[j] & (uint64_t(1) << MCProng::kProducedByGenerator)) {
-        if ((fProngs[i].fExcludeSource[j] & (uint64_t(1) << MCProng::kProducedByGenerator)) != currentMCParticle.producedByGenerator()) {
-          sourcesDecision |= (uint64_t(1) << MCProng::kProducedByGenerator);
+      if (fProngs[i].fSourceBits[j] & (static_cast<uint64_t>(1) << MCProng::kProducedByGenerator)) {
+        if ((fProngs[i].fExcludeSource[j] & (static_cast<uint64_t>(1) << MCProng::kProducedByGenerator)) != currentMCParticle.producedByGenerator()) {
+          sourcesDecision |= (static_cast<uint64_t>(1) << MCProng::kProducedByGenerator);
         }
       }
       // Check kFromBackgroundEvent
-      if (fProngs[i].fSourceBits[j] & (uint64_t(1) << MCProng::kFromBackgroundEvent)) {
-        if ((fProngs[i].fExcludeSource[j] & (uint64_t(1) << MCProng::kFromBackgroundEvent)) != currentMCParticle.fromBackgroundEvent()) {
-          sourcesDecision |= (uint64_t(1) << MCProng::kFromBackgroundEvent);
+      if (fProngs[i].fSourceBits[j] & (static_cast<uint64_t>(1) << MCProng::kFromBackgroundEvent)) {
+        if ((fProngs[i].fExcludeSource[j] & (static_cast<uint64_t>(1) << MCProng::kFromBackgroundEvent)) != currentMCParticle.fromBackgroundEvent()) {
+          sourcesDecision |= (static_cast<uint64_t>(1) << MCProng::kFromBackgroundEvent);
         }
       }
       // no source bit is fulfilled
@@ -246,9 +276,9 @@ bool MCSignal::CheckProng(int i, bool checkSources, const T& track)
     }
   }
 
-  if (fProngs[i].fPDGInHistory.size() == 0)
+  if (fProngs[i].fPDGInHistory.size() == 0) {
     return true;
-  else { // check if mother pdg is in history
+  } else { // check if mother pdg is in history
     std::vector<int> pdgInHistory;
 
     // while find mothers, check if the provided PDG codes are included or excluded in the particle decay history
diff --git a/PWGDQ/Core/MCSignalLibrary.cxx b/PWGDQ/Core/MCSignalLibrary.cxx
@@ -11,6 +11,8 @@
 //
 // Contact: iarsene@cern.ch, i.c.arsene@fys.uio.no
 //
+#include <string>
+
 #include <TPDGCode.h>
 #include "CommonConstants/PhysicsConstants.h"
 #include "PWGDQ/Core/MCSignalLibrary.h"
@@ -405,6 +407,11 @@ MCSignal* o2::aod::dqmcsignals::GetMCSignal(const char* name)
     signal = new MCSignal(name, "Electrons from jpsi decays", {prong}, {-1});
     return signal;
   }
+  if (!nameStr.compare("anythingFromJpsi")) {
+    MCProng prong(2, {MCProng::kPDGCodeNotAssigned, 443}, {true, true}, {false, false}, {0, 0}, {0, 0}, {false, false});
+    signal = new MCSignal(name, "Anything from jpsi decays", {prong}, {-1});
+    return signal;
+  }
   if (!nameStr.compare("eFromPromptJpsi")) {
     MCProng prong(2, {11, 443}, {true, true}, {false, false}, {0, 0}, {0, 0}, {false, false});
     prong.SetSourceBit(0, MCProng::kPhysicalPrimary);
@@ -701,6 +708,20 @@ MCSignal* o2::aod::dqmcsignals::GetMCSignal(const char* name)
     signal = new MCSignal(name, "ee pairs from j/psi decays", {prong, prong}, {1, 1}); // signal at pair level
     return signal;
   }
+  if (!nameStr.compare("eeFromJpsiExclusive")) {
+    MCProng prong(2, {11, 443}, {true, true}, {false, false}, {0, 0}, {0, 0}, {false, false});
+    prong.SetSourceBit(0, MCProng::kPhysicalPrimary);
+    signal = new MCSignal(name, "ee pairs from j/psi decays", {prong, prong}, {1, 1}); // signal at pair level
+    signal->SetDecayChannelIsExclusive(true);
+    return signal;
+  }
+  if (!nameStr.compare("eeFromJpsiNotExclusive")) {
+    MCProng prong(2, {11, 443}, {true, true}, {false, false}, {0, 0}, {0, 0}, {false, false});
+    prong.SetSourceBit(0, MCProng::kPhysicalPrimary);
+    signal = new MCSignal(name, "ee pairs from j/psi decays", {prong, prong}, {1, 1}); // signal at pair level
+    signal->SetDecayChannelIsNotExclusive(true);
+    return signal;
+  }
   if (!nameStr.compare("eePrimaryFromPromptJPsi")) {
     MCProng prong(2, {11, 443}, {true, true}, {false, false}, {0, 0}, {0, 0}, {false, false}, false, {503}, {true});
     prong.SetSourceBit(0, MCProng::kPhysicalPrimary);
@@ -1120,6 +1141,22 @@ MCSignal* o2::aod::dqmcsignals::GetMCSignal(const char* name)
     return signal;
   }
 
+  if (!nameStr.compare("eeKaonFromBplusExclusive")) {
+    MCProng pronge(3, {11, 443, 521}, {true, true, true}, {false, false, false}, {0, 0, 0}, {0, 0, 0}, {false, false, false});
+    MCProng prongKaon(2, {321, 521}, {true, true}, {false, false}, {0, 0}, {0, 0}, {false, false});
+    signal = new MCSignal(name, "Kaon and electron pair from B+", {pronge, pronge, prongKaon}, {2, 2, 1});
+    signal->SetDecayChannelIsExclusive(true);
+    return signal;
+  }
+
+  if (!nameStr.compare("eeKaonFromBplusNotExclusive")) {
+    MCProng pronge(3, {11, 443, 521}, {true, true, true}, {false, false, false}, {0, 0, 0}, {0, 0, 0}, {false, false, false});
+    MCProng prongKaon(2, {321, 521}, {true, true}, {false, false}, {0, 0}, {0, 0}, {false, false});
+    signal = new MCSignal(name, "Kaon and electron pair from B+", {pronge, pronge, prongKaon}, {2, 2, 1});
+    signal->SetDecayChannelIsNotExclusive(true);
+    return signal;
+  }
+
   if (!nameStr.compare("Bplus")) {
     MCProng prong(1, {521}, {true}, {false}, {0}, {0}, {false});
     signal = new MCSignal(name, "B+", {prong}, {-1});
diff --git a/PWGDQ/Tasks/dqEfficiency_withAssoc.cxx b/PWGDQ/Tasks/dqEfficiency_withAssoc.cxx
@@ -79,6 +79,7 @@ DECLARE_SOA_COLUMN(TauxyBcandidate, tauxyBcandidate, float);
 DECLARE_SOA_COLUMN(TauzBcandidate, tauzBcandidate, float);
 DECLARE_SOA_COLUMN(CosPBcandidate, cosPBcandidate, float);
 DECLARE_SOA_COLUMN(Chi2Bcandidate, chi2Bcandidate, float);
+DECLARE_SOA_COLUMN(DCAxyzBetweenProngs, dcaxyzBetweenProngs, float);
 DECLARE_SOA_COLUMN(McFlag, mcFlag, int8_t);
 } // namespace dqanalysisflags
 
@@ -88,7 +89,7 @@ DECLARE_SOA_TABLE(BarrelAmbiguities, "AOD", "DQBARRELAMB", dqanalysisflags::Barr
 DECLARE_SOA_TABLE(MuonTrackCuts, "AOD", "DQANAMUONCUTS", dqanalysisflags::IsMuonSelected);                                                       //!  joinable to ReducedMuonsAssoc
 DECLARE_SOA_TABLE(MuonAmbiguities, "AOD", "DQMUONAMB", dqanalysisflags::MuonAmbiguityInBunch, dqanalysisflags::MuonAmbiguityOutOfBunch);         //!  joinable to ReducedMuonTracks
 DECLARE_SOA_TABLE(Prefilter, "AOD", "DQPREFILTER", dqanalysisflags::IsBarrelSelectedPrefilter);                                                  //!  joinable to ReducedTracksAssoc
-DECLARE_SOA_TABLE(BmesonCandidates, "AOD", "DQBMESONS", dqanalysisflags::massBcandidate, dqanalysisflags::pTBcandidate, dqanalysisflags::LxyBcandidate, dqanalysisflags::LxyzBcandidate, dqanalysisflags::LzBcandidate, dqanalysisflags::TauxyBcandidate, dqanalysisflags::TauzBcandidate, dqanalysisflags::CosPBcandidate, dqanalysisflags::Chi2Bcandidate, dqanalysisflags::McFlag);
+DECLARE_SOA_TABLE(BmesonCandidates, "AOD", "DQBMESONS", dqanalysisflags::massBcandidate, dqanalysisflags::pTBcandidate, dqanalysisflags::LxyBcandidate, dqanalysisflags::LxyzBcandidate, dqanalysisflags::LzBcandidate, dqanalysisflags::TauxyBcandidate, dqanalysisflags::TauzBcandidate, dqanalysisflags::DCAxyzBetweenProngs, dqanalysisflags::CosPBcandidate, dqanalysisflags::Chi2Bcandidate, dqanalysisflags::McFlag);
 } // namespace o2::aod
 
 // Declarations of various short names
@@ -2136,7 +2137,7 @@ struct AnalysisDileptonTrack {
           }
         }
         // table to be written out for ML analysis
-        BmesonsTable(fValuesHadron[VarManager::kPairMass], fValuesHadron[VarManager::kPairPt], fValuesHadron[VarManager::kVertexingLxy], fValuesHadron[VarManager::kVertexingLxyz], fValuesHadron[VarManager::kVertexingLz], fValuesHadron[VarManager::kVertexingTauxy], fValuesHadron[VarManager::kVertexingTauz], fValuesHadron[VarManager::kCosPointingAngle], fValuesHadron[VarManager::kVertexingChi2PCA], mcDecision);
+        BmesonsTable(fValuesHadron[VarManager::kPairMass], fValuesHadron[VarManager::kPairPt], fValuesHadron[VarManager::kVertexingLxy], fValuesHadron[VarManager::kVertexingLxyz], fValuesHadron[VarManager::kVertexingLz], fValuesHadron[VarManager::kVertexingTauxy], fValuesHadron[VarManager::kVertexingTauz], fValuesHadron[VarManager::kKFDCAxyzBetweenProngs], fValuesHadron[VarManager::kCosPointingAngle], fValuesHadron[VarManager::kVertexingChi2PCA], mcDecision);
       }
     } // end loop over dileptons
   }

Original file line number	Diff line number	Diff line change
`@@ -1355,6 +1355,7 @@ void o2::aod::dqhistograms::DefineHistograms(HistogramManager* hm, const char* h`
`1355`	`1355`	`hm->AddHistogram(histClass, "TauzProj", "", false, 4000, -0.5, 0.5, VarManager::kVertexingTauzProjected);`
`1356`	`1356`	`hm->AddHistogram(histClass, "TauxyProj", "", false, 4000, -0.5, 0.5, VarManager::kVertexingTauxyProjected);`
`1357`	`1357`	`hm->AddHistogram(histClass, "CosPointingAngle", "", false, 100, 0.0, 1.0, VarManager::kCosPointingAngle);`
	`1358`	`+ hm->AddHistogram(histClass, "DCAxyzBetweenProngs", "", false, 100, 0.0, 1.0, VarManager::kKFDCAxyzBetweenProngs);`
`1358`	`1359`	`}`
`1359`	`1360`	`if (subGroupStr.Contains("multidimentional-vertexing-histograms")) {`
`1360`	`1361`	`hm->AddHistogram(histClass, "Mass_Tauxy", "", false, 75, 4.0, 7.0, VarManager::kPairMass, 40, -0.0, 0.02, VarManager::kVertexingTauxy);`
Original file line number	Diff line number	Diff line change
`@@ -79,6 +79,7 @@ DECLARE_SOA_COLUMN(TauxyBcandidate, tauxyBcandidate, float);`
`79`	`79`	`DECLARE_SOA_COLUMN(TauzBcandidate, tauzBcandidate, float);`
`80`	`80`	`DECLARE_SOA_COLUMN(CosPBcandidate, cosPBcandidate, float);`
`81`	`81`	`DECLARE_SOA_COLUMN(Chi2Bcandidate, chi2Bcandidate, float);`
	`82`	`+DECLARE_SOA_COLUMN(DCAxyzBetweenProngs, dcaxyzBetweenProngs, float);`
`82`	`83`	`DECLARE_SOA_COLUMN(McFlag, mcFlag, int8_t);`
`83`	`84`	`} // namespace dqanalysisflags`
`84`	`85`
`@@ -88,7 +89,7 @@ DECLARE_SOA_TABLE(BarrelAmbiguities, "AOD", "DQBARRELAMB", dqanalysisflags::Barr`
`88`	`89`	`DECLARE_SOA_TABLE(MuonTrackCuts, "AOD", "DQANAMUONCUTS", dqanalysisflags::IsMuonSelected); //! joinable to ReducedMuonsAssoc`
`89`	`90`	`DECLARE_SOA_TABLE(MuonAmbiguities, "AOD", "DQMUONAMB", dqanalysisflags::MuonAmbiguityInBunch, dqanalysisflags::MuonAmbiguityOutOfBunch); //! joinable to ReducedMuonTracks`
`90`	`91`	`DECLARE_SOA_TABLE(Prefilter, "AOD", "DQPREFILTER", dqanalysisflags::IsBarrelSelectedPrefilter); //! joinable to ReducedTracksAssoc`
`91`		`-DECLARE_SOA_TABLE(BmesonCandidates, "AOD", "DQBMESONS", dqanalysisflags::massBcandidate, dqanalysisflags::pTBcandidate, dqanalysisflags::LxyBcandidate, dqanalysisflags::LxyzBcandidate, dqanalysisflags::LzBcandidate, dqanalysisflags::TauxyBcandidate, dqanalysisflags::TauzBcandidate, dqanalysisflags::CosPBcandidate, dqanalysisflags::Chi2Bcandidate, dqanalysisflags::McFlag);`
	`92`	`+DECLARE_SOA_TABLE(BmesonCandidates, "AOD", "DQBMESONS", dqanalysisflags::massBcandidate, dqanalysisflags::pTBcandidate, dqanalysisflags::LxyBcandidate, dqanalysisflags::LxyzBcandidate, dqanalysisflags::LzBcandidate, dqanalysisflags::TauxyBcandidate, dqanalysisflags::TauzBcandidate, dqanalysisflags::DCAxyzBetweenProngs, dqanalysisflags::CosPBcandidate, dqanalysisflags::Chi2Bcandidate, dqanalysisflags::McFlag);`
`92`	`93`	`} // namespace o2::aod`
`93`	`94`
`94`	`95`	`// Declarations of various short names`
`@@ -2136,7 +2137,7 @@ struct AnalysisDileptonTrack {`
`2136`	`2137`	`}`
`2137`	`2138`	`}`
`2138`	`2139`	`// table to be written out for ML analysis`
`2139`		`- BmesonsTable(fValuesHadron[VarManager::kPairMass], fValuesHadron[VarManager::kPairPt], fValuesHadron[VarManager::kVertexingLxy], fValuesHadron[VarManager::kVertexingLxyz], fValuesHadron[VarManager::kVertexingLz], fValuesHadron[VarManager::kVertexingTauxy], fValuesHadron[VarManager::kVertexingTauz], fValuesHadron[VarManager::kCosPointingAngle], fValuesHadron[VarManager::kVertexingChi2PCA], mcDecision);`
	`2140`	`+ BmesonsTable(fValuesHadron[VarManager::kPairMass], fValuesHadron[VarManager::kPairPt], fValuesHadron[VarManager::kVertexingLxy], fValuesHadron[VarManager::kVertexingLxyz], fValuesHadron[VarManager::kVertexingLz], fValuesHadron[VarManager::kVertexingTauxy], fValuesHadron[VarManager::kVertexingTauz], fValuesHadron[VarManager::kKFDCAxyzBetweenProngs], fValuesHadron[VarManager::kCosPointingAngle], fValuesHadron[VarManager::kVertexingChi2PCA], mcDecision);`
`2140`	`2141`	`}`
`2141`	`2142`	`} // end loop over dileptons`
`2142`	`2143`	`}`