diff --git a/PWGCF/Femto/Core/cascadeBuilder.h b/PWGCF/Femto/Core/cascadeBuilder.h index b7342c3516f..5f43ecf6ab9 100644 --- a/PWGCF/Femto/Core/cascadeBuilder.h +++ b/PWGCF/Femto/Core/cascadeBuilder.h @@ -92,7 +92,7 @@ struct ConfOmegaBits : o2::framework::ConfigurableGroup { #define CASCADE_DEFAULT_SELECTION(defaultMassMin, defaultMassMax, defaultPdgCode) \ o2::framework::Configurable pdgCode{"pdgCode", defaultPdgCode, "Track PDG code"}; \ - o2::framework::Configurable sign{"sign", 1, "Sign of the Lambda (+1 for Lambda and -1 for Antilambda"}; \ + o2::framework::Configurable sign{"sign", 1, "Sign of the charge of the Cascade "}; \ o2::framework::Configurable ptMin{"ptMin", 0.f, "Minimum pT"}; \ o2::framework::Configurable ptMax{"ptMax", 999.f, "Maximum pT"}; \ o2::framework::Configurable etaMin{"etaMin", -10.f, "Minimum eta"}; \ @@ -105,7 +105,7 @@ struct ConfOmegaBits : o2::framework::ConfigurableGroup { struct ConfXiSelection : o2::framework::ConfigurableGroup { std::string prefix = std::string("XiSelection"); - CASCADE_DEFAULT_SELECTION(1.22, 1.42, 3212) + CASCADE_DEFAULT_SELECTION(1.22, 1.42, 3312) }; struct ConfOmegaSelection : o2::framework::ConfigurableGroup { diff --git a/PWGCF/Femto/Core/cascadeHistManager.h b/PWGCF/Femto/Core/cascadeHistManager.h index 19c0f9f0d97..91b2413ff08 100644 --- a/PWGCF/Femto/Core/cascadeHistManager.h +++ b/PWGCF/Femto/Core/cascadeHistManager.h @@ -113,7 +113,7 @@ constexpr std::array, kCascadeHistLast> HistT {kMassXiVsMassOmega, o2::framework::kTH2F, "hMassXiVsMassOmega", "mass #Xi vs mass #Omega; m_{#Lambda#pi} (GeV/#it{c}^{2}); m_{#LambdaK} (GeV/#it{c}^{2})"}}}; template -auto makeCascadeAnalysisHistSpecMap(const T& confBinningAnalysis) +auto makeCascadeHistSpecMap(const T& confBinningAnalysis) { return std::map>{ {kPt, {confBinningAnalysis.pt}}, diff --git a/PWGCF/Femto/Core/closePairRejection.h b/PWGCF/Femto/Core/closePairRejection.h index 84b60eefee9..3c21f953ad1 100644 --- a/PWGCF/Femto/Core/closePairRejection.h +++ b/PWGCF/Femto/Core/closePairRejection.h @@ -58,13 +58,17 @@ struct ConfCpr : o2::framework::ConfigurableGroup { // tpc radii for computing phistar constexpr int kNradii = 9; -constexpr std::array kTpcRadius = {85., 105., 125., 145., 165., 185., 205., 225., 245.}; +constexpr std::array kTpcRadius = {85., 105., 125., 145., 165., 185., 205., 225., 245.}; // in cm // directory names constexpr char PrefixTrackTrackSe[] = "CPR_TrackTrack/SE/"; constexpr char PrefixTrackTrackMe[] = "CPR_TrackTrack/ME/"; -constexpr char PrefixTrackV0Se[] = "CPR_TrackV0/SE/"; -constexpr char PrefixTrackV0Me[] = "CPR_TrackV0/ME/"; +constexpr char PrefixTrackV0Se[] = "CPR_TrackV0Daughter/SE/"; +constexpr char PrefixTrackV0Me[] = "CPR_TrackV0Daughter/ME/"; +constexpr char PrefixTrackTwoTrackResonanceSe[] = "CPR_TrackResonanceDaughter/SE/"; +constexpr char PrefixTrackTwoTrackResonnaceMe[] = "CPR_TrackResonanceDaughter/ME/"; +constexpr char PrefixTrackCascadeSe[] = "CPR_TrackCascadeBachelor/SE/"; +constexpr char PrefixTrackCascadeMe[] = "CPR_TrackCascadeBachelor/ME/"; constexpr char PrefixTrackKinkSe[] = "CPR_TrackKink/SE/"; constexpr char PrefixTrackKinkMe[] = "CPR_TrackKink/ME/"; @@ -117,7 +121,7 @@ class CloseTrackRejection mChargeTrack2 = chargeTrack2; if (utils::sign(mChargeTrack1) != utils::sign(mChargeTrack2)) { - LOG(warn) << "CPR is truned on for tracks with opposite charge. Is this intended?"; + LOG(warn) << "CPR is turned on for tracks with opposite charge. Is this intended?"; } mHistogramRegistry = registry; @@ -196,10 +200,12 @@ template class ClosePairRejectionTrackTrack { public: - void init(o2::framework::HistogramRegistry* registry, std::map>& specs, float detaMax, float dphistarMax, int signTrack1, int absChargeTrack1, int signTrack2, int AbsChargeTrack2, bool isActivated) + void init(o2::framework::HistogramRegistry* registry, std::map>& specs, float detaMax, float dphistarMax, int chargeTrack1, int chargeTrack2, bool isActivated) { mIsActivated = isActivated; - mCtr.init(registry, specs, detaMax, dphistarMax, signTrack1 * absChargeTrack1, signTrack2 * AbsChargeTrack2); + if (mIsActivated) { + mCtr.init(registry, specs, detaMax, dphistarMax, chargeTrack1, chargeTrack2); + } } void setMagField(float magField) { mCtr.setMagField(magField); } @@ -221,14 +227,16 @@ template class ClosePairRejectionTrackV0 // can also be used for any particle type that has pos/neg daughters, like resonances { public: - void init(o2::framework::HistogramRegistry* registry, std::map>& specs, float detaMax, float dphistarMax, int signTrack, int absChargeTrack, bool isActivated) + void init(o2::framework::HistogramRegistry* registry, std::map>& specs, float detaMax, float dphistarMax, int chargeTrack, bool isActivated) { mIsActivated = isActivated; - mSignTrack = signTrack; + mChargeTrack = chargeTrack; // initialize CPR with charge of the track and the same charge for the daughter particle - // absolute charge of the daughter track will be 1, so we can pass the sign directly - mCtr.init(registry, specs, detaMax, dphistarMax, signTrack * absChargeTrack, signTrack); + // absolute charge of the daughter track will be 1, so we just pass the sign + if (mIsActivated) { + mCtr.init(registry, specs, detaMax, dphistarMax, mChargeTrack, utils::sign(mChargeTrack)); + } } void setMagField(float magField) @@ -238,14 +246,14 @@ class ClosePairRejectionTrackV0 // can also be used for any particle type that h template void setPair(const T1& track, const T2& v0, const T3 /*trackTable*/) { - if (mSignTrack == 1) { + if (mChargeTrack > 0) { auto daughter = v0.template posDau_as(); mCtr.compute(track, daughter); - } else if (mSignTrack == -1) { + } else if (mChargeTrack < 0) { auto daughter = v0.template negDau_as(); mCtr.compute(track, daughter); } else { - LOG(fatal) << "CPR Track-V0: Wrong track sign"; + LOG(fatal) << "CPR Track-V0: Sign of the track is 0!"; } } @@ -258,23 +266,58 @@ class ClosePairRejectionTrackV0 // can also be used for any particle type that h private: CloseTrackRejection mCtr; - int mSignTrack = 0; + int mChargeTrack = 0; bool mIsActivated = true; }; template -class ClosePairRejectionTrackKink +class ClosePairRejectionTrackCascade // can also be used for any particle type that has pos/neg daughters, like resonances { public: - void init(o2::framework::HistogramRegistry* registry, std::map>& specs, float detaMax, float dphistarMax, int signTrack, int absChargeTrack, bool isActivated) + void init(o2::framework::HistogramRegistry* registry, std::map>& specs, float detaMax, float dphistarMax, int chargeTrack, int chargeCascade, bool isActivated) { mIsActivated = isActivated; - mSignTrack = signTrack; + if (mIsActivated) { + mCtr.init(registry, specs, detaMax, dphistarMax, chargeTrack, chargeCascade); + } + } + + void setMagField(float magField) + { + mCtr.setMagField(magField); + } + template + void setPair(const T1& track, const T2& cascade, const T3 /*trackTable*/) + { + auto bachelor = cascade.template posDau_as(); + mCtr.compute(track, bachelor); + } + bool isClosePair() const { return mCtr.isClosePair(); } + void fill() + { + mCtr.fill(); + } + bool isActivated() const { return mIsActivated; } + + private: + CloseTrackRejection mCtr; + bool mIsActivated = true; +}; + +template +class ClosePairRejectionTrackKink +{ + public: + void init(o2::framework::HistogramRegistry* registry, std::map>& specs, float detaMax, float dphistarMax, int chargeTrack, int signKinkCandidate, bool isActivated) + { + mIsActivated = isActivated; // initialize CPR with charge of the track and the charged daughter particle // For kinks, we compare the primary track with the charged daughter // The charged daughter has absolute charge of 1, so we can pass the sign directly - mCtr.init(registry, specs, detaMax, dphistarMax, signTrack * absChargeTrack, mSignTrack); + if (mIsActivated) { + mCtr.init(registry, specs, detaMax, dphistarMax, chargeTrack, signKinkCandidate); + } } void setMagField(float magField) @@ -285,12 +328,8 @@ class ClosePairRejectionTrackKink template void setPair(const T1& track, const T2& kink, const T3 /*trackTable*/) { - if (mSignTrack == 1 || mSignTrack == -1) { - auto daughter = kink.template chaDau_as(); - mCtr.compute(track, daughter); - } else { - LOG(warn) << "CPR Track-Kink: Wrong track sign"; - } + auto daughter = kink.template chaDau_as(); + mCtr.compute(track, daughter); } bool isClosePair() const { return mCtr.isClosePair(); } @@ -302,7 +341,6 @@ class ClosePairRejectionTrackKink private: CloseTrackRejection mCtr; - int mSignTrack = 0; bool mIsActivated = true; }; diff --git a/PWGCF/Femto/Core/collisionBuilder.h b/PWGCF/Femto/Core/collisionBuilder.h index 96c64645c7a..091dc6ec237 100644 --- a/PWGCF/Femto/Core/collisionBuilder.h +++ b/PWGCF/Femto/Core/collisionBuilder.h @@ -80,6 +80,14 @@ struct ConfCollisionTriggers : o2::framework::ConfigurableGroup { o2::framework::Configurable triggers{"triggers", std::string("fPPP,fPPL"), "Comma seperated list of all triggers to be used"}; }; +struct ConfCollisionRctFlags : o2::framework::ConfigurableGroup { + std::string prefix = std::string("CollisionRctFlags"); + o2::framework::Configurable useRctFlags{"useRctFlags", true, "Set to true to use RCT flags"}; + o2::framework::Configurable label{"label", std::string("CBT_hadronPID"), "Which RCT flag to check"}; + o2::framework::Configurable useZdc{"useZdc", false, "Whether to use ZDC (only use for PbPb)"}; + o2::framework::Configurable treatLimitedAcceptanceAsBad{"treatLimitedAcceptanceAsBad", false, "Whether to treat limited acceptance as bad or not"}; +}; + // configurables for collision selection struct ConfCollisionSelection : o2::framework::ConfigurableGroup { std::string prefix = std::string("CollisionSelection"); @@ -309,22 +317,27 @@ class CollisionBuilder CollisionBuilder() {} virtual ~CollisionBuilder() = default; - template - void init(T1& filter, T2& config, T3& table, T4& trigger, T5& initContext) + template + void init(T1& confFilter, T2& confBits, T3& confRct, T4& confTrigger, T5& confTable, T6& initContext) { - mCollisionSelection.configure(filter, config); - if (trigger.useTrigger.value) { + mCollisionSelection.configure(confFilter, confBits); + if (confTrigger.useTrigger.value) { mUseTrigger = true; - mTriggerNames = trigger.triggers.value; - mZorro.setBaseCCDBPath(trigger.ccdbPath.value); + mTriggerNames = confTrigger.triggers.value; + mZorro.setBaseCCDBPath(confTrigger.ccdbPath.value); + } + if (confRct.useRctFlags.value) { + mUseRctFlags = true; + mRctFlagsChecker.init(confRct.label.value, confRct.useZdc.value, confRct.treatLimitedAcceptanceAsBad.value); } + LOG(info) << "Initialize femto collision builder..."; - mProducedCollisions = utils::enableTable("FCols_001", table.produceCollisions.value, initContext); - mProducedCollisionMasks = utils::enableTable("FColMasks_001", table.produceCollisionMasks.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); + mProducedCollisions = utils::enableTable("FCols_001", confTable.produceCollisions.value, initContext); + mProducedCollisionMasks = utils::enableTable("FColMasks_001", confTable.produceCollisionMasks.value, initContext); + mProduceQns = utils::enableTable("FColQnBins_001", confTable.produceQns.value, initContext); + mProducedPositions = utils::enableTable("FColPos_001", confTable.producePositions.value, initContext); + mProducedMultiplicities = utils::enableTable("FColMults_001", confTable.produceMults.value, initContext); + mProducedCentralities = utils::enableTable("FColCents_001", confTable.produceCents.value, initContext); if (mProducedCollisions || mProducedCollisionMasks || mProducedPositions || mProducedMultiplicities || mProducedCentralities) { mFillAnyTable = true; mCollisionSelection.printSelections(colSelsName, colSelsToString); @@ -351,12 +364,17 @@ class CollisionBuilder template bool checkCollision(T1 const& bc, T2 const& col) { - if (mUseTrigger) { - return mZorro.isSelected(bc.globalBC()) && mCollisionSelection.checkFilters(col) && mCollisionSelection.passesAllRequiredSelections(); - } else { - - return mCollisionSelection.checkFilters(col) && mCollisionSelection.passesAllRequiredSelections(); + // First: if triggers are enabled, the object must be selected + if (mUseTrigger && !mZorro.isSelected(bc.globalBC())) { + return false; + } + // Then: if RCT flags are enabled, check them + if (mUseRctFlags && !mRctFlagsChecker(col)) { + return false; } + // Finally: do the expensive checks + return mCollisionSelection.checkFilters(col) && + mCollisionSelection.passesAllRequiredSelections(); } template @@ -406,6 +424,8 @@ class CollisionBuilder CollisionSelection mCollisionSelection; Zorro mZorro; bool mUseTrigger = false; + aod::rctsel::RCTFlagsChecker mRctFlagsChecker; + bool mUseRctFlags = false; std::string mTriggerNames = std::string(""); bool mFillAnyTable = false; bool mProducedCollisions = false; diff --git a/PWGCF/Femto/Core/dataTypes.h b/PWGCF/Femto/Core/dataTypes.h index 54cef607b7b..39ae9fc9ae8 100644 --- a/PWGCF/Femto/Core/dataTypes.h +++ b/PWGCF/Femto/Core/dataTypes.h @@ -25,6 +25,7 @@ namespace femtodatatypes // Note: Length of the bitmask is the limit of how many selections can be configured // datatypes for collsions +using CollisionTagType = uint64_t; using CollisionMaskType = uint16_t; // datatypes for tracks diff --git a/PWGCF/Femto/Core/femtoUtils.h b/PWGCF/Femto/Core/femtoUtils.h index f853d5e0c4b..fb082ae96fa 100644 --- a/PWGCF/Femto/Core/femtoUtils.h +++ b/PWGCF/Femto/Core/femtoUtils.h @@ -148,6 +148,12 @@ inline float getMass(int pdgCode) case kSigmaMinus: mass = o2::constants::physics::MassSigmaMinus; break; + case kXiMinus: + mass = o2::constants::physics::MassXiMinus; + break; + case kOmegaMinus: + mass = o2::constants::physics::MassOmegaMinus; + break; default: LOG(fatal) << "PDG code is not suppored"; } diff --git a/PWGCF/Femto/Core/pairBuilder.h b/PWGCF/Femto/Core/pairBuilder.h index 7e38b1ff98c..1af5a169e24 100644 --- a/PWGCF/Femto/Core/pairBuilder.h +++ b/PWGCF/Femto/Core/pairBuilder.h @@ -16,6 +16,7 @@ #ifndef PWGCF_FEMTO_CORE_PAIRBUILDER_H_ #define PWGCF_FEMTO_CORE_PAIRBUILDER_H_ +#include "PWGCF/Femto/Core/cascadeHistManager.h" #include "PWGCF/Femto/Core/closePairRejection.h" #include "PWGCF/Femto/Core/collisionHistManager.h" #include "PWGCF/Femto/Core/kinkHistManager.h" @@ -24,6 +25,7 @@ #include "PWGCF/Femto/Core/pairHistManager.h" #include "PWGCF/Femto/Core/pairProcessHelpers.h" #include "PWGCF/Femto/Core/trackHistManager.h" +#include "PWGCF/Femto/Core/twoTrackResonanceHistManager.h" #include "PWGCF/Femto/Core/v0HistManager.h" #include "PWGCF/Femto/DataModel/FemtoTables.h" @@ -83,23 +85,23 @@ class PairTrackTrackBuilder mTrackHistManager1.init(registry, trackHistSpec1); mPairHistManagerSe.setMass(confTrackSelection1.pdgCode.value, confTrackSelection1.pdgCode.value); - mPairHistManagerSe.setCharge(confTrackSelection1.absCharge.value, confTrackSelection1.absCharge.value); - mCprSe.init(registry, cprHistSpec, confCpr.detaMax.value, confCpr.dphistarMax.value, confTrackSelection1.sign.value, confTrackSelection1.absCharge.value, confTrackSelection1.sign.value, confTrackSelection1.absCharge.value, confCpr.on.value); + mPairHistManagerSe.setCharge(confTrackSelection1.charge.value, confTrackSelection1.charge.value); + mCprSe.init(registry, cprHistSpec, confCpr.detaMax.value, confCpr.dphistarMax.value, confTrackSelection1.charge.value, confTrackSelection1.charge.value, confCpr.on.value); mPairHistManagerMe.setMass(confTrackSelection1.pdgCode.value, confTrackSelection1.pdgCode.value); - mPairHistManagerMe.setCharge(confTrackSelection1.absCharge.value, confTrackSelection1.absCharge.value); - mCprMe.init(registry, cprHistSpec, confCpr.detaMax.value, confCpr.dphistarMax.value, confTrackSelection1.sign.value, confTrackSelection1.absCharge.value, confTrackSelection1.sign.value, confTrackSelection1.absCharge.value, confCpr.on.value); + mPairHistManagerMe.setCharge(confTrackSelection1.charge.value, confTrackSelection1.charge.value); + mCprMe.init(registry, cprHistSpec, confCpr.detaMax.value, confCpr.dphistarMax.value, confTrackSelection1.charge.value, confTrackSelection1.charge.value, confCpr.on.value); } else { mTrackHistManager1.init(registry, trackHistSpec1); mTrackHistManager2.init(registry, trackHistSpec2); mPairHistManagerSe.setMass(confTrackSelection1.pdgCode.value, confTrackSelection2.pdgCode.value); - mPairHistManagerSe.setCharge(confTrackSelection1.absCharge.value, confTrackSelection2.absCharge.value); - mCprSe.init(registry, cprHistSpec, confCpr.detaMax.value, confCpr.dphistarMax.value, confTrackSelection1.sign.value, confTrackSelection1.absCharge.value, confTrackSelection2.sign.value, confTrackSelection2.absCharge.value, confCpr.on.value); + mPairHistManagerSe.setCharge(confTrackSelection1.charge.value, confTrackSelection2.charge.value); + mCprSe.init(registry, cprHistSpec, confCpr.detaMax.value, confCpr.dphistarMax.value, confTrackSelection1.charge.value, confTrackSelection2.charge.value, confCpr.on.value); mPairHistManagerMe.setMass(confTrackSelection1.pdgCode.value, confTrackSelection2.pdgCode.value); - mPairHistManagerMe.setCharge(confTrackSelection1.absCharge.value, confTrackSelection2.absCharge.value); - mCprMe.init(registry, cprHistSpec, confCpr.detaMax.value, confCpr.dphistarMax.value, confTrackSelection1.sign.value, confTrackSelection1.absCharge.value, confTrackSelection2.sign.value, confTrackSelection2.absCharge.value, confCpr.on.value); + mPairHistManagerMe.setCharge(confTrackSelection1.charge.value, confTrackSelection2.charge.value); + mCprMe.init(registry, cprHistSpec, confCpr.detaMax.value, confCpr.dphistarMax.value, confTrackSelection1.charge.value, confTrackSelection2.charge.value, confCpr.on.value); } // setup mixing @@ -240,13 +242,13 @@ class PairTrackV0Builder mPairHistManagerSe.init(registry, pairHistSpec); mPairHistManagerSe.setMass(confTrackSelection.pdgCode.value, confV0Selection.pdgCode.value); - mPairHistManagerSe.setCharge(confTrackSelection.absCharge.value, 1); - mCprSe.init(registry, cprHistSpec, confCpr.detaMax.value, confCpr.dphistarMax.value, confTrackSelection.sign.value, confTrackSelection.absCharge.value, confCpr.on.value); + mPairHistManagerSe.setCharge(confTrackSelection.charge.value, 1); + mCprSe.init(registry, cprHistSpec, confCpr.detaMax.value, confCpr.dphistarMax.value, confTrackSelection.charge.value, confCpr.on.value); mPairHistManagerMe.init(registry, pairHistSpec); mPairHistManagerMe.setMass(confTrackSelection.pdgCode.value, confV0Selection.pdgCode.value); - mPairHistManagerMe.setCharge(confTrackSelection.absCharge.value, 1); - mCprMe.init(registry, cprHistSpec, confCpr.detaMax.value, confCpr.dphistarMax.value, confTrackSelection.sign.value, confTrackSelection.absCharge.value, confCpr.on.value); + mPairHistManagerMe.setCharge(confTrackSelection.charge.value, 1); + mCprMe.init(registry, cprHistSpec, confCpr.detaMax.value, confCpr.dphistarMax.value, confTrackSelection.charge.value, confCpr.on.value); // setup mixing mMixingPolicy = static_cast(confMixing.policy.value); @@ -297,6 +299,110 @@ class PairTrackV0Builder int mMixingDepth = 5; }; +template < + const char* prefixTrack, + const char* prefixResonance, + const char* prefixPosDau, + const char* prefixNegDau, + const char* prefixSe, + const char* prefixMe, + const char* prefixCprSe, + const char* prefixCprMe, + modes::Mode mode, + modes::TwoTrackResonance resonanceType> +class PairTrackTwoTrackResonanceBuilder +{ + public: + PairTrackTwoTrackResonanceBuilder() = default; + + template + void init(o2::framework::HistogramRegistry* registry, + T1& confTrackSelection, + T2& confResonanceSelection, + T3& confCpr, + T4& confMixing, + std::map>& colHistSpec, + std::map>& trackHistSpec, + std::map>& resonanceHistSpec, + std::map>& posDauHistSpec, + std::map>& negDauHistSpec, + std::map>& pairHistSpec, + std::map>& cprHistSpec) + { + mColHistManager.init(registry, colHistSpec); + + mTrackHistManager.init(registry, trackHistSpec); + mResonanceHistManager.init(registry, resonanceHistSpec, posDauHistSpec, negDauHistSpec); + + mPairHistManagerSe.init(registry, pairHistSpec); + mPairHistManagerSe.setMass(confTrackSelection.pdgCode.value, confResonanceSelection.pdgCode.value); + mPairHistManagerSe.setCharge(confTrackSelection.charge.value, 1); + mCprSe.init(registry, cprHistSpec, confCpr.detaMax.value, confCpr.dphistarMax.value, confTrackSelection.charge.value, confCpr.on.value); + + mPairHistManagerMe.init(registry, pairHistSpec); + mPairHistManagerMe.setMass(confTrackSelection.pdgCode.value, confResonanceSelection.pdgCode.value); + mPairHistManagerMe.setCharge(confTrackSelection.charge.value, 1); + mCprMe.init(registry, cprHistSpec, confCpr.detaMax.value, confCpr.dphistarMax.value, confTrackSelection.charge.value, confCpr.on.value); + + // setup mixing + mMixingPolicy = static_cast(confMixing.policy.value); + mMixingDepth = confMixing.depth.value; + } + + template + void processSameEvent(T1 const& col, T2& trackTable, T3& trackPartition, T4& /*resonanceTable*/, T5& resonancePartition, T6& cache) + { + auto trackSlice = trackPartition->sliceByCached(o2::aod::femtobase::stored::collisionId, col.globalIndex(), cache); + auto v0Slice = resonancePartition->sliceByCached(o2::aod::femtobase::stored::collisionId, col.globalIndex(), cache); + if (trackSlice.size() == 0 || v0Slice.size() == 0) { + return; + } + mColHistManager.fill(col); + mCprSe.setMagField(col.magField()); + pairprocesshelpers::processSameEvent(trackSlice, v0Slice, trackTable, mTrackHistManager, mResonanceHistManager, mPairHistManagerSe, mCprSe, mPc); + } + + template + void processMixedEvent(T1 const& cols, T2& trackTable, T3& trackPartition, T4& resonancePartition, T5& cache, T6& binsVtxMult, T7& binsVtxCent, T8& binsVtxMultCent) + { + switch (mMixingPolicy) { + case static_cast(pairhistmanager::kVtxMult): + pairprocesshelpers::processMixedEvent(cols, trackPartition, resonancePartition, trackTable, cache, binsVtxMult, mMixingDepth, mPairHistManagerMe, mCprMe, mPc); + break; + case static_cast(pairhistmanager::kVtxCent): + pairprocesshelpers::processMixedEvent(cols, trackPartition, resonancePartition, trackTable, cache, binsVtxCent, mMixingDepth, mPairHistManagerMe, mCprMe, mPc); + break; + case static_cast(pairhistmanager::kVtxMultCent): + pairprocesshelpers::processMixedEvent(cols, trackPartition, resonancePartition, trackTable, cache, binsVtxMultCent, mMixingDepth, mPairHistManagerMe, mCprMe, mPc); + break; + default: + LOG(fatal) << "Invalid binning policiy specifed. Breaking..."; + } + } + + private: + colhistmanager::CollisionHistManager mColHistManager; + trackhistmanager::TrackHistManager mTrackHistManager; + twotrackresonancehistmanager::TwoTrackResonanceHistManager mResonanceHistManager; + pairhistmanager::PairHistManager mPairHistManagerSe; + pairhistmanager::PairHistManager mPairHistManagerMe; + closepairrejection::ClosePairRejectionTrackV0 mCprSe; // cpr for twotrackresonances and v0 work the same way + closepairrejection::ClosePairRejectionTrackV0 mCprMe; // cpr for twotrackresonances and v0 work the same way + paircleaner::TrackV0PairCleaner mPc; // pc for twotrackresonances and v0 work the same way + pairhistmanager::MixingPoliciy mMixingPolicy = pairhistmanager::MixingPoliciy::kVtxMult; + int mMixingDepth = 5; +}; + template < const char* prefixTrack, const char* prefixKink, @@ -341,13 +447,13 @@ class PairTrackKinkBuilder mPairHistManagerSe.init(registry, pairHistSpec); mPairHistManagerSe.setMass(confTrackSelection.pdgCode.value, confKinkSelection.pdgCode.value); - mPairHistManagerSe.setCharge(confTrackSelection.absCharge.value, 1); - mCprSe.init(registry, cprHistSpec, confCpr.detaMax.value, confCpr.dphistarMax.value, confTrackSelection.sign.value, confTrackSelection.absCharge.value, confCpr.on.value); + mPairHistManagerSe.setCharge(confTrackSelection.charge.value, confKinkSelection.sign.value); + mCprSe.init(registry, cprHistSpec, confCpr.detaMax.value, confCpr.dphistarMax.value, confTrackSelection.charge.value, confKinkSelection.sign.value, confCpr.on.value); mPairHistManagerMe.init(registry, pairHistSpec); mPairHistManagerMe.setMass(confTrackSelection.pdgCode.value, confKinkSelection.pdgCode.value); - mPairHistManagerMe.setCharge(confTrackSelection.absCharge.value, 1); - mCprMe.init(registry, cprHistSpec, confCpr.detaMax.value, confCpr.dphistarMax.value, confTrackSelection.sign.value, confTrackSelection.absCharge.value, confCpr.on.value); + mPairHistManagerMe.setCharge(confTrackSelection.charge.value, confKinkSelection.sign.value); + mCprMe.init(registry, cprHistSpec, confCpr.detaMax.value, confCpr.dphistarMax.value, confTrackSelection.charge.value, confKinkSelection.sign.value, confCpr.on.value); // setup mixing mMixingPolicy = static_cast(confMixing.policy.value); @@ -398,6 +504,113 @@ class PairTrackKinkBuilder int mMixingDepth = 5; }; +template < + const char* prefixTrack, + const char* prefixCascade, + const char* prefixBachelor, + const char* prefixPosDau, + const char* prefixNegDau, + const char* prefixSe, + const char* prefixMe, + const char* prefixCprSe, + const char* prefixCprMe, + modes::Mode mode, + modes::Cascade cascadeType> +class PairTrackCascadeBuilder +{ + public: + PairTrackCascadeBuilder() = default; + + template + void init(o2::framework::HistogramRegistry* registry, + T1& confTrackSelection, + T2& confCascadeSelection, + T3& confCpr, + T4& confMixing, + std::map>& colHistSpec, + std::map>& trackHistSpec, + std::map>& cascadeHistSpec, + std::map>& bachelorHistSpec, + std::map>& posDauHistSpec, + std::map>& negDauHistSpec, + std::map>& pairHistSpec, + std::map>& cprHistSpec) + { + mColHistManager.init(registry, colHistSpec); + + mTrackHistManager.init(registry, trackHistSpec); + mCascadeHistManager.init(registry, cascadeHistSpec, bachelorHistSpec, posDauHistSpec, negDauHistSpec); + + mPairHistManagerSe.init(registry, pairHistSpec); + mPairHistManagerSe.setMass(confTrackSelection.pdgCode.value, confCascadeSelection.pdgCode.value); + mPairHistManagerSe.setCharge(confTrackSelection.charge.value, confCascadeSelection.sign.value); + mCprSe.init(registry, cprHistSpec, confCpr.detaMax.value, confCpr.dphistarMax.value, confTrackSelection.charge.value, confCascadeSelection.sign.value, confCpr.on.value); + + mPairHistManagerMe.init(registry, pairHistSpec); + mPairHistManagerMe.setMass(confTrackSelection.pdgCode.value, confCascadeSelection.pdgCode.value); + mPairHistManagerMe.setCharge(confTrackSelection.charge.value, confCascadeSelection.sign.value); + mCprMe.init(registry, cprHistSpec, confCpr.detaMax.value, confCpr.dphistarMax.value, confTrackSelection.charge.value, confCascadeSelection.sign.value, confCpr.on.value); + + // setup mixing + mMixingPolicy = static_cast(confMixing.policy.value); + mMixingDepth = confMixing.depth.value; + } + + template + void processSameEvent(T1 const& col, T2& trackTable, T3& trackPartition, T4& /*cascadeTable*/, T5& v0Partition, T6& cache) + { + auto trackSlice = trackPartition->sliceByCached(o2::aod::femtobase::stored::collisionId, col.globalIndex(), cache); + auto v0Slice = v0Partition->sliceByCached(o2::aod::femtobase::stored::collisionId, col.globalIndex(), cache); + if (trackSlice.size() == 0 || v0Slice.size() == 0) { + return; + } + mColHistManager.fill(col); + mCprSe.setMagField(col.magField()); + pairprocesshelpers::processSameEvent(trackSlice, v0Slice, trackTable, mTrackHistManager, mCascadeHistManager, mPairHistManagerSe, mCprSe, mPc); + } + + template + void processMixedEvent(T1 const& cols, T2& trackTable, T3& trackPartition, T4& v0Partition, T5& cache, T6& binsVtxMult, T7& binsVtxCent, T8& binsVtxMultCent) + { + switch (mMixingPolicy) { + case static_cast(pairhistmanager::kVtxMult): + pairprocesshelpers::processMixedEvent(cols, trackPartition, v0Partition, trackTable, cache, binsVtxMult, mMixingDepth, mPairHistManagerMe, mCprMe, mPc); + break; + case static_cast(pairhistmanager::kVtxCent): + pairprocesshelpers::processMixedEvent(cols, trackPartition, v0Partition, trackTable, cache, binsVtxCent, mMixingDepth, mPairHistManagerMe, mCprMe, mPc); + break; + case static_cast(pairhistmanager::kVtxMultCent): + pairprocesshelpers::processMixedEvent(cols, trackPartition, v0Partition, trackTable, cache, binsVtxMultCent, mMixingDepth, mPairHistManagerMe, mCprMe, mPc); + break; + default: + LOG(fatal) << "Invalid binning policiy specifed. Breaking..."; + } + } + + private: + colhistmanager::CollisionHistManager mColHistManager; + trackhistmanager::TrackHistManager mTrackHistManager; + cascadehistmanager::CascadeHistManager mCascadeHistManager; + pairhistmanager::PairHistManager mPairHistManagerSe; + pairhistmanager::PairHistManager mPairHistManagerMe; + closepairrejection::ClosePairRejectionTrackCascade mCprSe; + closepairrejection::ClosePairRejectionTrackCascade mCprMe; + paircleaner::TrackCascadePairCleaner mPc; + pairhistmanager::MixingPoliciy mMixingPolicy = pairhistmanager::MixingPoliciy::kVtxMult; + int mMixingDepth = 5; +}; + } // namespace pairbuilder } // namespace o2::analysis::femto diff --git a/PWGCF/Femto/Core/pairCleaner.h b/PWGCF/Femto/Core/pairCleaner.h index 81e0918552b..7a72b187d6a 100644 --- a/PWGCF/Femto/Core/pairCleaner.h +++ b/PWGCF/Femto/Core/pairCleaner.h @@ -46,7 +46,7 @@ class TrackTrackPairCleaner : public BasePairCleaner } }; -class TrackV0PairCleaner : public BasePairCleaner +class TrackV0PairCleaner : public BasePairCleaner // also works for particles decaying into a positive and negative daughter, like resonances { public: TrackV0PairCleaner() = default; @@ -55,7 +55,7 @@ class TrackV0PairCleaner : public BasePairCleaner { auto posDaughter = v0.template posDau_as(); auto negDaughter = v0.template negDau_as(); - return this->isCleanTrackPair(posDaughter, track) && this->isCleanTrackPair(negDaughter, track); + return (this->isCleanTrackPair(posDaughter, track) && this->isCleanTrackPair(negDaughter, track)); } }; @@ -70,6 +70,20 @@ class TrackKinkPairCleaner : public BasePairCleaner return this->isCleanTrackPair(chaDaughter, track); } }; + +class TrackCascadePairCleaner : public BasePairCleaner +{ + public: + TrackCascadePairCleaner() = default; + template + bool isCleanPair(const T1& track, const T2& cascade, const T3& /*trackTable */) const + { + auto bachelor = cascade.template bachelor_as(); + auto posDaughter = cascade.template posDau_as(); + auto negDaughter = cascade.template negDau_as(); + return (this->isCleanTrackPair(bachelor, track) && this->isCleanTrackPair(posDaughter, track) && this->isCleanTrackPair(negDaughter, track)); + } +}; } // namespace paircleaner } // namespace o2::analysis::femto diff --git a/PWGCF/Femto/Core/pairHistManager.h b/PWGCF/Femto/Core/pairHistManager.h index 5f6d8bbdf9b..8b5856ad208 100644 --- a/PWGCF/Femto/Core/pairHistManager.h +++ b/PWGCF/Femto/Core/pairHistManager.h @@ -121,6 +121,12 @@ constexpr char PrefixTrackTrackMe[] = "TrackTrack/ME/"; constexpr char PrefixTrackV0Se[] = "TrackV0/SE/"; constexpr char PrefixTrackV0Me[] = "TrackV0/ME/"; +constexpr char PrefixTrackResonanceSe[] = "TrackResonance/SE/"; +constexpr char PrefixTrackResonanceMe[] = "TrackResonance/ME/"; + +constexpr char PrefixTrackCascadeSe[] = "TrackCascade/SE/"; +constexpr char PrefixTrackCascadeMe[] = "TrackCascade/ME/"; + constexpr char PrefixTrackKinkSe[] = "TrackKink/SE/"; constexpr char PrefixTrackKinkMe[] = "TrackKink/ME/"; @@ -166,8 +172,10 @@ class PairHistManager } void setCharge(int chargeParticle1, int chargeParticle2) { - mAbsCharge1 = std::fabs(chargeParticle1); - mAbsCharge1 = std::fabs(chargeParticle2); + // the pt stored is actually pt/z, so in case of particles with z > 1, we have to rescale the pt (this is so far only for He3 the case) + // similarly, for neutral particles, no reason to rescale so we just set absolute charge to 1 + mAbsCharge1 = std::abs(chargeParticle1 == 0 ? 1 : chargeParticle1); + mAbsCharge2 = std::abs(chargeParticle2 == 0 ? 1 : chargeParticle2); } template diff --git a/PWGCF/Femto/Core/partitions.h b/PWGCF/Femto/Core/partitions.h index 4b4943bed44..7cc40b5ffdf 100644 --- a/PWGCF/Femto/Core/partitions.h +++ b/PWGCF/Femto/Core/partitions.h @@ -26,16 +26,16 @@ ncheckbit(femtocollisions::collisionMask, selection.collisionMask) // standard track partition -#define MAKE_TRACK_PARTITION(selection) \ - ifnode(selection.sign.node() > 0, femtobase::stored::signedPt > 0.f, femtobase::stored::signedPt < 0.f) && \ - (nabs(femtobase::stored::signedPt) > selection.ptMin) && \ - (nabs(femtobase::stored::signedPt) < selection.ptMax) && \ - (femtobase::stored::eta > selection.etaMin) && \ - (femtobase::stored::eta < selection.etaMax) && \ - (femtobase::stored::phi > selection.phiMin) && \ - (femtobase::stored::phi < selection.phiMax) && \ - ifnode(nabs(femtobase::stored::signedPt) * (nexp(femtobase::stored::eta) + nexp(-1.f * femtobase::stored::eta)) / 2.f <= selection.pidThres, /* o2-linter: disable=magic-number (formula for cosh) */ \ - ncheckbit(femtotracks::trackMask, selection.maskLowMomentum), \ +#define MAKE_TRACK_PARTITION(selection) \ + ifnode(selection.charge.node() > 0, femtobase::stored::signedPt > 0.f, femtobase::stored::signedPt < 0.f) && \ + (nabs(selection.charge.node() * femtobase::stored::signedPt) > selection.ptMin) && \ + (nabs(selection.charge.node() * femtobase::stored::signedPt) < selection.ptMax) && \ + (femtobase::stored::eta > selection.etaMin) && \ + (femtobase::stored::eta < selection.etaMax) && \ + (femtobase::stored::phi > selection.phiMin) && \ + (femtobase::stored::phi < selection.phiMax) && \ + ifnode(nabs(selection.charge.node() * femtobase::stored::signedPt) * (nexp(femtobase::stored::eta) + nexp(-1.f * femtobase::stored::eta)) / (2.f) <= selection.pidThres, \ + ncheckbit(femtotracks::trackMask, selection.maskLowMomentum), \ ncheckbit(femtotracks::trackMask, selection.maskHighMomentum)) // partition for phis and rhos, i.e. resonance that are their own antiparticle @@ -55,7 +55,7 @@ ncheckbit(femtotwotrackresonances::mask, selection.negDauMaskAboveThres), \ ncheckbit(femtotwotrackresonances::mask, selection.negDauMaskBelowThres)) -// partition for kstars, they have distince antiparticle +// partition for kstars, they have distinct antiparticle #define MAKE_RESONANCE_1_PARTITON(selection) \ ifnode(selection.sign.node() > 0, femtobase::stored::signedPt > 0.f, femtobase::stored::signedPt < 0.f) && \ (nabs(femtobase::stored::signedPt) > selection.ptMin) && \ diff --git a/PWGCF/Femto/Core/trackBuilder.h b/PWGCF/Femto/Core/trackBuilder.h index d8e1f3251dd..e179e520c29 100644 --- a/PWGCF/Femto/Core/trackBuilder.h +++ b/PWGCF/Femto/Core/trackBuilder.h @@ -56,6 +56,7 @@ struct ConfTrackBits : o2::framework::ConfigurableGroup { // track quality cuts o2::framework::Configurable> tpcClustersMin{"tpcClustersMin", {90.f}, "Minimum number of clusters in TPC"}; o2::framework::Configurable> tpcCrossedRowsMin{"tpcCrossedRowsMin", {80.f}, "Minimum number of crossed rows in TPC"}; + o2::framework::Configurable> tpcClustersOverCrossedRows{"tpcClustersOverCrossedRows", {0.83f}, "Minimum fraction of clusters over crossed rows in TPC"}; o2::framework::Configurable> tpcSharedClustersMax{"tpcSharedClustersMax", {160.f}, "Maximum number of shared clusters in TPC"}; o2::framework::Configurable> tpcSharedClusterFractionMax{"tpcSharedClusterFractionMax", {1.f}, "Maximum fraction of shared clusters in TPC"}; o2::framework::Configurable> itsClustersMin{"itsClustersMin", {5.f}, "Minimum number of clusters in ITS"}; @@ -117,8 +118,7 @@ struct ConfTrackSelection : public o2::framework::ConfigurableGroup { std::string prefix = Prefix; // Unique prefix based on the template argument // configuration parameters o2::framework::Configurable pdgCode{"pdgCode", 2212, "Track PDG code"}; - o2::framework::Configurable sign{"sign", 1, "Sign of the track (1 for positive tracks and -1 for negative tracks)"}; - o2::framework::Configurable absCharge{"absCharge", 1, "Absolute charge of the track (keep 1 for all tracks, except for He, it should be 2)"}; + o2::framework::Configurable charge{"charge", 1, "Charge of the track (use +/-1 for positive/negative tracks, except He3 needs +/-2)"}; // filters for kinematics o2::framework::Configurable ptMin{"ptMin", 0.2f, "Minimum pT (GeV/c)"}; o2::framework::Configurable ptMax{"ptMax", 6.f, "Maximum pT (GeV/c)"}; @@ -146,14 +146,15 @@ using ConfTrackSelection3 = ConfTrackSelection; /// enum for all track selections enum TrackSels { // track quality cuts - kTPCnClsMin, ///< Min. number of TPC clusters - kTPCcRowsMin, ///< Min. number of crossed TPC rows - kTPCsClsMax, ///< Max. number of shared TPC clusters - kTPCsClsFracMax, ///< Max. fractions of shared TPC clusters - kITSnClsMin, ///< Min. number of ITS clusters - kITSnClsIbMin, ///< Min. number of ITS clusters in the inner barrel - kDCAxyMax, ///< Max. |DCA_xy| (cm) as a function of pT - kDCAzMax, ///< Max. |DCA_z| (cm) as a function of pT + kTPCnClsMin, ///< Min. number of TPC clusters + kTPCcRowsMin, ///< Min. number of crossed TPC rows + kTPCnClsOvercRowsMin, ///< Min. fraction of TPC clusters of TPC crossed rows + kTPCsClsMax, ///< Max. number of shared TPC clusters + kTPCsClsFracMax, ///< Max. fractions of shared TPC clusters + kITSnClsMin, ///< Min. number of ITS clusters + kITSnClsIbMin, ///< Min. number of ITS clusters in the inner barrel + kDCAxyMax, ///< Max. |DCA_xy| (cm) as a function of pT + kDCAzMax, ///< Max. |DCA_z| (cm) as a function of pT /// track pid cuts kItsElectron, ///< ITS Electon PID @@ -203,6 +204,8 @@ const char trackSelsName[] = "Track Selection Object"; const std::unordered_map trackSelsToString = { {kTPCnClsMin, "Min. number of TPC clusters"}, {kTPCcRowsMin, "Min. number of crossed TPC rows"}, + {kTPCnClsOvercRowsMin, "Min. fraction of TPC clusters over TPC crossed rows"}, + {kTPCsClsMax, "Max. number of shared TPC clusters"}, {kTPCsClsMax, "Max. number of shared TPC clusters"}, {kTPCsClsFracMax, "Max. fractions of shared TPC clusters"}, {kITSnClsMin, "Min. number of ITS clusters"}, @@ -272,6 +275,7 @@ class TrackSelection : public BaseSelectionaddSelection(config.tpcClustersMin.value, kTPCnClsMin, limits::kLowerLimit, true, true); this->addSelection(config.tpcCrossedRowsMin.value, kTPCcRowsMin, limits::kLowerLimit, true, true); + this->addSelection(config.tpcClustersOverCrossedRows.value, kTPCnClsOvercRowsMin, limits::kLowerLimit, true, true); this->addSelection(config.tpcSharedClustersMax.value, kTPCsClsMax, limits::kUpperLimit, true, true); this->addSelection(config.tpcSharedClusterFractionMax.value, kTPCsClsFracMax, limits::kUpperLimit, true, true); this->addSelection(config.itsClustersMin.value, kITSnClsMin, limits::kLowerLimit, true, true); @@ -342,6 +346,7 @@ class TrackSelection : public BaseSelectionreset(); this->evaluateObservable(kTPCnClsMin, Track.tpcNClsFound()); this->evaluateObservable(kTPCcRowsMin, Track.tpcNClsCrossedRows()); + this->evaluateObservable(kTPCnClsOvercRowsMin, static_cast(Track.tpcNClsFound()) / static_cast(Track.tpcNClsCrossedRows())); this->evaluateObservable(kTPCsClsMax, Track.tpcNClsShared()); this->evaluateObservable(kTPCsClsFracMax, static_cast(Track.tpcNClsShared()) / static_cast(Track.tpcNClsFound())); this->evaluateObservable(kITSnClsMin, Track.itsNCls()); diff --git a/PWGCF/Femto/Core/trackHistManager.h b/PWGCF/Femto/Core/trackHistManager.h index 197c47983cc..f77bf9a029f 100644 --- a/PWGCF/Femto/Core/trackHistManager.h +++ b/PWGCF/Femto/Core/trackHistManager.h @@ -48,6 +48,7 @@ enum TrackHist { kItsClusterIb, kTpcCrossedRows, kTpcCluster, + kTpcClusterOverCrossedRows, kTpcClusterShared, kTpcClusterFractionShared, // kDcaxy, @@ -59,7 +60,11 @@ enum TrackHist { kPhiVsEta, kPtVsItsCluster, kPtVsTpcCluster, + kPtVsTpcCrossedRows, + kPtVsTpcClusterOverCrossedRows, kPtVsTpcClusterShared, + kPtVsTpcClusterFractionShared, + kTpcClusterVsTpcCrossedRows, kTpcClusterVsTpcClusterShared, kPtVsDcaxy, kPtVsDcaz, @@ -151,6 +156,7 @@ struct ConfTrackQaBinning : o2::framework::ConfigurableGroup { o2::framework::ConfigurableAxis itsClusterIb{"itsClusterIb", {{4, -0.5, 3.5}}, "ITS cluster in inner barrel"}; o2::framework::ConfigurableAxis tpcCrossedRows{"tpcCrossedRows", {{161, -0.5, 160.5}}, "TPC cluster"}; o2::framework::ConfigurableAxis tpcCluster{"tpcCluster", {{161, -0.5, 160.5}}, "TPC cluster"}; + o2::framework::ConfigurableAxis tpcClusterOverCrossedRows{"tpcClusterOverCrossedRows", {{75, 0, 1.5}}, "TPC cluster over TPC crossed rows"}; o2::framework::ConfigurableAxis tpcClusterShared{"tpcClusterShared", {{161, -0.5, 160.5}}, "TPC cluster shared"}; o2::framework::ConfigurableAxis tpcClusterFractionShared{"tpcClusterFractionShared", {{60, 0, 1.2}}, "TPC cluster fraction shared"}; o2::framework::ConfigurableAxis dcaXy{"dcaXy", {{300, -0.3, 0.3}}, "DCA_xy"}; @@ -231,6 +237,7 @@ constexpr std::array, kTrackHistLast> HistTable {kItsClusterIb, o2::framework::kTH1F, "hItsClusterIb", "ITS cluster in inner barrel; ITS IB cluster; Entries"}, {kTpcCrossedRows, o2::framework::kTH1F, "hTpcCrossedRows", "TPC crossed rows; TPC crossed rows; Entries"}, {kTpcCluster, o2::framework::kTH1F, "hTpcCluster", "TPC cluster found; TPC cluster found; Entries"}, + {kTpcClusterOverCrossedRows, o2::framework::kTH1F, "hTpcClusterOverCrossedRows", "TPC cluster found over TPC crossed rows; TPC cluster found / Tpc crossed rows; Entries"}, {kTpcClusterShared, o2::framework::kTH1F, "hTpcClusterShared", "TPC cluster shared; TPC cluster shared ; Entries"}, {kTpcClusterFractionShared, o2::framework::kTH1F, "hTpcClusterFractionShared", "TPC cluster fraction shared; TPC cluster found / TPC cluster shared ; Entries"}, {kPtVsEta, o2::framework::kTH2F, "hPtVsEta", "p_{T} vs #eta; p_{T} (GeV/#it{c}) ; #eta"}, @@ -238,7 +245,11 @@ constexpr std::array, kTrackHistLast> HistTable {kPhiVsEta, o2::framework::kTH2F, "hPhiVsEta", "#varphi vs #eta; #varphi ; #eta"}, {kPtVsItsCluster, o2::framework::kTH2F, "hPtVsItsCluster", "p_{T} vs ITS cluster; p_{T} (GeV/#it{c}) ; ITS cluster"}, {kPtVsTpcCluster, o2::framework::kTH2F, "hPtVsTpcCluster", "p_{T} vs TPC cluster found; p_{T} (GeV/#it{c}) ; TPC cluster found"}, + {kPtVsTpcCrossedRows, o2::framework::kTH2F, "hPtVsTpcCrossedRows", "p_{T} vs TPC crossed rows; p_{T} (GeV/#it{c}) ; TPC crossed rows"}, + {kPtVsTpcClusterOverCrossedRows, o2::framework::kTH2F, "hPtVsTpcClusterOverCrossedRows", "p_{T} vs TPC cluster found over crossed rows; p_{T} (GeV/#it{c}) ; TPC cluster found / TPC crossed rows"}, {kPtVsTpcClusterShared, o2::framework::kTH2F, "hPtVsTpcClusterShared", "p_{T} vs TPC cluster shared; p_{T} (GeV/#it{c}) ; TPC cluster shared"}, + {kPtVsTpcClusterFractionShared, o2::framework::kTH2F, "hPtVsTpcClusterSharedFraction", "p_{T} vs TPC cluster shared over TPC cluster found; p_{T} (GeV/#it{c}) ; TPC cluster shared / TPC cluster found"}, + {kTpcClusterVsTpcCrossedRows, o2::framework::kTH2F, "hTpcClusterVsTpcCrossedRows", "TPC cluster found vs TPC crossed rows; TPC cluster found; TPC crossed rows"}, {kTpcClusterVsTpcClusterShared, o2::framework::kTH2F, "hTpcClusterVsTpcClusterShared", "TPC cluster found vs TPC cluster shared; TPC cluster found; TPC cluster shared"}, {kPtVsDcaxy, o2::framework::kTH2F, "hPtVsDcaxy", "p_{T} vs DCA_{XY}; p_{T} (GeV/#it{c}); DCA_{XY} (cm)"}, {kPtVsDcaz, o2::framework::kTH2F, "hPtVsDcaz", "p_{T} vs DCA_{Z}; p_{T} (GeV/#it{c}); DCA_{Z} (cm)"}, @@ -308,10 +319,15 @@ auto makeTrackQaHistSpecMap(const T1& confBinningAnalysis, const T2 confiBinning {kPhiVsEta, {confBinningAnalysis.phi, confBinningAnalysis.eta}}, {kPtVsItsCluster, {confBinningAnalysis.pt, confiBinningQa.itsCluster}}, {kPtVsTpcCluster, {confBinningAnalysis.pt, confiBinningQa.tpcCluster}}, + {kPtVsTpcCrossedRows, {confBinningAnalysis.pt, confiBinningQa.tpcCrossedRows}}, + {kPtVsTpcClusterOverCrossedRows, {confBinningAnalysis.pt, confiBinningQa.tpcClusterOverCrossedRows}}, {kPtVsTpcClusterShared, {confBinningAnalysis.pt, confiBinningQa.tpcClusterShared}}, + {kPtVsTpcClusterFractionShared, {confBinningAnalysis.pt, confiBinningQa.tpcClusterFractionShared}}, + {kTpcClusterVsTpcCrossedRows, {confiBinningQa.tpcCluster, confiBinningQa.tpcCrossedRows}}, {kTpcClusterVsTpcClusterShared, {confiBinningQa.tpcCluster, confiBinningQa.tpcClusterShared}}, {kTpcCrossedRows, {confiBinningQa.tpcCrossedRows}}, {kTpcCluster, {confiBinningQa.tpcCluster}}, + {kTpcClusterOverCrossedRows, {confiBinningQa.tpcClusterOverCrossedRows}}, {kTpcClusterShared, {confiBinningQa.tpcClusterShared}}, {kTpcClusterFractionShared, {confiBinningQa.tpcClusterFractionShared}}, {kPtVsDcaxy, {confBinningAnalysis.pt, confiBinningQa.dcaXy}}, @@ -400,7 +416,7 @@ class TrackHistManager void init(o2::framework::HistogramRegistry* registry, std::map> Specs, float charge = 1, int momentumTypeForPid = 0) { mHistogramRegistry = registry; - mAbsCharge = std::fabs(charge); + mAbsCharge = std::fabs(charge); // stored absolute charge of the track to scale the momentum in case of Z!=1 (case only for He3) if constexpr (isFlagSet(mode, modes::Mode::kAnalysis)) { std::string analysisDir = std::string(prefix) + std::string(AnalysisDir); @@ -419,6 +435,7 @@ class TrackHistManager mHistogramRegistry->add(qaDir + GetHistNamev2(kItsClusterIb, HistTable), GetHistDesc(kItsClusterIb, HistTable), GetHistType(kItsClusterIb, HistTable), {Specs[kItsClusterIb]}); mHistogramRegistry->add(qaDir + GetHistNamev2(kTpcCrossedRows, HistTable), GetHistDesc(kTpcCrossedRows, HistTable), GetHistType(kTpcCrossedRows, HistTable), {Specs[kTpcCrossedRows]}); mHistogramRegistry->add(qaDir + GetHistNamev2(kTpcCluster, HistTable), GetHistDesc(kTpcCluster, HistTable), GetHistType(kTpcCluster, HistTable), {Specs[kTpcCluster]}); + mHistogramRegistry->add(qaDir + GetHistNamev2(kTpcClusterOverCrossedRows, HistTable), GetHistDesc(kTpcClusterOverCrossedRows, HistTable), GetHistType(kTpcClusterOverCrossedRows, HistTable), {Specs[kTpcClusterOverCrossedRows]}); mHistogramRegistry->add(qaDir + GetHistNamev2(kTpcClusterShared, HistTable), GetHistDesc(kTpcClusterShared, HistTable), GetHistType(kTpcClusterShared, HistTable), {Specs[kTpcClusterShared]}); mHistogramRegistry->add(qaDir + GetHistNamev2(kTpcClusterFractionShared, HistTable), GetHistDesc(kTpcClusterFractionShared, HistTable), GetHistType(kTpcClusterFractionShared, HistTable), {Specs[kTpcClusterFractionShared]}); @@ -428,7 +445,11 @@ class TrackHistManager mHistogramRegistry->add(qaDir + GetHistNamev2(kPhiVsEta, HistTable), GetHistDesc(kPhiVsEta, HistTable), GetHistType(kPhiVsEta, HistTable), {Specs[kPhiVsEta]}); mHistogramRegistry->add(qaDir + GetHistNamev2(kPtVsItsCluster, HistTable), GetHistDesc(kPtVsItsCluster, HistTable), GetHistType(kPtVsItsCluster, HistTable), {Specs[kPtVsItsCluster]}); mHistogramRegistry->add(qaDir + GetHistNamev2(kPtVsTpcCluster, HistTable), GetHistDesc(kPtVsTpcCluster, HistTable), GetHistType(kPtVsTpcCluster, HistTable), {Specs[kPtVsTpcCluster]}); + mHistogramRegistry->add(qaDir + GetHistNamev2(kPtVsTpcCrossedRows, HistTable), GetHistDesc(kPtVsTpcCrossedRows, HistTable), GetHistType(kPtVsTpcCrossedRows, HistTable), {Specs[kPtVsTpcCrossedRows]}); + mHistogramRegistry->add(qaDir + GetHistNamev2(kPtVsTpcClusterOverCrossedRows, HistTable), GetHistDesc(kPtVsTpcClusterOverCrossedRows, HistTable), GetHistType(kPtVsTpcClusterOverCrossedRows, HistTable), {Specs[kPtVsTpcClusterOverCrossedRows]}); mHistogramRegistry->add(qaDir + GetHistNamev2(kPtVsTpcClusterShared, HistTable), GetHistDesc(kPtVsTpcClusterShared, HistTable), GetHistType(kPtVsTpcClusterShared, HistTable), {Specs[kPtVsTpcClusterShared]}); + mHistogramRegistry->add(qaDir + GetHistNamev2(kPtVsTpcClusterFractionShared, HistTable), GetHistDesc(kPtVsTpcClusterFractionShared, HistTable), GetHistType(kPtVsTpcClusterFractionShared, HistTable), {Specs[kPtVsTpcClusterFractionShared]}); + mHistogramRegistry->add(qaDir + GetHistNamev2(kTpcClusterVsTpcCrossedRows, HistTable), GetHistDesc(kTpcClusterVsTpcCrossedRows, HistTable), GetHistType(kTpcClusterVsTpcCrossedRows, HistTable), {Specs[kTpcClusterVsTpcCrossedRows]}); mHistogramRegistry->add(qaDir + GetHistNamev2(kTpcClusterVsTpcClusterShared, HistTable), GetHistDesc(kTpcClusterVsTpcClusterShared, HistTable), GetHistType(kTpcClusterVsTpcClusterShared, HistTable), {Specs[kTpcClusterVsTpcClusterShared]}); // dca @@ -501,6 +522,7 @@ class TrackHistManager mHistogramRegistry->fill(HIST(prefix) + HIST(QaDir) + HIST(GetHistName(kItsClusterIb, HistTable)), static_cast(track.itsNClsInnerBarrel())); mHistogramRegistry->fill(HIST(prefix) + HIST(QaDir) + HIST(GetHistName(kTpcCrossedRows, HistTable)), static_cast(track.tpcNClsCrossedRows())); mHistogramRegistry->fill(HIST(prefix) + HIST(QaDir) + HIST(GetHistName(kTpcCluster, HistTable)), static_cast(track.tpcNClsFound())); + mHistogramRegistry->fill(HIST(prefix) + HIST(QaDir) + HIST(GetHistName(kTpcClusterOverCrossedRows, HistTable)), static_cast(track.tpcNClsFound()) / static_cast(track.tpcNClsCrossedRows())); mHistogramRegistry->fill(HIST(prefix) + HIST(QaDir) + HIST(GetHistName(kTpcClusterShared, HistTable)), static_cast(track.tpcNClsShared())); mHistogramRegistry->fill(HIST(prefix) + HIST(QaDir) + HIST(GetHistName(kTpcClusterFractionShared, HistTable)), track.tpcSharedOverFound()); @@ -509,7 +531,11 @@ class TrackHistManager mHistogramRegistry->fill(HIST(prefix) + HIST(QaDir) + HIST(GetHistName(kPhiVsEta, HistTable)), track.phi(), track.eta()); mHistogramRegistry->fill(HIST(prefix) + HIST(QaDir) + HIST(GetHistName(kPtVsItsCluster, HistTable)), mAbsCharge * track.pt(), static_cast(track.itsNCls())); mHistogramRegistry->fill(HIST(prefix) + HIST(QaDir) + HIST(GetHistName(kPtVsTpcCluster, HistTable)), mAbsCharge * track.pt(), static_cast(track.tpcNClsFound())); + mHistogramRegistry->fill(HIST(prefix) + HIST(QaDir) + HIST(GetHistName(kPtVsTpcCrossedRows, HistTable)), mAbsCharge * track.pt(), static_cast(track.tpcNClsCrossedRows())); + mHistogramRegistry->fill(HIST(prefix) + HIST(QaDir) + HIST(GetHistName(kPtVsTpcClusterOverCrossedRows, HistTable)), mAbsCharge * track.pt(), static_cast(track.tpcNClsFound()) / static_cast(track.tpcNClsCrossedRows())); mHistogramRegistry->fill(HIST(prefix) + HIST(QaDir) + HIST(GetHistName(kPtVsTpcClusterShared, HistTable)), mAbsCharge * track.pt(), static_cast(track.tpcNClsShared())); + mHistogramRegistry->fill(HIST(prefix) + HIST(QaDir) + HIST(GetHistName(kPtVsTpcClusterFractionShared, HistTable)), mAbsCharge * track.pt(), static_cast(track.tpcNClsShared()) / static_cast(track.tpcNClsFound())); + mHistogramRegistry->fill(HIST(prefix) + HIST(QaDir) + HIST(GetHistName(kTpcClusterVsTpcCrossedRows, HistTable)), static_cast(track.tpcNClsFound()), static_cast(track.tpcNClsCrossedRows())); mHistogramRegistry->fill(HIST(prefix) + HIST(QaDir) + HIST(GetHistName(kTpcClusterVsTpcClusterShared, HistTable)), static_cast(track.tpcNClsFound()), static_cast(track.tpcNClsShared())); mHistogramRegistry->fill(HIST(prefix) + HIST(QaDir) + HIST(GetHistName(kPtVsDcaxy, HistTable)), mAbsCharge * track.pt(), track.dcaXY()); diff --git a/PWGCF/Femto/Core/twoTrackResonanceBuilder.h b/PWGCF/Femto/Core/twoTrackResonanceBuilder.h index c1f944ed51d..e9bbeb0c245 100644 --- a/PWGCF/Femto/Core/twoTrackResonanceBuilder.h +++ b/PWGCF/Femto/Core/twoTrackResonanceBuilder.h @@ -127,7 +127,8 @@ struct ConfKstar0Bits : o2::framework::ConfigurableGroup { #undef TWOTRACKRESONANCE_KAONPID_BITS #undef TWOTRACKRESONANCE_PIONPID_BITS -#define TWOTRACKRESONANCE_DEFAULT_SELECTION(defaultMassMin, defaultMassMax) \ +#define TWOTRACKRESONANCE_DEFAULT_SELECTION(defaultPdgCode, defaultMassMin, defaultMassMax) \ + o2::framework::Configurable pdgCode{"pdgCode", defaultPdgCode, "Resonance PDG code"}; \ o2::framework::Configurable ptMin{"ptMin", 0.f, "Minimum pT"}; \ o2::framework::Configurable ptMax{"ptMax", 6.f, "Maximum pT"}; \ o2::framework::Configurable etaMin{"etaMin", -0.9f, "Minimum eta"}; \ @@ -145,18 +146,18 @@ struct ConfKstar0Bits : o2::framework::ConfigurableGroup { struct ConfPhiSelection : o2::framework::ConfigurableGroup { std::string prefix = std::string("PhiSelection"); - TWOTRACKRESONANCE_DEFAULT_SELECTION(0.95f, 1.05f) + TWOTRACKRESONANCE_DEFAULT_SELECTION(333, 0.95f, 1.05f) }; struct ConfRho0Selection : o2::framework::ConfigurableGroup { - std::string prefix = std::string("RhoSelection"); - TWOTRACKRESONANCE_DEFAULT_SELECTION(0.7f, 0.84f) + std::string prefix = std::string("Rho0Selection"); + TWOTRACKRESONANCE_DEFAULT_SELECTION(113, 0.7f, 0.84f) }; struct ConfKstar0Selection : o2::framework::ConfigurableGroup { std::string prefix = std::string("Kstar0Selection"); o2::framework::Configurable sign{"sign", 1, "Sign (+1 for Kstar0 and -1 for Kstar0Bar) "}; - TWOTRACKRESONANCE_DEFAULT_SELECTION(0.8f, 1.0f) + TWOTRACKRESONANCE_DEFAULT_SELECTION(313, 0.8f, 1.0f) }; #undef TWOTRACKRESONANCE_DEFAULT_SELECTION diff --git a/PWGCF/Femto/Core/twoTrackResonanceHistManager.h b/PWGCF/Femto/Core/twoTrackResonanceHistManager.h index b6e429b434a..1df3af003a4 100644 --- a/PWGCF/Femto/Core/twoTrackResonanceHistManager.h +++ b/PWGCF/Femto/Core/twoTrackResonanceHistManager.h @@ -93,7 +93,7 @@ std::map> makeTwoTrackRe {kEta, {confBinningAnalysis.eta}}, {kPhi, {confBinningAnalysis.phi}}, {kMass, {confBinningAnalysis.mass}}, - {kSign, {confBinningAnalysis.sing}}}; + {kSign, {confBinningAnalysis.sign}}}; }; template diff --git a/PWGCF/Femto/DataModel/FemtoTables.h b/PWGCF/Femto/DataModel/FemtoTables.h index 9f87b6a6d24..0756e3a91e1 100644 --- a/PWGCF/Femto/DataModel/FemtoTables.h +++ b/PWGCF/Femto/DataModel/FemtoTables.h @@ -35,6 +35,7 @@ namespace o2::aod namespace femtocollisions { DECLARE_SOA_COLUMN(CollisionMask, collisionMask, femtodatatypes::CollisionMaskType); //! Bitmask for collision selections +DECLARE_SOA_COLUMN(CollisionTag, collisionTag, femtodatatypes::CollisionTagType); //! Bitmask for collision selections DECLARE_SOA_COLUMN(PosX, posX, float); //! x coordinate of vertex DECLARE_SOA_COLUMN(PosY, posY, float); //! y coordinate of vertex diff --git a/PWGCF/Femto/TableProducer/femtoProducer.cxx b/PWGCF/Femto/TableProducer/femtoProducer.cxx index c5140fb5855..54b42aa8693 100644 --- a/PWGCF/Femto/TableProducer/femtoProducer.cxx +++ b/PWGCF/Femto/TableProducer/femtoProducer.cxx @@ -91,6 +91,7 @@ struct FemtoProducer { collisionbuilder::ConfCollisionTables confCollisionTables; collisionbuilder::ConfCollisionFilters confCollisionFilters; collisionbuilder::ConfCollisionBits confCollisionBits; + collisionbuilder::ConfCollisionRctFlags confCollisionRctFlags; collisionbuilder::ConfCollisionTriggers confCollisionTriggers; collisionbuilder::CollisionBuilder collisionBuilder; @@ -192,7 +193,7 @@ struct FemtoProducer { ccdb->setCreatedNotAfter(now); // collision selection - collisionBuilder.init(confCollisionFilters, confCollisionBits, confCollisionTables, confCollisionTriggers, context); + collisionBuilder.init(confCollisionFilters, confCollisionBits, confCollisionRctFlags, confCollisionTriggers, confCollisionTables, context); // configure track builder trackBuilder.init(confTrackBits, confTrackFilters, confTrackTables, context); diff --git a/PWGCF/Femto/Tasks/CMakeLists.txt b/PWGCF/Femto/Tasks/CMakeLists.txt index 1763a60b7bc..8fdc9dacae4 100644 --- a/PWGCF/Femto/Tasks/CMakeLists.txt +++ b/PWGCF/Femto/Tasks/CMakeLists.txt @@ -44,6 +44,16 @@ o2physics_add_dpl_workflow(femto-pair-track-v0 PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(femto-pair-track-two-track-resonance + SOURCES femtoPairTrackTwoTrackResonance.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore + COMPONENT_NAME Analysis) + +o2physics_add_dpl_workflow(femto-pair-track-cascade + SOURCES femtoPairTrackCascade.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(femto-pair-track-kink SOURCES femtoPairTrackKink.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore diff --git a/PWGCF/Femto/Tasks/femtoPairTrackCascade.cxx b/PWGCF/Femto/Tasks/femtoPairTrackCascade.cxx new file mode 100644 index 00000000000..7621d88fc65 --- /dev/null +++ b/PWGCF/Femto/Tasks/femtoPairTrackCascade.cxx @@ -0,0 +1,202 @@ +// Copyright 2019-2025 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +/// \file femtoPairTrackCascade.cxx +/// \brief Tasks that computes correlation between tracks and cascades +/// \author Anton Riedel, TU München, anton.riedel@cern.ch + +#include "PWGCF/Femto/Core/cascadeBuilder.h" +#include "PWGCF/Femto/Core/cascadeHistManager.h" +#include "PWGCF/Femto/Core/closePairRejection.h" +#include "PWGCF/Femto/Core/collisionBuilder.h" +#include "PWGCF/Femto/Core/collisionHistManager.h" +#include "PWGCF/Femto/Core/modes.h" +#include "PWGCF/Femto/Core/pairBuilder.h" +#include "PWGCF/Femto/Core/pairHistManager.h" +#include "PWGCF/Femto/Core/partitions.h" +#include "PWGCF/Femto/Core/trackBuilder.h" +#include "PWGCF/Femto/Core/trackHistManager.h" +#include "PWGCF/Femto/DataModel/FemtoTables.h" + +#include "Framework/ASoA.h" +#include "Framework/AnalysisTask.h" +#include "Framework/Configurable.h" +#include "Framework/Expressions.h" +#include "Framework/HistogramRegistry.h" +#include "Framework/runDataProcessing.h" + +#include +#include + +using namespace o2; +using namespace o2::aod; +using namespace o2::soa; +using namespace o2::framework; +using namespace o2::framework::expressions; +using namespace o2::analysis::femto; + +struct FemtoPairTrackCascade { + + // setup tables + using Collisions = Join; + using Collision = Collisions::iterator; + + using FilteredCollisions = o2::soa::Filtered; + using FilteredCollision = FilteredCollisions::iterator; + + using Tracks = o2::soa::Join; + using Xis = o2::soa::Join; + using Omegas = o2::soa::Join; + + SliceCache cache; + + // setup collisions + collisionbuilder::ConfCollisionSelection collisionSelection; + Filter collisionFilter = MAKE_COLLISION_FILTER(collisionSelection); + colhistmanager::ConfCollisionBinning confCollisionBinning; + + // setup tracks + trackbuilder::ConfTrackSelection1 trackSelection; + trackhistmanager::ConfTrackBinning1 confTrackBinning; + Partition trackPartition = MAKE_TRACK_PARTITION(trackSelection); + Preslice perColTracks = aod::femtobase::stored::collisionId; + + // setup for daughters/bachelor + trackhistmanager::ConfCascadePosDauBinning confPosDauBinning; + trackhistmanager::ConfCascadeNegDauBinning confNegDauBinning; + trackhistmanager::ConfCascadeBachelorBinning confBachelorBinning; + + // setup xis + cascadebuilder::ConfXiSelection xiSelection; + cascadehistmanager::ConfXiBinning confXiBinning; + Partition xiPartition = MAKE_CASCADE_PARTITION(xiSelection); + Preslice perColXis = aod::femtobase::stored::collisionId; + + // setup omegas + cascadebuilder::ConfOmegaSelection omegaSelection; + cascadehistmanager::ConfOmegaBinning confOmegaBinning; + Partition omegaPartition = MAKE_CASCADE_PARTITION(omegaSelection); + Preslice perColOmegas = aod::femtobase::stored::collisionId; + + // setup pairs + pairhistmanager::ConfPairBinning confPairBinning; + + pairbuilder::PairTrackCascadeBuilder< + trackhistmanager::PrefixTrack1, + cascadehistmanager::PrefixXi, + trackhistmanager::PrefixCascadeBachelor, + trackhistmanager::PrefixCascadePosDaughter, + trackhistmanager::PrefixCascadeNegDaughter, + pairhistmanager::PrefixTrackCascadeSe, + pairhistmanager::PrefixTrackCascadeMe, + closepairrejection::PrefixTrackCascadeSe, + closepairrejection::PrefixTrackCascadeMe, + modes::Mode::kAnalysis, + modes::Cascade::kXi> + pairTrackXiBuilder; + + pairbuilder::PairTrackCascadeBuilder< + trackhistmanager::PrefixTrack1, + cascadehistmanager::PrefixOmega, + trackhistmanager::PrefixCascadeBachelor, + trackhistmanager::PrefixCascadePosDaughter, + trackhistmanager::PrefixCascadeNegDaughter, + pairhistmanager::PrefixTrackCascadeSe, + pairhistmanager::PrefixTrackCascadeMe, + closepairrejection::PrefixTrackCascadeSe, + closepairrejection::PrefixTrackCascadeMe, + modes::Mode::kAnalysis, + modes::Cascade::kOmega> + pairTrackOmegaBuilder; + + // setup mixing + std::vector defaultVtxBins{10, -10, 10}; + std::vector defaultMultBins{50, 0, 200}; + std::vector defaultCentBins{10, 0, 100}; + ColumnBinningPolicy mixBinsVtxMult{{defaultVtxBins, defaultMultBins}, true}; + ColumnBinningPolicy mixBinsVtxCent{{defaultVtxBins, defaultCentBins}, true}; + ColumnBinningPolicy mixBinsVtxMultCent{{defaultVtxBins, defaultMultBins, defaultCentBins}, true}; + pairhistmanager::ConfMixing confMixing; + + HistogramRegistry hRegistry{"FemtoTrackCascade", {}, OutputObjHandlingPolicy::AnalysisObject}; + + // setup cpr + closepairrejection::ConfCpr confCpr; + + void init(InitContext&) + { + + // setup columnpolicy for binning + // default values are used during instantiation, so we need to explicity update them here + mixBinsVtxMult = {{confMixing.vtxBins, confMixing.multBins.value}, true}; + mixBinsVtxCent = {{confMixing.vtxBins.value, confMixing.centBins.value}, true}; + mixBinsVtxMultCent = {{confMixing.vtxBins.value, confMixing.multBins.value, confMixing.centBins.value}, true}; + + // setup histograms + auto colHistSpec = colhistmanager::makeColHistSpecMap(confCollisionBinning); + auto trackHistSpec = trackhistmanager::makeTrackHistSpecMap(confTrackBinning); + auto bachelorHistSpec = trackhistmanager::makeTrackHistSpecMap(confBachelorBinning); + auto posDauSpec = trackhistmanager::makeTrackHistSpecMap(confPosDauBinning); + auto negDauSpec = trackhistmanager::makeTrackHistSpecMap(confNegDauBinning); + auto pairHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confTrackBinning, confXiBinning); + auto cprHistSpec = closepairrejection::makeCprHistSpecMap(confCpr); + + // setup for xis + if (doprocessXiSameEvent || doprocessXiMixedEvent) { + auto xiHistSpec = cascadehistmanager::makeCascadeHistSpecMap(confXiBinning); + auto pairTrackXiHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confTrackBinning, confXiBinning); + pairTrackXiBuilder.init(&hRegistry, trackSelection, xiSelection, confCpr, confMixing, colHistSpec, trackHistSpec, xiHistSpec, bachelorHistSpec, posDauSpec, negDauSpec, pairTrackXiHistSpec, cprHistSpec); + } + + // setup for omegas + if (doprocessOmegaSameEvent || doprocessOmegaMixedEvent) { + auto omegaHistSpec = cascadehistmanager::makeCascadeHistSpecMap(confOmegaBinning); + auto pairTrackOmegaHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confTrackBinning, confOmegaBinning); + pairTrackOmegaBuilder.init(&hRegistry, trackSelection, omegaSelection, confCpr, confMixing, colHistSpec, trackHistSpec, omegaHistSpec, bachelorHistSpec, posDauSpec, negDauSpec, pairTrackOmegaHistSpec, cprHistSpec); + } + + if (((doprocessXiSameEvent || doprocessXiMixedEvent) + (doprocessOmegaSameEvent || doprocessOmegaMixedEvent)) > 1) { + LOG(fatal) << "Can only process xi-tracks Or omega-tracks"; + } + }; + + void processXiSameEvent(FilteredCollision const& col, Tracks const& tracks, Xis const& xis) + { + pairTrackXiBuilder.processSameEvent(col, tracks, trackPartition, xis, xiPartition, cache); + } + PROCESS_SWITCH(FemtoPairTrackCascade, processXiSameEvent, "Enable processing same event processing for tracks and xis", true); + + void processXiMixedEvent(FilteredCollisions const& cols, Tracks const& tracks, Xis const& /*xis*/) + { + pairTrackXiBuilder.processMixedEvent(cols, tracks, trackPartition, xiPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + } + PROCESS_SWITCH(FemtoPairTrackCascade, processXiMixedEvent, "Enable processing mixed event processing for tracks and xis", true); + + void processOmegaSameEvent(FilteredCollision const& col, Tracks const& tracks, Omegas const& omegas) + { + pairTrackOmegaBuilder.processSameEvent(col, tracks, trackPartition, omegas, omegaPartition, cache); + } + PROCESS_SWITCH(FemtoPairTrackCascade, processOmegaSameEvent, "Enable processing same event processing for tracks and omegas", false); + + void processOmegaMixedEvent(FilteredCollisions const& cols, Tracks const& tracks, Omegas const& /*omegas*/) + { + pairTrackOmegaBuilder.processMixedEvent(cols, tracks, trackPartition, omegaPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + } + PROCESS_SWITCH(FemtoPairTrackCascade, processOmegaMixedEvent, "Enable processing mixed event processing for tracks and omegas", false); +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + WorkflowSpec workflow{ + adaptAnalysisTask(cfgc), + }; + return workflow; +} diff --git a/PWGCF/Femto/Tasks/femtoPairTrackTwoTrackResonance.cxx b/PWGCF/Femto/Tasks/femtoPairTrackTwoTrackResonance.cxx new file mode 100644 index 00000000000..f85cdfa03bb --- /dev/null +++ b/PWGCF/Femto/Tasks/femtoPairTrackTwoTrackResonance.cxx @@ -0,0 +1,239 @@ +// Copyright 2019-2025 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +/// \file femtoPairTrackTwoTrackResonance.cxx +/// \brief Tasks that computes correlation between tracks and resonances decaying into two tracks +/// \author Anton Riedel, TU München, anton.riedel@cern.ch + +#include "PWGCF/Femto/Core/closePairRejection.h" +#include "PWGCF/Femto/Core/collisionBuilder.h" +#include "PWGCF/Femto/Core/collisionHistManager.h" +#include "PWGCF/Femto/Core/modes.h" +#include "PWGCF/Femto/Core/pairBuilder.h" +#include "PWGCF/Femto/Core/pairHistManager.h" +#include "PWGCF/Femto/Core/partitions.h" +#include "PWGCF/Femto/Core/trackBuilder.h" +#include "PWGCF/Femto/Core/trackHistManager.h" +#include "PWGCF/Femto/Core/twoTrackResonanceBuilder.h" +#include "PWGCF/Femto/Core/twoTrackResonanceHistManager.h" +#include "PWGCF/Femto/DataModel/FemtoTables.h" + +#include "Framework/ASoA.h" +#include "Framework/AnalysisTask.h" +#include "Framework/Configurable.h" +#include "Framework/Expressions.h" +#include "Framework/HistogramRegistry.h" +#include "Framework/runDataProcessing.h" + +#include +#include + +using namespace o2; +using namespace o2::aod; +using namespace o2::soa; +using namespace o2::framework; +using namespace o2::framework::expressions; +using namespace o2::analysis::femto; + +struct FemtoPairTrackTwoTrackResonance { + + // setup tables + using Collisions = Join; + using Collision = Collisions::iterator; + + using FilteredCollisions = o2::soa::Filtered; + using FilteredCollision = FilteredCollisions::iterator; + + using Tracks = o2::soa::Join; + using Phis = o2::soa::Join; + using Kstar0s = o2::soa::Join; + using Rho0s = o2::soa::Join; + + SliceCache cache; + + // setup collisions + collisionbuilder::ConfCollisionSelection collisionSelection; + Filter collisionFilter = MAKE_COLLISION_FILTER(collisionSelection); + colhistmanager::ConfCollisionBinning confCollisionBinning; + + // setup tracks + trackbuilder::ConfTrackSelection1 trackSelection; + trackhistmanager::ConfTrackBinning1 confTrackBinning; + Partition trackPartition = MAKE_TRACK_PARTITION(trackSelection); + Preslice perColTracks = aod::femtobase::stored::collisionId; + + // setup for daughters + trackhistmanager::ConfResonancePosDauBinning confPosDauBinning; + trackhistmanager::ConfResonanceNegDauBinning confNegDauBinning; + + // setup phis + twotrackresonancebuilder::ConfPhiSelection phiSelection; + twotrackresonancehistmanager::ConfPhiBinning confPhiBinning; + Partition phiPartition = MAKE_RESONANCE_0_PARTITON(phiSelection); + Preslice perColPhis = aod::femtobase::stored::collisionId; + + // setup kstar0 + twotrackresonancebuilder::ConfKstar0Selection kstar0Selection; + twotrackresonancehistmanager::ConfKstar0Binning confKstar0Binning; + Partition kstar0Partition = MAKE_RESONANCE_1_PARTITON(kstar0Selection); + Preslice perColKstar0s = aod::femtobase::stored::collisionId; + + // rho0s + twotrackresonancebuilder::ConfRho0Selection rho0Selection; + twotrackresonancehistmanager::ConfRho0Binning confRho0Binning; + Partition rho0Partition = MAKE_RESONANCE_0_PARTITON(rho0Selection); + Preslice perColRho0s = aod::femtobase::stored::collisionId; + + // setup pairs + pairhistmanager::ConfPairBinning confPairBinning; + + // setup for track-phi pairs + pairbuilder::PairTrackTwoTrackResonanceBuilder< + trackhistmanager::PrefixTrack1, + twotrackresonancehistmanager::PrefixPhi, + trackhistmanager::PrefixResonancePosDaughter, + trackhistmanager::PrefixResonanceNegDaughter, + pairhistmanager::PrefixTrackResonanceSe, + pairhistmanager::PrefixTrackResonanceMe, + closepairrejection::PrefixTrackV0Se, + closepairrejection::PrefixTrackV0Me, + modes::Mode::kAnalysis, + modes::TwoTrackResonance::kPhi> + pairTrackPhiBuilder; + + // setup for track-kstar0 pairs + pairbuilder::PairTrackTwoTrackResonanceBuilder< + trackhistmanager::PrefixTrack1, + twotrackresonancehistmanager::PrefixKstar, + trackhistmanager::PrefixResonancePosDaughter, + trackhistmanager::PrefixResonanceNegDaughter, + pairhistmanager::PrefixTrackResonanceSe, + pairhistmanager::PrefixTrackResonanceMe, + closepairrejection::PrefixTrackV0Se, + closepairrejection::PrefixTrackV0Me, + modes::Mode::kAnalysis, + modes::TwoTrackResonance::kKstar0> + pairTrackKstar0Builder; + + // setup for track-rho0 pairs + pairbuilder::PairTrackTwoTrackResonanceBuilder< + trackhistmanager::PrefixTrack1, + twotrackresonancehistmanager::PrefixRho, + trackhistmanager::PrefixResonancePosDaughter, + trackhistmanager::PrefixResonanceNegDaughter, + pairhistmanager::PrefixTrackResonanceSe, + pairhistmanager::PrefixTrackResonanceMe, + closepairrejection::PrefixTrackV0Se, + closepairrejection::PrefixTrackV0Me, + modes::Mode::kAnalysis, + modes::TwoTrackResonance::kRho0> + pairTrackRho0Builder; + + // setup mixing + std::vector defaultVtxBins{10, -10, 10}; + std::vector defaultMultBins{50, 0, 200}; + std::vector defaultCentBins{10, 0, 100}; + ColumnBinningPolicy mixBinsVtxMult{{defaultVtxBins, defaultMultBins}, true}; + ColumnBinningPolicy mixBinsVtxCent{{defaultVtxBins, defaultCentBins}, true}; + ColumnBinningPolicy mixBinsVtxMultCent{{defaultVtxBins, defaultMultBins, defaultCentBins}, true}; + pairhistmanager::ConfMixing confMixing; + + HistogramRegistry hRegistry{"FemtoTrackTwoTrackResonance", {}, OutputObjHandlingPolicy::AnalysisObject}; + + // setup cpr + closepairrejection::ConfCpr confCpr; + + void init(InitContext&) + { + + if (((doprocessPhiSameEvent || doprocessPhiMixedEvent) + (doprocessKstar0SameEvent || doprocessKstar0MixedEvent)) + (doprocessRho0SameEvent || doprocessRho0MixedEvent) > 1) { + LOG(fatal) << "Can only process lambda-tracks Or k0short-tracks"; + } + + // setup columnpolicy for binning + // default values are used during instantiation, so we need to explicity update them here + mixBinsVtxMult = {{confMixing.vtxBins, confMixing.multBins.value}, true}; + mixBinsVtxCent = {{confMixing.vtxBins.value, confMixing.centBins.value}, true}; + mixBinsVtxMultCent = {{confMixing.vtxBins.value, confMixing.multBins.value, confMixing.centBins.value}, true}; + + // setup histograms + auto colHistSpec = colhistmanager::makeColHistSpecMap(confCollisionBinning); + auto trackHistSpec = trackhistmanager::makeTrackHistSpecMap(confTrackBinning); + auto posDauSpec = trackhistmanager::makeTrackHistSpecMap(confPosDauBinning); + auto negDauSpec = trackhistmanager::makeTrackHistSpecMap(confNegDauBinning); + auto cprHistSpec = closepairrejection::makeCprHistSpecMap(confCpr); + + // setup for phi + if (doprocessPhiSameEvent || doprocessPhiMixedEvent) { + auto phiHistSpec = twotrackresonancehistmanager::makeTwoTrackResonanceHistSpecMap(confPhiBinning); + auto pairTrackPhiHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confTrackBinning, confPhiBinning); + pairTrackPhiBuilder.init(&hRegistry, trackSelection, phiSelection, confCpr, confMixing, colHistSpec, trackHistSpec, phiHistSpec, posDauSpec, negDauSpec, pairTrackPhiHistSpec, cprHistSpec); + } + + // setup for kstar0 + if (doprocessKstar0SameEvent || doprocessKstar0MixedEvent) { + auto kstar0HistSpec = twotrackresonancehistmanager::makeTwoTrackResonanceHistSpecMap(confKstar0Binning); + auto pairTrackKstar0HistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confTrackBinning, confKstar0Binning); + pairTrackKstar0Builder.init(&hRegistry, trackSelection, kstar0Selection, confCpr, confMixing, colHistSpec, trackHistSpec, kstar0HistSpec, posDauSpec, negDauSpec, pairTrackKstar0HistSpec, cprHistSpec); + } + + // setup for kstar0 + if (doprocessRho0SameEvent || doprocessRho0MixedEvent) { + auto rho0HistSpec = twotrackresonancehistmanager::makeTwoTrackResonanceHistSpecMap(confRho0Binning); + auto pairTrackRho0HistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confTrackBinning, confRho0Binning); + pairTrackRho0Builder.init(&hRegistry, trackSelection, rho0Selection, confCpr, confMixing, colHistSpec, trackHistSpec, rho0HistSpec, posDauSpec, negDauSpec, pairTrackRho0HistSpec, cprHistSpec); + } + }; + + void processPhiSameEvent(FilteredCollision const& col, Tracks const& tracks, Phis const& phis) + { + pairTrackPhiBuilder.processSameEvent(col, tracks, trackPartition, phis, phiPartition, cache); + } + PROCESS_SWITCH(FemtoPairTrackTwoTrackResonance, processPhiSameEvent, "Enable processing same event processing for tracks and phis", true); + + void processPhiMixedEvent(FilteredCollisions const& cols, Tracks const& tracks, Phis const& /*phis*/) + { + pairTrackPhiBuilder.processMixedEvent(cols, tracks, trackPartition, phiPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + } + PROCESS_SWITCH(FemtoPairTrackTwoTrackResonance, processPhiMixedEvent, "Enable processing mixed event processing for tracks and phis", true); + + void processKstar0SameEvent(FilteredCollision const& col, Tracks const& tracks, Kstar0s const& kstar0s) + { + pairTrackKstar0Builder.processSameEvent(col, tracks, trackPartition, kstar0s, kstar0Partition, cache); + } + PROCESS_SWITCH(FemtoPairTrackTwoTrackResonance, processKstar0SameEvent, "Enable processing same event processing for tracks and kstar0s", false); + + void processKstar0MixedEvent(FilteredCollisions const& cols, Tracks const& tracks, Kstar0s const& /*kstar0s*/) + { + pairTrackKstar0Builder.processMixedEvent(cols, tracks, trackPartition, kstar0Partition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + } + PROCESS_SWITCH(FemtoPairTrackTwoTrackResonance, processKstar0MixedEvent, "Enable processing mixed event processing for tracks and kstar0s", false); + + void processRho0SameEvent(FilteredCollision const& col, Tracks const& tracks, Rho0s const& rho0s) + { + pairTrackRho0Builder.processSameEvent(col, tracks, trackPartition, rho0s, rho0Partition, cache); + } + PROCESS_SWITCH(FemtoPairTrackTwoTrackResonance, processRho0SameEvent, "Enable processing same event processing for tracks and rho0s", false); + + void processRho0MixedEvent(FilteredCollisions const& cols, Tracks const& tracks, Rho0s const& /*rho0s*/) + { + pairTrackRho0Builder.processMixedEvent(cols, tracks, trackPartition, rho0Partition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + } + PROCESS_SWITCH(FemtoPairTrackTwoTrackResonance, processRho0MixedEvent, "Enable processing mixed event processing for tracks and rho0s", false); +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + WorkflowSpec workflow{ + adaptAnalysisTask(cfgc), + }; + return workflow; +} diff --git a/PWGCF/Femto/Tasks/femtoPairTrackV0.cxx b/PWGCF/Femto/Tasks/femtoPairTrackV0.cxx index 4ff228948f6..e72c7f64ac2 100644 --- a/PWGCF/Femto/Tasks/femtoPairTrackV0.cxx +++ b/PWGCF/Femto/Tasks/femtoPairTrackV0.cxx @@ -142,25 +142,24 @@ struct FemtoPairTrackV0 { auto trackHistSpec = trackhistmanager::makeTrackHistSpecMap(confTrackBinning); auto posDauSpec = trackhistmanager::makeTrackHistSpecMap(confPosDauBinning); auto negDauSpec = trackhistmanager::makeTrackHistSpecMap(confNegDauBinning); - auto pairHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confTrackBinning, confLambdaBinning); auto cprHistSpec = closepairrejection::makeCprHistSpecMap(confCpr); // setup for lambda - // if (doprocessLambdaSameEvent || doprocessLambdaMixedEvent) { - if (doprocessLambdaSameEvent) { + if (doprocessLambdaSameEvent || doprocessLambdaMixedEvent) { auto lambdaHistSpec = v0histmanager::makeV0HistSpecMap(confLambdaBinning); - pairTrackLambdaBuilder.init(&hRegistry, trackSelection, lambdaSelection, confCpr, confMixing, colHistSpec, trackHistSpec, lambdaHistSpec, posDauSpec, negDauSpec, pairHistSpec, cprHistSpec); + auto pairTrackLambdaHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confTrackBinning, confLambdaBinning); + pairTrackLambdaBuilder.init(&hRegistry, trackSelection, lambdaSelection, confCpr, confMixing, colHistSpec, trackHistSpec, lambdaHistSpec, posDauSpec, negDauSpec, pairTrackLambdaHistSpec, cprHistSpec); } - // if (((doprocessLambdaSameEvent || doprocessLambdaMixedEvent) + (doprocessK0shortSameEvent || doprocessK0shortMixedEvent)) > 1) { - // LOG(fatal) << "Can only process lambda-tracks Or k0short-tracks"; - // } - // setup for k0short - // if (doprocessK0shortSameEvent || doprocessK0shortMixedEvent) { - if (doprocessK0shortSameEvent) { + if (doprocessK0shortSameEvent || doprocessK0shortMixedEvent) { auto k0shortHistSpec = v0histmanager::makeV0HistSpecMap(confK0shortBinning); - pairTrackK0shortBuilder.init(&hRegistry, trackSelection, lambdaSelection, confCpr, confMixing, colHistSpec, trackHistSpec, k0shortHistSpec, posDauSpec, negDauSpec, pairHistSpec, cprHistSpec); + auto pairTrackK0shortHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confTrackBinning, confLambdaBinning); + pairTrackK0shortBuilder.init(&hRegistry, trackSelection, lambdaSelection, confCpr, confMixing, colHistSpec, trackHistSpec, k0shortHistSpec, posDauSpec, negDauSpec, pairTrackK0shortHistSpec, cprHistSpec); + } + + if (((doprocessLambdaSameEvent || doprocessLambdaMixedEvent) + (doprocessK0shortSameEvent || doprocessK0shortMixedEvent)) > 1) { + LOG(fatal) << "Can only process lambda-tracks Or k0short-tracks"; } }; diff --git a/PWGCF/Femto/Tasks/femtoTrackQa.cxx b/PWGCF/Femto/Tasks/femtoTrackQa.cxx index 53338a1852d..6398257a98d 100644 --- a/PWGCF/Femto/Tasks/femtoTrackQa.cxx +++ b/PWGCF/Femto/Tasks/femtoTrackQa.cxx @@ -76,7 +76,7 @@ struct FemtoTrackQa { auto colHistSpec = colhistmanager::makeColHistSpecMap(confCollisionBinning); colHistManager.init(&hRegistry, colHistSpec); auto trackHistSpec = trackhistmanager::makeTrackQaHistSpecMap(confTrackBinning, confTrackQaBinning); - trackHistManager.init(&hRegistry, trackHistSpec, trackSelections.absCharge.value, confTrackQaBinning.momentumType.value); + trackHistManager.init(&hRegistry, trackHistSpec, trackSelections.charge.value, confTrackQaBinning.momentumType.value); }; void process(FilteredCollision const& col, Tracks const& /*tracks*/)