From 0ff30ed08352dd40a18bba84187685f962acfb7a Mon Sep 17 00:00:00 2001 From: wenyaCern Date: Wed, 10 Sep 2025 17:59:25 +0200 Subject: [PATCH 01/13] Add functions for flow and qn in femto dream --- PWGCF/DataModel/FemtoDerived.h | 6 + .../Core/femtoDreamCollisionSelection.h | 299 +++++++++++++++++- PWGCF/FemtoDream/Core/femtoDreamContainer.h | 88 ++++++ .../femtoDreamProducerReducedTask.cxx | 214 ++++++++++++- .../Tasks/femtoDreamPairTaskTrackTrack.cxx | 95 +++++- 5 files changed, 696 insertions(+), 6 deletions(-) diff --git a/PWGCF/DataModel/FemtoDerived.h b/PWGCF/DataModel/FemtoDerived.h index 6bcd3432daf..bf60c53412f 100644 --- a/PWGCF/DataModel/FemtoDerived.h +++ b/PWGCF/DataModel/FemtoDerived.h @@ -50,6 +50,8 @@ DECLARE_SOA_COLUMN(BitMaskTrackTwo, bitmaskTrackTwo, BitMaskType); //! Bit f DECLARE_SOA_COLUMN(BitMaskTrackThree, bitmaskTrackThree, BitMaskType); //! Bit for track three DECLARE_SOA_COLUMN(Downsample, downsample, bool); //! Flag for downsampling + +DECLARE_SOA_COLUMN(QnBin, qnBin, int); //! qn bins for dividing events } // namespace femtodreamcollision DECLARE_SOA_TABLE_STAGED(FDCollisions, "FDCOLLISION", @@ -61,6 +63,10 @@ DECLARE_SOA_TABLE_STAGED(FDCollisions, "FDCOLLISION", femtodreamcollision::MagField); using FDCollision = FDCollisions::iterator; +DECLARE_SOA_TABLE(FDExtQnCollisions, "AOD", "FDEXTCOLLISION", + femtodreamcollision::QnBin); +using FDExtQnCollision = FDExtQnCollisions::iterator; + DECLARE_SOA_TABLE(FDColMasks, "AOD", "FDCOLMASK", femtodreamcollision::BitMaskTrackOne, femtodreamcollision::BitMaskTrackTwo, diff --git a/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h b/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h index 73350e81c6c..5a2ab6bac62 100644 --- a/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h +++ b/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h @@ -18,11 +18,15 @@ #include #include +#include #include "Common/CCDB/TriggerAliases.h" #include "Common/DataModel/EventSelection.h" #include "Framework/HistogramRegistry.h" #include "Framework/Logger.h" +#include "Common/Core/EventPlaneHelper.h" +#include "Common/DataModel/Qvectors.h" + using namespace o2::framework; namespace o2::analysis::femtoDream @@ -156,6 +160,36 @@ class FemtoDreamCollisionSelection return true; } + /// Pile-up selection of PbPb collisions + /// \tparam T type of the collision + /// \param col Collision + /// \return whether or not the collisions fulfills the specified selections + template + bool isPileUpCollisionPbPb(C const& col, + bool noSameBunchPileup, bool isGoodZvtxFT0vsPV, + bool isGoodITSLayersAll, bool noCollInRofStandard, + bool noHighMultCollInPrevRof, bool noCollInTimeRangeStandard, + bool /*isVertexITSTPC*/, + int tpcOccupancyMin, int tpcOccupancyMax) + { + const auto occupancy = col.trackOccupancyInTimeRange(); + if ((occupancy < tpcOccupancyMin || occupancy > tpcOccupancyMax)) { + return false; + } + if ((noSameBunchPileup && !col.selection_bit(aod::evsel::kNoSameBunchPileup)) + || (isGoodZvtxFT0vsPV && !col.selection_bit(aod::evsel::kIsGoodZvtxFT0vsPV)) + || (isGoodITSLayersAll && !col.selection_bit(aod::evsel::kIsGoodITSLayersAll)) + || (noCollInRofStandard && !col.selection_bit(aod::evsel::kNoCollInRofStandard)) + || (noHighMultCollInPrevRof && !col.selection_bit(aod::evsel::kNoHighMultCollInPrevRof)) + || (noCollInTimeRangeStandard && !col.selection_bit(aod::evsel::kNoCollInTimeRangeStandard)) + // || (isVertexITSTPC && !col.selection_bit(aod::evsel::kIsVertexITSTPC)) + ) { + return false; + } + + return true; + } + /// Some basic QA of the event /// \tparam T type of the collision /// \param col Collision @@ -175,6 +209,37 @@ class FemtoDreamCollisionSelection } } + /// Initializes histograms for the flow calculation + /// \param registry Histogram registry to be passed + void initFlow(HistogramRegistry* registry, bool doQnSeparation, int mumQnBins = 10, int binPt = 100, int binEta = 32) + { + if (!mCutsSet) { + LOGF(error, "Event selection not set - quitting!"); + } + mReQthisEvt = new TH2D("ReQthisEvt", "", binPt, 0., 5., binEta, -0.8, 0.8); + mImQthisEvt = new TH2D("ImQthisEvt", "", binPt, 0., 5., binEta, -0.8, 0.8); + mReQ2thisEvt = new TH2D("ReQ2thisEvt", "", binPt, 0., 5., binEta, -0.8, 0.8); + mImQ2thisEvt = new TH2D("ImQ2thisEvt", "", binPt, 0., 5., binEta, -0.8, 0.8); + mMQthisEvt = new TH2D("MQthisEvt", "", binPt, 0., 5., binEta, -0.8, 0.8); + mMQWeightthisEvt = new TH2D("MQWeightthisEvt", "", binPt, 0., 5., binEta, -0.8, 0.8); + mHistogramQn = registry; + mHistogramQn->add("Event/centFT0CBefore", "; cent", kTH1F, {{10, 0, 100}}); + mHistogramQn->add("Event/centFT0CAfter", "; cent", kTH1F, {{10, 0, 100}}); + mHistogramQn->add("Event/centVsqn", "; cent; qn", kTH2F, {{10, 0, 100}, {100, 0, 1000}}); + mHistogramQn->add("Event/centVsqnVsSpher", "; cent; qn; Sphericity", kTH3F, {{10, 0, 100}, {100, 0, 1000}, {100, 0, 1}}); + mHistogramQn->add("Event/qnBin", "; qnBin; entries", kTH1F, {{20, 0, 20}}); + + mHistogramQn->add("Event/profileC22", "; cent; c22", kTProfile, {{10, 0, 100}}); + mHistogramQn->add("Event/profileC24", "; cent; c24", kTProfile, {{10, 0, 100}}); + if (doQnSeparation){ + for (int iqn(0); iqn < mumQnBins; ++iqn) { + mHistogramQn->add(("Qn/profileC22_" + std::to_string(iqn)).c_str(), "; cent; c22", kTProfile, {{10, 0, 100}}); + mHistogramQn->add(("Qn/mult_" + std::to_string(iqn)).c_str(), "; cent; c22", kTH1F, {{100, 0, 1000}}); + } + } + return; + } + /// \todo to be implemented! /// Compute the sphericity of an event /// Important here is that the filter on tracks does not interfere here! @@ -246,8 +311,233 @@ class FemtoDreamCollisionSelection return spt; } + /// \todo to be implemented! + /// Compute the qn-vector(FT0C) of an event + /// \tparam T type of the collision + /// \param col Collision + /// \return value of the qn-vector of FT0C of the event + template + float computeqnVec(T const& col) + { + double qn = std::sqrt(col.qvecFT0CReVec()[0] * col.qvecFT0CReVec()[0] + col.qvecFT0CImVec()[0] * col.qvecFT0CImVec()[0]) * std::sqrt(col.sumAmplFT0C()); + return qn; + } + + /// \todo to be implemented! + /// \return the 1-d qn-vector separator to 2-d + std::vector> getQnBinSeparator2D(std::vector flat) + { + constexpr size_t nBins = 11; + + if (flat.empty() || flat.size() % nBins != 0) { + LOGP(error, "ConfQnBinSeparator size = {} is not divisible by {}", + flat.size(), nBins); + return {{-999, -999}}; + } + + size_t nCent = flat.size() / nBins; + std::vector> res(nCent, std::vector(nBins)); + + for (size_t i = 0; i < nCent; ++i) { + for (size_t j = 0; j < nBins; ++j) { + res[i][j] = flat[i * nBins + j]; + } + } + return res; + } + + /// \todo to be implemented! + /// Get the bin number of qn-vector(FT0C) of an event + /// \tparam T type of the collision + /// \param col Collision + /// \param centBinWidth centrality bin width, example: per 1%, per 10% ... + /// \return bin number of qn-vector of the event + template + int myqnBin(T const& col, float centMax, std::vector qnBinSeparator, float fSpher, float fMult, float centBinWidth = 1.f) + { + auto twoDSeparator = getQnBinSeparator2D(qnBinSeparator); + if (twoDSeparator.empty() || twoDSeparator[0][0] == -999.) { + LOGP(warning, "ConfQnBinSeparator not set, using default fallback!"); + return -999; // safe fallback + } + + mHistogramQn->fill(HIST("Event/centFT0CBefore"), col.centFT0C()); + int qnBin = -999; + float qn = computeqnVec(col); + int mycentBin = static_cast(col.centFT0C() / centBinWidth); + if (mycentBin >= static_cast(centMax / centBinWidth)) + return qnBin; + + if (mycentBin > static_cast(twoDSeparator.size()) -1) + return qnBin; + + for (int iqn(0); iqn < static_cast(twoDSeparator[mycentBin].size()) - 1; ++iqn) { + if (qn > twoDSeparator[mycentBin][iqn] && qn <= twoDSeparator[mycentBin][iqn + 1]) { + qnBin = iqn; + break; + } else { + continue; + } + } + + mHistogramQn->fill(HIST("Event/centFT0CAfter"), col.centFT0C()); + mHistogramQn->fill(HIST("Event/centVsqn"), col.centFT0C(), qn); + mHistogramQn->fill(HIST("Event/centVsqnVsSpher"), col.centFT0C(), qn, fSpher); + mHistogramQn->fill(HIST("Event/qnBin"), qnBin); + if (qnBin >= 0 && qnBin < 10){ + switch (qnBin) { + case 0: + mHistogramQn->fill(HIST("Qn/mult_") + HIST("0"), fMult); + break; + case 1: + mHistogramQn->fill(HIST("Qn/mult_") + HIST("1"), fMult); + break; + case 2: + mHistogramQn->fill(HIST("Qn/mult_") + HIST("2"), fMult); + break; + case 3: + mHistogramQn->fill(HIST("Qn/mult_") + HIST("3"), fMult); + break; + case 4: + mHistogramQn->fill(HIST("Qn/mult_") + HIST("4"), fMult); + break; + case 5: + mHistogramQn->fill(HIST("Qn/mult_") + HIST("5"), fMult); + break; + case 6: + mHistogramQn->fill(HIST("Qn/mult_") + HIST("6"), fMult); + break; + case 7: + mHistogramQn->fill(HIST("Qn/mult_") + HIST("7"), fMult); + break; + case 8: + mHistogramQn->fill(HIST("Qn/mult_") + HIST("8"), fMult); + break; + case 9: + mHistogramQn->fill(HIST("Qn/mult_") + HIST("9"), fMult); + break; + default: + return qnBin; // invalid qn bin + } + } + return qnBin; + } + + /// \todo to be implemented! + /// Fill cumulants histo for flow calculation + /// Reset hists event-by-event + /// \tparam T1 type of the collision + /// \tparam T2 type of the tracks + /// \param tracks All tracks + template + void fillCumulants(T1 const& col, T2 const& tracks, float fHarmonic=2.f) + { + int numOfTracks = col.numContrib(); + if (numOfTracks < 3) + return ; + + mReQthisEvt->Reset(); + mImQthisEvt->Reset(); + mReQ2thisEvt->Reset(); + mImQ2thisEvt->Reset(); + mMQthisEvt->Reset(); + mMQWeightthisEvt->Reset(); + + for (auto const& track : tracks) { + double weight=1; // Will implement NUA&NUE correction + double phi = track.phi(); + double pt = track.pt(); + double eta = track.eta(); + double cosnphi = weight * TMath::Cos(fHarmonic*phi); + double sinnphi = weight * TMath::Sin(fHarmonic*phi); + double cos2nphi = weight * TMath::Cos(2*fHarmonic*phi); + double sin2nphi = weight * TMath::Sin(2*fHarmonic*phi); + mReQthisEvt->Fill(pt, eta, cosnphi); + mImQthisEvt->Fill(pt, eta, sinnphi); + mReQ2thisEvt->Fill(pt,eta,cos2nphi); + mImQ2thisEvt->Fill(pt, eta, sin2nphi); + mMQthisEvt ->Fill(pt, eta); + mMQWeightthisEvt ->Fill(pt, eta, weight); + } + return; + } + + /// \todo to be implemented! + /// Do cumulants for flow calculation + /// \tparam T type of the collision + /// \param doQnSeparation to fill flow in divied qn bins + /// \param qnBin should be in 0-9 + /// \param fEtaGap eta gap for flow cumulant + template + void doCumulants(T const& col, bool doQnSeparation = false, int qnBin = -999, int mumQnBinNum = 10, float fEtaGap = 0.3f, int binPt = 100, int binEta = 32) + { + if (mMQthisEvt->Integral(1, binPt, 1, binEta) < 2) + return; + + double allReQ = mReQthisEvt ->Integral(1, binPt, 1, binEta); + double allImQ = mImQthisEvt ->Integral(1, binPt, 1, binEta); + TComplex Q(allReQ, allImQ); + TComplex QStar = TComplex::Conjugate(Q); + + double posEtaRe = mReQthisEvt->Integral(1, binPt, mReQthisEvt->GetYaxis()->FindBin(fEtaGap+1e-6), binEta); + double posEtaIm = mImQthisEvt->Integral(1, binPt, mImQthisEvt->GetYaxis()->FindBin(fEtaGap+1e-6), binEta); + if (mMQthisEvt->Integral(1, binPt, mMQthisEvt->GetYaxis()->FindBin(fEtaGap+1e-6), binEta) < 2) + return; + float posEtaMQ = mMQWeightthisEvt->Integral(1, binPt, mMQthisEvt->GetYaxis()->FindBin(fEtaGap+1e-6), binEta); + TComplex posEtaQ = TComplex(posEtaRe, posEtaIm); + TComplex posEtaQStar = TComplex::Conjugate(posEtaQ); + + double negEtaRe = mReQthisEvt->Integral(1, binPt, 1, mReQthisEvt->GetYaxis()->FindBin(-1*fEtaGap-1e-6)); + double negEtaIm = mImQthisEvt->Integral(1, binPt, 1, mImQthisEvt->GetYaxis()->FindBin(-1*fEtaGap-1e-6)); + if (mMQthisEvt->Integral(1, binPt, 1, mMQthisEvt->GetYaxis()->FindBin(-1*fEtaGap-1e-6)) < 2) + return; + float negEtaMQ = mMQWeightthisEvt->Integral(1, binPt, 1, mMQthisEvt->GetYaxis()->FindBin(-1*fEtaGap-1e-6)); + TComplex negEtaQ = TComplex(negEtaRe, negEtaIm); + TComplex negEtaQStar = TComplex::Conjugate(negEtaQ); + + mHistogramQn->get(HIST("Event/profileC22"))->Fill(col.centFT0C(), (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + if (doQnSeparation && qnBin >= 0 && qnBin < mumQnBinNum){ + switch (qnBin) { + case 0: + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("0"))->Fill(col.centFT0C(), (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + break; + case 1: + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("1"))->Fill(col.centFT0C(), (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + break; + case 2: + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("2"))->Fill(col.centFT0C(), (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + break; + case 3: + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("3"))->Fill(col.centFT0C(), (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + break; + case 4: + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("4"))->Fill(col.centFT0C(), (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + break; + case 5: + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("5"))->Fill(col.centFT0C(), (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + break; + case 6: + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("6"))->Fill(col.centFT0C(), (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + break; + case 7: + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("7"))->Fill(col.centFT0C(), (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + break; + case 8: + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("8"))->Fill(col.centFT0C(), (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + break; + case 9: + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("9"))->Fill(col.centFT0C(), (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + break; + default: + return; // invalid qn bin + } + } + return; + } + + private: - HistogramRegistry* mHistogramRegistry = nullptr; ///< For QA output + HistogramRegistry* mHistogramRegistry = nullptr; ///< For QA output bool mCutsSet = false; ///< Protection against running without cuts bool mCheckTrigger = false; ///< Check for trigger bool mCheckOffline = false; ///< Check for offline criteria (might change) @@ -257,6 +547,13 @@ class FemtoDreamCollisionSelection float mZvtxMax = 999.f; ///< Maximal deviation from nominal z-vertex (cm) float mMinSphericity = 0.f; float mSphericityPtmin = 0.f; + HistogramRegistry* mHistogramQn = nullptr; ///< For flow cumulant output + TH2D* mReQthisEvt = nullptr; ///< For flow cumulant in an event + TH2D* mImQthisEvt = nullptr; ///< For flow cumulant in an event + TH2D* mReQ2thisEvt = nullptr; ///< For flow cumulant in an event + TH2D* mImQ2thisEvt = nullptr; ///< For flow cumulant in an event + TH2D* mMQthisEvt = nullptr; ///< For flow cumulant in an event + TH2D* mMQWeightthisEvt = nullptr; ///< For flow cumulant in an event }; } // namespace o2::analysis::femtoDream diff --git a/PWGCF/FemtoDream/Core/femtoDreamContainer.h b/PWGCF/FemtoDream/Core/femtoDreamContainer.h index 3d95fc08311..60d51e54643 100644 --- a/PWGCF/FemtoDream/Core/femtoDreamContainer.h +++ b/PWGCF/FemtoDream/Core/femtoDreamContainer.h @@ -180,6 +180,43 @@ class FemtoDreamContainer } } + /// Initialize the histograms for pairs in divided qn bins + template + void init_base_qn(std::string folderName, std::string femtoObs, + T& femtoObsAxis, T& mTAxi4D, T& multPercentileAxis4D, T& qnAxis4D) + { + mHistogramRegistry->add((folderName + "/relPairkstarmTMultMultPercentileQn").c_str(), ("; " + femtoObs + "; #it{m}_{T} (GeV/#it{c}); Centrality; qn").c_str(), kTHnSparseF, {femtoObsAxis, mTAxi4D, multPercentileAxis4D, qnAxis4D}); + } + + template + void init_qn(HistogramRegistry* registry, + T& kstarBins4D, T& mTBins4D, T& multPercentileBins4D, + bool isMC, float highkstarCut, ConfigurableAxis qnBins4D = {"qnBins4D", {10,0,10}, "qn binning"}) + { + mHistogramRegistry = registry; + std::string femtoObs; + if constexpr (mFemtoObs == femtoDreamContainer::Observable::kstar) { + femtoObs = "#it{k*} (GeV/#it{c})"; + } + mHighkstarCut = highkstarCut; + + framework::AxisSpec kstarAxis4D = {kstarBins4D, femtoObs}; + framework::AxisSpec mTAxis4D = {mTBins4D, "#it{m}_{T} (GeV/#it{c})"}; + framework::AxisSpec multPercentileAxis4D = {multPercentileBins4D, "Centralty(%)"}; + framework::AxisSpec qnAxis4D = {qnBins4D, "qn"}; + + std::string folderName = static_cast(mFolderSuffix[mEventType]) + static_cast(o2::aod::femtodreamMCparticle::MCTypeName[o2::aod::femtodreamMCparticle::MCType::kRecon]) + static_cast("_qn"); + + init_base_qn(folderName, femtoObs, + kstarAxis4D, mTAxis4D, multPercentileAxis4D, qnAxis4D); + + if (isMC) { + folderName = static_cast(mFolderSuffix[mEventType]) + static_cast(o2::aod::femtodreamMCparticle::MCTypeName[o2::aod::femtodreamMCparticle::MCType::kTruth]) + static_cast("_qn"); + init_base_qn(folderName, femtoObs, + kstarAxis4D, mTAxis4D, multPercentileAxis4D, qnAxis4D); + } + } + /// Set the PDG codes of the two particles involved /// \param pdg1 PDG code of particle one /// \param pdg2 PDG code of particle two @@ -317,6 +354,57 @@ class FemtoDreamContainer } } + /// Pass a pair to the container and compute all the relevant observables in divided qn bins + template + void setPair_qn_base(const float femtoObs, const float mT, const float multPercentile, const int myQnBin, const int numQnBins = 10) + { + if (myQnBin >= 0 && myQnBin < numQnBins) { + mHistogramRegistry->fill(HIST(mFolderSuffix[mEventType]) + HIST(o2::aod::femtodreamMCparticle::MCTypeName[mc]) + HIST("_qn") + HIST("/relPairkstarmTMultMultPercentileQn"), femtoObs, mT, multPercentile, myQnBin); + } else { + return; + } + } + + template + void setPair_qn(T1 const& part1, T2 const& part2, const float multPercentile, const int myQnBin) + { + float femtoObs, femtoObsMC; + // Calculate femto observable and the mT with reconstructed information + if constexpr (mFemtoObs == femtoDreamContainer::Observable::kstar) { + femtoObs = FemtoDreamMath::getkstar(part1, mMassOne, part2, mMassTwo); + } + if (mHighkstarCut > 0) { + if (femtoObs > mHighkstarCut) { + return; + } + } + const float mT = FemtoDreamMath::getmT(part1, mMassOne, part2, mMassTwo); + const int numQnBins = 10; + + if (mHistogramRegistry) { + setPair_qn_base(femtoObs, mT, multPercentile, myQnBin, numQnBins); + + if constexpr (isMC) { + if (part1.has_fdMCParticle() && part2.has_fdMCParticle()) { + // calculate the femto observable and the mT with MC truth information + if constexpr (mFemtoObs == femtoDreamContainer::Observable::kstar) { + femtoObsMC = FemtoDreamMath::getkstar(part1.fdMCParticle(), mMassOne, part2.fdMCParticle(), mMassTwo); + } + const float mTMC = FemtoDreamMath::getmT(part1.fdMCParticle(), mMassOne, part2.fdMCParticle(), mMassTwo); + + if (abs(part1.fdMCParticle().pdgMCTruth()) == mPDGOne && abs(part2.fdMCParticle().pdgMCTruth()) == mPDGTwo) { // Note: all pair-histogramms are filled with MC truth information ONLY in case of non-fake candidates + setPair_qn_base(femtoObsMC, mTMC, multPercentile, myQnBin, numQnBins); + } else { + mHistogramRegistry->fill(HIST(mFolderSuffix[mEventType]) + HIST(o2::aod::femtodreamMCparticle::MCTypeName[o2::aod::femtodreamMCparticle::MCType::kTruth]) + HIST("/hFakePairsCounter"), 0); + } + + } else { + mHistogramRegistry->fill(HIST(mFolderSuffix[mEventType]) + HIST(o2::aod::femtodreamMCparticle::MCTypeName[o2::aod::femtodreamMCparticle::MCType::kTruth]) + HIST("/hNoMCtruthPairsCounter"), 0); + } + } + } + } + protected: HistogramRegistry* mHistogramRegistry = nullptr; ///< For QA output static constexpr std::string_view mFolderSuffix[2] = {"SameEvent", "MixedEvent"}; ///< Folder naming for the output according to mEventType diff --git a/PWGCF/FemtoDream/TableProducer/femtoDreamProducerReducedTask.cxx b/PWGCF/FemtoDream/TableProducer/femtoDreamProducerReducedTask.cxx index a1cd73cbf6f..a3fa912482a 100644 --- a/PWGCF/FemtoDream/TableProducer/femtoDreamProducerReducedTask.cxx +++ b/PWGCF/FemtoDream/TableProducer/femtoDreamProducerReducedTask.cxx @@ -50,6 +50,7 @@ namespace o2::aod using FemtoFullCollision = soa::Join::iterator; using FemtoFullCollisionMC = soa::Join::iterator; using FemtoFullCollision_noCent_MC = soa::Join::iterator; +using FemtoFullCollision_CentPbPb = soa::Join::iterator; using FemtoFullTracks = soa::Join outputCollision; + Produces outputExtQnCollision; Produces outputParts; Produces outputPartsMC; Produces outputDebugParts; @@ -99,14 +101,39 @@ struct femtoDreamProducerReducedTask { Configurable> ConfTrkITSnclsIbMin{FemtoDreamTrackSelection::getSelectionName(femtoDreamTrackSelection::kITSnClsIbMin, "ConfTrk"), std::vector{-1.f, 1.f}, FemtoDreamTrackSelection::getSelectionHelper(femtoDreamTrackSelection::kITSnClsIbMin, "Track selection: ")}; Configurable> ConfTrkDCAxyMax{FemtoDreamTrackSelection::getSelectionName(femtoDreamTrackSelection::kDCAxyMax, "ConfTrk"), std::vector{0.1f, 0.5f}, FemtoDreamTrackSelection::getSelectionHelper(femtoDreamTrackSelection::kDCAxyMax, "Track selection: ")}; /// here we need an open cut to do the DCA fits later on! Configurable> ConfTrkDCAzMax{FemtoDreamTrackSelection::getSelectionName(femtoDreamTrackSelection::kDCAzMax, "ConfTrk"), std::vector{0.2f, 0.5f}, FemtoDreamTrackSelection::getSelectionHelper(femtoDreamTrackSelection::kDCAzMax, "Track selection: ")}; - Configurable> ConfTrkPIDnSigmaMax{FemtoDreamTrackSelection::getSelectionName(femtoDreamTrackSelection::kPIDnSigmaMax, "Conf"), std::vector{3.5f, 3.f, 2.5f}, FemtoDreamTrackSelection::getSelectionHelper(femtoDreamTrackSelection::kPIDnSigmaMax, "Track selection: ")}; + Configurable> ConfTrkPIDnSigmaMax{FemtoDreamTrackSelection::getSelectionName(femtoDreamTrackSelection::kPIDnSigmaMax, "ConfTrk"), std::vector{3.5f, 3.f, 2.5f}, FemtoDreamTrackSelection::getSelectionHelper(femtoDreamTrackSelection::kPIDnSigmaMax, "Track selection: ")}; // off set the center of the nsigma distribution to deal with bad TPC/TOF calibration Configurable ConfTrkPIDnSigmaOffsetTPC{"ConfTrkPIDnSigmaOffsetTPC", 0., "Offset for TPC nSigma because of bad calibration"}; Configurable ConfTrkPIDnSigmaOffsetTOF{"ConfTrkPIDnSigmaOffsetTOF", 0., "Offset for TOF nSigma because of bad calibration"}; Configurable> ConfTrkPIDspecies{"ConfTrkPIDspecies", std::vector{o2::track::PID::Pion, o2::track::PID::Kaon, o2::track::PID::Proton, o2::track::PID::Deuteron}, "Trk sel: Particles species for PID"}; + struct : o2::framework::ConfigurableGroup { + Configurable ConfgFlowCalculate{"ConfgFlowCalculate", false, "Evt sel: Cumulant of flow"}; // To do + Configurable ConfgQnSeparation{"ConfgQnSeparation", false, "Evt sel: Qn of event"}; + Configurable> ConfQnBinSeparator{"ConfQnBinSeparator", std::vector{-999.f, -999.f, -999.f}, "Qn bin separator"}; + Configurable ConfCentralityMax{"ConfCentralityMax", 80.f, "Evt sel: Maximum Centrality cut"}; + Configurable ConfCentBinWidth{"ConfCentBinWidth", 1.f, "Centrality bin length for qn separator"}; + Configurable ConfQnBinMin{"ConfQnBinMin", 0, "Minimum qn bin"}; + Configurable ConfQnBinMax{"ConfQnBinMax", 10, "Maximum qn bin"}; + } qnCal; + + struct : o2::framework::ConfigurableGroup { + Configurable ConfIsPbPb{"ConfIsPbPb", false, "Running on Run3 or Run2"}; // Choose if running on PbPb data + Configurable ConfIsUsePileUp{"ConfIsUsePileUp", false, "Required for choosing whether to run the pile-up cuts"}; + Configurable ConfEvNoSameBunchPileup{"ConfEvNoSameBunchPileup", false, "Require kNoSameBunchPileup selection on Events."}; + Configurable ConfEvIsGoodZvtxFT0vsPV{"ConfEvIsGoodZvtxFT0vsPV", false, "Require kIsGoodZvtxFT0vsPV selection on Events."}; + Configurable ConfEvIsGoodITSLayersAll{"ConfEvIsGoodITSLayersAll", false, "Require kIsGoodITSLayersAll selection on Events."}; + Configurable ConfEvNoCollInRofStandard{"ConfEvNoCollInRofStandard", false, "Require kNoCollInRofStandard selection on Events."}; + Configurable ConfEvNoHighMultCollInPrevRof{"ConfEvNoHighMultCollInPrevRof", false, "Require kNoHighMultCollInPrevRof selection on Events."}; + Configurable ConfEvNoCollInTimeRangeStandard{"ConfEvNoCollInTimeRangeStandard", false, "Require kNoCollInTimeRangeStandard selection on Events."}; + Configurable ConfEvIsVertexITSTPC{"ConfEvIsVertexITSTPC", false, "Require kIsVertexITSTPC selection on Events"}; + Configurable ConfTPCOccupancyMin{"ConfTPCOccupancyMin", 0, "Minimum value for TPC Occupancy selection"}; + Configurable ConfTPCOccupancyMax{"ConfTPCOccupancyMax", 1000, "Maximum value for TPC Occupancy selection"}; + } evtSel_PbPb; + HistogramRegistry qaRegistry{"QAHistos", {}, OutputObjHandlingPolicy::AnalysisObject}; HistogramRegistry Registry{"Tracks", {}, OutputObjHandlingPolicy::AnalysisObject}; + HistogramRegistry FlowRegistry{"QnandFlowInfo", {}, OutputObjHandlingPolicy::AnalysisObject}; int mRunNumber; float mMagField; @@ -139,6 +166,11 @@ struct femtoDreamProducerReducedTask { trackCuts.init(&qaRegistry, &Registry); + + if (qnCal.ConfgFlowCalculate){ + colCuts.initFlow(&FlowRegistry, qnCal.ConfgQnSeparation); + } + mRunNumber = 0; mMagField = 0.0; /// Initializing CCDB @@ -325,8 +357,166 @@ struct femtoDreamProducerReducedTask { } } - void - processData(aod::FemtoFullCollision const& col, aod::BCsWithTimestamps const&, aod::FemtoFullTracks const& tracks) + // Centrality (Multiplicity percentile) obtained from FT0C + // Pile-up rejection involved + template + void fillCollisionsAndTracks_PbPb(CollisionType const& col, TrackType const& tracks) + { + const auto vtxZ = col.posZ(); + const auto spher = colCuts.computeSphericity(col, tracks); + int mult = 0; + int multNtr = 0; + if (ConfIsRun3) { + if constexpr (useCentrality) { + mult = col.centFT0C(); + } else { + mult = 0.; + } + multNtr = col.multNTracksPV(); + } else { + mult = 1; // multiplicity percentile is known in Run 2 + multNtr = col.multTracklets(); + } + if (ConfEvtUseTPCmult) { + multNtr = col.multTPC(); + } + colCuts.fillQA(col, mult); + + /// First thing to do is to check whether the basic event selection criteria are fulfilled + /// That includes checking if there are any usable tracks in a collision + if (!colCuts.isSelectedCollision(col)) { + return; + } + if (colCuts.isEmptyCollision(col, tracks, trackCuts)) { + return; + } + + // Pileup rejection in PbPb data + if (evtSel_PbPb.ConfIsPbPb && evtSel_PbPb.ConfIsUsePileUp && + !colCuts.isPileUpCollisionPbPb(col, evtSel_PbPb.ConfEvNoSameBunchPileup, evtSel_PbPb.ConfEvIsGoodZvtxFT0vsPV, + evtSel_PbPb.ConfEvIsGoodITSLayersAll, evtSel_PbPb.ConfEvNoCollInRofStandard, + evtSel_PbPb.ConfEvNoHighMultCollInPrevRof, evtSel_PbPb.ConfEvNoCollInTimeRangeStandard, + evtSel_PbPb.ConfEvIsVertexITSTPC, + evtSel_PbPb.ConfTPCOccupancyMin, evtSel_PbPb.ConfTPCOccupancyMax)) { + return; + } + // now the table is filled + outputCollision(vtxZ, mult, multNtr, spher, mMagField); + + // these IDs are necessary to keep track of the children + // since this producer only produces the tables for tracks, there are no children + std::vector childIDs = {0, 0}; + for (auto& track : tracks) { + /// if the most open selection criteria are not fulfilled there is no point looking further at the track + if (!trackCuts.isSelectedMinimal(track)) { + continue; + } + trackCuts.fillQA(track); + // an array of two bit-wise containers of the systematic variations is obtained + // one container for the track quality cuts and one for the PID cuts + auto cutContainer = trackCuts.getCutContainer(track, track.pt(), track.eta(), sqrtf(powf(track.dcaXY(), 2.f) + powf(track.dcaZ(), 2.f))); + + // now the table is filled + outputParts(outputCollision.lastIndex(), + track.pt(), + track.eta(), + track.phi(), + aod::femtodreamparticle::ParticleType::kTrack, + cutContainer.at(femtoDreamTrackSelection::TrackContainerPosition::kCuts), + cutContainer.at(femtoDreamTrackSelection::TrackContainerPosition::kPID), + track.dcaXY(), childIDs, 0, 0); + if constexpr (isMC) { + fillMCParticle(col, track, o2::aod::femtodreamparticle::ParticleType::kTrack); + } + + if (ConfIsDebug) { + outputDebugParts(track.sign(), + (uint8_t)track.tpcNClsFound(), + track.tpcNClsFindable(), + (uint8_t)track.tpcNClsCrossedRows(), + track.tpcNClsShared(), + track.tpcInnerParam(), + track.itsNCls(), + track.itsNClsInnerBarrel(), + track.dcaXY(), + track.dcaZ(), + track.tpcSignal(), + track.tpcNSigmaEl(), + track.tpcNSigmaPi(), + track.tpcNSigmaKa(), + track.tpcNSigmaPr(), + track.tpcNSigmaDe(), + track.tpcNSigmaTr(), + track.tpcNSigmaHe(), + track.tofNSigmaEl(), + track.tofNSigmaPi(), + track.tofNSigmaKa(), + track.tofNSigmaPr(), + track.tofNSigmaDe(), + track.tofNSigmaTr(), + track.tofNSigmaHe(), + -1, + track.itsNSigmaEl(), + track.itsNSigmaPi(), + track.itsNSigmaKa(), + track.itsNSigmaPr(), + track.itsNSigmaDe(), + track.itsNSigmaTr(), + track.itsNSigmaHe(), + -999., -999., -999., -999., -999., -999., + -999., -999., -999., -999., -999., -999., -999.); + } + } + } + + // Calculate and separate qn bins + // Do and fill cumulant in qn bins + template + void fillCollisionsFlow(CollisionType const& col, TrackType const& tracks) + { + // get magnetic field for run + + const auto spher = colCuts.computeSphericity(col, tracks); + int multNtr = 0; + if (ConfIsRun3) { + multNtr = col.multNTracksPV(); + } else { + multNtr = col.multTracklets(); + } + if (ConfEvtUseTPCmult) { + multNtr = col.multTPC(); + } + + /// First thing to do is to check whether the basic event selection criteria are fulfilled + /// That includes checking if there are any usable tracks in a collision + if (!colCuts.isSelectedCollision(col)) { + return; + } + if (colCuts.isEmptyCollision(col, tracks, trackCuts)) { + return; + } + + // Pileup rejection in PbPb data + if (evtSel_PbPb.ConfIsPbPb && evtSel_PbPb.ConfIsUsePileUp && + !colCuts.isPileUpCollisionPbPb(col, evtSel_PbPb.ConfEvNoSameBunchPileup, evtSel_PbPb.ConfEvIsGoodZvtxFT0vsPV, + evtSel_PbPb.ConfEvIsGoodITSLayersAll, evtSel_PbPb.ConfEvNoCollInRofStandard, + evtSel_PbPb.ConfEvNoHighMultCollInPrevRof, evtSel_PbPb.ConfEvNoCollInTimeRangeStandard, + evtSel_PbPb.ConfEvIsVertexITSTPC, + evtSel_PbPb.ConfTPCOccupancyMin, evtSel_PbPb.ConfTPCOccupancyMax)) { + return; + } + + // Calculate and fill qnBins + auto qnBin = colCuts.myqnBin(col, qnCal.ConfCentralityMax, qnCal.ConfQnBinSeparator, spher, multNtr, 1.f); + if (qnBin < qnCal.ConfQnBinMin || qnBin > qnCal.ConfQnBinMax){ + qnBin = -999; + } + colCuts.fillCumulants(col, tracks); + colCuts.doCumulants(col, qnCal.ConfgQnSeparation, qnBin); + outputExtQnCollision(qnBin); + } + + void processData(aod::FemtoFullCollision const& col, aod::BCsWithTimestamps const&, aod::FemtoFullTracks const& tracks) { // get magnetic field for run getMagneticFieldTesla(col.bc_as()); @@ -365,8 +555,24 @@ struct femtoDreamProducerReducedTask { fillCollisionsAndTracks(col, tracksWithItsPid); } PROCESS_SWITCH(femtoDreamProducerReducedTask, processMC_noCentrality, "Provide MC data", false); + + void processData_FlowCalc(aod::FemtoFullCollision_CentPbPb const& col, + aod::BCsWithTimestamps const&, + aod::FemtoFullTracks const& tracks) + { + // get magnetic field for run + getMagneticFieldTesla(col.bc_as()); + auto tracksWithItsPid = soa::Attach(tracks); + // fill the tables + fillCollisionsAndTracks_PbPb(col, tracksWithItsPid); + if (qnCal.ConfgQnSeparation){ + fillCollisionsFlow(col, tracksWithItsPid); + } + } + PROCESS_SWITCH(femtoDreamProducerReducedTask, processData_FlowCalc, + "Provide experimental data with cumulant flow calculation", false); }; - WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { WorkflowSpec workflow{adaptAnalysisTask(cfgc)}; diff --git a/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx b/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx index 6f45f0c2672..2792eb29b4c 100644 --- a/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx +++ b/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx @@ -82,10 +82,19 @@ struct femtoDreamPairTaskTrackTrack { Filter EventMultiplicity = aod::femtodreamcollision::multNtr >= EventSel.MultMin && aod::femtodreamcollision::multNtr <= EventSel.MultMax && aod::femtodreamcollision::sphericity >= EventSel.SphericityMin; Filter EventMultiplicityPercentile = aod::femtodreamcollision::multV0M >= EventSel.MultPercentileMin && aod::femtodreamcollision::multV0M <= EventSel.MultPercentileMax; + /// qn-separator + struct : ConfigurableGroup { + Configurable doQnSeparation{"doQnSeparation", false, "Do qn separation"}; + Configurable storeEvtTrkInfo{"storeEvtTrkInfo", false, "Fill info of track1 and track2 while pariing in divided qn bins"}; + Configurable numQnBins{"numQnBins", 10, "Number of qn bins"}; + } qnCal; + using FilteredCollisions = soa::Filtered; using FilteredCollision = FilteredCollisions::iterator; using FilteredMCCollisions = soa::Filtered>; using FilteredMCCollision = FilteredMCCollisions::iterator; + using FilteredQnCollisions = soa::Filtered>; + using FilteredQnCollision = FilteredQnCollisions::iterator; using FilteredMaskedCollisions = soa::Filtered>; using FilteredMaskedCollision = FilteredMaskedCollisions::iterator; @@ -226,6 +235,11 @@ struct femtoDreamPairTaskTrackTrack { FemtoDreamPairCleaner pairCleaner; FemtoDreamDetaDphiStar pairCloseRejectionSE; FemtoDreamDetaDphiStar pairCloseRejectionME; + + // Container for correlation functions in devided qn bins + FemtoDreamContainer sameEventQnCont; + // FemtoDreamContainer mixedEventQnCont; + /// Histogram output HistogramRegistry Registry{"Output", {}, OutputObjHandlingPolicy::AnalysisObject}; @@ -268,6 +282,12 @@ struct femtoDreamPairTaskTrackTrack { pairCloseRejectionME.init(&Registry, &Registry, Option.CPRdeltaPhiMax.value, Option.CPRdeltaEtaMax.value, Option.CPRPlotPerRadii.value, 2, Option.CPROld.value); } + if (qnCal.doQnSeparation){ + sameEventQnCont.init_qn(&Registry, + Binning4D.kstar, Binning4D.mT, Binning4D.multPercentile, + Option.IsMC, Option.HighkstarCut); + } + // get bit for the collision mask std::bitset<8 * sizeof(femtodreamcollision::BitMaskType)> mask; int index = 0; @@ -618,8 +638,81 @@ struct femtoDreamPairTaskTrackTrack { } } PROCESS_SWITCH(femtoDreamPairTaskTrackTrack, processMixedEventMCMasked, "Enable processing mixed events MC with masked collisions", false); -}; + /// This function processes the same event in divided qn bins + /// col.multV0M() get the event centrality from ft0c for PbPb data + template + void doSameEventQn(PartitionType SliceTrk1, PartitionType SliceTrk2, PartType parts, Collision col) + { + if (qnCal.storeEvtTrkInfo){ + for (auto& part : SliceTrk1) { + trackHistoPartOne.fillQA(part, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); + } + + if (!Option.SameSpecies.value) { + for (auto& part : SliceTrk2) { + trackHistoPartTwo.fillQA(part, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); + } + } + } + + /// Now build the combinations + float rand = 0.; + if (Option.SameSpecies.value) { + for (auto& [p1, p2] : combinations(CombinationsStrictlyUpperIndexPolicy(SliceTrk1, SliceTrk2))) { + if (Option.CPROn.value) { + if (pairCloseRejectionSE.isClosePair(p1, p2, parts, col.magField())) { + continue; + } + } + // track cleaning + if (!pairCleaner.isCleanPair(p1, p2, parts)) { + continue; + } + if (Option.RandomizePair.value) { + rand = random->Rndm(); + } + if (rand <= 0.5) { + sameEventQnCont.setPair_qn(p1, p2, col.multV0M(), col.qnBin()); + } else { + sameEventQnCont.setPair_qn(p2, p1, col.multV0M(), col.qnBin()); + } + } + } else { + for (auto& [p1, p2] : combinations(CombinationsFullIndexPolicy(SliceTrk1, SliceTrk2))) { + if (Option.CPROn.value) { + if (pairCloseRejectionSE.isClosePair(p1, p2, parts, col.magField())) { + continue; + } + } + // track cleaning + if (!pairCleaner.isCleanPair(p1, p2, parts)) { + continue; + } + sameEventQnCont.setPair_qn(p1, p2, col.multV0M(), col.qnBin()); + } + } + } + + /// process function for to call doSameEventQn with Data + /// \param col subscribe to the collision table (Data) + /// \param parts subscribe to the femtoDreamParticleTable + void processSameEventQn(FilteredQnCollision& col, o2::aod::FDParticles& parts) + { + if (qnCal.storeEvtTrkInfo) { + fillCollision(col); + } + auto SliceTrk1 = PartitionTrk1->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache); + auto SliceTrk2 = PartitionTrk2->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache); + if (SliceTrk1.size() == 0 && SliceTrk2.size() == 0) { + return; + } + if (qnCal.doQnSeparation){ + doSameEventQn(SliceTrk1, SliceTrk2, parts, col); + } + } + PROCESS_SWITCH(femtoDreamPairTaskTrackTrack, processSameEventQn, "Enable processing same event in divided qn bins", false); +}; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { WorkflowSpec workflow{ From 11c2bae04cf74ed1d34411d4d8a1b2ce0e5f790f Mon Sep 17 00:00:00 2001 From: wenyaCern Date: Thu, 11 Sep 2025 14:35:52 +0200 Subject: [PATCH 02/13] Add additional track cuts confgurable --- .../Core/femtoDreamCollisionSelection.h | 2 +- .../femtoDreamProducerReducedTask.cxx | 20 +++++++++++++++++-- 2 files changed, 19 insertions(+), 3 deletions(-) diff --git a/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h b/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h index 5a2ab6bac62..377411283c0 100644 --- a/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h +++ b/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h @@ -234,7 +234,7 @@ class FemtoDreamCollisionSelection if (doQnSeparation){ for (int iqn(0); iqn < mumQnBins; ++iqn) { mHistogramQn->add(("Qn/profileC22_" + std::to_string(iqn)).c_str(), "; cent; c22", kTProfile, {{10, 0, 100}}); - mHistogramQn->add(("Qn/mult_" + std::to_string(iqn)).c_str(), "; cent; c22", kTH1F, {{100, 0, 1000}}); + mHistogramQn->add(("Qn/mult_" + std::to_string(iqn)).c_str(), "; cent; c22", kTH1F, {{100, 0, 3500}}); } } return; diff --git a/PWGCF/FemtoDream/TableProducer/femtoDreamProducerReducedTask.cxx b/PWGCF/FemtoDream/TableProducer/femtoDreamProducerReducedTask.cxx index a3fa912482a..bca22598b0b 100644 --- a/PWGCF/FemtoDream/TableProducer/femtoDreamProducerReducedTask.cxx +++ b/PWGCF/FemtoDream/TableProducer/femtoDreamProducerReducedTask.cxx @@ -131,9 +131,17 @@ struct femtoDreamProducerReducedTask { Configurable ConfTPCOccupancyMax{"ConfTPCOccupancyMax", 1000, "Maximum value for TPC Occupancy selection"}; } evtSel_PbPb; + struct : o2::framework::ConfigurableGroup { + Configurable ConfTrkSpecialCuts{"ConfTrkSpecialCuts", false, "Choose for special track cuts"}; + Configurable ConfTPCFracsClsMax{"ConfTPCFracsCls", 0.4, "Maximum value for fraction of shared TPC clusters"}; + Configurable ConfTPCChi2NClMax{"ConfTPCChi2NCl", 2.5, "Maximum value chi2 per cluster for TPC"}; + Configurable ConfITSChi2NClMax{"ConfITSChi2NCl", 36, "Maximum value chi2 per cluster for ITS"}; + } specialTrkSel; + // Filter globalCutFilter = requireGlobalTrackInFilter(); + HistogramRegistry qaRegistry{"QAHistos", {}, OutputObjHandlingPolicy::AnalysisObject}; HistogramRegistry Registry{"Tracks", {}, OutputObjHandlingPolicy::AnalysisObject}; - HistogramRegistry FlowRegistry{"QnandFlowInfo", {}, OutputObjHandlingPolicy::AnalysisObject}; + HistogramRegistry FlowRegistry{"Qn", {}, OutputObjHandlingPolicy::AnalysisObject}; int mRunNumber; float mMagField; @@ -380,7 +388,6 @@ struct femtoDreamProducerReducedTask { if (ConfEvtUseTPCmult) { multNtr = col.multTPC(); } - colCuts.fillQA(col, mult); /// First thing to do is to check whether the basic event selection criteria are fulfilled /// That includes checking if there are any usable tracks in a collision @@ -400,8 +407,10 @@ struct femtoDreamProducerReducedTask { evtSel_PbPb.ConfTPCOccupancyMin, evtSel_PbPb.ConfTPCOccupancyMax)) { return; } + // now the table is filled outputCollision(vtxZ, mult, multNtr, spher, mMagField); + colCuts.fillQA(col, mult); // these IDs are necessary to keep track of the children // since this producer only produces the tables for tracks, there are no children @@ -411,6 +420,13 @@ struct femtoDreamProducerReducedTask { if (!trackCuts.isSelectedMinimal(track)) { continue; } + if (specialTrkSel.ConfTrkSpecialCuts + && track.tpcFractionSharedCls()>specialTrkSel.ConfTPCFracsClsMax + && track.tpcChi2NCl()>specialTrkSel.ConfTPCChi2NClMax + && track.itsChi2NCl()>specialTrkSel.ConfITSChi2NClMax) { + continue; + } + trackCuts.fillQA(track); // an array of two bit-wise containers of the systematic variations is obtained // one container for the track quality cuts and one for the PID cuts From bf9f57a5e233326beab090c65a2f43529c45ac21 Mon Sep 17 00:00:00 2001 From: wenyaCern Date: Fri, 12 Sep 2025 23:50:38 +0200 Subject: [PATCH 03/13] recover reduced task --- .../femtoDreamProducerReducedTask.cxx | 230 +----------------- 1 file changed, 4 insertions(+), 226 deletions(-) diff --git a/PWGCF/FemtoDream/TableProducer/femtoDreamProducerReducedTask.cxx b/PWGCF/FemtoDream/TableProducer/femtoDreamProducerReducedTask.cxx index bca22598b0b..a1cd73cbf6f 100644 --- a/PWGCF/FemtoDream/TableProducer/femtoDreamProducerReducedTask.cxx +++ b/PWGCF/FemtoDream/TableProducer/femtoDreamProducerReducedTask.cxx @@ -50,7 +50,6 @@ namespace o2::aod using FemtoFullCollision = soa::Join::iterator; using FemtoFullCollisionMC = soa::Join::iterator; using FemtoFullCollision_noCent_MC = soa::Join::iterator; -using FemtoFullCollision_CentPbPb = soa::Join::iterator; using FemtoFullTracks = soa::Join outputCollision; - Produces outputExtQnCollision; Produces outputParts; Produces outputPartsMC; Produces outputDebugParts; @@ -101,47 +99,14 @@ struct femtoDreamProducerReducedTask { Configurable> ConfTrkITSnclsIbMin{FemtoDreamTrackSelection::getSelectionName(femtoDreamTrackSelection::kITSnClsIbMin, "ConfTrk"), std::vector{-1.f, 1.f}, FemtoDreamTrackSelection::getSelectionHelper(femtoDreamTrackSelection::kITSnClsIbMin, "Track selection: ")}; Configurable> ConfTrkDCAxyMax{FemtoDreamTrackSelection::getSelectionName(femtoDreamTrackSelection::kDCAxyMax, "ConfTrk"), std::vector{0.1f, 0.5f}, FemtoDreamTrackSelection::getSelectionHelper(femtoDreamTrackSelection::kDCAxyMax, "Track selection: ")}; /// here we need an open cut to do the DCA fits later on! Configurable> ConfTrkDCAzMax{FemtoDreamTrackSelection::getSelectionName(femtoDreamTrackSelection::kDCAzMax, "ConfTrk"), std::vector{0.2f, 0.5f}, FemtoDreamTrackSelection::getSelectionHelper(femtoDreamTrackSelection::kDCAzMax, "Track selection: ")}; - Configurable> ConfTrkPIDnSigmaMax{FemtoDreamTrackSelection::getSelectionName(femtoDreamTrackSelection::kPIDnSigmaMax, "ConfTrk"), std::vector{3.5f, 3.f, 2.5f}, FemtoDreamTrackSelection::getSelectionHelper(femtoDreamTrackSelection::kPIDnSigmaMax, "Track selection: ")}; + Configurable> ConfTrkPIDnSigmaMax{FemtoDreamTrackSelection::getSelectionName(femtoDreamTrackSelection::kPIDnSigmaMax, "Conf"), std::vector{3.5f, 3.f, 2.5f}, FemtoDreamTrackSelection::getSelectionHelper(femtoDreamTrackSelection::kPIDnSigmaMax, "Track selection: ")}; // off set the center of the nsigma distribution to deal with bad TPC/TOF calibration Configurable ConfTrkPIDnSigmaOffsetTPC{"ConfTrkPIDnSigmaOffsetTPC", 0., "Offset for TPC nSigma because of bad calibration"}; Configurable ConfTrkPIDnSigmaOffsetTOF{"ConfTrkPIDnSigmaOffsetTOF", 0., "Offset for TOF nSigma because of bad calibration"}; Configurable> ConfTrkPIDspecies{"ConfTrkPIDspecies", std::vector{o2::track::PID::Pion, o2::track::PID::Kaon, o2::track::PID::Proton, o2::track::PID::Deuteron}, "Trk sel: Particles species for PID"}; - struct : o2::framework::ConfigurableGroup { - Configurable ConfgFlowCalculate{"ConfgFlowCalculate", false, "Evt sel: Cumulant of flow"}; // To do - Configurable ConfgQnSeparation{"ConfgQnSeparation", false, "Evt sel: Qn of event"}; - Configurable> ConfQnBinSeparator{"ConfQnBinSeparator", std::vector{-999.f, -999.f, -999.f}, "Qn bin separator"}; - Configurable ConfCentralityMax{"ConfCentralityMax", 80.f, "Evt sel: Maximum Centrality cut"}; - Configurable ConfCentBinWidth{"ConfCentBinWidth", 1.f, "Centrality bin length for qn separator"}; - Configurable ConfQnBinMin{"ConfQnBinMin", 0, "Minimum qn bin"}; - Configurable ConfQnBinMax{"ConfQnBinMax", 10, "Maximum qn bin"}; - } qnCal; - - struct : o2::framework::ConfigurableGroup { - Configurable ConfIsPbPb{"ConfIsPbPb", false, "Running on Run3 or Run2"}; // Choose if running on PbPb data - Configurable ConfIsUsePileUp{"ConfIsUsePileUp", false, "Required for choosing whether to run the pile-up cuts"}; - Configurable ConfEvNoSameBunchPileup{"ConfEvNoSameBunchPileup", false, "Require kNoSameBunchPileup selection on Events."}; - Configurable ConfEvIsGoodZvtxFT0vsPV{"ConfEvIsGoodZvtxFT0vsPV", false, "Require kIsGoodZvtxFT0vsPV selection on Events."}; - Configurable ConfEvIsGoodITSLayersAll{"ConfEvIsGoodITSLayersAll", false, "Require kIsGoodITSLayersAll selection on Events."}; - Configurable ConfEvNoCollInRofStandard{"ConfEvNoCollInRofStandard", false, "Require kNoCollInRofStandard selection on Events."}; - Configurable ConfEvNoHighMultCollInPrevRof{"ConfEvNoHighMultCollInPrevRof", false, "Require kNoHighMultCollInPrevRof selection on Events."}; - Configurable ConfEvNoCollInTimeRangeStandard{"ConfEvNoCollInTimeRangeStandard", false, "Require kNoCollInTimeRangeStandard selection on Events."}; - Configurable ConfEvIsVertexITSTPC{"ConfEvIsVertexITSTPC", false, "Require kIsVertexITSTPC selection on Events"}; - Configurable ConfTPCOccupancyMin{"ConfTPCOccupancyMin", 0, "Minimum value for TPC Occupancy selection"}; - Configurable ConfTPCOccupancyMax{"ConfTPCOccupancyMax", 1000, "Maximum value for TPC Occupancy selection"}; - } evtSel_PbPb; - - struct : o2::framework::ConfigurableGroup { - Configurable ConfTrkSpecialCuts{"ConfTrkSpecialCuts", false, "Choose for special track cuts"}; - Configurable ConfTPCFracsClsMax{"ConfTPCFracsCls", 0.4, "Maximum value for fraction of shared TPC clusters"}; - Configurable ConfTPCChi2NClMax{"ConfTPCChi2NCl", 2.5, "Maximum value chi2 per cluster for TPC"}; - Configurable ConfITSChi2NClMax{"ConfITSChi2NCl", 36, "Maximum value chi2 per cluster for ITS"}; - } specialTrkSel; - // Filter globalCutFilter = requireGlobalTrackInFilter(); - HistogramRegistry qaRegistry{"QAHistos", {}, OutputObjHandlingPolicy::AnalysisObject}; HistogramRegistry Registry{"Tracks", {}, OutputObjHandlingPolicy::AnalysisObject}; - HistogramRegistry FlowRegistry{"Qn", {}, OutputObjHandlingPolicy::AnalysisObject}; int mRunNumber; float mMagField; @@ -174,11 +139,6 @@ struct femtoDreamProducerReducedTask { trackCuts.init(&qaRegistry, &Registry); - - if (qnCal.ConfgFlowCalculate){ - colCuts.initFlow(&FlowRegistry, qnCal.ConfgQnSeparation); - } - mRunNumber = 0; mMagField = 0.0; /// Initializing CCDB @@ -365,174 +325,8 @@ struct femtoDreamProducerReducedTask { } } - // Centrality (Multiplicity percentile) obtained from FT0C - // Pile-up rejection involved - template - void fillCollisionsAndTracks_PbPb(CollisionType const& col, TrackType const& tracks) - { - const auto vtxZ = col.posZ(); - const auto spher = colCuts.computeSphericity(col, tracks); - int mult = 0; - int multNtr = 0; - if (ConfIsRun3) { - if constexpr (useCentrality) { - mult = col.centFT0C(); - } else { - mult = 0.; - } - multNtr = col.multNTracksPV(); - } else { - mult = 1; // multiplicity percentile is known in Run 2 - multNtr = col.multTracklets(); - } - if (ConfEvtUseTPCmult) { - multNtr = col.multTPC(); - } - - /// First thing to do is to check whether the basic event selection criteria are fulfilled - /// That includes checking if there are any usable tracks in a collision - if (!colCuts.isSelectedCollision(col)) { - return; - } - if (colCuts.isEmptyCollision(col, tracks, trackCuts)) { - return; - } - - // Pileup rejection in PbPb data - if (evtSel_PbPb.ConfIsPbPb && evtSel_PbPb.ConfIsUsePileUp && - !colCuts.isPileUpCollisionPbPb(col, evtSel_PbPb.ConfEvNoSameBunchPileup, evtSel_PbPb.ConfEvIsGoodZvtxFT0vsPV, - evtSel_PbPb.ConfEvIsGoodITSLayersAll, evtSel_PbPb.ConfEvNoCollInRofStandard, - evtSel_PbPb.ConfEvNoHighMultCollInPrevRof, evtSel_PbPb.ConfEvNoCollInTimeRangeStandard, - evtSel_PbPb.ConfEvIsVertexITSTPC, - evtSel_PbPb.ConfTPCOccupancyMin, evtSel_PbPb.ConfTPCOccupancyMax)) { - return; - } - - // now the table is filled - outputCollision(vtxZ, mult, multNtr, spher, mMagField); - colCuts.fillQA(col, mult); - - // these IDs are necessary to keep track of the children - // since this producer only produces the tables for tracks, there are no children - std::vector childIDs = {0, 0}; - for (auto& track : tracks) { - /// if the most open selection criteria are not fulfilled there is no point looking further at the track - if (!trackCuts.isSelectedMinimal(track)) { - continue; - } - if (specialTrkSel.ConfTrkSpecialCuts - && track.tpcFractionSharedCls()>specialTrkSel.ConfTPCFracsClsMax - && track.tpcChi2NCl()>specialTrkSel.ConfTPCChi2NClMax - && track.itsChi2NCl()>specialTrkSel.ConfITSChi2NClMax) { - continue; - } - - trackCuts.fillQA(track); - // an array of two bit-wise containers of the systematic variations is obtained - // one container for the track quality cuts and one for the PID cuts - auto cutContainer = trackCuts.getCutContainer(track, track.pt(), track.eta(), sqrtf(powf(track.dcaXY(), 2.f) + powf(track.dcaZ(), 2.f))); - - // now the table is filled - outputParts(outputCollision.lastIndex(), - track.pt(), - track.eta(), - track.phi(), - aod::femtodreamparticle::ParticleType::kTrack, - cutContainer.at(femtoDreamTrackSelection::TrackContainerPosition::kCuts), - cutContainer.at(femtoDreamTrackSelection::TrackContainerPosition::kPID), - track.dcaXY(), childIDs, 0, 0); - if constexpr (isMC) { - fillMCParticle(col, track, o2::aod::femtodreamparticle::ParticleType::kTrack); - } - - if (ConfIsDebug) { - outputDebugParts(track.sign(), - (uint8_t)track.tpcNClsFound(), - track.tpcNClsFindable(), - (uint8_t)track.tpcNClsCrossedRows(), - track.tpcNClsShared(), - track.tpcInnerParam(), - track.itsNCls(), - track.itsNClsInnerBarrel(), - track.dcaXY(), - track.dcaZ(), - track.tpcSignal(), - track.tpcNSigmaEl(), - track.tpcNSigmaPi(), - track.tpcNSigmaKa(), - track.tpcNSigmaPr(), - track.tpcNSigmaDe(), - track.tpcNSigmaTr(), - track.tpcNSigmaHe(), - track.tofNSigmaEl(), - track.tofNSigmaPi(), - track.tofNSigmaKa(), - track.tofNSigmaPr(), - track.tofNSigmaDe(), - track.tofNSigmaTr(), - track.tofNSigmaHe(), - -1, - track.itsNSigmaEl(), - track.itsNSigmaPi(), - track.itsNSigmaKa(), - track.itsNSigmaPr(), - track.itsNSigmaDe(), - track.itsNSigmaTr(), - track.itsNSigmaHe(), - -999., -999., -999., -999., -999., -999., - -999., -999., -999., -999., -999., -999., -999.); - } - } - } - - // Calculate and separate qn bins - // Do and fill cumulant in qn bins - template - void fillCollisionsFlow(CollisionType const& col, TrackType const& tracks) - { - // get magnetic field for run - - const auto spher = colCuts.computeSphericity(col, tracks); - int multNtr = 0; - if (ConfIsRun3) { - multNtr = col.multNTracksPV(); - } else { - multNtr = col.multTracklets(); - } - if (ConfEvtUseTPCmult) { - multNtr = col.multTPC(); - } - - /// First thing to do is to check whether the basic event selection criteria are fulfilled - /// That includes checking if there are any usable tracks in a collision - if (!colCuts.isSelectedCollision(col)) { - return; - } - if (colCuts.isEmptyCollision(col, tracks, trackCuts)) { - return; - } - - // Pileup rejection in PbPb data - if (evtSel_PbPb.ConfIsPbPb && evtSel_PbPb.ConfIsUsePileUp && - !colCuts.isPileUpCollisionPbPb(col, evtSel_PbPb.ConfEvNoSameBunchPileup, evtSel_PbPb.ConfEvIsGoodZvtxFT0vsPV, - evtSel_PbPb.ConfEvIsGoodITSLayersAll, evtSel_PbPb.ConfEvNoCollInRofStandard, - evtSel_PbPb.ConfEvNoHighMultCollInPrevRof, evtSel_PbPb.ConfEvNoCollInTimeRangeStandard, - evtSel_PbPb.ConfEvIsVertexITSTPC, - evtSel_PbPb.ConfTPCOccupancyMin, evtSel_PbPb.ConfTPCOccupancyMax)) { - return; - } - - // Calculate and fill qnBins - auto qnBin = colCuts.myqnBin(col, qnCal.ConfCentralityMax, qnCal.ConfQnBinSeparator, spher, multNtr, 1.f); - if (qnBin < qnCal.ConfQnBinMin || qnBin > qnCal.ConfQnBinMax){ - qnBin = -999; - } - colCuts.fillCumulants(col, tracks); - colCuts.doCumulants(col, qnCal.ConfgQnSeparation, qnBin); - outputExtQnCollision(qnBin); - } - - void processData(aod::FemtoFullCollision const& col, aod::BCsWithTimestamps const&, aod::FemtoFullTracks const& tracks) + void + processData(aod::FemtoFullCollision const& col, aod::BCsWithTimestamps const&, aod::FemtoFullTracks const& tracks) { // get magnetic field for run getMagneticFieldTesla(col.bc_as()); @@ -571,24 +365,8 @@ struct femtoDreamProducerReducedTask { fillCollisionsAndTracks(col, tracksWithItsPid); } PROCESS_SWITCH(femtoDreamProducerReducedTask, processMC_noCentrality, "Provide MC data", false); - - void processData_FlowCalc(aod::FemtoFullCollision_CentPbPb const& col, - aod::BCsWithTimestamps const&, - aod::FemtoFullTracks const& tracks) - { - // get magnetic field for run - getMagneticFieldTesla(col.bc_as()); - auto tracksWithItsPid = soa::Attach(tracks); - // fill the tables - fillCollisionsAndTracks_PbPb(col, tracksWithItsPid); - if (qnCal.ConfgQnSeparation){ - fillCollisionsFlow(col, tracksWithItsPid); - } - } - PROCESS_SWITCH(femtoDreamProducerReducedTask, processData_FlowCalc, - "Provide experimental data with cumulant flow calculation", false); }; + WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { WorkflowSpec workflow{adaptAnalysisTask(cfgc)}; From ee6475371865e7f57d24545e6476a268c31a47c3 Mon Sep 17 00:00:00 2001 From: wenyaCern Date: Fri, 12 Sep 2025 23:56:52 +0200 Subject: [PATCH 04/13] recover reduced task and edit full task --- PWGCF/DataModel/FemtoDerived.h | 8 +- .../Core/femtoDreamCollisionSelection.h | 180 +++++++++--------- PWGCF/FemtoDream/Core/femtoDreamContainer.h | 5 +- .../TableProducer/femtoDreamProducerTask.cxx | 150 ++++++++++++++- .../Tasks/femtoDreamPairTaskTrackTrack.cxx | 60 +++++- 5 files changed, 299 insertions(+), 104 deletions(-) diff --git a/PWGCF/DataModel/FemtoDerived.h b/PWGCF/DataModel/FemtoDerived.h index bf60c53412f..674c7464215 100644 --- a/PWGCF/DataModel/FemtoDerived.h +++ b/PWGCF/DataModel/FemtoDerived.h @@ -35,6 +35,7 @@ enum CollisionBinning { kMult, //! Bin collision in number of charged tracks for mixing kMultPercentile, //! Bin collision in multiplicity percentile for mixing kMultMultPercentile, //! Bin collision in number of charged tracks and multiplicity percentile for mixing + kMultPercentileqn, //! Bin collision in multiplicity percentile an qn value for mixing kNCollisionBinning }; @@ -51,7 +52,8 @@ DECLARE_SOA_COLUMN(BitMaskTrackThree, bitmaskTrackThree, BitMaskType); //! Bit f DECLARE_SOA_COLUMN(Downsample, downsample, bool); //! Flag for downsampling -DECLARE_SOA_COLUMN(QnBin, qnBin, int); //! qn bins for dividing events +DECLARE_SOA_COLUMN(QnVal, qnVal, int); //! qn bins for dividing events +DECLARE_SOA_COLUMN(Occupancy, occupancy, int); //! TPC occupancy } // namespace femtodreamcollision DECLARE_SOA_TABLE_STAGED(FDCollisions, "FDCOLLISION", @@ -64,8 +66,8 @@ DECLARE_SOA_TABLE_STAGED(FDCollisions, "FDCOLLISION", using FDCollision = FDCollisions::iterator; DECLARE_SOA_TABLE(FDExtQnCollisions, "AOD", "FDEXTCOLLISION", - femtodreamcollision::QnBin); -using FDExtQnCollision = FDExtQnCollisions::iterator; + femtodreamcollision::QnVal, + femtodreamcollision::Occupancy); DECLARE_SOA_TABLE(FDColMasks, "AOD", "FDCOLMASK", femtodreamcollision::BitMaskTrackOne, diff --git a/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h b/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h index 377411283c0..181a04d247c 100644 --- a/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h +++ b/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h @@ -166,10 +166,7 @@ class FemtoDreamCollisionSelection /// \return whether or not the collisions fulfills the specified selections template bool isPileUpCollisionPbPb(C const& col, - bool noSameBunchPileup, bool isGoodZvtxFT0vsPV, - bool isGoodITSLayersAll, bool noCollInRofStandard, - bool noHighMultCollInPrevRof, bool noCollInTimeRangeStandard, - bool /*isVertexITSTPC*/, + bool noSameBunchPileup, bool isGoodITSLayersAll, int tpcOccupancyMin, int tpcOccupancyMax) { const auto occupancy = col.trackOccupancyInTimeRange(); @@ -177,13 +174,8 @@ class FemtoDreamCollisionSelection return false; } if ((noSameBunchPileup && !col.selection_bit(aod::evsel::kNoSameBunchPileup)) - || (isGoodZvtxFT0vsPV && !col.selection_bit(aod::evsel::kIsGoodZvtxFT0vsPV)) || (isGoodITSLayersAll && !col.selection_bit(aod::evsel::kIsGoodITSLayersAll)) - || (noCollInRofStandard && !col.selection_bit(aod::evsel::kNoCollInRofStandard)) - || (noHighMultCollInPrevRof && !col.selection_bit(aod::evsel::kNoHighMultCollInPrevRof)) - || (noCollInTimeRangeStandard && !col.selection_bit(aod::evsel::kNoCollInTimeRangeStandard)) - // || (isVertexITSTPC && !col.selection_bit(aod::evsel::kIsVertexITSTPC)) - ) { + ) { return false; } @@ -209,6 +201,23 @@ class FemtoDreamCollisionSelection } } + /// Initializes histograms for qn bin + /// \param registry Histogram registry to be passed + void initQn(HistogramRegistry* registry, int mumQnBins = 10) + { + mHistogramQn = registry; + mHistogramQn->add("Event/centFT0CBefore", "; cent", kTH1F, {{10, 0, 100}}); + mHistogramQn->add("Event/centFT0CAfter", "; cent", kTH1F, {{10, 0, 100}}); + mHistogramQn->add("Event/centVsqn", "; cent; qn", kTH2F, {{10, 0, 100}, {100, 0, 1000}}); + mHistogramQn->add("Event/centVsqnVsSpher", "; cent; qn; Sphericity", kTH3F, {{10, 0, 100}, {100, 0, 1000}, {100, 0, 1}}); + mHistogramQn->add("Event/qnBin", "; qnBin; entries", kTH1F, {{20, 0, 20}}); + + for (int iqn(0); iqn < mumQnBins; ++iqn) { + mHistogramQn->add(("Qn/mult_" + std::to_string(iqn)).c_str(), "; cent; c22", kTH1F, {{100, 0, 3500}}); + } + return; + } + /// Initializes histograms for the flow calculation /// \param registry Histogram registry to be passed void initFlow(HistogramRegistry* registry, bool doQnSeparation, int mumQnBins = 10, int binPt = 100, int binEta = 32) @@ -222,19 +231,13 @@ class FemtoDreamCollisionSelection mImQ2thisEvt = new TH2D("ImQ2thisEvt", "", binPt, 0., 5., binEta, -0.8, 0.8); mMQthisEvt = new TH2D("MQthisEvt", "", binPt, 0., 5., binEta, -0.8, 0.8); mMQWeightthisEvt = new TH2D("MQWeightthisEvt", "", binPt, 0., 5., binEta, -0.8, 0.8); - mHistogramQn = registry; - mHistogramQn->add("Event/centFT0CBefore", "; cent", kTH1F, {{10, 0, 100}}); - mHistogramQn->add("Event/centFT0CAfter", "; cent", kTH1F, {{10, 0, 100}}); - mHistogramQn->add("Event/centVsqn", "; cent; qn", kTH2F, {{10, 0, 100}, {100, 0, 1000}}); - mHistogramQn->add("Event/centVsqnVsSpher", "; cent; qn; Sphericity", kTH3F, {{10, 0, 100}, {100, 0, 1000}, {100, 0, 1}}); - mHistogramQn->add("Event/qnBin", "; qnBin; entries", kTH1F, {{20, 0, 20}}); + mHistogramQn = registry; mHistogramQn->add("Event/profileC22", "; cent; c22", kTProfile, {{10, 0, 100}}); mHistogramQn->add("Event/profileC24", "; cent; c24", kTProfile, {{10, 0, 100}}); if (doQnSeparation){ for (int iqn(0); iqn < mumQnBins; ++iqn) { mHistogramQn->add(("Qn/profileC22_" + std::to_string(iqn)).c_str(), "; cent; c22", kTProfile, {{10, 0, 100}}); - mHistogramQn->add(("Qn/mult_" + std::to_string(iqn)).c_str(), "; cent; c22", kTH1F, {{100, 0, 3500}}); } } return; @@ -325,9 +328,9 @@ class FemtoDreamCollisionSelection /// \todo to be implemented! /// \return the 1-d qn-vector separator to 2-d - std::vector> getQnBinSeparator2D(std::vector flat) + std::vector> getQnBinSeparator2D(std::vector flat, const int numQnBins = 10) { - constexpr size_t nBins = 11; + size_t nBins = numQnBins+1; if (flat.empty() || flat.size() % nBins != 0) { LOGP(error, "ConfQnBinSeparator size = {} is not divisible by {}", @@ -348,23 +351,21 @@ class FemtoDreamCollisionSelection /// \todo to be implemented! /// Get the bin number of qn-vector(FT0C) of an event - /// \tparam T type of the collision - /// \param col Collision /// \param centBinWidth centrality bin width, example: per 1%, per 10% ... /// \return bin number of qn-vector of the event - template - int myqnBin(T const& col, float centMax, std::vector qnBinSeparator, float fSpher, float fMult, float centBinWidth = 1.f) + int myqnBin(float centrality, float centMax, std::vector qnBinSeparator, bool doFillHisto, float fSpher, float qn, const int numQnBins, float mult, float centBinWidth = 1.f) { - auto twoDSeparator = getQnBinSeparator2D(qnBinSeparator); + auto twoDSeparator = getQnBinSeparator2D(qnBinSeparator, numQnBins); if (twoDSeparator.empty() || twoDSeparator[0][0] == -999.) { LOGP(warning, "ConfQnBinSeparator not set, using default fallback!"); return -999; // safe fallback } - mHistogramQn->fill(HIST("Event/centFT0CBefore"), col.centFT0C()); + if (doFillHisto) + mHistogramQn->fill(HIST("Event/centFT0CBefore"), centrality); + int qnBin = -999; - float qn = computeqnVec(col); - int mycentBin = static_cast(col.centFT0C() / centBinWidth); + int mycentBin = static_cast(centrality / centBinWidth); if (mycentBin >= static_cast(centMax / centBinWidth)) return qnBin; @@ -379,47 +380,52 @@ class FemtoDreamCollisionSelection continue; } } - - mHistogramQn->fill(HIST("Event/centFT0CAfter"), col.centFT0C()); - mHistogramQn->fill(HIST("Event/centVsqn"), col.centFT0C(), qn); - mHistogramQn->fill(HIST("Event/centVsqnVsSpher"), col.centFT0C(), qn, fSpher); - mHistogramQn->fill(HIST("Event/qnBin"), qnBin); - if (qnBin >= 0 && qnBin < 10){ - switch (qnBin) { - case 0: - mHistogramQn->fill(HIST("Qn/mult_") + HIST("0"), fMult); - break; - case 1: - mHistogramQn->fill(HIST("Qn/mult_") + HIST("1"), fMult); - break; - case 2: - mHistogramQn->fill(HIST("Qn/mult_") + HIST("2"), fMult); - break; - case 3: - mHistogramQn->fill(HIST("Qn/mult_") + HIST("3"), fMult); - break; - case 4: - mHistogramQn->fill(HIST("Qn/mult_") + HIST("4"), fMult); - break; - case 5: - mHistogramQn->fill(HIST("Qn/mult_") + HIST("5"), fMult); - break; - case 6: - mHistogramQn->fill(HIST("Qn/mult_") + HIST("6"), fMult); - break; - case 7: - mHistogramQn->fill(HIST("Qn/mult_") + HIST("7"), fMult); - break; - case 8: - mHistogramQn->fill(HIST("Qn/mult_") + HIST("8"), fMult); - break; - case 9: - mHistogramQn->fill(HIST("Qn/mult_") + HIST("9"), fMult); - break; - default: - return qnBin; // invalid qn bin - } + + mQnBin = qnBin; + + if (doFillHisto){ + mHistogramQn->fill(HIST("Event/centFT0CAfter"), centrality); + mHistogramQn->fill(HIST("Event/centVsqn"), centrality, qn); + mHistogramQn->fill(HIST("Event/centVsqnVsSpher"), centrality, qn, fSpher); + mHistogramQn->fill(HIST("Event/qnBin"), qnBin); + if (qnBin >= 0 && qnBin < numQnBins){ + switch (qnBin) { + case 0: + mHistogramQn->fill(HIST("Qn/mult_") + HIST("0"), mult); + break; + case 1: + mHistogramQn->fill(HIST("Qn/mult_") + HIST("1"), mult); + break; + case 2: + mHistogramQn->fill(HIST("Qn/mult_") + HIST("2"), mult); + break; + case 3: + mHistogramQn->fill(HIST("Qn/mult_") + HIST("3"), mult); + break; + case 4: + mHistogramQn->fill(HIST("Qn/mult_") + HIST("4"), mult); + break; + case 5: + mHistogramQn->fill(HIST("Qn/mult_") + HIST("5"), mult); + break; + case 6: + mHistogramQn->fill(HIST("Qn/mult_") + HIST("6"), mult); + break; + case 7: + mHistogramQn->fill(HIST("Qn/mult_") + HIST("7"), mult); + break; + case 8: + mHistogramQn->fill(HIST("Qn/mult_") + HIST("8"), mult); + break; + case 9: + mHistogramQn->fill(HIST("Qn/mult_") + HIST("9"), mult); + break; + default: + return qnBin; // invalid qn bin + } + } } + return qnBin; } @@ -430,11 +436,11 @@ class FemtoDreamCollisionSelection /// \tparam T2 type of the tracks /// \param tracks All tracks template - void fillCumulants(T1 const& col, T2 const& tracks, float fHarmonic=2.f) + bool fillCumulants(T1 const& col, T2 const& tracks, float fHarmonic=2.f) { int numOfTracks = col.numContrib(); if (numOfTracks < 3) - return ; + return false; mReQthisEvt->Reset(); mImQthisEvt->Reset(); @@ -459,7 +465,7 @@ class FemtoDreamCollisionSelection mMQthisEvt ->Fill(pt, eta); mMQWeightthisEvt ->Fill(pt, eta, weight); } - return; + return true; } /// \todo to be implemented! @@ -468,9 +474,12 @@ class FemtoDreamCollisionSelection /// \param doQnSeparation to fill flow in divied qn bins /// \param qnBin should be in 0-9 /// \param fEtaGap eta gap for flow cumulant - template - void doCumulants(T const& col, bool doQnSeparation = false, int qnBin = -999, int mumQnBinNum = 10, float fEtaGap = 0.3f, int binPt = 100, int binEta = 32) + template + void doCumulants(T1 const& col, T2 const& tracks, float centrality, bool doQnSeparation = false, int numQnBins = 10, float fEtaGap = 0.3f, int binPt = 100, int binEta = 32) { + if (!fillCumulants(col, tracks)) + return; + if (mMQthisEvt->Integral(1, binPt, 1, binEta) < 2) return; @@ -495,38 +504,38 @@ class FemtoDreamCollisionSelection TComplex negEtaQ = TComplex(negEtaRe, negEtaIm); TComplex negEtaQStar = TComplex::Conjugate(negEtaQ); - mHistogramQn->get(HIST("Event/profileC22"))->Fill(col.centFT0C(), (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); - if (doQnSeparation && qnBin >= 0 && qnBin < mumQnBinNum){ - switch (qnBin) { + mHistogramQn->get(HIST("Event/profileC22"))->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + if (doQnSeparation && mQnBin >= 0 && mQnBin < numQnBins){ + switch (mQnBin) { case 0: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("0"))->Fill(col.centFT0C(), (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("0"))->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); break; case 1: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("1"))->Fill(col.centFT0C(), (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("1"))->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); break; case 2: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("2"))->Fill(col.centFT0C(), (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("2"))->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); break; case 3: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("3"))->Fill(col.centFT0C(), (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("3"))->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); break; case 4: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("4"))->Fill(col.centFT0C(), (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("4"))->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); break; case 5: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("5"))->Fill(col.centFT0C(), (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("5"))->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); break; case 6: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("6"))->Fill(col.centFT0C(), (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("6"))->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); break; case 7: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("7"))->Fill(col.centFT0C(), (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("7"))->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); break; case 8: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("8"))->Fill(col.centFT0C(), (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("8"))->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); break; case 9: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("9"))->Fill(col.centFT0C(), (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("9"))->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); break; default: return; // invalid qn bin @@ -547,6 +556,7 @@ class FemtoDreamCollisionSelection float mZvtxMax = 999.f; ///< Maximal deviation from nominal z-vertex (cm) float mMinSphericity = 0.f; float mSphericityPtmin = 0.f; + int mQnBin = -999; HistogramRegistry* mHistogramQn = nullptr; ///< For flow cumulant output TH2D* mReQthisEvt = nullptr; ///< For flow cumulant in an event TH2D* mImQthisEvt = nullptr; ///< For flow cumulant in an event diff --git a/PWGCF/FemtoDream/Core/femtoDreamContainer.h b/PWGCF/FemtoDream/Core/femtoDreamContainer.h index 60d51e54643..f48d84c832c 100644 --- a/PWGCF/FemtoDream/Core/femtoDreamContainer.h +++ b/PWGCF/FemtoDream/Core/femtoDreamContainer.h @@ -366,7 +366,7 @@ class FemtoDreamContainer } template - void setPair_qn(T1 const& part1, T2 const& part2, const float multPercentile, const int myQnBin) + void setPair_qn(T1 const& part1, T2 const& part2, const float multPercentile, const int myQnBin, const int numQnBins = 10) { float femtoObs, femtoObsMC; // Calculate femto observable and the mT with reconstructed information @@ -379,8 +379,7 @@ class FemtoDreamContainer } } const float mT = FemtoDreamMath::getmT(part1, mMassOne, part2, mMassTwo); - const int numQnBins = 10; - + if (mHistogramRegistry) { setPair_qn_base(femtoObs, mT, multPercentile, myQnBin, numQnBins); diff --git a/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx b/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx index 2103cf6f305..369b1ae8a89 100644 --- a/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx +++ b/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx @@ -60,6 +60,7 @@ namespace o2::aod using FemtoFullCollision = soa::Join::iterator; using FemtoFullCollision_noCent = soa::Join::iterator; using FemtoFullCollision_CentPbPb = soa::Join::iterator; +using FemtoFullCollision_CentPbPb_qvec = soa::Join::iterator; using FemtoFullCollisionMC = soa::Join::iterator; using FemtoFullCollision_noCent_MC = soa::Join::iterator; using FemtoFullCollisionMC_CentPbPb = soa::Join::iterator; @@ -100,6 +101,7 @@ struct femtoDreamProducerTask { Zorro zorro; Produces outputCollision; + Produces outputExtQnCollision; Produces outputMCCollision; Produces outputCollsMCLabels; Produces outputParts; @@ -261,7 +263,8 @@ struct femtoDreamProducerTask { Configurable ConfTrkMaxChi2PerClusterITS{"ConfTrkMaxChi2PerClusterITS", 1000.0f, "Minimal track selection: max allowed chi2 per ITS cluster"}; // 36.0 is default Configurable ConfTrkTPCRefit{"ConfTrkTPCRefit", false, "True: require TPC refit"}; Configurable ConfTrkITSRefit{"ConfTrkITSRefit", false, "True: require ITS refit"}; - + Configurable ConfTPCFracsClsCut{"ConfTPCFracsClsCut", false, "Cut fraction of shared TPC clusters"}; + Configurable ConfTPCFracsClsMax{"ConfTPCFracsCls", 1000.f, "Maximum value for fraction of shared TPC clusters"}; } OptionTrackSpecialSelections; struct : o2::framework::ConfigurableGroup { @@ -270,11 +273,31 @@ struct femtoDreamProducerTask { Configurable cfgEvtRCTFlagCheckerLimitAcceptAsBad{"cfgEvtRCTFlagCheckerLimitAcceptAsBad", true, "Evt sel: RCT flag checker treat Limited Acceptance As Bad"}; } rctCut; + struct : o2::framework::ConfigurableGroup { + Configurable ConfFlowCalculate{"ConfFlowCalculate", false, "Evt sel: Cumulant of flow"}; // To do + Configurable ConfQnSeparation{"ConfQnSeparation", false, "Evt sel: Qn of event"}; + Configurable> ConfQnBinSeparator{"ConfQnBinSeparator", std::vector{-999.f, -999.f, -999.f}, "Qn bin separator"}; + Configurable ConfdoFillHisto{"ConfdoFillHisto", false, "Fill histos for Qn and sphericity and mult "}; + Configurable ConfCentralityMax{"ConfCentralityMax", 80.f, "Evt sel: Maximum Centrality cut"}; + Configurable ConfCentBinWidth{"ConfCentBinWidth", 1.f, "Centrality bin length for qn separator"}; + Configurable ConfQnBinMin{"ConfQnBinMin", 0, "Minimum qn bin"}; + Configurable ConfNumQnBins{"ConfNumQnBins", 10, "Number of qn bins"}; + } qnCal; + + struct : o2::framework::ConfigurableGroup { + Configurable ConfIsUsePileUp{"ConfIsUsePileUp", false, "Required for choosing whether to run the pile-up cuts"}; + Configurable ConfEvNoSameBunchPileup{"ConfEvNoSameBunchPileup", false, "Require kNoSameBunchPileup selection on Events."}; + Configurable ConfEvIsGoodITSLayersAll{"ConfEvIsGoodITSLayersAll", false, "Require kIsGoodITSLayersAll selection on Events."}; + Configurable ConfTPCOccupancyMin{"ConfTPCOccupancyMin", 0, "Minimum value for TPC Occupancy selection"}; + Configurable ConfTPCOccupancyMax{"ConfTPCOccupancyMax", 5000, "Maximum value for TPC Occupancy selection"}; + } OptionEvtSpecialSelections; + HistogramRegistry qaRegistry{"QAHistos", {}, OutputObjHandlingPolicy::AnalysisObject}; HistogramRegistry TrackRegistry{"Tracks", {}, OutputObjHandlingPolicy::AnalysisObject}; HistogramRegistry V0Registry{"V0", {}, OutputObjHandlingPolicy::AnalysisObject}; HistogramRegistry ResoRegistry{"Reso", {}, OutputObjHandlingPolicy::AnalysisObject}; HistogramRegistry CascadeRegistry{"Cascade", {}, OutputObjHandlingPolicy::AnalysisObject}; + HistogramRegistry FlowRegistry{"Qn", {}, OutputObjHandlingPolicy::AnalysisObject}; int mRunNumber; float mMagField; @@ -284,10 +307,12 @@ struct femtoDreamProducerTask { void init(InitContext&) { - if (doprocessData == false && doprocessData_noCentrality == false && doprocessData_CentPbPb == false && doprocessMC == false && doprocessMC_noCentrality == false && doprocessMC_CentPbPb == false) { + if (doprocessData == false && doprocessData_noCentrality == false && doprocessData_CentPbPb == false && doprocessData_CentPbPb_qvec == false && doprocessMC == false && doprocessMC_noCentrality == false && doprocessMC_CentPbPb == false) { LOGF(fatal, "Neither processData nor processMC enabled. Please choose one."); } - if ((doprocessData == true && doprocessMC == true) || (doprocessData == true && doprocessMC_noCentrality == true) || (doprocessMC == true && doprocessMC_noCentrality == true) || (doprocessData_noCentrality == true && doprocessData == true) || (doprocessData_noCentrality == true && doprocessMC == true) || (doprocessData_noCentrality == true && doprocessMC_noCentrality == true) || (doprocessData_CentPbPb == true && doprocessData == true) || (doprocessData_CentPbPb == true && doprocessData_noCentrality == true) || (doprocessData_CentPbPb == true && doprocessMC == true) || (doprocessData_CentPbPb == true && doprocessMC_noCentrality == true) || (doprocessData_CentPbPb == true && doprocessMC_CentPbPb == true)) { + if ((doprocessData == true && doprocessMC == true) || (doprocessData == true && doprocessMC_noCentrality == true) || (doprocessMC == true && doprocessMC_noCentrality == true) || (doprocessData_noCentrality == true && doprocessData == true) || (doprocessData_noCentrality == true && doprocessMC == true) || (doprocessData_noCentrality == true && doprocessMC_noCentrality == true) || (doprocessData_CentPbPb == true && doprocessData == true) || (doprocessData_CentPbPb == true && doprocessData_noCentrality == true) || (doprocessData_CentPbPb == true && doprocessMC == true) || (doprocessData_CentPbPb == true && doprocessMC_noCentrality == true) || (doprocessData_CentPbPb == true && doprocessMC_CentPbPb == true) + || (doprocessData_CentPbPb_qvec == true && doprocessData == true) || (doprocessData_CentPbPb_qvec == true && doprocessData_noCentrality == true) || (doprocessData_CentPbPb_qvec == true && doprocessMC == true) || (doprocessData_CentPbPb_qvec == true && doprocessMC_noCentrality == true) || (doprocessData_CentPbPb_qvec == true && doprocessMC_CentPbPb == true) || (doprocessData_CentPbPb_qvec == true && doprocessData_CentPbPb == true) + ) { LOGF(fatal, "Cannot enable more than one process switch at the same time. " "Please choose one."); @@ -439,6 +464,12 @@ struct femtoDreamProducerTask { } } + if (qnCal.ConfFlowCalculate) { + colCuts.initFlow(&FlowRegistry, qnCal.ConfQnSeparation); + if (qnCal.ConfQnSeparation) + colCuts.initQn(&FlowRegistry, qnCal.ConfNumQnBins); + } + mRunNumber = 0; mMagField = 0.0; /// Initializing CCDB @@ -733,6 +764,15 @@ struct femtoDreamProducerTask { return; } + // Pileup rejection in PbPb data + if constexpr (analysePbPb) { + if (OptionEvtSpecialSelections.ConfIsUsePileUp && + !colCuts.isPileUpCollisionPbPb(col, OptionEvtSpecialSelections.ConfEvNoSameBunchPileup, OptionEvtSpecialSelections.ConfEvIsGoodITSLayersAll, + OptionEvtSpecialSelections.ConfTPCOccupancyMin, OptionEvtSpecialSelections.ConfTPCOccupancyMax)) { + return; + } + } + outputCollision(vtxZ, mult, multNtr, spher, mMagField); if constexpr (isMC) { fillMCCollision(col); @@ -762,6 +802,12 @@ struct femtoDreamProducerTask { continue; } + if constexpr (analysePbPb) { + if (OptionTrackSpecialSelections.ConfTPCFracsClsCut && track.tpcFractionSharedCls() > OptionTrackSpecialSelections.ConfTPCFracsClsMax) { + continue; + } + } + TrackRegistry.fill(HIST("AnalysisQA/Chi2ITSTPCperCluster"), track.itsChi2NCl(), track.tpcChi2NCl()); TrackRegistry.fill(HIST("AnalysisQA/RefitITSTPC"), track.hasITS(), track.hasTPC()); @@ -1080,6 +1126,74 @@ struct femtoDreamProducerTask { } } + // Separate function for fill flow and qn + template + void fillCollisionsFlow(CollisionType const& col, TrackType const& tracks) + { + // If triggering is enabled, select only events which were triggered wit our triggers + if (ConfEnableTriggerSelection) { + bool zorroSelected = zorro.isSelected(col.template bc_as().globalBC()); /// check if event was selected by triggers of interest + if (!zorroSelected) { + return; + } + } + + const auto spher = colCuts.computeSphericity(col, tracks); + float mult = 0; + int multNtr = 0; + if (ConfIsRun3) { + if constexpr (useCentrality) { + if constexpr (analysePbPb) { + mult = col.centFT0C(); + } else { + mult = col.centFT0M(); + } + } else { + mult = 0; + } + multNtr = col.multNTracksPV(); + } else { + mult = 1; // multiplicity percentile is know in Run 2 + multNtr = col.multTracklets(); + } + + // check whether the basic event selection criteria are fulfilled + // that included checking if there is at least on usable track or V0 + if (!colCuts.isSelectedCollision(col)) { + return; + } + // bool emptyCollision = false; + if (colCuts.isEmptyCollision(col, tracks, trackCuts)) { + return; + } + + if (rctCut.requireRCTFlagChecker && !rctChecker(col)) { + return; + } + + // Pileup rejection in PbPb data + if constexpr (analysePbPb) { + if (OptionEvtSpecialSelections.ConfIsUsePileUp && + !colCuts.isPileUpCollisionPbPb(col, OptionEvtSpecialSelections.ConfEvNoSameBunchPileup, OptionEvtSpecialSelections.ConfEvIsGoodITSLayersAll, + OptionEvtSpecialSelections.ConfTPCOccupancyMin, OptionEvtSpecialSelections.ConfTPCOccupancyMax)) { + return; + } + } + + // Calculate and fill qn values + float myqn = colCuts.computeqnVec(col); + outputExtQnCollision(myqn, col.trackOccupancyInTimeRange()); + + // Calculate flow via cumulant + if (qnCal.ConfFlowCalculate) { + int qnBin = colCuts.myqnBin(mult, qnCal.ConfCentralityMax, qnCal.ConfQnBinSeparator, qnCal.ConfdoFillHisto, spher, myqn, qnCal.ConfNumQnBins, multNtr, qnCal.ConfCentBinWidth); + if (qnBin < qnCal.ConfQnBinMin || qnBin > qnCal.ConfNumQnBins){ + qnBin = -999; + } + colCuts.doCumulants(col, tracks, mult, qnCal.ConfQnSeparation); + } + } + void processData(aod::FemtoFullCollision const& col, aod::BCsWithTimestamps const&, @@ -1134,14 +1248,38 @@ struct femtoDreamProducerTask { auto tracksWithItsPid = soa::Attach(tracks); if (ConfUseItsPid.value) { - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); } else { - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); } } PROCESS_SWITCH(femtoDreamProducerTask, processData_CentPbPb, "Provide experimental data with centrality information for PbPb collisions", false); + void processData_CentPbPb_qvec(aod::FemtoFullCollision_CentPbPb_qvec const& col, + aod::BCsWithTimestamps const&, + aod::FemtoFullTracks const& tracks, + o2::aod::V0Datas const& fullV0s, + o2::aod::CascDatas const& fullCascades) + { + // get magnetic field for run + initCCDB_Mag_Trig(col.bc_as()); + // fill the tables + auto tracksWithItsPid = soa::Attach(tracks); + if (ConfUseItsPid.value) { + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); + } else { + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); + } + + if (qnCal.ConfQnSeparation){ + fillCollisionsFlow(col, tracks); + } + } + PROCESS_SWITCH(femtoDreamProducerTask, processData_CentPbPb_qvec, + "Provide experimental data with centrality and q-vector table for PbPb collisions", false); + void processMC(aod::FemtoFullCollisionMC const& col, aod::BCsWithTimestamps const&, soa::Join const& tracks, @@ -1183,7 +1321,7 @@ struct femtoDreamProducerTask { // get magnetic field for run initCCDB_Mag_Trig(col.bc_as()); // fill the tables - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); } PROCESS_SWITCH(femtoDreamProducerTask, processMC_CentPbPb, "Provide MC data with centrality information for PbPb collisions", false); }; diff --git a/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx b/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx index 2792eb29b4c..efd9934ac40 100644 --- a/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx +++ b/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx @@ -31,6 +31,7 @@ #include "Framework/Expressions.h" #include "PWGCF/DataModel/FemtoDerived.h" +#include "PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h" #include "PWGCF/FemtoDream/Core/femtoDreamParticleHisto.h" #include "PWGCF/FemtoDream/Core/femtoDreamEventHisto.h" #include "PWGCF/FemtoDream/Core/femtoDreamPairCleaner.h" @@ -83,10 +84,17 @@ struct femtoDreamPairTaskTrackTrack { Filter EventMultiplicityPercentile = aod::femtodreamcollision::multV0M >= EventSel.MultPercentileMin && aod::femtodreamcollision::multV0M <= EventSel.MultPercentileMax; /// qn-separator + FemtoDreamCollisionSelection qnBinCalculator; struct : ConfigurableGroup { + std::string prefix = std::string("qnCal"); Configurable doQnSeparation{"doQnSeparation", false, "Do qn separation"}; + Configurable> qnBinSeparator{"qnBinSeparator", std::vector{-999.f, -999.f, -999.f}, "Qn bin separator"}; + Configurable doFillHisto{"doFillHisto", false, "Fill histos for Qn and sphericity and mult "}; Configurable storeEvtTrkInfo{"storeEvtTrkInfo", false, "Fill info of track1 and track2 while pariing in divided qn bins"}; Configurable numQnBins{"numQnBins", 10, "Number of qn bins"}; + Configurable qnBinMin{"qnBinMin", 0, "Number of qn bins"}; + Configurable centMax{"centMax", 80.f, "Evt sel: Maximum Centrality cut"}; + Configurable centBinWidth{"centBinWidth", 1.f, "Centrality bin length for qn separator"}; } qnCal; using FilteredCollisions = soa::Filtered; @@ -222,13 +230,15 @@ struct femtoDreamPairTaskTrackTrack { ConfigurableAxis MultMixBins{"MultMixBins", {VARIABLE_WIDTH, 0.0f, 4.0f, 8.0f, 12.0f, 16.0f, 20.0f, 24.0f, 28.0f, 32.0f, 36.0f, 40.0f, 44.0f, 48.0f, 52.0f, 56.0f, 60.0f, 64.0f, 68.0f, 72.0f, 76.0f, 80.0f, 84.0f, 88.0f, 92.0f, 96.0f, 100.0f, 200.0f}, "Mixing bins - multiplicity"}; ConfigurableAxis MultPercentileMixBins{"MultPercentileMixBins", {VARIABLE_WIDTH, 0.0f, 10.0f, 20.0f, 30.0f, 40.0f, 50.0f, 60.0f, 70.0f, 80.0f, 90.0f, 100.0f}, "Mixing bins - multiplicity percentile"}; ConfigurableAxis VztxMixBins{"VztxMixBins", {VARIABLE_WIDTH, -10.0f, -8.f, -6.f, -4.f, -2.f, 0.f, 2.f, 4.f, 6.f, 8.f, 10.f}, "Mixing bins - z-vertex"}; + ConfigurableAxis QnMixBins{"QnMixBins", {VARIABLE_WIDTH, 0.50f, 68.50f, 100.50f, 126.50f, 151.50f, 176.50f, 203.50f, 232.50f, 269.50f, 322.50f, 833.50f}, "Mixing bins - qn-value"}; Configurable Depth{"Depth", 5, "Number of events for mixing"}; - Configurable Policy{"Policy", 0, "Binning policy for mixing - 0: multiplicity, 1: multipliciy percentile, 2: both"}; + Configurable Policy{"Policy", 0, "Binning policy for mixing - 0: multiplicity, 1: multipliciy percentile, 2: both, 3: multipliciy percentile and qn value"}; } Mixing; ColumnBinningPolicy colBinningMult{{Mixing.VztxMixBins, Mixing.MultMixBins}, true}; ColumnBinningPolicy colBinningMultPercentile{{Mixing.VztxMixBins, Mixing.MultPercentileMixBins}, true}; ColumnBinningPolicy colBinningMultMultPercentile{{Mixing.VztxMixBins, Mixing.MultMixBins, Mixing.MultPercentileMixBins}, true}; + ColumnBinningPolicy colBinningMultPercentileqn{{Mixing.VztxMixBins, Mixing.MultPercentileMixBins, Mixing.QnMixBins}, true}; FemtoDreamContainer sameEventCont; FemtoDreamContainer mixedEventCont; @@ -238,7 +248,6 @@ struct femtoDreamPairTaskTrackTrack { // Container for correlation functions in devided qn bins FemtoDreamContainer sameEventQnCont; - // FemtoDreamContainer mixedEventQnCont; /// Histogram output HistogramRegistry Registry{"Output", {}, OutputObjHandlingPolicy::AnalysisObject}; @@ -252,6 +261,7 @@ struct femtoDreamPairTaskTrackTrack { colBinningMult = {{Mixing.VztxMixBins, Mixing.MultMixBins}, true}; colBinningMultPercentile = {{Mixing.VztxMixBins, Mixing.MultPercentileMixBins}, true}; colBinningMultMultPercentile = {{Mixing.VztxMixBins, Mixing.MultMixBins, Mixing.MultPercentileMixBins}, true}; + colBinningMultPercentileqn = {{Mixing.VztxMixBins, Mixing.MultPercentileMixBins, Mixing.QnMixBins}, true}; if (Option.RandomizePair.value) { random = new TRandom3(0); @@ -285,7 +295,10 @@ struct femtoDreamPairTaskTrackTrack { if (qnCal.doQnSeparation){ sameEventQnCont.init_qn(&Registry, Binning4D.kstar, Binning4D.mT, Binning4D.multPercentile, - Option.IsMC, Option.HighkstarCut); + Option.IsMC, Option.HighkstarCut); + if (qnCal.doFillHisto){ + qnBinCalculator.initQn(&Registry, qnCal.numQnBins); + } } // get bit for the collision mask @@ -326,8 +339,12 @@ struct femtoDreamPairTaskTrackTrack { } } } - if ((doprocessSameEvent && doprocessSameEventMasked) || + if ((doprocessSameEvent && doprocessSameEventMasked ) || + (doprocessSameEvent && doprocessSameEventQn ) || + (doprocessSameEventMasked && doprocessSameEventQn ) || (doprocessMixedEvent && doprocessMixedEventMasked) || + (doprocessMixedEvent && doprocessMixedEventQn) || + (doprocessMixedEventMasked && doprocessMixedEventQn) || (doprocessSameEventMC && doprocessSameEventMCMasked) || (doprocessMixedEventMC && doprocessMixedEventMCMasked)) { LOG(fatal) << "Normal and masked processing cannot be activated simultaneously!"; @@ -656,6 +673,11 @@ struct femtoDreamPairTaskTrackTrack { } } + auto myqnBin = qnBinCalculator.myqnBin(col.multV0M(), qnCal.centMax, qnCal.qnBinSeparator, qnCal.doFillHisto, col.sphericity(), col.qnVal(), qnCal.numQnBins, col.multNtr(), qnCal.centBinWidth); + if (myqnBin < qnCal.qnBinMin || myqnBin > qnCal.numQnBins){ + myqnBin = -999; + } + /// Now build the combinations float rand = 0.; if (Option.SameSpecies.value) { @@ -673,9 +695,9 @@ struct femtoDreamPairTaskTrackTrack { rand = random->Rndm(); } if (rand <= 0.5) { - sameEventQnCont.setPair_qn(p1, p2, col.multV0M(), col.qnBin()); + sameEventQnCont.setPair_qn(p1, p2, col.multV0M(), myqnBin, qnCal.numQnBins); } else { - sameEventQnCont.setPair_qn(p2, p1, col.multV0M(), col.qnBin()); + sameEventQnCont.setPair_qn(p2, p1, col.multV0M(), myqnBin, qnCal.numQnBins); } } } else { @@ -689,7 +711,7 @@ struct femtoDreamPairTaskTrackTrack { if (!pairCleaner.isCleanPair(p1, p2, parts)) { continue; } - sameEventQnCont.setPair_qn(p1, p2, col.multV0M(), col.qnBin()); + sameEventQnCont.setPair_qn(p1, p2, col.multV0M(), myqnBin, qnCal.numQnBins); } } } @@ -712,6 +734,30 @@ struct femtoDreamPairTaskTrackTrack { } } PROCESS_SWITCH(femtoDreamPairTaskTrackTrack, processSameEventQn, "Enable processing same event in divided qn bins", false); + + /// process function for to call doMixedEvent with Data + /// @param cols subscribe to the collisions table (Data) + /// @param parts subscribe to the femtoDreamParticleTable + void processMixedEventQn(FilteredQnCollisions& cols, o2::aod::FDParticles& parts) + { + switch (Mixing.Policy.value) { + case femtodreamcollision::kMult: + doMixedEvent_NotMasked(cols, parts, PartitionTrk1, PartitionTrk2, colBinningMult); + break; + case femtodreamcollision::kMultPercentile: + doMixedEvent_NotMasked(cols, parts, PartitionTrk1, PartitionTrk2, colBinningMultPercentile); + break; + case femtodreamcollision::kMultMultPercentile: + doMixedEvent_NotMasked(cols, parts, PartitionTrk1, PartitionTrk2, colBinningMultMultPercentile); + break; + case femtodreamcollision::kMultPercentileqn: + doMixedEvent_NotMasked(cols, parts, PartitionTrk1, PartitionTrk2, colBinningMultPercentileqn); + break; + default: + LOG(fatal) << "Invalid binning policiy specifed. Breaking..."; + } + } + PROCESS_SWITCH(femtoDreamPairTaskTrackTrack, processMixedEventQn, "Enable processing mixed events", false); }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { From bc609de94bdb7c8309b9d109678b3be49156c521 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Fri, 12 Sep 2025 21:57:24 +0000 Subject: [PATCH 05/13] Please consider the following formatting changes --- PWGCF/DataModel/FemtoDerived.h | 4 +- .../Core/femtoDreamCollisionSelection.h | 158 +++++++++--------- PWGCF/FemtoDream/Core/femtoDreamContainer.h | 16 +- .../TableProducer/femtoDreamProducerTask.cxx | 54 +++--- .../Tasks/femtoDreamPairTaskTrackTrack.cxx | 74 ++++---- 5 files changed, 152 insertions(+), 154 deletions(-) diff --git a/PWGCF/DataModel/FemtoDerived.h b/PWGCF/DataModel/FemtoDerived.h index 674c7464215..7c0c92974ae 100644 --- a/PWGCF/DataModel/FemtoDerived.h +++ b/PWGCF/DataModel/FemtoDerived.h @@ -35,7 +35,7 @@ enum CollisionBinning { kMult, //! Bin collision in number of charged tracks for mixing kMultPercentile, //! Bin collision in multiplicity percentile for mixing kMultMultPercentile, //! Bin collision in number of charged tracks and multiplicity percentile for mixing - kMultPercentileqn, //! Bin collision in multiplicity percentile an qn value for mixing + kMultPercentileqn, //! Bin collision in multiplicity percentile an qn value for mixing kNCollisionBinning }; @@ -52,7 +52,7 @@ DECLARE_SOA_COLUMN(BitMaskTrackThree, bitmaskTrackThree, BitMaskType); //! Bit f DECLARE_SOA_COLUMN(Downsample, downsample, bool); //! Flag for downsampling -DECLARE_SOA_COLUMN(QnVal, qnVal, int); //! qn bins for dividing events +DECLARE_SOA_COLUMN(QnVal, qnVal, int); //! qn bins for dividing events DECLARE_SOA_COLUMN(Occupancy, occupancy, int); //! TPC occupancy } // namespace femtodreamcollision diff --git a/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h b/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h index 181a04d247c..6ad6b1e06fd 100644 --- a/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h +++ b/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h @@ -16,16 +16,17 @@ #ifndef PWGCF_FEMTODREAM_CORE_FEMTODREAMCOLLISIONSELECTION_H_ #define PWGCF_FEMTODREAM_CORE_FEMTODREAMCOLLISIONSELECTION_H_ -#include -#include -#include #include "Common/CCDB/TriggerAliases.h" +#include "Common/Core/EventPlaneHelper.h" #include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/Qvectors.h" + #include "Framework/HistogramRegistry.h" #include "Framework/Logger.h" -#include "Common/Core/EventPlaneHelper.h" -#include "Common/DataModel/Qvectors.h" +#include +#include +#include using namespace o2::framework; @@ -165,17 +166,15 @@ class FemtoDreamCollisionSelection /// \param col Collision /// \return whether or not the collisions fulfills the specified selections template - bool isPileUpCollisionPbPb(C const& col, - bool noSameBunchPileup, bool isGoodITSLayersAll, - int tpcOccupancyMin, int tpcOccupancyMax) + bool isPileUpCollisionPbPb(C const& col, + bool noSameBunchPileup, bool isGoodITSLayersAll, + int tpcOccupancyMin, int tpcOccupancyMax) { const auto occupancy = col.trackOccupancyInTimeRange(); if ((occupancy < tpcOccupancyMin || occupancy > tpcOccupancyMax)) { return false; } - if ((noSameBunchPileup && !col.selection_bit(aod::evsel::kNoSameBunchPileup)) - || (isGoodITSLayersAll && !col.selection_bit(aod::evsel::kIsGoodITSLayersAll)) - ) { + if ((noSameBunchPileup && !col.selection_bit(aod::evsel::kNoSameBunchPileup)) || (isGoodITSLayersAll && !col.selection_bit(aod::evsel::kIsGoodITSLayersAll))) { return false; } @@ -207,11 +206,11 @@ class FemtoDreamCollisionSelection { mHistogramQn = registry; mHistogramQn->add("Event/centFT0CBefore", "; cent", kTH1F, {{10, 0, 100}}); - mHistogramQn->add("Event/centFT0CAfter", "; cent", kTH1F, {{10, 0, 100}}); + mHistogramQn->add("Event/centFT0CAfter", "; cent", kTH1F, {{10, 0, 100}}); mHistogramQn->add("Event/centVsqn", "; cent; qn", kTH2F, {{10, 0, 100}, {100, 0, 1000}}); mHistogramQn->add("Event/centVsqnVsSpher", "; cent; qn; Sphericity", kTH3F, {{10, 0, 100}, {100, 0, 1000}, {100, 0, 1}}); mHistogramQn->add("Event/qnBin", "; qnBin; entries", kTH1F, {{20, 0, 20}}); - + for (int iqn(0); iqn < mumQnBins; ++iqn) { mHistogramQn->add(("Qn/mult_" + std::to_string(iqn)).c_str(), "; cent; c22", kTH1F, {{100, 0, 3500}}); } @@ -230,12 +229,12 @@ class FemtoDreamCollisionSelection mReQ2thisEvt = new TH2D("ReQ2thisEvt", "", binPt, 0., 5., binEta, -0.8, 0.8); mImQ2thisEvt = new TH2D("ImQ2thisEvt", "", binPt, 0., 5., binEta, -0.8, 0.8); mMQthisEvt = new TH2D("MQthisEvt", "", binPt, 0., 5., binEta, -0.8, 0.8); - mMQWeightthisEvt = new TH2D("MQWeightthisEvt", "", binPt, 0., 5., binEta, -0.8, 0.8); - + mMQWeightthisEvt = new TH2D("MQWeightthisEvt", "", binPt, 0., 5., binEta, -0.8, 0.8); + mHistogramQn = registry; mHistogramQn->add("Event/profileC22", "; cent; c22", kTProfile, {{10, 0, 100}}); mHistogramQn->add("Event/profileC24", "; cent; c24", kTProfile, {{10, 0, 100}}); - if (doQnSeparation){ + if (doQnSeparation) { for (int iqn(0); iqn < mumQnBins; ++iqn) { mHistogramQn->add(("Qn/profileC22_" + std::to_string(iqn)).c_str(), "; cent; c22", kTProfile, {{10, 0, 100}}); } @@ -328,14 +327,14 @@ class FemtoDreamCollisionSelection /// \todo to be implemented! /// \return the 1-d qn-vector separator to 2-d - std::vector> getQnBinSeparator2D(std::vector flat, const int numQnBins = 10) + std::vector> getQnBinSeparator2D(std::vector flat, const int numQnBins = 10) { - size_t nBins = numQnBins+1; + size_t nBins = numQnBins + 1; if (flat.empty() || flat.size() % nBins != 0) { - LOGP(error, "ConfQnBinSeparator size = {} is not divisible by {}", + LOGP(error, "ConfQnBinSeparator size = {} is not divisible by {}", flat.size(), nBins); - return {{-999, -999}}; + return {{-999, -999}}; } size_t nCent = flat.size() / nBins; @@ -362,14 +361,14 @@ class FemtoDreamCollisionSelection } if (doFillHisto) - mHistogramQn->fill(HIST("Event/centFT0CBefore"), centrality); + mHistogramQn->fill(HIST("Event/centFT0CBefore"), centrality); int qnBin = -999; int mycentBin = static_cast(centrality / centBinWidth); if (mycentBin >= static_cast(centMax / centBinWidth)) return qnBin; - if (mycentBin > static_cast(twoDSeparator.size()) -1) + if (mycentBin > static_cast(twoDSeparator.size()) - 1) return qnBin; for (int iqn(0); iqn < static_cast(twoDSeparator[mycentBin].size()) - 1; ++iqn) { @@ -383,12 +382,12 @@ class FemtoDreamCollisionSelection mQnBin = qnBin; - if (doFillHisto){ + if (doFillHisto) { mHistogramQn->fill(HIST("Event/centFT0CAfter"), centrality); mHistogramQn->fill(HIST("Event/centVsqn"), centrality, qn); mHistogramQn->fill(HIST("Event/centVsqnVsSpher"), centrality, qn, fSpher); mHistogramQn->fill(HIST("Event/qnBin"), qnBin); - if (qnBin >= 0 && qnBin < numQnBins){ + if (qnBin >= 0 && qnBin < numQnBins) { switch (qnBin) { case 0: mHistogramQn->fill(HIST("Qn/mult_") + HIST("0"), mult); @@ -397,8 +396,8 @@ class FemtoDreamCollisionSelection mHistogramQn->fill(HIST("Qn/mult_") + HIST("1"), mult); break; case 2: - mHistogramQn->fill(HIST("Qn/mult_") + HIST("2"), mult); - break; + mHistogramQn->fill(HIST("Qn/mult_") + HIST("2"), mult); + break; case 3: mHistogramQn->fill(HIST("Qn/mult_") + HIST("3"), mult); break; @@ -419,11 +418,11 @@ class FemtoDreamCollisionSelection break; case 9: mHistogramQn->fill(HIST("Qn/mult_") + HIST("9"), mult); - break; + break; default: - return qnBin; // invalid qn bin + return qnBin; // invalid qn bin } - } + } } return qnBin; @@ -436,34 +435,34 @@ class FemtoDreamCollisionSelection /// \tparam T2 type of the tracks /// \param tracks All tracks template - bool fillCumulants(T1 const& col, T2 const& tracks, float fHarmonic=2.f) - { + bool fillCumulants(T1 const& col, T2 const& tracks, float fHarmonic = 2.f) + { int numOfTracks = col.numContrib(); if (numOfTracks < 3) return false; mReQthisEvt->Reset(); mImQthisEvt->Reset(); - mReQ2thisEvt->Reset(); - mImQ2thisEvt->Reset(); + mReQ2thisEvt->Reset(); + mImQ2thisEvt->Reset(); mMQthisEvt->Reset(); - mMQWeightthisEvt->Reset(); + mMQWeightthisEvt->Reset(); for (auto const& track : tracks) { - double weight=1; // Will implement NUA&NUE correction + double weight = 1; // Will implement NUA&NUE correction double phi = track.phi(); double pt = track.pt(); double eta = track.eta(); - double cosnphi = weight * TMath::Cos(fHarmonic*phi); - double sinnphi = weight * TMath::Sin(fHarmonic*phi); - double cos2nphi = weight * TMath::Cos(2*fHarmonic*phi); - double sin2nphi = weight * TMath::Sin(2*fHarmonic*phi); + double cosnphi = weight * TMath::Cos(fHarmonic * phi); + double sinnphi = weight * TMath::Sin(fHarmonic * phi); + double cos2nphi = weight * TMath::Cos(2 * fHarmonic * phi); + double sin2nphi = weight * TMath::Sin(2 * fHarmonic * phi); mReQthisEvt->Fill(pt, eta, cosnphi); mImQthisEvt->Fill(pt, eta, sinnphi); - mReQ2thisEvt->Fill(pt,eta,cos2nphi); - mImQ2thisEvt->Fill(pt, eta, sin2nphi); - mMQthisEvt ->Fill(pt, eta); - mMQWeightthisEvt ->Fill(pt, eta, weight); + mReQ2thisEvt->Fill(pt, eta, cos2nphi); + mImQ2thisEvt->Fill(pt, eta, sin2nphi); + mMQthisEvt->Fill(pt, eta); + mMQWeightthisEvt->Fill(pt, eta, weight); } return true; } @@ -480,73 +479,72 @@ class FemtoDreamCollisionSelection if (!fillCumulants(col, tracks)) return; - if (mMQthisEvt->Integral(1, binPt, 1, binEta) < 2) + if (mMQthisEvt->Integral(1, binPt, 1, binEta) < 2) return; - - double allReQ = mReQthisEvt ->Integral(1, binPt, 1, binEta); - double allImQ = mImQthisEvt ->Integral(1, binPt, 1, binEta); + + double allReQ = mReQthisEvt->Integral(1, binPt, 1, binEta); + double allImQ = mImQthisEvt->Integral(1, binPt, 1, binEta); TComplex Q(allReQ, allImQ); TComplex QStar = TComplex::Conjugate(Q); - - double posEtaRe = mReQthisEvt->Integral(1, binPt, mReQthisEvt->GetYaxis()->FindBin(fEtaGap+1e-6), binEta); - double posEtaIm = mImQthisEvt->Integral(1, binPt, mImQthisEvt->GetYaxis()->FindBin(fEtaGap+1e-6), binEta); - if (mMQthisEvt->Integral(1, binPt, mMQthisEvt->GetYaxis()->FindBin(fEtaGap+1e-6), binEta) < 2) + + double posEtaRe = mReQthisEvt->Integral(1, binPt, mReQthisEvt->GetYaxis()->FindBin(fEtaGap + 1e-6), binEta); + double posEtaIm = mImQthisEvt->Integral(1, binPt, mImQthisEvt->GetYaxis()->FindBin(fEtaGap + 1e-6), binEta); + if (mMQthisEvt->Integral(1, binPt, mMQthisEvt->GetYaxis()->FindBin(fEtaGap + 1e-6), binEta) < 2) return; - float posEtaMQ = mMQWeightthisEvt->Integral(1, binPt, mMQthisEvt->GetYaxis()->FindBin(fEtaGap+1e-6), binEta); + float posEtaMQ = mMQWeightthisEvt->Integral(1, binPt, mMQthisEvt->GetYaxis()->FindBin(fEtaGap + 1e-6), binEta); TComplex posEtaQ = TComplex(posEtaRe, posEtaIm); TComplex posEtaQStar = TComplex::Conjugate(posEtaQ); - - double negEtaRe = mReQthisEvt->Integral(1, binPt, 1, mReQthisEvt->GetYaxis()->FindBin(-1*fEtaGap-1e-6)); - double negEtaIm = mImQthisEvt->Integral(1, binPt, 1, mImQthisEvt->GetYaxis()->FindBin(-1*fEtaGap-1e-6)); - if (mMQthisEvt->Integral(1, binPt, 1, mMQthisEvt->GetYaxis()->FindBin(-1*fEtaGap-1e-6)) < 2) + + double negEtaRe = mReQthisEvt->Integral(1, binPt, 1, mReQthisEvt->GetYaxis()->FindBin(-1 * fEtaGap - 1e-6)); + double negEtaIm = mImQthisEvt->Integral(1, binPt, 1, mImQthisEvt->GetYaxis()->FindBin(-1 * fEtaGap - 1e-6)); + if (mMQthisEvt->Integral(1, binPt, 1, mMQthisEvt->GetYaxis()->FindBin(-1 * fEtaGap - 1e-6)) < 2) return; - float negEtaMQ = mMQWeightthisEvt->Integral(1, binPt, 1, mMQthisEvt->GetYaxis()->FindBin(-1*fEtaGap-1e-6)); + float negEtaMQ = mMQWeightthisEvt->Integral(1, binPt, 1, mMQthisEvt->GetYaxis()->FindBin(-1 * fEtaGap - 1e-6)); TComplex negEtaQ = TComplex(negEtaRe, negEtaIm); TComplex negEtaQStar = TComplex::Conjugate(negEtaQ); - mHistogramQn->get(HIST("Event/profileC22"))->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); - if (doQnSeparation && mQnBin >= 0 && mQnBin < numQnBins){ + mHistogramQn->get(HIST("Event/profileC22"))->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); + if (doQnSeparation && mQnBin >= 0 && mQnBin < numQnBins) { switch (mQnBin) { case 0: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("0"))->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("0"))->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); break; case 1: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("1"))->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("1"))->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); break; case 2: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("2"))->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("2"))->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); break; case 3: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("3"))->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("3"))->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); break; case 4: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("4"))->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("4"))->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); break; case 5: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("5"))->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("5"))->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); break; case 6: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("6"))->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("6"))->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); break; case 7: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("7"))->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("7"))->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); break; case 8: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("8"))->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("8"))->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); break; case 9: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("9"))->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); - break; + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("9"))->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); + break; default: - return; // invalid qn bin + return; // invalid qn bin } } return; } - private: - HistogramRegistry* mHistogramRegistry = nullptr; ///< For QA output + HistogramRegistry* mHistogramRegistry = nullptr; ///< For QA output bool mCutsSet = false; ///< Protection against running without cuts bool mCheckTrigger = false; ///< Check for trigger bool mCheckOffline = false; ///< Check for offline criteria (might change) @@ -557,13 +555,13 @@ class FemtoDreamCollisionSelection float mMinSphericity = 0.f; float mSphericityPtmin = 0.f; int mQnBin = -999; - HistogramRegistry* mHistogramQn = nullptr; ///< For flow cumulant output - TH2D* mReQthisEvt = nullptr; ///< For flow cumulant in an event - TH2D* mImQthisEvt = nullptr; ///< For flow cumulant in an event - TH2D* mReQ2thisEvt = nullptr; ///< For flow cumulant in an event - TH2D* mImQ2thisEvt = nullptr; ///< For flow cumulant in an event - TH2D* mMQthisEvt = nullptr; ///< For flow cumulant in an event - TH2D* mMQWeightthisEvt = nullptr; ///< For flow cumulant in an event + HistogramRegistry* mHistogramQn = nullptr; ///< For flow cumulant output + TH2D* mReQthisEvt = nullptr; ///< For flow cumulant in an event + TH2D* mImQthisEvt = nullptr; ///< For flow cumulant in an event + TH2D* mReQ2thisEvt = nullptr; ///< For flow cumulant in an event + TH2D* mImQ2thisEvt = nullptr; ///< For flow cumulant in an event + TH2D* mMQthisEvt = nullptr; ///< For flow cumulant in an event + TH2D* mMQWeightthisEvt = nullptr; ///< For flow cumulant in an event }; } // namespace o2::analysis::femtoDream diff --git a/PWGCF/FemtoDream/Core/femtoDreamContainer.h b/PWGCF/FemtoDream/Core/femtoDreamContainer.h index f48d84c832c..4e8300c5c9e 100644 --- a/PWGCF/FemtoDream/Core/femtoDreamContainer.h +++ b/PWGCF/FemtoDream/Core/femtoDreamContainer.h @@ -183,15 +183,15 @@ class FemtoDreamContainer /// Initialize the histograms for pairs in divided qn bins template void init_base_qn(std::string folderName, std::string femtoObs, - T& femtoObsAxis, T& mTAxi4D, T& multPercentileAxis4D, T& qnAxis4D) + T& femtoObsAxis, T& mTAxi4D, T& multPercentileAxis4D, T& qnAxis4D) { mHistogramRegistry->add((folderName + "/relPairkstarmTMultMultPercentileQn").c_str(), ("; " + femtoObs + "; #it{m}_{T} (GeV/#it{c}); Centrality; qn").c_str(), kTHnSparseF, {femtoObsAxis, mTAxi4D, multPercentileAxis4D, qnAxis4D}); } template void init_qn(HistogramRegistry* registry, - T& kstarBins4D, T& mTBins4D, T& multPercentileBins4D, - bool isMC, float highkstarCut, ConfigurableAxis qnBins4D = {"qnBins4D", {10,0,10}, "qn binning"}) + T& kstarBins4D, T& mTBins4D, T& multPercentileBins4D, + bool isMC, float highkstarCut, ConfigurableAxis qnBins4D = {"qnBins4D", {10, 0, 10}, "qn binning"}) { mHistogramRegistry = registry; std::string femtoObs; @@ -207,13 +207,13 @@ class FemtoDreamContainer std::string folderName = static_cast(mFolderSuffix[mEventType]) + static_cast(o2::aod::femtodreamMCparticle::MCTypeName[o2::aod::femtodreamMCparticle::MCType::kRecon]) + static_cast("_qn"); - init_base_qn(folderName, femtoObs, - kstarAxis4D, mTAxis4D, multPercentileAxis4D, qnAxis4D); + init_base_qn(folderName, femtoObs, + kstarAxis4D, mTAxis4D, multPercentileAxis4D, qnAxis4D); if (isMC) { folderName = static_cast(mFolderSuffix[mEventType]) + static_cast(o2::aod::femtodreamMCparticle::MCTypeName[o2::aod::femtodreamMCparticle::MCType::kTruth]) + static_cast("_qn"); init_base_qn(folderName, femtoObs, - kstarAxis4D, mTAxis4D, multPercentileAxis4D, qnAxis4D); + kstarAxis4D, mTAxis4D, multPercentileAxis4D, qnAxis4D); } } @@ -359,7 +359,7 @@ class FemtoDreamContainer void setPair_qn_base(const float femtoObs, const float mT, const float multPercentile, const int myQnBin, const int numQnBins = 10) { if (myQnBin >= 0 && myQnBin < numQnBins) { - mHistogramRegistry->fill(HIST(mFolderSuffix[mEventType]) + HIST(o2::aod::femtodreamMCparticle::MCTypeName[mc]) + HIST("_qn") + HIST("/relPairkstarmTMultMultPercentileQn"), femtoObs, mT, multPercentile, myQnBin); + mHistogramRegistry->fill(HIST(mFolderSuffix[mEventType]) + HIST(o2::aod::femtodreamMCparticle::MCTypeName[mc]) + HIST("_qn") + HIST("/relPairkstarmTMultMultPercentileQn"), femtoObs, mT, multPercentile, myQnBin); } else { return; } @@ -379,7 +379,7 @@ class FemtoDreamContainer } } const float mT = FemtoDreamMath::getmT(part1, mMassOne, part2, mMassTwo); - + if (mHistogramRegistry) { setPair_qn_base(femtoObs, mT, multPercentile, myQnBin, numQnBins); diff --git a/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx b/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx index 369b1ae8a89..e191b1c6791 100644 --- a/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx +++ b/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx @@ -276,9 +276,9 @@ struct femtoDreamProducerTask { struct : o2::framework::ConfigurableGroup { Configurable ConfFlowCalculate{"ConfFlowCalculate", false, "Evt sel: Cumulant of flow"}; // To do Configurable ConfQnSeparation{"ConfQnSeparation", false, "Evt sel: Qn of event"}; - Configurable> ConfQnBinSeparator{"ConfQnBinSeparator", std::vector{-999.f, -999.f, -999.f}, "Qn bin separator"}; + Configurable> ConfQnBinSeparator{"ConfQnBinSeparator", std::vector{-999.f, -999.f, -999.f}, "Qn bin separator"}; Configurable ConfdoFillHisto{"ConfdoFillHisto", false, "Fill histos for Qn and sphericity and mult "}; - Configurable ConfCentralityMax{"ConfCentralityMax", 80.f, "Evt sel: Maximum Centrality cut"}; + Configurable ConfCentralityMax{"ConfCentralityMax", 80.f, "Evt sel: Maximum Centrality cut"}; Configurable ConfCentBinWidth{"ConfCentBinWidth", 1.f, "Centrality bin length for qn separator"}; Configurable ConfQnBinMin{"ConfQnBinMin", 0, "Minimum qn bin"}; Configurable ConfNumQnBins{"ConfNumQnBins", 10, "Number of qn bins"}; @@ -310,9 +310,7 @@ struct femtoDreamProducerTask { if (doprocessData == false && doprocessData_noCentrality == false && doprocessData_CentPbPb == false && doprocessData_CentPbPb_qvec == false && doprocessMC == false && doprocessMC_noCentrality == false && doprocessMC_CentPbPb == false) { LOGF(fatal, "Neither processData nor processMC enabled. Please choose one."); } - if ((doprocessData == true && doprocessMC == true) || (doprocessData == true && doprocessMC_noCentrality == true) || (doprocessMC == true && doprocessMC_noCentrality == true) || (doprocessData_noCentrality == true && doprocessData == true) || (doprocessData_noCentrality == true && doprocessMC == true) || (doprocessData_noCentrality == true && doprocessMC_noCentrality == true) || (doprocessData_CentPbPb == true && doprocessData == true) || (doprocessData_CentPbPb == true && doprocessData_noCentrality == true) || (doprocessData_CentPbPb == true && doprocessMC == true) || (doprocessData_CentPbPb == true && doprocessMC_noCentrality == true) || (doprocessData_CentPbPb == true && doprocessMC_CentPbPb == true) - || (doprocessData_CentPbPb_qvec == true && doprocessData == true) || (doprocessData_CentPbPb_qvec == true && doprocessData_noCentrality == true) || (doprocessData_CentPbPb_qvec == true && doprocessMC == true) || (doprocessData_CentPbPb_qvec == true && doprocessMC_noCentrality == true) || (doprocessData_CentPbPb_qvec == true && doprocessMC_CentPbPb == true) || (doprocessData_CentPbPb_qvec == true && doprocessData_CentPbPb == true) - ) { + if ((doprocessData == true && doprocessMC == true) || (doprocessData == true && doprocessMC_noCentrality == true) || (doprocessMC == true && doprocessMC_noCentrality == true) || (doprocessData_noCentrality == true && doprocessData == true) || (doprocessData_noCentrality == true && doprocessMC == true) || (doprocessData_noCentrality == true && doprocessMC_noCentrality == true) || (doprocessData_CentPbPb == true && doprocessData == true) || (doprocessData_CentPbPb == true && doprocessData_noCentrality == true) || (doprocessData_CentPbPb == true && doprocessMC == true) || (doprocessData_CentPbPb == true && doprocessMC_noCentrality == true) || (doprocessData_CentPbPb == true && doprocessMC_CentPbPb == true) || (doprocessData_CentPbPb_qvec == true && doprocessData == true) || (doprocessData_CentPbPb_qvec == true && doprocessData_noCentrality == true) || (doprocessData_CentPbPb_qvec == true && doprocessMC == true) || (doprocessData_CentPbPb_qvec == true && doprocessMC_noCentrality == true) || (doprocessData_CentPbPb_qvec == true && doprocessMC_CentPbPb == true) || (doprocessData_CentPbPb_qvec == true && doprocessData_CentPbPb == true)) { LOGF(fatal, "Cannot enable more than one process switch at the same time. " "Please choose one."); @@ -766,10 +764,10 @@ struct femtoDreamProducerTask { // Pileup rejection in PbPb data if constexpr (analysePbPb) { - if (OptionEvtSpecialSelections.ConfIsUsePileUp && - !colCuts.isPileUpCollisionPbPb(col, OptionEvtSpecialSelections.ConfEvNoSameBunchPileup, OptionEvtSpecialSelections.ConfEvIsGoodITSLayersAll, - OptionEvtSpecialSelections.ConfTPCOccupancyMin, OptionEvtSpecialSelections.ConfTPCOccupancyMax)) { - return; + if (OptionEvtSpecialSelections.ConfIsUsePileUp && + !colCuts.isPileUpCollisionPbPb(col, OptionEvtSpecialSelections.ConfEvNoSameBunchPileup, OptionEvtSpecialSelections.ConfEvIsGoodITSLayersAll, + OptionEvtSpecialSelections.ConfTPCOccupancyMin, OptionEvtSpecialSelections.ConfTPCOccupancyMax)) { + return; } } @@ -1166,28 +1164,28 @@ struct femtoDreamProducerTask { if (colCuts.isEmptyCollision(col, tracks, trackCuts)) { return; } - + if (rctCut.requireRCTFlagChecker && !rctChecker(col)) { return; } // Pileup rejection in PbPb data if constexpr (analysePbPb) { - if (OptionEvtSpecialSelections.ConfIsUsePileUp && - !colCuts.isPileUpCollisionPbPb(col, OptionEvtSpecialSelections.ConfEvNoSameBunchPileup, OptionEvtSpecialSelections.ConfEvIsGoodITSLayersAll, - OptionEvtSpecialSelections.ConfTPCOccupancyMin, OptionEvtSpecialSelections.ConfTPCOccupancyMax)) { - return; + if (OptionEvtSpecialSelections.ConfIsUsePileUp && + !colCuts.isPileUpCollisionPbPb(col, OptionEvtSpecialSelections.ConfEvNoSameBunchPileup, OptionEvtSpecialSelections.ConfEvIsGoodITSLayersAll, + OptionEvtSpecialSelections.ConfTPCOccupancyMin, OptionEvtSpecialSelections.ConfTPCOccupancyMax)) { + return; } } - // Calculate and fill qn values + // Calculate and fill qn values float myqn = colCuts.computeqnVec(col); outputExtQnCollision(myqn, col.trackOccupancyInTimeRange()); - + // Calculate flow via cumulant if (qnCal.ConfFlowCalculate) { int qnBin = colCuts.myqnBin(mult, qnCal.ConfCentralityMax, qnCal.ConfQnBinSeparator, qnCal.ConfdoFillHisto, spher, myqn, qnCal.ConfNumQnBins, multNtr, qnCal.ConfCentBinWidth); - if (qnBin < qnCal.ConfQnBinMin || qnBin > qnCal.ConfNumQnBins){ + if (qnBin < qnCal.ConfQnBinMin || qnBin > qnCal.ConfNumQnBins) { qnBin = -999; } colCuts.doCumulants(col, tracks, mult, qnCal.ConfQnSeparation); @@ -1248,19 +1246,19 @@ struct femtoDreamProducerTask { auto tracksWithItsPid = soa::Attach(tracks); if (ConfUseItsPid.value) { - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); } else { - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); } } PROCESS_SWITCH(femtoDreamProducerTask, processData_CentPbPb, "Provide experimental data with centrality information for PbPb collisions", false); void processData_CentPbPb_qvec(aod::FemtoFullCollision_CentPbPb_qvec const& col, - aod::BCsWithTimestamps const&, - aod::FemtoFullTracks const& tracks, - o2::aod::V0Datas const& fullV0s, - o2::aod::CascDatas const& fullCascades) + aod::BCsWithTimestamps const&, + aod::FemtoFullTracks const& tracks, + o2::aod::V0Datas const& fullV0s, + o2::aod::CascDatas const& fullCascades) { // get magnetic field for run initCCDB_Mag_Trig(col.bc_as()); @@ -1268,13 +1266,13 @@ struct femtoDreamProducerTask { auto tracksWithItsPid = soa::Attach(tracks); if (ConfUseItsPid.value) { - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); } else { - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); } - if (qnCal.ConfQnSeparation){ - fillCollisionsFlow(col, tracks); + if (qnCal.ConfQnSeparation) { + fillCollisionsFlow(col, tracks); } } PROCESS_SWITCH(femtoDreamProducerTask, processData_CentPbPb_qvec, @@ -1321,7 +1319,7 @@ struct femtoDreamProducerTask { // get magnetic field for run initCCDB_Mag_Trig(col.bc_as()); // fill the tables - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); } PROCESS_SWITCH(femtoDreamProducerTask, processMC_CentPbPb, "Provide MC data with centrality information for PbPb collisions", false); }; diff --git a/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx b/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx index efd9934ac40..049d94ddb85 100644 --- a/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx +++ b/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx @@ -15,30 +15,32 @@ /// \author Georgios Mantzaridis, TU München, georgios.mantzaridis@tum.de /// \author Anton Riedel, TU München, anton.riedel@tum.de -#include -#include -#include -#include -#include "TRandom3.h" -#include "Framework/AnalysisTask.h" -#include "Framework/runDataProcessing.h" -#include "Framework/HistogramRegistry.h" -#include "Framework/ASoAHelpers.h" -#include "Framework/RunningWorkflowInfo.h" -#include "Framework/StepTHn.h" -#include "Framework/O2DatabasePDGPlugin.h" -#include "Framework/Configurable.h" -#include "Framework/Expressions.h" - #include "PWGCF/DataModel/FemtoDerived.h" #include "PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h" -#include "PWGCF/FemtoDream/Core/femtoDreamParticleHisto.h" -#include "PWGCF/FemtoDream/Core/femtoDreamEventHisto.h" -#include "PWGCF/FemtoDream/Core/femtoDreamPairCleaner.h" #include "PWGCF/FemtoDream/Core/femtoDreamContainer.h" #include "PWGCF/FemtoDream/Core/femtoDreamDetaDphiStar.h" +#include "PWGCF/FemtoDream/Core/femtoDreamEventHisto.h" +#include "PWGCF/FemtoDream/Core/femtoDreamPairCleaner.h" +#include "PWGCF/FemtoDream/Core/femtoDreamParticleHisto.h" #include "PWGCF/FemtoDream/Core/femtoDreamUtils.h" +#include "Framework/ASoAHelpers.h" +#include "Framework/AnalysisTask.h" +#include "Framework/Configurable.h" +#include "Framework/Expressions.h" +#include "Framework/HistogramRegistry.h" +#include "Framework/O2DatabasePDGPlugin.h" +#include "Framework/RunningWorkflowInfo.h" +#include "Framework/StepTHn.h" +#include "Framework/runDataProcessing.h" + +#include "TRandom3.h" + +#include +#include +#include +#include + using namespace o2::aod; using namespace o2::soa; using namespace o2::framework; @@ -87,13 +89,13 @@ struct femtoDreamPairTaskTrackTrack { FemtoDreamCollisionSelection qnBinCalculator; struct : ConfigurableGroup { std::string prefix = std::string("qnCal"); - Configurable doQnSeparation{"doQnSeparation", false, "Do qn separation"}; - Configurable> qnBinSeparator{"qnBinSeparator", std::vector{-999.f, -999.f, -999.f}, "Qn bin separator"}; + Configurable doQnSeparation{"doQnSeparation", false, "Do qn separation"}; + Configurable> qnBinSeparator{"qnBinSeparator", std::vector{-999.f, -999.f, -999.f}, "Qn bin separator"}; Configurable doFillHisto{"doFillHisto", false, "Fill histos for Qn and sphericity and mult "}; - Configurable storeEvtTrkInfo{"storeEvtTrkInfo", false, "Fill info of track1 and track2 while pariing in divided qn bins"}; + Configurable storeEvtTrkInfo{"storeEvtTrkInfo", false, "Fill info of track1 and track2 while pariing in divided qn bins"}; Configurable numQnBins{"numQnBins", 10, "Number of qn bins"}; Configurable qnBinMin{"qnBinMin", 0, "Number of qn bins"}; - Configurable centMax{"centMax", 80.f, "Evt sel: Maximum Centrality cut"}; + Configurable centMax{"centMax", 80.f, "Evt sel: Maximum Centrality cut"}; Configurable centBinWidth{"centBinWidth", 1.f, "Centrality bin length for qn separator"}; } qnCal; @@ -230,7 +232,7 @@ struct femtoDreamPairTaskTrackTrack { ConfigurableAxis MultMixBins{"MultMixBins", {VARIABLE_WIDTH, 0.0f, 4.0f, 8.0f, 12.0f, 16.0f, 20.0f, 24.0f, 28.0f, 32.0f, 36.0f, 40.0f, 44.0f, 48.0f, 52.0f, 56.0f, 60.0f, 64.0f, 68.0f, 72.0f, 76.0f, 80.0f, 84.0f, 88.0f, 92.0f, 96.0f, 100.0f, 200.0f}, "Mixing bins - multiplicity"}; ConfigurableAxis MultPercentileMixBins{"MultPercentileMixBins", {VARIABLE_WIDTH, 0.0f, 10.0f, 20.0f, 30.0f, 40.0f, 50.0f, 60.0f, 70.0f, 80.0f, 90.0f, 100.0f}, "Mixing bins - multiplicity percentile"}; ConfigurableAxis VztxMixBins{"VztxMixBins", {VARIABLE_WIDTH, -10.0f, -8.f, -6.f, -4.f, -2.f, 0.f, 2.f, 4.f, 6.f, 8.f, 10.f}, "Mixing bins - z-vertex"}; - ConfigurableAxis QnMixBins{"QnMixBins", {VARIABLE_WIDTH, 0.50f, 68.50f, 100.50f, 126.50f, 151.50f, 176.50f, 203.50f, 232.50f, 269.50f, 322.50f, 833.50f}, "Mixing bins - qn-value"}; + ConfigurableAxis QnMixBins{"QnMixBins", {VARIABLE_WIDTH, 0.50f, 68.50f, 100.50f, 126.50f, 151.50f, 176.50f, 203.50f, 232.50f, 269.50f, 322.50f, 833.50f}, "Mixing bins - qn-value"}; Configurable Depth{"Depth", 5, "Number of events for mixing"}; Configurable Policy{"Policy", 0, "Binning policy for mixing - 0: multiplicity, 1: multipliciy percentile, 2: both, 3: multipliciy percentile and qn value"}; } Mixing; @@ -292,13 +294,13 @@ struct femtoDreamPairTaskTrackTrack { pairCloseRejectionME.init(&Registry, &Registry, Option.CPRdeltaPhiMax.value, Option.CPRdeltaEtaMax.value, Option.CPRPlotPerRadii.value, 2, Option.CPROld.value); } - if (qnCal.doQnSeparation){ + if (qnCal.doQnSeparation) { sameEventQnCont.init_qn(&Registry, - Binning4D.kstar, Binning4D.mT, Binning4D.multPercentile, - Option.IsMC, Option.HighkstarCut); - if (qnCal.doFillHisto){ + Binning4D.kstar, Binning4D.mT, Binning4D.multPercentile, + Option.IsMC, Option.HighkstarCut); + if (qnCal.doFillHisto) { qnBinCalculator.initQn(&Registry, qnCal.numQnBins); - } + } } // get bit for the collision mask @@ -339,9 +341,9 @@ struct femtoDreamPairTaskTrackTrack { } } } - if ((doprocessSameEvent && doprocessSameEventMasked ) || - (doprocessSameEvent && doprocessSameEventQn ) || - (doprocessSameEventMasked && doprocessSameEventQn ) || + if ((doprocessSameEvent && doprocessSameEventMasked) || + (doprocessSameEvent && doprocessSameEventQn) || + (doprocessSameEventMasked && doprocessSameEventQn) || (doprocessMixedEvent && doprocessMixedEventMasked) || (doprocessMixedEvent && doprocessMixedEventQn) || (doprocessMixedEventMasked && doprocessMixedEventQn) || @@ -661,7 +663,7 @@ struct femtoDreamPairTaskTrackTrack { template void doSameEventQn(PartitionType SliceTrk1, PartitionType SliceTrk2, PartType parts, Collision col) { - if (qnCal.storeEvtTrkInfo){ + if (qnCal.storeEvtTrkInfo) { for (auto& part : SliceTrk1) { trackHistoPartOne.fillQA(part, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); } @@ -674,7 +676,7 @@ struct femtoDreamPairTaskTrackTrack { } auto myqnBin = qnBinCalculator.myqnBin(col.multV0M(), qnCal.centMax, qnCal.qnBinSeparator, qnCal.doFillHisto, col.sphericity(), col.qnVal(), qnCal.numQnBins, col.multNtr(), qnCal.centBinWidth); - if (myqnBin < qnCal.qnBinMin || myqnBin > qnCal.numQnBins){ + if (myqnBin < qnCal.qnBinMin || myqnBin > qnCal.numQnBins) { myqnBin = -999; } @@ -729,7 +731,7 @@ struct femtoDreamPairTaskTrackTrack { if (SliceTrk1.size() == 0 && SliceTrk2.size() == 0) { return; } - if (qnCal.doQnSeparation){ + if (qnCal.doQnSeparation) { doSameEventQn(SliceTrk1, SliceTrk2, parts, col); } } @@ -750,8 +752,8 @@ struct femtoDreamPairTaskTrackTrack { case femtodreamcollision::kMultMultPercentile: doMixedEvent_NotMasked(cols, parts, PartitionTrk1, PartitionTrk2, colBinningMultMultPercentile); break; - case femtodreamcollision::kMultPercentileqn: - doMixedEvent_NotMasked(cols, parts, PartitionTrk1, PartitionTrk2, colBinningMultPercentileqn); + case femtodreamcollision::kMultPercentileqn: + doMixedEvent_NotMasked(cols, parts, PartitionTrk1, PartitionTrk2, colBinningMultPercentileqn); break; default: LOG(fatal) << "Invalid binning policiy specifed. Breaking..."; From 274476d32047b57379aa55be42598a8491106bb4 Mon Sep 17 00:00:00 2001 From: wenyaCern <31894577+wenyaCern@users.noreply.github.com> Date: Mon, 15 Sep 2025 10:25:30 +0200 Subject: [PATCH 06/13] Update femtoDreamProducerTask.cxx Fix bug --- PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx b/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx index e191b1c6791..c181312f91a 100644 --- a/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx +++ b/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx @@ -1248,7 +1248,7 @@ struct femtoDreamProducerTask { if (ConfUseItsPid.value) { fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); } else { - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); } } PROCESS_SWITCH(femtoDreamProducerTask, processData_CentPbPb, @@ -1268,7 +1268,7 @@ struct femtoDreamProducerTask { if (ConfUseItsPid.value) { fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); } else { - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); } if (qnCal.ConfQnSeparation) { From 45ba9679d4130ab070d84f0555faafb2dc16bc40 Mon Sep 17 00:00:00 2001 From: wenyaCern Date: Tue, 16 Sep 2025 13:43:17 +0200 Subject: [PATCH 07/13] fixed as comments --- PWGCF/DataModel/FemtoDerived.h | 11 ++- .../Core/femtoDreamCollisionSelection.h | 55 +++++++++++++- .../TableProducer/femtoDreamProducerTask.cxx | 74 ++++++++++++++----- .../Tasks/femtoDreamPairTaskTrackTrack.cxx | 5 ++ 4 files changed, 122 insertions(+), 23 deletions(-) diff --git a/PWGCF/DataModel/FemtoDerived.h b/PWGCF/DataModel/FemtoDerived.h index 7c0c92974ae..e45602f6b6a 100644 --- a/PWGCF/DataModel/FemtoDerived.h +++ b/PWGCF/DataModel/FemtoDerived.h @@ -35,7 +35,11 @@ enum CollisionBinning { kMult, //! Bin collision in number of charged tracks for mixing kMultPercentile, //! Bin collision in multiplicity percentile for mixing kMultMultPercentile, //! Bin collision in number of charged tracks and multiplicity percentile for mixing +<<<<<<< HEAD kMultPercentileqn, //! Bin collision in multiplicity percentile an qn value for mixing +======= + kMultPercentileQn, //! Bin collision in multiplicity percentile an qn value for mixing +>>>>>>> 79d4db6e4 (fixed as comments) kNCollisionBinning }; @@ -52,8 +56,13 @@ DECLARE_SOA_COLUMN(BitMaskTrackThree, bitmaskTrackThree, BitMaskType); //! Bit f DECLARE_SOA_COLUMN(Downsample, downsample, bool); //! Flag for downsampling +<<<<<<< HEAD DECLARE_SOA_COLUMN(QnVal, qnVal, int); //! qn bins for dividing events DECLARE_SOA_COLUMN(Occupancy, occupancy, int); //! TPC occupancy +======= +DECLARE_SOA_COLUMN(QnVal, qnVal, int); //! qn values for dividing events +DECLARE_SOA_COLUMN(Occupancy, occupancy, int); //! Occupancy of the event +>>>>>>> 79d4db6e4 (fixed as comments) } // namespace femtodreamcollision DECLARE_SOA_TABLE_STAGED(FDCollisions, "FDCOLLISION", @@ -65,7 +74,7 @@ DECLARE_SOA_TABLE_STAGED(FDCollisions, "FDCOLLISION", femtodreamcollision::MagField); using FDCollision = FDCollisions::iterator; -DECLARE_SOA_TABLE(FDExtQnCollisions, "AOD", "FDEXTCOLLISION", +DECLARE_SOA_TABLE(FDExtQnCollisions, "AOD", "FDEXTQNCOLLISION", femtodreamcollision::QnVal, femtodreamcollision::Occupancy); diff --git a/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h b/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h index 6ad6b1e06fd..bb0f9a97a00 100644 --- a/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h +++ b/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h @@ -167,16 +167,38 @@ class FemtoDreamCollisionSelection /// \return whether or not the collisions fulfills the specified selections template bool isPileUpCollisionPbPb(C const& col, +<<<<<<< HEAD bool noSameBunchPileup, bool isGoodITSLayersAll, int tpcOccupancyMin, int tpcOccupancyMax) +======= + bool noSameBunchPileup, bool isGoodITSLayersAll) + { + if ((noSameBunchPileup && !col.selection_bit(aod::evsel::kNoSameBunchPileup)) || (isGoodITSLayersAll && !col.selection_bit(aod::evsel::kIsGoodITSLayersAll))) { + return false; + } + + return true; + } + + /// occupancy selection + /// \tparam T type of the collision + /// \param col Collision + /// \return whether or not the collisions fulfills the specified selections + template + bool occupancySelection(C const& col, + int tpcOccupancyMin, int tpcOccupancyMax) +>>>>>>> 79d4db6e4 (fixed as comments) { const auto occupancy = col.trackOccupancyInTimeRange(); if ((occupancy < tpcOccupancyMin || occupancy > tpcOccupancyMax)) { return false; } +<<<<<<< HEAD if ((noSameBunchPileup && !col.selection_bit(aod::evsel::kNoSameBunchPileup)) || (isGoodITSLayersAll && !col.selection_bit(aod::evsel::kIsGoodITSLayersAll))) { return false; } +======= +>>>>>>> 79d4db6e4 (fixed as comments) return true; } @@ -212,7 +234,7 @@ class FemtoDreamCollisionSelection mHistogramQn->add("Event/qnBin", "; qnBin; entries", kTH1F, {{20, 0, 20}}); for (int iqn(0); iqn < mumQnBins; ++iqn) { - mHistogramQn->add(("Qn/mult_" + std::to_string(iqn)).c_str(), "; cent; c22", kTH1F, {{100, 0, 3500}}); + qnMults.push_back(mHistogramQn->add(("Qn/mult_" + std::to_string(iqn)).c_str(), "; cent; c22", kTH1F, {{100, 0, 3500}})); } return; } @@ -234,9 +256,14 @@ class FemtoDreamCollisionSelection mHistogramQn = registry; mHistogramQn->add("Event/profileC22", "; cent; c22", kTProfile, {{10, 0, 100}}); mHistogramQn->add("Event/profileC24", "; cent; c24", kTProfile, {{10, 0, 100}}); +<<<<<<< HEAD if (doQnSeparation) { +======= + + if (doQnSeparation){ +>>>>>>> 79d4db6e4 (fixed as comments) for (int iqn(0); iqn < mumQnBins; ++iqn) { - mHistogramQn->add(("Qn/profileC22_" + std::to_string(iqn)).c_str(), "; cent; c22", kTProfile, {{10, 0, 100}}); + profilesC22.push_back(mHistogramQn->add(("Qn/profileC22_" + std::to_string(iqn)).c_str(), "; cent; c22", kTProfile, {{10, 0, 100}})); } } return; @@ -387,6 +414,7 @@ class FemtoDreamCollisionSelection mHistogramQn->fill(HIST("Event/centVsqn"), centrality, qn); mHistogramQn->fill(HIST("Event/centVsqnVsSpher"), centrality, qn, fSpher); mHistogramQn->fill(HIST("Event/qnBin"), qnBin); +<<<<<<< HEAD if (qnBin >= 0 && qnBin < numQnBins) { switch (qnBin) { case 0: @@ -423,6 +451,11 @@ class FemtoDreamCollisionSelection return qnBin; // invalid qn bin } } +======= + if (qnBin >= 0 && qnBin < numQnBins){ + std::get>(qnMults[qnBin])->Fill(mult); + } +>>>>>>> 79d4db6e4 (fixed as comments) } return qnBin; @@ -503,6 +536,7 @@ class FemtoDreamCollisionSelection TComplex negEtaQ = TComplex(negEtaRe, negEtaIm); TComplex negEtaQStar = TComplex::Conjugate(negEtaQ); +<<<<<<< HEAD mHistogramQn->get(HIST("Event/profileC22"))->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); if (doQnSeparation && mQnBin >= 0 && mQnBin < numQnBins) { switch (mQnBin) { @@ -539,6 +573,11 @@ class FemtoDreamCollisionSelection default: return; // invalid qn bin } +======= + mHistogramQn->get(HIST("Event/profileC22"))->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + if (doQnSeparation && mQnBin >= 0 && mQnBin < numQnBins){ + std::get>(profilesC22[mQnBin])->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); +>>>>>>> 79d4db6e4 (fixed as comments) } return; } @@ -555,6 +594,7 @@ class FemtoDreamCollisionSelection float mMinSphericity = 0.f; float mSphericityPtmin = 0.f; int mQnBin = -999; +<<<<<<< HEAD HistogramRegistry* mHistogramQn = nullptr; ///< For flow cumulant output TH2D* mReQthisEvt = nullptr; ///< For flow cumulant in an event TH2D* mImQthisEvt = nullptr; ///< For flow cumulant in an event @@ -562,6 +602,17 @@ class FemtoDreamCollisionSelection TH2D* mImQ2thisEvt = nullptr; ///< For flow cumulant in an event TH2D* mMQthisEvt = nullptr; ///< For flow cumulant in an event TH2D* mMQWeightthisEvt = nullptr; ///< For flow cumulant in an event +======= + std::vector qnMults; /// Histograms of multiplicity (TH1F) per Qn bin. Stored as HistPtr (variant of shared_ptr) from HistogramManager. + std::vector profilesC22; /// Pofile Histograms of c22 per Qn bin. + HistogramRegistry* mHistogramQn = nullptr; ///< For flow cumulant output + TH2D* mReQthisEvt = nullptr; ///< For flow cumulant in an event + TH2D* mImQthisEvt = nullptr; ///< For flow cumulant in an event + TH2D* mReQ2thisEvt = nullptr; ///< For flow cumulant in an event + TH2D* mImQ2thisEvt = nullptr; ///< For flow cumulant in an event + TH2D* mMQthisEvt = nullptr; ///< For flow cumulant in an event + TH2D* mMQWeightthisEvt = nullptr; ///< For flow cumulant in an event +>>>>>>> 79d4db6e4 (fixed as comments) }; } // namespace o2::analysis::femtoDream diff --git a/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx b/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx index c181312f91a..bea6aebafe2 100644 --- a/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx +++ b/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx @@ -263,8 +263,8 @@ struct femtoDreamProducerTask { Configurable ConfTrkMaxChi2PerClusterITS{"ConfTrkMaxChi2PerClusterITS", 1000.0f, "Minimal track selection: max allowed chi2 per ITS cluster"}; // 36.0 is default Configurable ConfTrkTPCRefit{"ConfTrkTPCRefit", false, "True: require TPC refit"}; Configurable ConfTrkITSRefit{"ConfTrkITSRefit", false, "True: require ITS refit"}; - Configurable ConfTPCFracsClsCut{"ConfTPCFracsClsCut", false, "Cut fraction of shared TPC clusters"}; - Configurable ConfTPCFracsClsMax{"ConfTPCFracsCls", 1000.f, "Maximum value for fraction of shared TPC clusters"}; + Configurable ConfCutTPCFracSharedCls{"ConfCutTPCFracSharedCls", false, "Cut fraction of shared TPC clusters"}; + Configurable ConfTPCFracSharedClsMax{"ConfTPCFracSharedClsMax", 1000.f, "Maximum value for fraction of shared TPC clusters"}; } OptionTrackSpecialSelections; struct : o2::framework::ConfigurableGroup { @@ -274,6 +274,7 @@ struct femtoDreamProducerTask { } rctCut; struct : o2::framework::ConfigurableGroup { + std::string prefix = std::string("qnCal"); Configurable ConfFlowCalculate{"ConfFlowCalculate", false, "Evt sel: Cumulant of flow"}; // To do Configurable ConfQnSeparation{"ConfQnSeparation", false, "Evt sel: Qn of event"}; Configurable> ConfQnBinSeparator{"ConfQnBinSeparator", std::vector{-999.f, -999.f, -999.f}, "Qn bin separator"}; @@ -285,9 +286,11 @@ struct femtoDreamProducerTask { } qnCal; struct : o2::framework::ConfigurableGroup { - Configurable ConfIsUsePileUp{"ConfIsUsePileUp", false, "Required for choosing whether to run the pile-up cuts"}; + std::string prefix = std::string("OptionEvtSpecialSelections"); + Configurable ConfIsUsePileUpPbPb{"ConfIsUsePileUpPbPb", false, "Required for choosing whether to run the pile-up cuts"}; Configurable ConfEvNoSameBunchPileup{"ConfEvNoSameBunchPileup", false, "Require kNoSameBunchPileup selection on Events."}; Configurable ConfEvIsGoodITSLayersAll{"ConfEvIsGoodITSLayersAll", false, "Require kIsGoodITSLayersAll selection on Events."}; + Configurable ConfIsUseOccupancy{"ConfIsUseOccupancy", false, "Required for choosing whether to run the pile-up cuts"}; Configurable ConfTPCOccupancyMin{"ConfTPCOccupancyMin", 0, "Minimum value for TPC Occupancy selection"}; Configurable ConfTPCOccupancyMax{"ConfTPCOccupancyMax", 5000, "Maximum value for TPC Occupancy selection"}; } OptionEvtSpecialSelections; @@ -704,7 +707,7 @@ struct femtoDreamProducerTask { outputCollsMCLabels(-1); } } - template + template void fillCollisionsAndTracksAndV0AndCascade(CollisionType const& col, TrackType const& tracks, TrackTypeWithItsPid const& tracksWithItsPid, V0Type const& fullV0s, CascadeType const& fullCascades) { // If triggering is enabled, select only events which were triggered wit our triggers @@ -764,10 +767,20 @@ struct femtoDreamProducerTask { // Pileup rejection in PbPb data if constexpr (analysePbPb) { +<<<<<<< HEAD if (OptionEvtSpecialSelections.ConfIsUsePileUp && !colCuts.isPileUpCollisionPbPb(col, OptionEvtSpecialSelections.ConfEvNoSameBunchPileup, OptionEvtSpecialSelections.ConfEvIsGoodITSLayersAll, OptionEvtSpecialSelections.ConfTPCOccupancyMin, OptionEvtSpecialSelections.ConfTPCOccupancyMax)) { return; +======= + if (OptionEvtSpecialSelections.ConfIsUsePileUpPbPb && + !colCuts.isPileUpCollisionPbPb(col, OptionEvtSpecialSelections.ConfEvNoSameBunchPileup, OptionEvtSpecialSelections.ConfEvIsGoodITSLayersAll)){ + return; + } + if (OptionEvtSpecialSelections.ConfIsUseOccupancy && + !colCuts.occupancySelection(col, OptionEvtSpecialSelections.ConfTPCOccupancyMin, OptionEvtSpecialSelections.ConfTPCOccupancyMax)) { + return; +>>>>>>> 79d4db6e4 (fixed as comments) } } @@ -776,6 +789,10 @@ struct femtoDreamProducerTask { fillMCCollision(col); } + if constexpr (doFlow) { + fillCollisionsFlow(col, tracks, mult, spher, multNtr); + } + std::vector childIDs = {0, 0}; // these IDs are necessary to keep track of the children std::vector cascadechildIDs = {0, 0, 0}; // these IDs are necessary to keep track of the children std::vector tmpIDtrack; // this vector keeps track of the matching of the primary track table row <-> aod::track table global index @@ -801,7 +818,7 @@ struct femtoDreamProducerTask { } if constexpr (analysePbPb) { - if (OptionTrackSpecialSelections.ConfTPCFracsClsCut && track.tpcFractionSharedCls() > OptionTrackSpecialSelections.ConfTPCFracsClsMax) { + if (OptionTrackSpecialSelections.ConfCutTPCFracSharedCls && track.tpcFractionSharedCls() > OptionTrackSpecialSelections.ConfTPCFracSharedClsMax) { continue; } } @@ -1124,18 +1141,17 @@ struct femtoDreamProducerTask { } } - // Separate function for fill flow and qn - template - void fillCollisionsFlow(CollisionType const& col, TrackType const& tracks) + template + void fillCollisionsFlow(CollisionType const& col, TrackType const& tracks, float mult, float spher, float multNtr) { - // If triggering is enabled, select only events which were triggered wit our triggers - if (ConfEnableTriggerSelection) { - bool zorroSelected = zorro.isSelected(col.template bc_as().globalBC()); /// check if event was selected by triggers of interest - if (!zorroSelected) { - return; - } + float myqn = -999.; + // Calculate and fill qn values + if (qnCal.ConfQnSeparation) { + myqn = colCuts.computeqnVec(col); + outputExtQnCollision(myqn, col.trackOccupancyInTimeRange()); } +<<<<<<< HEAD const auto spher = colCuts.computeSphericity(col, tracks); float mult = 0; int multNtr = 0; @@ -1182,6 +1198,8 @@ struct femtoDreamProducerTask { float myqn = colCuts.computeqnVec(col); outputExtQnCollision(myqn, col.trackOccupancyInTimeRange()); +======= +>>>>>>> 79d4db6e4 (fixed as comments) // Calculate flow via cumulant if (qnCal.ConfFlowCalculate) { int qnBin = colCuts.myqnBin(mult, qnCal.ConfCentralityMax, qnCal.ConfQnBinSeparator, qnCal.ConfdoFillHisto, spher, myqn, qnCal.ConfNumQnBins, multNtr, qnCal.ConfCentBinWidth); @@ -1205,9 +1223,9 @@ struct femtoDreamProducerTask { auto tracksWithItsPid = soa::Attach(tracks); if (ConfUseItsPid.value) { - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); } else { - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); } } PROCESS_SWITCH(femtoDreamProducerTask, processData, @@ -1226,9 +1244,9 @@ struct femtoDreamProducerTask { auto tracksWithItsPid = soa::Attach(tracks); if (ConfUseItsPid.value) { - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); } else { - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); } } PROCESS_SWITCH(femtoDreamProducerTask, processData_noCentrality, @@ -1246,9 +1264,15 @@ struct femtoDreamProducerTask { auto tracksWithItsPid = soa::Attach(tracks); if (ConfUseItsPid.value) { +<<<<<<< HEAD fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); } else { fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); +======= + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); + } else { + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); +>>>>>>> 79d4db6e4 (fixed as comments) } } PROCESS_SWITCH(femtoDreamProducerTask, processData_CentPbPb, @@ -1266,6 +1290,7 @@ struct femtoDreamProducerTask { auto tracksWithItsPid = soa::Attach(tracks); if (ConfUseItsPid.value) { +<<<<<<< HEAD fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); } else { fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); @@ -1273,6 +1298,11 @@ struct femtoDreamProducerTask { if (qnCal.ConfQnSeparation) { fillCollisionsFlow(col, tracks); +======= + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); + } else { + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); +>>>>>>> 79d4db6e4 (fixed as comments) } } PROCESS_SWITCH(femtoDreamProducerTask, processData_CentPbPb_qvec, @@ -1289,7 +1319,7 @@ struct femtoDreamProducerTask { // get magnetic field for run initCCDB_Mag_Trig(col.bc_as()); // fill the tables - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); } PROCESS_SWITCH(femtoDreamProducerTask, processMC, "Provide MC data", false); @@ -1304,7 +1334,7 @@ struct femtoDreamProducerTask { // get magnetic field for run initCCDB_Mag_Trig(col.bc_as()); // fill the tables - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); } PROCESS_SWITCH(femtoDreamProducerTask, processMC_noCentrality, "Provide MC data without requiring a centrality calibration", false); @@ -1319,7 +1349,11 @@ struct femtoDreamProducerTask { // get magnetic field for run initCCDB_Mag_Trig(col.bc_as()); // fill the tables +<<<<<<< HEAD fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); +======= + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); +>>>>>>> 79d4db6e4 (fixed as comments) } PROCESS_SWITCH(femtoDreamProducerTask, processMC_CentPbPb, "Provide MC data with centrality information for PbPb collisions", false); }; diff --git a/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx b/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx index 049d94ddb85..974e801370f 100644 --- a/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx +++ b/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx @@ -752,8 +752,13 @@ struct femtoDreamPairTaskTrackTrack { case femtodreamcollision::kMultMultPercentile: doMixedEvent_NotMasked(cols, parts, PartitionTrk1, PartitionTrk2, colBinningMultMultPercentile); break; +<<<<<<< HEAD case femtodreamcollision::kMultPercentileqn: doMixedEvent_NotMasked(cols, parts, PartitionTrk1, PartitionTrk2, colBinningMultPercentileqn); +======= + case femtodreamcollision::kMultPercentileQn: + doMixedEvent_NotMasked(cols, parts, PartitionTrk1, PartitionTrk2, colBinningMultPercentileqn); +>>>>>>> 79d4db6e4 (fixed as comments) break; default: LOG(fatal) << "Invalid binning policiy specifed. Breaking..."; From 8aa426fca2baedc32ec2de8357428fd3731be5a5 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Tue, 16 Sep 2025 11:47:55 +0000 Subject: [PATCH 08/13] Please consider the following formatting changes --- PWGCF/DataModel/FemtoDerived.h | 8 ++--- .../Core/femtoDreamCollisionSelection.h | 32 +++++++++---------- .../TableProducer/femtoDreamProducerTask.cxx | 20 ++++++------ .../Tasks/femtoDreamPairTaskTrackTrack.cxx | 2 +- 4 files changed, 31 insertions(+), 31 deletions(-) diff --git a/PWGCF/DataModel/FemtoDerived.h b/PWGCF/DataModel/FemtoDerived.h index e45602f6b6a..fe012ac6989 100644 --- a/PWGCF/DataModel/FemtoDerived.h +++ b/PWGCF/DataModel/FemtoDerived.h @@ -38,7 +38,7 @@ enum CollisionBinning { <<<<<<< HEAD kMultPercentileqn, //! Bin collision in multiplicity percentile an qn value for mixing ======= - kMultPercentileQn, //! Bin collision in multiplicity percentile an qn value for mixing + kMultPercentileQn, //! Bin collision in multiplicity percentile an qn value for mixing >>>>>>> 79d4db6e4 (fixed as comments) kNCollisionBinning }; @@ -57,10 +57,10 @@ DECLARE_SOA_COLUMN(BitMaskTrackThree, bitmaskTrackThree, BitMaskType); //! Bit f DECLARE_SOA_COLUMN(Downsample, downsample, bool); //! Flag for downsampling <<<<<<< HEAD -DECLARE_SOA_COLUMN(QnVal, qnVal, int); //! qn bins for dividing events -DECLARE_SOA_COLUMN(Occupancy, occupancy, int); //! TPC occupancy +DECLARE_SOA_COLUMN(QnVal, qnVal, int); //! qn bins for dividing events +DECLARE_SOA_COLUMN(Occupancy, occupancy, int); //! TPC occupancy ======= -DECLARE_SOA_COLUMN(QnVal, qnVal, int); //! qn values for dividing events +DECLARE_SOA_COLUMN(QnVal, qnVal, int); //! qn values for dividing events DECLARE_SOA_COLUMN(Occupancy, occupancy, int); //! Occupancy of the event >>>>>>> 79d4db6e4 (fixed as comments) } // namespace femtodreamcollision diff --git a/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h b/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h index bb0f9a97a00..3f8ed66ed9c 100644 --- a/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h +++ b/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h @@ -185,8 +185,8 @@ class FemtoDreamCollisionSelection /// \param col Collision /// \return whether or not the collisions fulfills the specified selections template - bool occupancySelection(C const& col, - int tpcOccupancyMin, int tpcOccupancyMax) + bool occupancySelection(C const& col, + int tpcOccupancyMin, int tpcOccupancyMax) >>>>>>> 79d4db6e4 (fixed as comments) { const auto occupancy = col.trackOccupancyInTimeRange(); @@ -260,7 +260,7 @@ class FemtoDreamCollisionSelection if (doQnSeparation) { ======= - if (doQnSeparation){ + if (doQnSeparation) { >>>>>>> 79d4db6e4 (fixed as comments) for (int iqn(0); iqn < mumQnBins; ++iqn) { profilesC22.push_back(mHistogramQn->add(("Qn/profileC22_" + std::to_string(iqn)).c_str(), "; cent; c22", kTProfile, {{10, 0, 100}})); @@ -452,7 +452,7 @@ class FemtoDreamCollisionSelection } } ======= - if (qnBin >= 0 && qnBin < numQnBins){ + if (qnBin >= 0 && qnBin < numQnBins) { std::get>(qnMults[qnBin])->Fill(mult); } >>>>>>> 79d4db6e4 (fixed as comments) @@ -574,9 +574,9 @@ class FemtoDreamCollisionSelection return; // invalid qn bin } ======= - mHistogramQn->get(HIST("Event/profileC22"))->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); - if (doQnSeparation && mQnBin >= 0 && mQnBin < numQnBins){ - std::get>(profilesC22[mQnBin])->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + mHistogramQn->get(HIST("Event/profileC22"))->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); + if (doQnSeparation && mQnBin >= 0 && mQnBin < numQnBins) { + std::get>(profilesC22[mQnBin])->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); >>>>>>> 79d4db6e4 (fixed as comments) } return; @@ -603,15 +603,15 @@ class FemtoDreamCollisionSelection TH2D* mMQthisEvt = nullptr; ///< For flow cumulant in an event TH2D* mMQWeightthisEvt = nullptr; ///< For flow cumulant in an event ======= - std::vector qnMults; /// Histograms of multiplicity (TH1F) per Qn bin. Stored as HistPtr (variant of shared_ptr) from HistogramManager. - std::vector profilesC22; /// Pofile Histograms of c22 per Qn bin. - HistogramRegistry* mHistogramQn = nullptr; ///< For flow cumulant output - TH2D* mReQthisEvt = nullptr; ///< For flow cumulant in an event - TH2D* mImQthisEvt = nullptr; ///< For flow cumulant in an event - TH2D* mReQ2thisEvt = nullptr; ///< For flow cumulant in an event - TH2D* mImQ2thisEvt = nullptr; ///< For flow cumulant in an event - TH2D* mMQthisEvt = nullptr; ///< For flow cumulant in an event - TH2D* mMQWeightthisEvt = nullptr; ///< For flow cumulant in an event + std::vector qnMults; /// Histograms of multiplicity (TH1F) per Qn bin. Stored as HistPtr (variant of shared_ptr) from HistogramManager. + std::vector profilesC22; /// Pofile Histograms of c22 per Qn bin. + HistogramRegistry* mHistogramQn = nullptr; ///< For flow cumulant output + TH2D* mReQthisEvt = nullptr; ///< For flow cumulant in an event + TH2D* mImQthisEvt = nullptr; ///< For flow cumulant in an event + TH2D* mReQ2thisEvt = nullptr; ///< For flow cumulant in an event + TH2D* mImQ2thisEvt = nullptr; ///< For flow cumulant in an event + TH2D* mMQthisEvt = nullptr; ///< For flow cumulant in an event + TH2D* mMQWeightthisEvt = nullptr; ///< For flow cumulant in an event >>>>>>> 79d4db6e4 (fixed as comments) }; } // namespace o2::analysis::femtoDream diff --git a/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx b/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx index bea6aebafe2..ef4f1e15ef3 100644 --- a/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx +++ b/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx @@ -774,12 +774,12 @@ struct femtoDreamProducerTask { return; ======= if (OptionEvtSpecialSelections.ConfIsUsePileUpPbPb && - !colCuts.isPileUpCollisionPbPb(col, OptionEvtSpecialSelections.ConfEvNoSameBunchPileup, OptionEvtSpecialSelections.ConfEvIsGoodITSLayersAll)){ - return; + !colCuts.isPileUpCollisionPbPb(col, OptionEvtSpecialSelections.ConfEvNoSameBunchPileup, OptionEvtSpecialSelections.ConfEvIsGoodITSLayersAll)) { + return; } - if (OptionEvtSpecialSelections.ConfIsUseOccupancy && - !colCuts.occupancySelection(col, OptionEvtSpecialSelections.ConfTPCOccupancyMin, OptionEvtSpecialSelections.ConfTPCOccupancyMax)) { - return; + if (OptionEvtSpecialSelections.ConfIsUseOccupancy && + !colCuts.occupancySelection(col, OptionEvtSpecialSelections.ConfTPCOccupancyMin, OptionEvtSpecialSelections.ConfTPCOccupancyMax)) { + return; >>>>>>> 79d4db6e4 (fixed as comments) } } @@ -1142,7 +1142,7 @@ struct femtoDreamProducerTask { } template - void fillCollisionsFlow(CollisionType const& col, TrackType const& tracks, float mult, float spher, float multNtr) + void fillCollisionsFlow(CollisionType const& col, TrackType const& tracks, float mult, float spher, float multNtr) { float myqn = -999.; // Calculate and fill qn values @@ -1269,9 +1269,9 @@ struct femtoDreamProducerTask { } else { fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); ======= - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); } else { - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); >>>>>>> 79d4db6e4 (fixed as comments) } } @@ -1299,9 +1299,9 @@ struct femtoDreamProducerTask { if (qnCal.ConfQnSeparation) { fillCollisionsFlow(col, tracks); ======= - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); } else { - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); >>>>>>> 79d4db6e4 (fixed as comments) } } diff --git a/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx b/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx index 974e801370f..31096df325a 100644 --- a/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx +++ b/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx @@ -756,7 +756,7 @@ struct femtoDreamPairTaskTrackTrack { case femtodreamcollision::kMultPercentileqn: doMixedEvent_NotMasked(cols, parts, PartitionTrk1, PartitionTrk2, colBinningMultPercentileqn); ======= - case femtodreamcollision::kMultPercentileQn: + case femtodreamcollision::kMultPercentileQn: doMixedEvent_NotMasked(cols, parts, PartitionTrk1, PartitionTrk2, colBinningMultPercentileqn); >>>>>>> 79d4db6e4 (fixed as comments) break; From abd0ced3025e46dd94b68eabf93b3ba5a3b51b00 Mon Sep 17 00:00:00 2001 From: wenyaCern Date: Tue, 16 Sep 2025 14:44:41 +0200 Subject: [PATCH 09/13] fixed as comments, no confllicts --- PWGCF/DataModel/FemtoDerived.h | 13 +- .../Core/femtoDreamCollisionSelection.h | 118 ++---------------- .../TableProducer/femtoDreamProducerTask.cxx | 83 +----------- .../Tasks/femtoDreamPairTaskTrackTrack.cxx | 7 +- 4 files changed, 13 insertions(+), 208 deletions(-) diff --git a/PWGCF/DataModel/FemtoDerived.h b/PWGCF/DataModel/FemtoDerived.h index fe012ac6989..ea42cd79f8b 100644 --- a/PWGCF/DataModel/FemtoDerived.h +++ b/PWGCF/DataModel/FemtoDerived.h @@ -35,11 +35,7 @@ enum CollisionBinning { kMult, //! Bin collision in number of charged tracks for mixing kMultPercentile, //! Bin collision in multiplicity percentile for mixing kMultMultPercentile, //! Bin collision in number of charged tracks and multiplicity percentile for mixing -<<<<<<< HEAD - kMultPercentileqn, //! Bin collision in multiplicity percentile an qn value for mixing -======= - kMultPercentileQn, //! Bin collision in multiplicity percentile an qn value for mixing ->>>>>>> 79d4db6e4 (fixed as comments) + kMultPercentileQn, //! Bin collision in multiplicity percentile an qn value for mixing kNCollisionBinning }; @@ -56,13 +52,8 @@ DECLARE_SOA_COLUMN(BitMaskTrackThree, bitmaskTrackThree, BitMaskType); //! Bit f DECLARE_SOA_COLUMN(Downsample, downsample, bool); //! Flag for downsampling -<<<<<<< HEAD -DECLARE_SOA_COLUMN(QnVal, qnVal, int); //! qn bins for dividing events -DECLARE_SOA_COLUMN(Occupancy, occupancy, int); //! TPC occupancy -======= -DECLARE_SOA_COLUMN(QnVal, qnVal, int); //! qn values for dividing events +DECLARE_SOA_COLUMN(QnVal, qnVal, int); //! qn values for dividing events DECLARE_SOA_COLUMN(Occupancy, occupancy, int); //! Occupancy of the event ->>>>>>> 79d4db6e4 (fixed as comments) } // namespace femtodreamcollision DECLARE_SOA_TABLE_STAGED(FDCollisions, "FDCOLLISION", diff --git a/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h b/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h index 3f8ed66ed9c..f6cf7af4db3 100644 --- a/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h +++ b/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h @@ -167,10 +167,6 @@ class FemtoDreamCollisionSelection /// \return whether or not the collisions fulfills the specified selections template bool isPileUpCollisionPbPb(C const& col, -<<<<<<< HEAD - bool noSameBunchPileup, bool isGoodITSLayersAll, - int tpcOccupancyMin, int tpcOccupancyMax) -======= bool noSameBunchPileup, bool isGoodITSLayersAll) { if ((noSameBunchPileup && !col.selection_bit(aod::evsel::kNoSameBunchPileup)) || (isGoodITSLayersAll && !col.selection_bit(aod::evsel::kIsGoodITSLayersAll))) { @@ -185,21 +181,13 @@ class FemtoDreamCollisionSelection /// \param col Collision /// \return whether or not the collisions fulfills the specified selections template - bool occupancySelection(C const& col, - int tpcOccupancyMin, int tpcOccupancyMax) ->>>>>>> 79d4db6e4 (fixed as comments) + bool occupancySelection(C const& col, + int tpcOccupancyMin, int tpcOccupancyMax) { const auto occupancy = col.trackOccupancyInTimeRange(); if ((occupancy < tpcOccupancyMin || occupancy > tpcOccupancyMax)) { return false; } -<<<<<<< HEAD - if ((noSameBunchPileup && !col.selection_bit(aod::evsel::kNoSameBunchPileup)) || (isGoodITSLayersAll && !col.selection_bit(aod::evsel::kIsGoodITSLayersAll))) { - return false; - } -======= ->>>>>>> 79d4db6e4 (fixed as comments) - return true; } @@ -256,12 +244,8 @@ class FemtoDreamCollisionSelection mHistogramQn = registry; mHistogramQn->add("Event/profileC22", "; cent; c22", kTProfile, {{10, 0, 100}}); mHistogramQn->add("Event/profileC24", "; cent; c24", kTProfile, {{10, 0, 100}}); -<<<<<<< HEAD - if (doQnSeparation) { -======= - if (doQnSeparation) { ->>>>>>> 79d4db6e4 (fixed as comments) + if (doQnSeparation){ for (int iqn(0); iqn < mumQnBins; ++iqn) { profilesC22.push_back(mHistogramQn->add(("Qn/profileC22_" + std::to_string(iqn)).c_str(), "; cent; c22", kTProfile, {{10, 0, 100}})); } @@ -414,48 +398,9 @@ class FemtoDreamCollisionSelection mHistogramQn->fill(HIST("Event/centVsqn"), centrality, qn); mHistogramQn->fill(HIST("Event/centVsqnVsSpher"), centrality, qn, fSpher); mHistogramQn->fill(HIST("Event/qnBin"), qnBin); -<<<<<<< HEAD - if (qnBin >= 0 && qnBin < numQnBins) { - switch (qnBin) { - case 0: - mHistogramQn->fill(HIST("Qn/mult_") + HIST("0"), mult); - break; - case 1: - mHistogramQn->fill(HIST("Qn/mult_") + HIST("1"), mult); - break; - case 2: - mHistogramQn->fill(HIST("Qn/mult_") + HIST("2"), mult); - break; - case 3: - mHistogramQn->fill(HIST("Qn/mult_") + HIST("3"), mult); - break; - case 4: - mHistogramQn->fill(HIST("Qn/mult_") + HIST("4"), mult); - break; - case 5: - mHistogramQn->fill(HIST("Qn/mult_") + HIST("5"), mult); - break; - case 6: - mHistogramQn->fill(HIST("Qn/mult_") + HIST("6"), mult); - break; - case 7: - mHistogramQn->fill(HIST("Qn/mult_") + HIST("7"), mult); - break; - case 8: - mHistogramQn->fill(HIST("Qn/mult_") + HIST("8"), mult); - break; - case 9: - mHistogramQn->fill(HIST("Qn/mult_") + HIST("9"), mult); - break; - default: - return qnBin; // invalid qn bin - } - } -======= if (qnBin >= 0 && qnBin < numQnBins) { std::get>(qnMults[qnBin])->Fill(mult); } ->>>>>>> 79d4db6e4 (fixed as comments) } return qnBin; @@ -536,48 +481,9 @@ class FemtoDreamCollisionSelection TComplex negEtaQ = TComplex(negEtaRe, negEtaIm); TComplex negEtaQStar = TComplex::Conjugate(negEtaQ); -<<<<<<< HEAD - mHistogramQn->get(HIST("Event/profileC22"))->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); - if (doQnSeparation && mQnBin >= 0 && mQnBin < numQnBins) { - switch (mQnBin) { - case 0: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("0"))->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); - break; - case 1: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("1"))->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); - break; - case 2: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("2"))->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); - break; - case 3: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("3"))->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); - break; - case 4: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("4"))->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); - break; - case 5: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("5"))->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); - break; - case 6: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("6"))->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); - break; - case 7: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("7"))->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); - break; - case 8: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("8"))->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); - break; - case 9: - mHistogramQn->get(HIST("Qn/profileC22_") + HIST("9"))->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); - break; - default: - return; // invalid qn bin - } -======= mHistogramQn->get(HIST("Event/profileC22"))->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); - if (doQnSeparation && mQnBin >= 0 && mQnBin < numQnBins) { - std::get>(profilesC22[mQnBin])->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); ->>>>>>> 79d4db6e4 (fixed as comments) + if (doQnSeparation && mQnBin >= 0 && mQnBin < numQnBins){ + std::get>(profilesC22[mQnBin])->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); } return; } @@ -594,25 +500,15 @@ class FemtoDreamCollisionSelection float mMinSphericity = 0.f; float mSphericityPtmin = 0.f; int mQnBin = -999; -<<<<<<< HEAD HistogramRegistry* mHistogramQn = nullptr; ///< For flow cumulant output + std::vector qnMults; /// Histograms of multiplicity (TH1F) per Qn bin. Stored as HistPtr (variant of shared_ptr) from HistogramManager. + std::vector profilesC22; /// Pofile Histograms of c22 per Qn bin TH2D* mReQthisEvt = nullptr; ///< For flow cumulant in an event TH2D* mImQthisEvt = nullptr; ///< For flow cumulant in an event TH2D* mReQ2thisEvt = nullptr; ///< For flow cumulant in an event TH2D* mImQ2thisEvt = nullptr; ///< For flow cumulant in an event TH2D* mMQthisEvt = nullptr; ///< For flow cumulant in an event TH2D* mMQWeightthisEvt = nullptr; ///< For flow cumulant in an event -======= - std::vector qnMults; /// Histograms of multiplicity (TH1F) per Qn bin. Stored as HistPtr (variant of shared_ptr) from HistogramManager. - std::vector profilesC22; /// Pofile Histograms of c22 per Qn bin. - HistogramRegistry* mHistogramQn = nullptr; ///< For flow cumulant output - TH2D* mReQthisEvt = nullptr; ///< For flow cumulant in an event - TH2D* mImQthisEvt = nullptr; ///< For flow cumulant in an event - TH2D* mReQ2thisEvt = nullptr; ///< For flow cumulant in an event - TH2D* mImQ2thisEvt = nullptr; ///< For flow cumulant in an event - TH2D* mMQthisEvt = nullptr; ///< For flow cumulant in an event - TH2D* mMQWeightthisEvt = nullptr; ///< For flow cumulant in an event ->>>>>>> 79d4db6e4 (fixed as comments) }; } // namespace o2::analysis::femtoDream diff --git a/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx b/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx index ef4f1e15ef3..df237b71f28 100644 --- a/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx +++ b/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx @@ -767,20 +767,13 @@ struct femtoDreamProducerTask { // Pileup rejection in PbPb data if constexpr (analysePbPb) { -<<<<<<< HEAD - if (OptionEvtSpecialSelections.ConfIsUsePileUp && - !colCuts.isPileUpCollisionPbPb(col, OptionEvtSpecialSelections.ConfEvNoSameBunchPileup, OptionEvtSpecialSelections.ConfEvIsGoodITSLayersAll, - OptionEvtSpecialSelections.ConfTPCOccupancyMin, OptionEvtSpecialSelections.ConfTPCOccupancyMax)) { - return; -======= if (OptionEvtSpecialSelections.ConfIsUsePileUpPbPb && !colCuts.isPileUpCollisionPbPb(col, OptionEvtSpecialSelections.ConfEvNoSameBunchPileup, OptionEvtSpecialSelections.ConfEvIsGoodITSLayersAll)) { return; } - if (OptionEvtSpecialSelections.ConfIsUseOccupancy && - !colCuts.occupancySelection(col, OptionEvtSpecialSelections.ConfTPCOccupancyMin, OptionEvtSpecialSelections.ConfTPCOccupancyMax)) { + if (OptionEvtSpecialSelections.ConfIsUseOccupancy && + !colCuts.occupancySelection(col, OptionEvtSpecialSelections.ConfTPCOccupancyMin, OptionEvtSpecialSelections.ConfTPCOccupancyMax)) { return; ->>>>>>> 79d4db6e4 (fixed as comments) } } @@ -1150,56 +1143,6 @@ struct femtoDreamProducerTask { myqn = colCuts.computeqnVec(col); outputExtQnCollision(myqn, col.trackOccupancyInTimeRange()); } - -<<<<<<< HEAD - const auto spher = colCuts.computeSphericity(col, tracks); - float mult = 0; - int multNtr = 0; - if (ConfIsRun3) { - if constexpr (useCentrality) { - if constexpr (analysePbPb) { - mult = col.centFT0C(); - } else { - mult = col.centFT0M(); - } - } else { - mult = 0; - } - multNtr = col.multNTracksPV(); - } else { - mult = 1; // multiplicity percentile is know in Run 2 - multNtr = col.multTracklets(); - } - - // check whether the basic event selection criteria are fulfilled - // that included checking if there is at least on usable track or V0 - if (!colCuts.isSelectedCollision(col)) { - return; - } - // bool emptyCollision = false; - if (colCuts.isEmptyCollision(col, tracks, trackCuts)) { - return; - } - - if (rctCut.requireRCTFlagChecker && !rctChecker(col)) { - return; - } - - // Pileup rejection in PbPb data - if constexpr (analysePbPb) { - if (OptionEvtSpecialSelections.ConfIsUsePileUp && - !colCuts.isPileUpCollisionPbPb(col, OptionEvtSpecialSelections.ConfEvNoSameBunchPileup, OptionEvtSpecialSelections.ConfEvIsGoodITSLayersAll, - OptionEvtSpecialSelections.ConfTPCOccupancyMin, OptionEvtSpecialSelections.ConfTPCOccupancyMax)) { - return; - } - } - - // Calculate and fill qn values - float myqn = colCuts.computeqnVec(col); - outputExtQnCollision(myqn, col.trackOccupancyInTimeRange()); - -======= ->>>>>>> 79d4db6e4 (fixed as comments) // Calculate flow via cumulant if (qnCal.ConfFlowCalculate) { int qnBin = colCuts.myqnBin(mult, qnCal.ConfCentralityMax, qnCal.ConfQnBinSeparator, qnCal.ConfdoFillHisto, spher, myqn, qnCal.ConfNumQnBins, multNtr, qnCal.ConfCentBinWidth); @@ -1264,15 +1207,9 @@ struct femtoDreamProducerTask { auto tracksWithItsPid = soa::Attach(tracks); if (ConfUseItsPid.value) { -<<<<<<< HEAD - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); - } else { - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); -======= fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); } else { fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); ->>>>>>> 79d4db6e4 (fixed as comments) } } PROCESS_SWITCH(femtoDreamProducerTask, processData_CentPbPb, @@ -1290,19 +1227,9 @@ struct femtoDreamProducerTask { auto tracksWithItsPid = soa::Attach(tracks); if (ConfUseItsPid.value) { -<<<<<<< HEAD - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); - } else { - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); - } - - if (qnCal.ConfQnSeparation) { - fillCollisionsFlow(col, tracks); -======= fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); } else { - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); ->>>>>>> 79d4db6e4 (fixed as comments) + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); } } PROCESS_SWITCH(femtoDreamProducerTask, processData_CentPbPb_qvec, @@ -1349,11 +1276,7 @@ struct femtoDreamProducerTask { // get magnetic field for run initCCDB_Mag_Trig(col.bc_as()); // fill the tables -<<<<<<< HEAD - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); -======= fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); ->>>>>>> 79d4db6e4 (fixed as comments) } PROCESS_SWITCH(femtoDreamProducerTask, processMC_CentPbPb, "Provide MC data with centrality information for PbPb collisions", false); }; diff --git a/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx b/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx index 31096df325a..d531665fbe0 100644 --- a/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx +++ b/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx @@ -752,13 +752,8 @@ struct femtoDreamPairTaskTrackTrack { case femtodreamcollision::kMultMultPercentile: doMixedEvent_NotMasked(cols, parts, PartitionTrk1, PartitionTrk2, colBinningMultMultPercentile); break; -<<<<<<< HEAD - case femtodreamcollision::kMultPercentileqn: + case femtodreamcollision::kMultPercentileQn: doMixedEvent_NotMasked(cols, parts, PartitionTrk1, PartitionTrk2, colBinningMultPercentileqn); -======= - case femtodreamcollision::kMultPercentileQn: - doMixedEvent_NotMasked(cols, parts, PartitionTrk1, PartitionTrk2, colBinningMultPercentileqn); ->>>>>>> 79d4db6e4 (fixed as comments) break; default: LOG(fatal) << "Invalid binning policiy specifed. Breaking..."; From 12a8b90969e9ec6a6caeb82a79994145fa0496ad Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Tue, 16 Sep 2025 12:46:01 +0000 Subject: [PATCH 10/13] Please consider the following formatting changes --- PWGCF/DataModel/FemtoDerived.h | 4 ++-- .../Core/femtoDreamCollisionSelection.h | 16 ++++++++-------- .../TableProducer/femtoDreamProducerTask.cxx | 8 ++++---- .../Tasks/femtoDreamPairTaskTrackTrack.cxx | 2 +- 4 files changed, 15 insertions(+), 15 deletions(-) diff --git a/PWGCF/DataModel/FemtoDerived.h b/PWGCF/DataModel/FemtoDerived.h index ea42cd79f8b..911f55ab294 100644 --- a/PWGCF/DataModel/FemtoDerived.h +++ b/PWGCF/DataModel/FemtoDerived.h @@ -35,7 +35,7 @@ enum CollisionBinning { kMult, //! Bin collision in number of charged tracks for mixing kMultPercentile, //! Bin collision in multiplicity percentile for mixing kMultMultPercentile, //! Bin collision in number of charged tracks and multiplicity percentile for mixing - kMultPercentileQn, //! Bin collision in multiplicity percentile an qn value for mixing + kMultPercentileQn, //! Bin collision in multiplicity percentile an qn value for mixing kNCollisionBinning }; @@ -52,7 +52,7 @@ DECLARE_SOA_COLUMN(BitMaskTrackThree, bitmaskTrackThree, BitMaskType); //! Bit f DECLARE_SOA_COLUMN(Downsample, downsample, bool); //! Flag for downsampling -DECLARE_SOA_COLUMN(QnVal, qnVal, int); //! qn values for dividing events +DECLARE_SOA_COLUMN(QnVal, qnVal, int); //! qn values for dividing events DECLARE_SOA_COLUMN(Occupancy, occupancy, int); //! Occupancy of the event } // namespace femtodreamcollision diff --git a/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h b/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h index f6cf7af4db3..c8a3947b141 100644 --- a/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h +++ b/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h @@ -181,8 +181,8 @@ class FemtoDreamCollisionSelection /// \param col Collision /// \return whether or not the collisions fulfills the specified selections template - bool occupancySelection(C const& col, - int tpcOccupancyMin, int tpcOccupancyMax) + bool occupancySelection(C const& col, + int tpcOccupancyMin, int tpcOccupancyMax) { const auto occupancy = col.trackOccupancyInTimeRange(); if ((occupancy < tpcOccupancyMin || occupancy > tpcOccupancyMax)) { @@ -245,7 +245,7 @@ class FemtoDreamCollisionSelection mHistogramQn->add("Event/profileC22", "; cent; c22", kTProfile, {{10, 0, 100}}); mHistogramQn->add("Event/profileC24", "; cent; c24", kTProfile, {{10, 0, 100}}); - if (doQnSeparation){ + if (doQnSeparation) { for (int iqn(0); iqn < mumQnBins; ++iqn) { profilesC22.push_back(mHistogramQn->add(("Qn/profileC22_" + std::to_string(iqn)).c_str(), "; cent; c22", kTProfile, {{10, 0, 100}})); } @@ -400,7 +400,7 @@ class FemtoDreamCollisionSelection mHistogramQn->fill(HIST("Event/qnBin"), qnBin); if (qnBin >= 0 && qnBin < numQnBins) { std::get>(qnMults[qnBin])->Fill(mult); - } + } } return qnBin; @@ -482,8 +482,8 @@ class FemtoDreamCollisionSelection TComplex negEtaQStar = TComplex::Conjugate(negEtaQ); mHistogramQn->get(HIST("Event/profileC22"))->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); - if (doQnSeparation && mQnBin >= 0 && mQnBin < numQnBins){ - std::get>(profilesC22[mQnBin])->Fill(centrality, (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); + if (doQnSeparation && mQnBin >= 0 && mQnBin < numQnBins) { + std::get>(profilesC22[mQnBin])->Fill(centrality, (negEtaQ * posEtaQStar).Re() / (negEtaMQ * posEtaMQ), (negEtaMQ * posEtaMQ)); } return; } @@ -501,8 +501,8 @@ class FemtoDreamCollisionSelection float mSphericityPtmin = 0.f; int mQnBin = -999; HistogramRegistry* mHistogramQn = nullptr; ///< For flow cumulant output - std::vector qnMults; /// Histograms of multiplicity (TH1F) per Qn bin. Stored as HistPtr (variant of shared_ptr) from HistogramManager. - std::vector profilesC22; /// Pofile Histograms of c22 per Qn bin + std::vector qnMults; /// Histograms of multiplicity (TH1F) per Qn bin. Stored as HistPtr (variant of shared_ptr) from HistogramManager. + std::vector profilesC22; /// Pofile Histograms of c22 per Qn bin TH2D* mReQthisEvt = nullptr; ///< For flow cumulant in an event TH2D* mImQthisEvt = nullptr; ///< For flow cumulant in an event TH2D* mReQ2thisEvt = nullptr; ///< For flow cumulant in an event diff --git a/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx b/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx index df237b71f28..900e33127df 100644 --- a/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx +++ b/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx @@ -771,8 +771,8 @@ struct femtoDreamProducerTask { !colCuts.isPileUpCollisionPbPb(col, OptionEvtSpecialSelections.ConfEvNoSameBunchPileup, OptionEvtSpecialSelections.ConfEvIsGoodITSLayersAll)) { return; } - if (OptionEvtSpecialSelections.ConfIsUseOccupancy && - !colCuts.occupancySelection(col, OptionEvtSpecialSelections.ConfTPCOccupancyMin, OptionEvtSpecialSelections.ConfTPCOccupancyMax)) { + if (OptionEvtSpecialSelections.ConfIsUseOccupancy && + !colCuts.occupancySelection(col, OptionEvtSpecialSelections.ConfTPCOccupancyMin, OptionEvtSpecialSelections.ConfTPCOccupancyMax)) { return; } } @@ -1209,7 +1209,7 @@ struct femtoDreamProducerTask { if (ConfUseItsPid.value) { fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracksWithItsPid, fullV0s, fullCascades); } else { - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); } } PROCESS_SWITCH(femtoDreamProducerTask, processData_CentPbPb, @@ -1276,7 +1276,7 @@ struct femtoDreamProducerTask { // get magnetic field for run initCCDB_Mag_Trig(col.bc_as()); // fill the tables - fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); + fillCollisionsAndTracksAndV0AndCascade(col, tracks, tracks, fullV0s, fullCascades); } PROCESS_SWITCH(femtoDreamProducerTask, processMC_CentPbPb, "Provide MC data with centrality information for PbPb collisions", false); }; diff --git a/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx b/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx index d531665fbe0..beaf7dc471d 100644 --- a/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx +++ b/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx @@ -752,7 +752,7 @@ struct femtoDreamPairTaskTrackTrack { case femtodreamcollision::kMultMultPercentile: doMixedEvent_NotMasked(cols, parts, PartitionTrk1, PartitionTrk2, colBinningMultMultPercentile); break; - case femtodreamcollision::kMultPercentileQn: + case femtodreamcollision::kMultPercentileQn: doMixedEvent_NotMasked(cols, parts, PartitionTrk1, PartitionTrk2, colBinningMultPercentileqn); break; default: From 66ac6cc5ca688663bcd03369c1b528be6b660dda Mon Sep 17 00:00:00 2001 From: wenyaCern <31894577+wenyaCern@users.noreply.github.com> Date: Thu, 18 Sep 2025 18:24:19 +0200 Subject: [PATCH 11/13] SetPDG code of container Fix a bug for the container of sameEventQnCont. The PDG code was not set previously, resulting in the mass of particles not being obtained, and k* was incorrectly calculated. --- PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx | 1 + 1 file changed, 1 insertion(+) diff --git a/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx b/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx index beaf7dc471d..f75d924683b 100644 --- a/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx +++ b/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx @@ -298,6 +298,7 @@ struct femtoDreamPairTaskTrackTrack { sameEventQnCont.init_qn(&Registry, Binning4D.kstar, Binning4D.mT, Binning4D.multPercentile, Option.IsMC, Option.HighkstarCut); + sameEventQnCont.setPDGCodes(Track1.PDGCode, Track2.PDGCode); if (qnCal.doFillHisto) { qnBinCalculator.initQn(&Registry, qnCal.numQnBins); } From df3b20ea6247e0eb3a627dfac4c43903c0286f83 Mon Sep 17 00:00:00 2001 From: wenyaCern Date: Thu, 25 Sep 2025 16:40:08 +0200 Subject: [PATCH 12/13] Add centrality cut to debug track --- PWGCF/FemtoDream/Tasks/femtoDreamDebugTrack.cxx | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/PWGCF/FemtoDream/Tasks/femtoDreamDebugTrack.cxx b/PWGCF/FemtoDream/Tasks/femtoDreamDebugTrack.cxx index 68fab988fb9..9d2d1dc71dd 100644 --- a/PWGCF/FemtoDream/Tasks/femtoDreamDebugTrack.cxx +++ b/PWGCF/FemtoDream/Tasks/femtoDreamDebugTrack.cxx @@ -66,6 +66,10 @@ struct femtoDreamDebugTrack { Configurable ConfTempFitVarMomentum{"ConfTempFitVarMomentum", 0, "Momentum used for binning: 0 -> pt; 1 -> preco; 2 -> ptpc"}; ConfigurableAxis ConfDummy{"ConfDummy", {1, 0, 1}, "Dummy axis for inv mass"}; + Configurable ConfdoCentCut{"ConfdoCentCut", false, "Enable centrality cut"}; + Configurable ConfCentMax{"ConfCentMax", 100., "Upper limit of centrality cut"}; + Configurable ConfCentMin{"ConfCentMin", 0., "Lower limit of centrality cut"}; + using FemtoMCCollisions = Join; using FemtoMCCollision = FemtoMCCollisions::iterator; @@ -110,6 +114,11 @@ struct femtoDreamDebugTrack { void FillDebugHistos(CollisionType& col, PartitionType& groupPartsOne) { eventHisto.fillQA(col); + + if (ConfdoCentCut.value && (col.multV0M() > ConfCentMax || col.multV0M() < ConfCentMin)){ + return; + } + for (auto& part : groupPartsOne) { trackHisto.fillQA(part, static_cast(ConfTempFitVarMomentum.value), col.multNtr(), col.multV0M(), ConfOptCorrelatedPlots); } From 8fef9b3a6139c08489719995b9b361ef89fb0300 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Thu, 25 Sep 2025 14:43:56 +0000 Subject: [PATCH 13/13] Please consider the following formatting changes --- PWGCF/FemtoDream/Tasks/femtoDreamDebugTrack.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGCF/FemtoDream/Tasks/femtoDreamDebugTrack.cxx b/PWGCF/FemtoDream/Tasks/femtoDreamDebugTrack.cxx index 9d2d1dc71dd..4c7e08cb7e7 100644 --- a/PWGCF/FemtoDream/Tasks/femtoDreamDebugTrack.cxx +++ b/PWGCF/FemtoDream/Tasks/femtoDreamDebugTrack.cxx @@ -115,7 +115,7 @@ struct femtoDreamDebugTrack { { eventHisto.fillQA(col); - if (ConfdoCentCut.value && (col.multV0M() > ConfCentMax || col.multV0M() < ConfCentMin)){ + if (ConfdoCentCut.value && (col.multV0M() > ConfCentMax || col.multV0M() < ConfCentMin)) { return; }