From 23120fbf788d28a188e1ea152c692792f491efc1 Mon Sep 17 00:00:00 2001 From: Lucia Anna Tarasovicova Date: Mon, 27 Jul 2026 14:17:25 +0200 Subject: [PATCH 1/2] - add chi2 its selection for primary tracks - add its-tpc mismatch check for MC tracks - add new histogram for h-V0 daughter correlations - add new histograms for invariant mass checks in different regions wrt trigger particle - add brackets for each if conddition if missing --- PWGLF/DataModel/LFHStrangeCorrelationTables.h | 6 +- .../Strangeness/hStrangeCorrelationFilter.cxx | 397 ++++--- .../Tasks/Strangeness/hStrangeCorrelation.cxx | 1024 +++++++++++------ 3 files changed, 902 insertions(+), 525 deletions(-) diff --git a/PWGLF/DataModel/LFHStrangeCorrelationTables.h b/PWGLF/DataModel/LFHStrangeCorrelationTables.h index 34404079cbc..ac0ec907db9 100644 --- a/PWGLF/DataModel/LFHStrangeCorrelationTables.h +++ b/PWGLF/DataModel/LFHStrangeCorrelationTables.h @@ -43,8 +43,9 @@ DECLARE_SOA_COLUMN(MCPhysicalPrimary, mcPhysicalPrimary, bool); // true ph DECLARE_SOA_INDEX_COLUMN_FULL(Track, track, int, Tracks, "_Trigger"); //! DECLARE_SOA_COLUMN(MCOriginalPt, mcOriginalPt, float); // true generated pt DECLARE_SOA_COLUMN(IsLeading, isLeading, bool); // is leading track in the event +DECLARE_SOA_COLUMN(MCMask, mcMask, uint16_t); // MC mask of the MC particle } // namespace triggerTracks -DECLARE_SOA_TABLE(TriggerTracks, "AOD", "TRIGGERTRACKS", o2::soa::Index<>, triggerTracks::CollisionId, triggerTracks::MCPhysicalPrimary, triggerTracks::TrackId, triggerTracks::MCOriginalPt, triggerTracks::IsLeading); +DECLARE_SOA_TABLE(TriggerTracks, "AOD", "TRIGGERTRACKS", o2::soa::Index<>, triggerTracks::CollisionId, triggerTracks::MCPhysicalPrimary, triggerTracks::TrackId, triggerTracks::MCOriginalPt, triggerTracks::IsLeading, triggerTracks::MCMask); namespace triggerTrackExtras { DECLARE_SOA_COLUMN(Extra, extra, int); // true physical primary flag @@ -59,8 +60,9 @@ DECLARE_SOA_COLUMN(MCPhysicalPrimary, mcPhysicalPrimary, bool); // true phys DECLARE_SOA_INDEX_COLUMN_FULL(Track, track, int, Tracks, "_Assoc"); //! DECLARE_SOA_COLUMN(MCOriginalPt, mcOriginalPt, float); // true generated pt DECLARE_SOA_COLUMN(PDGCode, pdgCode, float); // pdg code of the MC particle +DECLARE_SOA_COLUMN(MCMask, mcMask, uint16_t); // MC mask of the MC particle } // namespace assocHadrons -DECLARE_SOA_TABLE(AssocHadrons, "AOD", "ASSOCHADRONS", o2::soa::Index<>, assocHadrons::CollisionId, assocHadrons::MCPhysicalPrimary, assocHadrons::TrackId, assocHadrons::MCOriginalPt, assocHadrons::PDGCode); +DECLARE_SOA_TABLE(AssocHadrons, "AOD", "ASSOCHADRONS", o2::soa::Index<>, assocHadrons::CollisionId, assocHadrons::MCPhysicalPrimary, assocHadrons::TrackId, assocHadrons::MCOriginalPt, assocHadrons::PDGCode, assocHadrons::MCMask); /// _________________________________________ /// Table for storing assoc track PID namespace assocPID diff --git a/PWGLF/TableProducer/Strangeness/hStrangeCorrelationFilter.cxx b/PWGLF/TableProducer/Strangeness/hStrangeCorrelationFilter.cxx index ecd50c6dd54..d0f5927e2f2 100644 --- a/PWGLF/TableProducer/Strangeness/hStrangeCorrelationFilter.cxx +++ b/PWGLF/TableProducer/Strangeness/hStrangeCorrelationFilter.cxx @@ -59,12 +59,9 @@ using namespace o2::constants::math; using namespace o2::framework; using namespace o2::framework::expressions; -#define BIT_SET(var, nbit) ((var) |= (1 << (nbit))) -#define BIT_CHECK(var, nbit) ((var) & (1 << (nbit))) - struct HStrangeCorrelationFilter { - const float ctauxi = 4.91; // from PDG - const float ctauomega = 2.461; // from PDG + static constexpr float ctauxi = 4.91; // from PDG + static constexpr float ctauomega = 2.461; // from PDG Service ccdb; @@ -267,6 +264,7 @@ struct HStrangeCorrelationFilter { int trackId; bool isPhysicalPrimary; float origPt; + uint16_t mcMask; }; TriggCandidate thisTrigg; @@ -286,14 +284,14 @@ struct HStrangeCorrelationFilter { fOmegaMean->SetParameters(parameters.massParsOmegaMean->at(0), parameters.massParsOmegaMean->at(1), parameters.massParsOmegaMean->at(2), parameters.massParsOmegaMean->at(3)); fOmegaWidth->SetParameters(parameters.massParsOmegaWidth->at(0), parameters.massParsOmegaWidth->at(1), parameters.massParsOmegaWidth->at(2), parameters.massParsOmegaWidth->at(3)); } else { - hK0ShortMean = 0x0; - hK0ShortWidth = 0x0; - hLambdaMean = 0x0; - hLambdaWidth = 0x0; - hXiMean = 0x0; - hXiWidth = 0x0; - hOmegaMean = 0x0; - hOmegaWidth = 0x0; + hK0ShortMean = nullptr; + hK0ShortWidth = nullptr; + hLambdaMean = nullptr; + hLambdaWidth = nullptr; + hXiMean = nullptr; + hXiWidth = nullptr; + hOmegaMean = nullptr; + hOmegaWidth = nullptr; } if (doprocessV0s || doprocessV0sMC) { histos.add("h3dMassK0Short", "h3dMassK0Short", kTH3F, {axesConfigurations.axisPtQA, axesConfigurations.axisK0ShortMass, axesConfigurations.axisMult}); @@ -329,22 +327,22 @@ struct HStrangeCorrelationFilter { LOG(info) << "Loading mean and sigma from CCDB for run " << mRunNumber << " now..."; auto timeStamp = bc.timestamp(); - TList* listParameters = ccdb->getForTimeStamp(parameterCCDBPath, timeStamp); + auto listParameters = ccdb->getForTimeStamp(parameterCCDBPath, timeStamp); if (!listParameters) { LOG(fatal) << "Problem getting TList object with parameters!"; } if (doprocessV0s || doprocessV0sMC) { - hK0ShortMean = static_cast(listParameters->FindObject("hK0ShortMean")); - hK0ShortWidth = static_cast(listParameters->FindObject("hK0ShortWidth")); - hLambdaMean = static_cast(listParameters->FindObject("hLambdaMean")); - hLambdaWidth = static_cast(listParameters->FindObject("hLambdaWidth")); + hK0ShortMean = dynamic_cast(listParameters->FindObject("hK0ShortMean")); + hK0ShortWidth = dynamic_cast(listParameters->FindObject("hK0ShortWidth")); + hLambdaMean = dynamic_cast(listParameters->FindObject("hLambdaMean")); + hLambdaWidth = dynamic_cast(listParameters->FindObject("hLambdaWidth")); } if (doprocessCascades || doprocessCascadesMC) { - hXiMean = static_cast(listParameters->FindObject("hXiMean")); - hXiWidth = static_cast(listParameters->FindObject("hXiWidth")); - hOmegaMean = static_cast(listParameters->FindObject("hOmegaMean")); - hOmegaWidth = static_cast(listParameters->FindObject("hOmegaWidth")); + hXiMean = dynamic_cast(listParameters->FindObject("hXiMean")); + hXiWidth = dynamic_cast(listParameters->FindObject("hXiWidth")); + hOmegaMean = dynamic_cast(listParameters->FindObject("hOmegaMean")); + hOmegaWidth = dynamic_cast(listParameters->FindObject("hOmegaWidth")); } LOG(info) << "parameters now loaded for " << mRunNumber; } @@ -383,29 +381,36 @@ struct HStrangeCorrelationFilter { // more event selections in Pb-Pb template - bool isCollisionSelectedPbPb(TCollision collision) + bool isCollisionSelectedPbPb(TCollision const& collision) { - if (!collision.selection_bit(aod::evsel::kIsTriggerTVX) && eventSelections.requireGoodTriggerTVX) /* FT0 vertex (acceptable FT0C-FT0A time difference) collisions */ + if (!collision.selection_bit(aod::evsel::kIsTriggerTVX) && eventSelections.requireGoodTriggerTVX) { /* FT0 vertex (acceptable FT0C-FT0A time difference) collisions */ return false; - if (!collision.selection_bit(o2::aod::evsel::kIsGoodITSLayersAll) && eventSelections.requireAllGoodITSLayers) // cut time intervals with dead ITS staves + } + if (!collision.selection_bit(o2::aod::evsel::kIsGoodITSLayersAll) && eventSelections.requireAllGoodITSLayers) { // cut time intervals with dead ITS staves return false; - if (!collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV) && eventSelections.requireGoodZvtxFT0vsPV) // removes collisions with large differences between z of PV by tracks and z of PV from FT0 A-C time difference + } + if (!collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV) && eventSelections.requireGoodZvtxFT0vsPV) { // removes collisions with large differences between z of PV by tracks and z of PV from FT0 A-C time difference return false; + } auto occupancy = collision.trackOccupancyInTimeRange(); - if (occupancy < cfgCutOccupancyLow || occupancy > cfgCutOccupancyHigh) /* Below min occupancy and Above max occupancy*/ + if (occupancy < cfgCutOccupancyLow || occupancy > cfgCutOccupancyHigh) { /* Below min occupancy and Above max occupancy*/ return false; - if (!collision.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) // reject collisions close to Time Frame borders + } + if (!collision.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) { // reject collisions close to Time Frame borders return false; - if (!collision.selection_bit(o2::aod::evsel::kNoITSROFrameBorder)) // reject events affected by the ITS ROF border + } + if (!collision.selection_bit(o2::aod::evsel::kNoITSROFrameBorder)) { // reject events affected by the ITS ROF border return false; - if (!collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) // rejects collisions which are associated with the same "found-by-T0" bunch crossing + } + if (!collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) { // rejects collisions which are associated with the same "found-by-T0" bunch crossing return false; + } return true; } // reco-level trigger quality checks (N.B.: DCA is filtered, not selected) template - bool isValidTrigger(TTrack track) + bool isValidTrigger(TTrack const& track) { if (track.eta() > generalSelections.triggerEtaMax || track.eta() < generalSelections.triggerEtaMin) { return false; @@ -423,13 +428,13 @@ struct HStrangeCorrelationFilter { if (track.tpcNClsShared() > trackSelections.triggerMaxTPCSharedClusters) { return false; // skip, has shared clusters } - if (!(BIT_CHECK(track.itsClusterMap(), 0)) && trackSelections.triggerRequireL0) { + if (!(TESTBIT(track.itsClusterMap(), 0)) && trackSelections.triggerRequireL0) { return false; // skip, doesn't have cluster in ITS L0 } return true; } template - bool isValidAssocTrack(TTrack assoc) + bool isValidAssocTrack(TTrack const& assoc) { if (assoc.eta() > generalSelections.assocEtaMax || assoc.eta() < generalSelections.assocEtaMin) { return false; @@ -445,30 +450,38 @@ struct HStrangeCorrelationFilter { } // do this only if information is available - float nSigmaTPCTOF[8] = {-10, -10, -10, -10, -10, -10, -10, -10}; + std::array nSigmaTPCTOF = {-10, -10, -10, -10, -10, -10, -10, -10}; if constexpr (requires { assoc.tofSignal(); } && !requires { assoc.mcParticle(); }) { if (assoc.tofSignal() > 0) { - if (std::sqrt(assoc.tofNSigmaPi() * assoc.tofNSigmaPi() + assoc.tpcNSigmaPi() * assoc.tpcNSigmaPi()) > trackSelections.assocPionNSigmaTPCFOF) + if (std::sqrt(assoc.tofNSigmaPi() * assoc.tofNSigmaPi() + assoc.tpcNSigmaPi() * assoc.tpcNSigmaPi()) > trackSelections.assocPionNSigmaTPCFOF) { return false; - if (assoc.tofNSigmaPr() < trackSelections.rejectSigma) + } + if (assoc.tofNSigmaPr() < trackSelections.rejectSigma) { return false; - if (assoc.tpcNSigmaPr() < trackSelections.rejectSigma) + } + if (assoc.tpcNSigmaPr() < trackSelections.rejectSigma) { return false; - if (assoc.tofNSigmaKa() < trackSelections.rejectSigma) + } + if (assoc.tofNSigmaKa() < trackSelections.rejectSigma) { return false; - if (assoc.tpcNSigmaKa() < trackSelections.rejectSigma) + } + if (assoc.tpcNSigmaKa() < trackSelections.rejectSigma) { return false; + } nSigmaTPCTOF[4] = assoc.tofNSigmaPi(); nSigmaTPCTOF[5] = assoc.tofNSigmaKa(); nSigmaTPCTOF[6] = assoc.tofNSigmaPr(); nSigmaTPCTOF[7] = assoc.tofNSigmaEl(); } else { - if (assoc.tpcNSigmaPi() > trackSelections.assocPionNSigmaTPCFOF) + if (assoc.tpcNSigmaPi() > trackSelections.assocPionNSigmaTPCFOF) { return false; - if (assoc.tpcNSigmaPr() < trackSelections.rejectSigma) + } + if (assoc.tpcNSigmaPr() < trackSelections.rejectSigma) { return false; - if (assoc.tpcNSigmaKa() < trackSelections.rejectSigma) + } + if (assoc.tpcNSigmaKa() < trackSelections.rejectSigma) { return false; + } } nSigmaTPCTOF[0] = assoc.tpcNSigmaPi(); nSigmaTPCTOF[1] = assoc.tpcNSigmaKa(); @@ -479,12 +492,14 @@ struct HStrangeCorrelationFilter { bool physicalPrimary = false; float origPt = -1; float code = -9999; + uint16_t mcMask = 0; if constexpr (requires { assoc.mcParticle(); }) { if (assoc.has_mcParticle()) { auto mcParticle = assoc.mcParticle(); physicalPrimary = mcParticle.isPhysicalPrimary(); origPt = mcParticle.pt(); code = mcParticle.pdgCode(); + mcMask = assoc.mcMask(); } } @@ -493,7 +508,8 @@ struct HStrangeCorrelationFilter { physicalPrimary, assoc.globalIndex(), origPt, - code); + code, + mcMask); assocPID( nSigmaTPCTOF[0], nSigmaTPCTOF[1], @@ -508,43 +524,54 @@ struct HStrangeCorrelationFilter { // cascadeselection in PbPb template - bool cascadeSelectedPbPb(TCascade casc, float pvx, float pvy, float pvz) + bool cascadeSelectedPbPb(TCascade const& casc, float pvx, float pvy, float pvz) { // bachBaryonCosPA - if (casc.bachBaryonCosPA() < cascSelection.bachBaryonCosPA) + if (casc.bachBaryonCosPA() < cascSelection.bachBaryonCosPA) { return false; + } // bachBaryonDCAxyToPV - if (std::abs(casc.bachBaryonDCAxyToPV()) > cascSelection.bachBaryonDCAxyToPV) + if (std::abs(casc.bachBaryonDCAxyToPV()) > cascSelection.bachBaryonDCAxyToPV) { return false; + } // casccosPA - if (casc.casccosPA(pvx, pvy, pvz) < cascSelection.cascCospa) + if (casc.casccosPA(pvx, pvy, pvz) < cascSelection.cascCospa) { return false; + } // dcacascdaughters float ptDepCut = cascSelection.dcaCacsDauPar0; - if (casc.pt() > cascSelection.lowPtForCascDaugPtDep && casc.pt() < cascSelection.highPtForCascDaugPtDep) + if (casc.pt() > cascSelection.lowPtForCascDaugPtDep && casc.pt() < cascSelection.highPtForCascDaugPtDep) { ptDepCut = cascSelection.dcaCacsDauPar1; - else if (casc.pt() > cascSelection.highPtForCascDaugPtDep) + } else if (casc.pt() > cascSelection.highPtForCascDaugPtDep) { ptDepCut = cascSelection.dcaCacsDauPar2; - if (casc.dcacascdaughters() > ptDepCut) + } + if (casc.dcacascdaughters() > ptDepCut) { return false; + } // dcaV0daughters - if (casc.dcaV0daughters() > cascSelection.cascdcaV0dau) + if (casc.dcaV0daughters() > cascSelection.cascdcaV0dau) { return false; + } // dcav0topv - if (std::abs(casc.dcav0topv(pvx, pvy, pvz)) < cascSelection.cascMindcav0topv) + if (std::abs(casc.dcav0topv(pvx, pvy, pvz)) < cascSelection.cascMindcav0topv) { return false; + } // cascradius - if (casc.cascradius() < cascSelection.cascRadius) + if (casc.cascradius() < cascSelection.cascRadius) { return false; + } // v0radius - if (casc.v0radius() < cascSelection.cascv0RadiusMin) + if (casc.v0radius() < cascSelection.cascv0RadiusMin) { return false; + } // v0cosPA - if (casc.v0cosPA(casc.x(), casc.y(), casc.z()) < cascSelection.cascv0cospa) + if (casc.v0cosPA(casc.x(), casc.y(), casc.z()) < cascSelection.cascv0cospa) { return false; + } // lambdaMassWin - if (std::abs(casc.mLambda() - o2::constants::physics::MassLambda0) > cascSelection.lambdaMassWin) + if (std::abs(casc.mLambda() - o2::constants::physics::MassLambda0) > cascSelection.lambdaMassWin) { return false; + } return true; } @@ -561,8 +588,9 @@ struct HStrangeCorrelationFilter { double leadingPt = -1.; int leadingId = -1; for (auto const& track : tracks) { - if (!isValidTrigger(track)) + if (!isValidTrigger(track)) { continue; + } thisTrigg.pt = track.pt(); thisTrigg.trackId = track.globalIndex(); thisTrigg.collisionId = track.collisionId(); @@ -581,7 +609,8 @@ struct HStrangeCorrelationFilter { TriggCandidate.isPhysicalPrimary, TriggCandidate.trackId, TriggCandidate.origPt, - isLeading); + isLeading, + 0); triggerTrackExtra(1); } } @@ -599,8 +628,9 @@ struct HStrangeCorrelationFilter { double leadingPt = -1.; int leadingId = -1; for (auto const& track : tracks) { - if (!isValidTrigger(track)) + if (!isValidTrigger(track)) { continue; + } thisTrigg.pt = track.pt(); thisTrigg.trackId = track.globalIndex(); thisTrigg.collisionId = track.collisionId(); @@ -608,6 +638,7 @@ struct HStrangeCorrelationFilter { auto mcParticle = track.mcParticle(); thisTrigg.isPhysicalPrimary = mcParticle.isPhysicalPrimary(); thisTrigg.origPt = mcParticle.pt(); + thisTrigg.mcMask = track.mcMask(); } triggerCandidates.push_back(thisTrigg); if (track.pt() > leadingPt) { @@ -623,7 +654,8 @@ struct HStrangeCorrelationFilter { TriggCandidate.isPhysicalPrimary, TriggCandidate.trackId, TriggCandidate.origPt, - isLeading); + isLeading, + TriggCandidate.mcMask); triggerTrackExtra(1); } } @@ -651,8 +683,9 @@ struct HStrangeCorrelationFilter { /// _________________________________________________ /// Step 1: Populate table with trigger tracks for (auto const& track : tracks) { - if (!isValidAssocTrack(track)) + if (!isValidAssocTrack(track)) { continue; + } } } @@ -679,8 +712,9 @@ struct HStrangeCorrelationFilter { /// _________________________________________________ /// Step 1: Populate table with trigger tracks for (auto const& track : tracks) { - if (!isValidAssocTrack(track)) + if (!isValidAssocTrack(track)) { continue; + } } } @@ -707,8 +741,9 @@ struct HStrangeCorrelationFilter { /// _________________________________________________ /// Step 1: Populate table with trigger tracks for (auto const& track : tracks) { - if (!isValidAssocTrack(track)) + if (!isValidAssocTrack(track)) { continue; + } } } void processAssocHadronsMC(soa::Join::iterator const& collision, soa::Filtered const& tracks, aod::McParticles const&, aod::BCsWithTimestamps const&) @@ -734,8 +769,9 @@ struct HStrangeCorrelationFilter { /// _________________________________________________ /// Step 1: Populate table with trigger tracks for (auto const& track : tracks) { - if (!isValidAssocTrack(track)) + if (!isValidAssocTrack(track)) { continue; + } } } @@ -756,19 +792,22 @@ struct HStrangeCorrelationFilter { continue; } // check dE/dx compatibility - int compatibleK0Short = 0; - int compatibleLambda = 0; - int compatibleAntiLambda = 0; + int compatibleK0Short = -1; + int compatibleLambda = -1; + int compatibleAntiLambda = -1; auto posdau = v0.posTrack_as(); auto negdau = v0.negTrack_as(); - if (negdau.tpcNClsCrossedRows() < trackSelections.minTPCNCrossedRows) + if (negdau.tpcNClsCrossedRows() < trackSelections.minTPCNCrossedRows) { continue; - if (posdau.tpcNClsCrossedRows() < trackSelections.minTPCNCrossedRows) + } + if (posdau.tpcNClsCrossedRows() < trackSelections.minTPCNCrossedRows) { continue; - if (trackSelections.requireClusterInITS && (posdau.itsNCls() < trackSelections.minITSClustersForDaughterTracks || negdau.itsNCls() < trackSelections.minITSClustersForDaughterTracks)) + } + if (trackSelections.requireClusterInITS && (posdau.itsNCls() < trackSelections.minITSClustersForDaughterTracks || negdau.itsNCls() < trackSelections.minITSClustersForDaughterTracks)) { continue; + } float dcaDauCutForK0s = v0Selection.dcaDaugToPVForK0s == 0 ? v0Selection.dcaMesonToPV : v0Selection.dcaDaugToPVForK0s; bool isGoodK0Short = (v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * o2::constants::physics::MassK0Short < v0Selection.lifetimecutK0S && @@ -780,48 +819,48 @@ struct HStrangeCorrelationFilter { std::abs(v0.dcapostopv()) > v0Selection.dcaMesonToPV && std::abs(v0.dcanegtopv()) > v0Selection.dcaBaryonToPV); if (std::abs(posdau.tpcNSigmaPi()) < strangedEdxNSigmaLoose && std::abs(negdau.tpcNSigmaPi()) < strangedEdxNSigmaLoose) { if (doPPAnalysis || isGoodK0Short) { - BIT_SET(compatibleK0Short, 0); + SETBIT(compatibleK0Short, 0); } } if (std::abs(posdau.tpcNSigmaPi()) < strangedEdxNSigma && std::abs(negdau.tpcNSigmaPi()) < strangedEdxNSigma) { if (doPPAnalysis || isGoodK0Short) { - BIT_SET(compatibleK0Short, 1); + SETBIT(compatibleK0Short, 1); } } if (std::abs(posdau.tpcNSigmaPi()) < strangedEdxNSigmaTight && std::abs(negdau.tpcNSigmaPi()) < strangedEdxNSigmaTight) { if (doPPAnalysis || isGoodK0Short) { - BIT_SET(compatibleK0Short, 2); + SETBIT(compatibleK0Short, 2); } } if (v0.v0cosPA() > v0Selection.lambdaCospa) { if (std::abs(posdau.tpcNSigmaPr()) < strangedEdxNSigmaLoose && std::abs(negdau.tpcNSigmaPi()) < strangedEdxNSigmaLoose) { if (doPPAnalysis || isGoodLambda) { - BIT_SET(compatibleLambda, 0); + SETBIT(compatibleLambda, 0); } } if (std::abs(posdau.tpcNSigmaPr()) < strangedEdxNSigma && std::abs(negdau.tpcNSigmaPi()) < strangedEdxNSigma) { if (doPPAnalysis || isGoodLambda) { - BIT_SET(compatibleLambda, 1); + SETBIT(compatibleLambda, 1); } } if (std::abs(posdau.tpcNSigmaPr()) < strangedEdxNSigmaTight && std::abs(negdau.tpcNSigmaPi()) < strangedEdxNSigmaTight) { if (doPPAnalysis || isGoodLambda) { - BIT_SET(compatibleLambda, 2); + SETBIT(compatibleLambda, 2); } } if (std::abs(posdau.tpcNSigmaPi()) < strangedEdxNSigmaLoose && std::abs(negdau.tpcNSigmaPr()) < strangedEdxNSigmaLoose) { if (doPPAnalysis || isGoodAntiLambda) { - BIT_SET(compatibleAntiLambda, 0); + SETBIT(compatibleAntiLambda, 0); } } if (std::abs(posdau.tpcNSigmaPi()) < strangedEdxNSigma && std::abs(negdau.tpcNSigmaPr()) < strangedEdxNSigma) { if (doPPAnalysis || isGoodAntiLambda) { - BIT_SET(compatibleAntiLambda, 1); + SETBIT(compatibleAntiLambda, 1); } } if (std::abs(posdau.tpcNSigmaPi()) < strangedEdxNSigmaTight && std::abs(negdau.tpcNSigmaPr()) < strangedEdxNSigmaTight) { if (doPPAnalysis || isGoodAntiLambda) { - BIT_SET(compatibleAntiLambda, 2); + SETBIT(compatibleAntiLambda, 2); } } } @@ -846,12 +885,15 @@ struct HStrangeCorrelationFilter { massNSigmaAntiLambda = (v0.mAntiLambda() - hLambdaMean->Interpolate(v0.pt())) / (hLambdaWidth->Interpolate(v0.pt()) + 1e-6); } } - if (compatibleK0Short) + if (compatibleK0Short > 0) { histos.fill(HIST("h3dMassK0Short"), v0.pt(), v0.mK0Short(), cent); - if (compatibleLambda) + } + if (compatibleLambda > 0) { histos.fill(HIST("h3dMassLambda"), v0.pt(), v0.mLambda(), cent); - if (compatibleAntiLambda) + } + if (compatibleAntiLambda > 0) { histos.fill(HIST("h3dMassAntiLambda"), v0.pt(), v0.mAntiLambda(), cent); + } if (!fillTableOnlyWithCompatible || ( // start major condition check @@ -885,19 +927,22 @@ struct HStrangeCorrelationFilter { continue; } // check dE/dx compatibility - int compatibleK0Short = 0; - int compatibleLambda = 0; - int compatibleAntiLambda = 0; + int compatibleK0Short = -1; + int compatibleLambda = -1; + int compatibleAntiLambda = -1; auto posdau = v0.posTrack_as(); auto negdau = v0.negTrack_as(); - if (negdau.tpcNClsCrossedRows() < trackSelections.minTPCNCrossedRows) + if (negdau.tpcNClsCrossedRows() < trackSelections.minTPCNCrossedRows) { continue; - if (posdau.tpcNClsCrossedRows() < trackSelections.minTPCNCrossedRows) + } + if (posdau.tpcNClsCrossedRows() < trackSelections.minTPCNCrossedRows) { continue; - if (trackSelections.requireClusterInITS && (posdau.itsNCls() < trackSelections.minITSClustersForDaughterTracks || negdau.itsNCls() < trackSelections.minITSClustersForDaughterTracks)) + } + if (trackSelections.requireClusterInITS && (posdau.itsNCls() < trackSelections.minITSClustersForDaughterTracks || negdau.itsNCls() < trackSelections.minITSClustersForDaughterTracks)) { continue; + } float dcaDauCutForK0s = v0Selection.dcaDaugToPVForK0s == 0 ? v0Selection.dcaMesonToPV : v0Selection.dcaDaugToPVForK0s; bool isGoodK0Short = v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * o2::constants::physics::MassK0Short < v0Selection.lifetimecutK0S && @@ -909,49 +954,49 @@ struct HStrangeCorrelationFilter { std::abs(v0.dcapostopv()) > v0Selection.dcaMesonToPV && std::abs(v0.dcanegtopv()) > v0Selection.dcaBaryonToPV; if (std::abs(posdau.tpcNSigmaPi()) < strangedEdxNSigmaLoose && std::abs(negdau.tpcNSigmaPi()) < strangedEdxNSigmaLoose) { if (doPPAnalysis || isGoodK0Short) { - BIT_SET(compatibleK0Short, 0); + SETBIT(compatibleK0Short, 0); } } if (std::abs(posdau.tpcNSigmaPi()) < strangedEdxNSigma && std::abs(negdau.tpcNSigmaPi()) < strangedEdxNSigma) { if (doPPAnalysis || isGoodK0Short) { - BIT_SET(compatibleK0Short, 1); + SETBIT(compatibleK0Short, 1); } } if (std::abs(posdau.tpcNSigmaPi()) < strangedEdxNSigmaTight && std::abs(negdau.tpcNSigmaPi()) < strangedEdxNSigmaTight) { if (doPPAnalysis || isGoodK0Short) { - BIT_SET(compatibleK0Short, 2); + SETBIT(compatibleK0Short, 2); } } if (v0.v0cosPA() > v0Selection.lambdaCospa) { if (std::abs(posdau.tpcNSigmaPr()) < strangedEdxNSigmaLoose && std::abs(negdau.tpcNSigmaPi()) < strangedEdxNSigmaLoose) { if (doPPAnalysis || isGoodLambda) { - BIT_SET(compatibleLambda, 0); + SETBIT(compatibleLambda, 0); } } if (std::abs(posdau.tpcNSigmaPr()) < strangedEdxNSigma && std::abs(negdau.tpcNSigmaPi()) < strangedEdxNSigma) { if (doPPAnalysis || isGoodLambda) { - BIT_SET(compatibleLambda, 1); + SETBIT(compatibleLambda, 1); } } if (std::abs(posdau.tpcNSigmaPr()) < strangedEdxNSigmaTight && std::abs(negdau.tpcNSigmaPi()) < strangedEdxNSigmaTight) { if (doPPAnalysis || isGoodLambda) { - BIT_SET(compatibleLambda, 2); + SETBIT(compatibleLambda, 2); } } if (std::abs(posdau.tpcNSigmaPi()) < strangedEdxNSigmaLoose && std::abs(negdau.tpcNSigmaPr()) < strangedEdxNSigmaLoose) { if (doPPAnalysis || isGoodAntiLambda) { - BIT_SET(compatibleAntiLambda, 0); + SETBIT(compatibleAntiLambda, 0); } } if (std::abs(posdau.tpcNSigmaPi()) < strangedEdxNSigma && std::abs(negdau.tpcNSigmaPr()) < strangedEdxNSigma) { if (doPPAnalysis || isGoodAntiLambda) { - BIT_SET(compatibleAntiLambda, 1); + SETBIT(compatibleAntiLambda, 1); } } if (std::abs(posdau.tpcNSigmaPi()) < strangedEdxNSigmaTight && std::abs(negdau.tpcNSigmaPr()) < strangedEdxNSigmaTight) { if (doPPAnalysis || isGoodAntiLambda) { - BIT_SET(compatibleAntiLambda, 2); + SETBIT(compatibleAntiLambda, 2); } } } @@ -982,18 +1027,24 @@ struct HStrangeCorrelationFilter { bool trueLambda = false; bool trueAntiLambda = false; v0PhysicalPrimary = v0.isPhysicalPrimary(); - if (v0.pdgCode() == PDG_t::kK0Short) + if (v0.pdgCode() == PDG_t::kK0Short) { trueK0Short = true; - if (v0.pdgCode() == PDG_t::kLambda0) + } + if (v0.pdgCode() == PDG_t::kLambda0) { trueLambda = true; - if (v0.pdgCode() == PDG_t::kLambda0Bar) + } + if (v0.pdgCode() == PDG_t::kLambda0Bar) { trueAntiLambda = true; - if (compatibleK0Short && (!doTrueSelectionInMass || (trueK0Short && v0PhysicalPrimary))) + } + if (compatibleK0Short > 0 && (!doTrueSelectionInMass || (trueK0Short && v0PhysicalPrimary))) { histos.fill(HIST("h3dMassK0Short"), v0.pt(), v0.mK0Short(), cent); - if (compatibleLambda && (!doTrueSelectionInMass || (trueLambda && v0PhysicalPrimary))) + } + if (compatibleLambda > 0 && (!doTrueSelectionInMass || (trueLambda && v0PhysicalPrimary))) { histos.fill(HIST("h3dMassLambda"), v0.pt(), v0.mLambda(), cent); - if (compatibleAntiLambda && (!doTrueSelectionInMass || (trueAntiLambda && v0PhysicalPrimary))) + } + if (compatibleAntiLambda > 0 && (!doTrueSelectionInMass || (trueAntiLambda && v0PhysicalPrimary))) { histos.fill(HIST("h3dMassAntiLambda"), v0.pt(), v0.mAntiLambda(), cent); + } if (!fillTableOnlyWithCompatible || ( // start major condition check @@ -1029,33 +1080,39 @@ struct HStrangeCorrelationFilter { casc.casccosPA(collision.posX(), collision.posY(), collision.posZ()) < cascSelection.cascCospa || casc.cascradius() < cascSelection.cascRadius || std::abs(casc.dcav0topv(collision.posX(), collision.posY(), collision.posZ())) < cascSelection.cascMindcav0topv || - std::abs(casc.mLambda() - o2::constants::physics::MassLambda0) > cascSelection.cascV0masswindow)) + std::abs(casc.mLambda() - o2::constants::physics::MassLambda0) > cascSelection.cascV0masswindow)) { continue; + } auto bachTrackCast = casc.bachelor_as(); auto posTrackCast = casc.posTrack_as(); auto negTrackCast = casc.negTrack_as(); // minimum TPC crossed rows - if (bachTrackCast.tpcNClsCrossedRows() < trackSelections.minTPCNCrossedRows) + if (bachTrackCast.tpcNClsCrossedRows() < trackSelections.minTPCNCrossedRows) { continue; - if (posTrackCast.tpcNClsCrossedRows() < trackSelections.minTPCNCrossedRows) + } + if (posTrackCast.tpcNClsCrossedRows() < trackSelections.minTPCNCrossedRows) { continue; - if (negTrackCast.tpcNClsCrossedRows() < trackSelections.minTPCNCrossedRows) + } + if (negTrackCast.tpcNClsCrossedRows() < trackSelections.minTPCNCrossedRows) { continue; - if (!doPPAnalysis && !cascadeSelectedPbPb(casc, collision.posX(), collision.posY(), collision.posZ())) + } + if (!doPPAnalysis && !cascadeSelectedPbPb(casc, collision.posX(), collision.posY(), collision.posZ())) { continue; - if (trackSelections.requireClusterInITS && (posTrackCast.itsNCls() < trackSelections.minITSClustersForDaughterTracks || negTrackCast.itsNCls() < trackSelections.minITSClustersForDaughterTracks || bachTrackCast.itsNCls() < trackSelections.minITSClustersForDaughterTracks)) + } + if (trackSelections.requireClusterInITS && (posTrackCast.itsNCls() < trackSelections.minITSClustersForDaughterTracks || negTrackCast.itsNCls() < trackSelections.minITSClustersForDaughterTracks || bachTrackCast.itsNCls() < trackSelections.minITSClustersForDaughterTracks)) { continue; + } bool isGoodNegCascadePbPb = std::abs(casc.dcabachtopv()) > cascSelection.dcaBachToPV && std::abs(casc.dcapostopv()) > cascSelection.cascDcaBaryonToPV && std::abs(casc.dcanegtopv()) > cascSelection.cascDcaMesonToPV; bool isGoodPosCascadePbPb = std::abs(casc.dcabachtopv()) > cascSelection.dcaBachToPV && std::abs(casc.dcapostopv()) > cascSelection.cascDcaMesonToPV && std::abs(casc.dcanegtopv()) > cascSelection.cascDcaBaryonToPV; // check dE/dx compatibility - int compatibleXiMinus = 0; - int compatibleXiPlus = 0; - int compatibleOmegaMinus = 0; - int compatibleOmegaPlus = 0; + int compatibleXiMinus = -1; + int compatibleXiPlus = -1; + int compatibleOmegaMinus = -1; + int compatibleOmegaPlus = -1; float cascpos = std::hypot(casc.x() - collision.posX(), casc.y() - collision.posY(), casc.z() - collision.posZ()); float cascptotmom = std::hypot(casc.px(), casc.py(), casc.pz()); float ctauXi = o2::constants::physics::MassXiMinus * cascpos / ((cascptotmom + 1e-13) * ctauxi); @@ -1067,65 +1124,65 @@ struct HStrangeCorrelationFilter { ctauOmega < cascSelection.proplifetime && std::abs(casc.yOmega()) < cascSelection.rapCut; if (std::abs(posTrackCast.tpcNSigmaPr()) < strangedEdxNSigmaLoose && std::abs(negTrackCast.tpcNSigmaPi()) < strangedEdxNSigmaLoose && std::abs(bachTrackCast.tpcNSigmaPi()) < strangedEdxNSigmaLoose && casc.sign() < 0) { if (doPPAnalysis || (isGoodNegCascadePbPb && isGoodXiPbPb)) { - BIT_SET(compatibleXiMinus, 0); + SETBIT(compatibleXiMinus, 0); } } if (std::abs(posTrackCast.tpcNSigmaPr()) < strangedEdxNSigma && std::abs(negTrackCast.tpcNSigmaPi()) < strangedEdxNSigma && std::abs(bachTrackCast.tpcNSigmaPi()) < strangedEdxNSigma && casc.sign() < 0) { if (doPPAnalysis || (isGoodNegCascadePbPb && isGoodXiPbPb)) { - BIT_SET(compatibleXiMinus, 1); + SETBIT(compatibleXiMinus, 1); } } if (std::abs(posTrackCast.tpcNSigmaPr()) < strangedEdxNSigmaTight && std::abs(negTrackCast.tpcNSigmaPi()) < strangedEdxNSigmaTight && std::abs(bachTrackCast.tpcNSigmaPi()) < strangedEdxNSigmaTight && casc.sign() < 0) { if (doPPAnalysis || (isGoodNegCascadePbPb && isGoodXiPbPb)) { - BIT_SET(compatibleXiMinus, 2); + SETBIT(compatibleXiMinus, 2); } } if (std::abs(posTrackCast.tpcNSigmaPi()) < strangedEdxNSigmaLoose && std::abs(negTrackCast.tpcNSigmaPr()) < strangedEdxNSigmaLoose && std::abs(bachTrackCast.tpcNSigmaPi()) < strangedEdxNSigmaLoose && casc.sign() > 0) { if (doPPAnalysis || (isGoodPosCascadePbPb && isGoodXiPbPb)) { - BIT_SET(compatibleXiPlus, 0); + SETBIT(compatibleXiPlus, 0); } } if (std::abs(posTrackCast.tpcNSigmaPi()) < strangedEdxNSigma && std::abs(negTrackCast.tpcNSigmaPr()) < strangedEdxNSigma && std::abs(bachTrackCast.tpcNSigmaPi()) < strangedEdxNSigma && casc.sign() > 0) { if (doPPAnalysis || (isGoodPosCascadePbPb && isGoodXiPbPb)) { - BIT_SET(compatibleXiPlus, 1); + SETBIT(compatibleXiPlus, 1); } } if (std::abs(posTrackCast.tpcNSigmaPi()) < strangedEdxNSigmaTight && std::abs(negTrackCast.tpcNSigmaPr()) < strangedEdxNSigmaTight && std::abs(bachTrackCast.tpcNSigmaPi()) < strangedEdxNSigmaTight && casc.sign() > 0) { if (doPPAnalysis || (isGoodPosCascadePbPb && isGoodXiPbPb)) { - BIT_SET(compatibleXiPlus, 2); + SETBIT(compatibleXiPlus, 2); } } if (std::abs(posTrackCast.tpcNSigmaPr()) < strangedEdxNSigmaLoose && std::abs(negTrackCast.tpcNSigmaPi()) < strangedEdxNSigmaLoose && std::abs(bachTrackCast.tpcNSigmaKa()) < strangedEdxNSigmaLoose && casc.sign() < 0) { if (doPPAnalysis || (isGoodNegCascadePbPb && isGoodOmegaPbPb)) { - BIT_SET(compatibleOmegaMinus, 0); + SETBIT(compatibleOmegaMinus, 0); } } if (std::abs(posTrackCast.tpcNSigmaPr()) < strangedEdxNSigma && std::abs(negTrackCast.tpcNSigmaPi()) < strangedEdxNSigma && std::abs(bachTrackCast.tpcNSigmaKa()) < strangedEdxNSigma && casc.sign() < 0) { if (doPPAnalysis || (isGoodNegCascadePbPb && isGoodOmegaPbPb)) { - BIT_SET(compatibleOmegaMinus, 1); + SETBIT(compatibleOmegaMinus, 1); } } if (std::abs(posTrackCast.tpcNSigmaPr()) < strangedEdxNSigmaTight && std::abs(negTrackCast.tpcNSigmaPi()) < strangedEdxNSigmaTight && std::abs(bachTrackCast.tpcNSigmaKa()) < strangedEdxNSigmaTight && casc.sign() < 0) { if (doPPAnalysis || (isGoodNegCascadePbPb && isGoodOmegaPbPb)) { - BIT_SET(compatibleOmegaMinus, 2); + SETBIT(compatibleOmegaMinus, 2); } } if (std::abs(posTrackCast.tpcNSigmaPi()) < strangedEdxNSigmaLoose && std::abs(negTrackCast.tpcNSigmaPr()) < strangedEdxNSigmaLoose && std::abs(bachTrackCast.tpcNSigmaKa()) < strangedEdxNSigmaLoose && casc.sign() > 0) { if (doPPAnalysis || (isGoodPosCascadePbPb && isGoodOmegaPbPb)) { - BIT_SET(compatibleOmegaPlus, 0); + SETBIT(compatibleOmegaPlus, 0); } } if (std::abs(posTrackCast.tpcNSigmaPi()) < strangedEdxNSigma && std::abs(negTrackCast.tpcNSigmaPr()) < strangedEdxNSigma && std::abs(bachTrackCast.tpcNSigmaKa()) < strangedEdxNSigma && casc.sign() > 0) { if (doPPAnalysis || (isGoodPosCascadePbPb && isGoodOmegaPbPb)) { - BIT_SET(compatibleOmegaPlus, 1); + SETBIT(compatibleOmegaPlus, 1); } } if (std::abs(posTrackCast.tpcNSigmaPi()) < strangedEdxNSigmaTight && std::abs(negTrackCast.tpcNSigmaPr()) < strangedEdxNSigmaTight && std::abs(bachTrackCast.tpcNSigmaKa()) < strangedEdxNSigmaTight && casc.sign() > 0) { if (doPPAnalysis || (isGoodPosCascadePbPb && isGoodOmegaPbPb)) { - BIT_SET(compatibleOmegaPlus, 2); + SETBIT(compatibleOmegaPlus, 2); } } float massNSigmaXi = -20.0f; @@ -1144,14 +1201,18 @@ struct HStrangeCorrelationFilter { massNSigmaOmega = (casc.mOmega() - hOmegaMean->Interpolate(casc.pt())) / (hOmegaWidth->Interpolate(casc.pt()) + 1e-6); } } - if (compatibleXiMinus) + if (compatibleXiMinus > 0) { histos.fill(HIST("h3dMassXiMinus"), casc.pt(), casc.mXi(), cent); - if (compatibleXiPlus) + } + if (compatibleXiPlus > 0) { histos.fill(HIST("h3dMassXiPlus"), casc.pt(), casc.mXi(), cent); - if (compatibleOmegaMinus && std::abs(massNSigmaXi) > nSigmaNearXiMassCenter) + } + if (compatibleOmegaMinus > 0 && std::abs(massNSigmaXi) > nSigmaNearXiMassCenter) { histos.fill(HIST("h3dMassOmegaMinus"), casc.pt(), casc.mOmega(), cent); - if (compatibleOmegaPlus && std::abs(massNSigmaXi) > nSigmaNearXiMassCenter) + } + if (compatibleOmegaPlus > 0 && std::abs(massNSigmaXi) > nSigmaNearXiMassCenter) { histos.fill(HIST("h3dMassOmegaPlus"), casc.pt(), casc.mOmega(), cent); + } if (!fillTableOnlyWithCompatible || ( // start major condition check @@ -1187,33 +1248,39 @@ struct HStrangeCorrelationFilter { casc.casccosPA(collision.posX(), collision.posY(), collision.posZ()) < cascSelection.cascCospa || casc.cascradius() < cascSelection.cascRadius || std::abs(casc.dcav0topv(collision.posX(), collision.posY(), collision.posZ())) < cascSelection.cascMindcav0topv || - std::abs(casc.mLambda() - o2::constants::physics::MassLambda0) > cascSelection.cascV0masswindow)) + std::abs(casc.mLambda() - o2::constants::physics::MassLambda0) > cascSelection.cascV0masswindow)) { continue; + } auto bachTrackCast = casc.bachelor_as(); auto posTrackCast = casc.posTrack_as(); auto negTrackCast = casc.negTrack_as(); // minimum TPC crossed rows - if (bachTrackCast.tpcNClsCrossedRows() < trackSelections.minTPCNCrossedRows) + if (bachTrackCast.tpcNClsCrossedRows() < trackSelections.minTPCNCrossedRows) { continue; - if (posTrackCast.tpcNClsCrossedRows() < trackSelections.minTPCNCrossedRows) + } + if (posTrackCast.tpcNClsCrossedRows() < trackSelections.minTPCNCrossedRows) { continue; - if (negTrackCast.tpcNClsCrossedRows() < trackSelections.minTPCNCrossedRows) + } + if (negTrackCast.tpcNClsCrossedRows() < trackSelections.minTPCNCrossedRows) { continue; - if (!doPPAnalysis && !cascadeSelectedPbPb(casc, collision.posX(), collision.posY(), collision.posZ())) + } + if (!doPPAnalysis && !cascadeSelectedPbPb(casc, collision.posX(), collision.posY(), collision.posZ())) { continue; - if (trackSelections.requireClusterInITS && (posTrackCast.itsNCls() < trackSelections.minITSClustersForDaughterTracks || negTrackCast.itsNCls() < trackSelections.minITSClustersForDaughterTracks || bachTrackCast.itsNCls() < trackSelections.minITSClustersForDaughterTracks)) + } + if (trackSelections.requireClusterInITS && (posTrackCast.itsNCls() < trackSelections.minITSClustersForDaughterTracks || negTrackCast.itsNCls() < trackSelections.minITSClustersForDaughterTracks || bachTrackCast.itsNCls() < trackSelections.minITSClustersForDaughterTracks)) { continue; + } bool isGoodNegCascadePbPb = (std::abs(casc.dcabachtopv()) > cascSelection.dcaBachToPV && std::abs(casc.dcapostopv()) > cascSelection.cascDcaBaryonToPV && std::abs(casc.dcanegtopv()) > cascSelection.cascDcaMesonToPV); bool isGoodPosCascadePbPb = (std::abs(casc.dcabachtopv()) > cascSelection.dcaBachToPV && std::abs(casc.dcapostopv()) > cascSelection.cascDcaMesonToPV && std::abs(casc.dcanegtopv()) > cascSelection.cascDcaBaryonToPV); // check dE/dx compatibility - int compatibleXiMinus = 0; - int compatibleXiPlus = 0; - int compatibleOmegaMinus = 0; - int compatibleOmegaPlus = 0; + int compatibleXiMinus = -1; + int compatibleXiPlus = -1; + int compatibleOmegaMinus = -1; + int compatibleOmegaPlus = -1; float cascpos = std::hypot(casc.x() - collision.posX(), casc.y() - collision.posY(), casc.z() - collision.posZ()); float cascptotmom = std::hypot(casc.px(), casc.py(), casc.pz()); float ctauXi = o2::constants::physics::MassXiMinus * cascpos / ((cascptotmom + 1e-13) * ctauxi); @@ -1225,65 +1292,65 @@ struct HStrangeCorrelationFilter { ctauOmega < cascSelection.proplifetime && std::abs(casc.yOmega()) < cascSelection.rapCut; if (std::abs(posTrackCast.tpcNSigmaPr()) < strangedEdxNSigmaLoose && std::abs(negTrackCast.tpcNSigmaPi()) < strangedEdxNSigmaLoose && std::abs(bachTrackCast.tpcNSigmaPi()) < strangedEdxNSigmaLoose && casc.sign() < 0) { if (doPPAnalysis || (isGoodNegCascadePbPb && iGoodXiPbPb)) { - BIT_SET(compatibleXiMinus, 0); + SETBIT(compatibleXiMinus, 0); } } if (std::abs(posTrackCast.tpcNSigmaPr()) < strangedEdxNSigma && std::abs(negTrackCast.tpcNSigmaPi()) < strangedEdxNSigma && std::abs(bachTrackCast.tpcNSigmaPi()) < strangedEdxNSigma && casc.sign() < 0) { if (doPPAnalysis || (isGoodNegCascadePbPb && iGoodXiPbPb)) { - BIT_SET(compatibleXiMinus, 1); + SETBIT(compatibleXiMinus, 1); } } if (std::abs(posTrackCast.tpcNSigmaPr()) < strangedEdxNSigmaTight && std::abs(negTrackCast.tpcNSigmaPi()) < strangedEdxNSigmaTight && std::abs(bachTrackCast.tpcNSigmaPi()) < strangedEdxNSigmaTight && casc.sign() < 0) { if (doPPAnalysis || (isGoodNegCascadePbPb && iGoodXiPbPb)) { - BIT_SET(compatibleXiMinus, 2); + SETBIT(compatibleXiMinus, 2); } } if (std::abs(posTrackCast.tpcNSigmaPi()) < strangedEdxNSigmaLoose && std::abs(negTrackCast.tpcNSigmaPr()) < strangedEdxNSigmaLoose && std::abs(bachTrackCast.tpcNSigmaPi()) < strangedEdxNSigmaLoose && casc.sign() > 0) { if (doPPAnalysis || (isGoodPosCascadePbPb && iGoodXiPbPb)) { - BIT_SET(compatibleXiPlus, 0); + SETBIT(compatibleXiPlus, 0); } } if (std::abs(posTrackCast.tpcNSigmaPi()) < strangedEdxNSigma && std::abs(negTrackCast.tpcNSigmaPr()) < strangedEdxNSigma && std::abs(bachTrackCast.tpcNSigmaPi()) < strangedEdxNSigma && casc.sign() > 0) { if (doPPAnalysis || (isGoodPosCascadePbPb && iGoodXiPbPb)) { - BIT_SET(compatibleXiPlus, 1); + SETBIT(compatibleXiPlus, 1); } } if (std::abs(posTrackCast.tpcNSigmaPi()) < strangedEdxNSigmaTight && std::abs(negTrackCast.tpcNSigmaPr()) < strangedEdxNSigmaTight && std::abs(bachTrackCast.tpcNSigmaPi()) < strangedEdxNSigmaTight && casc.sign() > 0) { if (doPPAnalysis || (isGoodPosCascadePbPb && iGoodXiPbPb)) { - BIT_SET(compatibleXiPlus, 2); + SETBIT(compatibleXiPlus, 2); } } if (std::abs(posTrackCast.tpcNSigmaPr()) < strangedEdxNSigmaLoose && std::abs(negTrackCast.tpcNSigmaPi()) < strangedEdxNSigmaLoose && std::abs(bachTrackCast.tpcNSigmaKa()) < strangedEdxNSigmaLoose && casc.sign() < 0) { if (doPPAnalysis || (isGoodNegCascadePbPb && isGoodOmegaPbPb)) { - BIT_SET(compatibleOmegaMinus, 0); + SETBIT(compatibleOmegaMinus, 0); } } if (std::abs(posTrackCast.tpcNSigmaPr()) < strangedEdxNSigma && std::abs(negTrackCast.tpcNSigmaPi()) < strangedEdxNSigma && std::abs(bachTrackCast.tpcNSigmaKa()) < strangedEdxNSigma && casc.sign() < 0) { if (doPPAnalysis || (isGoodNegCascadePbPb && isGoodOmegaPbPb)) { - BIT_SET(compatibleOmegaMinus, 1); + SETBIT(compatibleOmegaMinus, 1); } } if (std::abs(posTrackCast.tpcNSigmaPr()) < strangedEdxNSigmaTight && std::abs(negTrackCast.tpcNSigmaPi()) < strangedEdxNSigmaTight && std::abs(bachTrackCast.tpcNSigmaKa()) < strangedEdxNSigmaTight && casc.sign() < 0) { if (doPPAnalysis || (isGoodNegCascadePbPb && isGoodOmegaPbPb)) { - BIT_SET(compatibleOmegaMinus, 2); + SETBIT(compatibleOmegaMinus, 2); } } if (std::abs(posTrackCast.tpcNSigmaPi()) < strangedEdxNSigmaLoose && std::abs(negTrackCast.tpcNSigmaPr()) < strangedEdxNSigmaLoose && std::abs(bachTrackCast.tpcNSigmaKa()) < strangedEdxNSigmaLoose && casc.sign() > 0) { if (doPPAnalysis || (isGoodPosCascadePbPb && isGoodOmegaPbPb)) { - BIT_SET(compatibleOmegaPlus, 0); + SETBIT(compatibleOmegaPlus, 0); } } if (std::abs(posTrackCast.tpcNSigmaPi()) < strangedEdxNSigma && std::abs(negTrackCast.tpcNSigmaPr()) < strangedEdxNSigma && std::abs(bachTrackCast.tpcNSigmaKa()) < strangedEdxNSigma && casc.sign() > 0) { if (doPPAnalysis || (isGoodPosCascadePbPb && isGoodOmegaPbPb)) { - BIT_SET(compatibleOmegaPlus, 1); + SETBIT(compatibleOmegaPlus, 1); } } if (std::abs(posTrackCast.tpcNSigmaPi()) < strangedEdxNSigmaTight && std::abs(negTrackCast.tpcNSigmaPr()) < strangedEdxNSigmaTight && std::abs(bachTrackCast.tpcNSigmaKa()) < strangedEdxNSigmaTight && casc.sign() > 0) { if (doPPAnalysis || (isGoodPosCascadePbPb && isGoodOmegaPbPb)) { - BIT_SET(compatibleOmegaPlus, 2); + SETBIT(compatibleOmegaPlus, 2); } } float massNSigmaXi = 20.0f; @@ -1309,22 +1376,30 @@ struct HStrangeCorrelationFilter { bool trueOmegaMinus = false; bool trueOmegaPlus = false; cascPhysicalPrimary = casc.isPhysicalPrimary(); - if (casc.pdgCode() == PDG_t::kXiMinus) + if (casc.pdgCode() == PDG_t::kXiMinus) { trueXiMinus = true; - if (casc.pdgCode() == PDG_t::kXiPlusBar) + } + if (casc.pdgCode() == PDG_t::kXiPlusBar) { trueXiPlus = true; - if (casc.pdgCode() == PDG_t::kOmegaMinus) + } + if (casc.pdgCode() == PDG_t::kOmegaMinus) { trueOmegaMinus = true; - if (casc.pdgCode() == PDG_t::kOmegaPlusBar) + } + if (casc.pdgCode() == PDG_t::kOmegaPlusBar) { trueOmegaPlus = true; - if (compatibleXiMinus && (!doTrueSelectionInMass || (trueXiMinus && cascPhysicalPrimary))) + } + if (compatibleXiMinus > 0 && (!doTrueSelectionInMass || (trueXiMinus && cascPhysicalPrimary))) { histos.fill(HIST("h3dMassXiMinus"), casc.pt(), casc.mXi(), cent); - if (compatibleXiPlus && (!doTrueSelectionInMass || (trueXiPlus && cascPhysicalPrimary))) + } + if (compatibleXiPlus > 0 && (!doTrueSelectionInMass || (trueXiPlus && cascPhysicalPrimary))) { histos.fill(HIST("h3dMassXiPlus"), casc.pt(), casc.mXi(), cent); - if (compatibleOmegaMinus && (!doTrueSelectionInMass || (trueOmegaMinus && cascPhysicalPrimary)) && std::abs(massNSigmaXi) > nSigmaNearXiMassCenter) + } + if (compatibleOmegaMinus > 0 && (!doTrueSelectionInMass || (trueOmegaMinus && cascPhysicalPrimary)) && std::abs(massNSigmaXi) > nSigmaNearXiMassCenter) { histos.fill(HIST("h3dMassOmegaMinus"), casc.pt(), casc.mOmega(), cent); - if (compatibleOmegaPlus && (!doTrueSelectionInMass || (trueOmegaPlus && cascPhysicalPrimary)) && std::abs(massNSigmaXi) > nSigmaNearXiMassCenter) + } + if (compatibleOmegaPlus > 0 && (!doTrueSelectionInMass || (trueOmegaPlus && cascPhysicalPrimary)) && std::abs(massNSigmaXi) > nSigmaNearXiMassCenter) { histos.fill(HIST("h3dMassOmegaPlus"), casc.pt(), casc.mOmega(), cent); + } if (!fillTableOnlyWithCompatible || ( // start major condition check @@ -1352,8 +1427,8 @@ struct HStrangeCorrelationFilter { PROCESS_SWITCH(HStrangeCorrelationFilter, processAssocHadronsMC, "Produce associated Hadron tables for MC", false); }; -WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +WorkflowSpec defineDataProcessing(ConfigContext const& context) { return WorkflowSpec{ - adaptAnalysisTask(cfgc)}; + adaptAnalysisTask(context)}; } diff --git a/PWGLF/Tasks/Strangeness/hStrangeCorrelation.cxx b/PWGLF/Tasks/Strangeness/hStrangeCorrelation.cxx index c6a99dab433..35c74361200 100644 --- a/PWGLF/Tasks/Strangeness/hStrangeCorrelation.cxx +++ b/PWGLF/Tasks/Strangeness/hStrangeCorrelation.cxx @@ -66,6 +66,7 @@ #include +#include #include #include #include @@ -128,6 +129,7 @@ struct HStrangeCorrelation { Configurable useCentralityinPrediction{"useCentralityinPrediction", false, "if true, use centrality instead of multiplisity"}; Configurable doMirroringInDelataEta{"doMirroringInDelataEta", false, "if true, fill only positive delta eta and mirror the negative side in post processing, Adjust the delta axis!"}; Configurable doMassSpectrumCheck{"doMassSpectrumCheck", false, "if true, add and fill invariant-mass spectrum"}; + Configurable doCorrelationsHadronV0daughter{"doCorrelationsHadronV0daughter", false, "if true, do correlations of hadrons with V0 daughters"}; } masterConfigurations; // master analysis switches @@ -209,7 +211,8 @@ struct HStrangeCorrelation { Configurable requireClusterInITS{"requireClusterInITS", false, "require cluster in ITS for V0 and cascade daughter tracks"}; Configurable minITSClustersForDaughterTracks{"minITSClustersForDaughterTracks", 1, "Minimum number of ITS clusters for V0 daughter tracks"}; Configurable requireDCAzCut{"requireDCAzCut", false, "require DCAz cut for trigger and associated primary tracks"}; - + Configurable doITSChi2Selection{"doITSChi2Selection", false, "require ITS chi2 cut for trigger and associated primary tracks"}; + Configurable checkForITSTPCMissmatchMC{"checkForITSTPCMissmatchMC", false, "if true, reject tracks with MC mask 13 (ITS-TPC mismatch) for trigger and associated primary tracks"}; // --- Trigger: DCA variation from basic formula: |DCAxy| < 0.004f + (0.013f / pt) Configurable dcaXYconstant{"dcaXYconstant", 0.004, "[0] in |DCAxy| < [0]+[1]/pT"}; Configurable dcaXYpTdep{"dcaXYpTdep", 0.013, "[1] in |DCAxy| < [0]+[1]/pT"}; @@ -222,6 +225,8 @@ struct HStrangeCorrelation { Configurable dcaZconstantAssoc{"dcaZconstantAssoc", 0.004, "[0] in |DCAz| < [0]+[1]/pT"}; Configurable dcaZpTdepAssoc{"dcaZpTdepAssoc", 0.013, "[1] in |DCAz| < [0]+[1]/pT"}; Configurable dEdxCompatibility{"dEdxCompatibility", 1, "0: loose, 1: normal, 2: tight. Defined in HStrangeCorrelationFilter"}; + Configurable chi2ITSfit{"chi2ITSfit", 36, "chi2 ITS fit for trigger and associated primary tracks"}; + } trackSelection; struct : ConfigurableGroup { std::string prefix = "v0Selection"; @@ -278,7 +283,7 @@ struct HStrangeCorrelation { // Configurable bachBaryonDCAxyToPV{"bachBaryonDCAxyToPV", 0.08, "DCA bachelor baryon to PV"}; // // on the fly correction instead of mixingParameter - Configurable doOnTheFlyFlattening{"doOnTheFlyFlattening", 0, "enable an on-the-fly correction instead of using mixing"}; + Configurable doOnTheFlyFlattening{"doOnTheFlyFlattening", false, "enable an on-the-fly correction instead of using mixing"}; // delta eta ranges for toward and transverse checks Configurable transwerseDeltaEtaRangeMin{"transwerseDeltaEtaRangeMin", 1.0, "minimum delta eta for transverse region"}; @@ -297,13 +302,13 @@ struct HStrangeCorrelation { float efficiencyError; int type; }; - float pvz; - float mult; + float pvz = 0.0f; + float mult = 0.0f; std::vector trigParticles; std::vector assocParticles; void addValidParticle(float eta, float phi, float pt, int region, float efficiency, float efficiencyError, int type) { - ValidParticle particle{eta, phi, pt, region, efficiency, efficiencyError, type}; + ValidParticle particle{.eta = eta, .phi = phi, .pt = pt, .region = region, .efficiency = efficiency, .efficiencyError = efficiencyError, .type = type}; if (type == -1) { trigParticles.push_back(particle); @@ -366,10 +371,10 @@ struct HStrangeCorrelation { Preslice collisionSliceHadrons = aod::assocHadrons::collisionId; Preslice perCollision = aod::mcparticle::mcCollisionId; - static constexpr std::string_view V0names[] = {"K0Short", "Lambda", "AntiLambda"}; - static constexpr std::string_view Cascadenames[] = {"XiMinus", "XiPlus", "OmegaMinus", "OmegaPlus"}; - static constexpr std::string_view Particlenames[] = {"K0Short", "Lambda", "AntiLambda", "XiMinus", "XiPlus", "OmegaMinus", "OmegaPlus", "Pion", "Hadron"}; - static constexpr int PdgCodes[] = {310, 3122, -3122, 3312, -3312, 3334, -3334, 211}; + static constexpr std::array V0names = {"K0Short", "Lambda", "AntiLambda"}; + static constexpr std::array Cascadenames = {"XiMinus", "XiPlus", "OmegaMinus", "OmegaPlus"}; + static constexpr std::array Particlenames = {"K0Short", "Lambda", "AntiLambda", "XiMinus", "XiPlus", "OmegaMinus", "OmegaPlus", "Pion", "Hadron"}; + static constexpr std::array PdgCodes = {310, 3122, -3122, 3312, -3312, 3334, -3334, 211}; static constexpr int IndexPion = 7; static constexpr int IndexXiMinus = 0; @@ -399,8 +404,8 @@ struct HStrangeCorrelation { std::vector> axisRanges; - const float ctauxi = 4.91; // from PDG - const float ctauomega = 2.461; // from PDG + static constexpr float ctauxi = 4.91; // from PDG + static constexpr float ctauomega = 2.461; // from PDG static constexpr float MinRadiusTPC = 0.8; static constexpr float MaxRadiusTPC = 2.5; @@ -409,6 +414,8 @@ struct HStrangeCorrelation { static constexpr int AssocParticleTypes = 9; // K0S, Lambda, AntiLambda, Xi-, Xi+, Omega-, Omega+, Pion, Hadron static constexpr int AssocParticleTypesNoHadron = 8; // K0S, Lambda, AntiLambda, Xi-, Xi+, Omega-, Omega+, Pion + static constexpr int AssocV0Types = 3; // K0S, Lambda, AntiLambda, + static constexpr int AssocCascadeTypes = 4; // Xi-, Xi+, Omega-, Omega+ /// Function to aid in calculating delta-phi /// \param phi1 first phi value @@ -445,91 +452,99 @@ struct HStrangeCorrelation { LOG(info) << "Loading efficiencies from CCDB for run " << mRunNumber << " now..."; auto timeStamp = bc.timestamp(); - TList* listEfficiencies = ccdb->getForTimeStamp(efficiencyCCDBPath, timeStamp); + auto* listEfficiencies = ccdb->getForTimeStamp(efficiencyCCDBPath, timeStamp); if (!listEfficiencies) { LOG(fatal) << "Problem getting TList object with efficiencies!"; } - hEfficiencyTrigger = static_cast(listEfficiencies->FindObject("hEfficiencyTrigger")); - hEfficiencyTriggerMult = static_cast(listEfficiencies->FindObject("hEfficiencyTriggerMult")); - hEfficiencyTriggerMultVsPhi = static_cast(listEfficiencies->FindObject("hEfficiencyTriggerMultVsPhi")); - hEfficiencyK0Short = static_cast(listEfficiencies->FindObject("hEfficiencyK0Short")); - hEfficiencyK0ShortMultVsPhi = static_cast(listEfficiencies->FindObject("hEfficiencyK0ShortMultVsPhi")); - hEfficiencyLambda = static_cast(listEfficiencies->FindObject("hEfficiencyLambda")); - hEfficiencyLambdaMultVsPhi = static_cast(listEfficiencies->FindObject("hEfficiencyLambdaMultVsPhi")); - hEfficiencyAntiLambda = static_cast(listEfficiencies->FindObject("hEfficiencyAntiLambda")); - hEfficiencyAntiLambdaMultVsPhi = static_cast(listEfficiencies->FindObject("hEfficiencyAntiLambdaMultVsPhi")); - hEfficiencyXiMinus = static_cast(listEfficiencies->FindObject("hEfficiencyXiMinus")); - hEfficiencyXiMinusMultVsPhi = static_cast(listEfficiencies->FindObject("hEfficiencyXiMinusMultVsPhi")); - hEfficiencyXiPlus = static_cast(listEfficiencies->FindObject("hEfficiencyXiPlus")); - hEfficiencyXiPlusMultVsPhi = static_cast(listEfficiencies->FindObject("hEfficiencyXiPlusMultVsPhi")); - hEfficiencyOmegaMinus = static_cast(listEfficiencies->FindObject("hEfficiencyOmegaMinus")); - hEfficiencyOmegaMinusMultVsPhi = static_cast(listEfficiencies->FindObject("hEfficiencyOmegaMinusMultVsPhi")); - hEfficiencyOmegaPlus = static_cast(listEfficiencies->FindObject("hEfficiencyOmegaPlus")); - hEfficiencyOmegaPlusMultVsPhi = static_cast(listEfficiencies->FindObject("hEfficiencyOmegaPlusMultVsPhi")); - hEfficiencyHadron = static_cast(listEfficiencies->FindObject("hEfficiencyHadron")); - hEfficiencyHadronMult = static_cast(listEfficiencies->FindObject("hEfficiencyHadronMult")); - hEfficiencyPion = static_cast(listEfficiencies->FindObject("hEfficiencyPion")); - hPurityHadron = static_cast(listEfficiencies->FindObject("hPurityHadron")); - hPurityHadronMult = static_cast(listEfficiencies->FindObject("hPurityHadronMult")); - hEfficiencyUncertaintyTrigger = static_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyTrigger")); - hEfficiencyUncertaintyTriggerMult = static_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyTriggerMult")); - hEfficiencyUncertaintyK0Short = static_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyK0Short")); - hEfficiencyUncertaintyLambda = static_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyLambda")); - hEfficiencyUncertaintyAntiLambda = static_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyAntiLambda")); - hEfficiencyUncertaintyXiMinus = static_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyXiMinus")); - hEfficiencyUncertaintyXiPlus = static_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyXiPlus")); - hEfficiencyUncertaintyOmegaMinus = static_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyOmegaMinus")); - hEfficiencyUncertaintyOmegaPlus = static_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyOmegaPlus")); - hEfficiencyUncertaintyPion = static_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyPion")); - hEfficiencyUncertaintyHadron = static_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyHadron")); - hEfficiencyUncertaintyHadronMult = static_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyHadronMult")); - hPurityUncertaintyHadron = static_cast(listEfficiencies->FindObject("hPurityUncertaintyHadron")); - hPurityUncertaintyHadronMult = static_cast(listEfficiencies->FindObject("hPurityUncertaintyHadronMult")); - if (efficiencyFlags.applyEfficiencyPropagation && !efficiencyFlags.applyEffAsFunctionOfMultAndPhi && !hEfficiencyUncertaintyTrigger) + hEfficiencyTrigger = dynamic_cast(listEfficiencies->FindObject("hEfficiencyTrigger")); + hEfficiencyTriggerMult = dynamic_cast(listEfficiencies->FindObject("hEfficiencyTriggerMult")); + hEfficiencyTriggerMultVsPhi = dynamic_cast(listEfficiencies->FindObject("hEfficiencyTriggerMultVsPhi")); + hEfficiencyK0Short = dynamic_cast(listEfficiencies->FindObject("hEfficiencyK0Short")); + hEfficiencyK0ShortMultVsPhi = dynamic_cast(listEfficiencies->FindObject("hEfficiencyK0ShortMultVsPhi")); + hEfficiencyLambda = dynamic_cast(listEfficiencies->FindObject("hEfficiencyLambda")); + hEfficiencyLambdaMultVsPhi = dynamic_cast(listEfficiencies->FindObject("hEfficiencyLambdaMultVsPhi")); + hEfficiencyAntiLambda = dynamic_cast(listEfficiencies->FindObject("hEfficiencyAntiLambda")); + hEfficiencyAntiLambdaMultVsPhi = dynamic_cast(listEfficiencies->FindObject("hEfficiencyAntiLambdaMultVsPhi")); + hEfficiencyXiMinus = dynamic_cast(listEfficiencies->FindObject("hEfficiencyXiMinus")); + hEfficiencyXiMinusMultVsPhi = dynamic_cast(listEfficiencies->FindObject("hEfficiencyXiMinusMultVsPhi")); + hEfficiencyXiPlus = dynamic_cast(listEfficiencies->FindObject("hEfficiencyXiPlus")); + hEfficiencyXiPlusMultVsPhi = dynamic_cast(listEfficiencies->FindObject("hEfficiencyXiPlusMultVsPhi")); + hEfficiencyOmegaMinus = dynamic_cast(listEfficiencies->FindObject("hEfficiencyOmegaMinus")); + hEfficiencyOmegaMinusMultVsPhi = dynamic_cast(listEfficiencies->FindObject("hEfficiencyOmegaMinusMultVsPhi")); + hEfficiencyOmegaPlus = dynamic_cast(listEfficiencies->FindObject("hEfficiencyOmegaPlus")); + hEfficiencyOmegaPlusMultVsPhi = dynamic_cast(listEfficiencies->FindObject("hEfficiencyOmegaPlusMultVsPhi")); + hEfficiencyHadron = dynamic_cast(listEfficiencies->FindObject("hEfficiencyHadron")); + hEfficiencyHadronMult = dynamic_cast(listEfficiencies->FindObject("hEfficiencyHadronMult")); + hEfficiencyPion = dynamic_cast(listEfficiencies->FindObject("hEfficiencyPion")); + hPurityHadron = dynamic_cast(listEfficiencies->FindObject("hPurityHadron")); + hPurityHadronMult = dynamic_cast(listEfficiencies->FindObject("hPurityHadronMult")); + hEfficiencyUncertaintyTrigger = dynamic_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyTrigger")); + hEfficiencyUncertaintyTriggerMult = dynamic_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyTriggerMult")); + hEfficiencyUncertaintyK0Short = dynamic_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyK0Short")); + hEfficiencyUncertaintyLambda = dynamic_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyLambda")); + hEfficiencyUncertaintyAntiLambda = dynamic_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyAntiLambda")); + hEfficiencyUncertaintyXiMinus = dynamic_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyXiMinus")); + hEfficiencyUncertaintyXiPlus = dynamic_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyXiPlus")); + hEfficiencyUncertaintyOmegaMinus = dynamic_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyOmegaMinus")); + hEfficiencyUncertaintyOmegaPlus = dynamic_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyOmegaPlus")); + hEfficiencyUncertaintyPion = dynamic_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyPion")); + hEfficiencyUncertaintyHadron = dynamic_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyHadron")); + hEfficiencyUncertaintyHadronMult = dynamic_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyHadronMult")); + hPurityUncertaintyHadron = dynamic_cast(listEfficiencies->FindObject("hPurityUncertaintyHadron")); + hPurityUncertaintyHadronMult = dynamic_cast(listEfficiencies->FindObject("hPurityUncertaintyHadronMult")); + if (efficiencyFlags.applyEfficiencyPropagation && !efficiencyFlags.applyEffAsFunctionOfMultAndPhi && !hEfficiencyUncertaintyTrigger) { LOG(fatal) << "Problem getting hEfficiencyUncertaintyTrigger!"; - if (efficiencyFlags.applyEffAsFunctionOfMult && !hEfficiencyTriggerMult) + } + if (efficiencyFlags.applyEffAsFunctionOfMult && !hEfficiencyTriggerMult) { LOG(fatal) << "Problem getting hEfficiencyTriggerMult!"; + } LOG(info) << "Efficiencies now loaded for " << mRunNumber; } template - uint64_t v0selectionBitmap(TV0 v0, float pvx, float pvy, float pvz) + uint64_t v0selectionBitmap(TV0 const& v0, float pvx, float pvy, float pvz) // precalculate this information so that a check is one mask operation, not many { uint64_t bitMap = 0; // proper lifetime , DCA daughter to prim.vtx if (masterConfigurations.doCorrelationK0Short) { // proper lifetime - if (v0.distovertotmom(pvx, pvy, pvz) * o2::constants::physics::MassK0Short < v0Selection.lifetimecutK0S) + if (v0.distovertotmom(pvx, pvy, pvz) * o2::constants::physics::MassK0Short < v0Selection.lifetimecutK0S) { SETBIT(bitMap, 0); + } // DCA daughter to prim.vtx and armenteros float dcaCut = v0Selection.dcaDaugToPVForK0s == 0 ? v0Selection.dcaMesonToPV : v0Selection.dcaDaugToPVForK0s; - if (std::abs(v0.dcapostopv()) > dcaCut && std::abs(v0.dcanegtopv()) > dcaCut && v0.qtarm() * v0Selection.armPodCut > std::abs(v0.alpha())) + if (std::abs(v0.dcapostopv()) > dcaCut && std::abs(v0.dcanegtopv()) > dcaCut && v0.qtarm() * v0Selection.armPodCut > std::abs(v0.alpha())) { SETBIT(bitMap, 3); + } } if (masterConfigurations.doCorrelationLambda) { // proper lifetime - if (v0.distovertotmom(pvx, pvy, pvz) * o2::constants::physics::MassLambda0 < v0Selection.lifetimecutLambda) + if (v0.distovertotmom(pvx, pvy, pvz) * o2::constants::physics::MassLambda0 < v0Selection.lifetimecutLambda) { SETBIT(bitMap, 1); + } // DCA daughter to prim.vtx - if (std::abs(v0.dcapostopv()) > v0Selection.dcaBaryonToPV && std::abs(v0.dcanegtopv()) > v0Selection.dcaMesonToPV) + if (std::abs(v0.dcapostopv()) > v0Selection.dcaBaryonToPV && std::abs(v0.dcanegtopv()) > v0Selection.dcaMesonToPV) { SETBIT(bitMap, 4); + } } if (masterConfigurations.doCorrelationAntiLambda) { // proper lifetime - if (v0.distovertotmom(pvx, pvy, pvz) * o2::constants::physics::MassLambda0 < v0Selection.lifetimecutLambda) + if (v0.distovertotmom(pvx, pvy, pvz) * o2::constants::physics::MassLambda0 < v0Selection.lifetimecutLambda) { SETBIT(bitMap, 2); + } // DCA daughter to prim.vtx - if (std::abs(v0.dcapostopv()) > v0Selection.dcaMesonToPV && std::abs(v0.dcanegtopv()) > v0Selection.dcaBaryonToPV) + if (std::abs(v0.dcapostopv()) > v0Selection.dcaMesonToPV && std::abs(v0.dcanegtopv()) > v0Selection.dcaBaryonToPV) { SETBIT(bitMap, 5); + } } return bitMap; } template - uint64_t cascadeselectionBitmap(TCascade casc, float pvx, float pvy, float pvz) + uint64_t cascadeselectionBitmap(TCascade const& casc, float pvx, float pvy, float pvz) { uint64_t bitMap = 0; float cascpos = std::hypot(casc.x() - pvx, casc.y() - pvy, casc.z() - pvz); @@ -544,64 +559,80 @@ struct HStrangeCorrelation { // TPC PID and DCA daughter to prim.vtx and comopeting casc.rej and life time if (masterConfigurations.doCorrelationXiMinus) { // DCA daughter to prim.vtx - if (isGoodDCANegCasc) + if (isGoodDCANegCasc) { SETBIT(bitMap, 0); + } // comopeting casc.rej - if (std::abs(casc.mOmega() - o2::constants::physics::MassOmegaMinus) > cascadeSelections.rejcomp) + if (std::abs(casc.mOmega() - o2::constants::physics::MassOmegaMinus) > cascadeSelections.rejcomp) { SETBIT(bitMap, 4); - if (ctauXi < cascadeSelections.proplifetime) + } + if (ctauXi < cascadeSelections.proplifetime) { SETBIT(bitMap, 8); + } // y cut - if (std::abs(casc.yXi()) < cascadeSelections.rapCut) + if (std::abs(casc.yXi()) < cascadeSelections.rapCut) { SETBIT(bitMap, 12); + } } if (masterConfigurations.doCorrelationXiPlus) { // DCA daughter to prim.vtx - if (isGoodDCAPosCasc) + if (isGoodDCAPosCasc) { SETBIT(bitMap, 1); + } // comopeting casc.rej - if (std::abs(casc.mOmega() - o2::constants::physics::MassOmegaMinus) > cascadeSelections.rejcomp) + if (std::abs(casc.mOmega() - o2::constants::physics::MassOmegaMinus) > cascadeSelections.rejcomp) { SETBIT(bitMap, 5); + } // life time - if (ctauXi < cascadeSelections.proplifetime) + if (ctauXi < cascadeSelections.proplifetime) { SETBIT(bitMap, 9); + } // y cut - if (std::abs(casc.yXi()) > cascadeSelections.rapCut) + if (std::abs(casc.yXi()) > cascadeSelections.rapCut) { SETBIT(bitMap, 13); + } } if (masterConfigurations.doCorrelationOmegaMinus) { // DCA daughter to prim.vtx - if (isGoodDCANegCasc) + if (isGoodDCANegCasc) { SETBIT(bitMap, 2); + } // comopeting casc.rej - if (std::abs(casc.mXi() - o2::constants::physics::MassXiMinus) > cascadeSelections.rejcomp) + if (std::abs(casc.mXi() - o2::constants::physics::MassXiMinus) > cascadeSelections.rejcomp) { SETBIT(bitMap, 6); + } // life time - if (ctauOmega < cascadeSelections.proplifetime) + if (ctauOmega < cascadeSelections.proplifetime) { SETBIT(bitMap, 10); + } // y cut - if (std::abs(casc.yOmega()) < cascadeSelections.rapCut) + if (std::abs(casc.yOmega()) < cascadeSelections.rapCut) { SETBIT(bitMap, 14); + } } if (masterConfigurations.doCorrelationOmegaPlus) { // DCA daughter to prim.vtx - if (isGoodDCAPosCasc) + if (isGoodDCAPosCasc) { SETBIT(bitMap, 3); + } // comopeting casc.rej - if (std::abs(casc.mXi() - o2::constants::physics::MassXiMinus) > cascadeSelections.rejcomp) + if (std::abs(casc.mXi() - o2::constants::physics::MassXiMinus) > cascadeSelections.rejcomp) { SETBIT(bitMap, 7); + } // life time - if (ctauOmega < cascadeSelections.proplifetime) + if (ctauOmega < cascadeSelections.proplifetime) { SETBIT(bitMap, 11); + } // y cut - if (std::abs(casc.yOmega()) > cascadeSelections.rapCut) + if (std::abs(casc.yOmega()) > cascadeSelections.rapCut) { SETBIT(bitMap, 15); + } } return bitMap; } template - bool isValidTrigger(TTrack track, bool isLeading) + bool isValidTrigger(TTrack const& track, bool isLeading) { if (track.tpcNClsCrossedRows() < trackSelection.minTPCNCrossedRowsTrigger) { return false; // crossed rows @@ -635,10 +666,13 @@ struct HStrangeCorrelation { if (useTheLeadingParticleAsTrigger && !isLeading) { return false; } + if (trackSelection.doITSChi2Selection && track.itsChi2NCl() > trackSelection.chi2ITSfit) { + return false; + } return true; } template - bool isValidAssocHadron(TTrack track) + bool isValidAssocHadron(TTrack const& track) { if (track.tpcNClsCrossedRows() < trackSelection.minTPCNCrossedRowsAssociated) { return false; // crossed rows @@ -663,68 +697,86 @@ struct HStrangeCorrelation { if (track.pt() > axisRanges[2][1] || track.pt() < axisRanges[2][0]) { return false; } + if (trackSelection.doITSChi2Selection && track.itsChi2NCl() > trackSelection.chi2ITSfit) { + return false; + } return true; } // V0selection in PbPb template - bool v0SelectedPbPb(TV0 v0) + bool v0SelectedPbPb(TV0 const& v0) { // v0radius - if (v0.v0radius() < v0Selection.v0RadiusMin) + if (v0.v0radius() < v0Selection.v0RadiusMin) { return false; - if (v0.v0radius() > v0Selection.v0RadiusMax) + } + if (v0.v0radius() > v0Selection.v0RadiusMax) { return false; + } // v0cosPA - if (v0.v0cosPA() < v0Selection.v0cospa) + if (v0.v0cosPA() < v0Selection.v0cospa) { return false; + } // dcaV0daughters - if (v0.dcaV0daughters() > v0Selection.dcaV0dau) + if (v0.dcaV0daughters() > v0Selection.dcaV0dau) { return false; + } return true; } // cascadeselection in PbPb template - bool cascadeSelectedPbPb(TCascade casc, float pvx, float pvy, float pvz) + bool cascadeSelectedPbPb(TCascade const& casc, float pvx, float pvy, float pvz) { // bachBaryonCosPA - if (casc.bachBaryonCosPA() < cascadeSelections.bachBaryonCosPA) + if (casc.bachBaryonCosPA() < cascadeSelections.bachBaryonCosPA) { return false; + } // bachBaryonDCAxyToPV - if (std::abs(casc.bachBaryonDCAxyToPV()) > cascadeSelections.bachBaryonDCAxyToPV) + if (std::abs(casc.bachBaryonDCAxyToPV()) > cascadeSelections.bachBaryonDCAxyToPV) { return false; + } // casccosPA - if (casc.casccosPA(pvx, pvy, pvz) < cascadeSelections.cascCospa) + if (casc.casccosPA(pvx, pvy, pvz) < cascadeSelections.cascCospa) { return false; + } // dcacascdaughters float ptDepCut = cascadeSelections.dcaCacsDauPar0; - if (casc.pt() > cascadeSelections.lowPtForCascDaugPtDep && casc.pt() < cascadeSelections.highPtForCascDaugPtDep) + if (casc.pt() > cascadeSelections.lowPtForCascDaugPtDep && casc.pt() < cascadeSelections.highPtForCascDaugPtDep) { ptDepCut = cascadeSelections.dcaCacsDauPar1; - else if (casc.pt() > cascadeSelections.highPtForCascDaugPtDep) + } else if (casc.pt() > cascadeSelections.highPtForCascDaugPtDep) { ptDepCut = cascadeSelections.dcaCacsDauPar2; - if (casc.dcacascdaughters() > ptDepCut) + } + if (casc.dcacascdaughters() > ptDepCut) { return false; + } // dcaV0daughters - if (casc.dcaV0daughters() > cascadeSelections.cascdcaV0dau) + if (casc.dcaV0daughters() > cascadeSelections.cascdcaV0dau) { return false; + } // dcav0topv - if (std::abs(casc.dcav0topv(pvx, pvy, pvz)) < cascadeSelections.cascdcaV0ToPV) + if (std::abs(casc.dcav0topv(pvx, pvy, pvz)) < cascadeSelections.cascdcaV0ToPV) { return false; + } // cascradius - if (casc.cascradius() < cascadeSelections.cascRadius) + if (casc.cascradius() < cascadeSelections.cascRadius) { return false; + } // v0radius - if (casc.v0radius() < cascadeSelections.cascv0RadiusMin) + if (casc.v0radius() < cascadeSelections.cascv0RadiusMin) { return false; + } // v0cosPA - if (casc.v0cosPA(casc.x(), casc.y(), casc.z()) < cascadeSelections.cascv0cospa) + if (casc.v0cosPA(pvx, pvy, pvz) < cascadeSelections.cascv0cospa) { return false; + } // lambdaMassWin - if (std::abs(casc.mLambda() - o2::constants::physics::MassLambda0) > cascadeSelections.cascV0masswindow) + if (std::abs(casc.mLambda() - o2::constants::physics::MassLambda0) > cascadeSelections.cascV0masswindow) { return false; + } return true; } - double calculateAverageDeltaPhiStar(double* trigg, double* assoc, double B) + double calculateAverageDeltaPhiStar(std::array const& trigg, std::array const& assoc, double B) { double dPhiStar = 0; double dPhiStarMean = 0; @@ -740,7 +792,7 @@ struct HStrangeCorrelation { return dPhiStarMean; } - void fillTriggerHistogram(std::shared_ptr hist, double pt, double mult, float eff, float effUncert, float purity, float purityErr) + void fillTriggerHistogram(std::shared_ptr const& hist, double pt, double mult, float eff, float effUncert, float purity, float purityErr) { int binx = hist->GetXaxis()->FindBin(pt); int biny = hist->GetYaxis()->FindBin(mult); @@ -751,10 +803,10 @@ struct HStrangeCorrelation { hist->SetBinContent(binx, biny, newContent); hist->SetBinError(binx, biny, newUncert); } - void fillCorrelationHistogram(std::shared_ptr hist, double binFillThn[], float etaWeight, float efficiency, float totalEffUncert, float purity, float totalPurityUncert) + void fillCorrelationHistogram(std::shared_ptr const& hist, std::array const& binFillThn, float etaWeight, float efficiency, float totalEffUncert, float purity, float totalPurityUncert) { - float previousContent, previousError2, currentContent, currentError2; - int bin = hist->GetBin(binFillThn); + float previousContent = 0.0f, previousError2 = 0.0f, currentContent = 0.0f, currentError2 = 0.0f; + int bin = hist->GetBin(binFillThn.data()); previousContent = hist->GetBinContent(bin); previousError2 = hist->GetBinError2(bin); currentContent = previousContent + etaWeight * purity / (efficiency); @@ -779,30 +831,37 @@ struct HStrangeCorrelation { } bool firstLoop = false; for (auto const& triggerTrack : triggers) { - if (masterConfigurations.doTriggPhysicalPrimary && !triggerTrack.mcPhysicalPrimary()) + if (masterConfigurations.doTriggPhysicalPrimary && !triggerTrack.mcPhysicalPrimary()) { continue; + } auto trigg = triggerTrack.track_as(); - if (!isValidTrigger(trigg, triggerTrack.isLeading())) + if (!isValidTrigger(trigg, triggerTrack.isLeading())) { + continue; + } + if (trackSelection.checkForITSTPCMissmatchMC && triggerTrack.mcMask() == 13) { continue; + } float efficiencyTrigg = 1.0f; float efficiencyTriggError = 0.0f; float purityTrigg = 1.0f; float purityTriggErr = 0.0; - double bintrig[4] = {trigg.pt(), trigg.eta(), trigg.phi(), mult}; + std::array bintrig = {trigg.pt(), trigg.eta(), trigg.phi(), mult}; if (efficiencyFlags.applyEfficiencyForTrigger) { if (!efficiencyFlags.applyEffAsFunctionOfMultAndPhi) { efficiencyTrigg = hEfficiencyTrigger->Interpolate(trigg.pt(), trigg.eta()); - if (efficiencyFlags.applyPurityTrigger) + if (efficiencyFlags.applyPurityTrigger) { purityTrigg = hPurityHadron->Interpolate(trigg.pt()); + } if (efficiencyFlags.applyEfficiencyPropagation) { efficiencyTriggError = hEfficiencyUncertaintyTrigger->Interpolate(trigg.pt(), trigg.eta()); - if (efficiencyFlags.applyPurityTrigger) + if (efficiencyFlags.applyPurityTrigger) { purityTriggErr = hPurityHadron->Interpolate(trigg.pt()); + } } } else { - efficiencyTrigg = hEfficiencyTriggerMultVsPhi->GetBinContent(hEfficiencyTriggerMultVsPhi->GetBin(bintrig)); + efficiencyTrigg = hEfficiencyTriggerMultVsPhi->GetBinContent(hEfficiencyTriggerMultVsPhi->GetBin(bintrig.data())); if (efficiencyFlags.applyEfficiencyPropagation) { - efficiencyTriggError = hEfficiencyTriggerMultVsPhi->GetBinError(hEfficiencyTriggerMultVsPhi->GetBin(bintrig)); + efficiencyTriggError = hEfficiencyTriggerMultVsPhi->GetBinError(hEfficiencyTriggerMultVsPhi->GetBin(bintrig.data())); } } if (efficiencyTrigg == 0) { // check for zero efficiency, do not apply if the case @@ -816,12 +875,13 @@ struct HStrangeCorrelation { } double triggSign = trigg.sign(); - double triggForDeltaPhiStar[] = {trigg.phi(), trigg.pt(), triggSign}; + std::array triggForDeltaPhiStar = {trigg.phi(), trigg.pt(), triggSign}; if (mixingInBf) { currentCollision.addValidParticle(trigg.eta(), trigg.phi(), trigg.pt(), -1, efficiencyTrigg, efficiencyTriggError, -1); - if (firstLoop) + if (firstLoop) { continue; + } } for (auto const& assocCandidate : assocs) { firstLoop = true; @@ -830,11 +890,13 @@ struct HStrangeCorrelation { //---] syst cuts [--- if ((masterConfigurations.doPPAnalysis && (assoc.v0radius() < v0Selection.v0RadiusMin || assoc.v0radius() > v0Selection.v0RadiusMax || std::abs(assoc.dcapostopv()) < v0Selection.dcapostopv || std::abs(assoc.dcanegtopv()) < v0Selection.dcanegtopv || - assoc.v0cosPA() < v0Selection.v0cospa || assoc.dcaV0daughters() > v0Selection.dcaV0dau))) + assoc.v0cosPA() < v0Selection.v0cospa || assoc.dcaV0daughters() > v0Selection.dcaV0dau))) { continue; + } - if (!masterConfigurations.doPPAnalysis && !v0SelectedPbPb(assoc)) + if (!masterConfigurations.doPPAnalysis && !v0SelectedPbPb(assoc)) { continue; + } uint64_t selMap = v0selectionBitmap(assoc, pvx, pvy, pvz); @@ -853,12 +915,15 @@ struct HStrangeCorrelation { } //---] track quality check [--- - if (postrack.tpcNClsCrossedRows() < trackSelection.minTPCNCrossedRowsAssociated || negtrack.tpcNClsCrossedRows() < trackSelection.minTPCNCrossedRowsAssociated) + if (postrack.tpcNClsCrossedRows() < trackSelection.minTPCNCrossedRowsAssociated || negtrack.tpcNClsCrossedRows() < trackSelection.minTPCNCrossedRowsAssociated) { continue; - if (trackSelection.checksRequireTPCChi2 && (postrack.tpcChi2NCl() < trackSelection.minTPCChi2PerClusterAssociated || negtrack.tpcChi2NCl() < trackSelection.minTPCChi2PerClusterAssociated)) + } + if (trackSelection.checksRequireTPCChi2 && (postrack.tpcChi2NCl() < trackSelection.minTPCChi2PerClusterAssociated || negtrack.tpcChi2NCl() < trackSelection.minTPCChi2PerClusterAssociated)) { continue; - if (trackSelection.requireClusterInITS && (postrack.itsNCls() < trackSelection.minITSClustersForDaughterTracks || negtrack.itsNCls() < trackSelection.minITSClustersForDaughterTracks)) + } + if (trackSelection.requireClusterInITS && (postrack.itsNCls() < trackSelection.minITSClustersForDaughterTracks || negtrack.itsNCls() < trackSelection.minITSClustersForDaughterTracks)) { continue; + } float deltaphi = computeDeltaPhi(trigg.phi(), assoc.phi()); float deltaeta = trigg.eta() - assoc.eta(); @@ -869,16 +934,19 @@ struct HStrangeCorrelation { float pttrigger = trigg.pt(); // skip if basic ranges not met - if (deltaphi < axisRanges[0][0] || deltaphi > axisRanges[0][1]) + if (deltaphi < axisRanges[0][0] || deltaphi > axisRanges[0][1]) { continue; - if (deltaeta < axisRanges[1][0] || deltaeta > axisRanges[1][1]) + } + if (deltaeta < axisRanges[1][0] || deltaeta > axisRanges[1][1]) { continue; - if (ptassoc < axisRanges[2][0] || ptassoc > axisRanges[2][1]) + } + if (ptassoc < axisRanges[2][0] || ptassoc > axisRanges[2][1]) { continue; + } - TH2F* hEfficiencyV0[3]; - TH2F* hEfficiencyUncertaintyV0[3]; - THnF* hEfficiencyV0MultVsPhi[3]; + std::array hEfficiencyV0{nullptr, nullptr, nullptr}; + std::array hEfficiencyUncertaintyV0{nullptr, nullptr, nullptr}; + std::array hEfficiencyV0MultVsPhi{nullptr, nullptr, nullptr}; if (efficiencyFlags.applyEffAsFunctionOfMultAndPhi) { hEfficiencyV0MultVsPhi[0] = hEfficiencyK0ShortMultVsPhi; hEfficiencyV0MultVsPhi[1] = hEfficiencyLambdaMultVsPhi; @@ -906,14 +974,19 @@ struct HStrangeCorrelation { double ptProton = postrack.pt(); double ptPion = negtrack.pt(); double signProton = postrack.sign(); + double signPion = negtrack.sign(); if (assocCandidate.compatible(2, trackSelection.dEdxCompatibility)) { phiProton = negtrack.phi(); etaProton = negtrack.eta(); ptProton = negtrack.pt(); signProton = negtrack.sign(); + phiPion = postrack.phi(); + etaPion = postrack.eta(); + ptPion = postrack.pt(); + signPion = postrack.sign(); } - double assocForDeltaPhiStar[] = {phiProton, ptProton, signProton}; - double assocForDeltaPhiStarPion[] = {phiPion, ptPion, -1}; + std::array assocForDeltaPhiStar = {phiProton, ptProton, signProton}; + std::array assocForDeltaPhiStarPion = {phiPion, ptPion, signPion}; static_for<0, 2>([&](auto i) { constexpr int Index = i.value; @@ -922,14 +995,16 @@ struct HStrangeCorrelation { float efficiencyError = 0.0f; if (efficiencyFlags.applyEfficiencyCorrection) { if (efficiencyFlags.applyEffAsFunctionOfMultAndPhi) { - double bin[4] = {ptassoc, assoc.eta(), assoc.phi(), mult}; - efficiency = hEfficiencyV0MultVsPhi[Index]->GetBinContent(hEfficiencyV0MultVsPhi[Index]->GetBin(bin)); - if (efficiencyFlags.applyEfficiencyPropagation) - efficiencyError = hEfficiencyV0MultVsPhi[Index]->GetBinError(hEfficiencyV0MultVsPhi[Index]->GetBin(bin)); + std::array bin = {ptassoc, assoc.eta(), assoc.phi(), mult}; + efficiency = hEfficiencyV0MultVsPhi[Index]->GetBinContent(hEfficiencyV0MultVsPhi[Index]->GetBin(bin.data())); + if (efficiencyFlags.applyEfficiencyPropagation) { + efficiencyError = hEfficiencyV0MultVsPhi[Index]->GetBinError(hEfficiencyV0MultVsPhi[Index]->GetBin(bin.data())); + } } else { efficiency = hEfficiencyV0[Index]->Interpolate(ptassoc, assoc.eta()); - if (efficiencyFlags.applyEfficiencyPropagation) + if (efficiencyFlags.applyEfficiencyPropagation) { efficiencyError = hEfficiencyUncertaintyV0[Index]->Interpolate(ptassoc, assoc.eta()); + } } } if (efficiency == 0) { // check for zero efficiency, do not apply if the case @@ -940,9 +1015,25 @@ struct HStrangeCorrelation { totalEffUncert = std::sqrt(std::pow(efficiencyTrigg * efficiencyError, 2) + std::pow(efficiencyTriggError * efficiency, 2)); } - double binFillThn[6] = {deltaphi, deltaeta, ptassoc, pttrigger, pvz, mult}; + std::array binFillThnOppositeSignDaugher = {computeDeltaPhi(trigg.phi(), phiPion), trigg.eta() - etaPion, ptPion, pttrigger, pvz, mult}; + std::array binFillThnSameSignDaugher = {computeDeltaPhi(trigg.phi(), phiProton), trigg.eta() - etaProton, ptProton, pttrigger, pvz, mult}; + if ((triggSign < Neutral && !assocCandidate.compatible(2, trackSelection.dEdxCompatibility)) || (triggSign > Neutral && assocCandidate.compatible(2, trackSelection.dEdxCompatibility))) { + std::swap(binFillThnOppositeSignDaugher[1], binFillThnSameSignDaugher[1]); + std::swap(binFillThnOppositeSignDaugher[0], binFillThnSameSignDaugher[0]); + std::swap(binFillThnOppositeSignDaugher[2], binFillThnSameSignDaugher[2]); + } + std::array binFillThn = {deltaphi, deltaeta, ptassoc, pttrigger, pvz, mult}; if (TESTBIT(doCorrelation, Index) && (!efficiencyFlags.applyEfficiencyCorrection || efficiency != 0) && (masterConfigurations.doPPAnalysis || (TESTBIT(selMap, Index) && TESTBIT(selMap, Index + 3)))) { if (assocCandidate.compatible(Index, trackSelection.dEdxCompatibility) && (!masterConfigurations.doMCassociation || assocCandidate.mcTrue(Index)) && (!doAssocPhysicalPrimary || assocCandidate.mcPhysicalPrimary()) && !mixing && -massWindowConfigurations.maxBgNSigma < assocCandidate.invMassNSigma(Index) && assocCandidate.invMassNSigma(Index) < -massWindowConfigurations.minBgNSigma) { + if (std::abs(deltaphi) < 0.5) { + histos.fill(HIST("sameEvent/") + HIST(V0names[Index]) + HIST("/hInvariantMassNearSide"), ptassoc, pttrigger, getV0InvariantMass(assoc)); + } + if (std::abs(PI - deltaphi) < 0.5) { + histos.fill(HIST("sameEvent/") + HIST(V0names[Index]) + HIST("/hInvariantMassAwaySide"), ptassoc, pttrigger, getV0InvariantMass(assoc)); + } + if (deltaphi > 1.0 && deltaphi < 1.5) { + histos.fill(HIST("sameEvent/") + HIST(V0names[Index]) + HIST("/hInvariantMassUE"), ptassoc, pttrigger, getV0InvariantMass(assoc)); + } fillCorrelationHistogram(histos.get(HIST("sameEvent/LeftBg/") + HIST(V0names[Index])), binFillThn, etaWeight, efficiency * efficiencyTrigg, totalEffUncert, purityTrigg, purityTriggErr); if (doDeltaPhiStarCheck) { double deltaPhiStar = calculateAverageDeltaPhiStar(triggForDeltaPhiStar, assocForDeltaPhiStar, bField); @@ -960,7 +1051,11 @@ struct HStrangeCorrelation { } } } - if (assocCandidate.compatible(Index, trackSelection.dEdxCompatibility) && (!masterConfigurations.doMCassociation || assocCandidate.mcTrue(Index)) && (!doAssocPhysicalPrimary || assocCandidate.mcPhysicalPrimary()) && !mixing && -massWindowConfigurations.maxPeakNSigma < assocCandidate.invMassNSigma(Index) && assocCandidate.invMassNSigma(Index) < +massWindowConfigurations.maxPeakNSigma) { + if (assocCandidate.compatible(Index, trackSelection.dEdxCompatibility) && (!masterConfigurations.doMCassociation || assocCandidate.mcTrue(Index)) && (!doAssocPhysicalPrimary || assocCandidate.mcPhysicalPrimary()) && !mixing && ((-massWindowConfigurations.maxPeakNSigma < assocCandidate.invMassNSigma(Index) && assocCandidate.invMassNSigma(Index) < +massWindowConfigurations.maxPeakNSigma))) { + if (masterConfigurations.doCorrelationsHadronV0daughter) { + fillCorrelationHistogram(histos.get(HIST("sameEvent/Signal/") + HIST(V0names[Index]) + HIST("/hSameSign")), binFillThnSameSignDaugher, 1, 1, 1, 1, 1); + fillCorrelationHistogram(histos.get(HIST("sameEvent/Signal/") + HIST(V0names[Index]) + HIST("/hOppositeSign")), binFillThnOppositeSignDaugher, 1, 1, 1, 1, 1); + } fillCorrelationHistogram(histos.get(HIST("sameEvent/Signal/") + HIST(V0names[Index])), binFillThn, etaWeight, efficiency * efficiencyTrigg, totalEffUncert, purityTrigg, purityTriggErr); if (std::abs(deltaphi) < checks.towardDeltaEtaRange && doITSClustersQA) { histos.fill(HIST("hITSClusters") + HIST(V0names[Index]) + HIST("NegativeDaughterToward"), ptassoc, negtrack.itsNCls(), assoc.v0radius()); @@ -1017,6 +1112,10 @@ struct HStrangeCorrelation { } else { fillCorrelationHistogram(histos.get(HIST("mixedEvent/Signal/") + HIST(V0names[Index])), binFillThn, 1, efficiency * efficiencyTrigg, totalEffUncert, purityTrigg, purityTriggErr); } + if (masterConfigurations.doCorrelationsHadronV0daughter) { + fillCorrelationHistogram(histos.get(HIST("mixedEvent/Signal/") + HIST(V0names[Index]) + HIST("/hSameSign")), binFillThnSameSignDaugher, 1, 1, 1, 1, 1); + fillCorrelationHistogram(histos.get(HIST("mixedEvent/Signal/") + HIST(V0names[Index]) + HIST("/hOppositeSign")), binFillThnOppositeSignDaugher, 1, 1, 1, 1, 1); + } } if (assocCandidate.compatible(Index, trackSelection.dEdxCompatibility) && (!masterConfigurations.doMCassociation || assocCandidate.mcTrue(Index)) && (!doAssocPhysicalPrimary || assocCandidate.mcPhysicalPrimary()) && mixing && +massWindowConfigurations.minBgNSigma < assocCandidate.invMassNSigma(Index) && assocCandidate.invMassNSigma(Index) < +massWindowConfigurations.maxBgNSigma) { if (mixingInBf) { @@ -1029,15 +1128,17 @@ struct HStrangeCorrelation { }); } } - if (!mixingInBf || binVtxZ < 0 || binVtxZ > nBinsVtxZ - 1 || binMult < 0 || binMult > nBinsMult - 1) + if (!mixingInBf || binVtxZ < 0 || binVtxZ > nBinsVtxZ - 1 || binMult < 0 || binMult > nBinsMult - 1) { return; + } int binnumb = binMult * nBinsVtxZ + binVtxZ; int hastirgorassoc = masterConfigurations.collisionHasTriggOrAssoc; if ((hastirgorassoc == 1 && currentCollision.trigParticles.empty()) || (hastirgorassoc == 2 && currentCollision.assocParticles.empty()) || (hastirgorassoc == 3 && currentCollision.trigParticles.empty() && currentCollision.assocParticles.empty()) || - (hastirgorassoc == 4 && (currentCollision.trigParticles.empty() || currentCollision.assocParticles.empty()))) + (hastirgorassoc == 4 && (currentCollision.trigParticles.empty() || currentCollision.assocParticles.empty()))) { return; + } for (const auto& collision : validCollisions[binnumb]) { BinningTypePP colBinning{{axesConfigurations.axisVtxZ, axesConfigurations.axisMult}, true}; // When 'collisionHasTriggOrAssoc' = 0: @@ -1063,7 +1164,7 @@ struct HStrangeCorrelation { if (masterConfigurations.doMirroringInDelataEta) { deltaeta = std::abs(deltaeta); } - double binFillThn[6] = {deltaphi, deltaeta, ptassoc, pttrigger, pvz, mult}; + std::array binFillThn = {deltaphi, deltaeta, ptassoc, pttrigger, pvz, mult}; static_for<0, 2>([&](auto i) { constexpr int Index = i.value; if (Index == assoc.type && assoc.region == 0) { @@ -1082,8 +1183,9 @@ struct HStrangeCorrelation { if (validCollisions[binnumb].size() >= static_cast(masterConfigurations.mixingParameter)) { validCollisions[binnumb].erase(validCollisions[binnumb].begin()); } - if (!currentCollision.trigParticles.empty()) + if (!currentCollision.trigParticles.empty()) { validCollisions[binnumb].push_back(currentCollision); + } } void fillCorrelationsCascade(aod::TriggerTracks const& triggers, aod::AssocCascades const& assocs, bool mixing, bool mixingInBf, float pvx, float pvy, float pvz, float mult, double bField) @@ -1103,43 +1205,48 @@ struct HStrangeCorrelation { } bool firstLoop = false; for (auto const& triggerTrack : triggers) { - if (masterConfigurations.doTriggPhysicalPrimary && !triggerTrack.mcPhysicalPrimary()) + if (masterConfigurations.doTriggPhysicalPrimary && !triggerTrack.mcPhysicalPrimary()) { continue; + } auto trigg = triggerTrack.track_as(); - if (!isValidTrigger(trigg, triggerTrack.isLeading())) + if (!isValidTrigger(trigg, triggerTrack.isLeading())) { continue; + } float efficiencyTrigg = 1.0f; float efficiencyTriggError = 0.0f; float purityTrigg = 1.0f; float purityTriggErr = 0.0f; if (efficiencyFlags.applyEfficiencyForTrigger) { - double bintrig[4] = {trigg.pt(), trigg.eta(), trigg.phi(), mult}; + std::array bintrig = {trigg.pt(), trigg.eta(), trigg.phi(), mult}; if (efficiencyFlags.applyEffAsFunctionOfMult) { efficiencyTrigg = hEfficiencyTriggerMult->Interpolate(trigg.pt(), trigg.eta(), mult); } else if (efficiencyFlags.applyEffAsFunctionOfMultAndPhi) { - efficiencyTrigg = hEfficiencyTriggerMultVsPhi->GetBinContent(hEfficiencyTriggerMultVsPhi->GetBin(bintrig)); + efficiencyTrigg = hEfficiencyTriggerMultVsPhi->GetBinContent(hEfficiencyTriggerMultVsPhi->GetBin(bintrig.data())); } else { efficiencyTrigg = hEfficiencyTrigger->Interpolate(trigg.pt(), trigg.eta()); } if (efficiencyFlags.applyPurityTrigger) { - if (efficiencyFlags.applyEffAsFunctionOfMult) + if (efficiencyFlags.applyEffAsFunctionOfMult) { purityTrigg = hPurityHadronMult->Interpolate(trigg.pt(), mult); - else + } else { purityTrigg = hPurityHadron->Interpolate(trigg.pt()); + } } if (efficiencyFlags.applyEfficiencyPropagation) { - if (efficiencyFlags.applyEffAsFunctionOfMult) + if (efficiencyFlags.applyEffAsFunctionOfMult) { efficiencyTriggError = hEfficiencyUncertaintyTriggerMult->Interpolate(trigg.pt(), trigg.eta(), mult); - else if (efficiencyFlags.applyEffAsFunctionOfMultAndPhi) - efficiencyTriggError = hEfficiencyTriggerMultVsPhi->GetBinError(hEfficiencyTriggerMultVsPhi->GetBin(bintrig)); - else + } else if (efficiencyFlags.applyEffAsFunctionOfMultAndPhi) { + efficiencyTriggError = hEfficiencyTriggerMultVsPhi->GetBinError(hEfficiencyTriggerMultVsPhi->GetBin(bintrig.data())); + } else { efficiencyTriggError = hEfficiencyUncertaintyTrigger->Interpolate(trigg.pt(), trigg.eta()); + } if (efficiencyFlags.applyPurityTrigger) { - if (efficiencyFlags.applyEffAsFunctionOfMult) + if (efficiencyFlags.applyEffAsFunctionOfMult) { purityTriggErr = hPurityUncertaintyHadronMult->Interpolate(trigg.pt(), mult); - else + } else { purityTriggErr = hPurityUncertaintyHadron->Interpolate(trigg.pt()); + } } } if (efficiencyTrigg == 0) { // check for zero efficiency, do not apply if the case @@ -1151,12 +1258,13 @@ struct HStrangeCorrelation { fillTriggerHistogram(histos.get(HIST("sameEvent/TriggerParticlesCascade")), trigg.pt(), mult, efficiencyTrigg, efficiencyTriggError, purityTrigg, purityTriggErr); } double triggSign = trigg.sign(); - double triggForDeltaPhiStar[] = {trigg.phi(), trigg.pt(), triggSign}; + std::array triggForDeltaPhiStar = {trigg.phi(), trigg.pt(), triggSign}; if (mixingInBf) { currentCollision.addValidParticle(trigg.eta(), trigg.phi(), trigg.pt(), -1, efficiencyTrigg, efficiencyTriggError, -1); - if (firstLoop) + if (firstLoop) { continue; + } } for (auto const& assocCandidate : assocs) { firstLoop = true; @@ -1172,10 +1280,12 @@ struct HStrangeCorrelation { assoc.casccosPA(pvx, pvy, pvz) < cascadeSelections.cascCospa || assoc.cascradius() < cascadeSelections.cascRadius || std::abs(assoc.dcav0topv(pvx, pvy, pvz)) < cascadeSelections.cascdcaV0ToPV || - std::abs(assoc.mLambda() - o2::constants::physics::MassLambda0) > cascadeSelections.cascV0masswindow)) + std::abs(assoc.mLambda() - o2::constants::physics::MassLambda0) > cascadeSelections.cascV0masswindow)) { continue; - if (!masterConfigurations.doPPAnalysis && !cascadeSelectedPbPb(assoc, pvx, pvy, pvz)) + } + if (!masterConfigurations.doPPAnalysis && !cascadeSelectedPbPb(assoc, pvx, pvy, pvz)) { continue; + } uint64_t cascselMap = cascadeselectionBitmap(assoc, pvx, pvy, pvz); //---] removing autocorrelations [--- auto postrack = assoc.posTrack_as(); @@ -1206,14 +1316,17 @@ struct HStrangeCorrelation { ptProton = negtrack.pt(); signProton = negtrack.sign(); } - double assocForDeltaPhiStar[] = {phiProton, ptProton, signProton}; + std::array assocForDeltaPhiStar = {phiProton, ptProton, signProton}; //---] track quality check [--- - if (postrack.tpcNClsCrossedRows() < trackSelection.minTPCNCrossedRowsAssociated || negtrack.tpcNClsCrossedRows() < trackSelection.minTPCNCrossedRowsAssociated || bachtrack.tpcNClsCrossedRows() < trackSelection.minTPCNCrossedRowsAssociated) + if (postrack.tpcNClsCrossedRows() < trackSelection.minTPCNCrossedRowsAssociated || negtrack.tpcNClsCrossedRows() < trackSelection.minTPCNCrossedRowsAssociated || bachtrack.tpcNClsCrossedRows() < trackSelection.minTPCNCrossedRowsAssociated) { continue; - if (trackSelection.checksRequireTPCChi2 && (postrack.tpcChi2NCl() < trackSelection.minTPCChi2PerClusterAssociated || negtrack.tpcChi2NCl() < trackSelection.minTPCChi2PerClusterAssociated || bachtrack.tpcChi2NCl() < trackSelection.minTPCChi2PerClusterAssociated)) + } + if (trackSelection.checksRequireTPCChi2 && (postrack.tpcChi2NCl() < trackSelection.minTPCChi2PerClusterAssociated || negtrack.tpcChi2NCl() < trackSelection.minTPCChi2PerClusterAssociated || bachtrack.tpcChi2NCl() < trackSelection.minTPCChi2PerClusterAssociated)) { continue; - if (trackSelection.requireClusterInITS && (postrack.itsNCls() < trackSelection.minITSClustersForDaughterTracks || negtrack.itsNCls() < trackSelection.minITSClustersForDaughterTracks || bachtrack.itsNCls() < trackSelection.minITSClustersForDaughterTracks)) + } + if (trackSelection.requireClusterInITS && (postrack.itsNCls() < trackSelection.minITSClustersForDaughterTracks || negtrack.itsNCls() < trackSelection.minITSClustersForDaughterTracks || bachtrack.itsNCls() < trackSelection.minITSClustersForDaughterTracks)) { continue; + } float deltaphi = computeDeltaPhi(trigg.phi(), assoc.phi()); float deltaeta = trigg.eta() - assoc.eta(); @@ -1224,15 +1337,18 @@ struct HStrangeCorrelation { float pttrigger = trigg.pt(); // skip if basic ranges not met - if (deltaphi < axisRanges[0][0] || deltaphi > axisRanges[0][1]) + if (deltaphi < axisRanges[0][0] || deltaphi > axisRanges[0][1]) { continue; - if (deltaeta < axisRanges[1][0] || deltaeta > axisRanges[1][1]) + } + if (deltaeta < axisRanges[1][0] || deltaeta > axisRanges[1][1]) { continue; - if (ptassoc < axisRanges[2][0] || ptassoc > axisRanges[2][1]) + } + if (ptassoc < axisRanges[2][0] || ptassoc > axisRanges[2][1]) { continue; + } - TH2F* hEfficiencyCascade[4]; - THnF* hEfficiencyCascadeMultVsPhi[4]; + std::array hEfficiencyCascade{nullptr, nullptr, nullptr, nullptr}; + std::array hEfficiencyCascadeMultVsPhi{nullptr, nullptr, nullptr, nullptr}; if (efficiencyFlags.applyEffAsFunctionOfMultAndPhi) { hEfficiencyCascadeMultVsPhi[0] = hEfficiencyXiMinusMultVsPhi; hEfficiencyCascadeMultVsPhi[1] = hEfficiencyXiPlusMultVsPhi; @@ -1245,7 +1361,7 @@ struct HStrangeCorrelation { hEfficiencyCascade[3] = hEfficiencyOmegaPlus; } - TH2F* hEfficiencyUncertaintyCascade[4]; + std::array hEfficiencyUncertaintyCascade{nullptr, nullptr, nullptr, nullptr}; hEfficiencyUncertaintyCascade[0] = hEfficiencyUncertaintyXiMinus; hEfficiencyUncertaintyCascade[1] = hEfficiencyUncertaintyXiPlus; hEfficiencyUncertaintyCascade[2] = hEfficiencyUncertaintyOmegaMinus; @@ -1267,14 +1383,16 @@ struct HStrangeCorrelation { float efficiencyError = 0.0f; if (efficiencyFlags.applyEfficiencyCorrection) { if (efficiencyFlags.applyEffAsFunctionOfMultAndPhi) { - double bin[4] = {ptassoc, assoc.eta(), assoc.phi(), mult}; - efficiency = hEfficiencyCascadeMultVsPhi[Index]->GetBinContent(hEfficiencyCascadeMultVsPhi[Index]->GetBin(bin)); - if (efficiencyFlags.applyEfficiencyPropagation) - efficiencyError = hEfficiencyCascadeMultVsPhi[Index]->GetBinError(hEfficiencyCascadeMultVsPhi[Index]->GetBin(bin)); + std::array bin = {ptassoc, assoc.eta(), assoc.phi(), mult}; + efficiency = hEfficiencyCascadeMultVsPhi[Index]->GetBinContent(hEfficiencyCascadeMultVsPhi[Index]->GetBin(bin.data())); + if (efficiencyFlags.applyEfficiencyPropagation) { + efficiencyError = hEfficiencyCascadeMultVsPhi[Index]->GetBinError(hEfficiencyCascadeMultVsPhi[Index]->GetBin(bin.data())); + } } else { efficiency = hEfficiencyCascade[Index]->Interpolate(ptassoc, assoc.eta()); - if (efficiencyFlags.applyEfficiencyPropagation) + if (efficiencyFlags.applyEfficiencyPropagation) { efficiencyError = hEfficiencyUncertaintyCascade[Index]->Interpolate(ptassoc, assoc.eta()); + } } } if (efficiency == 0) { // check for zero efficiency, do not apply if the case @@ -1285,36 +1403,39 @@ struct HStrangeCorrelation { totalEffUncert = std::sqrt(std::pow(efficiencyTrigg * efficiencyError, 2) + std::pow(efficiencyTriggError * efficiency, 2)); } - double binFillThn[6] = {deltaphi, deltaeta, ptassoc, pttrigger, pvz, mult}; + std::array binFillThn = {deltaphi, deltaeta, ptassoc, pttrigger, pvz, mult}; if (TESTBIT(doCorrelation, Index + 3) && (!efficiencyFlags.applyEfficiencyCorrection || efficiency != 0) && (masterConfigurations.doPPAnalysis || (TESTBIT(cascselMap, Index) && TESTBIT(cascselMap, Index + 4) && TESTBIT(cascselMap, Index + 8) && TESTBIT(cascselMap, Index + 12)))) { if (assocCandidate.compatible(Index, trackSelection.dEdxCompatibility) && (!masterConfigurations.doMCassociation || assocCandidate.mcTrue(Index)) && (!doAssocPhysicalPrimary || assocCandidate.mcPhysicalPrimary()) && !mixing && -massWindowConfigurations.maxBgNSigma < assocCandidate.invMassNSigma(Index) && assocCandidate.invMassNSigma(Index) < -massWindowConfigurations.minBgNSigma) { fillCorrelationHistogram(histos.get(HIST("sameEvent/LeftBg/") + HIST(Cascadenames[Index])), binFillThn, etaWeight, efficiency * efficiencyTrigg, totalEffUncert, purityTrigg, purityTriggErr); if (doDeltaPhiStarCheck) { double deltaPhiStar = calculateAverageDeltaPhiStar(triggForDeltaPhiStar, assocForDeltaPhiStar, bField); - if ((Index == IndexXiMinus && triggSign > Neutral) || (Index == IndexXiPlus && triggSign < Neutral) || (Index == IndexOmegaMinus && triggSign > Neutral) || (Index == IndexOmegaPlus && triggSign < 0)) + if ((Index == IndexXiMinus && triggSign > Neutral) || (Index == IndexXiPlus && triggSign < Neutral) || (Index == IndexOmegaMinus && triggSign > Neutral) || (Index == IndexOmegaPlus && triggSign < 0)) { histos.fill(HIST("sameEvent/LeftBg/") + HIST(Cascadenames[Index]) + HIST("DeltaPhiStar"), deltaPhiStar, trigg.eta() - etaProton, 0.5); - else + } else { histos.fill(HIST("sameEvent/LeftBg/") + HIST(Cascadenames[Index]) + HIST("DeltaPhiStar"), deltaPhiStar, trigg.eta() - etaProton, -0.5); + } } } if (assocCandidate.compatible(Index, trackSelection.dEdxCompatibility) && (!masterConfigurations.doMCassociation || assocCandidate.mcTrue(Index)) && (!doAssocPhysicalPrimary || assocCandidate.mcPhysicalPrimary()) && !mixing && -massWindowConfigurations.maxPeakNSigma < assocCandidate.invMassNSigma(Index) && assocCandidate.invMassNSigma(Index) < +massWindowConfigurations.maxPeakNSigma) { fillCorrelationHistogram(histos.get(HIST("sameEvent/Signal/") + HIST(Cascadenames[Index])), binFillThn, etaWeight, efficiency * efficiencyTrigg, totalEffUncert, purityTrigg, purityTriggErr); if (doDeltaPhiStarCheck) { double deltaPhiStar = calculateAverageDeltaPhiStar(triggForDeltaPhiStar, assocForDeltaPhiStar, bField); - if ((Index == IndexXiMinus && triggSign > Neutral) || (Index == IndexXiPlus && triggSign < Neutral) || (Index == IndexOmegaMinus && triggSign > Neutral) || (Index == IndexOmegaPlus && triggSign < 0)) + if ((Index == IndexXiMinus && triggSign > Neutral) || (Index == IndexXiPlus && triggSign < Neutral) || (Index == IndexOmegaMinus && triggSign > Neutral) || (Index == IndexOmegaPlus && triggSign < 0)) { histos.fill(HIST("sameEvent/Signal/") + HIST(Cascadenames[Index]) + HIST("DeltaPhiStar"), deltaPhiStar, trigg.eta() - etaProton, 0.5); - else + } else { histos.fill(HIST("sameEvent/Signal/") + HIST(Cascadenames[Index]) + HIST("DeltaPhiStar"), deltaPhiStar, trigg.eta() - etaProton, -0.5); + } } } if (assocCandidate.compatible(Index, trackSelection.dEdxCompatibility) && (!masterConfigurations.doMCassociation || assocCandidate.mcTrue(Index)) && (!doAssocPhysicalPrimary || assocCandidate.mcPhysicalPrimary()) && !mixing && +massWindowConfigurations.minBgNSigma < assocCandidate.invMassNSigma(Index) && assocCandidate.invMassNSigma(Index) < +massWindowConfigurations.maxBgNSigma) { fillCorrelationHistogram(histos.get(HIST("sameEvent/RightBg/") + HIST(Cascadenames[Index])), binFillThn, etaWeight, efficiency * efficiencyTrigg, totalEffUncert, purityTrigg, purityTriggErr); if (doDeltaPhiStarCheck) { double deltaPhiStar = calculateAverageDeltaPhiStar(triggForDeltaPhiStar, assocForDeltaPhiStar, bField); - if ((Index == IndexXiMinus && triggSign > Neutral) || (Index == IndexXiPlus && triggSign < Neutral) || (Index == IndexOmegaMinus && triggSign > Neutral) || (Index == IndexOmegaPlus && triggSign < 0)) + if ((Index == IndexXiMinus && triggSign > Neutral) || (Index == IndexXiPlus && triggSign < Neutral) || (Index == IndexOmegaMinus && triggSign > Neutral) || (Index == IndexOmegaPlus && triggSign < 0)) { histos.fill(HIST("sameEvent/RightBg/") + HIST(Cascadenames[Index]) + HIST("DeltaPhiStar"), deltaPhiStar, trigg.eta() - etaProton, 0.5); - else + } else { histos.fill(HIST("sameEvent/RightBg/") + HIST(Cascadenames[Index]) + HIST("DeltaPhiStar"), deltaPhiStar, trigg.eta() - etaProton, -0.5); + } } } if (assocCandidate.compatible(Index, trackSelection.dEdxCompatibility) && (!masterConfigurations.doMCassociation || assocCandidate.mcTrue(Index)) && (!doAssocPhysicalPrimary || assocCandidate.mcPhysicalPrimary()) && mixing && -massWindowConfigurations.maxBgNSigma < assocCandidate.invMassNSigma(Index) && assocCandidate.invMassNSigma(Index) < -massWindowConfigurations.minBgNSigma) { @@ -1342,15 +1463,17 @@ struct HStrangeCorrelation { }); } } - if (!mixingInBf || binVtxZ < 0 || binVtxZ > nBinsVtxZ - 1 || binMult < 0 || binMult > nBinsMult - 1) + if (!mixingInBf || binVtxZ < 0 || binVtxZ > nBinsVtxZ - 1 || binMult < 0 || binMult > nBinsMult - 1) { return; + } int binnumb = binMult * nBinsVtxZ + binVtxZ; int hastirgorassoc = masterConfigurations.collisionHasTriggOrAssoc; if ((hastirgorassoc == 1 && currentCollision.trigParticles.empty()) || (hastirgorassoc == 2 && currentCollision.assocParticles.empty()) || (hastirgorassoc == 3 && currentCollision.trigParticles.empty() && currentCollision.assocParticles.empty()) || - (hastirgorassoc == 4 && (currentCollision.trigParticles.empty() || currentCollision.assocParticles.empty()))) + (hastirgorassoc == 4 && (currentCollision.trigParticles.empty() || currentCollision.assocParticles.empty()))) { return; + } for (const auto& collision : validCollisions[binnumb]) { BinningTypePP colBinning{{axesConfigurations.axisVtxZ, axesConfigurations.axisMult}, true}; histos.fill(HIST("MixingQA/hMECollisionBins"), colBinning.getBin({collision.pvz, collision.mult})); @@ -1371,7 +1494,7 @@ struct HStrangeCorrelation { if (masterConfigurations.doMirroringInDelataEta) { deltaeta = std::abs(deltaeta); } - double binFillThn[6] = {deltaphi, deltaeta, ptassoc, pttrigger, pvz, mult}; + std::array binFillThn = {deltaphi, deltaeta, ptassoc, pttrigger, pvz, mult}; static_for<0, 3>([&](auto i) { constexpr int Index = i.value; if (Index == assoc.type && assoc.region == 0) { @@ -1390,45 +1513,52 @@ struct HStrangeCorrelation { if (validCollisions[binnumb].size() >= static_cast(masterConfigurations.mixingParameter)) { validCollisions[binnumb].erase(validCollisions[binnumb].begin()); } - if (!currentCollision.trigParticles.empty()) + if (!currentCollision.trigParticles.empty()) { validCollisions[binnumb].push_back(currentCollision); + } } template void fillCorrelationsHadron(TTriggers const& triggers, THadrons const& assocs, bool mixing, float pvz, float mult, double bField) { for (auto const& triggerTrack : triggers) { - if (masterConfigurations.doTriggPhysicalPrimary && !triggerTrack.mcPhysicalPrimary()) + if (masterConfigurations.doTriggPhysicalPrimary && !triggerTrack.mcPhysicalPrimary()) { continue; + } auto trigg = triggerTrack.template track_as(); - if (!isValidTrigger(trigg, triggerTrack.isLeading())) + if (!isValidTrigger(trigg, triggerTrack.isLeading())) { continue; + } float efficiencyTrigger = 1.0f; float efficiencyTriggerError = 0.0f; float purityTrigger = 1.0f; float purityTriggerError = 0.0f; if (efficiencyFlags.applyEfficiencyForTrigger) { - if (efficiencyFlags.applyEffAsFunctionOfMult) + if (efficiencyFlags.applyEffAsFunctionOfMult) { efficiencyTrigger = hEfficiencyTriggerMult->Interpolate(trigg.pt(), trigg.eta(), mult); - else + } else { efficiencyTrigger = hEfficiencyTrigger->Interpolate(trigg.pt(), trigg.eta()); + } if (efficiencyFlags.applyPurityTrigger) { - if (efficiencyFlags.applyEffAsFunctionOfMult) + if (efficiencyFlags.applyEffAsFunctionOfMult) { purityTrigger = hPurityHadronMult->Interpolate(trigg.pt(), mult); - else + } else { purityTrigger = hPurityHadron->Interpolate(trigg.pt()); + } } if (efficiencyFlags.applyEfficiencyPropagation) { - if (efficiencyFlags.applyEffAsFunctionOfMult) + if (efficiencyFlags.applyEffAsFunctionOfMult) { efficiencyTriggerError = hEfficiencyUncertaintyTriggerMult->Interpolate(trigg.pt(), trigg.eta(), mult); - else + } else { efficiencyTriggerError = hEfficiencyUncertaintyTrigger->Interpolate(trigg.pt(), trigg.eta()); + } if (efficiencyFlags.applyPurityTrigger) { - if (efficiencyFlags.applyEffAsFunctionOfMult) + if (efficiencyFlags.applyEffAsFunctionOfMult) { purityTriggerError = hPurityUncertaintyHadronMult->Interpolate(trigg.pt(), mult); - else + } else { purityTriggerError = hPurityUncertaintyHadron->Interpolate(trigg.pt()); + } } } if (efficiencyTrigger == 0) { // check for zero efficiency, do not apply if the case @@ -1437,29 +1567,32 @@ struct HStrangeCorrelation { } } if (!mixing) { - if constexpr (requires { triggerTrack.extra(); }) + if constexpr (requires { triggerTrack.extra(); }) { fillTriggerHistogram(histos.get(HIST("sameEvent/TriggerParticlesPion")), trigg.pt(), mult, efficiencyTrigger, efficiencyTriggerError, purityTrigger, purityTriggerError); - else + } else { fillTriggerHistogram(histos.get(HIST("sameEvent/TriggerParticlesHadron")), trigg.pt(), mult, efficiencyTrigger, efficiencyTriggerError, purityTrigger, purityTriggerError); + } } double triggSign = trigg.sign(); - double triggForDeltaPhiStar[] = {trigg.phi(), trigg.pt(), triggSign}; + std::array triggForDeltaPhiStar = {trigg.phi(), trigg.pt(), triggSign}; for (auto const& assocTrack : assocs) { auto assoc = assocTrack.template track_as(); //---] removing autocorrelations [--- if (doAutocorrelationRejection) { if (trigg.globalIndex() == assoc.globalIndex()) { - if constexpr (requires { assocTrack.nSigmaTPCPi(); }) + if constexpr (requires { assocTrack.nSigmaTPCPi(); }) { histos.fill(HIST("hNumberOfRejectedPairsPion"), 0.5); - else + } else { histos.fill(HIST("hNumberOfRejectedPairsHadron"), 0.5); + } continue; } } //---] track quality check [--- - if (!isValidAssocHadron(assoc)) + if (!isValidAssocHadron(assoc)) { continue; + } if (doAssocPhysicalPrimary && !assocTrack.mcPhysicalPrimary()) { continue; } @@ -1472,7 +1605,7 @@ struct HStrangeCorrelation { float pttrigger = trigg.pt(); double assocSign = assoc.sign(); - double assocForDeltaPhiStar[] = {assoc.phi(), assoc.pt(), assocSign}; + std::array assocForDeltaPhiStar = {assoc.phi(), assoc.pt(), assocSign}; float etaWeight = 1.; if (checks.doOnTheFlyFlattening) { @@ -1481,12 +1614,15 @@ struct HStrangeCorrelation { } // skip if basic ranges not met - if (deltaphi < axisRanges[0][0] || deltaphi > axisRanges[0][1]) + if (deltaphi < axisRanges[0][0] || deltaphi > axisRanges[0][1]) { continue; - if (deltaeta < axisRanges[1][0] || deltaeta > axisRanges[1][1]) + } + if (deltaeta < axisRanges[1][0] || deltaeta > axisRanges[1][1]) { continue; - if (ptassoc < axisRanges[2][0] || ptassoc > axisRanges[2][1]) + } + if (ptassoc < axisRanges[2][0] || ptassoc > axisRanges[2][1]) { continue; + } float efficiency = 1; float purity = 1.0f; @@ -1497,29 +1633,34 @@ struct HStrangeCorrelation { if (efficiencyFlags.applyEfficiencyCorrection) { if constexpr (requires { assocTrack.nSigmaTPCPi(); }) { efficiency = hEfficiencyPion->Interpolate(ptassoc, assoc.eta()); - if (efficiencyFlags.applyEfficiencyPropagation) + if (efficiencyFlags.applyEfficiencyPropagation) { efficiencyUncertainty = hEfficiencyUncertaintyPion->Interpolate(ptassoc, assoc.eta()); + } } else { - if (efficiencyFlags.applyEffAsFunctionOfMult) + if (efficiencyFlags.applyEffAsFunctionOfMult) { efficiency = hEfficiencyHadronMult->Interpolate(ptassoc, assoc.eta(), mult); - else + } else { efficiency = hEfficiencyHadron->Interpolate(ptassoc, assoc.eta()); + } if (efficiencyFlags.applyPurityHadron) { - if (efficiencyFlags.applyEffAsFunctionOfMult) + if (efficiencyFlags.applyEffAsFunctionOfMult) { purity = hPurityHadronMult->Interpolate(ptassoc, mult); - else + } else { purity = hPurityHadron->Interpolate(ptassoc); + } } if (efficiencyFlags.applyEfficiencyPropagation) { - if (efficiencyFlags.applyEffAsFunctionOfMult) + if (efficiencyFlags.applyEffAsFunctionOfMult) { efficiencyUncertainty = hEfficiencyUncertaintyHadronMult->Interpolate(ptassoc, assoc.eta(), mult); - else + } else { efficiencyUncertainty = hEfficiencyUncertaintyHadron->Interpolate(ptassoc, assoc.eta()); + } if (efficiencyFlags.applyPurityHadron) { - if (efficiencyFlags.applyEffAsFunctionOfMult) + if (efficiencyFlags.applyEffAsFunctionOfMult) { purityUncertainty = hPurityUncertaintyHadronMult->Interpolate(ptassoc, mult); - else + } else { purityUncertainty = hPurityUncertaintyHadron->Interpolate(ptassoc); + } } } } @@ -1533,7 +1674,7 @@ struct HStrangeCorrelation { totalPurityUncert = std::sqrt(std::pow(purityTrigger * purityUncertainty, 2) + std::pow(purity * purityTriggerError, 2)); } - double binFillThn[6] = {deltaphi, deltaeta, ptassoc, pttrigger, pvz, mult}; + std::array binFillThn = {deltaphi, deltaeta, ptassoc, pttrigger, pvz, mult}; double deltaPhiStar = calculateAverageDeltaPhiStar(triggForDeltaPhiStar, assocForDeltaPhiStar, bField); if (!mixing) { if constexpr (requires { assocTrack.nSigmaTPCPi(); }) { @@ -1567,49 +1708,58 @@ struct HStrangeCorrelation { zorroSummary.setObject(zorro.getZorroSummary()); mRunNumber = 0; mRunNumberZorro = 0; - hEfficiencyPion = 0x0; - hEfficiencyK0Short = 0x0; - hEfficiencyLambda = 0x0; - hEfficiencyAntiLambda = 0x0; - hEfficiencyXiMinus = 0x0; - hEfficiencyXiPlus = 0x0; - hEfficiencyOmegaMinus = 0x0; - hEfficiencyOmegaPlus = 0x0; - hEfficiencyUncertaintyTrigger = 0x0; - hEfficiencyUncertaintyXiMinus = 0x0; - hEfficiencyUncertaintyXiPlus = 0x0; - hEfficiencyUncertaintyOmegaMinus = 0x0; - hEfficiencyUncertaintyOmegaPlus = 0x0; - hEfficiencyUncertaintyPion = 0x0; - hEfficiencyUncertaintyK0Short = 0x0; - hEfficiencyUncertaintyLambda = 0x0; - hEfficiencyUncertaintyAntiLambda = 0x0; - - hEfficiencyHadron = 0x0; - hPurityHadron = 0x0; - hPurityUncertaintyHadron = 0x0; - hEfficiencyUncertaintyHadron = 0x0; + hEfficiencyPion = nullptr; + hEfficiencyK0Short = nullptr; + hEfficiencyLambda = nullptr; + hEfficiencyAntiLambda = nullptr; + hEfficiencyXiMinus = nullptr; + hEfficiencyXiPlus = nullptr; + hEfficiencyOmegaMinus = nullptr; + hEfficiencyOmegaPlus = nullptr; + hEfficiencyUncertaintyTrigger = nullptr; + hEfficiencyUncertaintyXiMinus = nullptr; + hEfficiencyUncertaintyXiPlus = nullptr; + hEfficiencyUncertaintyOmegaMinus = nullptr; + hEfficiencyUncertaintyOmegaPlus = nullptr; + hEfficiencyUncertaintyPion = nullptr; + hEfficiencyUncertaintyK0Short = nullptr; + hEfficiencyUncertaintyLambda = nullptr; + hEfficiencyUncertaintyAntiLambda = nullptr; + + hEfficiencyHadron = nullptr; + hPurityHadron = nullptr; + hPurityUncertaintyHadron = nullptr; + hEfficiencyUncertaintyHadron = nullptr; // set bitmap for convenience doCorrelation = 0; - if (masterConfigurations.doCorrelationK0Short) + if (masterConfigurations.doCorrelationK0Short) { SETBIT(doCorrelation, 0); - if (masterConfigurations.doCorrelationLambda) + } + if (masterConfigurations.doCorrelationLambda) { SETBIT(doCorrelation, 1); - if (masterConfigurations.doCorrelationAntiLambda) + } + if (masterConfigurations.doCorrelationAntiLambda) { SETBIT(doCorrelation, 2); - if (masterConfigurations.doCorrelationXiMinus) + } + if (masterConfigurations.doCorrelationXiMinus) { SETBIT(doCorrelation, 3); - if (masterConfigurations.doCorrelationXiPlus) + } + if (masterConfigurations.doCorrelationXiPlus) { SETBIT(doCorrelation, 4); - if (masterConfigurations.doCorrelationOmegaMinus) + } + if (masterConfigurations.doCorrelationOmegaMinus) { SETBIT(doCorrelation, 5); - if (masterConfigurations.doCorrelationOmegaPlus) + } + if (masterConfigurations.doCorrelationOmegaPlus) { SETBIT(doCorrelation, 6); - if (masterConfigurations.doCorrelationPion) + } + if (masterConfigurations.doCorrelationPion) { SETBIT(doCorrelation, 7); - if (masterConfigurations.doCorrelationHadron) + } + if (masterConfigurations.doCorrelationHadron) { SETBIT(doCorrelation, 8); + } // Store axis ranges to prevent spurious filling // axis status: @@ -1685,86 +1835,100 @@ struct HStrangeCorrelation { // ===] delta-phi [=== if (!preAxisDeltaPhi.nBins.has_value()) { // variable binning, use bins provided - for (int i = offset; i < static_cast(edgesDeltaPhiOrig.size()) - offset; i++) + for (int i = offset; i < static_cast(edgesDeltaPhiOrig.size()) - offset; i++) { edgesDeltaPhi.emplace_back(edgesDeltaPhiOrig[i]); + } } else { // fixed binning, generate the bin edges on-the-spot double min = edgesDeltaPhiOrig[0]; double delta = (edgesDeltaPhiOrig[1] - edgesDeltaPhiOrig[0]) / preAxisDeltaPhi.nBins.value(); - for (int i = offset; i < preAxisDeltaPhi.nBins.value() + 1 - offset; i++) + for (int i = offset; i < preAxisDeltaPhi.nBins.value() + 1 - offset; i++) { edgesDeltaPhi.emplace_back(min + static_cast(i) * delta); + } } // ===] delta-eta [=== if (!preAxisDeltaEta.nBins.has_value()) { // variable binning, use bins provided - for (int i = offset; i < static_cast(edgesDeltaEtaOrig.size()) - offset; i++) + for (int i = offset; i < static_cast(edgesDeltaEtaOrig.size()) - offset; i++) { edgesDeltaEta.emplace_back(edgesDeltaEtaOrig[i]); + } } else { // fixed binning, generate the bin edges on-the-spot double min = edgesDeltaEtaOrig[0]; double delta = (edgesDeltaEtaOrig[1] - edgesDeltaEtaOrig[0]) / preAxisDeltaEta.nBins.value(); - for (int i = offset; i < preAxisDeltaEta.nBins.value() + 1 - offset; i++) + for (int i = offset; i < preAxisDeltaEta.nBins.value() + 1 - offset; i++) { edgesDeltaEta.emplace_back(min + static_cast(i) * delta); + } } // ===] pt assoc [=== if (!preAxisPtAssoc.nBins.has_value()) { // variable binning, use bins provided - for (int i = offset; i < static_cast(edgesPtAssocOrig.size()) - offset; i++) + for (int i = offset; i < static_cast(edgesPtAssocOrig.size()) - offset; i++) { edgesPtAssoc.emplace_back(edgesPtAssocOrig[i]); + } } else { // fixed binning, generate the bin edges on-the-spot double min = edgesPtAssocOrig[0]; double delta = (edgesPtAssocOrig[1] - edgesPtAssocOrig[0]) / preAxisPtAssoc.nBins.value(); - for (int i = offset; i < preAxisPtAssoc.nBins.value() + 1 - offset; i++) + for (int i = offset; i < preAxisPtAssoc.nBins.value() + 1 - offset; i++) { edgesPtAssoc.emplace_back(min + static_cast(i) * delta); + } } // ===] pt trigger [=== if (!preAxisPtTrigger.nBins.has_value()) { // variable binning, use bins provided - for (int i = offset; i < static_cast(edgesPtTriggerOrig.size()) - offset; i++) + for (int i = offset; i < static_cast(edgesPtTriggerOrig.size()) - offset; i++) { edgesPtTrigger.emplace_back(edgesPtTriggerOrig[i]); + } } else { // fixed binning, generate the bin edges on-the-spot double min = edgesPtTriggerOrig[0]; double delta = (edgesPtTriggerOrig[1] - edgesPtTriggerOrig[0]) / preAxisPtTrigger.nBins.value(); - for (int i = offset; i < preAxisPtTrigger.nBins.value() + 1 - offset; i++) + for (int i = offset; i < preAxisPtTrigger.nBins.value() + 1 - offset; i++) { edgesPtTrigger.emplace_back(min + static_cast(i) * delta); + } } // ===] vtx Z [=== if (!preAxisVtxZ.nBins.has_value()) { // variable binning, use bins provided - for (int i = offset; i < static_cast(edgesVtxZOrig.size()) - offset; i++) + for (int i = offset; i < static_cast(edgesVtxZOrig.size()) - offset; i++) { edgesVtxZ.emplace_back(edgesVtxZOrig[i]); + } } else { // fixed binning, generate the bin edges on-the-spot double min = edgesVtxZOrig[0]; double delta = (edgesVtxZOrig[1] - edgesVtxZOrig[0]) / preAxisVtxZ.nBins.value(); - for (int i = offset; i < preAxisVtxZ.nBins.value() + 1 - offset; i++) + for (int i = offset; i < preAxisVtxZ.nBins.value() + 1 - offset; i++) { edgesVtxZ.emplace_back(min + static_cast(i) * delta); + } } // ===] mult percentile [=== if (!preAxisMult.nBins.has_value()) { // variable binning, use bins provided - for (int i = offset; i < static_cast(edgesMultOrig.size()) - offset; i++) + for (int i = offset; i < static_cast(edgesMultOrig.size()) - offset; i++) { edgesMult.emplace_back(edgesMultOrig[i]); + } } else { // fixed binning, generate the bin edges on-the-spot double min = edgesMultOrig[0]; double delta = (edgesMultOrig[1] - edgesMultOrig[0]) / preAxisMult.nBins.value(); - for (int i = offset; i < preAxisMult.nBins.value() + 1 - offset; i++) + for (int i = offset; i < preAxisMult.nBins.value() + 1 - offset; i++) { edgesMult.emplace_back(min + static_cast(i) * delta); + } } // ===] multiplicity count [=== if (!preAxisMultiplicity.nBins.has_value()) { // variable binning, use bins provided - for (int i = offset; i < static_cast(edgesMultiplicityOrig.size()) - offset; i++) + for (int i = offset; i < static_cast(edgesMultiplicityOrig.size()) - offset; i++) { edgesMultiplicity.emplace_back(edgesMultiplicityOrig[i]); + } } else { // fixed binning, generate the bin edges on-the-spot double min = edgesMultiplicityOrig[0]; double delta = (edgesMultiplicityOrig[1] - edgesMultiplicityOrig[0]) / preAxisMultiplicity.nBins.value(); - for (int i = offset; i < preAxisMultiplicity.nBins.value() + 1 - offset; i++) + for (int i = offset; i < preAxisMultiplicity.nBins.value() + 1 - offset; i++) { edgesMultiplicity.emplace_back(min + static_cast(i) * delta); + } } LOGF(info, "Initialized THnF axis delta-phi with %i bins.", edgesDeltaPhi.size() - 1); @@ -1792,9 +1956,9 @@ struct HStrangeCorrelation { if (!masterConfigurations.doPPAnalysis) { // event selections in Pb-Pb histos.add("hEventSelection", "hEventSelection", kTH1F, {{10, 0, 10}}); - TString eventSelLabel[] = {"all", "sel8", "kIsTriggerTVX", "PV_{z}", "kIsGoodITSLayersAll", "kIsGoodZvtxFT0vsPV", "OccupCut", "kNoTimeFrameBorder", "kNoITSROFrameBorder", "kNoSameBunchPileup "}; + std::array eventSelLabel = {"all", "sel8", "kIsTriggerTVX", "PV_{z}", "kIsGoodITSLayersAll", "kIsGoodZvtxFT0vsPV", "OccupCut", "kNoTimeFrameBorder", "kNoITSROFrameBorder", "kNoSameBunchPileup "}; for (int i = 1; i <= histos.get(HIST("hEventSelection"))->GetNbinsX(); i++) { - histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(i, eventSelLabel[i - 1]); + histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(i, eventSelLabel[i - 1].Data()); } } // Some QA plots @@ -1857,8 +2021,9 @@ struct HStrangeCorrelation { bool hStrange = false; for (int i = 0; i < AssocParticleTypes; i++) { if (TESTBIT(doCorrelation, i)) { - if (masterConfigurations.doFullCorrelationStudy) + if (masterConfigurations.doFullCorrelationStudy) { histos.add(fmt::format("sameEvent/Signal/{}", Particlenames[i]).c_str(), "", kTHnF, {axisDeltaPhiNDim, axisDeltaEtaNDim, axisPtAssocNDim, axisPtTriggerNDim, axisVtxZNDim, axisMultNDim}); + } if (doDeltaPhiStarCheck && masterConfigurations.doFullCorrelationStudy) { histos.add(fmt::format("sameEvent/Signal/{}DeltaPhiStar", Particlenames[i]).c_str(), "", kTH3F, {{100, -0.3, 0.3}, {50, -0.05, 0.05}, {2, -1, 1}}); // -1 oposite charge, 1 same charge } @@ -1899,6 +2064,34 @@ struct HStrangeCorrelation { histos.addClone("sameEvent/Signal/", "sameEvent/LeftBg/"); histos.addClone("sameEvent/Signal/", "sameEvent/RightBg/"); } + + if (masterConfigurations.doFullCorrelationStudy && doprocessSameEventHV0s) { + if (TESTBIT(doCorrelation, 0)) { + histos.add("sameEvent/K0Short/hInvariantMassNearSide", "", kTH3F, {axesConfigurations.axisPtAssoc, axesConfigurations.axisPtTrigger, axesConfigurations.axisK0ShortMass}); + histos.add("sameEvent/K0Short/hInvariantMassAwaySide", "", kTH3F, {axesConfigurations.axisPtAssoc, axesConfigurations.axisPtTrigger, axesConfigurations.axisK0ShortMass}); + histos.add("sameEvent/K0Short/hInvariantMassUE", "", kTH3F, {axesConfigurations.axisPtAssoc, axesConfigurations.axisPtTrigger, axesConfigurations.axisK0ShortMass}); + if (masterConfigurations.doCorrelationsHadronV0daughter) { + histos.add("sameEvent/Signal/K0Short/hSameSign", "", kTHnF, {axisDeltaPhiNDim, axisDeltaEtaNDim, axisPtAssocNDim, axisPtTriggerNDim, axisVtxZNDim, axisMultNDim}); + histos.add("sameEvent/Signal/K0Short/hOppositeSign", "", kTHnF, {axisDeltaPhiNDim, axisDeltaEtaNDim, axisPtAssocNDim, axisPtTriggerNDim, axisVtxZNDim, axisMultNDim}); + } + } + if (TESTBIT(doCorrelation, 1)) { + histos.add("sameEvent/Lambda/hInvariantMassNearSide", "", kTH3F, {axesConfigurations.axisPtAssoc, axesConfigurations.axisPtTrigger, axesConfigurations.axisLambdaMass}); + histos.add("sameEvent/Lambda/hInvariantMassAwaySide", "", kTH3F, {axesConfigurations.axisPtAssoc, axesConfigurations.axisPtTrigger, axesConfigurations.axisLambdaMass}); + histos.add("sameEvent/Lambda/hInvariantMassUE", "", kTH3F, {axesConfigurations.axisPtAssoc, axesConfigurations.axisPtTrigger, axesConfigurations.axisLambdaMass}); + if (masterConfigurations.doCorrelationsHadronV0daughter) { + histos.add("sameEvent/Signal/Lambda/hSameSign", "", kTHnF, {axisDeltaPhiNDim, axisDeltaEtaNDim, axisPtAssocNDim, axisPtTriggerNDim, axisVtxZNDim, axisMultNDim}); + histos.add("sameEvent/Signal/Lambda/hOppositeSign", "", kTHnF, {axisDeltaPhiNDim, axisDeltaEtaNDim, axisPtAssocNDim, axisPtTriggerNDim, axisVtxZNDim, axisMultNDim}); + } + } + if (TESTBIT(doCorrelation, 2)) { + histos.addClone("sameEvent/Lambda/", "sameEvent/AntiLambda/"); + if (masterConfigurations.doCorrelationsHadronV0daughter) { + histos.add("sameEvent/Signal/AntiLambda/hSameSign", "", kTHnF, {axisDeltaPhiNDim, axisDeltaEtaNDim, axisPtAssocNDim, axisPtTriggerNDim, axisVtxZNDim, axisMultNDim}); + histos.add("sameEvent/Signal/AntiLambda/hOppositeSign", "", kTHnF, {axisDeltaPhiNDim, axisDeltaEtaNDim, axisPtAssocNDim, axisPtTriggerNDim, axisVtxZNDim, axisMultNDim}); + } + } + } if (TESTBIT(doCorrelation, 0) && doprocessSameEventHV0s && masterConfigurations.doMassSpectrumCheck) { histos.add("hK0ShortPtVsMass", "", kTH2F, {axesConfigurations.axisPtQA, axesConfigurations.axisK0ShortMass}); } @@ -1913,14 +2106,18 @@ struct HStrangeCorrelation { if ((doprocessMixedEventHV0sInBuffer || doprocessMixedEventHCascadesInBuffer || doprocessMixedEventHV0s || doprocessMixedEventHCascades || doprocessMixedEventHPions || doprocessMixedEventHHadrons) && masterConfigurations.doFullCorrelationStudy) { histos.addClone("sameEvent/", "mixedEvent/"); } - if (doprocessSameEventHHadrons && masterConfigurations.doFullCorrelationStudy) + if (doprocessSameEventHHadrons && masterConfigurations.doFullCorrelationStudy) { histos.add("sameEvent/TriggerParticlesHadron", "TriggersHadron", kTH2F, {axesConfigurations.axisPtQA, axesConfigurations.axisMult}); - if (doprocessSameEventHV0s && masterConfigurations.doFullCorrelationStudy) + } + if (doprocessSameEventHV0s && masterConfigurations.doFullCorrelationStudy) { histos.add("sameEvent/TriggerParticlesV0", "TriggersV0", kTH2F, {axesConfigurations.axisPtQA, axesConfigurations.axisMult}); - if (doprocessSameEventHCascades && masterConfigurations.doFullCorrelationStudy) + } + if (doprocessSameEventHCascades && masterConfigurations.doFullCorrelationStudy) { histos.add("sameEvent/TriggerParticlesCascade", "TriggersCascade", kTH2F, {axesConfigurations.axisPtQA, axesConfigurations.axisMult}); - if (doprocessSameEventHPions && masterConfigurations.doFullCorrelationStudy) + } + if (doprocessSameEventHPions && masterConfigurations.doFullCorrelationStudy) { histos.add("sameEvent/TriggerParticlesPion", "TriggersPion", kTH2F, {axesConfigurations.axisPtQA, axesConfigurations.axisMult}); + } // MC generated plots if (doprocessMCGenerated) { @@ -1952,10 +2149,16 @@ struct HStrangeCorrelation { } if (doprocessClosureTest) { for (int i = 0; i < AssocParticleTypes; i++) { - if (TESTBIT(doCorrelation, i)) + if (TESTBIT(doCorrelation, i)) { histos.add(fmt::format("ClosureTest/sameEvent/{}", Particlenames[i]).c_str(), "", kTHnF, {axisDeltaPhiNDim, axisDeltaEtaNDim, axisPtAssocNDim, axisPtTriggerNDim, axisVtxZNDim, axisMultNDim}); - if (TESTBIT(doCorrelation, i)) + if (masterConfigurations.doCorrelationsHadronV0daughter) { + histos.add(fmt::format("ClosureTest/sameEvent/{}_SameSignDaughter", Particlenames[i]).c_str(), "", kTHnF, {axisDeltaPhiNDim, axisDeltaEtaNDim, axisPtAssocNDim, axisPtTriggerNDim, axisVtxZNDim, axisMultNDim}); + histos.add(fmt::format("ClosureTest/sameEvent/{}_OppSignDaughter", Particlenames[i]).c_str(), "", kTHnF, {axisDeltaPhiNDim, axisDeltaEtaNDim, axisPtAssocNDim, axisPtTriggerNDim, axisVtxZNDim, axisMultNDim}); + } + } + if (TESTBIT(doCorrelation, i)) { histos.add(fmt::format("ClosureTest/h{}", Particlenames[i]).c_str(), "", kTH3F, {axesConfigurations.axisPtQA, axesConfigurations.axisEta, axesConfigurations.axisPhi}); + } } histos.add("ClosureTest/hTrigger", "Trigger Tracks", kTH3F, {axesConfigurations.axisPtQA, axesConfigurations.axisEta, axesConfigurations.axisMult}); } @@ -1979,7 +2182,7 @@ struct HStrangeCorrelation { mCounter.mPdgDatabase = pdgDB.service; mCounter.mSelectPrimaries = doAssocPhysicalPrimary.value; histos.add("Prediction/hEventSelection", "hEventSelection", kTH1F, {{3, 0, 3}}); - TString eventSelLabel[] = {"Read", "INELgt0", "|Z|<10"}; + std::array eventSelLabel = {"Read", "INELgt0", "|Z|<10"}; for (int i = 1; i <= histos.get(HIST("Prediction/hEventSelection"))->GetNbinsX(); i++) { histos.get(HIST("Prediction/hEventSelection"))->GetXaxis()->SetBinLabel(i, eventSelLabel[i - 1]); } @@ -2003,14 +2206,17 @@ struct HStrangeCorrelation { histos.add("Prediction/hFT0MvsNchEta05", "Nch in 0.5 vs FT0M multiplicity", kTH2F, {axesConfigurations.axisMultiplicity, axesConfigurations.axisMidrapidityMultiplicity}); } for (int i = 0; i < AssocParticleTypes; i++) { - if (TESTBIT(doCorrelation, i)) + if (TESTBIT(doCorrelation, i)) { histos.add(fmt::format("Prediction/h{}", Particlenames[i]).c_str(), "", kTH3F, {axesConfigurations.axisPtQA, axesConfigurations.axisEta, axesConfigurations.axisPhi}); + } if (masterConfigurations.useCentralityinPrediction) { - if (TESTBIT(doCorrelation, i)) + if (TESTBIT(doCorrelation, i)) { histos.add(fmt::format("Prediction/sameEvent/{}", Particlenames[i]).c_str(), "", kTHnF, {axisDeltaPhiNDim, axisDeltaEtaNDim, axisPtAssocNDim, axisPtTriggerNDim, axisVtxZNDim, axisMultNDim}); + } } else { - if (TESTBIT(doCorrelation, i)) + if (TESTBIT(doCorrelation, i)) { histos.add(fmt::format("Prediction/sameEvent/{}", Particlenames[i]).c_str(), "", kTHnF, {axisDeltaPhiNDim, axisDeltaEtaNDim, axisPtAssocNDim, axisPtTriggerNDim, axisVtxZNDim, axisMultiplicityNDim}); + } } } if (masterConfigurations.doSeparateFT0Prediction) { @@ -2065,50 +2271,58 @@ struct HStrangeCorrelation { // event selections in Pb-Pb template - bool isCollisionSelectedPbPb(TCollision collision, bool fillHists) + bool isCollisionSelectedPbPb(TCollision const& collision, bool fillHists) { - if (fillHists) + if (fillHists) { histos.fill(HIST("hEventSelection"), 0.5 /* all collisions */); + } // Perform basic event selection if (!collision.sel8()) { return false; } - if (fillHists) + if (fillHists) { histos.fill(HIST("hEventSelection"), 1.5 /* collisions after sel8*/); + } if (!collision.selection_bit(aod::evsel::kIsTriggerTVX) && masterConfigurations.requireGoodTriggerTVX) { return false; } - if (fillHists) + if (fillHists) { histos.fill(HIST("hEventSelection"), 2.5 /* FT0 vertex (acceptable FT0C-FT0A time difference) collisions */); + } if (std::abs(collision.posZ()) > masterConfigurations.zVertexCut) { return false; } - if (fillHists) + if (fillHists) { histos.fill(HIST("hEventSelection"), 3.5 /* collisions after sel pvz sel*/); + } if (!collision.selection_bit(aod::evsel::kIsGoodITSLayersAll) && masterConfigurations.requireAllGoodITSLayers) { // cut time intervals with dead ITS staves return false; } - if (fillHists) + if (fillHists) { histos.fill(HIST("hEventSelection"), 4.5 /* collisions after cut time intervals with dead ITS staves*/); + } if (!collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV) && masterConfigurations.requireGoodZvtxFT0vsPV) { // removes collisions with large differences between z of PV by tracks and z of PV from FT0 A-C time difference // use this cut at low multiplicities with caution return false; } - if (fillHists) + if (fillHists) { histos.fill(HIST("hEventSelection"), 5.5 /* removes collisions with large differences between z of PV by tracks and z of PV from FT0 A-C time difference*/); + } auto occupancy = collision.trackOccupancyInTimeRange(); - if (occupancy < cfgCutOccupancyLow || occupancy > cfgCutOccupancyHigh) + if (occupancy < cfgCutOccupancyLow || occupancy > cfgCutOccupancyHigh) { return false; - if (fillHists) + } + if (fillHists) { histos.fill(HIST("hEventSelection"), 6.5 /* Below min occupancy and Above max occupancy*/); + } /* if (collision.alias_bit(kTVXinTRD)) { @@ -2122,24 +2336,27 @@ struct HStrangeCorrelation { // O2-4623 return false; } - if (fillHists) + if (fillHists) { histos.fill(HIST("hEventSelection"), 7.5 /* reject collisions close to Time Frame borders*/); + } if (!collision.selection_bit(o2::aod::evsel::kNoITSROFrameBorder)) { // reject events affected by the ITS ROF border // O2-4309 return false; } - if (fillHists) + if (fillHists) { histos.fill(HIST("hEventSelection"), 8.5 /* reject events affected by the ITS ROF border*/); + } if (!collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) { // rejects collisions which are associated with the same "found-by-T0" bunch crossing // https://indico.cern.ch/event/1396220/#1-event-selection-with-its-rof return false; } - if (fillHists) + if (fillHists) { histos.fill(HIST("hEventSelection"), 9.5 /* rejects collisions which are associated with the same "found-by-T0" bunch crossing*/); + } return true; } @@ -2227,8 +2444,9 @@ struct HStrangeCorrelation { if (!doprocessSameEventHCascades && !doprocessSameEventHV0s && !doprocessSameEventHPions) { for (auto const& triggerTrack : triggerTracks) { auto track = triggerTrack.track_as(); - if (!isValidTrigger(track, triggerTrack.isLeading())) + if (!isValidTrigger(track, triggerTrack.isLeading())) { continue; + } histos.fill(HIST("hDCAzTriggerHadron"), track.dcaZ(), track.pt()); histos.fill(HIST("hDCAxyTriggerHadron"), track.dcaXY(), track.pt()); float efficiency = 1.0f; @@ -2241,24 +2459,27 @@ struct HStrangeCorrelation { float weight = efficiencyFlags.applyEfficiencyCorrection ? 1. / efficiency : 1.0f; histos.fill(HIST("hTriggerAllSelectedEtaVsPt"), track.pt(), track.eta(), collision.centFT0M()); histos.fill(HIST("hTriggerPtResolution"), track.pt(), triggerTrack.mcOriginalPt()); - if (masterConfigurations.doTriggPhysicalPrimary && !triggerTrack.mcPhysicalPrimary()) + if (masterConfigurations.doTriggPhysicalPrimary && !triggerTrack.mcPhysicalPrimary()) { continue; + } histos.fill(HIST("hTriggerPrimaryEtaVsPt"), track.pt(), track.eta(), collision.centFT0M()); histos.fill(HIST("hTrackEtaVsPtVsPhi"), track.pt(), track.eta(), track.phi(), weight); } } for (auto const& assocTrack : assocHadrons) { auto assoc = assocTrack.track_as(); - if (!isValidAssocHadron(assoc)) + if (!isValidAssocHadron(assoc)) { continue; + } float efficiency = 1.0f; float purity = 1.0f; histos.fill(HIST("hDCAzAssociatedHadron"), assoc.dcaZ(), assoc.pt()); histos.fill(HIST("hDCAxyAssociatedHadron"), assoc.dcaXY(), assoc.pt()); if (efficiencyFlags.applyEfficiencyCorrection) { efficiency = hEfficiencyHadron->Interpolate(assoc.pt(), assoc.eta()); - if (efficiencyFlags.applyPurityHadron) + if (efficiencyFlags.applyPurityHadron) { purity = hPurityHadron->Interpolate(assoc.pt()); + } } if (efficiency == 0) { // check for zero efficiency, do not apply if the case efficiency = 1; @@ -2266,16 +2487,18 @@ struct HStrangeCorrelation { float weight = efficiencyFlags.applyEfficiencyCorrection ? purity / efficiency : 1.0f; histos.fill(HIST("hAssocHadronsAllSelectedEtaVsPt"), assoc.pt(), assoc.eta(), collision.centFT0M(), weight); histos.fill(HIST("hAssocPtResolution"), assoc.pt(), assocTrack.mcOriginalPt()); - if (doAssocPhysicalPrimary && !assocTrack.mcPhysicalPrimary()) + if (doAssocPhysicalPrimary && !assocTrack.mcPhysicalPrimary()) { continue; + } histos.fill(HIST("hAssocPrimaryEtaVsPt"), assoc.pt(), assoc.eta(), collision.centFT0M()); histos.fill(HIST("hAsssocTrackEtaVsPtVsPhi"), assoc.pt(), assoc.eta(), assoc.phi(), weight); } // ________________________________________________ // Do hadron - hadron correlations - if (masterConfigurations.doFullCorrelationStudy) + if (masterConfigurations.doFullCorrelationStudy) { fillCorrelationsHadron(triggerTracks, assocHadrons, false, collision.posZ(), collision.centFT0M(), bField); + } } void processSameEventHV0s(soa::Join::iterator const& collision, @@ -2316,8 +2539,8 @@ struct HStrangeCorrelation { if (efficiencyFlags.applyEfficiencyCorrection) { initEfficiencyFromCCDB(bc); } - TH2F* hEfficiencyV0[3]; - THnF* hEfficiencyV0MultVsPhi[3]; + std::array hEfficiencyV0{nullptr, nullptr, nullptr}; + std::array hEfficiencyV0MultVsPhi{nullptr, nullptr, nullptr}; if (efficiencyFlags.applyEffAsFunctionOfMultAndPhi) { hEfficiencyV0MultVsPhi[0] = hEfficiencyK0ShortMultVsPhi; hEfficiencyV0MultVsPhi[1] = hEfficiencyLambdaMultVsPhi; @@ -2334,19 +2557,24 @@ struct HStrangeCorrelation { //---] track quality check [--- auto postrack = v0Data.posTrack_as(); auto negtrack = v0Data.negTrack_as(); - if (postrack.tpcNClsCrossedRows() < trackSelection.minTPCNCrossedRowsAssociated || negtrack.tpcNClsCrossedRows() < trackSelection.minTPCNCrossedRowsAssociated) + if (postrack.tpcNClsCrossedRows() < trackSelection.minTPCNCrossedRowsAssociated || negtrack.tpcNClsCrossedRows() < trackSelection.minTPCNCrossedRowsAssociated) { continue; - if (trackSelection.checksRequireTPCChi2 && (postrack.tpcChi2NCl() < trackSelection.minTPCChi2PerClusterAssociated || negtrack.tpcChi2NCl() < trackSelection.minTPCChi2PerClusterAssociated)) + } + if (trackSelection.checksRequireTPCChi2 && (postrack.tpcChi2NCl() < trackSelection.minTPCChi2PerClusterAssociated || negtrack.tpcChi2NCl() < trackSelection.minTPCChi2PerClusterAssociated)) { continue; - if (trackSelection.requireClusterInITS && (postrack.itsNCls() < trackSelection.minITSClustersForDaughterTracks || negtrack.itsNCls() < trackSelection.minITSClustersForDaughterTracks)) + } + if (trackSelection.requireClusterInITS && (postrack.itsNCls() < trackSelection.minITSClustersForDaughterTracks || negtrack.itsNCls() < trackSelection.minITSClustersForDaughterTracks)) { continue; + } //---] syst cuts [--- if (masterConfigurations.doPPAnalysis && (v0Data.v0radius() < v0Selection.v0RadiusMin || v0Data.v0radius() > v0Selection.v0RadiusMax || std::abs(v0Data.dcapostopv()) < v0Selection.dcapostopv || std::abs(v0Data.dcanegtopv()) < v0Selection.dcanegtopv || - v0Data.v0cosPA() < v0Selection.v0cospa || v0Data.dcaV0daughters() > v0Selection.dcaV0dau)) + v0Data.v0cosPA() < v0Selection.v0cospa || v0Data.dcaV0daughters() > v0Selection.dcaV0dau)) { continue; - if (!masterConfigurations.doPPAnalysis && !v0SelectedPbPb(v0Data)) + } + if (!masterConfigurations.doPPAnalysis && !v0SelectedPbPb(v0Data)) { continue; + } uint64_t selMap = v0selectionBitmap(v0Data, collision.posX(), collision.posY(), collision.posZ()); static_for<0, 2>([&](auto i) { @@ -2354,8 +2582,8 @@ struct HStrangeCorrelation { float efficiency = 1.0f; if (efficiencyFlags.applyEffAsFunctionOfMultAndPhi) { if (efficiencyFlags.applyEfficiencyCorrection) { - double bin[4] = {v0Data.pt(), v0Data.eta(), v0Data.phi(), cent}; - efficiency = hEfficiencyV0MultVsPhi[Index]->GetBinContent(hEfficiencyV0MultVsPhi[Index]->GetBin(bin)); + std::array bin = {v0Data.pt(), v0Data.eta(), v0Data.phi(), cent}; + efficiency = hEfficiencyV0MultVsPhi[Index]->GetBinContent(hEfficiencyV0MultVsPhi[Index]->GetBin(bin.data())); } } else { if (efficiencyFlags.applyEfficiencyCorrection) { @@ -2397,12 +2625,14 @@ struct HStrangeCorrelation { if (!doprocessSameEventHCascades) { for (auto const& triggerTrack : triggerTracks) { auto track = triggerTrack.track_as(); - if (!isValidTrigger(track, triggerTrack.isLeading())) + if (!isValidTrigger(track, triggerTrack.isLeading())) { continue; + } histos.fill(HIST("hTriggerAllSelectedEtaVsPt"), track.pt(), track.eta(), cent); histos.fill(HIST("hTriggerPtResolution"), track.pt(), triggerTrack.mcOriginalPt()); - if (masterConfigurations.doTriggPhysicalPrimary && !triggerTrack.mcPhysicalPrimary()) + if (masterConfigurations.doTriggPhysicalPrimary && !triggerTrack.mcPhysicalPrimary()) { continue; + } if (!efficiencyFlags.applyEffAsFunctionOfMultAndPhi) { histos.fill(HIST("hTriggerPrimaryEtaVsPt"), track.pt(), track.eta(), cent); } else { @@ -2414,8 +2644,9 @@ struct HStrangeCorrelation { // ________________________________________________ // Do hadron - V0 correlations - if (masterConfigurations.doFullCorrelationStudy) + if (masterConfigurations.doFullCorrelationStudy) { fillCorrelationsV0(triggerTracks, associatedV0s, false, false, collision.posX(), collision.posY(), collision.posZ(), cent, bField); + } } void processSameEventHCascades(soa::Join::iterator const& collision, @@ -2455,8 +2686,8 @@ struct HStrangeCorrelation { if (efficiencyFlags.applyEfficiencyCorrection) { initEfficiencyFromCCDB(bc); } - TH2F* hEfficiencyCascade[4]; - THnF* hEfficiencyCascadeMultVsPhi[4]; + std::array hEfficiencyCascade{nullptr, nullptr, nullptr, nullptr}; + std::array hEfficiencyCascadeMultVsPhi{nullptr, nullptr, nullptr, nullptr}; if (efficiencyFlags.applyEfficiencyCorrection) { if (efficiencyFlags.applyEffAsFunctionOfMultAndPhi) { hEfficiencyCascadeMultVsPhi[0] = hEfficiencyXiMinusMultVsPhi; @@ -2483,21 +2714,26 @@ struct HStrangeCorrelation { cascData.casccosPA(collision.posX(), collision.posY(), collision.posZ()) < cascadeSelections.cascCospa || cascData.cascradius() < cascadeSelections.cascRadius || std::abs(cascData.dcav0topv(collision.posX(), collision.posY(), collision.posZ())) < cascadeSelections.cascdcaV0ToPV || - std::abs(cascData.mLambda() - o2::constants::physics::MassLambda0) > cascadeSelections.cascV0masswindow)) + std::abs(cascData.mLambda() - o2::constants::physics::MassLambda0) > cascadeSelections.cascV0masswindow)) { continue; - if (!masterConfigurations.doPPAnalysis && !cascadeSelectedPbPb(cascData, collision.posX(), collision.posY(), collision.posZ())) + } + if (!masterConfigurations.doPPAnalysis && !cascadeSelectedPbPb(cascData, collision.posX(), collision.posY(), collision.posZ())) { continue; + } uint64_t cascselMap = cascadeselectionBitmap(cascData, collision.posX(), collision.posY(), collision.posZ()); //---] track quality check [--- auto postrack = cascData.posTrack_as(); auto negtrack = cascData.negTrack_as(); auto bachtrack = cascData.bachelor_as(); - if (postrack.tpcNClsCrossedRows() < trackSelection.minTPCNCrossedRowsAssociated || negtrack.tpcNClsCrossedRows() < trackSelection.minTPCNCrossedRowsAssociated || bachtrack.tpcNClsCrossedRows() < trackSelection.minTPCNCrossedRowsAssociated) + if (postrack.tpcNClsCrossedRows() < trackSelection.minTPCNCrossedRowsAssociated || negtrack.tpcNClsCrossedRows() < trackSelection.minTPCNCrossedRowsAssociated || bachtrack.tpcNClsCrossedRows() < trackSelection.minTPCNCrossedRowsAssociated) { continue; - if (trackSelection.checksRequireTPCChi2 && (postrack.tpcChi2NCl() < trackSelection.minTPCChi2PerClusterAssociated || negtrack.tpcChi2NCl() < trackSelection.minTPCChi2PerClusterAssociated || bachtrack.tpcChi2NCl() < trackSelection.minTPCChi2PerClusterAssociated)) + } + if (trackSelection.checksRequireTPCChi2 && (postrack.tpcChi2NCl() < trackSelection.minTPCChi2PerClusterAssociated || negtrack.tpcChi2NCl() < trackSelection.minTPCChi2PerClusterAssociated || bachtrack.tpcChi2NCl() < trackSelection.minTPCChi2PerClusterAssociated)) { continue; - if (trackSelection.requireClusterInITS && (postrack.itsNCls() < trackSelection.minITSClustersForDaughterTracks || negtrack.itsNCls() < trackSelection.minITSClustersForDaughterTracks)) + } + if (trackSelection.requireClusterInITS && (postrack.itsNCls() < trackSelection.minITSClustersForDaughterTracks || negtrack.itsNCls() < trackSelection.minITSClustersForDaughterTracks)) { continue; + } static_for<0, 3>([&](auto i) { constexpr int Index = i.value; @@ -2507,8 +2743,8 @@ struct HStrangeCorrelation { float efficiency = 1.0f; if (efficiencyFlags.applyEfficiencyCorrection) { if (efficiencyFlags.applyEffAsFunctionOfMultAndPhi) { - double bin[4] = {cascData.pt(), cascData.eta(), cascData.phi(), cent}; - efficiency = hEfficiencyCascadeMultVsPhi[Index]->GetBinContent(hEfficiencyCascadeMultVsPhi[Index]->GetBin(bin)); + std::array bin = {cascData.pt(), cascData.eta(), cascData.phi(), cent}; + efficiency = hEfficiencyCascadeMultVsPhi[Index]->GetBinContent(hEfficiencyCascadeMultVsPhi[Index]->GetBin(bin.data())); } else { efficiency = hEfficiencyCascade[Index]->Interpolate(cascData.pt(), cascData.eta()); } @@ -2544,28 +2780,32 @@ struct HStrangeCorrelation { } for (auto const& triggerTrack : triggerTracks) { auto track = triggerTrack.track_as(); - if (!isValidTrigger(track, triggerTrack.isLeading())) + if (!isValidTrigger(track, triggerTrack.isLeading())) { continue; + } histos.fill(HIST("hTriggerAllSelectedEtaVsPt"), track.pt(), track.eta(), cent); histos.fill(HIST("hTriggerPtResolution"), track.pt(), triggerTrack.mcOriginalPt()); - if (masterConfigurations.doTriggPhysicalPrimary && !triggerTrack.mcPhysicalPrimary()) + if (masterConfigurations.doTriggPhysicalPrimary && !triggerTrack.mcPhysicalPrimary()) { continue; + } if (!efficiencyFlags.applyEffAsFunctionOfMultAndPhi) { histos.fill(HIST("hTriggerPrimaryEtaVsPt"), track.pt(), track.eta(), cent); } else { histos.fill(HIST("hTriggerPrimaryEtaVsPt"), track.pt(), track.eta(), track.phi(), cent); } - if (track.sign() > 0) + if (track.sign() > 0) { histos.fill(HIST("hPositiveTriggerPrimaryEtaVsPt"), track.pt(), track.eta(), cent); - else + } else { histos.fill(HIST("hNegativeTriggerPrimaryEtaVsPt"), track.pt(), track.eta(), cent); + } histos.fill(HIST("hTrackEtaVsPtVsPhi"), track.pt(), track.eta(), track.phi()); } // ________________________________________________ // Do hadron - cascade correlations - if (masterConfigurations.doFullCorrelationStudy) + if (masterConfigurations.doFullCorrelationStudy) { fillCorrelationsCascade(triggerTracks, associatedCascades, false, false, collision.posX(), collision.posY(), collision.posZ(), cent, bField); + } } void processSameEventHPions(soa::Join::iterator const& collision, soa::Join const& associatedPions, soa::Join const& triggerTracks, @@ -2598,29 +2838,35 @@ struct HStrangeCorrelation { // Do basic QA for (auto const& pion : associatedPions) { auto pionTrack = pion.track_as(); - if (!isValidAssocHadron(pionTrack)) + if (!isValidAssocHadron(pionTrack)) { continue; + } histos.fill(HIST("hPionEtaVsPtAllSelected"), pionTrack.pt(), pionTrack.eta(), collision.centFT0M()); - if (doAssocPhysicalPrimary && !pion.mcPhysicalPrimary()) + if (doAssocPhysicalPrimary && !pion.mcPhysicalPrimary()) { continue; - if (masterConfigurations.doMCassociation && std::abs(pion.pdgCode()) != PdgCodes[IndexPion]) + } + if (masterConfigurations.doMCassociation && std::abs(pion.pdgCode()) != PdgCodes[IndexPion]) { continue; + } histos.fill(HIST("hPionEtaVsPt"), pionTrack.pt(), pionTrack.eta(), collision.centFT0M()); - if (pionTrack.sign() > 0) + if (pionTrack.sign() > 0) { histos.fill(HIST("hPositivePionEtaVsPt"), pionTrack.pt(), pionTrack.eta(), collision.centFT0M()); - else + } else { histos.fill(HIST("hNegativePionEtaVsPt"), pionTrack.pt(), pionTrack.eta(), collision.centFT0M()); + } } if (!doprocessSameEventHCascades && !doprocessSameEventHV0s) { for (auto const& triggerTrack : triggerTracks) { auto track = triggerTrack.track_as(); - if (!isValidTrigger(track, triggerTrack.isLeading())) + if (!isValidTrigger(track, triggerTrack.isLeading())) { continue; + } histos.fill(HIST("hTriggerAllSelectedEtaVsPt"), track.pt(), track.eta(), collision.centFT0M()); histos.fill(HIST("hTriggerPtResolution"), track.pt(), triggerTrack.mcOriginalPt()); - if (masterConfigurations.doTriggPhysicalPrimary && !triggerTrack.mcPhysicalPrimary()) + if (masterConfigurations.doTriggPhysicalPrimary && !triggerTrack.mcPhysicalPrimary()) { continue; + } histos.fill(HIST("hTriggerPrimaryEtaVsPt"), track.pt(), track.eta(), collision.centFT0M()); histos.fill(HIST("hTrackEtaVsPtVsPhi"), track.pt(), track.eta(), track.phi()); } @@ -2628,8 +2874,9 @@ struct HStrangeCorrelation { // ________________________________________________ // Do hadron - Pion correlations - if (masterConfigurations.doFullCorrelationStudy) + if (masterConfigurations.doFullCorrelationStudy) { fillCorrelationsHadron(triggerTracks, associatedPions, false, collision.posZ(), collision.centFT0M(), bField); + } } void processMixedEventHHadrons(soa::Join const& collisions, @@ -2655,10 +2902,12 @@ struct HStrangeCorrelation { if (!isCollisionSelected(collision1) || !isCollisionSelected(collision2)) { continue; } - if (collision1.centFT0M() > axisRanges[5][1] || collision1.centFT0M() < axisRanges[5][0]) + if (collision1.centFT0M() > axisRanges[5][1] || collision1.centFT0M() < axisRanges[5][0]) { continue; - if (collision2.centFT0M() > axisRanges[5][1] || collision2.centFT0M() < axisRanges[5][0]) + } + if (collision2.centFT0M() > axisRanges[5][1] || collision2.centFT0M() < axisRanges[5][0]) { continue; + } if (doMixingQAandEventQA) { if (collision1.globalIndex() == collision2.globalIndex()) { histos.fill(HIST("MixingQA/hMixingQA"), 0.0f); // same-collision pair counting @@ -2673,8 +2922,9 @@ struct HStrangeCorrelation { auto slicedAssocHadrons = assocHadrons.sliceBy(collisionSliceHadrons, collision2.globalIndex()); // ________________________________________________ // Do hadron - hadron correlations - if (masterConfigurations.doFullCorrelationStudy) + if (masterConfigurations.doFullCorrelationStudy) { fillCorrelationsHadron(slicedTriggerTracks, slicedAssocHadrons, true, collision1.posZ(), collision1.centFT0M(), bField); + } } } @@ -2708,10 +2958,12 @@ struct HStrangeCorrelation { if ((masterConfigurations.doPPAnalysis && (!isCollisionSelected(collision1) || !isCollisionSelected(collision2))) || (!masterConfigurations.doPPAnalysis && (!isCollisionSelectedPbPb(collision1, false) || (!isCollisionSelectedPbPb(collision2, false))))) { continue; } - if (cent1 > axisRanges[5][1] || cent1 < axisRanges[5][0]) + if (cent1 > axisRanges[5][1] || cent1 < axisRanges[5][0]) { continue; - if (cent2 > axisRanges[5][1] || cent2 < axisRanges[5][0]) + } + if (cent2 > axisRanges[5][1] || cent2 < axisRanges[5][0]) { continue; + } if (!doprocessMixedEventHCascades && doMixingQAandEventQA) { if (collision1.globalIndex() == collision2.globalIndex()) { @@ -2727,8 +2979,9 @@ struct HStrangeCorrelation { auto slicedAssocV0s = associatedV0s.sliceBy(collisionSliceV0s, collision2.globalIndex()); // ________________________________________________ // Do hadron - V0 correlations - if (masterConfigurations.doFullCorrelationStudy) + if (masterConfigurations.doFullCorrelationStudy) { fillCorrelationsV0(slicedTriggerTracks, slicedAssocV0s, true, false, collision1.posX(), collision1.posY(), collision1.posZ(), cent1, bField); + } } }, colBinning); @@ -2764,10 +3017,12 @@ struct HStrangeCorrelation { if ((masterConfigurations.doPPAnalysis && (!isCollisionSelected(collision1) || !isCollisionSelected(collision2))) || (!masterConfigurations.doPPAnalysis && (!isCollisionSelectedPbPb(collision1, false) || (!isCollisionSelectedPbPb(collision2, false))))) { continue; } - if (cent1 > axisRanges[5][1] || cent1 < axisRanges[5][0]) + if (cent1 > axisRanges[5][1] || cent1 < axisRanges[5][0]) { continue; - if (cent2 > axisRanges[5][1] || cent2 < axisRanges[5][0]) + } + if (cent2 > axisRanges[5][1] || cent2 < axisRanges[5][0]) { continue; + } if (doMixingQAandEventQA) { if (collision1.globalIndex() == collision2.globalIndex()) { histos.fill(HIST("MixingQA/hMixingQA"), 0.0f); // same-collision pair counting @@ -2782,8 +3037,9 @@ struct HStrangeCorrelation { auto slicedAssocCascades = associatedCascades.sliceBy(collisionSliceCascades, collision2.globalIndex()); // ________________________________________________ // Do hadron - cascade correlations - if (masterConfigurations.doFullCorrelationStudy) + if (masterConfigurations.doFullCorrelationStudy) { fillCorrelationsCascade(slicedTriggerTracks, slicedAssocCascades, true, false, collision1.posX(), collision1.posY(), collision1.posZ(), cent1, bField); + } } }, colBinning); @@ -2812,10 +3068,12 @@ struct HStrangeCorrelation { if (!isCollisionSelected(collision1) || !isCollisionSelected(collision2)) { continue; } - if (collision1.centFT0M() > axisRanges[5][1] || collision1.centFT0M() < axisRanges[5][0]) + if (collision1.centFT0M() > axisRanges[5][1] || collision1.centFT0M() < axisRanges[5][0]) { continue; - if (collision2.centFT0M() > axisRanges[5][1] || collision2.centFT0M() < axisRanges[5][0]) + } + if (collision2.centFT0M() > axisRanges[5][1] || collision2.centFT0M() < axisRanges[5][0]) { continue; + } if (doMixingQAandEventQA) { if (collision1.globalIndex() == collision2.globalIndex()) { histos.fill(HIST("MixingQA/hMixingQA"), 0.0f); // same-collision pair counting @@ -2830,8 +3088,9 @@ struct HStrangeCorrelation { auto slicedAssocPions = assocPions.sliceBy(collisionSliceHadrons, collision2.globalIndex()); // ________________________________________________ // Do hadron - cascade correlations - if (masterConfigurations.doFullCorrelationStudy) + if (masterConfigurations.doFullCorrelationStudy) { fillCorrelationsHadron(slicedTriggerTracks, slicedAssocPions, true, collision1.posZ(), collision1.centFT0M(), bField); + } } } @@ -2859,8 +3118,9 @@ struct HStrangeCorrelation { } for (auto const& mcParticle : mcParticles) { - if (doAssocPhysicalPrimaryInGen && !mcParticle.isPhysicalPrimary()) + if (doAssocPhysicalPrimaryInGen && !mcParticle.isPhysicalPrimary()) { continue; + } static_for<0, 7>([&](auto i) { constexpr int Index = i.value; if (i == IndexPion && mcParticle.pdgCode() > Neutral) { @@ -2876,13 +3136,14 @@ struct HStrangeCorrelation { } }); } - if (collisions.size() < 1) + if (collisions.size() < 1) { return; + } // determine best collision properties int biggestNContribs = -1; - int bestCollisionFT0Mpercentile = -1; - int bestCollisionFT0Cpercentile = -1; + float bestCollisionFT0Mpercentile = -1; + float bestCollisionFT0Cpercentile = -1; float bestCollisionVtxZ = 0.0f; bool bestCollisionSel8 = false; bool bestCollisionINELgtZERO = false; @@ -2901,22 +3162,26 @@ struct HStrangeCorrelation { bestCollisionVtxZ = collision.posZ(); bestCollisionINELgtZERO = collision.isInelGt0(); } - if (triggerPresenceMap.size() > 0) + if (triggerPresenceMap.size() > 0) { bestCollisionTriggerPresenceMap = triggerPresenceMap[collision.globalIndex()]; + } } } if (collisions.size() > 1) { for (auto const& mcParticle : mcParticles) { - if (doAssocPhysicalPrimaryInGen && !mcParticle.isPhysicalPrimary()) + if (doAssocPhysicalPrimaryInGen && !mcParticle.isPhysicalPrimary()) { continue; - if (std::abs(mcParticle.y()) > ySel) + } + if (std::abs(mcParticle.y()) > ySel) { continue; + } static_for<0, 7>([&](auto i) { constexpr int Index = i.value; - if (mcParticle.pdgCode() == PdgCodes[i]) + if (mcParticle.pdgCode() == PdgCodes[i]) { histos.fill(HIST("GeneratedWithPV/h") + HIST(Particlenames[Index]) + HIST("_MidYVsMult_TwoPVsOrMore"), mcParticle.pt(), bestCollisionFT0Mpercentile); + } }); } } @@ -2931,15 +3196,19 @@ struct HStrangeCorrelation { return; } if (masterConfigurations.applyNewMCSelection) { - if (!isCollisionSelect) + if (!isCollisionSelect) { return; + } } else { - if (!bestCollisionSel8) + if (!bestCollisionSel8) { return; - if (std::abs(bestCollisionVtxZ) > masterConfigurations.zVertexCut) + } + if (std::abs(bestCollisionVtxZ) > masterConfigurations.zVertexCut) { return; - if (!bestCollisionINELgtZERO) + } + if (!bestCollisionINELgtZERO) { return; + } } histos.fill(HIST("hClosureTestEventCounter"), 3.5f); @@ -2975,10 +3244,11 @@ struct HStrangeCorrelation { } else { histos.fill(HIST("GeneratedWithPV/hTrigger"), gpt, geta, bestCollisionFT0Mpercentile); } - if (mcParticle.pdgCode() > 0) + if (mcParticle.pdgCode() > 0) { histos.fill(HIST("GeneratedWithPV/hPositiveTrigger"), gpt, geta, bestCollisionFT0Mpercentile); - else + } else { histos.fill(HIST("GeneratedWithPV/hNegativeTrigger"), gpt, geta, bestCollisionFT0Mpercentile); + } } if (mcParticle.pdgCode() == PDG_t::kLambda0 && !doAssocPhysicalPrimaryInGen && !mcParticle.isPhysicalPrimary()) { @@ -3036,8 +3306,9 @@ struct HStrangeCorrelation { } else { histos.fill(HIST("GeneratedWithPV/h") + HIST(Particlenames[Index]), gpt, geta, bestCollisionFT0Mpercentile); } - if (std::abs(mcParticle.y()) < ySel) + if (std::abs(mcParticle.y()) < ySel) { histos.fill(HIST("GeneratedWithPV/h") + HIST(Particlenames[Index]) + HIST("_MidYVsMult"), gpt, bestCollisionFT0Mpercentile); + } } }); } @@ -3078,7 +3349,7 @@ struct HStrangeCorrelation { histos.fill(HIST("hClosureTestEventCounter"), 0.5f); - int bestCollisionCentpercentile = -1; + float bestCollisionCentpercentile = -1; float bestCollisionVtxZ = 0.0f; bool bestCollisionSel8 = false; bool bestCollisionINELgtZERO = false; @@ -3097,8 +3368,9 @@ struct HStrangeCorrelation { bestCollisionVtxZ = recCollision.posZ(); bestCollisionINELgtZERO = recCollision.isInelGt0(); } - if (triggerPresenceMap.size() > 0) + if (triggerPresenceMap.size() > 0) { bestCollisionTriggerPresenceMap = triggerPresenceMap[recCollision.globalIndex()]; + } } } // ________________________________________________ @@ -3106,17 +3378,22 @@ struct HStrangeCorrelation { if (triggerPresenceMap.size() > 0 && !TESTBIT(bestCollisionTriggerPresenceMap, triggerBinToSelect)) { return; } + if (masterConfigurations.applyNewMCSelection) { - if (!isCollisionSelect) + if (!isCollisionSelect) { return; + } } else { if (masterConfigurations.doGenEventSelection) { - if (!bestCollisionSel8) + if (!bestCollisionSel8) { return; - if (std::abs(bestCollisionVtxZ) > masterConfigurations.zVertexCut) + } + if (std::abs(bestCollisionVtxZ) > masterConfigurations.zVertexCut) { return; - if (!bestCollisionINELgtZERO) + } + if (!bestCollisionINELgtZERO) { return; + } if (bestCollisionCentpercentile > axisRanges[5][1] || bestCollisionCentpercentile < axisRanges[5][0]) { return; } @@ -3233,14 +3510,28 @@ struct HStrangeCorrelation { double deltaeta = getatrigger - getaassoc; // skip if basic ranges not met - if (deltaphi < axisRanges[0][0] || deltaphi > axisRanges[0][1]) + if (deltaphi < axisRanges[0][0] || deltaphi > axisRanges[0][1]) { continue; - if (deltaeta < axisRanges[1][0] || deltaeta > axisRanges[1][1]) + } + if (deltaeta < axisRanges[1][0] || deltaeta > axisRanges[1][1]) { continue; - if (ptassoc < axisRanges[2][0] || ptassoc > axisRanges[2][1]) + } + if (ptassoc < axisRanges[2][0] || ptassoc > axisRanges[2][1]) { continue; - if (TESTBIT(doCorrelation, i)) + } + if (TESTBIT(doCorrelation, i)) { histos.fill(HIST("ClosureTest/sameEvent/") + HIST(Particlenames[Index]), computeDeltaPhi(gphitrigger, gphiassoc), deltaeta, ptassoc, pttrigger, bestCollisionVtxZ, bestCollisionCentpercentile); + } + if (i < 3 && TESTBIT(doCorrelation, i) && masterConfigurations.doCorrelationsHadronV0daughter) { + auto assocParticleDaugters = assocParticle.daughters_as(); + for (const auto& assocParticleDaugter : assocParticleDaugters) { + if (((assocParticleDaugter.pdgCode() == PDG_t::kPiPlus || assocParticleDaugter.pdgCode() == PDG_t::kProton) && (triggerParticle.pdgCode() > 0)) || ((assocParticleDaugter.pdgCode() == PDG_t::kPiMinus || assocParticleDaugter.pdgCode() == PDG_t::kProtonBar) && (triggerParticle.pdgCode() < 0))) { + histos.fill(HIST("ClosureTest/sameEvent/") + HIST(Particlenames[Index]) + HIST("_SameSignDaughter"), computeDeltaPhi(gphitrigger, assocParticleDaugter.phi()), getatrigger - assocParticleDaugter.eta(), assocParticleDaugter.pt(), pttrigger, bestCollisionVtxZ, bestCollisionCentpercentile); + } else { + histos.fill(HIST("ClosureTest/sameEvent/") + HIST(Particlenames[Index]) + HIST("_OppSignDaughter"), computeDeltaPhi(gphitrigger, assocParticleDaugter.phi()), getatrigger - assocParticleDaugter.eta(), assocParticleDaugter.pt(), pttrigger, bestCollisionVtxZ, bestCollisionCentpercentile); + } + } + } } } }); @@ -3262,14 +3553,16 @@ struct HStrangeCorrelation { //---] track quality check [--- auto postrack = v0Data.posTrack_as(); auto negtrack = v0Data.negTrack_as(); - if (postrack.tpcNClsCrossedRows() < trackSelection.minTPCNCrossedRowsAssociated || negtrack.tpcNClsCrossedRows() < trackSelection.minTPCNCrossedRowsAssociated) + if (postrack.tpcNClsCrossedRows() < trackSelection.minTPCNCrossedRowsAssociated || negtrack.tpcNClsCrossedRows() < trackSelection.minTPCNCrossedRowsAssociated) { continue; + } //---] syst cuts [--- if (v0Data.v0radius() < v0Selection.v0RadiusMin || v0Data.v0radius() > v0Selection.v0RadiusMax || std::abs(v0Data.dcapostopv()) < v0Selection.dcapostopv || std::abs(v0Data.dcanegtopv()) < v0Selection.dcanegtopv || - v0Data.v0cosPA() < v0Selection.v0cospa || v0Data.dcaV0daughters() > v0Selection.dcaV0dau) + v0Data.v0cosPA() < v0Selection.v0cospa || v0Data.dcaV0daughters() > v0Selection.dcaV0dau) { continue; + } if (v0Data.has_mcParticle()) { auto v0mcParticle = v0Data.mcParticle_as(); @@ -3349,12 +3642,14 @@ struct HStrangeCorrelation { if (((masterConfigurations.doPPAnalysis && !isCollisionSelected(collision))) || (!masterConfigurations.doPPAnalysis && !isCollisionSelectedPbPb(collision, false))) { return; } - if (cent > axisRanges[5][1] || cent < axisRanges[5][0]) + if (cent > axisRanges[5][1] || cent < axisRanges[5][0]) { return; + } // ________________________________________________ - if (masterConfigurations.doFullCorrelationStudy) + if (masterConfigurations.doFullCorrelationStudy) { fillCorrelationsV0(triggerTracks, associatedV0s, true, true, collision.posX(), collision.posY(), collision.posZ(), cent, bField); + } } void processMixedEventHCascadesInBuffer(soa::Join::iterator const& collision, aod::AssocV0s const&, aod::AssocCascades const& associatedCascades, aod::TriggerTracks const& triggerTracks, @@ -3376,12 +3671,14 @@ struct HStrangeCorrelation { if ((masterConfigurations.doPPAnalysis && !isCollisionSelected(collision)) || (!masterConfigurations.doPPAnalysis && (!isCollisionSelectedPbPb(collision, false)))) { return; } - if (cent > axisRanges[5][1] || cent < axisRanges[5][0]) + if (cent > axisRanges[5][1] || cent < axisRanges[5][0]) { return; + } // ________________________________________________ // Do hadron - cascade correlations - if (masterConfigurations.doFullCorrelationStudy) + if (masterConfigurations.doFullCorrelationStudy) { fillCorrelationsCascade(triggerTracks, associatedCascades, true, true, collision.posX(), collision.posY(), collision.posZ(), cent, bField); + } } void processPrediction(soa::Join::iterator const& mcCollision, aod::McParticles const& mcParticles) { @@ -3535,12 +3832,15 @@ struct HStrangeCorrelation { double deltaeta = getatrigger - getaassoc; // skip if basic ranges not met - if (deltaphi < axisRanges[0][0] || deltaphi > axisRanges[0][1]) + if (deltaphi < axisRanges[0][0] || deltaphi > axisRanges[0][1]) { continue; - if (deltaeta < axisRanges[1][0] || deltaeta > axisRanges[1][1]) + } + if (deltaeta < axisRanges[1][0] || deltaeta > axisRanges[1][1]) { continue; - if (ptassoc < axisRanges[2][0] || ptassoc > axisRanges[2][1]) + } + if (ptassoc < axisRanges[2][0] || ptassoc > axisRanges[2][1]) { continue; + } if (TESTBIT(doCorrelation, i)) { if (masterConfigurations.useCentralityinPrediction) { histos.fill(HIST("Prediction/sameEvent/") + HIST(Particlenames[Index]), computeDeltaPhi(gphitrigger, gphiassoc), deltaeta, ptassoc, pttrigger, mcCollision.posZ(), centMultFT0M); @@ -3580,8 +3880,8 @@ struct HStrangeCorrelation { PROCESS_SWITCH(HStrangeCorrelation, processPrediction, "process model prediction", false); }; -WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +WorkflowSpec defineDataProcessing(ConfigContext const& context) { return WorkflowSpec{ - adaptAnalysisTask(cfgc)}; + adaptAnalysisTask(context)}; } From 649945224f21b4b8af095f6f5b925a9123c5d6bf Mon Sep 17 00:00:00 2001 From: Lucia Anna Tarasovicova Date: Mon, 27 Jul 2026 14:33:53 +0200 Subject: [PATCH 2/2] fix MegaLinter --- .../Strangeness/hStrangeCorrelationFilter.cxx | 28 ++++---- .../Tasks/Strangeness/hStrangeCorrelation.cxx | 72 +++++++++---------- 2 files changed, 50 insertions(+), 50 deletions(-) diff --git a/PWGLF/TableProducer/Strangeness/hStrangeCorrelationFilter.cxx b/PWGLF/TableProducer/Strangeness/hStrangeCorrelationFilter.cxx index d0f5927e2f2..b405d3855d5 100644 --- a/PWGLF/TableProducer/Strangeness/hStrangeCorrelationFilter.cxx +++ b/PWGLF/TableProducer/Strangeness/hStrangeCorrelationFilter.cxx @@ -60,8 +60,8 @@ using namespace o2::framework; using namespace o2::framework::expressions; struct HStrangeCorrelationFilter { - static constexpr float ctauxi = 4.91; // from PDG - static constexpr float ctauomega = 2.461; // from PDG + static constexpr float Xictau = 4.91; // from PDG + static constexpr float Omegactau = 2.461; // from PDG Service ccdb; @@ -246,14 +246,14 @@ struct HStrangeCorrelationFilter { TF1* fXiWidth = new TF1("fXiWidth", "[0]+[1]*x+[2]*std::exp(-[3]*x)"); TF1* fOmegaMean = new TF1("fomegaMean", "[0]+[1]*x+[2]*std::exp(-[3]*x)"); TF1* fOmegaWidth = new TF1("fomegaWidth", "[0]+[1]*x+[2]*std::exp(-[3]*x)"); - TH1F* hK0ShortMean; - TH1F* hK0ShortWidth; - TH1F* hLambdaMean; - TH1F* hLambdaWidth; - TH1F* hXiMean; - TH1F* hXiWidth; - TH1F* hOmegaMean; - TH1F* hOmegaWidth; + TH1F* hK0ShortMean = nullptr; + TH1F* hK0ShortWidth = nullptr; + TH1F* hLambdaMean = nullptr; + TH1F* hLambdaWidth = nullptr; + TH1F* hXiMean = nullptr; + TH1F* hXiWidth = nullptr; + TH1F* hOmegaMean = nullptr; + TH1F* hOmegaWidth = nullptr; Zorro zorro; OutputObj zorroSummary{"zorroSummary"}; int mRunNumber; @@ -1115,8 +1115,8 @@ struct HStrangeCorrelationFilter { int compatibleOmegaPlus = -1; float cascpos = std::hypot(casc.x() - collision.posX(), casc.y() - collision.posY(), casc.z() - collision.posZ()); float cascptotmom = std::hypot(casc.px(), casc.py(), casc.pz()); - float ctauXi = o2::constants::physics::MassXiMinus * cascpos / ((cascptotmom + 1e-13) * ctauxi); - float ctauOmega = o2::constants::physics::MassOmegaMinus * cascpos / ((cascptotmom + 1e-13) * ctauomega); + float ctauXi = o2::constants::physics::MassXiMinus * cascpos / ((cascptotmom + 1e-13) * Xictau); + float ctauOmega = o2::constants::physics::MassOmegaMinus * cascpos / ((cascptotmom + 1e-13) * Omegactau); bool isGoodXiPbPb = std::abs(casc.mOmega() - o2::constants::physics::MassOmegaMinus) > cascSelection.rejcomp && ctauXi < cascSelection.proplifetime && std::abs(casc.yXi()) < cascSelection.rapCut; @@ -1283,8 +1283,8 @@ struct HStrangeCorrelationFilter { int compatibleOmegaPlus = -1; float cascpos = std::hypot(casc.x() - collision.posX(), casc.y() - collision.posY(), casc.z() - collision.posZ()); float cascptotmom = std::hypot(casc.px(), casc.py(), casc.pz()); - float ctauXi = o2::constants::physics::MassXiMinus * cascpos / ((cascptotmom + 1e-13) * ctauxi); - float ctauOmega = o2::constants::physics::MassOmegaMinus * cascpos / ((cascptotmom + 1e-13) * ctauomega); + float ctauXi = o2::constants::physics::MassXiMinus * cascpos / ((cascptotmom + 1e-13) * Xictau); + float ctauOmega = o2::constants::physics::MassOmegaMinus * cascpos / ((cascptotmom + 1e-13) * Omegactau); bool iGoodXiPbPb = std::abs(casc.mOmega() - o2::constants::physics::MassOmegaMinus) > cascSelection.rejcomp && ctauXi < cascSelection.proplifetime && std::abs(casc.yXi()) < cascSelection.rapCut; diff --git a/PWGLF/Tasks/Strangeness/hStrangeCorrelation.cxx b/PWGLF/Tasks/Strangeness/hStrangeCorrelation.cxx index 35c74361200..3fb2f60415d 100644 --- a/PWGLF/Tasks/Strangeness/hStrangeCorrelation.cxx +++ b/PWGLF/Tasks/Strangeness/hStrangeCorrelation.cxx @@ -322,43 +322,43 @@ struct HStrangeCorrelation { ValidCollisions validCollisions; // objects to use for efficiency corrections - TH2F* hEfficiencyTrigger; - TH3F* hEfficiencyTriggerMult; - THnF* hEfficiencyTriggerMultVsPhi; - TH2F* hEfficiencyPion; - TH2F* hEfficiencyK0Short; - THnF* hEfficiencyK0ShortMultVsPhi; - TH2F* hEfficiencyLambda; - THnF* hEfficiencyLambdaMultVsPhi; - TH2F* hEfficiencyAntiLambda; - THnF* hEfficiencyAntiLambdaMultVsPhi; - TH2F* hEfficiencyXiMinus; - THnF* hEfficiencyXiMinusMultVsPhi; - TH2F* hEfficiencyXiPlus; - THnF* hEfficiencyXiPlusMultVsPhi; - TH2F* hEfficiencyOmegaMinus; - THnF* hEfficiencyOmegaMinusMultVsPhi; - TH2F* hEfficiencyOmegaPlus; - THnF* hEfficiencyOmegaPlusMultVsPhi; - TH2F* hEfficiencyHadron; - TH3F* hEfficiencyHadronMult; - TH1F* hPurityHadron; - TH2F* hPurityHadronMult; + TH2F* hEfficiencyTrigger = nullptr; + TH3F* hEfficiencyTriggerMult = nullptr; + THnF* hEfficiencyTriggerMultVsPhi = nullptr; + TH2F* hEfficiencyPion = nullptr; + TH2F* hEfficiencyK0Short = nullptr; + THnF* hEfficiencyK0ShortMultVsPhi = nullptr; + TH2F* hEfficiencyLambda = nullptr; + THnF* hEfficiencyLambdaMultVsPhi = nullptr; + TH2F* hEfficiencyAntiLambda = nullptr; + THnF* hEfficiencyAntiLambdaMultVsPhi = nullptr; + TH2F* hEfficiencyXiMinus = nullptr; + THnF* hEfficiencyXiMinusMultVsPhi = nullptr; + TH2F* hEfficiencyXiPlus = nullptr; + THnF* hEfficiencyXiPlusMultVsPhi = nullptr; + TH2F* hEfficiencyOmegaMinus = nullptr; + THnF* hEfficiencyOmegaMinusMultVsPhi = nullptr; + TH2F* hEfficiencyOmegaPlus = nullptr; + THnF* hEfficiencyOmegaPlusMultVsPhi = nullptr; + TH2F* hEfficiencyHadron = nullptr; + TH3F* hEfficiencyHadronMult = nullptr; + TH1F* hPurityHadron = nullptr; + TH2F* hPurityHadronMult = nullptr; // objects to propagate the efficiency uncertainty - TH2F* hEfficiencyUncertaintyTrigger; - TH3F* hEfficiencyUncertaintyTriggerMult; - TH2F* hEfficiencyUncertaintyPion; - TH2F* hEfficiencyUncertaintyK0Short; - TH2F* hEfficiencyUncertaintyLambda; - TH2F* hEfficiencyUncertaintyAntiLambda; - TH2F* hEfficiencyUncertaintyXiMinus; - TH2F* hEfficiencyUncertaintyXiPlus; - TH2F* hEfficiencyUncertaintyOmegaMinus; - TH2F* hEfficiencyUncertaintyOmegaPlus; - TH2F* hEfficiencyUncertaintyHadron; - TH3F* hEfficiencyUncertaintyHadronMult; - TH1F* hPurityUncertaintyHadron; - TH2F* hPurityUncertaintyHadronMult; + TH2F* hEfficiencyUncertaintyTrigger = nullptr; + TH3F* hEfficiencyUncertaintyTriggerMult = nullptr; + TH2F* hEfficiencyUncertaintyPion = nullptr; + TH2F* hEfficiencyUncertaintyK0Short = nullptr; + TH2F* hEfficiencyUncertaintyLambda = nullptr; + TH2F* hEfficiencyUncertaintyAntiLambda = nullptr; + TH2F* hEfficiencyUncertaintyXiMinus = nullptr; + TH2F* hEfficiencyUncertaintyXiPlus = nullptr; + TH2F* hEfficiencyUncertaintyOmegaMinus = nullptr; + TH2F* hEfficiencyUncertaintyOmegaPlus = nullptr; + TH2F* hEfficiencyUncertaintyHadron = nullptr; + TH3F* hEfficiencyUncertaintyHadronMult = nullptr; + TH1F* hPurityUncertaintyHadron = nullptr; + TH2F* hPurityUncertaintyHadronMult = nullptr; using BinningTypePP = ColumnBinningPolicy; using BinningTypePbPb = ColumnBinningPolicy;