Skip to content

[PWGLF] K*(892)0 PbPb analysis update #15303

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
murioni wants to merge 4 commits into
base: master
Choose a base branch
from
+62 −25
Open

[PWGLF] K*(892)0 PbPb analysis update #15303

Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
4dafc11
adding TOF and TPC circular cut
murioni Mar 6, 2026
7652df0
adding like-sign process function
murioni Mar 7, 2026
efce97c
removing unused variable
murioni Mar 9, 2026
73737ce
run clang-format
murioni Mar 9, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
87 changes: 62 additions & 25 deletions PWGLF/Tasks/Resonances/k892analysispbpb.cxx
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -114,6 +114,7 @@ struct K892analysispbpb {
Configurable<bool> cTPClowpt{"cTPClowpt", true, "apply TPC at low pt"};
Configurable<bool> cTOFonlyHighpt{"cTOFonlyHighpt", false, "apply TOF only at high pt"};
Configurable<bool> cTOFandTPCHighpt{"cTOFandTPCHighpt", false, "apply TOF and TPC at high pt"};
Configurable<bool> circularCut{"circularCut", false, "apply TOF and TPC circular cut (applied only if cTOFandTPCHighpt is true)"};

// rotational bkg
Configurable<int> cfgNoRotations{"cfgNoRotations", 3, "Number of rotations per pair for rotbkg"};
Expand Down Expand Up @@ -409,10 +410,16 @@ struct K892analysispbpb {

} else if (cTOFandTPCHighpt) {

if (candidate.hasTOF() && std::abs(candidate.tofNSigmaKa()) <= cMaxTOFnSigmaKaon && candidate.hasTPC() && std::abs(candidate.tpcNSigmaKa()) <= cMaxTPCnSigmaKaon) { // tof and tpc cut
return true;
}
if (circularCut) {

if (candidate.hasTOF() && candidate.hasTPC() && std::sqrt(std::pow(candidate.tpcNSigmaKa(), 2) + std::pow(candidate.tofNSigmaKa(), 2)) <= cMaxTPCnSigmaKaon) // tof and tpc circular cut
return true;

} else {

if (candidate.hasTOF() && std::abs(candidate.tofNSigmaKa()) <= cMaxTOFnSigmaKaon && candidate.hasTPC() && std::abs(candidate.tpcNSigmaKa()) <= cMaxTPCnSigmaKaon) // tof and tpc cut
return true;
}
} else {

if (candidate.hasTPC() && std::abs(candidate.tpcNSigmaKa()) <= cMaxTPCnSigmaKaon) { // tpc cut, tof when available
Expand Down Expand Up @@ -447,8 +454,15 @@ struct K892analysispbpb {

} else if (cTOFandTPCHighpt) {

if (candidate.hasTOF() && std::abs(candidate.tofNSigmaPi()) <= cMaxTOFnSigmaPion && candidate.hasTPC() && std::abs(candidate.tpcNSigmaPi()) <= cMaxTPCnSigmaPion) { // tof and tpc cut
return true;
if (circularCut) {

if (candidate.hasTOF() && candidate.hasTPC() && std::sqrt(std::pow(candidate.tpcNSigmaPi(), 2) + std::pow(candidate.tofNSigmaPi(), 2)) <= cMaxTPCnSigmaPion) // tof and tpc circular cut
return true;

} else {

if (candidate.hasTOF() && std::abs(candidate.tofNSigmaPi()) <= cMaxTOFnSigmaPion && candidate.hasTPC() && std::abs(candidate.tpcNSigmaPi()) <= cMaxTPCnSigmaPion) // tof and tpc cut
return true;
}

} else {
Expand Down Expand Up @@ -838,47 +852,59 @@ struct K892analysispbpb {

Preslice<aod::Tracks> trackPerCollision = aod::track::collisionId;

template <bool IsMC, bool IsMix, bool IsRot, bool IsRun2, typename CollisionType, typename TracksType>
template <bool IsMC, bool IsMix, bool IsRot, bool IsRun2, bool isLikeSig, typename CollisionType, typename TracksType>
void callFillHistoswithPartitions(const CollisionType& collision1, const TracksType&, const CollisionType& collision2, const TracksType&)
{
if (cTPClowpt) {
//+-
auto candPosPitpc = posPitpc->sliceByCached(aod::track::collisionId, collision1.globalIndex(), cache);
auto candNegKatpc = negKatpc->sliceByCached(aod::track::collisionId, collision2.globalIndex(), cache);

fillHistograms<IsMC, IsMix, IsRot, IsRun2>(collision1, candPosPitpc, candNegKatpc);

//-+
auto candNegPitpc = negPitpc->sliceByCached(aod::track::collisionId, collision1.globalIndex(), cache);
auto candPosKatpc = posKatpc->sliceByCached(aod::track::collisionId, collision2.globalIndex(), cache);

fillHistograms<IsMC, IsMix, IsRot, IsRun2>(collision1, candNegPitpc, candPosKatpc);
if constexpr (!isLikeSig) {
fillHistograms<IsMC, IsMix, IsRot, IsRun2>(collision1, candPosPitpc, candNegKatpc);
fillHistograms<IsMC, IsMix, IsRot, IsRun2>(collision1, candNegPitpc, candPosKatpc);
} else {
fillHistograms<IsMC, IsMix, IsRot, IsRun2>(collision1, candPosPitpc, candPosKatpc);
fillHistograms<IsMC, IsMix, IsRot, IsRun2>(collision1, candNegPitpc, candNegKatpc);
}

} else if (cTOFandTPCHighpt) {
//+-
auto candPosPitoftpc = posPitoftpc->sliceByCached(aod::track::collisionId, collision1.globalIndex(), cache);
auto candNegKatoftpc = negKatoftpc->sliceByCached(aod::track::collisionId, collision2.globalIndex(), cache);

fillHistograms<IsMC, IsMix, IsRot, IsRun2>(collision1, candPosPitoftpc, candNegKatoftpc);

//-+
auto candNegPitoftpc = negPitoftpc->sliceByCached(aod::track::collisionId, collision1.globalIndex(), cache);
auto candPosKatoftpc = posKatoftpc->sliceByCached(aod::track::collisionId, collision2.globalIndex(), cache);

fillHistograms<IsMC, IsMix, IsRot, IsRun2>(collision1, candNegPitoftpc, candPosKatoftpc);
if constexpr (!isLikeSig) {
fillHistograms<IsMC, IsMix, IsRot, IsRun2>(collision1, candPosPitoftpc, candNegKatoftpc);
fillHistograms<IsMC, IsMix, IsRot, IsRun2>(collision1, candNegPitoftpc, candPosKatoftpc);
} else {
fillHistograms<IsMC, IsMix, IsRot, IsRun2>(collision1, candPosPitoftpc, candPosKatoftpc);
fillHistograms<IsMC, IsMix, IsRot, IsRun2>(collision1, candNegPitoftpc, candNegKatoftpc);
}

} else if (cTOFonlyHighpt) {
//+-
auto candPosPitof = posPitof->sliceByCached(aod::track::collisionId, collision1.globalIndex(), cache);
auto candNegKatof = negKatof->sliceByCached(aod::track::collisionId, collision2.globalIndex(), cache);

fillHistograms<IsMC, IsMix, IsRot, IsRun2>(collision1, candPosPitof, candNegKatof);

//-+
auto candNegPitof = negPitof->sliceByCached(aod::track::collisionId, collision1.globalIndex(), cache);
auto candPosKatof = posKatof->sliceByCached(aod::track::collisionId, collision2.globalIndex(), cache);

fillHistograms<IsMC, IsMix, IsRot, IsRun2>(collision1, candNegPitof, candPosKatof);
if constexpr (!isLikeSig) {
fillHistograms<IsMC, IsMix, IsRot, IsRun2>(collision1, candPosPitof, candNegKatof);
fillHistograms<IsMC, IsMix, IsRot, IsRun2>(collision1, candNegPitof, candPosKatof);
} else {
fillHistograms<IsMC, IsMix, IsRot, IsRun2>(collision1, candPosPitof, candPosKatof);
fillHistograms<IsMC, IsMix, IsRot, IsRun2>(collision1, candNegPitof, candNegKatof);
}
}
}

Expand All @@ -898,8 +924,8 @@ struct K892analysispbpb {
histos.fill(HIST("TestME/hCollisionIndexSameE"), collision.globalIndex());
histos.fill(HIST("TestME/hnTrksSameE"), tracks.size());
}
// <IsMC, IsMix, IsRot, IsRun2>
callFillHistoswithPartitions<false, false, false, false>(collision, tracks, collision, tracks);
// <IsMC, IsMix, IsRot, IsRun2, isLikeSig>
callFillHistoswithPartitions<false, false, false, false, false>(collision, tracks, collision, tracks);
}
PROCESS_SWITCH(K892analysispbpb, processSameEvent, "Process Same event", true);

Expand All @@ -918,8 +944,8 @@ struct K892analysispbpb {
histos.fill(HIST("TestME/hnTrksSameE"), tracks.size());
}

// <IsMC, IsMix, IsRot, IsRun2>
callFillHistoswithPartitions<false, false, false, true>(collision, tracks, collision, tracks);
// <IsMC, IsMix, IsRot, IsRun2, isLikeSig>
callFillHistoswithPartitions<false, false, false, true, false>(collision, tracks, collision, tracks);
}
PROCESS_SWITCH(K892analysispbpb, processSameEventRun2, "Process Same event Run2", false);

Expand All @@ -929,8 +955,8 @@ struct K892analysispbpb {
if (!myEventSelections(collision))
return;

// <IsMC, IsMix, IsRot, IsRun2>
callFillHistoswithPartitions<false, false, true, false>(collision, tracks, collision, tracks);
// <IsMC, IsMix, IsRot, IsRun2, isLikeSig>
callFillHistoswithPartitions<false, false, true, false, false>(collision, tracks, collision, tracks);
}
PROCESS_SWITCH(K892analysispbpb, processRotationalBkg, "Process Rotational Background", false);

Expand All @@ -945,6 +971,17 @@ struct K892analysispbpb {
}
PROCESS_SWITCH(K892analysispbpb, processRotationalBkgMC, "Process Rotational Background MC", false);

void processLikeSign(EventCandidates::iterator const& collision, TrackCandidates const& tracks, aod::BCs const&)
{

if (!myEventSelections(collision))
return;

// <IsMC, IsMix, IsRot, IsRun2, isLikeSig>
callFillHistoswithPartitions<false, false, false, false, true>(collision, tracks, collision, tracks);
}
PROCESS_SWITCH(K892analysispbpb, processLikeSign, "Process Like Sign", false);

void processMixedEvent(EventCandidates const& collisions, TrackCandidates const& tracks)
{
auto tracksTuple = std::make_tuple(tracks);
Expand All @@ -966,8 +1003,8 @@ struct K892analysispbpb {
histos.fill(HIST("TestME/hnTrksMixedE"), tracks1.size());
}

// <IsMC, IsMix, IsRot, IsRun2>
callFillHistoswithPartitions<false, true, false, false>(collision1, tracks1, collision2, tracks2);
// <IsMC, IsMix, IsRot, IsRun2, isLikeSig>
callFillHistoswithPartitions<false, true, false, false, false>(collision1, tracks1, collision2, tracks2);
}
}
PROCESS_SWITCH(K892analysispbpb, processMixedEvent, "Process Mixed event", true);
Expand All @@ -991,8 +1028,8 @@ struct K892analysispbpb {
histos.fill(HIST("TestME/hnTrksMixedE"), tracks1.size());
}

// <IsMC, IsMix, IsRot, IsRun2>
callFillHistoswithPartitions<false, true, false, true>(collision1, tracks1, collision2, tracks2);
// <IsMC, IsMix, IsRot, IsRun2, isLikeSig>
callFillHistoswithPartitions<false, true, false, true, false>(collision1, tracks1, collision2, tracks2);
}
}
PROCESS_SWITCH(K892analysispbpb, processMixedEventRun2, "Process Mixed event Run2", false);
Expand Down
Loading