From 1c19aae2b21bef308e31d3d082f1020586cc2bdb Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Thu, 24 Apr 2025 18:05:18 +0000 Subject: [PATCH] Please consider the following formatting changes --- PWGLF/DataModel/LFSigmaTables.h | 4 +- .../Strangeness/sigma0builder.cxx | 272 +++--- PWGLF/Tasks/Strangeness/sigmaanalysis.cxx | 812 +++++++++--------- 3 files changed, 539 insertions(+), 549 deletions(-) diff --git a/PWGLF/DataModel/LFSigmaTables.h b/PWGLF/DataModel/LFSigmaTables.h index c5a3d7adac2..0980b6891ad 100644 --- a/PWGLF/DataModel/LFSigmaTables.h +++ b/PWGLF/DataModel/LFSigmaTables.h @@ -47,7 +47,7 @@ DECLARE_SOA_TABLE(Sigma0Cores, "AOD", "SIGMA0CORES", sigma0Core::SigmaOPAngle, sigma0Core::SigmaCentrality, sigma0Core::SigmaRunNumber, - sigma0Core::SigmaTimestamp, + sigma0Core::SigmaTimestamp, sigma0Core::SigmaIR); // For Photon extra info @@ -123,7 +123,7 @@ DECLARE_SOA_TABLE(SigmaPhotonExtras, "AOD", "SIGMA0PHOTON", sigmaPhotonExtra::PhotonNegITSChi2PerNcl, sigmaPhotonExtra::PhotonPosTrackCode, sigmaPhotonExtra::PhotonNegTrackCode, - sigmaPhotonExtra::PhotonV0Type, + sigmaPhotonExtra::PhotonV0Type, sigmaPhotonExtra::GammaBDTScore); // For Lambda extra info diff --git a/PWGLF/TableProducer/Strangeness/sigma0builder.cxx b/PWGLF/TableProducer/Strangeness/sigma0builder.cxx index 59428ce894e..fba55d86389 100644 --- a/PWGLF/TableProducer/Strangeness/sigma0builder.cxx +++ b/PWGLF/TableProducer/Strangeness/sigma0builder.cxx @@ -77,10 +77,10 @@ struct sigma0builder { // pack track quality but separte also afterburner // dynamic range: 0-31 enum selection : int { hasTPC = 0, - hasITSTracker, - hasITSAfterburner, - hasTRD, - hasTOF }; + hasITSTracker, + hasITSAfterburner, + hasTRD, + hasTOF }; // Histogram registry HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; @@ -93,7 +93,7 @@ struct sigma0builder { // Event level Configurable doPPAnalysis{"doPPAnalysis", true, "if in pp, set to true"}; Configurable fGetIR{"fGetIR", false, "Flag to retrieve the IR info."}; - Configurable fIRCrashOnNull{"fIRCrashOnNull", false, "Flag to avoid CTP RateFetcher crash."}; + Configurable fIRCrashOnNull{"fIRCrashOnNull", false, "Flag to avoid CTP RateFetcher crash."}; Configurable irSource{"irSource", "T0VTX", "Estimator of the interaction rate (Recommended: pp --> T0VTX, Pb-Pb --> ZNC hadronic)"}; struct : ConfigurableGroup { @@ -165,7 +165,7 @@ struct sigma0builder { // Axis // base properties ConfigurableAxis axisPt{"axisPt", {VARIABLE_WIDTH, 0.0f, 0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f, 1.1f, 1.2f, 1.3f, 1.4f, 1.5f, 1.6f, 1.7f, 1.8f, 1.9f, 2.0f, 2.2f, 2.4f, 2.6f, 2.8f, 3.0f, 3.2f, 3.4f, 3.6f, 3.8f, 4.0f, 4.4f, 4.8f, 5.2f, 5.6f, 6.0f, 6.5f, 7.0f, 7.5f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 30.0f, 35.0f, 40.0f, 50.0f}, "pt axis for analysis"}; - ConfigurableAxis axisCentrality{"axisCentrality", {VARIABLE_WIDTH, 0.0f, 5.0f, 10.0f, 20.0f, 30.0f, 40.0f, 50.0f, 60.0f, 70.0f, 80.0f, 90.0f, 100.0f, 110.0f}, "Centrality"}; + ConfigurableAxis axisCentrality{"axisCentrality", {VARIABLE_WIDTH, 0.0f, 5.0f, 10.0f, 20.0f, 30.0f, 40.0f, 50.0f, 60.0f, 70.0f, 80.0f, 90.0f, 100.0f, 110.0f}, "Centrality"}; // Invariant Mass ConfigurableAxis axisSigmaMass{"axisSigmaMass", {500, 1.10f, 1.30f}, "M_{#Sigma^{0}} (GeV/c^{2})"}; @@ -274,7 +274,7 @@ struct sigma0builder { histos.add("SigmaSel/hSigmaMassSelected", "hSigmaMassSelected", kTH1F, {axisSigmaMass}); histos.add("SigmaSel/h3dMassSigma0AfterSel", "h3dMassSigma0AfterSel", kTH3F, {axisCentrality, axisPt, axisSigmaMass}); - if (fillQAhistos){ + if (fillQAhistos) { histos.add("GeneralQA/h2dMassGammaVsK0S", "h2dMassGammaVsK0S", kTH2D, {axisPhotonMass, axisK0SMass}); histos.add("GeneralQA/h2dMassLambdaVsK0S", "h2dMassLambdaVsK0S", kTH2D, {axisLambdaMass, axisK0SMass}); histos.add("GeneralQA/h2dMassGammaVsLambda", "h2dMassGammaVsLambda", kTH2D, {axisPhotonMass, axisLambdaMass}); @@ -286,13 +286,13 @@ struct sigma0builder { histos.add("GeneralQA/h2dV0XY", "h2dV0XY", kTH2F, {axisXY, axisXY}); } - if (fGetIR){ + if (fGetIR) { histos.add("GeneralQA/hRunNumberNegativeIR", "", kTH1D, {{1, 0., 1.}}); histos.add("GeneralQA/hInteractionRate", "hInteractionRate", kTH1F, {axisIRBinning}); histos.add("GeneralQA/hCentralityVsInteractionRate", "hCentralityVsInteractionRate", kTH2F, {axisCentrality, axisIRBinning}); } - if (doAssocStudy && doprocessMonteCarlo){ + if (doAssocStudy && doprocessMonteCarlo) { histos.add("V0AssoQA/h2dIRVsPt_TrueGamma", "h2dIRVsPt_TrueGamma", kTH2F, {axisIRBinning, axisPt}); histos.add("V0AssoQA/h3dPAVsIRVsPt_TrueGamma", "h3dPAVsIRVsPt_TrueGamma", kTH3F, {axisPA, axisIRBinning, axisPt}); histos.add("V0AssoQA/h2dIRVsPt_TrueGamma_BadCollAssig", "h2dIRVsPt_TrueGamma_BadCollAssig", kTH2F, {axisIRBinning, axisPt}); @@ -303,9 +303,9 @@ struct sigma0builder { histos.add("V0AssoQA/h2dIRVsPt_TrueLambda_BadCollAssig", "h2dIRVsPt_TrueLambda_BadCollAssig", kTH2F, {axisIRBinning, axisPt}); histos.add("V0AssoQA/h3dPAVsIRVsPt_TrueLambda_BadCollAssig", "h3dPAVsIRVsPt_TrueLambda_BadCollAssig", kTH3F, {axisPA, axisIRBinning, axisPt}); } - + // MC - if (doprocessMonteCarlo){ + if (doprocessMonteCarlo) { histos.add("MC/h2dPtVsCentralityBeforeSel_MCAssocGamma", "h2dPtVsCentralityBeforeSel_MCAssocGamma", kTH2D, {axisCentrality, axisPt}); histos.add("MC/h2dPtVsCentralityBeforeSel_MCAssocLambda", "h2dPtVsCentralityBeforeSel_MCAssocLambda", kTH2D, {axisCentrality, axisPt}); histos.add("MC/h2dPtVsCentralityBeforeSel_MCAssocALambda", "h2dPtVsCentralityBeforeSel_MCAssocALambda", kTH2D, {axisCentrality, axisPt}); @@ -317,9 +317,9 @@ struct sigma0builder { histos.add("MC/h2dPtVsCentralityAfterSel_MCAssocASigma0", "h2dPtVsCentralityAfterSel_MCAssocASigma0", kTH2D, {axisCentrality, axisPt}); histos.add("MC/h2dGammaXYConversion", "h2dGammaXYConversion", kTH2F, {axisXY, axisXY}); } - + // For background decomposition - if (fillBkgQAhistos && doprocessMonteCarlo){ + if (fillBkgQAhistos && doprocessMonteCarlo) { histos.add("BkgStudy/h2dPtVsMassSigma_All", "h2dPtVsMassSigma_All", kTH2D, {axisPt, axisSigmaMass}); histos.add("BkgStudy/h2dPtVsMassSigma_TrueDaughters", "h2dPtVsMassSigma_TrueDaughters", kTH2D, {axisPt, axisSigmaMass}); histos.add("BkgStudy/h2dPtVsMassSigma_TrueGammaFakeLambda", "h2dPtVsMassSigma_TrueGammaFakeLambda", kTH2D, {axisPt, axisSigmaMass}); @@ -330,15 +330,15 @@ struct sigma0builder { histos.add("BkgStudy/h2dFakeGammaTrueLambdaMatrix", "h2dFakeGammaTrueLambdaMatrix", kTHnSparseD, {{10001, -5000.5f, +5000.5f}, {10001, -5000.5f, +5000.5f}}); histos.add("BkgStudy/h2dFakeDaughtersMatrix", "h2dFakeDaughtersMatrix", kTHnSparseD, {{10001, -5000.5f, +5000.5f}, {10001, -5000.5f, +5000.5f}}); } - + // For Pi0 QA - if (doPi0QA){ + if (doPi0QA) { histos.add("Pi0QA/h2dPtVsMassPi0BeforeSel_MCAssoc", "h2dPtVsMassPi0BeforeSel_MCAssoc", kTH2D, {axisPt, axisPi0Mass}); histos.add("Pi0QA/h2dPtVsMassPi0AfterSel_MCAssoc", "h2dPtVsMassPi0AfterSel_MCAssoc", kTH2D, {axisPt, axisPi0Mass}); histos.add("Pi0QA/h2dPtVsMassPi0BeforeSel_Candidates", "h2dPtVsMassPi0BeforeSel_Candidates", kTH2D, {axisPt, axisPi0Mass}); histos.add("Pi0QA/h2dPtVsMassPi0AfterSel_Candidates", "h2dPtVsMassPi0AfterSel_Candidates", kTH2D, {axisPt, axisPi0Mass}); } - + if (doprocessGeneratedCollRun3) histos.add("Gen/hNEventsNch", "hNEventsNch", kTH1D, {axisMonteCarloNch}); } @@ -477,45 +477,45 @@ struct sigma0builder { if ((PhotonPDGCode != 22) && (LambdaPDGCode != 3122) && (LambdaPDGCode != -3122)) { histos.fill(HIST("BkgStudy/h2dPtVsMassSigma_FakeDaughters"), sigmapT, sigmaMass); histos.fill(HIST("BkgStudy/h2dFakeDaughtersMatrix"), LambdaPDGCodeMother, PhotonPDGCodeMother); - } + } } template void analyzeV0CollAssoc(TCollision const& collision, TV0Object const& fullv0s, std::vector selV0Indices, float IR) - { + { auto v0MCCollision = collision.template straMCCollision_as>(); - for (size_t i = 0; i < selV0Indices.size(); ++i) { + for (size_t i = 0; i < selV0Indices.size(); ++i) { auto v0 = fullv0s.rawIteratorAt(selV0Indices[i]); - auto v0MC = v0.template v0MCCore_as>(); - + auto v0MC = v0.template v0MCCore_as>(); + float V0MCpT = RecoDecay::pt(array{v0MC.pxMC(), v0MC.pyMC()}); float V0PA = TMath::ACos(v0.v0cosPA()); bool fIsV0CorrectlyAssigned = (v0MC.straMCCollisionId() == v0MCCollision.globalIndex()); - + if (v0MC.pdgCode() == 22) { // True Gamma histos.fill(HIST("V0AssoQA/h2dIRVsPt_TrueGamma"), IR, V0MCpT); histos.fill(HIST("V0AssoQA/h3dPAVsIRVsPt_TrueGamma"), V0PA, IR, V0MCpT); - if (!fIsV0CorrectlyAssigned){ + if (!fIsV0CorrectlyAssigned) { histos.fill(HIST("V0AssoQA/h2dIRVsPt_TrueGamma_BadCollAssig"), IR, V0MCpT); - histos.fill(HIST("V0AssoQA/h3dPAVsIRVsPt_TrueGamma_BadCollAssig"), V0PA, IR, V0MCpT); + histos.fill(HIST("V0AssoQA/h3dPAVsIRVsPt_TrueGamma_BadCollAssig"), V0PA, IR, V0MCpT); } } if (v0MC.pdgCode() == 3122) { // True Lambda histos.fill(HIST("V0AssoQA/h2dIRVsPt_TrueLambda"), IR, V0MCpT); histos.fill(HIST("V0AssoQA/h3dPAVsIRVsPt_TrueLambda"), V0PA, IR, V0MCpT); - if (!fIsV0CorrectlyAssigned){ + if (!fIsV0CorrectlyAssigned) { histos.fill(HIST("V0AssoQA/h2dIRVsPt_TrueLambda_BadCollAssig"), IR, V0MCpT); - histos.fill(HIST("V0AssoQA/h3dPAVsIRVsPt_TrueLambda_BadCollAssig"), V0PA, IR, V0MCpT); + histos.fill(HIST("V0AssoQA/h3dPAVsIRVsPt_TrueLambda_BadCollAssig"), V0PA, IR, V0MCpT); } } - } + } } template void runPi0QA(TV0Object const& gamma1, TV0Object const& gamma2) - { + { // Check if both V0s are made of the same tracks if (gamma1.posTrackExtraId() == gamma2.posTrackExtraId() || gamma1.negTrackExtraId() == gamma2.negTrackExtraId() || @@ -523,7 +523,7 @@ struct sigma0builder { gamma1.negTrackExtraId() == gamma2.posTrackExtraId()) { return; } - + // Calculate pi0 properties std::array pVecGamma1{gamma1.px(), gamma1.py(), gamma1.pz()}; std::array pVecGamma2{gamma2.px(), gamma2.py(), gamma2.pz()}; @@ -531,7 +531,7 @@ struct sigma0builder { float pi0Mass = RecoDecay::m(arrpi0, std::array{o2::constants::physics::MassPhoton, o2::constants::physics::MassPhoton}); float pi0Pt = RecoDecay::pt(std::array{gamma1.px() + gamma2.px(), gamma1.py() + gamma2.py()}); float pi0Y = RecoDecay::y(std::array{gamma1.px() + gamma2.px(), gamma1.py() + gamma2.py(), gamma1.pz() + gamma2.pz()}, o2::constants::physics::MassPi0); - + // MC-specific variables bool fIsPi0 = false, fIsMC = false; @@ -549,8 +549,8 @@ struct sigma0builder { histos.fill(HIST("Pi0QA/h2dPtVsMassPi0BeforeSel_MCAssoc"), pi0Pt, pi0Mass); } } - } - + } + histos.fill(HIST("Pi0QA/h2dPtVsMassPi0BeforeSel_Candidates"), pi0Pt, pi0Mass); // Photon-specific selections @@ -562,7 +562,7 @@ struct sigma0builder { // Gamma1 Selection bool passedTPCGamma1 = (posTrackGamma1.tpcNSigmaEl() == -999.f || TMath::Abs(posTrackGamma1.tpcNSigmaEl()) < Pi0PhotonMaxTPCNSigmas) && (negTrackGamma1.tpcNSigmaEl() == -999.f || TMath::Abs(negTrackGamma1.tpcNSigmaEl()) < Pi0PhotonMaxTPCNSigmas); - + if (TMath::Abs(gamma1.mGamma()) > Pi0PhotonMaxMass || gamma1.qtarm() >= Pi0PhotonMaxQt || TMath::Abs(gamma1.alpha()) >= Pi0PhotonMaxAlpha || @@ -608,8 +608,8 @@ struct sigma0builder { // Fill histograms histos.fill(HIST("Pi0QA/h2dPtVsMassPi0AfterSel_Candidates"), pi0Pt, pi0Mass); - if (fIsMC && fIsPi0) - histos.fill(HIST("Pi0QA/h2dPtVsMassPi0AfterSel_MCAssoc"), pi0Pt, pi0Mass); + if (fIsMC && fIsPi0) + histos.fill(HIST("Pi0QA/h2dPtVsMassPi0AfterSel_MCAssoc"), pi0Pt, pi0Mass); } // Process photon candidate @@ -624,8 +624,7 @@ struct sigma0builder { if (gamma.gammaBDTScore() <= Gamma_MLThreshold) return false; - } - else { + } else { // Standard selection // Gamma basic selection criteria: histos.fill(HIST("PhotonSel/hSelectionStatistics"), 1.); @@ -651,7 +650,7 @@ struct sigma0builder { if ((gamma.v0radius() < PhotonMinRadius) || (gamma.v0radius() > PhotonMaxRadius)) return false; histos.fill(HIST("PhotonSel/hSelectionStatistics"), 6.); - } + } return true; } @@ -661,13 +660,12 @@ struct sigma0builder { { if (lambda.v0Type() != 1) return false; - + if (useMLScores) { if ((lambda.lambdaBDTScore() <= Lambda_MLThreshold) && (lambda.antiLambdaBDTScore() <= AntiLambda_MLThreshold)) return false; - } - else { + } else { // Lambda basic selection criteria: histos.fill(HIST("LambdaSel/hSelectionStatistics"), 1.); histos.fill(HIST("LambdaSel/hLambdaMass"), lambda.mLambda()); @@ -701,7 +699,7 @@ struct sigma0builder { // Process sigma candidate and store properties in object template bool buildSigma0(TV0Object const& lambda, TV0Object const& gamma) - { + { // Checking if both V0s are made of the very same tracks if (gamma.posTrackExtraId() == lambda.posTrackExtraId() || gamma.negTrackExtraId() == lambda.negTrackExtraId() || @@ -716,19 +714,19 @@ struct sigma0builder { auto arrMom = std::array{pVecPhotons, pVecLambda}; float sigmamass = RecoDecay::m(arrMom, std::array{o2::constants::physics::MassPhoton, o2::constants::physics::MassLambda0}); float sigmarap = RecoDecay::y(std::array{gamma.px() + lambda.px(), gamma.py() + lambda.py(), gamma.pz() + lambda.pz()}, o2::constants::physics::MassSigma0); - + histos.fill(HIST("SigmaSel/hSelectionStatistics"), 1.); histos.fill(HIST("SigmaSel/hSigmaMass"), sigmamass); histos.fill(HIST("SigmaSel/hSigmaMassWindow"), sigmamass - 1.192642); - - if (fillQAhistos){ + + if (fillQAhistos) { histos.fill(HIST("GeneralQA/h2dMassGammaVsK0S"), gamma.mGamma(), gamma.mK0Short()); histos.fill(HIST("GeneralQA/h2dMassLambdaVsK0S"), lambda.mLambda(), lambda.mK0Short()); histos.fill(HIST("GeneralQA/h2dMassGammaVsLambda"), gamma.mGamma(), gamma.mLambda()); histos.fill(HIST("GeneralQA/h2dMassLambdaVsGamma"), lambda.mLambda(), lambda.mGamma()); histos.fill(HIST("GeneralQA/h3dMassSigma0VsDaupTs"), gamma.pt(), lambda.pt(), sigmamass); } - + if (TMath::Abs(sigmamass - 1.192642) > Sigma0Window) return false; @@ -740,14 +738,14 @@ struct sigma0builder { histos.fill(HIST("SigmaSel/hSigmaMassSelected"), sigmamass); histos.fill(HIST("SigmaSel/hSelectionStatistics"), 3.); - - if (fillQAhistos){ + + if (fillQAhistos) { histos.fill(HIST("GeneralQA/h2dMassGammaVsK0SAfterMassSel"), gamma.mGamma(), gamma.mK0Short()); histos.fill(HIST("GeneralQA/h2dMassLambdaVsK0SAfterMassSel"), lambda.mLambda(), lambda.mK0Short()); histos.fill(HIST("GeneralQA/h2dMassGammaVsLambdaAfterMassSel"), gamma.mGamma(), lambda.mLambda()); histos.fill(HIST("GeneralQA/h2dV0XY"), gamma.x(), gamma.y()); } - + return true; } @@ -803,10 +801,10 @@ struct sigma0builder { (uint8_t(posTrackGamma.hasTOF()) << hasTOF)); uint8_t fPhotonNegTrackCode = ((uint8_t(negTrackGamma.hasTPC()) << hasTPC) | - (uint8_t(negTrackGamma.hasITSTracker()) << hasITSTracker) | - (uint8_t(negTrackGamma.hasITSAfterburner()) << hasITSAfterburner) | - (uint8_t(negTrackGamma.hasTRD()) << hasTRD) | - (uint8_t(negTrackGamma.hasTOF()) << hasTOF)); + (uint8_t(negTrackGamma.hasITSTracker()) << hasITSTracker) | + (uint8_t(negTrackGamma.hasITSAfterburner()) << hasITSAfterburner) | + (uint8_t(negTrackGamma.hasTRD()) << hasTRD) | + (uint8_t(negTrackGamma.hasTOF()) << hasTOF)); // Lambda auto posTrackLambda = lambda.template posTrackExtra_as(); @@ -859,10 +857,10 @@ struct sigma0builder { (uint8_t(posTrackLambda.hasTOF()) << hasTOF)); uint8_t fLambdaNegTrackCode = ((uint8_t(negTrackLambda.hasTPC()) << hasTPC) | - (uint8_t(negTrackLambda.hasITSTracker()) << hasITSTracker) | - (uint8_t(negTrackLambda.hasITSAfterburner()) << hasITSAfterburner) | - (uint8_t(negTrackLambda.hasTRD()) << hasTRD) | - (uint8_t(negTrackLambda.hasTOF()) << hasTOF)); + (uint8_t(negTrackLambda.hasITSTracker()) << hasITSTracker) | + (uint8_t(negTrackLambda.hasITSAfterburner()) << hasITSAfterburner) | + (uint8_t(negTrackLambda.hasTRD()) << hasTRD) | + (uint8_t(negTrackLambda.hasTOF()) << hasTOF)); // Sigma0 candidate properties std::array pVecPhotons{gamma.px(), gamma.py(), gamma.pz()}; @@ -910,60 +908,60 @@ struct sigma0builder { { for (const auto& coll : collisions) { - if (!IsEventAccepted(coll, true)) + if (!IsEventAccepted(coll, true)) continue; - + // Do analysis with collision-grouped V0s, retain full collision information const uint64_t collIdx = coll.globalIndex(); auto V0s = fullV0s.sliceBy(perCollisionMCDerived, collIdx); float centrality = coll.centFT0C(); histos.fill(HIST("hEventCentrality"), centrality); - - bool fhasMCColl=false; + + bool fhasMCColl = false; if (coll.has_straMCCollision()) - fhasMCColl=true; - + fhasMCColl = true; + //_______________________________________________ // Retrieving IR info float interactionRate = -1; - if (fGetIR){ + if (fGetIR) { interactionRate = rateFetcher.fetch(ccdb.service, coll.timestamp(), coll.runNumber(), irSource, fIRCrashOnNull) * 1.e-3; - - if (interactionRate<0) - histos.get(HIST("GeneralQA/hRunNumberNegativeIR"))->Fill(Form("%d", coll.runNumber()), 1); - histos.fill(HIST("GeneralQA/hInteractionRate"), interactionRate); - histos.fill(HIST("GeneralQA/hCentralityVsInteractionRate"), centrality, interactionRate); + if (interactionRate < 0) + histos.get(HIST("GeneralQA/hRunNumberNegativeIR"))->Fill(Form("%d", coll.runNumber()), 1); + + histos.fill(HIST("GeneralQA/hInteractionRate"), interactionRate); + histos.fill(HIST("GeneralQA/hCentralityVsInteractionRate"), centrality, interactionRate); } - + std::vector bestGammasArray; - std::vector bestLambdasArray; + std::vector bestLambdasArray; //_______________________________________________ - // Photon-only loop - for (auto& gamma : V0s) { // selecting photons from Sigma0 + // Photon-only loop + for (auto& gamma : V0s) { // selecting photons from Sigma0 if (!gamma.has_v0MCCore()) continue; auto gammaMC = gamma.v0MCCore_as>(); - + if (gammaMC.pdgCode() == 22) { histos.fill(HIST("MC/h2dGammaXYConversion"), gamma.x(), gamma.y()); float GammaY = TMath::Abs(RecoDecay::y(std::array{gamma.px(), gamma.py(), gamma.pz()}, o2::constants::physics::MassGamma)); if (GammaY < 0.5) { // rapidity selection - histos.fill(HIST("MC/h2dPtVsCentralityBeforeSel_MCAssocGamma"), centrality, gamma.pt()); // isgamma + histos.fill(HIST("MC/h2dPtVsCentralityBeforeSel_MCAssocGamma"), centrality, gamma.pt()); // isgamma } } // basic photon selection - if (!processPhotonCandidate(gamma)) + if (!processPhotonCandidate(gamma)) continue; // Save indices of best gamma candidates bestGammasArray.push_back(gamma.globalIndex()); } - + //_______________________________________________ // Lambda-only loop for (auto& lambda : V0s) { // selecting lambdas from Sigma0 @@ -972,40 +970,40 @@ struct sigma0builder { auto lambdaMC = lambda.v0MCCore_as>(); float lambdaY = TMath::Abs(RecoDecay::y(std::array{lambda.px(), lambda.py(), lambda.pz()}, o2::constants::physics::MassLambda)); - - if (lambdaY < 0.5){ - if (lambdaMC.pdgCode() == 3122) // Is Lambda - histos.fill(HIST("MC/h2dPtVsCentralityBeforeSel_MCAssocLambda"), centrality, lambda.pt()); - if (lambdaMC.pdgCode() == -3122) // Is AntiLambda - histos.fill(HIST("MC/h2dPtVsCentralityBeforeSel_MCAssocALambda"), centrality, lambda.pt()); + + if (lambdaY < 0.5) { + if (lambdaMC.pdgCode() == 3122) // Is Lambda + histos.fill(HIST("MC/h2dPtVsCentralityBeforeSel_MCAssocLambda"), centrality, lambda.pt()); + if (lambdaMC.pdgCode() == -3122) // Is AntiLambda + histos.fill(HIST("MC/h2dPtVsCentralityBeforeSel_MCAssocALambda"), centrality, lambda.pt()); } - + // basic lambda selection - if (!processLambdaCandidate(lambda)) + if (!processLambdaCandidate(lambda)) continue; // Save indices of best lambda candidates - bestLambdasArray.push_back(lambda.globalIndex()); + bestLambdasArray.push_back(lambda.globalIndex()); } //_______________________________________________ // Pi0 optional loop - if (doPi0QA){ + if (doPi0QA) { for (size_t i = 0; i < bestGammasArray.size(); ++i) { auto gamma1 = fullV0s.rawIteratorAt(bestGammasArray[i]); - for (size_t j = i + 1; j < bestGammasArray.size(); ++j) { - auto gamma2 = fullV0s.rawIteratorAt(bestGammasArray[j]); + for (size_t j = i + 1; j < bestGammasArray.size(); ++j) { + auto gamma2 = fullV0s.rawIteratorAt(bestGammasArray[j]); runPi0QA(gamma1, gamma2); } } } - + //_______________________________________________ // Wrongly collision association study - if (doAssocStudy && fhasMCColl){ - analyzeV0CollAssoc(coll, fullV0s, bestGammasArray, interactionRate); // Gamma - analyzeV0CollAssoc(coll, fullV0s, bestLambdasArray, interactionRate); // Lambda + if (doAssocStudy && fhasMCColl) { + analyzeV0CollAssoc(coll, fullV0s, bestGammasArray, interactionRate); // Gamma + analyzeV0CollAssoc(coll, fullV0s, bestLambdasArray, interactionRate); // Lambda } - + //_______________________________________________ // Sigma0 loop for (size_t i = 0; i < bestGammasArray.size(); ++i) { @@ -1022,14 +1020,14 @@ struct sigma0builder { fIsPhotonCorrectlyAssign = (gammaMC.straMCCollisionId() == gammaMCCollision.globalIndex()); } - for (size_t j = 0; j < bestLambdasArray.size(); ++j){ + for (size_t j = 0; j < bestLambdasArray.size(); ++j) { auto lambda = fullV0s.iteratorAt(bestLambdasArray[j]); - + if (!lambda.has_v0MCCore()) continue; auto lambdaMC = lambda.v0MCCore_as>(); - + // Sigma0 candidate properties std::array pVecPhotons{gamma.px(), gamma.py(), gamma.pz()}; std::array pVecLambda{lambda.px(), lambda.py(), lambda.pz()}; @@ -1042,8 +1040,8 @@ struct sigma0builder { bool fIsSigma = false; bool fIsAntiSigma = false; bool fIsPhotonPrimary = gammaMC.isPhysicalPrimary(); - bool fIsLambdaPrimary = lambdaMC.isPhysicalPrimary(); - bool fIsLambdaCorrectlyAssign = false; + bool fIsLambdaPrimary = lambdaMC.isPhysicalPrimary(); + bool fIsLambdaCorrectlyAssign = false; int PhotonCandPDGCode = gammaMC.pdgCode(); int PhotonCandPDGCodeMother = gammaMC.pdgCodeMother(); @@ -1053,7 +1051,7 @@ struct sigma0builder { float SigmaMCpT = RecoDecay::pt(array{gammaMC.pxMC() + lambdaMC.pxMC(), gammaMC.pyMC() + lambdaMC.pyMC()}); float PhotonMCpT = RecoDecay::pt(array{gammaMC.pxMC(), gammaMC.pyMC()}); float LambdaMCpT = RecoDecay::pt(array{lambdaMC.pxMC(), lambdaMC.pyMC()}); - + if (fhasMCColl) { auto lambdaMCCollision = coll.template straMCCollision_as>(); fIsLambdaCorrectlyAssign = (lambdaMC.straMCCollisionId() == lambdaMCCollision.globalIndex()); @@ -1064,33 +1062,33 @@ struct sigma0builder { if ((PhotonCandPDGCode == 22) && (PhotonCandPDGCodeMother == -3212) && (LambdaCandPDGCode == -3122) && (LambdaCandPDGCodeMother == -3212) && (gamma.motherMCPartId() == lambda.motherMCPartId())) fIsAntiSigma = true; - if (SigmaY < 0.5){ + if (SigmaY < 0.5) { if (fIsSigma) { histos.fill(HIST("MC/h2dPtVsCentralityBeforeSel_MCAssocSigma0"), centrality, SigmaMCpT); histos.fill(HIST("MC/h2dSigma0PtVsLambdaPtBeforeSel_MCAssoc"), SigmaMCpT, LambdaMCpT); histos.fill(HIST("MC/h2dSigma0PtVsGammaPtBeforeSel_MCAssoc"), SigmaMCpT, PhotonMCpT); } if (fIsAntiSigma) - histos.fill(HIST("MC/h2dPtVsCentralityBeforeSel_MCAssocASigma0"), centrality, SigmaMCpT); + histos.fill(HIST("MC/h2dPtVsCentralityBeforeSel_MCAssocASigma0"), centrality, SigmaMCpT); } histos.fill(HIST("SigmaSel/h3dMassSigma0BeforeSel"), centrality, SigmapT, SigmaMass); - + // Build sigma0 candidate, please - if (!buildSigma0(lambda, gamma)) + if (!buildSigma0(lambda, gamma)) continue; // Filling histos and tables histos.fill(HIST("SigmaSel/h3dMassSigma0AfterSel"), centrality, SigmapT, SigmaMass); - if (SigmaY < 0.5){ - if (fIsSigma) - histos.fill(HIST("MC/h2dPtVsCentralityAfterSel_MCAssocSigma0"), centrality, SigmaMCpT); - if (fIsAntiSigma) + if (SigmaY < 0.5) { + if (fIsSigma) + histos.fill(HIST("MC/h2dPtVsCentralityAfterSel_MCAssocSigma0"), centrality, SigmaMCpT); + if (fIsAntiSigma) histos.fill(HIST("MC/h2dPtVsCentralityAfterSel_MCAssocASigma0"), centrality, SigmaMCpT); } - - if (fillBkgQAhistos) + + if (fillBkgQAhistos) runBkgAnalysis(fIsSigma, fIsAntiSigma, PhotonCandPDGCode, PhotonCandPDGCodeMother, LambdaCandPDGCode, LambdaCandPDGCodeMother, SigmapT, SigmaMass); // Fill Tables please @@ -1101,20 +1099,20 @@ struct sigma0builder { fillTables(lambda, gamma, coll); // filling tables with accepted candidates nSigmaCandidates++; - if (nSigmaCandidates % 10000 == 0) + if (nSigmaCandidates % 10000 == 0) LOG(info) << "Sigma0 Candidates built: " << nSigmaCandidates; } } - } + } } void processRealData(soa::Join const& collisions, V0StandardDerivedDatas const& fullV0s, dauTracks const&) - { + { for (const auto& coll : collisions) { - if (!IsEventAccepted(coll, true)) + if (!IsEventAccepted(coll, true)) continue; - + // Do analysis with collision-grouped V0s, retain full collision information const uint64_t collIdx = coll.globalIndex(); auto V0s = fullV0s.sliceBy(perCollisionSTDDerived, collIdx); @@ -1123,25 +1121,25 @@ struct sigma0builder { histos.fill(HIST("hEventCentrality"), centrality); //_______________________________________________ - // Retrieving IR info + // Retrieving IR info float interactionRate = -1; - if (fGetIR){ + if (fGetIR) { interactionRate = rateFetcher.fetch(ccdb.service, coll.timestamp(), coll.runNumber(), irSource, fIRCrashOnNull) * 1.e-3; - - if (interactionRate<0) - histos.get(HIST("GeneralQA/hRunNumberNegativeIR"))->Fill(Form("%d", coll.runNumber()), 1); + + if (interactionRate < 0) + histos.get(HIST("GeneralQA/hRunNumberNegativeIR"))->Fill(Form("%d", coll.runNumber()), 1); histos.fill(HIST("GeneralQA/hInteractionRate"), interactionRate); - histos.fill(HIST("GeneralQA/hCentralityVsInteractionRate"), centrality, interactionRate); + histos.fill(HIST("GeneralQA/hCentralityVsInteractionRate"), centrality, interactionRate); } - + std::vector bestGammasArray; - std::vector bestLambdasArray; + std::vector bestLambdasArray; //_______________________________________________ // Photon-only loop - for (auto& gamma : V0s) { // selecting photons - if (!processPhotonCandidate(gamma)) + for (auto& gamma : V0s) { // selecting photons + if (!processPhotonCandidate(gamma)) continue; // Save indices of best gamma candidates @@ -1150,21 +1148,21 @@ struct sigma0builder { //_______________________________________________ // Lambda-only loop - for (auto& lambda : V0s) { // selecting lambdas - if (!processLambdaCandidate(lambda)) + for (auto& lambda : V0s) { // selecting lambdas + if (!processLambdaCandidate(lambda)) continue; // Save indices of best lambda candidates - bestLambdasArray.push_back(lambda.globalIndex()); + bestLambdasArray.push_back(lambda.globalIndex()); } //_______________________________________________ // Pi0 optional loop - if (doPi0QA){ + if (doPi0QA) { for (size_t i = 0; i < bestGammasArray.size(); ++i) { auto gamma1 = fullV0s.rawIteratorAt(bestGammasArray[i]); - for (size_t j = i + 1; j < bestGammasArray.size(); ++j) { - auto gamma2 = fullV0s.rawIteratorAt(bestGammasArray[j]); + for (size_t j = i + 1; j < bestGammasArray.size(); ++j) { + auto gamma2 = fullV0s.rawIteratorAt(bestGammasArray[j]); runPi0QA(gamma1, gamma2); } } @@ -1174,8 +1172,8 @@ struct sigma0builder { // Sigma0 loop for (size_t i = 0; i < bestGammasArray.size(); ++i) { auto gamma = fullV0s.rawIteratorAt(bestGammasArray[i]); - - for (size_t j = 0; j < bestLambdasArray.size(); ++j){ + + for (size_t j = 0; j < bestLambdasArray.size(); ++j) { auto lambda = fullV0s.iteratorAt(bestLambdasArray[j]); // Sigma0 candidate properties @@ -1188,7 +1186,7 @@ struct sigma0builder { histos.fill(HIST("SigmaSel/h3dMassSigma0BeforeSel"), centrality, SigmapT, SigmaMass); // Building sigma0 candidate - if (!buildSigma0(lambda, gamma)) + if (!buildSigma0(lambda, gamma)) continue; fillTables(lambda, gamma, coll); // filling tables with accepted candidates @@ -1197,10 +1195,10 @@ struct sigma0builder { nSigmaCandidates++; if (nSigmaCandidates % 10000 == 0) - LOG(info) << "Sigma0 Candidates built: " << nSigmaCandidates; + LOG(info) << "Sigma0 Candidates built: " << nSigmaCandidates; } - } - } + } + } } // Simulated processing in Run 3 (subscribes to MC information too) diff --git a/PWGLF/Tasks/Strangeness/sigmaanalysis.cxx b/PWGLF/Tasks/Strangeness/sigmaanalysis.cxx index 77c6f64a6b7..2e88ccc50b4 100644 --- a/PWGLF/Tasks/Strangeness/sigmaanalysis.cxx +++ b/PWGLF/Tasks/Strangeness/sigmaanalysis.cxx @@ -57,32 +57,31 @@ using std::array; using V0MCSigmas = soa::Join; using V0Sigmas = soa::Join; -static const std::vector PhotonSels = {"NoSel", "V0Type", "DaupT", "DCADauToPV", - "DCADau", "DauTPCCR", "TPCNSigmaEl", "V0pT", - "Y", "V0Radius", "RZCut", "Armenteros", "CosPA", - "PsiPair", "Phi", "Mass"}; +static const std::vector PhotonSels = {"NoSel", "V0Type", "DaupT", "DCADauToPV", + "DCADau", "DauTPCCR", "TPCNSigmaEl", "V0pT", + "Y", "V0Radius", "RZCut", "Armenteros", "CosPA", + "PsiPair", "Phi", "Mass"}; -static const std::vector LambdaSels = {"NoSel", "V0Radius", "DCADau", "Armenteros", - "CosPA", "Y", "TPCCR", "DauITSCls", "Lifetime", - "TPCTOFPID", "DCADauToPV", "Mass"}; - +static const std::vector LambdaSels = {"NoSel", "V0Radius", "DCADau", "Armenteros", + "CosPA", "Y", "TPCCR", "DauITSCls", "Lifetime", + "TPCTOFPID", "DCADauToPV", "Mass"}; -static const std::vector DirList = {"BeforeSel", "AfterSel"}; +static const std::vector DirList = {"BeforeSel", "AfterSel"}; -struct sigmaanalysis { +struct sigmaanalysis { HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; Configurable fillQAhistos{"fillQAhistos", false, "if true, fill QA histograms"}; Configurable fillBkgQAhistos{"fillBkgQAhistos", false, "if true, fill MC QA histograms for Bkg study. Only works with MC."}; Configurable fillpTResoQAhistos{"fillpTResoQAhistos", false, "if true, fill MC QA histograms for pT resolution study. Only works with MC."}; - - // Interaction rate selection: - Configurable fGetIR{"fGetIR", false, "Flag to retrieve the IR info."}; + + // Interaction rate selection: + Configurable fGetIR{"fGetIR", false, "Flag to retrieve the IR info."}; Configurable minIR{"minIR", -1, "Min Interaction Rate (kHz). Leave -1 if no selection desired."}; Configurable maxIR{"maxIR", -1, "Max Interaction Rate (kHz). Leave -1 if no selection desired."}; // Analysis strategy: - Configurable fUseMLSel{"fUseMLSel", false, "Flag to use ML selection. If False, the standard selection is applied."}; + Configurable fUseMLSel{"fUseMLSel", false, "Flag to use ML selection. If False, the standard selection is applied."}; Configurable fselLambdaTPCPID{"fselLambdaTPCPID", true, "Flag to select lambda-like candidates using TPC NSigma."}; Configurable fselLambdaTOFPID{"fselLambdaTOFPID", false, "Flag to select lambda-like candidates using TOF NSigma."}; Configurable doMCAssociation{"doMCAssociation", false, "Flag to process only signal candidates. Use only with processMonteCarlo!"}; @@ -126,7 +125,7 @@ struct sigmaanalysis { Configurable PhotonMaxDCAV0Dau{"PhotonMaxDCAV0Dau", 3.5, "Max DCA V0 Daughters (cm)"}; Configurable PhotonMinTPCCrossedRows{"PhotonMinTPCCrossedRows", 30, "Min daughter TPC Crossed Rows"}; Configurable PhotonMinTPCNSigmas{"PhotonMinTPCNSigmas", -7, "Min TPC NSigmas for daughters"}; - Configurable PhotonMaxTPCNSigmas{"PhotonMaxTPCNSigmas", 7, "Max TPC NSigmas for daughters"}; + Configurable PhotonMaxTPCNSigmas{"PhotonMaxTPCNSigmas", 7, "Max TPC NSigmas for daughters"}; Configurable PhotonMinPt{"PhotonMinPt", 0.0, "Min photon pT (GeV/c)"}; Configurable PhotonMaxPt{"PhotonMaxPt", 50.0, "Max photon pT (GeV/c)"}; Configurable PhotonMaxRap{"PhotonMaxRap", 0.5, "Max photon rapidity"}; @@ -180,7 +179,7 @@ struct sigmaanalysis { ConfigurableAxis axisCosPA{"axisCosPA", {200, 0.5f, 1.0f}, "Cosine of pointing angle"}; ConfigurableAxis axisPA{"axisPA", {100, 0.0f, 1}, "Pointing angle"}; ConfigurableAxis axisPsiPair{"axisPsiPair", {250, -5.0f, 5.0f}, "Psipair for photons"}; - ConfigurableAxis axisPhi{"axisPhi", {200, 0, 2 * o2::constants::math::PI}, "Phi for photons"}; + ConfigurableAxis axisPhi{"axisPhi", {200, 0, 2 * o2::constants::math::PI}, "Phi for photons"}; ConfigurableAxis axisZ{"axisZ", {120, -120.0f, 120.0f}, "V0 Z position (cm)"}; ConfigurableAxis axisCandSel{"axisCandSel", {20, 0.5f, +20.5f}, "Candidate Selection"}; @@ -189,209 +188,209 @@ struct sigmaanalysis { ConfigurableAxis MLProb{"MLOutput", {100, 0.0f, 1.0f}, ""}; void init(InitContext const&) - { + { for (const auto& histodir : DirList) { - histos.add(histodir+"/Photon/hTrackCode", "hTrackCode", kTH1F, {{11, 0.5f, 11.5f}}); - histos.add(histodir+"/Photon/hV0Type", "hV0Type", kTH1F, {{8, 0.5f, 8.5f}}); - histos.add(histodir+"/Photon/hNegpT", "hNegpT", kTH1F, {axisPt}); - histos.add(histodir+"/Photon/hPospT", "hPospT", kTH1F, {axisPt}); - histos.add(histodir+"/Photon/hDCANegToPV", "hDCANegToPV", kTH1F, {axisDCAtoPV}); - histos.add(histodir+"/Photon/hDCAPosToPV", "hDCAPosToPV", kTH1F, {axisDCAtoPV}); - histos.add(histodir+"/Photon/hDCADau", "hDCADau", kTH1F, {axisDCAdau}); - histos.add(histodir+"/Photon/hPosTPCCR", "hPosTPCCR", kTH1F, {axisTPCrows}); - histos.add(histodir+"/Photon/hNegTPCCR", "hNegTPCCR", kTH1F, {axisTPCrows}); - histos.add(histodir+"/Photon/h2dPosTPCNSigmaEl", "h2dPosTPCNSigmaEl", kTH2F, {axisPt, axisTPCNSigma}); - histos.add(histodir+"/Photon/h2dNegTPCNSigmaEl", "h2dNegTPCNSigmaEl", kTH2F, {axisPt, axisTPCNSigma}); - histos.add(histodir+"/Photon/h2dPosTPCNSigmaPi", "h2dPosTPCNSigmaPi", kTH2F, {axisPt, axisTPCNSigma}); - histos.add(histodir+"/Photon/h2dNegTPCNSigmaPi", "h2dNegTPCNSigmaPi", kTH2F, {axisPt, axisTPCNSigma}); - histos.add(histodir+"/Photon/hpT", "hpT", kTH1F, {axisPt}); - histos.add(histodir+"/Photon/hY", "hY", kTH1F, {axisRapidity}); - histos.add(histodir+"/Photon/hPosEta", "hPosEta", kTH1F, {axisRapidity}); - histos.add(histodir+"/Photon/hNegEta", "hNegEta", kTH1F, {axisRapidity}); - histos.add(histodir+"/Photon/hRadius", "hRadius", kTH1F, {axisRadius}); - histos.add(histodir+"/Photon/hZ", "hZ", kTH1F, {axisZ}); - histos.add(histodir+"/Photon/h2dRZCut", "h2dRZCut", kTH2F, {axisZ, axisRadius}); - histos.add(histodir+"/Photon/h2dRZPlane", "h2dRZPlane", kTH2F, {axisZ, axisRadius}); - histos.add(histodir+"/Photon/hCosPA", "hCosPA", kTH1F, {axisCosPA}); - histos.add(histodir+"/Photon/hPsiPair", "hPsiPair", kTH1F, {axisPsiPair}); - histos.add(histodir+"/Photon/hPhi", "hPhi", kTH1F, {axisPhi}); - histos.add(histodir+"/Photon/h3dMass", "h3dMass", kTH3F, {axisCentrality, axisPt, axisPhotonMass}); - histos.add(histodir+"/Photon/hMass", "hMass", kTH1F, {axisPhotonMass}); - - histos.add(histodir+"/Lambda/hTrackCode", "hTrackCode", kTH1F, {{11, 0.5f, 11.5f}}); - histos.add(histodir+"/Lambda/hRadius", "hRadius", kTH1F, {axisRadius}); - histos.add(histodir+"/Lambda/hDCADau", "hDCADau", kTH1F, {axisDCAdau}); - histos.add(histodir+"/Lambda/hCosPA", "hCosPA", kTH1F, {axisCosPA}); - histos.add(histodir+"/Lambda/hY", "hY", kTH1F, {axisRapidity}); - histos.add(histodir+"/Lambda/hPosEta", "hPosEta", kTH1F, {axisRapidity}); - histos.add(histodir+"/Lambda/hNegEta", "hNegEta", kTH1F, {axisRapidity}); - histos.add(histodir+"/Lambda/hPosTPCCR", "hPosTPCCR", kTH1F, {axisTPCrows}); - histos.add(histodir+"/Lambda/hNegTPCCR", "hNegTPCCR", kTH1F, {axisTPCrows}); - histos.add(histodir+"/Lambda/hPosITSCls", "hPosITSCls", kTH1F, {axisNCls}); - histos.add(histodir+"/Lambda/hNegITSCls", "hNegITSCls", kTH1F, {axisNCls}); - histos.add(histodir+"/Lambda/hPosChi2PerNc", "hPosChi2PerNc", kTH1F, {axisChi2PerNcl}); - histos.add(histodir+"/Lambda/hNegChi2PerNc", "hNegChi2PerNc", kTH1F, {axisChi2PerNcl}); - histos.add(histodir+"/Lambda/hLifeTime", "hLifeTime", kTH1F, {axisLifetime}); - histos.add(histodir+"/Lambda/h2dTPCvsTOFNSigma_LambdaPr", "h2dTPCvsTOFNSigma_LambdaPr", kTH2F, {axisTPCNSigma, axisTOFNSigma}); - histos.add(histodir+"/Lambda/h2dTPCvsTOFNSigma_LambdaPi", "h2dTPCvsTOFNSigma_LambdaPi", kTH2F, {axisTPCNSigma, axisTOFNSigma}); - histos.add(histodir+"/Lambda/hLambdaDCANegToPV", "hLambdaDCANegToPV", kTH1F, {axisDCAtoPV}); - histos.add(histodir+"/Lambda/hLambdaDCAPosToPV", "hLambdaDCAPosToPV", kTH1F, {axisDCAtoPV}); - histos.add(histodir+"/Lambda/hLambdapT", "hLambdapT", kTH1F, {axisPt}); - histos.add(histodir+"/Lambda/hLambdaMass", "hLambdaMass", kTH1F, {axisLambdaMass}); - histos.add(histodir+"/Lambda/h3dLambdaMass", "h3dLambdaMass", kTH3F, {axisCentrality, axisPt, axisLambdaMass}); - histos.add(histodir+"/Lambda/h2dTPCvsTOFNSigma_ALambdaPr", "h2dTPCvsTOFNSigma_ALambdaPr", kTH2F, {axisTPCNSigma, axisTOFNSigma}); - histos.add(histodir+"/Lambda/h2dTPCvsTOFNSigma_ALambdaPi", "h2dTPCvsTOFNSigma_ALambdaPi", kTH2F, {axisTPCNSigma, axisTOFNSigma}); - histos.add(histodir+"/Lambda/hALambdaDCANegToPV", "hALambdaDCANegToPV", kTH1F, {axisDCAtoPV}); - histos.add(histodir+"/Lambda/hALambdaDCAPosToPV", "hALambdaDCAPosToPV", kTH1F, {axisDCAtoPV}); - histos.add(histodir+"/Lambda/hALambdapT", "hALambdapT", kTH1F, {axisPt}); - histos.add(histodir+"/Lambda/hAntiLambdaMass", "hAntiLambdaMass", kTH1F, {axisLambdaMass}); - histos.add(histodir+"/Lambda/h3dAntiLambdaMass", "h3dAntiLambdaMass", kTH3F, {axisCentrality, axisPt, axisLambdaMass}); - - histos.add(histodir+"/h2dArmenteros", "h2dArmenteros", kTH2F, {axisAPAlpha, axisAPQt}); - - histos.add(histodir+"/Sigma0/hMass", "hMass", kTH1F, {axisSigmaMass}); - histos.add(histodir+"/Sigma0/hPt", "hPt", kTH1F, {axisPt}); - histos.add(histodir+"/Sigma0/hY", "hY", kTH1F, {axisRapidity}); - histos.add(histodir+"/Sigma0/h3dMass", "h3dMass", kTH3F, {axisCentrality, axisPt, axisSigmaMass}); - histos.add(histodir+"/Sigma0/h3dPhotonRadiusVsMassSigma", "h3dPhotonRadiusVsMassSigma", kTH3F, {axisCentrality, axisRadius, axisSigmaMass}); - histos.add(histodir+"/Sigma0/h2dpTVsOPAngle", "h2dpTVsOPAngle", kTH2F, {axisPt, {140, 0.0f, +7.0f}}); - - histos.add(histodir+"/ASigma0/hMass", "hMass", kTH1F, {axisSigmaMass}); - histos.add(histodir+"/ASigma0/hPt", "hPt", kTH1F, {axisPt}); - histos.add(histodir+"/ASigma0/hY", "hY", kTH1F, {axisRapidity}); - histos.add(histodir+"/ASigma0/h3dMass", "h3dMass", kTH3F, {axisCentrality, axisPt, axisSigmaMass}); - histos.add(histodir+"/ASigma0/h3dPhotonRadiusVsMassSigma", "h3dPhotonRadiusVsMassSigma", kTH3F, {axisCentrality, axisRadius, axisSigmaMass}); - histos.add(histodir+"/ASigma0/h2dpTVsOPAngle", "h2dpTVsOPAngle", kTH2F, {axisPt, {140, 0.0f, +7.0f}}); + histos.add(histodir + "/Photon/hTrackCode", "hTrackCode", kTH1F, {{11, 0.5f, 11.5f}}); + histos.add(histodir + "/Photon/hV0Type", "hV0Type", kTH1F, {{8, 0.5f, 8.5f}}); + histos.add(histodir + "/Photon/hNegpT", "hNegpT", kTH1F, {axisPt}); + histos.add(histodir + "/Photon/hPospT", "hPospT", kTH1F, {axisPt}); + histos.add(histodir + "/Photon/hDCANegToPV", "hDCANegToPV", kTH1F, {axisDCAtoPV}); + histos.add(histodir + "/Photon/hDCAPosToPV", "hDCAPosToPV", kTH1F, {axisDCAtoPV}); + histos.add(histodir + "/Photon/hDCADau", "hDCADau", kTH1F, {axisDCAdau}); + histos.add(histodir + "/Photon/hPosTPCCR", "hPosTPCCR", kTH1F, {axisTPCrows}); + histos.add(histodir + "/Photon/hNegTPCCR", "hNegTPCCR", kTH1F, {axisTPCrows}); + histos.add(histodir + "/Photon/h2dPosTPCNSigmaEl", "h2dPosTPCNSigmaEl", kTH2F, {axisPt, axisTPCNSigma}); + histos.add(histodir + "/Photon/h2dNegTPCNSigmaEl", "h2dNegTPCNSigmaEl", kTH2F, {axisPt, axisTPCNSigma}); + histos.add(histodir + "/Photon/h2dPosTPCNSigmaPi", "h2dPosTPCNSigmaPi", kTH2F, {axisPt, axisTPCNSigma}); + histos.add(histodir + "/Photon/h2dNegTPCNSigmaPi", "h2dNegTPCNSigmaPi", kTH2F, {axisPt, axisTPCNSigma}); + histos.add(histodir + "/Photon/hpT", "hpT", kTH1F, {axisPt}); + histos.add(histodir + "/Photon/hY", "hY", kTH1F, {axisRapidity}); + histos.add(histodir + "/Photon/hPosEta", "hPosEta", kTH1F, {axisRapidity}); + histos.add(histodir + "/Photon/hNegEta", "hNegEta", kTH1F, {axisRapidity}); + histos.add(histodir + "/Photon/hRadius", "hRadius", kTH1F, {axisRadius}); + histos.add(histodir + "/Photon/hZ", "hZ", kTH1F, {axisZ}); + histos.add(histodir + "/Photon/h2dRZCut", "h2dRZCut", kTH2F, {axisZ, axisRadius}); + histos.add(histodir + "/Photon/h2dRZPlane", "h2dRZPlane", kTH2F, {axisZ, axisRadius}); + histos.add(histodir + "/Photon/hCosPA", "hCosPA", kTH1F, {axisCosPA}); + histos.add(histodir + "/Photon/hPsiPair", "hPsiPair", kTH1F, {axisPsiPair}); + histos.add(histodir + "/Photon/hPhi", "hPhi", kTH1F, {axisPhi}); + histos.add(histodir + "/Photon/h3dMass", "h3dMass", kTH3F, {axisCentrality, axisPt, axisPhotonMass}); + histos.add(histodir + "/Photon/hMass", "hMass", kTH1F, {axisPhotonMass}); + + histos.add(histodir + "/Lambda/hTrackCode", "hTrackCode", kTH1F, {{11, 0.5f, 11.5f}}); + histos.add(histodir + "/Lambda/hRadius", "hRadius", kTH1F, {axisRadius}); + histos.add(histodir + "/Lambda/hDCADau", "hDCADau", kTH1F, {axisDCAdau}); + histos.add(histodir + "/Lambda/hCosPA", "hCosPA", kTH1F, {axisCosPA}); + histos.add(histodir + "/Lambda/hY", "hY", kTH1F, {axisRapidity}); + histos.add(histodir + "/Lambda/hPosEta", "hPosEta", kTH1F, {axisRapidity}); + histos.add(histodir + "/Lambda/hNegEta", "hNegEta", kTH1F, {axisRapidity}); + histos.add(histodir + "/Lambda/hPosTPCCR", "hPosTPCCR", kTH1F, {axisTPCrows}); + histos.add(histodir + "/Lambda/hNegTPCCR", "hNegTPCCR", kTH1F, {axisTPCrows}); + histos.add(histodir + "/Lambda/hPosITSCls", "hPosITSCls", kTH1F, {axisNCls}); + histos.add(histodir + "/Lambda/hNegITSCls", "hNegITSCls", kTH1F, {axisNCls}); + histos.add(histodir + "/Lambda/hPosChi2PerNc", "hPosChi2PerNc", kTH1F, {axisChi2PerNcl}); + histos.add(histodir + "/Lambda/hNegChi2PerNc", "hNegChi2PerNc", kTH1F, {axisChi2PerNcl}); + histos.add(histodir + "/Lambda/hLifeTime", "hLifeTime", kTH1F, {axisLifetime}); + histos.add(histodir + "/Lambda/h2dTPCvsTOFNSigma_LambdaPr", "h2dTPCvsTOFNSigma_LambdaPr", kTH2F, {axisTPCNSigma, axisTOFNSigma}); + histos.add(histodir + "/Lambda/h2dTPCvsTOFNSigma_LambdaPi", "h2dTPCvsTOFNSigma_LambdaPi", kTH2F, {axisTPCNSigma, axisTOFNSigma}); + histos.add(histodir + "/Lambda/hLambdaDCANegToPV", "hLambdaDCANegToPV", kTH1F, {axisDCAtoPV}); + histos.add(histodir + "/Lambda/hLambdaDCAPosToPV", "hLambdaDCAPosToPV", kTH1F, {axisDCAtoPV}); + histos.add(histodir + "/Lambda/hLambdapT", "hLambdapT", kTH1F, {axisPt}); + histos.add(histodir + "/Lambda/hLambdaMass", "hLambdaMass", kTH1F, {axisLambdaMass}); + histos.add(histodir + "/Lambda/h3dLambdaMass", "h3dLambdaMass", kTH3F, {axisCentrality, axisPt, axisLambdaMass}); + histos.add(histodir + "/Lambda/h2dTPCvsTOFNSigma_ALambdaPr", "h2dTPCvsTOFNSigma_ALambdaPr", kTH2F, {axisTPCNSigma, axisTOFNSigma}); + histos.add(histodir + "/Lambda/h2dTPCvsTOFNSigma_ALambdaPi", "h2dTPCvsTOFNSigma_ALambdaPi", kTH2F, {axisTPCNSigma, axisTOFNSigma}); + histos.add(histodir + "/Lambda/hALambdaDCANegToPV", "hALambdaDCANegToPV", kTH1F, {axisDCAtoPV}); + histos.add(histodir + "/Lambda/hALambdaDCAPosToPV", "hALambdaDCAPosToPV", kTH1F, {axisDCAtoPV}); + histos.add(histodir + "/Lambda/hALambdapT", "hALambdapT", kTH1F, {axisPt}); + histos.add(histodir + "/Lambda/hAntiLambdaMass", "hAntiLambdaMass", kTH1F, {axisLambdaMass}); + histos.add(histodir + "/Lambda/h3dAntiLambdaMass", "h3dAntiLambdaMass", kTH3F, {axisCentrality, axisPt, axisLambdaMass}); + + histos.add(histodir + "/h2dArmenteros", "h2dArmenteros", kTH2F, {axisAPAlpha, axisAPQt}); + + histos.add(histodir + "/Sigma0/hMass", "hMass", kTH1F, {axisSigmaMass}); + histos.add(histodir + "/Sigma0/hPt", "hPt", kTH1F, {axisPt}); + histos.add(histodir + "/Sigma0/hY", "hY", kTH1F, {axisRapidity}); + histos.add(histodir + "/Sigma0/h3dMass", "h3dMass", kTH3F, {axisCentrality, axisPt, axisSigmaMass}); + histos.add(histodir + "/Sigma0/h3dPhotonRadiusVsMassSigma", "h3dPhotonRadiusVsMassSigma", kTH3F, {axisCentrality, axisRadius, axisSigmaMass}); + histos.add(histodir + "/Sigma0/h2dpTVsOPAngle", "h2dpTVsOPAngle", kTH2F, {axisPt, {140, 0.0f, +7.0f}}); + + histos.add(histodir + "/ASigma0/hMass", "hMass", kTH1F, {axisSigmaMass}); + histos.add(histodir + "/ASigma0/hPt", "hPt", kTH1F, {axisPt}); + histos.add(histodir + "/ASigma0/hY", "hY", kTH1F, {axisRapidity}); + histos.add(histodir + "/ASigma0/h3dMass", "h3dMass", kTH3F, {axisCentrality, axisPt, axisSigmaMass}); + histos.add(histodir + "/ASigma0/h3dPhotonRadiusVsMassSigma", "h3dPhotonRadiusVsMassSigma", kTH3F, {axisCentrality, axisRadius, axisSigmaMass}); + histos.add(histodir + "/ASigma0/h2dpTVsOPAngle", "h2dpTVsOPAngle", kTH2F, {axisPt, {140, 0.0f, +7.0f}}); // Process MC if (doprocessMonteCarlo) { - histos.add(histodir+"/MC/Photon/hV0ToCollAssoc", "hV0ToCollAssoc", kTH1F, {{2, 0.0f, 2.0f}}); - histos.add(histodir+"/MC/Photon/hPt", "hPt", kTH1F, {axisPt}); - histos.add(histodir+"/MC/Photon/hMCPt", "hMCPt", kTH1F, {axisPt}); - histos.add(histodir+"/MC/Photon/h2dPosTPCNSigmaEl", "h2dPosTPCNSigmaEl", kTH2F, {axisPt, axisTPCNSigma}); - histos.add(histodir+"/MC/Photon/h2dNegTPCNSigmaEl", "h2dNegTPCNSigmaEl", kTH2F, {axisPt, axisTPCNSigma}); - histos.add(histodir+"/MC/Photon/h2dPosTPCNSigmaPi", "h2dPosTPCNSigmaPi", kTH2F, {axisPt, axisTPCNSigma}); - histos.add(histodir+"/MC/Photon/h2dNegTPCNSigmaPi", "h2dNegTPCNSigmaPi", kTH2F, {axisPt, axisTPCNSigma}); - histos.add(histodir+"/MC/Photon/h2dIRVsPt", "h2dIRVsPt", kTH2F, {axisIRBinning, axisPt}); - histos.add(histodir+"/MC/Photon/h3dPAVsIRVsPt", "h3dPAVsIRVsPt", kTH3F, {axisPA, axisIRBinning, axisPt}); - histos.add(histodir+"/MC/Photon/h2dIRVsPt_BadCollAssig", "h2dIRVsPt_BadCollAssig", kTH2F, {axisIRBinning, axisPt}); - histos.add(histodir+"/MC/Photon/h3dPAVsIRVsPt_BadCollAssig", "h3dPAVsIRVsPt_BadCollAssig", kTH3F, {axisPA, axisIRBinning, axisPt}); - - histos.add(histodir+"/MC/Lambda/hV0ToCollAssoc", "hV0ToCollAssoc", kTH1F, {{2, 0.0f, 2.0f}}); - histos.add(histodir+"/MC/Lambda/hPt", "hPt", kTH1F, {axisPt}); - histos.add(histodir+"/MC/Lambda/hMCPt", "hMCPt", kTH1F, {axisPt}); - histos.add(histodir+"/MC/Lambda/h3dTPCvsTOFNSigma_Pr", "h3dTPCvsTOFNSigma_Pr", kTH3F, {axisTPCNSigma, axisTOFNSigma, axisPt}); - histos.add(histodir+"/MC/Lambda/h3dTPCvsTOFNSigma_Pi", "h3dTPCvsTOFNSigma_Pi", kTH3F, {axisTPCNSigma, axisTOFNSigma, axisPt}); - - histos.add(histodir+"/MC/ALambda/hV0ToCollAssoc", "hV0ToCollAssoc", kTH1F, {{2, 0.0f, 2.0f}}); - histos.add(histodir+"/MC/ALambda/hPt", "hPt", kTH1F, {axisPt}); - histos.add(histodir+"/MC/ALambda/hMCPt", "hMCPt", kTH1F, {axisPt}); - histos.add(histodir+"/MC/ALambda/h3dTPCvsTOFNSigma_Pr", "h3dTPCvsTOFNSigma_Pr", kTH3F, {axisTPCNSigma, axisTOFNSigma, axisPt}); - histos.add(histodir+"/MC/ALambda/h3dTPCvsTOFNSigma_Pi", "h3dTPCvsTOFNSigma_Pi", kTH3F, {axisTPCNSigma, axisTOFNSigma, axisPt}); - - histos.add(histodir+"/MC/h2dArmenteros", "h2dArmenteros", kTH2F, {axisAPAlpha, axisAPQt}); - - histos.add(histodir+"/MC/Sigma0/hPt", "hPt", kTH1F, {axisPt}); - histos.add(histodir+"/MC/Sigma0/hMCPt", "hMCPt", kTH1F, {axisPt}); - histos.add(histodir+"/MC/Sigma0/h2dMCPtVsLambdaMCPt", "h2dMCPtVsLambdaMCPt", kTH2F, {axisPt, axisPt}); - histos.add(histodir+"/MC/Sigma0/h2dMCPtVsGammaMCPt", "h2dMCPtVsGammaMCPt", kTH2F, {axisPt, axisPt}); - histos.add(histodir+"/MC/Sigma0/hMass", "hMass", kTH1F, {axisSigmaMass}); - histos.add(histodir+"/MC/Sigma0/h3dMass", "h3dMass", kTH3F, {axisCentrality, axisPt, axisSigmaMass}); - - histos.add(histodir+"/MC/ASigma0/hPt", "hPt", kTH1F, {axisPt}); - histos.add(histodir+"/MC/ASigma0/hMCPt", "hMCPt", kTH1F, {axisPt}); - histos.add(histodir+"/MC/ASigma0/h2dMCPtVsLambdaMCPt", "h2dMCPtVsLambdaMCPt", kTH2F, {axisPt, axisPt}); - histos.add(histodir+"/MC/ASigma0/h2dMCPtVsPhotonMCPt", "h2dMCPtVsPhotonMCPt", kTH2F, {axisPt, axisPt}); - histos.add(histodir+"/MC/ASigma0/hMass", "hMass", kTH1F, {axisSigmaMass}); - histos.add(histodir+"/MC/ASigma0/h3dMass", "h3dMass", kTH3F, {axisCentrality, axisPt, axisSigmaMass}); + histos.add(histodir + "/MC/Photon/hV0ToCollAssoc", "hV0ToCollAssoc", kTH1F, {{2, 0.0f, 2.0f}}); + histos.add(histodir + "/MC/Photon/hPt", "hPt", kTH1F, {axisPt}); + histos.add(histodir + "/MC/Photon/hMCPt", "hMCPt", kTH1F, {axisPt}); + histos.add(histodir + "/MC/Photon/h2dPosTPCNSigmaEl", "h2dPosTPCNSigmaEl", kTH2F, {axisPt, axisTPCNSigma}); + histos.add(histodir + "/MC/Photon/h2dNegTPCNSigmaEl", "h2dNegTPCNSigmaEl", kTH2F, {axisPt, axisTPCNSigma}); + histos.add(histodir + "/MC/Photon/h2dPosTPCNSigmaPi", "h2dPosTPCNSigmaPi", kTH2F, {axisPt, axisTPCNSigma}); + histos.add(histodir + "/MC/Photon/h2dNegTPCNSigmaPi", "h2dNegTPCNSigmaPi", kTH2F, {axisPt, axisTPCNSigma}); + histos.add(histodir + "/MC/Photon/h2dIRVsPt", "h2dIRVsPt", kTH2F, {axisIRBinning, axisPt}); + histos.add(histodir + "/MC/Photon/h3dPAVsIRVsPt", "h3dPAVsIRVsPt", kTH3F, {axisPA, axisIRBinning, axisPt}); + histos.add(histodir + "/MC/Photon/h2dIRVsPt_BadCollAssig", "h2dIRVsPt_BadCollAssig", kTH2F, {axisIRBinning, axisPt}); + histos.add(histodir + "/MC/Photon/h3dPAVsIRVsPt_BadCollAssig", "h3dPAVsIRVsPt_BadCollAssig", kTH3F, {axisPA, axisIRBinning, axisPt}); + + histos.add(histodir + "/MC/Lambda/hV0ToCollAssoc", "hV0ToCollAssoc", kTH1F, {{2, 0.0f, 2.0f}}); + histos.add(histodir + "/MC/Lambda/hPt", "hPt", kTH1F, {axisPt}); + histos.add(histodir + "/MC/Lambda/hMCPt", "hMCPt", kTH1F, {axisPt}); + histos.add(histodir + "/MC/Lambda/h3dTPCvsTOFNSigma_Pr", "h3dTPCvsTOFNSigma_Pr", kTH3F, {axisTPCNSigma, axisTOFNSigma, axisPt}); + histos.add(histodir + "/MC/Lambda/h3dTPCvsTOFNSigma_Pi", "h3dTPCvsTOFNSigma_Pi", kTH3F, {axisTPCNSigma, axisTOFNSigma, axisPt}); + + histos.add(histodir + "/MC/ALambda/hV0ToCollAssoc", "hV0ToCollAssoc", kTH1F, {{2, 0.0f, 2.0f}}); + histos.add(histodir + "/MC/ALambda/hPt", "hPt", kTH1F, {axisPt}); + histos.add(histodir + "/MC/ALambda/hMCPt", "hMCPt", kTH1F, {axisPt}); + histos.add(histodir + "/MC/ALambda/h3dTPCvsTOFNSigma_Pr", "h3dTPCvsTOFNSigma_Pr", kTH3F, {axisTPCNSigma, axisTOFNSigma, axisPt}); + histos.add(histodir + "/MC/ALambda/h3dTPCvsTOFNSigma_Pi", "h3dTPCvsTOFNSigma_Pi", kTH3F, {axisTPCNSigma, axisTOFNSigma, axisPt}); + + histos.add(histodir + "/MC/h2dArmenteros", "h2dArmenteros", kTH2F, {axisAPAlpha, axisAPQt}); + + histos.add(histodir + "/MC/Sigma0/hPt", "hPt", kTH1F, {axisPt}); + histos.add(histodir + "/MC/Sigma0/hMCPt", "hMCPt", kTH1F, {axisPt}); + histos.add(histodir + "/MC/Sigma0/h2dMCPtVsLambdaMCPt", "h2dMCPtVsLambdaMCPt", kTH2F, {axisPt, axisPt}); + histos.add(histodir + "/MC/Sigma0/h2dMCPtVsGammaMCPt", "h2dMCPtVsGammaMCPt", kTH2F, {axisPt, axisPt}); + histos.add(histodir + "/MC/Sigma0/hMass", "hMass", kTH1F, {axisSigmaMass}); + histos.add(histodir + "/MC/Sigma0/h3dMass", "h3dMass", kTH3F, {axisCentrality, axisPt, axisSigmaMass}); + + histos.add(histodir + "/MC/ASigma0/hPt", "hPt", kTH1F, {axisPt}); + histos.add(histodir + "/MC/ASigma0/hMCPt", "hMCPt", kTH1F, {axisPt}); + histos.add(histodir + "/MC/ASigma0/h2dMCPtVsLambdaMCPt", "h2dMCPtVsLambdaMCPt", kTH2F, {axisPt, axisPt}); + histos.add(histodir + "/MC/ASigma0/h2dMCPtVsPhotonMCPt", "h2dMCPtVsPhotonMCPt", kTH2F, {axisPt, axisPt}); + histos.add(histodir + "/MC/ASigma0/hMass", "hMass", kTH1F, {axisSigmaMass}); + histos.add(histodir + "/MC/ASigma0/h3dMass", "h3dMass", kTH3F, {axisCentrality, axisPt, axisSigmaMass}); // 1/pT Resolution: - if (fillpTResoQAhistos && histodir=="BeforeSel"){ - histos.add(histodir+"/MC/pTReso/h3dGammaPtResoVsTPCCR", "h3dGammaPtResoVsTPCCR", kTH3F, {axisInvPt, axisDeltaPt, axisTPCrows}); - histos.add(histodir+"/MC/pTReso/h3dGammaPtResoVsTPCCR", "h3dGammaPtResoVsTPCCR", kTH3F, {axisInvPt, axisDeltaPt, axisTPCrows}); - histos.add(histodir+"/MC/pTReso/h2dGammaPtResolution", "h2dGammaPtResolution", kTH2F, {axisInvPt, axisDeltaPt}); - histos.add(histodir+"/MC/pTReso/h2dLambdaPtResolution", "h2dLambdaPtResolution", kTH2F, {axisInvPt, axisDeltaPt}); - histos.add(histodir+"/MC/pTReso/h3dLambdaPtResoVsTPCCR", "h3dLambdaPtResoVsTPCCR", kTH3F, {axisInvPt, axisDeltaPt, axisTPCrows}); - histos.add(histodir+"/MC/pTReso/h3dLambdaPtResoVsTPCCR", "h3dLambdaPtResoVsTPCCR", kTH3F, {axisInvPt, axisDeltaPt, axisTPCrows}); - histos.add(histodir+"/MC/pTReso/h2dAntiLambdaPtResolution", "h2dAntiLambdaPtResolution", kTH2F, {axisInvPt, axisDeltaPt}); - histos.add(histodir+"/MC/pTReso/h3dAntiLambdaPtResoVsTPCCR", "h3dAntiLambdaPtResoVsTPCCR", kTH3F, {axisInvPt, axisDeltaPt, axisTPCrows}); - histos.add(histodir+"/MC/pTReso/h3dAntiLambdaPtResoVsTPCCR", "h3dAntiLambdaPtResoVsTPCCR", kTH3F, {axisInvPt, axisDeltaPt, axisTPCrows}); - histos.add(histodir+"/MC/pTReso/h2dSigma0PtResolution", "h2dSigma0PtResolution", kTH2F, {axisInvPt, axisDeltaPt}); - histos.add(histodir+"/MC/pTReso/h2dAntiSigma0PtResolution", "h2dAntiSigma0PtResolution", kTH2F, {axisInvPt, axisDeltaPt}); + if (fillpTResoQAhistos && histodir == "BeforeSel") { + histos.add(histodir + "/MC/pTReso/h3dGammaPtResoVsTPCCR", "h3dGammaPtResoVsTPCCR", kTH3F, {axisInvPt, axisDeltaPt, axisTPCrows}); + histos.add(histodir + "/MC/pTReso/h3dGammaPtResoVsTPCCR", "h3dGammaPtResoVsTPCCR", kTH3F, {axisInvPt, axisDeltaPt, axisTPCrows}); + histos.add(histodir + "/MC/pTReso/h2dGammaPtResolution", "h2dGammaPtResolution", kTH2F, {axisInvPt, axisDeltaPt}); + histos.add(histodir + "/MC/pTReso/h2dLambdaPtResolution", "h2dLambdaPtResolution", kTH2F, {axisInvPt, axisDeltaPt}); + histos.add(histodir + "/MC/pTReso/h3dLambdaPtResoVsTPCCR", "h3dLambdaPtResoVsTPCCR", kTH3F, {axisInvPt, axisDeltaPt, axisTPCrows}); + histos.add(histodir + "/MC/pTReso/h3dLambdaPtResoVsTPCCR", "h3dLambdaPtResoVsTPCCR", kTH3F, {axisInvPt, axisDeltaPt, axisTPCrows}); + histos.add(histodir + "/MC/pTReso/h2dAntiLambdaPtResolution", "h2dAntiLambdaPtResolution", kTH2F, {axisInvPt, axisDeltaPt}); + histos.add(histodir + "/MC/pTReso/h3dAntiLambdaPtResoVsTPCCR", "h3dAntiLambdaPtResoVsTPCCR", kTH3F, {axisInvPt, axisDeltaPt, axisTPCrows}); + histos.add(histodir + "/MC/pTReso/h3dAntiLambdaPtResoVsTPCCR", "h3dAntiLambdaPtResoVsTPCCR", kTH3F, {axisInvPt, axisDeltaPt, axisTPCrows}); + histos.add(histodir + "/MC/pTReso/h2dSigma0PtResolution", "h2dSigma0PtResolution", kTH2F, {axisInvPt, axisDeltaPt}); + histos.add(histodir + "/MC/pTReso/h2dAntiSigma0PtResolution", "h2dAntiSigma0PtResolution", kTH2F, {axisInvPt, axisDeltaPt}); } // For background decomposition study - if (fillBkgQAhistos){ - histos.add(histodir+"/MC/BkgStudy/h2dPtVsMassSigma_All", "h2dPtVsMassSigma_All", kTH2F, {axisPt, axisSigmaMass}); - histos.add(histodir+"/MC/BkgStudy/h2dPtVsMassSigma_TrueDaughters", "h2dPtVsMassSigma_TrueDaughters", kTH2F, {axisPt, axisSigmaMass}); - histos.add(histodir+"/MC/BkgStudy/h2dTrueDaughtersMatrix", "h2dTrueDaughtersMatrix", kTHnSparseD, {{10001, -5000.5f, +5000.5f}, {10001, -5000.5f, +5000.5f}}); - histos.add(histodir+"/MC/BkgStudy/h2dPtVsMassSigma_TrueGammaFakeLambda", "h2dPtVsMassSigma_TrueGammaFakeLambda", kTH2F, {axisPt, axisSigmaMass}); - histos.add(histodir+"/MC/BkgStudy/h2dPtVsMassSigma_FakeGammaTrueLambda", "h2dPtVsMassSigma_FakeGammaTrueLambda", kTH2F, {axisPt, axisSigmaMass}); - histos.add(histodir+"/MC/BkgStudy/h2dPtVsMassSigma_FakeDaughters", "h2dPtVsMassSigma_FakeDaughters", kTH2F, {axisPt, axisSigmaMass}); + if (fillBkgQAhistos) { + histos.add(histodir + "/MC/BkgStudy/h2dPtVsMassSigma_All", "h2dPtVsMassSigma_All", kTH2F, {axisPt, axisSigmaMass}); + histos.add(histodir + "/MC/BkgStudy/h2dPtVsMassSigma_TrueDaughters", "h2dPtVsMassSigma_TrueDaughters", kTH2F, {axisPt, axisSigmaMass}); + histos.add(histodir + "/MC/BkgStudy/h2dTrueDaughtersMatrix", "h2dTrueDaughtersMatrix", kTHnSparseD, {{10001, -5000.5f, +5000.5f}, {10001, -5000.5f, +5000.5f}}); + histos.add(histodir + "/MC/BkgStudy/h2dPtVsMassSigma_TrueGammaFakeLambda", "h2dPtVsMassSigma_TrueGammaFakeLambda", kTH2F, {axisPt, axisSigmaMass}); + histos.add(histodir + "/MC/BkgStudy/h2dPtVsMassSigma_FakeGammaTrueLambda", "h2dPtVsMassSigma_FakeGammaTrueLambda", kTH2F, {axisPt, axisSigmaMass}); + histos.add(histodir + "/MC/BkgStudy/h2dPtVsMassSigma_FakeDaughters", "h2dPtVsMassSigma_FakeDaughters", kTH2F, {axisPt, axisSigmaMass}); } } } - + // Selections histos.add("Selection/Photon/hCandidateSel", "hCandidateSel", kTH1F, {axisCandSel}); histos.add("Selection/Lambda/hCandidateSel", "hCandidateSel", kTH1F, {axisCandSel}); - + for (size_t i = 0; i < PhotonSels.size(); ++i) { const auto& sel = PhotonSels[i]; - + histos.add(Form("Selection/Photon/h2d%s", sel.c_str()), ("h2d" + sel).c_str(), kTH2F, {axisPt, axisPhotonMass}); - histos.get(HIST("Selection/Photon/hCandidateSel"))->GetXaxis()->SetBinLabel(i+1, sel.c_str()); + histos.get(HIST("Selection/Photon/hCandidateSel"))->GetXaxis()->SetBinLabel(i + 1, sel.c_str()); histos.add(Form("Selection/Sigma0/h2dPhoton%s", sel.c_str()), ("h2dPhoton" + sel).c_str(), kTH2F, {axisPt, axisSigmaMass}); } for (size_t i = 0; i < LambdaSels.size(); ++i) { const auto& sel = LambdaSels[i]; - + histos.add(Form("Selection/Lambda/h2d%s", sel.c_str()), ("h2d" + sel).c_str(), kTH2F, {axisPt, axisLambdaMass}); - histos.get(HIST("Selection/Lambda/hCandidateSel"))->GetXaxis()->SetBinLabel(i+1, sel.c_str()); + histos.get(HIST("Selection/Lambda/hCandidateSel"))->GetXaxis()->SetBinLabel(i + 1, sel.c_str()); histos.add(Form("Selection/Sigma0/h2dLambda%s", sel.c_str()), ("h2dLambda" + sel).c_str(), kTH2F, {axisPt, axisSigmaMass}); } - } - + //__________________________________________ template - int retrieveV0TrackCode(TV0Object const& sigma){ - + int retrieveV0TrackCode(TV0Object const& sigma) + { + int TrkCode = 10; // 1: TPC-only, 2: TPC+Something, 3: ITS-Only, 4: ITS+TPC + Something, 10: anything else - - if (isGamma){ - if (sigma.photonPosTrackCode()==1 && sigma.photonNegTrackCode()==1) + + if (isGamma) { + if (sigma.photonPosTrackCode() == 1 && sigma.photonNegTrackCode() == 1) TrkCode = 1; - if ((sigma.photonPosTrackCode()!=1 && sigma.photonNegTrackCode()==1) || (sigma.photonPosTrackCode()==1 && sigma.photonNegTrackCode()!=1)) + if ((sigma.photonPosTrackCode() != 1 && sigma.photonNegTrackCode() == 1) || (sigma.photonPosTrackCode() == 1 && sigma.photonNegTrackCode() != 1)) TrkCode = 2; - if (sigma.photonPosTrackCode()==3 && sigma.photonNegTrackCode()==3) + if (sigma.photonPosTrackCode() == 3 && sigma.photonNegTrackCode() == 3) TrkCode = 3; - if (sigma.photonPosTrackCode()==2 || sigma.photonNegTrackCode()==2) + if (sigma.photonPosTrackCode() == 2 || sigma.photonNegTrackCode() == 2) TrkCode = 4; - } - else{ - if (sigma.lambdaPosTrackCode()==1 && sigma.lambdaNegTrackCode()==1) - TrkCode = 1; - if ((sigma.lambdaPosTrackCode()!=1 && sigma.lambdaNegTrackCode()==1) || (sigma.lambdaPosTrackCode()==1 && sigma.lambdaNegTrackCode()!=1)) + } else { + if (sigma.lambdaPosTrackCode() == 1 && sigma.lambdaNegTrackCode() == 1) + TrkCode = 1; + if ((sigma.lambdaPosTrackCode() != 1 && sigma.lambdaNegTrackCode() == 1) || (sigma.lambdaPosTrackCode() == 1 && sigma.lambdaNegTrackCode() != 1)) TrkCode = 2; - if (sigma.lambdaPosTrackCode()==3 && sigma.lambdaNegTrackCode()==3) + if (sigma.lambdaPosTrackCode() == 3 && sigma.lambdaNegTrackCode() == 3) TrkCode = 3; - if (sigma.lambdaPosTrackCode()==2 || sigma.lambdaNegTrackCode()==2) + if (sigma.lambdaPosTrackCode() == 2 || sigma.lambdaNegTrackCode() == 2) TrkCode = 4; } - + return TrkCode; } - + template - void getpTResolution(TV0Object const& sigma){ + void getpTResolution(TV0Object const& sigma) + { //_______________________________________ // Gamma MC association - if (sigma.photonCandPDGCode() == 22) { + if (sigma.photonCandPDGCode() == 22) { if (sigma.photonMCPt() > 0) { histos.fill(HIST("BeforeSel/MC/pTReso/h3dGammaPtResoVsTPCCR"), 1.f / sigma.lambdaMCPt(), 1.f / sigma.lambdaPt() - 1.f / sigma.lambdaMCPt(), -1 * sigma.photonNegTPCCrossedRows()); // 1/pT resolution histos.fill(HIST("BeforeSel/MC/pTReso/h3dGammaPtResoVsTPCCR"), 1.f / sigma.lambdaMCPt(), 1.f / sigma.lambdaPt() - 1.f / sigma.lambdaMCPt(), sigma.photonPosTPCCrossedRows()); // 1/pT resolution @@ -401,7 +400,7 @@ struct sigmaanalysis { //_______________________________________ // Lambda MC association - if (sigma.lambdaCandPDGCode() == 3122) { + if (sigma.lambdaCandPDGCode() == 3122) { if (sigma.lambdaMCPt() > 0) { histos.fill(HIST("BeforeSel/MC/pTReso/h2dLambdaPtResolution"), 1.f / sigma.lambdaMCPt(), 1.f / sigma.lambdaPt() - 1.f / sigma.lambdaMCPt()); // 1/pT resolution histos.fill(HIST("BeforeSel/MC/pTReso/h3dLambdaPtResoVsTPCCR"), 1.f / sigma.lambdaMCPt(), 1.f / sigma.lambdaPt() - 1.f / sigma.lambdaMCPt(), -1 * sigma.lambdaNegTPCCrossedRows()); // 1/pT resolution @@ -416,7 +415,7 @@ struct sigmaanalysis { histos.fill(HIST("BeforeSel/MC/pTReso/h2dAntiLambdaPtResolution"), 1.f / sigma.lambdaMCPt(), 1.f / sigma.lambdaPt() - 1.f / sigma.lambdaMCPt()); // pT resolution histos.fill(HIST("BeforeSel/MC/pTReso/h3dAntiLambdaPtResoVsTPCCR"), 1.f / sigma.lambdaMCPt(), 1.f / sigma.lambdaPt() - 1.f / sigma.lambdaMCPt(), -1 * sigma.lambdaNegTPCCrossedRows()); // 1/pT resolution histos.fill(HIST("BeforeSel/MC/pTReso/h3dAntiLambdaPtResoVsTPCCR"), 1.f / sigma.lambdaMCPt(), 1.f / sigma.lambdaPt() - 1.f / sigma.lambdaMCPt(), sigma.lambdaPosTPCCrossedRows()); // 1/pT resolution - } + } } //_______________________________________ @@ -425,277 +424,271 @@ struct sigmaanalysis { if (sigma.sigmaMCPt() > 0) histos.fill(HIST("BeforeSel/MC/pTReso/h2dSigma0PtResolution"), 1.f / sigma.sigmaMCPt(), 1.f / sigma.sigmapT() - 1.f / sigma.sigmaMCPt()); // pT resolution } - if (sigma.isAntiSigma()) { + if (sigma.isAntiSigma()) { if (sigma.sigmaMCPt() > 0) histos.fill(HIST("BeforeSel/MC/pTReso/h2dAntiSigma0PtResolution"), 1.f / sigma.sigmaMCPt(), 1.f / sigma.sigmapT() - 1.f / sigma.sigmaMCPt()); // pT resolution - } + } } // To save histograms for background analysis template void runBkgAnalysis(TV0Object const& sigma) { - // Check whether it is before or after selections + // Check whether it is before or after selections static constexpr std::string_view MainDir[] = {"BeforeSel", "AfterSel"}; - - bool fIsSigma = sigma.isSigma(); + + bool fIsSigma = sigma.isSigma(); bool fIsAntiSigma = sigma.isAntiSigma(); - int PhotonPDGCode = sigma.photonCandPDGCode(); - int PhotonPDGCodeMother = sigma.photonCandPDGCodeMother(); - int LambdaPDGCode = sigma.lambdaCandPDGCode(); - int LambdaPDGCodeMother = sigma.lambdaCandPDGCodeMother(); + int PhotonPDGCode = sigma.photonCandPDGCode(); + int PhotonPDGCodeMother = sigma.photonCandPDGCodeMother(); + int LambdaPDGCode = sigma.lambdaCandPDGCode(); + int LambdaPDGCodeMother = sigma.lambdaCandPDGCodeMother(); float sigmapT = sigma.sigmapT(); float sigmaMass = sigma.sigmaMass(); - histos.fill(HIST(MainDir[mode])+HIST("/MC/BkgStudy/h2dPtVsMassSigma_All"), sigmapT, sigmaMass); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/BkgStudy/h2dPtVsMassSigma_All"), sigmapT, sigmaMass); - //_______________________________________ + //_______________________________________ // Real Gamma x Real Lambda - but not from the same sigma0/antisigma0! if ((PhotonPDGCode == 22) && ((LambdaPDGCode == 3122) || (LambdaPDGCode == -3122)) && (!fIsSigma && !fIsAntiSigma)) { - histos.fill(HIST(MainDir[mode])+HIST("/MC/BkgStudy/h2dPtVsMassSigma_TrueDaughters"), sigmapT, sigmaMass); - histos.fill(HIST(MainDir[mode])+HIST("/MC/BkgStudy/h2dTrueDaughtersMatrix"), LambdaPDGCodeMother, PhotonPDGCodeMother); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/BkgStudy/h2dPtVsMassSigma_TrueDaughters"), sigmapT, sigmaMass); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/BkgStudy/h2dTrueDaughtersMatrix"), LambdaPDGCodeMother, PhotonPDGCodeMother); } - //_______________________________________ + //_______________________________________ // Real Gamma x fake Lambda - if ((PhotonPDGCode == 22) && (LambdaPDGCode != 3122) && (LambdaPDGCode != -3122)) - histos.fill(HIST(MainDir[mode])+HIST("/MC/BkgStudy/h2dPtVsMassSigma_TrueGammaFakeLambda"), sigmapT, sigmaMass); - - //_______________________________________ + if ((PhotonPDGCode == 22) && (LambdaPDGCode != 3122) && (LambdaPDGCode != -3122)) + histos.fill(HIST(MainDir[mode]) + HIST("/MC/BkgStudy/h2dPtVsMassSigma_TrueGammaFakeLambda"), sigmapT, sigmaMass); + + //_______________________________________ // Fake Gamma x Real Lambda - if ((PhotonPDGCode != 22) && ((LambdaPDGCode == 3122) || (LambdaPDGCode == -3122))) - histos.fill(HIST(MainDir[mode])+HIST("/MC/BkgStudy/h2dPtVsMassSigma_FakeGammaTrueLambda"), sigmapT, sigmaMass); + if ((PhotonPDGCode != 22) && ((LambdaPDGCode == 3122) || (LambdaPDGCode == -3122))) + histos.fill(HIST(MainDir[mode]) + HIST("/MC/BkgStudy/h2dPtVsMassSigma_FakeGammaTrueLambda"), sigmapT, sigmaMass); - //_______________________________________ + //_______________________________________ // Fake Gamma x Fake Lambda - if ((PhotonPDGCode != 22) && (LambdaPDGCode != 3122) && (LambdaPDGCode != -3122)) - histos.fill(HIST(MainDir[mode])+HIST("/MC/BkgStudy/h2dPtVsMassSigma_FakeDaughters"), sigmapT, sigmaMass); + if ((PhotonPDGCode != 22) && (LambdaPDGCode != 3122) && (LambdaPDGCode != -3122)) + histos.fill(HIST(MainDir[mode]) + HIST("/MC/BkgStudy/h2dPtVsMassSigma_FakeDaughters"), sigmapT, sigmaMass); } - template - void fillQAHistos(TV0Object const& sigma){ - + template + void fillQAHistos(TV0Object const& sigma) + { + // Check whether it is before or after selections // static std::string main_dir; // main_dir = IsBeforeSel ? "BeforeSel" : "AfterSel"; static constexpr std::string_view MainDir[] = {"BeforeSel", "AfterSel"}; - - // Get V0trackCode + + // Get V0trackCode int GammaTrkCode = retrieveV0TrackCode(sigma); int LambdaTrkCode = retrieveV0TrackCode(sigma); - + float photonRZLineCut = TMath::Abs(sigma.photonZconv()) * TMath::Tan(2 * TMath::ATan(TMath::Exp(-PhotonMaxDauEta))) - PhotonLineCutZ0; - //_______________________________________ - // Photon - histos.fill(HIST(MainDir[mode])+HIST("/Photon/hTrackCode"), GammaTrkCode); - histos.fill(HIST(MainDir[mode])+HIST("/Photon/hV0Type"), sigma.photonV0Type()); - histos.fill(HIST(MainDir[mode])+HIST("/Photon/hNegpT"), sigma.photonNegPt()); - histos.fill(HIST(MainDir[mode])+HIST("/Photon/hPospT"), sigma.photonPosPt()); - histos.fill(HIST(MainDir[mode])+HIST("/Photon/hDCANegToPV"), sigma.photonDCANegPV()); - histos.fill(HIST(MainDir[mode])+HIST("/Photon/hDCAPosToPV"), sigma.photonDCAPosPV()); - histos.fill(HIST(MainDir[mode])+HIST("/Photon/hDCADau"), sigma.photonDCADau()); - histos.fill(HIST(MainDir[mode])+HIST("/Photon/hPosTPCCR"), sigma.photonPosTPCCrossedRows()); - histos.fill(HIST(MainDir[mode])+HIST("/Photon/hNegTPCCR"), sigma.photonNegTPCCrossedRows()); - histos.fill(HIST(MainDir[mode])+HIST("/Photon/h2dPosTPCNSigmaEl"), sigma.photonPosPt(), sigma.photonPosTPCNSigmaEl()); - histos.fill(HIST(MainDir[mode])+HIST("/Photon/h2dNegTPCNSigmaEl"), sigma.photonNegPt(), sigma.photonNegTPCNSigmaEl()); - histos.fill(HIST(MainDir[mode])+HIST("/Photon/h2dPosTPCNSigmaPi"), sigma.photonPosPt(), sigma.photonPosTPCNSigmaPi()); - histos.fill(HIST(MainDir[mode])+HIST("/Photon/h2dNegTPCNSigmaPi"), sigma.photonNegPt(), sigma.photonNegTPCNSigmaPi()); - histos.fill(HIST(MainDir[mode])+HIST("/Photon/hpT"), sigma.photonPt()); - histos.fill(HIST(MainDir[mode])+HIST("/Photon/hY"), sigma.photonY()); - histos.fill(HIST(MainDir[mode])+HIST("/Photon/hPosEta"), sigma.photonPosEta()); - histos.fill(HIST(MainDir[mode])+HIST("/Photon/hNegEta"), sigma.photonNegEta()); - histos.fill(HIST(MainDir[mode])+HIST("/Photon/hRadius"), sigma.photonRadius()); - histos.fill(HIST(MainDir[mode])+HIST("/Photon/hZ"), sigma.photonZconv()); - histos.fill(HIST(MainDir[mode])+HIST("/Photon/h2dRZCut"), sigma.photonRadius(), photonRZLineCut); - histos.fill(HIST(MainDir[mode])+HIST("/Photon/h2dRZPlane"), sigma.photonZconv(), sigma.photonRadius()); - histos.fill(HIST(MainDir[mode])+HIST("/Photon/hCosPA"), sigma.photonCosPA()); - histos.fill(HIST(MainDir[mode])+HIST("/Photon/hPsiPair"), sigma.photonPsiPair()); - histos.fill(HIST(MainDir[mode])+HIST("/Photon/hPhi"), sigma.photonPhi()); - histos.fill(HIST(MainDir[mode])+HIST("/Photon/h3dMass"), sigma.sigmaCentrality(), sigma.photonPt(), sigma.photonMass()); - histos.fill(HIST(MainDir[mode])+HIST("/Photon/hMass"), sigma.photonMass()); + //_______________________________________ + // Photon + histos.fill(HIST(MainDir[mode]) + HIST("/Photon/hTrackCode"), GammaTrkCode); + histos.fill(HIST(MainDir[mode]) + HIST("/Photon/hV0Type"), sigma.photonV0Type()); + histos.fill(HIST(MainDir[mode]) + HIST("/Photon/hNegpT"), sigma.photonNegPt()); + histos.fill(HIST(MainDir[mode]) + HIST("/Photon/hPospT"), sigma.photonPosPt()); + histos.fill(HIST(MainDir[mode]) + HIST("/Photon/hDCANegToPV"), sigma.photonDCANegPV()); + histos.fill(HIST(MainDir[mode]) + HIST("/Photon/hDCAPosToPV"), sigma.photonDCAPosPV()); + histos.fill(HIST(MainDir[mode]) + HIST("/Photon/hDCADau"), sigma.photonDCADau()); + histos.fill(HIST(MainDir[mode]) + HIST("/Photon/hPosTPCCR"), sigma.photonPosTPCCrossedRows()); + histos.fill(HIST(MainDir[mode]) + HIST("/Photon/hNegTPCCR"), sigma.photonNegTPCCrossedRows()); + histos.fill(HIST(MainDir[mode]) + HIST("/Photon/h2dPosTPCNSigmaEl"), sigma.photonPosPt(), sigma.photonPosTPCNSigmaEl()); + histos.fill(HIST(MainDir[mode]) + HIST("/Photon/h2dNegTPCNSigmaEl"), sigma.photonNegPt(), sigma.photonNegTPCNSigmaEl()); + histos.fill(HIST(MainDir[mode]) + HIST("/Photon/h2dPosTPCNSigmaPi"), sigma.photonPosPt(), sigma.photonPosTPCNSigmaPi()); + histos.fill(HIST(MainDir[mode]) + HIST("/Photon/h2dNegTPCNSigmaPi"), sigma.photonNegPt(), sigma.photonNegTPCNSigmaPi()); + histos.fill(HIST(MainDir[mode]) + HIST("/Photon/hpT"), sigma.photonPt()); + histos.fill(HIST(MainDir[mode]) + HIST("/Photon/hY"), sigma.photonY()); + histos.fill(HIST(MainDir[mode]) + HIST("/Photon/hPosEta"), sigma.photonPosEta()); + histos.fill(HIST(MainDir[mode]) + HIST("/Photon/hNegEta"), sigma.photonNegEta()); + histos.fill(HIST(MainDir[mode]) + HIST("/Photon/hRadius"), sigma.photonRadius()); + histos.fill(HIST(MainDir[mode]) + HIST("/Photon/hZ"), sigma.photonZconv()); + histos.fill(HIST(MainDir[mode]) + HIST("/Photon/h2dRZCut"), sigma.photonRadius(), photonRZLineCut); + histos.fill(HIST(MainDir[mode]) + HIST("/Photon/h2dRZPlane"), sigma.photonZconv(), sigma.photonRadius()); + histos.fill(HIST(MainDir[mode]) + HIST("/Photon/hCosPA"), sigma.photonCosPA()); + histos.fill(HIST(MainDir[mode]) + HIST("/Photon/hPsiPair"), sigma.photonPsiPair()); + histos.fill(HIST(MainDir[mode]) + HIST("/Photon/hPhi"), sigma.photonPhi()); + histos.fill(HIST(MainDir[mode]) + HIST("/Photon/h3dMass"), sigma.sigmaCentrality(), sigma.photonPt(), sigma.photonMass()); + histos.fill(HIST(MainDir[mode]) + HIST("/Photon/hMass"), sigma.photonMass()); //_______________________________________ - // Lambdas - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/hTrackCode"), LambdaTrkCode); - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/hRadius"), sigma.lambdaRadius()); - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/hDCADau"), sigma.lambdaDCADau()); - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/hCosPA"), sigma.lambdaCosPA()); - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/hY"), sigma.lambdaY()); - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/hPosEta"), sigma.lambdaPosEta()); - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/hNegEta"), sigma.lambdaNegEta()); - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/hPosTPCCR"), sigma.lambdaPosTPCCrossedRows()); - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/hNegTPCCR"), sigma.lambdaNegTPCCrossedRows()); - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/hPosITSCls"), sigma.lambdaPosITSCls()); - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/hNegITSCls"), sigma.lambdaNegITSCls()); - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/hPosChi2PerNc"), sigma.lambdaPosChi2PerNcl()); - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/hNegChi2PerNc"), sigma.lambdaNegChi2PerNcl()); - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/hLifeTime"), sigma.lambdaLifeTime()); - + // Lambdas + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/hTrackCode"), LambdaTrkCode); + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/hRadius"), sigma.lambdaRadius()); + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/hDCADau"), sigma.lambdaDCADau()); + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/hCosPA"), sigma.lambdaCosPA()); + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/hY"), sigma.lambdaY()); + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/hPosEta"), sigma.lambdaPosEta()); + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/hNegEta"), sigma.lambdaNegEta()); + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/hPosTPCCR"), sigma.lambdaPosTPCCrossedRows()); + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/hNegTPCCR"), sigma.lambdaNegTPCCrossedRows()); + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/hPosITSCls"), sigma.lambdaPosITSCls()); + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/hNegITSCls"), sigma.lambdaNegITSCls()); + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/hPosChi2PerNc"), sigma.lambdaPosChi2PerNcl()); + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/hNegChi2PerNc"), sigma.lambdaNegChi2PerNcl()); + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/hLifeTime"), sigma.lambdaLifeTime()); + //_______________________________________ // Sigmas and Lambdas - histos.fill(HIST(MainDir[mode])+HIST("/h2dArmenteros"), sigma.photonAlpha(), sigma.photonQt()); - histos.fill(HIST(MainDir[mode])+HIST("/h2dArmenteros"), sigma.lambdaAlpha(), sigma.lambdaQt()); - - if (sigma.lambdaAlpha() > 0) { - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/h2dTPCvsTOFNSigma_LambdaPr"), sigma.lambdaPosPrTPCNSigma(), sigma.lambdaPrTOFNSigma()); - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/h2dTPCvsTOFNSigma_LambdaPi"), sigma.lambdaNegPiTPCNSigma(), sigma.lambdaPiTOFNSigma()); - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/hLambdaDCANegToPV"), sigma.lambdaDCANegPV()); - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/hLambdaDCAPosToPV"), sigma.lambdaDCAPosPV()); - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/hLambdapT"), sigma.lambdaPt()); - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/hLambdaMass"), sigma.lambdaMass()); - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/h3dLambdaMass"), sigma.sigmaCentrality(), sigma.lambdaPt(), sigma.lambdaMass()); - - histos.fill(HIST(MainDir[mode])+HIST("/Sigma0/hMass"), sigma.sigmaMass()); - histos.fill(HIST(MainDir[mode])+HIST("/Sigma0/hPt"), sigma.sigmapT()); - histos.fill(HIST(MainDir[mode])+HIST("/Sigma0/hY"), sigma.sigmaRapidity()); - histos.fill(HIST(MainDir[mode])+HIST("/Sigma0/h3dMass"), sigma.sigmaCentrality(), sigma.sigmapT(), sigma.sigmaMass()); - histos.fill(HIST(MainDir[mode])+HIST("/Sigma0/h3dPhotonRadiusVsMassSigma"), sigma.sigmaCentrality(), sigma.photonRadius(), sigma.sigmaMass()); - histos.fill(HIST(MainDir[mode])+HIST("/Sigma0/h2dpTVsOPAngle"), sigma.sigmapT(), sigma.sigmaOPAngle()); - } - else{ - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/h2dTPCvsTOFNSigma_ALambdaPr"), sigma.lambdaNegPrTPCNSigma(), sigma.aLambdaPrTOFNSigma()); - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/h2dTPCvsTOFNSigma_ALambdaPi"), sigma.lambdaPosPiTPCNSigma(), sigma.aLambdaPiTOFNSigma()); - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/hALambdaDCANegToPV"), sigma.lambdaDCANegPV()); - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/hALambdaDCAPosToPV"), sigma.lambdaDCAPosPV()); - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/hALambdapT"), sigma.lambdaPt()); - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/hAntiLambdaMass"), sigma.antilambdaMass()); - histos.fill(HIST(MainDir[mode])+HIST("/Lambda/h3dAntiLambdaMass"), sigma.sigmaCentrality(), sigma.lambdaPt(), sigma.antilambdaMass()); - - histos.fill(HIST(MainDir[mode])+HIST("/ASigma0/hMass"), sigma.sigmaMass()); - histos.fill(HIST(MainDir[mode])+HIST("/ASigma0/hPt"), sigma.sigmapT()); - histos.fill(HIST(MainDir[mode])+HIST("/ASigma0/hY"), sigma.sigmaRapidity()); - histos.fill(HIST(MainDir[mode])+HIST("/ASigma0/h3dMass"), sigma.sigmaCentrality(), sigma.sigmapT(), sigma.sigmaMass()); - histos.fill(HIST(MainDir[mode])+HIST("/ASigma0/h3dPhotonRadiusVsMassSigma"), sigma.sigmaCentrality(), sigma.photonRadius(), sigma.sigmaMass()); - histos.fill(HIST(MainDir[mode])+HIST("/ASigma0/h2dpTVsOPAngle"), sigma.sigmapT(), sigma.sigmaOPAngle()); + histos.fill(HIST(MainDir[mode]) + HIST("/h2dArmenteros"), sigma.photonAlpha(), sigma.photonQt()); + histos.fill(HIST(MainDir[mode]) + HIST("/h2dArmenteros"), sigma.lambdaAlpha(), sigma.lambdaQt()); + + if (sigma.lambdaAlpha() > 0) { + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/h2dTPCvsTOFNSigma_LambdaPr"), sigma.lambdaPosPrTPCNSigma(), sigma.lambdaPrTOFNSigma()); + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/h2dTPCvsTOFNSigma_LambdaPi"), sigma.lambdaNegPiTPCNSigma(), sigma.lambdaPiTOFNSigma()); + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/hLambdaDCANegToPV"), sigma.lambdaDCANegPV()); + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/hLambdaDCAPosToPV"), sigma.lambdaDCAPosPV()); + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/hLambdapT"), sigma.lambdaPt()); + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/hLambdaMass"), sigma.lambdaMass()); + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/h3dLambdaMass"), sigma.sigmaCentrality(), sigma.lambdaPt(), sigma.lambdaMass()); + + histos.fill(HIST(MainDir[mode]) + HIST("/Sigma0/hMass"), sigma.sigmaMass()); + histos.fill(HIST(MainDir[mode]) + HIST("/Sigma0/hPt"), sigma.sigmapT()); + histos.fill(HIST(MainDir[mode]) + HIST("/Sigma0/hY"), sigma.sigmaRapidity()); + histos.fill(HIST(MainDir[mode]) + HIST("/Sigma0/h3dMass"), sigma.sigmaCentrality(), sigma.sigmapT(), sigma.sigmaMass()); + histos.fill(HIST(MainDir[mode]) + HIST("/Sigma0/h3dPhotonRadiusVsMassSigma"), sigma.sigmaCentrality(), sigma.photonRadius(), sigma.sigmaMass()); + histos.fill(HIST(MainDir[mode]) + HIST("/Sigma0/h2dpTVsOPAngle"), sigma.sigmapT(), sigma.sigmaOPAngle()); + } else { + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/h2dTPCvsTOFNSigma_ALambdaPr"), sigma.lambdaNegPrTPCNSigma(), sigma.aLambdaPrTOFNSigma()); + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/h2dTPCvsTOFNSigma_ALambdaPi"), sigma.lambdaPosPiTPCNSigma(), sigma.aLambdaPiTOFNSigma()); + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/hALambdaDCANegToPV"), sigma.lambdaDCANegPV()); + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/hALambdaDCAPosToPV"), sigma.lambdaDCAPosPV()); + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/hALambdapT"), sigma.lambdaPt()); + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/hAntiLambdaMass"), sigma.antilambdaMass()); + histos.fill(HIST(MainDir[mode]) + HIST("/Lambda/h3dAntiLambdaMass"), sigma.sigmaCentrality(), sigma.lambdaPt(), sigma.antilambdaMass()); + + histos.fill(HIST(MainDir[mode]) + HIST("/ASigma0/hMass"), sigma.sigmaMass()); + histos.fill(HIST(MainDir[mode]) + HIST("/ASigma0/hPt"), sigma.sigmapT()); + histos.fill(HIST(MainDir[mode]) + HIST("/ASigma0/hY"), sigma.sigmaRapidity()); + histos.fill(HIST(MainDir[mode]) + HIST("/ASigma0/h3dMass"), sigma.sigmaCentrality(), sigma.sigmapT(), sigma.sigmaMass()); + histos.fill(HIST(MainDir[mode]) + HIST("/ASigma0/h3dPhotonRadiusVsMassSigma"), sigma.sigmaCentrality(), sigma.photonRadius(), sigma.sigmaMass()); + histos.fill(HIST(MainDir[mode]) + HIST("/ASigma0/h2dpTVsOPAngle"), sigma.sigmapT(), sigma.sigmaOPAngle()); } //_______________________________________ - // MC specific + // MC specific if (doprocessMonteCarlo) { - if constexpr (requires { sigma.lambdaCandPDGCode(); sigma.photonCandPDGCode(); }){ - + if constexpr (requires { sigma.lambdaCandPDGCode(); sigma.photonCandPDGCode(); }) { + //_______________________________________ // Gamma MC association - if (sigma.photonCandPDGCode()==22){ - histos.fill(HIST(MainDir[mode])+HIST("/MC/Photon/hV0ToCollAssoc"), sigma.photonIsCorrectlyAssoc()); - histos.fill(HIST(MainDir[mode])+HIST("/MC/Photon/hPt"), sigma.photonPt()); - histos.fill(HIST(MainDir[mode])+HIST("/MC/Photon/hMCPt"), sigma.photonMCPt()); - - histos.fill(HIST(MainDir[mode])+HIST("/MC/Photon/h2dPosTPCNSigmaEl"), sigma.photonPosPt(), sigma.photonPosTPCNSigmaEl()); - histos.fill(HIST(MainDir[mode])+HIST("/MC/Photon/h2dNegTPCNSigmaEl"), sigma.photonNegPt(), sigma.photonNegTPCNSigmaEl()); - histos.fill(HIST(MainDir[mode])+HIST("/MC/Photon/h2dPosTPCNSigmaPi"), sigma.photonPosPt(), sigma.photonPosTPCNSigmaPi()); - histos.fill(HIST(MainDir[mode])+HIST("/MC/Photon/h2dNegTPCNSigmaPi"), sigma.photonNegPt(), sigma.photonNegTPCNSigmaPi()); - - histos.fill(HIST(MainDir[mode])+HIST("/MC/Photon/h2dIRVsPt"), sigma.sigmaIR(), sigma.photonMCPt()); - histos.fill(HIST(MainDir[mode])+HIST("/MC/Photon/h3dPAVsIRVsPt"), TMath::ACos(sigma.photonCosPA()), sigma.sigmaIR(), sigma.photonMCPt()); - - if (!sigma.photonIsCorrectlyAssoc()){ - histos.fill(HIST(MainDir[mode])+HIST("/MC/Photon/h2dIRVsPt_BadCollAssig"), sigma.sigmaIR(), sigma.photonMCPt()); - histos.fill(HIST(MainDir[mode])+HIST("/MC/Photon/h3dPAVsIRVsPt_BadCollAssig"), TMath::ACos(sigma.photonCosPA()), sigma.sigmaIR(), sigma.photonMCPt()); + if (sigma.photonCandPDGCode() == 22) { + histos.fill(HIST(MainDir[mode]) + HIST("/MC/Photon/hV0ToCollAssoc"), sigma.photonIsCorrectlyAssoc()); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/Photon/hPt"), sigma.photonPt()); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/Photon/hMCPt"), sigma.photonMCPt()); + + histos.fill(HIST(MainDir[mode]) + HIST("/MC/Photon/h2dPosTPCNSigmaEl"), sigma.photonPosPt(), sigma.photonPosTPCNSigmaEl()); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/Photon/h2dNegTPCNSigmaEl"), sigma.photonNegPt(), sigma.photonNegTPCNSigmaEl()); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/Photon/h2dPosTPCNSigmaPi"), sigma.photonPosPt(), sigma.photonPosTPCNSigmaPi()); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/Photon/h2dNegTPCNSigmaPi"), sigma.photonNegPt(), sigma.photonNegTPCNSigmaPi()); + + histos.fill(HIST(MainDir[mode]) + HIST("/MC/Photon/h2dIRVsPt"), sigma.sigmaIR(), sigma.photonMCPt()); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/Photon/h3dPAVsIRVsPt"), TMath::ACos(sigma.photonCosPA()), sigma.sigmaIR(), sigma.photonMCPt()); + + if (!sigma.photonIsCorrectlyAssoc()) { + histos.fill(HIST(MainDir[mode]) + HIST("/MC/Photon/h2dIRVsPt_BadCollAssig"), sigma.sigmaIR(), sigma.photonMCPt()); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/Photon/h3dPAVsIRVsPt_BadCollAssig"), TMath::ACos(sigma.photonCosPA()), sigma.sigmaIR(), sigma.photonMCPt()); } } //_______________________________________ // Lambda MC association - if (sigma.lambdaCandPDGCode()==3122){ - histos.fill(HIST(MainDir[mode])+HIST("/MC/Lambda/hV0ToCollAssoc"), sigma.lambdaIsCorrectlyAssoc()); - histos.fill(HIST(MainDir[mode])+HIST("/MC/Lambda/hPt"), sigma.lambdaPt()); - histos.fill(HIST(MainDir[mode])+HIST("/MC/Lambda/hMCPt"), sigma.lambdaMCPt()); - histos.fill(HIST(MainDir[mode])+HIST("/MC/Lambda/h3dTPCvsTOFNSigma_Pr"), sigma.lambdaPosPrTPCNSigma(), sigma.lambdaPrTOFNSigma(), sigma.lambdaPt()); - histos.fill(HIST(MainDir[mode])+HIST("/MC/Lambda/h3dTPCvsTOFNSigma_Pi"), sigma.lambdaNegPiTPCNSigma(), sigma.lambdaPiTOFNSigma(), sigma.lambdaPt()); + if (sigma.lambdaCandPDGCode() == 3122) { + histos.fill(HIST(MainDir[mode]) + HIST("/MC/Lambda/hV0ToCollAssoc"), sigma.lambdaIsCorrectlyAssoc()); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/Lambda/hPt"), sigma.lambdaPt()); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/Lambda/hMCPt"), sigma.lambdaMCPt()); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/Lambda/h3dTPCvsTOFNSigma_Pr"), sigma.lambdaPosPrTPCNSigma(), sigma.lambdaPrTOFNSigma(), sigma.lambdaPt()); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/Lambda/h3dTPCvsTOFNSigma_Pi"), sigma.lambdaNegPiTPCNSigma(), sigma.lambdaPiTOFNSigma(), sigma.lambdaPt()); } //_______________________________________ // AntiLambda MC association - if (sigma.lambdaCandPDGCode() == -3122){ - histos.fill(HIST(MainDir[mode])+HIST("/MC/ALambda/hV0ToCollAssoc"), sigma.lambdaIsCorrectlyAssoc()); - histos.fill(HIST(MainDir[mode])+HIST("/MC/ALambda/hPt"), sigma.lambdaPt()); - histos.fill(HIST(MainDir[mode])+HIST("/MC/ALambda/hMCPt"), sigma.lambdaMCPt()); - histos.fill(HIST(MainDir[mode])+HIST("/MC/ALambda/h3dTPCvsTOFNSigma_Pr"), sigma.lambdaNegPrTPCNSigma(), sigma.aLambdaPrTOFNSigma(), sigma.lambdaPt()); - histos.fill(HIST(MainDir[mode])+HIST("/MC/ALambda/h3dTPCvsTOFNSigma_Pi"), sigma.lambdaPosPiTPCNSigma(), sigma.aLambdaPiTOFNSigma(), sigma.lambdaPt()); + if (sigma.lambdaCandPDGCode() == -3122) { + histos.fill(HIST(MainDir[mode]) + HIST("/MC/ALambda/hV0ToCollAssoc"), sigma.lambdaIsCorrectlyAssoc()); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/ALambda/hPt"), sigma.lambdaPt()); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/ALambda/hMCPt"), sigma.lambdaMCPt()); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/ALambda/h3dTPCvsTOFNSigma_Pr"), sigma.lambdaNegPrTPCNSigma(), sigma.aLambdaPrTOFNSigma(), sigma.lambdaPt()); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/ALambda/h3dTPCvsTOFNSigma_Pi"), sigma.lambdaPosPiTPCNSigma(), sigma.aLambdaPiTOFNSigma(), sigma.lambdaPt()); } //_______________________________________ // Sigma0 MC association - if (sigma.isSigma()){ - histos.fill(HIST(MainDir[mode])+HIST("/MC/h2dArmenteros"), sigma.photonAlpha(), sigma.photonQt()); - histos.fill(HIST(MainDir[mode])+HIST("/MC/h2dArmenteros"), sigma.lambdaAlpha(), sigma.lambdaQt()); - - histos.fill(HIST(MainDir[mode])+HIST("/MC/Sigma0/hPt"), sigma.sigmapT()); - histos.fill(HIST(MainDir[mode])+HIST("/MC/Sigma0/hMCPt"), sigma.sigmaMCPt()); - histos.fill(HIST(MainDir[mode])+HIST("/MC/Sigma0/h2dMCPtVsLambdaMCPt"), sigma.sigmaMCPt(), sigma.lambdaMCPt()); - histos.fill(HIST(MainDir[mode])+HIST("/MC/Sigma0/h2dMCPtVsGammaMCPt"), sigma.sigmaMCPt(), sigma.photonMCPt()); - histos.fill(HIST(MainDir[mode])+HIST("/MC/Sigma0/hMass"), sigma.sigmaMass()); - histos.fill(HIST(MainDir[mode])+HIST("/MC/Sigma0/h3dMass"), sigma.sigmaCentrality(), sigma.sigmapT(), sigma.sigmaMass()); - + if (sigma.isSigma()) { + histos.fill(HIST(MainDir[mode]) + HIST("/MC/h2dArmenteros"), sigma.photonAlpha(), sigma.photonQt()); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/h2dArmenteros"), sigma.lambdaAlpha(), sigma.lambdaQt()); + + histos.fill(HIST(MainDir[mode]) + HIST("/MC/Sigma0/hPt"), sigma.sigmapT()); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/Sigma0/hMCPt"), sigma.sigmaMCPt()); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/Sigma0/h2dMCPtVsLambdaMCPt"), sigma.sigmaMCPt(), sigma.lambdaMCPt()); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/Sigma0/h2dMCPtVsGammaMCPt"), sigma.sigmaMCPt(), sigma.photonMCPt()); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/Sigma0/hMass"), sigma.sigmaMass()); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/Sigma0/h3dMass"), sigma.sigmaCentrality(), sigma.sigmapT(), sigma.sigmaMass()); } //_______________________________________ // AntiSigma0 MC association - if (sigma.isAntiSigma()){ - histos.fill(HIST(MainDir[mode])+HIST("/MC/h2dArmenteros"), sigma.photonAlpha(), sigma.photonQt()); - histos.fill(HIST(MainDir[mode])+HIST("/MC/h2dArmenteros"), sigma.lambdaAlpha(), sigma.lambdaQt()); - - histos.fill(HIST(MainDir[mode])+HIST("/MC/ASigma0/hPt"), sigma.sigmapT()); - histos.fill(HIST(MainDir[mode])+HIST("/MC/ASigma0/hMCPt"), sigma.sigmaMCPt()); - histos.fill(HIST(MainDir[mode])+HIST("/MC/ASigma0/h2dMCPtVsLambdaMCPt"), sigma.sigmaMCPt(), sigma.lambdaMCPt()); - histos.fill(HIST(MainDir[mode])+HIST("/MC/ASigma0/h2dMCPtVsPhotonMCPt"), sigma.sigmaMCPt(), sigma.photonMCPt()); - histos.fill(HIST(MainDir[mode])+HIST("/MC/ASigma0/hMass"), sigma.sigmaMass()); - histos.fill(HIST(MainDir[mode])+HIST("/MC/ASigma0/h3dMass"), sigma.sigmaCentrality(), sigma.sigmapT(), sigma.sigmaMass()); - + if (sigma.isAntiSigma()) { + histos.fill(HIST(MainDir[mode]) + HIST("/MC/h2dArmenteros"), sigma.photonAlpha(), sigma.photonQt()); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/h2dArmenteros"), sigma.lambdaAlpha(), sigma.lambdaQt()); + + histos.fill(HIST(MainDir[mode]) + HIST("/MC/ASigma0/hPt"), sigma.sigmapT()); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/ASigma0/hMCPt"), sigma.sigmaMCPt()); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/ASigma0/h2dMCPtVsLambdaMCPt"), sigma.sigmaMCPt(), sigma.lambdaMCPt()); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/ASigma0/h2dMCPtVsPhotonMCPt"), sigma.sigmaMCPt(), sigma.photonMCPt()); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/ASigma0/hMass"), sigma.sigmaMass()); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/ASigma0/h3dMass"), sigma.sigmaCentrality(), sigma.sigmapT(), sigma.sigmaMass()); } - + // For background studies: - if (fillBkgQAhistos) - runBkgAnalysis(sigma); + if (fillBkgQAhistos) + runBkgAnalysis(sigma); - //_______________________________________ + //_______________________________________ // pT resolution histos - if ((mode==0) && fillpTResoQAhistos) - getpTResolution(sigma); - - } - } + if ((mode == 0) && fillpTResoQAhistos) + getpTResolution(sigma); + } + } } template - void fillSelHistos(TV0Object const& sigma, int PDGRequired){ - - static constexpr std::string_view PhotonSelsLocal[] = {"NoSel", "V0Type", "DaupT", "DCADauToPV", - "DCADau", "DauTPCCR", "TPCNSigmaEl", "V0pT", - "Y", "V0Radius", "RZCut", "Armenteros", "CosPA", - "PsiPair", "Phi", "Mass"}; - - static constexpr std::string_view LambdaSelsLocal[] = {"NoSel", "V0Radius", "DCADau", "Armenteros", - "CosPA", "Y", "TPCCR", "DauITSCls", "Lifetime", + void fillSelHistos(TV0Object const& sigma, int PDGRequired) + { + + static constexpr std::string_view PhotonSelsLocal[] = {"NoSel", "V0Type", "DaupT", "DCADauToPV", + "DCADau", "DauTPCCR", "TPCNSigmaEl", "V0pT", + "Y", "V0Radius", "RZCut", "Armenteros", "CosPA", + "PsiPair", "Phi", "Mass"}; + + static constexpr std::string_view LambdaSelsLocal[] = {"NoSel", "V0Radius", "DCADau", "Armenteros", + "CosPA", "Y", "TPCCR", "DauITSCls", "Lifetime", "TPCTOFPID", "DCADauToPV", "Mass"}; - - - - if (PDGRequired==22){ - if constexpr (selection_index >= 0 && selection_index < (int)std::size(PhotonSelsLocal)){ + + if (PDGRequired == 22) { + if constexpr (selection_index >= 0 && selection_index < (int)std::size(PhotonSelsLocal)) { histos.fill(HIST("Selection/Photon/hCandidateSel"), selection_index); - histos.fill(HIST("Selection/Photon/h2d")+HIST(PhotonSelsLocal[selection_index]), sigma.photonPt(), sigma.photonMass()); - histos.fill(HIST("Selection/Sigma0/h2dPhoton")+HIST(PhotonSelsLocal[selection_index]), sigma.sigmapT(), sigma.sigmaMass()); + histos.fill(HIST("Selection/Photon/h2d") + HIST(PhotonSelsLocal[selection_index]), sigma.photonPt(), sigma.photonMass()); + histos.fill(HIST("Selection/Sigma0/h2dPhoton") + HIST(PhotonSelsLocal[selection_index]), sigma.sigmapT(), sigma.sigmaMass()); } - } - - if (PDGRequired==3122){ - if constexpr (selection_index >= 0 && selection_index < (int)std::size(LambdaSelsLocal)){ + + if (PDGRequired == 3122) { + if constexpr (selection_index >= 0 && selection_index < (int)std::size(LambdaSelsLocal)) { histos.fill(HIST("Selection/Lambda/hCandidateSel"), selection_index); - histos.fill(HIST("Selection/Lambda/h2d")+HIST(LambdaSelsLocal[selection_index]), sigma.lambdaPt(), sigma.lambdaMass()); - histos.fill(HIST("Selection/Sigma0/h2dLambda")+HIST(LambdaSelsLocal[selection_index]), sigma.sigmapT(), sigma.sigmaMass()); + histos.fill(HIST("Selection/Lambda/h2d") + HIST(LambdaSelsLocal[selection_index]), sigma.lambdaPt(), sigma.lambdaMass()); + histos.fill(HIST("Selection/Sigma0/h2dLambda") + HIST(LambdaSelsLocal[selection_index]), sigma.sigmapT(), sigma.sigmaMass()); } - - } + } } - + // Apply specific selections for photons template bool selectPhoton(TV0Object const& cand) { - fillSelHistos<0>(cand, 22); + fillSelHistos<0>(cand, 22); if (cand.photonV0Type() != Photonv0TypeSel && Photonv0TypeSel > -1) return false; @@ -714,14 +707,14 @@ struct sigmaanalysis { fillSelHistos<4>(cand, 22); if ((cand.photonPosTPCCrossedRows() < PhotonMinTPCCrossedRows) || (cand.photonNegTPCCrossedRows() < PhotonMinTPCCrossedRows)) return false; - + fillSelHistos<5>(cand, 22); if (((cand.photonPosTPCNSigmaEl() < PhotonMinTPCNSigmas) || (cand.photonPosTPCNSigmaEl() > PhotonMaxTPCNSigmas))) return false; - + if (((cand.photonNegTPCNSigmaEl() < PhotonMinTPCNSigmas) || (cand.photonNegTPCNSigmaEl() > PhotonMaxTPCNSigmas))) return false; - + fillSelHistos<6>(cand, 22); if ((cand.photonPt() < PhotonMinPt) || (cand.photonPt() > PhotonMaxPt)) return false; @@ -735,14 +728,14 @@ struct sigmaanalysis { return false; fillSelHistos<9>(cand, 22); - float photonRZLineCut = TMath::Abs(cand.photonZconv()) * TMath::Tan(2 * TMath::ATan(TMath::Exp(-PhotonMaxDauEta))) - PhotonLineCutZ0; + float photonRZLineCut = TMath::Abs(cand.photonZconv()) * TMath::Tan(2 * TMath::ATan(TMath::Exp(-PhotonMaxDauEta))) - PhotonLineCutZ0; if ((TMath::Abs(cand.photonRadius()) < photonRZLineCut) || (TMath::Abs(cand.photonZconv()) > PhotonMaxZ)) return false; fillSelHistos<10>(cand, 22); if (cand.photonQt() > PhotonMaxQt) return false; - + if (TMath::Abs(cand.photonAlpha()) > PhotonMaxAlpha) return false; @@ -755,7 +748,7 @@ struct sigmaanalysis { return false; fillSelHistos<13>(cand, 22); - if ((((cand.photonPhi() > PhotonPhiMin1) && (cand.photonPhi() < PhotonPhiMax1)) || ((cand.photonPhi() > PhotonPhiMin2) && (cand.photonPhi() < PhotonPhiMax2))) && ((PhotonPhiMin1!=-1) && (PhotonPhiMax1!=-1) && (PhotonPhiMin2!=-1) && (PhotonPhiMax2!=-1))) + if ((((cand.photonPhi() > PhotonPhiMin1) && (cand.photonPhi() < PhotonPhiMax1)) || ((cand.photonPhi() > PhotonPhiMin2) && (cand.photonPhi() < PhotonPhiMax2))) && ((PhotonPhiMin1 != -1) && (PhotonPhiMax1 != -1) && (PhotonPhiMin2 != -1) && (PhotonPhiMax2 != -1))) return false; fillSelHistos<14>(cand, 22); @@ -769,11 +762,11 @@ struct sigmaanalysis { // Apply specific selections for lambdas template bool selectLambda(TV0Object const& cand) - { - fillSelHistos<0>(cand, 3122); + { + fillSelHistos<0>(cand, 3122); if ((cand.lambdaRadius() < LambdaMinv0radius) || (cand.lambdaRadius() > LambdaMaxv0radius)) return false; - + fillSelHistos<1>(cand, 3122); if (TMath::Abs(cand.lambdaDCADau()) > LambdaMaxDCAV0Dau) return false; @@ -781,7 +774,7 @@ struct sigmaanalysis { fillSelHistos<2>(cand, 3122); if ((cand.lambdaQt() < LambdaMinQt) || (cand.lambdaQt() > LambdaMaxQt)) return false; - + if ((TMath::Abs(cand.lambdaAlpha()) < LambdaMinAlpha) || (TMath::Abs(cand.lambdaAlpha()) > LambdaMaxAlpha)) return false; @@ -805,14 +798,14 @@ struct sigmaanalysis { return false; if (cand.lambdaNegITSCls() < LambdaMinITSclusters && (!LambdaRejectNegITSafterburner || negIsFromAfterburner)) return false; - + fillSelHistos<7>(cand, 3122); if (cand.lambdaLifeTime() > LambdaMaxLifeTime) return false; // Separating lambda and antilambda selections: - fillSelHistos<8>(cand, 3122); - if (cand.lambdaAlpha() > 0) { // Lambda selection + fillSelHistos<8>(cand, 3122); + if (cand.lambdaAlpha() > 0) { // Lambda selection // TPC Selection if (fselLambdaTPCPID && (TMath::Abs(cand.lambdaPosPrTPCNSigma()) > LambdaMaxTPCNSigmas)) return false; @@ -824,8 +817,8 @@ struct sigmaanalysis { return false; if (fselLambdaTOFPID && (TMath::Abs(cand.lambdaPiTOFNSigma()) > LambdaPiMaxTOFNSigmas)) return false; - - // DCA Selection + + // DCA Selection fillSelHistos<9>(cand, 3122); if ((TMath::Abs(cand.lambdaDCAPosPV()) < LambdaMinDCAPosToPv) || (TMath::Abs(cand.lambdaDCANegPV()) < LambdaMinDCANegToPv)) return false; @@ -838,7 +831,7 @@ struct sigmaanalysis { fillSelHistos<11>(cand, 3122); } else { // AntiLambda selection - + // TPC Selection if (fselLambdaTPCPID && (TMath::Abs(cand.lambdaPosPiTPCNSigma()) > LambdaMaxTPCNSigmas)) return false; @@ -850,20 +843,20 @@ struct sigmaanalysis { return false; if (fselLambdaTOFPID && (TMath::Abs(cand.aLambdaPiTOFNSigma()) > LambdaPiMaxTOFNSigmas)) return false; - - // DCA Selection + + // DCA Selection fillSelHistos<9>(cand, 3122); if ((TMath::Abs(cand.lambdaDCAPosPV()) < ALambdaMinDCAPosToPv) || (TMath::Abs(cand.lambdaDCANegPV()) < ALambdaMinDCANegToPv)) return false; - - // Mass Selection + + // Mass Selection fillSelHistos<10>(cand, 3122); if (TMath::Abs(cand.antilambdaMass() - o2::constants::physics::MassLambda0) > LambdaWindow) return false; - + fillSelHistos<11>(cand, 3122); } - + return true; } @@ -871,13 +864,13 @@ struct sigmaanalysis { template bool processSigmaCandidate(TV0Object const& cand) { - // Optionally Select on Interaction Rate + // Optionally Select on Interaction Rate if (fGetIR && (maxIR != -1) && (minIR != -1) && ((cand.sigmaIR() <= minIR) || (cand.sigmaIR() >= maxIR))) { return false; } - + // Do ML analysis - if (fUseMLSel) { + if (fUseMLSel) { if ((cand.gammaBDTScore() == -1) || (cand.lambdaBDTScore() == -1) || (cand.antilambdaBDTScore() == -1)) { LOGF(fatal, "ML Score is not available! Please, enable gamma and lambda selection with ML in sigmabuilder!"); } @@ -892,23 +885,23 @@ struct sigmaanalysis { // AntiLambda selection: if (cand.antilambdaBDTScore() <= AntiLambda_MLThreshold) return false; - + } // Go for standard analysis - else { + else { - // Photon specific selections + // Photon specific selections if (!selectPhoton(cand)) return false; - + // Lambda specific selections if (!selectLambda(cand)) return false; - // Sigma0 specific selections + // Sigma0 specific selections if (TMath::Abs(cand.sigmaRapidity()) > SigmaMaxRap) - return false; + return false; } return true; @@ -923,11 +916,11 @@ struct sigmaanalysis { // Fill histos before any selection fillQAHistos<0>(sigma); - + // Select sigma0 candidates if (!processSigmaCandidate(sigma)) continue; - + // Fill histos after all selections fillQAHistos<1>(sigma); } @@ -936,25 +929,24 @@ struct sigmaanalysis { void processRealData(V0Sigmas const& sigmas) { for (auto& sigma : sigmas) { // selecting Sigma0-like candidates - + // Fill histos before any selection fillQAHistos<0>(sigma); - + // Select sigma0 candidates if (!processSigmaCandidate(sigma)) continue; - + // Fill histos after all selections - fillQAHistos<1>(sigma); + fillQAHistos<1>(sigma); } } - + PROCESS_SWITCH(sigmaanalysis, processMonteCarlo, "Do Monte-Carlo-based analysis", false); - PROCESS_SWITCH(sigmaanalysis, processRealData, "Do real data analysis", true); + PROCESS_SWITCH(sigmaanalysis, processRealData, "Do real data analysis", true); }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{adaptAnalysisTask(cfgc)}; } -