From 61c672acef296646ce7a6090a7b7b8942ebd3c21 Mon Sep 17 00:00:00 2001 From: jimun_lee Date: Wed, 5 Nov 2025 20:59:23 +0900 Subject: [PATCH 1/5] [PWGLF] Added the TOF switch of KstarInOO.cxx --- PWGLF/Tasks/Resonances/kstarInOO.cxx | 150 ++++++++++++++++----------- 1 file changed, 91 insertions(+), 59 deletions(-) diff --git a/PWGLF/Tasks/Resonances/kstarInOO.cxx b/PWGLF/Tasks/Resonances/kstarInOO.cxx index 17ba713c086..64edb8f43a7 100644 --- a/PWGLF/Tasks/Resonances/kstarInOO.cxx +++ b/PWGLF/Tasks/Resonances/kstarInOO.cxx @@ -66,7 +66,10 @@ struct kstarInOO { // Event Selection Configurable cfgEventVtxCut{"cfgEventVtxCut", 10.0, "V_z cut selection"}; - ConfigurableAxis cfgCentAxis{"cfgCentAxis", {VARIABLE_WIDTH, 0.0, 1.0, 5.0, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0, 110.0}, "Binning of the centrality axis"}; + ConfigurableAxis cfgCentAxis{"cfgCentAxis", {VARIABLE_WIDTH, 0.0, 1.0, 5.0, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0}, "Binning of the centrality axis"}; + Configurable cfgOccupancySel{"cfgOccupancySel", false, "Occupancy selection"}; + Configurable cfgOccupancyMax{"cfgOccupancyMax", 999999, "maximum occupancy of tracks in neighbouring collisions in a given time range"}; + Configurable cfgOccupancyMin{"cfgOccupancyMin", -100, "minimum occupancy of tracks in neighbouring collisions in a given time range"}; // Track Selection // General @@ -90,6 +93,11 @@ struct kstarInOO { // PID Configurable cfgTrackTPCPID{"cfgTrackTPCPID", true, "Enables TPC PID"}; Configurable cfgTrackTOFPID{"cfgTrackTOFPID", true, "Enables TOF PID"}; + Configurable cfgTrackSquarePIDCut{"cfgTrackSqurePIDCut", true, "Enables PID cut shape square switch"}; + Configurable cfgTrackCirclePIDCut{"cfgTrackCirclePIDCut", true, "Enables PID cut shape circle switch"}; + Configurable cfgTrackCircleValue{"cfgTrackCircleValue", 2, "Enables TOF TPC PID circle cut value"}; + Configurable cfgTrackTOFHard{"cfgTrackTOFHard", false, "Enables TOF Hard"}; + Configurable cfgTrackTPCPIDnSig{"cfgTrackTPCPIDnSig", 4.0, "nTPC PID sigma"}; Configurable cfgTrackTOFPIDnSig{"cfgTrackTOFPIDnSig", 4.0, "nTOF PID sigma"}; Configurable cDebugLevel{"cDebugLevel", 0, "Resolution of Debug"}; @@ -98,6 +106,7 @@ struct kstarInOO { ConfigurableAxis cfgBinsMixMult{"cfgBinsCent", {VARIABLE_WIDTH, 0.0, 1.0, 5.0, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0, 110.0}, "Binning of the centrality axis"}; ConfigurableAxis cfgBinsMixVtx{"cfgBinsMixVtx", {VARIABLE_WIDTH, -10.0f, -5.f, 0.f, 5.f, 10.f}, "Mixing bins - z-vertex"}; Configurable cfgMixNMixedEvents{"cfgMixNMixedEvents", 10, "Number of mixed events per event"}; + Configurable cfgVtxMixCut{"cfgVtxMixCut", 10, "Vertex Mix Cut"}; // MCGen Configurable cfgForceGenReco{"cfgForceGenReco", false, "Only consider events which are reconstructed (neglect event-loss)"}; @@ -181,14 +190,8 @@ struct kstarInOO { } if (cfgMcHistos) { - histos.add("hPion_PID_Purity", "hPion_PID_Purity", kTH1F, {{3, -1.5, 1.5}}); - histos.add("hKaon_PID_Purity", "hKaon_PID_Purity", kTH1F, {{3, -1.5, 1.5}}); - histos.add("hSimplePion_PID_Purity", "hSimplePion_PID_Purity", kTH1F, {{3, -1.5, 1.5}}); - histos.add("hSimpleKaon_PID_Purity", "hSimpleKaon_PID_Purity", kTH1F, {{3, -1.5, 1.5}}); - histos.add("nEvents_MC", "nEvents_MC", kTH1F, {{4, 0.0, 4.0}}); histos.add("nEvents_MC_True", "nEvents_MC_True", kTH1F, {{4, 0.0, 4.0}}); - histos.add("hMC_kstar_True", "hMC_kstar_True", kTHnSparseF, {cfgCentAxis, ptAxis}); histos.add("hMC_USS_True", "hMC_USS_True", kTHnSparseF, {cfgCentAxis, ptAxis, minvAxis}); @@ -248,6 +251,10 @@ struct kstarInOO { return false; if (!event.selection_bit(aod::evsel::kNoCollInTimeRangeStandard)) return false; + if (!event.selection_bit(o2::aod::evsel::kIsGoodITSLayersAll)) + return false; + if (cfgOccupancySel && (event.trackOccupancyInTimeRange() > cfgOccupancyMax || event.trackOccupancyInTimeRange() < cfgOccupancyMin)) + return false; if (cfgEventCutQA) { histos.fill(HIST("hPosZ_AC"), event.posZ()); @@ -322,19 +329,42 @@ struct kstarInOO { histos.fill(HIST("QA_nSigma_kaon_TOF_BC"), candidate.pt(), candidate.tofNSigmaKa()); histos.fill(HIST("QA_kaon_TPC_TOF_BC"), candidate.tpcNSigmaKa(), candidate.tofNSigmaKa()); } - + double tpcpid = 0; + double tofpid = 0; bool tpcPIDPassed{false}, tofPIDPassed{false}; // TPC - if (std::abs(candidate.tpcNSigmaKa()) < cfgTrackTPCPIDnSig) - tpcPIDPassed = true; - // TOF - if (candidate.hasTOF()) { - if (std::abs(candidate.tofNSigmaKa()) < cfgTrackTOFPIDnSig) { + if (cfgTrackSquarePIDCut) { + if (std::abs(candidate.tpcNSigmaKa()) < cfgTrackTPCPIDnSig) + tpcPIDPassed = true; + if (candidate.hasTOF()) { + if (std::abs(candidate.tofNSigmaKa()) < cfgTrackTOFPIDnSig) { + tofPIDPassed = true; + } + } else { + if (!cfgTrackTOFHard) { + tofPIDPassed = true; + } else { + tofPIDPassed = false; + } + } + } // end of square cut + if (cfgTrackCirclePIDCut) { + if (std::abs(candidate.tpcNSigmaKa()) < cfgTrackTPCPIDnSig) + tpcpid = std::abs(candidate.tpcNSigmaKa()); + tofpid = 0; + + if (candidate.hasTOF()) { + tofpid = std::abs(candidate.tofNSigmaKa()); + } else { + if (cfgTrackTOFHard) { + tofpid = 999; + } + } + if (std::sqrt(tpcpid * tpcpid + tofpid * tofpid) < cfgTrackCircleValue) { + tpcPIDPassed = true; tofPIDPassed = true; } - } else { - tofPIDPassed = true; - } + } // circular cut // TPC & TOF if (tpcPIDPassed && tofPIDPassed) { if (cfgTrackCutQA && QA) { @@ -355,18 +385,44 @@ struct kstarInOO { histos.fill(HIST("QA_nSigma_pion_TOF_BC"), candidate.pt(), candidate.tofNSigmaPi()); histos.fill(HIST("QA_pion_TPC_TOF_BC"), candidate.tpcNSigmaPi(), candidate.tofNSigmaPi()); } + double tpcpid = 0; + double tofpid = 0; bool tpcPIDPassed{false}, tofPIDPassed{false}; // TPC - if (std::abs(candidate.tpcNSigmaPi()) < cfgTrackTPCPIDnSig) - tpcPIDPassed = true; - if (candidate.hasTOF()) { - if (std::abs(candidate.tofNSigmaPi()) < cfgTrackTOFPIDnSig) { + if (cfgTrackSquarePIDCut) { + if (std::abs(candidate.tpcNSigmaPi()) < cfgTrackTPCPIDnSig) + tpcPIDPassed = true; + if (candidate.hasTOF()) { + if (std::abs(candidate.tofNSigmaPi()) < cfgTrackTOFPIDnSig) { + tofPIDPassed = true; + } + } else { + if (!cfgTrackTOFHard) { + tofPIDPassed = true; + } else { + tofPIDPassed = false; + } + } + } // end of square cut + if (cfgTrackCirclePIDCut) { + if (std::abs(candidate.tpcNSigmaPi()) < cfgTrackTPCPIDnSig) + tpcpid = std::abs(candidate.tpcNSigmaPi()); + tofpid = 0; + + if (candidate.hasTOF()) { + tofpid = std::abs(candidate.tofNSigmaPi()); + } else { + if (cfgTrackTOFHard) { + tofpid = 999; + } + } + if (std::sqrt(tpcpid * tpcpid + tofpid * tofpid) < cfgTrackCircleValue) { + tpcPIDPassed = true; tofPIDPassed = true; } - } else { - tofPIDPassed = true; - } - // TPC & TOF + } // circular cut + + // TPC & TOF if (tpcPIDPassed && tofPIDPassed) { if (cfgTrackCutQA && QA) { histos.fill(HIST("QA_nSigma_pion_TPC_AC"), candidate.pt(), candidate.tpcNSigmaPi()); @@ -421,8 +477,6 @@ struct kstarInOO { auto centrality = collision1.centFT0C(); std::vector mcMemory; - std::vector PIDPurityKey_Kaon; - std::vector PIDPurityKey_Pion; for (const auto& [trk1, trk2] : combinations(o2::soa::CombinationsFullIndexPolicy(tracks1, tracks2))) { if (!trk1.has_mcParticle() || !trk2.has_mcParticle()) @@ -544,9 +598,6 @@ struct kstarInOO { if (!trackPIDKaon(trk1, QA) || !trackPIDPion(trk2, QA)) return {-1.0, -1.0}; - // if (trk1.index() >= trk2.index()) - // return {-1.0, -1.0}; - // I checked that index and globalIndex was same function if (trk1.globalIndex() >= trk2.globalIndex()) return {-1.0, -1.0}; @@ -626,9 +677,20 @@ struct kstarInOO { } auto goodEv1 = eventSelection(collision1); auto goodEv2 = eventSelection(collision2); + bool VtxMixFlag = false; + bool CentMixFlag = false; + // bool OccupanacyMixFlag = false; + if (std::fabs(collision1.posZ() - collision2.posZ()) <= cfgVtxMixCut) // set default to maybe 10 + VtxMixFlag = true; + if (std::fabs(collision1.centFT0C() - collision2.centFT0C()) <= cfgVtxMixCut) // set default to maybe 10 + CentMixFlag = true; if (!goodEv1 || !goodEv2) continue; + if (!CentMixFlag) + continue; + if (!VtxMixFlag) + continue; TrackSlicing(collision1, tracks1, collision2, tracks2, true, false); } @@ -669,36 +731,6 @@ struct kstarInOO { if (!INELgt0) return; - auto tracks1 = kaonMC->sliceByCached(aod::track::collisionId, collision.globalIndex(), cache); - for (const auto& kaon : tracks1) { - if (!trackSelection(kaon, false)) - continue; - if (!trackPIDKaon(kaon, false)) - continue; - auto particle1 = kaon.mcParticle(); - if (std::fabs(particle1.pdgCode()) == 321) - histos.fill(HIST("hSimpleKaon_PID_Purity"), 1); // histogram with two bins, -1.5, 1.5 fill 1 or -1 - else if (std::fabs(particle1.pdgCode()) == 211) - histos.fill(HIST("hSimpleKaon_PID_Purity"), -1); // histogram with two bins, -1.5, 1.5 fill 1 or -1 - else - histos.fill(HIST("hSimpleKaon_PID_Purity"), 0); // histogram with two bins, -1.5, 1.5 fill 1 or -1 - } - - auto tracks2 = pionMC->sliceByCached(aod::track::collisionId, collision.globalIndex(), cache); - for (const auto& pion : tracks2) { - if (!trackSelection(pion, false)) - continue; - if (!trackPIDPion(pion, false)) - continue; - auto particle2 = pion.mcParticle(); - if (std::fabs(particle2.pdgCode()) == 211) - histos.fill(HIST("hSimplePion_PID_Purity"), 1); // histogram with two bins, -1.5, 1.5 fill 1 or -1 - else if (std::fabs(particle2.pdgCode()) == 321) - histos.fill(HIST("hSimplePion_PID_Purity"), -1); // histogram with two bins, -1.5, 1.5 fill 1 or -1 - else - histos.fill(HIST("hSimplePion_PID_Purity"), 0); // histogram with two bins, -1.5, 1.5 fill 1 or -1 - } - if (cfgMcHistos) { histos.fill(HIST("nEvents_MC"), 1.5); } From 726d76e9a8c8c7c11ca75c246fd705105a3242e3 Mon Sep 17 00:00:00 2001 From: jimun_lee Date: Mon, 10 Nov 2025 15:56:57 +0900 Subject: [PATCH 2/5] [PWGLF] Fixed the TOF cutting shape of KstarInOO.cxx --- PWGLF/Tasks/Resonances/kstarInOO.cxx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/PWGLF/Tasks/Resonances/kstarInOO.cxx b/PWGLF/Tasks/Resonances/kstarInOO.cxx index 64edb8f43a7..2d936857bd5 100644 --- a/PWGLF/Tasks/Resonances/kstarInOO.cxx +++ b/PWGLF/Tasks/Resonances/kstarInOO.cxx @@ -360,7 +360,7 @@ struct kstarInOO { tofpid = 999; } } - if (std::sqrt(tpcpid * tpcpid + tofpid * tofpid) < cfgTrackCircleValue) { + if (tpcpid * tpcpid + tofpid * tofpid < cfgTrackCircleValue) { tpcPIDPassed = true; tofPIDPassed = true; } @@ -416,7 +416,7 @@ struct kstarInOO { tofpid = 999; } } - if (std::sqrt(tpcpid * tpcpid + tofpid * tofpid) < cfgTrackCircleValue) { + if (tpcpid * tpcpid + tofpid * tofpid < cfgTrackCircleValue) { tpcPIDPassed = true; tofPIDPassed = true; } From 859be45a2fbdff2c039d11a7d28e2d42463a0ac5 Mon Sep 17 00:00:00 2001 From: jimun_lee Date: Mon, 10 Nov 2025 18:17:21 +0900 Subject: [PATCH 3/5] [PWGLF] Fixed the TOF cutting shape of KstarInOO.cxx --- PWGLF/Tasks/Resonances/kstarInOO.cxx | 52 ++++++++++++++++++++++++++-- 1 file changed, 49 insertions(+), 3 deletions(-) diff --git a/PWGLF/Tasks/Resonances/kstarInOO.cxx b/PWGLF/Tasks/Resonances/kstarInOO.cxx index 2d936857bd5..69f9f3e62b2 100644 --- a/PWGLF/Tasks/Resonances/kstarInOO.cxx +++ b/PWGLF/Tasks/Resonances/kstarInOO.cxx @@ -68,8 +68,8 @@ struct kstarInOO { Configurable cfgEventVtxCut{"cfgEventVtxCut", 10.0, "V_z cut selection"}; ConfigurableAxis cfgCentAxis{"cfgCentAxis", {VARIABLE_WIDTH, 0.0, 1.0, 5.0, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0}, "Binning of the centrality axis"}; Configurable cfgOccupancySel{"cfgOccupancySel", false, "Occupancy selection"}; - Configurable cfgOccupancyMax{"cfgOccupancyMax", 999999, "maximum occupancy of tracks in neighbouring collisions in a given time range"}; - Configurable cfgOccupancyMin{"cfgOccupancyMin", -100, "minimum occupancy of tracks in neighbouring collisions in a given time range"}; + Configurable cfgOccupancyMax{"cfgOccupancyMax", 999999., "maximum occupancy of tracks in neighbouring collisions in a given time range"}; + Configurable cfgOccupancyMin{"cfgOccupancyMin", -100., "minimum occupancy of tracks in neighbouring collisions in a given time range"}; // Track Selection // General @@ -137,6 +137,7 @@ struct kstarInOO { const AxisSpec axisDCAxy{binsDCAxy, "DCA_{XY}"}; if (cfgEventCutQA) { + histos.add("hEvent_Cut", "Number of event after cuts", kTH1D, {{12, 0, 12}}); histos.add("hPosZ_BC", "hPosZ_Bc", kTH1F, {{300, -15.0, 15.0}}); histos.add("hPosZ_AC", "hPosZ_AC", kTH1F, {{300, -15.0, 15.0}}); histos.add("hcentFT0C_BC", "centFT0C_BC", kTH1F, {{110, 0.0, 110.0}}); @@ -206,6 +207,24 @@ struct kstarInOO { histos.add("hMC_USS_KPi_True", "hMC_USS_KPi_True", kTHnSparseF, {cfgCentAxis, ptAxis, minvAxis}); histos.add("hMC_USS_PiK_True", "hMC_USS_PiK_True", kTHnSparseF, {cfgCentAxis, ptAxis, minvAxis}); } + + std::shared_ptr hCutFlow = histos.get(HIST("hEvent_Cut")); + std::vector eventCutLabels = { + "All Events", + "sel8", + Form("|Vz| < %.1f", cfgEventVtxCut.value), + "kIsGoodZvtxFT0vsPV", + "kNoSameBunchPileup", + "kNoTimeFrameBorder", + "kNoITSROFrameBorder", + "kNoCollInTimeRangeStandard", + "kIsGoodITSLayersAll", + Form("Occupancy < %.0f", cfgOccupancyMax.value), + "All passed events"}; + for (size_t i = 0; i < eventCutLabels.size(); ++i) { + hCutFlow->GetXaxis()->SetBinLabel(i + 1, eventCutLabels[i].c_str()); + } + } // end of init using EventCandidates = soa::Join; //, aod::CentFT0Ms, aod::CentFT0As @@ -234,29 +253,57 @@ struct kstarInOO { bool eventSelection(const EventType event) { if (cfgEventCutQA) { + histos.fill(HIST("hEvent_Cut"), 0); histos.fill(HIST("hPosZ_BC"), event.posZ()); histos.fill(HIST("hcentFT0C_BC"), event.centFT0C()); } if (!event.sel8()) return false; + if (cfgEventCutQA) + histos.fill(HIST("hEvent_Cut"), 1); + if (std::abs(event.posZ()) > cfgEventVtxCut) return false; + if (cfgEventCutQA) + histos.fill(HIST("hEvent_Cut"), 2); + if (!event.selection_bit(aod::evsel::kIsGoodZvtxFT0vsPV)) return false; + if (cfgEventCutQA) + histos.fill(HIST("hEvent_Cut"), 3); + if (!event.selection_bit(aod::evsel::kNoSameBunchPileup)) return false; + if (cfgEventCutQA) + histos.fill(HIST("hEvent_Cut"), 4); + if (!event.selection_bit(aod::evsel::kNoTimeFrameBorder)) return false; + if (cfgEventCutQA) + histos.fill(HIST("hEvent_Cut"), 5); + if (!event.selection_bit(aod::evsel::kNoITSROFrameBorder)) return false; + if (cfgEventCutQA) + histos.fill(HIST("hEvent_Cut"), 6); + if (!event.selection_bit(aod::evsel::kNoCollInTimeRangeStandard)) return false; + if (cfgEventCutQA) + histos.fill(HIST("hEvent_Cut"), 7); + if (!event.selection_bit(o2::aod::evsel::kIsGoodITSLayersAll)) return false; + if (cfgEventCutQA) + histos.fill(HIST("hEvent_Cut"), 8); + if (cfgOccupancySel && (event.trackOccupancyInTimeRange() > cfgOccupancyMax || event.trackOccupancyInTimeRange() < cfgOccupancyMin)) return false; + if (cfgEventCutQA) + histos.fill(HIST("hEvent_Cut"), 9); if (cfgEventCutQA) { + histos.fill(HIST("hEvent_Cut"), 10); histos.fill(HIST("hPosZ_AC"), event.posZ()); histos.fill(HIST("hcentFT0C_AC"), event.centFT0C()); } @@ -278,7 +325,6 @@ struct kstarInOO { histos.fill(HIST("hTPCChi2_BC"), track.tpcChi2NCl()); histos.fill(HIST("QA_track_pT_BC"), track.pt()); } - if (cfgTrackGlobalSel && !track.isGlobalTrack()) return false; if (track.pt() < cfgTrackMinPt) From c124dfdc0ee261aa71b9d7e840345197d0774ed1 Mon Sep 17 00:00:00 2001 From: jimun_lee Date: Mon, 10 Nov 2025 18:41:28 +0900 Subject: [PATCH 4/5] [PWGLF] Fixed the TOF cutting shape of KstarInOO.cxx --- PWGLF/Tasks/Resonances/kstarInOO.cxx | 1 + 1 file changed, 1 insertion(+) diff --git a/PWGLF/Tasks/Resonances/kstarInOO.cxx b/PWGLF/Tasks/Resonances/kstarInOO.cxx index 69f9f3e62b2..fe33aba7908 100644 --- a/PWGLF/Tasks/Resonances/kstarInOO.cxx +++ b/PWGLF/Tasks/Resonances/kstarInOO.cxx @@ -45,6 +45,7 @@ #include #include #include +#include #include #include #include From f4406afc02e2b340b9da972b38178fa82d8bd9cb Mon Sep 17 00:00:00 2001 From: jimun_lee Date: Tue, 20 Jan 2026 17:05:51 +0900 Subject: [PATCH 5/5] [PWGLF] Added the processJetData part of KstarInOO.cxx --- PWGLF/Tasks/Resonances/kstarInOO.cxx | 363 ++++++++++++++++++++++++++- 1 file changed, 352 insertions(+), 11 deletions(-) diff --git a/PWGLF/Tasks/Resonances/kstarInOO.cxx b/PWGLF/Tasks/Resonances/kstarInOO.cxx index 628e2a6fddb..f94d02d49d6 100644 --- a/PWGLF/Tasks/Resonances/kstarInOO.cxx +++ b/PWGLF/Tasks/Resonances/kstarInOO.cxx @@ -33,6 +33,14 @@ #include #include +// jet +#include "PWGJE/Core/JetDerivedDataUtilities.h" +#include "PWGJE/DataModel/EMCALClusters.h" +#include "PWGJE/DataModel/Jet.h" +#include "PWGJE/DataModel/JetReducedData.h" + +#include + #include #include #include @@ -67,6 +75,7 @@ struct kstarInOO { //================================== // Event Selection + Configurable cfgEventSelections{"cfgEventSelections", "sel8", "Set event selection"}; Configurable cfgEventVtxCut{"cfgEventVtxCut", 10.0, "V_z cut selection"}; ConfigurableAxis cfgCentAxis{"cfgCentAxis", {VARIABLE_WIDTH, 0.0, 1.0, 5.0, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0}, "Binning of the centrality axis"}; Configurable cfgOccupancySel{"cfgOccupancySel", false, "Occupancy selection"}; @@ -84,13 +93,13 @@ struct kstarInOO { Configurable cfgTrackConnectedToPV{"cfgTrackConnectedToPV", true, "PV contributor track selection"}; // PV Contriuibutor Configurable cfgTrackGlobalWoDCATrack{"cfgTrackGlobalWoDCATrack", true, "Global track selection without DCA"}; // kQualityTracks (kTrackType | kTPCNCls | kTPCCrossedRows | kTPCCrossedRowsOverNCls | kTPCChi2NDF | kTPCRefit | kITSNCls | kITSChi2NDF | kITSRefit | kITSHits) | kInAcceptanceTracks (kPtRange | kEtaRange) // TPC - Configurable cfgTracknFindableTPCClusters{"cfgTrackFindableTPCClusters", 50, "nFindable TPC Clusters"}; - Configurable cfgTracknTPCCrossedRows{"cfgTrackTPCCrossedRows", 70, "nCrossed TPC Rows"}; - Configurable cfgTracknRowsOverFindable{"cfgTrackRowsOverFindable", 1.2, "nRowsOverFindable TPC CLusters"}; - Configurable cfgTracknTPCChi2{"cfgTrackTPCChi2", 4.0, "nTPC Chi2 per Cluster"}; + Configurable cfgTrackFindableTPCClusters{"cfgTrackFindableTPCClusters", 50, "nFindable TPC Clusters"}; + Configurable cfgTrackTPCCrossedRows{"cfgTrackTPCCrossedRows", 70, "nCrossed TPC Rows"}; + Configurable cfgTrackRowsOverFindable{"cfgTrackRowsOverFindable", 1.2, "nRowsOverFindable TPC CLusters"}; + Configurable cfgTrackTPCChi2{"cfgTrackTPCChi2", 4.0, "nTPC Chi2 per Cluster"}; // ITS - Configurable cfgTracknITSChi2{"cfgTrackITSChi2", 36.0, "nITS Chi2 per Cluster"}; + Configurable cfgTrackITSChi2{"cfgTrackITSChi2", 36.0, "nITS Chi2 per Cluster"}; // PID Configurable cfgTrackTPCPID{"cfgTrackTPCPID", true, "Enables TPC PID"}; @@ -123,9 +132,34 @@ struct kstarInOO { ConfigurableAxis binsDCAxy{"binsDCAxy", {40, -0.2, 0.2}, ""}; Configurable cfgEventCutQA{"cfgEventCutsQA", false, "Enable Event QA Hists"}; Configurable cfgTrackCutQA{"cfgTrackCutQA", false, "Enable Track QA Hists"}; + Configurable cfgJetQAHistos{"cfgJetQAHistos", false, "Enable Jet QA Histos"}; + Configurable cfgDataHistos{"cfgDataHistos", false, "Enable Data Hists"}; Configurable cfgMcHistos{"cfgMcHistos", false, "Enable MC Hists"}; + Configurable cfgJetDataHistos{"cfgJetDataHistos", false, "Enable Jet Data Histos"}; + Configurable cfgJetMCHistos{"cfgJetMCHistos", false, "Enable Jet MC Histos"}; + Configurable cfgCutonTrig{"cfgCutonTrig", false, "Enable Jet Cut on Trig"}; + Configurable cfgTestTriggers{"cfgTestTriggers", false, "Enable Jet Test Triggers"}; + + //====================== + //|| + //|| JET + //|| + //====================== + Configurable cfgJetpT{"cfgJetpT", 5.0, "Set Jet pT minimum"}; + Configurable cfgJetR{"cfgJetR", 0.4, "Set Jet radius parameter"}; + Configurable cfgSingleJet{"cfgSingleJet", false, "Enforces strict phi-jet correspondance"}; + Configurable cfgRealTriggerMasks{"cfgRealTriggerMasks", "", "possible JE Trigger masks: fJetChLowPt,fJetChHighPt,fTrackLowPt,fTrackHighPt,fJetD0ChLowPt,fJetD0ChHighPt,fJetLcChLowPt,fJetLcChHighPt,fEMCALReadout,fJetFullHighPt,fJetFullLowPt,fJetNeutralHighPt,fJetNeutralLowPt,fGammaVeryHighPtEMCAL,fGammaVeryHighPtDCAL,fGammaHighPtEMCAL,fGammaHighPtDCAL,fGammaLowPtEMCAL,fGammaLowPtDCAL,fGammaVeryLowPtEMCAL,fGammaVeryLowPtDCAL"}; + Configurable cfgTriggerMasksTest1{"cfgTriggerMasksTest1", "", "possible JE Trigger masks Test1"}; + Configurable cfgTriggerMasksTest2{"cfgTriggerMasksTest2", "", "possible JE Trigger masks Test2"}; + Configurable cfgTriggerMasksTest3{"cfgTriggerMasksTest3", "", "possible JE Trigger masks Test3"}; + + std::vector eventSelectionBits; + std::vector RealTriggerMaskBits; + std::vector triggerMaskBitsTest1; + std::vector triggerMaskBitsTest2; + std::vector triggerMaskBitsTest3; // Main void init(o2::framework::InitContext&) { @@ -137,10 +171,11 @@ struct kstarInOO { const AxisSpec minvAxis = {cfgMinvNBins, cfgMinvMin, cfgMinvMax}; const AxisSpec axisDCAz{binsDCAz, "DCA_{z}"}; const AxisSpec axisDCAxy{binsDCAxy, "DCA_{XY}"}; + const AxisSpec dRAxis = {100, 0, 100}; if (cfgEventCutQA) { histos.add("hEvent_Cut", "Number of event after cuts", kTH1D, {{12, 0, 12}}); - histos.add("hPosZ_BC", "hPosZ_Bc", kTH1F, {{300, -15.0, 15.0}}); + histos.add("hPosZ_BC", "hPosZ_BC", kTH1F, {{300, -15.0, 15.0}}); histos.add("hPosZ_AC", "hPosZ_AC", kTH1F, {{300, -15.0, 15.0}}); histos.add("hcentFT0C_BC", "centFT0C_BC", kTH1F, {{110, 0.0, 110.0}}); histos.add("hcentFT0C_AC", "centFT0C_AC", kTH1F, {{110, 0.0, 110.0}}); @@ -156,6 +191,7 @@ struct kstarInOO { histos.add("hFindableTPCRows_BC", "hFindableTPCRows_BC", kTH1F, {{200, 0, 200}}); histos.add("hClustersVsRows_BC", "hClustersVsRows_BC", kTH1F, {{200, 0, 2}}); histos.add("hTPCChi2_BC", "hTPCChi2_BC", kTH1F, {{200, 0, 100}}); + histos.add("hITSChi2_BC", "hITSChi2_BC", kTH1F, {{200, 0, 100}}); histos.add("QA_nSigma_pion_TPC_BC", "QA_nSigma_pion_TPC_BC", {HistType::kTH2F, {ptAxis, pidAxis}}); histos.add("QA_nSigma_pion_TOF_BC", "QA_nSigma_pion_TOF_BC", {HistType::kTH2F, {ptAxis, pidAxis}}); histos.add("QA_pion_TPC_TOF_BC", "QA_pion_TPC_TOF_BC", {HistType::kTH2F, {pidAxis, pidAxis}}); @@ -173,6 +209,7 @@ struct kstarInOO { histos.add("hFindableTPCRows_AC", "hFindableTPCRows_AC", kTH1F, {{200, 0, 200}}); histos.add("hClustersVsRows_AC", "hClustersVsRows_AC", kTH1F, {{200, 0, 2}}); histos.add("hTPCChi2_AC", "hTPCChi2_AC", kTH1F, {{200, 0, 100}}); + histos.add("hITSChi2_AC", "hITSChi2_AC", kTH1F, {{200, 0, 100}}); histos.add("QA_nSigma_pion_TPC_AC", "QA_nSigma_pion_TPC_AC", {HistType::kTH2F, {ptAxis, pidAxis}}); histos.add("QA_nSigma_pion_TOF_AC", "QA_nSigma_pion_TOF_AC", {HistType::kTH2F, {ptAxis, pidAxis}}); histos.add("QA_pion_TPC_TOF_AC", "QA_pion_TPC_TOF_AC", {HistType::kTH2F, {pidAxis, pidAxis}}); @@ -210,6 +247,36 @@ struct kstarInOO { histos.add("hMC_USS_PiK_True", "hMC_USS_PiK_True", kTHnSparseF, {cfgCentAxis, ptAxis, minvAxis}); } + if (cfgJetQAHistos) { + histos.add("JetpT", "Jet pT (GeV/c)", kTH1F, {{4000, 0., 200.}}); + histos.add("JetEta", "Jet Eta", kTH1F, {{100, -1.0, 1.0}}); + histos.add("JetPhi", "Jet Phi", kTH1F, {{80, -1.0, 7.0}}); + + histos.add("rawDimpT", "rawDimpT", kTH2F, {{1000, 0.0, 10.0}, {100, -0.5, 0.5}}); + histos.add("jetTrackEta", "Jet Track Eta", kTH1F, {{100, -1.0, 1.0}}); + histos.add("jetTrackPhi", "Jet Track Phi", kTH1F, {{80, -1.0, 7.0}}); + + histos.add("nJetsPerEvent", "nJetsPerEvent", kTH1I, {{4, -0.5, 3.5}}); + histos.add("nGoodjets", "nGoodjets", kTH1I, {{4, -0.5, 3.5}}); + } + if (cfgJetDataHistos) { + histos.add("nJetEvents", "nJetEvents", kTH1F, {{7, 0.0, 7.0}}); + histos.add("nTriggerQA", "nTriggerQA", kTH1F, {{7, 0.0, 7.0}}); + + histos.add("hMB_USS_KPi", "hMB_USS_KPi", kTHnSparseF, {cfgCentAxis, ptAxis, minvAxis}); + histos.add("hMB_USS_PiK", "hMB_USS_PiK", kTHnSparseF, {cfgCentAxis, ptAxis, minvAxis}); + histos.add("hMB_LSS_KPi", "hMB_LSS_KPi", kTHnSparseF, {cfgCentAxis, ptAxis, minvAxis}); + histos.add("hMB_LSS_PiK", "hMB_LSS_PiK", kTHnSparseF, {cfgCentAxis, ptAxis, minvAxis}); + + histos.add("hUSS_INSIDE_KPi", "hUSS_INSIDE_KPi", kTHnSparseF, {cfgCentAxis, dRAxis, ptAxis, minvAxis}); + histos.add("hUSS_INSIDE_PiK", "hUSS_INSIDE_PiK", kTHnSparseF, {cfgCentAxis, dRAxis, ptAxis, minvAxis}); + histos.add("hLSS_INSIDE_KPi", "hLSS_INSIDE_KPi", kTHnSparseF, {cfgCentAxis, dRAxis, ptAxis, minvAxis}); + histos.add("hLSS_INSIDE_PiK", "hLSS_INSIDE_PiK", kTHnSparseF, {cfgCentAxis, dRAxis, ptAxis, minvAxis}); + } + if (cfgJetMCHistos) { + histos.add("nJetMCEvents", "nJetMCEvents", kTH1F, {{7, -.0, 7.0}}); + } + std::shared_ptr hCutFlow = histos.get(HIST("hEvent_Cut")); std::vector eventCutLabels = { "All Events", @@ -227,14 +294,39 @@ struct kstarInOO { hCutFlow->GetXaxis()->SetBinLabel(i + 1, eventCutLabels[i].c_str()); } + // Jet + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(cfgEventSelections)); + RealTriggerMaskBits = jetderiveddatautilities::initialiseTriggerMaskBits(cfgRealTriggerMasks); + triggerMaskBitsTest1 = jetderiveddatautilities::initialiseTriggerMaskBits(cfgTriggerMasksTest1); + triggerMaskBitsTest2 = jetderiveddatautilities::initialiseTriggerMaskBits(cfgTriggerMasksTest2); + triggerMaskBitsTest3 = jetderiveddatautilities::initialiseTriggerMaskBits(cfgTriggerMasksTest3); } // end of init + //====================== + //|| For LF Analysis + //====================== using EventCandidates = soa::Join; //, aod::CentFT0Ms, aod::CentFT0As using EventCandidatesTrue = aod::McCollisions; using TrackCandidates = soa::Join; using TrackCandidatesMC = soa::Join; + + //============== + //|| For jets + //============== + Filter JEPosZFilter = nabs(aod::jcollision::posZ) < cfgEventVtxCut; + Filter JEMCPosZFilter = nabs(aod::jmccollision::posZ) < cfgEventVtxCut; + Filter jetCuts = aod::jet::pt > cfgJetpT&& aod::jet::r == nround(cfgJetR.node() * 100.0f); + + using JetSelectedMCCollisions = soa::Join; + using JetSelectedDataCollisions = soa::Join; + using JetTrackCandidates = soa::Join; + + using JetFilteredMCCollisions = soa::Filtered; + using JetFilteredDataCollisions = soa::Filtered; + using JetFilteredJets = soa::Filtered>; + // For Mixed Event using BinningType = ColumnBinningPolicy; @@ -325,6 +417,7 @@ struct kstarInOO { histos.fill(HIST("hFindableTPCRows_BC"), track.tpcNClsCrossedRows()); histos.fill(HIST("hClustersVsRows_BC"), track.tpcCrossedRowsOverFindableCls()); histos.fill(HIST("hTPCChi2_BC"), track.tpcChi2NCl()); + histos.fill(HIST("hITSChi2_BC"), track.itsChi2NCl()); histos.fill(HIST("QA_track_pT_BC"), track.pt()); } if (cfgTrackGlobalSel && !track.isGlobalTrack()) @@ -341,15 +434,15 @@ struct kstarInOO { return false; if (cfgTrackGlobalWoDCATrack && !track.isGlobalTrackWoDCA()) return false; - if (cfgTracknFindableTPCClusters > 0 && track.tpcNClsFindable() < cfgTracknFindableTPCClusters) + if (cfgTrackFindableTPCClusters > 0 && track.tpcNClsFindable() < cfgTrackFindableTPCClusters) return false; - if (track.tpcNClsCrossedRows() < cfgTracknTPCCrossedRows) + if (track.tpcNClsCrossedRows() < cfgTrackTPCCrossedRows) return false; - if (cfgTracknRowsOverFindable > 0 && track.tpcCrossedRowsOverFindableCls() > cfgTracknRowsOverFindable) + if (cfgTrackRowsOverFindable > 0 && track.tpcCrossedRowsOverFindableCls() > cfgTrackRowsOverFindable) return false; - if (track.tpcChi2NCl() > cfgTracknTPCChi2) + if (track.tpcChi2NCl() > cfgTrackTPCChi2) return false; - if (track.itsChi2NCl() > cfgTracknITSChi2) + if (track.itsChi2NCl() > cfgTrackITSChi2) return false; if (cfgTrackConnectedToPV && !track.isPVContributor()) return false; @@ -364,6 +457,7 @@ struct kstarInOO { histos.fill(HIST("hFindableTPCRows_AC"), track.tpcNClsCrossedRows()); histos.fill(HIST("hClustersVsRows_AC"), track.tpcCrossedRowsOverFindableCls()); histos.fill(HIST("hTPCChi2_AC"), track.tpcChi2NCl()); + histos.fill(HIST("hITSChi2_AC"), track.itsChi2NCl()); histos.fill(HIST("QA_track_pT_AC"), track.pt()); } return true; @@ -664,6 +758,253 @@ struct kstarInOO { return {lResonance.Pt(), lResonance.M()}; } + template + double DistinguishJets(const JetType& jets, const TLorentzVector lResonance) + { + if (cDebugLevel > 0) + std::cout << "Finded multiple jets to the same phi." << std::endl; + + double bestR = 0; + double bestJetpT = 0; + for (auto const& jet : jets) { + double phidiff = TVector2::Phi_mpi_pi(jet.phi() - lResonance.Phi()); + double etadiff = jet.eta() - lResonance.Eta(); + double R = TMath::Sqrt((phidiff * phidiff) + (etadiff * etadiff)); + if (R < cfgJetR && bestR == 0) { + bestR = R; + bestJetpT = jet.pt(); + } else if (R < bestR) { + bestR = R; + bestJetpT = jet.pt(); + } + } // jet + return bestJetpT; + } + + template + std::pair JetminvReconstruction(aod::JetCollision const& collision, const TracksType& trk1, const TracksType& trk2, const JetType& jets, const bool QA, const bool flip) + { + if (!trackSelection(trk1, false) || !trackSelection(trk2, false)) + return {-1.0, -1.0}; + + if (!trackPIDKaon(trk1, QA) || !trackPIDPion(trk2, QA)) + return {-1.0, -1.0}; + + if (trk1.globalIndex() >= trk2.globalIndex()) + return {-1.0, -1.0}; + + TLorentzVector lDecayDaughter1, lDecayDaughter2, lResonance; + if (!flip) { + lDecayDaughter1.SetXYZM(trk1.px(), trk1.py(), trk1.pz(), massKa); + lDecayDaughter2.SetXYZM(trk2.px(), trk2.py(), trk2.pz(), massPi); + } else { + lDecayDaughter1.SetXYZM(trk1.px(), trk1.py(), trk1.pz(), massPi); + lDecayDaughter2.SetXYZM(trk2.px(), trk2.py(), trk2.pz(), massKa); + } + lResonance = lDecayDaughter1 + lDecayDaughter2; + + if (std::abs(lResonance.Eta()) > cfgTrackMaxEta) + return {-1.0, -1.0}; + + //====================== + //| MinBias Event M_inv + //====================== + auto mult = collision.centFT0C(); + double conjugate = trk1.sign() * trk2.sign(); + if (cfgJetDataHistos) { + if (!flip) { + if (conjugate < 0) { + histos.fill(HIST("hMB_USS_KPi"), mult, lResonance.Pt(), lResonance.M()); + } else if (conjugate > 0) { + histos.fill(HIST("hMB_LSS_KPi"), mult, lResonance.Pt(), lResonance.M()); + } + } else { + if (conjugate < 0) { + histos.fill(HIST("hMB_USS_PiK"), mult, lResonance.Pt(), lResonance.M()); + } else if (conjugate > 0) { + histos.fill(HIST("hMB_LSS_PiK"), mult, lResonance.Pt(), lResonance.M()); + } + } + } // cfgJetDataHistos + + //====================== + //| Inside jets M_inv + //====================== + bool jetFlag = false; + int goodjets = 0; + double jetpt = 0; + for (auto const& jet : jets) { + double phidiff = TVector2::Phi_mpi_pi(jet.phi() - lResonance.Phi()); + double etadiff = jet.eta() - lResonance.Eta(); + double R = TMath::Sqrt((etadiff * etadiff) + (phidiff * phidiff)); + if (R < cfgJetR) { + jetFlag = true; + jetpt = jet.pt(); + goodjets++; + } + } + if (cfgJetQAHistos) { + histos.fill(HIST("nGoodjets"), goodjets); + } + if (!cfgSingleJet) { + if (goodjets > 1) { + jetpt = DistinguishJets(jets, lResonance); + } + } + + if (jetFlag) { + if (cfgJetDataHistos) { + if (!flip) { + if (conjugate < 0) { + histos.fill(HIST("hUSS_INSIDE_KPi"), mult, jetpt, lResonance.Pt(), lResonance.M()); + } else if (conjugate > 0) { + histos.fill(HIST("hLSS_INSIDE_KPi"), mult, jetpt, lResonance.Pt(), lResonance.M()); + } + } else { + if (conjugate < 0) { + histos.fill(HIST("hUSS_INSIDE_PiK"), mult, jetpt, lResonance.Pt(), lResonance.M()); + } else if (conjugate > 0) { + histos.fill(HIST("hLSS_INSIDE_PiK"), mult, jetpt, lResonance.Pt(), lResonance.M()); + } + } + } // cfgJetDataHistos + } // jetFlag + + if (lResonance.M() > 0.85 && lResonance.M() < 0.95) { + if (jetFlag) + return {3.0, 3.0}; + if (goodjets > 0) + return {2.0, 2.0}; + return {1.0, 1.0}; + } else { + return {-1.0, -1.0}; + } + } // JetminvReconstruction + + //======================================================= + //| + //| JET DATA STUFF + //| + //======================================================= + int nJetEvents = 0; + void processDataJets(aod::JetCollision const& collision, soa::Filtered> const& chargedjets, soa::Join const& jetTracks, TrackCandidates const&) + { + if (cDebugLevel > 0) { + nJetEvents++; + if ((nJetEvents + 1) % 10000 == 0) { + std::cout << "Processed Jet Data Events: " << nJetEvents << std::endl; + } + } + if (cfgJetDataHistos) { + histos.fill(HIST("nJetEvents"), 0.5); // Raw event + } + + if (std::abs(collision.posZ()) > cfgEventVtxCut) + return; + + // Trigger before we start jet finding + if (cfgCutonTrig) { + bool RT = false; + bool VTtest1 = false; + bool VTtest2 = false; + bool VTtest3 = false; + if (jetderiveddatautilities::selectTrigger(collision, RealTriggerMaskBits)) { + RT = true; + if (cfgJetDataHistos) { + histos.fill(HIST("nTriggerQA"), 0.5); + } + } + if (jetderiveddatautilities::selectTrigger(collision, triggerMaskBitsTest1)) { + VTtest1 = true; + if (cfgJetDataHistos) { + histos.fill(HIST("nTriggerQA"), 1.5); + } + } + if (jetderiveddatautilities::selectTrigger(collision, triggerMaskBitsTest2)) { + VTtest2 = true; + if (cfgJetDataHistos) { + histos.fill(HIST("nTriggerQA"), 2.5); + } + } + if (jetderiveddatautilities::selectTrigger(collision, triggerMaskBitsTest3)) { + VTtest3 = true; + if (cfgJetDataHistos) { + histos.fill(HIST("nTriggerQA"), 3.5); + } + } + if (!RT) { + return; + } else if (RT && (VTtest1 || VTtest2 || VTtest3)) { + return; + } + } // Trigger cut + + if (cfgJetDataHistos) { + histos.fill(HIST("nJetEvents"), 1.5); // Before passing the condition + } + + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { + return; + } + + if (cfgJetDataHistos) { + histos.fill(HIST("nJetEvents"), 2.5); // Events after event quality selection for Inclusive + } + + std::vector jetpT{}; + std::vector jetEta{}; + std::vector jetPhi{}; + bool HasJets = false; + int nJets = 0; + for (auto chargedjet : chargedjets) { + jetpT.push_back(chargedjet.pt()); + jetEta.push_back(chargedjet.eta()); + jetPhi.push_back(chargedjet.phi()); + nJets++; + if (cfgJetQAHistos) { + histos.fill(HIST("JetpT"), chargedjet.pt()); + histos.fill(HIST("JetEta"), chargedjet.eta()); + histos.fill(HIST("JetPhi"), chargedjet.phi()); + } + if (chargedjet.pt() > cfgJetpT) + HasJets = true; + } + if (cfgJetQAHistos) { + histos.fill(HIST("nJetsPerEvent"), nJets); + } + + if (!HasJets) + return; + if (cfgJetDataHistos) { + histos.fill(HIST("nJetEvents"), 3.5); // Has jets + } + + for (auto& [track1, track2] : combinations(o2::soa::CombinationsFullIndexPolicy(jetTracks, jetTracks))) { + auto trk1 = track1.track_as>(); + auto trk2 = track2.track_as>(); + + JetminvReconstruction(collision, trk1, trk2, chargedjets, true, false); + JetminvReconstruction(collision, trk1, trk2, chargedjets, true, true); + } // track loop + + bool INELgt0 = false; + for (auto& jetTrack : jetTracks) { + auto originTrack = jetTrack.track_as>(); + if (!trackSelection(originTrack, true)) + continue; + INELgt0 = true; + + if (cfgJetQAHistos) { + histos.fill(HIST("rawDimpT"), jetTrack.pt(), jetTrack.pt() - originTrack.pt()); + histos.fill(HIST("jetTrackEta"), jetTrack.eta()); + histos.fill(HIST("jetTrackPhi"), jetTrack.phi()); + } + } // jetTrack loop + if (!INELgt0) + return; + } // ProcessDataJets + PROCESS_SWITCH(kstarInOO, processDataJets, "process Data Jets", false); + //======================================================= //| //| DATA STUFF (SE)