resolve conflict linter NBinsPt: implement KF-based cuts in candidateSelectorLc

lubynets · lubynets · commit 078b04826e25 · 2025-03-14T19:37:34.000+01:00
diff --git a/PWGHF/Core/SelectorCuts.h b/PWGHF/Core/SelectorCuts.h
@@ -465,6 +465,7 @@ namespace hf_cuts_lc_to_p_k_pi
 {
 static constexpr int NBinsPt = 10;
 static constexpr int NCutVars = 11;
+static constexpr int NKfCutVars = 12;
 // default values for the pT bin edges (can be used to configure histogram axis)
 // offset by 1 from the bin numbers in cuts array
 constexpr double BinsPt[NBinsPt + 1] = {
@@ -493,6 +494,19 @@ constexpr double Cuts[NBinsPt][NCutVars] = {{0.4, 0.4, 0.4, 0.4, 0., 0.005, 0.,
                                             {0.4, 0.4, 0.4, 0.4, 0., 0.005, 0., 0., 0., 1e+10, -1.},  /* 12 < pT < 24 */
                                             {0.4, 0.4, 0.4, 0.4, 0., 0.005, 0., 0., 0., 1e+10, -1.}}; /* 24 < pT < 36 */
 
+// default value for the cuts                    Chi2Prim      Chi2Geo       DCA, cm     Chi2Geo  Chi2Topo
+//                                               P   K  Pi  KPi PPi  PK  KPi    PPi   PK   ↓  LdL  ↓
+constexpr double kfCuts[nBinsPt][NKfCutVars] = {{3., 3., 3., 3., 3., 3., 0.01, 0.01, 0.01, 3., 5., 5.},  /* 0  < pT < 1  */
+                                                {3., 3., 3., 3., 3., 3., 0.01, 0.01, 0.01, 3., 5., 5.},  /* 1  < pT < 2  */
+                                                {3., 3., 3., 3., 3., 3., 0.01, 0.01, 0.01, 3., 5., 5.},  /* 2  < pT < 3  */
+                                                {3., 3., 3., 3., 3., 3., 0.01, 0.01, 0.01, 3., 5., 5.},  /* 3  < pT < 4  */
+                                                {3., 3., 3., 3., 3., 3., 0.01, 0.01, 0.01, 3., 5., 5.},  /* 4  < pT < 5  */
+                                                {3., 3., 3., 3., 3., 3., 0.01, 0.01, 0.01, 3., 5., 5.},  /* 5  < pT < 6  */
+                                                {3., 3., 3., 3., 3., 3., 0.01, 0.01, 0.01, 3., 5., 5.},  /* 6  < pT < 8  */
+                                                {3., 3., 3., 3., 3., 3., 0.01, 0.01, 0.01, 3., 5., 5.},  /* 8  < pT < 12 */
+                                                {3., 3., 3., 3., 3., 3., 0.01, 0.01, 0.01, 3., 5., 5.},  /* 12 < pT < 24 */
+                                                {3., 3., 3., 3., 3., 3., 0.01, 0.01, 0.01, 3., 5., 5.}}; /* 24 < pT < 36 */
+
 // row labels
 static const std::vector<std::string> labelsPt = {
   "pT bin 0",
@@ -508,6 +522,7 @@ static const std::vector<std::string> labelsPt = {
 
 // column labels
 static const std::vector<std::string> labelsCutVar = {"m", "pT p", "pT K", "pT Pi", "Chi2PCA", "decay length", "cos pointing angle", "decLengthXY", "normDecLXY", "impParXY", "mass (Kpi)"};
+static const std::vector<std::string> labelsKfCutVar = {"kfChi2PrimPr", "kfChi2PrimKa", "kfChi2PrimPi", "kfChi2GeoKaPi", "kfChi2GeoPrPi", "kfChi2GeoPrKa", "kfDcaKaPi", "kfDcaPrPi", "kfDcaPrKa", "kfChi2Geo", "kfLdL", "kfChi2Topo"};
 } // namespace hf_cuts_lc_to_p_k_pi
 
 namespace hf_cuts_lc_to_k0s_p
diff --git a/PWGHF/TableProducer/candidateSelectorLc.cxx b/PWGHF/TableProducer/candidateSelectorLc.cxx
@@ -72,7 +72,10 @@ struct HfCandidateSelectorLc {
   Configurable<LabeledArray<double>> cutsSingleTrack{"cutsSingleTrack", {hf_cuts_single_track::CutsTrack[0], hf_cuts_single_track::NBinsPtTrack, hf_cuts_single_track::NCutVarsTrack, hf_cuts_single_track::labelsPtTrack, hf_cuts_single_track::labelsCutVarTrack}, "Single-track selections"};
   // topological cuts
   Configurable<std::vector<double>> binsPt{"binsPt", std::vector<double>{hf_cuts_lc_to_p_k_pi::vecBinsPt}, "pT bin limits"};
-  Configurable<LabeledArray<double>> cuts{"cuts", {hf_cuts_lc_to_p_k_pi::Cuts[0], hf_cuts_lc_to_p_k_pi::NBinsPt, hf_cuts_lc_to_p_k_pi::NCutVars, hf_cuts_lc_to_p_k_pi::labelsPt, hf_cuts_lc_to_p_k_pi::labelsCutVar}, "Lc candidate selection per pT bin"};
+  Configurable<LabeledArray<double>> cuts{"cuts", {hf_cuts_lc_to_p_k_pi::cuts[0], hf_cuts_lc_to_p_k_pi::NBinsPt, hf_cuts_lc_to_p_k_pi::nCutVars, hf_cuts_lc_to_p_k_pi::labelsPt, hf_cuts_lc_to_p_k_pi::labelsCutVar}, "Lc candidate selection per pT bin"};
+  Configurable<LabeledArray<double>> kfCuts{"kfCuts", {hf_cuts_lc_to_p_k_pi::kfCuts[0], hf_cuts_lc_to_p_k_pi::NBinsPt, hf_cuts_lc_to_p_k_pi::nKfCutVars, hf_cuts_lc_to_p_k_pi::labelsPt, hf_cuts_lc_to_p_k_pi::labelsKfCutVar}, "Lc candidate selection per pT bin with KF-associated variables"};
+  Configurable<bool> applyNonKfCuts{"applyNonKfCuts", true, "Whether to apply non-KF cuts when running in KF mode. In DCAFitter mode this field is not effective"};
+  Configurable<bool> applyKfCuts{"applyKfCuts", true, "Whether to apply KF cuts when running in KF mode. In DCAFitter mode this field is not effective"};
   // QA switch
   Configurable<bool> activateQA{"activateQA", false, "Flag to enable QA histogram"};
   // ML inference
@@ -175,7 +178,7 @@ struct HfCandidateSelectorLc {
   /// Conjugate-independent topological cuts
   /// \param candidate is candidate
   /// \return true if candidate passes all cuts
-  template <typename T>
+  template <aod::hf_cand::VertexerType reconstructionType, typename T>
   bool selectionTopol(const T& candidate)
   {
     auto candpT = candidate.pt();
@@ -190,33 +193,52 @@ struct HfCandidateSelectorLc {
       return false;
     }
 
-    // cosine of pointing angle
-    if (candidate.cpa() <= cuts->get(pTBin, "cos pointing angle")) {
-      return false;
-    }
+    if (reconstructionType == aod::hf_cand::VertexerType::DCAFitter || (reconstructionType == aod::hf_cand::VertexerType::KfParticle && applyNonKfCuts)) {
+      // cosine of pointing angle
+      if (candidate.cpa() <= cuts->get(pTBin, "cos pointing angle")) {
+        return false;
+      }
 
-    // candidate chi2PCA
-    if (candidate.chi2PCA() > cuts->get(pTBin, "Chi2PCA")) {
-      return false;
-    }
+      // candidate chi2PCA
+      if (candidate.chi2PCA() > cuts->get(pTBin, "Chi2PCA")) {
+        return false;
+      }
 
-    if (candidate.decayLength() <= cuts->get(pTBin, "decay length")) {
-      return false;
-    }
+      if (candidate.decayLength() <= cuts->get(pTBin, "decay length")) {
+        return false;
+      }
 
-    // candidate decay length XY
-    if (candidate.decayLengthXY() <= cuts->get(pTBin, "decLengthXY")) {
-      return false;
-    }
+      // candidate decay length XY
+      if (candidate.decayLengthXY() <= cuts->get(pTBin, "decLengthXY")) {
+        return false;
+      }
 
-    // candidate normalized decay length XY
-    if (candidate.decayLengthXYNormalised() < cuts->get(pTBin, "normDecLXY")) {
-      return false;
+      // candidate normalized decay length XY
+      if (candidate.decayLengthXYNormalised() < cuts->get(pTBin, "normDecLXY")) {
+        return false;
+      }
+
+      // candidate impact parameter XY
+      if (std::abs(candidate.impactParameterXY()) > cuts->get(pTBin, "impParXY")) {
+        return false;
+      }
     }
 
-    // candidate impact parameter XY
-    if (std::abs(candidate.impactParameterXY()) > cuts->get(pTBin, "impParXY")) {
-      return false;
+    if (reconstructionType == aod::hf_cand::VertexerType::KfParticle && applyKfCuts) {
+      // candidate chi2geo of the triplet of prongs
+      if (candidate.kfChi2Geo() > kfCuts->get(pTBin, "kfChi2Geo")) {
+        return false;
+      }
+
+      // candidate's decay point separation from the PV in terms of its error
+      if (candidate.kfDecayLength() / candidate.kfDecayLengthError() < kfCuts->get(pTBin, "kfLdL")) {
+        return false;
+      }
+
+      // candidate's chi2 to the PV
+      if (candidate.kfChi2Topo() > kfCuts->get(pTBin, "kfChi2Topo")) {
+        return false;
+      }
     }
 
     if (!isSelectedCandidateProngDca(candidate)) {
@@ -242,13 +264,6 @@ struct HfCandidateSelectorLc {
       return false;
     }
 
-    // cut on daughter pT
-    if (trackProton.pt() < cuts->get(pTBin, "pT p") || trackKaon.pt() < cuts->get(pTBin, "pT K") || trackPion.pt() < cuts->get(pTBin, "pT Pi")) {
-      return false;
-    }
-
-    // cut on Lc->pKpi, piKp mass values
-    /// cut on the Kpi pair invariant mass, to study Lc->pK*(->Kpi)
     float massLc, massKPi;
     if constexpr (reconstructionType == aod::hf_cand::VertexerType::DCAFitter) {
       if (trackProton.globalIndex() == candidate.prong0Id()) {
@@ -268,14 +283,96 @@ struct HfCandidateSelectorLc {
       }
     }
 
-    if (std::abs(massLc - o2::constants::physics::MassLambdaCPlus) > cuts->get(pTBin, "m")) {
-      return false;
+    if (reconstructionType == aod::hf_cand::VertexerType::DCAFitter || (reconstructionType == aod::hf_cand::VertexerType::KfParticle && applyNonKfCuts)) {
+      // cut on daughter pT
+      if (trackProton.pt() < cuts->get(pTBin, "pT p") || trackKaon.pt() < cuts->get(pTBin, "pT K") || trackPion.pt() < cuts->get(pTBin, "pT Pi")) {
+        return false;
+      }
+
+      // cut on Lc->pKpi, piKp mass values
+      if (std::abs(massLc - o2::constants::physics::MassLambdaCPlus) > cuts->get(pTBin, "m")) {
+        return false;
+      }
+
+      /// cut on the Kpi pair invariant mass, to study Lc->pK*(->Kpi)
+      const double cutMassKPi = cuts->get(pTBin, "mass (Kpi)");
+      if (cutMassKPi > 0 && std::abs(massKPi - massK0Star892) > cutMassKPi) {
+        return false;
+      }
     }
 
-    /// cut on the Kpi pair invariant mass, to study Lc->pK*(->Kpi)
-    const double cutMassKPi = cuts->get(pTBin, "mass (Kpi)");
-    if (cutMassKPi > 0 && std::abs(massKPi - massK0Star892) > cutMassKPi) {
-      return false;
+    if (reconstructionType == aod::hf_cand::VertexerType::KfParticle && applyKfCuts) {
+
+      const float chi2PrimProng0 = candidate.kfChi2PrimProng0();
+      const float chi2PrimProng1 = candidate.kfChi2PrimProng1();
+      const float chi2PrimProng2 = candidate.kfChi2PrimProng2();
+
+      const float chi2GeoProng1Prong2 = candidate.kfGeoProng1Prong2();
+      const float chi2GeoProng0Prong2 = candidate.kfGeoProng0Prong2();
+      const float chi2GeoProng0Prong1 = candidate.kfGeoProng0Prong1();
+
+      const float dcaProng1Prong2 = candidate.kfDcaProng1Prong2();
+      const float dcaProng0Prong2 = candidate.kfDcaProng0Prong2();
+      const float dcaProng0Prong1 = candidate.kfDcaProng0Prong1();
+
+      const double cutChi2PrimPr = kfCuts->get(pTBin, "kfChi2PrimPr");
+      const double cutChi2PrimKa = kfCuts->get(pTBin, "kfChi2PrimKa");
+      const double cutChi2PrimPi = kfCuts->get(pTBin, "kfChi2PrimPi");
+
+      const double cutChi2GeoKaPi = kfCuts->get(pTBin, "kfChi2GeoKaPi");
+      const double cutChi2GeoPrPi = kfCuts->get(pTBin, "kfChi2GeoPrPi");
+      const double cutChi2GeoPrKa = kfCuts->get(pTBin, "kfChi2GeoPrKa");
+
+      const double cutDcaKaPi = kfCuts->get(pTBin, "kfDcaKaPi");
+      const double cutDcaPrPi = kfCuts->get(pTBin, "kfDcaPrPi");
+      const double cutDcaPrKa = kfCuts->get(pTBin, "kfDcaPrKa");
+
+      // kaon's chi2 to the PV
+      if (chi2PrimProng1 < cutChi2PrimKa) {
+        return false;
+      }
+
+      // chi2geo between proton and pion
+      if (chi2GeoProng0Prong2 > cutChi2GeoPrPi) {
+        return false;
+      }
+
+      // dca between proton and pion
+      if (dcaProng0Prong2 > cutDcaPrPi) {
+        return false;
+      }
+
+      const bool isPKPi = trackProton.globalIndex() == candidate.prong0Id();
+
+      // 0-th prong chi2 to the PV
+      if (chi2PrimProng0 < (isPKPi ? cutChi2PrimPr : cutChi2PrimPi)) {
+        return false;
+      }
+
+      // 2-nd prong chi2 to the PV
+      if (chi2PrimProng2 < (isPKPi ? cutChi2PrimPi : cutChi2PrimPr)) {
+        return false;
+      }
+
+      // chi2geo between 1-st and 2-nd prongs
+      if (chi2GeoProng1Prong2 > (isPKPi ? cutChi2GeoKaPi : cutChi2GeoPrKa)) {
+        return false;
+      }
+
+      // chi2geo between 0-th and 1-st prongs
+      if (chi2GeoProng0Prong1 > (isPKPi ? cutChi2GeoPrKa : cutChi2GeoKaPi)) {
+        return false;
+      }
+
+      // dca between 1-st and 2-nd prongs
+      if (dcaProng1Prong2 > (isPKPi ? cutDcaKaPi : cutDcaPrKa)) {
+        return false;
+      }
+
+      // dca between 0-th and 1-st prongs
+      if (dcaProng0Prong1 > (isPKPi ? cutDcaPrKa : cutDcaKaPi)) {
+        return false;
+      }
     }
 
     return true;
