From ee11f349de0dc16661be836ff5b93ffe903c3026 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Mon, 10 Jun 2024 12:56:21 +0000 Subject: [PATCH] Please consider the following formatting changes --- PWGLF/DataModel/LFSigmaTables.h | 84 ++++++++-------- .../Strangeness/lambdakzeromlselection.cxx | 38 +++---- .../Strangeness/sigma0builder.cxx | 89 ++++++++--------- PWGLF/Tasks/Strangeness/sigmaanalysis.cxx | 99 +++++++++---------- 4 files changed, 153 insertions(+), 157 deletions(-) diff --git a/PWGLF/DataModel/LFSigmaTables.h b/PWGLF/DataModel/LFSigmaTables.h index acd3561dfee..703127efaee 100644 --- a/PWGLF/DataModel/LFSigmaTables.h +++ b/PWGLF/DataModel/LFSigmaTables.h @@ -39,7 +39,7 @@ namespace v0SigmaCandidate //______________________________________________________ // REGULAR COLUMNS FOR INDEXING // FOR DERIVED -DECLARE_SOA_INDEX_COLUMN(Sigma0Collision, sigma0Collision); //! +DECLARE_SOA_INDEX_COLUMN(Sigma0Collision, sigma0Collision); //! } // namespace v0SigmaCandidate // for real data @@ -77,10 +77,10 @@ DECLARE_SOA_COLUMN(PhotonDCAPosPV, photonDCAPosPV, float); DECLARE_SOA_COLUMN(PhotonZconv, photonZconv, float); DECLARE_SOA_COLUMN(PhotonEta, photonEta, float); DECLARE_SOA_COLUMN(PhotonY, photonY, float); -DECLARE_SOA_COLUMN(PhotonPosTPCNSigma, photonPosTPCNSigma, float); -DECLARE_SOA_COLUMN(PhotonNegTPCNSigma, photonNegTPCNSigma, float); -DECLARE_SOA_COLUMN(PhotonPosTPCCrossedRows, photonPosTPCCrossedRows, uint8_t); -DECLARE_SOA_COLUMN(PhotonNegTPCCrossedRows, photonNegTPCCrossedRows, uint8_t); +DECLARE_SOA_COLUMN(PhotonPosTPCNSigma, photonPosTPCNSigma, float); +DECLARE_SOA_COLUMN(PhotonNegTPCNSigma, photonNegTPCNSigma, float); +DECLARE_SOA_COLUMN(PhotonPosTPCCrossedRows, photonPosTPCCrossedRows, uint8_t); +DECLARE_SOA_COLUMN(PhotonNegTPCCrossedRows, photonNegTPCCrossedRows, uint8_t); DECLARE_SOA_COLUMN(PhotonPosPt, photonPosPt, float); DECLARE_SOA_COLUMN(PhotonNegPt, photonNegPt, float); DECLARE_SOA_COLUMN(PhotonPosEta, photonPosEta, float); @@ -88,11 +88,11 @@ DECLARE_SOA_COLUMN(PhotonNegEta, photonNegEta, float); DECLARE_SOA_COLUMN(PhotonPosY, photonPosY, float); DECLARE_SOA_COLUMN(PhotonNegY, photonNegY, float); DECLARE_SOA_COLUMN(PhotonPsiPair, photonPsiPair, float); -DECLARE_SOA_COLUMN(PhotonPosITSCls, photonPosITSCls, int); -DECLARE_SOA_COLUMN(PhotonNegITSCls, photonNegITSCls, int); -DECLARE_SOA_COLUMN(PhotonPosITSClSize, photonPosITSClSize, uint32_t); -DECLARE_SOA_COLUMN(PhotonNegITSClSize, photonNegITSClSize, uint32_t); -DECLARE_SOA_COLUMN(PhotonV0Type, photonV0Type, uint8_t); +DECLARE_SOA_COLUMN(PhotonPosITSCls, photonPosITSCls, int); +DECLARE_SOA_COLUMN(PhotonNegITSCls, photonNegITSCls, int); +DECLARE_SOA_COLUMN(PhotonPosITSClSize, photonPosITSClSize, uint32_t); +DECLARE_SOA_COLUMN(PhotonNegITSClSize, photonNegITSClSize, uint32_t); +DECLARE_SOA_COLUMN(PhotonV0Type, photonV0Type, uint8_t); DECLARE_SOA_COLUMN(GammaBDTScore, gammaBDTScore, float); } // namespace v0SigmaPhotonExtras @@ -167,38 +167,38 @@ DECLARE_SOA_COLUMN(AntiLambdaBDTScore, antilambdaBDTScore, float); } // namespace v0SigmaLambdaExtras DECLARE_SOA_TABLE(V0SigmaLambdaExtras, "AOD", "V0SIGMALAMBDA", - v0SigmaLambdaExtras::LambdaPt, - v0SigmaLambdaExtras::LambdaMass, - v0SigmaLambdaExtras::LambdaQt, - v0SigmaLambdaExtras::LambdaAlpha, - v0SigmaLambdaExtras::LambdaRadius, - v0SigmaLambdaExtras::LambdaCosPA, - v0SigmaLambdaExtras::LambdaDCADau, - v0SigmaLambdaExtras::LambdaDCANegPV, - v0SigmaLambdaExtras::LambdaDCAPosPV, - v0SigmaLambdaExtras::LambdaEta, - v0SigmaLambdaExtras::LambdaY, - v0SigmaLambdaExtras::LambdaPosPrTPCNSigma, - v0SigmaLambdaExtras::LambdaPosPiTPCNSigma, - v0SigmaLambdaExtras::LambdaNegPrTPCNSigma, - v0SigmaLambdaExtras::LambdaNegPiTPCNSigma, - v0SigmaLambdaExtras::LambdaPosTPCCrossedRows, - v0SigmaLambdaExtras::LambdaNegTPCCrossedRows, - v0SigmaLambdaExtras::LambdaPosPt, - v0SigmaLambdaExtras::LambdaNegPt, - v0SigmaLambdaExtras::LambdaPosEta, - v0SigmaLambdaExtras::LambdaNegEta, - v0SigmaLambdaExtras::LambdaPosPrY, - v0SigmaLambdaExtras::LambdaPosPiY, - v0SigmaLambdaExtras::LambdaNegPrY, - v0SigmaLambdaExtras::LambdaNegPiY, - v0SigmaLambdaExtras::LambdaPosITSCls, - v0SigmaLambdaExtras::LambdaNegITSCls, - v0SigmaLambdaExtras::LambdaPosITSClSize, - v0SigmaLambdaExtras::LambdaNegITSClSize, - v0SigmaLambdaExtras::LambdaV0Type, - v0SigmaLambdaExtras::LambdaBDTScore, - v0SigmaLambdaExtras::AntiLambdaBDTScore); + v0SigmaLambdaExtras::LambdaPt, + v0SigmaLambdaExtras::LambdaMass, + v0SigmaLambdaExtras::LambdaQt, + v0SigmaLambdaExtras::LambdaAlpha, + v0SigmaLambdaExtras::LambdaRadius, + v0SigmaLambdaExtras::LambdaCosPA, + v0SigmaLambdaExtras::LambdaDCADau, + v0SigmaLambdaExtras::LambdaDCANegPV, + v0SigmaLambdaExtras::LambdaDCAPosPV, + v0SigmaLambdaExtras::LambdaEta, + v0SigmaLambdaExtras::LambdaY, + v0SigmaLambdaExtras::LambdaPosPrTPCNSigma, + v0SigmaLambdaExtras::LambdaPosPiTPCNSigma, + v0SigmaLambdaExtras::LambdaNegPrTPCNSigma, + v0SigmaLambdaExtras::LambdaNegPiTPCNSigma, + v0SigmaLambdaExtras::LambdaPosTPCCrossedRows, + v0SigmaLambdaExtras::LambdaNegTPCCrossedRows, + v0SigmaLambdaExtras::LambdaPosPt, + v0SigmaLambdaExtras::LambdaNegPt, + v0SigmaLambdaExtras::LambdaPosEta, + v0SigmaLambdaExtras::LambdaNegEta, + v0SigmaLambdaExtras::LambdaPosPrY, + v0SigmaLambdaExtras::LambdaPosPiY, + v0SigmaLambdaExtras::LambdaNegPrY, + v0SigmaLambdaExtras::LambdaNegPiY, + v0SigmaLambdaExtras::LambdaPosITSCls, + v0SigmaLambdaExtras::LambdaNegITSCls, + v0SigmaLambdaExtras::LambdaPosITSClSize, + v0SigmaLambdaExtras::LambdaNegITSClSize, + v0SigmaLambdaExtras::LambdaV0Type, + v0SigmaLambdaExtras::LambdaBDTScore, + v0SigmaLambdaExtras::AntiLambdaBDTScore); // for MC data namespace v0SigmaMCCandidate diff --git a/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx b/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx index ce89691309a..412161ebe52 100644 --- a/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx +++ b/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx @@ -78,7 +78,7 @@ struct lambdakzeromlselection { Produces gammaMLSelections; // optionally aggregate information from ML output for posterior analysis (derived data) Produces lambdaMLSelections; // optionally aggregate information from ML output for posterior analysis (derived data) Produces antiLambdaMLSelections; // optionally aggregate information from ML output for posterior analysis (derived data) - Produces kzeroShortMLSelections; // optionally aggregate information from ML output for posterior analysis (derived data) + Produces kzeroShortMLSelections; // optionally aggregate information from ML output for posterior analysis (derived data) HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; @@ -97,7 +97,7 @@ struct lambdakzeromlselection { //// Order: Z, V0radius, PA, DCApostopv, DCAnegtopv, DCAV0daughters, DCAv0topv, PsiPair Configurable> Topo_SelMap{"Topo_SelMap", std::vector{0, 1, 1, 1, 1, 1, 1, 0}, "Mask to select basic topological features for ML Inference"}; - //// Casting + //// Casting std::vector CastKine_SelMap, CastTopo_SelMap, Feature_SelMask; // CCDB configuration @@ -177,7 +177,7 @@ struct lambdakzeromlselection { if (PredictKZeroShort) kzeroshort_bdt.initModel(BDTLocalPathKZeroShort.value, enableOptimizations.value); } - + /// Here the Configurables are passed to std::vectors CastKine_SelMap = (std::vector)Kine_SelMap; CastTopo_SelMap = (std::vector)Topo_SelMap; @@ -189,47 +189,48 @@ struct lambdakzeromlselection { LOG(info) << "Feature_SelMask size: " << Feature_SelMask.size(); } - template - std::vector extractSelectedElements(const std::vector& base_features, const std::vector& Sel_mask) { + template + std::vector extractSelectedElements(const std::vector& base_features, const std::vector& Sel_mask) + { std::vector selected_elements; for (size_t i = 0; i < Sel_mask.size(); ++i) { - if (Sel_mask[i]>=1) { // If the mask value is true, select the corresponding element - selected_elements.push_back(base_features[i]); - } + if (Sel_mask[i] >= 1) { // If the mask value is true, select the corresponding element + selected_elements.push_back(base_features[i]); + } } return selected_elements; -} + } // Process candidate and store properties in object template void processCandidate(TV0Object const& cand, const std::vector& Feature_SelMask) { // Select features - std::vector base_features{cand.mLambda(), cand.mAntiLambda(), - cand.mGamma(), cand.mK0Short(), - cand.pt(), static_cast(cand.qtarm()), cand.alpha(), + std::vector base_features{cand.mLambda(), cand.mAntiLambda(), + cand.mGamma(), cand.mK0Short(), + cand.pt(), static_cast(cand.qtarm()), cand.alpha(), cand.positiveeta(), cand.negativeeta(), cand.eta(), - cand.z(), cand.v0radius(), static_cast(TMath::ACos(cand.v0cosPA())), - cand.dcapostopv(), cand.dcanegtopv(), cand.dcaV0daughters(), + cand.z(), cand.v0radius(), static_cast(TMath::ACos(cand.v0cosPA())), + cand.dcapostopv(), cand.dcanegtopv(), cand.dcaV0daughters(), cand.dcav0topv(), cand.psipair()}; // Apply mask to select features std::vector inputFeatures = extractSelectedElements(base_features, Feature_SelMask); // calculate classifier output - if (PredictLambda){ + if (PredictLambda) { float* LambdaProbability = lambda_bdt.evalModel(inputFeatures); lambdaMLSelections(LambdaProbability[1]); } - if (PredictGamma){ + if (PredictGamma) { float* GammaProbability = gamma_bdt.evalModel(inputFeatures); gammaMLSelections(GammaProbability[1]); } - if (PredictAntiLambda){ + if (PredictAntiLambda) { float* AntiLambdaProbability = antilambda_bdt.evalModel(inputFeatures); antiLambdaMLSelections(AntiLambdaProbability[1]); } - if (PredictKZeroShort){ + if (PredictKZeroShort) { float* KZeroShortProbability = kzeroshort_bdt.evalModel(inputFeatures); kzeroShortMLSelections(KZeroShortProbability[1]); } @@ -266,4 +267,3 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{adaptAnalysisTask(cfgc)}; } - diff --git a/PWGLF/TableProducer/Strangeness/sigma0builder.cxx b/PWGLF/TableProducer/Strangeness/sigma0builder.cxx index a78d1e5f479..8e628ce81c9 100644 --- a/PWGLF/TableProducer/Strangeness/sigma0builder.cxx +++ b/PWGLF/TableProducer/Strangeness/sigma0builder.cxx @@ -64,12 +64,12 @@ using V0StandardDerivedDatas = soa::Join v0sigma0Coll; // characterises collisions - Produces v0Sigma0CollRefs; // characterises collisions + Produces v0sigma0Coll; // characterises collisions + Produces v0Sigma0CollRefs; // characterises collisions Produces v0Sigmas; // save sigma0 candidates for analysis - Produces v0SigmaPhotonExtras; // save sigma0 candidates for analysis - Produces v0SigmaLambdaExtras; // save sigma0 candidates for analysis - Produces v0MCSigmas; + Produces v0SigmaPhotonExtras; // save sigma0 candidates for analysis + Produces v0SigmaLambdaExtras; // save sigma0 candidates for analysis + Produces v0MCSigmas; // For manual sliceBy Preslice perCollisionMCDerived = o2::aod::v0data::straCollisionId; @@ -97,11 +97,11 @@ struct sigma0builder { //// Photon criteria: Configurable PhotonDauPseudoRap{"PhotonDauPseudoRap", 1.0, "Max pseudorapidity of daughter tracks"}; Configurable Photondcadautopv{"Photondcadautopv", 0.01, "Min DCA daughter To PV (cm)"}; - Configurable Photondcav0dau{"Photondcav0dau", 3.0, "Max DCA V0 Daughters (cm)"}; + Configurable Photondcav0dau{"Photondcav0dau", 3.0, "Max DCA V0 Daughters (cm)"}; Configurable PhotonMinRadius{"PhotonMinRadius", 0.5, "Min photon conversion radius (cm)"}; Configurable PhotonMaxRadius{"PhotonMaxRadius", 250, "Max photon conversion radius (cm)"}; Configurable PhotonMaxMass{"PhotonMaxMass", 0.2, "Max photon mass (GeV/c^{2})"}; - + //// Sigma0 criteria: Configurable Sigma0Window{"Sigma0Window", 0.04, "Mass window around expected (in GeV/c2)"}; @@ -130,35 +130,35 @@ struct sigma0builder { float GammaBDTScore = -1; float LambdaBDTScore = -1; float AntiLambdaBDTScore = -1; - - if ((lambda.v0Type()==0) || (gamma.v0Type()==0)) + + if ((lambda.v0Type() == 0) || (gamma.v0Type() == 0)) return false; - if constexpr (requires { gamma.gammaBDTScore(); } && - requires { lambda.lambdaBDTScore(); } && - requires { lambda.antiLambdaBDTScore(); }){ - - LOGF(info, "X-check: ML Selection is on!"); - // Gamma selection: - if (gamma.gammaBDTScore() <= Gamma_MLThreshold) - return false; - - // Lambda and AntiLambda selection - if ((lambda.lambdaBDTScore() <= Lambda_MLThreshold) && (lambda.antiLambdaBDTScore() <= AntiLambda_MLThreshold)) - return false; - - GammaBDTScore = gamma.gammaBDTScore(); - LambdaBDTScore = lambda.lambdaBDTScore(); - AntiLambdaBDTScore = lambda.antiLambdaBDTScore(); - } - else{ + if constexpr ( + requires { gamma.gammaBDTScore(); } && + requires { lambda.lambdaBDTScore(); } && + requires { lambda.antiLambdaBDTScore(); }) { + + LOGF(info, "X-check: ML Selection is on!"); + // Gamma selection: + if (gamma.gammaBDTScore() <= Gamma_MLThreshold) + return false; + + // Lambda and AntiLambda selection + if ((lambda.lambdaBDTScore() <= Lambda_MLThreshold) && (lambda.antiLambdaBDTScore() <= AntiLambda_MLThreshold)) + return false; + + GammaBDTScore = gamma.gammaBDTScore(); + LambdaBDTScore = lambda.lambdaBDTScore(); + AntiLambdaBDTScore = lambda.antiLambdaBDTScore(); + } else { // Standard selection // Gamma basic selection criteria: if (TMath::Abs(gamma.mGamma()) > PhotonMaxMass) return false; if ((TMath::Abs(gamma.negativeeta()) > PhotonDauPseudoRap) || (TMath::Abs(gamma.positiveeta()) > PhotonDauPseudoRap)) return false; - if ((gamma.dcapostopv() > Photondcadautopv) || ( gamma.dcanegtopv() > Photondcadautopv)) + if ((gamma.dcapostopv() > Photondcadautopv) || (gamma.dcanegtopv() > Photondcadautopv)) return false; if (gamma.dcaV0daughters() > Photondcav0dau) return false; @@ -187,7 +187,7 @@ struct sigma0builder { sigmaCandidate.Rapidity = RecoDecay::y(std::array{gamma.px() + lambda.px(), gamma.py() + lambda.py(), gamma.pz() + lambda.pz()}, o2::constants::physics::MassSigma0); if (TMath::Abs(sigmaCandidate.mass - 1.192642) > Sigma0Window) - return false; + return false; // Sigma related float fSigmapT = sigmaCandidate.pT; @@ -221,7 +221,7 @@ struct sigma0builder { float fPhotonNegEta = gamma.negativeeta(); float fPhotonPosY = RecoDecay::y(std::array{gamma.pxpos(), gamma.pypos(), gamma.pzpos()}, o2::constants::physics::MassElectron); float fPhotonNegY = RecoDecay::y(std::array{gamma.pxneg(), gamma.pyneg(), gamma.pzneg()}, o2::constants::physics::MassElectron); - float fPhotonPsiPair = gamma.psipair(); + float fPhotonPsiPair = gamma.psipair(); int fPhotonPosITSCls = posTrackGamma.itsNCls(); int fPhotonNegITSCls = negTrackGamma.itsNCls(); uint32_t fPhotonPosITSClSize = posTrackGamma.itsClusterSizes(); @@ -265,21 +265,20 @@ struct sigma0builder { // Filling TTree for ML analysis v0Sigmas(fSigmapT, fSigmaMass, fSigmaRap); - + v0SigmaPhotonExtras(fPhotonPt, fPhotonMass, fPhotonQt, fPhotonAlpha, fPhotonRadius, fPhotonCosPA, fPhotonDCADau, fPhotonDCANegPV, fPhotonDCAPosPV, fPhotonZconv, - fPhotonEta, fPhotonY,fPhotonPosTPCNSigma, fPhotonNegTPCNSigma, fPhotonPosTPCCrossedRows, + fPhotonEta, fPhotonY, fPhotonPosTPCNSigma, fPhotonNegTPCNSigma, fPhotonPosTPCCrossedRows, fPhotonNegTPCCrossedRows, fPhotonPosPt, fPhotonNegPt, fPhotonPosEta, fPhotonNegEta, fPhotonPosY, fPhotonNegY, fPhotonPsiPair, fPhotonPosITSCls, fPhotonNegITSCls, fPhotonPosITSClSize, fPhotonNegITSClSize, fPhotonV0Type, GammaBDTScore); - - - v0SigmaLambdaExtras(fLambdaPt,fLambdaMass,fLambdaQt, fLambdaAlpha, + + v0SigmaLambdaExtras(fLambdaPt, fLambdaMass, fLambdaQt, fLambdaAlpha, fLambdaRadius, fLambdaCosPA, fLambdaDCADau, fLambdaDCANegPV, fLambdaDCAPosPV, fLambdaEta, fLambdaY, fLambdaPosPrTPCNSigma, fLambdaPosPiTPCNSigma, fLambdaNegPrTPCNSigma, fLambdaNegPiTPCNSigma, fLambdaPosTPCCrossedRows, - fLambdaNegTPCCrossedRows, fLambdaPosPt, fLambdaNegPt,fLambdaPosEta, + fLambdaNegTPCCrossedRows, fLambdaPosPt, fLambdaNegPt, fLambdaPosEta, fLambdaNegEta, fLambdaPosPrY, fLambdaPosPiY, fLambdaNegPrY, fLambdaNegPiY, fLambdaPosITSCls, fLambdaNegITSCls, fLambdaPosITSClSize, fLambdaNegITSClSize, fLambdaV0Type, LambdaBDTScore, AntiLambdaBDTScore); @@ -301,9 +300,9 @@ struct sigma0builder { continue; bool fIsSigma = false; - if ((gamma.pdgCode()==22) && (gamma.pdgCodeMother()==3212) && (lambda.pdgCode()==3122) && (lambda.pdgCodeMother()==3212) && (gamma.motherMCPartId() == lambda.motherMCPartId())) + if ((gamma.pdgCode() == 22) && (gamma.pdgCodeMother() == 3212) && (lambda.pdgCode() == 3122) && (lambda.pdgCodeMother() == 3212) && (gamma.motherMCPartId() == lambda.motherMCPartId())) fIsSigma = true; - + v0MCSigmas(fIsSigma); } } @@ -328,11 +327,11 @@ struct sigma0builder { nSigmaCandidates++; if (nSigmaCandidates % 5000 == 0) { - LOG(info) << "Sigma0 Candidates built: " << nSigmaCandidates; + LOG(info) << "Sigma0 Candidates built: " << nSigmaCandidates; } - v0Sigma0CollRefs(v0sigma0Coll.lastIndex()); + v0Sigma0CollRefs(v0sigma0Coll.lastIndex()); } - } + } } } @@ -354,13 +353,12 @@ struct sigma0builder { nSigmaCandidates++; if (nSigmaCandidates % 5000 == 0) { - LOG(info) << "Sigma0 Candidates built: " << nSigmaCandidates; + LOG(info) << "Sigma0 Candidates built: " << nSigmaCandidates; } - v0Sigma0CollRefs(v0sigma0Coll.lastIndex()); + v0Sigma0CollRefs(v0sigma0Coll.lastIndex()); } - } + } } - } PROCESS_SWITCH(sigma0builder, processMonteCarlo, "Fill sigma0 MC table", false); PROCESS_SWITCH(sigma0builder, processSTDSelection, "Select gammas and lambdas with standard cuts", true); @@ -371,4 +369,3 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{adaptAnalysisTask(cfgc)}; } - diff --git a/PWGLF/Tasks/Strangeness/sigmaanalysis.cxx b/PWGLF/Tasks/Strangeness/sigmaanalysis.cxx index d8cc204160c..9565d327585 100644 --- a/PWGLF/Tasks/Strangeness/sigmaanalysis.cxx +++ b/PWGLF/Tasks/Strangeness/sigmaanalysis.cxx @@ -68,8 +68,8 @@ struct sigmaanalysis { // Configurable analyseAntiSigma{"analyseAntiSigma", false, "process AntiSigma-like candidates"}; // Analysis strategy: - Configurable fUseMLSel{"fUseMLSel", true, "Flag to use ML selection. If False, the standard selection is applied."}; - Configurable fProcessMonteCarlo{"fProcessMonteCarlo", false, "Flag to process MC data."}; + Configurable fUseMLSel{"fUseMLSel", true, "Flag to use ML selection. If False, the standard selection is applied."}; + Configurable fProcessMonteCarlo{"fProcessMonteCarlo", false, "Flag to process MC data."}; // For ML Selection Configurable Gamma_MLThreshold{"Gamma_MLThreshold", 0.1, "Decision Threshold value to select gammas"}; @@ -94,8 +94,8 @@ struct sigmaanalysis { Configurable PhotonDauPseudoRap{"PhotonDauPseudoRap", 0.9, "Max pseudorapidity of daughter tracks"}; Configurable PhotondauMinPt{"PhotondauMinPt", 0.05, "Min daughter pT (GeV/c)"}; Configurable Photondcadautopv{"Photondcadautopv", 0.05, "Min DCA daughter To PV (cm)"}; - Configurable Photondcav0dau{"Photondcav0dau", 1.5, "Max DCA V0 Daughters (cm)"}; - Configurable PhotonTPCCrossedRows{"PhotonTPCCrossedRows", 30, "Min daughter TPC Crossed Rows"}; + Configurable Photondcav0dau{"Photondcav0dau", 1.5, "Max DCA V0 Daughters (cm)"}; + Configurable PhotonTPCCrossedRows{"PhotonTPCCrossedRows", 30, "Min daughter TPC Crossed Rows"}; Configurable PhotonMinTPCNSigmas{"PhotonMinTPCNSigmas", -6, "Min TPC NSigmas for daughters"}; Configurable PhotonMaxTPCNSigmas{"PhotonMaxTPCNSigmas", 7, "Max TPC NSigmas for daughters"}; Configurable PhotonMinPt{"PhotonMinPt", 0.02, "Min photon pT (GeV/c)"}; @@ -120,7 +120,7 @@ struct sigmaanalysis { // Invariant Mass ConfigurableAxis axisSigmaMass{"axisSigmaMass", {200, 1.16f, 1.23f}, "M_{#Sigma^{0}} (GeV/c^{2})"}; ConfigurableAxis axisLambdaMass{"axisLambdaMass", {200, 1.101f, 1.131f}, "M_{#Lambda} (GeV/c^{2})"}; - ConfigurableAxis axisPhotonMass{"axisPhotonMass", {200, -0.1f, 0.1f}, "M_{#Gamma}"}; + ConfigurableAxis axisPhotonMass{"axisPhotonMass", {200, -0.1f, 0.1f}, "M_{#Gamma}"}; // AP plot axes ConfigurableAxis axisAPAlpha{"axisAPAlpha", {220, -1.1f, 1.1f}, "V0 AP alpha"}; @@ -144,7 +144,7 @@ struct sigmaanalysis { // Event counter histos.add("hEventCentrality", "hEventCentrality", kTH1F, {axisCentrality}); - // For Signal Extraction + // For Signal Extraction histos.add("h3dMassSigma0", "h3dMassSigma0", kTH3F, {axisCentrality, axisPt, axisSigmaMass}); histos.add("h3dMassAntiSigma0", "h3dMassAntiSigma0", kTH3F, {axisCentrality, axisPt, axisSigmaMass}); @@ -212,7 +212,7 @@ struct sigmaanalysis { // Event counter histos.add("hMCEventCentrality", "hMCEventCentrality", kTH1F, {axisCentrality}); - // For Signal Extraction + // For Signal Extraction histos.add("h3dMCMassSigma0", "h3dMCMassSigma0", kTH3F, {axisCentrality, axisPt, axisSigmaMass}); histos.add("GeneralQA/h2dMCArmenterosAll", "h2dMCArmenterosAll", {HistType::kTH2F, {axisAPAlpha, axisAPQt}}); @@ -233,8 +233,8 @@ struct sigmaanalysis { template bool processSigmaCandidate(TV0Object const& cand) { - if (fUseMLSel){ - if ((cand.gammaBDTScore()==-1) || (cand.lambdaBDTScore()==-1) || (cand.antilambdaBDTScore()==-1)){ + 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!"); } // Gamma selection: @@ -249,15 +249,15 @@ struct sigmaanalysis { if (cand.antilambdaBDTScore() <= AntiLambda_MLThreshold) return false; } - - else{ + + else { if (TMath::Abs(cand.photonMass()) > PhotonMaxMass) return false; if ((TMath::Abs(cand.photonPosEta()) > PhotonDauPseudoRap) || (TMath::Abs(cand.photonNegEta()) > PhotonDauPseudoRap)) return false; if ((cand.photonPosPt() < PhotondauMinPt) || (cand.photonNegPt() < PhotondauMinPt)) return false; - if ((cand.photonDCAPosPV() > Photondcadautopv) || ( cand.photonDCANegPV() > Photondcadautopv)) + if ((cand.photonDCAPosPV() > Photondcadautopv) || (cand.photonDCANegPV() > Photondcadautopv)) return false; if (cand.photonDCADau() > Photondcav0dau) return false; @@ -299,7 +299,7 @@ struct sigmaanalysis { return false; } - return true; + return true; } // This process function cross-checks index correctness @@ -315,51 +315,51 @@ struct sigmaanalysis { void processMonteCarlo(aod::Sigma0Collision const& coll, V0MCSigmas const& v0s) { histos.fill(HIST("hMCEventCentrality"), coll.centFT0C()); - for (auto& sigma : v0s) { // selecting Sigma0-like candidates - if (sigma.isSigma()){ - histos.fill(HIST("GeneralQA/h2dMCArmenterosAll"), sigma.photonAlpha(), sigma.photonQt()); - histos.fill(HIST("GeneralQA/h2dMCArmenterosAll"), sigma.lambdaAlpha(), sigma.lambdaQt()); - - if (!processSigmaCandidate(sigma)) - continue; - - histos.fill(HIST("GeneralQA/h2dMCArmenterosSelected"), sigma.photonAlpha(), sigma.photonQt()); - histos.fill(HIST("GeneralQA/h2dMCArmenterosSelected"), sigma.lambdaAlpha(), sigma.lambdaQt()); - - histos.fill(HIST("Sigma0/hMCMassSigma0"), sigma.sigmaMass()); - histos.fill(HIST("Sigma0/hMCPtSigma0"), sigma.sigmapT()); - - histos.fill(HIST("h3dMCMassSigma0"), coll.centFT0C(), sigma.sigmapT(), sigma.sigmaMass()); - } + for (auto& sigma : v0s) { // selecting Sigma0-like candidates + if (sigma.isSigma()) { + histos.fill(HIST("GeneralQA/h2dMCArmenterosAll"), sigma.photonAlpha(), sigma.photonQt()); + histos.fill(HIST("GeneralQA/h2dMCArmenterosAll"), sigma.lambdaAlpha(), sigma.lambdaQt()); + + if (!processSigmaCandidate(sigma)) + continue; + + histos.fill(HIST("GeneralQA/h2dMCArmenterosSelected"), sigma.photonAlpha(), sigma.photonQt()); + histos.fill(HIST("GeneralQA/h2dMCArmenterosSelected"), sigma.lambdaAlpha(), sigma.lambdaQt()); + + histos.fill(HIST("Sigma0/hMCMassSigma0"), sigma.sigmaMass()); + histos.fill(HIST("Sigma0/hMCPtSigma0"), sigma.sigmapT()); + + histos.fill(HIST("h3dMCMassSigma0"), coll.centFT0C(), sigma.sigmapT(), sigma.sigmaMass()); } + } } - + void processRealData(aod::Sigma0Collision const& coll, V0Sigmas const& v0s) { histos.fill(HIST("hEventCentrality"), coll.centFT0C()); - for (auto& sigma : v0s) { // selecting Sigma0-like candidates - histos.fill(HIST("GeneralQA/h2dArmenterosAll"), sigma.photonAlpha(), sigma.photonQt()); - histos.fill(HIST("GeneralQA/h2dArmenterosAll"), sigma.lambdaAlpha(), sigma.lambdaQt()); - - nSigmaCandidates++; - if (nSigmaCandidates % 50000 == 0) { - LOG(info) << "Sigma0 Candidates processed: " << nSigmaCandidates; - } - if (!processSigmaCandidate(sigma)) - continue; + for (auto& sigma : v0s) { // selecting Sigma0-like candidates + histos.fill(HIST("GeneralQA/h2dArmenterosAll"), sigma.photonAlpha(), sigma.photonQt()); + histos.fill(HIST("GeneralQA/h2dArmenterosAll"), sigma.lambdaAlpha(), sigma.lambdaQt()); - histos.fill(HIST("GeneralQA/h2dArmenterosSelected"), sigma.photonAlpha(), sigma.photonQt()); - histos.fill(HIST("GeneralQA/h2dArmenterosSelected"), sigma.lambdaAlpha(), sigma.lambdaQt()); - - histos.fill(HIST("Sigma0/hMassSigma0"), sigma.sigmaMass()); - histos.fill(HIST("Sigma0/hPtSigma0"), sigma.sigmapT()); - histos.fill(HIST("Sigma0/hRapiditySigma0"), sigma.sigmaRapidity()); - - histos.fill(HIST("h3dMassSigma0"), coll.centFT0C(), sigma.sigmapT(), sigma.sigmaMass()); + nSigmaCandidates++; + if (nSigmaCandidates % 50000 == 0) { + LOG(info) << "Sigma0 Candidates processed: " << nSigmaCandidates; } + if (!processSigmaCandidate(sigma)) + continue; + + histos.fill(HIST("GeneralQA/h2dArmenterosSelected"), sigma.photonAlpha(), sigma.photonQt()); + histos.fill(HIST("GeneralQA/h2dArmenterosSelected"), sigma.lambdaAlpha(), sigma.lambdaQt()); + + histos.fill(HIST("Sigma0/hMassSigma0"), sigma.sigmaMass()); + histos.fill(HIST("Sigma0/hPtSigma0"), sigma.sigmapT()); + histos.fill(HIST("Sigma0/hRapiditySigma0"), sigma.sigmaRapidity()); + + histos.fill(HIST("h3dMassSigma0"), coll.centFT0C(), sigma.sigmapT(), sigma.sigmaMass()); + } } - //PROCESS_SWITCH(sigmaanalysis, processCounterQA, "Check standard counter correctness", true); + // PROCESS_SWITCH(sigmaanalysis, processCounterQA, "Check standard counter correctness", true); PROCESS_SWITCH(sigmaanalysis, processMonteCarlo, "Do Monte-Carlo-based analysis", true); PROCESS_SWITCH(sigmaanalysis, processRealData, "Do real data analysis", true); }; @@ -368,4 +368,3 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{adaptAnalysisTask(cfgc)}; } -