From 16990dc5f41e55c2bafda2edee474826e5ba15a6 Mon Sep 17 00:00:00 2001 From: Anton Riedel Date: Tue, 16 Sep 2025 14:02:03 +0200 Subject: [PATCH] Feat: finish CollisionBuilder --- PWGCF/Femto/Core/baseSelection.h | 35 +- PWGCF/Femto/Core/cascadeBuilder.h | 54 +-- PWGCF/Femto/Core/collisionBuilder.h | 314 ++++++++++-------- PWGCF/Femto/Core/dataTypes.h | 3 + PWGCF/Femto/Core/modes.h | 2 - PWGCF/Femto/Core/selectionContainer.h | 7 +- PWGCF/Femto/Core/trackBuilder.h | 90 ++--- PWGCF/Femto/Core/twoTrackResonanceBuilder.h | 102 +++--- PWGCF/Femto/Core/v0Builder.h | 54 +-- PWGCF/Femto/DataModel/FemtoTables.h | 7 + PWGCF/Femto/TableProducer/CMakeLists.txt | 2 +- PWGCF/Femto/TableProducer/femtoProducer.cxx | 14 +- PWGCF/Femto/Tasks/femtoCascadeQa.cxx | 2 +- PWGCF/Femto/Tasks/femtoTrackQa.cxx | 2 +- .../Femto/Tasks/femtoTwotrackresonanceQa.cxx | 2 +- PWGCF/Femto/Tasks/femtoV0Qa.cxx | 2 +- 16 files changed, 389 insertions(+), 303 deletions(-) diff --git a/PWGCF/Femto/Core/baseSelection.h b/PWGCF/Femto/Core/baseSelection.h index f452db10e21..e64f5d05665 100644 --- a/PWGCF/Femto/Core/baseSelection.h +++ b/PWGCF/Femto/Core/baseSelection.h @@ -110,17 +110,48 @@ class BaseSelection mSelectionContainers.at(observableIndex) = SelectionContainer(baseName, lowerLimit, upperLimit, selectionValues, limitType, skipMostPermissiveBit, isMinimalCut); } + /// \brief Add a boolean based selection for a specific observable. + /// \param mode Whether the selection is not applied, minimal or optional cut + /// \param observableIndex Index of the observable. + void addSelection(int mode, int observableIndex) + { + if (static_cast(observableIndex) >= NumObservables) { + LOG(fatal) << "Observable is not valid. Observable (index) has to be smaller than " << NumObservables; + } + switch (mode) { + case -1: // cut is optional and we store bit for the cut + mNSelections += 1; + mHasOptionalSelection = true; + mSelectionContainers.at(observableIndex) = SelectionContainer(std::vector{1}, limits::LimitType::kEqual, false, false); + break; + case 0: // cut is not applied, initalize with empty vector, so we bail out later + mSelectionContainers.at(observableIndex) = SelectionContainer(std::vector{}, limits::LimitType::kEqual, false, false); + break; + case 1: // cut is added as mininal selection (since it is only one value, not extra bit is stored) + mSelectionContainers.at(observableIndex) = SelectionContainer(std::vector{1}, limits::LimitType::kEqual, true, true); + break; + default: + LOG(fatal) << "Invalid switch for boolean selection"; + } + if (mNSelections >= sizeof(BitmaskType) * CHAR_BIT) { + LOG(fatal) << "Too many selections. At most " << sizeof(BitmaskType) * CHAR_BIT << " are supported"; + } + } + /// \brief Update the limits of a function-based selection for a specific observable. /// \param observable Index of the observable. /// \param value Value at which to evaluate the selection functions. - void updateLimits(int observable, T value) { mSelectionContainers.at(observable).updateLimits(value); } + void updateLimits(int observable, T value) + { + mSelectionContainers.at(observable).updateLimits(value); + } /// \brief Reset the internal bitmask and evaluation flags before evaluating a new event. void reset() { mFinalBitmask.reset(); mPassesMinimalSelections = true; - // will be true if no optional cut as been defined and + // will be true if no optional cut has been defined and // will be set to false if we have optional cuts (but will be set to true in the case at least one optional cut succeeds) mPassesOptionalSelections = !mHasOptionalSelection; } diff --git a/PWGCF/Femto/Core/cascadeBuilder.h b/PWGCF/Femto/Core/cascadeBuilder.h index 637bbce5f3d..b7342c3516f 100644 --- a/PWGCF/Femto/Core/cascadeBuilder.h +++ b/PWGCF/Femto/Core/cascadeBuilder.h @@ -337,23 +337,23 @@ class CascadeBuilder template void init(T1& config, T2& filter, T3& table, T4& initContext) { - cascadeSelection.configure(config, filter); + mCascadeSelection.configure(config, filter); if constexpr (modes::isEqual(cascadeType, modes::Cascade::kXi)) { LOG(info) << "Initialize femto Xi builder..."; - produceXis = utils::enableTable("FXis_001", table.produceXis.value, initContext); - produceXiMasks = utils::enableTable("FXiMasks_001", table.produceXiMasks.value, initContext); - produceXiExtras = utils::enableTable("FXiExtras_001", table.produceXiExtras.value, initContext); + mProduceXis = utils::enableTable("FXis_001", table.produceXis.value, initContext); + mProduceXiMasks = utils::enableTable("FXiMasks_001", table.produceXiMasks.value, initContext); + mProduceXiExtras = utils::enableTable("FXiExtras_001", table.produceXiExtras.value, initContext); } if constexpr (modes::isEqual(cascadeType, modes::Cascade::kOmega)) { LOG(info) << "Initialize femto Omega builder..."; - produceOmegas = utils::enableTable("FOmegas_001", table.produceOmegas.value, initContext); - produceOmegaMasks = utils::enableTable("FOmegaMasks_001", table.produceOmegaMasks.value, initContext); - produceOmegaExtras = utils::enableTable("FOmegaExtras_001", table.produceOmegaExtras.value, initContext); + mProduceOmegas = utils::enableTable("FOmegas_001", table.produceOmegas.value, initContext); + mProduceOmegaMasks = utils::enableTable("FOmegaMasks_001", table.produceOmegaMasks.value, initContext); + mProduceOmegaExtras = utils::enableTable("FOmegaExtras_001", table.produceOmegaExtras.value, initContext); } - if (produceXis || produceXiExtras || produceXiMasks || produceOmegas || produceOmegaMasks || produceOmegaExtras) { + if (mProduceXis || mProduceXiExtras || mProduceXiMasks || mProduceOmegas || mProduceOmegaMasks || mProduceOmegaExtras) { mFillAnyTable = true; - cascadeSelection.printSelections(cascadeSelsName, cascadeSelsToString); + mCascadeSelection.printSelections(cascadeSelsName, cascadeSelsToString); } else { LOG(info) << "No tables configured"; } @@ -371,11 +371,11 @@ class CascadeBuilder int64_t posDaughterIndex = 0; int64_t negDaughterIndex = 0; for (const auto& cascade : fullCascades) { - if (!cascadeSelection.checkFilters(cascade)) { + if (!mCascadeSelection.checkFilters(cascade)) { continue; } - cascadeSelection.applySelections(cascade, fullTracks, col); - if (cascadeSelection.passesAllRequiredSelections() && cascadeSelection.checkHypothesis(cascade)) { + mCascadeSelection.applySelections(cascade, fullTracks, col); + if (mCascadeSelection.passesAllRequiredSelections() && mCascadeSelection.checkHypothesis(cascade)) { auto bachelor = cascade.template bachelor_as(); auto posDaughter = cascade.template posTrack_as(); @@ -394,7 +394,7 @@ class CascadeBuilder void fillCascade(T1& collisionProducts, T2& cascadeProducts, T3 const& cascade, T4 const& col, int bachelorIndex, int posDaughterIndex, int negDaughterIndex) { if constexpr (modes::isEqual(cascadeType, modes::Cascade::kXi)) { - if (produceXis) { + if (mProduceXis) { cascadeProducts.producedXis(collisionProducts.producedCollision.lastIndex(), cascade.sign() * cascade.pt(), cascade.eta(), @@ -404,10 +404,10 @@ class CascadeBuilder posDaughterIndex, negDaughterIndex); } - if (produceXiMasks) { - cascadeProducts.producedXiMasks(cascadeSelection.getBitmask()); + if (mProduceXiMasks) { + cascadeProducts.producedXiMasks(mCascadeSelection.getBitmask()); } - if (produceXiExtras) { + if (mProduceXiExtras) { cascadeProducts.producedXiExtras( cascade.mOmega(), cascade.casccosPA(col.posX(), col.posY(), col.posZ()), @@ -420,7 +420,7 @@ class CascadeBuilder } } if constexpr (modes::isEqual(cascadeType, modes::Cascade::kOmega)) { - if (produceOmegas) { + if (mProduceOmegas) { cascadeProducts.producedOmegas(collisionProducts.producedCollision.lastIndex(), cascade.sign() * cascade.pt(), cascade.eta(), @@ -430,10 +430,10 @@ class CascadeBuilder posDaughterIndex, negDaughterIndex); } - if (produceOmegaMasks) { - cascadeProducts.producedOmegaMasks(cascadeSelection.getBitmask()); + if (mProduceOmegaMasks) { + cascadeProducts.producedOmegaMasks(mCascadeSelection.getBitmask()); } - if (produceOmegaExtras) { + if (mProduceOmegaExtras) { cascadeProducts.producedOmegaExtras( cascade.mXi(), cascade.casccosPA(col.posX(), col.posY(), col.posZ()), @@ -450,14 +450,14 @@ class CascadeBuilder bool fillAnyTable() { return mFillAnyTable; } private: - CascadeSelection cascadeSelection; + CascadeSelection mCascadeSelection; bool mFillAnyTable = false; - bool produceXis = false; - bool produceXiMasks = false; - bool produceXiExtras = false; - bool produceOmegas = false; - bool produceOmegaMasks = false; - bool produceOmegaExtras = false; + bool mProduceXis = false; + bool mProduceXiMasks = false; + bool mProduceXiExtras = false; + bool mProduceOmegas = false; + bool mProduceOmegaMasks = false; + bool mProduceOmegaExtras = false; }; } // namespace cascadebuilder diff --git a/PWGCF/Femto/Core/collisionBuilder.h b/PWGCF/Femto/Core/collisionBuilder.h index a11a4071721..b33619dcf6f 100644 --- a/PWGCF/Femto/Core/collisionBuilder.h +++ b/PWGCF/Femto/Core/collisionBuilder.h @@ -16,11 +16,13 @@ #ifndef PWGCF_FEMTO_CORE_COLLISIONBUILDER_H_ #define PWGCF_FEMTO_CORE_COLLISIONBUILDER_H_ +#include "PWGCF/Femto/Core/baseSelection.h" #include "PWGCF/Femto/Core/femtoUtils.h" #include "PWGCF/Femto/Core/modes.h" #include "PWGCF/Femto/DataModel/FemtoTables.h" #include "Common/CCDB/EventSelectionParams.h" +#include "EventFiltering/Zorro.h" #include "Framework/AnalysisHelpers.h" #include "Framework/Configurable.h" @@ -29,6 +31,7 @@ #include #include +#include namespace o2::analysis::femto { @@ -36,7 +39,7 @@ namespace collisionbuilder { // configurables for collision selection -struct ConfCollisionFilter : o2::framework::ConfigurableGroup { +struct ConfCollisionFilters : o2::framework::ConfigurableGroup { std::string prefix = std::string("CollisionFilter"); o2::framework::Configurable vtxZMin{"vtxZMin", -10.f, "Minimum vertex Z position (cm)"}; o2::framework::Configurable vtxZMax{"vtxZMax", 10.f, "Maximum vertex Z position (cm)"}; @@ -52,48 +55,75 @@ struct ConfCollisionFilter : o2::framework::ConfigurableGroup { o2::framework::Configurable magFieldMax{"magFieldMax", 1.f, "Maximum magnetic field strength (T)"}; }; -struct ConfCollisionFlags : o2::framework::ConfigurableGroup { - o2::framework::Configurable sel8{"sel8", true, "Use sel8 (Should suffice for pp, for PbPb the other flags are more important)"}; - o2::framework::Configurable noSameBunchPileup{"noSameBunchPileup", false, "Reject collisions in case of pileup with another collision in the same foundBC"}; - o2::framework::Configurable isVertexItsTpc{"isVertexItsTpc", false, "At least one ITS-TPC track found for the vertex"}; - o2::framework::Configurable isGoodZvtxFt0VsPv{"isGoodZvtxFt0VsPv", false, "small difference between z-vertex from PV and from FT0"}; - o2::framework::Configurable noCollInTimeRangeNarrow{"noCollInTimeRangeNarrow", false, "no other collisions in specified time range (narrower than Strict)"}; - o2::framework::Configurable noCollInTimeRangeStrict{"noCollInTimeRangeStrict", false, "no other collisions in specified time range"}; - o2::framework::Configurable noCollInTimeRangeStandard{"noCollInTimeRangeStandard", false, "no other collisions in specified time range with per-collision multiplicity above threshold"}; - o2::framework::Configurable noCollInRofStrict{"noCollInRofStrict", false, "no other collisions in this Readout Frame"}; - o2::framework::Configurable noCollInRofStandard{"noCollInRofStandard", false, "no other collisions in this Readout Frame with per-collision multiplicity above threshold"}; - o2::framework::Configurable noHighMultCollInPrevRof{"noHighMultCollInPrevRof", false, "veto an event if FT0C amplitude in previous ITS ROF is above threshold"}; - o2::framework::Configurable isGoodItsLayer3{"isGoodItsLayer3", false, "number of inactive chips on ITS layer 3 is below maximum allowed value"}; - o2::framework::Configurable isGoodItsLayer0123{"isGoodItsLayer0123", false, "numbers of inactive chips on ITS layers 0-3 are below maximum allowed values"}; - o2::framework::Configurable isGoodItsLayersAll{"isGoodItsLayersAll", false, "numbers of inactive chips on all ITS layers are below maximum allowed values"}; +struct ConfCollisionBits : o2::framework::ConfigurableGroup { + std::string prefix = std::string("CollisionBits"); + o2::framework::Configurable sel8{"sel8", 1, "Use sel8 (-1: stored in bitmaks; 0 off; 1 on)"}; + o2::framework::Configurable noSameBunchPileup{"noSameBunchPileup", 0, "Reject collisions in case of pileup with another collision in the same foundBC (-1: stored in bitmaks; 0 off; 1 on)"}; + o2::framework::Configurable isVertexItsTpc{"isVertexItsTpc", 0, "At least one ITS-TPC track found for the vertex (-1: stored in bitmaks; 0 off; 1 on)"}; + o2::framework::Configurable isGoodZvtxFt0VsPv{"isGoodZvtxFt0VsPv", 0, "small difference between z-vertex from PV and from FT0 (-1: stored in bitmaks; 0 off; 1 on)"}; + o2::framework::Configurable noCollInTimeRangeNarrow{"noCollInTimeRangeNarrow", 0, "no other collisions in specified time range (narrower than Strict)(-1: stored in bitmaks; 0 off; 1 on)"}; + o2::framework::Configurable noCollInTimeRangeStrict{"noCollInTimeRangeStrict", 0, "no other collisions in specified time range strict (-1: stored in bitmaks; 0 off; 1 on)"}; + o2::framework::Configurable noCollInTimeRangeStandard{"noCollInTimeRangeStandard", 0, "no other collisions in specified time range with per-collision multiplicity above threshold (-1: stored in bitmaks; 0 off; 1 on)"}; + o2::framework::Configurable noCollInRofStrict{"noCollInRofStrict", 0, "no other collisions in this Readout Frame strict (-1: stored in bitmaks; 0 off; 1 on)"}; + o2::framework::Configurable noCollInRofStandard{"noCollInRofStandard", 0, "no other collisions in this Readout Frame with per-collision multiplicity above threshold (-1: stored in bitmaks; 0 off; 1 on)"}; + o2::framework::Configurable noHighMultCollInPrevRof{"noHighMultCollInPrevRof", 0, "veto an event if FT0C amplitude in previous ITS ROF is above threshold (-1: stored in bitmaks; 0 off; 1 on)"}; + o2::framework::Configurable isGoodItsLayer3{"isGoodItsLayer3", 0, "number of inactive chips on ITS layer 3 is below maximum allowed value (-1: stored in bitmaks; 0 off; 1 on)"}; + o2::framework::Configurable isGoodItsLayer0123{"isGoodItsLayer0123", 0, "numbers of inactive chips on ITS layers 0-3 are below maximum allowed values (-1: stored in bitmaks; 0 off; 1 on)"}; + o2::framework::Configurable isGoodItsLayersAll{"isGoodItsLayersAll", 0, "numbers of inactive chips on all ITS layers are below maximum allowed values (-1: stored in bitmaks; 0 off; 1 on)"}; }; -/// \class FemtoDreamTrackCuts -/// \brief Cut class to contain and execute all cuts applied to tracks -class CollisionSelection +struct ConfCollisionTriggers : o2::framework::ConfigurableGroup { + std::string prefix = std::string("CollisionTriggers"); + o2::framework::Configurable useTrigger{"useTrigger", false, "Set to true to only selected triggered collisions"}; + o2::framework::Configurable ccdbPath{"ccdbPath", std::string("EventFiltering/Zorro/"), "CCDB path for trigger information"}; + o2::framework::Configurable triggers{"triggers", std::string("fPPP,fPPL"), "Comma seperated list of all triggers to be used"}; +}; + +/// enum for all collision selections +enum CollisionSels { + // collsion selection flags + kSel8, ///< Sel8 + kNoSameBunchPileUp, ///< Reject collisions in case of pileup with another collision in the same foundBC + kIsVertexItsTpc, ///< At least one ITS-TPC track found for the vertex + kIsGoodZvtxFt0VsPv, ///< small difference between z-vertex from PV and from FT0 + kNoCollInTimeRangeNarrow, ///< no other collisions in specified time range (narrower than Strict) + kNoCollInTimeRangeStrict, ///< no other collisions in specified time range strict + kNoCollInTimeRangeStandard, ///< no other collisions in specified time range + kNoCollInRofStrict, ///< no other collisions in this Readout Frame strict + kNoCollInRofStandard, ///< no other collisions in this Readout Frame + kNoHighMultCollInPrevRof, ///< veto an event if FT0C amplitude in previous ITS ROF is above threshold + kIsGoodItsLayer3, ///< number of inactive chips on ITS layer 3 is below maximum allowed value + kIsGoodItsLayer0123, ///< numbers of inactive chips on ITS layers 0-3 are below maximum allowed values + kIsGoodItsLayersAll, ///< numbers of inactive chips on all ITS layers are below maximum allowed values + + kCollisionSelsMax +}; + +const char colSelsName[] = "Collision Selection Object"; +const std::unordered_map colSelsToString = { + {kSel8, "Sel8"}, + {kNoSameBunchPileUp, "No same bunch pileup"}, + {kIsVertexItsTpc, "Is vertex ITS TPC"}, + {kIsGoodZvtxFt0VsPv, "Is good zvtx FT0 vs PV"}, + {kNoCollInTimeRangeNarrow, "No collision in time range narrow"}, + {kNoCollInTimeRangeStrict, "No collision in time range strict"}, + {kNoCollInTimeRangeStandard, "No collission in time range standard"}, + {kNoCollInRofStrict, "No collsion in ROF strict"}, + {kNoCollInRofStandard, "No collision in ROF standard"}, + {kNoHighMultCollInPrevRof, "No high mult collsions in previous ROF"}, + {kIsGoodItsLayer3, "Is good ITS layer 3"}, + {kIsGoodItsLayer0123, "Is good ITS layer 0-3"}, + {kIsGoodItsLayersAll, "Is good ITS layer all"}}; + +class CollisionSelection : public BaseSelection { public: CollisionSelection() {} virtual ~CollisionSelection() = default; template - void configure(T1 const& filter, T2 const& flags) + void configure(T1 const& filter, T2 const& config) { - // flags - mSel8 = flags.sel8.value; - mNoSameBunchPileup = flags.noSameBunchPileup.value; - mIsVertexItsTpc = flags.isVertexItsTpc.value; - mIsGoodZvtxFt0VsPv = flags.isGoodZvtxFt0VsPv.value; - mNoCollInTimeRangeNarrow = flags.noCollInTimeRangeNarrow.value; - mNoCollInTimeRangeStrict = flags.noCollInTimeRangeStrict.value; - mNoCollInTimeRangeStandard = flags.noCollInTimeRangeStandard.value; - mNoCollInRofStrict = flags.noCollInRofStrict.value; - mNoCollInRofStandard = flags.noCollInRofStandard.value; - mNoHighMultCollInPrevRof = flags.noHighMultCollInPrevRof.value; - mIsGoodItsLayer3 = flags.isGoodItsLayer3.value; - mIsGoodItsLayer0123 = flags.isGoodItsLayer0123.value; - mIsGoodItsLayersAll = flags.isGoodItsLayersAll.value; - // cuts mVtxZMin = filter.vtxZMin.value; mVtxZMax = filter.vtxZMax.value; @@ -107,6 +137,20 @@ class CollisionSelection mSphericityMax = filter.spherMax.value; mOccupancyMin = filter.occupancyMin.value; mOccupancyMax = filter.occupancyMax.value; + + // flags + this->addSelection(config.sel8.value, kSel8); + this->addSelection(config.noSameBunchPileup.value, kNoSameBunchPileUp); + this->addSelection(config.isGoodZvtxFt0VsPv.value, kIsGoodZvtxFt0VsPv); + this->addSelection(config.noCollInTimeRangeNarrow.value, kNoCollInTimeRangeNarrow); + this->addSelection(config.noCollInTimeRangeStrict.value, kNoCollInTimeRangeStrict); + this->addSelection(config.noCollInTimeRangeStandard.value, kNoCollInTimeRangeStandard); + this->addSelection(config.noCollInRofStrict.value, kNoCollInRofStrict); + this->addSelection(config.noCollInRofStandard.value, kNoCollInRofStandard); + this->addSelection(config.noHighMultCollInPrevRof.value, kNoHighMultCollInPrevRof); + this->addSelection(config.isGoodItsLayer3.value, kIsGoodItsLayer3); + this->addSelection(config.isGoodItsLayer0123.value, kIsGoodItsLayer0123); + this->addSelection(config.isGoodItsLayersAll.value, kIsGoodItsLayersAll); }; void setMagneticField(float MagField) @@ -139,56 +183,26 @@ class CollisionSelection } float getCentrality() const { return mCentrality; } - template - bool checkCuts(T const& col) + template + void setMultiplicity(const T& col) { - - // flags - if (mSel8 && !col.sel8()) { // might change in the future, but sel8 checks TVXTrigger and cuts out time frame border and ITS readout frame border - return false; - } - if (mNoSameBunchPileup && !col.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) { - return false; - } - if (mIsVertexItsTpc && !col.selection_bit(o2::aod::evsel::kIsVertexITSTPC)) { - return false; - } - if (mIsGoodZvtxFt0VsPv && !col.selection_bit(aod::evsel::kIsGoodZvtxFT0vsPV)) { - return false; - } - if (mNoCollInTimeRangeNarrow && !col.selection_bit(aod::evsel::kNoCollInTimeRangeNarrow)) { - return false; - } - if (mNoCollInTimeRangeStrict && !col.selection_bit(aod::evsel::kNoCollInTimeRangeStrict)) { - return false; - } - if (mNoCollInTimeRangeStandard && !col.selection_bit(aod::evsel::kNoCollInTimeRangeStandard)) { - return false; - } - if (mNoCollInRofStrict && !col.selection_bit(aod::evsel::kNoCollInRofStrict)) { - return false; - } - if (mNoCollInRofStandard && !col.selection_bit(aod::evsel::kNoCollInRofStandard)) { - return false; - } - if (mNoHighMultCollInPrevRof && !col.selection_bit(aod::evsel::kNoHighMultCollInPrevRof)) { - return false; - } - if (mIsGoodItsLayer3 && !col.selection_bit(aod::evsel::kIsGoodITSLayer3)) { - return false; - } - if (mIsGoodItsLayer0123 && !col.selection_bit(aod::evsel::kIsGoodITSLayer0123)) { - return false; + if constexpr (modes::isFlagSet(system, modes::System::kPP)) { + mMultiplicity = col.multNTracksPV(); } - if (mIsGoodItsLayersAll && !col.selection_bit(aod::evsel::kIsGoodITSLayersAll)) { - return false; + if constexpr (modes::isFlagSet(system, modes::System::kPbPb)) { + // change multiplicity estimator for PbPb? + mMultiplicity = col.multNTracksPV(); } + } + float getMultiplicity() const { return mMultiplicity; } - // cuts + template + bool checkFilters(T const& col) const + { if (col.posZ() < mVtxZMin || col.posZ() > mVtxZMax) { return false; } - if (col.multNTracksPV() < mMultMin || col.multNTracksPV() > mMultMax) { + if (mMultiplicity < mMultMin || mMultiplicity > mMultMax) { return false; } if (mCentrality < mCentMin || mCentrality > mCentMax) { @@ -200,28 +214,38 @@ class CollisionSelection if (mSphericity < mSphericityMin || mSphericity > mSphericityMax) { return false; } + if (col.trackOccupancyInTimeRange() < mOccupancyMin || col.trackOccupancyInTimeRange() > mOccupancyMax) { + return false; + } return true; } - private: - float mCentrality = 0.f; + template + void applySelections(T const& col) + { + this->reset(); + + // casting bool to float gurantees + // false -> 0 + // true -> 1 + this->evaluateObservable(kSel8, static_cast(col.sel8())); + this->evaluateObservable(kNoSameBunchPileUp, static_cast(col.selection_bit(o2::aod::evsel::kNoSameBunchPileup))); + this->evaluateObservable(kIsVertexItsTpc, static_cast(col.selection_bit(o2::aod::evsel::kIsVertexITSTPC))); + this->evaluateObservable(kIsGoodZvtxFt0VsPv, static_cast(col.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV))); + this->evaluateObservable(kNoCollInTimeRangeNarrow, static_cast(col.selection_bit(o2::aod::evsel::kNoCollInTimeRangeNarrow))); + this->evaluateObservable(kNoCollInTimeRangeStrict, static_cast(col.selection_bit(o2::aod::evsel::kNoCollInTimeRangeStrict))); + this->evaluateObservable(kNoCollInRofStrict, static_cast(col.selection_bit(o2::aod::evsel::kNoCollInRofStrict))); + this->evaluateObservable(kNoCollInRofStandard, static_cast(col.selection_bit(o2::aod::evsel::kNoCollInRofStandard))); + this->evaluateObservable(kNoHighMultCollInPrevRof, static_cast(col.selection_bit(o2::aod::evsel::kNoHighMultCollInPrevRof))); + this->evaluateObservable(kIsGoodItsLayer3, static_cast(col.selection_bit(o2::aod::evsel::kIsGoodITSLayer3))); + this->evaluateObservable(kIsGoodItsLayer0123, static_cast(col.selection_bit(o2::aod::evsel::kIsGoodITSLayer0123))); + this->evaluateObservable(kIsGoodItsLayersAll, static_cast(col.selection_bit(o2::aod::evsel::kIsGoodITSLayersAll))); + + this->assembleBitmask(); + }; - // flags - bool mSel8 = false; - bool mNoSameBunchPileup = false; - bool mIsVertexItsTpc = false; - bool mIsGoodZvtxFt0VsPv = false; - bool mNoCollInTimeRangeNarrow = false; - bool mNoCollInTimeRangeStrict = false; - bool mNoCollInTimeRangeStandard = false; - bool mNoCollInRofStrict = false; - bool mNoCollInRofStandard = false; - bool mNoHighMultCollInPrevRof = false; - bool mIsGoodItsLayer3 = false; - bool mIsGoodItsLayer0123 = false; - bool mIsGoodItsLayersAll = false; - - // cuts + protected: + // filter cuts float mVtxZMin = -12.f; float mVtxZMax = -12.f; float mSphericityMin = 0.f; @@ -237,10 +261,13 @@ class CollisionSelection float mMagField = 0.f; float mSphericity = 0.f; + float mCentrality = 0.f; + float mMultiplicity = 0.f; }; struct CollisionBuilderProducts : o2::framework::ProducesGroup { o2::framework::Produces producedCollision; + o2::framework::Produces produceCollisionMask; o2::framework::Produces producedOccupancy; o2::framework::Produces producedQns; o2::framework::Produces producedPositions; @@ -251,6 +278,7 @@ struct CollisionBuilderProducts : o2::framework::ProducesGroup { struct ConfCollisionTables : o2::framework::ConfigurableGroup { std::string prefix = std::string("CollisionTables"); o2::framework::Configurable produceCollisions{"produceCollisions", -1, "Produce Collisions (-1: auto; 0 off; 1 on)"}; + o2::framework::Configurable produceCollisionMasks{"produceCollisionMasks", -1, "Produce Collision Masks (-1: auto; 0 off; 1 on)"}; o2::framework::Configurable produceOccupancy{"produceOccupancy", -1, "Produce Occupancy (-1: auto; 0 off; 1 on)"}; o2::framework::Configurable produceQns{"produceQns", -1, "Produce Qn (-1: auto; 0 off; 1 on)"}; o2::framework::Configurable producePositions{"producePositions", -1, "Produce Positions (-1: auto; 0 off; 1 on)"}; @@ -264,62 +292,80 @@ class CollisionBuilder CollisionBuilder() {} virtual ~CollisionBuilder() = default; - template - void init(T1& filter, T2& flags, T3& table, T4& initContext) + template + void init(T1& filter, T2& config, T3& table, T4& trigger, T5& initContext) { - collisionSelection.configure(filter, flags); + mCollisionSelection.configure(filter, config); + if (trigger.useTrigger.value) { + mUseTrigger = true; + mTriggerNames = trigger.triggers.value; + mZorro.setBaseCCDBPath(trigger.ccdbPath.value); + } LOG(info) << "Initialize femto collision builder..."; - producedCollisions = utils::enableTable("FCols_001", table.produceCollisions.value, initContext); - produceOccupancy = utils::enableTable("FColOccs_001", table.produceOccupancy.value, initContext); - produceQns = utils::enableTable("FColQnBins_001", table.produceQns.value, initContext); - producedPositions = utils::enableTable("FColPos_001", table.producePositions.value, initContext); - producedMultiplicities = utils::enableTable("FColMults_001", table.produceMults.value, initContext); - producedCentralities = utils::enableTable("FColCents_001", table.produceCents.value, initContext); - if (producedCollisions || producedPositions || producedMultiplicities || producedCentralities) { - fillAnyTable = true; + mProducedCollisions = utils::enableTable("FCols_001", table.produceCollisions.value, initContext); + mProducedCollisionMasks = utils::enableTable("FColMasks_001", table.produceCollisionMasks.value, initContext); + mProduceOccupancy = utils::enableTable("FColOccs_001", table.produceOccupancy.value, initContext); + mProduceQns = utils::enableTable("FColQnBins_001", table.produceQns.value, initContext); + mProducedPositions = utils::enableTable("FColPos_001", table.producePositions.value, initContext); + mProducedMultiplicities = utils::enableTable("FColMults_001", table.produceMults.value, initContext); + mProducedCentralities = utils::enableTable("FColCents_001", table.produceCents.value, initContext); + if (mProducedCollisions || mProducedCollisionMasks || mProducedPositions || mProducedMultiplicities || mProducedCentralities) { + mFillAnyTable = true; + mCollisionSelection.printSelections(colSelsName, colSelsToString); } else { LOG(info) << "No tables configured"; } LOG(info) << "Initialization done..."; } - template - void buildCollision(T1& col, T2 tracks, float magField) + template + void buildCollision(T1& bc, T2& col, T3& tracks, T4& ccdb, float magField) { - collisionSelection.setMagneticField(magField); - collisionSelection.setSphericity(tracks); - collisionSelection.setCentrality(col); + if (mUseTrigger) { + mZorro.initCCDB(ccdb.service, bc.runNumber(), bc.timestamp(), mTriggerNames); + } + mCollisionSelection.setMagneticField(magField); + mCollisionSelection.setSphericity(tracks); + mCollisionSelection.setMultiplicity(col); + mCollisionSelection.setCentrality(col); + + mCollisionSelection.applySelections(col); } - template - bool checkCuts(T const& col) + template + bool checkCollision(T1 const& bc, T2 const& col) { - return collisionSelection.checkCuts(col); + if (mUseTrigger) { + return mZorro.isSelected(bc.globalBC()) && mCollisionSelection.checkFilters(col) && mCollisionSelection.passesAllRequiredSelections(); + } else { + + return mCollisionSelection.checkFilters(col) && mCollisionSelection.passesAllRequiredSelections(); + } } template void fillCollision(T1& collisionProducts, T2 const& col) { - if (!fillAnyTable) { + if (!mFillAnyTable) { return; } - if (producedCollisions) { + if (mProducedCollisions) { collisionProducts.producedCollision(col.posZ(), col.multNTracksPV(), - collisionSelection.getCentrality(), - collisionSelection.getSphericity(), - collisionSelection.getMagneticField()); + mCollisionSelection.getCentrality(), + mCollisionSelection.getSphericity(), + mCollisionSelection.getMagneticField()); } - if (produceOccupancy) { + if (mProduceOccupancy) { collisionProducts.producedOccupancy(col.trackOccupancyInTimeRange()); } - if (producedPositions) { + if (mProducedPositions) { collisionProducts.producedPositions(col.posX(), col.posY()); } - if (producedMultiplicities) { + if (mProducedMultiplicities) { collisionProducts.producedMultiplicityEstimators( col.multFT0A(), col.multFT0C(), @@ -328,7 +374,7 @@ class CollisionBuilder col.trackOccupancyInTimeRange(), col.ft0cOccupancyInTimeRange()); } - if (producedCentralities) { + if (mProducedCentralities) { collisionProducts.producedCentralityEstimators( col.centFT0A(), col.centFT0C()); @@ -336,21 +382,25 @@ class CollisionBuilder // PbPb specific columns if constexpr (modes::isFlagSet(system, modes::System::kPbPb)) { - if (produceQns) { + if (mProduceQns) { collisionProducts.producedQns(utils::qn(col)); } } } private: - CollisionSelection collisionSelection; - bool fillAnyTable = false; - bool producedCollisions = false; - bool produceOccupancy = false; - bool produceQns = false; - bool producedPositions = false; - bool producedMultiplicities = false; - bool producedCentralities = false; + CollisionSelection mCollisionSelection; + Zorro mZorro; + bool mUseTrigger = false; + std::string mTriggerNames = std::string(""); + bool mFillAnyTable = false; + bool mProducedCollisions = false; + bool mProducedCollisionMasks = false; + bool mProduceOccupancy = false; + bool mProduceQns = false; + bool mProducedPositions = false; + bool mProducedMultiplicities = false; + bool mProducedCentralities = false; }; }; // namespace collisionbuilder }; // namespace o2::analysis::femto diff --git a/PWGCF/Femto/Core/dataTypes.h b/PWGCF/Femto/Core/dataTypes.h index ade9456f068..2fa1273dbcc 100644 --- a/PWGCF/Femto/Core/dataTypes.h +++ b/PWGCF/Femto/Core/dataTypes.h @@ -24,6 +24,9 @@ namespace femtodatatypes { // Note: Length of the bitmask is the limit of how many selections can be configured +// datatypes for collsions +using CollsionsMaskType = uint64_t; + // datatypes for tracks using TrackMaskType = uint64_t; using TrackType = uint16_t; diff --git a/PWGCF/Femto/Core/modes.h b/PWGCF/Femto/Core/modes.h index 83a230672ff..dccd9ac8559 100644 --- a/PWGCF/Femto/Core/modes.h +++ b/PWGCF/Femto/Core/modes.h @@ -59,10 +59,8 @@ enum class System : uint32_t { kMC = BIT(2), kRun3 = BIT(3), kRun2 = BIT(4), - kNoCentCal = BIT(5), kPP_Run3 = kPP | kRun3, kPP_Run2 = kPP | kRun2, - kPP_NoCentCal_Run3 = kPP | kRun3 | kNoCentCal, kPbPb_Run3 = kPbPb | kRun3, kPbPb_Run2 = kPbPb | kRun2, }; diff --git a/PWGCF/Femto/Core/selectionContainer.h b/PWGCF/Femto/Core/selectionContainer.h index 8b050a4b700..420af6554d6 100644 --- a/PWGCF/Femto/Core/selectionContainer.h +++ b/PWGCF/Femto/Core/selectionContainer.h @@ -86,10 +86,6 @@ class SelectionContainer if (mSelectionValues.size() > sizeof(BitmaskType) * CHAR_BIT) { LOG(fatal) << "Too many selections for single a observable. Limit is " << sizeof(BitmaskType) * CHAR_BIT; } - // for kEqual we can never skip the last bit - if (limitType == limits::kEqual) { - mSkipMostPermissiveBit = false; - } // values for selection are not necessarily ordered correctly sortSelections(); } @@ -226,7 +222,7 @@ class SelectionContainer break; case (limits::kEqual): // special case for kEqual since here we cannot really establish an order so we need to check all cases explicitly and we cannot bail early - if (std::abs(value - mSelectionValues.at(i)) < constants::math::Epsilon) { + if (std::fabs(value - mSelectionValues.at(i)) < constants::math::Epsilon) { mBitmask.set(i); } break; @@ -246,7 +242,6 @@ class SelectionContainer std::bitset getBitmask() const { // if we do not skip the last bit, return full bitmask - // in the constructor we ensure that for kEqual we do not skip the most permissive bit if (mSkipMostPermissiveBit == false) { return mBitmask; } else { diff --git a/PWGCF/Femto/Core/trackBuilder.h b/PWGCF/Femto/Core/trackBuilder.h index ae3331226b1..9a784acee35 100644 --- a/PWGCF/Femto/Core/trackBuilder.h +++ b/PWGCF/Femto/Core/trackBuilder.h @@ -449,24 +449,24 @@ class TrackBuilder template void init(T1& config, T2& filter, T3& table, T4& initContext) { - trackSelection.configure(config, filter); + mTrackSelection.configure(config, filter); LOG(info) << "Initialize femto track builder..."; - produceTracks = utils::enableTable("FTracks_001", table.produceTracks.value, initContext); - produceTrackMasks = utils::enableTable("FTrackMasks_001", table.produceTrackMasks.value, initContext); - produceTrackDcas = utils::enableTable("FTrackDcas_001", table.produceTrackDcas.value, initContext); - produceTrackExtras = utils::enableTable("FTrackExtras_001", table.produceTrackExtras.value, initContext); - produceElectronPids = utils::enableTable("FElectronPids_001", table.produceElectronPids.value, initContext); - producePionPids = utils::enableTable("FPionPids_001", table.producePionPids.value, initContext); - produceKaonPids = utils::enableTable("FKaonPids_001", table.produceKaonPids.value, initContext); - produceProtonPids = utils::enableTable("FProtonPids_001", table.produceProtonPids.value, initContext); - produceDeuteronPids = utils::enableTable("FDeuteronPids_001", table.produceDeuteronPids.value, initContext); - produceTritonPids = utils::enableTable("FTritonPids_001", table.produceTritonPids.value, initContext); - produceHeliumPids = utils::enableTable("FHeliumPids_001", table.produceHeliumPids.value, initContext); - - if (produceTracks || produceTrackMasks || produceTrackDcas || produceTrackExtras || produceElectronPids || producePionPids || produceKaonPids || produceProtonPids || produceDeuteronPids || produceTritonPids || produceHeliumPids) { - fillAnyTable = true; - trackSelection.printSelections(trackSelsName, trackSelsToString); + mProduceTracks = utils::enableTable("FTracks_001", table.produceTracks.value, initContext); + mProduceTrackMasks = utils::enableTable("FTrackMasks_001", table.produceTrackMasks.value, initContext); + mProduceTrackDcas = utils::enableTable("FTrackDcas_001", table.produceTrackDcas.value, initContext); + mProduceTrackExtras = utils::enableTable("FTrackExtras_001", table.produceTrackExtras.value, initContext); + mProduceElectronPids = utils::enableTable("FElectronPids_001", table.produceElectronPids.value, initContext); + mProducePionPids = utils::enableTable("FPionPids_001", table.producePionPids.value, initContext); + mProduceKaonPids = utils::enableTable("FKaonPids_001", table.produceKaonPids.value, initContext); + mProduceProtonPids = utils::enableTable("FProtonPids_001", table.produceProtonPids.value, initContext); + mProduceDeuteronPids = utils::enableTable("FDeuteronPids_001", table.produceDeuteronPids.value, initContext); + mProduceTritonPids = utils::enableTable("FTritonPids_001", table.produceTritonPids.value, initContext); + mProduceHeliumPids = utils::enableTable("FHeliumPids_001", table.produceHeliumPids.value, initContext); + + if (mProduceTracks || mProduceTrackMasks || mProduceTrackDcas || mProduceTrackExtras || mProduceElectronPids || mProducePionPids || mProduceKaonPids || mProduceProtonPids || mProduceDeuteronPids || mProduceTritonPids || mProduceHeliumPids) { + mFillAnyTable = true; + mTrackSelection.printSelections(trackSelsName, trackSelsToString); } else { LOG(info) << "No tables configured"; } @@ -476,15 +476,15 @@ class TrackBuilder template void fillTracks(T1 const& tracks, T2& trackProducts, T3& collisionProducts, T4& indexMap) { - if (!fillAnyTable) { + if (!mFillAnyTable) { return; } for (const auto& track : tracks) { - if (!trackSelection.checkFilters(track) || !trackSelection.hasTofAboveThreshold(track)) { + if (!mTrackSelection.checkFilters(track) || !mTrackSelection.hasTofAboveThreshold(track)) { continue; } - trackSelection.applySelections(track); - if (!trackSelection.passesAllRequiredSelections()) { + mTrackSelection.applySelections(track); + if (!mTrackSelection.passesAllRequiredSelections()) { continue; } this->fillTrack(track, trackProducts, collisionProducts, indexMap); @@ -494,25 +494,25 @@ class TrackBuilder template void fillTrack(T1 const& track, T2& trackProducts, T3& collisionProducts, T4& indexMap) { - if (produceTracks) { + if (mProduceTracks) { trackProducts.producedTracks(collisionProducts.producedCollision.lastIndex(), track.pt() * track.sign(), track.eta(), track.phi()); } - if (produceTrackMasks) { + if (mProduceTrackMasks) { if constexpr (type == modes::Track::kPrimaryTrack) { - trackProducts.producedTrackMasks(trackSelection.getBitmask()); + trackProducts.producedTrackMasks(mTrackSelection.getBitmask()); } else { trackProducts.producedTrackMasks(static_cast(0u)); } } - if (produceTrackDcas) { + if (mProduceTrackDcas) { trackProducts.producedTrackDcas(track.dcaXY(), track.dcaZ()); } - if (produceTrackExtras) { + if (mProduceTrackExtras) { trackProducts.producedTrackExtras(track.isPVContributor(), track.itsNCls(), track.itsNClsInnerBarrel(), @@ -527,49 +527,49 @@ class TrackBuilder track.mass()); } - if (produceElectronPids) { + if (mProduceElectronPids) { if constexpr (type == modes::Track::kPrimaryTrack) { trackProducts.producedElectronPids(track.itsNSigmaEl(), track.tpcNSigmaEl(), track.tofNSigmaEl()); } else { trackProducts.producedElectronPids(0, track.tpcNSigmaEl(), track.tofNSigmaEl()); } } - if (producePionPids) { + if (mProducePionPids) { if constexpr (type == modes::Track::kPrimaryTrack) { trackProducts.producedPionPids(track.itsNSigmaPi(), track.tpcNSigmaPi(), track.tofNSigmaPi()); } else { trackProducts.producedPionPids(0, track.tpcNSigmaPi(), track.tofNSigmaPi()); } } - if (produceKaonPids) { + if (mProduceKaonPids) { if constexpr (type == modes::Track::kPrimaryTrack) { trackProducts.producedKaonPids(track.itsNSigmaKa(), track.tpcNSigmaKa(), track.tofNSigmaKa()); } else { trackProducts.producedKaonPids(0, track.tpcNSigmaKa(), track.tofNSigmaKa()); } } - if (produceProtonPids) { + if (mProduceProtonPids) { if constexpr (type == modes::Track::kPrimaryTrack) { trackProducts.producedProtonPids(track.itsNSigmaPr(), track.tpcNSigmaPr(), track.tofNSigmaPr()); } else { trackProducts.producedProtonPids(0, track.tpcNSigmaPr(), track.tofNSigmaPr()); } } - if (produceDeuteronPids) { + if (mProduceDeuteronPids) { if constexpr (type == modes::Track::kPrimaryTrack) { trackProducts.producedDeuteronPids(track.itsNSigmaDe(), track.tpcNSigmaDe(), track.tofNSigmaDe()); } else { trackProducts.producedDeuteronPids(0, track.tpcNSigmaDe(), track.tofNSigmaDe()); } } - if (produceTritonPids) { + if (mProduceTritonPids) { if constexpr (type == modes::Track::kPrimaryTrack) { trackProducts.producedTritonPids(track.itsNSigmaTr(), track.tpcNSigmaTr(), track.tofNSigmaTr()); } else { trackProducts.producedTritonPids(0, track.tpcNSigmaTr(), track.tofNSigmaTr()); } } - if (produceHeliumPids) { + if (mProduceHeliumPids) { if constexpr (type == modes::Track::kPrimaryTrack) { trackProducts.producedHeliumPids(track.itsNSigmaHe(), track.tpcNSigmaHe(), track.tofNSigmaHe()); } else { @@ -594,19 +594,19 @@ class TrackBuilder } private: - TrackSelection trackSelection; - bool fillAnyTable = false; - bool produceTracks = false; - bool produceTrackMasks = false; - bool produceTrackDcas = false; - bool produceTrackExtras = false; - bool produceElectronPids = false; - bool producePionPids = false; - bool produceKaonPids = false; - bool produceProtonPids = false; - bool produceDeuteronPids = false; - bool produceTritonPids = false; - bool produceHeliumPids = false; + TrackSelection mTrackSelection; + bool mFillAnyTable = false; + bool mProduceTracks = false; + bool mProduceTrackMasks = false; + bool mProduceTrackDcas = false; + bool mProduceTrackExtras = false; + bool mProduceElectronPids = false; + bool mProducePionPids = false; + bool mProduceKaonPids = false; + bool mProduceProtonPids = false; + bool mProduceDeuteronPids = false; + bool mProduceTritonPids = false; + bool mProduceHeliumPids = false; }; } // namespace trackbuilder diff --git a/PWGCF/Femto/Core/twoTrackResonanceBuilder.h b/PWGCF/Femto/Core/twoTrackResonanceBuilder.h index 9b44d628af6..c1f944ed51d 100644 --- a/PWGCF/Femto/Core/twoTrackResonanceBuilder.h +++ b/PWGCF/Femto/Core/twoTrackResonanceBuilder.h @@ -469,11 +469,11 @@ class TwoTrackResonanceBuilder template void init(T1& config, T2& filter, T3& daughterFilter, T4& table, T5 initContext) { - twoTrackResonanceSelection.configure(config, filter, daughterFilter); + mTwoTrackResonanceSelection.configure(config, filter, daughterFilter); if constexpr (modes::isEqual(resoType, modes::TwoTrackResonance::kPhi)) { LOG(info) << "Initialize femto Phi builder..."; - producePhis = utils::enableTable("FPhis_001", table.producePhis.value, initContext); - producePhiMasks = utils::enableTable("FPhiMasks_001", table.producePhiMasks.value, initContext); + mProducePhis = utils::enableTable("FPhis_001", table.producePhis.value, initContext); + mProducePhiMasks = utils::enableTable("FPhiMasks_001", table.producePhiMasks.value, initContext); } if constexpr (modes::isEqual(resoType, modes::TwoTrackResonance::kKstar0) || modes::isEqual(resoType, modes::TwoTrackResonance::kKstar0Bar)) { if constexpr (modes::isEqual(resoType, modes::TwoTrackResonance::kKstar0)) { @@ -482,18 +482,18 @@ class TwoTrackResonanceBuilder if constexpr (modes::isEqual(resoType, modes::TwoTrackResonance::kKstar0Bar)) { LOG(info) << "Initialize femto Kstar0Bar builder..."; } - produceKstar0s = utils::enableTable("FKstar0s_001", table.produceKstar0s.value, initContext); - produceKstar0Masks = utils::enableTable("FKstar0Masks_001", table.produceKstar0Masks.value, initContext); + mProduceKstar0s = utils::enableTable("FKstar0s_001", table.produceKstar0s.value, initContext); + mProduceKstar0Masks = utils::enableTable("FKstar0Masks_001", table.produceKstar0Masks.value, initContext); } if constexpr (modes::isEqual(resoType, modes::TwoTrackResonance::kRho0)) { LOG(info) << "Initialize femto Rho0 builder..."; - produceRho0s = utils::enableTable("FRho0s_001", table.produceRho0s.value, initContext); - produceRho0Masks = utils::enableTable("FRho0Masks_001", table.produceRho0Masks.value, initContext); + mProduceRho0s = utils::enableTable("FRho0s_001", table.produceRho0s.value, initContext); + mProduceRho0Masks = utils::enableTable("FRho0Masks_001", table.produceRho0Masks.value, initContext); } - if (producePhis || producePhiMasks || produceKstar0s || produceKstar0Masks || produceRho0s || produceRho0Masks) { - fillAnyTable = true; - twoTrackResonanceSelection.printSelections(twoTrackResonanceSelsName, twoTrackResonanceSelsToString); + if (mProducePhis || mProducePhiMasks || mProduceKstar0s || mProduceKstar0Masks || mProduceRho0s || mProduceRho0Masks) { + mFillAnyTable = true; + mTwoTrackResonanceSelection.printSelections(twoTrackResonanceSelsName, twoTrackResonanceSelsToString); } else { LOG(info) << "No tables configured"; } @@ -503,7 +503,7 @@ class TwoTrackResonanceBuilder template void fillResonances(T1& collisionProducts, T2& trackProducts, T3& resonanceProducts, T4& groupPositiveTracks, T5& groupNegativeTracks, T6& trackBuilder, T7& indexMap) { - if (!fillAnyTable) { + if (!mFillAnyTable) { return; } for (auto const& positiveTrack : groupPositiveTracks) { @@ -517,12 +517,12 @@ class TwoTrackResonanceBuilder void fillResonance(T1& collisionProducts, T2& trackProducts, T3& resonanceProducts, T4 const& posDaughter, T4 const& negDaughter, T5& trackBuilder, T6& indexMap) { - twoTrackResonanceSelection.applySelections(posDaughter, negDaughter); // for resonances selection are only applied to daughter tracks - if (!twoTrackResonanceSelection.hasTofAboveThreshold(posDaughter, negDaughter) || !twoTrackResonanceSelection.passesAllRequiredSelections()) { + mTwoTrackResonanceSelection.applySelections(posDaughter, negDaughter); // for resonances selection are only applied to daughter tracks + if (!mTwoTrackResonanceSelection.hasTofAboveThreshold(posDaughter, negDaughter) || !mTwoTrackResonanceSelection.passesAllRequiredSelections()) { return; } - twoTrackResonanceSelection.reconstructResonance(posDaughter, negDaughter); - if (!twoTrackResonanceSelection.checkFilters() || !twoTrackResonanceSelection.checkHypothesis()) { + mTwoTrackResonanceSelection.reconstructResonance(posDaughter, negDaughter); + if (!mTwoTrackResonanceSelection.checkFilters() || !mTwoTrackResonanceSelection.checkHypothesis()) { return; } int64_t posDaughterIndex = 0; @@ -531,76 +531,76 @@ class TwoTrackResonanceBuilder negDaughterIndex = trackBuilder.template getDaughterIndex(negDaughter, trackProducts, collisionProducts, indexMap); if constexpr (modes::isEqual(resoType, modes::TwoTrackResonance::kRho0)) { - if (produceRho0s) { + if (mProduceRho0s) { resonanceProducts.producedRhos( collisionProducts.producedCollision.lastIndex(), - twoTrackResonanceSelection.getPt(), - twoTrackResonanceSelection.getEta(), - twoTrackResonanceSelection.getPhi(), - twoTrackResonanceSelection.getMass(), + mTwoTrackResonanceSelection.getPt(), + mTwoTrackResonanceSelection.getEta(), + mTwoTrackResonanceSelection.getPhi(), + mTwoTrackResonanceSelection.getMass(), posDaughterIndex, negDaughterIndex); } - if (produceRho0Masks) { - resonanceProducts.producedRhoMasks(twoTrackResonanceSelection.getBitmask()); + if (mProduceRho0Masks) { + resonanceProducts.producedRhoMasks(mTwoTrackResonanceSelection.getBitmask()); } } if constexpr (modes::isEqual(resoType, modes::TwoTrackResonance::kPhi)) { - if (producePhis) { + if (mProducePhis) { resonanceProducts.producedPhis( collisionProducts.producedCollision.lastIndex(), - twoTrackResonanceSelection.getPt(), - twoTrackResonanceSelection.getEta(), - twoTrackResonanceSelection.getPhi(), - twoTrackResonanceSelection.getMass(), + mTwoTrackResonanceSelection.getPt(), + mTwoTrackResonanceSelection.getEta(), + mTwoTrackResonanceSelection.getPhi(), + mTwoTrackResonanceSelection.getMass(), posDaughterIndex, negDaughterIndex); } - if (producePhiMasks) { - resonanceProducts.producedPhiMasks(twoTrackResonanceSelection.getBitmask()); + if (mProducePhiMasks) { + resonanceProducts.producedPhiMasks(mTwoTrackResonanceSelection.getBitmask()); } } if constexpr (modes::isEqual(resoType, modes::TwoTrackResonance::kKstar0)) { - if (produceKstar0s) { + if (mProduceKstar0s) { resonanceProducts.producedKstars( collisionProducts.producedCollision.lastIndex(), - twoTrackResonanceSelection.getPt(), - twoTrackResonanceSelection.getEta(), - twoTrackResonanceSelection.getPhi(), - twoTrackResonanceSelection.getMass(), + mTwoTrackResonanceSelection.getPt(), + mTwoTrackResonanceSelection.getEta(), + mTwoTrackResonanceSelection.getPhi(), + mTwoTrackResonanceSelection.getMass(), posDaughterIndex, negDaughterIndex); } - if (produceKstar0Masks) { - resonanceProducts.producedKstarMasks(twoTrackResonanceSelection.getBitmask()); + if (mProduceKstar0Masks) { + resonanceProducts.producedKstarMasks(mTwoTrackResonanceSelection.getBitmask()); } } if constexpr (modes::isEqual(resoType, modes::TwoTrackResonance::kKstar0Bar)) { - if (produceKstar0s) { + if (mProduceKstar0s) { resonanceProducts.producedKstars( collisionProducts.producedCollision.lastIndex(), - -1.f * twoTrackResonanceSelection.getPt(), - twoTrackResonanceSelection.getEta(), - twoTrackResonanceSelection.getPhi(), - twoTrackResonanceSelection.getMass(), + -1.f * mTwoTrackResonanceSelection.getPt(), + mTwoTrackResonanceSelection.getEta(), + mTwoTrackResonanceSelection.getPhi(), + mTwoTrackResonanceSelection.getMass(), posDaughterIndex, negDaughterIndex); } - if (produceKstar0Masks) { - resonanceProducts.producedKstarMasks(twoTrackResonanceSelection.getBitmask()); + if (mProduceKstar0Masks) { + resonanceProducts.producedKstarMasks(mTwoTrackResonanceSelection.getBitmask()); } } } private: - TwoTrackResonanceSelection twoTrackResonanceSelection; - bool fillAnyTable = false; - bool producePhis = false; - bool producePhiMasks = false; - bool produceKstar0s = false; - bool produceKstar0Masks = false; - bool produceRho0s = false; - bool produceRho0Masks = false; + TwoTrackResonanceSelection mTwoTrackResonanceSelection; + bool mFillAnyTable = false; + bool mProducePhis = false; + bool mProducePhiMasks = false; + bool mProduceKstar0s = false; + bool mProduceKstar0Masks = false; + bool mProduceRho0s = false; + bool mProduceRho0Masks = false; }; // namespace twotrackresonancebuilder } // namespace twotrackresonancebuilder diff --git a/PWGCF/Femto/Core/v0Builder.h b/PWGCF/Femto/Core/v0Builder.h index 300a996c05e..8f1faf319a2 100644 --- a/PWGCF/Femto/Core/v0Builder.h +++ b/PWGCF/Femto/Core/v0Builder.h @@ -332,7 +332,7 @@ class V0Builder template void init(T1& config, T2& filter, T3& table, T4& initContext) { - v0Selection.configure(config, filter); + mV0Selection.configure(config, filter); if constexpr (modes::isEqual(v0Type, modes::V0::kLambda) || modes::isEqual(v0Type, modes::V0::kAntiLambda)) { if constexpr (modes::isEqual(v0Type, modes::V0::kLambda)) { LOG(info) << "Initialize femto Lambda builder..."; @@ -340,19 +340,19 @@ class V0Builder if constexpr (modes::isEqual(v0Type, modes::V0::kAntiLambda)) { LOG(info) << "Initialize femto AntiLambda builder..."; } - produceLambdas = utils::enableTable("FLambdas_001", table.produceLambdas.value, initContext); - produceLambdaMasks = utils::enableTable("FLambdaMasks_001", table.produceLambdaMasks.value, initContext); - produceLambdaExtras = utils::enableTable("FLambdaExtras_001", table.produceLambdaExtras.value, initContext); + mProduceLambdas = utils::enableTable("FLambdas_001", table.produceLambdas.value, initContext); + mProduceLambdaMasks = utils::enableTable("FLambdaMasks_001", table.produceLambdaMasks.value, initContext); + mProduceLambdaExtras = utils::enableTable("FLambdaExtras_001", table.produceLambdaExtras.value, initContext); } if constexpr (modes::isEqual(v0Type, modes::V0::kK0short)) { LOG(info) << "Initialize femto K0short builder..."; - produceK0shorts = utils::enableTable("FK0shorts_001", table.produceK0shorts.value, initContext); - produceK0shortMasks = utils::enableTable("FK0shortMasks_001", table.produceK0shortMasks.value, initContext); - produceK0shortExtras = utils::enableTable("FK0shortExtras_001", table.produceK0shortExtras.value, initContext); + mProduceK0shorts = utils::enableTable("FK0shorts_001", table.produceK0shorts.value, initContext); + mProduceK0shortMasks = utils::enableTable("FK0shortMasks_001", table.produceK0shortMasks.value, initContext); + mProduceK0shortExtras = utils::enableTable("FK0shortExtras_001", table.produceK0shortExtras.value, initContext); } - if (produceLambdas || produceLambdaMasks || produceLambdaExtras || produceK0shorts || produceK0shortMasks || produceK0shortExtras) { + if (mProduceLambdas || mProduceLambdaMasks || mProduceLambdaExtras || mProduceK0shorts || mProduceK0shortMasks || mProduceK0shortExtras) { mFillAnyTable = true; - v0Selection.printSelections(v0SelsName, v0SelsToStrings); + mV0Selection.printSelections(v0SelsName, v0SelsToStrings); } else { LOG(info) << "No tables configured"; } @@ -368,11 +368,11 @@ class V0Builder int64_t posDaughterIndex = 0; int64_t negDaughterIndex = 0; for (const auto& v0 : v0s) { - if (!v0Selection.checkFilters(v0)) { + if (!mV0Selection.checkFilters(v0)) { continue; } - v0Selection.applySelections(v0, tracks); - if (v0Selection.passesAllRequiredSelections() && v0Selection.checkHypothesis(v0)) { + mV0Selection.applySelections(v0, tracks); + if (mV0Selection.passesAllRequiredSelections() && mV0Selection.checkHypothesis(v0)) { auto posDaughter = v0.template posTrack_as(); auto negDaughter = v0.template negTrack_as(); posDaughterIndex = trackBuilder.template getDaughterIndex(posDaughter, trackProducts, collisionProducts, indexMap); @@ -401,7 +401,7 @@ class V0Builder mass = v0.mAntiLambda(); massAnti = v0.mLambda(); } - if (produceLambdas) { + if (mProduceLambdas) { v0products.producedLambdas(collisionProducts.producedCollision.lastIndex(), sign * v0.pt(), v0.eta(), @@ -410,10 +410,10 @@ class V0Builder posDaughterIndex, negDaughterIndex); } - if (produceLambdaMasks) { - v0products.producedLambdaMasks(v0Selection.getBitmask()); + if (mProduceLambdaMasks) { + v0products.producedLambdaMasks(mV0Selection.getBitmask()); } - if (produceLambdaExtras) { + if (mProduceLambdaExtras) { v0products.producedLambdaExtras( massAnti, v0.mK0Short(), @@ -429,7 +429,7 @@ class V0Builder template void fillK0short(T1& collisionProducts, T2& v0products, T3 const& v0, int posDaughterIndex, int negDaughterIndex) { - if (produceK0shorts) { + if (mProduceK0shorts) { v0products.producedK0shorts(collisionProducts.producedCollision.lastIndex(), v0.pt(), v0.eta(), @@ -438,10 +438,10 @@ class V0Builder posDaughterIndex, negDaughterIndex); } - if (produceK0shortMasks) { - v0products.producedK0shortMasks(v0Selection.getBitmask()); + if (mProduceK0shortMasks) { + v0products.producedK0shortMasks(mV0Selection.getBitmask()); } - if (produceK0shortExtras) { + if (mProduceK0shortExtras) { v0products.producedK0shortExtras( v0.mLambda(), v0.mAntiLambda(), @@ -457,14 +457,14 @@ class V0Builder bool fillAnyTable() { return mFillAnyTable; } private: - V0Selection v0Selection; + V0Selection mV0Selection; bool mFillAnyTable = false; - bool produceLambdas = false; - bool produceLambdaMasks = false; - bool produceLambdaExtras = false; - bool produceK0shorts = false; - bool produceK0shortMasks = false; - bool produceK0shortExtras = false; + bool mProduceLambdas = false; + bool mProduceLambdaMasks = false; + bool mProduceLambdaExtras = false; + bool mProduceK0shorts = false; + bool mProduceK0shortMasks = false; + bool mProduceK0shortExtras = false; }; } // namespace v0builder } // namespace o2::analysis::femto diff --git a/PWGCF/Femto/DataModel/FemtoTables.h b/PWGCF/Femto/DataModel/FemtoTables.h index e96708d657d..1708ba66ba7 100644 --- a/PWGCF/Femto/DataModel/FemtoTables.h +++ b/PWGCF/Femto/DataModel/FemtoTables.h @@ -34,6 +34,8 @@ namespace o2::aod namespace femtocollisions { +DECLARE_SOA_COLUMN(CollisionMask, collisionMask, femtodatatypes::CollsionsMaskType); //! Bitmask for collision selections + DECLARE_SOA_COLUMN(PosX, posX, float); //! x coordinate of vertex DECLARE_SOA_COLUMN(PosY, posY, float); //! y coordinate of vertex DECLARE_SOA_COLUMN(PosZ, posZ, float); //! z coordinate of vertex @@ -55,6 +57,11 @@ DECLARE_SOA_TABLE_STAGED_VERSIONED(FCols_001, "FCOL", 1, //! femto collisions femtocollisions::MagField); using FCols = FCols_001; +// table for collisions selections +DECLARE_SOA_TABLE_STAGED_VERSIONED(FColMasks_001, "FCOLMASK", 1, //! track masks + femtocollisions::CollisionMask); +using FColMasks = FColMasks_001; + // table for occupancy DECLARE_SOA_TABLE_STAGED_VERSIONED(FColOccs_001, "FCOLOCC", 1, //! occupancy femtocollisions::Occupancy); diff --git a/PWGCF/Femto/TableProducer/CMakeLists.txt b/PWGCF/Femto/TableProducer/CMakeLists.txt index e5808562f51..81829ec83a1 100644 --- a/PWGCF/Femto/TableProducer/CMakeLists.txt +++ b/PWGCF/Femto/TableProducer/CMakeLists.txt @@ -11,5 +11,5 @@ o2physics_add_dpl_workflow(femto-producer SOURCES femtoProducer.cxx - PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2Physics::EventFilteringUtils COMPONENT_NAME Analysis) diff --git a/PWGCF/Femto/TableProducer/femtoProducer.cxx b/PWGCF/Femto/TableProducer/femtoProducer.cxx index 0f69056e11d..205ca34a986 100644 --- a/PWGCF/Femto/TableProducer/femtoProducer.cxx +++ b/PWGCF/Femto/TableProducer/femtoProducer.cxx @@ -85,8 +85,9 @@ struct FemtoProducer { // collision builder collisionbuilder::CollisionBuilderProducts collisionBuilderProducts; collisionbuilder::ConfCollisionTables confCollisionTables; - collisionbuilder::ConfCollisionFilter confCollisionFilter; - collisionbuilder::ConfCollisionFlags confCollisionFlags; + collisionbuilder::ConfCollisionFilters confCollisionFilters; + collisionbuilder::ConfCollisionBits confCollisionBits; + collisionbuilder::ConfCollisionTriggers confCollisionTriggers; collisionbuilder::CollisionBuilder collisionBuilder; // track builder @@ -180,7 +181,7 @@ struct FemtoProducer { ccdb->setCreatedNotAfter(now); // collision selection - collisionBuilder.init(confCollisionFilter, confCollisionFlags, confCollisionTables, context); + collisionBuilder.init(confCollisionFilters, confCollisionBits, confCollisionTables, confCollisionTriggers, context); // configure track builder trackBuilder.init(confTrackBits, confTrackFilters, confTrackTables, context); @@ -212,9 +213,10 @@ struct FemtoProducer { template void processTracks(T1 const& col, T2 const& /* bcs*/, T3 const& tracks, T4 const& tracksWithItsPid) { - initFromCcdb(col.template bc_as()); - collisionBuilder.buildCollision(col, tracks, magField); - if (!collisionBuilder.checkCuts(col)) { + auto bc = col.template bc_as(); + initFromCcdb(bc); + collisionBuilder.buildCollision(bc, col, tracks, ccdb, magField); + if (!collisionBuilder.checkCollision(bc, col)) { return; } collisionBuilder.fillCollision(collisionBuilderProducts, col); diff --git a/PWGCF/Femto/Tasks/femtoCascadeQa.cxx b/PWGCF/Femto/Tasks/femtoCascadeQa.cxx index b447d31633b..1de5aef92ec 100644 --- a/PWGCF/Femto/Tasks/femtoCascadeQa.cxx +++ b/PWGCF/Femto/Tasks/femtoCascadeQa.cxx @@ -61,7 +61,7 @@ struct FemtoCascadeQa { // setup collisions colhistmanager::CollisionHistManager colHistManager; colhistmanager::ConfCollisionBinning confCollisionBinning; - collisionbuilder::ConfCollisionFilter collisionSelection; + collisionbuilder::ConfCollisionFilters collisionSelection; Filter collisionFilter = MAKE_COLLISION_FILTER(collisionSelection); // setup for xis diff --git a/PWGCF/Femto/Tasks/femtoTrackQa.cxx b/PWGCF/Femto/Tasks/femtoTrackQa.cxx index 4963b54f9dc..a111111f6b0 100644 --- a/PWGCF/Femto/Tasks/femtoTrackQa.cxx +++ b/PWGCF/Femto/Tasks/femtoTrackQa.cxx @@ -54,7 +54,7 @@ struct FemtoTrackQa { SliceCache cache; // setup collisions - collisionbuilder::ConfCollisionFilter collisionSelection; + collisionbuilder::ConfCollisionFilters collisionSelection; Filter collisionFilter = MAKE_COLLISION_FILTER(collisionSelection); colhistmanager::ConfCollisionBinning confCollisionBinning; colhistmanager::CollisionHistManager colHistManager; diff --git a/PWGCF/Femto/Tasks/femtoTwotrackresonanceQa.cxx b/PWGCF/Femto/Tasks/femtoTwotrackresonanceQa.cxx index 3ea287908d5..83b28842469 100644 --- a/PWGCF/Femto/Tasks/femtoTwotrackresonanceQa.cxx +++ b/PWGCF/Femto/Tasks/femtoTwotrackresonanceQa.cxx @@ -60,7 +60,7 @@ struct FemtoTwotrackresonanceQa { // setup for collisions colhistmanager::CollisionHistManager colHistManager; colhistmanager::ConfCollisionBinning confCollisionBinning; - collisionbuilder::ConfCollisionFilter collisionSelection; + collisionbuilder::ConfCollisionFilters collisionSelection; Filter collisionFilter = MAKE_COLLISION_FILTER(collisionSelection); // setup for phis diff --git a/PWGCF/Femto/Tasks/femtoV0Qa.cxx b/PWGCF/Femto/Tasks/femtoV0Qa.cxx index c7ae9a8d786..1b75bcd24ea 100644 --- a/PWGCF/Femto/Tasks/femtoV0Qa.cxx +++ b/PWGCF/Femto/Tasks/femtoV0Qa.cxx @@ -46,7 +46,7 @@ using namespace o2::analysis::femto; struct FemtoV0Qa { // setup for collisions - collisionbuilder::ConfCollisionFilter collisionSelection; + collisionbuilder::ConfCollisionFilters collisionSelection; Filter collisionFilter = MAKE_COLLISION_FILTER(collisionSelection); colhistmanager::CollisionHistManager colHistManager;