Update taskXic0ToXiPi.cxx

Tao-Fang · web-flow · commit e7cc03cb9a38 · 2025-10-06T16:37:51.000+08:00
diff --git a/PWGHF/D2H/Tasks/taskXic0ToXiPi.cxx b/PWGHF/D2H/Tasks/taskXic0ToXiPi.cxx
@@ -106,9 +106,10 @@ struct HfTaskXic0ToXiPi {
 
   void init(InitContext&)
   {
-    std::array<bool, 16> doprocess{doprocessDataWithDCAFitter, doprocessDataWithDCAFitterMl, doprocessDataWithDCAFitterFT0C, doprocessDataWithDCAFitterFT0M, doprocessDataWithDCAFitterMlFT0C, doprocessDataWithDCAFitterMlFT0M,
-                                   doprocessDataWithKFParticle, doprocessDataWithKFParticleMl, doprocessDataWithKFParticleFT0C, doprocessDataWithKFParticleFT0M, doprocessDataWithKFParticleMlFT0C, doprocessDataWithKFParticleMlFT0M,
-                                   doprocessMcWithKFParticle, doprocessMcWithKFParticleMl, doprocessMcWithDCAFitter, doprocessMcWithDCAFitterMl};
+    std::array<bool, 16> doprocess{doprocessDataWithDCAFitter, doprocessDataWithDCAFitterMl, doprocessDataWithDCAFitterFT0C, doprocessDataWithDCAFitterFT0M, doprocessDataWithDCAFitterMlFT0C, doprocessDataWithDCAFitterMlFT0M, \
+        doprocessDataWithKFParticle, doprocessDataWithKFParticleMl, doprocessDataWithKFParticleFT0C, doprocessDataWithKFParticleFT0M, doprocessDataWithKFParticleMlFT0C, doprocessDataWithKFParticleMlFT0M, \
+        doprocessMcWithKFParticle, doprocessMcWithKFParticleMl,doprocessMcWithDCAFitter, doprocessMcWithDCAFitterMl
+      };
     if ((std::accumulate(doprocess.begin(), doprocess.end(), 0)) != 1) {
       LOGP(fatal, "One and only one process function should be enabled at a time.");
     }
@@ -158,32 +159,14 @@ struct HfTaskXic0ToXiPi {
     }
   }
 
-  template <bool applyMl, typename CandType, typename CollType>
-  void processData(const CandType& candidates, CollType const&)
-  {
-    for (const auto& candidate : candidates) {
-      if (candidate.resultSelections() != true) {
-        continue;
-      }
-      if (yCandRecMax >= 0. && std::abs(candidate.etaCharmBaryon()) > yCandRecMax) {
-        continue;
-      }
-
-      if constexpr (applyMl) {
-        registry.fill(HIST("hBdtScoreVsMassVsPtVsPtBVsYVsOriginVsXic0Type"), candidate.mlProbToXiPi()[0], candidate.invMassCharmBaryon(), candidate.ptXic(), candidate.etaCharmBaryon());
-      } else {
-        registry.fill(HIST("hMassVsPtVsPtBVsYVsOriginVsXic0Type"), candidate.invMassCharmBaryon(), candidate.ptXic(), candidate.etaCharmBaryon());
-      }
-    }
-  }
-
-  template <bool useCentrality, bool applyMl, typename CandType, typename CollType>
+  template <bool useKfParticle, bool useCentrality, bool applyMl, typename CandType, typename CollType>
   void processDataCent(const CandType& candidate, CollType const& collision)
   {
     if (candidate.resultSelections() != true) {
       return;
     }
-    if (yCandRecMax >= 0. && std::abs(candidate.etaCharmBaryon()) > yCandRecMax) {
+    double etaCharmBaryon = useKfParticle ? candidate.kfRapXic() : candidate.etaCharmBaryon();
+    if (yCandRecMax >= 0. && std::abs(etaCharmBaryon) > yCandRecMax) {
       return;
     }
 
@@ -199,22 +182,22 @@ struct HfTaskXic0ToXiPi {
                     candidate.mlProbToXiPi()[0],
                     candidate.invMassCharmBaryon(),
                     ptXic,
-                    candidate.etaCharmBaryon(),
+                    etaCharmBaryon,
                     centrality,
                     ptPiFromXic,
                     numPvContributors);
     } else {
       registry.fill(HIST("hMassVsPtVsYVsCentVsPtPion"),
                     candidate.invMassCharmBaryon(),
                     ptXic,
-                    candidate.etaCharmBaryon(),
+                    etaCharmBaryon,
                     centrality,
                     ptPiFromXic,
                     numPvContributors);
     }
   }
 
-  template <bool applyMl, typename CandType, typename CollType>
+  template <bool useKfParticle, bool applyMl, typename CandType, typename CollType>
   void processMc(const CandType& candidates,
                  Xic0Gen const& mcParticles,
                  TracksMc const&,
@@ -224,20 +207,21 @@ struct HfTaskXic0ToXiPi {
     // MC rec.
     for (const auto& candidate : candidates) {
       if (candidate.resultSelections() != true) {
-        continue;
+        return;
       }
-      if (yCandRecMax >= 0. && std::abs(candidate.etaCharmBaryon()) > yCandRecMax) {
-        continue;
+      double etaCharmBaryon = useKfParticle ? candidate.kfRapXic() : candidate.etaCharmBaryon();
+      if (yCandRecMax >= 0. && std::abs(etaCharmBaryon) > yCandRecMax) {
+        return;
       }
 
       auto numPvContributors = candidate.template collision_as<CollType>().numContrib();
-      double ptXic = RecoDecay::pt(candidate.pxCharmBaryon(), candidate.pyCharmBaryon());
+      double ptXic = RecoDecay::pt(candidate.pxCharmBaryon(), candidate.pyCharmBaryon());      
       if constexpr (applyMl) {
         registry.fill(HIST("hBdtScoreVsMassVsPtVsPtBVsYVsOriginVsXic0Type"),
                       candidate.mlProbToXiPi()[0],
                       candidate.invMassCharmBaryon(),
                       ptXic,
-                      candidate.etaCharmBaryon(),
+                      etaCharmBaryon,
                       candidate.ptBhadMotherPart(),
                       candidate.originMcRec(),
                       candidate.flagMcMatchRec(),
@@ -246,7 +230,7 @@ struct HfTaskXic0ToXiPi {
         registry.fill(HIST("hMassVsPtVsPtBVsYVsOriginVsXic0Type"),
                       candidate.invMassCharmBaryon(),
                       ptXic,
-                      candidate.etaCharmBaryon(),
+                      etaCharmBaryon,
                       candidate.ptBhadMotherPart(),
                       candidate.originMcRec(),
                       candidate.flagMcMatchRec(),
@@ -287,15 +271,15 @@ struct HfTaskXic0ToXiPi {
       }
     }
   }
-
+  
   void processDataWithDCAFitter(Xic0Cands const& candidates,
                                 CollisionsWithEvSels const& collisions)
   {
     for (const auto& collision : collisions) {
       auto thisCollId = collision.globalIndex();
       auto groupedXicCandidates = candidates.sliceBy(candXicPerCollision, thisCollId);
       for (const auto& candidate : groupedXicCandidates) {
-        processDataCent<false, false>(candidate, collision);
+        processDataCent<false, false, false>(candidate, collision);
       }
     }
   }
@@ -308,20 +292,20 @@ struct HfTaskXic0ToXiPi {
       auto thisCollId = collision.globalIndex();
       auto groupedXicCandidates = candidates.sliceBy(candXicKFPerCollision, thisCollId);
       for (const auto& candidate : groupedXicCandidates) {
-        processDataCent<false, false>(candidate, collision);
+        processDataCent<true, false, false>(candidate, collision);
       }
     }
   }
   PROCESS_SWITCH(HfTaskXic0ToXiPi, processDataWithKFParticle, "process HfTaskXic0ToXiPi with KFParticle", true);
 
   void processDataWithDCAFitterMl(Xic0CandsMl const& candidates,
-                                  CollisionsWithEvSels const& collisions)
+                                CollisionsWithEvSels const& collisions)
   {
     for (const auto& collision : collisions) {
       auto thisCollId = collision.globalIndex();
       auto groupedXicCandidates = candidates.sliceBy(candXicMlPerCollision, thisCollId);
       for (const auto& candidate : groupedXicCandidates) {
-        processDataCent<false, true>(candidate, collision);
+        processDataCent<false, false, true>(candidate, collision);
       }
     }
   }
@@ -334,20 +318,20 @@ struct HfTaskXic0ToXiPi {
       auto thisCollId = collision.globalIndex();
       auto groupedXicCandidates = candidates.sliceBy(candXicKFMlPerCollision, thisCollId);
       for (const auto& candidate : groupedXicCandidates) {
-        processDataCent<false, true>(candidate, collision);
+        processDataCent<true, false, true>(candidate, collision);
       }
     }
   }
   PROCESS_SWITCH(HfTaskXic0ToXiPi, processDataWithKFParticleMl, "process HfTaskXic0ToXiPi with KFParticle and ML selections", false);
 
   void processDataWithDCAFitterFT0C(Xic0Cands const& candidates,
-                                    CollisionsWithFT0C const& collisions)
+                                CollisionsWithFT0C const& collisions)
   {
     for (const auto& collision : collisions) {
       auto thisCollId = collision.globalIndex();
       auto groupedXicCandidates = candidates.sliceBy(candXicPerCollision, thisCollId);
       for (const auto& candidate : groupedXicCandidates) {
-        processDataCent<true, false>(candidate, collision);
+        processDataCent<false, true, false>(candidate, collision);
       }
     }
   }
@@ -360,20 +344,20 @@ struct HfTaskXic0ToXiPi {
       auto thisCollId = collision.globalIndex();
       auto groupedXicCandidates = candidates.sliceBy(candXicKFPerCollision, thisCollId);
       for (const auto& candidate : groupedXicCandidates) {
-        processDataCent<true, false>(candidate, collision);
+        processDataCent<true, true, false>(candidate, collision);
       }
     }
   }
   PROCESS_SWITCH(HfTaskXic0ToXiPi, processDataWithKFParticleFT0C, "process HfTaskXic0ToXiPi with KFParticle and with FT0C centrality", false);
 
   void processDataWithDCAFitterFT0M(Xic0Cands const& candidates,
-                                    CollisionsWithFT0M const& collisions)
+                                CollisionsWithFT0M const& collisions)
   {
     for (const auto& collision : collisions) {
       auto thisCollId = collision.globalIndex();
       auto groupedXicCandidates = candidates.sliceBy(candXicPerCollision, thisCollId);
       for (const auto& candidate : groupedXicCandidates) {
-        processDataCent<true, false>(candidate, collision);
+        processDataCent<false, true, false>(candidate, collision);
       }
     }
   }
@@ -386,48 +370,48 @@ struct HfTaskXic0ToXiPi {
       auto thisCollId = collision.globalIndex();
       auto groupedXicCandidates = candidates.sliceBy(candXicKFPerCollision, thisCollId);
       for (const auto& candidate : groupedXicCandidates) {
-        processDataCent<true, false>(candidate, collision);
+        processDataCent<true, true, false>(candidate, collision);
       }
     }
   }
   PROCESS_SWITCH(HfTaskXic0ToXiPi, processDataWithKFParticleFT0M, "process HfTaskXic0ToXiPi with KFParticle and with FT0M centrality", false);
 
   void processDataWithDCAFitterMlFT0C(Xic0CandsMl const& candidates,
-                                      CollisionsWithFT0C const& collisions)
+                                       CollisionsWithFT0C const& collisions)
   {
     for (const auto& collision : collisions) {
       auto thisCollId = collision.globalIndex();
       auto groupedXicCandidates = candidates.sliceBy(candXicMlPerCollision, thisCollId);
       for (const auto& candidate : groupedXicCandidates) {
-        processDataCent<true, true>(candidate, collision);
+        processDataCent<false, true, true>(candidate, collision);
       }
-    }
+    }  
   }
   PROCESS_SWITCH(HfTaskXic0ToXiPi, processDataWithDCAFitterMlFT0C, "process HfTaskXic0ToXiPi with DCAFitter and ML selections and with FT0C centrality", false);
-
+  
   void processDataWithKFParticleMlFT0C(Xic0CandsMlKF const& candidates,
                                        CollisionsWithFT0C const& collisions)
   {
     for (const auto& collision : collisions) {
       auto thisCollId = collision.globalIndex();
       auto groupedXicCandidates = candidates.sliceBy(candXicKFMlPerCollision, thisCollId);
       for (const auto& candidate : groupedXicCandidates) {
-        processDataCent<true, true>(candidate, collision);
+        processDataCent<true, true, true>(candidate, collision);
       }
-    }
+    }  
   }
   PROCESS_SWITCH(HfTaskXic0ToXiPi, processDataWithKFParticleMlFT0C, "process HfTaskXic0ToXiPi with KFParticle and ML selections and with FT0C centrality", false);
 
   void processDataWithDCAFitterMlFT0M(Xic0CandsMl const& candidates,
-                                      CollisionsWithFT0M const& collisions)
+                                       CollisionsWithFT0M const& collisions)
   {
     for (const auto& collision : collisions) {
       auto thisCollId = collision.globalIndex();
       auto groupedXicCandidates = candidates.sliceBy(candXicMlPerCollision, thisCollId);
       for (const auto& candidate : groupedXicCandidates) {
-        processDataCent<true, true>(candidate, collision);
+        processDataCent<false, true, true>(candidate, collision);
       }
-    }
+    }  
   }
   PROCESS_SWITCH(HfTaskXic0ToXiPi, processDataWithDCAFitterMlFT0M, "process HfTaskXic0ToXiPi with DCAFitter and ML selections and with FT0M centrality", false);
 
@@ -438,19 +422,19 @@ struct HfTaskXic0ToXiPi {
       auto thisCollId = collision.globalIndex();
       auto groupedXicCandidates = candidates.sliceBy(candXicKFMlPerCollision, thisCollId);
       for (const auto& candidate : groupedXicCandidates) {
-        processDataCent<true, true>(candidate, collision);
+        processDataCent<true, true, true>(candidate, collision);
       }
-    }
+    }  
   }
   PROCESS_SWITCH(HfTaskXic0ToXiPi, processDataWithKFParticleMlFT0M, "process HfTaskXic0ToXiPi with KFParticle and ML selections and with FT0M centrality", false);
 
   void processMcWithDCAFitter(Xic0CandsMc const& Xic0CandidatesMc,
-                              Xic0Gen const& mcParticles,
-                              TracksMc const& tracks,
-                              CollisionsWithMcLabels const& collisions,
-                              aod::McCollisions const& mcCollisions)
+                               Xic0Gen const& mcParticles,
+                               TracksMc const& tracks,
+                               CollisionsWithMcLabels const& collisions,
+                               aod::McCollisions const& mcCollisions)
   {
-    processMc<false>(Xic0CandidatesMc, mcParticles, tracks, collisions, mcCollisions);
+    processMc<false, false>(Xic0CandidatesMc, mcParticles, tracks, collisions, mcCollisions);
   }
   PROCESS_SWITCH(HfTaskXic0ToXiPi, processMcWithDCAFitter, "Process MC with KFParticle", false);
 
@@ -460,17 +444,17 @@ struct HfTaskXic0ToXiPi {
                                CollisionsWithMcLabels const& collisions,
                                aod::McCollisions const& mcCollisions)
   {
-    processMc<false>(Xic0CandidatesMcKF, mcParticles, tracks, collisions, mcCollisions);
+    processMc<true, false>(Xic0CandidatesMcKF, mcParticles, tracks, collisions, mcCollisions);
   }
   PROCESS_SWITCH(HfTaskXic0ToXiPi, processMcWithKFParticle, "Process MC with KFParticle", false);
 
   void processMcWithDCAFitterMl(Xic0CandsMlMc const& Xic0CandidatesMlMc,
-                                Xic0Gen const& mcParticles,
-                                TracksMc const& tracks,
-                                CollisionsWithMcLabels const& collisions,
-                                aod::McCollisions const& mcCollisions)
+                                 Xic0Gen const& mcParticles,
+                                 TracksMc const& tracks,
+                                 CollisionsWithMcLabels const& collisions,
+                                 aod::McCollisions const& mcCollisions)
   {
-    processMc<true>(Xic0CandidatesMlMc, mcParticles, tracks, collisions, mcCollisions);
+    processMc<false, true>(Xic0CandidatesMlMc, mcParticles, tracks, collisions, mcCollisions);
   }
   PROCESS_SWITCH(HfTaskXic0ToXiPi, processMcWithDCAFitterMl, "Process MC with KFParticle and ML selections", false);
 
@@ -480,7 +464,7 @@ struct HfTaskXic0ToXiPi {
                                  CollisionsWithMcLabels const& collisions,
                                  aod::McCollisions const& mcCollisions)
   {
-    processMc<true>(Xic0CandidatesMlMcKF, mcParticles, tracks, collisions, mcCollisions);
+    processMc<true, true>(Xic0CandidatesMlMcKF, mcParticles, tracks, collisions, mcCollisions);
   }
   PROCESS_SWITCH(HfTaskXic0ToXiPi, processMcWithKFParticleMl, "Process MC with KFParticle and ML selections", false);
 };

Original file line number	Diff line number	Diff line change
`@@ -106,9 +106,10 @@ struct HfTaskXic0ToXiPi {`
`106`	`106`
`107`	`107`	`void init(InitContext&)`
`108`	`108`	`{`
`109`		`- std::array<bool, 16> doprocess{doprocessDataWithDCAFitter, doprocessDataWithDCAFitterMl, doprocessDataWithDCAFitterFT0C, doprocessDataWithDCAFitterFT0M, doprocessDataWithDCAFitterMlFT0C, doprocessDataWithDCAFitterMlFT0M,`
`110`		`- doprocessDataWithKFParticle, doprocessDataWithKFParticleMl, doprocessDataWithKFParticleFT0C, doprocessDataWithKFParticleFT0M, doprocessDataWithKFParticleMlFT0C, doprocessDataWithKFParticleMlFT0M,`
`111`		`- doprocessMcWithKFParticle, doprocessMcWithKFParticleMl, doprocessMcWithDCAFitter, doprocessMcWithDCAFitterMl};`
	`109`	`+ std::array<bool, 16> doprocess{doprocessDataWithDCAFitter, doprocessDataWithDCAFitterMl, doprocessDataWithDCAFitterFT0C, doprocessDataWithDCAFitterFT0M, doprocessDataWithDCAFitterMlFT0C, doprocessDataWithDCAFitterMlFT0M, \`
	`110`	`+ doprocessDataWithKFParticle, doprocessDataWithKFParticleMl, doprocessDataWithKFParticleFT0C, doprocessDataWithKFParticleFT0M, doprocessDataWithKFParticleMlFT0C, doprocessDataWithKFParticleMlFT0M, \`
	`111`	`+ doprocessMcWithKFParticle, doprocessMcWithKFParticleMl,doprocessMcWithDCAFitter, doprocessMcWithDCAFitterMl`
	`112`	`+ };`
`112`	`113`	`if ((std::accumulate(doprocess.begin(), doprocess.end(), 0)) != 1) {`
`113`	`114`	`LOGP(fatal, "One and only one process function should be enabled at a time.");`
`114`	`115`	`}`
`@@ -158,32 +159,14 @@ struct HfTaskXic0ToXiPi {`
`158`	`159`	`}`
`159`	`160`	`}`
`160`	`161`
`161`		`- template <bool applyMl, typename CandType, typename CollType>`
`162`		`- void processData(const CandType& candidates, CollType const&)`
`163`		`- {`
`164`		`- for (const auto& candidate : candidates) {`
`165`		`- if (candidate.resultSelections() != true) {`
`166`		`- continue;`
`167`		`- }`
`168`		`- if (yCandRecMax >= 0. && std::abs(candidate.etaCharmBaryon()) > yCandRecMax) {`
`169`		`- continue;`
`170`		`- }`
`171`		`-`
`172`		`- if constexpr (applyMl) {`
`173`		`- registry.fill(HIST("hBdtScoreVsMassVsPtVsPtBVsYVsOriginVsXic0Type"), candidate.mlProbToXiPi()[0], candidate.invMassCharmBaryon(), candidate.ptXic(), candidate.etaCharmBaryon());`
`174`		`- } else {`
`175`		`- registry.fill(HIST("hMassVsPtVsPtBVsYVsOriginVsXic0Type"), candidate.invMassCharmBaryon(), candidate.ptXic(), candidate.etaCharmBaryon());`
`176`		`- }`
`177`		`- }`
`178`		`- }`
`179`		`-`
`180`		`- template <bool useCentrality, bool applyMl, typename CandType, typename CollType>`
	`162`	`+ template <bool useKfParticle, bool useCentrality, bool applyMl, typename CandType, typename CollType>`
`181`	`163`	`void processDataCent(const CandType& candidate, CollType const& collision)`
`182`	`164`	`{`
`183`	`165`	`if (candidate.resultSelections() != true) {`
`184`	`166`	`return;`
`185`	`167`	`}`
`186`		`- if (yCandRecMax >= 0. && std::abs(candidate.etaCharmBaryon()) > yCandRecMax) {`
	`168`	`+ double etaCharmBaryon = useKfParticle ? candidate.kfRapXic() : candidate.etaCharmBaryon();`
	`169`	`+ if (yCandRecMax >= 0. && std::abs(etaCharmBaryon) > yCandRecMax) {`
`187`	`170`	`return;`
`188`	`171`	`}`
`189`	`172`
`@@ -199,22 +182,22 @@ struct HfTaskXic0ToXiPi {`
`199`	`182`	`candidate.mlProbToXiPi()[0],`
`200`	`183`	`candidate.invMassCharmBaryon(),`
`201`	`184`	`ptXic,`
`202`		`- candidate.etaCharmBaryon(),`
	`185`	`+ etaCharmBaryon,`
`203`	`186`	`centrality,`
`204`	`187`	`ptPiFromXic,`
`205`	`188`	`numPvContributors);`
`206`	`189`	`} else {`
`207`	`190`	`registry.fill(HIST("hMassVsPtVsYVsCentVsPtPion"),`
`208`	`191`	`candidate.invMassCharmBaryon(),`
`209`	`192`	`ptXic,`
`210`		`- candidate.etaCharmBaryon(),`
	`193`	`+ etaCharmBaryon,`
`211`	`194`	`centrality,`
`212`	`195`	`ptPiFromXic,`
`213`	`196`	`numPvContributors);`
`214`	`197`	`}`
`215`	`198`	`}`
`216`	`199`
`217`		`- template <bool applyMl, typename CandType, typename CollType>`
	`200`	`+ template <bool useKfParticle, bool applyMl, typename CandType, typename CollType>`
`218`	`201`	`void processMc(const CandType& candidates,`
`219`	`202`	`Xic0Gen const& mcParticles,`
`220`	`203`	`TracksMc const&,`
`@@ -224,20 +207,21 @@ struct HfTaskXic0ToXiPi {`
`224`	`207`	`// MC rec.`
`225`	`208`	`for (const auto& candidate : candidates) {`
`226`	`209`	`if (candidate.resultSelections() != true) {`
`227`		`- continue;`
	`210`	`+ return;`
`228`	`211`	`}`
`229`		`- if (yCandRecMax >= 0. && std::abs(candidate.etaCharmBaryon()) > yCandRecMax) {`
`230`		`- continue;`
	`212`	`+ double etaCharmBaryon = useKfParticle ? candidate.kfRapXic() : candidate.etaCharmBaryon();`
	`213`	`+ if (yCandRecMax >= 0. && std::abs(etaCharmBaryon) > yCandRecMax) {`
	`214`	`+ return;`
`231`	`215`	`}`
`232`	`216`
`233`	`217`	`auto numPvContributors = candidate.template collision_as<CollType>().numContrib();`
`234`		`- double ptXic = RecoDecay::pt(candidate.pxCharmBaryon(), candidate.pyCharmBaryon());`
	`218`	`+ double ptXic = RecoDecay::pt(candidate.pxCharmBaryon(), candidate.pyCharmBaryon());`
`235`	`219`	`if constexpr (applyMl) {`
`236`	`220`	`registry.fill(HIST("hBdtScoreVsMassVsPtVsPtBVsYVsOriginVsXic0Type"),`
`237`	`221`	`candidate.mlProbToXiPi()[0],`
`238`	`222`	`candidate.invMassCharmBaryon(),`
`239`	`223`	`ptXic,`
`240`		`- candidate.etaCharmBaryon(),`
	`224`	`+ etaCharmBaryon,`
`241`	`225`	`candidate.ptBhadMotherPart(),`
`242`	`226`	`candidate.originMcRec(),`
`243`	`227`	`candidate.flagMcMatchRec(),`
`@@ -246,7 +230,7 @@ struct HfTaskXic0ToXiPi {`
`246`	`230`	`registry.fill(HIST("hMassVsPtVsPtBVsYVsOriginVsXic0Type"),`
`247`	`231`	`candidate.invMassCharmBaryon(),`
`248`	`232`	`ptXic,`
`249`		`- candidate.etaCharmBaryon(),`
	`233`	`+ etaCharmBaryon,`
`250`	`234`	`candidate.ptBhadMotherPart(),`
`251`	`235`	`candidate.originMcRec(),`
`252`	`236`	`candidate.flagMcMatchRec(),`
`@@ -287,15 +271,15 @@ struct HfTaskXic0ToXiPi {`
`287`	`271`	`}`
`288`	`272`	`}`
`289`	`273`	`}`
`290`		`-`
	`274`	`+`
`291`	`275`	`void processDataWithDCAFitter(Xic0Cands const& candidates,`
`292`	`276`	`CollisionsWithEvSels const& collisions)`
`293`	`277`	`{`
`294`	`278`	`for (const auto& collision : collisions) {`
`295`	`279`	`auto thisCollId = collision.globalIndex();`
`296`	`280`	`auto groupedXicCandidates = candidates.sliceBy(candXicPerCollision, thisCollId);`
`297`	`281`	`for (const auto& candidate : groupedXicCandidates) {`
`298`		`- processDataCent<false, false>(candidate, collision);`
	`282`	`+ processDataCent<false, false, false>(candidate, collision);`
`299`	`283`	`}`
`300`	`284`	`}`
`301`	`285`	`}`
`@@ -308,20 +292,20 @@ struct HfTaskXic0ToXiPi {`
`308`	`292`	`auto thisCollId = collision.globalIndex();`
`309`	`293`	`auto groupedXicCandidates = candidates.sliceBy(candXicKFPerCollision, thisCollId);`
`310`	`294`	`for (const auto& candidate : groupedXicCandidates) {`
`311`		`- processDataCent<false, false>(candidate, collision);`
	`295`	`+ processDataCent<true, false, false>(candidate, collision);`
`312`	`296`	`}`
`313`	`297`	`}`
`314`	`298`	`}`
`315`	`299`	`PROCESS_SWITCH(HfTaskXic0ToXiPi, processDataWithKFParticle, "process HfTaskXic0ToXiPi with KFParticle", true);`
`316`	`300`
`317`	`301`	`void processDataWithDCAFitterMl(Xic0CandsMl const& candidates,`
`318`		`- CollisionsWithEvSels const& collisions)`
	`302`	`+ CollisionsWithEvSels const& collisions)`
`319`	`303`	`{`
`320`	`304`	`for (const auto& collision : collisions) {`
`321`	`305`	`auto thisCollId = collision.globalIndex();`
`322`	`306`	`auto groupedXicCandidates = candidates.sliceBy(candXicMlPerCollision, thisCollId);`
`323`	`307`	`for (const auto& candidate : groupedXicCandidates) {`
`324`		`- processDataCent<false, true>(candidate, collision);`
	`308`	`+ processDataCent<false, false, true>(candidate, collision);`
`325`	`309`	`}`
`326`	`310`	`}`
`327`	`311`	`}`
`@@ -334,20 +318,20 @@ struct HfTaskXic0ToXiPi {`
`334`	`318`	`auto thisCollId = collision.globalIndex();`
`335`	`319`	`auto groupedXicCandidates = candidates.sliceBy(candXicKFMlPerCollision, thisCollId);`
`336`	`320`	`for (const auto& candidate : groupedXicCandidates) {`
`337`		`- processDataCent<false, true>(candidate, collision);`
	`321`	`+ processDataCent<true, false, true>(candidate, collision);`
`338`	`322`	`}`
`339`	`323`	`}`
`340`	`324`	`}`
`341`	`325`	`PROCESS_SWITCH(HfTaskXic0ToXiPi, processDataWithKFParticleMl, "process HfTaskXic0ToXiPi with KFParticle and ML selections", false);`
`342`	`326`
`343`	`327`	`void processDataWithDCAFitterFT0C(Xic0Cands const& candidates,`
`344`		`- CollisionsWithFT0C const& collisions)`
	`328`	`+ CollisionsWithFT0C const& collisions)`
`345`	`329`	`{`
`346`	`330`	`for (const auto& collision : collisions) {`
`347`	`331`	`auto thisCollId = collision.globalIndex();`
`348`	`332`	`auto groupedXicCandidates = candidates.sliceBy(candXicPerCollision, thisCollId);`
`349`	`333`	`for (const auto& candidate : groupedXicCandidates) {`
`350`		`- processDataCent<true, false>(candidate, collision);`
	`334`	`+ processDataCent<false, true, false>(candidate, collision);`
`351`	`335`	`}`
`352`	`336`	`}`
`353`	`337`	`}`
`@@ -360,20 +344,20 @@ struct HfTaskXic0ToXiPi {`
`360`	`344`	`auto thisCollId = collision.globalIndex();`
`361`	`345`	`auto groupedXicCandidates = candidates.sliceBy(candXicKFPerCollision, thisCollId);`
`362`	`346`	`for (const auto& candidate : groupedXicCandidates) {`
`363`		`- processDataCent<true, false>(candidate, collision);`
	`347`	`+ processDataCent<true, true, false>(candidate, collision);`
`364`	`348`	`}`
`365`	`349`	`}`
`366`	`350`	`}`
`367`	`351`	`PROCESS_SWITCH(HfTaskXic0ToXiPi, processDataWithKFParticleFT0C, "process HfTaskXic0ToXiPi with KFParticle and with FT0C centrality", false);`
`368`	`352`
`369`	`353`	`void processDataWithDCAFitterFT0M(Xic0Cands const& candidates,`
`370`		`- CollisionsWithFT0M const& collisions)`
	`354`	`+ CollisionsWithFT0M const& collisions)`
`371`	`355`	`{`
`372`	`356`	`for (const auto& collision : collisions) {`
`373`	`357`	`auto thisCollId = collision.globalIndex();`
`374`	`358`	`auto groupedXicCandidates = candidates.sliceBy(candXicPerCollision, thisCollId);`
`375`	`359`	`for (const auto& candidate : groupedXicCandidates) {`
`376`		`- processDataCent<true, false>(candidate, collision);`
	`360`	`+ processDataCent<false, true, false>(candidate, collision);`
`377`	`361`	`}`
`378`	`362`	`}`
`379`	`363`	`}`
`@@ -386,48 +370,48 @@ struct HfTaskXic0ToXiPi {`
`386`	`370`	`auto thisCollId = collision.globalIndex();`
`387`	`371`	`auto groupedXicCandidates = candidates.sliceBy(candXicKFPerCollision, thisCollId);`
`388`	`372`	`for (const auto& candidate : groupedXicCandidates) {`
`389`		`- processDataCent<true, false>(candidate, collision);`
	`373`	`+ processDataCent<true, true, false>(candidate, collision);`
`390`	`374`	`}`
`391`	`375`	`}`
`392`	`376`	`}`
`393`	`377`	`PROCESS_SWITCH(HfTaskXic0ToXiPi, processDataWithKFParticleFT0M, "process HfTaskXic0ToXiPi with KFParticle and with FT0M centrality", false);`
`394`	`378`
`395`	`379`	`void processDataWithDCAFitterMlFT0C(Xic0CandsMl const& candidates,`
`396`		`- CollisionsWithFT0C const& collisions)`
	`380`	`+ CollisionsWithFT0C const& collisions)`
`397`	`381`	`{`
`398`	`382`	`for (const auto& collision : collisions) {`
`399`	`383`	`auto thisCollId = collision.globalIndex();`
`400`	`384`	`auto groupedXicCandidates = candidates.sliceBy(candXicMlPerCollision, thisCollId);`
`401`	`385`	`for (const auto& candidate : groupedXicCandidates) {`
`402`		`- processDataCent<true, true>(candidate, collision);`
	`386`	`+ processDataCent<false, true, true>(candidate, collision);`
`403`	`387`	`}`
`404`		`- }`
	`388`	`+ }`
`405`	`389`	`}`
`406`	`390`	`PROCESS_SWITCH(HfTaskXic0ToXiPi, processDataWithDCAFitterMlFT0C, "process HfTaskXic0ToXiPi with DCAFitter and ML selections and with FT0C centrality", false);`
`407`		`-`
	`391`	`+`
`408`	`392`	`void processDataWithKFParticleMlFT0C(Xic0CandsMlKF const& candidates,`
`409`	`393`	`CollisionsWithFT0C const& collisions)`
`410`	`394`	`{`
`411`	`395`	`for (const auto& collision : collisions) {`
`412`	`396`	`auto thisCollId = collision.globalIndex();`
`413`	`397`	`auto groupedXicCandidates = candidates.sliceBy(candXicKFMlPerCollision, thisCollId);`
`414`	`398`	`for (const auto& candidate : groupedXicCandidates) {`
`415`		`- processDataCent<true, true>(candidate, collision);`
	`399`	`+ processDataCent<true, true, true>(candidate, collision);`
`416`	`400`	`}`
`417`		`- }`
	`401`	`+ }`
`418`	`402`	`}`
`419`	`403`	`PROCESS_SWITCH(HfTaskXic0ToXiPi, processDataWithKFParticleMlFT0C, "process HfTaskXic0ToXiPi with KFParticle and ML selections and with FT0C centrality", false);`
`420`	`404`
`421`	`405`	`void processDataWithDCAFitterMlFT0M(Xic0CandsMl const& candidates,`
`422`		`- CollisionsWithFT0M const& collisions)`
	`406`	`+ CollisionsWithFT0M const& collisions)`
`423`	`407`	`{`
`424`	`408`	`for (const auto& collision : collisions) {`
`425`	`409`	`auto thisCollId = collision.globalIndex();`
`426`	`410`	`auto groupedXicCandidates = candidates.sliceBy(candXicMlPerCollision, thisCollId);`
`427`	`411`	`for (const auto& candidate : groupedXicCandidates) {`
`428`		`- processDataCent<true, true>(candidate, collision);`
	`412`	`+ processDataCent<false, true, true>(candidate, collision);`
`429`	`413`	`}`
`430`		`- }`
	`414`	`+ }`
`431`	`415`	`}`
`432`	`416`	`PROCESS_SWITCH(HfTaskXic0ToXiPi, processDataWithDCAFitterMlFT0M, "process HfTaskXic0ToXiPi with DCAFitter and ML selections and with FT0M centrality", false);`
`433`	`417`
`@@ -438,19 +422,19 @@ struct HfTaskXic0ToXiPi {`
`438`	`422`	`auto thisCollId = collision.globalIndex();`
`439`	`423`	`auto groupedXicCandidates = candidates.sliceBy(candXicKFMlPerCollision, thisCollId);`
`440`	`424`	`for (const auto& candidate : groupedXicCandidates) {`
`441`		`- processDataCent<true, true>(candidate, collision);`
	`425`	`+ processDataCent<true, true, true>(candidate, collision);`
`442`	`426`	`}`
`443`		`- }`
	`427`	`+ }`
`444`	`428`	`}`
`445`	`429`	`PROCESS_SWITCH(HfTaskXic0ToXiPi, processDataWithKFParticleMlFT0M, "process HfTaskXic0ToXiPi with KFParticle and ML selections and with FT0M centrality", false);`
`446`	`430`
`447`	`431`	`void processMcWithDCAFitter(Xic0CandsMc const& Xic0CandidatesMc,`
`448`		`- Xic0Gen const& mcParticles,`
`449`		`- TracksMc const& tracks,`
`450`		`- CollisionsWithMcLabels const& collisions,`
`451`		`- aod::McCollisions const& mcCollisions)`
	`432`	`+ Xic0Gen const& mcParticles,`
	`433`	`+ TracksMc const& tracks,`
	`434`	`+ CollisionsWithMcLabels const& collisions,`
	`435`	`+ aod::McCollisions const& mcCollisions)`
`452`	`436`	`{`
`453`		`- processMc<false>(Xic0CandidatesMc, mcParticles, tracks, collisions, mcCollisions);`
	`437`	`+ processMc<false, false>(Xic0CandidatesMc, mcParticles, tracks, collisions, mcCollisions);`
`454`	`438`	`}`
`455`	`439`	`PROCESS_SWITCH(HfTaskXic0ToXiPi, processMcWithDCAFitter, "Process MC with KFParticle", false);`
`456`	`440`
`@@ -460,17 +444,17 @@ struct HfTaskXic0ToXiPi {`
`460`	`444`	`CollisionsWithMcLabels const& collisions,`
`461`	`445`	`aod::McCollisions const& mcCollisions)`
`462`	`446`	`{`
`463`		`- processMc<false>(Xic0CandidatesMcKF, mcParticles, tracks, collisions, mcCollisions);`
	`447`	`+ processMc<true, false>(Xic0CandidatesMcKF, mcParticles, tracks, collisions, mcCollisions);`
`464`	`448`	`}`
`465`	`449`	`PROCESS_SWITCH(HfTaskXic0ToXiPi, processMcWithKFParticle, "Process MC with KFParticle", false);`
`466`	`450`
`467`	`451`	`void processMcWithDCAFitterMl(Xic0CandsMlMc const& Xic0CandidatesMlMc,`
`468`		`- Xic0Gen const& mcParticles,`
`469`		`- TracksMc const& tracks,`
`470`		`- CollisionsWithMcLabels const& collisions,`
`471`		`- aod::McCollisions const& mcCollisions)`
	`452`	`+ Xic0Gen const& mcParticles,`
	`453`	`+ TracksMc const& tracks,`
	`454`	`+ CollisionsWithMcLabels const& collisions,`
	`455`	`+ aod::McCollisions const& mcCollisions)`
`472`	`456`	`{`
`473`		`- processMc<true>(Xic0CandidatesMlMc, mcParticles, tracks, collisions, mcCollisions);`
	`457`	`+ processMc<false, true>(Xic0CandidatesMlMc, mcParticles, tracks, collisions, mcCollisions);`
`474`	`458`	`}`
`475`	`459`	`PROCESS_SWITCH(HfTaskXic0ToXiPi, processMcWithDCAFitterMl, "Process MC with KFParticle and ML selections", false);`
`476`	`460`
`@@ -480,7 +464,7 @@ struct HfTaskXic0ToXiPi {`
`480`	`464`	`CollisionsWithMcLabels const& collisions,`
`481`	`465`	`aod::McCollisions const& mcCollisions)`
`482`	`466`	`{`
`483`		`- processMc<true>(Xic0CandidatesMlMcKF, mcParticles, tracks, collisions, mcCollisions);`
	`467`	`+ processMc<true, true>(Xic0CandidatesMlMcKF, mcParticles, tracks, collisions, mcCollisions);`
`484`	`468`	`}`
`485`	`469`	`PROCESS_SWITCH(HfTaskXic0ToXiPi, processMcWithKFParticleMl, "Process MC with KFParticle and ML selections", false);`
`486`	`470`	`};`