diff --git a/ALICE3/DataModel/OTFStrangeness.h b/ALICE3/DataModel/OTFStrangeness.h index 73bbf0fc39c..7ee5c862313 100644 --- a/ALICE3/DataModel/OTFStrangeness.h +++ b/ALICE3/DataModel/OTFStrangeness.h @@ -35,8 +35,8 @@ DECLARE_SOA_INDEX_COLUMN_FULL(NegTrack, negTrack, int, Tracks, "_Neg"); DECLARE_SOA_INDEX_COLUMN_FULL(BachTrack, bachTrack, int, Tracks, "_Bach"); //! // topo vars -DECLARE_SOA_COLUMN(DCAV0Daughters, dcaV0Daughters, float); -DECLARE_SOA_COLUMN(DCACascadeDaughters, dcaCascadeDaughters, float); +DECLARE_SOA_COLUMN(DcaV0Daughters, dcaV0Daughters, float); +DECLARE_SOA_COLUMN(DcaCascadeDaughters, dcaCascadeDaughters, float); DECLARE_SOA_COLUMN(V0Radius, v0Radius, float); DECLARE_SOA_COLUMN(CascRadius, cascRadius, float); DECLARE_SOA_COLUMN(CascRadiusMC, cascRadiusMC, float); @@ -55,8 +55,8 @@ DECLARE_SOA_TABLE(UpgradeCascades, "AOD", "UPGRADECASCADES", otfcascade::PosTrackId, otfcascade::NegTrackId, otfcascade::BachTrackId, - otfcascade::DCAV0Daughters, - otfcascade::DCACascadeDaughters, + otfcascade::DcaV0Daughters, + otfcascade::DcaCascadeDaughters, otfcascade::V0Radius, otfcascade::CascRadius, otfcascade::CascRadiusMC, @@ -75,7 +75,7 @@ DECLARE_SOA_INDEX_COLUMN_FULL(NegTrack, negTrack, int, Tracks, "_Neg"); //! DECLARE_SOA_INDEX_COLUMN(V0, v0); //! index of the mc particle corresponding to the V0 // topo vars -DECLARE_SOA_COLUMN(DCAV0Daughters, dcaV0Daughters, float); +DECLARE_SOA_COLUMN(DcaV0Daughters, dcaV0Daughters, float); DECLARE_SOA_COLUMN(V0Radius, v0Radius, float); DECLARE_SOA_COLUMN(MLambda, mLambda, float); DECLARE_SOA_COLUMN(MAntiLambda, mAntiLambda, float); @@ -91,7 +91,7 @@ DECLARE_SOA_TABLE(UpgradeV0s, "AOD", "UPGRADEV0S", otfv0::V0Id, otfv0::PosTrackId, otfv0::NegTrackId, - otfv0::DCAV0Daughters, + otfv0::DcaV0Daughters, otfv0::V0Radius, otfv0::MLambda, otfv0::MAntiLambda, @@ -107,25 +107,28 @@ DECLARE_SOA_INDEX_COLUMN_FULL(PosTrack, posTrack, int, Tracks, "_Pos"); //! DECLARE_SOA_INDEX_COLUMN_FULL(NegTrack, negTrack, int, Tracks, "_Neg"); //! DECLARE_SOA_INDEX_COLUMN(V0, v0); //! +// Label to MC particle +DECLARE_SOA_INDEX_COLUMN_FULL(McParticle, mcParticle, int, McParticles, ""); //! label to the MC particle corresponding to the V0 + // General V0 properties: position, momentum DECLARE_SOA_COLUMN(PosX, posX, float); //! positive track X at min DECLARE_SOA_COLUMN(NegX, negX, float); //! negative track X at min -DECLARE_SOA_COLUMN(PxPos, pxpos, float); //! positive track px at min -DECLARE_SOA_COLUMN(PyPos, pypos, float); //! positive track py at min -DECLARE_SOA_COLUMN(PzPos, pzpos, float); //! positive track pz at min -DECLARE_SOA_COLUMN(PxNeg, pxneg, float); //! negative track px at min -DECLARE_SOA_COLUMN(PyNeg, pyneg, float); //! negative track py at min -DECLARE_SOA_COLUMN(PzNeg, pzneg, float); //! negative track pz at min +DECLARE_SOA_COLUMN(PxPos, pxPos, float); //! positive track px at min +DECLARE_SOA_COLUMN(PyPos, pyPos, float); //! positive track py at min +DECLARE_SOA_COLUMN(PzPos, pzPos, float); //! positive track pz at min +DECLARE_SOA_COLUMN(PxNeg, pxNeg, float); //! negative track px at min +DECLARE_SOA_COLUMN(PyNeg, pyNeg, float); //! negative track py at min +DECLARE_SOA_COLUMN(PzNeg, pzNeg, float); //! negative track pz at min DECLARE_SOA_COLUMN(X, x, float); //! decay position X DECLARE_SOA_COLUMN(Y, y, float); //! decay position Y DECLARE_SOA_COLUMN(Z, z, float); //! decay position Z // topo vars -DECLARE_SOA_COLUMN(DCAV0Daughters, dcaV0Daughters, float); +DECLARE_SOA_COLUMN(DcaV0Daughters, dcaV0Daughters, float); DECLARE_SOA_COLUMN(CosPA, cosPA, float); -DECLARE_SOA_COLUMN(DCAPosToPV, dcaPosToPV, float); -DECLARE_SOA_COLUMN(DCANegToPV, dcaNegToPV, float); -DECLARE_SOA_COLUMN(DCAV0ToPV, dcaV0ToPV, float); +DECLARE_SOA_COLUMN(DcaPosToPV, dcaPosToPV, float); +DECLARE_SOA_COLUMN(DcaNegToPV, dcaNegToPV, float); +DECLARE_SOA_COLUMN(DcaV0ToPV, dcaV0ToPV, float); //______________________________________________________ // DYNAMIC COLUMNS @@ -151,14 +154,14 @@ DECLARE_SOA_DYNAMIC_COLUMN(Eta, eta, //! Pseudorapidity, conditionally defined t return RecoDecay::eta(std::array{pxPos + pxNeg, pyPos + pyNeg, pzPos + pzNeg}); }); // Length quantities -DECLARE_SOA_DYNAMIC_COLUMN(V0Radius, v0radius, //! V0 decay radius (2D, centered at zero) +DECLARE_SOA_DYNAMIC_COLUMN(V0radius, v0radius, //! V0 decay radius (2D, centered at zero) [](float x, float y) -> float { return RecoDecay::sqrtSumOfSquares(x, y); }); // Distance Over To Mom -DECLARE_SOA_DYNAMIC_COLUMN(DistOverTotMom, distovertotmom, //! PV to V0decay distance over total momentum +DECLARE_SOA_DYNAMIC_COLUMN(DistOverTotMom, distOverTotMom, //! PV to V0decay distance over total momentum [](float X, float Y, float Z, float pxPos, float pyPos, float pzPos, float pxNeg, float pyNeg, float pzNeg, float pvX, float pvY, float pvZ) { - float P = RecoDecay::sqrtSumOfSquares(pxPos + pxNeg, pyPos + pyNeg, pzPos + pzNeg); - return std::sqrt(std::pow(X - pvX, 2) + std::pow(Y - pvY, 2) + std::pow(Z - pvZ, 2)) / (P + 1E-10); + float p = RecoDecay::sqrtSumOfSquares(pxPos + pxNeg, pyPos + pyNeg, pzPos + pzNeg); + return std::sqrt(std::pow(X - pvX, 2) + std::pow(Y - pvY, 2) + std::pow(Z - pvZ, 2)) / (p + 1E-10); }); // Armenteros-Podolanski variables @@ -170,7 +173,7 @@ DECLARE_SOA_DYNAMIC_COLUMN(Alpha, alpha, //! Armenteros Alpha return (lQlPos - lQlNeg) / (lQlPos + lQlNeg); // alphav0 }); -DECLARE_SOA_DYNAMIC_COLUMN(QtArm, qtarm, //! Armenteros Qt +DECLARE_SOA_DYNAMIC_COLUMN(QtArm, qtArm, //! Armenteros Qt [](float pxpos, float pypos, float pzpos, float pxneg, float pyneg, float pzneg) { float momTot = RecoDecay::p2(pxpos + pxneg, pypos + pyneg, pzpos + pzneg); float dp = RecoDecay::dotProd(std::array{pxneg, pyneg, pzneg}, std::array{pxpos + pxneg, pypos + pyneg, pzpos + pzneg}); @@ -199,29 +202,29 @@ DECLARE_SOA_DYNAMIC_COLUMN(YLambda, yLambda, //! V0 y with lambda or antilambda return RecoDecay::y(std::array{pxpos + pxneg, pypos + pyneg, pzpos + pzneg}, o2::constants::physics::MassLambda); }); // Daughter track momenta -DECLARE_SOA_DYNAMIC_COLUMN(NegativePt, negativept, //! negative daughter pT +DECLARE_SOA_DYNAMIC_COLUMN(NegativePt, negativePt, //! negative daughter pT [](float pxneg, float pyneg) -> float { return RecoDecay::sqrtSumOfSquares(pxneg, pyneg); }); -DECLARE_SOA_DYNAMIC_COLUMN(PositivePt, positivept, //! positive daughter pT +DECLARE_SOA_DYNAMIC_COLUMN(PositivePt, positivePt, //! positive daughter pT [](float pxpos, float pypos) -> float { return RecoDecay::sqrtSumOfSquares(pxpos, pypos); }); -DECLARE_SOA_DYNAMIC_COLUMN(NegativeEta, negativeeta, //! negative daughter eta +DECLARE_SOA_DYNAMIC_COLUMN(NegativeEta, negativeEta, //! negative daughter eta [](float PxNeg, float PyNeg, float PzNeg) -> float { return RecoDecay::eta(std::array{PxNeg, PyNeg, PzNeg}); }); -DECLARE_SOA_DYNAMIC_COLUMN(NegativePhi, negativephi, //! negative daughter phi +DECLARE_SOA_DYNAMIC_COLUMN(NegativePhi, negativePhi, //! negative daughter phi [](float PxNeg, float PyNeg) -> float { return RecoDecay::phi(PxNeg, PyNeg); }); -DECLARE_SOA_DYNAMIC_COLUMN(PositiveEta, positiveeta, //! positive daughter eta +DECLARE_SOA_DYNAMIC_COLUMN(PositiveEta, positiveEta, //! positive daughter eta [](float PxPos, float PyPos, float PzPos) -> float { return RecoDecay::eta(std::array{PxPos, PyPos, PzPos}); }); -DECLARE_SOA_DYNAMIC_COLUMN(PositivePhi, positivephi, //! positive daughter phi +DECLARE_SOA_DYNAMIC_COLUMN(PositivePhi, positivePhi, //! positive daughter phi [](float PxPos, float PyPos) -> float { return RecoDecay::phi(PxPos, PyPos); }); } // namespace candidatev0 DECLARE_SOA_TABLE(V0CandidateIndices, "AOD", "V0CANDIDATEINDEX", //! index table - o2::soa::Index<>, candidatev0::CollisionId, candidatev0::PosTrackId, candidatev0::NegTrackId); + o2::soa::Index<>, candidatev0::CollisionId, candidatev0::PosTrackId, candidatev0::NegTrackId, candidatev0::McParticleId); DECLARE_SOA_TABLE(V0CandidateCores, "AOD", "V0CANDIDATECORE", o2::soa::Index<>, candidatev0::X, candidatev0::Y, candidatev0::Z, candidatev0::PxPos, candidatev0::PyPos, candidatev0::PzPos, candidatev0::PxNeg, candidatev0::PyNeg, candidatev0::PzNeg, - candidatev0::DCAV0Daughters, candidatev0::DCAPosToPV, candidatev0::DCANegToPV, - candidatev0::CosPA, candidatev0::DCAV0ToPV, + candidatev0::DcaV0Daughters, candidatev0::DcaPosToPV, candidatev0::DcaNegToPV, + candidatev0::CosPA, candidatev0::DcaV0ToPV, candidatev0::Px, candidatev0::Py, candidatev0::Pz, @@ -229,7 +232,7 @@ DECLARE_SOA_TABLE(V0CandidateCores, "AOD", "V0CANDIDATECORE", candidatev0::P, candidatev0::Phi, candidatev0::Eta, - candidatev0::V0Radius, + candidatev0::V0radius, candidatev0::DistOverTotMom, candidatev0::Alpha, candidatev0::QtArm, diff --git a/ALICE3/TableProducer/CMakeLists.txt b/ALICE3/TableProducer/CMakeLists.txt index a3ec83bd851..53b56706f0c 100644 --- a/ALICE3/TableProducer/CMakeLists.txt +++ b/ALICE3/TableProducer/CMakeLists.txt @@ -61,7 +61,7 @@ o2physics_add_dpl_workflow(alice3-tracking-translator PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore COMPONENT_NAME Analysis) -o2physics_add_dpl_workflow(alice3-strangeness-finder - SOURCES alice3-strangenessFinder.cxx +o2physics_add_dpl_workflow(alice3strangenessfinder + SOURCES alice3strangenessFinder.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore COMPONENT_NAME Analysis) diff --git a/ALICE3/TableProducer/OTF/onTheFlyTracker.cxx b/ALICE3/TableProducer/OTF/onTheFlyTracker.cxx index 4e10b6a5779..591bf56a9fb 100644 --- a/ALICE3/TableProducer/OTF/onTheFlyTracker.cxx +++ b/ALICE3/TableProducer/OTF/onTheFlyTracker.cxx @@ -246,8 +246,8 @@ struct OnTheFlyTracker { // Helper struct to pass V0 information struct v0candidate { - int positiveId; // track index in the Tracks table - int negativeId; // track index in the Tracks table + int positiveId; // track index in the Tracks table + int negativeId; // track index in the Tracks table int mcParticleId; // mc particle index float pt; @@ -635,12 +635,12 @@ struct OnTheFlyTracker { negDauMass = o2::constants::physics::MassPionCharged; posDauMass = o2::constants::physics::MassPionCharged; ctau = 2.68; - } else if (std::abs(pdgCode) == kLambda0) { + } else if (pdgCode == kLambda0) { v0Mass = o2::constants::physics::MassLambda; negDauMass = o2::constants::physics::MassPionCharged; posDauMass = o2::constants::physics::MassProton; ctau = 7.845; - } else if (std::abs(pdgCode) == kLambda0Bar) { + } else if (pdgCode == kLambda0Bar) { v0Mass = o2::constants::physics::MassLambda; negDauMass = o2::constants::physics::MassProton; posDauMass = o2::constants::physics::MassPionCharged; @@ -751,10 +751,10 @@ struct OnTheFlyTracker { laDecayRadius2D = std::hypot(laDecayVertex[0], laDecayVertex[1]); } } - const bool isV0 = std::find(v0PDGs.begin(), v0PDGs.end(), std::abs(mcParticle.pdgCode())) != v0PDGs.end(); + const bool isV0 = std::find(v0PDGs.begin(), v0PDGs.end(), mcParticle.pdgCode()) != v0PDGs.end(); if (v0DecaySettings.decayV0 && isV0) { - decayV0Particle(mcParticle, v0DecayProducts, v0DecayVertex, std::abs(mcParticle.pdgCode())); + decayV0Particle(mcParticle, v0DecayProducts, v0DecayVertex, mcParticle.pdgCode()); v0DecayRadius2D = std::hypot(v0DecayVertex[0], v0DecayVertex[1]); } @@ -1246,8 +1246,8 @@ struct OnTheFlyTracker { if (mcParticle.pdgCode() == kLambda0) { thisV0.mLambda = RecoDecay::m(std::array{std::array{posP[0], posP[1], posP[2]}, std::array{negP[0], negP[1], negP[2]}}, - std::array{o2::constants::physics::MassPionCharged, - o2::constants::physics::MassProton}); + std::array{o2::constants::physics::MassProton, + o2::constants::physics::MassPionCharged}); } else { thisV0.mLambda = -1; } @@ -1255,17 +1255,23 @@ struct OnTheFlyTracker { if (mcParticle.pdgCode() == kLambda0Bar) { thisV0.mAntiLambda = RecoDecay::m(std::array{std::array{posP[0], posP[1], posP[2]}, std::array{negP[0], negP[1], negP[2]}}, - std::array{o2::constants::physics::MassProton, - o2::constants::physics::MassPionCharged}); + std::array{o2::constants::physics::MassPionCharged, + o2::constants::physics::MassProton}); } else { thisV0.mAntiLambda = -1; } if (v0DecaySettings.doV0QA) { fillHist(TH1, Form("V0Building_Configuration_%i/hV0Building", icfg), 4.0f); - fillHist(TH2, Form("V0Building_Configuration_%i/K0/hMass", icfg), thisV0.mK0, thisV0.pt); - fillHist(TH2, Form("V0Building_Configuration_%i/Lambda/hMass", icfg), thisV0.mLambda, thisV0.pt); - fillHist(TH2, Form("V0Building_Configuration_%i/AntiLambda/hMass", icfg), thisV0.mAntiLambda, thisV0.pt); + if (std::abs(mcParticle.pdgCode()) == kK0Short) { + fillHist(TH2, Form("V0Building_Configuration_%i/K0/hMass", icfg), thisV0.mK0, thisV0.pt); + } + if (mcParticle.pdgCode() == kLambda0) { + fillHist(TH2, Form("V0Building_Configuration_%i/Lambda/hMass", icfg), thisV0.mLambda, thisV0.pt); + } + if (mcParticle.pdgCode() == kLambda0Bar) { + fillHist(TH2, Form("V0Building_Configuration_%i/AntiLambda/hMass", icfg), thisV0.mAntiLambda, thisV0.pt); + } } // add this V0 to vector (will fill cursor later with collision ID) @@ -1277,6 +1283,9 @@ struct OnTheFlyTracker { if (doExtraQA) { histos.fill(HIST("hSimTrackX"), trackParCov.getX()); } + if (isV0) { + continue; // V0 handling done, should not be considered anymore + } bool reconstructed = true; if (enablePrimarySmearing && !fastPrimaryTrackerSettings.fastTrackPrimaries) { diff --git a/ALICE3/TableProducer/alice3-strangenessFinder.cxx b/ALICE3/TableProducer/alice3strangenessFinder.cxx similarity index 60% rename from ALICE3/TableProducer/alice3-strangenessFinder.cxx rename to ALICE3/TableProducer/alice3strangenessFinder.cxx index 29e05d5e7e7..0ecfa6ef7ab 100644 --- a/ALICE3/TableProducer/alice3-strangenessFinder.cxx +++ b/ALICE3/TableProducer/alice3strangenessFinder.cxx @@ -9,7 +9,7 @@ // granted to it by virtue of its status as an Intergovernmental Organization // or submit itself to any jurisdiction. -/// \file alice3-strangenessFinder.cxx +/// \file alice3strangenessFinder.cxx /// /// \brief finding of V0 and cascade candidates for ALICE 3 /// @@ -33,6 +33,7 @@ #include "Framework/runDataProcessing.h" #include "ReconstructionDataFormats/Track.h" #include +#include #include @@ -42,20 +43,42 @@ using namespace o2::framework; using namespace o2::constants::physics; using Alice3TracksWPid = soa::Join; -using Alice3Tracks = soa::Join; +using Alice3Tracks = soa::Join; -struct alice3strangenessFinder { +struct Alice3strangenessFinder { SliceCache cache; + HistogramRegistry histos{"histos", {}, OutputObjHandlingPolicy::AnalysisObject}; + Produces v0CandidateIndices; // contains V0 candidate indices Produces v0CandidateCores; // contains V0 candidate core information - Configurable mcSameMotherCheck{"mcSameMotherCheck", true, "check if tracks come from the same MC mother"}; - Configurable nSigmaTOF{"nSigmaTOF", 5.0f, "Nsigma for TOF PID (if enabled)"}; Configurable dcaXYconstant{"dcaXYconstant", -1.0f, "[0] in |DCAxy| > [0]+[1]/pT"}; Configurable dcaXYpTdep{"dcaXYpTdep", 0.0, "[1] in |DCAxy| > [0]+[1]/pT"}; + // Vertexing + Configurable propagateToPCA{"propagateToPCA", false, "create tracks version propagated to PCA"}; + Configurable useAbsDCA{"useAbsDCA", true, "Minimise abs. distance rather than chi2"}; + Configurable useWeightedFinalPCA{"useWeightedFinalPCA", false, "Recalculate vertex position using track covariances, effective only if useAbsDCA is true"}; + Configurable maxR{"maxR", 150., "reject PCA's above this radius"}; + Configurable maxDZIni{"maxDZIni", 5, "reject (if>0) PCA candidate if tracks DZ exceeds threshold"}; + Configurable maxDXYIni{"maxDXYIni", 4, "reject (if>0) PCA candidate if tracks DXY exceeds threshold"}; + Configurable maxVtxChi2{"maxVtxChi2", 2, "reject (if>0) vtx. chi2 above this value"}; + Configurable minParamChange{"minParamChange", 1.e-3, "stop iterations if largest change of any X is smaller than this"}; + Configurable minRelChi2Change{"minRelChi2Change", 0.9, "stop iterations is chi2/chi2old > this"}; + // Operation and minimisation criteria + Configurable magneticField{"magneticField", 20.0f, "Magnetic field (in kilogauss)"}; + Configurable doDCAplotsD{"doDCAplotsD", true, "do daughter prong DCA plots for D mesons"}; + Configurable doDCAplots3Prong{"doDCAplots3Prong", true, "do daughter prong DCA plots for Lc baryons"}; + Configurable doTopoPlotsForSAndB{"doTopoPlotsForSAndB", true, "do topological variable distributions for S and B separately"}; + Configurable dcaDaughtersSelection{"dcaDaughtersSelection", 1000.0f, "DCA between daughters (cm)"}; + Configurable mcSameMotherCheck{"mcSameMotherCheck", true, "check if tracks come from the same MC mother"}; + // propagation options + Configurable usePropagator{"usePropagator", false, "use external propagator"}; + Configurable refitWithMatCorr{"refitWithMatCorr", false, "refit V0 applying material corrections"}; + Configurable useCollinearV0{"useCollinearV0", true, "use collinear approximation for V0 fitting"}; + o2::vertexing::DCAFitterN<2> fitter; o2::vertexing::DCAFitterN<3> fitter3; @@ -72,9 +95,9 @@ struct alice3strangenessFinder { struct { float dcaDau; std::array posSV; - std::array P; - std::array Pdaug; // positive track - std::array Ndaug; // negative track + std::array pV0; + std::array pPos; // positive track + std::array pNeg; // negative track float cosPA; float dcaToPV; } v0cand; @@ -82,6 +105,21 @@ struct alice3strangenessFinder { void init(InitContext&) { // Initialization code here + fitter.setBz(magneticField); + fitter.setUseAbsDCA(useAbsDCA); + fitter.setPropagateToPCA(propagateToPCA); + fitter.setMaxR(maxR); + fitter.setMinParamChange(minParamChange); + fitter.setMinRelChi2Change(minRelChi2Change); + fitter.setMaxDZIni(maxDZIni); + fitter.setMaxDXYIni(maxDXYIni); + fitter.setMaxChi2(maxVtxChi2); + fitter.setUsePropagator(usePropagator); + fitter.setRefitWithMatCorr(refitWithMatCorr); + fitter.setCollinear(useCollinearV0); + fitter.setMatCorrType(o2::base::Propagator::MatCorrType::USEMatCorrNONE); + + histos.add("hV0Counter", "", kTH1D, {{4, 0, 4}}); // For QA reasons, counting found V0, 0: K0s, 1: Lambda, 2:AntiLambda, 3: wrongly identified V0 } /// function to check if tracks have the same mother in MC template @@ -92,14 +130,8 @@ struct alice3strangenessFinder { return sameMother; auto mcParticle1 = track1.template mcParticle_as(); auto mcParticle2 = track2.template mcParticle_as(); - if (!mcParticle1.has_mothers() || !mcParticle2.has_mothers()) - return sameMother; - for (auto& mcParticleMother1 : mcParticle1.template mothers_as()) { - for (auto& mcParticleMother2 : mcParticle2.template mothers_as()) { - if (mcParticleMother1.globalIndex() == mcParticleMother2.globalIndex()) { - sameMother = true; - } - } + if (mcParticle2.globalIndex() == mcParticle1.globalIndex()) { // for the V0 daughters we store the mc label of the mother particle in the daughter tracks + sameMother = true; } return sameMother; } @@ -122,6 +154,10 @@ struct alice3strangenessFinder { return false; } //}-{}-{}-{}-{}-{}-{}-{}-{}-{} + if (!fitter.isPropagateTracksToVertexDone() && !fitter.propagateTracksToVertex()) { + LOG(debug) << "RejProp failed"; + return false; + } posTrackCov = fitter.getTrack(0); negTrackCov = fitter.getTrack(1); @@ -129,24 +165,24 @@ struct alice3strangenessFinder { std::array negP; posTrackCov.getPxPyPzGlo(posP); negTrackCov.getPxPyPzGlo(negP); - v0cand.dcaDau = TMath::Sqrt(fitter.getChi2AtPCACandidate()); - v0cand.Pdaug[0] = posP[0]; - v0cand.Pdaug[1] = posP[1]; - v0cand.Pdaug[2] = posP[2]; - v0cand.Ndaug[0] = negP[0]; - v0cand.Ndaug[1] = negP[1]; - v0cand.Ndaug[2] = negP[2]; - v0cand.P[0] = posP[0] + negP[0]; - v0cand.P[1] = posP[1] + negP[1]; - v0cand.P[2] = posP[2] + negP[2]; - const auto posSV = fitter.getPCACandidate(); + v0cand.dcaDau = std::sqrt(fitter.getChi2AtPCACandidate()); + v0cand.pPos[0] = posP[0]; + v0cand.pPos[1] = posP[1]; + v0cand.pPos[2] = posP[2]; + v0cand.pNeg[0] = negP[0]; + v0cand.pNeg[1] = negP[1]; + v0cand.pNeg[2] = negP[2]; + v0cand.pV0[0] = posP[0] + negP[0]; + v0cand.pV0[1] = posP[1] + negP[1]; + v0cand.pV0[2] = posP[2] + negP[2]; + const auto posSV = fitter.getPCACandidatePos(); v0cand.posSV[0] = posSV[0]; v0cand.posSV[1] = posSV[1]; v0cand.posSV[2] = posSV[2]; return true; } - float CalculateDCAStraightToPV(float X, float Y, float Z, float Px, float Py, float Pz, float pvX, float pvY, float pvZ) + float calculateDCAStraightToPV(float X, float Y, float Z, float Px, float Py, float Pz, float pvX, float pvY, float pvZ) { return std::sqrt((std::pow((pvY - Y) * Pz - (pvZ - Z) * Py, 2) + std::pow((pvX - X) * Pz - (pvZ - Z) * Px, 2) + std::pow((pvX - X) * Py - (pvY - Y) * Px, 2)) / (Px * Px + Py * Py + Pz * Pz)); } @@ -156,26 +192,43 @@ struct alice3strangenessFinder { auto positiveSecondaryTracksGrouped = positiveSecondaryTracks->sliceByCached(aod::track::collisionId, collision.globalIndex(), cache); for (auto const& posTrack : positiveSecondaryTracksGrouped) { + if (!posTrack.isReconstructed()) { + continue; // no ghost tracks + } for (auto const& negTrack : negativeSecondaryTracksGrouped) { + if (!negTrack.isReconstructed()) { + continue; // no ghost tracks + } + auto mcParticle1 = posTrack.template mcParticle_as(); if (mcSameMotherCheck && !checkSameMother(posTrack, negTrack)) continue; if (!buildDecayCandidateTwoBody(posTrack, negTrack)) continue; - v0cand.cosPA = RecoDecay::cpa(std::array{collision.posX(), collision.posY(), collision.posZ()}, std::array{v0cand.posSV[0], v0cand.posSV[1], v0cand.posSV[2]}, std::array{v0cand.P[0], v0cand.P[1], v0cand.P[2]}); - v0cand.dcaToPV = CalculateDCAStraightToPV( + v0cand.cosPA = RecoDecay::cpa(std::array{collision.posX(), collision.posY(), collision.posZ()}, std::array{v0cand.posSV[0], v0cand.posSV[1], v0cand.posSV[2]}, std::array{v0cand.pV0[0], v0cand.pV0[1], v0cand.pV0[2]}); + v0cand.dcaToPV = calculateDCAStraightToPV( v0cand.posSV[0], v0cand.posSV[1], v0cand.posSV[2], - v0cand.P[0], v0cand.P[1], v0cand.P[2], + v0cand.pV0[0], v0cand.pV0[1], v0cand.pV0[2], collision.posX(), collision.posY(), collision.posZ()); v0CandidateIndices(collision.globalIndex(), posTrack.globalIndex(), - negTrack.globalIndex()); + negTrack.globalIndex(), + mcParticle1.globalIndex()); v0CandidateCores( v0cand.posSV[0], v0cand.posSV[1], v0cand.posSV[2], - v0cand.Pdaug[0], v0cand.Pdaug[1], v0cand.Pdaug[2], - v0cand.Ndaug[0], v0cand.Ndaug[1], v0cand.Ndaug[2], + v0cand.pPos[0], v0cand.pPos[1], v0cand.pPos[2], + v0cand.pNeg[0], v0cand.pNeg[1], v0cand.pNeg[2], v0cand.dcaDau, posTrack.dcaXY(), negTrack.dcaXY(), v0cand.cosPA, v0cand.dcaToPV); + if (mcParticle1.pdgCode() == kK0Short) { + histos.fill(HIST("hV0Counter"), 0.5); + } else if (mcParticle1.pdgCode() == kLambda0) { + histos.fill(HIST("hV0Counter"), 1.5); + } else if (mcParticle1.pdgCode() == kLambda0Bar) { + histos.fill(HIST("hV0Counter"), 2.5); + } else { + histos.fill(HIST("hV0Counter"), 3.5); + } } } } @@ -186,12 +239,12 @@ struct alice3strangenessFinder { // auto secondaryProtonsGrouped = secondaryProtons->sliceByCached(aod::track::collisionId, collision.globalIndex(), cache); // auto secondaryAntiProtonsGrouped = secondaryAntiProtons->sliceByCached(aod::track::collisionId, collision.globalIndex(), cache); // } - PROCESS_SWITCH(alice3strangenessFinder, processFindV0CandidateNoPid, "find V0 without PID", true); + PROCESS_SWITCH(Alice3strangenessFinder, processFindV0CandidateNoPid, "find V0 without PID", true); // PROCESS_SWITCH(alice3strangenessFinder, processFindV0CandidateWithPid, "find V0 with PID", false); }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{ - adaptAnalysisTask(cfgc)}; + adaptAnalysisTask(cfgc)}; } diff --git a/ALICE3/Tasks/CMakeLists.txt b/ALICE3/Tasks/CMakeLists.txt index f1158275ec8..8ae02abe6c7 100644 --- a/ALICE3/Tasks/CMakeLists.txt +++ b/ALICE3/Tasks/CMakeLists.txt @@ -84,8 +84,8 @@ o2physics_add_dpl_workflow(alice3-pid-evaluation PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore COMPONENT_NAME Analysis) -o2physics_add_dpl_workflow(alice3-strangeness - SOURCES alice3-strangeness.cxx +o2physics_add_dpl_workflow(alice3strangeness + SOURCES alice3Strangeness.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore COMPONENT_NAME Analysis) diff --git a/ALICE3/Tasks/alice3-strangeness.cxx b/ALICE3/Tasks/alice3Strangeness.cxx similarity index 80% rename from ALICE3/Tasks/alice3-strangeness.cxx rename to ALICE3/Tasks/alice3Strangeness.cxx index b46c4b22add..83dd10b9776 100644 --- a/ALICE3/Tasks/alice3-strangeness.cxx +++ b/ALICE3/Tasks/alice3Strangeness.cxx @@ -9,7 +9,7 @@ // granted to it by virtue of its status as an Intergovernmental Organization // or submit itself to any jurisdiction. /// -/// \file alice3-strangeness.cxx +/// \file alice3Strangeness.cxx /// /// \brief This task produces invariant mass distributions for strange hadrons /// @@ -34,19 +34,15 @@ #include #include #include -#include -#include #include #include #include #include -#include #include #include #include #include -#include #include #include @@ -59,11 +55,11 @@ using namespace o2; using namespace o2::framework; using namespace o2::constants::math; -using alice3tracks = soa::Join; -using fullV0Candidates = soa::Join; -using fullCollisions = soa::Join; +using Alice3tracks = soa::Join; +using FullV0Candidates = soa::Join; +using FullCollisions = soa::Join; -struct alice3strangeness { +struct Alice3Strangeness { HistogramRegistry histos{"histos", {}, OutputObjHandlingPolicy::AnalysisObject}; Configurable idGeometry{"idGeometry", 0, "geometry ID used for propagation"}; @@ -83,15 +79,16 @@ struct alice3strangeness { struct : ConfigurableGroup { std::string prefix = "selectionFlags"; Configurable applyRapiditySelection{"applyRapiditySelection", true, "apply rapidity selection"}; - Configurable applyDCAdaughterSelection{"applyDCADaughterSelection", true, "apply DCA daughter selection"}; + Configurable applyDCAdaughterSelection{"applyDCAdaughterSelection", true, "apply DCA daughter selection"}; Configurable applyCosOfPAngleSelection{"applyCosOfPAngleSelection", true, "apply cosine of pointing angle selection"}; - Configurable applyDCAdaughtersToPVSelection{"applyDCADaughtersToPVSelection", true, "apply DCA daughters to primary vertex selection"}; + Configurable applyDCADaughtersToPVSelection{"applyDCADaughtersToPVSelection", true, "apply DCA daughters to primary vertex selection"}; Configurable applyV0RadiusSelection{"applyV0RadiusSelection", true, "apply V0 radius selection"}; Configurable applyArmenterosSelection{"applyArmenterosSelection", true, "apply Armenteros-Podolanski selection"}; Configurable applyCompetingMassRejection{"applyCompetingMassRejection", true, "apply competing mass rejection"}; Configurable applyLifetimeSelection{"applyLifetimeSelection", true, "apply lifetime selection"}; Configurable applyEtaDaughterSelection{"applyEtaDaughterSelection", true, "apply eta daughter selection"}; Configurable doQAforSelectionVariables{"doQAforSelectionVariables", false, "enable QA plots"}; + Configurable analyseOnlyTrueV0s{"analyseOnlyTrueV0s", false, "analyse only true V0s from MC"}; } selectionFlags; struct : ConfigurableGroup { @@ -108,12 +105,15 @@ struct alice3strangeness { Configurable lifetimecutambda{"lifetimecutambda", 30, "lifetime cut for Lambda in cm"}; Configurable lifetimecutak0{"lifetimecutak0", 20, "lifetime cut for K0 in cm"}; Configurable etaDaughterSelection{"etaDaughterSelection", 0.8f, "eta daughter selection"}; + Configurable acceptedLambdaMassWindow{"acceptedLambdaMassWindow", 0.2f, "accepted Lambda mass window around PDG mass"}; + Configurable acceptedK0MassWindow{"acceptedK0MassWindow", 0.3f, "accepted K0 mass window around PDG mass"}; } selectionValues; - uint16_t AppliedSelectionCheckMask; + uint16_t appliedSelectionCheckMask; double selectionCheck; double selectionCheckPos; - static constexpr std::string_view kSelectionNames[] = {"DCAV0Daughters", "PointingAngle", "DCAtoPVNegDaughter", "DCAtoPVPosDaughter", "V0Radius", "ProperLifeTime"}; + const int posDaugDCAselIDx = 3; + static constexpr std::string_view KSelectionNames[] = {"DCAV0Daughters", "PointingAngle", "DCAtoPVNegDaughter", "DCAtoPVPosDaughter", "V0Radius", "ProperLifeTime"}; void init(InitContext&) { @@ -126,11 +126,13 @@ struct alice3strangeness { histos.add("hV0CandidateCounter", "hV0CandidateCounter", kTH1F, {{11, 0, 11}}); histos.add("reconstructedCandidates/hEtaDaughters", "hEtaDaughters", kTH1F, {histAxes.axisEta}); histos.add("reconstructedCandidates/K0/hMass", "hMass", kTH3D, {histAxes.axisK0Mass, histAxes.axisPt, histAxes.axisEta}); + histos.add("reconstructedCandidates/K0/hMass1D", "hMass1D", kTH1D, {histAxes.axisK0Mass}); histos.add("reconstructedCandidates/Lambda/hMass", "hMass", kTH3D, {histAxes.axisLambdaMass, histAxes.axisPt, histAxes.axisEta}); - histos.add("reconstructedCandidates/hArmeterosBeforeAllSelections", "hArmeterosBeforeAllSelections", kTH2D, {{100, -1.0f, 1.0f}, {100, 0.0f, 0.25f}}); - histos.add("reconstructedCandidates/hArmeterosAfterAllSelections", "hArmeterosAfterAllSelections", kTH2D, {{100, -1.0f, 1.0f}, {100, 0.0f, 0.25f}}); + histos.add("reconstructedCandidates/Lambda/hMass1D", "hMass1D", kTH1D, {histAxes.axisLambdaMass}); + histos.add("reconstructedCandidates/hArmeterosBeforeAllSelections", "hArmeterosBeforeAllSelections", kTH2D, {{100, -1.0f, 1.0f}, {200, 0.0f, 0.5f}}); + histos.add("reconstructedCandidates/hArmeterosAfterAllSelections", "hArmeterosAfterAllSelections", kTH2D, {{100, -1.0f, 1.0f}, {200, 0.0f, 0.5f}}); if (selectionFlags.doQAforSelectionVariables) { - if (!selectionFlags.applyDCAdaughtersToPVSelection) { + if (!selectionFlags.applyDCADaughtersToPVSelection) { histos.add("reconstructedCandidates/K0/hDCAtoPVNegDaughter", "hDCAtoPVNegDaughter", kTH3D, {histAxes.axisK0Mass, histAxes.axisPt, histAxes.axisDCA}); histos.add("reconstructedCandidates/K0/hDCAtoPVPosDaughter", "hDCAtoPVPosDaughter", kTH3D, {histAxes.axisK0Mass, histAxes.axisPt, histAxes.axisDCA}); histos.add("reconstructedCandidates/Lambda/hDCAtoPVNegDaughter", "hDCAtoPVNegDaughter", kTH3D, {histAxes.axisLambdaMass, histAxes.axisPt, histAxes.axisDCA}); @@ -155,32 +157,30 @@ struct alice3strangeness { } histos.addClone("reconstructedCandidates/Lambda/", "reconstructedCandidates/AntiLambda/"); - AppliedSelectionCheckMask = 0; + appliedSelectionCheckMask = 0; if (!selectionFlags.applyDCAdaughterSelection) - SETBIT(AppliedSelectionCheckMask, 0); + SETBIT(appliedSelectionCheckMask, 0); if (!selectionFlags.applyCosOfPAngleSelection) - SETBIT(AppliedSelectionCheckMask, 1); - if (!selectionFlags.applyDCAdaughtersToPVSelection) { - SETBIT(AppliedSelectionCheckMask, 2); - SETBIT(AppliedSelectionCheckMask, 3); + SETBIT(appliedSelectionCheckMask, 1); + if (!selectionFlags.applyDCADaughtersToPVSelection) { + SETBIT(appliedSelectionCheckMask, 2); + SETBIT(appliedSelectionCheckMask, 3); } if (!selectionFlags.applyV0RadiusSelection) - SETBIT(AppliedSelectionCheckMask, 4); + SETBIT(appliedSelectionCheckMask, 4); if (!selectionFlags.applyLifetimeSelection) - SETBIT(AppliedSelectionCheckMask, 5); + SETBIT(appliedSelectionCheckMask, 5); } - long int nEvents = 0; - void processAllFindableCandidates(aod::Collisions const& collisions, aod::McCollisions const& mcCollisions, aod::UpgradeV0s const& v0Recos, alice3tracks const&) + void processAllFindableCandidates(aod::Collisions const& collisions, aod::McCollisions const&, aod::UpgradeV0s const& v0Recos, Alice3tracks const&) { - LOG(info) << "Event processed " << nEvents++ << " :" << collisions.size() << " " << mcCollisions.size(); for (const auto& collision : collisions) { float collisionZ = collision.posZ(); // std::cout << "______ process V0_______" << collision.size() << std::endl; histos.fill(HIST("hPVz"), collisionZ); for (const auto& v0Cand : v0Recos) { - auto negV0Daughter = v0Cand.negTrack_as(); // de-reference neg track - auto posV0Daughter = v0Cand.posTrack_as(); // de-reference pos track + auto negV0Daughter = v0Cand.negTrack_as(); // de-reference neg track + auto posV0Daughter = v0Cand.posTrack_as(); // de-reference pos track bool isK0 = v0Cand.mK0() > 0; if (isK0) { @@ -188,19 +188,19 @@ struct alice3strangeness { histos.fill(HIST("K0/hSelections"), 0); // all candidates histos.fill(HIST("K0/hDCANegDaughter"), negV0Daughter.dcaXY()); histos.fill(HIST("K0/hDCAPosDaughter"), posV0Daughter.dcaXY()); - if (std::abs(negV0Daughter.dcaXY()) < 0.05) + if (std::abs(negV0Daughter.dcaXY()) < selectionValues.dcaDaughtersToPVSelection) continue; histos.fill(HIST("K0/hSelections"), 1); // dcaXY cut - if (std::abs(posV0Daughter.dcaXY()) < 0.05) + if (std::abs(posV0Daughter.dcaXY()) < selectionValues.dcaDaughtersToPVSelection) continue; histos.fill(HIST("K0/hSelections"), 2); // dcaXY cut - if (v0Cand.dcaV0Daughters() > 1.0) + if (v0Cand.dcaV0Daughters() > selectionValues.dcaDaughterSelection) continue; histos.fill(HIST("K0/hSelections"), 3); // dca between daughters - if (v0Cand.v0Radius() < 0.5) + if (v0Cand.v0Radius() < selectionValues.v0RadiusSelection) continue; histos.fill(HIST("K0/hSelections"), 4); // radius cut - if (std::abs(negV0Daughter.eta()) > 0.8 || std::abs(posV0Daughter.eta()) > 0.8) + if (std::abs(negV0Daughter.eta()) > selectionValues.etaDaughterSelection || std::abs(posV0Daughter.eta()) > selectionValues.etaDaughterSelection) continue; histos.fill(HIST("K0/hSelections"), 5); // eta cut histos.fill(HIST("K0/hMassSelected"), v0Cand.mK0(), v0Cand.pt()); @@ -208,21 +208,21 @@ struct alice3strangeness { } } } - void processFoundV0Candidates(aod::Collision const& collision, fullV0Candidates const& v0Candidates, alice3tracks const&) + void processFoundV0Candidates(aod::Collision const& collision, FullV0Candidates const& v0Candidates, Alice3tracks const&, aod::McParticles const&) { // if(collision.lutConfigId()!=idGeometry) // return; for (auto const& v0 : v0Candidates) { - bool isK0 = (v0.mK0Short() - o2::constants::physics::MassK0Short) < 0.3; - bool isLambda = (v0.mLambda() - o2::constants::physics::MassLambda0) < 0.2; - bool isAntiLambda = (v0.mAntiLambda() - o2::constants::physics::MassLambda0) < 0.2; + bool isK0 = (v0.mK0Short() - o2::constants::physics::MassK0Short) < selectionValues.acceptedK0MassWindow; + bool isLambda = (v0.mLambda() - o2::constants::physics::MassLambda0) < selectionValues.acceptedLambdaMassWindow; + bool isAntiLambda = (v0.mAntiLambda() - o2::constants::physics::MassLambda0) < selectionValues.acceptedLambdaMassWindow; - histos.fill(HIST("reconstructedCandidates/hArmeterosBeforeAllSelections"), v0.alpha(), v0.qtarm()); + histos.fill(HIST("reconstructedCandidates/hArmeterosBeforeAllSelections"), v0.alpha(), v0.qtArm()); histos.fill(HIST("hV0CandidateCounter"), 0.5); if (selectionFlags.applyRapiditySelection) { if (isK0 && std::abs(v0.yK0Short()) > selectionValues.yK0Selection) continue; - if ((isLambda || isAntiLambda) && std::abs(v0.yLambda()) < selectionValues.yLambdaSelection) + if ((isLambda || isAntiLambda) && std::abs(v0.yLambda()) > selectionValues.yLambdaSelection) continue; } histos.fill(HIST("hV0CandidateCounter"), 1.5); @@ -240,7 +240,7 @@ struct alice3strangeness { selectionCheck = std::acos(v0.cosPA()); } histos.fill(HIST("hV0CandidateCounter"), 3.5); - if (selectionFlags.applyDCAdaughtersToPVSelection) { + if (selectionFlags.applyDCADaughtersToPVSelection) { if ((std::abs(v0.dcaNegToPV()) < selectionValues.dcaDaughtersToPVSelection) || (std::abs(v0.dcaPosToPV()) < selectionValues.dcaDaughtersToPVSelection)) continue; @@ -258,7 +258,7 @@ struct alice3strangeness { histos.fill(HIST("hV0CandidateCounter"), 5.5); if (isK0) { if (selectionFlags.applyArmenterosSelection) { - if (v0.qtarm() < selectionValues.armenterosSelection * std::abs(v0.alpha())) + if (v0.qtArm() < selectionValues.armenterosSelection * std::abs(v0.alpha())) continue; } } @@ -275,19 +275,19 @@ struct alice3strangeness { } histos.fill(HIST("hV0CandidateCounter"), 7.5); if (selectionFlags.applyLifetimeSelection) { - if (isK0 && v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * o2::constants::physics::MassK0Short < selectionValues.lifetimecutak0) + if (isK0 && v0.distOverTotMom(collision.posX(), collision.posY(), collision.posZ()) * o2::constants::physics::MassK0Short > selectionValues.lifetimecutak0) continue; - if ((isLambda || isAntiLambda) && v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * o2::constants::physics::MassLambda0 < selectionValues.lifetimecutambda) + if ((isLambda || isAntiLambda) && v0.distOverTotMom(collision.posX(), collision.posY(), collision.posZ()) * o2::constants::physics::MassLambda0 > selectionValues.lifetimecutambda) continue; } else { if (isK0) - selectionCheck = v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * o2::constants::physics::MassK0Short; + selectionCheck = v0.distOverTotMom(collision.posX(), collision.posY(), collision.posZ()) * o2::constants::physics::MassK0Short; else - selectionCheck = v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * o2::constants::physics::MassLambda0; + selectionCheck = v0.distOverTotMom(collision.posX(), collision.posY(), collision.posZ()) * o2::constants::physics::MassLambda0; } histos.fill(HIST("hV0CandidateCounter"), 8.5); - auto posTrack = v0.template posTrack_as(); - auto negTrack = v0.template negTrack_as(); + auto posTrack = v0.template posTrack_as(); + auto negTrack = v0.template negTrack_as(); if (selectionFlags.applyEtaDaughterSelection) { if (std::abs(posTrack.eta()) > selectionValues.etaDaughterSelection || std::abs(negTrack.eta()) > selectionValues.etaDaughterSelection) continue; @@ -296,36 +296,42 @@ struct alice3strangeness { histos.fill(HIST("reconstructedCandidates/hEtaDaughters"), negTrack.eta()); histos.fill(HIST("hV0CandidateCounter"), 9.5); - histos.fill(HIST("reconstructedCandidates/hArmeterosAfterAllSelections"), v0.alpha(), v0.qtarm()); + histos.fill(HIST("reconstructedCandidates/hArmeterosAfterAllSelections"), v0.alpha(), v0.qtArm()); if (selectionFlags.doQAforSelectionVariables) { static_for<0, 5>([&](auto i) { constexpr int In = i.value; - if (TESTBIT(AppliedSelectionCheckMask, In)) { - if (In == 3) + if (TESTBIT(appliedSelectionCheckMask, In)) { + if (In == posDaugDCAselIDx) selectionCheck = selectionCheckPos; if (isK0) - histos.fill(HIST("reconstructedCandidates/K0/h") + HIST(kSelectionNames[In]), v0.mK0Short(), v0.pt(), selectionCheck); + histos.fill(HIST("reconstructedCandidates/K0/h") + HIST(KSelectionNames[In]), v0.mK0Short(), v0.pt(), selectionCheck); if (isLambda) - histos.fill(HIST("reconstructedCandidates/Lambda/h") + HIST(kSelectionNames[In]), v0.mLambda(), v0.pt(), selectionCheck); + histos.fill(HIST("reconstructedCandidates/Lambda/h") + HIST(KSelectionNames[In]), v0.mLambda(), v0.pt(), selectionCheck); if (isAntiLambda) - histos.fill(HIST("reconstructedCandidates/AntiLambda/h") + HIST(kSelectionNames[In]), v0.mAntiLambda(), v0.pt(), selectionCheck); + histos.fill(HIST("reconstructedCandidates/AntiLambda/h") + HIST(KSelectionNames[In]), v0.mAntiLambda(), v0.pt(), selectionCheck); } }); } - if (isK0) + if (isK0) { histos.fill(HIST("reconstructedCandidates/K0/hMass"), v0.mK0Short(), v0.pt(), v0.eta()); - if (isLambda) + histos.fill(HIST("reconstructedCandidates/K0/hMass1D"), v0.mK0Short()); + } + if (isLambda) { histos.fill(HIST("reconstructedCandidates/Lambda/hMass"), v0.mLambda(), v0.pt(), v0.eta()); - if (isAntiLambda) + histos.fill(HIST("reconstructedCandidates/Lambda/hMass1D"), v0.mLambda()); + } + if (isAntiLambda) { histos.fill(HIST("reconstructedCandidates/AntiLambda/hMass"), v0.mAntiLambda(), v0.pt(), v0.eta()); + histos.fill(HIST("reconstructedCandidates/AntiLambda/hMass1D"), v0.mAntiLambda()); + } } } - PROCESS_SWITCH(alice3strangeness, processAllFindableCandidates, "", false); - PROCESS_SWITCH(alice3strangeness, processFoundV0Candidates, "", true); + PROCESS_SWITCH(Alice3Strangeness, processAllFindableCandidates, "", false); + PROCESS_SWITCH(Alice3Strangeness, processFoundV0Candidates, "", true); }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{ - adaptAnalysisTask(cfgc)}; + adaptAnalysisTask(cfgc)}; }