From 089f8748518c991981e0d8dbf525a835db1d1d53 Mon Sep 17 00:00:00 2001 From: nzardosh Date: Fri, 31 Jan 2025 16:52:26 +0100 Subject: [PATCH] Adding the ability to modularise event selection --- EventFiltering/PWGJE/jetFilter.cxx | 7 +- PWGJE/Core/JetDerivedDataUtilities.h | 190 ++++++++++++------- PWGJE/DataModel/JetReducedData.h | 4 +- PWGJE/JetFinders/jetFinder.cxx | 8 +- PWGJE/JetFinders/jetFinderHF.cxx | 6 +- PWGJE/JetFinders/jetFinderV0.cxx | 6 +- PWGJE/TableProducer/luminosityCalculator.cxx | 5 +- PWGJE/TableProducer/luminosityProducer.cxx | 44 +++-- PWGJE/Tasks/ChJetTriggerQATask.cxx | 6 +- PWGJE/Tasks/bjetTaggingML.cxx | 8 +- PWGJE/Tasks/bjetTreeCreator.cxx | 10 +- PWGJE/Tasks/dijetFinderQA.cxx | 10 +- PWGJE/Tasks/fullJetSpectraPP.cxx | 4 +- PWGJE/Tasks/gammaJetTreeProducer.cxx | 6 +- PWGJE/Tasks/hadronPhotonCorrelation.cxx | 21 +- PWGJE/Tasks/hfFragmentationFunction.cxx | 10 +- PWGJE/Tasks/jetBackgroundAnalysis.cxx | 9 +- PWGJE/Tasks/jetChargedV2.cxx | 12 +- PWGJE/Tasks/jetFinderHFQA.cxx | 18 +- PWGJE/Tasks/jetFinderQA.cxx | 20 +- PWGJE/Tasks/jetFinderV0QA.cxx | 10 +- PWGJE/Tasks/jetFragmentation.cxx | 29 +-- PWGJE/Tasks/jetHadronRecoil.cxx | 28 +-- PWGJE/Tasks/jetLundReclustering.cxx | 7 +- PWGJE/Tasks/jetPlanarFlow.cxx | 13 +- PWGJE/Tasks/jetSpectraCharged.cxx | 25 +-- PWGJE/Tasks/jetSpectraEseTask.cxx | 12 +- PWGJE/Tasks/jetTaggerHFQA.cxx | 8 +- PWGJE/Tasks/jetTutorial.cxx | 33 ++-- PWGJE/Tasks/jetTutorialSkeleton.cxx | 7 +- PWGJE/Tasks/jetValidationQA.cxx | 4 +- PWGJE/Tasks/nucleiInJets.cxx | 7 +- PWGJE/Tasks/phiInJets.cxx | 16 +- PWGJE/Tasks/photonIsolationQA.cxx | 4 +- PWGJE/Tasks/recoilJets.cxx | 6 +- PWGJE/Tasks/trackEfficiency.cxx | 24 +-- PWGJE/Tasks/v0JetSpectra.cxx | 13 +- PWGJE/Tasks/v0QA.cxx | 23 ++- 38 files changed, 380 insertions(+), 293 deletions(-) diff --git a/EventFiltering/PWGJE/jetFilter.cxx b/EventFiltering/PWGJE/jetFilter.cxx index 54c24ee627d..277f749d22b 100644 --- a/EventFiltering/PWGJE/jetFilter.cxx +++ b/EventFiltering/PWGJE/jetFilter.cxx @@ -14,6 +14,7 @@ #include #include #include +#include #include "Framework/ASoA.h" #include "Framework/ASoAHelpers.h" @@ -94,13 +95,13 @@ struct jetFilter { Filter trackFilter = (nabs(aod::jtrack::eta) < static_cast(cfgEtaTPC)) && (aod::jtrack::pt > trackPtMin); int trackSelection = -1; - int eventSelection = -1; + std::vector eventSelectionBits; void init(o2::framework::InitContext&) { triggerJetR = TMath::Nint(cfgJetR * 100.0f); trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(evSel)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(evSel)); spectra.add("fCollZpos", "collision z position", HistType::kTH1F, {{200, -20., +20., "#it{z}_{vtx} position (cm)"}}); @@ -196,7 +197,7 @@ struct jetFilter { spectra.fill(HIST("fCollZpos"), collision.posZ()); hProcessedEvents->Fill(static_cast(kBinAllEvents) + 0.1f); // all minimum bias events - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { tags(keepEvent[kJetChLowPt], keepEvent[kJetChHighPt], keepEvent[kTrackLowPt], keepEvent[kTrackHighPt]); return; } diff --git a/PWGJE/Core/JetDerivedDataUtilities.h b/PWGJE/Core/JetDerivedDataUtilities.h index f9bfdc0bd01..5462d9623f8 100644 --- a/PWGJE/Core/JetDerivedDataUtilities.h +++ b/PWGJE/Core/JetDerivedDataUtilities.h @@ -29,15 +29,15 @@ static constexpr float mPion = 0.139; // TDatabasePDG::Instance()->GetParticle(2 enum JCollisionSel { sel8 = 0, - sel8Full = 1, - sel8FullPbPb = 2, - selMC = 3, - selMCFull = 4, - selMCFullPbPb = 5, - selUnanchoredMC = 6, - selTVX = 7, - sel7 = 8, - sel7KINT7 = 9 + sel7 = 1, + sel7KINT7 = 2, + selTVX = 3, + selNoTimeFrameBorder = 4, + selNoITSROFrameBorder = 5, + selNoSameBunchPileup = 6, + selIsGoodZvtxFT0vsPV = 7, + selNoCollInTimeRangeStandard = 8, + selNoCollInRofStandard = 9 }; enum JCollisionSubGeneratorId { @@ -46,50 +46,96 @@ enum JCollisionSubGeneratorId { }; template -bool selectCollision(T const& collision, int eventSelection = -1, bool skipMBGapEvents = true) +bool selectCollision(T const& collision, std::vector eventSelectionMaskBits, bool skipMBGapEvents = true) { if (skipMBGapEvents && collision.subGeneratorId() == JCollisionSubGeneratorId::mbGap) { return false; } - if (eventSelection == -1) { + if (eventSelectionMaskBits.size() == 0) { return true; } - return (collision.eventSel() & (1 << eventSelection)); + for (auto eventSelectionMaskBit : eventSelectionMaskBits) { + if (!(collision.eventSel() & (1 << eventSelectionMaskBit))) { + return false; + } + } + return true; +} + +bool eventSelectionMasksContainSelection(std::string eventSelectionMasks, std::string selection) +{ + size_t position = 0; + while ((position = eventSelectionMasks.find(selection, position)) != std::string::npos) { + bool validStart = (position == 0 || eventSelectionMasks[position - 1] == '+'); + bool validEnd = (position + selection.length() == eventSelectionMasks.length() || eventSelectionMasks[position + selection.length()] == '+'); + if (validStart && validEnd) { + return true; + } + position += selection.length(); + } + return false; } -int initialiseEventSelection(std::string eventSelection) +std::vector initialiseEventSelectionBits(std::string eventSelectionMasks) { - if (eventSelection == "sel8") { - return JCollisionSel::sel8; + std::vector eventSelectionMaskBits; + if (eventSelectionMasksContainSelection(eventSelectionMasks, "sel8")) { + eventSelectionMaskBits.push_back(JCollisionSel::sel8); } - if (eventSelection == "sel8Full") { - return JCollisionSel::sel8Full; + if (eventSelectionMasksContainSelection(eventSelectionMasks, "sel7")) { + eventSelectionMaskBits.push_back(JCollisionSel::sel7); } - if (eventSelection == "sel8FullPbPb") { - return JCollisionSel::sel8FullPbPb; + if (eventSelectionMasksContainSelection(eventSelectionMasks, "sel7KINT7")) { + eventSelectionMaskBits.push_back(JCollisionSel::sel7KINT7); } - if (eventSelection == "selMC") { - return JCollisionSel::selMC; + if (eventSelectionMasksContainSelection(eventSelectionMasks, "TVX")) { + eventSelectionMaskBits.push_back(JCollisionSel::selTVX); } - if (eventSelection == "selMCFull") { - return JCollisionSel::selMCFull; + if (eventSelectionMasksContainSelection(eventSelectionMasks, "NoTimeFrameBorder")) { + eventSelectionMaskBits.push_back(JCollisionSel::selNoTimeFrameBorder); } - if (eventSelection == "selMCFullPbPb") { - return JCollisionSel::selMCFullPbPb; + if (eventSelectionMasksContainSelection(eventSelectionMasks, "NoITSROFrameBorder")) { + eventSelectionMaskBits.push_back(JCollisionSel::selNoITSROFrameBorder); } - if (eventSelection == "selUnanchoredMC") { - return JCollisionSel::selUnanchoredMC; + if (eventSelectionMasksContainSelection(eventSelectionMasks, "NoSameBunchPileup")) { + eventSelectionMaskBits.push_back(JCollisionSel::selNoSameBunchPileup); } - if (eventSelection == "selTVX") { - return JCollisionSel::selTVX; + if (eventSelectionMasksContainSelection(eventSelectionMasks, "IsGoodZvtxFT0vsPV")) { + eventSelectionMaskBits.push_back(JCollisionSel::selIsGoodZvtxFT0vsPV); } - if (eventSelection == "sel7") { - return JCollisionSel::sel7; + if (eventSelectionMasksContainSelection(eventSelectionMasks, "NoCollInTimeRangeStandard")) { + eventSelectionMaskBits.push_back(JCollisionSel::selNoCollInTimeRangeStandard); } - if (eventSelection == "sel7KINT7") { - return JCollisionSel::sel7KINT7; + if (eventSelectionMasksContainSelection(eventSelectionMasks, "NoCollInRofStandard")) { + eventSelectionMaskBits.push_back(JCollisionSel::selNoCollInRofStandard); } - return -1; + + if (eventSelectionMasksContainSelection(eventSelectionMasks, "sel8Full")) { + eventSelectionMaskBits.push_back(JCollisionSel::sel8); + eventSelectionMaskBits.push_back(JCollisionSel::selNoSameBunchPileup); + } + if (eventSelectionMasksContainSelection(eventSelectionMasks, "sel8FullPbPb")) { + eventSelectionMaskBits.push_back(JCollisionSel::selNoCollInTimeRangeStandard); + eventSelectionMaskBits.push_back(JCollisionSel::selNoCollInRofStandard); + } + if (eventSelectionMasksContainSelection(eventSelectionMasks, "selUnanchoredMC")) { + eventSelectionMaskBits.push_back(JCollisionSel::selTVX); + eventSelectionMaskBits.push_back(JCollisionSel::selNoTimeFrameBorder); + } + if (eventSelectionMasksContainSelection(eventSelectionMasks, "selMC")) { + eventSelectionMaskBits.push_back(JCollisionSel::selTVX); + } + if (eventSelectionMasksContainSelection(eventSelectionMasks, "selMCFull")) { + eventSelectionMaskBits.push_back(JCollisionSel::selTVX); + eventSelectionMaskBits.push_back(JCollisionSel::selNoTimeFrameBorder); + eventSelectionMaskBits.push_back(JCollisionSel::selNoSameBunchPileup); + } + if (eventSelectionMasksContainSelection(eventSelectionMasks, "selMCFullPbPb")) { + eventSelectionMaskBits.push_back(JCollisionSel::selTVX); + eventSelectionMaskBits.push_back(JCollisionSel::selNoCollInTimeRangeStandard); + eventSelectionMaskBits.push_back(JCollisionSel::selNoCollInRofStandard); + } + return eventSelectionMaskBits; } template @@ -98,12 +144,6 @@ uint16_t setEventSelectionBit(T const& collision) uint16_t bit = 0; if (collision.sel8()) { SETBIT(bit, JCollisionSel::sel8); - if (collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup) && collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) { - SETBIT(bit, JCollisionSel::sel8Full); - if (collision.selection_bit(o2::aod::evsel::kNoCollInTimeRangeStandard)) { - SETBIT(bit, JCollisionSel::sel8FullPbPb); - } - } } if (collision.sel7()) { SETBIT(bit, JCollisionSel::sel7); @@ -113,16 +153,24 @@ uint16_t setEventSelectionBit(T const& collision) } if (collision.selection_bit(o2::aod::evsel::kIsTriggerTVX)) { SETBIT(bit, JCollisionSel::selTVX); - SETBIT(bit, JCollisionSel::selUnanchoredMC); - if (collision.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) { - SETBIT(bit, JCollisionSel::selMC); - if (collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup) && collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) { - SETBIT(bit, JCollisionSel::selMCFull); - if (collision.selection_bit(o2::aod::evsel::kNoCollInTimeRangeStandard)) { - SETBIT(bit, JCollisionSel::selMCFullPbPb); - } - } - } + } + if (collision.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) { + SETBIT(bit, JCollisionSel::selNoTimeFrameBorder); + } + if (collision.selection_bit(o2::aod::evsel::kNoITSROFrameBorder)) { + SETBIT(bit, JCollisionSel::selNoITSROFrameBorder); + } + if (collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) { + SETBIT(bit, JCollisionSel::selNoSameBunchPileup); + } + if (collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) { + SETBIT(bit, JCollisionSel::selIsGoodZvtxFT0vsPV); + } + if (collision.selection_bit(o2::aod::evsel::kNoCollInTimeRangeStandard)) { + SETBIT(bit, JCollisionSel::selNoCollInTimeRangeStandard); + } + if (collision.selection_bit(o2::aod::evsel::kNoCollInRofStandard)) { + SETBIT(bit, JCollisionSel::selNoCollInRofStandard); } return bit; } @@ -210,67 +258,67 @@ std::vector initialiseTriggerMaskBits(std::string triggerMasks) { std::vector triggerMaskBits; if (triggerMasksContainTrigger(triggerMasks, "fJetChLowPt")) { - triggerMaskBits.push_back(JetChLowPt); + triggerMaskBits.push_back(JTrigSel::JetChLowPt); } if (triggerMasksContainTrigger(triggerMasks, "fJetChHighPt")) { - triggerMaskBits.push_back(JetChHighPt); + triggerMaskBits.push_back(JTrigSel::JetChHighPt); } if (triggerMasksContainTrigger(triggerMasks, "fTrackLowPt")) { - triggerMaskBits.push_back(TrackLowPt); + triggerMaskBits.push_back(JTrigSel::TrackLowPt); } if (triggerMasksContainTrigger(triggerMasks, "fTrackHighPt")) { - triggerMaskBits.push_back(TrackHighPt); + triggerMaskBits.push_back(JTrigSel::TrackHighPt); } if (triggerMasksContainTrigger(triggerMasks, "fJetD0ChLowPt")) { - triggerMaskBits.push_back(JetD0ChLowPt); + triggerMaskBits.push_back(JTrigSel::JetD0ChLowPt); } if (triggerMasksContainTrigger(triggerMasks, "fJetD0ChHighPt")) { - triggerMaskBits.push_back(JetD0ChHighPt); + triggerMaskBits.push_back(JTrigSel::JetD0ChHighPt); } if (triggerMasksContainTrigger(triggerMasks, "fJetLcChLowPt")) { - triggerMaskBits.push_back(JetLcChLowPt); + triggerMaskBits.push_back(JTrigSel::JetLcChLowPt); } if (triggerMasksContainTrigger(triggerMasks, "fJetLcChHighPt")) { - triggerMaskBits.push_back(JetLcChHighPt); + triggerMaskBits.push_back(JTrigSel::JetLcChHighPt); } if (triggerMasksContainTrigger(triggerMasks, "fEMCALReadout")) { - triggerMaskBits.push_back(EMCALReadout); + triggerMaskBits.push_back(JTrigSel::EMCALReadout); } if (triggerMasksContainTrigger(triggerMasks, "fJetFullHighPt")) { - triggerMaskBits.push_back(JetFullHighPt); + triggerMaskBits.push_back(JTrigSel::JetFullHighPt); } if (triggerMasksContainTrigger(triggerMasks, "fJetFullLowPt")) { - triggerMaskBits.push_back(JetFullLowPt); + triggerMaskBits.push_back(JTrigSel::JetFullLowPt); } if (triggerMasksContainTrigger(triggerMasks, "fJetNeutralHighPt")) { - triggerMaskBits.push_back(JetNeutralHighPt); + triggerMaskBits.push_back(JTrigSel::JetNeutralHighPt); } if (triggerMasksContainTrigger(triggerMasks, "fJetNeutralLowPt")) { - triggerMaskBits.push_back(JetNeutralLowPt); + triggerMaskBits.push_back(JTrigSel::JetNeutralLowPt); } if (triggerMasksContainTrigger(triggerMasks, "fGammaVeryHighPtEMCAL")) { - triggerMaskBits.push_back(GammaVeryHighPtEMCAL); + triggerMaskBits.push_back(JTrigSel::GammaVeryHighPtEMCAL); } if (triggerMasksContainTrigger(triggerMasks, "fGammaVeryHighPtDCAL")) { - triggerMaskBits.push_back(GammaVeryHighPtDCAL); + triggerMaskBits.push_back(JTrigSel::GammaVeryHighPtDCAL); } if (triggerMasksContainTrigger(triggerMasks, "fGammaHighPtEMCAL")) { - triggerMaskBits.push_back(GammaHighPtEMCAL); + triggerMaskBits.push_back(JTrigSel::GammaHighPtEMCAL); } if (triggerMasksContainTrigger(triggerMasks, "fGammaHighPtDCAL")) { - triggerMaskBits.push_back(GammaHighPtDCAL); + triggerMaskBits.push_back(JTrigSel::GammaHighPtDCAL); } if (triggerMasksContainTrigger(triggerMasks, "fGammaLowPtEMCAL")) { - triggerMaskBits.push_back(GammaLowPtEMCAL); + triggerMaskBits.push_back(JTrigSel::GammaLowPtEMCAL); } if (triggerMasksContainTrigger(triggerMasks, "fGammaLowPtDCAL")) { - triggerMaskBits.push_back(GammaLowPtDCAL); + triggerMaskBits.push_back(JTrigSel::GammaLowPtDCAL); } if (triggerMasksContainTrigger(triggerMasks, "fGammaVeryLowPtEMCAL")) { - triggerMaskBits.push_back(GammaVeryLowPtEMCAL); + triggerMaskBits.push_back(JTrigSel::GammaVeryLowPtEMCAL); } if (triggerMasksContainTrigger(triggerMasks, "fGammaVeryLowPtDCAL")) { - triggerMaskBits.push_back(GammaVeryLowPtDCAL); + triggerMaskBits.push_back(JTrigSel::GammaVeryLowPtDCAL); } return triggerMaskBits; } diff --git a/PWGJE/DataModel/JetReducedData.h b/PWGJE/DataModel/JetReducedData.h index 5b7ebda5c9a..cb93cfff445 100644 --- a/PWGJE/DataModel/JetReducedData.h +++ b/PWGJE/DataModel/JetReducedData.h @@ -90,6 +90,7 @@ DECLARE_SOA_COLUMN(ReadCountsWithTVXAndZVertexAndSelUnanchoredMC, readCountsWith DECLARE_SOA_COLUMN(ReadCountsWithTVXAndZVertexAndSelTVX, readCountsWithTVXAndZVertexAndSelTVX, std::vector); DECLARE_SOA_COLUMN(ReadCountsWithTVXAndZVertexAndSel7, readCountsWithTVXAndZVertexAndSel7, std::vector); DECLARE_SOA_COLUMN(ReadCountsWithTVXAndZVertexAndSel7KINT7, readCountsWithTVXAndZVertexAndSel7KINT7, std::vector); +DECLARE_SOA_COLUMN(ReadCountsWithCustom, readCountsWithCustom, std::vector); DECLARE_SOA_COLUMN(IsAmbiguous, isAmbiguous, bool); DECLARE_SOA_COLUMN(IsEMCALReadout, isEmcalReadout, bool); } // namespace jcollision @@ -146,7 +147,8 @@ DECLARE_SOA_TABLE_STAGED(CollisionCounts, "COLLCOUNT", jcollision::ReadCountsWithTVXAndZVertexAndSelUnanchoredMC, jcollision::ReadCountsWithTVXAndZVertexAndSelTVX, jcollision::ReadCountsWithTVXAndZVertexAndSel7, - jcollision::ReadCountsWithTVXAndZVertexAndSel7KINT7); + jcollision::ReadCountsWithTVXAndZVertexAndSel7KINT7, + jcollision::ReadCountsWithCustom); namespace jmccollision { diff --git a/PWGJE/JetFinders/jetFinder.cxx b/PWGJE/JetFinders/jetFinder.cxx index 7d625549b1f..c95d4d971df 100644 --- a/PWGJE/JetFinders/jetFinder.cxx +++ b/PWGJE/JetFinders/jetFinder.cxx @@ -88,7 +88,7 @@ struct JetFinderTask { Service pdgDatabase; int trackSelection = -1; - int eventSelection = -1; + std::vector eventSelectionBits; std::string particleSelection; JetFinder jetFinder; @@ -98,7 +98,7 @@ struct JetFinderTask { void init(InitContext const&) { - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); triggerMaskBits = jetderiveddatautilities::initialiseTriggerMaskBits(triggerMasks); trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); particleSelection = static_cast(particleSelections); @@ -151,7 +151,7 @@ struct JetFinderTask { void processChargedJets(soa::Filtered::iterator const& collision, soa::Filtered const& tracks) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection) || !jetderiveddatautilities::selectTrigger(collision, triggerMaskBits) || (doEMCALEventSelectionChargedJets && !jetderiveddatautilities::eventEMCAL(collision))) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits) || !jetderiveddatautilities::selectTrigger(collision, triggerMaskBits) || (doEMCALEventSelectionChargedJets && !jetderiveddatautilities::eventEMCAL(collision))) { return; } inputParticles.clear(); @@ -164,7 +164,7 @@ struct JetFinderTask { void processChargedEvtWiseSubJets(soa::Filtered::iterator const& collision, soa::Filtered const& tracks) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection) || !jetderiveddatautilities::selectTrigger(collision, triggerMaskBits) || (doEMCALEventSelectionChargedJets && !jetderiveddatautilities::eventEMCAL(collision))) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits) || !jetderiveddatautilities::selectTrigger(collision, triggerMaskBits) || (doEMCALEventSelectionChargedJets && !jetderiveddatautilities::eventEMCAL(collision))) { return; } inputParticles.clear(); diff --git a/PWGJE/JetFinders/jetFinderHF.cxx b/PWGJE/JetFinders/jetFinderHF.cxx index 02492d997b6..b153a3adc52 100644 --- a/PWGJE/JetFinders/jetFinderHF.cxx +++ b/PWGJE/JetFinders/jetFinderHF.cxx @@ -100,7 +100,7 @@ struct JetFinderHFTask { Service pdgDatabase; int trackSelection = -1; - int eventSelection = -1; + std::vector eventSelectionBits; std::string particleSelection; JetFinder jetFinder; @@ -112,7 +112,7 @@ struct JetFinderHFTask { { trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); triggerMaskBits = jetderiveddatautilities::initialiseTriggerMaskBits(triggerMasks); - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); particleSelection = static_cast(particleSelections); jetFinder.etaMin = trackEtaMin; @@ -173,7 +173,7 @@ struct JetFinderHFTask { template void analyseCharged(T const& collision, U const& tracks, V const& candidate, M& jetsTableInput, N& constituentsTableInput, O& /*originalTracks*/, float minJetPt, float maxJetPt) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection) || !jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits) || !jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) { return; } inputParticles.clear(); diff --git a/PWGJE/JetFinders/jetFinderV0.cxx b/PWGJE/JetFinders/jetFinderV0.cxx index 14a4e17ac3e..62b03b83129 100644 --- a/PWGJE/JetFinders/jetFinderV0.cxx +++ b/PWGJE/JetFinders/jetFinderV0.cxx @@ -83,7 +83,7 @@ struct JetFinderV0Task { Service pdgDatabase; int trackSelection = -1; - int eventSelection = -1; + std::vector eventSelectionBits; std::string particleSelection; JetFinder jetFinder; @@ -97,7 +97,7 @@ struct JetFinderV0Task { { trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); triggerMaskBits = jetderiveddatautilities::initialiseTriggerMaskBits(triggerMasks); - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); particleSelection = static_cast(particleSelections); jetFinder.etaMin = trackEtaMin; @@ -154,7 +154,7 @@ struct JetFinderV0Task { template void analyseCharged(T const& collision, U const& tracks, V const& candidates, M& jetsTableInput, N& constituentsTableInput, float minJetPt, float maxJetPt) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection) || !jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits) || !jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) { return; } inputParticles.clear(); diff --git a/PWGJE/TableProducer/luminosityCalculator.cxx b/PWGJE/TableProducer/luminosityCalculator.cxx index c818ad6b3b2..b1d509ab321 100644 --- a/PWGJE/TableProducer/luminosityCalculator.cxx +++ b/PWGJE/TableProducer/luminosityCalculator.cxx @@ -32,7 +32,7 @@ struct LuminosityCalculator { void init(InitContext&) { - std::vector histLabels = {"BC", "BC+TVX", "BC+TVX+NoTFB", "BC+TVX+NoTFB+NoITSROFB", "Coll", "Coll+TVX", "Coll+TVX+VtxZ+Sel8", "Coll+TVX+VtxZ+Sel8Full", "Coll+TVX+VtxZ+Sel8FullPbPb", "Coll+TVX+VtxZ+SelMC", "Coll+TVX+VtxZ+SelMCFull", "Coll+TVX+VtxZ+SelMCFullPbPb", "Coll+TVX+VtxZ+SelUnanchoredMC", "Coll+TVX+VtxZ+SelTVX", "Coll+TVX+VtxZ+Sel7", "Coll+TVX+VtxZ+Sel7KINT7"}; + std::vector histLabels = {"BC", "BC+TVX", "BC+TVX+NoTFB", "BC+TVX+NoTFB+NoITSROFB", "Coll", "Coll+TVX", "Coll+TVX+VtxZ+Sel8", "Coll+TVX+VtxZ+Sel8Full", "Coll+TVX+VtxZ+Sel8FullPbPb", "Coll+TVX+VtxZ+SelMC", "Coll+TVX+VtxZ+SelMCFull", "Coll+TVX+VtxZ+SelMCFullPbPb", "Coll+TVX+VtxZ+SelUnanchoredMC", "Coll+TVX+VtxZ+SelTVX", "Coll+TVX+VtxZ+Sel7", "Coll+TVX+VtxZ+Sel7KINT7", "custom"}; registry.add("counter", "BCs and Collisions", HistType::kTH1D, {{static_cast(histLabels.size()), -0.5, static_cast(histLabels.size()) - 0.5}}); auto counter = registry.get(HIST("counter")); for (std::vector::size_type iCounter = 0; iCounter < histLabels.size(); iCounter++) { @@ -66,6 +66,7 @@ struct LuminosityCalculator { int readCollisionWithTVXAndZVertexAndSelTVXCounter = 0; int readCollisionWithTVXAndZVertexAndSel7Counter = 0; int readCollisionWithTVXAndZVertexAndSel7KINT7Counter = 0; + int readCollisionWithCustomCounter = 0; for (const auto& collisionCount : collisionCounts) { readCollision += collisionCount.readCounts().front(); @@ -80,6 +81,7 @@ struct LuminosityCalculator { readCollisionWithTVXAndZVertexAndSelTVXCounter += collisionCount.readCountsWithTVXAndZVertexAndSelTVX().front(); readCollisionWithTVXAndZVertexAndSel7Counter += collisionCount.readCountsWithTVXAndZVertexAndSel7().front(); readCollisionWithTVXAndZVertexAndSel7KINT7Counter += collisionCount.readCountsWithTVXAndZVertexAndSel7KINT7().front(); + readCollisionWithCustomCounter += collisionCount.readCountsWithCustom().front(); } registry.get(HIST("counter"))->SetBinContent(1, registry.get(HIST("counter"))->GetBinContent(1) + readBC); @@ -98,6 +100,7 @@ struct LuminosityCalculator { registry.get(HIST("counter"))->SetBinContent(14, registry.get(HIST("counter"))->GetBinContent(14) + readCollisionWithTVXAndZVertexAndSelTVXCounter); registry.get(HIST("counter"))->SetBinContent(15, registry.get(HIST("counter"))->GetBinContent(15) + readCollisionWithTVXAndZVertexAndSel7Counter); registry.get(HIST("counter"))->SetBinContent(16, registry.get(HIST("counter"))->GetBinContent(16) + readCollisionWithTVXAndZVertexAndSel7KINT7Counter); + registry.get(HIST("counter"))->SetBinContent(16, registry.get(HIST("counter"))->GetBinContent(17) + readCollisionWithCustomCounter); } PROCESS_SWITCH(LuminosityCalculator, processCalculateLuminosity, "calculate ingredients for luminosity and fill a histogram", true); }; diff --git a/PWGJE/TableProducer/luminosityProducer.cxx b/PWGJE/TableProducer/luminosityProducer.cxx index 0d67a0b5488..6877da8a812 100644 --- a/PWGJE/TableProducer/luminosityProducer.cxx +++ b/PWGJE/TableProducer/luminosityProducer.cxx @@ -32,6 +32,7 @@ struct LuminosityProducer { Produces storedCollisionCountsTable; Configurable vertexZCutForCounting{"vertexZCutForCounting", 10.0, "choose z-vertex cut for collision counter"}; + Configurable customEventSelections{"customEventSelections", "sel8", "choose custom event selection to be added"}; void init(InitContext&) { @@ -102,42 +103,46 @@ struct LuminosityProducer { int readCollisionWithTVXAndZVertexAndSelTVXCounter = 0; // redundant but we keep it int readCollisionWithTVXAndZVertexAndSel7Counter = 0; int readCollisionWithTVXAndZVertexAndSel7KINT7Counter = 0; + int readCollisionWithCustomCounter = 0; for (const auto& collision : collisions) { readCollisionCounter++; - if (jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::JCollisionSel::selTVX)) { // asuumes all selections include the TVX trigger + if (jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::initialiseEventSelectionBits("TVX"))) { // asuumes all selections include the TVX trigger readCollisionWithTVXCounter++; if (std::abs(collision.posZ()) > vertexZCutForCounting) { continue; } - if (jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::JCollisionSel::sel8)) { + if (jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::initialiseEventSelectionBits("sel8"))) { readCollisionWithTVXAndZVertexAndSel8Counter++; } - if (jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::JCollisionSel::sel8Full)) { + if (jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::initialiseEventSelectionBits("TVX"))) { + readCollisionWithTVXAndZVertexAndSelTVXCounter++; + } + if (jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::initialiseEventSelectionBits("sel7"))) { + readCollisionWithTVXAndZVertexAndSel7Counter++; + } + if (jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::initialiseEventSelectionBits("sel7KINT7"))) { + readCollisionWithTVXAndZVertexAndSel7KINT7Counter++; + } + if (jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::initialiseEventSelectionBits("sel8Full"))) { readCollisionWithTVXAndZVertexAndSel8FullCounter++; } - if (jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::JCollisionSel::sel8FullPbPb)) { + if (jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::initialiseEventSelectionBits("sel8FullPbPb"))) { readCollisionWithTVXAndZVertexAndSel8FullPbPbCounter++; } - if (jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::JCollisionSel::selMC)) { + if (jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::initialiseEventSelectionBits("selMC"))) { readCollisionWithTVXAndZVertexAndSelMCCounter++; } - if (jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::JCollisionSel::selMCFull)) { + if (jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::initialiseEventSelectionBits("selMCFull"))) { readCollisionWithTVXAndZVertexAndSelMCFullCounter++; } - if (jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::JCollisionSel::selMCFullPbPb)) { + if (jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::initialiseEventSelectionBits("selMCFullPbPb"))) { readCollisionWithTVXAndZVertexAndSelMCFullPbPbCounter++; } - if (jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::JCollisionSel::selUnanchoredMC)) { + if (jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::initialiseEventSelectionBits("selUnanchoredMC"))) { readCollisionWithTVXAndZVertexAndSelUnanchoredMCCounter++; } - if (jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::JCollisionSel::selTVX)) { - readCollisionWithTVXAndZVertexAndSelTVXCounter++; - } - if (jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::JCollisionSel::sel7)) { - readCollisionWithTVXAndZVertexAndSel7Counter++; - } - if (jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::JCollisionSel::sel7KINT7)) { - readCollisionWithTVXAndZVertexAndSel7KINT7Counter++; + if (jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::initialiseEventSelectionBits(static_cast(customEventSelections)))) { + readCollisionWithCustomCounter++; } } } @@ -153,6 +158,7 @@ struct LuminosityProducer { std::vector previousReadCountsWithTVXAndZVertexAndSelTVX; std::vector previousReadCountsWithTVXAndZVertexAndSel7; std::vector previousReadCountsWithTVXAndZVertexAndSel7KINT7; + std::vector previousReadCountsWithCustom; int iPreviousDataFrame = 0; for (const auto& collisionCount : collisionCounts) { @@ -168,6 +174,7 @@ struct LuminosityProducer { auto readCollisionWithTVXAndZVertexAndSelTVXCounterSpan = collisionCount.readCountsWithTVXAndZVertexAndSelTVX(); auto readCollisionWithTVXAndZVertexAndSel7CounterSpan = collisionCount.readCountsWithTVXAndZVertexAndSel7(); auto readCollisionWithTVXAndZVertexAndSel7KINT7CounterSpan = collisionCount.readCountsWithTVXAndZVertexAndSel7KINT7(); + auto readCollisionWithCustomCounterSpan = collisionCount.readCountsWithCustom(); if (iPreviousDataFrame == 0) { std::copy(readCollisionCounterSpan.begin(), readCollisionCounterSpan.end(), std::back_inserter(previousReadCounts)); @@ -182,6 +189,7 @@ struct LuminosityProducer { std::copy(readCollisionWithTVXAndZVertexAndSelTVXCounterSpan.begin(), readCollisionWithTVXAndZVertexAndSelTVXCounterSpan.end(), std::back_inserter(previousReadCountsWithTVXAndZVertexAndSelTVX)); std::copy(readCollisionWithTVXAndZVertexAndSel7CounterSpan.begin(), readCollisionWithTVXAndZVertexAndSel7CounterSpan.end(), std::back_inserter(previousReadCountsWithTVXAndZVertexAndSel7)); std::copy(readCollisionWithTVXAndZVertexAndSel7KINT7CounterSpan.begin(), readCollisionWithTVXAndZVertexAndSel7KINT7CounterSpan.end(), std::back_inserter(previousReadCountsWithTVXAndZVertexAndSel7KINT7)); + std::copy(readCollisionWithCustomCounterSpan.begin(), readCollisionWithCustomCounterSpan.end(), std::back_inserter(previousReadCountsWithCustom)); } else { for (unsigned int i = 0; i < previousReadCounts.size(); i++) { // in principle we only care about the first element, but might be interesting information to keep @@ -197,6 +205,7 @@ struct LuminosityProducer { previousReadCountsWithTVXAndZVertexAndSelTVX[i] += readCollisionWithTVXAndZVertexAndSelTVXCounterSpan[i]; previousReadCountsWithTVXAndZVertexAndSel7[i] += readCollisionWithTVXAndZVertexAndSel7CounterSpan[i]; previousReadCountsWithTVXAndZVertexAndSel7KINT7[i] += readCollisionWithTVXAndZVertexAndSel7KINT7CounterSpan[i]; + previousReadCountsWithCustom[i] += readCollisionWithCustomCounterSpan[i]; } } iPreviousDataFrame++; @@ -213,8 +222,9 @@ struct LuminosityProducer { previousReadCountsWithTVXAndZVertexAndSelTVX.push_back(readCollisionWithTVXAndZVertexAndSelTVXCounter); previousReadCountsWithTVXAndZVertexAndSel7.push_back(readCollisionWithTVXAndZVertexAndSel7Counter); previousReadCountsWithTVXAndZVertexAndSel7KINT7.push_back(readCollisionWithTVXAndZVertexAndSel7KINT7Counter); + previousReadCountsWithCustom.push_back(readCollisionWithCustomCounter); - storedCollisionCountsTable(previousReadCounts, previousReadCountsWithTVX, previousReadCountsWithTVXAndZVertexAndSel8, previousReadCountsWithTVXAndZVertexAndSel8Full, previousReadCountsWithTVXAndZVertexAndSel8FullPbPb, previousReadCountsWithTVXAndZVertexAndSelMC, previousReadCountsWithTVXAndZVertexAndSelMCFull, previousReadCountsWithTVXAndZVertexAndSelMCFullPbPb, previousReadCountsWithTVXAndZVertexAndSelUnanchoredMC, previousReadCountsWithTVXAndZVertexAndSelTVX, previousReadCountsWithTVXAndZVertexAndSel7, previousReadCountsWithTVXAndZVertexAndSel7KINT7); + storedCollisionCountsTable(previousReadCounts, previousReadCountsWithTVX, previousReadCountsWithTVXAndZVertexAndSel8, previousReadCountsWithTVXAndZVertexAndSel8Full, previousReadCountsWithTVXAndZVertexAndSel8FullPbPb, previousReadCountsWithTVXAndZVertexAndSelMC, previousReadCountsWithTVXAndZVertexAndSelMCFull, previousReadCountsWithTVXAndZVertexAndSelMCFullPbPb, previousReadCountsWithTVXAndZVertexAndSelUnanchoredMC, previousReadCountsWithTVXAndZVertexAndSelTVX, previousReadCountsWithTVXAndZVertexAndSel7, previousReadCountsWithTVXAndZVertexAndSel7KINT7, previousReadCountsWithCustom); } PROCESS_SWITCH(LuminosityProducer, processStoreCollisionCounting, "write out collision counting output table", true); }; diff --git a/PWGJE/Tasks/ChJetTriggerQATask.cxx b/PWGJE/Tasks/ChJetTriggerQATask.cxx index 7b8331706bc..6b60b68569d 100644 --- a/PWGJE/Tasks/ChJetTriggerQATask.cxx +++ b/PWGJE/Tasks/ChJetTriggerQATask.cxx @@ -96,13 +96,13 @@ struct ChJetTriggerQATask { HistogramRegistry spectra; - int eventSelection = -1; + std::vector eventSelectionBits; int trackSelection = -1; void init(InitContext&) { fiducialVolume = static_cast(cfgTPCVolume) - static_cast(cfgJetR); - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(evSel)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(evSel)); trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); // Basic histos @@ -166,7 +166,7 @@ struct ChJetTriggerQATask { return; } - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } diff --git a/PWGJE/Tasks/bjetTaggingML.cxx b/PWGJE/Tasks/bjetTaggingML.cxx index 8a7be4daa9a..df6939ae504 100644 --- a/PWGJE/Tasks/bjetTaggingML.cxx +++ b/PWGJE/Tasks/bjetTaggingML.cxx @@ -73,7 +73,7 @@ struct BJetTaggingML { Configurable> jetRadii{"jetRadii", std::vector{0.4}, "jet resolution parameters"}; - int eventSelection = -1; + std::vector eventSelectionBits; std::vector jetRadiiValues; @@ -84,7 +84,7 @@ struct BJetTaggingML { jetRadiiValues = (std::vector)jetRadii; - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); registry.add("h_vertexZ", "Vertex Z;#it{Z} (cm)", {HistType::kTH1F, {{40, -20.0, 20.0}}}); @@ -270,7 +270,7 @@ struct BJetTaggingML { void processDataJets(FilteredCollision::iterator const& collision, DataJets const& alljets, JetTrackswID const& allTracks, aod::DataSecondaryVertex3Prongs const& allSVs) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } @@ -321,7 +321,7 @@ struct BJetTaggingML { void processMCJets(FilteredCollisionMCD::iterator const& collision, MCDJetTable const& MCDjets, MCPJetTable const& MCPjets, JetTracksMCDwID const& allTracks, aod::JetParticles const& /*MCParticles*/, aod::MCDSecondaryVertex3Prongs const& allSVs) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } diff --git a/PWGJE/Tasks/bjetTreeCreator.cxx b/PWGJE/Tasks/bjetTreeCreator.cxx index 361c250e5e2..b99d6f41bd8 100644 --- a/PWGJE/Tasks/bjetTreeCreator.cxx +++ b/PWGJE/Tasks/bjetTreeCreator.cxx @@ -227,7 +227,7 @@ struct BJetTreeCreator { Configurable vtxRes{"vtxRes", 0.01, "Vertex position resolution (cluster size) for GNN vertex predictions (cm)"}; - int eventSelection = -1; + std::vector eventSelectionBits; std::vector jetRadiiValues; std::vector jetPtBinsReduction; @@ -242,7 +242,7 @@ struct BJetTreeCreator { jetPtBinsReduction = (std::vector)jetPtBins; jetReductionFactorsPt = (std::vector)jetReductionFactors; - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); registry.add("h_vertexZ", "Vertex Z;#it{Z} (cm)", {HistType::kTH1F, {{40, -20.0, 20.0}}}); @@ -544,7 +544,7 @@ struct BJetTreeCreator { void processDataJets(FilteredCollision::iterator const& collision, DataJets const& alljets, JetTrackswID const& allTracks, aod::DataSecondaryVertex3Prongs const& allSVs) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection) || (static_cast(std::rand()) / RAND_MAX < eventReductionFactor)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits) || (static_cast(std::rand()) / RAND_MAX < eventReductionFactor)) { return; } @@ -598,7 +598,7 @@ struct BJetTreeCreator { void processMCJets(FilteredCollisionMCD::iterator const& collision, MCDJetTable const& MCDjets, MCPJetTable const& MCPjets, JetTracksMCDwID const& allTracks, aod::JetParticles const& MCParticles, aod::MCDSecondaryVertex3Prongs const& allSVs) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection) || (static_cast(std::rand()) / RAND_MAX < eventReductionFactor)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits) || (static_cast(std::rand()) / RAND_MAX < eventReductionFactor)) { return; } @@ -698,7 +698,7 @@ struct BJetTreeCreator { void processMCJetsForGNN(FilteredCollisionMCD::iterator const& collision, aod::JMcCollisions const&, MCDJetTableNoSV const& MCDjets, MCPJetTable const& MCPjets, JetTracksMCDwID const& allTracks, JetParticleswID const& MCParticles, OriginalTracks const& origTracks, aod::McParticles const& origParticles) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection) || (static_cast(std::rand()) / RAND_MAX < eventReductionFactor)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits) || (static_cast(std::rand()) / RAND_MAX < eventReductionFactor)) { return; } diff --git a/PWGJE/Tasks/dijetFinderQA.cxx b/PWGJE/Tasks/dijetFinderQA.cxx index 45f757c6914..4f094c68cd9 100644 --- a/PWGJE/Tasks/dijetFinderQA.cxx +++ b/PWGJE/Tasks/dijetFinderQA.cxx @@ -69,14 +69,14 @@ struct DijetFinderQATask { Configurable trackSelections{"trackSelections", "globalTracks", "set track selections"}; Configurable checkMcCollisionIsMatched{"checkMcCollisionIsMatched", false, "0: count whole MCcollisions, 1: select MCcollisions which only have their correspond collisions"}; - int eventSelection = -1; + std::vector eventSelectionBits; int trackSelection = -1; std::vector jetPtBins; void init(o2::framework::InitContext&) { - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); auto jetPtTemp = 0.0; @@ -249,7 +249,7 @@ struct DijetFinderQATask { void processDijetMCD(soa::Filtered::iterator const& collision, soa::Filtered const& jets) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } std::vector> jetPtcuts; @@ -286,7 +286,7 @@ struct DijetFinderQATask { void processDijetData(soa::Filtered::iterator const& collision, soa::Filtered const& jets) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } @@ -327,7 +327,7 @@ struct DijetFinderQATask { soa::Filtered> const& mcdjets, JetMCPTable const&, aod::JetTracks const&, aod::JetParticles const&) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } diff --git a/PWGJE/Tasks/fullJetSpectraPP.cxx b/PWGJE/Tasks/fullJetSpectraPP.cxx index 64b0f308bf5..9b16c0501ef 100644 --- a/PWGJE/Tasks/fullJetSpectraPP.cxx +++ b/PWGJE/Tasks/fullJetSpectraPP.cxx @@ -106,7 +106,7 @@ struct FullJetSpectrapp { Configurable pTHatExponent{"pTHatExponent", 4.0, "exponent of the event weight for the calculation of pTHat"}; // 6 for MB MC and 4 for JJ MC int trackSelection = -1; - int eventSelection = -1; + std::vector eventSelectionBits; std::vector filledJetR; std::vector jetRadiiValues; @@ -149,7 +149,7 @@ struct FullJetSpectrapp { void init(o2::framework::InitContext&) { trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); particleSelection = static_cast(particleSelections); jetRadiiValues = (std::vector)jetRadii; diff --git a/PWGJE/Tasks/gammaJetTreeProducer.cxx b/PWGJE/Tasks/gammaJetTreeProducer.cxx index e1ffd83887f..351742682d0 100644 --- a/PWGJE/Tasks/gammaJetTreeProducer.cxx +++ b/PWGJE/Tasks/gammaJetTreeProducer.cxx @@ -85,7 +85,7 @@ struct GammaJetTreeProducer { Configurable minClusterETrigger{"minClusterETrigger", 0.0, "minimum cluster energy to trigger"}; int mRunNumber = 0; - int eventSelection = -1; + std::vector eventSelectionBits; int trackSelection = -1; std::unordered_map collisionMapping; @@ -96,7 +96,7 @@ struct GammaJetTreeProducer { using o2HistType = HistType; using o2Axis = AxisSpec; - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); triggerMaskBits = jetderiveddatautilities::initialiseTriggerMaskBits(triggerMasks); trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); @@ -150,7 +150,7 @@ struct GammaJetTreeProducer { if (collision.posZ() > mVertexCut) { return false; } - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return false; } if (!jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) { diff --git a/PWGJE/Tasks/hadronPhotonCorrelation.cxx b/PWGJE/Tasks/hadronPhotonCorrelation.cxx index 429981aac0e..df7c9dc17b1 100644 --- a/PWGJE/Tasks/hadronPhotonCorrelation.cxx +++ b/PWGJE/Tasks/hadronPhotonCorrelation.cxx @@ -18,6 +18,7 @@ #include #include +#include #include "Framework/ASoA.h" #include "Framework/ASoAHelpers.h" @@ -115,7 +116,7 @@ struct HadronPhotonCorrelation { return dphi; } - int eventSelection = -1; + std::vector eventSelectionBits; int trackSelection = -1; void init(o2::framework::InitContext&) @@ -125,7 +126,7 @@ struct HadronPhotonCorrelation { ptMinAssoc = axisPtAssoc->at(1); ptMaxAssoc = axisPtAssoc->back(); - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); // Generated histograms @@ -317,7 +318,7 @@ struct HadronPhotonCorrelation { void processTrigsReco(JetCollision const& collision, JetTracks const& tracks) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } @@ -343,7 +344,7 @@ struct HadronPhotonCorrelation { Join const& tracks, JetParticles const&) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } @@ -391,7 +392,7 @@ struct HadronPhotonCorrelation { MyTracks const&, V0Datas const& v0s) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } @@ -430,7 +431,7 @@ struct HadronPhotonCorrelation { MyTracksMC const&, V0Datas const& v0s) { - if (!jetderiveddatautilities::selectCollision(collision_reco, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision_reco, eventSelectionBits)) { return; } @@ -509,7 +510,7 @@ struct HadronPhotonCorrelation { void processHadronCorrelations(JetCollision const& collision, Join const& tracks) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } @@ -580,7 +581,7 @@ struct HadronPhotonCorrelation { Join const& tracks_reco, JetParticles const&) { - if (!jetderiveddatautilities::selectCollision(collision_reco, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision_reco, eventSelectionBits)) { return; } @@ -638,7 +639,7 @@ struct HadronPhotonCorrelation { void processPionCorrelations(JetCollision const& collision, Join const& tracks) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } @@ -708,7 +709,7 @@ struct HadronPhotonCorrelation { Join const& tracks_reco, JetParticles const&) { - if (!jetderiveddatautilities::selectCollision(collision_reco, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision_reco, eventSelectionBits)) { return; } diff --git a/PWGJE/Tasks/hfFragmentationFunction.cxx b/PWGJE/Tasks/hfFragmentationFunction.cxx index 611ac1aab1e..667baf91bf0 100644 --- a/PWGJE/Tasks/hfFragmentationFunction.cxx +++ b/PWGJE/Tasks/hfFragmentationFunction.cxx @@ -193,12 +193,12 @@ struct HfFragmentationFunction { Configurable vertexZCut{"vertexZCut", 10.0f, "Accepted z-vertex range"}; Configurable eventSelections{"eventSelections", "sel8", "choose event selection"}; - int eventSelection = -1; + std::vector eventSelectionBits; void init(InitContext const&) { // initialise event selection: - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); // create histograms // collision system histograms @@ -238,7 +238,7 @@ struct HfFragmentationFunction { { // apply event selection and fill histograms for sanity check registry.fill(HIST("h_collision_counter"), 2.0); - if (!jetderiveddatautilities::selectCollision(collision, eventSelection) || !(std::abs(collision.posZ()) < vertexZCut)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits) || !(std::abs(collision.posZ()) < vertexZCut)) { return; } registry.fill(HIST("h_collision_counter"), 3.0); @@ -307,7 +307,7 @@ struct HfFragmentationFunction { for (const auto& collision : collisionsPerMCCollision) { registry.fill(HIST("h_collision_counter"), 2.0); - if (!jetderiveddatautilities::selectCollision(collision, eventSelection) || !(std::abs(collision.posZ()) < vertexZCut)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits) || !(std::abs(collision.posZ()) < vertexZCut)) { continue; } registry.fill(HIST("h_collision_counter"), 3.0); @@ -398,7 +398,7 @@ struct HfFragmentationFunction { for (const auto& collision : collisionsPerMCCollision) { registry.fill(HIST("h_collision_counter"), 2.0); - if (!jetderiveddatautilities::selectCollision(collision, eventSelection) || !(std::abs(collision.posZ()) < vertexZCut)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits) || !(std::abs(collision.posZ()) < vertexZCut)) { continue; } registry.fill(HIST("h_collision_counter"), 3.0); diff --git a/PWGJE/Tasks/jetBackgroundAnalysis.cxx b/PWGJE/Tasks/jetBackgroundAnalysis.cxx index c242b681604..75ed414d205 100644 --- a/PWGJE/Tasks/jetBackgroundAnalysis.cxx +++ b/PWGJE/Tasks/jetBackgroundAnalysis.cxx @@ -17,6 +17,7 @@ #include #include #include +#include #include "TLorentzVector.h" #include "Framework/ASoA.h" @@ -68,13 +69,13 @@ struct JetBackgroundAnalysisTask { Configurable randomConeR{"randomConeR", 0.4, "size of random Cone for estimating background fluctuations"}; Configurable randomConeLeadJetDeltaR{"randomConeLeadJetDeltaR", -99.0, "min distance between leading jet axis and random cone (RC) axis; if negative, min distance is set to automatic value of R_leadJet+R_RC "}; - int eventSelection = -1; + std::vector eventSelectionBits; int trackSelection = -1; void init(o2::framework::InitContext&) { // selection settings initialisation - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); // histogram definitions @@ -113,7 +114,7 @@ struct JetBackgroundAnalysisTask { template void bkgFluctuationsRandomCone(TCollisions const& collision, TJets const& jets, TTracks const& tracks) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { @@ -200,7 +201,7 @@ struct JetBackgroundAnalysisTask { void processRho(soa::Filtered>::iterator const& collision, soa::Filtered const& tracks) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { diff --git a/PWGJE/Tasks/jetChargedV2.cxx b/PWGJE/Tasks/jetChargedV2.cxx index 2ff6b01957c..d4e319765af 100644 --- a/PWGJE/Tasks/jetChargedV2.cxx +++ b/PWGJE/Tasks/jetChargedV2.cxx @@ -149,7 +149,7 @@ struct JetChargedV2 { std::vector jetPtBins; std::vector jetPtBinsRhoAreaSub; - int eventSelection = -1; + std::vector eventSelectionBits; int trackSelection = -1; double evtnum = 0; double accptTrack = 0; @@ -200,7 +200,7 @@ struct JetChargedV2 { AxisSpec axixCent = {20, 0, 100}; AxisSpec axisChID = {220, 0, 220}; - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); //< \sigma p_T at local rho test plot > @@ -354,7 +354,7 @@ struct JetChargedV2 { if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { return; } - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } //=====================< evt pln [n=2->\Psi_2, n=3->\Psi_3] >=====================// @@ -446,7 +446,7 @@ struct JetChargedV2 { if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { return; } - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } double leadingJetPt = -1; @@ -735,7 +735,7 @@ struct JetChargedV2 { if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { return; } - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } @@ -798,7 +798,7 @@ struct JetChargedV2 { if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { return; } - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } for (auto const& track : tracks) { diff --git a/PWGJE/Tasks/jetFinderHFQA.cxx b/PWGJE/Tasks/jetFinderHFQA.cxx index f20c9314905..6ed3ab41306 100644 --- a/PWGJE/Tasks/jetFinderHFQA.cxx +++ b/PWGJE/Tasks/jetFinderHFQA.cxx @@ -81,7 +81,7 @@ struct JetFinderHFQATask { std::vector filledJetHFR_High; std::vector jetRadiiValues; - int eventSelection = -1; + std::vector eventSelectionBits; int trackSelection = -1; std::vector jetPtBins; @@ -89,7 +89,7 @@ struct JetFinderHFQATask { void init(o2::framework::InitContext&) { - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); jetRadiiValues = (std::vector)jetRadii; @@ -949,7 +949,7 @@ struct JetFinderHFQATask { void randomCone(T const& collision, U const& jets, V const& candidates, M const& tracks) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } for (auto const& candidate : candidates) { @@ -1196,7 +1196,7 @@ struct JetFinderHFQATask { return; } registry.fill(HIST("h_collision_trigger_events"), 1.5); // all events with z vertex cut - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } registry.fill(HIST("h_collision_trigger_events"), 2.5); // events with sel8() @@ -1362,7 +1362,7 @@ struct JetFinderHFQATask { return; } registry.fill(HIST("h_collision_hftrigger_events"), 1.5); // all events with z vertex cut - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } registry.fill(HIST("h_collision_hftrigger_events"), 2.5); // events with sel8() @@ -1477,7 +1477,7 @@ struct JetFinderHFQATask { } registry.fill(HIST("h_collisions"), 0.5); registry.fill(HIST("h2_centrality_collisions"), collision.centrality(), 0.5); - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } registry.fill(HIST("h_collisions"), 1.5); @@ -1496,7 +1496,7 @@ struct JetFinderHFQATask { } registry.fill(HIST("h_collisions"), 0.5); registry.fill(HIST("h_collisions_weighted"), 0.5, eventWeight); - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } registry.fill(HIST("h_collisions"), 1.5); @@ -1512,7 +1512,7 @@ struct JetFinderHFQATask { if (skipMBGapEvents && collision.subGeneratorId() == jetderiveddatautilities::JCollisionSubGeneratorId::mbGap) { return; } - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } for (auto const& candidate : candidates) { @@ -1532,7 +1532,7 @@ struct JetFinderHFQATask { if (skipMBGapEvents && collision.subGeneratorId() == jetderiveddatautilities::JCollisionSubGeneratorId::mbGap) { return; } - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } for (auto const& candidate : candidates) { diff --git a/PWGJE/Tasks/jetFinderQA.cxx b/PWGJE/Tasks/jetFinderQA.cxx index 337389e8c53..c5a0440f5b5 100644 --- a/PWGJE/Tasks/jetFinderQA.cxx +++ b/PWGJE/Tasks/jetFinderQA.cxx @@ -80,7 +80,7 @@ struct JetFinderQATask { std::vector filledJetR_High; std::vector jetRadiiValues; - int eventSelection = -1; + std::vector eventSelectionBits; int trackSelection = -1; std::vector jetPtBins; @@ -88,7 +88,7 @@ struct JetFinderQATask { void init(o2::framework::InitContext&) { - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); jetRadiiValues = (std::vector)jetRadii; @@ -611,7 +611,7 @@ struct JetFinderQATask { template void randomCone(T const& collision, U const& jets, V const& tracks) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { @@ -854,7 +854,7 @@ struct JetFinderQATask { } if (checkMcCollisionIsMatched) { auto collisionspermcpjet = collisions.sliceBy(CollisionsPerMCPCollision, jet.mcCollisionId()); - if (collisionspermcpjet.size() >= 1 && jetderiveddatautilities::selectCollision(collisionspermcpjet.begin(), eventSelection)) { + if (collisionspermcpjet.size() >= 1 && jetderiveddatautilities::selectCollision(collisionspermcpjet.begin(), eventSelectionBits)) { fillMCPHistograms(jet); } } else { @@ -879,7 +879,7 @@ struct JetFinderQATask { } if (checkMcCollisionIsMatched) { auto collisionspermcpjet = collisions.sliceBy(CollisionsPerMCPCollision, jet.mcCollisionId()); - if (collisionspermcpjet.size() >= 1 && jetderiveddatautilities::selectCollision(collisionspermcpjet.begin(), eventSelection)) { + if (collisionspermcpjet.size() >= 1 && jetderiveddatautilities::selectCollision(collisionspermcpjet.begin(), eventSelectionBits)) { fillMCPHistograms(jet, jet.eventWeight()); } } else { @@ -946,7 +946,7 @@ struct JetFinderQATask { return; } registry.fill(HIST("h_collision_trigger_events"), 1.5); // all events with z vertex cut - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } registry.fill(HIST("h_collision_trigger_events"), 2.5); // events with sel8() @@ -1071,7 +1071,7 @@ struct JetFinderQATask { } registry.fill(HIST("h_collisions"), 0.5); registry.fill(HIST("h2_centrality_collisions"), collision.centrality(), 0.5); - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } registry.fill(HIST("h_collisions"), 1.5); @@ -1095,7 +1095,7 @@ struct JetFinderQATask { } registry.fill(HIST("h_collisions"), 0.5); registry.fill(HIST("h_collisions_weighted"), 0.5, eventWeight); - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } registry.fill(HIST("h_collisions"), 1.5); @@ -1115,7 +1115,7 @@ struct JetFinderQATask { if (skipMBGapEvents && collision.subGeneratorId() == jetderiveddatautilities::JCollisionSubGeneratorId::mbGap) { return; } - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { @@ -1134,7 +1134,7 @@ struct JetFinderQATask { if (skipMBGapEvents && collision.subGeneratorId() == jetderiveddatautilities::JCollisionSubGeneratorId::mbGap) { return; } - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { diff --git a/PWGJE/Tasks/jetFinderV0QA.cxx b/PWGJE/Tasks/jetFinderV0QA.cxx index 362239cf8e1..9c681fa3bce 100644 --- a/PWGJE/Tasks/jetFinderV0QA.cxx +++ b/PWGJE/Tasks/jetFinderV0QA.cxx @@ -13,6 +13,8 @@ // /// \author Nima Zardoshti +#include +#include #include #include "CommonConstants/PhysicsConstants.h" @@ -68,12 +70,12 @@ struct JetFinderV0QATask { Configurable pTHatMaxMCP{"pTHatMaxMCP", 999.0, "maximum fraction of hard scattering for jet acceptance in particle MC"}; Configurable pTHatExponent{"pTHatExponent", 6.0, "exponent of the event weight for the calculation of pTHat"}; - int eventSelection = -1; + std::vector eventSelectionBits; int trackSelection = -1; void init(o2::framework::InitContext&) { - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); auto jetRadiiBins = (std::vector)jetRadii; @@ -386,7 +388,7 @@ struct JetFinderV0QATask { { registry.fill(HIST("h_collisions"), 0.5); registry.fill(HIST("h2_centrality_collisions"), collision.centrality(), 0.5); - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } registry.fill(HIST("h_collisions"), 1.5); @@ -402,7 +404,7 @@ struct JetFinderV0QATask { float eventWeight = collision.mcCollision().weight(); registry.fill(HIST("h_collisions"), 0.5); registry.fill(HIST("h_collisions_weighted"), 0.5, eventWeight); - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } registry.fill(HIST("h_collisions"), 1.5); diff --git a/PWGJE/Tasks/jetFragmentation.cxx b/PWGJE/Tasks/jetFragmentation.cxx index 8f939d75f46..c1ff81fcf88 100644 --- a/PWGJE/Tasks/jetFragmentation.cxx +++ b/PWGJE/Tasks/jetFragmentation.cxx @@ -14,6 +14,7 @@ /// \author Gijs van Weelden // +#include #include "TH1F.h" #include "TTree.h" @@ -160,11 +161,11 @@ struct JetFragmentation { Preslice JetParticlesPerCollision = aod::jmcparticle::mcCollisionId; Preslice ParticlesPerCollision = aod::mcparticle::mcCollisionId; - int eventSelection = -1; + std::vector eventSelectionBits; void init(InitContext&) { - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(evSel)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(evSel)); // Axes AxisSpec jetPtAxis = {binJetPt, "#it{p}_{T}^{ jet}"}; // Data @@ -2320,7 +2321,7 @@ struct JetFragmentation { if (!collision.has_mcCollision()) { return; } - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } double nJets = 0, nTracks = 0; @@ -2365,7 +2366,7 @@ struct JetFragmentation { ChargedJetsWithConstituents const& jets, aod::JetTracks const& tracks) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } double nJets = 0, nTracks = 0; @@ -2398,7 +2399,7 @@ struct JetFragmentation { if (!collision.has_mcCollision()) { return; } - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } double weight = collision.mcCollision().weight(); @@ -2485,7 +2486,7 @@ struct JetFragmentation { if (!collision.has_mcCollision()) { return; } - // if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + // if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { // return; // } double weight = collision.mcCollision().weight(); @@ -2512,7 +2513,7 @@ struct JetFragmentation { if (!jcoll.has_mcCollision()) { return; } - if (!jetderiveddatautilities::selectCollision(jcoll, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(jcoll, eventSelectionBits)) { return; } double weight = jcoll.mcCollision().weight(); @@ -2665,7 +2666,7 @@ struct JetFragmentation { aod::Collisions const&, aod::V0Datas const& allV0s) { - if (!jetderiveddatautilities::selectCollision(jcoll, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(jcoll, eventSelectionBits)) { return; } // This is necessary, because jets are linked to aod::JetCollisions, but V0s are linked to Collisions @@ -2744,7 +2745,7 @@ struct JetFragmentation { // ---------------- V0 jets ---------------- void processDataV0JetsFrag(soa::Filtered::iterator const& jcoll, soa::Join const& v0jets, aod::CandidatesV0Data const& v0s) { - if (!jetderiveddatautilities::selectCollision(jcoll, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(jcoll, eventSelectionBits)) { return; } registry.fill(HIST("data/V0/nV0sEvent"), v0s.size()); @@ -2781,7 +2782,7 @@ struct JetFragmentation { void processDataV0JetsFragWithWeights(soa::Filtered::iterator const& jcoll, soa::Join const& v0jets, aod::CandidatesV0Data const& v0s) { - if (!jetderiveddatautilities::selectCollision(jcoll, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(jcoll, eventSelectionBits)) { return; } registry.fill(HIST("data/V0/nV0sEvent"), v0s.size()); @@ -2828,7 +2829,7 @@ struct JetFragmentation { void processDataV0PerpCone(soa::Filtered::iterator const& jcoll, aod::V0ChargedJets const& v0jets, aod::CandidatesV0Data const& v0s) { - if (!jetderiveddatautilities::selectCollision(jcoll, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(jcoll, eventSelectionBits)) { return; } if (v0s.size() == 0) { @@ -2851,7 +2852,7 @@ struct JetFragmentation { if (!jcoll.has_mcCollision()) { return; } - if (!jetderiveddatautilities::selectCollision(jcoll, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(jcoll, eventSelectionBits)) { return; } double weight = jcoll.mcCollision().weight(); @@ -2971,7 +2972,7 @@ struct JetFragmentation { void processMcV0PerpCone(soa::Filtered::iterator const& jcoll, aod::JetMcCollisions const&, MatchedMCDV0Jets const& v0jets, soa::Join const& v0s, aod::McParticles const& particles) { - if (!jetderiveddatautilities::selectCollision(jcoll, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(jcoll, eventSelectionBits)) { return; } if (v0s.size() == 0) { @@ -2992,7 +2993,7 @@ struct JetFragmentation { void processMcV0MatchedPerpCone(soa::Filtered::iterator const& jcoll, aod::JetMcCollisions const&, MatchedMCDV0Jets const& v0jets, MatchedMCPV0Jets const&, soa::Join const& v0s, aod::McParticles const& particles) { - if (!jetderiveddatautilities::selectCollision(jcoll, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(jcoll, eventSelectionBits)) { return; } if (v0s.size() == 0) { diff --git a/PWGJE/Tasks/jetHadronRecoil.cxx b/PWGJE/Tasks/jetHadronRecoil.cxx index 3f4a8d844aa..e88b08617d5 100644 --- a/PWGJE/Tasks/jetHadronRecoil.cxx +++ b/PWGJE/Tasks/jetHadronRecoil.cxx @@ -139,7 +139,7 @@ struct JetHadronRecoil { {"hDeltaRResolution", "#DeltaR Resolution;p_{T,part};Resolution", {HistType::kTH2F, {{200, 0, 200}, {1000, -0.15, 0.15}}}}, {"hFullMatching", "Full 6D matching;p_{T,det};p_{T,part};#phi_{det};#phi_{part};#DeltaR_{det};#DeltaR_{part}", {HistType::kTHnSparseD, {ptAxisDet, ptAxisPart, phiAxisDet, phiAxisPart, dRAxisDet, dRAxisPart}}}}}; - int eventSelection = -1; + std::vector eventSelectionBits; int trackSelection = -1; std::vector triggerMaskBits; @@ -147,7 +147,7 @@ struct JetHadronRecoil { void init(InitContext const&) { - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); triggerMaskBits = jetderiveddatautilities::initialiseTriggerMaskBits(triggerMasks); @@ -469,7 +469,7 @@ struct JetHadronRecoil { soa::Filtered> const& jetsWTA, soa::Filtered const& tracks) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } if (!jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) { @@ -485,7 +485,7 @@ struct JetHadronRecoil { soa::Filtered> const& jetsWTA, soa::Filtered const& tracks) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } if (!jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) { @@ -501,7 +501,7 @@ struct JetHadronRecoil { soa::Filtered> const& jetsWTA, soa::Filtered const& tracks) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } if (skipMBGapEvents && collision.subGeneratorId() == jetderiveddatautilities::JCollisionSubGeneratorId::mbGap) { @@ -520,7 +520,7 @@ struct JetHadronRecoil { soa::Filtered> const& jetsWTA, soa::Filtered const& tracks) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } if (skipMBGapEvents && collision.subGeneratorId() == jetderiveddatautilities::JCollisionSubGeneratorId::mbGap) { @@ -540,7 +540,7 @@ struct JetHadronRecoil { soa::Filtered> const& jetsWTA, soa::Filtered const& tracks) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } if (skipMBGapEvents && collision.subGeneratorId() == jetderiveddatautilities::JCollisionSubGeneratorId::mbGap) { @@ -560,7 +560,7 @@ struct JetHadronRecoil { soa::Filtered> const& jetsWTA, soa::Filtered const& tracks) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } if (skipMBGapEvents && collision.subGeneratorId() == jetderiveddatautilities::JCollisionSubGeneratorId::mbGap) { @@ -615,7 +615,7 @@ struct JetHadronRecoil { aod::JetMcCollisions const&, soa::Filtered> const& mcpjets) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } if (!jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) { @@ -638,7 +638,7 @@ struct JetHadronRecoil { aod::JetMcCollisions const&, soa::Filtered> const& mcpjets) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } if (!jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) { @@ -661,7 +661,7 @@ struct JetHadronRecoil { aod::JetMcCollisions const&, soa::Filtered> const& mcpjets) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } if (!jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) { @@ -684,7 +684,7 @@ struct JetHadronRecoil { aod::JetMcCollisions const&, soa::Filtered> const& mcpjets) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } if (!jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) { @@ -707,7 +707,7 @@ struct JetHadronRecoil { aod::JetMcCollisions const&, soa::Filtered> const& mcpjets) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } if (!jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) { @@ -739,7 +739,7 @@ struct JetHadronRecoil { aod::JetMcCollisions const&, soa::Filtered> const& mcpjets) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } if (!jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) { diff --git a/PWGJE/Tasks/jetLundReclustering.cxx b/PWGJE/Tasks/jetLundReclustering.cxx index 4b43b0ad2a2..c18053343cf 100644 --- a/PWGJE/Tasks/jetLundReclustering.cxx +++ b/PWGJE/Tasks/jetLundReclustering.cxx @@ -21,6 +21,7 @@ #include #include #include +#include #include "fastjet/contrib/LundGenerator.hh" #include "fastjet/PseudoJet.hh" @@ -67,11 +68,11 @@ struct JetLundReclustering { Configurable jet_max_eta{"jet_max_eta", 0.5, "maximum jet eta"}; Configurable vertexZCut{"vertexZCut", 10.0f, "Accepted z-vertex range"}; - int eventSelection = -1; + std::vector eventSelectionBits; void init(InitContext const&) { - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); registry.add("PrimaryLundPlane_kT", "Primary Lund 3D plane;ln(R/Delta);ln(k_{t}/GeV);{p}_{t}", {HistType::kTH3F, {{100, 0, 10}, {100, -10, 10}, {20, 0, 200}}}); registry.add("PrimaryLundPlane_z", "Primary Lund 3D plane;ln(R/Delta);ln(1/z);{p}_{t}", {HistType::kTH3F, {{100, 0, 10}, {100, 0, 10}, {20, 0, 200}}}); @@ -122,7 +123,7 @@ struct JetLundReclustering { soa::Filtered> const& jets, aod::JetTracks const&) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } for (const auto& jet : jets) { diff --git a/PWGJE/Tasks/jetPlanarFlow.cxx b/PWGJE/Tasks/jetPlanarFlow.cxx index 9c2769978ca..d54ebea1ac2 100644 --- a/PWGJE/Tasks/jetPlanarFlow.cxx +++ b/PWGJE/Tasks/jetPlanarFlow.cxx @@ -14,6 +14,7 @@ /// \author Nima Zardoshti // +#include #include #include "Framework/AnalysisTask.h" @@ -106,7 +107,7 @@ struct JetPlanarFlowTask { Configurable zCutSD{"zCutSD", 0.10, "SoftDrop z cut"}; int trackSelection = -1; - int eventSelection = -1; + std::vector eventSelectionBits; std::string particleSelection; uint32_t precisionMask; @@ -120,7 +121,7 @@ struct JetPlanarFlowTask { void init(o2::framework::InitContext&) { trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); particleSelection = static_cast(particleSelections); precisionMask = 0xFFFFFC00; } @@ -282,7 +283,7 @@ struct JetPlanarFlowTask { soa::Join const& jets, aod::JetTracks const& tracks) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } for (auto const& jet : jets) { @@ -300,7 +301,7 @@ struct JetPlanarFlowTask { soa::Join const& jets, aod::JetTracks const& tracks) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } for (auto const& jet : jets) { @@ -318,7 +319,7 @@ struct JetPlanarFlowTask { soa::Join const& jets, aod::JetTracksSub const& tracks) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } for (auto const& jet : jets) { @@ -336,7 +337,7 @@ struct JetPlanarFlowTask { soa::Join const& jets, aod::JetTracks const& tracks) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } for (auto const& jet : jets) { diff --git a/PWGJE/Tasks/jetSpectraCharged.cxx b/PWGJE/Tasks/jetSpectraCharged.cxx index d4a111e3032..d4e3be818c0 100644 --- a/PWGJE/Tasks/jetSpectraCharged.cxx +++ b/PWGJE/Tasks/jetSpectraCharged.cxx @@ -18,6 +18,7 @@ #include #include #include +#include #include "Framework/ASoA.h" #include "Framework/AnalysisDataModel.h" @@ -82,12 +83,12 @@ struct JetSpectraCharged { Configurable checkGeoPtMatched{"checkGeoPtMatched", false, "0: turn off geometry and pT matching, 1: do geometry and pT matching"}; Configurable doMCPJetSubtraction{"doMCPJetSubtraction", false, "0: turn off subtraction for MCP jets, 1: do subtraction for MCP jets"}; - int eventSelection = -1; + std::vector eventSelectionBits; int trackSelection = -1; void init(o2::framework::InitContext&) { - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); AxisSpec centralityAxis = {1200, -10., 110., "Centrality"}; @@ -400,7 +401,7 @@ struct JetSpectraCharged { soa::Filtered> const& tracks) { registry.fill(HIST("h_collisions"), 0.5); - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } registry.fill(HIST("h_collisions"), 1.5); @@ -427,7 +428,7 @@ struct JetSpectraCharged { float eventWeight = collision.mcCollision().weight(); registry.fill(HIST("h_collisions"), 0.5); registry.fill(HIST("h_collisions_weighted"), 0.5, eventWeight); - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } registry.fill(HIST("h_collisions"), 1.5); @@ -452,7 +453,7 @@ struct JetSpectraCharged { soa::Join const& jets, aod::JetTracks const&) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { @@ -474,7 +475,7 @@ struct JetSpectraCharged { soa::Join const& jets, aod::JetTracks const&) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { @@ -496,7 +497,7 @@ struct JetSpectraCharged { soa::Join const& jets, aod::JetTracks const&) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { @@ -580,7 +581,7 @@ struct JetSpectraCharged { soa::Join const& jets, aod::JetTracksSub const&) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { @@ -602,7 +603,7 @@ struct JetSpectraCharged { soa::Join const& jets, aod::JetTracksSub const&) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { @@ -625,7 +626,7 @@ struct JetSpectraCharged { ChargedMCPMatchedJets const&, aod::JetTracks const&, aod::JetParticles const&) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { @@ -649,7 +650,7 @@ struct JetSpectraCharged { ChargedMCPMatchedJetsWeighted const&, aod::JetTracks const&, aod::JetParticles const&) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { @@ -686,7 +687,7 @@ struct JetSpectraCharged { registry.fill(HIST("h_mc_rho_matched"), mcrho); for (const auto& collision : collisions) { registry.fill(HIST("h_mcd_events_matched"), 0.5); - if (!jetderiveddatautilities::selectCollision(collision, eventSelection) || !(std::abs(collision.posZ()) < vertexZCut)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits) || !(std::abs(collision.posZ()) < vertexZCut)) { continue; } registry.fill(HIST("h_mcd_events_matched"), 1.5); diff --git a/PWGJE/Tasks/jetSpectraEseTask.cxx b/PWGJE/Tasks/jetSpectraEseTask.cxx index f6ea1fe4018..1a1e082b494 100644 --- a/PWGJE/Tasks/jetSpectraEseTask.cxx +++ b/PWGJE/Tasks/jetSpectraEseTask.cxx @@ -80,7 +80,7 @@ struct JetSpectraEseTask { HistogramRegistry registry{"registry", {}, OutputObjHandlingPolicy::AnalysisObject, false, false}; - int eventSelection{-1}; + std::vector eventSelectionBits; int trackSelection{-1}; using ChargedMCDJets = soa::Filtered>; @@ -96,7 +96,7 @@ struct JetSpectraEseTask { void init(o2::framework::InitContext&) { - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); LOGF(info, "jetSpectraEse::init()"); @@ -187,7 +187,7 @@ struct JetSpectraEseTask { { float counter{0.5f}; registry.fill(HIST("hEventCounter"), counter++); - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) return; registry.fill(HIST("hEventCounter"), counter++); @@ -239,7 +239,7 @@ struct JetSpectraEseTask { registry.fill(HIST("hPsiOccupancy"), collision.centrality(), vPsi2, occupancy); registry.fill(HIST("hOccupancy"), occupancy); - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) return; registry.fill(HIST("hEventCounterOcc"), count++); @@ -285,7 +285,7 @@ struct JetSpectraEseTask { aod::JetParticles const&) { float counter{0.5f}; - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) return; registry.fill(HIST("hMCDetEventCounter"), counter++); @@ -330,7 +330,7 @@ struct JetSpectraEseTask { return; } - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) return; registry.fill(HIST("hMCDMatchedEventCounter"), secCount++); diff --git a/PWGJE/Tasks/jetTaggerHFQA.cxx b/PWGJE/Tasks/jetTaggerHFQA.cxx index 7333b04c2bb..85e70a2eb0d 100644 --- a/PWGJE/Tasks/jetTaggerHFQA.cxx +++ b/PWGJE/Tasks/jetTaggerHFQA.cxx @@ -110,7 +110,7 @@ struct JetTaggerHFQA { ConfigurableAxis binSigmaLxyz{"binSigmaLxyz", {100, 0., 0.1}, ""}; int numberOfJetFlavourSpecies = 6; - int eventSelection = -1; + std::vector eventSelectionBits; int trackSelection = -1; HistogramRegistry registry{"registry", {}, OutputObjHandlingPolicy::AnalysisObject}; @@ -119,7 +119,7 @@ struct JetTaggerHFQA { { numberOfJetFlavourSpecies = static_cast(numFlavourSpecies); - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); // Axis AxisSpec axisJetFlavour = {binJetFlavour, "Jet flavour"}; @@ -969,7 +969,7 @@ struct JetTaggerHFQA { } if (checkMcCollisionIsMatched) { auto collisionspermcpjet = collisions.sliceBy(collisionsPerMCPCollision, mcpjet.mcCollisionId()); - if (collisionspermcpjet.size() >= 1 && jetderiveddatautilities::selectCollision(collisionspermcpjet.begin(), eventSelection)) { + if (collisionspermcpjet.size() >= 1 && jetderiveddatautilities::selectCollision(collisionspermcpjet.begin(), eventSelectionBits)) { fillHistogramIPsMCP(mcpjet); } } else { @@ -990,7 +990,7 @@ struct JetTaggerHFQA { } if (checkMcCollisionIsMatched) { auto collisionspermcpjet = collisions.sliceBy(collisionsPerMCPCollision, mcpjet.mcCollisionId()); - if (collisionspermcpjet.size() >= 1 && jetderiveddatautilities::selectCollision(collisionspermcpjet.begin(), eventSelection)) { + if (collisionspermcpjet.size() >= 1 && jetderiveddatautilities::selectCollision(collisionspermcpjet.begin(), eventSelectionBits)) { fillHistogramIPsMCP(mcpjet, mcpjet.eventWeight()); } else { fillHistogramIPsMCP(mcpjet, mcpjet.eventWeight()); diff --git a/PWGJE/Tasks/jetTutorial.cxx b/PWGJE/Tasks/jetTutorial.cxx index 230aaa53aaa..5a58f28886e 100644 --- a/PWGJE/Tasks/jetTutorial.cxx +++ b/PWGJE/Tasks/jetTutorial.cxx @@ -14,6 +14,9 @@ /// \author Nima Zardoshti // +#include +#include + #include "Framework/ASoA.h" #include "Framework/AnalysisDataModel.h" #include "Framework/AnalysisTask.h" @@ -82,13 +85,13 @@ struct JetTutorialTask { Configurable triggerMasks{"triggerMasks", "", "possible JE Trigger masks: fJetChLowPt,fJetChHighPt,fTrackLowPt,fTrackHighPt,fJetD0ChLowPt,fJetD0ChHighPt,fJetLcChLowPt,fJetLcChHighPt,fEMCALReadout,fJetFullHighPt,fJetFullLowPt,fJetNeutralHighPt,fJetNeutralLowPt,fGammaVeryHighPtEMCAL,fGammaVeryHighPtDCAL,fGammaHighPtEMCAL,fGammaHighPtDCAL,fGammaLowPtEMCAL,fGammaLowPtDCAL,fGammaVeryLowPtEMCAL,fGammaVeryLowPtDCAL"}; - int eventSelection = -1; + std::vector eventSelectionBits; int trackSelection = -1; std::vector triggerMaskBits; void init(o2::framework::InitContext&) { - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); triggerMaskBits = jetderiveddatautilities::initialiseTriggerMaskBits(triggerMasks); } @@ -103,7 +106,7 @@ struct JetTutorialTask { { registry.fill(HIST("h_collisions"), 0.5); - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } registry.fill(HIST("h_collisions"), 1.5); @@ -122,7 +125,7 @@ struct JetTutorialTask { { registry.fill(HIST("h_collisions"), 0.5); - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } registry.fill(HIST("h_collisions"), 1.5); @@ -141,7 +144,7 @@ struct JetTutorialTask { void processDataCharged(soa::Filtered::iterator const& collision, soa::Filtered const& jets) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } for (auto& jet : jets) { @@ -154,7 +157,7 @@ struct JetTutorialTask { void processMCDetectorLevelCharged(soa::Filtered::iterator const& collision, soa::Filtered const& jets) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } for (auto& jet : jets) { @@ -167,7 +170,7 @@ struct JetTutorialTask { void processMCDetectorLevelWeightedCharged(soa::Filtered::iterator const& collision, aod::JetMcCollisions const&, soa::Filtered const& jets) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } for (auto& jet : jets) { @@ -190,7 +193,7 @@ struct JetTutorialTask { void processMCCharged(soa::Filtered::iterator const& collision, aod::JetMcCollisions const&, soa::Filtered const& mcdjets, soa::Filtered const& mcpjets) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } for (auto& mcdjet : mcdjets) { @@ -214,7 +217,7 @@ struct JetTutorialTask { aod::JetTracks const&, aod::JetParticles const&) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } for (const auto& mcdjet : mcdjets) { @@ -229,7 +232,7 @@ struct JetTutorialTask { void processDataSubstructureCharged(soa::Filtered::iterator const& collision, soa::Filtered> const& jets, aod::JetTracks const&) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } for (auto& jet : jets) { @@ -294,7 +297,7 @@ struct JetTutorialTask { void processRecoilDataCharged(soa::Filtered::iterator const& collision, soa::Filtered const& jets, aod::JetTracks const& tracks) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } bool selectedEvent = false; @@ -325,7 +328,7 @@ struct JetTutorialTask { void processDataRhoAreaSubtractedCharged(soa::Filtered>::iterator const& collision, soa::Filtered const& jets) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } for (auto jet : jets) { @@ -339,7 +342,7 @@ struct JetTutorialTask { void processDataConstituentSubtractedCharged(soa::Filtered::iterator const& collision, soa::Filtered const& jets) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } for (auto jet : jets) { @@ -352,7 +355,7 @@ struct JetTutorialTask { void processDataConstituentSubtractedSubstructureCharged(soa::Filtered::iterator const& collision, soa::Filtered> const& jets, aod::JetTracksSub const&) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } for (auto jet : jets) { @@ -372,7 +375,7 @@ struct JetTutorialTask { void processDataTriggered(soa::Filtered::iterator const& collision, soa::Filtered const& jets) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection) || !jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits) || !jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) { return; } for (auto& jet : jets) { diff --git a/PWGJE/Tasks/jetTutorialSkeleton.cxx b/PWGJE/Tasks/jetTutorialSkeleton.cxx index 70fc22ec736..df2098539e8 100644 --- a/PWGJE/Tasks/jetTutorialSkeleton.cxx +++ b/PWGJE/Tasks/jetTutorialSkeleton.cxx @@ -14,6 +14,9 @@ /// \author Nima Zardoshti // +#include +#include + #include "Framework/ASoA.h" #include "Framework/AnalysisDataModel.h" #include "Framework/AnalysisTask.h" @@ -82,13 +85,13 @@ struct JetTutorialSkeletonTask { Configurable triggerMasks{"triggerMasks", "", "possible JE Trigger masks: fJetChLowPt,fJetChHighPt,fTrackLowPt,fTrackHighPt,fJetD0ChLowPt,fJetD0ChHighPt,fJetLcChLowPt,fJetLcChHighPt,fEMCALReadout,fJetFullHighPt,fJetFullLowPt,fJetNeutralHighPt,fJetNeutralLowPt,fGammaVeryHighPtEMCAL,fGammaVeryHighPtDCAL,fGammaHighPtEMCAL,fGammaHighPtDCAL,fGammaLowPtEMCAL,fGammaLowPtDCAL,fGammaVeryLowPtEMCAL,fGammaVeryLowPtDCAL"}; - int eventSelection = -1; + std::vector eventSelectionBits; int trackSelection = -1; std::vector triggerMaskBits; void init(o2::framework::InitContext&) { - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); triggerMaskBits = jetderiveddatautilities::initialiseTriggerMaskBits(triggerMasks); } diff --git a/PWGJE/Tasks/jetValidationQA.cxx b/PWGJE/Tasks/jetValidationQA.cxx index 261bea68571..9facbcaf6e9 100644 --- a/PWGJE/Tasks/jetValidationQA.cxx +++ b/PWGJE/Tasks/jetValidationQA.cxx @@ -175,7 +175,7 @@ struct jetTrackCollisionQa { { mHistManager.fill(HIST("controlCollisionVtxZ"), collision.posZ()); if (evSel == true) { - if (!jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::JCollisionSel::sel7) || fabs(collision.posZ()) > 10) { + if (!jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::initialiseEventSelectionBits("sel7")) || fabs(collision.posZ()) > 10) { return; } } else { @@ -242,7 +242,7 @@ struct jetTrackCollisionQa { void processRun3AOD(aod::JetCollision const& collision, soa::Join const& jets, TracksJE const& tracks, Tracks const&) { if (evSel == true) { - if (!jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::JCollisionSel::sel8) || fabs(collision.posZ()) > 10) { + if (!jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::initialiseEventSelectionBits("sel8")) || fabs(collision.posZ()) > 10) { return; } } else { diff --git a/PWGJE/Tasks/nucleiInJets.cxx b/PWGJE/Tasks/nucleiInJets.cxx index 8e382d784fb..bdc0807a671 100644 --- a/PWGJE/Tasks/nucleiInJets.cxx +++ b/PWGJE/Tasks/nucleiInJets.cxx @@ -90,7 +90,6 @@ struct nucleiInJets { } } - Configurable cfgeventSelections{"cfgeventSelections", "sel8", "choose event selection"}; Configurable cfgtrackSelections{"cfgtrackSelections", "globalTracks", "set track selections"}; Configurable isMC{"isMC", false, "flag for the MC"}; @@ -938,7 +937,7 @@ struct nucleiInJets { if (fabs(collision.posZ()) > 10) return; - if (!jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::JCollisionSel::sel8)) + if (!jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::initialiseEventSelectionBits("sel8"))) return; int nJets = 0; @@ -1046,7 +1045,7 @@ struct nucleiInJets { jetHist.fill(HIST("mcdJet/eventStat"), 0.5); // JEhistos.fill(HIST("nEvents_MCRec"), 0.5); - if (!jetderiveddatautilities::selectCollision(collisionJet, jetderiveddatautilities::JCollisionSel::sel8)) + if (!jetderiveddatautilities::selectCollision(collisionJet, jetderiveddatautilities::initialiseEventSelectionBits("sel8"))) return; // bool jetFlag = kFALSE; @@ -1142,7 +1141,7 @@ struct nucleiInJets { { if (fabs(collision.posZ()) > 10) return; - if (!jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::JCollisionSel::sel8)) + if (!jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::initialiseEventSelectionBits("sel8"))) return; jetHist.fill(HIST("recmatched/vertexZ"), collision.posZ()); diff --git a/PWGJE/Tasks/phiInJets.cxx b/PWGJE/Tasks/phiInJets.cxx index 05af59828e9..26c381492b2 100644 --- a/PWGJE/Tasks/phiInJets.cxx +++ b/PWGJE/Tasks/phiInJets.cxx @@ -15,6 +15,8 @@ /// /// \author Adrian Fereydon Nassirpour +#include +#include #include #include @@ -83,7 +85,7 @@ struct phiInJets { // CONFIG DONE ///////////////////////////////////////// //INIT - int eventSelection = -1; + std::vector eventSelectionBits; void init(o2::framework::InitContext&) { @@ -271,7 +273,7 @@ struct phiInJets { // JEhistos.add("hMCRec_nonmatch_hUSS_OUTSIDE_TRIG_1D_2_3", "hMCRec_nonmatch_hUSS_OUTSIDE_TRIG_1D_2_3", kTH1F, {MinvAxis}); // EVENT SELECTION - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(cfgeventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(cfgeventSelections)); } // end of init @@ -588,7 +590,7 @@ struct phiInJets { if (fabs(collision.posZ()) > cfgVtxCut) return; - if (!jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::JCollisionSel::sel8)) + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) return; int nReso = 0; @@ -672,7 +674,7 @@ struct phiInJets { JEhistos.fill(HIST("nEvents_MCRec"), 0.5); if (fabs(collision.posZ()) > cfgVtxCut) return; - if (!jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::JCollisionSel::sel8)) + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) return; bool INELgt0 = false; @@ -901,7 +903,7 @@ struct phiInJets { return; for (auto& recocoll : recocolls) { // poorly reconstructed - if (!jetderiveddatautilities::selectCollision(recocoll, jetderiveddatautilities::JCollisionSel::sel8)) + if (!jetderiveddatautilities::selectCollision(recocoll, eventSelectionBits)) return; } @@ -1084,7 +1086,7 @@ struct phiInJets { if (recocolls.size() <= 0) // not reconstructed return; for (auto& recocoll : recocolls) { // poorly reconstructed - if (!jetderiveddatautilities::selectCollision(recocoll, jetderiveddatautilities::JCollisionSel::sel8)) + if (!jetderiveddatautilities::selectCollision(recocoll, eventSelectionBits)) return; } @@ -1318,7 +1320,7 @@ struct phiInJets { if (fabs(collision.posZ()) > cfgVtxCut) return; - if (!jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::JCollisionSel::sel8)) + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) return; bool INELgt0 = false; diff --git a/PWGJE/Tasks/photonIsolationQA.cxx b/PWGJE/Tasks/photonIsolationQA.cxx index 03b8e4f1fe6..7bac1ce3d5b 100644 --- a/PWGJE/Tasks/photonIsolationQA.cxx +++ b/PWGJE/Tasks/photonIsolationQA.cxx @@ -101,11 +101,11 @@ struct PhotonIsolationQA { Preslice ClustersPerCol = aod::emcalcluster::collisionId; Preslice CellsPerCluster = aod::emcalclustercell::emcalclusterId; - int eventSelection = -1; + std::vector eventSelectionBits; int trackSelection = -1; void init(o2::framework::InitContext&) { - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); mGeometry = o2::emcal::Geometry::GetInstanceFromRunNumber(300000); diff --git a/PWGJE/Tasks/recoilJets.cxx b/PWGJE/Tasks/recoilJets.cxx index 4b2dd5589e9..1ef4e89f543 100644 --- a/PWGJE/Tasks/recoilJets.cxx +++ b/PWGJE/Tasks/recoilJets.cxx @@ -118,14 +118,14 @@ struct RecoilJets { HistogramRegistry spectra; - int eventSelection = -1; + std::vector eventSelectionBits; int trackSelection = -1; std::vector triggerMaskBits; void init(InitContext const&) { - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(evSel)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(evSel)); trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trkSel)); triggerMaskBits = jetderiveddatautilities::initialiseTriggerMaskBits(triggerMasks); @@ -525,7 +525,7 @@ struct RecoilJets { bool skipEvent(const Collision& coll) { /// \brief: trigger cut is needed for pp data - return !jetderiveddatautilities::selectCollision(coll, eventSelection) || !jetderiveddatautilities::selectTrigger(coll, triggerMaskBits); + return !jetderiveddatautilities::selectCollision(coll, eventSelectionBits) || !jetderiveddatautilities::selectTrigger(coll, triggerMaskBits); } template diff --git a/PWGJE/Tasks/trackEfficiency.cxx b/PWGJE/Tasks/trackEfficiency.cxx index 47d5ce4ea17..74d5aa30d59 100644 --- a/PWGJE/Tasks/trackEfficiency.cxx +++ b/PWGJE/Tasks/trackEfficiency.cxx @@ -14,6 +14,8 @@ /// \author Aimeric Landou #include +#include +#include #include #include @@ -70,7 +72,7 @@ struct TrackEfficiencyJets { Configurable trackOccupancyInTimeRangeMax{"trackOccupancyInTimeRangeMax", 999999, "maximum occupancy of tracks in neighbouring collisions in a given time range; only applied for reconstructed tracks, not mc particles"}; Configurable trackOccupancyInTimeRangeMin{"trackOccupancyInTimeRangeMin", -999999, "minimum occupancy of tracks in neighbouring collisions in a given time range; only applied for reconstructed tracks, not mc particles"}; - int eventSelection = -1; + std::vector eventSelectionBits; int trackSelection = -1; bool isChargedParticle(int code) @@ -114,7 +116,7 @@ struct TrackEfficiencyJets { void init(o2::framework::InitContext&) { - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); if (doprocessEFficiencyPurity) { @@ -255,7 +257,7 @@ struct TrackEfficiencyJets { bool hasSel8Coll = false; bool centralityCheck = false; if (acceptSplitCollisions == 2) { // check only that the first reconstructed collision passes the check - if (jetderiveddatautilities::selectCollision(collisions.begin(), eventSelection)) { // Skipping MC events that have not a single selected reconstructed collision ; effect unclear if mcColl is split + if (jetderiveddatautilities::selectCollision(collisions.begin(), eventSelectionBits)) { // Skipping MC events that have not a single selected reconstructed collision ; effect unclear if mcColl is split hasSel8Coll = true; } if (!checkCentrality || ((centralityMin < collisions.begin().centrality()) && (collisions.begin().centrality() < centralityMax))) { // effect unclear if mcColl is split @@ -263,7 +265,7 @@ struct TrackEfficiencyJets { } } else { // check that at least one of the reconstructed collisions passes the checks for (auto& collision : collisions) { - if (jetderiveddatautilities::selectCollision(collision, eventSelection)) { // Skipping MC events that have not a single selected reconstructed collision ; effect unclear if mcColl is split + if (jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { // Skipping MC events that have not a single selected reconstructed collision ; effect unclear if mcColl is split hasSel8Coll = true; } if (!checkCentrality || ((centralityMin < collision.centrality()) && (collision.centrality() < centralityMax))) { // effect unclear if mcColl is split @@ -314,7 +316,7 @@ struct TrackEfficiencyJets { return; } - if (!jetderiveddatautilities::selectCollision(collision, eventSelection) || !(abs(collision.posZ()) < vertexZCut)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits) || !(abs(collision.posZ()) < vertexZCut)) { continue; } @@ -389,7 +391,7 @@ struct TrackEfficiencyJets { { registry.fill(HIST("h_collisions"), 0.5); registry.fill(HIST("h2_centrality_collisions"), collision.centrality(), 0.5); - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } registry.fill(HIST("h_collisions"), 1.5); @@ -410,7 +412,7 @@ struct TrackEfficiencyJets { float eventWeight = collision.mcCollision().weight(); registry.fill(HIST("h_collisions"), 0.5); registry.fill(HIST("h_collisions_weighted"), 0.5, eventWeight); - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } registry.fill(HIST("h_collisions"), 1.5); @@ -444,7 +446,7 @@ struct TrackEfficiencyJets { bool hasSel8Coll = false; bool centralityCheck = false; if (acceptSplitCollisions == 2) { // check only that the first reconstructed collision passes the check - if (jetderiveddatautilities::selectCollision(collisions.begin(), eventSelection)) { // Skipping MC events that have not a single selected reconstructed collision ; effect unclear if mcColl is split + if (jetderiveddatautilities::selectCollision(collisions.begin(), eventSelectionBits)) { // Skipping MC events that have not a single selected reconstructed collision ; effect unclear if mcColl is split hasSel8Coll = true; } if (!checkCentrality || ((centralityMin < collisions.begin().centrality()) && (collisions.begin().centrality() < centralityMax))) { // effect unclear if mcColl is split @@ -452,7 +454,7 @@ struct TrackEfficiencyJets { } } else { // check that at least one of the reconstructed collisions passes the checks for (auto& collision : collisions) { - if (jetderiveddatautilities::selectCollision(collision, eventSelection)) { // Skipping MC events that have not a single selected reconstructed collision ; effect unclear if mcColl is split + if (jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { // Skipping MC events that have not a single selected reconstructed collision ; effect unclear if mcColl is split hasSel8Coll = true; } if (!checkCentrality || ((centralityMin < collision.centrality()) && (collision.centrality() < centralityMax))) { // effect unclear if mcColl is split @@ -494,7 +496,7 @@ struct TrackEfficiencyJets { bool hasSel8Coll = false; bool centralityCheck = false; if (acceptSplitCollisions == 2) { // check only that the first reconstructed collision passes the check - if (jetderiveddatautilities::selectCollision(collisions.begin(), eventSelection)) { // Skipping MC events that have not a single selected reconstructed collision ; effect unclear if mcColl is split + if (jetderiveddatautilities::selectCollision(collisions.begin(), eventSelectionBits)) { // Skipping MC events that have not a single selected reconstructed collision ; effect unclear if mcColl is split hasSel8Coll = true; } if (!checkCentrality || ((centralityMin < collisions.begin().centrality()) && (collisions.begin().centrality() < centralityMax))) { // effect unclear if mcColl is split @@ -502,7 +504,7 @@ struct TrackEfficiencyJets { } } else { // check that at least one of the reconstructed collisions passes the checks for (auto& collision : collisions) { - if (jetderiveddatautilities::selectCollision(collision, eventSelection)) { // Skipping MC events that have not a single selected reconstructed collision ; effect unclear if mcColl is split + if (jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { // Skipping MC events that have not a single selected reconstructed collision ; effect unclear if mcColl is split hasSel8Coll = true; } if (!checkCentrality || ((centralityMin < collision.centrality()) && (collision.centrality() < centralityMax))) { // effect unclear if mcColl is split diff --git a/PWGJE/Tasks/v0JetSpectra.cxx b/PWGJE/Tasks/v0JetSpectra.cxx index cbf39c5b057..700f0b33b54 100644 --- a/PWGJE/Tasks/v0JetSpectra.cxx +++ b/PWGJE/Tasks/v0JetSpectra.cxx @@ -14,6 +14,9 @@ /// \author Gijs van Weelden // +#include +#include + #include "TH1F.h" #include "TTree.h" @@ -63,13 +66,13 @@ struct V0JetSpectra { Configurable evSel{"evSel", "sel8WithoutTimeFrameBorderCut", "choose event selection"}; Configurable vertexZCut{"vertexZCut", 10.f, "vertex z cut"}; - int eventSelection = -1; + std::vector eventSelectionBits; Filter jetCollisionFilter = nabs(aod::jcollision::posZ) < vertexZCut; void init(InitContext&) { - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(evSel)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(evSel)); registry.add("jetPtEtaPhi", "Jets; #it{p}_{T}; #eta; #phi", HistType::kTH3D, {{200, 0., 200.}, {20, -1.f, 1.f}, {18 * 8, 0.f, 2. * TMath::Pi()}}); registry.add("mcpJetPtEtaPhi", "Jets; #it{p}_{T}; #eta; #phi", HistType::kTH3D, {{200, 0., 200.}, {20, -1.f, 1.f}, {18 * 8, 0.f, 2. * TMath::Pi()}}); } @@ -91,7 +94,7 @@ struct V0JetSpectra { void processData(soa::Filtered::iterator const& jcoll, aod::ChargedJets const& chjets, aod::V0ChargedJets const& v0jets) { - if (!jetderiveddatautilities::selectCollision(jcoll, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(jcoll, eventSelectionBits)) { return; } if (v0jets.size() == 0) { @@ -105,7 +108,7 @@ struct V0JetSpectra { if (!jcoll.has_mcCollision()) { return; } - if (!jetderiveddatautilities::selectCollision(jcoll, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(jcoll, eventSelectionBits)) { return; } double weight = jcoll.mcCollision().weight(); @@ -126,7 +129,7 @@ struct V0JetSpectra { void processMcMatched(soa::Filtered::iterator const& jcoll, aod::JetMcCollisions const&, MatchedMCDJets const& chjetsMCD, MatchedMCPJets const& chjetsMCP, MatchedMCDV0Jets const& v0jetsMCD, MatchedMCPV0Jets const& v0jetsMCP) { - if (!jetderiveddatautilities::selectCollision(jcoll, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(jcoll, eventSelectionBits)) { return; } // TODO: Need to add checker to only count matched jets (?) diff --git a/PWGJE/Tasks/v0QA.cxx b/PWGJE/Tasks/v0QA.cxx index e4de0088ccf..852794c5a21 100644 --- a/PWGJE/Tasks/v0QA.cxx +++ b/PWGJE/Tasks/v0QA.cxx @@ -14,6 +14,9 @@ /// \author Gijs van Weelden // +#include +#include + #include "TH1F.h" #include "TTree.h" @@ -88,11 +91,11 @@ struct V0QA { ConfigurableAxis binTPCNClSharedFraction{"sharedFraction", {100, 0., 1.}, ""}; ConfigurableAxis binTPCCrossedRowsOverFindableCl{"crossedOverFindable", {120, 0.0, 1.2}, ""}; - int eventSelection = -1; + std::vector eventSelectionBits; void init(InitContext&) { - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(evSel)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(evSel)); const AxisSpec axisJetPt{binPtJet, "Jet Pt (GeV/c)"}; const AxisSpec axisV0Pt{binPtV0, "V0 Pt (GeV/c)"}; @@ -393,12 +396,12 @@ struct V0QA { } // init template - bool isCollisionReconstructed(T const& collision, U const& eventSelection) + bool isCollisionReconstructed(T const& collision, U const& eventSelectionBits) { if (!collision.has_mcCollision()) { return false; } - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return false; } return true; @@ -719,7 +722,7 @@ struct V0QA { void processMcD(soa::Filtered::iterator const& jcoll, aod::JetMcCollisions const&, CandidatesV0MCDWithFlags const& v0s, aod::McParticles const&) { registry.fill(HIST("inclusive/hEvents"), 0.5); - if (!isCollisionReconstructed(jcoll, eventSelection)) { + if (!isCollisionReconstructed(jcoll, eventSelectionBits)) { return; } registry.fill(HIST("inclusive/hEvents"), 1.5); @@ -759,7 +762,7 @@ struct V0QA { bool isReconstructed = false; for (auto collision : collisions) { - if (!isCollisionReconstructed(collision, eventSelection)) { + if (!isCollisionReconstructed(collision, eventSelectionBits)) { continue; } if (collision.mcCollision().globalIndex() != mccoll.globalIndex()) { @@ -802,7 +805,7 @@ struct V0QA { void processMcDJets(soa::Filtered::iterator const& jcoll, aod::JetMcCollisions const&, MCDV0JetsWithConstituents const& mcdjets, CandidatesV0MCDWithFlags const&, aod::McParticles const&) { registry.fill(HIST("jets/hJetEvents"), 0.5); - if (!isCollisionReconstructed(jcoll, eventSelection)) { + if (!isCollisionReconstructed(jcoll, eventSelectionBits)) { return; } registry.fill(HIST("jets/hJetEvents"), 1.5); @@ -842,7 +845,7 @@ struct V0QA { void processMcDMatchedJets(soa::Filtered::iterator const& jcoll, aod::JetMcCollisions const&, MatchedMCDV0JetsWithConstituents const& mcdjets, MatchedMCPV0JetsWithConstituents const&, CandidatesV0MCDWithFlags const&, aod::CandidatesV0MCP const&, aod::JetTracksMCD const& jTracks, aod::McParticles const&) { registry.fill(HIST("jets/hMatchedJetEvents"), 0.5); - if (!isCollisionReconstructed(jcoll, eventSelection)) { + if (!isCollisionReconstructed(jcoll, eventSelectionBits)) { return; } registry.fill(HIST("jets/hMatchedJetEvents"), 1.5); @@ -891,7 +894,7 @@ struct V0QA { bool isReconstructed = false; for (auto collision : collisions) { - if (!isCollisionReconstructed(collision, eventSelection)) { + if (!isCollisionReconstructed(collision, eventSelectionBits)) { continue; } if (collision.mcCollision().globalIndex() != mccoll.globalIndex()) { @@ -1260,7 +1263,7 @@ struct V0QA { using DaughterTracks = soa::Join; void processV0TrackQA(aod::JetCollision const& /*jcoll*/, soa::Join const& v0s, DaughterJTracks const&, DaughterTracks const&) { - // if (!jetderiveddatautilities::selectCollision(jcoll, eventSelection)) { + // if (!jetderiveddatautilities::selectCollision(jcoll, eventSelectionBits)) { // return; // } for (const auto& v0 : v0s) {