From 254b895c5ff52c86d820cd6a36744cc71d10d2d8 Mon Sep 17 00:00:00 2001 From: Mattia Faggin Date: Wed, 13 Mar 2024 15:49:20 +0100 Subject: [PATCH 01/11] Implement bitmask for event selection in candidate creators. --- .../TableProducer/candidateCreator2Prong.cxx | 70 +++++++++++-------- .../TableProducer/candidateCreator3Prong.cxx | 35 ++++++---- .../TableProducer/candidateCreatorCascade.cxx | 35 ++++++---- PWGHF/TableProducer/candidateCreatorDstar.cxx | 35 ++++++---- PWGHF/TableProducer/trackIndexSkimCreator.cxx | 14 +--- PWGHF/Utils/utilsEvSelHf.h | 45 ++++++++++-- 6 files changed, 139 insertions(+), 95 deletions(-) diff --git a/PWGHF/TableProducer/candidateCreator2Prong.cxx b/PWGHF/TableProducer/candidateCreator2Prong.cxx index a81ebfe2bfd..60842818ca6 100644 --- a/PWGHF/TableProducer/candidateCreator2Prong.cxx +++ b/PWGHF/TableProducer/candidateCreator2Prong.cxx @@ -150,24 +150,29 @@ struct HfCandidateCreator2Prong { // loop over pairs of track indices for (const auto& rowTrackIndexProng2 : rowsTrackIndexProng2) { - // reject candidates in collisions outside the centrality range + /// reject candidates not satisfying the event selections auto collision = rowTrackIndexProng2.template collision_as(); - float centrality = -1.; - if constexpr (centEstimator != CentralityEstimator::None) { - if constexpr (centEstimator == CentralityEstimator::FT0C) { - centrality = collision.centFT0C(); - } else if constexpr (centEstimator == CentralityEstimator::FT0M) { - centrality = collision.centFT0M(); - } else { - LOGP(fatal, "Centrality estimator different from FT0C and FT0M, fix it!"); - } - if (centrality < centralityMin || centrality > centralityMax) { - continue; - } + bool useCentrality = true; + if constexpr (centEstimator == CentralityEstimator::None) { + useCentrality = false; } + float centrality = -1.; + uint16_t statusCollision = isHfCollisionSelected(collision, useCentrality, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut, centrality); - /// event selection: sel8, PV posZ, TF border cut - if (!isHfCollisionSelected(collision, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut)) { + if (useCentrality && TESTBIT(statusCollision, EventRejection::Centrality)) { + /// event selection - centrality + continue; + } + if (useSel8Trigger && TESTBIT(statusCollision, EventRejection::Trigger)) { + /// event selection - sel8() + continue; + } + if (TESTBIT(statusCollision, EventRejection::PositionZ)) { + /// event selection - PV position Z + continue; + } + if (useTimeFrameBorderCut && TESTBIT(statusCollision, EventRejection::TimeFrameBorderCut)) { + /// event selection - Time Frame border cut continue; } @@ -292,24 +297,29 @@ struct HfCandidateCreator2Prong { for (const auto& rowTrackIndexProng2 : rowsTrackIndexProng2) { - // reject candidates in collisions outside the centrality range + /// reject candidates not satisfying the event selections auto collision = rowTrackIndexProng2.template collision_as(); - float centrality = -1.; - if constexpr (centEstimator != CentralityEstimator::None) { - if constexpr (centEstimator == CentralityEstimator::FT0C) { - centrality = collision.centFT0C(); - } else if constexpr (centEstimator == CentralityEstimator::FT0M) { - centrality = collision.centFT0M(); - } else { - LOGP(fatal, "Centrality estimator different from FT0C and FT0M, fix it!"); - } - if (centrality < centralityMin || centrality > centralityMax) { - continue; - } + bool useCentrality = true; + if constexpr (centEstimator == CentralityEstimator::None) { + useCentrality = false; } + float centrality = -1.; + uint16_t statusCollision = isHfCollisionSelected(collision, useCentrality, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut, centrality); - /// event selection: sel8, PV posZ, TF border cut - if (!isHfCollisionSelected(collision, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut)) { + if (useCentrality && !TESTBIT(statusCollision, EventRejection::Centrality)) { + /// event selection - centrality + continue; + } + if (useSel8Trigger && !TESTBIT(statusCollision, EventRejection::Trigger)) { + /// event selection - sel8() + continue; + } + if (!TESTBIT(statusCollision, EventRejection::PositionZ)) { + /// event selection - PV position Z + continue; + } + if (useTimeFrameBorderCut && !TESTBIT(statusCollision, EventRejection::TimeFrameBorderCut)) { + /// event selection - Time Frame border cut continue; } diff --git a/PWGHF/TableProducer/candidateCreator3Prong.cxx b/PWGHF/TableProducer/candidateCreator3Prong.cxx index ccfa9451593..f13c14df6f0 100644 --- a/PWGHF/TableProducer/candidateCreator3Prong.cxx +++ b/PWGHF/TableProducer/candidateCreator3Prong.cxx @@ -143,24 +143,29 @@ struct HfCandidateCreator3Prong { // loop over triplets of track indices for (const auto& rowTrackIndexProng3 : rowsTrackIndexProng3) { - // reject candidates in collisions outside the centrality range + /// reject candidates not satisfying the event selections auto collision = rowTrackIndexProng3.template collision_as(); - float centrality = -1.; - if constexpr (centEstimator != CentralityEstimator::None) { - if constexpr (centEstimator == CentralityEstimator::FT0C) { - centrality = collision.centFT0C(); - } else if constexpr (centEstimator == CentralityEstimator::FT0M) { - centrality = collision.centFT0M(); - } else { - LOGP(fatal, "Centrality estimator different from FT0C and FT0M, fix it!"); - } - if (centrality < centralityMin || centrality > centralityMax) { - continue; - } + bool useCentrality = true; + if constexpr (centEstimator == CentralityEstimator::None) { + useCentrality = false; } + float centrality = -1.; + uint16_t statusCollision = isHfCollisionSelected(collision, useCentrality, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut, centrality); - /// event selection: sel8, PV posZ, TF border cut - if (!isHfCollisionSelected(collision, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut)) { + if (useCentrality && TESTBIT(statusCollision, EventRejection::Centrality)) { + /// event selection - centrality + continue; + } + if (useSel8Trigger && TESTBIT(statusCollision, EventRejection::Trigger)) { + /// event selection - sel8() + continue; + } + if (TESTBIT(statusCollision, EventRejection::PositionZ)) { + /// event selection - PV position Z + continue; + } + if (useTimeFrameBorderCut && TESTBIT(statusCollision, EventRejection::TimeFrameBorderCut)) { + /// event selection - Time Frame border cut continue; } diff --git a/PWGHF/TableProducer/candidateCreatorCascade.cxx b/PWGHF/TableProducer/candidateCreatorCascade.cxx index 9c08adb124d..9ef53c460ce 100644 --- a/PWGHF/TableProducer/candidateCreatorCascade.cxx +++ b/PWGHF/TableProducer/candidateCreatorCascade.cxx @@ -122,24 +122,29 @@ struct HfCandidateCreatorCascade { // loop over pairs of track indices for (const auto& casc : rowsTrackIndexCasc) { - // reject candidates in collisions outside the centrality range + /// reject candidates not satisfying the event selections auto collision = casc.template collision_as(); - float centrality = -1.; - if constexpr (centEstimator != CentralityEstimator::None) { - if constexpr (centEstimator == CentralityEstimator::FT0C) { - centrality = collision.centFT0C(); - } else if constexpr (centEstimator == CentralityEstimator::FT0M) { - centrality = collision.centFT0M(); - } else { - LOGP(fatal, "Centrality estimator different from FT0C and FT0M, fix it!"); - } - if (centrality < centralityMin || centrality > centralityMax) { - continue; - } + bool useCentrality = true; + if constexpr (centEstimator == CentralityEstimator::None) { + useCentrality = false; } + float centrality = -1.; + uint16_t statusCollision = isHfCollisionSelected(collision, useCentrality, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut, centrality); - /// event selection: sel8, PV posZ, TF border cut - if (!isHfCollisionSelected(collision, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut)) { + if (useCentrality && TESTBIT(statusCollision, EventRejection::Centrality)) { + /// event selection - centrality + continue; + } + if (useSel8Trigger && TESTBIT(statusCollision, EventRejection::Trigger)) { + /// event selection - sel8() + continue; + } + if (TESTBIT(statusCollision, EventRejection::PositionZ)) { + /// event selection - PV position Z + continue; + } + if (useTimeFrameBorderCut && TESTBIT(statusCollision, EventRejection::TimeFrameBorderCut)) { + /// event selection - Time Frame border cut continue; } diff --git a/PWGHF/TableProducer/candidateCreatorDstar.cxx b/PWGHF/TableProducer/candidateCreatorDstar.cxx index c7322121e98..cc309fcb142 100644 --- a/PWGHF/TableProducer/candidateCreatorDstar.cxx +++ b/PWGHF/TableProducer/candidateCreatorDstar.cxx @@ -157,24 +157,29 @@ struct HfCandidateCreatorDstar { // loop over suspected Dstar Candidate for (const auto& rowTrackIndexDstar : rowsTrackIndexDstar) { - // reject candidates in collisions outside the centrality range + /// reject candidates not satisfying the event selections auto collision = rowTrackIndexDstar.template collision_as(); - float centrality = -1.; - if constexpr (centEstimator != CentralityEstimator::None) { - if constexpr (centEstimator == CentralityEstimator::FT0C) { - centrality = collision.centFT0C(); - } else if constexpr (centEstimator == CentralityEstimator::FT0M) { - centrality = collision.centFT0M(); - } else { - LOGP(fatal, "Centrality estimator different from FT0C and FT0M, fix it!"); - } - if (centrality < centralityMin || centrality > centralityMax) { - continue; - } + bool useCentrality = true; + if constexpr (centEstimator == CentralityEstimator::None) { + useCentrality = false; } + float centrality = -1.; + uint16_t statusCollision = isHfCollisionSelected(collision, useCentrality, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut, centrality); - /// event selection: sel8, PV posZ, TF border cut - if (!isHfCollisionSelected(collision, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut)) { + if (useCentrality && TESTBIT(statusCollision, EventRejection::Centrality)) { + /// event selection - centrality + continue; + } + if (useSel8Trigger && TESTBIT(statusCollision, EventRejection::Trigger)) { + /// event selection - sel8() + continue; + } + if (TESTBIT(statusCollision, EventRejection::PositionZ)) { + /// event selection - PV position Z + continue; + } + if (useTimeFrameBorderCut && TESTBIT(statusCollision, EventRejection::TimeFrameBorderCut)) { + /// event selection - Time Frame border cut continue; } diff --git a/PWGHF/TableProducer/trackIndexSkimCreator.cxx b/PWGHF/TableProducer/trackIndexSkimCreator.cxx index c301130f013..385abbe0312 100644 --- a/PWGHF/TableProducer/trackIndexSkimCreator.cxx +++ b/PWGHF/TableProducer/trackIndexSkimCreator.cxx @@ -50,6 +50,7 @@ #include "PWGHF/DataModel/CandidateReconstructionTables.h" #include "PWGHF/Utils/utilsAnalysis.h" #include "PWGHF/Utils/utilsBfieldCCDB.h" +#include "PWGHF/Utils/utilsEvSelHf.h" using namespace o2; using namespace o2::analysis; @@ -68,19 +69,6 @@ enum CandidateType { NCandidateTypes }; -// event rejection types -enum EventRejection { - Trigger = 0, - TimeFrameBorderCut, - PositionX, - PositionY, - PositionZ, - NContrib, - Chi2, - Centrality, - NEventRejection -}; - // enum for proton PID strategy (only proton for baryons) enum ProtonPidStrategy { NoPid = 0, diff --git a/PWGHF/Utils/utilsEvSelHf.h b/PWGHF/Utils/utilsEvSelHf.h index 0b87373377c..22321bf344d 100644 --- a/PWGHF/Utils/utilsEvSelHf.h +++ b/PWGHF/Utils/utilsEvSelHf.h @@ -16,32 +16,63 @@ #ifndef PWGHF_UTILS_UTILSEVSELHF_H_ #define PWGHF_UTILS_UTILSEVSELHF_H_ +using namespace o2::aod::hf_collision_centrality; + +// event rejection types +enum EventRejection { + Trigger = 0, + TimeFrameBorderCut, + PositionX, + PositionY, + PositionZ, + NContrib, + Chi2, + Centrality, + NEventRejection +}; + /// \brief Function to apply event selections in HF analyses /// \param collision collision that has to satisfy the selection criteria /// \param useSel8Trigger switch to activate the sel8() event selection /// \param zPvPosMax maximum primary-vertex z /// \param useTimeFrameBorderCut switch to activate the time frame border cut /// \return true if collision satisfies all criteria, false otherwise -template -bool isHfCollisionSelected(const Coll& collision, bool useSel8Trigger, float maxPvPosZ, bool useTimeFrameBorderCut) +template +bool isHfCollisionSelected(const Coll& collision, bool useCentrality, std::array centralityLimits, bool useSel8Trigger, float maxPvPosZ, bool useTimeFrameBorderCut, float& centrality) { + uint16_t statusCollision = 0; // 16 bits, in case new ev. selections will be added + + if constexpr (centEstimator != CentralityEstimator::None) { + if constexpr (centEstimator == CentralityEstimator::FT0C) { + centrality = collision.centFT0C(); + } else if constexpr (centEstimator == CentralityEstimator::FT0M) { + centrality = collision.centFT0M(); + } else { + LOGP(fatal, "Centrality estimator different from FT0C and FT0M, fix it!"); + } + if (centrality < centralityLimits.at(0) || centrality > centralityLimits.at(1)) { + SETBIT(statusCollision, EventRejection::Centrality); + } + } + /// sel8() condition if (useSel8Trigger && !collision.sel8()) { - return false; + SETBIT(statusCollision, EventRejection::Trigger); } /// primary vertex z if (std::fabs(collision.posZ()) > maxPvPosZ) { - return false; + SETBIT(statusCollision, EventRejection::PositionZ); } /// time frame border cut if (useTimeFrameBorderCut && !collision.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) { - return false; + SETBIT(statusCollision, EventRejection::TimeFrameBorderCut); } - /// all conditions satisfied - return true; + /// TODO: add other selections, to extend it to the trackIndexSkimCreator + + return statusCollision; } #endif // PWGHF_UTILS_UTILSEVSELHF_H_ From 04ea384a64949144ce2b1b2361fdc881e77a7cf3 Mon Sep 17 00:00:00 2001 From: Mattia Faggin Date: Wed, 13 Mar 2024 17:41:34 +0100 Subject: [PATCH 02/11] Bug fix in bitmap return, improvements and collision process for 3-prong creator. --- .../TableProducer/candidateCreator2Prong.cxx | 27 ++--- .../TableProducer/candidateCreator3Prong.cxx | 105 ++++++++++++++++-- .../TableProducer/candidateCreatorCascade.cxx | 12 +- PWGHF/TableProducer/candidateCreatorDstar.cxx | 12 +- PWGHF/Utils/utilsEvSelHf.h | 3 +- 5 files changed, 112 insertions(+), 47 deletions(-) diff --git a/PWGHF/TableProducer/candidateCreator2Prong.cxx b/PWGHF/TableProducer/candidateCreator2Prong.cxx index 60842818ca6..ee99d4f4645 100644 --- a/PWGHF/TableProducer/candidateCreator2Prong.cxx +++ b/PWGHF/TableProducer/candidateCreator2Prong.cxx @@ -152,14 +152,9 @@ struct HfCandidateCreator2Prong { /// reject candidates not satisfying the event selections auto collision = rowTrackIndexProng2.template collision_as(); - bool useCentrality = true; - if constexpr (centEstimator == CentralityEstimator::None) { - useCentrality = false; - } - float centrality = -1.; - uint16_t statusCollision = isHfCollisionSelected(collision, useCentrality, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut, centrality); + const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); - if (useCentrality && TESTBIT(statusCollision, EventRejection::Centrality)) { + if (TESTBIT(statusCollision, EventRejection::Centrality)) { /// event selection - centrality continue; } @@ -297,28 +292,22 @@ struct HfCandidateCreator2Prong { for (const auto& rowTrackIndexProng2 : rowsTrackIndexProng2) { - /// reject candidates not satisfying the event selections + /// reject candidates in collisions not satisfying the event selections auto collision = rowTrackIndexProng2.template collision_as(); - bool useCentrality = true; - if constexpr (centEstimator == CentralityEstimator::None) { - useCentrality = false; - } - float centrality = -1.; - uint16_t statusCollision = isHfCollisionSelected(collision, useCentrality, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut, centrality); - - if (useCentrality && !TESTBIT(statusCollision, EventRejection::Centrality)) { + const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + if (TESTBIT(statusCollision, EventRejection::Centrality)) { /// event selection - centrality continue; } - if (useSel8Trigger && !TESTBIT(statusCollision, EventRejection::Trigger)) { + if (useSel8Trigger && TESTBIT(statusCollision, EventRejection::Trigger)) { /// event selection - sel8() continue; } - if (!TESTBIT(statusCollision, EventRejection::PositionZ)) { + if (TESTBIT(statusCollision, EventRejection::PositionZ)) { /// event selection - PV position Z continue; } - if (useTimeFrameBorderCut && !TESTBIT(statusCollision, EventRejection::TimeFrameBorderCut)) { + if (useTimeFrameBorderCut && TESTBIT(statusCollision, EventRejection::TimeFrameBorderCut)) { /// event selection - Time Frame border cut continue; } diff --git a/PWGHF/TableProducer/candidateCreator3Prong.cxx b/PWGHF/TableProducer/candidateCreator3Prong.cxx index f13c14df6f0..d7ef746c6f2 100644 --- a/PWGHF/TableProducer/candidateCreator3Prong.cxx +++ b/PWGHF/TableProducer/candidateCreator3Prong.cxx @@ -99,6 +99,9 @@ struct HfCandidateCreator3Prong { OutputObj hCovSVZZ{TH1F("hCovSVZZ", "3-prong candidates;ZZ element of cov. matrix of sec. vtx. position (cm^{2});entries", 100, 0., 0.2)}; OutputObj hDcaXYProngs{TH2F("hDcaXYProngs", "DCAxy of 3-prong candidates;#it{p}_{T} (GeV/#it{c};#it{d}_{xy}) (#mum);entries", 100, 0., 20., 200, -500., 500.)}; OutputObj hDcaZProngs{TH2F("hDcaZProngs", "DCAz of 3-prong candidates;#it{p}_{T} (GeV/#it{c};#it{d}_{z}) (#mum);entries", 100, 0., 20., 200, -500., 500.)}; + OutputObj hCollisions{TH1D("hCollisions", "HF event counter", 5, -0.5, 4.5)}; + OutputObj hPosZBeforeEvSel{TH1D("hPosZBeforeEvSel", "PV position Z before ev. selection;posZ (cm);entries", 400, -20, 20)}; + OutputObj hPosZAfterEvSel{TH1D("hPosZAfterEvSel", "PV position Z after ev. selection;posZ (cm);entries", 400, -20, 20)}; void init(InitContext const&) { @@ -109,6 +112,20 @@ struct HfCandidateCreator3Prong { LOGP(fatal, "One and only one process function must be enabled at a time."); } + std::array processesCollisions = {doprocessCollisions, doprocessCollisionsCentFT0C, doprocessCollisionsCentFT0M}; + if (std::accumulate(processesCollisions.begin(), processesCollisions.end(), 0) != 1) { + LOGP(fatal, "One and only one process function for collision monitoring must be enabled at a time."); + } + if ((doprocessPvRefit || doprocessNoPvRefit) && !doprocessCollisions) { + LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisions\"?"); + } + if ((doprocessPvRefitCentFT0C || doprocessNoPvRefitCentFT0C) && !doprocessCollisionsCentFT0C) { + LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisionsCentFT0C\"?"); + } + if ((doprocessPvRefitCentFT0M || doprocessNoPvRefitCentFT0M) && !doprocessCollisionsCentFT0M) { + LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisionsCentFT0M\"?"); + } + std::array creationFlags = {createDplus, createDs, createLc, createXic}; if (std::accumulate(creationFlags.begin(), creationFlags.end(), 0) == 0) { LOGP(fatal, "At least one particle specie should be enabled for the creation."); @@ -132,6 +149,13 @@ struct HfCandidateCreator3Prong { ccdb->setLocalObjectValidityChecking(); lut = o2::base::MatLayerCylSet::rectifyPtrFromFile(ccdb->get(ccdbPathLut)); runNumber = 0; + + /// collision monitoring + hCollisions->GetXaxis()->SetBinLabel(1, "All collisions"); + hCollisions->GetXaxis()->SetBinLabel(2, "Centrality ok"); + hCollisions->GetXaxis()->SetBinLabel(3, "Centrality + sel8 ok"); + hCollisions->GetXaxis()->SetBinLabel(4, "Centrality + sel8 + posZ ok"); + hCollisions->GetXaxis()->SetBinLabel(5, "Centrality + sel8 + posZ + TF border ok"); } template @@ -143,16 +167,10 @@ struct HfCandidateCreator3Prong { // loop over triplets of track indices for (const auto& rowTrackIndexProng3 : rowsTrackIndexProng3) { - /// reject candidates not satisfying the event selections + /// reject candidates in collisions not satisfying the event selections auto collision = rowTrackIndexProng3.template collision_as(); - bool useCentrality = true; - if constexpr (centEstimator == CentralityEstimator::None) { - useCentrality = false; - } - float centrality = -1.; - uint16_t statusCollision = isHfCollisionSelected(collision, useCentrality, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut, centrality); - - if (useCentrality && TESTBIT(statusCollision, EventRejection::Centrality)) { + uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + if (TESTBIT(statusCollision, EventRejection::Centrality)) { /// event selection - centrality continue; } @@ -292,6 +310,48 @@ struct HfCandidateCreator3Prong { } } + template + void monitorCollisions(Coll const& collisions) + { + + /// loop over collisions + for (const auto& collision : collisions) { + + hCollisions->Fill(0); // all collisions + const float posZ = collision.posZ(); + hPosZBeforeEvSel->Fill(posZ); + + /// bitmask with event. selection info + const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + + /// centrality + if (TESTBIT(statusCollision, EventRejection::Centrality)) { + continue; + } + hCollisions->Fill(1); // Centrality ok + + /// sel8() + if (useSel8Trigger && TESTBIT(statusCollision, EventRejection::Trigger)) { + continue; + } + hCollisions->Fill(2); // Centrality + sel8 ok + + /// PV position Z + if (TESTBIT(statusCollision, EventRejection::PositionZ)) { + continue; + } + hCollisions->Fill(3); // Centrality + sel8 + posZ ok + + /// Time Frame border cut + if (useTimeFrameBorderCut && TESTBIT(statusCollision, EventRejection::TimeFrameBorderCut)) { + continue; + } + hCollisions->Fill(4); // Centrality + sel8 + posZ + TF border ok + hPosZAfterEvSel->Fill(posZ); + + } /// end loop over collisions + } + /////////////////////////////////// /// /// /// No centrality selection /// @@ -369,6 +429,33 @@ struct HfCandidateCreator3Prong { runCreator3Prong(collisions, rowsTrackIndexProng3, tracks, bcWithTimeStamps); } PROCESS_SWITCH(HfCandidateCreator3Prong, processNoPvRefitCentFT0M, "Run candidate creator without PV refit and w/ centrality selection on FT0M", false); + + /////////////////////////////////////////////////////////// + /// /// + /// Process functions only for collision monitoring /// + /// /// + /////////////////////////////////////////////////////////// + + /// @brief process function to monitor collisions - no centrality + void processCollisions(soa::Join const& collisions) + { + monitorCollisions(collisions); + } + PROCESS_SWITCH(HfCandidateCreator3Prong, processCollisions, "Collision monitoring - no centrality", true); + + /// @brief process function to monitor collisions - FT0C centrality + void processCollisionsCentFT0C(soa::Join const& collisions) + { + monitorCollisions(collisions); + } + PROCESS_SWITCH(HfCandidateCreator3Prong, processCollisionsCentFT0C, "Collision monitoring - FT0C centrality", false); + + /// @brief process function to monitor collisions - FT0M centrality + void processCollisionsCentFT0M(soa::Join const& collisions) + { + monitorCollisions(collisions); + } + PROCESS_SWITCH(HfCandidateCreator3Prong, processCollisionsCentFT0M, "Collision monitoring - FT0M centrality", false); }; /// Extends the base table with expression columns. diff --git a/PWGHF/TableProducer/candidateCreatorCascade.cxx b/PWGHF/TableProducer/candidateCreatorCascade.cxx index 9ef53c460ce..db230cc64c6 100644 --- a/PWGHF/TableProducer/candidateCreatorCascade.cxx +++ b/PWGHF/TableProducer/candidateCreatorCascade.cxx @@ -122,16 +122,10 @@ struct HfCandidateCreatorCascade { // loop over pairs of track indices for (const auto& casc : rowsTrackIndexCasc) { - /// reject candidates not satisfying the event selections + /// reject candidates in collisions not satisfying the event selections auto collision = casc.template collision_as(); - bool useCentrality = true; - if constexpr (centEstimator == CentralityEstimator::None) { - useCentrality = false; - } - float centrality = -1.; - uint16_t statusCollision = isHfCollisionSelected(collision, useCentrality, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut, centrality); - - if (useCentrality && TESTBIT(statusCollision, EventRejection::Centrality)) { + const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + if (TESTBIT(statusCollision, EventRejection::Centrality)) { /// event selection - centrality continue; } diff --git a/PWGHF/TableProducer/candidateCreatorDstar.cxx b/PWGHF/TableProducer/candidateCreatorDstar.cxx index cc309fcb142..6f9533cab5a 100644 --- a/PWGHF/TableProducer/candidateCreatorDstar.cxx +++ b/PWGHF/TableProducer/candidateCreatorDstar.cxx @@ -157,16 +157,10 @@ struct HfCandidateCreatorDstar { // loop over suspected Dstar Candidate for (const auto& rowTrackIndexDstar : rowsTrackIndexDstar) { - /// reject candidates not satisfying the event selections + /// reject candidates in collisions not satisfying the event selections auto collision = rowTrackIndexDstar.template collision_as(); - bool useCentrality = true; - if constexpr (centEstimator == CentralityEstimator::None) { - useCentrality = false; - } - float centrality = -1.; - uint16_t statusCollision = isHfCollisionSelected(collision, useCentrality, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut, centrality); - - if (useCentrality && TESTBIT(statusCollision, EventRejection::Centrality)) { + const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + if (TESTBIT(statusCollision, EventRejection::Centrality)) { /// event selection - centrality continue; } diff --git a/PWGHF/Utils/utilsEvSelHf.h b/PWGHF/Utils/utilsEvSelHf.h index 22321bf344d..6643e41e8c8 100644 --- a/PWGHF/Utils/utilsEvSelHf.h +++ b/PWGHF/Utils/utilsEvSelHf.h @@ -38,10 +38,11 @@ enum EventRejection { /// \param useTimeFrameBorderCut switch to activate the time frame border cut /// \return true if collision satisfies all criteria, false otherwise template -bool isHfCollisionSelected(const Coll& collision, bool useCentrality, std::array centralityLimits, bool useSel8Trigger, float maxPvPosZ, bool useTimeFrameBorderCut, float& centrality) +uint16_t isHfCollisionSelected(const Coll& collision, std::array centralityLimits, bool useSel8Trigger, float maxPvPosZ, bool useTimeFrameBorderCut) { uint16_t statusCollision = 0; // 16 bits, in case new ev. selections will be added + float centrality = -1.; if constexpr (centEstimator != CentralityEstimator::None) { if constexpr (centEstimator == CentralityEstimator::FT0C) { From c37d016afe8c7f864edb42b7fb20ca54ef732229 Mon Sep 17 00:00:00 2001 From: Mattia Faggin Date: Wed, 13 Mar 2024 18:19:16 +0100 Subject: [PATCH 03/11] Promote monitoCollision to a common utility. --- .../TableProducer/candidateCreator3Prong.cxx | 76 ++++++++----------- PWGHF/Utils/utilsMonitorCollisions.h | 58 ++++++++++++++ 2 files changed, 89 insertions(+), 45 deletions(-) create mode 100644 PWGHF/Utils/utilsMonitorCollisions.h diff --git a/PWGHF/TableProducer/candidateCreator3Prong.cxx b/PWGHF/TableProducer/candidateCreator3Prong.cxx index d7ef746c6f2..2e04ffe4eb0 100644 --- a/PWGHF/TableProducer/candidateCreator3Prong.cxx +++ b/PWGHF/TableProducer/candidateCreator3Prong.cxx @@ -29,6 +29,7 @@ #include "PWGHF/DataModel/CandidateReconstructionTables.h" #include "PWGHF/Utils/utilsBfieldCCDB.h" #include "PWGHF/Utils/utilsEvSelHf.h" +#include "PWGHF/Utils/utilsMonitorCollisions.h" using namespace o2; using namespace o2::analysis; @@ -310,48 +311,6 @@ struct HfCandidateCreator3Prong { } } - template - void monitorCollisions(Coll const& collisions) - { - - /// loop over collisions - for (const auto& collision : collisions) { - - hCollisions->Fill(0); // all collisions - const float posZ = collision.posZ(); - hPosZBeforeEvSel->Fill(posZ); - - /// bitmask with event. selection info - const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); - - /// centrality - if (TESTBIT(statusCollision, EventRejection::Centrality)) { - continue; - } - hCollisions->Fill(1); // Centrality ok - - /// sel8() - if (useSel8Trigger && TESTBIT(statusCollision, EventRejection::Trigger)) { - continue; - } - hCollisions->Fill(2); // Centrality + sel8 ok - - /// PV position Z - if (TESTBIT(statusCollision, EventRejection::PositionZ)) { - continue; - } - hCollisions->Fill(3); // Centrality + sel8 + posZ ok - - /// Time Frame border cut - if (useTimeFrameBorderCut && TESTBIT(statusCollision, EventRejection::TimeFrameBorderCut)) { - continue; - } - hCollisions->Fill(4); // Centrality + sel8 + posZ + TF border ok - hPosZAfterEvSel->Fill(posZ); - - } /// end loop over collisions - } - /////////////////////////////////// /// /// /// No centrality selection /// @@ -439,21 +398,48 @@ struct HfCandidateCreator3Prong { /// @brief process function to monitor collisions - no centrality void processCollisions(soa::Join const& collisions) { - monitorCollisions(collisions); + /// loop over collisions + for (const auto& collision : collisions) { + + /// bitmask with event. selection info + const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + + /// monitor the satisfied event selections + monitorCollision(collision, statusCollision, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); + + } /// end loop over collisions } PROCESS_SWITCH(HfCandidateCreator3Prong, processCollisions, "Collision monitoring - no centrality", true); /// @brief process function to monitor collisions - FT0C centrality void processCollisionsCentFT0C(soa::Join const& collisions) { - monitorCollisions(collisions); + /// loop over collisions + for (const auto& collision : collisions) { + + /// bitmask with event. selection info + const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + + /// monitor the satisfied event selections + monitorCollision(collision, statusCollision, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); + + } /// end loop over collisions } PROCESS_SWITCH(HfCandidateCreator3Prong, processCollisionsCentFT0C, "Collision monitoring - FT0C centrality", false); /// @brief process function to monitor collisions - FT0M centrality void processCollisionsCentFT0M(soa::Join const& collisions) { - monitorCollisions(collisions); + /// loop over collisions + for (const auto& collision : collisions) { + + /// bitmask with event. selection info + const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + + /// monitor the satisfied event selections + monitorCollision(collision, statusCollision, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); + + } /// end loop over collisions } PROCESS_SWITCH(HfCandidateCreator3Prong, processCollisionsCentFT0M, "Collision monitoring - FT0M centrality", false); }; diff --git a/PWGHF/Utils/utilsMonitorCollisions.h b/PWGHF/Utils/utilsMonitorCollisions.h new file mode 100644 index 00000000000..9be6f55f517 --- /dev/null +++ b/PWGHF/Utils/utilsMonitorCollisions.h @@ -0,0 +1,58 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +/// \file utilsMonitoCollisions.h +/// \brief Utility to monitor collisions passing the event selections for HF analyses +/// \author Mattia Faggin , CERN + +#ifndef PWGHF_UTILS_MONITORCOLLISIONS_H_ +#define PWGHF_UTILS_MONITORCOLLISIONS_H_ + +/// @brief function to monitor the event selection satisfied by collisions used for HF analyses +/// \param collisions are the collisions in the DF +/// \param hCollisions is a histogram to keep track of the satisfied event selections +/// \param hPosZBeforeEvSel is PV position Z for all analysed collisions +/// \param hPosZAfterEvSel is PV position Z only for collisions satisfying the event selections +template +void monitorCollision(Coll const& collision, const uint16_t statusCollision, Hist const& hCollisions, Hist const& hPosZBeforeEvSel, Hist const& hPosZAfterEvSel) +{ + + hCollisions->Fill(0); // all collisions + const float posZ = collision.posZ(); + hPosZBeforeEvSel->Fill(posZ); + + /// centrality + if (TESTBIT(statusCollision, EventRejection::Centrality)) { + return; + } + hCollisions->Fill(1); // Centrality ok + + /// sel8() + if (TESTBIT(statusCollision, EventRejection::Trigger)) { + return; + } + hCollisions->Fill(2); // Centrality + sel8 ok + + /// PV position Z + if (TESTBIT(statusCollision, EventRejection::PositionZ)) { + return; + } + hCollisions->Fill(3); // Centrality + sel8 + posZ ok + + /// Time Frame border cut + if (TESTBIT(statusCollision, EventRejection::TimeFrameBorderCut)) { + return; + } + hCollisions->Fill(4); // Centrality + sel8 + posZ + TF border ok + hPosZAfterEvSel->Fill(posZ); +} + +#endif \ No newline at end of file From 6aa7b49366831efeaad2f9a436056d2b9c4871c9 Mon Sep 17 00:00:00 2001 From: Mattia Faggin Date: Wed, 13 Mar 2024 18:48:44 +0100 Subject: [PATCH 04/11] Simplify ev. selection in candidate loop and add collision processes in other creators. --- .../TableProducer/candidateCreator2Prong.cxx | 112 +++++++++++++----- .../TableProducer/candidateCreator3Prong.cxx | 16 +-- .../TableProducer/candidateCreatorCascade.cxx | 95 ++++++++++++--- PWGHF/TableProducer/candidateCreatorDstar.cxx | 97 ++++++++++++--- PWGHF/Utils/utilsMonitorCollisions.h | 4 +- 5 files changed, 251 insertions(+), 73 deletions(-) diff --git a/PWGHF/TableProducer/candidateCreator2Prong.cxx b/PWGHF/TableProducer/candidateCreator2Prong.cxx index ee99d4f4645..8c6a6d1963b 100644 --- a/PWGHF/TableProducer/candidateCreator2Prong.cxx +++ b/PWGHF/TableProducer/candidateCreator2Prong.cxx @@ -40,6 +40,7 @@ #include "PWGHF/DataModel/CandidateReconstructionTables.h" #include "PWGHF/Utils/utilsBfieldCCDB.h" #include "PWGHF/Utils/utilsEvSelHf.h" +#include "PWGHF/Utils/utilsMonitorCollisions.h" using namespace o2; using namespace o2::analysis; @@ -102,6 +103,9 @@ struct HfCandidateCreator2Prong { OutputObj hDcaXYProngs{TH2F("hDcaXYProngs", "DCAxy of 2-prong candidates;#it{p}_{T} (GeV/#it{c};#it{d}_{xy}) (#mum);entries", 100, 0., 20., 200, -500., 500.)}; OutputObj hDcaZProngs{TH2F("hDcaZProngs", "DCAz of 2-prong candidates;#it{p}_{T} (GeV/#it{c};#it{d}_{z}) (#mum);entries", 100, 0., 20., 200, -500., 500.)}; OutputObj hVertexerType{TH1F("hVertexerType", "Use KF or DCAFitterN;Vertexer type;entries", 2, -0.5, 1.5)}; // See o2::aod::hf_cand::VertexerType + OutputObj hCollisions{TH1D("hCollisions", "HF event counter", 5, -0.5, 4.5)}; + OutputObj hPosZBeforeEvSel{TH1D("hPosZBeforeEvSel", "PV position Z before ev. selection;posZ (cm);entries", 400, -20, 20)}; + OutputObj hPosZAfterEvSel{TH1D("hPosZAfterEvSel", "PV position Z after ev. selection;posZ (cm);entries", 400, -20, 20)}; void init(InitContext const&) { @@ -115,6 +119,20 @@ struct HfCandidateCreator2Prong { LOGP(fatal, "One and only one process function must be enabled at a time."); } + std::array processesCollisions = {doprocessCollisions, doprocessCollisionsCentFT0C, doprocessCollisionsCentFT0M}; + if (std::accumulate(processesCollisions.begin(), processesCollisions.end(), 0) != 1) { + LOGP(fatal, "One and only one process function for collision monitoring must be enabled at a time."); + } + if ((doprocessPvRefitWithDCAFitterN || doprocessNoPvRefitWithDCAFitterN || doprocessPvRefitWithKFParticle || doprocessNoPvRefitWithKFParticle) && !doprocessCollisions) { + LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisions\"?"); + } + if ((doprocessPvRefitWithDCAFitterNCentFT0C || doprocessNoPvRefitWithDCAFitterNCentFT0C || doprocessPvRefitWithKFParticleCentFT0C || doprocessNoPvRefitWithKFParticleCentFT0C) && !doprocessCollisionsCentFT0C) { + LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisionsCentFT0C\"?"); + } + if ((doprocessPvRefitWithDCAFitterNCentFT0M || doprocessNoPvRefitWithDCAFitterNCentFT0M || doprocessPvRefitWithKFParticleCentFT0M || doprocessNoPvRefitWithKFParticleCentFT0M) && !doprocessCollisionsCentFT0M) { + LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisionsCentFT0M\"?"); + } + massPi = MassPiPlus; massK = MassKPlus; @@ -139,6 +157,13 @@ struct HfCandidateCreator2Prong { ccdb->setLocalObjectValidityChecking(); lut = o2::base::MatLayerCylSet::rectifyPtrFromFile(ccdb->get(ccdbPathLut)); runNumber = 0; + + /// collision monitoring + hCollisions->GetXaxis()->SetBinLabel(1, "All collisions"); + hCollisions->GetXaxis()->SetBinLabel(2, "Centrality ok"); + hCollisions->GetXaxis()->SetBinLabel(3, "Centrality + sel8 ok"); + hCollisions->GetXaxis()->SetBinLabel(4, "Centrality + sel8 + posZ ok"); + hCollisions->GetXaxis()->SetBinLabel(5, "Centrality + sel8 + posZ + TF border ok"); } template @@ -153,21 +178,8 @@ struct HfCandidateCreator2Prong { /// reject candidates not satisfying the event selections auto collision = rowTrackIndexProng2.template collision_as(); const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); - - if (TESTBIT(statusCollision, EventRejection::Centrality)) { - /// event selection - centrality - continue; - } - if (useSel8Trigger && TESTBIT(statusCollision, EventRejection::Trigger)) { - /// event selection - sel8() - continue; - } - if (TESTBIT(statusCollision, EventRejection::PositionZ)) { - /// event selection - PV position Z - continue; - } - if (useTimeFrameBorderCut && TESTBIT(statusCollision, EventRejection::TimeFrameBorderCut)) { - /// event selection - Time Frame border cut + if (statusCollision != 0) { + /// at least one event selection not satisfied --> reject the candidate continue; } @@ -295,20 +307,8 @@ struct HfCandidateCreator2Prong { /// reject candidates in collisions not satisfying the event selections auto collision = rowTrackIndexProng2.template collision_as(); const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); - if (TESTBIT(statusCollision, EventRejection::Centrality)) { - /// event selection - centrality - continue; - } - if (useSel8Trigger && TESTBIT(statusCollision, EventRejection::Trigger)) { - /// event selection - sel8() - continue; - } - if (TESTBIT(statusCollision, EventRejection::PositionZ)) { - /// event selection - PV position Z - continue; - } - if (useTimeFrameBorderCut && TESTBIT(statusCollision, EventRejection::TimeFrameBorderCut)) { - /// event selection - Time Frame border cut + if (statusCollision != 0) { + /// at least one event selection not satisfied --> reject the candidate continue; } @@ -571,6 +571,60 @@ struct HfCandidateCreator2Prong { runCreator2ProngWithKFParticle(collisions, rowsTrackIndexProng2, tracks, bcWithTimeStamps); } PROCESS_SWITCH(HfCandidateCreator2Prong, processNoPvRefitWithKFParticleCentFT0M, "Run candidate creator using KFParticle package w/o PV refit and w/ centrality selection on FT0M", false); + + /////////////////////////////////////////////////////////// + /// /// + /// Process functions only for collision monitoring /// + /// /// + /////////////////////////////////////////////////////////// + + /// @brief process function to monitor collisions - no centrality + void processCollisions(soa::Join const& collisions) + { + /// loop over collisions + for (const auto& collision : collisions) { + + /// bitmask with event. selection info + const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + + /// monitor the satisfied event selections + monitorCollision(collision, statusCollision, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); + + } /// end loop over collisions + } + PROCESS_SWITCH(HfCandidateCreator2Prong, processCollisions, "Collision monitoring - no centrality", true); + + /// @brief process function to monitor collisions - FT0C centrality + void processCollisionsCentFT0C(soa::Join const& collisions) + { + /// loop over collisions + for (const auto& collision : collisions) { + + /// bitmask with event. selection info + const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + + /// monitor the satisfied event selections + monitorCollision(collision, statusCollision, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); + + } /// end loop over collisions + } + PROCESS_SWITCH(HfCandidateCreator2Prong, processCollisionsCentFT0C, "Collision monitoring - FT0C centrality", false); + + /// @brief process function to monitor collisions - FT0M centrality + void processCollisionsCentFT0M(soa::Join const& collisions) + { + /// loop over collisions + for (const auto& collision : collisions) { + + /// bitmask with event. selection info + const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + + /// monitor the satisfied event selections + monitorCollision(collision, statusCollision, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); + + } /// end loop over collisions + } + PROCESS_SWITCH(HfCandidateCreator2Prong, processCollisionsCentFT0M, "Collision monitoring - FT0M centrality", false); }; /// Extends the base table with expression columns. diff --git a/PWGHF/TableProducer/candidateCreator3Prong.cxx b/PWGHF/TableProducer/candidateCreator3Prong.cxx index 2e04ffe4eb0..4983f00c82e 100644 --- a/PWGHF/TableProducer/candidateCreator3Prong.cxx +++ b/PWGHF/TableProducer/candidateCreator3Prong.cxx @@ -171,20 +171,8 @@ struct HfCandidateCreator3Prong { /// reject candidates in collisions not satisfying the event selections auto collision = rowTrackIndexProng3.template collision_as(); uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); - if (TESTBIT(statusCollision, EventRejection::Centrality)) { - /// event selection - centrality - continue; - } - if (useSel8Trigger && TESTBIT(statusCollision, EventRejection::Trigger)) { - /// event selection - sel8() - continue; - } - if (TESTBIT(statusCollision, EventRejection::PositionZ)) { - /// event selection - PV position Z - continue; - } - if (useTimeFrameBorderCut && TESTBIT(statusCollision, EventRejection::TimeFrameBorderCut)) { - /// event selection - Time Frame border cut + if (statusCollision != 0) { + /// at least one event selection not satisfied --> reject the candidate continue; } diff --git a/PWGHF/TableProducer/candidateCreatorCascade.cxx b/PWGHF/TableProducer/candidateCreatorCascade.cxx index db230cc64c6..4c20f51dc8d 100644 --- a/PWGHF/TableProducer/candidateCreatorCascade.cxx +++ b/PWGHF/TableProducer/candidateCreatorCascade.cxx @@ -29,6 +29,7 @@ #include "PWGHF/DataModel/CandidateReconstructionTables.h" #include "PWGHF/Utils/utilsBfieldCCDB.h" #include "PWGHF/Utils/utilsEvSelHf.h" +#include "PWGHF/Utils/utilsMonitorCollisions.h" using namespace o2; using namespace o2::analysis; @@ -81,6 +82,9 @@ struct HfCandidateCreatorCascade { OutputObj hMass2{TH1F("hMass2", "2-prong candidates;inv. mass (p K_{S}^{0}) (GeV/#it{c}^{2});entries", 500, 0., 5.)}; OutputObj hCovPVXX{TH1F("hCovPVXX", "2-prong candidates;XX element of cov. matrix of prim. vtx. position (cm^{2});entries", 100, 0., 1.e-4)}; OutputObj hCovSVXX{TH1F("hCovSVXX", "2-prong candidates;XX element of cov. matrix of sec. vtx. position (cm^{2});entries", 100, 0., 0.2)}; + OutputObj hCollisions{TH1D("hCollisions", "HF event counter", 5, -0.5, 4.5)}; + OutputObj hPosZBeforeEvSel{TH1D("hPosZBeforeEvSel", "PV position Z before ev. selection;posZ (cm);entries", 400, -20, 20)}; + OutputObj hPosZAfterEvSel{TH1D("hPosZAfterEvSel", "PV position Z after ev. selection;posZ (cm);entries", 400, -20, 20)}; void init(InitContext const&) { @@ -89,6 +93,20 @@ struct HfCandidateCreatorCascade { LOGP(fatal, "One and only one process function must be enabled at a time."); } + std::array processesCollisions = {doprocessCollisions, doprocessCollisionsCentFT0C, doprocessCollisionsCentFT0M}; + if (std::accumulate(processesCollisions.begin(), processesCollisions.end(), 0) != 1) { + LOGP(fatal, "One and only one process function for collision monitoring must be enabled at a time."); + } + if (doprocessNoCent && !doprocessCollisions) { + LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisions\"?"); + } + if (doprocessCentFT0C && !doprocessCollisionsCentFT0C) { + LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisionsCentFT0C\"?"); + } + if (doprocessCentFT0M && !doprocessCollisionsCentFT0M) { + LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisionsCentFT0M\"?"); + } + massP = MassProton; massK0s = MassK0Short; massPi = MassPiPlus; @@ -108,6 +126,13 @@ struct HfCandidateCreatorCascade { ccdb->setLocalObjectValidityChecking(); lut = o2::base::MatLayerCylSet::rectifyPtrFromFile(ccdb->get(ccdbPathLut)); runNumber = 0; + + /// collision monitoring + hCollisions->GetXaxis()->SetBinLabel(1, "All collisions"); + hCollisions->GetXaxis()->SetBinLabel(2, "Centrality ok"); + hCollisions->GetXaxis()->SetBinLabel(3, "Centrality + sel8 ok"); + hCollisions->GetXaxis()->SetBinLabel(4, "Centrality + sel8 + posZ ok"); + hCollisions->GetXaxis()->SetBinLabel(5, "Centrality + sel8 + posZ + TF border ok"); } template @@ -125,20 +150,8 @@ struct HfCandidateCreatorCascade { /// reject candidates in collisions not satisfying the event selections auto collision = casc.template collision_as(); const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); - if (TESTBIT(statusCollision, EventRejection::Centrality)) { - /// event selection - centrality - continue; - } - if (useSel8Trigger && TESTBIT(statusCollision, EventRejection::Trigger)) { - /// event selection - sel8() - continue; - } - if (TESTBIT(statusCollision, EventRejection::PositionZ)) { - /// event selection - PV position Z - continue; - } - if (useTimeFrameBorderCut && TESTBIT(statusCollision, EventRejection::TimeFrameBorderCut)) { - /// event selection - Time Frame border cut + if (statusCollision != 0) { + /// at least one event selection not satisfied --> reject the candidate continue; } @@ -343,6 +356,60 @@ struct HfCandidateCreatorCascade { runCreatorCascade(collisions, rowsTrackIndexCasc, v0sLinked, v0Data, v0fCDatas, tracks, bcs); } PROCESS_SWITCH(HfCandidateCreatorCascade, processCentFT0M, " Run candidate creator w/ centrality selection on FT0M", false); + + /////////////////////////////////////////////////////////// + /// /// + /// Process functions only for collision monitoring /// + /// /// + /////////////////////////////////////////////////////////// + + /// @brief process function to monitor collisions - no centrality + void processCollisions(soa::Join const& collisions) + { + /// loop over collisions + for (const auto& collision : collisions) { + + /// bitmask with event. selection info + const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + + /// monitor the satisfied event selections + monitorCollision(collision, statusCollision, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); + + } /// end loop over collisions + } + PROCESS_SWITCH(HfCandidateCreatorCascade, processCollisions, "Collision monitoring - no centrality", true); + + /// @brief process function to monitor collisions - FT0C centrality + void processCollisionsCentFT0C(soa::Join const& collisions) + { + /// loop over collisions + for (const auto& collision : collisions) { + + /// bitmask with event. selection info + const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + + /// monitor the satisfied event selections + monitorCollision(collision, statusCollision, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); + + } /// end loop over collisions + } + PROCESS_SWITCH(HfCandidateCreatorCascade, processCollisionsCentFT0C, "Collision monitoring - FT0C centrality", false); + + /// @brief process function to monitor collisions - FT0M centrality + void processCollisionsCentFT0M(soa::Join const& collisions) + { + /// loop over collisions + for (const auto& collision : collisions) { + + /// bitmask with event. selection info + const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + + /// monitor the satisfied event selections + monitorCollision(collision, statusCollision, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); + + } /// end loop over collisions + } + PROCESS_SWITCH(HfCandidateCreatorCascade, processCollisionsCentFT0M, "Collision monitoring - FT0M centrality", false); }; /// Performs MC matching. diff --git a/PWGHF/TableProducer/candidateCreatorDstar.cxx b/PWGHF/TableProducer/candidateCreatorDstar.cxx index 6f9533cab5a..a93b14312cc 100644 --- a/PWGHF/TableProducer/candidateCreatorDstar.cxx +++ b/PWGHF/TableProducer/candidateCreatorDstar.cxx @@ -30,6 +30,7 @@ #include "PWGHF/DataModel/CandidateReconstructionTables.h" #include "PWGHF/Utils/utilsBfieldCCDB.h" #include "PWGHF/Utils/utilsEvSelHf.h" +#include "PWGHF/Utils/utilsMonitorCollisions.h" using namespace o2; using namespace o2::aod::hf_collision_centrality; @@ -107,6 +108,10 @@ struct HfCandidateCreatorDstar { {"QA/hPtD0", "D^{0} candidates", {HistType::kTH1F, {ptAxis}}}, {"QA/hPtDstar", "D* candidates", {HistType::kTH1F, {ptAxis}}}}}; + OutputObj hCollisions{TH1D("hCollisions", "HF event counter", 5, -0.5, 4.5)}; + OutputObj hPosZBeforeEvSel{TH1D("hPosZBeforeEvSel", "PV position Z before ev. selection;posZ (cm);entries", 400, -20, 20)}; + OutputObj hPosZAfterEvSel{TH1D("hPosZAfterEvSel", "PV position Z after ev. selection;posZ (cm);entries", 400, -20, 20)}; + /// @brief This function initializes the ccdb setting, vertex fitter and runs function MatLayerCylSet::rectifyPtrFromFile(..args..) void init(InitContext const&) { @@ -116,6 +121,21 @@ struct HfCandidateCreatorDstar { if (std::accumulate(processes.begin(), processes.end(), 0) != 1) { LOGP(fatal, "One and only one process function must be enabled at a time."); } + + std::array processesCollisions = {doprocessCollisions, doprocessCollisionsCentFT0C, doprocessCollisionsCentFT0M}; + if (std::accumulate(processesCollisions.begin(), processesCollisions.end(), 0) != 1) { + LOGP(fatal, "One and only one process function for collision monitoring must be enabled at a time."); + } + if ((doprocessPvRefit || doprocessNoPvRefit) && !doprocessCollisions) { + LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisions\"?"); + } + if ((doprocessPvRefitCentFT0C || doprocessNoPvRefitCentFT0C) && !doprocessCollisionsCentFT0C) { + LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisionsCentFT0C\"?"); + } + if ((doprocessPvRefitCentFT0M || doprocessNoPvRefitCentFT0M) && !doprocessCollisionsCentFT0M) { + LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisionsCentFT0M\"?"); + } + // LOG(info) << "Init Function Invoked"; massPi = MassPiPlus; massK = MassKPlus; @@ -135,6 +155,13 @@ struct HfCandidateCreatorDstar { ccdb->setLocalObjectValidityChecking(); // set the flag to check object validity before CCDB query runNumber = 0; bz = 0; + + /// collision monitoring + hCollisions->GetXaxis()->SetBinLabel(1, "All collisions"); + hCollisions->GetXaxis()->SetBinLabel(2, "Centrality ok"); + hCollisions->GetXaxis()->SetBinLabel(3, "Centrality + sel8 ok"); + hCollisions->GetXaxis()->SetBinLabel(4, "Centrality + sel8 + posZ ok"); + hCollisions->GetXaxis()->SetBinLabel(5, "Centrality + sel8 + posZ + TF border ok"); } /// @brief function for secondary vertex reconstruction and candidate creator @@ -160,20 +187,8 @@ struct HfCandidateCreatorDstar { /// reject candidates in collisions not satisfying the event selections auto collision = rowTrackIndexDstar.template collision_as(); const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); - if (TESTBIT(statusCollision, EventRejection::Centrality)) { - /// event selection - centrality - continue; - } - if (useSel8Trigger && TESTBIT(statusCollision, EventRejection::Trigger)) { - /// event selection - sel8() - continue; - } - if (TESTBIT(statusCollision, EventRejection::PositionZ)) { - /// event selection - PV position Z - continue; - } - if (useTimeFrameBorderCut && TESTBIT(statusCollision, EventRejection::TimeFrameBorderCut)) { - /// event selection - Time Frame border cut + if (statusCollision != 0) { + /// at least one event selection not satisfied --> reject the candidate continue; } @@ -412,6 +427,60 @@ struct HfCandidateCreatorDstar { runCreatorDstar(collisions, rowsTrackIndexDstar, rowsTrackIndexD0, tracks, bcWithTimeStamps); } PROCESS_SWITCH(HfCandidateCreatorDstar, processNoPvRefitCentFT0M, " Run candidate creator without PV refit and w/ centrality selection on FT0M", false); + + /////////////////////////////////////////////////////////// + /// /// + /// Process functions only for collision monitoring /// + /// /// + /////////////////////////////////////////////////////////// + + /// @brief process function to monitor collisions - no centrality + void processCollisions(soa::Join const& collisions) + { + /// loop over collisions + for (const auto& collision : collisions) { + + /// bitmask with event. selection info + const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + + /// monitor the satisfied event selections + monitorCollision(collision, statusCollision, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); + + } /// end loop over collisions + } + PROCESS_SWITCH(HfCandidateCreatorDstar, processCollisions, "Collision monitoring - no centrality", true); + + /// @brief process function to monitor collisions - FT0C centrality + void processCollisionsCentFT0C(soa::Join const& collisions) + { + /// loop over collisions + for (const auto& collision : collisions) { + + /// bitmask with event. selection info + const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + + /// monitor the satisfied event selections + monitorCollision(collision, statusCollision, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); + + } /// end loop over collisions + } + PROCESS_SWITCH(HfCandidateCreatorDstar, processCollisionsCentFT0C, "Collision monitoring - FT0C centrality", false); + + /// @brief process function to monitor collisions - FT0M centrality + void processCollisionsCentFT0M(soa::Join const& collisions) + { + /// loop over collisions + for (const auto& collision : collisions) { + + /// bitmask with event. selection info + const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + + /// monitor the satisfied event selections + monitorCollision(collision, statusCollision, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); + + } /// end loop over collisions + } + PROCESS_SWITCH(HfCandidateCreatorDstar, processCollisionsCentFT0M, "Collision monitoring - FT0M centrality", false); }; struct HfCandidateCreatorDstarExpressions { diff --git a/PWGHF/Utils/utilsMonitorCollisions.h b/PWGHF/Utils/utilsMonitorCollisions.h index 9be6f55f517..65a7f5d2d48 100644 --- a/PWGHF/Utils/utilsMonitorCollisions.h +++ b/PWGHF/Utils/utilsMonitorCollisions.h @@ -13,8 +13,8 @@ /// \brief Utility to monitor collisions passing the event selections for HF analyses /// \author Mattia Faggin , CERN -#ifndef PWGHF_UTILS_MONITORCOLLISIONS_H_ -#define PWGHF_UTILS_MONITORCOLLISIONS_H_ +#ifndef PWGHF_UTILS_UTILSMONITORCOLLISIONS_H_ +#define PWGHF_UTILS_UTILSMONITORCOLLISIONS_H_ /// @brief function to monitor the event selection satisfied by collisions used for HF analyses /// \param collisions are the collisions in the DF From de6598aa5404a8d3bb8ec6dad6a931fa0f351dac Mon Sep 17 00:00:00 2001 From: Mattia Faggin Date: Wed, 13 Mar 2024 19:03:25 +0100 Subject: [PATCH 05/11] Fix MegaLinter. --- PWGHF/Utils/utilsMonitorCollisions.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGHF/Utils/utilsMonitorCollisions.h b/PWGHF/Utils/utilsMonitorCollisions.h index 65a7f5d2d48..e3c9768e157 100644 --- a/PWGHF/Utils/utilsMonitorCollisions.h +++ b/PWGHF/Utils/utilsMonitorCollisions.h @@ -55,4 +55,4 @@ void monitorCollision(Coll const& collision, const uint16_t statusCollision, His hPosZAfterEvSel->Fill(posZ); } -#endif \ No newline at end of file +#endif // PWGHF_UTILS_UTILSMONITORCOLLISIONS_H_ From c8c59a1ec430e5a4fd71f366fffde34f805d1d62 Mon Sep 17 00:00:00 2001 From: Mattia Faggin Date: Wed, 13 Mar 2024 19:53:33 +0100 Subject: [PATCH 06/11] Address comments. --- .../TableProducer/candidateCreator2Prong.cxx | 25 ++++---- .../TableProducer/candidateCreator3Prong.cxx | 19 +++--- .../TableProducer/candidateCreatorCascade.cxx | 19 +++--- PWGHF/TableProducer/candidateCreatorDstar.cxx | 19 +++--- PWGHF/Utils/utilsEvSelHf.h | 55 +++++++++++++++--- PWGHF/Utils/utilsMonitorCollisions.h | 58 ------------------- 6 files changed, 86 insertions(+), 109 deletions(-) delete mode 100644 PWGHF/Utils/utilsMonitorCollisions.h diff --git a/PWGHF/TableProducer/candidateCreator2Prong.cxx b/PWGHF/TableProducer/candidateCreator2Prong.cxx index 8c6a6d1963b..bd74b3a9e47 100644 --- a/PWGHF/TableProducer/candidateCreator2Prong.cxx +++ b/PWGHF/TableProducer/candidateCreator2Prong.cxx @@ -40,7 +40,6 @@ #include "PWGHF/DataModel/CandidateReconstructionTables.h" #include "PWGHF/Utils/utilsBfieldCCDB.h" #include "PWGHF/Utils/utilsEvSelHf.h" -#include "PWGHF/Utils/utilsMonitorCollisions.h" using namespace o2; using namespace o2::analysis; @@ -166,7 +165,7 @@ struct HfCandidateCreator2Prong { hCollisions->GetXaxis()->SetBinLabel(5, "Centrality + sel8 + posZ + TF border ok"); } - template + template void runCreator2ProngWithDCAFitterN(Coll const& collisions, CandType const& rowsTrackIndexProng2, TTracks const& tracks, @@ -177,8 +176,8 @@ struct HfCandidateCreator2Prong { /// reject candidates not satisfying the event selections auto collision = rowTrackIndexProng2.template collision_as(); - const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); - if (statusCollision != 0) { + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + if (rejectionMask != 0) { /// at least one event selection not satisfied --> reject the candidate continue; } @@ -295,7 +294,7 @@ struct HfCandidateCreator2Prong { } } - template + template void runCreator2ProngWithKFParticle(Coll const& collisions, CandType const& rowsTrackIndexProng2, TTracks const& tracks, @@ -306,8 +305,8 @@ struct HfCandidateCreator2Prong { /// reject candidates in collisions not satisfying the event selections auto collision = rowTrackIndexProng2.template collision_as(); - const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); - if (statusCollision != 0) { + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + if (rejectionMask != 0) { /// at least one event selection not satisfied --> reject the candidate continue; } @@ -585,10 +584,10 @@ struct HfCandidateCreator2Prong { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections - monitorCollision(collision, statusCollision, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); + monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); } /// end loop over collisions } @@ -601,10 +600,10 @@ struct HfCandidateCreator2Prong { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections - monitorCollision(collision, statusCollision, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); + monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); } /// end loop over collisions } @@ -617,10 +616,10 @@ struct HfCandidateCreator2Prong { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections - monitorCollision(collision, statusCollision, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); + monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); } /// end loop over collisions } diff --git a/PWGHF/TableProducer/candidateCreator3Prong.cxx b/PWGHF/TableProducer/candidateCreator3Prong.cxx index 4983f00c82e..0342a9e95ca 100644 --- a/PWGHF/TableProducer/candidateCreator3Prong.cxx +++ b/PWGHF/TableProducer/candidateCreator3Prong.cxx @@ -29,7 +29,6 @@ #include "PWGHF/DataModel/CandidateReconstructionTables.h" #include "PWGHF/Utils/utilsBfieldCCDB.h" #include "PWGHF/Utils/utilsEvSelHf.h" -#include "PWGHF/Utils/utilsMonitorCollisions.h" using namespace o2; using namespace o2::analysis; @@ -159,7 +158,7 @@ struct HfCandidateCreator3Prong { hCollisions->GetXaxis()->SetBinLabel(5, "Centrality + sel8 + posZ + TF border ok"); } - template + template void runCreator3Prong(Coll const& collisions, Cand const& rowsTrackIndexProng3, aod::TracksWCovExtra const& tracks, @@ -170,8 +169,8 @@ struct HfCandidateCreator3Prong { /// reject candidates in collisions not satisfying the event selections auto collision = rowTrackIndexProng3.template collision_as(); - uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); - if (statusCollision != 0) { + uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + if (rejectionMask != 0) { /// at least one event selection not satisfied --> reject the candidate continue; } @@ -390,10 +389,10 @@ struct HfCandidateCreator3Prong { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections - monitorCollision(collision, statusCollision, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); + monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); } /// end loop over collisions } @@ -406,10 +405,10 @@ struct HfCandidateCreator3Prong { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections - monitorCollision(collision, statusCollision, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); + monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); } /// end loop over collisions } @@ -422,10 +421,10 @@ struct HfCandidateCreator3Prong { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections - monitorCollision(collision, statusCollision, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); + monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); } /// end loop over collisions } diff --git a/PWGHF/TableProducer/candidateCreatorCascade.cxx b/PWGHF/TableProducer/candidateCreatorCascade.cxx index 4c20f51dc8d..f21243b49ba 100644 --- a/PWGHF/TableProducer/candidateCreatorCascade.cxx +++ b/PWGHF/TableProducer/candidateCreatorCascade.cxx @@ -29,7 +29,6 @@ #include "PWGHF/DataModel/CandidateReconstructionTables.h" #include "PWGHF/Utils/utilsBfieldCCDB.h" #include "PWGHF/Utils/utilsEvSelHf.h" -#include "PWGHF/Utils/utilsMonitorCollisions.h" using namespace o2; using namespace o2::analysis; @@ -135,7 +134,7 @@ struct HfCandidateCreatorCascade { hCollisions->GetXaxis()->SetBinLabel(5, "Centrality + sel8 + posZ + TF border ok"); } - template + template void runCreatorCascade(Coll const&, aod::HfCascades const& rowsTrackIndexCasc, aod::V0sLinked const&, @@ -149,8 +148,8 @@ struct HfCandidateCreatorCascade { /// reject candidates in collisions not satisfying the event selections auto collision = casc.template collision_as(); - const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); - if (statusCollision != 0) { + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + if (rejectionMask != 0) { /// at least one event selection not satisfied --> reject the candidate continue; } @@ -370,10 +369,10 @@ struct HfCandidateCreatorCascade { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections - monitorCollision(collision, statusCollision, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); + monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); } /// end loop over collisions } @@ -386,10 +385,10 @@ struct HfCandidateCreatorCascade { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections - monitorCollision(collision, statusCollision, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); + monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); } /// end loop over collisions } @@ -402,10 +401,10 @@ struct HfCandidateCreatorCascade { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections - monitorCollision(collision, statusCollision, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); + monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); } /// end loop over collisions } diff --git a/PWGHF/TableProducer/candidateCreatorDstar.cxx b/PWGHF/TableProducer/candidateCreatorDstar.cxx index a93b14312cc..2929021eddb 100644 --- a/PWGHF/TableProducer/candidateCreatorDstar.cxx +++ b/PWGHF/TableProducer/candidateCreatorDstar.cxx @@ -30,7 +30,6 @@ #include "PWGHF/DataModel/CandidateReconstructionTables.h" #include "PWGHF/Utils/utilsBfieldCCDB.h" #include "PWGHF/Utils/utilsEvSelHf.h" -#include "PWGHF/Utils/utilsMonitorCollisions.h" using namespace o2; using namespace o2::aod::hf_collision_centrality; @@ -172,7 +171,7 @@ struct HfCandidateCreatorDstar { /// @param rowsTrackIndexD0 D0 table object from trackIndexSkimCreator.cxx /// @param tracks track table with Cov object /// @param bcWithTimeStamps Bunch Crossing with timestamps - template + template void runCreatorDstar(Coll const& collisions, CandsDstar const& rowsTrackIndexDstar, aod::Hf2Prongs const& rowsTrackIndexD0, @@ -186,8 +185,8 @@ struct HfCandidateCreatorDstar { /// reject candidates in collisions not satisfying the event selections auto collision = rowTrackIndexDstar.template collision_as(); - const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); - if (statusCollision != 0) { + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + if (rejectionMask != 0) { /// at least one event selection not satisfied --> reject the candidate continue; } @@ -441,10 +440,10 @@ struct HfCandidateCreatorDstar { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections - monitorCollision(collision, statusCollision, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); + monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); } /// end loop over collisions } @@ -457,10 +456,10 @@ struct HfCandidateCreatorDstar { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections - monitorCollision(collision, statusCollision, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); + monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); } /// end loop over collisions } @@ -473,10 +472,10 @@ struct HfCandidateCreatorDstar { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t statusCollision = isHfCollisionSelected(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections - monitorCollision(collision, statusCollision, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); + monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); } /// end loop over collisions } diff --git a/PWGHF/Utils/utilsEvSelHf.h b/PWGHF/Utils/utilsEvSelHf.h index 6643e41e8c8..aa7b4e91b17 100644 --- a/PWGHF/Utils/utilsEvSelHf.h +++ b/PWGHF/Utils/utilsEvSelHf.h @@ -16,8 +16,6 @@ #ifndef PWGHF_UTILS_UTILSEVSELHF_H_ #define PWGHF_UTILS_UTILSEVSELHF_H_ -using namespace o2::aod::hf_collision_centrality; - // event rejection types enum EventRejection { Trigger = 0, @@ -36,18 +34,18 @@ enum EventRejection { /// \param useSel8Trigger switch to activate the sel8() event selection /// \param zPvPosMax maximum primary-vertex z /// \param useTimeFrameBorderCut switch to activate the time frame border cut -/// \return true if collision satisfies all criteria, false otherwise -template -uint16_t isHfCollisionSelected(const Coll& collision, std::array centralityLimits, bool useSel8Trigger, float maxPvPosZ, bool useTimeFrameBorderCut) +/// \return a bitmask with the event selections not satisfied by the analysed collision +template +uint16_t getHfCollisionRejectionMask(const Coll& collision, std::array centralityLimits, bool useSel8Trigger, float maxPvPosZ, bool useTimeFrameBorderCut) { uint16_t statusCollision = 0; // 16 bits, in case new ev. selections will be added float centrality = -1.; - if constexpr (centEstimator != CentralityEstimator::None) { - if constexpr (centEstimator == CentralityEstimator::FT0C) { + if constexpr (centEstimator != o2::aod::hf_collision_centrality::CentralityEstimator::None) { + if constexpr (centEstimator == o2::aod::hf_collision_centrality::CentralityEstimator::FT0C) { centrality = collision.centFT0C(); - } else if constexpr (centEstimator == CentralityEstimator::FT0M) { + } else if constexpr (centEstimator == o2::aod::hf_collision_centrality::CentralityEstimator::FT0M) { centrality = collision.centFT0M(); } else { LOGP(fatal, "Centrality estimator different from FT0C and FT0M, fix it!"); @@ -76,4 +74,45 @@ uint16_t isHfCollisionSelected(const Coll& collision, std::array centr return statusCollision; } + +/// @brief function to monitor the event selection satisfied by collisions used for HF analyses +/// \param collision is the analysed collision +/// \param rejectionMask is the bitmask storing the info about which ev. selections are not satisfied by the collision +/// \param hCollisions is a histogram to keep track of the satisfied event selections +/// \param hPosZBeforeEvSel is PV position Z for all analysed collisions +/// \param hPosZAfterEvSel is PV position Z only for collisions satisfying the event selections +template +void monitorCollision(Coll const& collision, const uint16_t rejectionMask, Hist const& hCollisions, Hist const& hPosZBeforeEvSel, Hist const& hPosZAfterEvSel) +{ + + hCollisions->Fill(0); // all collisions + const float posZ = collision.posZ(); + hPosZBeforeEvSel->Fill(posZ); + + /// centrality + if (TESTBIT(rejectionMask, EventRejection::Centrality)) { + return; + } + hCollisions->Fill(1); // Centrality ok + + /// sel8() + if (TESTBIT(rejectionMask, EventRejection::Trigger)) { + return; + } + hCollisions->Fill(2); // Centrality + sel8 ok + + /// PV position Z + if (TESTBIT(rejectionMask, EventRejection::PositionZ)) { + return; + } + hCollisions->Fill(3); // Centrality + sel8 + posZ ok + + /// Time Frame border cut + if (TESTBIT(rejectionMask, EventRejection::TimeFrameBorderCut)) { + return; + } + hCollisions->Fill(4); // Centrality + sel8 + posZ + TF border ok + hPosZAfterEvSel->Fill(posZ); +} + #endif // PWGHF_UTILS_UTILSEVSELHF_H_ diff --git a/PWGHF/Utils/utilsMonitorCollisions.h b/PWGHF/Utils/utilsMonitorCollisions.h deleted file mode 100644 index e3c9768e157..00000000000 --- a/PWGHF/Utils/utilsMonitorCollisions.h +++ /dev/null @@ -1,58 +0,0 @@ -// Copyright 2019-2020 CERN and copyright holders of ALICE O2. -// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. -// All rights not expressly granted are reserved. -// -// This software is distributed under the terms of the GNU General Public -// License v3 (GPL Version 3), copied verbatim in the file "COPYING". -// -// In applying this license CERN does not waive the privileges and immunities -// granted to it by virtue of its status as an Intergovernmental Organization -// or submit itself to any jurisdiction. - -/// \file utilsMonitoCollisions.h -/// \brief Utility to monitor collisions passing the event selections for HF analyses -/// \author Mattia Faggin , CERN - -#ifndef PWGHF_UTILS_UTILSMONITORCOLLISIONS_H_ -#define PWGHF_UTILS_UTILSMONITORCOLLISIONS_H_ - -/// @brief function to monitor the event selection satisfied by collisions used for HF analyses -/// \param collisions are the collisions in the DF -/// \param hCollisions is a histogram to keep track of the satisfied event selections -/// \param hPosZBeforeEvSel is PV position Z for all analysed collisions -/// \param hPosZAfterEvSel is PV position Z only for collisions satisfying the event selections -template -void monitorCollision(Coll const& collision, const uint16_t statusCollision, Hist const& hCollisions, Hist const& hPosZBeforeEvSel, Hist const& hPosZAfterEvSel) -{ - - hCollisions->Fill(0); // all collisions - const float posZ = collision.posZ(); - hPosZBeforeEvSel->Fill(posZ); - - /// centrality - if (TESTBIT(statusCollision, EventRejection::Centrality)) { - return; - } - hCollisions->Fill(1); // Centrality ok - - /// sel8() - if (TESTBIT(statusCollision, EventRejection::Trigger)) { - return; - } - hCollisions->Fill(2); // Centrality + sel8 ok - - /// PV position Z - if (TESTBIT(statusCollision, EventRejection::PositionZ)) { - return; - } - hCollisions->Fill(3); // Centrality + sel8 + posZ ok - - /// Time Frame border cut - if (TESTBIT(statusCollision, EventRejection::TimeFrameBorderCut)) { - return; - } - hCollisions->Fill(4); // Centrality + sel8 + posZ + TF border ok - hPosZAfterEvSel->Fill(posZ); -} - -#endif // PWGHF_UTILS_UTILSMONITORCOLLISIONS_H_ From 391688e4b8f270d30c56e41e12040ba2cb701f12 Mon Sep 17 00:00:00 2001 From: Mattia Faggin Date: Thu, 14 Mar 2024 08:35:00 +0100 Subject: [PATCH 07/11] Fix macos compilation error. --- PWGHF/TableProducer/candidateCreator3Prong.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGHF/TableProducer/candidateCreator3Prong.cxx b/PWGHF/TableProducer/candidateCreator3Prong.cxx index 0342a9e95ca..0d7e2ebdc5a 100644 --- a/PWGHF/TableProducer/candidateCreator3Prong.cxx +++ b/PWGHF/TableProducer/candidateCreator3Prong.cxx @@ -158,7 +158,7 @@ struct HfCandidateCreator3Prong { hCollisions->GetXaxis()->SetBinLabel(5, "Centrality + sel8 + posZ + TF border ok"); } - template + template void runCreator3Prong(Coll const& collisions, Cand const& rowsTrackIndexProng3, aod::TracksWCovExtra const& tracks, From 9576674080ceef9ed274e54b67baa5b13e44456e Mon Sep 17 00:00:00 2001 From: Mattia Faggin Date: Thu, 14 Mar 2024 10:51:17 +0100 Subject: [PATCH 08/11] Make collision processes optional. --- .../TableProducer/candidateCreator2Prong.cxx | 23 +++++++++++-------- .../TableProducer/candidateCreator3Prong.cxx | 23 +++++++++++-------- .../TableProducer/candidateCreatorCascade.cxx | 23 +++++++++++-------- PWGHF/TableProducer/candidateCreatorDstar.cxx | 23 +++++++++++-------- 4 files changed, 52 insertions(+), 40 deletions(-) diff --git a/PWGHF/TableProducer/candidateCreator2Prong.cxx b/PWGHF/TableProducer/candidateCreator2Prong.cxx index bd74b3a9e47..a153fa6076f 100644 --- a/PWGHF/TableProducer/candidateCreator2Prong.cxx +++ b/PWGHF/TableProducer/candidateCreator2Prong.cxx @@ -119,17 +119,20 @@ struct HfCandidateCreator2Prong { } std::array processesCollisions = {doprocessCollisions, doprocessCollisionsCentFT0C, doprocessCollisionsCentFT0M}; - if (std::accumulate(processesCollisions.begin(), processesCollisions.end(), 0) != 1) { - LOGP(fatal, "One and only one process function for collision monitoring must be enabled at a time."); + const int nProcessesCollisions = std::accumulate(processesCollisions.begin(), processesCollisions.end(), 0); + if (nProcessesCollisions > 1) { + LOGP(fatal, "At most one process function for collision monitoring can be enabled at a time."); } - if ((doprocessPvRefitWithDCAFitterN || doprocessNoPvRefitWithDCAFitterN || doprocessPvRefitWithKFParticle || doprocessNoPvRefitWithKFParticle) && !doprocessCollisions) { - LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisions\"?"); - } - if ((doprocessPvRefitWithDCAFitterNCentFT0C || doprocessNoPvRefitWithDCAFitterNCentFT0C || doprocessPvRefitWithKFParticleCentFT0C || doprocessNoPvRefitWithKFParticleCentFT0C) && !doprocessCollisionsCentFT0C) { - LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisionsCentFT0C\"?"); - } - if ((doprocessPvRefitWithDCAFitterNCentFT0M || doprocessNoPvRefitWithDCAFitterNCentFT0M || doprocessPvRefitWithKFParticleCentFT0M || doprocessNoPvRefitWithKFParticleCentFT0M) && !doprocessCollisionsCentFT0M) { - LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisionsCentFT0M\"?"); + if (nProcessesCollisions == 1) { + if ((doprocessPvRefitWithDCAFitterN || doprocessNoPvRefitWithDCAFitterN || doprocessPvRefitWithKFParticle || doprocessNoPvRefitWithKFParticle) && !doprocessCollisions) { + LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisions\"?"); + } + if ((doprocessPvRefitWithDCAFitterNCentFT0C || doprocessNoPvRefitWithDCAFitterNCentFT0C || doprocessPvRefitWithKFParticleCentFT0C || doprocessNoPvRefitWithKFParticleCentFT0C) && !doprocessCollisionsCentFT0C) { + LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisionsCentFT0C\"?"); + } + if ((doprocessPvRefitWithDCAFitterNCentFT0M || doprocessNoPvRefitWithDCAFitterNCentFT0M || doprocessPvRefitWithKFParticleCentFT0M || doprocessNoPvRefitWithKFParticleCentFT0M) && !doprocessCollisionsCentFT0M) { + LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisionsCentFT0M\"?"); + } } massPi = MassPiPlus; diff --git a/PWGHF/TableProducer/candidateCreator3Prong.cxx b/PWGHF/TableProducer/candidateCreator3Prong.cxx index 0d7e2ebdc5a..7028ea748aa 100644 --- a/PWGHF/TableProducer/candidateCreator3Prong.cxx +++ b/PWGHF/TableProducer/candidateCreator3Prong.cxx @@ -113,17 +113,20 @@ struct HfCandidateCreator3Prong { } std::array processesCollisions = {doprocessCollisions, doprocessCollisionsCentFT0C, doprocessCollisionsCentFT0M}; - if (std::accumulate(processesCollisions.begin(), processesCollisions.end(), 0) != 1) { - LOGP(fatal, "One and only one process function for collision monitoring must be enabled at a time."); + const int nProcessesCollisions = std::accumulate(processesCollisions.begin(), processesCollisions.end(), 0); + if (nProcessesCollisions > 1) { + LOGP(fatal, "At most one process function for collision monitoring can be enabled at a time."); } - if ((doprocessPvRefit || doprocessNoPvRefit) && !doprocessCollisions) { - LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisions\"?"); - } - if ((doprocessPvRefitCentFT0C || doprocessNoPvRefitCentFT0C) && !doprocessCollisionsCentFT0C) { - LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisionsCentFT0C\"?"); - } - if ((doprocessPvRefitCentFT0M || doprocessNoPvRefitCentFT0M) && !doprocessCollisionsCentFT0M) { - LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisionsCentFT0M\"?"); + if (nProcessesCollisions == 1) { + if ((doprocessPvRefit || doprocessNoPvRefit) && !doprocessCollisions) { + LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisions\"?"); + } + if ((doprocessPvRefitCentFT0C || doprocessNoPvRefitCentFT0C) && !doprocessCollisionsCentFT0C) { + LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisionsCentFT0C\"?"); + } + if ((doprocessPvRefitCentFT0M || doprocessNoPvRefitCentFT0M) && !doprocessCollisionsCentFT0M) { + LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisionsCentFT0M\"?"); + } } std::array creationFlags = {createDplus, createDs, createLc, createXic}; diff --git a/PWGHF/TableProducer/candidateCreatorCascade.cxx b/PWGHF/TableProducer/candidateCreatorCascade.cxx index f21243b49ba..394c8c3e032 100644 --- a/PWGHF/TableProducer/candidateCreatorCascade.cxx +++ b/PWGHF/TableProducer/candidateCreatorCascade.cxx @@ -93,17 +93,20 @@ struct HfCandidateCreatorCascade { } std::array processesCollisions = {doprocessCollisions, doprocessCollisionsCentFT0C, doprocessCollisionsCentFT0M}; - if (std::accumulate(processesCollisions.begin(), processesCollisions.end(), 0) != 1) { - LOGP(fatal, "One and only one process function for collision monitoring must be enabled at a time."); + const int nProcessesCollisions = std::accumulate(processesCollisions.begin(), processesCollisions.end(), 0); + if (nProcessesCollisions > 1) { + LOGP(fatal, "At most one process function for collision monitoring can be enabled at a time."); } - if (doprocessNoCent && !doprocessCollisions) { - LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisions\"?"); - } - if (doprocessCentFT0C && !doprocessCollisionsCentFT0C) { - LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisionsCentFT0C\"?"); - } - if (doprocessCentFT0M && !doprocessCollisionsCentFT0M) { - LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisionsCentFT0M\"?"); + if (nProcessesCollisions == 1) { + if (doprocessNoCent && !doprocessCollisions) { + LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisions\"?"); + } + if (doprocessCentFT0C && !doprocessCollisionsCentFT0C) { + LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisionsCentFT0C\"?"); + } + if (doprocessCentFT0M && !doprocessCollisionsCentFT0M) { + LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisionsCentFT0M\"?"); + } } massP = MassProton; diff --git a/PWGHF/TableProducer/candidateCreatorDstar.cxx b/PWGHF/TableProducer/candidateCreatorDstar.cxx index 2929021eddb..5b28ede2e9b 100644 --- a/PWGHF/TableProducer/candidateCreatorDstar.cxx +++ b/PWGHF/TableProducer/candidateCreatorDstar.cxx @@ -122,17 +122,20 @@ struct HfCandidateCreatorDstar { } std::array processesCollisions = {doprocessCollisions, doprocessCollisionsCentFT0C, doprocessCollisionsCentFT0M}; - if (std::accumulate(processesCollisions.begin(), processesCollisions.end(), 0) != 1) { - LOGP(fatal, "One and only one process function for collision monitoring must be enabled at a time."); + const int nProcessesCollisions = std::accumulate(processesCollisions.begin(), processesCollisions.end(), 0); + if (nProcessesCollisions > 1) { + LOGP(fatal, "At most one process function for collision monitoring can be enabled at a time."); } - if ((doprocessPvRefit || doprocessNoPvRefit) && !doprocessCollisions) { - LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisions\"?"); - } - if ((doprocessPvRefitCentFT0C || doprocessNoPvRefitCentFT0C) && !doprocessCollisionsCentFT0C) { - LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisionsCentFT0C\"?"); - } - if ((doprocessPvRefitCentFT0M || doprocessNoPvRefitCentFT0M) && !doprocessCollisionsCentFT0M) { - LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisionsCentFT0M\"?"); + if (nProcessesCollisions == 1) { + if ((doprocessPvRefit || doprocessNoPvRefit) && !doprocessCollisions) { + LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisions\"?"); + } + if ((doprocessPvRefitCentFT0C || doprocessNoPvRefitCentFT0C) && !doprocessCollisionsCentFT0C) { + LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisionsCentFT0C\"?"); + } + if ((doprocessPvRefitCentFT0M || doprocessNoPvRefitCentFT0M) && !doprocessCollisionsCentFT0M) { + LOGP(fatal, "Process function for collision monitoring not correctly enabled. Did you enable \"processCollisionsCentFT0M\"?"); + } } // LOG(info) << "Init Function Invoked"; From 8d4a9672893ab7fdf256b7fd4cf3dfca67cdc676 Mon Sep 17 00:00:00 2001 From: Mattia Faggin Date: Thu, 14 Mar 2024 14:07:01 +0100 Subject: [PATCH 09/11] Final comments by Vit. --- .../TableProducer/candidateCreator2Prong.cxx | 18 ++++----- .../TableProducer/candidateCreator3Prong.cxx | 16 +++----- .../TableProducer/candidateCreatorCascade.cxx | 16 +++----- PWGHF/TableProducer/candidateCreatorDstar.cxx | 16 +++----- PWGHF/Utils/utilsEvSelHf.h | 37 +++++++++++++++---- 5 files changed, 54 insertions(+), 49 deletions(-) diff --git a/PWGHF/TableProducer/candidateCreator2Prong.cxx b/PWGHF/TableProducer/candidateCreator2Prong.cxx index a153fa6076f..38aa5ef0574 100644 --- a/PWGHF/TableProducer/candidateCreator2Prong.cxx +++ b/PWGHF/TableProducer/candidateCreator2Prong.cxx @@ -102,7 +102,7 @@ struct HfCandidateCreator2Prong { OutputObj hDcaXYProngs{TH2F("hDcaXYProngs", "DCAxy of 2-prong candidates;#it{p}_{T} (GeV/#it{c};#it{d}_{xy}) (#mum);entries", 100, 0., 20., 200, -500., 500.)}; OutputObj hDcaZProngs{TH2F("hDcaZProngs", "DCAz of 2-prong candidates;#it{p}_{T} (GeV/#it{c};#it{d}_{z}) (#mum);entries", 100, 0., 20., 200, -500., 500.)}; OutputObj hVertexerType{TH1F("hVertexerType", "Use KF or DCAFitterN;Vertexer type;entries", 2, -0.5, 1.5)}; // See o2::aod::hf_cand::VertexerType - OutputObj hCollisions{TH1D("hCollisions", "HF event counter", 5, -0.5, 4.5)}; + OutputObj hCollisions{TH1D("hCollisions", "HF event counter", ValuesEvSel::NEvSel, -0.5f, static_cast(ValuesEvSel::NEvSel) - 0.5f)}; OutputObj hPosZBeforeEvSel{TH1D("hPosZBeforeEvSel", "PV position Z before ev. selection;posZ (cm);entries", 400, -20, 20)}; OutputObj hPosZAfterEvSel{TH1D("hPosZAfterEvSel", "PV position Z after ev. selection;posZ (cm);entries", 400, -20, 20)}; @@ -161,11 +161,7 @@ struct HfCandidateCreator2Prong { runNumber = 0; /// collision monitoring - hCollisions->GetXaxis()->SetBinLabel(1, "All collisions"); - hCollisions->GetXaxis()->SetBinLabel(2, "Centrality ok"); - hCollisions->GetXaxis()->SetBinLabel(3, "Centrality + sel8 ok"); - hCollisions->GetXaxis()->SetBinLabel(4, "Centrality + sel8 + posZ ok"); - hCollisions->GetXaxis()->SetBinLabel(5, "Centrality + sel8 + posZ + TF border ok"); + setLabelHistoEvSel(hCollisions.object); } template @@ -179,7 +175,7 @@ struct HfCandidateCreator2Prong { /// reject candidates not satisfying the event selections auto collision = rowTrackIndexProng2.template collision_as(); - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); if (rejectionMask != 0) { /// at least one event selection not satisfied --> reject the candidate continue; @@ -308,7 +304,7 @@ struct HfCandidateCreator2Prong { /// reject candidates in collisions not satisfying the event selections auto collision = rowTrackIndexProng2.template collision_as(); - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); if (rejectionMask != 0) { /// at least one event selection not satisfied --> reject the candidate continue; @@ -587,7 +583,7 @@ struct HfCandidateCreator2Prong { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); @@ -603,7 +599,7 @@ struct HfCandidateCreator2Prong { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); @@ -619,7 +615,7 @@ struct HfCandidateCreator2Prong { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); diff --git a/PWGHF/TableProducer/candidateCreator3Prong.cxx b/PWGHF/TableProducer/candidateCreator3Prong.cxx index 7028ea748aa..158aae7c1d4 100644 --- a/PWGHF/TableProducer/candidateCreator3Prong.cxx +++ b/PWGHF/TableProducer/candidateCreator3Prong.cxx @@ -99,7 +99,7 @@ struct HfCandidateCreator3Prong { OutputObj hCovSVZZ{TH1F("hCovSVZZ", "3-prong candidates;ZZ element of cov. matrix of sec. vtx. position (cm^{2});entries", 100, 0., 0.2)}; OutputObj hDcaXYProngs{TH2F("hDcaXYProngs", "DCAxy of 3-prong candidates;#it{p}_{T} (GeV/#it{c};#it{d}_{xy}) (#mum);entries", 100, 0., 20., 200, -500., 500.)}; OutputObj hDcaZProngs{TH2F("hDcaZProngs", "DCAz of 3-prong candidates;#it{p}_{T} (GeV/#it{c};#it{d}_{z}) (#mum);entries", 100, 0., 20., 200, -500., 500.)}; - OutputObj hCollisions{TH1D("hCollisions", "HF event counter", 5, -0.5, 4.5)}; + OutputObj hCollisions{TH1D("hCollisions", "HF event counter", ValuesEvSel::NEvSel, -0.5f, static_cast(ValuesEvSel::NEvSel) - 0.5f)}; OutputObj hPosZBeforeEvSel{TH1D("hPosZBeforeEvSel", "PV position Z before ev. selection;posZ (cm);entries", 400, -20, 20)}; OutputObj hPosZAfterEvSel{TH1D("hPosZAfterEvSel", "PV position Z after ev. selection;posZ (cm);entries", 400, -20, 20)}; @@ -154,11 +154,7 @@ struct HfCandidateCreator3Prong { runNumber = 0; /// collision monitoring - hCollisions->GetXaxis()->SetBinLabel(1, "All collisions"); - hCollisions->GetXaxis()->SetBinLabel(2, "Centrality ok"); - hCollisions->GetXaxis()->SetBinLabel(3, "Centrality + sel8 ok"); - hCollisions->GetXaxis()->SetBinLabel(4, "Centrality + sel8 + posZ ok"); - hCollisions->GetXaxis()->SetBinLabel(5, "Centrality + sel8 + posZ + TF border ok"); + setLabelHistoEvSel(hCollisions.object); } template @@ -172,7 +168,7 @@ struct HfCandidateCreator3Prong { /// reject candidates in collisions not satisfying the event selections auto collision = rowTrackIndexProng3.template collision_as(); - uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); if (rejectionMask != 0) { /// at least one event selection not satisfied --> reject the candidate continue; @@ -392,7 +388,7 @@ struct HfCandidateCreator3Prong { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); @@ -408,7 +404,7 @@ struct HfCandidateCreator3Prong { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); @@ -424,7 +420,7 @@ struct HfCandidateCreator3Prong { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); diff --git a/PWGHF/TableProducer/candidateCreatorCascade.cxx b/PWGHF/TableProducer/candidateCreatorCascade.cxx index 394c8c3e032..4cb80310b97 100644 --- a/PWGHF/TableProducer/candidateCreatorCascade.cxx +++ b/PWGHF/TableProducer/candidateCreatorCascade.cxx @@ -81,7 +81,7 @@ struct HfCandidateCreatorCascade { OutputObj hMass2{TH1F("hMass2", "2-prong candidates;inv. mass (p K_{S}^{0}) (GeV/#it{c}^{2});entries", 500, 0., 5.)}; OutputObj hCovPVXX{TH1F("hCovPVXX", "2-prong candidates;XX element of cov. matrix of prim. vtx. position (cm^{2});entries", 100, 0., 1.e-4)}; OutputObj hCovSVXX{TH1F("hCovSVXX", "2-prong candidates;XX element of cov. matrix of sec. vtx. position (cm^{2});entries", 100, 0., 0.2)}; - OutputObj hCollisions{TH1D("hCollisions", "HF event counter", 5, -0.5, 4.5)}; + OutputObj hCollisions{TH1D("hCollisions", "HF event counter", ValuesEvSel::NEvSel, -0.5f, static_cast(ValuesEvSel::NEvSel) - 0.5f)}; OutputObj hPosZBeforeEvSel{TH1D("hPosZBeforeEvSel", "PV position Z before ev. selection;posZ (cm);entries", 400, -20, 20)}; OutputObj hPosZAfterEvSel{TH1D("hPosZAfterEvSel", "PV position Z after ev. selection;posZ (cm);entries", 400, -20, 20)}; @@ -130,11 +130,7 @@ struct HfCandidateCreatorCascade { runNumber = 0; /// collision monitoring - hCollisions->GetXaxis()->SetBinLabel(1, "All collisions"); - hCollisions->GetXaxis()->SetBinLabel(2, "Centrality ok"); - hCollisions->GetXaxis()->SetBinLabel(3, "Centrality + sel8 ok"); - hCollisions->GetXaxis()->SetBinLabel(4, "Centrality + sel8 + posZ ok"); - hCollisions->GetXaxis()->SetBinLabel(5, "Centrality + sel8 + posZ + TF border ok"); + setLabelHistoEvSel(hCollisions.object); } template @@ -151,7 +147,7 @@ struct HfCandidateCreatorCascade { /// reject candidates in collisions not satisfying the event selections auto collision = casc.template collision_as(); - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); if (rejectionMask != 0) { /// at least one event selection not satisfied --> reject the candidate continue; @@ -372,7 +368,7 @@ struct HfCandidateCreatorCascade { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); @@ -388,7 +384,7 @@ struct HfCandidateCreatorCascade { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); @@ -404,7 +400,7 @@ struct HfCandidateCreatorCascade { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); diff --git a/PWGHF/TableProducer/candidateCreatorDstar.cxx b/PWGHF/TableProducer/candidateCreatorDstar.cxx index 5b28ede2e9b..737d5aaab93 100644 --- a/PWGHF/TableProducer/candidateCreatorDstar.cxx +++ b/PWGHF/TableProducer/candidateCreatorDstar.cxx @@ -107,7 +107,7 @@ struct HfCandidateCreatorDstar { {"QA/hPtD0", "D^{0} candidates", {HistType::kTH1F, {ptAxis}}}, {"QA/hPtDstar", "D* candidates", {HistType::kTH1F, {ptAxis}}}}}; - OutputObj hCollisions{TH1D("hCollisions", "HF event counter", 5, -0.5, 4.5)}; + OutputObj hCollisions{TH1D("hCollisions", "HF event counter", ValuesEvSel::NEvSel, -0.5f, static_cast(ValuesEvSel::NEvSel) - 0.5f)}; OutputObj hPosZBeforeEvSel{TH1D("hPosZBeforeEvSel", "PV position Z before ev. selection;posZ (cm);entries", 400, -20, 20)}; OutputObj hPosZAfterEvSel{TH1D("hPosZAfterEvSel", "PV position Z after ev. selection;posZ (cm);entries", 400, -20, 20)}; @@ -159,11 +159,7 @@ struct HfCandidateCreatorDstar { bz = 0; /// collision monitoring - hCollisions->GetXaxis()->SetBinLabel(1, "All collisions"); - hCollisions->GetXaxis()->SetBinLabel(2, "Centrality ok"); - hCollisions->GetXaxis()->SetBinLabel(3, "Centrality + sel8 ok"); - hCollisions->GetXaxis()->SetBinLabel(4, "Centrality + sel8 + posZ ok"); - hCollisions->GetXaxis()->SetBinLabel(5, "Centrality + sel8 + posZ + TF border ok"); + setLabelHistoEvSel(hCollisions.object); } /// @brief function for secondary vertex reconstruction and candidate creator @@ -188,7 +184,7 @@ struct HfCandidateCreatorDstar { /// reject candidates in collisions not satisfying the event selections auto collision = rowTrackIndexDstar.template collision_as(); - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); if (rejectionMask != 0) { /// at least one event selection not satisfied --> reject the candidate continue; @@ -443,7 +439,7 @@ struct HfCandidateCreatorDstar { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); @@ -459,7 +455,7 @@ struct HfCandidateCreatorDstar { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); @@ -475,7 +471,7 @@ struct HfCandidateCreatorDstar { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, std::array{centralityMin.value, centralityMax.value}, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); diff --git a/PWGHF/Utils/utilsEvSelHf.h b/PWGHF/Utils/utilsEvSelHf.h index aa7b4e91b17..dafa46e1df2 100644 --- a/PWGHF/Utils/utilsEvSelHf.h +++ b/PWGHF/Utils/utilsEvSelHf.h @@ -29,6 +29,27 @@ enum EventRejection { NEventRejection }; +enum ValuesEvSel : int { + All = 0, + Cent, + CentSel8, + CentSel8PosZ, + CentSel8PosZTFBorder, + NEvSel +}; + +/// @brief Function to put labels on collision monitoring histogram +/// \param hCollisions is the histogram +template +void setLabelHistoEvSel(Histo& hCollisions) +{ + hCollisions->GetXaxis()->SetBinLabel(ValuesEvSel::All + 1, "All collisions"); + hCollisions->GetXaxis()->SetBinLabel(ValuesEvSel::Cent + 1, "Centrality ok"); + hCollisions->GetXaxis()->SetBinLabel(ValuesEvSel::CentSel8 + 1, "Centrality + sel8 ok"); + hCollisions->GetXaxis()->SetBinLabel(ValuesEvSel::CentSel8PosZ + 1, "Centrality + sel8 + posZ ok"); + hCollisions->GetXaxis()->SetBinLabel(ValuesEvSel::CentSel8PosZTFBorder + 1, "Centrality + sel8 + posZ + TF border ok"); +} + /// \brief Function to apply event selections in HF analyses /// \param collision collision that has to satisfy the selection criteria /// \param useSel8Trigger switch to activate the sel8() event selection @@ -36,7 +57,7 @@ enum EventRejection { /// \param useTimeFrameBorderCut switch to activate the time frame border cut /// \return a bitmask with the event selections not satisfied by the analysed collision template -uint16_t getHfCollisionRejectionMask(const Coll& collision, std::array centralityLimits, bool useSel8Trigger, float maxPvPosZ, bool useTimeFrameBorderCut) +uint16_t getHfCollisionRejectionMask(const Coll& collision, float centralityMin, float centralityMax, bool useSel8Trigger, float maxPvPosZ, bool useTimeFrameBorderCut) { uint16_t statusCollision = 0; // 16 bits, in case new ev. selections will be added @@ -50,7 +71,7 @@ uint16_t getHfCollisionRejectionMask(const Coll& collision, std::array } else { LOGP(fatal, "Centrality estimator different from FT0C and FT0M, fix it!"); } - if (centrality < centralityLimits.at(0) || centrality > centralityLimits.at(1)) { + if (centrality < centralityMin || centrality > centralityMax) { SETBIT(statusCollision, EventRejection::Centrality); } } @@ -82,10 +103,10 @@ uint16_t getHfCollisionRejectionMask(const Coll& collision, std::array /// \param hPosZBeforeEvSel is PV position Z for all analysed collisions /// \param hPosZAfterEvSel is PV position Z only for collisions satisfying the event selections template -void monitorCollision(Coll const& collision, const uint16_t rejectionMask, Hist const& hCollisions, Hist const& hPosZBeforeEvSel, Hist const& hPosZAfterEvSel) +void monitorCollision(Coll const& collision, const uint16_t rejectionMask, Hist& hCollisions, Hist& hPosZBeforeEvSel, Hist& hPosZAfterEvSel) { - hCollisions->Fill(0); // all collisions + hCollisions->Fill(ValuesEvSel::All); // all collisions const float posZ = collision.posZ(); hPosZBeforeEvSel->Fill(posZ); @@ -93,25 +114,25 @@ void monitorCollision(Coll const& collision, const uint16_t rejectionMask, Hist if (TESTBIT(rejectionMask, EventRejection::Centrality)) { return; } - hCollisions->Fill(1); // Centrality ok + hCollisions->Fill(ValuesEvSel::Cent); // Centrality ok /// sel8() if (TESTBIT(rejectionMask, EventRejection::Trigger)) { return; } - hCollisions->Fill(2); // Centrality + sel8 ok + hCollisions->Fill(ValuesEvSel::CentSel8); // Centrality + sel8 ok /// PV position Z if (TESTBIT(rejectionMask, EventRejection::PositionZ)) { return; } - hCollisions->Fill(3); // Centrality + sel8 + posZ ok + hCollisions->Fill(ValuesEvSel::CentSel8PosZ); // Centrality + sel8 + posZ ok /// Time Frame border cut if (TESTBIT(rejectionMask, EventRejection::TimeFrameBorderCut)) { return; } - hCollisions->Fill(4); // Centrality + sel8 + posZ + TF border ok + hCollisions->Fill(ValuesEvSel::CentSel8PosZTFBorder); // Centrality + sel8 + posZ + TF border ok hPosZAfterEvSel->Fill(posZ); } From ce0fafa7e9ab7e501d054556f6fe342f72ef2dc4 Mon Sep 17 00:00:00 2001 From: Mattia Faggin Date: Thu, 14 Mar 2024 18:10:58 +0100 Subject: [PATCH 10/11] Declare returned value as auto, in case the returned type will be changed in the future. --- PWGHF/TableProducer/candidateCreator2Prong.cxx | 10 +++++----- PWGHF/TableProducer/candidateCreator3Prong.cxx | 8 ++++---- PWGHF/TableProducer/candidateCreatorCascade.cxx | 8 ++++---- PWGHF/TableProducer/candidateCreatorDstar.cxx | 8 ++++---- 4 files changed, 17 insertions(+), 17 deletions(-) diff --git a/PWGHF/TableProducer/candidateCreator2Prong.cxx b/PWGHF/TableProducer/candidateCreator2Prong.cxx index 38aa5ef0574..74628c854de 100644 --- a/PWGHF/TableProducer/candidateCreator2Prong.cxx +++ b/PWGHF/TableProducer/candidateCreator2Prong.cxx @@ -175,7 +175,7 @@ struct HfCandidateCreator2Prong { /// reject candidates not satisfying the event selections auto collision = rowTrackIndexProng2.template collision_as(); - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const auto rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); if (rejectionMask != 0) { /// at least one event selection not satisfied --> reject the candidate continue; @@ -304,7 +304,7 @@ struct HfCandidateCreator2Prong { /// reject candidates in collisions not satisfying the event selections auto collision = rowTrackIndexProng2.template collision_as(); - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const auto rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); if (rejectionMask != 0) { /// at least one event selection not satisfied --> reject the candidate continue; @@ -583,7 +583,7 @@ struct HfCandidateCreator2Prong { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const auto rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); @@ -599,7 +599,7 @@ struct HfCandidateCreator2Prong { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const auto rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); @@ -615,7 +615,7 @@ struct HfCandidateCreator2Prong { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const auto rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); diff --git a/PWGHF/TableProducer/candidateCreator3Prong.cxx b/PWGHF/TableProducer/candidateCreator3Prong.cxx index 158aae7c1d4..6b37d8f9392 100644 --- a/PWGHF/TableProducer/candidateCreator3Prong.cxx +++ b/PWGHF/TableProducer/candidateCreator3Prong.cxx @@ -168,7 +168,7 @@ struct HfCandidateCreator3Prong { /// reject candidates in collisions not satisfying the event selections auto collision = rowTrackIndexProng3.template collision_as(); - uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + auto rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); if (rejectionMask != 0) { /// at least one event selection not satisfied --> reject the candidate continue; @@ -388,7 +388,7 @@ struct HfCandidateCreator3Prong { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const auto rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); @@ -404,7 +404,7 @@ struct HfCandidateCreator3Prong { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const auto rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); @@ -420,7 +420,7 @@ struct HfCandidateCreator3Prong { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const auto rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); diff --git a/PWGHF/TableProducer/candidateCreatorCascade.cxx b/PWGHF/TableProducer/candidateCreatorCascade.cxx index 4cb80310b97..ad63bfa35c6 100644 --- a/PWGHF/TableProducer/candidateCreatorCascade.cxx +++ b/PWGHF/TableProducer/candidateCreatorCascade.cxx @@ -147,7 +147,7 @@ struct HfCandidateCreatorCascade { /// reject candidates in collisions not satisfying the event selections auto collision = casc.template collision_as(); - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const auto rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); if (rejectionMask != 0) { /// at least one event selection not satisfied --> reject the candidate continue; @@ -368,7 +368,7 @@ struct HfCandidateCreatorCascade { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const auto rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); @@ -384,7 +384,7 @@ struct HfCandidateCreatorCascade { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const auto rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); @@ -400,7 +400,7 @@ struct HfCandidateCreatorCascade { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const auto rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); diff --git a/PWGHF/TableProducer/candidateCreatorDstar.cxx b/PWGHF/TableProducer/candidateCreatorDstar.cxx index 737d5aaab93..8017ceee44d 100644 --- a/PWGHF/TableProducer/candidateCreatorDstar.cxx +++ b/PWGHF/TableProducer/candidateCreatorDstar.cxx @@ -184,7 +184,7 @@ struct HfCandidateCreatorDstar { /// reject candidates in collisions not satisfying the event selections auto collision = rowTrackIndexDstar.template collision_as(); - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const auto rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); if (rejectionMask != 0) { /// at least one event selection not satisfied --> reject the candidate continue; @@ -439,7 +439,7 @@ struct HfCandidateCreatorDstar { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const auto rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); @@ -455,7 +455,7 @@ struct HfCandidateCreatorDstar { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const auto rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); @@ -471,7 +471,7 @@ struct HfCandidateCreatorDstar { for (const auto& collision : collisions) { /// bitmask with event. selection info - const uint16_t rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const auto rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); /// monitor the satisfied event selections monitorCollision(collision, rejectionMask, hCollisions.object, hPosZBeforeEvSel.object, hPosZAfterEvSel.object); From 3729a185ce506a2c6949702609a05350c1cbe521 Mon Sep 17 00:00:00 2001 From: Mattia Faggin Date: Thu, 14 Mar 2024 18:12:44 +0100 Subject: [PATCH 11/11] Fix. --- PWGHF/TableProducer/candidateCreator3Prong.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGHF/TableProducer/candidateCreator3Prong.cxx b/PWGHF/TableProducer/candidateCreator3Prong.cxx index 6b37d8f9392..e6571bcf3a9 100644 --- a/PWGHF/TableProducer/candidateCreator3Prong.cxx +++ b/PWGHF/TableProducer/candidateCreator3Prong.cxx @@ -168,7 +168,7 @@ struct HfCandidateCreator3Prong { /// reject candidates in collisions not satisfying the event selections auto collision = rowTrackIndexProng3.template collision_as(); - auto rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); + const auto rejectionMask = getHfCollisionRejectionMask(collision, centralityMin, centralityMax, useSel8Trigger, maxPvPosZ, useTimeFrameBorderCut); if (rejectionMask != 0) { /// at least one event selection not satisfied --> reject the candidate continue;