From 5b2f3a8b7f66ff4b38d62f0b0d64086c54afff96 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Thu, 11 Sep 2025 12:36:38 +0000 Subject: [PATCH] Please consider the following formatting changes --- .../Core/femtoDreamCollisionSelection.h | 163 +++++++++--------- PWGCF/FemtoDream/Core/femtoDreamContainer.h | 14 +- .../femtoDreamProducerReducedTask.cxx | 51 +++--- .../Tasks/femtoDreamPairTaskTrackTrack.cxx | 14 +- 4 files changed, 117 insertions(+), 125 deletions(-) diff --git a/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h b/PWGCF/FemtoDream/Core/femtoDreamCollisionSelection.h index 377411283c0..8777927465c 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,24 +166,19 @@ class FemtoDreamCollisionSelection /// \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) + 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)) + 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; } @@ -221,17 +217,17 @@ 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/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){ + 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}}); @@ -325,14 +321,14 @@ 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) { constexpr size_t nBins = 11; 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; @@ -361,14 +357,14 @@ class FemtoDreamCollisionSelection return -999; // safe fallback } - mHistogramQn->fill(HIST("Event/centFT0CBefore"), col.centFT0C()); + 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) + if (mycentBin > static_cast(twoDSeparator.size()) - 1) return qnBin; for (int iqn(0); iqn < static_cast(twoDSeparator[mycentBin].size()) - 1; ++iqn) { @@ -379,12 +375,12 @@ 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){ + if (qnBin >= 0 && qnBin < 10) { switch (qnBin) { case 0: mHistogramQn->fill(HIST("Qn/mult_") + HIST("0"), fMult); @@ -393,8 +389,8 @@ class FemtoDreamCollisionSelection mHistogramQn->fill(HIST("Qn/mult_") + HIST("1"), fMult); break; case 2: - mHistogramQn->fill(HIST("Qn/mult_") + HIST("2"), fMult); - break; + mHistogramQn->fill(HIST("Qn/mult_") + HIST("2"), fMult); + break; case 3: mHistogramQn->fill(HIST("Qn/mult_") + HIST("3"), fMult); break; @@ -415,9 +411,9 @@ class FemtoDreamCollisionSelection break; case 9: mHistogramQn->fill(HIST("Qn/mult_") + HIST("9"), fMult); - break; + break; default: - return qnBin; // invalid qn bin + return qnBin; // invalid qn bin } } return qnBin; @@ -430,34 +426,34 @@ 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) - { + void fillCumulants(T1 const& col, T2 const& tracks, float fHarmonic = 2.f) + { int numOfTracks = col.numContrib(); if (numOfTracks < 3) - return ; + return; 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; } @@ -471,73 +467,72 @@ class FemtoDreamCollisionSelection 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) + 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(col.centFT0C(), (negEtaQ*posEtaQStar).Re()/(negEtaMQ*posEtaMQ), (negEtaMQ*posEtaMQ)); - if (doQnSeparation && qnBin >= 0 && qnBin < mumQnBinNum){ + 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)); + 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)); + 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)); + 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)); + 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)); + 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)); + 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)); + 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)); + 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)); + 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; + mHistogramQn->get(HIST("Qn/profileC22_") + HIST("9"))->Fill(col.centFT0C(), (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) @@ -547,13 +542,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 + 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 60d51e54643..80e47a7dbaf 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; } diff --git a/PWGCF/FemtoDream/TableProducer/femtoDreamProducerReducedTask.cxx b/PWGCF/FemtoDream/TableProducer/femtoDreamProducerReducedTask.cxx index bca22598b0b..b984efa5a63 100644 --- a/PWGCF/FemtoDream/TableProducer/femtoDreamProducerReducedTask.cxx +++ b/PWGCF/FemtoDream/TableProducer/femtoDreamProducerReducedTask.cxx @@ -110,8 +110,8 @@ struct femtoDreamProducerReducedTask { 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> 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"}; @@ -174,8 +174,8 @@ struct femtoDreamProducerReducedTask { trackCuts.init(&qaRegistry, &Registry); - - if (qnCal.ConfgFlowCalculate){ + + if (qnCal.ConfgFlowCalculate) { colCuts.initFlow(&FlowRegistry, qnCal.ConfgQnSeparation); } @@ -399,12 +399,12 @@ struct femtoDreamProducerReducedTask { } // 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)) { + 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; } @@ -420,10 +420,7 @@ struct femtoDreamProducerReducedTask { if (!trackCuts.isSelectedMinimal(track)) { continue; } - if (specialTrkSel.ConfTrkSpecialCuts - && track.tpcFractionSharedCls()>specialTrkSel.ConfTPCFracsClsMax - && track.tpcChi2NCl()>specialTrkSel.ConfTPCChi2NClMax - && track.itsChi2NCl()>specialTrkSel.ConfITSChi2NClMax) { + if (specialTrkSel.ConfTrkSpecialCuts && track.tpcFractionSharedCls() > specialTrkSel.ConfTPCFracsClsMax && track.tpcChi2NCl() > specialTrkSel.ConfTPCChi2NClMax && track.itsChi2NCl() > specialTrkSel.ConfITSChi2NClMax) { continue; } @@ -486,7 +483,7 @@ struct femtoDreamProducerReducedTask { } // Calculate and separate qn bins - // Do and fill cumulant in qn bins + // Do and fill cumulant in qn bins template void fillCollisionsFlow(CollisionType const& col, TrackType const& tracks) { @@ -513,23 +510,23 @@ struct femtoDreamProducerReducedTask { } // 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)) { + 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 + // Calculate and fill qnBins auto qnBin = colCuts.myqnBin(col, qnCal.ConfCentralityMax, qnCal.ConfQnBinSeparator, spher, multNtr, 1.f); - if (qnBin < qnCal.ConfQnBinMin || qnBin > qnCal.ConfQnBinMax){ + if (qnBin < qnCal.ConfQnBinMin || qnBin > qnCal.ConfQnBinMax) { qnBin = -999; } colCuts.fillCumulants(col, tracks); colCuts.doCumulants(col, qnCal.ConfgQnSeparation, qnBin); - outputExtQnCollision(qnBin); + outputExtQnCollision(qnBin); } void processData(aod::FemtoFullCollision const& col, aod::BCsWithTimestamps const&, aod::FemtoFullTracks const& tracks) @@ -571,7 +568,7 @@ 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) @@ -580,9 +577,9 @@ struct femtoDreamProducerReducedTask { getMagneticFieldTesla(col.bc_as()); auto tracksWithItsPid = soa::Attach(tracks); - // fill the tables + // fill the tables fillCollisionsAndTracks_PbPb(col, tracksWithItsPid); - if (qnCal.ConfgQnSeparation){ + if (qnCal.ConfgQnSeparation) { fillCollisionsFlow(col, tracksWithItsPid); } } diff --git a/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx b/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx index 2792eb29b4c..672ac421ece 100644 --- a/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx +++ b/PWGCF/FemtoDream/Tasks/femtoDreamPairTaskTrackTrack.cxx @@ -84,8 +84,8 @@ struct femtoDreamPairTaskTrackTrack { /// 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 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; @@ -282,10 +282,10 @@ 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); + Binning4D.kstar, Binning4D.mT, Binning4D.multPercentile, + Option.IsMC, Option.HighkstarCut); } // get bit for the collision mask @@ -644,7 +644,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()); } @@ -707,7 +707,7 @@ struct femtoDreamPairTaskTrackTrack { if (SliceTrk1.size() == 0 && SliceTrk2.size() == 0) { return; } - if (qnCal.doQnSeparation){ + if (qnCal.doQnSeparation) { doSameEventQn(SliceTrk1, SliceTrk2, parts, col); } }