From e48973e2ae4d91939ed97aca9f6e9b1f71dd998c Mon Sep 17 00:00:00 2001 From: ddobrigk Date: Wed, 10 Apr 2024 17:42:00 +0200 Subject: [PATCH 01/26] ML and Sigma0 work --- PWGLF/DataModel/LFSigmaTables.h | 152 +++++++++ PWGLF/DataModel/LFStrangenessMLTables.h | 85 +++++ .../TableProducer/Strangeness/CMakeLists.txt | 16 + .../Strangeness/lambdakzeroTreeCreator.cxx | 283 ++++++++++++++++ .../Strangeness/lambdakzeromlselection.cxx | 202 ++++++++++++ .../Strangeness/sigma0builder.cxx | 243 ++++++++++++++ PWGLF/Tasks/Strangeness/CMakeLists.txt | 5 + PWGLF/Tasks/Strangeness/sigmaanalysis.cxx | 308 ++++++++++++++++++ 8 files changed, 1294 insertions(+) create mode 100644 PWGLF/DataModel/LFSigmaTables.h create mode 100644 PWGLF/DataModel/LFStrangenessMLTables.h create mode 100644 PWGLF/TableProducer/Strangeness/lambdakzeroTreeCreator.cxx create mode 100644 PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx create mode 100644 PWGLF/TableProducer/Strangeness/sigma0builder.cxx create mode 100644 PWGLF/Tasks/Strangeness/sigmaanalysis.cxx diff --git a/PWGLF/DataModel/LFSigmaTables.h b/PWGLF/DataModel/LFSigmaTables.h new file mode 100644 index 00000000000..861bb6759a0 --- /dev/null +++ b/PWGLF/DataModel/LFSigmaTables.h @@ -0,0 +1,152 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +#include +#include "Framework/AnalysisDataModel.h" +#include "Framework/ASoAHelpers.h" +#include "Common/Core/RecoDecay.h" +#include "CommonConstants/PhysicsConstants.h" + +#ifndef PWGLF_DATAMODEL_LFSIGMATABLES_H_ +#define PWGLF_DATAMODEL_LFSIGMATABLES_H_ + +using namespace o2; +using namespace o2::framework; + + +// Creating output TTree for ML analysis +namespace o2::aod +{ + +// for real data +namespace V0MLSigmaCandidate +{ +DECLARE_SOA_COLUMN(SigmapT, sigmapT, float); +DECLARE_SOA_COLUMN(SigmaMass, sigmaMass, float); +// DECLARE_SOA_COLUMN(SigmaDCAz, sigmaDCAz, float); +// DECLARE_SOA_COLUMN(SigmaDCAxy, sigmaDCAxy, float); +// DECLARE_SOA_COLUMN(SigmaDCADau, sigmaDCADau, float); +DECLARE_SOA_COLUMN(PhotonPt, photonPt, float); +DECLARE_SOA_COLUMN(PhotonMass, photonMass, float); +DECLARE_SOA_COLUMN(PhotonQt, photonQt, float); +DECLARE_SOA_COLUMN(PhotonAlpha, photonAlpha, float); +DECLARE_SOA_COLUMN(PhotonRadius, photonRadius, float); +DECLARE_SOA_COLUMN(PhotonCosPA, photonCosPA, float); +DECLARE_SOA_COLUMN(PhotonDCADau, photonDCADau, float); +DECLARE_SOA_COLUMN(PhotonDCANegPV, photonDCANegPV, float); +DECLARE_SOA_COLUMN(PhotonDCAPosPV, photonDCAPosPV, float); +DECLARE_SOA_COLUMN(PhotonZconv, photonZconv, float); +DECLARE_SOA_COLUMN(LambdaPt, lambdaPt, float); +DECLARE_SOA_COLUMN(LambdaMass, lambdaMass, float); +DECLARE_SOA_COLUMN(LambdaQt, lambdaQt, float); +DECLARE_SOA_COLUMN(LambdaAlpha, lambdaAlpha, float); +DECLARE_SOA_COLUMN(LambdaRadius, lambdaRadius, float); +DECLARE_SOA_COLUMN(LambdaCosPA, lambdaCosPA, float); +DECLARE_SOA_COLUMN(LambdaDCADau, lambdaDCADau, float); +DECLARE_SOA_COLUMN(LambdaDCANegPV, lambdaDCANegPV, float); +DECLARE_SOA_COLUMN(LambdaDCAPosPV, lambdaDCAPosPV, float); +DECLARE_SOA_COLUMN(GammaProbability, gammaProbability, float); +DECLARE_SOA_COLUMN(LambdaProbability, lambdaProbability, float); + +} // namespace V0MLSigmaCandidate + +DECLARE_SOA_TABLE(V0MLSigmaCandidates, "AOD", "V0MLSIGMAS", + V0MLSigmaCandidate::SigmapT, + V0MLSigmaCandidate::SigmaMass, + // V0MLSigmaCandidate::SigmaDCAz, + // V0MLSigmaCandidate::SigmaDCAxy, + // V0MLSigmaCandidate::SigmaDCADau, + V0MLSigmaCandidate::PhotonPt, + V0MLSigmaCandidate::PhotonMass, + V0MLSigmaCandidate::PhotonQt, + V0MLSigmaCandidate::PhotonAlpha, + V0MLSigmaCandidate::PhotonRadius, + V0MLSigmaCandidate::PhotonCosPA, + V0MLSigmaCandidate::PhotonDCADau, + V0MLSigmaCandidate::PhotonDCANegPV, + V0MLSigmaCandidate::PhotonDCAPosPV, + V0MLSigmaCandidate::PhotonZconv, + V0MLSigmaCandidate::LambdaPt, + V0MLSigmaCandidate::LambdaMass, + V0MLSigmaCandidate::LambdaQt, + V0MLSigmaCandidate::LambdaAlpha, + V0MLSigmaCandidate::LambdaRadius, + V0MLSigmaCandidate::LambdaCosPA, + V0MLSigmaCandidate::LambdaDCADau, + V0MLSigmaCandidate::LambdaDCANegPV, + V0MLSigmaCandidate::LambdaDCAPosPV, + V0MLSigmaCandidate::GammaProbability, + V0MLSigmaCandidate::LambdaProbability); + +// for MC data +namespace V0MLSigmaMCCandidate +{ +DECLARE_SOA_COLUMN(SigmapT, sigmapT, float); +DECLARE_SOA_COLUMN(SigmaMass, sigmaMass, float); +// DECLARE_SOA_COLUMN(SigmaDCAz, sigmaDCAz, float); +// DECLARE_SOA_COLUMN(SigmaDCAxy, sigmaDCAxy, float); +// DECLARE_SOA_COLUMN(SigmaDCADau, sigmaDCADau, float); +DECLARE_SOA_COLUMN(PhotonPt, photonPt, float); +DECLARE_SOA_COLUMN(PhotonMass, photonMass, float); +DECLARE_SOA_COLUMN(PhotonQt, photonQt, float); +DECLARE_SOA_COLUMN(PhotonAlpha, photonAlpha, float); +DECLARE_SOA_COLUMN(PhotonRadius, photonRadius, float); +DECLARE_SOA_COLUMN(PhotonCosPA, photonCosPA, float); +DECLARE_SOA_COLUMN(PhotonDCADau, photonDCADau, float); +DECLARE_SOA_COLUMN(PhotonDCANegPV, photonDCANegPV, float); +DECLARE_SOA_COLUMN(PhotonDCAPosPV, photonDCAPosPV, float); +DECLARE_SOA_COLUMN(PhotonZconv, photonZconv, float); +DECLARE_SOA_COLUMN(LambdaPt, lambdaPt, float); +DECLARE_SOA_COLUMN(LambdaMass, lambdaMass, float); +DECLARE_SOA_COLUMN(LambdaQt, lambdaQt, float); +DECLARE_SOA_COLUMN(LambdaAlpha, lambdaAlpha, float); +DECLARE_SOA_COLUMN(LambdaRadius, lambdaRadius, float); +DECLARE_SOA_COLUMN(LambdaCosPA, lambdaCosPA, float); +DECLARE_SOA_COLUMN(LambdaDCADau, lambdaDCADau, float); +DECLARE_SOA_COLUMN(LambdaDCANegPV, lambdaDCANegPV, float); +DECLARE_SOA_COLUMN(LambdaDCAPosPV, lambdaDCAPosPV, float); +DECLARE_SOA_COLUMN(GammaProbability, gammaProbability, float); +DECLARE_SOA_COLUMN(LambdaProbability, lambdaProbability, float); +DECLARE_SOA_COLUMN(IsSigma, isSigma, bool); + +} // namespace V0MLSigmaMCCandidate + +DECLARE_SOA_TABLE(V0MLSigmaMCCandidates, "AOD", "V0MLMCSIGMAS", + V0MLSigmaMCCandidate::SigmapT, + V0MLSigmaMCCandidate::SigmaMass, + // V0MLSigmaMCCandidate::SigmaDCAz, + // V0MLSigmaMCCandidate::SigmaDCAxy, + // V0MLSigmaMCCandidate::SigmaDCADau, + V0MLSigmaMCCandidate::PhotonPt, + V0MLSigmaMCCandidate::PhotonMass, + V0MLSigmaMCCandidate::PhotonQt, + V0MLSigmaMCCandidate::PhotonAlpha, + V0MLSigmaMCCandidate::PhotonRadius, + V0MLSigmaMCCandidate::PhotonCosPA, + V0MLSigmaMCCandidate::PhotonDCADau, + V0MLSigmaMCCandidate::PhotonDCANegPV, + V0MLSigmaMCCandidate::PhotonDCAPosPV, + V0MLSigmaMCCandidate::PhotonZconv, + V0MLSigmaMCCandidate::LambdaPt, + V0MLSigmaMCCandidate::LambdaMass, + V0MLSigmaMCCandidate::LambdaQt, + V0MLSigmaMCCandidate::LambdaAlpha, + V0MLSigmaMCCandidate::LambdaRadius, + V0MLSigmaMCCandidate::LambdaCosPA, + V0MLSigmaMCCandidate::LambdaDCADau, + V0MLSigmaMCCandidate::LambdaDCANegPV, + V0MLSigmaMCCandidate::LambdaDCAPosPV, + V0MLSigmaMCCandidate::GammaProbability, + V0MLSigmaMCCandidate::LambdaProbability, + V0MLSigmaMCCandidate::IsSigma); +} // namespace o2::aod + +#endif // PWGLF_DATAMODEL_LFSIGMATABLES_H_ \ No newline at end of file diff --git a/PWGLF/DataModel/LFStrangenessMLTables.h b/PWGLF/DataModel/LFStrangenessMLTables.h new file mode 100644 index 00000000000..2c8faffa4ce --- /dev/null +++ b/PWGLF/DataModel/LFStrangenessMLTables.h @@ -0,0 +1,85 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +#include +#include "Framework/AnalysisDataModel.h" +#include "Framework/ASoAHelpers.h" +#include "Common/Core/RecoDecay.h" +#include "CommonConstants/PhysicsConstants.h" + +#ifndef PWGLF_DATAMODEL_LFSTRANGENESSMLTABLES_H_ +#define PWGLF_DATAMODEL_LFSTRANGENESSMLTABLES_H_ + +using namespace o2; +using namespace o2::framework; + + +// Creating output TTree for ML analysis +namespace o2::aod +{ +namespace v0mlcandidates +{ +DECLARE_SOA_COLUMN(LambdaMass, lambdaMass, float); +DECLARE_SOA_COLUMN(AntiLambdaMass, antilambdaMass, float); +DECLARE_SOA_COLUMN(GammaMass, gammaMass, float); +DECLARE_SOA_COLUMN(KZeroShortMass, kZeroShortMass, float); +DECLARE_SOA_COLUMN(Pt, pt, float); +DECLARE_SOA_COLUMN(Qt, qt, float); +DECLARE_SOA_COLUMN(Alpha, alpha, float); +DECLARE_SOA_COLUMN(Radius, radius, float); +DECLARE_SOA_COLUMN(CosPA, cosPA, float); +DECLARE_SOA_COLUMN(DCADau, dcaDau, float); +DECLARE_SOA_COLUMN(DCANegPV, dcaNegPV, float); +DECLARE_SOA_COLUMN(DCAPosPV, dcaPosPV, float); +DECLARE_SOA_COLUMN(IsLambda, isLambda, bool); +DECLARE_SOA_COLUMN(IsAntiLambda, isAntiLambda, bool); +DECLARE_SOA_COLUMN(IsGamma, isGamma, bool); +DECLARE_SOA_COLUMN(IsKZeroShort, isKZeroShort, bool); +} // namespace v0mlcandidates + +DECLARE_SOA_TABLE(V0MLCandidates, "AOD", "V0MLCANDIDATES", + v0mlcandidates::LambdaMass, + v0mlcandidates::AntiLambdaMass, + v0mlcandidates::GammaMass, + v0mlcandidates::KZeroShortMass, + v0mlcandidates::Pt, + v0mlcandidates::Qt, + v0mlcandidates::Alpha, + v0mlcandidates::Radius, + v0mlcandidates::CosPA, + v0mlcandidates::DCADau, + v0mlcandidates::DCANegPV, + v0mlcandidates::DCAPosPV, + v0mlcandidates::IsLambda, + v0mlcandidates::IsAntiLambda, + v0mlcandidates::IsGamma, + v0mlcandidates::IsKZeroShort); + + +namespace V0MLSelection +{ +DECLARE_SOA_COLUMN(GammaBDTScore, gammaBDTScore, float); +DECLARE_SOA_COLUMN(LambdaBDTScore, lambdaBDTScore, float); +DECLARE_SOA_COLUMN(AntiLambdaBDTScore, antiLambdaBDTScore, float); +DECLARE_SOA_COLUMN(K0ShortBDTScore, k0ShortBDTScore, float); +} // namespace V0MLSelection + +DECLARE_SOA_TABLE(V0GammaMLScores, "AOD", "V0GaMLScores", + V0MLSelection::GammaBDTScore); +DECLARE_SOA_TABLE(V0LambdaMLScores, "AOD", "V0LaMLScores", + V0MLSelection::LambdaBDTScore); +DECLARE_SOA_TABLE(V0AntiLambdaMLScores, "AOD", "V0ALaMLScores", + V0MLSelection::AntiLambdaBDTScore); +DECLARE_SOA_TABLE(V0K0ShortMLScores, "AOD", "V0K0MLScores", + V0MLSelection::K0ShortBDTScore); +} // namespace o2::aod + +#endif // PWGLF_DATAMODEL_LFSTRANGENESSMLTABLES_H_ \ No newline at end of file diff --git a/PWGLF/TableProducer/Strangeness/CMakeLists.txt b/PWGLF/TableProducer/Strangeness/CMakeLists.txt index cd7896e6b07..5d1402bf6b9 100644 --- a/PWGLF/TableProducer/Strangeness/CMakeLists.txt +++ b/PWGLF/TableProducer/Strangeness/CMakeLists.txt @@ -103,3 +103,19 @@ o2physics_add_dpl_workflow(v0qaanalysis SOURCES v0qaanalysis.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore COMPONENT_NAME Analysis) + +# ML selection +o2physics_add_dpl_workflow(lambdakzerotreecreator + SOURCES lambdakzeroTreeCreator.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2Physics::MLCore + COMPONENT_NAME Analysis) + +o2physics_add_dpl_workflow(lambdakzeromlselection + SOURCES lambdakzeromlselection.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2Physics::MLCore + COMPONENT_NAME Analysis) + +o2physics_add_dpl_workflow(sigma0builder + SOURCES sigma0builder.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2Physics::MLCore + COMPONENT_NAME Analysis) \ No newline at end of file diff --git a/PWGLF/TableProducer/Strangeness/lambdakzeroTreeCreator.cxx b/PWGLF/TableProducer/Strangeness/lambdakzeroTreeCreator.cxx new file mode 100644 index 00000000000..f3bef595d78 --- /dev/null +++ b/PWGLF/TableProducer/Strangeness/lambdakzeroTreeCreator.cxx @@ -0,0 +1,283 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. +// +// *+-+*+-+*+-+*+-+*+-+*+-+* +// V0 ML Tree Creator task +// *+-+*+-+*+-+*+-+*+-+*+-+* +// +// This task loops over a set of V0 indices and +// creates a TTree for ML training and testing. +// +// +// Comments, questions, complaints, suggestions? +// Please write to: +// gianni.shigeru.setoue.liveraro@cern.ch +// romain.schotter@cern.ch +// david.dobrigkeit.chinellato@cern.ch +// + + +#include "Framework/runDataProcessing.h" +#include "Framework/RunningWorkflowInfo.h" +#include "Framework/AnalysisTask.h" +#include "Framework/AnalysisDataModel.h" +#include "Framework/ASoAHelpers.h" +#include "Framework/ASoA.h" +#include "ReconstructionDataFormats/Track.h" +#include "Common/Core/RecoDecay.h" +#include "Common/Core/trackUtilities.h" +#include "PWGLF/DataModel/LFStrangenessTables.h" +#include "PWGLF/DataModel/LFStrangenessPIDTables.h" +#include "PWGLF/DataModel/LFStrangenessMLTables.h" +#include "Common/Core/TrackSelection.h" +#include "Common/DataModel/TrackSelectionTables.h" +#include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/Centrality.h" +#include "Common/DataModel/PIDResponse.h" +#include "CCDB/BasicCCDBManager.h" +#include "CommonConstants/PhysicsConstants.h" +#include "Common/TableProducer/PID/pidTOFBase.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; +using std::array; +using std::cout; +using std::endl; + +struct lambdakzeroTreeCreator{ + Produces v0MLCandidates; + HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; + + // selection switches: please, use just one at a time + Configurable fGetAllCandidates{"fGetAllCandidates", true, "If True, create a Tree containing all available candidates"}; + Configurable fGetLambdaOnly{"fGetLambdaOnly", false, "If True, apply cuts to select only lambda signal and bkg candidates"}; + Configurable fGetAntiLambdaOnly{"fGetAntiLambdaOnly", false, "If True, apply cuts to select only lambda signal and bkg candidates"}; + Configurable fGetGammaOnly{"fGetGammaOnly", false, "If True, apply cuts to select only Gamma signal and bkg candidates"}; + Configurable fGetK0ShortOnly{"fGetK0ShortOnly", false, "If True, apply cuts to select only K0Short signal and bkg candidates"}; + + // Base selection criteria + + /// Selection criteria: acceptance + Configurable rapidityCut{"rapidityCut", 0.5, "rapidity"}; + Configurable daughterEtaCut{"daughterEtaCut", 0.8, "max eta for daughters"}; + + // PID (TPC) + Configurable TpcPidNsigmaCut{"TpcPidNsigmaCut", 4, "TpcPidNsigmaCut"}; + Configurable allowTPConly{"allowTPConly", false, "Accept V0s that are TPC-only"}; + + // Track quality + Configurable minTPCrows{"minTPCrows", 70, "minimum TPC crossed rows"}; + + // Lambda standard criteria:: + //Configurable lambdaWindow{"lambdaWindow", 0.01, "Accept +/- this wrt Lambda mass (GeV/c^{2})"}; + Configurable Lambdav0cospa{"Lambdav0cospa", 0.90, "min V0 CosPA"}; + Configurable Lambdadcav0dau{"Lambdadcav0dau", 1.0, "max DCA V0 Daughters (cm)"}; + Configurable Lambdadcanegtopv{"Lambdadcanegtopv", .05, "min DCA Neg To PV (cm)"}; + Configurable Lambdadcapostopv{"Lambdadcapostopv", .05, "min DCA Pos To PV (cm)"}; + Configurable Lambdav0radius{"Lambdav0radius", 1.5, "minimum V0 radius (cm)"}; + + // Anti-Lambda standard criteria:: + Configurable AntiLambdav0cospa{"AntiLambdav0cospa", 0.90, "min V0 CosPA"}; + Configurable AntiLambdadcav0dau{"AntiLambdadcav0dau", 1.0, "max DCA V0 Daughters (cm)"}; + Configurable AntiLambdadcanegtopv{"AntiLambdadcanegtopv", .05, "min DCA Neg To PV (cm)"}; + Configurable AntiLambdadcapostopv{"AntiLambdadcapostopv", .05, "min DCA Pos To PV (cm)"}; + Configurable AntiLambdav0radius{"AntiLambdav0radius", 1.5, "minimum V0 radius (cm)"}; + + // Photon standard criteria: + Configurable PhotonMinRadius{"PhotonMinRadius", 1.0, "minimum photon conversion radius (cm)"}; + Configurable PhotonMaxRadius{"PhotonMaxRadius", 200, "maximum photon conversion radius (cm)"}; + Configurable PhotonMinPt{"PhotonMinPt", 0.001, "minimum photon pT (GeV/c)"}; + Configurable PhotonMaxMass{"PhotonMaxMass", 0.2, "Maximum photon mass (GeV/c^{2})"}; + Configurable PhotonMaxqt{"PhotonMaxqt", 0.1, "Maximum photon qt value (AP plot) (GeV/c)"}; + Configurable PhotonMaxalpha{"PhotonMaxalpha", 1.0, "Max photon alpha absolute value (AP plot)"}; + + // TODO: Include here K0Short standard criteria + + // Axis: + ConfigurableAxis vertexZ{"vertexZ", {30, -15.0f, 15.0f}, ""}; + + void init(InitContext const&) + { + histos.add("hEventVertexZMC", "hEventVertexZMC", kTH1F, {vertexZ}); + } + + // Helper struct to pass v0 information + struct { + float LambdaMass; + float AntiLambdaMass; + float GammaMass; + float KZeroShortMass; + float pT; + float qt; + float alpha; + float v0radius; + float v0cosPA; + float dcapostopv; + float dcanegtopv; + float dcaV0daughters; + bool isLambda; + bool isAntiLambda; + bool isGamma; + bool isKZeroShort; + } Candidate; + + // Process candidate and store properties in object + template + bool processCandidate(TV0Object const& cand) + { + Candidate.LambdaMass = cand.mLambda(); + Candidate.AntiLambdaMass = cand.mAntiLambda(); + Candidate.GammaMass = cand.mGamma(); + Candidate.KZeroShortMass = cand.mK0Short(); + Candidate.pT = cand.pt(); + Candidate.qt = cand.qtarm(); + Candidate.alpha = cand.alpha(); + Candidate.v0radius = cand.v0radius(); + Candidate.v0cosPA = cand.v0cosPA(); + Candidate.dcapostopv = cand.dcapostopv(); + Candidate.dcanegtopv = cand.dcanegtopv(); + Candidate.dcaV0daughters = cand.dcaV0daughters(); + Candidate.isLambda = (cand.pdgCode()==3122); + Candidate.isAntiLambda = (cand.pdgCode()==-3122); + Candidate.isGamma = (cand.pdgCode()==22); + Candidate.isKZeroShort = (cand.pdgCode()==310); + + return true; + } + + // Process lambda candidate + template + bool processLambdaCandidate(TV0Object const& lambda) + { + // FIXME: there are smarter ways to perform this selection + // Lambda base selection criteria: + + if( lambda.v0radius() < Lambdav0radius) + return false; + if( lambda.v0cosPA() < Lambdav0cospa) + return false; + if(TMath::Abs(lambda.dcapostopv()) < Lambdadcapostopv) + return false; + if(TMath::Abs(lambda.dcanegtopv()) < Lambdadcanegtopv) + return false; + if( lambda.dcaV0daughters() > Lambdadcav0dau) + return false; + + return processCandidate(lambda); + } + + // Process antilambda candidate + template + bool processAntiLambdaCandidate(TV0Object const& antilambda) + { + // FIXME: there are smarter ways to perform this selection + // AntiLambda base selection criteria: + + if( antilambda.v0radius() < AntiLambdav0radius) + return false; + if( antilambda.v0cosPA() < AntiLambdav0cospa) + return false; + if(TMath::Abs(antilambda.dcapostopv()) < AntiLambdadcapostopv) + return false; + if(TMath::Abs(antilambda.dcanegtopv()) < AntiLambdadcanegtopv) + return false; + if( antilambda.dcaV0daughters() > AntiLambdadcav0dau) + return false; + + return processCandidate(antilambda); + } + + // Process gamma candidate + template + bool processGammaCandidate(TV0Object const& gamma) + { + // FIXME: there are smarter ways to perform this selection + // Gamma selection criteria: + if( gamma.mGamma() > PhotonMaxMass ) + return false; + if( gamma.v0radius() < PhotonMinRadius ) + return false; + if( gamma.v0radius() > PhotonMaxRadius ) + return false; + if( gamma.pt() < PhotonMinPt) + return false; + if( gamma.qtarm() > PhotonMaxqt) + return false; + if(TMath::Abs(gamma.alpha()) > PhotonMaxalpha) + return false; + + return processCandidate(gamma); + } + + // Process k0short candidate + template + bool processK0ShortCandidate(TV0Object const& kzero) + { + // FIXME: there are smarter ways to perform this selection + // TODO: Include KZeroShort selection criteria + + return processCandidate(kzero); + } + + void process(aod::StraCollision const& coll, soa::Join const& v0s) + { + histos.fill(HIST("hEventVertexZMC"), coll.posZ()); + for (auto& cand: v0s){ // looping over lambdas + + if(fGetLambdaOnly){ + if (!processLambdaCandidate(cand)) + continue; + } + if(fGetAntiLambdaOnly){ + if (!processAntiLambdaCandidate(cand)) + continue; + } + if(fGetGammaOnly){ + if (!processGammaCandidate(cand)) + continue; + } + if(fGetK0ShortOnly){ + if(!processK0ShortCandidate(cand)) + continue; + } + if(fGetAllCandidates) { + if(!processCandidate(cand)) + continue; + } + + // Filling TTree for ML analysis + v0MLCandidates(Candidate.LambdaMass, Candidate.AntiLambdaMass, Candidate.GammaMass, Candidate.KZeroShortMass, + Candidate.pT, Candidate.qt, Candidate.alpha, Candidate.v0radius, Candidate.v0cosPA, + Candidate.dcapostopv, Candidate.dcanegtopv, Candidate.dcaV0daughters, + Candidate.isLambda, Candidate.isAntiLambda, Candidate.isGamma, Candidate.isKZeroShort); + } + +} + +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{adaptAnalysisTask(cfgc)}; + +} \ No newline at end of file diff --git a/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx b/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx new file mode 100644 index 00000000000..6a45a0b775f --- /dev/null +++ b/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx @@ -0,0 +1,202 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. +// +// *+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+* +// Lambdakzero ML selection task +// *+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+* +// +// Comments, questions, complaints, suggestions? +// Please write to: +// gianni.shigeru.setoue.liveraro@cern.ch +// romain.schotter@cern.ch +// david.dobrigkeit.chinellato@cern.ch +// + +#include "Framework/runDataProcessing.h" +#include "Framework/AnalysisTask.h" +#include "Framework/HistogramRegistry.h" +#include "Framework/AnalysisDataModel.h" +#include "Framework/ASoAHelpers.h" +#include "Framework/ASoA.h" +#include "ReconstructionDataFormats/Track.h" +#include "Common/Core/RecoDecay.h" +#include "Common/Core/trackUtilities.h" +#include "PWGLF/DataModel/LFStrangenessTables.h" +#include "PWGLF/DataModel/LFStrangenessPIDTables.h" +#include "PWGLF/DataModel/LFStrangenessMLTables.h" +#include "Common/Core/TrackSelection.h" +#include "Common/DataModel/TrackSelectionTables.h" +#include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/Centrality.h" +#include "Common/DataModel/PIDResponse.h" +#include "CCDB/BasicCCDBManager.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "Tools/ML/MlResponse.h" +#include "Tools/ML/model.h" + +using namespace o2; +using namespace o2::analysis; +using namespace o2::framework; +using namespace o2::framework::expressions; +using namespace o2::ml; +using std::array; +using std::cout; +using std::endl; + +//OnnxModel bdt; +OnnxModel lambda_bdt; +OnnxModel antilambda_bdt; +OnnxModel gamma_bdt; +OnnxModel kzeroshort_bdt; + +// For original data loops +using V0OriginalDatas = soa::Join; + +// For derived data analysis +using V0DerivedDatas = soa::Join; + +std::map metadata; +std::map headers; + +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) + HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; + + // ML inference + Configurable PredictLambda{"PredictLambda", true, "Flag to enable or disable the loading of model"}; + Configurable PredictAntiLambda{"PredictAntiLambda", false, "Flag to enable or disable the loading of model"}; + Configurable PredictGamma{"PredictGamma", true, "Flag to enable or disable the loading of model"}; + Configurable PredictKZeroShort{"PredictKZeroShort", false, "Flag to enable or disable the loading of model"}; + Configurable fIsMC{"fIsMC", false, "If true, save additional MC info for analysis"}; + + // CCDB configuration + o2::ccdb::CcdbApi ccdbApi; + Service ccdb; + Configurable ccdbUrl{"ccdb-url", "http://alice-ccdb.cern.ch", "url of the ccdb repository"}; + Configurable BDTLocalPathLambda{"BDTLocalPathLambda", "Lambda_BDTModel.onnx", "(std::string) Path to the local .onnx file."}; + Configurable BDTLocalPathAntiLambda{"BDTLocalPathAntiLambda", "AntiLambda_BDTModel.onnx", "(std::string) Path to the local .onnx file."}; + Configurable BDTLocalPathGamma{"BDTLocalPathGamma", "Gamma_BDTModel.onnx", "(std::string) Path to the local .onnx file."}; + Configurable BDTLocalPathKZeroShort{"BDTLocalPathKZeroShort", "KZeroShort_BDTModel.onnx", "(std::string) Path to the local .onnx file."}; + + Configurable BDTPathCCDB{"BDTPathCCDB", "Users/g/gsetouel/MLModels2", "Path on CCDB"}; + Configurable timestampCCDB{"timestampCCDB", -1, "timestamp of the ONNX file for ML model used to query in CCDB. Exceptions: > 0 for the specific timestamp, 0 gets the run dependent timestamp"}; + Configurable loadModelsFromCCDB{"loadModelsFromCCDB", false, "Flag to enable or disable the loading of models from CCDB"}; + Configurable enableOptimizations{"enableOptimizations", false, "Enables the ONNX extended model-optimization: sessionOptions.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_ENABLE_EXTENDED)"}; + + // Axis + // base properties + ConfigurableAxis vertexZ{"vertexZ", {30, -15.0f, 15.0f}, ""}; + + int nCandidates = 0; + void init(InitContext const&) + { + // Histograms + histos.add("hEventVertexZ", "hEventVertexZ", kTH1F, {vertexZ}); + + ccdb->setURL(ccdbUrl.value); + // Retrieve the model from CCDB + if (loadModelsFromCCDB) { + ccdbApi.init(ccdbUrl); + + /// Fetching model for specific timestamp + LOG(info) << "Fetching model for timestamp: " << timestampCCDB.value; + //headers = ccdbApi.retrieveHeaders(BDTPathCCDB.value, metadata, timestampCCDB.value); + + if (PredictLambda) { + bool retrieveSuccessLambda = ccdbApi.retrieveBlob(BDTPathCCDB.value, ".", metadata, timestampCCDB.value, false, BDTLocalPathLambda.value); + if (retrieveSuccessLambda) lambda_bdt.initModel(BDTLocalPathLambda.value, enableOptimizations.value); + else{ + LOG(fatal) << "Error encountered while fetching/loading the Lambda model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?";} + } + + if (PredictAntiLambda) { + bool retrieveSuccessAntiLambda = ccdbApi.retrieveBlob(BDTPathCCDB.value, ".", metadata, timestampCCDB.value, false, BDTLocalPathAntiLambda.value); + if (retrieveSuccessAntiLambda) antilambda_bdt.initModel(BDTLocalPathAntiLambda.value, enableOptimizations.value); + else{ + LOG(fatal) << "Error encountered while fetching/loading the AntiLambda model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?";} + } + + if (PredictGamma) { + bool retrieveSuccessGamma = ccdbApi.retrieveBlob(BDTPathCCDB.value, ".", metadata, timestampCCDB.value, false, BDTLocalPathGamma.value); + if (retrieveSuccessGamma) gamma_bdt.initModel(BDTLocalPathGamma.value, enableOptimizations.value); + else{ + LOG(fatal) << "Error encountered while fetching/loading the Gamma model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?";} + } + + if (PredictKZeroShort) { + bool retrieveSuccessKZeroShort = ccdbApi.retrieveBlob(BDTPathCCDB.value, ".", metadata, timestampCCDB.value, false, BDTLocalPathKZeroShort.value); + if (retrieveSuccessKZeroShort) kzeroshort_bdt.initModel(BDTLocalPathKZeroShort.value, enableOptimizations.value); + else{ + LOG(fatal) << "Error encountered while fetching/loading the KZeroShort model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?";} + } + } + else { + if (PredictLambda) lambda_bdt.initModel(BDTLocalPathLambda.value, enableOptimizations.value); + if (PredictAntiLambda) antilambda_bdt.initModel(BDTLocalPathAntiLambda.value, enableOptimizations.value); + if (PredictGamma) gamma_bdt.initModel(BDTLocalPathGamma.value, enableOptimizations.value); + if (PredictKZeroShort) kzeroshort_bdt.initModel(BDTLocalPathKZeroShort.value, enableOptimizations.value); + } + } + + // Process candidate and store properties in object + template + void processCandidate(TV0Object const& cand) + { + std::vector inputFeatures{cand.pt(), static_cast(cand.qtarm()), + cand.alpha(), cand.v0radius(), + cand.v0cosPA(), cand.dcaV0daughters(), + cand.dcapostopv(), cand.dcanegtopv()}; + + // calculate classifier + float* LambdaProbability = lambda_bdt.evalModel(inputFeatures); + float* GammaProbability = gamma_bdt.evalModel(inputFeatures); + //float* AntiLambdaProbability = antilambda_bdt.evalModel(inputFeatures); // WIP + //float* KZeroShortProbability = kzeroshort_bdt.evalModel(inputFeatures); // WIP + + gammaMLSelections(GammaProbability[1]); + lambdaMLSelections(LambdaProbability[1]); + } + + void processDerivedData(aod::StraCollision const& coll, V0DerivedDatas const& v0s) + { + histos.fill(HIST("hEventVertexZ"), coll.posZ()); + for (auto& v0: v0s){ // looping over lambdas + processCandidate(v0); + } + } + void processStandardData(aod::Collision const& coll, V0OriginalDatas const& v0s) + { + histos.fill(HIST("hEventVertexZ"), coll.posZ()); + for (auto& v0: v0s){ // looping over lambdas + processCandidate(v0); + } + } + + PROCESS_SWITCH(lambdakzeromlselection, processStandardData, "Process standard data", true); + PROCESS_SWITCH(lambdakzeromlselection, processDerivedData, "Process derived data", false); +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{adaptAnalysisTask(cfgc)}; +} diff --git a/PWGLF/TableProducer/Strangeness/sigma0builder.cxx b/PWGLF/TableProducer/Strangeness/sigma0builder.cxx new file mode 100644 index 00000000000..f80ca401a1e --- /dev/null +++ b/PWGLF/TableProducer/Strangeness/sigma0builder.cxx @@ -0,0 +1,243 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. +// +// This is a task that employs the standard V0 tables and attempts to combine +// two V0s into a Sigma0 -> Lambda + gamma candidate. + +#include "Framework/runDataProcessing.h" +#include "Framework/AnalysisTask.h" +#include "Framework/AnalysisDataModel.h" +#include "Framework/ASoAHelpers.h" +#include "Framework/ASoA.h" +#include "ReconstructionDataFormats/Track.h" +#include "Common/Core/RecoDecay.h" +#include "Common/Core/trackUtilities.h" +#include "PWGLF/DataModel/LFStrangenessTables.h" +#include "PWGLF/DataModel/LFStrangenessPIDTables.h" +#include "PWGLF/DataModel/LFStrangenessMLTables.h" +#include "PWGLF/DataModel/LFSigmaTables.h" +#include "Common/Core/TrackSelection.h" +#include "Common/DataModel/TrackSelectionTables.h" +#include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/Centrality.h" +#include "Common/DataModel/PIDResponse.h" +#include "CCDB/BasicCCDBManager.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; +using std::array; +using std::cout; +using std::endl; + +struct sigma0builder{ + Produces v0MLSigmas; // save sigma0 candidates for analysis + Produces v0MLMCSigmas; // save sigma0 candidates for analysis + + HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; + + Configurable Gamma_MLThreshold{"Gamma_MLThreshold", 0.1, "Decision Threshold value to select gammas of sigma0 candidates"}; + Configurable Lambda_MLThreshold{"Lambda_MLThreshold", 0.1, "Decision Threshold value to select lambdas of sigma0 candidates"}; + // Axis + // base properties + ConfigurableAxis vertexZ{"vertexZ", {30, -15.0f, 15.0f}, ""}; + // Invariant Mass + ConfigurableAxis axisSigmaMass{"axisSigmaMass", {200, 1.16f, 1.23f}, "M_{#Sigma^{0}} (GeV/c^{2})"}; + + void init(InitContext const&) + { + // Event counter + histos.add("hEventVertexZ", "hEventVertexZ", kTH1F, {vertexZ}); + histos.add("hEventVertexZMC", "hEventVertexZMC", kTH1F, {vertexZ}); + + // Number of reconstructed sigma per collision as QA + histos.add("hNSigmaCandidates", "hNSigmaCandidates", kTH1F, {{100,-0.5f, 99.5f}}); + histos.add("hNSigmaCandidatesMC", "hNSigmaCandidatesMC", kTH1F, {{100,-0.5f, 99.5f}}); + histos.add("hNGammaCandidatesMC", "hNGammaCandidatesMC", kTH1F, {{100,-0.5f, 99.5f}}); + histos.add("hNLambdaCandidatesMC", "hNLambdaCandidatesMC", kTH1F, {{100,-0.5f, 99.5f}}); + + // Invariant Mass + histos.add("InvMassSigmaMC", "InvMassSigmaMC", kTH1F, {axisSigmaMass}); + + if(doprocessCounterQA){ + histos.add("hGammaIndices", "hGammaIndices", {HistType::kTH1F, {{4000,0.0f, 400000.0f}}}); + histos.add("hCollIndices", "hCollIndices", {HistType::kTH1F, {{4000,0.0f, 4000.0f}}}); + histos.add("h2dIndices", "h2dIndices", {HistType::kTH2F, {{4000,0.0f, 40000.0f},{4000,0.0f, 400000.0f}}}); + } + } + + // Helper struct to pass v0 information + struct { + float mass; + float pT; + } sigmaCandidate; + + // Process sigma candidate and store properties in object + template + bool processSigmaCandidate(TCollision const& collision, TV0Object const& lambda, TV0Object const& gamma) + { + // Gamma selection: + if( gamma.gammaBDTScore() <= Gamma_MLThreshold) + return false; + + // Lambda selection: + if( lambda.lambdaBDTScore() <= Lambda_MLThreshold) + return false; + + std::array pVecPhotons{gamma.px(), gamma.py(), gamma.pz()}; + std::array pVecLambda{lambda.px(),lambda.py(), lambda.pz()}; + auto arrMom = std::array{pVecPhotons, pVecLambda}; + sigmaCandidate.mass = RecoDecay::m(arrMom, std::array{o2::constants::physics::MassPhoton, o2::constants::physics::MassLambda0}); + sigmaCandidate.pT = RecoDecay::pt(array{gamma.px() + lambda.px(), gamma.py() + lambda.py()}); + return true; + } + + // This process function cross-checks index correctness + void processCounterQA(soa::Join const& v0s) + { + for (auto& gamma: v0s) { + histos.fill(HIST("hGammaIndices"), gamma.globalIndex()); + histos.fill(HIST("hCollIndices"), gamma.straCollisionId()); + histos.fill(HIST("h2dIndices"), gamma.straCollisionId(), gamma.globalIndex()); + } + } + + void processMonteCarlo(aod::StraCollision const& coll, soa::Join const& v0s) + { + int SigmaCounter = 0; + int GammaCounter = 0; + int LambdaCounter = 0; + + histos.fill(HIST("hEventVertexZMC"), coll.posZ()); + + for (auto& gamma: v0s) { // selecting photons from Sigma0 + + if ((gamma.pdgCode()!=22) || (gamma.pdgCodeMother()!=3212)) continue; + GammaCounter++; + for (auto& lambda: v0s){ // selecting lambdas from Sigma0 + if ((lambda.pdgCode()!=3122) || (lambda.pdgCodeMother()!=3212)) continue; + LambdaCounter++; + + //if (gamma.motherMCPartId()!=lambda.motherMCPartId()) continue; + if(!processSigmaCandidate(coll, lambda,gamma)) continue; + SigmaCounter ++; + + bool fIsSigma = (gamma.motherMCPartId()==lambda.motherMCPartId()); + + // Sigma related + float fSigmapT = sigmaCandidate.pT; + float fSigmaMass = sigmaCandidate.mass; + + // Daughters related + /// Photon + float fPhotonPt = gamma.pt(); + float fPhotonMass = gamma.mGamma(); + float fPhotonQt = gamma.qtarm(); + float fPhotonAlpha = gamma.alpha(); + float fPhotonRadius = gamma.v0radius(); + float fPhotonCosPA = gamma.v0cosPA(); + float fPhotonDCADau = gamma.dcaV0daughters(); + float fPhotonDCANegPV = gamma.dcanegtopv(); + float fPhotonDCAPosPV = gamma.dcapostopv(); + float fPhotonZconv = gamma.z(); + + // Lambda + float fLambdaPt = lambda.pt(); + float fLambdaMass = lambda.mLambda(); + float fLambdaQt = lambda.qtarm(); + float fLambdaAlpha = lambda.alpha(); + float fLambdaRadius = lambda.v0radius(); + float fLambdaCosPA = lambda.v0cosPA(); + float fLambdaDCADau = lambda.dcaV0daughters(); + float fLambdaDCANegPV = lambda.dcanegtopv(); + float fLambdaDCAPosPV = lambda.dcapostopv(); + + // Filling TTree for ML analysis + v0MLMCSigmas(fSigmapT, fSigmaMass, fPhotonPt, fPhotonMass, fPhotonQt, fPhotonAlpha, fPhotonRadius, fPhotonCosPA, fPhotonDCADau, fPhotonDCANegPV, fPhotonDCAPosPV, fPhotonZconv, fLambdaPt, fLambdaMass, fLambdaQt, fLambdaAlpha, fLambdaRadius, fLambdaCosPA, fLambdaDCADau, fLambdaDCANegPV, fLambdaDCAPosPV, fIsSigma, gamma.gammaBDTScore(), lambda.lambdaBDTScore()); + histos.fill(HIST("InvMassSigmaMC"), fSigmaMass); + } + } + histos.fill(HIST("hNSigmaCandidatesMC"), SigmaCounter); + histos.fill(HIST("hNGammaCandidatesMC"), GammaCounter); + histos.fill(HIST("hNLambdaCandidatesMC"), LambdaCounter); + } + + void processRealData(aod::StraCollision const& coll, soa::Join const& v0s) + { + int SigmaCounter = 0; + + histos.fill(HIST("hEventVertexZ"), coll.posZ()); + + for (auto& gamma: v0s) { // selecting photons from Sigma0 + for (auto& lambda: v0s){ // selecting lambdas from Sigma0 + if(!processSigmaCandidate(coll, lambda,gamma)) + continue; + SigmaCounter ++; + + //bool fIsSigma = false; + + // Sigma related + float fSigmapT = sigmaCandidate.pT; + float fSigmaMass = sigmaCandidate.mass; + + // Daughters related + /// Photon + float fPhotonPt = gamma.pt(); + float fPhotonMass = gamma.mGamma(); + float fPhotonQt = gamma.qtarm(); + float fPhotonAlpha = gamma.alpha(); + float fPhotonRadius = gamma.v0radius(); + float fPhotonCosPA = gamma.v0cosPA(); + float fPhotonDCADau = gamma.dcaV0daughters(); + float fPhotonDCANegPV = gamma.dcanegtopv(); + float fPhotonDCAPosPV = gamma.dcapostopv(); + float fPhotonZconv = gamma.z(); + + // Lambda + float fLambdaPt = lambda.pt(); + float fLambdaMass = lambda.mLambda(); + float fLambdaQt = lambda.qtarm(); + float fLambdaAlpha = lambda.alpha(); + float fLambdaRadius = lambda.v0radius(); + float fLambdaCosPA = lambda.v0cosPA(); + float fLambdaDCADau = lambda.dcaV0daughters(); + float fLambdaDCANegPV = lambda.dcanegtopv(); + float fLambdaDCAPosPV = lambda.dcapostopv(); + + // Filling TTree for ML analysis + v0MLSigmas(fSigmapT, fSigmaMass, fPhotonPt, fPhotonMass, fPhotonQt, fPhotonAlpha, fPhotonRadius, fPhotonCosPA, fPhotonDCADau, fPhotonDCANegPV, fPhotonDCAPosPV, fPhotonZconv, fLambdaPt, fLambdaMass, fLambdaQt, fLambdaAlpha, fLambdaRadius, fLambdaCosPA, fLambdaDCADau, fLambdaDCANegPV, fLambdaDCAPosPV, gamma.gammaBDTScore(), lambda.lambdaBDTScore()); + + } + } + histos.fill(HIST("hNSigmaCandidates"), SigmaCounter); + } + + PROCESS_SWITCH(sigma0builder, processCounterQA, "Check standard counter correctness", true); + PROCESS_SWITCH(sigma0builder, processMonteCarlo, "Do Monte-Carlo-based analysis", true); + PROCESS_SWITCH(sigma0builder, processRealData, "Do real data analysis", false); +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{adaptAnalysisTask(cfgc)}; + +} \ No newline at end of file diff --git a/PWGLF/Tasks/Strangeness/CMakeLists.txt b/PWGLF/Tasks/Strangeness/CMakeLists.txt index 3458c3dfb81..e765fe1e847 100644 --- a/PWGLF/Tasks/Strangeness/CMakeLists.txt +++ b/PWGLF/Tasks/Strangeness/CMakeLists.txt @@ -78,3 +78,8 @@ o2physics_add_dpl_workflow(hstrangecorrelation SOURCES hStrangeCorrelation.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2::DetectorsBase O2Physics::AnalysisCore COMPONENT_NAME Analysis) + +o2physics_add_dpl_workflow(sigmaanalysis + SOURCES sigmaanalysis.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME Analysis) \ No newline at end of file diff --git a/PWGLF/Tasks/Strangeness/sigmaanalysis.cxx b/PWGLF/Tasks/Strangeness/sigmaanalysis.cxx new file mode 100644 index 00000000000..5d3a3d31add --- /dev/null +++ b/PWGLF/Tasks/Strangeness/sigmaanalysis.cxx @@ -0,0 +1,308 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. +// +// This is a task that employs the standard V0 tables and attempts to combine +// two V0s into a Sigma0 -> Lambda + gamma candidate. + +#include "Framework/runDataProcessing.h" +#include "Framework/AnalysisTask.h" +#include "Framework/AnalysisDataModel.h" +#include "Framework/ASoAHelpers.h" +#include "Framework/ASoA.h" +#include "ReconstructionDataFormats/Track.h" +#include "Common/Core/RecoDecay.h" +#include "Common/Core/trackUtilities.h" +#include "PWGLF/DataModel/LFStrangenessTables.h" +#include "PWGLF/DataModel/LFStrangenessPIDTables.h" +#include "PWGLF/DataModel/LFStrangenessMLTables.h" +#include "PWGLF/DataModel/LFSigmaTables.h" +#include "Common/Core/TrackSelection.h" +#include "Common/DataModel/TrackSelectionTables.h" +#include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/Centrality.h" +#include "Common/DataModel/PIDResponse.h" +#include "CCDB/BasicCCDBManager.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; +using std::array; +using std::cout; +using std::endl; +using dauTracks = soa::Join; + +struct sigmaanalysis{ + HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; + + // master analysis switches + //Configurable fSaveTTree{"fSaveTTree", false, "Save TTree with Sigma0 candidates info for ML-based analysis"}; + //Configurable analyseSigma{"analyseSigma", false, "process Sigma-like candidates"}; + //Configurable analyseAntiSigma{"analyseAntiSigma", false, "process AntiSigma-like candidates"}; + // Base selection criteria + + // Selection criteria: acceptance + Configurable rapidityCut{"rapidityCut", 0.5, "rapidity"}; + Configurable daughterEtaCut{"daughterEtaCut", 0.8, "max eta for daughters"}; + + // Photon standard criteria: + Configurable minPhotonRadius{"minPhotonRadius", 5.0, "minimum photon conversion radius (cm)"}; + Configurable maxPhotonRadius{"maxPhotonRadius", 180, "maximum photon conversion radius (cm)"}; + Configurable minPhotonPt{"minPhotonPt", 0.02, "minimum photon pT (GeV/c)"}; + Configurable minPhotonEta{"minPhotonEta", 0.9, "minimum photon eta"}; + Configurable maxPhotonMass{"maxPhotonMass", 0.1, "Maximum photon mass (GeV/c^{2})"}; + Configurable maxPhotonqt{"maxPhotonqt", 0.06, "Maximum photon qt value (AP plot) (GeV/c)"}; + Configurable Photonalpha{"Photonalpha", 0.95, "Max photon alpha absolute value (AP plot)"}; + + // PID (TPC) + Configurable TpcPidNsigmaCut{"TpcPidNsigmaCut", 4, "TpcPidNsigmaCut"}; + Configurable allowTPConly{"allowTPConly", false, "Accept V0s that are TPC-only"}; + + // Track quality + Configurable minTPCrows{"minTPCrows", 70, "minimum TPC crossed rows"}; + + // Lambda: + Configurable lambdaWindow{"lambdaWindow", 0.01, "Accept +/- this wrt Lambda mass (GeV/c^{2})"}; + Configurable v0cospa{"v0cospa", 0.97, "min V0 CosPA"}; + Configurable dcav0dau{"dcav0dau", 1.0, "max DCA V0 Daughters (cm)"}; + Configurable dcanegtopv{"dcanegtopv", .05, "min DCA Neg To PV (cm)"}; + Configurable dcapostopv{"dcapostopv", .05, "min DCA Pos To PV (cm)"}; + Configurable v0radius{"v0radius", 1.2, "minimum V0 radius (cm)"}; + + // Axis + // base properties + ConfigurableAxis vertexZ{"vertexZ", {30, -15.0f, 15.0f}, ""}; + 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}, "p_{T} (GeV/c)"}; + ConfigurableAxis axisRadius{"axisRadius", {200, 0.0f, 100.0f}, "V0 radius (cm)"}; + + // Invariant Mass + ConfigurableAxis axisSigmaMass{"axisSigmaMass", {200, 1.16f, 1.23f}, "M_{#Sigma^{0}} (GeV/c^{2})"}; + ConfigurableAxis axisLambdaMass{"axisLambdaMass", {200, 1.08f, 1.16f}, "M_{#Lambda} (GeV/c^{2})"}; + ConfigurableAxis axisPhotonMass{"axisPhotonMass", {200, -0.1f, 0.1f}, "M_{#Gamma}"}; + + // AP plot axes + ConfigurableAxis axisAPAlpha{"axisAPAlpha", {220, -1.1f, 1.1f}, "V0 AP alpha"}; + ConfigurableAxis axisAPQt{"axisAPQt", {220, 0.0f, 0.5f}, "V0 AP alpha"}; + + // ML + ConfigurableAxis MLProb{"MLOutput", {100, 0.0f, 1.0f}, ""}; + + void init(InitContext const&) + { + // Event counter + histos.add("hEventVertexZ", "hEventVertexZ", kTH1F, {vertexZ}); + histos.add("hEventVertexZMC", "hEventVertexZMC", kTH1F, {vertexZ}); + + // Number of reconstructed sigma per collision as QA + histos.add("hNSigmaCandidates", "hNSigmaCandidates", kTH1F, {{100,-0.5f, 99.5f}}); + histos.add("hNSigmaCandidatesMC", "hNSigmaCandidatesMC", kTH1F, {{100,-0.5f, 99.5f}}); + + // V0 Radius + histos.add("h2dLambdaRadiusVsPt", "hLambdaRadiusVsPt", {HistType::kTH2F, {axisPt, axisRadius}}); + histos.add("h2dPhotonRadiusVsPt", "hPhotonRadiusVsPt", {HistType::kTH2F, {axisPt, axisRadius}}); + histos.add("h2dLambdaRadiusVsPtMC", "hLambdaRadiusVsPtMC", {HistType::kTH2F, {axisPt, axisRadius}}); + histos.add("h2dPhotonRadiusVsPtMC", "hPhotonRadiusVsPtMC", {HistType::kTH2F, {axisPt, axisRadius}}); + + // Invariant Mass + histos.add("h2dSigmaMassVsPt", "hSigmaMassVsPt", {HistType::kTH2F, {axisPt, axisSigmaMass}}); + histos.add("h2dLambdaMassVsPt", "hLambdaMassVsPt", {HistType::kTH2F, {axisPt, axisLambdaMass}}); + histos.add("h2dPhotonMassVsPt", "hPhotonMassVsPt", {HistType::kTH2F, {axisPt, axisPhotonMass}}); + histos.add("h2dSigmaMassVsPtMC", "hSigmaMassVsPtMC", {HistType::kTH2F, {axisPt, axisSigmaMass}}); + histos.add("h2dLambdaMassVsPtMC", "hLambdaMassVsPtMC", {HistType::kTH2F, {axisPt, axisLambdaMass}}); + histos.add("h2dPhotonMassVsPtMC", "hPhotonMassVsPtMC", {HistType::kTH2F, {axisPt, axisPhotonMass}}); + + // Exploratory Analysis with MC: + /// Armenteros-Polanski plot: + histos.add("h2dMCArmenterosPolanski", "h2dMCArmenterosPolanski", {HistType::kTH2F, {axisAPAlpha, axisAPQt}}); + + /// Lambda + histos.add("hMCLambdaCosPA", "hMCLambdaCosPA", kTH1F, {{100, 0.9f, 1.0f}}); + histos.add("hMCLambdaDCA_V0Dau", "hMCLambdaDCA_V0Dau", kTH1F, {{100, 0.0f, 3.0f}}); + histos.add("hMCLambdaDCA_V0Pos", "hMCLambdaDCA_V0Pos", kTH1F, {{100, 0.0f, 2.0f}}); + histos.add("hMCLambdaDCA_V0Neg", "hMCLambdaDCA_V0Neg", kTH1F, {{100, 0.0f, 2.0f}}); + histos.add("hMCLambda_V0Radius", "hMCLambda_V0Radius", kTH1F, {{100, 0.0f, 40.0f}}); + + /// Photon: + histos.add("hMCPhoton_ConversionRadius", "hMCPhoton_ConversionRadius", kTH1F, {{100, 0.0f, 150.0f}}); + histos.add("hMCPhotonCosPA", "hMCPhotonCosPA", kTH1F, {{100, 0.9f, 1.0f}}); + histos.add("hMCPhotonDCA_V0Dau", "hMCPhotonDCA_V0Dau", kTH1F, {{100, 0.0f, 5.0}}); + histos.add("hMCPhotonDCA_V0Pos", "hMCPhotonDCA_V0Pos", kTH1F, {{100, 0.0f, 5.0f}}); + histos.add("hMCPhotonDCA_V0Neg", "hMCPhotonDCA_V0Neg", kTH1F, {{100, 0.0f, 5.0f}}); + + // ML Analysis + histos.add("hMLOutputLambda", "hMLOutputLambda", kTH1F, {MLProb}); + histos.add("hMLOutputGamma", "hMLOutputGamma", kTH1F, {MLProb}); + + if(doprocessCounterQA){ + histos.add("hGammaIndices", "hGammaIndices", {HistType::kTH1F, {{4000,0.0f, 400000.0f}}}); + histos.add("hCollIndices", "hCollIndices", {HistType::kTH1F, {{4000,0.0f, 4000.0f}}}); + histos.add("h2dIndices", "h2dIndices", {HistType::kTH2F, {{4000,0.0f, 40000.0f},{4000,0.0f, 400000.0f}}}); + } + } + + // Helper struct to pass v0 information + struct { + float mass; + float pT; + } sigmaCandidate; + + // Process sigma candidate and store properties in object + template + bool processSigmaCandidate(TCollision const& collision, TV0Object const& lambda, TV0Object const& gamma) + { + // FIXME: this should be at the single particle level, preferably partitions + if( !allowTPConly && (lambda.v0Type()>1||gamma.v0Type()>1)) + return false; + + // Gamma selection criteria: + if( gamma.mGamma() > maxPhotonMass ) + return false; + if( gamma.v0radius() < minPhotonRadius ) + return false; + if( gamma.v0radius() > maxPhotonRadius ) + return false; + if( gamma.pt() < minPhotonPt) + return false; + if( gamma.qtarm() > maxPhotonqt) + return false; + if(TMath::Abs(gamma.alpha()) > Photonalpha) + return false; + + // Lambda selection criteria: + if( TMath::Abs(lambda.mLambda()-1.115683) > lambdaWindow) + return false; + if( lambda.v0radius() < v0radius) + return false; + if( lambda.v0cosPA() < v0cospa) + return false; + if( lambda.dcapostopv() < dcapostopv) + return false; + if( lambda.dcanegtopv() < dcanegtopv) + return false; + if( lambda.dcaV0daughters() > dcav0dau) + return false; + + std::array pVecPhotons{gamma.px(), gamma.py(), gamma.pz()}; + std::array pVecLambda{lambda.px(),lambda.py(), lambda.pz()}; + auto arrMom = std::array{pVecPhotons, pVecLambda}; + sigmaCandidate.mass = RecoDecay::m(arrMom, std::array{o2::constants::physics::MassPhoton, o2::constants::physics::MassLambda0}); + sigmaCandidate.pT = RecoDecay::pt(array{gamma.px() + lambda.px(), gamma.py() + lambda.py()}); + return true; + } + + // This process function cross-checks index correctness + void processCounterQA(soa::Join const& v0s) + { + for (auto& gamma: v0s) { + histos.fill(HIST("hGammaIndices"), gamma.globalIndex()); + histos.fill(HIST("hCollIndices"), gamma.straCollisionId()); + histos.fill(HIST("h2dIndices"), gamma.straCollisionId(), gamma.globalIndex()); + } + } + + void processMonteCarlo(aod::StraCollision const& coll, soa::Join const& v0s) + { + int SigmaCounter = 0; + + histos.fill(HIST("hEventVertexZMC"), coll.posZ()); + + for (auto& gamma: v0s) { // selecting photons from Sigma0 + + if ((gamma.pdgCode()!=22 || gamma.pdgCodeMother()!=3212) && (gamma.pdgCode()!=-22 || gamma.pdgCodeMother()!=-3212)) continue; + + for (auto& lambda: v0s){ // selecting lambdas from Sigma0 + if ((lambda.pdgCode()!=3122 || lambda.pdgCodeMother()!=3212) && (lambda.pdgCode()!=-3122 || lambda.pdgCodeMother()!=-3212)) continue; + if (gamma.motherMCPartId()!=lambda.motherMCPartId()) continue; // selecting pair from exactly the same mother + + // Exploratory Analysis histograms: + + // Lambda + histos.fill(HIST("hMCLambdaCosPA"), lambda.v0cosPA()); + histos.fill(HIST("hMCLambdaDCA_V0Dau"), TMath::Abs(lambda.dcaV0daughters())); + histos.fill(HIST("hMCLambdaDCA_V0Pos"), TMath::Abs(lambda.dcapostopv())); + histos.fill(HIST("hMCLambdaDCA_V0Neg"), TMath::Abs(lambda.dcanegtopv())); + histos.fill(HIST("hMCLambda_V0Radius"), lambda.v0radius()); + + // Photon + histos.fill(HIST("hMCPhoton_ConversionRadius"), gamma.v0radius()); + histos.fill(HIST("hMCPhotonCosPA"), gamma.v0cosPA()); + histos.fill(HIST("hMCPhotonDCA_V0Dau"), TMath::Abs(gamma.dcaV0daughters())); + histos.fill(HIST("hMCPhotonDCA_V0Pos"), TMath::Abs(gamma.dcapostopv())); + histos.fill(HIST("hMCPhotonDCA_V0Neg"), TMath::Abs(gamma.dcanegtopv())); + + // Armenteros-Polanski plot: + histos.fill(HIST("h2dMCArmenterosPolanski"), gamma.alpha(), gamma.qtarm()); + histos.fill(HIST("h2dMCArmenterosPolanski"), lambda.alpha(), lambda.qtarm()); + + if(!processSigmaCandidate(coll, lambda,gamma)) + continue; + SigmaCounter ++; + + histos.fill(HIST("h2dLambdaRadiusVsPtMC"), sigmaCandidate.pT, lambda.v0radius()); + histos.fill(HIST("h2dPhotonRadiusVsPtMC"), sigmaCandidate.pT, gamma.v0radius()); + + //Inv Mass + histos.fill(HIST("h2dLambdaMassVsPtMC"), sigmaCandidate.pT, lambda.mLambda()); + histos.fill(HIST("h2dPhotonMassVsPtMC"), sigmaCandidate.pT, gamma.mGamma()); + histos.fill(HIST("h2dSigmaMassVsPtMC"), sigmaCandidate.pT, sigmaCandidate.mass); + } + } + histos.fill(HIST("hNSigmaCandidatesMC"), SigmaCounter); + } + + void processRealData(aod::StraCollision const& coll, soa::Join const& v0s) + { + int SigmaCounter = 0; + + histos.fill(HIST("hEventVertexZ"), coll.posZ()); + + for (auto& gamma: v0s) { // selecting photons from Sigma0 + for (auto& lambda: v0s){ // selecting lambdas from Sigma0 + if(!processSigmaCandidate(coll, lambda,gamma)) + continue; + SigmaCounter ++; + + histos.fill(HIST("h2dLambdaRadiusVsPt"), sigmaCandidate.pT, lambda.v0radius()); + histos.fill(HIST("h2dPhotonRadiusVsPt"), sigmaCandidate.pT, gamma.v0radius()); + + //Inv Mass + histos.fill(HIST("h2dLambdaMassVsPt"), sigmaCandidate.pT, lambda.mLambda()); + histos.fill(HIST("h2dPhotonMassVsPt"), sigmaCandidate.pT, gamma.mGamma()); + histos.fill(HIST("h2dSigmaMassVsPt"), sigmaCandidate.pT, sigmaCandidate.mass); + + histos.fill(HIST("hMLOutputLambda"), lambda.lambdaBDTScore()); + histos.fill(HIST("hMLOutputGamma"), gamma.gammaBDTScore()); + + } + } + histos.fill(HIST("hNSigmaCandidates"), SigmaCounter); + } + + 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); +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{adaptAnalysisTask(cfgc)}; + +} \ No newline at end of file From 66e7c88509068c89e3c28f5f25c8b247f44d3f6b Mon Sep 17 00:00:00 2001 From: gianniliveraro Date: Thu, 11 Apr 2024 07:16:49 -0300 Subject: [PATCH 02/26] PWGLF: Updating feature list and selections --- PWGLF/DataModel/LFStrangenessMLTables.h | 86 ++++++-- .../Strangeness/lambdakzeroTreeCreator.cxx | 184 +++++++++++------- 2 files changed, 176 insertions(+), 94 deletions(-) diff --git a/PWGLF/DataModel/LFStrangenessMLTables.h b/PWGLF/DataModel/LFStrangenessMLTables.h index 2c8faffa4ce..562f0b3d7e3 100644 --- a/PWGLF/DataModel/LFStrangenessMLTables.h +++ b/PWGLF/DataModel/LFStrangenessMLTables.h @@ -27,18 +27,41 @@ namespace o2::aod { namespace v0mlcandidates { +DECLARE_SOA_COLUMN(PosITSCls, posITSCls, int); +DECLARE_SOA_COLUMN(NegITSCls, negITSCls, int); +DECLARE_SOA_COLUMN(PosTPCRows, posTPCRows, float); +DECLARE_SOA_COLUMN(NegTPCRows, negTPCRows, float); +DECLARE_SOA_COLUMN(PosTPCSigmaPi, posTPCSigmaPi, float); +DECLARE_SOA_COLUMN(NegTPCSigmaPi, negTPCSigmaPi, float); +DECLARE_SOA_COLUMN(PosTPCSigmaPr, posTPCSigmaPr, float); +DECLARE_SOA_COLUMN(NegTPCSigmaPr, negTPCSigmaPr, float); +DECLARE_SOA_COLUMN(PosTPCSigmaEl, posTPCSigmaEl, float); +DECLARE_SOA_COLUMN(NegTPCSigmaEl, negTPCSigmaEl, float); +DECLARE_SOA_COLUMN(TOFSigmaLaPr, tofSigmaLaPr, float); +DECLARE_SOA_COLUMN(TOFSigmaLaPi, tofSigmaLaPi, float); +DECLARE_SOA_COLUMN(TOFSigmaALaPi, tofSigmaALaPi, float); +DECLARE_SOA_COLUMN(TOFSigmaALaPr, tofSigmaALaPr, float); +DECLARE_SOA_COLUMN(TOFSigmaK0PiPlus, tofSigmaK0PiPlus, float); +DECLARE_SOA_COLUMN(TOFSigmaK0PiMinus, tofSigmaK0PiMinus, float); DECLARE_SOA_COLUMN(LambdaMass, lambdaMass, float); -DECLARE_SOA_COLUMN(AntiLambdaMass, antilambdaMass, float); +DECLARE_SOA_COLUMN(AntiLambdaMass, antiLambdaMass, float); DECLARE_SOA_COLUMN(GammaMass, gammaMass, float); DECLARE_SOA_COLUMN(KZeroShortMass, kZeroShortMass, float); -DECLARE_SOA_COLUMN(Pt, pt, float); +DECLARE_SOA_COLUMN(PT, pT, float); DECLARE_SOA_COLUMN(Qt, qt, float); DECLARE_SOA_COLUMN(Alpha, alpha, float); -DECLARE_SOA_COLUMN(Radius, radius, float); -DECLARE_SOA_COLUMN(CosPA, cosPA, float); -DECLARE_SOA_COLUMN(DCADau, dcaDau, float); -DECLARE_SOA_COLUMN(DCANegPV, dcaNegPV, float); -DECLARE_SOA_COLUMN(DCAPosPV, dcaPosPV, float); +DECLARE_SOA_COLUMN(PosEta, posEta, float); +DECLARE_SOA_COLUMN(NegEta, negEta, float); +DECLARE_SOA_COLUMN(V0Eta, v0Eta, float); +DECLARE_SOA_COLUMN(Z, z, float); +DECLARE_SOA_COLUMN(V0radius, v0radius, float); +DECLARE_SOA_COLUMN(PA, pa, float); +DECLARE_SOA_COLUMN(DCApostopv, dcapostopv, float); +DECLARE_SOA_COLUMN(DCAnegtopv, dcanegtopv, float); +DECLARE_SOA_COLUMN(DCAV0daughters, dcaV0daughters, float); +DECLARE_SOA_COLUMN(DCAv0topv, dcav0topv, float); +DECLARE_SOA_COLUMN(PsiPair, psiPair, float); +DECLARE_SOA_COLUMN(V0type, v0type, uint8_t); DECLARE_SOA_COLUMN(IsLambda, isLambda, bool); DECLARE_SOA_COLUMN(IsAntiLambda, isAntiLambda, bool); DECLARE_SOA_COLUMN(IsGamma, isGamma, bool); @@ -46,21 +69,44 @@ DECLARE_SOA_COLUMN(IsKZeroShort, isKZeroShort, bool); } // namespace v0mlcandidates DECLARE_SOA_TABLE(V0MLCandidates, "AOD", "V0MLCANDIDATES", - v0mlcandidates::LambdaMass, - v0mlcandidates::AntiLambdaMass, - v0mlcandidates::GammaMass, - v0mlcandidates::KZeroShortMass, - v0mlcandidates::Pt, + v0mlcandidates::PosITSCls, + v0mlcandidates::NegITSCls, + v0mlcandidates::PosTPCRows, + v0mlcandidates::NegTPCRows, + v0mlcandidates::PosTPCSigmaPi, + v0mlcandidates::NegTPCSigmaPi, + v0mlcandidates::PosTPCSigmaPr, + v0mlcandidates::NegTPCSigmaPr, + v0mlcandidates::PosTPCSigmaEl, + v0mlcandidates::NegTPCSigmaEl, + v0mlcandidates::TOFSigmaLaPr, + v0mlcandidates::TOFSigmaLaPi, + v0mlcandidates::TOFSigmaALaPi, + v0mlcandidates::TOFSigmaALaPr, + v0mlcandidates::TOFSigmaK0PiPlus, + v0mlcandidates::TOFSigmaK0PiMinus, + v0mlcandidates::LambdaMass, + v0mlcandidates::AntiLambdaMass, + v0mlcandidates::GammaMass, + v0mlcandidates::KZeroShortMass, + v0mlcandidates::PT, v0mlcandidates::Qt, v0mlcandidates::Alpha, - v0mlcandidates::Radius, - v0mlcandidates::CosPA, - v0mlcandidates::DCADau, - v0mlcandidates::DCANegPV, - v0mlcandidates::DCAPosPV, - v0mlcandidates::IsLambda, - v0mlcandidates::IsAntiLambda, - v0mlcandidates::IsGamma, + v0mlcandidates::PosEta, + v0mlcandidates::NegEta, + v0mlcandidates::V0Eta, + v0mlcandidates::Z, + v0mlcandidates::V0radius, + v0mlcandidates::PA, + v0mlcandidates::DCApostopv, + v0mlcandidates::DCAnegtopv, + v0mlcandidates::DCAV0daughters, + v0mlcandidates::DCAv0topv, + v0mlcandidates::PsiPair, + v0mlcandidates::V0type, + v0mlcandidates::IsLambda, + v0mlcandidates::IsAntiLambda, + v0mlcandidates::IsGamma, v0mlcandidates::IsKZeroShort); diff --git a/PWGLF/TableProducer/Strangeness/lambdakzeroTreeCreator.cxx b/PWGLF/TableProducer/Strangeness/lambdakzeroTreeCreator.cxx index f3bef595d78..530aea480a6 100644 --- a/PWGLF/TableProducer/Strangeness/lambdakzeroTreeCreator.cxx +++ b/PWGLF/TableProducer/Strangeness/lambdakzeroTreeCreator.cxx @@ -64,37 +64,28 @@ using std::array; using std::cout; using std::endl; +using dauTracks = soa::Join; + struct lambdakzeroTreeCreator{ Produces v0MLCandidates; HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; - // selection switches: please, use just one at a time + // selection switches: please, use just one at a time! Configurable fGetAllCandidates{"fGetAllCandidates", true, "If True, create a Tree containing all available candidates"}; Configurable fGetLambdaOnly{"fGetLambdaOnly", false, "If True, apply cuts to select only lambda signal and bkg candidates"}; - Configurable fGetAntiLambdaOnly{"fGetAntiLambdaOnly", false, "If True, apply cuts to select only lambda signal and bkg candidates"}; + Configurable fGetAntiLambdaOnly{"fGetAntiLambdaOnly", false, "If True, apply cuts to select only antilambda signal and bkg candidates"}; Configurable fGetGammaOnly{"fGetGammaOnly", false, "If True, apply cuts to select only Gamma signal and bkg candidates"}; Configurable fGetK0ShortOnly{"fGetK0ShortOnly", false, "If True, apply cuts to select only K0Short signal and bkg candidates"}; // Base selection criteria - /// Selection criteria: acceptance - Configurable rapidityCut{"rapidityCut", 0.5, "rapidity"}; - Configurable daughterEtaCut{"daughterEtaCut", 0.8, "max eta for daughters"}; - - // PID (TPC) - Configurable TpcPidNsigmaCut{"TpcPidNsigmaCut", 4, "TpcPidNsigmaCut"}; - Configurable allowTPConly{"allowTPConly", false, "Accept V0s that are TPC-only"}; - - // Track quality - Configurable minTPCrows{"minTPCrows", 70, "minimum TPC crossed rows"}; - // Lambda standard criteria:: - //Configurable lambdaWindow{"lambdaWindow", 0.01, "Accept +/- this wrt Lambda mass (GeV/c^{2})"}; Configurable Lambdav0cospa{"Lambdav0cospa", 0.90, "min V0 CosPA"}; Configurable Lambdadcav0dau{"Lambdadcav0dau", 1.0, "max DCA V0 Daughters (cm)"}; Configurable Lambdadcanegtopv{"Lambdadcanegtopv", .05, "min DCA Neg To PV (cm)"}; Configurable Lambdadcapostopv{"Lambdadcapostopv", .05, "min DCA Pos To PV (cm)"}; Configurable Lambdav0radius{"Lambdav0radius", 1.5, "minimum V0 radius (cm)"}; + Configurable LambdaWindow{"LambdaWindow", 0.01, "Mass window around expected (in GeV/c2)"}; // Anti-Lambda standard criteria:: Configurable AntiLambdav0cospa{"AntiLambdav0cospa", 0.90, "min V0 CosPA"}; @@ -102,6 +93,7 @@ struct lambdakzeroTreeCreator{ Configurable AntiLambdadcanegtopv{"AntiLambdadcanegtopv", .05, "min DCA Neg To PV (cm)"}; Configurable AntiLambdadcapostopv{"AntiLambdadcapostopv", .05, "min DCA Pos To PV (cm)"}; Configurable AntiLambdav0radius{"AntiLambdav0radius", 1.5, "minimum V0 radius (cm)"}; + Configurable AntiLambdaWindow{"AntiLambdaWindow", 0.01, "Mass window around expected (in GeV/c2)"}; // Photon standard criteria: Configurable PhotonMinRadius{"PhotonMinRadius", 1.0, "minimum photon conversion radius (cm)"}; @@ -110,8 +102,16 @@ struct lambdakzeroTreeCreator{ Configurable PhotonMaxMass{"PhotonMaxMass", 0.2, "Maximum photon mass (GeV/c^{2})"}; Configurable PhotonMaxqt{"PhotonMaxqt", 0.1, "Maximum photon qt value (AP plot) (GeV/c)"}; Configurable PhotonMaxalpha{"PhotonMaxalpha", 1.0, "Max photon alpha absolute value (AP plot)"}; + Configurable PhotonWindow{"PhotonWindow", 0.01, "Mass window around expected (in GeV/c2)"}; - // TODO: Include here K0Short standard criteria + // KZeroShort standard criteria: + // TODO: update criteria + Configurable K0Shortv0cospa{"K0Shortv0cospa", 0.90, "min V0 CosPA"}; + Configurable K0Shortdcav0dau{"K0Shortdcav0dau", 1.0, "max DCA V0 Daughters (cm)"}; + Configurable K0Shortdcanegtopv{"K0Shortdcanegtopv", .05, "min DCA Neg To PV (cm)"}; + Configurable K0Shortdcapostopv{"K0Shortdcapostopv", .05, "min DCA Pos To PV (cm)"}; + Configurable K0Shortv0radius{"K0Shortv0radius", 1.5, "minimum V0 radius (cm)"}; + Configurable K0ShortWindow{"K0ShortWindow", 0.01, "Mass window around expected (in GeV/c2)"}; // Axis: ConfigurableAxis vertexZ{"vertexZ", {30, -15.0f, 15.0f}, ""}; @@ -123,28 +123,77 @@ struct lambdakzeroTreeCreator{ // Helper struct to pass v0 information struct { - float LambdaMass; - float AntiLambdaMass; - float GammaMass; - float KZeroShortMass; - float pT; - float qt; - float alpha; - float v0radius; - float v0cosPA; - float dcapostopv; - float dcanegtopv; - float dcaV0daughters; - bool isLambda; - bool isAntiLambda; - bool isGamma; - bool isKZeroShort; + int posITSCls; + int negITSCls; + float posTPCRows; + float negTPCRows; + float posTPCSigmaPi; + float negTPCSigmaPi; + float posTPCSigmaPr; + float negTPCSigmaPr; + float posTPCSigmaEl; + float negTPCSigmaEl; + float TOFSigmaLaPr; + float TOFSigmaLaPi; + float TOFSigmaALaPi; + float TOFSigmaALaPr; + float TOFSigmaK0PiPlus; + float TOFSigmaK0PiMinus; + float LambdaMass; + float AntiLambdaMass; + float GammaMass; + float KZeroShortMass; + float pT; + float qt; + float alpha; + float posEta; + float negEta; + float v0Eta; + float Z; + float v0radius; + float PA; + float dcapostopv; + float dcanegtopv; + float dcaV0daughters; + float dcav0topv; + float PsiPair; + uint8_t v0type; + bool isLambda; + bool isAntiLambda; + bool isGamma; + bool isKZeroShort; } Candidate; // Process candidate and store properties in object template bool processCandidate(TV0Object const& cand) { + auto posTrackExtra = cand.template posTrackExtra_as(); + auto negTrackExtra = cand.template negTrackExtra_as(); + + // Track quality + Candidate.posITSCls = posTrackExtra.itsNCls(); + Candidate.negITSCls = negTrackExtra.itsNCls(); + Candidate.posTPCRows = posTrackExtra.tpcCrossedRows(); + Candidate.negTPCRows = negTrackExtra.tpcCrossedRows(); + + // TPC PID + Candidate.posTPCSigmaPi = posTrackExtra.tpcNSigmaPi(); + Candidate.negTPCSigmaPi = negTrackExtra.tpcNSigmaPi(); + Candidate.posTPCSigmaPr = posTrackExtra.tpcNSigmaPr(); + Candidate.negTPCSigmaPr = negTrackExtra.tpcNSigmaPr(); + Candidate.posTPCSigmaEl = posTrackExtra.tpcNSigmaEl(); + Candidate.negTPCSigmaEl = negTrackExtra.tpcNSigmaEl(); + + // TOF PID: + Candidate.TOFSigmaLaPr = cand.tofNSigmaLaPr(); + Candidate.TOFSigmaLaPi = cand.tofNSigmaLaPi(); + Candidate.TOFSigmaALaPi = cand.tofNSigmaALaPi(); + Candidate.TOFSigmaALaPr = cand.tofNSigmaALaPr(); + Candidate.TOFSigmaK0PiPlus = cand.tofNSigmaK0PiPlus(); + Candidate.TOFSigmaK0PiMinus = cand.tofNSigmaK0PiMinus(); + + // General Candidate.LambdaMass = cand.mLambda(); Candidate.AntiLambdaMass = cand.mAntiLambda(); Candidate.GammaMass = cand.mGamma(); @@ -152,11 +201,24 @@ struct lambdakzeroTreeCreator{ Candidate.pT = cand.pt(); Candidate.qt = cand.qtarm(); Candidate.alpha = cand.alpha(); + Candidate.posEta = cand.positiveeta(); + Candidate.negEta = cand.negativeeta(); + Candidate.v0Eta = cand.eta(); + Candidate.Z = cand.z(); + + // Topological Candidate.v0radius = cand.v0radius(); - Candidate.v0cosPA = cand.v0cosPA(); + Candidate.PA = TMath::ACos(cand.v0cosPA()); Candidate.dcapostopv = cand.dcapostopv(); Candidate.dcanegtopv = cand.dcanegtopv(); Candidate.dcaV0daughters = cand.dcaV0daughters(); + Candidate.dcav0topv = cand.dcav0topv(); + Candidate.PsiPair = cand.psipair(); + + // Debug + Candidate.v0type = cand.v0Type(); + + // MC flags Candidate.isLambda = (cand.pdgCode()==3122); Candidate.isAntiLambda = (cand.pdgCode()==-3122); Candidate.isGamma = (cand.pdgCode()==22); @@ -171,18 +233,8 @@ struct lambdakzeroTreeCreator{ { // FIXME: there are smarter ways to perform this selection // Lambda base selection criteria: - - if( lambda.v0radius() < Lambdav0radius) - return false; - if( lambda.v0cosPA() < Lambdav0cospa) - return false; - if(TMath::Abs(lambda.dcapostopv()) < Lambdadcapostopv) - return false; - if(TMath::Abs(lambda.dcanegtopv()) < Lambdadcanegtopv) + if ((std::abs(lambda.mLambda() - 1.115683) > LambdaWindow) || (lambda.v0radius() < Lambdav0radius) || ( lambda.v0cosPA() < Lambdav0cospa) || (TMath::Abs(lambda.dcapostopv()) < Lambdadcapostopv) || (TMath::Abs(lambda.dcanegtopv()) < Lambdadcanegtopv) || ( lambda.dcaV0daughters() > Lambdadcav0dau)) return false; - if( lambda.dcaV0daughters() > Lambdadcav0dau) - return false; - return processCandidate(lambda); } @@ -192,18 +244,8 @@ struct lambdakzeroTreeCreator{ { // FIXME: there are smarter ways to perform this selection // AntiLambda base selection criteria: - - if( antilambda.v0radius() < AntiLambdav0radius) - return false; - if( antilambda.v0cosPA() < AntiLambdav0cospa) + if ((std::abs(antilambda.mAntiLambda() - 1.115683) > AntiLambdaWindow) || (antilambda.v0radius() < AntiLambdav0radius) || (antilambda.v0cosPA() < AntiLambdav0cospa) || (TMath::Abs(antilambda.dcapostopv()) < AntiLambdadcapostopv) || (TMath::Abs(antilambda.dcanegtopv()) < AntiLambdadcanegtopv) || (antilambda.dcaV0daughters() > AntiLambdadcav0dau)) return false; - if(TMath::Abs(antilambda.dcapostopv()) < AntiLambdadcapostopv) - return false; - if(TMath::Abs(antilambda.dcanegtopv()) < AntiLambdadcanegtopv) - return false; - if( antilambda.dcaV0daughters() > AntiLambdadcav0dau) - return false; - return processCandidate(antilambda); } @@ -213,19 +255,8 @@ struct lambdakzeroTreeCreator{ { // FIXME: there are smarter ways to perform this selection // Gamma selection criteria: - if( gamma.mGamma() > PhotonMaxMass ) - return false; - if( gamma.v0radius() < PhotonMinRadius ) - return false; - if( gamma.v0radius() > PhotonMaxRadius ) - return false; - if( gamma.pt() < PhotonMinPt) - return false; - if( gamma.qtarm() > PhotonMaxqt) - return false; - if(TMath::Abs(gamma.alpha()) > PhotonMaxalpha) - return false; - + if ((std::abs(gamma.mGamma()) > PhotonWindow) || (gamma.mGamma() > PhotonMaxMass) || (gamma.v0radius() < PhotonMinRadius) || (gamma.v0radius() > PhotonMaxRadius) || (gamma.pt() < PhotonMinPt) || (gamma.qtarm() > PhotonMaxqt) || (TMath::Abs(gamma.alpha()) > PhotonMaxalpha)) + return false; return processCandidate(gamma); } @@ -234,12 +265,13 @@ struct lambdakzeroTreeCreator{ bool processK0ShortCandidate(TV0Object const& kzero) { // FIXME: there are smarter ways to perform this selection - // TODO: Include KZeroShort selection criteria - + // TODO: Update KZeroShort selection criteria + if ((std::abs(kzero.mK0Short() - 0.497) > K0ShortWindow) || (kzero.v0radius() < K0Shortv0radius) || (kzero.v0cosPA() < K0Shortv0cospa) || (TMath::Abs(kzero.dcapostopv()) < K0Shortdcapostopv) || (TMath::Abs(kzero.dcanegtopv()) < K0Shortdcanegtopv) || (kzero.dcaV0daughters() > K0Shortdcav0dau)) + return false; return processCandidate(kzero); } - void process(aod::StraCollision const& coll, soa::Join const& v0s) + void process(aod::StraCollision const& coll, soa::Join const& v0s) { histos.fill(HIST("hEventVertexZMC"), coll.posZ()); for (auto& cand: v0s){ // looping over lambdas @@ -266,10 +298,14 @@ struct lambdakzeroTreeCreator{ } // Filling TTree for ML analysis - v0MLCandidates(Candidate.LambdaMass, Candidate.AntiLambdaMass, Candidate.GammaMass, Candidate.KZeroShortMass, - Candidate.pT, Candidate.qt, Candidate.alpha, Candidate.v0radius, Candidate.v0cosPA, - Candidate.dcapostopv, Candidate.dcanegtopv, Candidate.dcaV0daughters, - Candidate.isLambda, Candidate.isAntiLambda, Candidate.isGamma, Candidate.isKZeroShort); + v0MLCandidates(Candidate.posITSCls, Candidate.negITSCls, Candidate.posTPCRows, Candidate.negTPCRows, + Candidate.posTPCSigmaPi, Candidate.negTPCSigmaPi, Candidate.posTPCSigmaPr, Candidate.negTPCSigmaPr, + Candidate.posTPCSigmaEl, Candidate.negTPCSigmaEl, Candidate.TOFSigmaLaPr, Candidate.TOFSigmaLaPi, + Candidate.TOFSigmaALaPi, Candidate.TOFSigmaALaPr, Candidate.TOFSigmaK0PiPlus, Candidate.TOFSigmaK0PiMinus, + Candidate.LambdaMass, Candidate.AntiLambdaMass, Candidate.GammaMass, Candidate.KZeroShortMass, Candidate.pT, + Candidate.qt, Candidate.alpha, Candidate.posEta, Candidate.negEta, Candidate.v0Eta, Candidate.Z, + Candidate.v0radius, Candidate.PA, Candidate.dcapostopv, Candidate.dcanegtopv, Candidate.dcaV0daughters, Candidate.dcav0topv, Candidate.PsiPair, + Candidate.v0type, Candidate.isLambda, Candidate.isAntiLambda, Candidate.isGamma, Candidate.isKZeroShort); } } From 78a333895b1491f2facf1789a49acaebc2dcc16f Mon Sep 17 00:00:00 2001 From: gianniliveraro Date: Thu, 11 Apr 2024 08:15:00 -0300 Subject: [PATCH 03/26] PWGLF/Sigma0builder: modularize further --- PWGLF/DataModel/LFSigmaTables.h | 120 +++++------------- .../Strangeness/sigma0builder.cxx | 93 ++------------ 2 files changed, 46 insertions(+), 167 deletions(-) diff --git a/PWGLF/DataModel/LFSigmaTables.h b/PWGLF/DataModel/LFSigmaTables.h index 861bb6759a0..e0ec85f6ec0 100644 --- a/PWGLF/DataModel/LFSigmaTables.h +++ b/PWGLF/DataModel/LFSigmaTables.h @@ -22,12 +22,12 @@ using namespace o2; using namespace o2::framework; -// Creating output TTree for ML analysis +// Creating output TTree for sigma analysis namespace o2::aod { // for real data -namespace V0MLSigmaCandidate +namespace v0SigmaCandidate { DECLARE_SOA_COLUMN(SigmapT, sigmapT, float); DECLARE_SOA_COLUMN(SigmaMass, sigmaMass, float); @@ -56,97 +56,45 @@ DECLARE_SOA_COLUMN(LambdaDCAPosPV, lambdaDCAPosPV, float); DECLARE_SOA_COLUMN(GammaProbability, gammaProbability, float); DECLARE_SOA_COLUMN(LambdaProbability, lambdaProbability, float); -} // namespace V0MLSigmaCandidate +} // namespace v0SigmaCandidate -DECLARE_SOA_TABLE(V0MLSigmaCandidates, "AOD", "V0MLSIGMAS", - V0MLSigmaCandidate::SigmapT, - V0MLSigmaCandidate::SigmaMass, - // V0MLSigmaCandidate::SigmaDCAz, - // V0MLSigmaCandidate::SigmaDCAxy, - // V0MLSigmaCandidate::SigmaDCADau, - V0MLSigmaCandidate::PhotonPt, - V0MLSigmaCandidate::PhotonMass, - V0MLSigmaCandidate::PhotonQt, - V0MLSigmaCandidate::PhotonAlpha, - V0MLSigmaCandidate::PhotonRadius, - V0MLSigmaCandidate::PhotonCosPA, - V0MLSigmaCandidate::PhotonDCADau, - V0MLSigmaCandidate::PhotonDCANegPV, - V0MLSigmaCandidate::PhotonDCAPosPV, - V0MLSigmaCandidate::PhotonZconv, - V0MLSigmaCandidate::LambdaPt, - V0MLSigmaCandidate::LambdaMass, - V0MLSigmaCandidate::LambdaQt, - V0MLSigmaCandidate::LambdaAlpha, - V0MLSigmaCandidate::LambdaRadius, - V0MLSigmaCandidate::LambdaCosPA, - V0MLSigmaCandidate::LambdaDCADau, - V0MLSigmaCandidate::LambdaDCANegPV, - V0MLSigmaCandidate::LambdaDCAPosPV, - V0MLSigmaCandidate::GammaProbability, - V0MLSigmaCandidate::LambdaProbability); +DECLARE_SOA_TABLE(V0SigmaCandidates, "AOD", "V0SIGMAS", + v0SigmaCandidate::SigmapT, + v0SigmaCandidate::SigmaMass, + // v0SigmaCandidate::SigmaDCAz, + // v0SigmaCandidate::SigmaDCAxy, + // v0SigmaCandidate::SigmaDCADau, + v0SigmaCandidate::PhotonPt, + v0SigmaCandidate::PhotonMass, + v0SigmaCandidate::PhotonQt, + v0SigmaCandidate::PhotonAlpha, + v0SigmaCandidate::PhotonRadius, + v0SigmaCandidate::PhotonCosPA, + v0SigmaCandidate::PhotonDCADau, + v0SigmaCandidate::PhotonDCANegPV, + v0SigmaCandidate::PhotonDCAPosPV, + v0SigmaCandidate::PhotonZconv, + v0SigmaCandidate::LambdaPt, + v0SigmaCandidate::LambdaMass, + v0SigmaCandidate::LambdaQt, + v0SigmaCandidate::LambdaAlpha, + v0SigmaCandidate::LambdaRadius, + v0SigmaCandidate::LambdaCosPA, + v0SigmaCandidate::LambdaDCADau, + v0SigmaCandidate::LambdaDCANegPV, + v0SigmaCandidate::LambdaDCAPosPV, + v0SigmaCandidate::GammaProbability, + v0SigmaCandidate::LambdaProbability); // for MC data -namespace V0MLSigmaMCCandidate +namespace v0SigmaMCCandidate { -DECLARE_SOA_COLUMN(SigmapT, sigmapT, float); -DECLARE_SOA_COLUMN(SigmaMass, sigmaMass, float); -// DECLARE_SOA_COLUMN(SigmaDCAz, sigmaDCAz, float); -// DECLARE_SOA_COLUMN(SigmaDCAxy, sigmaDCAxy, float); -// DECLARE_SOA_COLUMN(SigmaDCADau, sigmaDCADau, float); -DECLARE_SOA_COLUMN(PhotonPt, photonPt, float); -DECLARE_SOA_COLUMN(PhotonMass, photonMass, float); -DECLARE_SOA_COLUMN(PhotonQt, photonQt, float); -DECLARE_SOA_COLUMN(PhotonAlpha, photonAlpha, float); -DECLARE_SOA_COLUMN(PhotonRadius, photonRadius, float); -DECLARE_SOA_COLUMN(PhotonCosPA, photonCosPA, float); -DECLARE_SOA_COLUMN(PhotonDCADau, photonDCADau, float); -DECLARE_SOA_COLUMN(PhotonDCANegPV, photonDCANegPV, float); -DECLARE_SOA_COLUMN(PhotonDCAPosPV, photonDCAPosPV, float); -DECLARE_SOA_COLUMN(PhotonZconv, photonZconv, float); -DECLARE_SOA_COLUMN(LambdaPt, lambdaPt, float); -DECLARE_SOA_COLUMN(LambdaMass, lambdaMass, float); -DECLARE_SOA_COLUMN(LambdaQt, lambdaQt, float); -DECLARE_SOA_COLUMN(LambdaAlpha, lambdaAlpha, float); -DECLARE_SOA_COLUMN(LambdaRadius, lambdaRadius, float); -DECLARE_SOA_COLUMN(LambdaCosPA, lambdaCosPA, float); -DECLARE_SOA_COLUMN(LambdaDCADau, lambdaDCADau, float); -DECLARE_SOA_COLUMN(LambdaDCANegPV, lambdaDCANegPV, float); -DECLARE_SOA_COLUMN(LambdaDCAPosPV, lambdaDCAPosPV, float); -DECLARE_SOA_COLUMN(GammaProbability, gammaProbability, float); -DECLARE_SOA_COLUMN(LambdaProbability, lambdaProbability, float); DECLARE_SOA_COLUMN(IsSigma, isSigma, bool); -} // namespace V0MLSigmaMCCandidate +} // namespace v0SigmaMCCandidate -DECLARE_SOA_TABLE(V0MLSigmaMCCandidates, "AOD", "V0MLMCSIGMAS", - V0MLSigmaMCCandidate::SigmapT, - V0MLSigmaMCCandidate::SigmaMass, - // V0MLSigmaMCCandidate::SigmaDCAz, - // V0MLSigmaMCCandidate::SigmaDCAxy, - // V0MLSigmaMCCandidate::SigmaDCADau, - V0MLSigmaMCCandidate::PhotonPt, - V0MLSigmaMCCandidate::PhotonMass, - V0MLSigmaMCCandidate::PhotonQt, - V0MLSigmaMCCandidate::PhotonAlpha, - V0MLSigmaMCCandidate::PhotonRadius, - V0MLSigmaMCCandidate::PhotonCosPA, - V0MLSigmaMCCandidate::PhotonDCADau, - V0MLSigmaMCCandidate::PhotonDCANegPV, - V0MLSigmaMCCandidate::PhotonDCAPosPV, - V0MLSigmaMCCandidate::PhotonZconv, - V0MLSigmaMCCandidate::LambdaPt, - V0MLSigmaMCCandidate::LambdaMass, - V0MLSigmaMCCandidate::LambdaQt, - V0MLSigmaMCCandidate::LambdaAlpha, - V0MLSigmaMCCandidate::LambdaRadius, - V0MLSigmaMCCandidate::LambdaCosPA, - V0MLSigmaMCCandidate::LambdaDCADau, - V0MLSigmaMCCandidate::LambdaDCANegPV, - V0MLSigmaMCCandidate::LambdaDCAPosPV, - V0MLSigmaMCCandidate::GammaProbability, - V0MLSigmaMCCandidate::LambdaProbability, - V0MLSigmaMCCandidate::IsSigma); +DECLARE_SOA_TABLE(V0SigmaMCCandidates, "AOD", "V0MCSIGMAS", + v0SigmaMCCandidate::IsSigma); } // namespace o2::aod #endif // PWGLF_DATAMODEL_LFSIGMATABLES_H_ \ No newline at end of file diff --git a/PWGLF/TableProducer/Strangeness/sigma0builder.cxx b/PWGLF/TableProducer/Strangeness/sigma0builder.cxx index f80ca401a1e..76174cf45dc 100644 --- a/PWGLF/TableProducer/Strangeness/sigma0builder.cxx +++ b/PWGLF/TableProducer/Strangeness/sigma0builder.cxx @@ -50,8 +50,8 @@ using std::cout; using std::endl; struct sigma0builder{ - Produces v0MLSigmas; // save sigma0 candidates for analysis - Produces v0MLMCSigmas; // save sigma0 candidates for analysis + Produces v0Sigmas; // save sigma0 candidates for analysis + Produces v0MCSigmas; // save sigma0 candidates for analysis HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; @@ -68,21 +68,6 @@ struct sigma0builder{ // Event counter histos.add("hEventVertexZ", "hEventVertexZ", kTH1F, {vertexZ}); histos.add("hEventVertexZMC", "hEventVertexZMC", kTH1F, {vertexZ}); - - // Number of reconstructed sigma per collision as QA - histos.add("hNSigmaCandidates", "hNSigmaCandidates", kTH1F, {{100,-0.5f, 99.5f}}); - histos.add("hNSigmaCandidatesMC", "hNSigmaCandidatesMC", kTH1F, {{100,-0.5f, 99.5f}}); - histos.add("hNGammaCandidatesMC", "hNGammaCandidatesMC", kTH1F, {{100,-0.5f, 99.5f}}); - histos.add("hNLambdaCandidatesMC", "hNLambdaCandidatesMC", kTH1F, {{100,-0.5f, 99.5f}}); - - // Invariant Mass - histos.add("InvMassSigmaMC", "InvMassSigmaMC", kTH1F, {axisSigmaMass}); - - if(doprocessCounterQA){ - histos.add("hGammaIndices", "hGammaIndices", {HistType::kTH1F, {{4000,0.0f, 400000.0f}}}); - histos.add("hCollIndices", "hCollIndices", {HistType::kTH1F, {{4000,0.0f, 4000.0f}}}); - histos.add("h2dIndices", "h2dIndices", {HistType::kTH2F, {{4000,0.0f, 40000.0f},{4000,0.0f, 400000.0f}}}); - } } // Helper struct to pass v0 information @@ -111,90 +96,35 @@ struct sigma0builder{ return true; } - // This process function cross-checks index correctness - void processCounterQA(soa::Join const& v0s) - { - for (auto& gamma: v0s) { - histos.fill(HIST("hGammaIndices"), gamma.globalIndex()); - histos.fill(HIST("hCollIndices"), gamma.straCollisionId()); - histos.fill(HIST("h2dIndices"), gamma.straCollisionId(), gamma.globalIndex()); - } - } - void processMonteCarlo(aod::StraCollision const& coll, soa::Join const& v0s) { - int SigmaCounter = 0; - int GammaCounter = 0; - int LambdaCounter = 0; - histos.fill(HIST("hEventVertexZMC"), coll.posZ()); for (auto& gamma: v0s) { // selecting photons from Sigma0 if ((gamma.pdgCode()!=22) || (gamma.pdgCodeMother()!=3212)) continue; - GammaCounter++; for (auto& lambda: v0s){ // selecting lambdas from Sigma0 if ((lambda.pdgCode()!=3122) || (lambda.pdgCodeMother()!=3212)) continue; - LambdaCounter++; - + //if (gamma.motherMCPartId()!=lambda.motherMCPartId()) continue; if(!processSigmaCandidate(coll, lambda,gamma)) continue; - SigmaCounter ++; - bool fIsSigma = (gamma.motherMCPartId()==lambda.motherMCPartId()); - // Sigma related - float fSigmapT = sigmaCandidate.pT; - float fSigmaMass = sigmaCandidate.mass; - - // Daughters related - /// Photon - float fPhotonPt = gamma.pt(); - float fPhotonMass = gamma.mGamma(); - float fPhotonQt = gamma.qtarm(); - float fPhotonAlpha = gamma.alpha(); - float fPhotonRadius = gamma.v0radius(); - float fPhotonCosPA = gamma.v0cosPA(); - float fPhotonDCADau = gamma.dcaV0daughters(); - float fPhotonDCANegPV = gamma.dcanegtopv(); - float fPhotonDCAPosPV = gamma.dcapostopv(); - float fPhotonZconv = gamma.z(); - - // Lambda - float fLambdaPt = lambda.pt(); - float fLambdaMass = lambda.mLambda(); - float fLambdaQt = lambda.qtarm(); - float fLambdaAlpha = lambda.alpha(); - float fLambdaRadius = lambda.v0radius(); - float fLambdaCosPA = lambda.v0cosPA(); - float fLambdaDCADau = lambda.dcaV0daughters(); - float fLambdaDCANegPV = lambda.dcanegtopv(); - float fLambdaDCAPosPV = lambda.dcapostopv(); - // Filling TTree for ML analysis - v0MLMCSigmas(fSigmapT, fSigmaMass, fPhotonPt, fPhotonMass, fPhotonQt, fPhotonAlpha, fPhotonRadius, fPhotonCosPA, fPhotonDCADau, fPhotonDCANegPV, fPhotonDCAPosPV, fPhotonZconv, fLambdaPt, fLambdaMass, fLambdaQt, fLambdaAlpha, fLambdaRadius, fLambdaCosPA, fLambdaDCADau, fLambdaDCANegPV, fLambdaDCAPosPV, fIsSigma, gamma.gammaBDTScore(), lambda.lambdaBDTScore()); - histos.fill(HIST("InvMassSigmaMC"), fSigmaMass); + v0MCSigmas(fIsSigma); } } - histos.fill(HIST("hNSigmaCandidatesMC"), SigmaCounter); - histos.fill(HIST("hNGammaCandidatesMC"), GammaCounter); - histos.fill(HIST("hNLambdaCandidatesMC"), LambdaCounter); } void processRealData(aod::StraCollision const& coll, soa::Join const& v0s) { - int SigmaCounter = 0; - histos.fill(HIST("hEventVertexZ"), coll.posZ()); for (auto& gamma: v0s) { // selecting photons from Sigma0 for (auto& lambda: v0s){ // selecting lambdas from Sigma0 if(!processSigmaCandidate(coll, lambda,gamma)) continue; - SigmaCounter ++; - - //bool fIsSigma = false; - + // Sigma related float fSigmapT = sigmaCandidate.pT; float fSigmaMass = sigmaCandidate.mass; @@ -224,16 +154,17 @@ struct sigma0builder{ float fLambdaDCAPosPV = lambda.dcapostopv(); // Filling TTree for ML analysis - v0MLSigmas(fSigmapT, fSigmaMass, fPhotonPt, fPhotonMass, fPhotonQt, fPhotonAlpha, fPhotonRadius, fPhotonCosPA, fPhotonDCADau, fPhotonDCANegPV, fPhotonDCAPosPV, fPhotonZconv, fLambdaPt, fLambdaMass, fLambdaQt, fLambdaAlpha, fLambdaRadius, fLambdaCosPA, fLambdaDCADau, fLambdaDCANegPV, fLambdaDCAPosPV, gamma.gammaBDTScore(), lambda.lambdaBDTScore()); + v0Sigmas(fSigmapT, fSigmaMass, fPhotonPt, fPhotonMass, fPhotonQt, fPhotonAlpha, + fPhotonRadius, fPhotonCosPA, fPhotonDCADau, fPhotonDCANegPV, fPhotonDCAPosPV, + fPhotonZconv, fLambdaPt, fLambdaMass, fLambdaQt, fLambdaAlpha, fLambdaRadius, + fLambdaCosPA, fLambdaDCADau, fLambdaDCANegPV, fLambdaDCAPosPV, + gamma.gammaBDTScore(), lambda.lambdaBDTScore()); } } - histos.fill(HIST("hNSigmaCandidates"), SigmaCounter); } - - PROCESS_SWITCH(sigma0builder, processCounterQA, "Check standard counter correctness", true); - PROCESS_SWITCH(sigma0builder, processMonteCarlo, "Do Monte-Carlo-based analysis", true); - PROCESS_SWITCH(sigma0builder, processRealData, "Do real data analysis", false); + PROCESS_SWITCH(sigma0builder, processMonteCarlo, "Do Monte-Carlo-based analysis", false); + PROCESS_SWITCH(sigma0builder, processRealData, "Do real data analysis", true); }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) From d4290c2c0270f81863ff0af22f9193d0f219b6a4 Mon Sep 17 00:00:00 2001 From: ddobrigk Date: Thu, 11 Apr 2024 15:25:28 +0200 Subject: [PATCH 04/26] Lambdakzerobuilder tuning --- .../Strangeness/lambdakzerobuilder.cxx | 175 ++++++++++-------- 1 file changed, 93 insertions(+), 82 deletions(-) diff --git a/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx b/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx index 77bc8f4220f..2f9d59c7f42 100644 --- a/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx +++ b/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx @@ -54,6 +54,7 @@ #include "Common/Core/RecoDecay.h" #include "Common/Core/trackUtilities.h" #include "PWGLF/DataModel/LFStrangenessTables.h" +#include "PWGLF/DataModel/LFStrangenessMLTables.h" #include "PWGLF/DataModel/LFParticleIdentification.h" #include "Common/Core/TrackSelection.h" #include "Common/DataModel/TrackSelectionTables.h" @@ -107,6 +108,12 @@ struct lambdakzeroBuilder { Produces v0fctrackXs; Produces v0fccovs; + // produces calls for machine-learning selections + Produces gammaMLSelections; // gamma scores + Produces lambdaMLSelections; // lambda scores + Produces antiLambdaMLSelections; // AntiLambda scores + Produces k0ShortMLSelections; // K0Short scores + Service ccdb; // Configurables related to table creation @@ -121,19 +128,19 @@ struct lambdakzeroBuilder { Configurable d_UseAutodetectMode{"d_UseAutodetectMode", false, "Autodetect requested topo sels"}; // downscaling for testing - Configurable downscaleFactor{"downscaleFactor", 2, "Downscale factor (0: build nothing, 1: build all)"}; unsigned int randomSeed = 0; TRandom3 prng; // downscaling for Marian Ivanov -> different strategies struct : ConfigurableGroup { - Configurable downscale_adaptive{"downscale_adaptive", false, "Downscale: use pT-dependent techniques"}; - Configurable downscale_mass{"downscale_mass", .139, "Downscale: Tsallis Mass"}; - Configurable downscale_sqrts{"downscale_sqrts", 13.6, "Downscale: Tsallis sqrts"}; - Configurable downscale_factorPt{"downscale_factorPt", 1.0, "Downscale: factor Pt"}; - Configurable downscale_factor1Pt{"downscale_factor1Pt", 1.0, "Downscale: factor 1/Pt"}; - Configurable downscale_factorUniform{"downscale_factorUniform", 1e-3, "Downscale: factor Pt"}; - Configurable downscale_triggerMaskSelection{"downscale_triggerMaskSelection", 0, "Downscale: trigger mask selection"}; + Configurable downscaleFactor{"downscalingOptions.downscaleFactor", 2, "Downscale factor (0: build nothing, 1: build all)"}; + Configurable downscale_adaptive{"downscalingOptions.downscale_adaptive", false, "Downscale: use pT-dependent techniques"}; + Configurable downscale_mass{"downscalingOptions.downscale_mass", .139, "Downscale: Tsallis Mass"}; + Configurable downscale_sqrts{"downscalingOptions.downscale_sqrts", 13.6, "Downscale: Tsallis sqrts"}; + Configurable downscale_factorPt{"downscalingOptions.downscale_factorPt", 1.0, "Downscale: factor Pt"}; + Configurable downscale_factor1Pt{"downscalingOptions.downscale_factor1Pt", 1.0, "Downscale: factor 1/Pt"}; + Configurable downscale_factorUniform{"downscalingOptions.downscale_factorUniform", 1e-3, "Downscale: factor Pt"}; + Configurable downscale_triggerMaskSelection{"downscalingOptions.downscale_triggerMaskSelection", 0, "Downscale: trigger mask selection"}; } downscalingOptions; Configurable dcanegtopv{"dcanegtopv", .1, "DCA Neg To PV"}; @@ -150,26 +157,25 @@ struct lambdakzeroBuilder { Configurable maxDaughterEta{"maxDaughterEta", 5.0, "Maximum daughter eta"}; // Operation and minimisation criteria - Configurable d_bz_input{"d_bz", -999, "bz field, -999 is automatic"}; - Configurable d_UseAbsDCA{"d_UseAbsDCA", true, "Use Abs DCAs"}; - Configurable d_UseWeightedPCA{"d_UseWeightedPCA", false, "Vertices use cov matrices"}; - Configurable d_UseCollinearFit{"d_UseCollinearFit", false, "Fit V0s via the collinear Method in DCAFitter"}; - Configurable d_maxDZIni{"d_maxDZIni", 1e9, "Dont consider a seed (circles intersection) if Z distance exceeds this"}; - Configurable d_maxDXYIni{"d_maxDXYIni", 4, "Dont consider a seed (circles intersection) if XY distance exceeds this"}; - Configurable useMatCorrType{"useMatCorrType", 2, "0: none, 1: TGeo, 2: LUT"}; - Configurable rejDiffCollTracks{"rejDiffCollTracks", 0, "rejDiffCollTracks"}; - Configurable d_doTrackQA{"d_doTrackQA", false, "do track QA"}; - Configurable d_QA_checkMC{"d_QA_checkMC", true, "check MC truth in QA"}; - Configurable d_QA_checkdEdx{"d_QA_checkdEdx", false, "check dEdx in QA"}; + struct : ConfigurableGroup { + Configurable d_bz_input{"dcaFitterConfigurations.d_bz", -999, "bz field, -999 is automatic"}; + Configurable d_UseAbsDCA{"dcaFitterConfigurations.d_UseAbsDCA", true, "Use Abs DCAs"}; + Configurable d_UseWeightedPCA{"dcaFitterConfigurations.d_UseWeightedPCA", false, "Vertices use cov matrices"}; + Configurable d_UseCollinearFit{"dcaFitterConfigurations.d_UseCollinearFit", false, "Fit V0s via the collinear Method in DCAFitter"}; + Configurable d_maxDZIni{"dcaFitterConfigurations.d_maxDZIni", 1e9, "Dont consider a seed (circles intersection) if Z distance exceeds this"}; + Configurable d_maxDXYIni{"dcaFitterConfigurations.d_maxDXYIni", 4, "Dont consider a seed (circles intersection) if XY distance exceeds this"}; + Configurable useMatCorrType{"dcaFitterConfigurations.useMatCorrType", 2, "0: none, 1: TGeo, 2: LUT"}; + Configurable rejDiffCollTracks{"dcaFitterConfigurations.rejDiffCollTracks", 0, "rejDiffCollTracks"}; + } dcaFitterConfigurations; // CCDB options struct : ConfigurableGroup { - Configurable ccdburl{"ccdb-url", "http://alice-ccdb.cern.ch", "url of the ccdb repository"}; - Configurable grpPath{"grpPath", "GLO/GRP/GRP", "Path of the grp file"}; - Configurable grpmagPath{"grpmagPath", "GLO/Config/GRPMagField", "CCDB path of the GRPMagField object"}; - Configurable lutPath{"lutPath", "GLO/Param/MatLUT", "Path of the Lut parametrization"}; - Configurable geoPath{"geoPath", "GLO/Config/GeometryAligned", "Path of the geometry file"}; - Configurable mVtxPath{"mVtxPath", "GLO/Calib/MeanVertex", "Path of the mean vertex file"}; + Configurable ccdburl{"ccdbConfigurations.ccdb-url", "http://alice-ccdb.cern.ch", "url of the ccdb repository"}; + Configurable grpPath{"ccdbConfigurations.grpPath", "GLO/GRP/GRP", "Path of the grp file"}; + Configurable grpmagPath{"ccdbConfigurations.grpmagPath", "GLO/Config/GRPMagField", "CCDB path of the GRPMagField object"}; + Configurable lutPath{"ccdbConfigurations.lutPath", "GLO/Param/MatLUT", "Path of the Lut parametrization"}; + Configurable geoPath{"ccdbConfigurations.geoPath", "GLO/Config/GeometryAligned", "Path of the geometry file"}; + Configurable mVtxPath{"ccdbConfigurations.mVtxPath", "GLO/Calib/MeanVertex", "Path of the mean vertex file"}; } ccdbConfigurations; // round some V0 core variables up to a certain level of precision if requested @@ -179,16 +185,19 @@ struct lambdakzeroBuilder { Configurable precisionDCAs{"precisionDCAs", 0.01f, "precision to keep the DCAs with"}; // generate and fill extra QA histograms if requested - Configurable d_doQA{"d_doQA", false, "Do basic QA"}; - Configurable dQANBinsRadius{"dQANBinsRadius", 500, "Number of radius bins in QA histo"}; - Configurable dQANBinsPtCoarse{"dQANBinsPtCoarse", 10, "Number of pT bins in QA histo"}; - Configurable dQANBinsMass{"dQANBinsMass", 400, "Number of mass bins for QA histograms"}; - Configurable dQAMaxPt{"dQAMaxPt", 5, "max pT in QA histo"}; - Configurable dQAGammaMassWindow{"dQAGammaMassWindow", 0.05, "gamma mass window for ITS cluster map QA"}; - Configurable dQAK0ShortMassWindow{"dQAK0ShortMassWindow", 0.005, "K0 mass window for ITS cluster map QA"}; - Configurable dQALambdaMassWindow{"dQALambdaMassWindow", 0.005, "Lambda/AntiLambda mass window for ITS cluster map QA"}; - - ConfigurableAxis axisPtQA{"axisPtQA", {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 QA histograms"}; + struct : ConfigurableGroup { + Configurable d_doQA{"qaConfigurations.d_doQA", false, "Do basic QA"}; + Configurable dQANBinsRadius{"qaConfigurations.dQANBinsRadius", 500, "Number of radius bins in QA histo"}; + Configurable dQANBinsPtCoarse{"qaConfigurations.dQANBinsPtCoarse", 10, "Number of pT bins in QA histo"}; + Configurable dQANBinsMass{"qaConfigurations.dQANBinsMass", 400, "Number of mass bins for QA histograms"}; + Configurable dQAMaxPt{"qaConfigurations.dQAMaxPt", 5, "max pT in QA histo"}; + Configurable dQAGammaMassWindow{"qaConfigurations.dQAGammaMassWindow", 0.05, "gamma mass window for ITS cluster map QA"}; + Configurable dQAK0ShortMassWindow{"qaConfigurations.dQAK0ShortMassWindow", 0.005, "K0 mass window for ITS cluster map QA"}; + Configurable dQALambdaMassWindow{"qaConfigurations.dQALambdaMassWindow", 0.005, "Lambda/AntiLambda mass window for ITS cluster map QA"}; + Configurable d_doTrackQA{"qaConfigurations.d_doTrackQA", false, "do track QA"}; + Configurable d_QA_checkMC{"qaConfigurations.d_QA_checkMC", true, "check MC truth in QA"}; + Configurable d_QA_checkdEdx{"qaConfigurations.d_QA_checkdEdx", false, "check dEdx in QA"}; + } qaConfigurations; // for topo var QA struct : ConfigurableGroup { @@ -205,6 +214,8 @@ struct lambdakzeroBuilder { ConfigurableAxis axisDCAXY{"axisConfigurations.axisDCAXY", {500, -50, 50}, "(cm)"}; ConfigurableAxis axisDCACHI2{"axisConfigurations.axisDCACHI2", {500, 0, 50}, "#chi^{2}"}; ConfigurableAxis axisPositionGuess{"axisConfigurations.axisPositionGuess", {240, 0, 120}, "(cm)"}; + + ConfigurableAxis axisPtQA{"axisConfigurations.axisPtQA", {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 QA histograms"}; } axisConfigurations; // default parameters from central Pb-Pb (worst case scenario), PbPb 2023 pass1 @@ -373,7 +384,7 @@ struct lambdakzeroBuilder { registry.fill(HIST("hCaughtExceptions"), 0.0, statisticsRegistry.exceptions); for (Int_t ii = 0; ii < kNV0Steps; ii++) registry.fill(HIST("hV0Criteria"), ii, statisticsRegistry.v0stats[ii]); - if (d_doTrackQA) { + if (qaConfigurations.d_doTrackQA) { for (Int_t ii = 0; ii < 10; ii++) { registry.fill(HIST("hPositiveITSClusters"), ii, statisticsRegistry.posITSclu[ii]); registry.fill(HIST("hNegativeITSClusters"), ii, statisticsRegistry.negITSclu[ii]); @@ -404,13 +415,13 @@ struct lambdakzeroBuilder { randomSeed = static_cast(std::chrono::duration_cast(std::chrono::system_clock::now().time_since_epoch()).count()); // Optionally, add extra QA histograms to processing chain - if (d_doQA) { + if (qaConfigurations.d_doQA) { // Basic histograms containing invariant masses of all built candidates - const AxisSpec axisVsPtCoarse{static_cast(dQANBinsPtCoarse), 0, dQAMaxPt, "#it{p}_{T} (GeV/c)"}; - const AxisSpec axisGammaMass{static_cast(dQANBinsMass), 0.000f, 0.400f, "Inv. Mass (GeV/c^{2})"}; - const AxisSpec axisK0ShortMass{static_cast(dQANBinsMass), 0.400f, 0.600f, "Inv. Mass (GeV/c^{2})"}; - const AxisSpec axisLambdaMass{static_cast(5 * dQANBinsMass), 1.01f, 2.01f, "Inv. Mass (GeV/c^{2})"}; - const AxisSpec axisHypertritonMass{static_cast(dQANBinsMass), 2.900f, 3.300f, "Inv. Mass (GeV/c^{2})"}; + const AxisSpec axisVsPtCoarse{static_cast(qaConfigurations.dQANBinsPtCoarse), 0, qaConfigurations.dQAMaxPt, "#it{p}_{T} (GeV/c)"}; + const AxisSpec axisGammaMass{static_cast(qaConfigurations.dQANBinsMass), 0.000f, 0.400f, "Inv. Mass (GeV/c^{2})"}; + const AxisSpec axisK0ShortMass{static_cast(qaConfigurations.dQANBinsMass), 0.400f, 0.600f, "Inv. Mass (GeV/c^{2})"}; + const AxisSpec axisLambdaMass{static_cast(5 * qaConfigurations.dQANBinsMass), 1.01f, 2.01f, "Inv. Mass (GeV/c^{2})"}; + const AxisSpec axisHypertritonMass{static_cast(qaConfigurations.dQANBinsMass), 2.900f, 3.300f, "Inv. Mass (GeV/c^{2})"}; registry.add("h2dGammaMass", "h2dGammaMass", kTH2F, {axisVsPtCoarse, axisGammaMass}); registry.add("h2dK0ShortMass", "h2dK0ShortMass", kTH2F, {axisVsPtCoarse, axisK0ShortMass}); @@ -435,27 +446,27 @@ struct lambdakzeroBuilder { registry.add("h2dXIU_AntiLambda", "h2dXIU_AntiLambda", kTH3D, {axisConfigurations.axisX, axisConfigurations.axisX, axisConfigurations.axisRadius}); // QA plots of topological variables using axisPtQA - registry.add("h2dTopoVarPointingAngle", "h2dTopoVarPointingAngle", kTH2D, {axisPtQA, axisConfigurations.axisTopoVarPointingAngle}); - registry.add("h2dTopoVarRAP", "h2dTopoVarRAP", kTH2D, {axisPtQA, axisConfigurations.axisTopoVarRAP}); - registry.add("h2dTopoVarV0Radius", "h2dTopoVarV0Radius", kTH2D, {axisPtQA, axisConfigurations.axisTopoVarV0Radius}); - registry.add("h2dTopoVarDCAV0Dau", "h2dTopoVarDCAV0Dau", kTH2D, {axisPtQA, axisConfigurations.axisTopoVarDCAV0Dau}); - registry.add("h2dTopoVarPosDCAToPV", "h2dTopoVarPosDCAToPV", kTH2D, {axisPtQA, axisConfigurations.axisTopoVarDCAToPV}); - registry.add("h2dTopoVarNegDCAToPV", "h2dTopoVarNegDCAToPV", kTH2D, {axisPtQA, axisConfigurations.axisTopoVarDCAToPV}); - registry.add("h2dTopoVarDCAV0ToPV", "h2dTopoVarDCAV0ToPV", kTH2D, {axisPtQA, axisConfigurations.axisTopoVarDCAV0ToPV}); + registry.add("h2dTopoVarPointingAngle", "h2dTopoVarPointingAngle", kTH2D, {axisConfigurations.axisPtQA, axisConfigurations.axisTopoVarPointingAngle}); + registry.add("h2dTopoVarRAP", "h2dTopoVarRAP", kTH2D, {axisConfigurations.axisPtQA, axisConfigurations.axisTopoVarRAP}); + registry.add("h2dTopoVarV0Radius", "h2dTopoVarV0Radius", kTH2D, {axisConfigurations.axisPtQA, axisConfigurations.axisTopoVarV0Radius}); + registry.add("h2dTopoVarDCAV0Dau", "h2dTopoVarDCAV0Dau", kTH2D, {axisConfigurations.axisPtQA, axisConfigurations.axisTopoVarDCAV0Dau}); + registry.add("h2dTopoVarPosDCAToPV", "h2dTopoVarPosDCAToPV", kTH2D, {axisConfigurations.axisPtQA, axisConfigurations.axisTopoVarDCAToPV}); + registry.add("h2dTopoVarNegDCAToPV", "h2dTopoVarNegDCAToPV", kTH2D, {axisConfigurations.axisPtQA, axisConfigurations.axisTopoVarDCAToPV}); + registry.add("h2dTopoVarDCAV0ToPV", "h2dTopoVarDCAV0ToPV", kTH2D, {axisConfigurations.axisPtQA, axisConfigurations.axisTopoVarDCAV0ToPV}); // QA for PCM - registry.add("h2d_pcm_DCAXY_True", "h2d_pcm_DCAXY_True", kTH2D, {axisPtQA, axisConfigurations.axisDCAXY}); - registry.add("h2d_pcm_DCAXY_Bg", "h2d_pcm_DCAXY_Bg", kTH2D, {axisPtQA, axisConfigurations.axisDCAXY}); - registry.add("h2d_pcm_DCACHI2_True", "h2d_pcm_DCACHI2_True", kTH2D, {axisPtQA, axisConfigurations.axisDCACHI2}); - registry.add("h2d_pcm_DCACHI2_Bg", "h2d_pcm_DCACHI2_Bg", kTH2D, {axisPtQA, axisConfigurations.axisDCACHI2}); - registry.add("h2d_pcm_DeltaDistanceRadii_True", "h2d_pcm_DeltaDistanceRadii_True", kTH2D, {axisPtQA, axisConfigurations.axisDeltaDistanceRadii}); - registry.add("h2d_pcm_DeltaDistanceRadii_Bg", "h2d_pcm_DeltaDistanceRadii_Bg", kTH2D, {axisPtQA, axisConfigurations.axisDeltaDistanceRadii}); - registry.add("h2d_pcm_PositionGuess_True", "h2d_pcm_PositionGuess_True", kTH2D, {axisPtQA, axisConfigurations.axisPositionGuess}); - registry.add("h2d_pcm_PositionGuess_Bg", "h2d_pcm_PositionGuess_Bg", kTH2D, {axisPtQA, axisConfigurations.axisPositionGuess}); - registry.add("h2d_pcm_RadiallyOutgoingAtThisRadius1_True", "h2d_pcm_RadiallyOutgoingAtThisRadius1_True", kTH2D, {axisPtQA, axisConfigurations.axisPositionGuess}); - registry.add("h2d_pcm_RadiallyOutgoingAtThisRadius2_True", "h2d_pcm_RadiallyOutgoingAtThisRadius2_True", kTH2D, {axisPtQA, axisConfigurations.axisPositionGuess}); - registry.add("h2d_pcm_RadiallyOutgoingAtThisRadius1_Bg", "h2d_pcm_RadiallyOutgoingAtThisRadius1_Bg", kTH2D, {axisPtQA, axisConfigurations.axisPositionGuess}); - registry.add("h2d_pcm_RadiallyOutgoingAtThisRadius2_Bg", "h2d_pcm_RadiallyOutgoingAtThisRadius2_Bg", kTH2D, {axisPtQA, axisConfigurations.axisPositionGuess}); + registry.add("h2d_pcm_DCAXY_True", "h2d_pcm_DCAXY_True", kTH2D, {axisConfigurations.axisPtQA, axisConfigurations.axisDCAXY}); + registry.add("h2d_pcm_DCAXY_Bg", "h2d_pcm_DCAXY_Bg", kTH2D, {axisConfigurations.axisPtQA, axisConfigurations.axisDCAXY}); + registry.add("h2d_pcm_DCACHI2_True", "h2d_pcm_DCACHI2_True", kTH2D, {axisConfigurations.axisPtQA, axisConfigurations.axisDCACHI2}); + registry.add("h2d_pcm_DCACHI2_Bg", "h2d_pcm_DCACHI2_Bg", kTH2D, {axisConfigurations.axisPtQA, axisConfigurations.axisDCACHI2}); + registry.add("h2d_pcm_DeltaDistanceRadii_True", "h2d_pcm_DeltaDistanceRadii_True", kTH2D, {axisConfigurations.axisPtQA, axisConfigurations.axisDeltaDistanceRadii}); + registry.add("h2d_pcm_DeltaDistanceRadii_Bg", "h2d_pcm_DeltaDistanceRadii_Bg", kTH2D, {axisConfigurations.axisPtQA, axisConfigurations.axisDeltaDistanceRadii}); + registry.add("h2d_pcm_PositionGuess_True", "h2d_pcm_PositionGuess_True", kTH2D, {axisConfigurations.axisPtQA, axisConfigurations.axisPositionGuess}); + registry.add("h2d_pcm_PositionGuess_Bg", "h2d_pcm_PositionGuess_Bg", kTH2D, {axisConfigurations.axisPtQA, axisConfigurations.axisPositionGuess}); + registry.add("h2d_pcm_RadiallyOutgoingAtThisRadius1_True", "h2d_pcm_RadiallyOutgoingAtThisRadius1_True", kTH2D, {axisConfigurations.axisPtQA, axisConfigurations.axisPositionGuess}); + registry.add("h2d_pcm_RadiallyOutgoingAtThisRadius2_True", "h2d_pcm_RadiallyOutgoingAtThisRadius2_True", kTH2D, {axisConfigurations.axisPtQA, axisConfigurations.axisPositionGuess}); + registry.add("h2d_pcm_RadiallyOutgoingAtThisRadius1_Bg", "h2d_pcm_RadiallyOutgoingAtThisRadius1_Bg", kTH2D, {axisConfigurations.axisPtQA, axisConfigurations.axisPositionGuess}); + registry.add("h2d_pcm_RadiallyOutgoingAtThisRadius2_Bg", "h2d_pcm_RadiallyOutgoingAtThisRadius2_Bg", kTH2D, {axisConfigurations.axisPtQA, axisConfigurations.axisPositionGuess}); } mRunNumber = 0; @@ -468,13 +479,13 @@ struct lambdakzeroBuilder { ccdb->setLocalObjectValidityChecking(); ccdb->setFatalWhenNull(false); - if (useMatCorrType == 1) { + if (dcaFitterConfigurations.useMatCorrType == 1) { LOGF(info, "TGeo correction requested, loading geometry"); if (!o2::base::GeometryManager::isGeometryLoaded()) { ccdb->get(ccdbConfigurations.geoPath); } } - if (useMatCorrType == 2) { + if (dcaFitterConfigurations.useMatCorrType == 2) { LOGF(info, "LUT correction requested, loading LUT"); lut = o2::base::MatLayerCylSet::rectifyPtrFromFile(ccdb->get(ccdbConfigurations.lutPath)); LOGF(info, "LUT load done!"); @@ -595,17 +606,17 @@ struct lambdakzeroBuilder { fitter.setMaxR(200.); fitter.setMinParamChange(1e-3); fitter.setMinRelChi2Change(0.9); - fitter.setMaxDZIni(d_maxDZIni); - fitter.setMaxDXYIni(d_maxDXYIni); + fitter.setMaxDZIni(dcaFitterConfigurations.d_maxDZIni); + fitter.setMaxDXYIni(dcaFitterConfigurations.d_maxDXYIni); fitter.setMaxChi2(1e9); - fitter.setUseAbsDCA(d_UseAbsDCA); - fitter.setWeightedFinalPCA(d_UseWeightedPCA); + fitter.setUseAbsDCA(dcaFitterConfigurations.d_UseAbsDCA); + fitter.setWeightedFinalPCA(dcaFitterConfigurations.d_UseWeightedPCA); // Material correction in the DCA fitter o2::base::Propagator::MatCorrType matCorr = o2::base::Propagator::MatCorrType::USEMatCorrNONE; - if (useMatCorrType == 1) + if (dcaFitterConfigurations.useMatCorrType == 1) matCorr = o2::base::Propagator::MatCorrType::USEMatCorrTGeo; - if (useMatCorrType == 2) + if (dcaFitterConfigurations.useMatCorrType == 2) matCorr = o2::base::Propagator::MatCorrType::USEMatCorrLUT; fitter.setMatCorrType(matCorr); } @@ -617,8 +628,8 @@ struct lambdakzeroBuilder { } // In case override, don't proceed, please - no CCDB access required - if (d_bz_input > -990) { - d_bz = d_bz_input; + if (dcaFitterConfigurations.d_bz_input > -990) { + d_bz = dcaFitterConfigurations.d_bz_input; fitter.setBz(d_bz); o2::parameters::GRPMagField grpmag; if (fabs(d_bz) > 1e-5) { @@ -654,7 +665,7 @@ struct lambdakzeroBuilder { // Set magnetic field value once known fitter.setBz(d_bz); - if (useMatCorrType == 2) { + if (dcaFitterConfigurations.useMatCorrType == 2) { // setMatLUT only after magfield has been initalized // (setMatLUT has implicit and problematic init field call if not) o2::base::Propagator::Instance()->setMatLUT(lut); @@ -723,7 +734,7 @@ struct lambdakzeroBuilder { //---/---/---/ // Move close to minima int nCand = 0; - fitter.setCollinear(d_UseCollinearFit || V0.isCollinearV0()); + fitter.setCollinear(dcaFitterConfigurations.d_UseCollinearFit || V0.isCollinearV0()); try { nCand = fitter.process(lPositiveTrack, lNegativeTrack); } catch (...) { @@ -856,16 +867,16 @@ struct lambdakzeroBuilder { if (!keepCandidate) return false; - if (d_doTrackQA) { + if (qaConfigurations.d_doTrackQA) { if (posTrack.itsNCls() < 10) statisticsRegistry.posITSclu[posTrack.itsNCls()]++; if (negTrack.itsNCls() < 10) statisticsRegistry.negITSclu[negTrack.itsNCls()]++; } - if (d_doQA) { - bool mcUnchecked = !d_QA_checkMC; - bool dEdxUnchecked = !d_QA_checkdEdx; + if (qaConfigurations.d_doQA) { + bool mcUnchecked = !qaConfigurations.d_QA_checkMC; + bool dEdxUnchecked = !qaConfigurations.d_QA_checkdEdx; auto lPtHy = RecoDecay::sqrtSumOfSquares(2.0f * v0candidate.posP[0] + v0candidate.negP[0], 2.0f * v0candidate.posP[1] + v0candidate.negP[1]); auto lPtAnHy = RecoDecay::sqrtSumOfSquares(v0candidate.posP[0] + 2.0f * v0candidate.negP[0], v0candidate.posP[1] + 2.0f * v0candidate.negP[1]); @@ -887,19 +898,19 @@ struct lambdakzeroBuilder { } // Fill ITS cluster maps with specific mass cuts - if (TMath::Abs(lGammaMass - 0.0) < dQAGammaMassWindow && ((V0.isdEdxGamma() || dEdxUnchecked) && (V0.isTrueGamma() || mcUnchecked))) { + if (TMath::Abs(lGammaMass - 0.0) < qaConfigurations.dQAGammaMassWindow && ((V0.isdEdxGamma() || dEdxUnchecked) && (V0.isTrueGamma() || mcUnchecked))) { registry.fill(HIST("h2dITSCluMap_Gamma"), static_cast(posTrack.itsClusterMap()), static_cast(negTrack.itsClusterMap()), v0candidate.V0radius); registry.fill(HIST("h2dXIU_Gamma"), static_cast(posTrack.x()), static_cast(negTrack.x()), v0candidate.V0radius); } - if (TMath::Abs(v0candidate.k0ShortMass - 0.497) < dQAK0ShortMassWindow && ((V0.isdEdxK0Short() || dEdxUnchecked) && (V0.isTrueK0Short() || mcUnchecked))) { + if (TMath::Abs(v0candidate.k0ShortMass - 0.497) < qaConfigurations.dQAK0ShortMassWindow && ((V0.isdEdxK0Short() || dEdxUnchecked) && (V0.isTrueK0Short() || mcUnchecked))) { registry.fill(HIST("h2dITSCluMap_K0Short"), static_cast(posTrack.itsClusterMap()), static_cast(negTrack.itsClusterMap()), v0candidate.V0radius); registry.fill(HIST("h2dXIU_K0Short"), static_cast(posTrack.x()), static_cast(negTrack.x()), v0candidate.V0radius); } - if (TMath::Abs(v0candidate.lambdaMass - 1.116) < dQALambdaMassWindow && ((V0.isdEdxLambda() || dEdxUnchecked) && (V0.isTrueLambda() || mcUnchecked))) { + if (TMath::Abs(v0candidate.lambdaMass - 1.116) < qaConfigurations.dQALambdaMassWindow && ((V0.isdEdxLambda() || dEdxUnchecked) && (V0.isTrueLambda() || mcUnchecked))) { registry.fill(HIST("h2dITSCluMap_Lambda"), static_cast(posTrack.itsClusterMap()), static_cast(negTrack.itsClusterMap()), v0candidate.V0radius); registry.fill(HIST("h2dXIU_Lambda"), static_cast(posTrack.x()), static_cast(negTrack.x()), v0candidate.V0radius); } - if (TMath::Abs(v0candidate.antiLambdaMass - 1.116) < dQALambdaMassWindow && ((V0.isdEdxAntiLambda() || dEdxUnchecked) && (V0.isTrueAntiLambda() || mcUnchecked))) { + if (TMath::Abs(v0candidate.antiLambdaMass - 1.116) < qaConfigurations.dQALambdaMassWindow && ((V0.isdEdxAntiLambda() || dEdxUnchecked) && (V0.isTrueAntiLambda() || mcUnchecked))) { registry.fill(HIST("h2dITSCluMap_AntiLambda"), static_cast(posTrack.itsClusterMap()), static_cast(negTrack.itsClusterMap()), v0candidate.V0radius); registry.fill(HIST("h2dXIU_AntiLambda"), static_cast(posTrack.x()), static_cast(negTrack.x()), v0candidate.V0radius); } @@ -968,7 +979,7 @@ struct lambdakzeroBuilder { // Loops over all V0s in the time frame for (auto& V0 : V0s) { // downscale some V0s if requested to do so - if (downscaleFactor < 1.f && (static_cast(rand_r(&randomSeed)) / static_cast(RAND_MAX)) > downscaleFactor) { + if (downscalingOptions.downscaleFactor < 1.f && (static_cast(rand_r(&randomSeed)) / static_cast(RAND_MAX)) > downscalingOptions.downscaleFactor) { return; } From a97e7733213fac4c89555a3e4ed2e3f5b2e7cb12 Mon Sep 17 00:00:00 2001 From: ddobrigk Date: Thu, 11 Apr 2024 17:03:45 +0200 Subject: [PATCH 05/26] Builder incorporates ML --- .../TableProducer/Strangeness/CMakeLists.txt | 2 +- .../Strangeness/lambdakzerobuilder.cxx | 149 ++++++++++++++++-- 2 files changed, 141 insertions(+), 10 deletions(-) diff --git a/PWGLF/TableProducer/Strangeness/CMakeLists.txt b/PWGLF/TableProducer/Strangeness/CMakeLists.txt index 5d1402bf6b9..e269a6ea4e7 100644 --- a/PWGLF/TableProducer/Strangeness/CMakeLists.txt +++ b/PWGLF/TableProducer/Strangeness/CMakeLists.txt @@ -56,7 +56,7 @@ o2physics_add_dpl_workflow(hstrangecorrelationfilter o2physics_add_dpl_workflow(lambdakzerobuilder SOURCES lambdakzerobuilder.cxx - PUBLIC_LINK_LIBRARIES O2::DCAFitter O2Physics::AnalysisCore + PUBLIC_LINK_LIBRARIES O2::DCAFitter O2Physics::AnalysisCore O2Physics::MLCore COMPONENT_NAME Analysis) o2physics_add_dpl_workflow(lambdakzerofinder diff --git a/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx b/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx index 2f9d59c7f42..7b6f97189e1 100644 --- a/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx +++ b/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx @@ -65,6 +65,8 @@ #include "CCDB/BasicCCDBManager.h" #include "DataFormatsCalibration/MeanVertexObject.h" #include "TableHelper.h" +#include "Tools/ML/MlResponse.h" +#include "Tools/ML/model.h" using namespace o2; using namespace o2::framework; @@ -93,6 +95,14 @@ using TaggedV0s = soa::Join; using LabeledTracksExtra = soa::Join; struct lambdakzeroBuilder { + o2::ml::OnnxModel mlModelK0Short; + o2::ml::OnnxModel mlModelLambda; + o2::ml::OnnxModel mlModelAntiLambda; + o2::ml::OnnxModel mlModelGamma; + + std::map metadata; + std::map headers; + Produces v0indices; Produces v0cores; Produces v0trackXs; @@ -114,6 +124,7 @@ struct lambdakzeroBuilder { Produces antiLambdaMLSelections; // AntiLambda scores Produces k0ShortMLSelections; // K0Short scores + o2::ccdb::CcdbApi ccdbApi; Service ccdb; // Configurables related to table creation @@ -156,16 +167,43 @@ struct lambdakzeroBuilder { Configurable maximumPt{"maximumPt", 1000.0f, "Maximum pT to store candidate"}; Configurable maxDaughterEta{"maxDaughterEta", 5.0, "Maximum daughter eta"}; + // Machine learning evaluation for pre-selection and corresponding information generation + struct : ConfigurableGroup { + // ML classifiers: master flags to populate ML Selection tables + Configurable calculateK0ShortScores{"mlConfigurations.calculateK0ShortScores", false, "calculate K0Short ML scores"}; + Configurable calculateLambdaScores{"mlConfigurations.calculateLambdaScores", false, "calculate Lambda ML scores"}; + Configurable calculateAntiLambdaScores{"mlConfigurations.calculateAntiLambdaScores", false, "calculate AntiLambda ML scores"}; + Configurable calculateGammaScores{"mlConfigurations.calculateGammaScores", false, "calculate Gamma ML scores"}; + + // ML input for ML calculation + Configurable modelPathCCDB{"mlConfigurations.modelPathCCDB", "", "ML Model path in CCDB"}; + Configurable timestampCCDB{"mlConfigurations.timestampCCDB", -1, "timestamp of the ONNX file for ML model used to query in CCDB. Exceptions: > 0 for the specific timestamp, 0 gets the run dependent timestamp"}; + Configurable loadModelsFromCCDB{"mlConfigurations.loadModelsFromCCDB", false, "Flag to enable or disable the loading of models from CCDB"}; + Configurable enableOptimizations{"mlConfigurations.enableOptimizations", false, "Enables the ONNX extended model-optimization: sessionOptions.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_ENABLE_EXTENDED)"}; + + // Local paths for test purposes + Configurable localModelPathLambda{"mlConfigurations.localModelPathLambda", "Lambda_BDTModel.onnx", "(std::string) Path to the local .onnx file."}; + Configurable localModelPathAntiLambda{"mlConfigurations.localModelPathAntiLambda", "AntiLambda_BDTModel.onnx", "(std::string) Path to the local .onnx file."}; + Configurable localModelPathGamma{"mlConfigurations.localModelPathGamma", "Gamma_BDTModel.onnx", "(std::string) Path to the local .onnx file."}; + Configurable localModelPathK0Short{"mlConfigurations.localModelPathK0Short", "KZeroShort_BDTModel.onnx", "(std::string) Path to the local .onnx file."}; + + // Thresholds for choosing to populate V0Cores tables with pre-selections + Configurable thresholdGamma{"mlConfigurations.thresholdGamma", -1.0f, "Threshold to keep gamma candidates"}; + Configurable thresholdLambda{"mlConfigurations.thresholdLambda", -1.0f, "Threshold to keep Lambda candidates"}; + Configurable thresholdAntiLambda{"mlConfigurations.thresholdAntiLambda", -1.0f, "Threshold to keep AntiLambda candidates"}; + Configurable thresholdK0Short{"mlConfigurations.thresholdK0Short", -1.0f, "Threshold to keep K0Short candidates"}; + } mlConfigurations; + // Operation and minimisation criteria struct : ConfigurableGroup { - Configurable d_bz_input{"dcaFitterConfigurations.d_bz", -999, "bz field, -999 is automatic"}; - Configurable d_UseAbsDCA{"dcaFitterConfigurations.d_UseAbsDCA", true, "Use Abs DCAs"}; - Configurable d_UseWeightedPCA{"dcaFitterConfigurations.d_UseWeightedPCA", false, "Vertices use cov matrices"}; - Configurable d_UseCollinearFit{"dcaFitterConfigurations.d_UseCollinearFit", false, "Fit V0s via the collinear Method in DCAFitter"}; - Configurable d_maxDZIni{"dcaFitterConfigurations.d_maxDZIni", 1e9, "Dont consider a seed (circles intersection) if Z distance exceeds this"}; - Configurable d_maxDXYIni{"dcaFitterConfigurations.d_maxDXYIni", 4, "Dont consider a seed (circles intersection) if XY distance exceeds this"}; - Configurable useMatCorrType{"dcaFitterConfigurations.useMatCorrType", 2, "0: none, 1: TGeo, 2: LUT"}; - Configurable rejDiffCollTracks{"dcaFitterConfigurations.rejDiffCollTracks", 0, "rejDiffCollTracks"}; + Configurable d_bz_input{"dcaFitterConfigurations.d_bz", -999, "bz field, -999 is automatic"}; + Configurable d_UseAbsDCA{"dcaFitterConfigurations.d_UseAbsDCA", true, "Use Abs DCAs"}; + Configurable d_UseWeightedPCA{"dcaFitterConfigurations.d_UseWeightedPCA", false, "Vertices use cov matrices"}; + Configurable d_UseCollinearFit{"dcaFitterConfigurations.d_UseCollinearFit", false, "Fit V0s via the collinear Method in DCAFitter"}; + Configurable d_maxDZIni{"dcaFitterConfigurations.d_maxDZIni", 1e9, "Dont consider a seed (circles intersection) if Z distance exceeds this"}; + Configurable d_maxDXYIni{"dcaFitterConfigurations.d_maxDXYIni", 4, "Dont consider a seed (circles intersection) if XY distance exceeds this"}; + Configurable useMatCorrType{"dcaFitterConfigurations.useMatCorrType", 2, "0: none, 1: TGeo, 2: LUT"}; + Configurable rejDiffCollTracks{"dcaFitterConfigurations.rejDiffCollTracks", 0, "rejDiffCollTracks"}; } dcaFitterConfigurations; // CCDB options @@ -627,6 +665,18 @@ struct lambdakzeroBuilder { return; } + // machine learning initialization if requested + if (mlConfigurations.calculateK0ShortScores || + mlConfigurations.calculateLambdaScores || + mlConfigurations.calculateAntiLambdaScores || + mlConfigurations.calculateGammaScores) + { + int64_t timeStampML = bc.timestamp(); + if(mlConfigurations.timestampCCDB.value!=-1) + timeStampML = mlConfigurations.timestampCCDB.value; + LoadMachines(timeStampML); + } + // In case override, don't proceed, please - no CCDB access required if (dcaFitterConfigurations.d_bz_input > -990) { d_bz = dcaFitterConfigurations.d_bz_input; @@ -672,6 +722,48 @@ struct lambdakzeroBuilder { } } + // function to load models for ML-based classifiers + void LoadMachines(int64_t timeStampML){ + if(mlConfigurations.loadModelsFromCCDB){ + ccdbApi.init(ccdbConfigurations.ccdburl); + LOG(info) << "Fetching models for timestamp: " << timeStampML; + + if (mlConfigurations.calculateLambdaScores) { + bool retrieveSuccessLambda = ccdbApi.retrieveBlob(mlConfigurations.modelPathCCDB, ".", metadata, timeStampML, false, mlConfigurations.localModelPathLambda.value); + if (retrieveSuccessLambda) mlModelLambda.initModel(mlConfigurations.localModelPathLambda.value, mlConfigurations.enableOptimizations.value); + else{ + LOG(fatal) << "Error encountered while fetching/loading the Lambda model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?";} + } + + if (mlConfigurations.calculateAntiLambdaScores) { + bool retrieveSuccessAntiLambda = ccdbApi.retrieveBlob(mlConfigurations.modelPathCCDB, ".", metadata, timeStampML, false, mlConfigurations.localModelPathAntiLambda.value); + if (retrieveSuccessAntiLambda) mlModelAntiLambda.initModel(mlConfigurations.localModelPathAntiLambda.value, mlConfigurations.enableOptimizations.value); + else{ + LOG(fatal) << "Error encountered while fetching/loading the AntiLambda model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?";} + } + + if (mlConfigurations.calculateGammaScores) { + bool retrieveSuccessGamma = ccdbApi.retrieveBlob(mlConfigurations.modelPathCCDB, ".", metadata, timeStampML, false, mlConfigurations.localModelPathGamma.value); + if (retrieveSuccessGamma) mlModelGamma.initModel(mlConfigurations.localModelPathGamma.value, mlConfigurations.enableOptimizations.value); + else{ + LOG(fatal) << "Error encountered while fetching/loading the Gamma model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?";} + } + + if (mlConfigurations.calculateK0ShortScores) { + bool retrieveSuccessKZeroShort = ccdbApi.retrieveBlob(mlConfigurations.modelPathCCDB, ".", metadata, timeStampML, false, mlConfigurations.localModelPathK0Short.value); + if (retrieveSuccessKZeroShort) mlModelK0Short.initModel(mlConfigurations.localModelPathK0Short.value, mlConfigurations.enableOptimizations.value); + else{ + LOG(fatal) << "Error encountered while fetching/loading the K0Short model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?";} + } + } else { + if (mlConfigurations.calculateLambdaScores) mlModelLambda.initModel(mlConfigurations.localModelPathLambda.value, mlConfigurations.enableOptimizations.value); + if (mlConfigurations.calculateAntiLambdaScores) mlModelAntiLambda.initModel(mlConfigurations.localModelPathAntiLambda.value, mlConfigurations.enableOptimizations.value); + if (mlConfigurations.calculateGammaScores) mlModelGamma.initModel(mlConfigurations.localModelPathGamma.value, mlConfigurations.enableOptimizations.value); + if (mlConfigurations.calculateK0ShortScores) mlModelK0Short.initModel(mlConfigurations.localModelPathK0Short.value, mlConfigurations.enableOptimizations.value); + } + LOG(info) << "ML Models loaded."; + } + template bool buildV0Candidate(TV0Object const& V0) { @@ -991,8 +1083,8 @@ struct lambdakzeroBuilder { } int ivanovMap = 0; + float pt = RecoDecay::sqrtSumOfSquares(v0candidate.posP[0] + v0candidate.negP[0], v0candidate.posP[1] + v0candidate.negP[1]); if (downscalingOptions.downscale_adaptive) { - float pt = RecoDecay::sqrtSumOfSquares(v0candidate.posP[0] + v0candidate.negP[0], v0candidate.posP[1] + v0candidate.negP[1]); ivanovMap = DownsampleMap(pt); if (ivanovMap == 0) continue; // skip this V0, passes nothing @@ -1007,6 +1099,45 @@ struct lambdakzeroBuilder { if (V0.v0Type() > 0) { if (V0.v0Type() > 1 && !storePhotonCandidates) continue; + + float gammaScore = -1.0f, lambdaScore = -1.0f, antiLambdaScore = -1.0f, k0ShortScore = -1.0f; + + // evaluate machine learning at this point: check if requested + if (mlConfigurations.calculateK0ShortScores || + mlConfigurations.calculateLambdaScores || + mlConfigurations.calculateAntiLambdaScores || + mlConfigurations.calculateGammaScores) + { + // machine learning is on, go for calculation of thresholds + // FIXME THIS NEEDS ADJUSTING + std::vector inputFeatures{pt, 0.0f, + 0.0f, v0candidate.V0radius, + v0candidate.cosPA, v0candidate.dcaV0dau, + v0candidate.posDCAxy, v0candidate.negDCAxy}; + + // calculate classifier + float* lambdaProbability = mlModelLambda.evalModel(inputFeatures); + float* gammaProbability = mlModelGamma.evalModel(inputFeatures); + + // save score + gammaScore = gammaProbability[1]; + lambdaScore = lambdaProbability[1]; + + // Skip anything that doesn't fulfull any of the desired conditions + if( gammaScore < mlConfigurations.thresholdGamma.value && + lambdaScore < mlConfigurations.thresholdLambda.value && + antiLambdaScore < mlConfigurations.thresholdAntiLambda.value && + k0ShortScore < mlConfigurations.thresholdK0Short.value){ + continue; // skipped as uninteresting in any hypothesis considered + } + + // at this stage, the candidate is interesting -> populate table + gammaMLSelections(gammaScore); + lambdaMLSelections(lambdaScore); + antiLambdaMLSelections(antiLambdaScore); + k0ShortMLSelections(k0ShortScore); + } + // populates the various tables for analysis statisticsRegistry.v0stats[kCountStandardV0]++; v0indices(V0.posTrackId(), V0.negTrackId(), From dc42fb80b52f5028a589ffe5943253de651c4a05 Mon Sep 17 00:00:00 2001 From: ddobrigk Date: Thu, 11 Apr 2024 17:19:01 +0200 Subject: [PATCH 06/26] Move ML calculation to cover both V0 and V0fC --- .../Strangeness/lambdakzerobuilder.cxx | 60 ++++++++++--------- 1 file changed, 33 insertions(+), 27 deletions(-) diff --git a/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx b/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx index 7b6f97189e1..a140924625f 100644 --- a/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx +++ b/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx @@ -1094,43 +1094,49 @@ struct lambdakzeroBuilder { if (roundDCAVariables) roundV0CandidateVariables(); + // evaluate machine-learning scores + float gammaScore = -1.0f, lambdaScore = -1.0f, antiLambdaScore = -1.0f, k0ShortScore = -1.0f; + + if (mlConfigurations.calculateK0ShortScores || + mlConfigurations.calculateLambdaScores || + mlConfigurations.calculateAntiLambdaScores || + mlConfigurations.calculateGammaScores) + { + // machine learning is on, go for calculation of thresholds + // FIXME THIS NEEDS ADJUSTING + std::vector inputFeatures{pt, 0.0f, + 0.0f, v0candidate.V0radius, + v0candidate.cosPA, v0candidate.dcaV0dau, + v0candidate.posDCAxy, v0candidate.negDCAxy}; + + // calculate classifier + float* lambdaProbability = mlModelLambda.evalModel(inputFeatures); + float* gammaProbability = mlModelGamma.evalModel(inputFeatures); + + // save score + gammaScore = gammaProbability[1]; + lambdaScore = lambdaProbability[1]; + + // Skip anything that doesn't fulfull any of the desired conditions + if( gammaScore < mlConfigurations.thresholdGamma.value && + lambdaScore < mlConfigurations.thresholdLambda.value && + antiLambdaScore < mlConfigurations.thresholdAntiLambda.value && + k0ShortScore < mlConfigurations.thresholdK0Short.value){ + continue; // skipped as uninteresting in any hypothesis considered + } + } + // V0 logic reminder // 0: v0 saved for the only due to the cascade, 1: standalone v0, 3: standard v0 with photon-only test if (V0.v0Type() > 0) { if (V0.v0Type() > 1 && !storePhotonCandidates) continue; - - float gammaScore = -1.0f, lambdaScore = -1.0f, antiLambdaScore = -1.0f, k0ShortScore = -1.0f; - - // evaluate machine learning at this point: check if requested + if (mlConfigurations.calculateK0ShortScores || mlConfigurations.calculateLambdaScores || mlConfigurations.calculateAntiLambdaScores || mlConfigurations.calculateGammaScores) { - // machine learning is on, go for calculation of thresholds - // FIXME THIS NEEDS ADJUSTING - std::vector inputFeatures{pt, 0.0f, - 0.0f, v0candidate.V0radius, - v0candidate.cosPA, v0candidate.dcaV0dau, - v0candidate.posDCAxy, v0candidate.negDCAxy}; - - // calculate classifier - float* lambdaProbability = mlModelLambda.evalModel(inputFeatures); - float* gammaProbability = mlModelGamma.evalModel(inputFeatures); - - // save score - gammaScore = gammaProbability[1]; - lambdaScore = lambdaProbability[1]; - - // Skip anything that doesn't fulfull any of the desired conditions - if( gammaScore < mlConfigurations.thresholdGamma.value && - lambdaScore < mlConfigurations.thresholdLambda.value && - antiLambdaScore < mlConfigurations.thresholdAntiLambda.value && - k0ShortScore < mlConfigurations.thresholdK0Short.value){ - continue; // skipped as uninteresting in any hypothesis considered - } - // at this stage, the candidate is interesting -> populate table gammaMLSelections(gammaScore); lambdaMLSelections(lambdaScore); From 5ba3e5ae174fa702cc6b765c22c2bb7299642d46 Mon Sep 17 00:00:00 2001 From: gianniliveraro Date: Thu, 11 Apr 2024 14:33:48 -0300 Subject: [PATCH 07/26] PWGLF/ML: Changing task name, minor adjustments in ML selection --- PWGLF/TableProducer/Strangeness/CMakeLists.txt | 4 ++-- ...cxx => lambdakzeroMLSelectionTreeCreator.cxx} | 4 ++-- .../Strangeness/lambdakzeromlselection.cxx | 16 +++++++--------- 3 files changed, 11 insertions(+), 13 deletions(-) rename PWGLF/TableProducer/Strangeness/{lambdakzeroTreeCreator.cxx => lambdakzeroMLSelectionTreeCreator.cxx} (99%) diff --git a/PWGLF/TableProducer/Strangeness/CMakeLists.txt b/PWGLF/TableProducer/Strangeness/CMakeLists.txt index e269a6ea4e7..905f3fd3192 100644 --- a/PWGLF/TableProducer/Strangeness/CMakeLists.txt +++ b/PWGLF/TableProducer/Strangeness/CMakeLists.txt @@ -105,8 +105,8 @@ o2physics_add_dpl_workflow(v0qaanalysis COMPONENT_NAME Analysis) # ML selection -o2physics_add_dpl_workflow(lambdakzerotreecreator - SOURCES lambdakzeroTreeCreator.cxx +o2physics_add_dpl_workflow(lambdakzeromlselectiontreecreator + SOURCES lambdakzeroMLSelectionTreeCreator.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2Physics::MLCore COMPONENT_NAME Analysis) diff --git a/PWGLF/TableProducer/Strangeness/lambdakzeroTreeCreator.cxx b/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx similarity index 99% rename from PWGLF/TableProducer/Strangeness/lambdakzeroTreeCreator.cxx rename to PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx index 530aea480a6..748aea25475 100644 --- a/PWGLF/TableProducer/Strangeness/lambdakzeroTreeCreator.cxx +++ b/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx @@ -66,7 +66,7 @@ using std::endl; using dauTracks = soa::Join; -struct lambdakzeroTreeCreator{ +struct lambdakzeroMLSelectionTreeCreator{ Produces v0MLCandidates; HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; @@ -314,6 +314,6 @@ struct lambdakzeroTreeCreator{ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { - return WorkflowSpec{adaptAnalysisTask(cfgc)}; + return WorkflowSpec{adaptAnalysisTask(cfgc)}; } \ No newline at end of file diff --git a/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx b/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx index 6a45a0b775f..72aec92266d 100644 --- a/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx +++ b/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx @@ -62,11 +62,6 @@ using std::array; using std::cout; using std::endl; -//OnnxModel bdt; -OnnxModel lambda_bdt; -OnnxModel antilambda_bdt; -OnnxModel gamma_bdt; -OnnxModel kzeroshort_bdt; // For original data loops using V0OriginalDatas = soa::Join; @@ -74,10 +69,14 @@ using V0OriginalDatas = soa::Join; // For derived data analysis using V0DerivedDatas = soa::Join; -std::map metadata; -std::map headers; - struct lambdakzeromlselection{ + o2::ml::OnnxModel lambda_bdt;; + o2::ml::OnnxModel antilambda_bdt; + o2::ml::OnnxModel gamma_bdt; + o2::ml::OnnxModel kzeroshort_bdt; + + std::map metadata; + 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) HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; @@ -120,7 +119,6 @@ struct lambdakzeromlselection{ /// Fetching model for specific timestamp LOG(info) << "Fetching model for timestamp: " << timestampCCDB.value; - //headers = ccdbApi.retrieveHeaders(BDTPathCCDB.value, metadata, timestampCCDB.value); if (PredictLambda) { bool retrieveSuccessLambda = ccdbApi.retrieveBlob(BDTPathCCDB.value, ".", metadata, timestampCCDB.value, false, BDTLocalPathLambda.value); From 9818cdc6b9978752674fd7b1c1bacf23475d5d78 Mon Sep 17 00:00:00 2001 From: ddobrigk Date: Fri, 12 Apr 2024 08:50:21 +0200 Subject: [PATCH 08/26] Eval only if requested --- .../Strangeness/lambdakzerobuilder.cxx | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx b/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx index a140924625f..c0ef6a32833 100644 --- a/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx +++ b/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx @@ -1109,13 +1109,15 @@ struct lambdakzeroBuilder { v0candidate.cosPA, v0candidate.dcaV0dau, v0candidate.posDCAxy, v0candidate.negDCAxy}; - // calculate classifier - float* lambdaProbability = mlModelLambda.evalModel(inputFeatures); - float* gammaProbability = mlModelGamma.evalModel(inputFeatures); - - // save score - gammaScore = gammaProbability[1]; - lambdaScore = lambdaProbability[1]; + // calculate scores + if(mlConfigurations.calculateLambdaScores){ + float* lambdaProbability = mlModelLambda.evalModel(inputFeatures); + lambdaScore = lambdaProbability[1]; + } + if(mlConfigurations.calculateGammaScores){ + float* gammaProbability = mlModelGamma.evalModel(inputFeatures); + gammaScore = gammaProbability[1]; + } // Skip anything that doesn't fulfull any of the desired conditions if( gammaScore < mlConfigurations.thresholdGamma.value && From 3060fd385413492b69393f7328b4bf6882b32874 Mon Sep 17 00:00:00 2001 From: ddobrigk Date: Fri, 12 Apr 2024 10:50:53 +0200 Subject: [PATCH 09/26] implementation of ML in cascade builder --- .../TableProducer/Strangeness/CMakeLists.txt | 2 +- .../Strangeness/cascadebuilder.cxx | 273 ++++++++++++++---- .../Strangeness/lambdakzerobuilder.cxx | 1 - 3 files changed, 215 insertions(+), 61 deletions(-) diff --git a/PWGLF/TableProducer/Strangeness/CMakeLists.txt b/PWGLF/TableProducer/Strangeness/CMakeLists.txt index 905f3fd3192..50751d09b77 100644 --- a/PWGLF/TableProducer/Strangeness/CMakeLists.txt +++ b/PWGLF/TableProducer/Strangeness/CMakeLists.txt @@ -11,7 +11,7 @@ o2physics_add_dpl_workflow(cascadebuilder SOURCES cascadebuilder.cxx - PUBLIC_LINK_LIBRARIES O2::DCAFitter O2Physics::AnalysisCore KFParticle::KFParticle + PUBLIC_LINK_LIBRARIES O2::DCAFitter O2Physics::AnalysisCore KFParticle::KFParticle O2Physics::MLCore COMPONENT_NAME Analysis) o2physics_add_dpl_workflow(cascadefinder diff --git a/PWGLF/TableProducer/Strangeness/cascadebuilder.cxx b/PWGLF/TableProducer/Strangeness/cascadebuilder.cxx index 0d94bc67356..0dc1b5edb21 100644 --- a/PWGLF/TableProducer/Strangeness/cascadebuilder.cxx +++ b/PWGLF/TableProducer/Strangeness/cascadebuilder.cxx @@ -61,6 +61,8 @@ #include "DataFormatsParameters/GRPObject.h" #include "DataFormatsParameters/GRPMagField.h" #include "CCDB/BasicCCDBManager.h" +#include "Tools/ML/MlResponse.h" +#include "Tools/ML/model.h" #ifndef HomogeneousField #define HomogeneousField @@ -104,6 +106,13 @@ using LabeledTracksExtra = soa::Join; //*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+* // Builder task: rebuilds multi-strange candidates struct cascadeBuilder { + o2::ml::OnnxModel mlModelXiMinus; + o2::ml::OnnxModel mlModelXiPlus; + o2::ml::OnnxModel mlModelOmegaMinus; + o2::ml::OnnxModel mlModelOmegaPlus; + + std::map metadata; + Produces cascidx; Produces kfcascidx; Produces trackedcascidx; @@ -114,6 +123,8 @@ struct cascadeBuilder { Produces cascbb; // if enabled Produces casccovs; // if requested by someone Produces kfcasccovs; // if requested by someone + + o2::ccdb::CcdbApi ccdbApi; Service ccdb; Configurable d_UseAutodetectMode{"d_UseAutodetectMode", false, "Autodetect requested topo sels"}; @@ -149,26 +160,30 @@ struct cascadeBuilder { Configurable calculateBachBaryonVars{"calculateBachBaryonVars", false, "calculate variables for removing cascade inv mass bump"}; // CCDB options - Configurable ccdburl{"ccdb-url", "http://alice-ccdb.cern.ch", "url of the ccdb repository"}; - Configurable grpPath{"grpPath", "GLO/GRP/GRP", "Path of the grp file"}; - Configurable grpmagPath{"grpmagPath", "GLO/Config/GRPMagField", "CCDB path of the GRPMagField object"}; - Configurable lutPath{"lutPath", "GLO/Param/MatLUT", "Path of the Lut parametrization"}; - Configurable geoPath{"geoPath", "GLO/Config/GeometryAligned", "Path of the geometry file"}; + struct : ConfigurableGroup { + Configurable ccdburl{"ccdb-url", "http://alice-ccdb.cern.ch", "url of the ccdb repository"}; + Configurable grpPath{"grpPath", "GLO/GRP/GRP", "Path of the grp file"}; + Configurable grpmagPath{"grpmagPath", "GLO/Config/GRPMagField", "CCDB path of the GRPMagField object"}; + Configurable lutPath{"lutPath", "GLO/Param/MatLUT", "Path of the Lut parametrization"}; + Configurable geoPath{"geoPath", "GLO/Config/GeometryAligned", "Path of the geometry file"}; + } ccdbConfigurations; // generate and fill extra QA histograms if requested - Configurable d_doQA{"d_doQA", false, "Do basic QA"}; - Configurable dQANBinsRadius{"dQANBinsRadius", 500, "Number of radius bins in QA histo"}; - Configurable dQANBinsPtCoarse{"dQANBinsPtCoarse", 10, "Number of pT bins in QA histo"}; - Configurable dQANBinsMass{"dQANBinsMass", 400, "Number of mass bins for QA histograms"}; - Configurable dQANBinsDCAxy{"dQANBinsDCAxy", 200, "DCAxy of cascade to PV Nbins"}; - Configurable dQANBinsChi2{"dQANBinsChi2", 200, "Chi2 Nbins"}; - Configurable dQANBinsCluSize{"dQANBinsCluSize", 200, "Cluster size Nbins"}; - Configurable dQAMaxPt{"dQAMaxPt", 5, "max pT in QA histo"}; - Configurable dQAMaxDCA{"dQAMaxDCA", 1, "max DCAxy QA histo"}; - Configurable dQAMaxChi2{"dQAMaxChi2", 20, "max chi2"}; - Configurable dQAMaxCluSize{"dQAMaxCluSize", 10, "max ITS clu size"}; - Configurable dQAXiMassWindow{"dQAXiMassWindow", 0.005, "Xi mass window for ITS cluster map QA"}; - Configurable dQAOmegaMassWindow{"dQAOmegaMassWindow", 0.005, "Omega mass window for ITS cluster map QA"}; + struct : ConfigurableGroup { + Configurable d_doQA{"qaConfigurations.d_doQA", false, "Do basic QA"}; + Configurable dQANBinsRadius{"qaConfigurations.dQANBinsRadius", 500, "Number of radius bins in QA histo"}; + Configurable dQANBinsPtCoarse{"qaConfigurations.dQANBinsPtCoarse", 10, "Number of pT bins in QA histo"}; + Configurable dQANBinsMass{"qaConfigurations.dQANBinsMass", 400, "Number of mass bins for QA histograms"}; + Configurable dQANBinsDCAxy{"qaConfigurations.dQANBinsDCAxy", 200, "DCAxy of cascade to PV Nbins"}; + Configurable dQANBinsChi2{"qaConfigurations.dQANBinsChi2", 200, "Chi2 Nbins"}; + Configurable dQANBinsCluSize{"qaConfigurations.dQANBinsCluSize", 200, "Cluster size Nbins"}; + Configurable dQAMaxPt{"qaConfigurations.dQAMaxPt", 5, "max pT in QA histo"}; + Configurable dQAMaxDCA{"qaConfigurations.dQAMaxDCA", 1, "max DCAxy QA histo"}; + Configurable dQAMaxChi2{"qaConfigurations.dQAMaxChi2", 20, "max chi2"}; + Configurable dQAMaxCluSize{"qaConfigurations.dQAMaxCluSize", 10, "max ITS clu size"}; + Configurable dQAXiMassWindow{"qaConfigurations.dQAXiMassWindow", 0.005, "Xi mass window for ITS cluster map QA"}; + Configurable dQAOmegaMassWindow{"qaConfigurations.dQAOmegaMassWindow", 0.005, "Omega mass window for ITS cluster map QA"}; + } qaConfigurations; // for KF particle operation Configurable kfTuneForOmega{"kfTuneForOmega", false, "if enabled, take main cascade properties from Omega fit instead of Xi fit (= default)"}; @@ -178,15 +193,43 @@ struct cascadeBuilder { Configurable kfDoDCAFitterPreMinimV0{"kfDoDCAFitterPreMinimV0", true, "KF: do DCAFitter pre-optimization before KF fit to include material corrections for V0"}; Configurable kfDoDCAFitterPreMinimCasc{"kfDoDCAFitterPreMinimCasc", true, "KF: do DCAFitter pre-optimization before KF fit to include material corrections for Xi"}; - ConfigurableAxis axisPtQA{"axisPtQA", {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 QA histograms"}; - // for topo var QA - ConfigurableAxis axisTopoVarPointingAngle{"axisTopoVarPointingAngle", {50, 0.0, 1.0}, "pointing angle"}; - ConfigurableAxis axisTopoVarRAP{"axisTopoVarRAP", {50, 0.0, 1.0}, "radius x pointing angle axis"}; - ConfigurableAxis axisTopoVarV0Radius{"axisTopoVarV0Radius", {500, 0.0, 100.0}, "V0 decay radius (cm)"}; - ConfigurableAxis axisTopoVarDCAV0Dau{"axisTopoVarDCAV0Dau", {200, 0.0, 2.0}, "DCA between V0 daughters (cm)"}; - ConfigurableAxis axisTopoVarDCAToPV{"axisTopoVarDCAToPV", {200, -1, 1.0}, "single track DCA to PV (cm)"}; - ConfigurableAxis axisTopoVarDCAV0ToPV{"axisTopoVarDCAV0ToPV", {200, 0, 5.0}, "V0 DCA to PV (cm)"}; + struct : ConfigurableGroup { + ConfigurableAxis axisTopoVarPointingAngle{"axisConfigurations.axisTopoVarPointingAngle", {50, 0.0, 1.0}, "pointing angle"}; + ConfigurableAxis axisTopoVarRAP{"axisConfigurations.axisTopoVarRAP", {50, 0.0, 1.0}, "radius x pointing angle axis"}; + ConfigurableAxis axisTopoVarV0Radius{"axisConfigurations.axisTopoVarV0Radius", {500, 0.0, 100.0}, "V0 decay radius (cm)"}; + ConfigurableAxis axisTopoVarDCAV0Dau{"axisConfigurations.axisTopoVarDCAV0Dau", {200, 0.0, 2.0}, "DCA between V0 daughters (cm)"}; + ConfigurableAxis axisTopoVarDCAToPV{"axisConfigurations.axisTopoVarDCAToPV", {200, -1, 1.0}, "single track DCA to PV (cm)"}; + ConfigurableAxis axisTopoVarDCAV0ToPV{"axisConfigurations.axisTopoVarDCAV0ToPV", {200, 0, 5.0}, "V0 DCA to PV (cm)"}; + ConfigurableAxis axisPtQA{"axisPtQA", {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 QA histograms"}; + } axisConfigurations; + + // Machine learning evaluation for pre-selection and corresponding information generation + struct : ConfigurableGroup { + // ML classifiers: master flags to populate ML Selection tables + Configurable calculateXiMinusScores{"mlConfigurations.calculateXiMinusScores", false, "calculate XiMinus ML scores"}; + Configurable calculateXiPlusScores{"mlConfigurations.calculateXiPlusScores", false, "calculate XiPlus ML scores"}; + Configurable calculateOmegaMinusScores{"mlConfigurations.calculateOmegaMinusScores", false, "calculate OmegaMinus ML scores"}; + Configurable calculateOmegaPlusScores{"mlConfigurations.calculateOmegaPlusScores", false, "calculate OmegaPlus ML scores"}; + + // ML input for ML calculation + Configurable modelPathCCDB{"mlConfigurations.modelPathCCDB", "", "ML Model path in CCDB"}; + Configurable timestampCCDB{"mlConfigurations.timestampCCDB", -1, "timestamp of the ONNX file for ML model used to query in CCDB. Exceptions: > 0 for the specific timestamp, 0 gets the run dependent timestamp"}; + Configurable loadModelsFromCCDB{"mlConfigurations.loadModelsFromCCDB", false, "Flag to enable or disable the loading of models from CCDB"}; + Configurable enableOptimizations{"mlConfigurations.enableOptimizations", false, "Enables the ONNX extended model-optimization: sessionOptions.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_ENABLE_EXTENDED)"}; + + // Local paths for test purposes + Configurable localModelPathXiMinus{"mlConfigurations.localModelPathXiMinus", "XiMinus_BDTModel.onnx", "(std::string) Path to the local .onnx file."}; + Configurable localModelPathXiPlus{"mlConfigurations.localModelPathXiPlus", "XiPlus_BDTModel.onnx", "(std::string) Path to the local .onnx file."}; + Configurable localModelPathOmegaMinus{"mlConfigurations.localModelPathOmegaMinus", "OmegaMinus_BDTModel.onnx", "(std::string) Path to the local .onnx file."}; + Configurable localModelPathOmegaPlus{"mlConfigurations.localModelPathOmegaPlus", "OmegaPlus_BDTModel.onnx", "(std::string) Path to the local .onnx file."}; + + // Thresholds for choosing to populate V0Cores tables with pre-selections + Configurable thresholdXiMinus{"mlConfigurations.thresholdXiMinus", -1.0f, "Threshold to keep XiMinus candidates"}; + Configurable thresholdXiPlus{"mlConfigurations.thresholdXiPlus", -1.0f, "Threshold to keep XiPlus candidates"}; + Configurable thresholdOmegaMinus{"mlConfigurations.thresholdOmegaMinus", -1.0f, "Threshold to keep OmegaMinus candidates"}; + Configurable thresholdOmegaPlus{"mlConfigurations.thresholdOmegaPlus", -1.0f, "Threshold to keep OmegaPlus candidates"}; + } mlConfigurations; // round some V0 core variables up to a certain level of precision if requested // useful to keep derived data sizes under control @@ -265,6 +308,10 @@ struct cascadeBuilder { std::array kfV0Cov; std::array kfV0DauPosCov; std::array kfV0DauNegCov; + float mlXiMinusScore; + float mlXiPlusScore; + float mlOmegaMinusScore; + float mlOmegaPlusScore; } cascadecandidate; o2::track::TrackParCov lBachelorTrack; @@ -354,27 +401,27 @@ struct cascadeBuilder { h->GetXaxis()->SetBinLabel(10, "Tracked"); // Optionally, add extra QA histograms to processing chain - if (d_doQA) { + if (qaConfigurations.d_doQA) { // Basic histograms containing invariant masses of all built candidates - const AxisSpec axisVsPtCoarse{static_cast(dQANBinsPtCoarse), 0, dQAMaxPt, "#it{p}_{T} (GeV/c)"}; - const AxisSpec axisLamMass{static_cast(dQANBinsMass), 1.075f, 1.275f, "Inv. Mass (GeV/c^{2})"}; - const AxisSpec axisXiMass{static_cast(dQANBinsMass), 1.222f, 1.422f, "Inv. Mass (GeV/c^{2})"}; - const AxisSpec axisOmegaMass{static_cast(dQANBinsMass), 1.572f, 1.772f, "Inv. Mass (GeV/c^{2})"}; - const AxisSpec axisCascadeDCAtoPV{static_cast(dQANBinsDCAxy), -dQAMaxDCA, dQAMaxDCA, "DCA_{xy} (cm)"}; - - registry.add("h2dLambdaMass", "h2dLambdaMass", kTH2F, {axisPtQA, axisLamMass}); - registry.add("h2dAntiLambdaMass", "h2dAntiLambdaMass", kTH2F, {axisPtQA, axisLamMass}); - registry.add("MassHistograms/h2dXiMinusMass", "h2dXiMinusMass", kTH2F, {axisPtQA, axisXiMass}); - registry.add("MassHistograms/h2dXiPlusMass", "h2dXiPlusMass", kTH2F, {axisPtQA, axisXiMass}); - registry.add("MassHistograms/h2dOmegaMinusMass", "h2dOmegaMinusMass", kTH2F, {axisPtQA, axisOmegaMass}); - registry.add("MassHistograms/h2dOmegaPlusMass", "h2dOmegaPlusMass", kTH2F, {axisPtQA, axisOmegaMass}); + const AxisSpec axisVsPtCoarse{static_cast(qaConfigurations.dQANBinsPtCoarse), 0, qaConfigurations.dQAMaxPt, "#it{p}_{T} (GeV/c)"}; + const AxisSpec axisLamMass{static_cast(qaConfigurations.dQANBinsMass), 1.075f, 1.275f, "Inv. Mass (GeV/c^{2})"}; + const AxisSpec axisXiMass{static_cast(qaConfigurations.dQANBinsMass), 1.222f, 1.422f, "Inv. Mass (GeV/c^{2})"}; + const AxisSpec axisOmegaMass{static_cast(qaConfigurations.dQANBinsMass), 1.572f, 1.772f, "Inv. Mass (GeV/c^{2})"}; + const AxisSpec axisCascadeDCAtoPV{static_cast(qaConfigurations.dQANBinsDCAxy), -qaConfigurations.dQAMaxDCA, qaConfigurations.dQAMaxDCA, "DCA_{xy} (cm)"}; + + registry.add("h2dLambdaMass", "h2dLambdaMass", kTH2F, {axisConfigurations.axisPtQA, axisLamMass}); + registry.add("h2dAntiLambdaMass", "h2dAntiLambdaMass", kTH2F, {axisConfigurations.axisPtQA, axisLamMass}); + registry.add("MassHistograms/h2dXiMinusMass", "h2dXiMinusMass", kTH2F, {axisConfigurations.axisPtQA, axisXiMass}); + registry.add("MassHistograms/h2dXiPlusMass", "h2dXiPlusMass", kTH2F, {axisConfigurations.axisPtQA, axisXiMass}); + registry.add("MassHistograms/h2dOmegaMinusMass", "h2dOmegaMinusMass", kTH2F, {axisConfigurations.axisPtQA, axisOmegaMass}); + registry.add("MassHistograms/h2dOmegaPlusMass", "h2dOmegaPlusMass", kTH2F, {axisConfigurations.axisPtQA, axisOmegaMass}); if (d_doPtDep_CosPaCut) registry.addClone("MassHistograms/", "MassHistograms_BefPAcut/"); // bit packed ITS cluster map const AxisSpec axisITSCluMap{static_cast(128), -0.5f, +127.5f, "Packed ITS map"}; - const AxisSpec axisRadius{static_cast(dQANBinsRadius), 0.0f, +50.0f, "Radius (cm)"}; + const AxisSpec axisRadius{static_cast(qaConfigurations.dQANBinsRadius), 0.0f, +50.0f, "Radius (cm)"}; // Histogram to bookkeep cluster maps registry.add("h2dITSCluMap_XiMinusPositive", "h2dITSCluMap_XiMinusPositive", kTH2D, {axisITSCluMap, axisRadius}); @@ -391,9 +438,9 @@ struct cascadeBuilder { registry.add("h2dITSCluMap_OmegaPlusBachelor", "h2dITSCluMap_OmegaPlusBachelor", kTH2D, {axisITSCluMap, axisRadius}); // QA plots of topological variables using axisPtQA - registry.add("h2dTopoVarCascPointingAngle", "h2dTopoVarCascPointingAngle", kTH2D, {axisPtQA, axisTopoVarPointingAngle}); - registry.add("h2dTopoVarCascRAP", "h2dTopoVarCascRAP", kTH2D, {axisPtQA, axisTopoVarRAP}); - registry.add("h2dTopoVarCascRadius", "h2dTopoVarCascRadius", kTH2D, {axisPtQA, axisTopoVarV0Radius}); + registry.add("h2dTopoVarCascPointingAngle", "h2dTopoVarCascPointingAngle", kTH2D, {axisConfigurations.axisPtQA, axisConfigurations.axisTopoVarPointingAngle}); + registry.add("h2dTopoVarCascRAP", "h2dTopoVarCascRAP", kTH2D, {axisConfigurations.axisPtQA, axisConfigurations.axisTopoVarRAP}); + registry.add("h2dTopoVarCascRadius", "h2dTopoVarCascRadius", kTH2D, {axisConfigurations.axisPtQA, axisConfigurations.axisTopoVarV0Radius}); // if basic strangeness tracking QA is desired, do it here // convenience: equivalence between regular cascade and tracked cascade is easy to check here @@ -448,8 +495,8 @@ struct cascadeBuilder { registry.add("hDCAzTrackedCascadeToPVOmegaPlus", "hDCAzTrackedCascadeToPVOmegaPlus", kTH2F, {axisVsPtCoarse, axisCascadeDCAtoPV}); // specific variables associated to strangeness tracking - const AxisSpec axisChi2{static_cast(dQANBinsChi2), 0.0f, dQAMaxChi2, "#chi^{2}"}; - const AxisSpec axisCluSize{static_cast(dQANBinsCluSize), 0.0f, dQAMaxCluSize, "Mean ITS cluster size"}; + const AxisSpec axisChi2{static_cast(qaConfigurations.dQANBinsChi2), 0.0f, qaConfigurations.dQAMaxChi2, "#chi^{2}"}; + const AxisSpec axisCluSize{static_cast(qaConfigurations.dQANBinsCluSize), 0.0f, qaConfigurations.dQAMaxCluSize, "Mean ITS cluster size"}; registry.add("hMatchingChi2_XiMinus", "hMatchingChi2_XiMinus", kTH1D, {axisChi2}); registry.add("hMatchingChi2_XiPlus", "hMatchingChi2_XiPlus", kTH1D, {axisChi2}); registry.add("hMatchingChi2_OmegaMinus", "hMatchingChi2_OmegaMinus", kTH1D, {axisChi2}); @@ -470,7 +517,7 @@ struct cascadeBuilder { maxSnp = 0.85f; // could be changed later maxStep = 2.00f; // could be changed later - ccdb->setURL(ccdburl); + ccdb->setURL(ccdbConfigurations.ccdburl); ccdb->setCaching(true); ccdb->setLocalObjectValidityChecking(); ccdb->setFatalWhenNull(false); @@ -478,12 +525,12 @@ struct cascadeBuilder { if (useMatCorrType == 1) { LOGF(info, "TGeo correction requested, loading geometry"); if (!o2::base::GeometryManager::isGeometryLoaded()) { - ccdb->get(geoPath); + ccdb->get(ccdbConfigurations.geoPath); } } if (useMatCorrType == 2) { LOGF(info, "LUT correction requested, loading LUT"); - lut = o2::base::MatLayerCylSet::rectifyPtrFromFile(ccdb->get(lutPath)); + lut = o2::base::MatLayerCylSet::rectifyPtrFromFile(ccdb->get(ccdbConfigurations.lutPath)); } if (doprocessRun2 == false && doprocessRun3 == false && doprocessRun3withStrangenessTracking == false && doprocessRun3withKFParticle == false) { @@ -646,6 +693,18 @@ struct cascadeBuilder { return; } + // machine learning initialization if requested + if (mlConfigurations.calculateXiMinusScores || + mlConfigurations.calculateXiPlusScores || + mlConfigurations.calculateOmegaMinusScores || + mlConfigurations.calculateOmegaPlusScores) + { + int64_t timeStampML = bc.timestamp(); + if(mlConfigurations.timestampCCDB.value!=-1) + timeStampML = mlConfigurations.timestampCCDB.value; + LoadMachines(timeStampML); + } + // In case override, don't proceed, please - no CCDB access required if (d_bz_input > -990) { d_bz = d_bz_input; @@ -663,15 +722,15 @@ struct cascadeBuilder { o2::parameters::GRPObject* grpo = 0x0; o2::parameters::GRPMagField* grpmag = 0x0; if (doprocessRun2) { - grpo = ccdb->getForTimeStamp(grpPath, timestamp); + grpo = ccdb->getForTimeStamp(ccdbConfigurations.grpPath, timestamp); if (!grpo) { - LOG(fatal) << "Got nullptr from CCDB for path " << grpPath << " of object GRPObject for timestamp " << timestamp; + LOG(fatal) << "Got nullptr from CCDB for path " << ccdbConfigurations.grpPath << " of object GRPObject for timestamp " << timestamp; } o2::base::Propagator::initFieldFromGRP(grpo); } else { - grpmag = ccdb->getForTimeStamp(grpmagPath, timestamp); + grpmag = ccdb->getForTimeStamp(ccdbConfigurations.grpmagPath, timestamp); if (!grpmag) { - LOG(fatal) << "Got nullptr from CCDB for path " << grpmagPath << " of object GRPMagField for timestamp " << timestamp; + LOG(fatal) << "Got nullptr from CCDB for path " << ccdbConfigurations.grpmagPath << " of object GRPMagField for timestamp " << timestamp; } o2::base::Propagator::initFieldFromGRP(grpmag); } @@ -690,6 +749,57 @@ struct cascadeBuilder { o2::base::Propagator::Instance()->setMatLUT(lut); } } + + // function to load models for ML-based classifiers + void LoadMachines(int64_t timeStampML){ + if(mlConfigurations.loadModelsFromCCDB){ + ccdbApi.init(ccdbConfigurations.ccdburl); + LOG(info) << "Fetching cascade models for timestamp: " << timeStampML; + + if (mlConfigurations.calculateXiMinusScores) { + bool retrieveSuccess = ccdbApi.retrieveBlob(mlConfigurations.modelPathCCDB, ".", metadata, timeStampML, false, mlConfigurations.localModelPathXiMinus.value); + if (retrieveSuccess){ + mlModelXiMinus.initModel(mlConfigurations.localModelPathXiMinus.value, mlConfigurations.enableOptimizations.value); + } else { + LOG(fatal) << "Error encountered while fetching/loading the XiMinus model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?"; + } + } + + if (mlConfigurations.calculateXiPlusScores) { + bool retrieveSuccess = ccdbApi.retrieveBlob(mlConfigurations.modelPathCCDB, ".", metadata, timeStampML, false, mlConfigurations.localModelPathXiPlus.value); + if (retrieveSuccess){ + mlModelXiPlus.initModel(mlConfigurations.localModelPathXiPlus.value, mlConfigurations.enableOptimizations.value); + } else { + LOG(fatal) << "Error encountered while fetching/loading the XiPlus model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?"; + } + } + + if (mlConfigurations.calculateOmegaMinusScores) { + bool retrieveSuccess = ccdbApi.retrieveBlob(mlConfigurations.modelPathCCDB, ".", metadata, timeStampML, false, mlConfigurations.localModelPathOmegaMinus.value); + if (retrieveSuccess){ + mlModelOmegaMinus.initModel(mlConfigurations.localModelPathOmegaMinus.value, mlConfigurations.enableOptimizations.value); + } else { + LOG(fatal) << "Error encountered while fetching/loading the OmegaMinus model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?"; + } + } + + if (mlConfigurations.calculateOmegaPlusScores) { + bool retrieveSuccess = ccdbApi.retrieveBlob(mlConfigurations.modelPathCCDB, ".", metadata, timeStampML, false, mlConfigurations.localModelPathOmegaPlus.value); + if (retrieveSuccess){ + mlModelOmegaPlus.initModel(mlConfigurations.localModelPathOmegaPlus.value, mlConfigurations.enableOptimizations.value); + } else { + LOG(fatal) << "Error encountered while fetching/loading the OmegaPlus model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?"; + } + } + } else { + if (mlConfigurations.calculateXiMinusScores) mlModelXiMinus.initModel(mlConfigurations.localModelPathXiMinus.value, mlConfigurations.enableOptimizations.value); + if (mlConfigurations.calculateXiPlusScores) mlModelXiPlus.initModel(mlConfigurations.localModelPathXiPlus.value, mlConfigurations.enableOptimizations.value); + if (mlConfigurations.calculateOmegaMinusScores) mlModelOmegaMinus.initModel(mlConfigurations.localModelPathOmegaMinus.value, mlConfigurations.enableOptimizations.value); + if (mlConfigurations.calculateOmegaPlusScores) mlModelOmegaPlus.initModel(mlConfigurations.localModelPathOmegaPlus.value, mlConfigurations.enableOptimizations.value); + } + LOG(info) << "Cascade ML Models loaded."; + } + // TrackParCov to KF converter // FIXME: could be an utility somewhere else // from Carolina Reetz (thank you!) @@ -836,7 +946,7 @@ struct cascadeBuilder { // Overall cascade charge cascadecandidate.charge = bachTrack.signed1Pt() > 0 ? +1 : -1; - if (d_doQA) { + if (qaConfigurations.d_doQA) { // produce a plot that showcases the mass of the received lambdas if (cascadecandidate.charge < 0) registry.fill(HIST("h2dLambdaMass"), v0.pt(), v0.mLambda()); @@ -916,7 +1026,7 @@ struct cascadeBuilder { cascadecandidate.pos[i] = vtx[i]; } - if (d_doQA && d_doPtDep_CosPaCut) { + if (qaConfigurations.d_doQA && d_doPtDep_CosPaCut) { bool mcUnchecked = !d_QA_checkMC; bool dEdxUnchecked = !d_QA_checkdEdx; @@ -1011,7 +1121,7 @@ struct cascadeBuilder { statisticsRegistry.bachITSclu[bachTrack.itsNCls()]++; } - if (d_doQA) { + if (qaConfigurations.d_doQA) { bool mcUnchecked = !d_QA_checkMC; bool dEdxUnchecked = !d_QA_checkdEdx; @@ -1030,22 +1140,22 @@ struct cascadeBuilder { registry.fill(HIST("MassHistograms/h2dOmegaPlusMass"), lPt, cascadecandidate.mOmega); // Fill ITS cluster maps with specific mass cuts - if (TMath::Abs(cascadecandidate.mXi - 1.322) < dQAXiMassWindow && ((cascade.isdEdxXiMinus() || dEdxUnchecked) && (cascade.isTrueXiMinus() || mcUnchecked)) && cascadecandidate.charge < 0) { + if (TMath::Abs(cascadecandidate.mXi - 1.322) < qaConfigurations.dQAXiMassWindow && ((cascade.isdEdxXiMinus() || dEdxUnchecked) && (cascade.isTrueXiMinus() || mcUnchecked)) && cascadecandidate.charge < 0) { registry.fill(HIST("h2dITSCluMap_XiMinusPositive"), static_cast(posTrack.itsClusterMap()), v0.v0radius()); registry.fill(HIST("h2dITSCluMap_XiMinusNegative"), static_cast(negTrack.itsClusterMap()), v0.v0radius()); registry.fill(HIST("h2dITSCluMap_XiMinusBachelor"), static_cast(bachTrack.itsClusterMap()), cascadecandidate.cascradius); } - if (TMath::Abs(cascadecandidate.mXi - 1.322) < dQAXiMassWindow && ((cascade.isdEdxXiPlus() || dEdxUnchecked) && (cascade.isTrueXiPlus() || mcUnchecked)) && cascadecandidate.charge > 0) { + if (TMath::Abs(cascadecandidate.mXi - 1.322) < qaConfigurations.dQAXiMassWindow && ((cascade.isdEdxXiPlus() || dEdxUnchecked) && (cascade.isTrueXiPlus() || mcUnchecked)) && cascadecandidate.charge > 0) { registry.fill(HIST("h2dITSCluMap_XiPlusPositive"), static_cast(posTrack.itsClusterMap()), v0.v0radius()); registry.fill(HIST("h2dITSCluMap_XiPlusNegative"), static_cast(negTrack.itsClusterMap()), v0.v0radius()); registry.fill(HIST("h2dITSCluMap_XiPlusBachelor"), static_cast(bachTrack.itsClusterMap()), cascadecandidate.cascradius); } - if (TMath::Abs(cascadecandidate.mOmega - 1.672) < dQAOmegaMassWindow && ((cascade.isdEdxOmegaMinus() || dEdxUnchecked) && (cascade.isTrueOmegaMinus() || mcUnchecked)) && cascadecandidate.charge < 0) { + if (TMath::Abs(cascadecandidate.mOmega - 1.672) < qaConfigurations.dQAOmegaMassWindow && ((cascade.isdEdxOmegaMinus() || dEdxUnchecked) && (cascade.isTrueOmegaMinus() || mcUnchecked)) && cascadecandidate.charge < 0) { registry.fill(HIST("h2dITSCluMap_OmegaMinusPositive"), static_cast(posTrack.itsClusterMap()), v0.v0radius()); registry.fill(HIST("h2dITSCluMap_OmegaMinusNegative"), static_cast(negTrack.itsClusterMap()), v0.v0radius()); registry.fill(HIST("h2dITSCluMap_OmegaMinusBachelor"), static_cast(bachTrack.itsClusterMap()), cascadecandidate.cascradius); } - if (TMath::Abs(cascadecandidate.mOmega - 1.672) < dQAOmegaMassWindow && ((cascade.isdEdxOmegaPlus() || dEdxUnchecked) && (cascade.isTrueOmegaPlus() || mcUnchecked)) && cascadecandidate.charge > 0) { + if (TMath::Abs(cascadecandidate.mOmega - 1.672) < qaConfigurations.dQAOmegaMassWindow && ((cascade.isdEdxOmegaPlus() || dEdxUnchecked) && (cascade.isTrueOmegaPlus() || mcUnchecked)) && cascadecandidate.charge > 0) { registry.fill(HIST("h2dITSCluMap_OmegaPlusPositive"), static_cast(posTrack.itsClusterMap()), v0.v0radius()); registry.fill(HIST("h2dITSCluMap_OmegaPlusNegative"), static_cast(negTrack.itsClusterMap()), v0.v0radius()); registry.fill(HIST("h2dITSCluMap_OmegaPlusBachelor"), static_cast(bachTrack.itsClusterMap()), cascadecandidate.cascradius); @@ -1056,6 +1166,51 @@ struct cascadeBuilder { registry.fill(HIST("h2dTopoVarCascRAP"), lPt, TMath::ACos(cascadecandidate.cosPA) * cascadecandidate.cascradius); registry.fill(HIST("h2dTopoVarCascRadius"), lPt, cascadecandidate.cascradius); } + + // calculate machine learning scores, compare against thresholds + cascadecandidate.mlXiMinusScore = -1.0f; + cascadecandidate.mlXiPlusScore = -1.0f; + cascadecandidate.mlOmegaMinusScore = -1.0f; + cascadecandidate.mlOmegaPlusScore = -1.0f; + + if (mlConfigurations.calculateXiMinusScores || + mlConfigurations.calculateXiPlusScores || + mlConfigurations.calculateOmegaMinusScores || + mlConfigurations.calculateOmegaPlusScores) + { + // machine learning is on, go for calculation of thresholds + // FIXME THIS NEEDS ADJUSTING + std::vector inputFeatures{0.0f, 0.0f, + 0.0f, 0.0f}; + + // calculate scores + if(mlConfigurations.calculateXiMinusScores){ + float* xiMinusProbability = mlModelXiMinus.evalModel(inputFeatures); + cascadecandidate.mlXiMinusScore = xiMinusProbability[1]; + } + if(mlConfigurations.calculateXiPlusScores){ + float* xiPlusProbability = mlModelXiPlus.evalModel(inputFeatures); + cascadecandidate.mlXiPlusScore = xiPlusProbability[1]; + } + if(mlConfigurations.calculateOmegaMinusScores){ + float* omegaMinusProbability = mlModelOmegaMinus.evalModel(inputFeatures); + cascadecandidate.mlOmegaMinusScore = omegaMinusProbability[1]; + } + if(mlConfigurations.calculateOmegaPlusScores){ + float* omegaPlusProbability = mlModelOmegaPlus.evalModel(inputFeatures); + cascadecandidate.mlOmegaPlusScore = omegaPlusProbability[1]; + } + + // Skip anything that doesn't fulfull any of the desired conditions + if( cascadecandidate.mlXiMinusScore < mlConfigurations.thresholdXiMinus.value && + cascadecandidate.mlXiPlusScore < mlConfigurations.thresholdXiPlus.value && + cascadecandidate.mlOmegaMinusScore < mlConfigurations.thresholdOmegaMinus.value && + cascadecandidate.mlOmegaPlusScore < mlConfigurations.thresholdOmegaPlus.value){ + return false; // skipped as uninteresting in any hypothesis considered + } + } + + // Final outcome is YES if I got here! return true; } diff --git a/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx b/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx index c0ef6a32833..2f95d0a8227 100644 --- a/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx +++ b/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx @@ -101,7 +101,6 @@ struct lambdakzeroBuilder { o2::ml::OnnxModel mlModelGamma; std::map metadata; - std::map headers; Produces v0indices; Produces v0cores; From d5d4f2cbc2c5b81daa27c2a5ff28df9a725fc868 Mon Sep 17 00:00:00 2001 From: ddobrigk Date: Fri, 12 Apr 2024 13:51:02 +0200 Subject: [PATCH 10/26] Add cascade ML selection TC --- PWGLF/TableProducer/Strangeness/CMakeLists.txt | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/PWGLF/TableProducer/Strangeness/CMakeLists.txt b/PWGLF/TableProducer/Strangeness/CMakeLists.txt index 50751d09b77..3f3ddddaa31 100644 --- a/PWGLF/TableProducer/Strangeness/CMakeLists.txt +++ b/PWGLF/TableProducer/Strangeness/CMakeLists.txt @@ -107,7 +107,12 @@ o2physics_add_dpl_workflow(v0qaanalysis # ML selection o2physics_add_dpl_workflow(lambdakzeromlselectiontreecreator SOURCES lambdakzeroMLSelectionTreeCreator.cxx - PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2Physics::MLCore + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME Analysis) + +o2physics_add_dpl_workflow(cascademlselectiontreecreator + SOURCES cascadeMLSelectionTreeCreator.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore COMPONENT_NAME Analysis) o2physics_add_dpl_workflow(lambdakzeromlselection From 24f2e86b8ffcf4ae46552fb3f7c12376342e7baf Mon Sep 17 00:00:00 2001 From: gianniliveraro Date: Fri, 12 Apr 2024 09:53:24 -0300 Subject: [PATCH 11/26] PWGLF/ML: Including ITSClSizes in feature list --- PWGLF/DataModel/LFStrangenessMLTables.h | 4 ++++ .../Strangeness/lambdakzeroMLSelectionTreeCreator.cxx | 6 +++++- 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/PWGLF/DataModel/LFStrangenessMLTables.h b/PWGLF/DataModel/LFStrangenessMLTables.h index 562f0b3d7e3..1251e3e30dd 100644 --- a/PWGLF/DataModel/LFStrangenessMLTables.h +++ b/PWGLF/DataModel/LFStrangenessMLTables.h @@ -29,6 +29,8 @@ namespace v0mlcandidates { DECLARE_SOA_COLUMN(PosITSCls, posITSCls, int); DECLARE_SOA_COLUMN(NegITSCls, negITSCls, int); +DECLARE_SOA_COLUMN(PosITSClSize, posITSClSize, int); +DECLARE_SOA_COLUMN(NegITSClSize, negITSClSize, int); DECLARE_SOA_COLUMN(PosTPCRows, posTPCRows, float); DECLARE_SOA_COLUMN(NegTPCRows, negTPCRows, float); DECLARE_SOA_COLUMN(PosTPCSigmaPi, posTPCSigmaPi, float); @@ -71,6 +73,8 @@ DECLARE_SOA_COLUMN(IsKZeroShort, isKZeroShort, bool); DECLARE_SOA_TABLE(V0MLCandidates, "AOD", "V0MLCANDIDATES", v0mlcandidates::PosITSCls, v0mlcandidates::NegITSCls, + v0mlcandidates::PosITSClSize, + v0mlcandidates::NegITSClSize, v0mlcandidates::PosTPCRows, v0mlcandidates::NegTPCRows, v0mlcandidates::PosTPCSigmaPi, diff --git a/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx b/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx index 748aea25475..c494a15f82b 100644 --- a/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx +++ b/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx @@ -125,6 +125,8 @@ struct lambdakzeroMLSelectionTreeCreator{ struct { int posITSCls; int negITSCls; + int posITSClSize; + int negITSClSize; float posTPCRows; float negTPCRows; float posTPCSigmaPi; @@ -174,6 +176,8 @@ struct lambdakzeroMLSelectionTreeCreator{ // Track quality Candidate.posITSCls = posTrackExtra.itsNCls(); Candidate.negITSCls = negTrackExtra.itsNCls(); + Candidate.posITSClSize = posTrackExtra.itsClusterSizes(); + Candidate.negITSClSize = negTrackExtra.itsClusterSizes(); Candidate.posTPCRows = posTrackExtra.tpcCrossedRows(); Candidate.negTPCRows = negTrackExtra.tpcCrossedRows(); @@ -298,7 +302,7 @@ struct lambdakzeroMLSelectionTreeCreator{ } // Filling TTree for ML analysis - v0MLCandidates(Candidate.posITSCls, Candidate.negITSCls, Candidate.posTPCRows, Candidate.negTPCRows, + v0MLCandidates(Candidate.posITSCls, Candidate.negITSCls, Candidate.posITSClSize, Candidate.negITSClSize, Candidate.posTPCRows, Candidate.negTPCRows, Candidate.posTPCSigmaPi, Candidate.negTPCSigmaPi, Candidate.posTPCSigmaPr, Candidate.negTPCSigmaPr, Candidate.posTPCSigmaEl, Candidate.negTPCSigmaEl, Candidate.TOFSigmaLaPr, Candidate.TOFSigmaLaPi, Candidate.TOFSigmaALaPi, Candidate.TOFSigmaALaPr, Candidate.TOFSigmaK0PiPlus, Candidate.TOFSigmaK0PiMinus, From fbfe3a4e3606c7999bf6ee57dbe7835dd3326165 Mon Sep 17 00:00:00 2001 From: ddobrigk Date: Fri, 12 Apr 2024 15:02:19 +0200 Subject: [PATCH 12/26] Forgot git add --- .../cascadeMLSelectionTreeCreator.cxx | 251 ++++++++++++++++++ 1 file changed, 251 insertions(+) create mode 100644 PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx diff --git a/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx b/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx new file mode 100644 index 00000000000..59f385cec8b --- /dev/null +++ b/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx @@ -0,0 +1,251 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. +// +// *+-+*+-+*+-+*+-+*+-+*+-+*+-+* +// Cascade ML Tree Creator task +// *+-+*+-+*+-+*+-+*+-+*+-+*+-+* +// +// This task loops over a set of V0 indices and +// creates a TTree for ML training and testing. +// +// Comments, questions, complaints, suggestions? +// Please write to: +// gianni.shigeru.setoue.liveraro@cern.ch +// romain.schotter@cern.ch +// david.dobrigkeit.chinellato@cern.ch +// + + +#include "Framework/runDataProcessing.h" +#include "Framework/RunningWorkflowInfo.h" +#include "Framework/AnalysisTask.h" +#include "Framework/AnalysisDataModel.h" +#include "Framework/ASoAHelpers.h" +#include "Framework/ASoA.h" +#include "ReconstructionDataFormats/Track.h" +#include "Common/Core/RecoDecay.h" +#include "Common/Core/trackUtilities.h" +#include "PWGLF/DataModel/LFStrangenessTables.h" +#include "PWGLF/DataModel/LFStrangenessPIDTables.h" +#include "PWGLF/DataModel/LFStrangenessMLTables.h" +#include "Common/Core/TrackSelection.h" +#include "Common/DataModel/TrackSelectionTables.h" +#include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/Centrality.h" +#include "Common/DataModel/PIDResponse.h" +#include "CCDB/BasicCCDBManager.h" +#include "CommonConstants/PhysicsConstants.h" +#include "Common/TableProducer/PID/pidTOFBase.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; +using std::array; +using std::cout; +using std::endl; + +using dauTracks = soa::Join; + +struct cascadeMLSelectionTreeCreator{ + //Produces cascadeMLCandidates; + HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; + + // selection switches: please, use just one at a time! + Configurable getXiMinus{"getXiMinus", false, "If True, apply cuts to select XiMinus signal and bkg candidates"}; + Configurable getXiPlus{"getXiPlus", false, "If True, apply cuts to select XiPlus signal and bkg candidates"}; + Configurable getOmegaMinus{"getOmegaMinus", false, "If True, apply cuts to select OmegaMinus signal and bkg candidates"}; + Configurable getOmegaPlus{"getOmegaPlus", false, "If True, apply cuts to select OmegaPlus signal and bkg candidates"}; + + // Master switch for selecting candidates + struct : ConfigurableGroup { + Configurable Lambdav0cospa{"Lambdav0cospa", 0.90, "min V0 CosPA"}; + Configurable Lambdadcav0dau{"Lambdadcav0dau", 1.0, "max DCA V0 Daughters (cm)"}; + Configurable Lambdadcanegtopv{"Lambdadcanegtopv", .05, "min DCA Neg To PV (cm)"}; + Configurable Lambdadcapostopv{"Lambdadcapostopv", .05, "min DCA Pos To PV (cm)"}; + Configurable Lambdav0radius{"Lambdav0radius", 1.5, "minimum V0 radius (cm)"}; + Configurable LambdaWindow{"LambdaWindow", 0.01, "Mass window around expected (in GeV/c2)"}; + } topoConfiguration; + + // Axis: + ConfigurableAxis centralityAxis{"centralityAxis", {100, 0.0f, 100.0f}, ""}; + + void init(InitContext const&) + { + histos.add("hEventCentrality", "hEventCentrality", kTH1F, {centralityAxis}); + } + + // Helper struct to pass v0 information + struct { + int charge; + + // tracking properties + int posITSCls; + int negITSCls; + int bachITSCls; + float posTPCRows; + float negTPCRows; + float bachTPCRows; + + // PID properties + float posTPCSigmaPi; + float negTPCSigmaPi; + float posTPCSigmaPr; + float negTPCSigmaPr; + float bachTPCSigmaPi; + float bachTPCSigmaKa; + float TOFNSigmaXiLaPi; + float TOFNSigmaXiLaPr; + float TOFNSigmaXiPi; + float TOFNSigmaOmLaPi; + float TOFNSigmaOmLaPr; + float TOFNSigmaOmKa; + + // Basic kine + float mXi; + float mOmega; + float yXi; + float yOmega; + float mLambdaDaughter; + float pt; + float posEta; + float negEta; + float bachEta; + + // Topological + float v0radius; + float cascradius; + float dcapostopv; + float dcanegtopv; + float dcabachtopv; + float dcaV0Daughters; + float dcaCascDaughters; + float dcav0topv; + float v0CosPA; + float cascCosPA; + + // reserved for MC operation + bool isXiMinus; + bool isXiPlus; + bool isOmegaMinus; + bool isOmegaPlus; + } cascadeCandidate; + + // Process candidate and store properties in object + template + void processCandidate(TCollision const& coll, TCascObject const& cand) + { + auto posTrackExtra = cand.template posTrackExtra_as(); + auto negTrackExtra = cand.template negTrackExtra_as(); + auto bachTrackExtra = cand.template bachTrackExtra_as(); + + cascadeCandidate.charge = cand.sign(); + cascadeCandidate.centrality = coll.centFT0C(); + + // Track quality + cascadeCandidate.posITSCls = posTrackExtra.itsNCls(); + cascadeCandidate.negITSCls = negTrackExtra.itsNCls(); + cascadeCandidate.bachITSCls = negTrackExtra.itsNCls(); + cascadeCandidate.posTPCRows = posTrackExtra.tpcCrossedRows(); + cascadeCandidate.negTPCRows = negTrackExtra.tpcCrossedRows(); + cascadeCandidate.bachTPCRows = bachTrackExtra.tpcCrossedRows(); + + // TPC PID + cascadeCandidate.posTPCSigmaPi = posTrackExtra.tpcNSigmaPi(); + cascadeCandidate.negTPCSigmaPi = negTrackExtra.tpcNSigmaPi(); + cascadeCandidate.posTPCSigmaPr = posTrackExtra.tpcNSigmaPr(); + cascadeCandidate.negTPCSigmaPr = negTrackExtra.tpcNSigmaPr(); + cascadeCandidate.bachTPCSigmaPi = bachTrackExtra.tpcNSigmaPi(); + cascadeCandidate.bachTPCSigmaKa = bachTrackExtra.tpcNSigmaKa(); + + // TOF PID + cascadeCandidate.TOFNSigmaXiLaPi = cand.tofNSigmaXiLaPi(); + cascadeCandidate.TOFNSigmaXiLaPr = cand.tofNSigmaXiLaPr(); + cascadeCandidate.TOFNSigmaXiPi = cand.tofNSigmaXiPi(); + cascadeCandidate.TOFNSigmaOmLaPi = cand.tofNSigmaOmLaPi(); + cascadeCandidate.TOFNSigmaOmLaPr = cand.tofNSigmaOmLaPr(); + cascadeCandidate.TOFNSigmaOmKa = cand.tofNSigmaOmKa(); + + // Basic Kine + cascadeCandidate.mXi = cand.mXi(); + cascadeCandidate.mOmega = cand.mOmega(); + cascadeCandidate.yXi = cand.yXi(); + cascadeCandidate.yOmega = cand.yOmega(); + cascadeCandidate.mLambdaDaughter = cand.mLambda(); + cascadeCandidate.pt = cand.pt(); + cascadeCandidate.posEta = cand.positiveeta(); + cascadeCandidate.negEta = cand.negativeeta(); + cascadeCandidate.bachEta = cand.bacheloreta(); + + // Topological + cascadeCandidate.v0radius = cand.v0radius(); + cascadeCandidate.cascradius = cand.cascradius(); + cascadeCandidate.dcapostopv = cand.dcapostopv(); + cascadeCandidate.dcanegtopv = cand.dcanegtopv(); + cascadeCandidate.dcabachtopv = cand.dcabachtopv(); + cascadeCandidate.dcaV0Daughters = cand.dcaV0daughters(); + cascadeCandidate.dcaCascDaughters = cand.dcacascdaughters(); + cascadeCandidate.dcav0topv = cand.dcav0topv(coll.posX(), coll.posY(), coll.posZ()); + cascadeCandidate.v0CosPA = cand.v0cosPA(coll.posX(), coll.posY(), coll.posZ()); + cascadeCandidate.cascCosPA = cand.casccosPA(coll.posX(), coll.posY(), coll.posZ()); + + // MC flags + cascadeCandidate.isXiMinus = false; + cascadeCandidate.isXiPlus = false; + cascadeCandidate.isOmegaMinus = false; + cascadeCandidate.isOmegaPlus = false; + + if constexpr ( requires {cand.pdgCode();} ) { + cascadeCandidate.isXiMinus = (cand.pdgCode() == 3312); + cascadeCandidate.isXiPlus = (cand.pdgCode() == -3312); + cascadeCandidate.isOmegaMinus = (cand.pdgCode() == 3334); + cascadeCandidate.isOmegaPlus = (cand.pdgCode() == -3334); + } + + // Mass window selections + + + } + + void processRealData(soa::Join const& coll, soa::Join const& cascades) + { + histos.fill(HIST("hEventCentrality"), coll.centFT0C()); + for (auto& casc: cascades){ // looping over lambdas + processCandidate(coll, casc); + } + } + void processSimData(soa::Join const& coll, soa::Join const& cascades) + { + histos.fill(HIST("hEventCentrality"), coll.centFT0C()); + for (auto& casc: cascades){ // looping over lambdas + processCandidate(coll, casc); + } + } + + PROCESS_SWITCH(cascadeMLSelectionTreeCreator, processRealData, "Produce Run 3 cascade tables (real data)", false); + PROCESS_SWITCH(cascadeMLSelectionTreeCreator, processSimData, "Produce Run 3 cascade tables (simulation)", true); +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{adaptAnalysisTask(cfgc)}; + +} \ No newline at end of file From d6390907cf9a599d8a900157f3f109ed2e37c770 Mon Sep 17 00:00:00 2001 From: ddobrigk Date: Fri, 12 Apr 2024 15:26:29 +0200 Subject: [PATCH 13/26] Modifications for cascades --- PWGLF/DataModel/LFStrangenessMLTables.h | 106 +++++++++++++++++- .../cascadeMLSelectionTreeCreator.cxx | 76 ++++++++++++- .../lambdakzeroMLSelectionTreeCreator.cxx | 2 +- 3 files changed, 177 insertions(+), 7 deletions(-) diff --git a/PWGLF/DataModel/LFStrangenessMLTables.h b/PWGLF/DataModel/LFStrangenessMLTables.h index 1251e3e30dd..01bea8f9e5e 100644 --- a/PWGLF/DataModel/LFStrangenessMLTables.h +++ b/PWGLF/DataModel/LFStrangenessMLTables.h @@ -29,8 +29,8 @@ namespace v0mlcandidates { DECLARE_SOA_COLUMN(PosITSCls, posITSCls, int); DECLARE_SOA_COLUMN(NegITSCls, negITSCls, int); -DECLARE_SOA_COLUMN(PosITSClSize, posITSClSize, int); -DECLARE_SOA_COLUMN(NegITSClSize, negITSClSize, int); +DECLARE_SOA_COLUMN(PosITSClSize, posITSClSize, uint32_t); +DECLARE_SOA_COLUMN(NegITSClSize, negITSClSize, uint32_t); DECLARE_SOA_COLUMN(PosTPCRows, posTPCRows, float); DECLARE_SOA_COLUMN(NegTPCRows, negTPCRows, float); DECLARE_SOA_COLUMN(PosTPCSigmaPi, posTPCSigmaPi, float); @@ -130,6 +130,108 @@ DECLARE_SOA_TABLE(V0AntiLambdaMLScores, "AOD", "V0ALaMLScores", V0MLSelection::AntiLambdaBDTScore); DECLARE_SOA_TABLE(V0K0ShortMLScores, "AOD", "V0K0MLScores", V0MLSelection::K0ShortBDTScore); + +// Cascade candidates +namespace cascmlcandidates +{ +DECLARE_SOA_COLUMN(Charge, charge, int); +DECLARE_SOA_COLUMN(Centrality, centrality, float); +DECLARE_SOA_COLUMN(PosITSCls, posITSCls, int); +DECLARE_SOA_COLUMN(NegITSCls, negITSCls, int); +DECLARE_SOA_COLUMN(BachITSCls, bachITSCls, int); +DECLARE_SOA_COLUMN(PosITSClSize, posITSClSize, int); +DECLARE_SOA_COLUMN(NegITSClSize, negITSClSize, int); +DECLARE_SOA_COLUMN(BachITSClSize, bachITSClSize, int); +DECLARE_SOA_COLUMN(PosTPCRows, posTPCRows, float); +DECLARE_SOA_COLUMN(NegTPCRows, negTPCRows, float); +DECLARE_SOA_COLUMN(BachTPCRows, bachTPCRows, float); +DECLARE_SOA_COLUMN(PosTPCSigmaPi, posTPCSigmaPi, float); +DECLARE_SOA_COLUMN(NegTPCSigmaPi, negTPCSigmaPi, float); +DECLARE_SOA_COLUMN(PosTPCSigmaPr, posTPCSigmaPr, float); +DECLARE_SOA_COLUMN(NegTPCSigmaPr, negTPCSigmaPr, float); +DECLARE_SOA_COLUMN(BachTPCSigmaPi, bachTPCSigmaPi, float); +DECLARE_SOA_COLUMN(BachTPCSigmaKa, bachTPCSigmaKa, float); +DECLARE_SOA_COLUMN(TOFNSigmaXiLaPi, tofNSigmaXiLaPi, float); +DECLARE_SOA_COLUMN(TOFNSigmaXiLaPr, tofNSigmaXiLaPr, float); +DECLARE_SOA_COLUMN(TOFNSigmaXiPi, tofNSigmaXiPi, float); +DECLARE_SOA_COLUMN(TOFNSigmaOmLaPi, tofNSigmaOmLaPi, float); +DECLARE_SOA_COLUMN(TOFNSigmaOmLaPr, tofNSigmaOmLaPr, float); +DECLARE_SOA_COLUMN(TOFNSigmaOmKa, tofNSigmaOmKa, float); + +DECLARE_SOA_COLUMN(MXi, mXi, float); +DECLARE_SOA_COLUMN(MOmega, mOmega, float); +DECLARE_SOA_COLUMN(YXi, yXi, float); +DECLARE_SOA_COLUMN(YOmega, yOmega, float); +DECLARE_SOA_COLUMN(MLambda, mLambda, float); +DECLARE_SOA_COLUMN(Pt, pt, float); +DECLARE_SOA_COLUMN(PosEta, posEta, float); +DECLARE_SOA_COLUMN(NegEta, negEta, float); +DECLARE_SOA_COLUMN(BachEta, bachEta, float); + +DECLARE_SOA_COLUMN(V0radius, v0radius, float); +DECLARE_SOA_COLUMN(CascRadius, cascradius, float); +DECLARE_SOA_COLUMN(DCApostopv, dcapostopv, float); +DECLARE_SOA_COLUMN(DCAnegtopv, dcanegtopv, float); +DECLARE_SOA_COLUMN(DCAbachtopv, dcabachtopv, float); +DECLARE_SOA_COLUMN(DCAV0daughters, dcaV0daughters, float); +DECLARE_SOA_COLUMN(DCACascDaughters, dcaCascDaughters, float); +DECLARE_SOA_COLUMN(DCAv0topv, dcav0topv, float); +DECLARE_SOA_COLUMN(V0PA, v0PA, float); +DECLARE_SOA_COLUMN(CascPA, cascPA, float); + +DECLARE_SOA_COLUMN(IsXiMinus, isXiMinus, bool); +DECLARE_SOA_COLUMN(IsXiPlus, isXiPlus, bool); +DECLARE_SOA_COLUMN(IsOmegaMinus, isOmegaMinus, bool); +DECLARE_SOA_COLUMN(IsOmegaPlus, isOmegaPlus, bool); +} // namespace cascmlcandidates + +DECLARE_SOA_TABLE(CascMLCandidates, "AOD", "CAMLCANDIDATES", + cascmlcandidates::Charge, + cascmlcandidates::Centrality, + cascmlcandidates::PosITSCls, + cascmlcandidates::NegITSCls, + cascmlcandidates::BachITSCls, + cascmlcandidates::PosITSClSize, + cascmlcandidates::NegITSClSize, + cascmlcandidates::BachITSClSize, + cascmlcandidates::PosTPCRows, + cascmlcandidates::NegTPCRows, + cascmlcandidates::BachTPCRows, + cascmlcandidates::PosTPCSigmaPi, + cascmlcandidates::NegTPCSigmaPi, + cascmlcandidates::PosTPCSigmaPr, + cascmlcandidates::NegTPCSigmaPr, + cascmlcandidates::BachTPCSigmaPi, + cascmlcandidates::BachTPCSigmaKa, + cascmlcandidates::TOFNSigmaXiLaPi, + cascmlcandidates::TOFNSigmaXiLaPr, + cascmlcandidates::TOFNSigmaXiPi, + cascmlcandidates::TOFNSigmaOmLaPi, + cascmlcandidates::TOFNSigmaOmLaPr, + cascmlcandidates::TOFNSigmaOmKa, + cascmlcandidates::MXi, + cascmlcandidates::MOmega, + cascmlcandidates::YXi, + cascmlcandidates::YOmega, + cascmlcandidates::MLambda, + cascmlcandidates::Pt, + cascmlcandidates::PosEta, + cascmlcandidates::NegEta, + cascmlcandidates::BachEta, + cascmlcandidates::V0radius, + cascmlcandidates::CascRadius, + cascmlcandidates::DCApostopv, + cascmlcandidates::DCAnegtopv, + cascmlcandidates::DCAbachtopv, + cascmlcandidates::DCAV0daughters, + cascmlcandidates::DCACascDaughters, + cascmlcandidates::DCAv0topv, + cascmlcandidates::V0PA, + cascmlcandidates::CascPA, + cascmlcandidates::IsXiMinus, + cascmlcandidates::IsXiPlus, + cascmlcandidates::IsOmegaMinus, + cascmlcandidates::IsOmegaPlus); } // namespace o2::aod #endif // PWGLF_DATAMODEL_LFSTRANGENESSMLTABLES_H_ \ No newline at end of file diff --git a/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx b/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx index 59f385cec8b..f8d8d32d77c 100644 --- a/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx +++ b/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx @@ -66,7 +66,7 @@ using std::endl; using dauTracks = soa::Join; struct cascadeMLSelectionTreeCreator{ - //Produces cascadeMLCandidates; + Produces cascadeMLCandidates; HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; // selection switches: please, use just one at a time! @@ -96,11 +96,15 @@ struct cascadeMLSelectionTreeCreator{ // Helper struct to pass v0 information struct { int charge; + float centrality; // tracking properties int posITSCls; int negITSCls; int bachITSCls; + uint32_t posITSClsSizes; + uint32_t negITSClsSizes; + uint32_t bachITSClsSizes; float posTPCRows; float negTPCRows; float bachTPCRows; @@ -164,6 +168,9 @@ struct cascadeMLSelectionTreeCreator{ cascadeCandidate.posITSCls = posTrackExtra.itsNCls(); cascadeCandidate.negITSCls = negTrackExtra.itsNCls(); cascadeCandidate.bachITSCls = negTrackExtra.itsNCls(); + cascadeCandidate.posITSClsSizes = posTrackExtra.itsClusterSizes(); + cascadeCandidate.negITSClsSizes = negTrackExtra.itsClusterSizes(); + cascadeCandidate.bachITSClsSizes = negTrackExtra.itsClusterSizes(); cascadeCandidate.posTPCRows = posTrackExtra.tpcCrossedRows(); cascadeCandidate.negTPCRows = negTrackExtra.tpcCrossedRows(); cascadeCandidate.bachTPCRows = bachTrackExtra.tpcCrossedRows(); @@ -222,17 +229,78 @@ struct cascadeMLSelectionTreeCreator{ // Mass window selections - + + // populate + cascadeMLCandidates( + cascadeCandidate.charge, + cascadeCandidate.centrality, + + // Track quality + cascadeCandidate.posITSCls, + cascadeCandidate.negITSCls, + cascadeCandidate.bachITSCls, + cascadeCandidate.posITSClsSizes, + cascadeCandidate.negITSClsSizes, + cascadeCandidate.bachITSClsSizes, + cascadeCandidate.posTPCRows, + cascadeCandidate.negTPCRows, + cascadeCandidate.bachTPCRows, + + // TPC PID + cascadeCandidate.posTPCSigmaPi, + cascadeCandidate.negTPCSigmaPi, + cascadeCandidate.posTPCSigmaPr, + cascadeCandidate.negTPCSigmaPr, + cascadeCandidate.bachTPCSigmaPi, + cascadeCandidate.bachTPCSigmaKa, + + // TOF PID + cascadeCandidate.TOFNSigmaXiLaPi, + cascadeCandidate.TOFNSigmaXiLaPr, + cascadeCandidate.TOFNSigmaXiPi, + cascadeCandidate.TOFNSigmaOmLaPi, + cascadeCandidate.TOFNSigmaOmLaPr, + cascadeCandidate.TOFNSigmaOmKa, + + // Basic Kine + cascadeCandidate.mXi, + cascadeCandidate.mOmega, + cascadeCandidate.yXi, + cascadeCandidate.yOmega, + cascadeCandidate.mLambdaDaughter, + cascadeCandidate.pt, + cascadeCandidate.posEta, + cascadeCandidate.negEta, + cascadeCandidate.bachEta, + + // Topological + cascadeCandidate.v0radius, + cascadeCandidate.cascradius, + cascadeCandidate.dcapostopv, + cascadeCandidate.dcanegtopv, + cascadeCandidate.dcabachtopv, + cascadeCandidate.dcaV0Daughters, + cascadeCandidate.dcaCascDaughters, + cascadeCandidate.dcav0topv, + cascadeCandidate.v0CosPA, + cascadeCandidate.cascCosPA, + + // MC identity + cascadeCandidate.isXiMinus, + cascadeCandidate.isXiPlus, + cascadeCandidate.isOmegaMinus, + cascadeCandidate.isOmegaPlus + ); } - void processRealData(soa::Join const& coll, soa::Join const& cascades) + void processRealData(soa::Join::iterator const& coll, soa::Join const& cascades, dauTracks const&) { histos.fill(HIST("hEventCentrality"), coll.centFT0C()); for (auto& casc: cascades){ // looping over lambdas processCandidate(coll, casc); } } - void processSimData(soa::Join const& coll, soa::Join const& cascades) + void processSimData(soa::Join::iterator const& coll, soa::Join const& cascades, dauTracks const&) { histos.fill(HIST("hEventCentrality"), coll.centFT0C()); for (auto& casc: cascades){ // looping over lambdas diff --git a/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx b/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx index c494a15f82b..2d23a31bd7b 100644 --- a/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx +++ b/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx @@ -275,7 +275,7 @@ struct lambdakzeroMLSelectionTreeCreator{ return processCandidate(kzero); } - void process(aod::StraCollision const& coll, soa::Join const& v0s) + void process(aod::StraCollision const& coll, soa::Join const& v0s, dauTracks const&) { histos.fill(HIST("hEventVertexZMC"), coll.posZ()); for (auto& cand: v0s){ // looping over lambdas From d4f459680e28e8a4ec0865b952ae6b7d4de58d6f Mon Sep 17 00:00:00 2001 From: ddobrigk Date: Fri, 12 Apr 2024 15:33:15 +0200 Subject: [PATCH 14/26] Add mass window conformity map --- PWGLF/DataModel/LFStrangenessMLTables.h | 2 + .../cascadeMLSelectionTreeCreator.cxx | 114 +++++++++--------- 2 files changed, 60 insertions(+), 56 deletions(-) diff --git a/PWGLF/DataModel/LFStrangenessMLTables.h b/PWGLF/DataModel/LFStrangenessMLTables.h index 01bea8f9e5e..697e2a78fb0 100644 --- a/PWGLF/DataModel/LFStrangenessMLTables.h +++ b/PWGLF/DataModel/LFStrangenessMLTables.h @@ -134,6 +134,7 @@ DECLARE_SOA_TABLE(V0K0ShortMLScores, "AOD", "V0K0MLScores", // Cascade candidates namespace cascmlcandidates { +DECLARE_SOA_COLUMN(MassWindows, massWindows, uint8_t); DECLARE_SOA_COLUMN(Charge, charge, int); DECLARE_SOA_COLUMN(Centrality, centrality, float); DECLARE_SOA_COLUMN(PosITSCls, posITSCls, int); @@ -186,6 +187,7 @@ DECLARE_SOA_COLUMN(IsOmegaPlus, isOmegaPlus, bool); } // namespace cascmlcandidates DECLARE_SOA_TABLE(CascMLCandidates, "AOD", "CAMLCANDIDATES", + cascmlcandidates::MassWindows, cascmlcandidates::Charge, cascmlcandidates::Centrality, cascmlcandidates::PosITSCls, diff --git a/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx b/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx index f8d8d32d77c..3b05b4940c2 100644 --- a/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx +++ b/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx @@ -95,62 +95,63 @@ struct cascadeMLSelectionTreeCreator{ // Helper struct to pass v0 information struct { - int charge; - float centrality; - - // tracking properties - int posITSCls; - int negITSCls; - int bachITSCls; - uint32_t posITSClsSizes; - uint32_t negITSClsSizes; - uint32_t bachITSClsSizes; - float posTPCRows; - float negTPCRows; - float bachTPCRows; - - // PID properties - float posTPCSigmaPi; - float negTPCSigmaPi; - float posTPCSigmaPr; - float negTPCSigmaPr; - float bachTPCSigmaPi; - float bachTPCSigmaKa; - float TOFNSigmaXiLaPi; - float TOFNSigmaXiLaPr; - float TOFNSigmaXiPi; - float TOFNSigmaOmLaPi; - float TOFNSigmaOmLaPr; - float TOFNSigmaOmKa; - - // Basic kine - float mXi; - float mOmega; - float yXi; - float yOmega; - float mLambdaDaughter; - float pt; - float posEta; - float negEta; - float bachEta; - - // Topological - float v0radius; - float cascradius; - float dcapostopv; - float dcanegtopv; - float dcabachtopv; - float dcaV0Daughters; - float dcaCascDaughters; - float dcav0topv; - float v0CosPA; - float cascCosPA; - - // reserved for MC operation - bool isXiMinus; - bool isXiPlus; - bool isOmegaMinus; - bool isOmegaPlus; + uint8_t massWindows; + int charge; + float centrality; + + // tracking properties + int posITSCls; + int negITSCls; + int bachITSCls; + uint32_t posITSClsSizes; + uint32_t negITSClsSizes; + uint32_t bachITSClsSizes; + float posTPCRows; + float negTPCRows; + float bachTPCRows; + + // PID properties + float posTPCSigmaPi; + float negTPCSigmaPi; + float posTPCSigmaPr; + float negTPCSigmaPr; + float bachTPCSigmaPi; + float bachTPCSigmaKa; + float TOFNSigmaXiLaPi; + float TOFNSigmaXiLaPr; + float TOFNSigmaXiPi; + float TOFNSigmaOmLaPi; + float TOFNSigmaOmLaPr; + float TOFNSigmaOmKa; + + // Basic kine + float mXi; + float mOmega; + float yXi; + float yOmega; + float mLambdaDaughter; + float pt; + float posEta; + float negEta; + float bachEta; + + // Topological + float v0radius; + float cascradius; + float dcapostopv; + float dcanegtopv; + float dcabachtopv; + float dcaV0Daughters; + float dcaCascDaughters; + float dcav0topv; + float v0CosPA; + float cascCosPA; + + // reserved for MC operation + bool isXiMinus; + bool isXiPlus; + bool isOmegaMinus; + bool isOmegaPlus; } cascadeCandidate; // Process candidate and store properties in object @@ -232,6 +233,7 @@ struct cascadeMLSelectionTreeCreator{ // populate cascadeMLCandidates( + cascadeCandidate.massWindows, cascadeCandidate.charge, cascadeCandidate.centrality, From 016f8ffe166b2c22ac94e9c2d365312f6787f8d6 Mon Sep 17 00:00:00 2001 From: gianniliveraro Date: Fri, 12 Apr 2024 11:48:58 -0300 Subject: [PATCH 15/26] PWGLF/ML: Major adjustment in TC --- PWGLF/DataModel/LFStrangenessMLTables.h | 4 + .../lambdakzeroMLSelectionTreeCreator.cxx | 164 ++++++++---------- 2 files changed, 72 insertions(+), 96 deletions(-) diff --git a/PWGLF/DataModel/LFStrangenessMLTables.h b/PWGLF/DataModel/LFStrangenessMLTables.h index 697e2a78fb0..7facaa49b75 100644 --- a/PWGLF/DataModel/LFStrangenessMLTables.h +++ b/PWGLF/DataModel/LFStrangenessMLTables.h @@ -64,6 +64,8 @@ DECLARE_SOA_COLUMN(DCAV0daughters, dcaV0daughters, float); DECLARE_SOA_COLUMN(DCAv0topv, dcav0topv, float); DECLARE_SOA_COLUMN(PsiPair, psiPair, float); DECLARE_SOA_COLUMN(V0type, v0type, uint8_t); +DECLARE_SOA_COLUMN(Centrality, centrality, float); +DECLARE_SOA_COLUMN(SelHypothesis, selHypothesis, uint8_t); DECLARE_SOA_COLUMN(IsLambda, isLambda, bool); DECLARE_SOA_COLUMN(IsAntiLambda, isAntiLambda, bool); DECLARE_SOA_COLUMN(IsGamma, isGamma, bool); @@ -108,6 +110,8 @@ DECLARE_SOA_TABLE(V0MLCandidates, "AOD", "V0MLCANDIDATES", v0mlcandidates::DCAv0topv, v0mlcandidates::PsiPair, v0mlcandidates::V0type, + v0mlcandidates::Centrality, + v0mlcandidates::SelHypothesis, v0mlcandidates::IsLambda, v0mlcandidates::IsAntiLambda, v0mlcandidates::IsGamma, diff --git a/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx b/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx index 2d23a31bd7b..4d3695c6532 100644 --- a/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx +++ b/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx @@ -69,14 +69,7 @@ using dauTracks = soa::Join; struct lambdakzeroMLSelectionTreeCreator{ Produces v0MLCandidates; HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; - - // selection switches: please, use just one at a time! - Configurable fGetAllCandidates{"fGetAllCandidates", true, "If True, create a Tree containing all available candidates"}; - Configurable fGetLambdaOnly{"fGetLambdaOnly", false, "If True, apply cuts to select only lambda signal and bkg candidates"}; - Configurable fGetAntiLambdaOnly{"fGetAntiLambdaOnly", false, "If True, apply cuts to select only antilambda signal and bkg candidates"}; - Configurable fGetGammaOnly{"fGetGammaOnly", false, "If True, apply cuts to select only Gamma signal and bkg candidates"}; - Configurable fGetK0ShortOnly{"fGetK0ShortOnly", false, "If True, apply cuts to select only K0Short signal and bkg candidates"}; - + // Base selection criteria // Lambda standard criteria:: @@ -114,19 +107,19 @@ struct lambdakzeroMLSelectionTreeCreator{ Configurable K0ShortWindow{"K0ShortWindow", 0.01, "Mass window around expected (in GeV/c2)"}; // Axis: - ConfigurableAxis vertexZ{"vertexZ", {30, -15.0f, 15.0f}, ""}; + ConfigurableAxis centralityAxis{"centralityAxis", {100, 0.0f, 100.0f}, ""}; void init(InitContext const&) { - histos.add("hEventVertexZMC", "hEventVertexZMC", kTH1F, {vertexZ}); + histos.add("hEventCentrality", "hEventCentrality", kTH1F, {centralityAxis}); } // Helper struct to pass v0 information struct { int posITSCls; int negITSCls; - int posITSClSize; - int negITSClSize; + uint32_t posITSClSize; + uint32_t negITSClSize; float posTPCRows; float negTPCRows; float posTPCSigmaPi; @@ -160,6 +153,8 @@ struct lambdakzeroMLSelectionTreeCreator{ float dcav0topv; float PsiPair; uint8_t v0type; + float centrality; + uint8_t SelHypothesis; bool isLambda; bool isAntiLambda; bool isGamma; @@ -167,9 +162,14 @@ struct lambdakzeroMLSelectionTreeCreator{ } Candidate; // Process candidate and store properties in object - template - bool processCandidate(TV0Object const& cand) - { + template + void processCandidate(TCollision const& coll, TV0Object const& cand) + { + bool lConsistentWithLambda = true; + bool lConsistentWithAntiLambda = true; + bool lConsistentWithGamma = true; + bool lConsistentWithK0Short = true; + auto posTrackExtra = cand.template posTrackExtra_as(); auto negTrackExtra = cand.template negTrackExtra_as(); @@ -219,89 +219,44 @@ struct lambdakzeroMLSelectionTreeCreator{ Candidate.dcav0topv = cand.dcav0topv(); Candidate.PsiPair = cand.psipair(); - // Debug + // Debug/Aditional Candidate.v0type = cand.v0Type(); + Candidate.centrality = coll.centFT0C(); + + // Applying selections and saving hypothesis + if ((std::abs(cand.mLambda() - 1.115683) > LambdaWindow) || (cand.v0radius() < Lambdav0radius) || ( cand.v0cosPA() < Lambdav0cospa) || (TMath::Abs(cand.dcapostopv()) < Lambdadcapostopv) || (TMath::Abs(cand.dcanegtopv()) < Lambdadcanegtopv) || ( cand.dcaV0daughters() > Lambdadcav0dau)) + lConsistentWithLambda = false; + if ((std::abs(cand.mAntiLambda() - 1.115683) > AntiLambdaWindow) || (cand.v0radius() < AntiLambdav0radius) || (cand.v0cosPA() < AntiLambdav0cospa) || (TMath::Abs(cand.dcapostopv()) < AntiLambdadcapostopv) || (TMath::Abs(cand.dcanegtopv()) < AntiLambdadcanegtopv) || (cand.dcaV0daughters() > AntiLambdadcav0dau)) + lConsistentWithAntiLambda = false; + if ((std::abs(cand.mGamma()) > PhotonWindow) || (cand.mGamma() > PhotonMaxMass) || (cand.v0radius() < PhotonMinRadius) || (cand.v0radius() > PhotonMaxRadius) || (cand.pt() < PhotonMinPt) || (cand.qtarm() > PhotonMaxqt) || (TMath::Abs(cand.alpha()) > PhotonMaxalpha)) + lConsistentWithGamma = false; + if ((std::abs(cand.mK0Short() - 0.497) > K0ShortWindow) || (cand.v0radius() < K0Shortv0radius) || (cand.v0cosPA() < K0Shortv0cospa) || (TMath::Abs(cand.dcapostopv()) < K0Shortdcapostopv) || (TMath::Abs(cand.dcanegtopv()) < K0Shortdcanegtopv) || (cand.dcaV0daughters() > K0Shortdcav0dau)) + lConsistentWithK0Short = false; + + Candidate.SelHypothesis = lConsistentWithLambda << 0 | lConsistentWithAntiLambda << 1 | lConsistentWithGamma << 2 | lConsistentWithK0Short << 3; + // 1: Consistent with Lambda only, 2: Consistent with Anti-Lambda only + // 3: Consistent with Lambda and Anti-Lambda, 4: Consistent with Gamma only + // 5: Consistent with Lambda and Gamma, 6: Consistent with Anti-Lambda and Gamma + // 7: Consistent with Lambda, Anti-Lambda, and Gamma, 8: Consistent with K0Short only + // 9: Consistent with Lambda and K0Short, 10: Consistent with Anti-Lambda and K0Short + // 11: Consistent with Lambda, Anti-Lambda, and K0Short, 12: Consistent with Gamma and K0Short + // 13: Consistent with Lambda, Gamma, and K0Short, 14: Consistent with Anti-Lambda, Gamma, and K0Short + // 15: Consistent with Lambda, Anti-Lambda, Gamma, and K0Short // MC flags - Candidate.isLambda = (cand.pdgCode()==3122); - Candidate.isAntiLambda = (cand.pdgCode()==-3122); - Candidate.isGamma = (cand.pdgCode()==22); - Candidate.isKZeroShort = (cand.pdgCode()==310); - - return true; - } - - // Process lambda candidate - template - bool processLambdaCandidate(TV0Object const& lambda) - { - // FIXME: there are smarter ways to perform this selection - // Lambda base selection criteria: - if ((std::abs(lambda.mLambda() - 1.115683) > LambdaWindow) || (lambda.v0radius() < Lambdav0radius) || ( lambda.v0cosPA() < Lambdav0cospa) || (TMath::Abs(lambda.dcapostopv()) < Lambdadcapostopv) || (TMath::Abs(lambda.dcanegtopv()) < Lambdadcanegtopv) || ( lambda.dcaV0daughters() > Lambdadcav0dau)) - return false; - return processCandidate(lambda); - } - - // Process antilambda candidate - template - bool processAntiLambdaCandidate(TV0Object const& antilambda) - { - // FIXME: there are smarter ways to perform this selection - // AntiLambda base selection criteria: - if ((std::abs(antilambda.mAntiLambda() - 1.115683) > AntiLambdaWindow) || (antilambda.v0radius() < AntiLambdav0radius) || (antilambda.v0cosPA() < AntiLambdav0cospa) || (TMath::Abs(antilambda.dcapostopv()) < AntiLambdadcapostopv) || (TMath::Abs(antilambda.dcanegtopv()) < AntiLambdadcanegtopv) || (antilambda.dcaV0daughters() > AntiLambdadcav0dau)) - return false; - return processCandidate(antilambda); - } - - // Process gamma candidate - template - bool processGammaCandidate(TV0Object const& gamma) - { - // FIXME: there are smarter ways to perform this selection - // Gamma selection criteria: - if ((std::abs(gamma.mGamma()) > PhotonWindow) || (gamma.mGamma() > PhotonMaxMass) || (gamma.v0radius() < PhotonMinRadius) || (gamma.v0radius() > PhotonMaxRadius) || (gamma.pt() < PhotonMinPt) || (gamma.qtarm() > PhotonMaxqt) || (TMath::Abs(gamma.alpha()) > PhotonMaxalpha)) - return false; - return processCandidate(gamma); - } - - // Process k0short candidate - template - bool processK0ShortCandidate(TV0Object const& kzero) - { - // FIXME: there are smarter ways to perform this selection - // TODO: Update KZeroShort selection criteria - if ((std::abs(kzero.mK0Short() - 0.497) > K0ShortWindow) || (kzero.v0radius() < K0Shortv0radius) || (kzero.v0cosPA() < K0Shortv0cospa) || (TMath::Abs(kzero.dcapostopv()) < K0Shortdcapostopv) || (TMath::Abs(kzero.dcanegtopv()) < K0Shortdcanegtopv) || (kzero.dcaV0daughters() > K0Shortdcav0dau)) - return false; - return processCandidate(kzero); - } - - void process(aod::StraCollision const& coll, soa::Join const& v0s, dauTracks const&) - { - histos.fill(HIST("hEventVertexZMC"), coll.posZ()); - for (auto& cand: v0s){ // looping over lambdas - - if(fGetLambdaOnly){ - if (!processLambdaCandidate(cand)) - continue; - } - if(fGetAntiLambdaOnly){ - if (!processAntiLambdaCandidate(cand)) - continue; - } - if(fGetGammaOnly){ - if (!processGammaCandidate(cand)) - continue; - } - if(fGetK0ShortOnly){ - if(!processK0ShortCandidate(cand)) - continue; - } - if(fGetAllCandidates) { - if(!processCandidate(cand)) - continue; - } + Candidate.isLambda = false; + Candidate.isAntiLambda = false; + Candidate.isGamma = false; + Candidate.isKZeroShort = false; + + if constexpr ( requires {cand.pdgCode();} ) { + Candidate.isLambda = (cand.pdgCode()==3122); + Candidate.isAntiLambda = (cand.pdgCode()==-3122); + Candidate.isGamma = (cand.pdgCode()==22); + Candidate.isKZeroShort = (cand.pdgCode()==310); + } - // Filling TTree for ML analysis + // Filling TTree for ML analysis v0MLCandidates(Candidate.posITSCls, Candidate.negITSCls, Candidate.posITSClSize, Candidate.negITSClSize, Candidate.posTPCRows, Candidate.negTPCRows, Candidate.posTPCSigmaPi, Candidate.negTPCSigmaPi, Candidate.posTPCSigmaPr, Candidate.negTPCSigmaPr, Candidate.posTPCSigmaEl, Candidate.negTPCSigmaEl, Candidate.TOFSigmaLaPr, Candidate.TOFSigmaLaPi, @@ -309,10 +264,27 @@ struct lambdakzeroMLSelectionTreeCreator{ Candidate.LambdaMass, Candidate.AntiLambdaMass, Candidate.GammaMass, Candidate.KZeroShortMass, Candidate.pT, Candidate.qt, Candidate.alpha, Candidate.posEta, Candidate.negEta, Candidate.v0Eta, Candidate.Z, Candidate.v0radius, Candidate.PA, Candidate.dcapostopv, Candidate.dcanegtopv, Candidate.dcaV0daughters, Candidate.dcav0topv, Candidate.PsiPair, - Candidate.v0type, Candidate.isLambda, Candidate.isAntiLambda, Candidate.isGamma, Candidate.isKZeroShort); + Candidate.v0type, Candidate.centrality, Candidate.SelHypothesis, Candidate.isLambda, Candidate.isAntiLambda, Candidate.isGamma, Candidate.isKZeroShort); + } + + void processRealData(soa::Join::iterator const& coll, soa::Join const& v0s, dauTracks const&) + { + histos.fill(HIST("hEventCentrality"), coll.centFT0C()); + for (auto& cand: v0s){ // looping over lambdas + processCandidate(coll, cand); + } + } + + void processSimData(soa::Join::iterator const& coll, soa::Join const& v0s, dauTracks const&) + { + histos.fill(HIST("hEventCentrality"), coll.centFT0C()); + for (auto& cand: v0s){ // looping over lambdas + processCandidate(coll, cand); + } } -} + PROCESS_SWITCH(lambdakzeroMLSelectionTreeCreator, processRealData, "Produce Run 3 v0 tables (real data)", false); + PROCESS_SWITCH(lambdakzeroMLSelectionTreeCreator, processSimData, "Produce Run 3 v0 tables (simulation)", true); }; From 5f2ac6af8fcb60e2fae8e2d88c9af6d3efc862db Mon Sep 17 00:00:00 2001 From: ddobrigk Date: Fri, 12 Apr 2024 20:33:58 +0200 Subject: [PATCH 16/26] Add mass windows --- .../Strangeness/cascadeMLSelectionTreeCreator.cxx | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx b/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx index 3b05b4940c2..1a26fdc12a5 100644 --- a/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx +++ b/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx @@ -75,6 +75,9 @@ struct cascadeMLSelectionTreeCreator{ Configurable getOmegaMinus{"getOmegaMinus", false, "If True, apply cuts to select OmegaMinus signal and bkg candidates"}; Configurable getOmegaPlus{"getOmegaPlus", false, "If True, apply cuts to select OmegaPlus signal and bkg candidates"}; + Configurable xiMassWindow{"xiMassWindow", 0.060, "Xi Mass Window around mass peak to consider (+/-, in GeV/c^2)"}; + Configurable omegaMassWindow{"omegaMassWindow", 0.060, "Omega Mass Window around mass peak to consider (+/-, in GeV/c^2)"}; + // Master switch for selecting candidates struct : ConfigurableGroup { Configurable Lambdav0cospa{"Lambdav0cospa", 0.90, "min V0 CosPA"}; @@ -229,7 +232,16 @@ struct cascadeMLSelectionTreeCreator{ } // Mass window selections - + cascadeCandidate.massWindows = 0; + if(std::abs(cascadeCandidate.mXi-1.322) < xiMassWindow) { + cascadeCandidate.massWindows = cascadeCandidate.massWindows | 1 << 0 ; + } + if(std::abs(cascadeCandidate.mOmega-1.6725) < omegaMassWindow) { + cascadeCandidate.massWindows = cascadeCandidate.massWindows | 1 << 1 ; + } + if(cascadeCandidate.massWindows == 0){ + return; // skip + } // populate cascadeMLCandidates( From 2ff598363d971490335570a41ff89618831c997c Mon Sep 17 00:00:00 2001 From: ddobrigk Date: Fri, 12 Apr 2024 20:43:06 +0200 Subject: [PATCH 17/26] Changes in pre-selections --- .../cascadeMLSelectionTreeCreator.cxx | 51 +++++++++++++++---- 1 file changed, 40 insertions(+), 11 deletions(-) diff --git a/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx b/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx index 1a26fdc12a5..0a184984011 100644 --- a/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx +++ b/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx @@ -78,15 +78,20 @@ struct cascadeMLSelectionTreeCreator{ Configurable xiMassWindow{"xiMassWindow", 0.060, "Xi Mass Window around mass peak to consider (+/-, in GeV/c^2)"}; Configurable omegaMassWindow{"omegaMassWindow", 0.060, "Omega Mass Window around mass peak to consider (+/-, in GeV/c^2)"}; - // Master switch for selecting candidates - struct : ConfigurableGroup { - Configurable Lambdav0cospa{"Lambdav0cospa", 0.90, "min V0 CosPA"}; - Configurable Lambdadcav0dau{"Lambdadcav0dau", 1.0, "max DCA V0 Daughters (cm)"}; - Configurable Lambdadcanegtopv{"Lambdadcanegtopv", .05, "min DCA Neg To PV (cm)"}; - Configurable Lambdadcapostopv{"Lambdadcapostopv", .05, "min DCA Pos To PV (cm)"}; - Configurable Lambdav0radius{"Lambdav0radius", 1.5, "minimum V0 radius (cm)"}; - Configurable LambdaWindow{"LambdaWindow", 0.01, "Mass window around expected (in GeV/c2)"}; - } topoConfiguration; + //*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+* + // Selection criteria - compatible with core wagon autodetect + Configurable v0setting_cospa{"v0setting_cospa", 0.95, "v0setting_cospa"}; + Configurable v0setting_dcav0dau{"v0setting_dcav0dau", 1.0, "v0setting_dcav0dau"}; + Configurable v0setting_dcapostopv{"v0setting_dcapostopv", 0.1, "v0setting_dcapostopv"}; + Configurable v0setting_dcanegtopv{"v0setting_dcanegtopv", 0.1, "v0setting_dcanegtopv"}; + Configurable v0setting_radius{"v0setting_radius", 0.9, "v0setting_radius"}; + Configurable cascadesetting_cospa{"cascadesetting_cospa", 0.95, "cascadesetting_cospa"}; + Configurable cascadesetting_dcacascdau{"cascadesetting_dcacascdau", 1.0, "cascadesetting_dcacascdau"}; + Configurable cascadesetting_dcabachtopv{"cascadesetting_dcabachtopv", 0.1, "cascadesetting_dcabachtopv"}; + Configurable cascadesetting_cascradius{"cascadesetting_cascradius", 0.5, "cascadesetting_cascradius"}; + Configurable cascadesetting_v0masswindow{"cascadesetting_v0masswindow", 0.01, "cascadesetting_v0masswindow"}; + Configurable cascadesetting_mindcav0topv{"cascadesetting_mindcav0topv", 0.01, "cascadesetting_mindcav0topv"}; + //*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+* // Axis: ConfigurableAxis centralityAxis{"centralityAxis", {100, 0.0f, 100.0f}, ""}; @@ -231,6 +236,30 @@ struct cascadeMLSelectionTreeCreator{ cascadeCandidate.isOmegaPlus = (cand.pdgCode() == -3334); } + // base topological selections + if( cascadeCandidate.v0CosPA < v0setting_cospa ) + return; + if( cascadeCandidate.dcaV0Daughters > v0setting_dcav0dau ) + return; + if( cascadeCandidate.dcapostopv < v0setting_dcapostopv ) + return; + if( cascadeCandidate.dcapostopv < v0setting_dcanegtopv ) + return; + if( cascadeCandidate.dcabachtopv < cascadesetting_dcabachtopv ) + return; + if( cascadeCandidate.v0radius < v0setting_radius ) + return; + if( cascadeCandidate.cascCosPA < cascadesetting_cospa ) + return; + if( cascadeCandidate.dcaCascDaughters > cascadesetting_dcacascdau ) + return; + if( cascadeCandidate.cascradius < cascadesetting_cascradius ) + return; + if( std::abs(cascadeCandidate.mLambdaDaughter-1.116) > cascadesetting_v0masswindow ) + return; + if( cascadeCandidate.dcav0topv < cascadesetting_mindcav0topv ) + return; + // Mass window selections cascadeCandidate.massWindows = 0; if(std::abs(cascadeCandidate.mXi-1.322) < xiMassWindow) { @@ -296,8 +325,8 @@ struct cascadeMLSelectionTreeCreator{ cascadeCandidate.dcaV0Daughters, cascadeCandidate.dcaCascDaughters, cascadeCandidate.dcav0topv, - cascadeCandidate.v0CosPA, - cascadeCandidate.cascCosPA, + TMath::ACos(cascadeCandidate.v0CosPA), + TMath::ACos(cascadeCandidate.cascCosPA), // MC identity cascadeCandidate.isXiMinus, From 38747440b5b90137121f3a9144bc5d4311976f3c Mon Sep 17 00:00:00 2001 From: ddobrigk Date: Fri, 12 Apr 2024 20:44:08 +0200 Subject: [PATCH 18/26] Open defaults --- .../Strangeness/cascadeMLSelectionTreeCreator.cxx | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx b/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx index 0a184984011..5c38c257adc 100644 --- a/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx +++ b/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx @@ -80,17 +80,17 @@ struct cascadeMLSelectionTreeCreator{ //*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+* // Selection criteria - compatible with core wagon autodetect - Configurable v0setting_cospa{"v0setting_cospa", 0.95, "v0setting_cospa"}; + Configurable v0setting_cospa{"v0setting_cospa", 0.9, "v0setting_cospa"}; Configurable v0setting_dcav0dau{"v0setting_dcav0dau", 1.0, "v0setting_dcav0dau"}; - Configurable v0setting_dcapostopv{"v0setting_dcapostopv", 0.1, "v0setting_dcapostopv"}; - Configurable v0setting_dcanegtopv{"v0setting_dcanegtopv", 0.1, "v0setting_dcanegtopv"}; + Configurable v0setting_dcapostopv{"v0setting_dcapostopv", 0.05, "v0setting_dcapostopv"}; + Configurable v0setting_dcanegtopv{"v0setting_dcanegtopv", 0.05, "v0setting_dcanegtopv"}; Configurable v0setting_radius{"v0setting_radius", 0.9, "v0setting_radius"}; - Configurable cascadesetting_cospa{"cascadesetting_cospa", 0.95, "cascadesetting_cospa"}; + Configurable cascadesetting_cospa{"cascadesetting_cospa", 0.9, "cascadesetting_cospa"}; Configurable cascadesetting_dcacascdau{"cascadesetting_dcacascdau", 1.0, "cascadesetting_dcacascdau"}; - Configurable cascadesetting_dcabachtopv{"cascadesetting_dcabachtopv", 0.1, "cascadesetting_dcabachtopv"}; + Configurable cascadesetting_dcabachtopv{"cascadesetting_dcabachtopv", 0.05, "cascadesetting_dcabachtopv"}; Configurable cascadesetting_cascradius{"cascadesetting_cascradius", 0.5, "cascadesetting_cascradius"}; Configurable cascadesetting_v0masswindow{"cascadesetting_v0masswindow", 0.01, "cascadesetting_v0masswindow"}; - Configurable cascadesetting_mindcav0topv{"cascadesetting_mindcav0topv", 0.01, "cascadesetting_mindcav0topv"}; + Configurable cascadesetting_mindcav0topv{"cascadesetting_mindcav0topv", 0.005, "cascadesetting_mindcav0topv"}; //*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+* // Axis: From 23c7ca7d3f8cf722492cd29d6bc2c4828356917f Mon Sep 17 00:00:00 2001 From: ddobrigk Date: Fri, 12 Apr 2024 20:44:39 +0200 Subject: [PATCH 19/26] Open defaults --- .../Strangeness/cascadeMLSelectionTreeCreator.cxx | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx b/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx index 5c38c257adc..a73a6220516 100644 --- a/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx +++ b/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx @@ -81,16 +81,16 @@ struct cascadeMLSelectionTreeCreator{ //*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+* // Selection criteria - compatible with core wagon autodetect Configurable v0setting_cospa{"v0setting_cospa", 0.9, "v0setting_cospa"}; - Configurable v0setting_dcav0dau{"v0setting_dcav0dau", 1.0, "v0setting_dcav0dau"}; + Configurable v0setting_dcav0dau{"v0setting_dcav0dau", 2.0, "v0setting_dcav0dau"}; Configurable v0setting_dcapostopv{"v0setting_dcapostopv", 0.05, "v0setting_dcapostopv"}; Configurable v0setting_dcanegtopv{"v0setting_dcanegtopv", 0.05, "v0setting_dcanegtopv"}; Configurable v0setting_radius{"v0setting_radius", 0.9, "v0setting_radius"}; Configurable cascadesetting_cospa{"cascadesetting_cospa", 0.9, "cascadesetting_cospa"}; - Configurable cascadesetting_dcacascdau{"cascadesetting_dcacascdau", 1.0, "cascadesetting_dcacascdau"}; + Configurable cascadesetting_dcacascdau{"cascadesetting_dcacascdau", 2.0, "cascadesetting_dcacascdau"}; Configurable cascadesetting_dcabachtopv{"cascadesetting_dcabachtopv", 0.05, "cascadesetting_dcabachtopv"}; Configurable cascadesetting_cascradius{"cascadesetting_cascradius", 0.5, "cascadesetting_cascradius"}; - Configurable cascadesetting_v0masswindow{"cascadesetting_v0masswindow", 0.01, "cascadesetting_v0masswindow"}; - Configurable cascadesetting_mindcav0topv{"cascadesetting_mindcav0topv", 0.005, "cascadesetting_mindcav0topv"}; + Configurable cascadesetting_v0masswindow{"cascadesetting_v0masswindow", 0.02, "cascadesetting_v0masswindow"}; + Configurable cascadesetting_mindcav0topv{"cascadesetting_mindcav0topv", 0.0, "cascadesetting_mindcav0topv"}; //*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+* // Axis: From 767466c800e4606d6827a536e270ea6d5ef52c47 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Fri, 12 Apr 2024 18:55:45 +0000 Subject: [PATCH 20/26] Please consider the following formatting changes --- PWGLF/DataModel/LFSigmaTables.h | 61 +++-- PWGLF/DataModel/LFStrangenessMLTables.h | 194 ++++++++------- .../cascadeMLSelectionTreeCreator.cxx | 85 ++++--- .../Strangeness/cascadebuilder.cxx | 93 ++++---- .../lambdakzeroMLSelectionTreeCreator.cxx | 221 +++++++++--------- .../Strangeness/lambdakzerobuilder.cxx | 122 +++++----- .../Strangeness/lambdakzeromlselection.cxx | 81 ++++--- .../Strangeness/sigma0builder.cxx | 73 +++--- PWGLF/Tasks/Strangeness/sigmaanalysis.cxx | 135 +++++------ 9 files changed, 541 insertions(+), 524 deletions(-) diff --git a/PWGLF/DataModel/LFSigmaTables.h b/PWGLF/DataModel/LFSigmaTables.h index e0ec85f6ec0..dc901000cee 100644 --- a/PWGLF/DataModel/LFSigmaTables.h +++ b/PWGLF/DataModel/LFSigmaTables.h @@ -21,9 +21,8 @@ using namespace o2; using namespace o2::framework; - // Creating output TTree for sigma analysis -namespace o2::aod +namespace o2::aod { // for real data @@ -58,43 +57,43 @@ DECLARE_SOA_COLUMN(LambdaProbability, lambdaProbability, float); } // namespace v0SigmaCandidate -DECLARE_SOA_TABLE(V0SigmaCandidates, "AOD", "V0SIGMAS", - v0SigmaCandidate::SigmapT, - v0SigmaCandidate::SigmaMass, - // v0SigmaCandidate::SigmaDCAz, - // v0SigmaCandidate::SigmaDCAxy, - // v0SigmaCandidate::SigmaDCADau, - v0SigmaCandidate::PhotonPt, - v0SigmaCandidate::PhotonMass, - v0SigmaCandidate::PhotonQt, - v0SigmaCandidate::PhotonAlpha, - v0SigmaCandidate::PhotonRadius, - v0SigmaCandidate::PhotonCosPA, - v0SigmaCandidate::PhotonDCADau, - v0SigmaCandidate::PhotonDCANegPV, - v0SigmaCandidate::PhotonDCAPosPV, - v0SigmaCandidate::PhotonZconv, - v0SigmaCandidate::LambdaPt, - v0SigmaCandidate::LambdaMass, - v0SigmaCandidate::LambdaQt, - v0SigmaCandidate::LambdaAlpha, - v0SigmaCandidate::LambdaRadius, - v0SigmaCandidate::LambdaCosPA, - v0SigmaCandidate::LambdaDCADau, - v0SigmaCandidate::LambdaDCANegPV, - v0SigmaCandidate::LambdaDCAPosPV, - v0SigmaCandidate::GammaProbability, - v0SigmaCandidate::LambdaProbability); +DECLARE_SOA_TABLE(V0SigmaCandidates, "AOD", "V0SIGMAS", + v0SigmaCandidate::SigmapT, + v0SigmaCandidate::SigmaMass, + // v0SigmaCandidate::SigmaDCAz, + // v0SigmaCandidate::SigmaDCAxy, + // v0SigmaCandidate::SigmaDCADau, + v0SigmaCandidate::PhotonPt, + v0SigmaCandidate::PhotonMass, + v0SigmaCandidate::PhotonQt, + v0SigmaCandidate::PhotonAlpha, + v0SigmaCandidate::PhotonRadius, + v0SigmaCandidate::PhotonCosPA, + v0SigmaCandidate::PhotonDCADau, + v0SigmaCandidate::PhotonDCANegPV, + v0SigmaCandidate::PhotonDCAPosPV, + v0SigmaCandidate::PhotonZconv, + v0SigmaCandidate::LambdaPt, + v0SigmaCandidate::LambdaMass, + v0SigmaCandidate::LambdaQt, + v0SigmaCandidate::LambdaAlpha, + v0SigmaCandidate::LambdaRadius, + v0SigmaCandidate::LambdaCosPA, + v0SigmaCandidate::LambdaDCADau, + v0SigmaCandidate::LambdaDCANegPV, + v0SigmaCandidate::LambdaDCAPosPV, + v0SigmaCandidate::GammaProbability, + v0SigmaCandidate::LambdaProbability); // for MC data -namespace v0SigmaMCCandidate +namespace v0SigmaMCCandidate { DECLARE_SOA_COLUMN(IsSigma, isSigma, bool); } // namespace v0SigmaMCCandidate DECLARE_SOA_TABLE(V0SigmaMCCandidates, "AOD", "V0MCSIGMAS", - v0SigmaMCCandidate::IsSigma); + v0SigmaMCCandidate::IsSigma); } // namespace o2::aod #endif // PWGLF_DATAMODEL_LFSIGMATABLES_H_ \ No newline at end of file diff --git a/PWGLF/DataModel/LFStrangenessMLTables.h b/PWGLF/DataModel/LFStrangenessMLTables.h index 7facaa49b75..d40e058b396 100644 --- a/PWGLF/DataModel/LFStrangenessMLTables.h +++ b/PWGLF/DataModel/LFStrangenessMLTables.h @@ -21,9 +21,8 @@ using namespace o2; using namespace o2::framework; - // Creating output TTree for ML analysis -namespace o2::aod +namespace o2::aod { namespace v0mlcandidates { @@ -73,67 +72,66 @@ DECLARE_SOA_COLUMN(IsKZeroShort, isKZeroShort, bool); } // namespace v0mlcandidates DECLARE_SOA_TABLE(V0MLCandidates, "AOD", "V0MLCANDIDATES", - v0mlcandidates::PosITSCls, - v0mlcandidates::NegITSCls, - v0mlcandidates::PosITSClSize, - v0mlcandidates::NegITSClSize, - v0mlcandidates::PosTPCRows, - v0mlcandidates::NegTPCRows, - v0mlcandidates::PosTPCSigmaPi, - v0mlcandidates::NegTPCSigmaPi, - v0mlcandidates::PosTPCSigmaPr, - v0mlcandidates::NegTPCSigmaPr, - v0mlcandidates::PosTPCSigmaEl, - v0mlcandidates::NegTPCSigmaEl, - v0mlcandidates::TOFSigmaLaPr, - v0mlcandidates::TOFSigmaLaPi, - v0mlcandidates::TOFSigmaALaPi, - v0mlcandidates::TOFSigmaALaPr, - v0mlcandidates::TOFSigmaK0PiPlus, - v0mlcandidates::TOFSigmaK0PiMinus, - v0mlcandidates::LambdaMass, - v0mlcandidates::AntiLambdaMass, - v0mlcandidates::GammaMass, - v0mlcandidates::KZeroShortMass, - v0mlcandidates::PT, - v0mlcandidates::Qt, - v0mlcandidates::Alpha, - v0mlcandidates::PosEta, - v0mlcandidates::NegEta, - v0mlcandidates::V0Eta, - v0mlcandidates::Z, - v0mlcandidates::V0radius, - v0mlcandidates::PA, - v0mlcandidates::DCApostopv, - v0mlcandidates::DCAnegtopv, - v0mlcandidates::DCAV0daughters, - v0mlcandidates::DCAv0topv, - v0mlcandidates::PsiPair, - v0mlcandidates::V0type, - v0mlcandidates::Centrality, - v0mlcandidates::SelHypothesis, - v0mlcandidates::IsLambda, - v0mlcandidates::IsAntiLambda, - v0mlcandidates::IsGamma, - v0mlcandidates::IsKZeroShort); - + v0mlcandidates::PosITSCls, + v0mlcandidates::NegITSCls, + v0mlcandidates::PosITSClSize, + v0mlcandidates::NegITSClSize, + v0mlcandidates::PosTPCRows, + v0mlcandidates::NegTPCRows, + v0mlcandidates::PosTPCSigmaPi, + v0mlcandidates::NegTPCSigmaPi, + v0mlcandidates::PosTPCSigmaPr, + v0mlcandidates::NegTPCSigmaPr, + v0mlcandidates::PosTPCSigmaEl, + v0mlcandidates::NegTPCSigmaEl, + v0mlcandidates::TOFSigmaLaPr, + v0mlcandidates::TOFSigmaLaPi, + v0mlcandidates::TOFSigmaALaPi, + v0mlcandidates::TOFSigmaALaPr, + v0mlcandidates::TOFSigmaK0PiPlus, + v0mlcandidates::TOFSigmaK0PiMinus, + v0mlcandidates::LambdaMass, + v0mlcandidates::AntiLambdaMass, + v0mlcandidates::GammaMass, + v0mlcandidates::KZeroShortMass, + v0mlcandidates::PT, + v0mlcandidates::Qt, + v0mlcandidates::Alpha, + v0mlcandidates::PosEta, + v0mlcandidates::NegEta, + v0mlcandidates::V0Eta, + v0mlcandidates::Z, + v0mlcandidates::V0radius, + v0mlcandidates::PA, + v0mlcandidates::DCApostopv, + v0mlcandidates::DCAnegtopv, + v0mlcandidates::DCAV0daughters, + v0mlcandidates::DCAv0topv, + v0mlcandidates::PsiPair, + v0mlcandidates::V0type, + v0mlcandidates::Centrality, + v0mlcandidates::SelHypothesis, + v0mlcandidates::IsLambda, + v0mlcandidates::IsAntiLambda, + v0mlcandidates::IsGamma, + v0mlcandidates::IsKZeroShort); namespace V0MLSelection { DECLARE_SOA_COLUMN(GammaBDTScore, gammaBDTScore, float); DECLARE_SOA_COLUMN(LambdaBDTScore, lambdaBDTScore, float); -DECLARE_SOA_COLUMN(AntiLambdaBDTScore, antiLambdaBDTScore, float); +DECLARE_SOA_COLUMN(AntiLambdaBDTScore, antiLambdaBDTScore, float); DECLARE_SOA_COLUMN(K0ShortBDTScore, k0ShortBDTScore, float); } // namespace V0MLSelection DECLARE_SOA_TABLE(V0GammaMLScores, "AOD", "V0GaMLScores", - V0MLSelection::GammaBDTScore); + V0MLSelection::GammaBDTScore); DECLARE_SOA_TABLE(V0LambdaMLScores, "AOD", "V0LaMLScores", - V0MLSelection::LambdaBDTScore); + V0MLSelection::LambdaBDTScore); DECLARE_SOA_TABLE(V0AntiLambdaMLScores, "AOD", "V0ALaMLScores", - V0MLSelection::AntiLambdaBDTScore); + V0MLSelection::AntiLambdaBDTScore); DECLARE_SOA_TABLE(V0K0ShortMLScores, "AOD", "V0K0MLScores", - V0MLSelection::K0ShortBDTScore); + V0MLSelection::K0ShortBDTScore); // Cascade candidates namespace cascmlcandidates @@ -191,53 +189,53 @@ DECLARE_SOA_COLUMN(IsOmegaPlus, isOmegaPlus, bool); } // namespace cascmlcandidates DECLARE_SOA_TABLE(CascMLCandidates, "AOD", "CAMLCANDIDATES", - cascmlcandidates::MassWindows, - cascmlcandidates::Charge, - cascmlcandidates::Centrality, - cascmlcandidates::PosITSCls, - cascmlcandidates::NegITSCls, - cascmlcandidates::BachITSCls, - cascmlcandidates::PosITSClSize, - cascmlcandidates::NegITSClSize, - cascmlcandidates::BachITSClSize, - cascmlcandidates::PosTPCRows, - cascmlcandidates::NegTPCRows, - cascmlcandidates::BachTPCRows, - cascmlcandidates::PosTPCSigmaPi, - cascmlcandidates::NegTPCSigmaPi, - cascmlcandidates::PosTPCSigmaPr, - cascmlcandidates::NegTPCSigmaPr, - cascmlcandidates::BachTPCSigmaPi, - cascmlcandidates::BachTPCSigmaKa, - cascmlcandidates::TOFNSigmaXiLaPi, - cascmlcandidates::TOFNSigmaXiLaPr, - cascmlcandidates::TOFNSigmaXiPi, - cascmlcandidates::TOFNSigmaOmLaPi, - cascmlcandidates::TOFNSigmaOmLaPr, - cascmlcandidates::TOFNSigmaOmKa, - cascmlcandidates::MXi, - cascmlcandidates::MOmega, - cascmlcandidates::YXi, - cascmlcandidates::YOmega, - cascmlcandidates::MLambda, - cascmlcandidates::Pt, - cascmlcandidates::PosEta, - cascmlcandidates::NegEta, - cascmlcandidates::BachEta, - cascmlcandidates::V0radius, - cascmlcandidates::CascRadius, - cascmlcandidates::DCApostopv, - cascmlcandidates::DCAnegtopv, - cascmlcandidates::DCAbachtopv, - cascmlcandidates::DCAV0daughters, - cascmlcandidates::DCACascDaughters, - cascmlcandidates::DCAv0topv, - cascmlcandidates::V0PA, - cascmlcandidates::CascPA, - cascmlcandidates::IsXiMinus, - cascmlcandidates::IsXiPlus, - cascmlcandidates::IsOmegaMinus, - cascmlcandidates::IsOmegaPlus); + cascmlcandidates::MassWindows, + cascmlcandidates::Charge, + cascmlcandidates::Centrality, + cascmlcandidates::PosITSCls, + cascmlcandidates::NegITSCls, + cascmlcandidates::BachITSCls, + cascmlcandidates::PosITSClSize, + cascmlcandidates::NegITSClSize, + cascmlcandidates::BachITSClSize, + cascmlcandidates::PosTPCRows, + cascmlcandidates::NegTPCRows, + cascmlcandidates::BachTPCRows, + cascmlcandidates::PosTPCSigmaPi, + cascmlcandidates::NegTPCSigmaPi, + cascmlcandidates::PosTPCSigmaPr, + cascmlcandidates::NegTPCSigmaPr, + cascmlcandidates::BachTPCSigmaPi, + cascmlcandidates::BachTPCSigmaKa, + cascmlcandidates::TOFNSigmaXiLaPi, + cascmlcandidates::TOFNSigmaXiLaPr, + cascmlcandidates::TOFNSigmaXiPi, + cascmlcandidates::TOFNSigmaOmLaPi, + cascmlcandidates::TOFNSigmaOmLaPr, + cascmlcandidates::TOFNSigmaOmKa, + cascmlcandidates::MXi, + cascmlcandidates::MOmega, + cascmlcandidates::YXi, + cascmlcandidates::YOmega, + cascmlcandidates::MLambda, + cascmlcandidates::Pt, + cascmlcandidates::PosEta, + cascmlcandidates::NegEta, + cascmlcandidates::BachEta, + cascmlcandidates::V0radius, + cascmlcandidates::CascRadius, + cascmlcandidates::DCApostopv, + cascmlcandidates::DCAnegtopv, + cascmlcandidates::DCAbachtopv, + cascmlcandidates::DCAV0daughters, + cascmlcandidates::DCACascDaughters, + cascmlcandidates::DCAv0topv, + cascmlcandidates::V0PA, + cascmlcandidates::CascPA, + cascmlcandidates::IsXiMinus, + cascmlcandidates::IsXiPlus, + cascmlcandidates::IsOmegaMinus, + cascmlcandidates::IsOmegaPlus); } // namespace o2::aod #endif // PWGLF_DATAMODEL_LFSTRANGENESSMLTABLES_H_ \ No newline at end of file diff --git a/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx b/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx index a73a6220516..0162ff13f2e 100644 --- a/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx +++ b/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx @@ -23,7 +23,6 @@ // david.dobrigkeit.chinellato@cern.ch // - #include "Framework/runDataProcessing.h" #include "Framework/RunningWorkflowInfo.h" #include "Framework/AnalysisTask.h" @@ -65,11 +64,11 @@ using std::endl; using dauTracks = soa::Join; -struct cascadeMLSelectionTreeCreator{ +struct cascadeMLSelectionTreeCreator { Produces cascadeMLCandidates; HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; - // selection switches: please, use just one at a time! + // selection switches: please, use just one at a time! Configurable getXiMinus{"getXiMinus", false, "If True, apply cuts to select XiMinus signal and bkg candidates"}; Configurable getXiPlus{"getXiPlus", false, "If True, apply cuts to select XiPlus signal and bkg candidates"}; Configurable getOmegaMinus{"getOmegaMinus", false, "If True, apply cuts to select OmegaMinus signal and bkg candidates"}; @@ -101,7 +100,7 @@ struct cascadeMLSelectionTreeCreator{ histos.add("hEventCentrality", "hEventCentrality", kTH1F, {centralityAxis}); } - // Helper struct to pass v0 information + // Helper struct to pass v0 information struct { uint8_t massWindows; int charge; @@ -117,7 +116,7 @@ struct cascadeMLSelectionTreeCreator{ float posTPCRows; float negTPCRows; float bachTPCRows; - + // PID properties float posTPCSigmaPi; float negTPCSigmaPi; @@ -159,13 +158,13 @@ struct cascadeMLSelectionTreeCreator{ bool isXiMinus; bool isXiPlus; bool isOmegaMinus; - bool isOmegaPlus; + bool isOmegaPlus; } cascadeCandidate; - + // Process candidate and store properties in object template void processCandidate(TCollision const& coll, TCascObject const& cand) - { + { auto posTrackExtra = cand.template posTrackExtra_as(); auto negTrackExtra = cand.template negTrackExtra_as(); auto bachTrackExtra = cand.template bachTrackExtra_as(); @@ -211,7 +210,7 @@ struct cascadeMLSelectionTreeCreator{ cascadeCandidate.negEta = cand.negativeeta(); cascadeCandidate.bachEta = cand.bacheloreta(); - // Topological + // Topological cascadeCandidate.v0radius = cand.v0radius(); cascadeCandidate.cascradius = cand.cascradius(); cascadeCandidate.dcapostopv = cand.dcapostopv(); @@ -229,7 +228,7 @@ struct cascadeMLSelectionTreeCreator{ cascadeCandidate.isOmegaMinus = false; cascadeCandidate.isOmegaPlus = false; - if constexpr ( requires {cand.pdgCode();} ) { + if constexpr (requires { cand.pdgCode(); }) { cascadeCandidate.isXiMinus = (cand.pdgCode() == 3312); cascadeCandidate.isXiPlus = (cand.pdgCode() == -3312); cascadeCandidate.isOmegaMinus = (cand.pdgCode() == 3334); @@ -237,38 +236,38 @@ struct cascadeMLSelectionTreeCreator{ } // base topological selections - if( cascadeCandidate.v0CosPA < v0setting_cospa ) - return; - if( cascadeCandidate.dcaV0Daughters > v0setting_dcav0dau ) - return; - if( cascadeCandidate.dcapostopv < v0setting_dcapostopv ) - return; - if( cascadeCandidate.dcapostopv < v0setting_dcanegtopv ) - return; - if( cascadeCandidate.dcabachtopv < cascadesetting_dcabachtopv ) - return; - if( cascadeCandidate.v0radius < v0setting_radius ) - return; - if( cascadeCandidate.cascCosPA < cascadesetting_cospa ) - return; - if( cascadeCandidate.dcaCascDaughters > cascadesetting_dcacascdau ) - return; - if( cascadeCandidate.cascradius < cascadesetting_cascradius ) - return; - if( std::abs(cascadeCandidate.mLambdaDaughter-1.116) > cascadesetting_v0masswindow ) - return; - if( cascadeCandidate.dcav0topv < cascadesetting_mindcav0topv ) - return; + if (cascadeCandidate.v0CosPA < v0setting_cospa) + return; + if (cascadeCandidate.dcaV0Daughters > v0setting_dcav0dau) + return; + if (cascadeCandidate.dcapostopv < v0setting_dcapostopv) + return; + if (cascadeCandidate.dcapostopv < v0setting_dcanegtopv) + return; + if (cascadeCandidate.dcabachtopv < cascadesetting_dcabachtopv) + return; + if (cascadeCandidate.v0radius < v0setting_radius) + return; + if (cascadeCandidate.cascCosPA < cascadesetting_cospa) + return; + if (cascadeCandidate.dcaCascDaughters > cascadesetting_dcacascdau) + return; + if (cascadeCandidate.cascradius < cascadesetting_cascradius) + return; + if (std::abs(cascadeCandidate.mLambdaDaughter - 1.116) > cascadesetting_v0masswindow) + return; + if (cascadeCandidate.dcav0topv < cascadesetting_mindcav0topv) + return; // Mass window selections cascadeCandidate.massWindows = 0; - if(std::abs(cascadeCandidate.mXi-1.322) < xiMassWindow) { - cascadeCandidate.massWindows = cascadeCandidate.massWindows | 1 << 0 ; + if (std::abs(cascadeCandidate.mXi - 1.322) < xiMassWindow) { + cascadeCandidate.massWindows = cascadeCandidate.massWindows | 1 << 0; } - if(std::abs(cascadeCandidate.mOmega-1.6725) < omegaMassWindow) { - cascadeCandidate.massWindows = cascadeCandidate.massWindows | 1 << 1 ; + if (std::abs(cascadeCandidate.mOmega - 1.6725) < omegaMassWindow) { + cascadeCandidate.massWindows = cascadeCandidate.massWindows | 1 << 1; } - if(cascadeCandidate.massWindows == 0){ + if (cascadeCandidate.massWindows == 0) { return; // skip } @@ -316,7 +315,7 @@ struct cascadeMLSelectionTreeCreator{ cascadeCandidate.negEta, cascadeCandidate.bachEta, - // Topological + // Topological cascadeCandidate.v0radius, cascadeCandidate.cascradius, cascadeCandidate.dcapostopv, @@ -332,31 +331,29 @@ struct cascadeMLSelectionTreeCreator{ cascadeCandidate.isXiMinus, cascadeCandidate.isXiPlus, cascadeCandidate.isOmegaMinus, - cascadeCandidate.isOmegaPlus - ); + cascadeCandidate.isOmegaPlus); } void processRealData(soa::Join::iterator const& coll, soa::Join const& cascades, dauTracks const&) { histos.fill(HIST("hEventCentrality"), coll.centFT0C()); - for (auto& casc: cascades){ // looping over lambdas + for (auto& casc : cascades) { // looping over lambdas processCandidate(coll, casc); } } void processSimData(soa::Join::iterator const& coll, soa::Join const& cascades, dauTracks const&) { histos.fill(HIST("hEventCentrality"), coll.centFT0C()); - for (auto& casc: cascades){ // looping over lambdas + for (auto& casc : cascades) { // looping over lambdas processCandidate(coll, casc); } } - PROCESS_SWITCH(cascadeMLSelectionTreeCreator, processRealData, "Produce Run 3 cascade tables (real data)", false); + PROCESS_SWITCH(cascadeMLSelectionTreeCreator, processRealData, "Produce Run 3 cascade tables (real data)", false); PROCESS_SWITCH(cascadeMLSelectionTreeCreator, processSimData, "Produce Run 3 cascade tables (simulation)", true); }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{adaptAnalysisTask(cfgc)}; - } \ No newline at end of file diff --git a/PWGLF/TableProducer/Strangeness/cascadebuilder.cxx b/PWGLF/TableProducer/Strangeness/cascadebuilder.cxx index 0dc1b5edb21..ce6ab3aaaac 100644 --- a/PWGLF/TableProducer/Strangeness/cascadebuilder.cxx +++ b/PWGLF/TableProducer/Strangeness/cascadebuilder.cxx @@ -308,10 +308,10 @@ struct cascadeBuilder { std::array kfV0Cov; std::array kfV0DauPosCov; std::array kfV0DauNegCov; - float mlXiMinusScore; - float mlXiPlusScore; - float mlOmegaMinusScore; - float mlOmegaPlusScore; + float mlXiMinusScore; + float mlXiPlusScore; + float mlOmegaMinusScore; + float mlOmegaPlusScore; } cascadecandidate; o2::track::TrackParCov lBachelorTrack; @@ -694,13 +694,12 @@ struct cascadeBuilder { } // machine learning initialization if requested - if (mlConfigurations.calculateXiMinusScores || - mlConfigurations.calculateXiPlusScores || - mlConfigurations.calculateOmegaMinusScores || - mlConfigurations.calculateOmegaPlusScores) - { + if (mlConfigurations.calculateXiMinusScores || + mlConfigurations.calculateXiPlusScores || + mlConfigurations.calculateOmegaMinusScores || + mlConfigurations.calculateOmegaPlusScores) { int64_t timeStampML = bc.timestamp(); - if(mlConfigurations.timestampCCDB.value!=-1) + if (mlConfigurations.timestampCCDB.value != -1) timeStampML = mlConfigurations.timestampCCDB.value; LoadMachines(timeStampML); } @@ -751,24 +750,25 @@ struct cascadeBuilder { } // function to load models for ML-based classifiers - void LoadMachines(int64_t timeStampML){ - if(mlConfigurations.loadModelsFromCCDB){ + void LoadMachines(int64_t timeStampML) + { + if (mlConfigurations.loadModelsFromCCDB) { ccdbApi.init(ccdbConfigurations.ccdburl); LOG(info) << "Fetching cascade models for timestamp: " << timeStampML; if (mlConfigurations.calculateXiMinusScores) { bool retrieveSuccess = ccdbApi.retrieveBlob(mlConfigurations.modelPathCCDB, ".", metadata, timeStampML, false, mlConfigurations.localModelPathXiMinus.value); - if (retrieveSuccess){ - mlModelXiMinus.initModel(mlConfigurations.localModelPathXiMinus.value, mlConfigurations.enableOptimizations.value); + if (retrieveSuccess) { + mlModelXiMinus.initModel(mlConfigurations.localModelPathXiMinus.value, mlConfigurations.enableOptimizations.value); } else { LOG(fatal) << "Error encountered while fetching/loading the XiMinus model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?"; } } - + if (mlConfigurations.calculateXiPlusScores) { bool retrieveSuccess = ccdbApi.retrieveBlob(mlConfigurations.modelPathCCDB, ".", metadata, timeStampML, false, mlConfigurations.localModelPathXiPlus.value); - if (retrieveSuccess){ - mlModelXiPlus.initModel(mlConfigurations.localModelPathXiPlus.value, mlConfigurations.enableOptimizations.value); + if (retrieveSuccess) { + mlModelXiPlus.initModel(mlConfigurations.localModelPathXiPlus.value, mlConfigurations.enableOptimizations.value); } else { LOG(fatal) << "Error encountered while fetching/loading the XiPlus model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?"; } @@ -776,26 +776,30 @@ struct cascadeBuilder { if (mlConfigurations.calculateOmegaMinusScores) { bool retrieveSuccess = ccdbApi.retrieveBlob(mlConfigurations.modelPathCCDB, ".", metadata, timeStampML, false, mlConfigurations.localModelPathOmegaMinus.value); - if (retrieveSuccess){ - mlModelOmegaMinus.initModel(mlConfigurations.localModelPathOmegaMinus.value, mlConfigurations.enableOptimizations.value); + if (retrieveSuccess) { + mlModelOmegaMinus.initModel(mlConfigurations.localModelPathOmegaMinus.value, mlConfigurations.enableOptimizations.value); } else { LOG(fatal) << "Error encountered while fetching/loading the OmegaMinus model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?"; } } - + if (mlConfigurations.calculateOmegaPlusScores) { bool retrieveSuccess = ccdbApi.retrieveBlob(mlConfigurations.modelPathCCDB, ".", metadata, timeStampML, false, mlConfigurations.localModelPathOmegaPlus.value); - if (retrieveSuccess){ - mlModelOmegaPlus.initModel(mlConfigurations.localModelPathOmegaPlus.value, mlConfigurations.enableOptimizations.value); + if (retrieveSuccess) { + mlModelOmegaPlus.initModel(mlConfigurations.localModelPathOmegaPlus.value, mlConfigurations.enableOptimizations.value); } else { LOG(fatal) << "Error encountered while fetching/loading the OmegaPlus model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?"; } } } else { - if (mlConfigurations.calculateXiMinusScores) mlModelXiMinus.initModel(mlConfigurations.localModelPathXiMinus.value, mlConfigurations.enableOptimizations.value); - if (mlConfigurations.calculateXiPlusScores) mlModelXiPlus.initModel(mlConfigurations.localModelPathXiPlus.value, mlConfigurations.enableOptimizations.value); - if (mlConfigurations.calculateOmegaMinusScores) mlModelOmegaMinus.initModel(mlConfigurations.localModelPathOmegaMinus.value, mlConfigurations.enableOptimizations.value); - if (mlConfigurations.calculateOmegaPlusScores) mlModelOmegaPlus.initModel(mlConfigurations.localModelPathOmegaPlus.value, mlConfigurations.enableOptimizations.value); + if (mlConfigurations.calculateXiMinusScores) + mlModelXiMinus.initModel(mlConfigurations.localModelPathXiMinus.value, mlConfigurations.enableOptimizations.value); + if (mlConfigurations.calculateXiPlusScores) + mlModelXiPlus.initModel(mlConfigurations.localModelPathXiPlus.value, mlConfigurations.enableOptimizations.value); + if (mlConfigurations.calculateOmegaMinusScores) + mlModelOmegaMinus.initModel(mlConfigurations.localModelPathOmegaMinus.value, mlConfigurations.enableOptimizations.value); + if (mlConfigurations.calculateOmegaPlusScores) + mlModelOmegaPlus.initModel(mlConfigurations.localModelPathOmegaPlus.value, mlConfigurations.enableOptimizations.value); } LOG(info) << "Cascade ML Models loaded."; } @@ -1166,51 +1170,50 @@ struct cascadeBuilder { registry.fill(HIST("h2dTopoVarCascRAP"), lPt, TMath::ACos(cascadecandidate.cosPA) * cascadecandidate.cascradius); registry.fill(HIST("h2dTopoVarCascRadius"), lPt, cascadecandidate.cascradius); } - + // calculate machine learning scores, compare against thresholds cascadecandidate.mlXiMinusScore = -1.0f; cascadecandidate.mlXiPlusScore = -1.0f; cascadecandidate.mlOmegaMinusScore = -1.0f; cascadecandidate.mlOmegaPlusScore = -1.0f; - if (mlConfigurations.calculateXiMinusScores || - mlConfigurations.calculateXiPlusScores || - mlConfigurations.calculateOmegaMinusScores || - mlConfigurations.calculateOmegaPlusScores) - { + if (mlConfigurations.calculateXiMinusScores || + mlConfigurations.calculateXiPlusScores || + mlConfigurations.calculateOmegaMinusScores || + mlConfigurations.calculateOmegaPlusScores) { // machine learning is on, go for calculation of thresholds // FIXME THIS NEEDS ADJUSTING - std::vector inputFeatures{0.0f, 0.0f, - 0.0f, 0.0f}; + std::vector inputFeatures{0.0f, 0.0f, + 0.0f, 0.0f}; // calculate scores - if(mlConfigurations.calculateXiMinusScores){ + if (mlConfigurations.calculateXiMinusScores) { float* xiMinusProbability = mlModelXiMinus.evalModel(inputFeatures); cascadecandidate.mlXiMinusScore = xiMinusProbability[1]; } - if(mlConfigurations.calculateXiPlusScores){ + if (mlConfigurations.calculateXiPlusScores) { float* xiPlusProbability = mlModelXiPlus.evalModel(inputFeatures); cascadecandidate.mlXiPlusScore = xiPlusProbability[1]; } - if(mlConfigurations.calculateOmegaMinusScores){ + if (mlConfigurations.calculateOmegaMinusScores) { float* omegaMinusProbability = mlModelOmegaMinus.evalModel(inputFeatures); cascadecandidate.mlOmegaMinusScore = omegaMinusProbability[1]; } - if(mlConfigurations.calculateOmegaPlusScores){ + if (mlConfigurations.calculateOmegaPlusScores) { float* omegaPlusProbability = mlModelOmegaPlus.evalModel(inputFeatures); cascadecandidate.mlOmegaPlusScore = omegaPlusProbability[1]; } - // Skip anything that doesn't fulfull any of the desired conditions - if( cascadecandidate.mlXiMinusScore < mlConfigurations.thresholdXiMinus.value && + // Skip anything that doesn't fulfull any of the desired conditions + if (cascadecandidate.mlXiMinusScore < mlConfigurations.thresholdXiMinus.value && cascadecandidate.mlXiPlusScore < mlConfigurations.thresholdXiPlus.value && - cascadecandidate.mlOmegaMinusScore < mlConfigurations.thresholdOmegaMinus.value && - cascadecandidate.mlOmegaPlusScore < mlConfigurations.thresholdOmegaPlus.value){ - return false; // skipped as uninteresting in any hypothesis considered - } + cascadecandidate.mlOmegaMinusScore < mlConfigurations.thresholdOmegaMinus.value && + cascadecandidate.mlOmegaPlusScore < mlConfigurations.thresholdOmegaPlus.value) { + return false; // skipped as uninteresting in any hypothesis considered + } } - // Final outcome is YES if I got here! + // Final outcome is YES if I got here! return true; } diff --git a/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx b/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx index 4d3695c6532..b693c5ae085 100644 --- a/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx +++ b/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx @@ -24,7 +24,6 @@ // david.dobrigkeit.chinellato@cern.ch // - #include "Framework/runDataProcessing.h" #include "Framework/RunningWorkflowInfo.h" #include "Framework/AnalysisTask.h" @@ -66,105 +65,105 @@ using std::endl; using dauTracks = soa::Join; -struct lambdakzeroMLSelectionTreeCreator{ - Produces v0MLCandidates; - HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; - - // Base selection criteria +struct lambdakzeroMLSelectionTreeCreator { + Produces v0MLCandidates; + HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; - // Lambda standard criteria:: - Configurable Lambdav0cospa{"Lambdav0cospa", 0.90, "min V0 CosPA"}; - Configurable Lambdadcav0dau{"Lambdadcav0dau", 1.0, "max DCA V0 Daughters (cm)"}; - Configurable Lambdadcanegtopv{"Lambdadcanegtopv", .05, "min DCA Neg To PV (cm)"}; - Configurable Lambdadcapostopv{"Lambdadcapostopv", .05, "min DCA Pos To PV (cm)"}; - Configurable Lambdav0radius{"Lambdav0radius", 1.5, "minimum V0 radius (cm)"}; - Configurable LambdaWindow{"LambdaWindow", 0.01, "Mass window around expected (in GeV/c2)"}; + // Base selection criteria - // Anti-Lambda standard criteria:: - Configurable AntiLambdav0cospa{"AntiLambdav0cospa", 0.90, "min V0 CosPA"}; - Configurable AntiLambdadcav0dau{"AntiLambdadcav0dau", 1.0, "max DCA V0 Daughters (cm)"}; - Configurable AntiLambdadcanegtopv{"AntiLambdadcanegtopv", .05, "min DCA Neg To PV (cm)"}; - Configurable AntiLambdadcapostopv{"AntiLambdadcapostopv", .05, "min DCA Pos To PV (cm)"}; - Configurable AntiLambdav0radius{"AntiLambdav0radius", 1.5, "minimum V0 radius (cm)"}; - Configurable AntiLambdaWindow{"AntiLambdaWindow", 0.01, "Mass window around expected (in GeV/c2)"}; + // Lambda standard criteria:: + Configurable Lambdav0cospa{"Lambdav0cospa", 0.90, "min V0 CosPA"}; + Configurable Lambdadcav0dau{"Lambdadcav0dau", 1.0, "max DCA V0 Daughters (cm)"}; + Configurable Lambdadcanegtopv{"Lambdadcanegtopv", .05, "min DCA Neg To PV (cm)"}; + Configurable Lambdadcapostopv{"Lambdadcapostopv", .05, "min DCA Pos To PV (cm)"}; + Configurable Lambdav0radius{"Lambdav0radius", 1.5, "minimum V0 radius (cm)"}; + Configurable LambdaWindow{"LambdaWindow", 0.01, "Mass window around expected (in GeV/c2)"}; - // Photon standard criteria: - Configurable PhotonMinRadius{"PhotonMinRadius", 1.0, "minimum photon conversion radius (cm)"}; - Configurable PhotonMaxRadius{"PhotonMaxRadius", 200, "maximum photon conversion radius (cm)"}; - Configurable PhotonMinPt{"PhotonMinPt", 0.001, "minimum photon pT (GeV/c)"}; - Configurable PhotonMaxMass{"PhotonMaxMass", 0.2, "Maximum photon mass (GeV/c^{2})"}; - Configurable PhotonMaxqt{"PhotonMaxqt", 0.1, "Maximum photon qt value (AP plot) (GeV/c)"}; - Configurable PhotonMaxalpha{"PhotonMaxalpha", 1.0, "Max photon alpha absolute value (AP plot)"}; - Configurable PhotonWindow{"PhotonWindow", 0.01, "Mass window around expected (in GeV/c2)"}; + // Anti-Lambda standard criteria:: + Configurable AntiLambdav0cospa{"AntiLambdav0cospa", 0.90, "min V0 CosPA"}; + Configurable AntiLambdadcav0dau{"AntiLambdadcav0dau", 1.0, "max DCA V0 Daughters (cm)"}; + Configurable AntiLambdadcanegtopv{"AntiLambdadcanegtopv", .05, "min DCA Neg To PV (cm)"}; + Configurable AntiLambdadcapostopv{"AntiLambdadcapostopv", .05, "min DCA Pos To PV (cm)"}; + Configurable AntiLambdav0radius{"AntiLambdav0radius", 1.5, "minimum V0 radius (cm)"}; + Configurable AntiLambdaWindow{"AntiLambdaWindow", 0.01, "Mass window around expected (in GeV/c2)"}; - // KZeroShort standard criteria: - // TODO: update criteria - Configurable K0Shortv0cospa{"K0Shortv0cospa", 0.90, "min V0 CosPA"}; - Configurable K0Shortdcav0dau{"K0Shortdcav0dau", 1.0, "max DCA V0 Daughters (cm)"}; - Configurable K0Shortdcanegtopv{"K0Shortdcanegtopv", .05, "min DCA Neg To PV (cm)"}; - Configurable K0Shortdcapostopv{"K0Shortdcapostopv", .05, "min DCA Pos To PV (cm)"}; - Configurable K0Shortv0radius{"K0Shortv0radius", 1.5, "minimum V0 radius (cm)"}; - Configurable K0ShortWindow{"K0ShortWindow", 0.01, "Mass window around expected (in GeV/c2)"}; + // Photon standard criteria: + Configurable PhotonMinRadius{"PhotonMinRadius", 1.0, "minimum photon conversion radius (cm)"}; + Configurable PhotonMaxRadius{"PhotonMaxRadius", 200, "maximum photon conversion radius (cm)"}; + Configurable PhotonMinPt{"PhotonMinPt", 0.001, "minimum photon pT (GeV/c)"}; + Configurable PhotonMaxMass{"PhotonMaxMass", 0.2, "Maximum photon mass (GeV/c^{2})"}; + Configurable PhotonMaxqt{"PhotonMaxqt", 0.1, "Maximum photon qt value (AP plot) (GeV/c)"}; + Configurable PhotonMaxalpha{"PhotonMaxalpha", 1.0, "Max photon alpha absolute value (AP plot)"}; + Configurable PhotonWindow{"PhotonWindow", 0.01, "Mass window around expected (in GeV/c2)"}; - // Axis: - ConfigurableAxis centralityAxis{"centralityAxis", {100, 0.0f, 100.0f}, ""}; + // KZeroShort standard criteria: + // TODO: update criteria + Configurable K0Shortv0cospa{"K0Shortv0cospa", 0.90, "min V0 CosPA"}; + Configurable K0Shortdcav0dau{"K0Shortdcav0dau", 1.0, "max DCA V0 Daughters (cm)"}; + Configurable K0Shortdcanegtopv{"K0Shortdcanegtopv", .05, "min DCA Neg To PV (cm)"}; + Configurable K0Shortdcapostopv{"K0Shortdcapostopv", .05, "min DCA Pos To PV (cm)"}; + Configurable K0Shortv0radius{"K0Shortv0radius", 1.5, "minimum V0 radius (cm)"}; + Configurable K0ShortWindow{"K0ShortWindow", 0.01, "Mass window around expected (in GeV/c2)"}; - void init(InitContext const&) - { - histos.add("hEventCentrality", "hEventCentrality", kTH1F, {centralityAxis}); - } + // Axis: + ConfigurableAxis centralityAxis{"centralityAxis", {100, 0.0f, 100.0f}, ""}; + + void init(InitContext const&) + { + histos.add("hEventCentrality", "hEventCentrality", kTH1F, {centralityAxis}); + } - // Helper struct to pass v0 information + // Helper struct to pass v0 information struct { - int posITSCls; - int negITSCls; - uint32_t posITSClSize; - uint32_t negITSClSize; - float posTPCRows; - float negTPCRows; - float posTPCSigmaPi; - float negTPCSigmaPi; - float posTPCSigmaPr; - float negTPCSigmaPr; - float posTPCSigmaEl; - float negTPCSigmaEl; - float TOFSigmaLaPr; - float TOFSigmaLaPi; - float TOFSigmaALaPi; - float TOFSigmaALaPr; - float TOFSigmaK0PiPlus; - float TOFSigmaK0PiMinus; - float LambdaMass; - float AntiLambdaMass; - float GammaMass; - float KZeroShortMass; - float pT; - float qt; - float alpha; - float posEta; - float negEta; - float v0Eta; - float Z; - float v0radius; - float PA; - float dcapostopv; - float dcanegtopv; - float dcaV0daughters; - float dcav0topv; - float PsiPair; - uint8_t v0type; - float centrality; - uint8_t SelHypothesis; - bool isLambda; - bool isAntiLambda; - bool isGamma; - bool isKZeroShort; + int posITSCls; + int negITSCls; + uint32_t posITSClSize; + uint32_t negITSClSize; + float posTPCRows; + float negTPCRows; + float posTPCSigmaPi; + float negTPCSigmaPi; + float posTPCSigmaPr; + float negTPCSigmaPr; + float posTPCSigmaEl; + float negTPCSigmaEl; + float TOFSigmaLaPr; + float TOFSigmaLaPi; + float TOFSigmaALaPi; + float TOFSigmaALaPr; + float TOFSigmaK0PiPlus; + float TOFSigmaK0PiMinus; + float LambdaMass; + float AntiLambdaMass; + float GammaMass; + float KZeroShortMass; + float pT; + float qt; + float alpha; + float posEta; + float negEta; + float v0Eta; + float Z; + float v0radius; + float PA; + float dcapostopv; + float dcanegtopv; + float dcaV0daughters; + float dcav0topv; + float PsiPair; + uint8_t v0type; + float centrality; + uint8_t SelHypothesis; + bool isLambda; + bool isAntiLambda; + bool isGamma; + bool isKZeroShort; } Candidate; - + // Process candidate and store properties in object template void processCandidate(TCollision const& coll, TV0Object const& cand) - { + { bool lConsistentWithLambda = true; bool lConsistentWithAntiLambda = true; bool lConsistentWithGamma = true; @@ -189,7 +188,7 @@ struct lambdakzeroMLSelectionTreeCreator{ Candidate.posTPCSigmaEl = posTrackExtra.tpcNSigmaEl(); Candidate.negTPCSigmaEl = negTrackExtra.tpcNSigmaEl(); - // TOF PID: + // TOF PID: Candidate.TOFSigmaLaPr = cand.tofNSigmaLaPr(); Candidate.TOFSigmaLaPi = cand.tofNSigmaLaPi(); Candidate.TOFSigmaALaPi = cand.tofNSigmaALaPi(); @@ -197,7 +196,7 @@ struct lambdakzeroMLSelectionTreeCreator{ Candidate.TOFSigmaK0PiPlus = cand.tofNSigmaK0PiPlus(); Candidate.TOFSigmaK0PiMinus = cand.tofNSigmaK0PiMinus(); - // General + // General Candidate.LambdaMass = cand.mLambda(); Candidate.AntiLambdaMass = cand.mAntiLambda(); Candidate.GammaMass = cand.mGamma(); @@ -210,7 +209,7 @@ struct lambdakzeroMLSelectionTreeCreator{ Candidate.v0Eta = cand.eta(); Candidate.Z = cand.z(); - // Topological + // Topological Candidate.v0radius = cand.v0radius(); Candidate.PA = TMath::ACos(cand.v0cosPA()); Candidate.dcapostopv = cand.dcapostopv(); @@ -219,19 +218,19 @@ struct lambdakzeroMLSelectionTreeCreator{ Candidate.dcav0topv = cand.dcav0topv(); Candidate.PsiPair = cand.psipair(); - // Debug/Aditional + // Debug/Aditional Candidate.v0type = cand.v0Type(); Candidate.centrality = coll.centFT0C(); // Applying selections and saving hypothesis - if ((std::abs(cand.mLambda() - 1.115683) > LambdaWindow) || (cand.v0radius() < Lambdav0radius) || ( cand.v0cosPA() < Lambdav0cospa) || (TMath::Abs(cand.dcapostopv()) < Lambdadcapostopv) || (TMath::Abs(cand.dcanegtopv()) < Lambdadcanegtopv) || ( cand.dcaV0daughters() > Lambdadcav0dau)) + if ((std::abs(cand.mLambda() - 1.115683) > LambdaWindow) || (cand.v0radius() < Lambdav0radius) || (cand.v0cosPA() < Lambdav0cospa) || (TMath::Abs(cand.dcapostopv()) < Lambdadcapostopv) || (TMath::Abs(cand.dcanegtopv()) < Lambdadcanegtopv) || (cand.dcaV0daughters() > Lambdadcav0dau)) lConsistentWithLambda = false; if ((std::abs(cand.mAntiLambda() - 1.115683) > AntiLambdaWindow) || (cand.v0radius() < AntiLambdav0radius) || (cand.v0cosPA() < AntiLambdav0cospa) || (TMath::Abs(cand.dcapostopv()) < AntiLambdadcapostopv) || (TMath::Abs(cand.dcanegtopv()) < AntiLambdadcanegtopv) || (cand.dcaV0daughters() > AntiLambdadcav0dau)) lConsistentWithAntiLambda = false; if ((std::abs(cand.mGamma()) > PhotonWindow) || (cand.mGamma() > PhotonMaxMass) || (cand.v0radius() < PhotonMinRadius) || (cand.v0radius() > PhotonMaxRadius) || (cand.pt() < PhotonMinPt) || (cand.qtarm() > PhotonMaxqt) || (TMath::Abs(cand.alpha()) > PhotonMaxalpha)) lConsistentWithGamma = false; if ((std::abs(cand.mK0Short() - 0.497) > K0ShortWindow) || (cand.v0radius() < K0Shortv0radius) || (cand.v0cosPA() < K0Shortv0cospa) || (TMath::Abs(cand.dcapostopv()) < K0Shortdcapostopv) || (TMath::Abs(cand.dcanegtopv()) < K0Shortdcanegtopv) || (cand.dcaV0daughters() > K0Shortdcav0dau)) - lConsistentWithK0Short = false; + lConsistentWithK0Short = false; Candidate.SelHypothesis = lConsistentWithLambda << 0 | lConsistentWithAntiLambda << 1 | lConsistentWithGamma << 2 | lConsistentWithK0Short << 3; // 1: Consistent with Lambda only, 2: Consistent with Anti-Lambda only @@ -249,28 +248,28 @@ struct lambdakzeroMLSelectionTreeCreator{ Candidate.isGamma = false; Candidate.isKZeroShort = false; - if constexpr ( requires {cand.pdgCode();} ) { - Candidate.isLambda = (cand.pdgCode()==3122); - Candidate.isAntiLambda = (cand.pdgCode()==-3122); - Candidate.isGamma = (cand.pdgCode()==22); - Candidate.isKZeroShort = (cand.pdgCode()==310); + if constexpr (requires { cand.pdgCode(); }) { + Candidate.isLambda = (cand.pdgCode() == 3122); + Candidate.isAntiLambda = (cand.pdgCode() == -3122); + Candidate.isGamma = (cand.pdgCode() == 22); + Candidate.isKZeroShort = (cand.pdgCode() == 310); } // Filling TTree for ML analysis - v0MLCandidates(Candidate.posITSCls, Candidate.negITSCls, Candidate.posITSClSize, Candidate.negITSClSize, Candidate.posTPCRows, Candidate.negTPCRows, - Candidate.posTPCSigmaPi, Candidate.negTPCSigmaPi, Candidate.posTPCSigmaPr, Candidate.negTPCSigmaPr, - Candidate.posTPCSigmaEl, Candidate.negTPCSigmaEl, Candidate.TOFSigmaLaPr, Candidate.TOFSigmaLaPi, - Candidate.TOFSigmaALaPi, Candidate.TOFSigmaALaPr, Candidate.TOFSigmaK0PiPlus, Candidate.TOFSigmaK0PiMinus, - Candidate.LambdaMass, Candidate.AntiLambdaMass, Candidate.GammaMass, Candidate.KZeroShortMass, Candidate.pT, - Candidate.qt, Candidate.alpha, Candidate.posEta, Candidate.negEta, Candidate.v0Eta, Candidate.Z, - Candidate.v0radius, Candidate.PA, Candidate.dcapostopv, Candidate.dcanegtopv, Candidate.dcaV0daughters, Candidate.dcav0topv, Candidate.PsiPair, - Candidate.v0type, Candidate.centrality, Candidate.SelHypothesis, Candidate.isLambda, Candidate.isAntiLambda, Candidate.isGamma, Candidate.isKZeroShort); + v0MLCandidates(Candidate.posITSCls, Candidate.negITSCls, Candidate.posITSClSize, Candidate.negITSClSize, Candidate.posTPCRows, Candidate.negTPCRows, + Candidate.posTPCSigmaPi, Candidate.negTPCSigmaPi, Candidate.posTPCSigmaPr, Candidate.negTPCSigmaPr, + Candidate.posTPCSigmaEl, Candidate.negTPCSigmaEl, Candidate.TOFSigmaLaPr, Candidate.TOFSigmaLaPi, + Candidate.TOFSigmaALaPi, Candidate.TOFSigmaALaPr, Candidate.TOFSigmaK0PiPlus, Candidate.TOFSigmaK0PiMinus, + Candidate.LambdaMass, Candidate.AntiLambdaMass, Candidate.GammaMass, Candidate.KZeroShortMass, Candidate.pT, + Candidate.qt, Candidate.alpha, Candidate.posEta, Candidate.negEta, Candidate.v0Eta, Candidate.Z, + Candidate.v0radius, Candidate.PA, Candidate.dcapostopv, Candidate.dcanegtopv, Candidate.dcaV0daughters, Candidate.dcav0topv, Candidate.PsiPair, + Candidate.v0type, Candidate.centrality, Candidate.SelHypothesis, Candidate.isLambda, Candidate.isAntiLambda, Candidate.isGamma, Candidate.isKZeroShort); } void processRealData(soa::Join::iterator const& coll, soa::Join const& v0s, dauTracks const&) { histos.fill(HIST("hEventCentrality"), coll.centFT0C()); - for (auto& cand: v0s){ // looping over lambdas + for (auto& cand : v0s) { // looping over lambdas processCandidate(coll, cand); } } @@ -278,18 +277,16 @@ struct lambdakzeroMLSelectionTreeCreator{ void processSimData(soa::Join::iterator const& coll, soa::Join const& v0s, dauTracks const&) { histos.fill(HIST("hEventCentrality"), coll.centFT0C()); - for (auto& cand: v0s){ // looping over lambdas + for (auto& cand : v0s) { // looping over lambdas processCandidate(coll, cand); } } - PROCESS_SWITCH(lambdakzeroMLSelectionTreeCreator, processRealData, "Produce Run 3 v0 tables (real data)", false); + PROCESS_SWITCH(lambdakzeroMLSelectionTreeCreator, processRealData, "Produce Run 3 v0 tables (real data)", false); PROCESS_SWITCH(lambdakzeroMLSelectionTreeCreator, processSimData, "Produce Run 3 v0 tables (simulation)", true); - }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{adaptAnalysisTask(cfgc)}; - } \ No newline at end of file diff --git a/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx b/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx index 2f95d0a8227..f61d0e67e6d 100644 --- a/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx +++ b/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx @@ -117,11 +117,11 @@ struct lambdakzeroBuilder { Produces v0fctrackXs; Produces v0fccovs; - // produces calls for machine-learning selections - Produces gammaMLSelections; // gamma scores - Produces lambdaMLSelections; // lambda scores - Produces antiLambdaMLSelections; // AntiLambda scores - Produces k0ShortMLSelections; // K0Short scores + // produces calls for machine-learning selections + Produces gammaMLSelections; // gamma scores + Produces lambdaMLSelections; // lambda scores + Produces antiLambdaMLSelections; // AntiLambda scores + Produces k0ShortMLSelections; // K0Short scores o2::ccdb::CcdbApi ccdbApi; Service ccdb; @@ -234,7 +234,7 @@ struct lambdakzeroBuilder { Configurable d_doTrackQA{"qaConfigurations.d_doTrackQA", false, "do track QA"}; Configurable d_QA_checkMC{"qaConfigurations.d_QA_checkMC", true, "check MC truth in QA"}; Configurable d_QA_checkdEdx{"qaConfigurations.d_QA_checkdEdx", false, "check dEdx in QA"}; - } qaConfigurations; + } qaConfigurations; // for topo var QA struct : ConfigurableGroup { @@ -665,13 +665,12 @@ struct lambdakzeroBuilder { } // machine learning initialization if requested - if (mlConfigurations.calculateK0ShortScores || - mlConfigurations.calculateLambdaScores || - mlConfigurations.calculateAntiLambdaScores || - mlConfigurations.calculateGammaScores) - { + if (mlConfigurations.calculateK0ShortScores || + mlConfigurations.calculateLambdaScores || + mlConfigurations.calculateAntiLambdaScores || + mlConfigurations.calculateGammaScores) { int64_t timeStampML = bc.timestamp(); - if(mlConfigurations.timestampCCDB.value!=-1) + if (mlConfigurations.timestampCCDB.value != -1) timeStampML = mlConfigurations.timestampCCDB.value; LoadMachines(timeStampML); } @@ -722,43 +721,56 @@ struct lambdakzeroBuilder { } // function to load models for ML-based classifiers - void LoadMachines(int64_t timeStampML){ - if(mlConfigurations.loadModelsFromCCDB){ + void LoadMachines(int64_t timeStampML) + { + if (mlConfigurations.loadModelsFromCCDB) { ccdbApi.init(ccdbConfigurations.ccdburl); LOG(info) << "Fetching models for timestamp: " << timeStampML; if (mlConfigurations.calculateLambdaScores) { bool retrieveSuccessLambda = ccdbApi.retrieveBlob(mlConfigurations.modelPathCCDB, ".", metadata, timeStampML, false, mlConfigurations.localModelPathLambda.value); - if (retrieveSuccessLambda) mlModelLambda.initModel(mlConfigurations.localModelPathLambda.value, mlConfigurations.enableOptimizations.value); - else{ - LOG(fatal) << "Error encountered while fetching/loading the Lambda model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?";} + if (retrieveSuccessLambda) + mlModelLambda.initModel(mlConfigurations.localModelPathLambda.value, mlConfigurations.enableOptimizations.value); + else { + LOG(fatal) << "Error encountered while fetching/loading the Lambda model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?"; } - + } + if (mlConfigurations.calculateAntiLambdaScores) { bool retrieveSuccessAntiLambda = ccdbApi.retrieveBlob(mlConfigurations.modelPathCCDB, ".", metadata, timeStampML, false, mlConfigurations.localModelPathAntiLambda.value); - if (retrieveSuccessAntiLambda) mlModelAntiLambda.initModel(mlConfigurations.localModelPathAntiLambda.value, mlConfigurations.enableOptimizations.value); - else{ - LOG(fatal) << "Error encountered while fetching/loading the AntiLambda model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?";} + if (retrieveSuccessAntiLambda) + mlModelAntiLambda.initModel(mlConfigurations.localModelPathAntiLambda.value, mlConfigurations.enableOptimizations.value); + else { + LOG(fatal) << "Error encountered while fetching/loading the AntiLambda model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?"; } + } if (mlConfigurations.calculateGammaScores) { bool retrieveSuccessGamma = ccdbApi.retrieveBlob(mlConfigurations.modelPathCCDB, ".", metadata, timeStampML, false, mlConfigurations.localModelPathGamma.value); - if (retrieveSuccessGamma) mlModelGamma.initModel(mlConfigurations.localModelPathGamma.value, mlConfigurations.enableOptimizations.value); - else{ - LOG(fatal) << "Error encountered while fetching/loading the Gamma model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?";} + if (retrieveSuccessGamma) + mlModelGamma.initModel(mlConfigurations.localModelPathGamma.value, mlConfigurations.enableOptimizations.value); + else { + LOG(fatal) << "Error encountered while fetching/loading the Gamma model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?"; } - + } + if (mlConfigurations.calculateK0ShortScores) { bool retrieveSuccessKZeroShort = ccdbApi.retrieveBlob(mlConfigurations.modelPathCCDB, ".", metadata, timeStampML, false, mlConfigurations.localModelPathK0Short.value); - if (retrieveSuccessKZeroShort) mlModelK0Short.initModel(mlConfigurations.localModelPathK0Short.value, mlConfigurations.enableOptimizations.value); - else{ - LOG(fatal) << "Error encountered while fetching/loading the K0Short model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?";} + if (retrieveSuccessKZeroShort) + mlModelK0Short.initModel(mlConfigurations.localModelPathK0Short.value, mlConfigurations.enableOptimizations.value); + else { + LOG(fatal) << "Error encountered while fetching/loading the K0Short model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?"; + } } } else { - if (mlConfigurations.calculateLambdaScores) mlModelLambda.initModel(mlConfigurations.localModelPathLambda.value, mlConfigurations.enableOptimizations.value); - if (mlConfigurations.calculateAntiLambdaScores) mlModelAntiLambda.initModel(mlConfigurations.localModelPathAntiLambda.value, mlConfigurations.enableOptimizations.value); - if (mlConfigurations.calculateGammaScores) mlModelGamma.initModel(mlConfigurations.localModelPathGamma.value, mlConfigurations.enableOptimizations.value); - if (mlConfigurations.calculateK0ShortScores) mlModelK0Short.initModel(mlConfigurations.localModelPathK0Short.value, mlConfigurations.enableOptimizations.value); + if (mlConfigurations.calculateLambdaScores) + mlModelLambda.initModel(mlConfigurations.localModelPathLambda.value, mlConfigurations.enableOptimizations.value); + if (mlConfigurations.calculateAntiLambdaScores) + mlModelAntiLambda.initModel(mlConfigurations.localModelPathAntiLambda.value, mlConfigurations.enableOptimizations.value); + if (mlConfigurations.calculateGammaScores) + mlModelGamma.initModel(mlConfigurations.localModelPathGamma.value, mlConfigurations.enableOptimizations.value); + if (mlConfigurations.calculateK0ShortScores) + mlModelK0Short.initModel(mlConfigurations.localModelPathK0Short.value, mlConfigurations.enableOptimizations.value); } LOG(info) << "ML Models loaded."; } @@ -1096,35 +1108,34 @@ struct lambdakzeroBuilder { // evaluate machine-learning scores float gammaScore = -1.0f, lambdaScore = -1.0f, antiLambdaScore = -1.0f, k0ShortScore = -1.0f; - if (mlConfigurations.calculateK0ShortScores || - mlConfigurations.calculateLambdaScores || - mlConfigurations.calculateAntiLambdaScores || - mlConfigurations.calculateGammaScores) - { + if (mlConfigurations.calculateK0ShortScores || + mlConfigurations.calculateLambdaScores || + mlConfigurations.calculateAntiLambdaScores || + mlConfigurations.calculateGammaScores) { // machine learning is on, go for calculation of thresholds // FIXME THIS NEEDS ADJUSTING - std::vector inputFeatures{pt, 0.0f, - 0.0f, v0candidate.V0radius, - v0candidate.cosPA, v0candidate.dcaV0dau, - v0candidate.posDCAxy, v0candidate.negDCAxy}; + std::vector inputFeatures{pt, 0.0f, + 0.0f, v0candidate.V0radius, + v0candidate.cosPA, v0candidate.dcaV0dau, + v0candidate.posDCAxy, v0candidate.negDCAxy}; // calculate scores - if(mlConfigurations.calculateLambdaScores){ + if (mlConfigurations.calculateLambdaScores) { float* lambdaProbability = mlModelLambda.evalModel(inputFeatures); lambdaScore = lambdaProbability[1]; } - if(mlConfigurations.calculateGammaScores){ + if (mlConfigurations.calculateGammaScores) { float* gammaProbability = mlModelGamma.evalModel(inputFeatures); gammaScore = gammaProbability[1]; } - // Skip anything that doesn't fulfull any of the desired conditions - if( gammaScore < mlConfigurations.thresholdGamma.value && + // Skip anything that doesn't fulfull any of the desired conditions + if (gammaScore < mlConfigurations.thresholdGamma.value && lambdaScore < mlConfigurations.thresholdLambda.value && - antiLambdaScore < mlConfigurations.thresholdAntiLambda.value && - k0ShortScore < mlConfigurations.thresholdK0Short.value){ - continue; // skipped as uninteresting in any hypothesis considered - } + antiLambdaScore < mlConfigurations.thresholdAntiLambda.value && + k0ShortScore < mlConfigurations.thresholdK0Short.value) { + continue; // skipped as uninteresting in any hypothesis considered + } } // V0 logic reminder @@ -1132,13 +1143,12 @@ struct lambdakzeroBuilder { if (V0.v0Type() > 0) { if (V0.v0Type() > 1 && !storePhotonCandidates) continue; - - if (mlConfigurations.calculateK0ShortScores || - mlConfigurations.calculateLambdaScores || - mlConfigurations.calculateAntiLambdaScores || - mlConfigurations.calculateGammaScores) - { - // at this stage, the candidate is interesting -> populate table + + if (mlConfigurations.calculateK0ShortScores || + mlConfigurations.calculateLambdaScores || + mlConfigurations.calculateAntiLambdaScores || + mlConfigurations.calculateGammaScores) { + // at this stage, the candidate is interesting -> populate table gammaMLSelections(gammaScore); lambdaMLSelections(lambdaScore); antiLambdaMLSelections(antiLambdaScore); diff --git a/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx b/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx index 72aec92266d..d50bd718d94 100644 --- a/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx +++ b/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx @@ -62,22 +62,22 @@ using std::array; using std::cout; using std::endl; - // For original data loops using V0OriginalDatas = soa::Join; // For derived data analysis using V0DerivedDatas = soa::Join; -struct lambdakzeromlselection{ - o2::ml::OnnxModel lambda_bdt;; +struct lambdakzeromlselection { + o2::ml::OnnxModel lambda_bdt; + ; o2::ml::OnnxModel antilambda_bdt; o2::ml::OnnxModel gamma_bdt; o2::ml::OnnxModel kzeroshort_bdt; std::map metadata; - Produces gammaMLSelections; // optionally aggregate information from ML output for posterior analysis (derived data) + 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) HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; @@ -101,8 +101,8 @@ struct lambdakzeromlselection{ Configurable timestampCCDB{"timestampCCDB", -1, "timestamp of the ONNX file for ML model used to query in CCDB. Exceptions: > 0 for the specific timestamp, 0 gets the run dependent timestamp"}; Configurable loadModelsFromCCDB{"loadModelsFromCCDB", false, "Flag to enable or disable the loading of models from CCDB"}; Configurable enableOptimizations{"enableOptimizations", false, "Enables the ONNX extended model-optimization: sessionOptions.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_ENABLE_EXTENDED)"}; - - // Axis + + // Axis // base properties ConfigurableAxis vertexZ{"vertexZ", {30, -15.0f, 15.0f}, ""}; @@ -113,7 +113,7 @@ struct lambdakzeromlselection{ histos.add("hEventVertexZ", "hEventVertexZ", kTH1F, {vertexZ}); ccdb->setURL(ccdbUrl.value); - // Retrieve the model from CCDB + // Retrieve the model from CCDB if (loadModelsFromCCDB) { ccdbApi.init(ccdbUrl); @@ -122,54 +122,65 @@ struct lambdakzeromlselection{ if (PredictLambda) { bool retrieveSuccessLambda = ccdbApi.retrieveBlob(BDTPathCCDB.value, ".", metadata, timestampCCDB.value, false, BDTLocalPathLambda.value); - if (retrieveSuccessLambda) lambda_bdt.initModel(BDTLocalPathLambda.value, enableOptimizations.value); - else{ - LOG(fatal) << "Error encountered while fetching/loading the Lambda model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?";} + if (retrieveSuccessLambda) + lambda_bdt.initModel(BDTLocalPathLambda.value, enableOptimizations.value); + else { + LOG(fatal) << "Error encountered while fetching/loading the Lambda model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?"; } - + } + if (PredictAntiLambda) { bool retrieveSuccessAntiLambda = ccdbApi.retrieveBlob(BDTPathCCDB.value, ".", metadata, timestampCCDB.value, false, BDTLocalPathAntiLambda.value); - if (retrieveSuccessAntiLambda) antilambda_bdt.initModel(BDTLocalPathAntiLambda.value, enableOptimizations.value); - else{ - LOG(fatal) << "Error encountered while fetching/loading the AntiLambda model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?";} + if (retrieveSuccessAntiLambda) + antilambda_bdt.initModel(BDTLocalPathAntiLambda.value, enableOptimizations.value); + else { + LOG(fatal) << "Error encountered while fetching/loading the AntiLambda model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?"; } + } if (PredictGamma) { bool retrieveSuccessGamma = ccdbApi.retrieveBlob(BDTPathCCDB.value, ".", metadata, timestampCCDB.value, false, BDTLocalPathGamma.value); - if (retrieveSuccessGamma) gamma_bdt.initModel(BDTLocalPathGamma.value, enableOptimizations.value); - else{ - LOG(fatal) << "Error encountered while fetching/loading the Gamma model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?";} + if (retrieveSuccessGamma) + gamma_bdt.initModel(BDTLocalPathGamma.value, enableOptimizations.value); + else { + LOG(fatal) << "Error encountered while fetching/loading the Gamma model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?"; } - + } + if (PredictKZeroShort) { bool retrieveSuccessKZeroShort = ccdbApi.retrieveBlob(BDTPathCCDB.value, ".", metadata, timestampCCDB.value, false, BDTLocalPathKZeroShort.value); - if (retrieveSuccessKZeroShort) kzeroshort_bdt.initModel(BDTLocalPathKZeroShort.value, enableOptimizations.value); - else{ - LOG(fatal) << "Error encountered while fetching/loading the KZeroShort model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?";} + if (retrieveSuccessKZeroShort) + kzeroshort_bdt.initModel(BDTLocalPathKZeroShort.value, enableOptimizations.value); + else { + LOG(fatal) << "Error encountered while fetching/loading the KZeroShort model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?"; + } } - } - else { - if (PredictLambda) lambda_bdt.initModel(BDTLocalPathLambda.value, enableOptimizations.value); - if (PredictAntiLambda) antilambda_bdt.initModel(BDTLocalPathAntiLambda.value, enableOptimizations.value); - if (PredictGamma) gamma_bdt.initModel(BDTLocalPathGamma.value, enableOptimizations.value); - if (PredictKZeroShort) kzeroshort_bdt.initModel(BDTLocalPathKZeroShort.value, enableOptimizations.value); + } else { + if (PredictLambda) + lambda_bdt.initModel(BDTLocalPathLambda.value, enableOptimizations.value); + if (PredictAntiLambda) + antilambda_bdt.initModel(BDTLocalPathAntiLambda.value, enableOptimizations.value); + if (PredictGamma) + gamma_bdt.initModel(BDTLocalPathGamma.value, enableOptimizations.value); + if (PredictKZeroShort) + kzeroshort_bdt.initModel(BDTLocalPathKZeroShort.value, enableOptimizations.value); } } // Process candidate and store properties in object template void processCandidate(TV0Object const& cand) - { - std::vector inputFeatures{cand.pt(), static_cast(cand.qtarm()), - cand.alpha(), cand.v0radius(), - cand.v0cosPA(), cand.dcaV0daughters(), + { + std::vector inputFeatures{cand.pt(), static_cast(cand.qtarm()), + cand.alpha(), cand.v0radius(), + cand.v0cosPA(), cand.dcaV0daughters(), cand.dcapostopv(), cand.dcanegtopv()}; // calculate classifier float* LambdaProbability = lambda_bdt.evalModel(inputFeatures); float* GammaProbability = gamma_bdt.evalModel(inputFeatures); - //float* AntiLambdaProbability = antilambda_bdt.evalModel(inputFeatures); // WIP - //float* KZeroShortProbability = kzeroshort_bdt.evalModel(inputFeatures); // WIP + // float* AntiLambdaProbability = antilambda_bdt.evalModel(inputFeatures); // WIP + // float* KZeroShortProbability = kzeroshort_bdt.evalModel(inputFeatures); // WIP gammaMLSelections(GammaProbability[1]); lambdaMLSelections(LambdaProbability[1]); @@ -178,14 +189,14 @@ struct lambdakzeromlselection{ void processDerivedData(aod::StraCollision const& coll, V0DerivedDatas const& v0s) { histos.fill(HIST("hEventVertexZ"), coll.posZ()); - for (auto& v0: v0s){ // looping over lambdas + for (auto& v0 : v0s) { // looping over lambdas processCandidate(v0); } } void processStandardData(aod::Collision const& coll, V0OriginalDatas const& v0s) { histos.fill(HIST("hEventVertexZ"), coll.posZ()); - for (auto& v0: v0s){ // looping over lambdas + for (auto& v0 : v0s) { // looping over lambdas processCandidate(v0); } } diff --git a/PWGLF/TableProducer/Strangeness/sigma0builder.cxx b/PWGLF/TableProducer/Strangeness/sigma0builder.cxx index 76174cf45dc..989de846377 100644 --- a/PWGLF/TableProducer/Strangeness/sigma0builder.cxx +++ b/PWGLF/TableProducer/Strangeness/sigma0builder.cxx @@ -9,8 +9,8 @@ // granted to it by virtue of its status as an Intergovernmental Organization // or submit itself to any jurisdiction. // -// This is a task that employs the standard V0 tables and attempts to combine -// two V0s into a Sigma0 -> Lambda + gamma candidate. +// This is a task that employs the standard V0 tables and attempts to combine +// two V0s into a Sigma0 -> Lambda + gamma candidate. #include "Framework/runDataProcessing.h" #include "Framework/AnalysisTask.h" @@ -49,15 +49,15 @@ using std::array; using std::cout; using std::endl; -struct sigma0builder{ - Produces v0Sigmas; // save sigma0 candidates for analysis +struct sigma0builder { + Produces v0Sigmas; // save sigma0 candidates for analysis Produces v0MCSigmas; // save sigma0 candidates for analysis HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; Configurable Gamma_MLThreshold{"Gamma_MLThreshold", 0.1, "Decision Threshold value to select gammas of sigma0 candidates"}; Configurable Lambda_MLThreshold{"Lambda_MLThreshold", 0.1, "Decision Threshold value to select lambdas of sigma0 candidates"}; - // Axis + // Axis // base properties ConfigurableAxis vertexZ{"vertexZ", {30, -15.0f, 15.0f}, ""}; // Invariant Mass @@ -75,21 +75,21 @@ struct sigma0builder{ float mass; float pT; } sigmaCandidate; - + // Process sigma candidate and store properties in object template bool processSigmaCandidate(TCollision const& collision, TV0Object const& lambda, TV0Object const& gamma) - { + { // Gamma selection: - if( gamma.gammaBDTScore() <= Gamma_MLThreshold) + if (gamma.gammaBDTScore() <= Gamma_MLThreshold) return false; // Lambda selection: - if( lambda.lambdaBDTScore() <= Lambda_MLThreshold) + if (lambda.lambdaBDTScore() <= Lambda_MLThreshold) return false; - + std::array pVecPhotons{gamma.px(), gamma.py(), gamma.pz()}; - std::array pVecLambda{lambda.px(),lambda.py(), lambda.pz()}; + std::array pVecLambda{lambda.px(), lambda.py(), lambda.pz()}; auto arrMom = std::array{pVecPhotons, pVecLambda}; sigmaCandidate.mass = RecoDecay::m(arrMom, std::array{o2::constants::physics::MassPhoton, o2::constants::physics::MassLambda0}); sigmaCandidate.pT = RecoDecay::pt(array{gamma.px() + lambda.px(), gamma.py() + lambda.py()}); @@ -100,15 +100,18 @@ struct sigma0builder{ { histos.fill(HIST("hEventVertexZMC"), coll.posZ()); - for (auto& gamma: v0s) { // selecting photons from Sigma0 + for (auto& gamma : v0s) { // selecting photons from Sigma0 - if ((gamma.pdgCode()!=22) || (gamma.pdgCodeMother()!=3212)) continue; - for (auto& lambda: v0s){ // selecting lambdas from Sigma0 - if ((lambda.pdgCode()!=3122) || (lambda.pdgCodeMother()!=3212)) continue; + if ((gamma.pdgCode() != 22) || (gamma.pdgCodeMother() != 3212)) + continue; + for (auto& lambda : v0s) { // selecting lambdas from Sigma0 + if ((lambda.pdgCode() != 3122) || (lambda.pdgCodeMother() != 3212)) + continue; - //if (gamma.motherMCPartId()!=lambda.motherMCPartId()) continue; - if(!processSigmaCandidate(coll, lambda,gamma)) continue; - bool fIsSigma = (gamma.motherMCPartId()==lambda.motherMCPartId()); + // if (gamma.motherMCPartId()!=lambda.motherMCPartId()) continue; + if (!processSigmaCandidate(coll, lambda, gamma)) + continue; + bool fIsSigma = (gamma.motherMCPartId() == lambda.motherMCPartId()); // Filling TTree for ML analysis v0MCSigmas(fIsSigma); @@ -116,32 +119,32 @@ struct sigma0builder{ } } - void processRealData(aod::StraCollision const& coll, soa::Join const& v0s) + void processRealData(aod::StraCollision const& coll, soa::Join const& v0s) { histos.fill(HIST("hEventVertexZ"), coll.posZ()); - for (auto& gamma: v0s) { // selecting photons from Sigma0 - for (auto& lambda: v0s){ // selecting lambdas from Sigma0 - if(!processSigmaCandidate(coll, lambda,gamma)) - continue; - + for (auto& gamma : v0s) { // selecting photons from Sigma0 + for (auto& lambda : v0s) { // selecting lambdas from Sigma0 + if (!processSigmaCandidate(coll, lambda, gamma)) + continue; + // Sigma related float fSigmapT = sigmaCandidate.pT; - float fSigmaMass = sigmaCandidate.mass; - + float fSigmaMass = sigmaCandidate.mass; + // Daughters related /// Photon float fPhotonPt = gamma.pt(); float fPhotonMass = gamma.mGamma(); float fPhotonQt = gamma.qtarm(); float fPhotonAlpha = gamma.alpha(); - float fPhotonRadius = gamma.v0radius(); + float fPhotonRadius = gamma.v0radius(); float fPhotonCosPA = gamma.v0cosPA(); float fPhotonDCADau = gamma.dcaV0daughters(); float fPhotonDCANegPV = gamma.dcanegtopv(); float fPhotonDCAPosPV = gamma.dcapostopv(); - float fPhotonZconv = gamma.z(); - + float fPhotonZconv = gamma.z(); + // Lambda float fLambdaPt = lambda.pt(); float fLambdaMass = lambda.mLambda(); @@ -154,12 +157,11 @@ struct sigma0builder{ float fLambdaDCAPosPV = lambda.dcapostopv(); // Filling TTree for ML analysis - v0Sigmas(fSigmapT, fSigmaMass, fPhotonPt, fPhotonMass, fPhotonQt, fPhotonAlpha, - fPhotonRadius, fPhotonCosPA, fPhotonDCADau, fPhotonDCANegPV, fPhotonDCAPosPV, - fPhotonZconv, fLambdaPt, fLambdaMass, fLambdaQt, fLambdaAlpha, fLambdaRadius, - fLambdaCosPA, fLambdaDCADau, fLambdaDCANegPV, fLambdaDCAPosPV, - gamma.gammaBDTScore(), lambda.lambdaBDTScore()); - + v0Sigmas(fSigmapT, fSigmaMass, fPhotonPt, fPhotonMass, fPhotonQt, fPhotonAlpha, + fPhotonRadius, fPhotonCosPA, fPhotonDCADau, fPhotonDCANegPV, fPhotonDCAPosPV, + fPhotonZconv, fLambdaPt, fLambdaMass, fLambdaQt, fLambdaAlpha, fLambdaRadius, + fLambdaCosPA, fLambdaDCADau, fLambdaDCANegPV, fLambdaDCAPosPV, + gamma.gammaBDTScore(), lambda.lambdaBDTScore()); } } } @@ -170,5 +172,4 @@ struct sigma0builder{ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{adaptAnalysisTask(cfgc)}; - } \ No newline at end of file diff --git a/PWGLF/Tasks/Strangeness/sigmaanalysis.cxx b/PWGLF/Tasks/Strangeness/sigmaanalysis.cxx index 5d3a3d31add..d58895bc27d 100644 --- a/PWGLF/Tasks/Strangeness/sigmaanalysis.cxx +++ b/PWGLF/Tasks/Strangeness/sigmaanalysis.cxx @@ -9,8 +9,8 @@ // granted to it by virtue of its status as an Intergovernmental Organization // or submit itself to any jurisdiction. // -// This is a task that employs the standard V0 tables and attempts to combine -// two V0s into a Sigma0 -> Lambda + gamma candidate. +// This is a task that employs the standard V0 tables and attempts to combine +// two V0s into a Sigma0 -> Lambda + gamma candidate. #include "Framework/runDataProcessing.h" #include "Framework/AnalysisTask.h" @@ -50,13 +50,13 @@ using std::cout; using std::endl; using dauTracks = soa::Join; -struct sigmaanalysis{ +struct sigmaanalysis { HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; // master analysis switches - //Configurable fSaveTTree{"fSaveTTree", false, "Save TTree with Sigma0 candidates info for ML-based analysis"}; - //Configurable analyseSigma{"analyseSigma", false, "process Sigma-like candidates"}; - //Configurable analyseAntiSigma{"analyseAntiSigma", false, "process AntiSigma-like candidates"}; + // Configurable fSaveTTree{"fSaveTTree", false, "Save TTree with Sigma0 candidates info for ML-based analysis"}; + // Configurable analyseSigma{"analyseSigma", false, "process Sigma-like candidates"}; + // Configurable analyseAntiSigma{"analyseAntiSigma", false, "process AntiSigma-like candidates"}; // Base selection criteria // Selection criteria: acceptance @@ -75,7 +75,7 @@ struct sigmaanalysis{ // PID (TPC) Configurable TpcPidNsigmaCut{"TpcPidNsigmaCut", 4, "TpcPidNsigmaCut"}; Configurable allowTPConly{"allowTPConly", false, "Accept V0s that are TPC-only"}; - + // Track quality Configurable minTPCrows{"minTPCrows", 70, "minimum TPC crossed rows"}; @@ -87,7 +87,7 @@ struct sigmaanalysis{ Configurable dcapostopv{"dcapostopv", .05, "min DCA Pos To PV (cm)"}; Configurable v0radius{"v0radius", 1.2, "minimum V0 radius (cm)"}; - // Axis + // Axis // base properties ConfigurableAxis vertexZ{"vertexZ", {30, -15.0f, 15.0f}, ""}; 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}, "p_{T} (GeV/c)"}; @@ -110,11 +110,11 @@ struct sigmaanalysis{ // Event counter histos.add("hEventVertexZ", "hEventVertexZ", kTH1F, {vertexZ}); histos.add("hEventVertexZMC", "hEventVertexZMC", kTH1F, {vertexZ}); - + // Number of reconstructed sigma per collision as QA - histos.add("hNSigmaCandidates", "hNSigmaCandidates", kTH1F, {{100,-0.5f, 99.5f}}); - histos.add("hNSigmaCandidatesMC", "hNSigmaCandidatesMC", kTH1F, {{100,-0.5f, 99.5f}}); - + histos.add("hNSigmaCandidates", "hNSigmaCandidates", kTH1F, {{100, -0.5f, 99.5f}}); + histos.add("hNSigmaCandidatesMC", "hNSigmaCandidatesMC", kTH1F, {{100, -0.5f, 99.5f}}); + // V0 Radius histos.add("h2dLambdaRadiusVsPt", "hLambdaRadiusVsPt", {HistType::kTH2F, {axisPt, axisRadius}}); histos.add("h2dPhotonRadiusVsPt", "hPhotonRadiusVsPt", {HistType::kTH2F, {axisPt, axisRadius}}); @@ -128,18 +128,18 @@ struct sigmaanalysis{ histos.add("h2dSigmaMassVsPtMC", "hSigmaMassVsPtMC", {HistType::kTH2F, {axisPt, axisSigmaMass}}); histos.add("h2dLambdaMassVsPtMC", "hLambdaMassVsPtMC", {HistType::kTH2F, {axisPt, axisLambdaMass}}); histos.add("h2dPhotonMassVsPtMC", "hPhotonMassVsPtMC", {HistType::kTH2F, {axisPt, axisPhotonMass}}); - + // Exploratory Analysis with MC: /// Armenteros-Polanski plot: histos.add("h2dMCArmenterosPolanski", "h2dMCArmenterosPolanski", {HistType::kTH2F, {axisAPAlpha, axisAPQt}}); - + /// Lambda histos.add("hMCLambdaCosPA", "hMCLambdaCosPA", kTH1F, {{100, 0.9f, 1.0f}}); histos.add("hMCLambdaDCA_V0Dau", "hMCLambdaDCA_V0Dau", kTH1F, {{100, 0.0f, 3.0f}}); histos.add("hMCLambdaDCA_V0Pos", "hMCLambdaDCA_V0Pos", kTH1F, {{100, 0.0f, 2.0f}}); histos.add("hMCLambdaDCA_V0Neg", "hMCLambdaDCA_V0Neg", kTH1F, {{100, 0.0f, 2.0f}}); histos.add("hMCLambda_V0Radius", "hMCLambda_V0Radius", kTH1F, {{100, 0.0f, 40.0f}}); - + /// Photon: histos.add("hMCPhoton_ConversionRadius", "hMCPhoton_ConversionRadius", kTH1F, {{100, 0.0f, 150.0f}}); histos.add("hMCPhotonCosPA", "hMCPhotonCosPA", kTH1F, {{100, 0.9f, 1.0f}}); @@ -150,11 +150,11 @@ struct sigmaanalysis{ // ML Analysis histos.add("hMLOutputLambda", "hMLOutputLambda", kTH1F, {MLProb}); histos.add("hMLOutputGamma", "hMLOutputGamma", kTH1F, {MLProb}); - - if(doprocessCounterQA){ - histos.add("hGammaIndices", "hGammaIndices", {HistType::kTH1F, {{4000,0.0f, 400000.0f}}}); - histos.add("hCollIndices", "hCollIndices", {HistType::kTH1F, {{4000,0.0f, 4000.0f}}}); - histos.add("h2dIndices", "h2dIndices", {HistType::kTH2F, {{4000,0.0f, 40000.0f},{4000,0.0f, 400000.0f}}}); + + if (doprocessCounterQA) { + histos.add("hGammaIndices", "hGammaIndices", {HistType::kTH1F, {{4000, 0.0f, 400000.0f}}}); + histos.add("hCollIndices", "hCollIndices", {HistType::kTH1F, {{4000, 0.0f, 4000.0f}}}); + histos.add("h2dIndices", "h2dIndices", {HistType::kTH2F, {{4000, 0.0f, 40000.0f}, {4000, 0.0f, 400000.0f}}}); } } @@ -163,60 +163,60 @@ struct sigmaanalysis{ float mass; float pT; } sigmaCandidate; - + // Process sigma candidate and store properties in object template bool processSigmaCandidate(TCollision const& collision, TV0Object const& lambda, TV0Object const& gamma) - { + { // FIXME: this should be at the single particle level, preferably partitions - if( !allowTPConly && (lambda.v0Type()>1||gamma.v0Type()>1)) + if (!allowTPConly && (lambda.v0Type() > 1 || gamma.v0Type() > 1)) return false; - + // Gamma selection criteria: - if( gamma.mGamma() > maxPhotonMass ) + if (gamma.mGamma() > maxPhotonMass) return false; - if( gamma.v0radius() < minPhotonRadius ) + if (gamma.v0radius() < minPhotonRadius) return false; - if( gamma.v0radius() > maxPhotonRadius ) + if (gamma.v0radius() > maxPhotonRadius) return false; - if( gamma.pt() < minPhotonPt) + if (gamma.pt() < minPhotonPt) return false; - if( gamma.qtarm() > maxPhotonqt) + if (gamma.qtarm() > maxPhotonqt) return false; - if(TMath::Abs(gamma.alpha()) > Photonalpha) + if (TMath::Abs(gamma.alpha()) > Photonalpha) return false; // Lambda selection criteria: - if( TMath::Abs(lambda.mLambda()-1.115683) > lambdaWindow) + if (TMath::Abs(lambda.mLambda() - 1.115683) > lambdaWindow) return false; - if( lambda.v0radius() < v0radius) + if (lambda.v0radius() < v0radius) return false; - if( lambda.v0cosPA() < v0cospa) + if (lambda.v0cosPA() < v0cospa) return false; - if( lambda.dcapostopv() < dcapostopv) + if (lambda.dcapostopv() < dcapostopv) return false; - if( lambda.dcanegtopv() < dcanegtopv) + if (lambda.dcanegtopv() < dcanegtopv) return false; - if( lambda.dcaV0daughters() > dcav0dau) + if (lambda.dcaV0daughters() > dcav0dau) return false; - + std::array pVecPhotons{gamma.px(), gamma.py(), gamma.pz()}; - std::array pVecLambda{lambda.px(),lambda.py(), lambda.pz()}; + std::array pVecLambda{lambda.px(), lambda.py(), lambda.pz()}; auto arrMom = std::array{pVecPhotons, pVecLambda}; sigmaCandidate.mass = RecoDecay::m(arrMom, std::array{o2::constants::physics::MassPhoton, o2::constants::physics::MassLambda0}); sigmaCandidate.pT = RecoDecay::pt(array{gamma.px() + lambda.px(), gamma.py() + lambda.py()}); return true; } - // This process function cross-checks index correctness + // This process function cross-checks index correctness void processCounterQA(soa::Join const& v0s) { - for (auto& gamma: v0s) { - histos.fill(HIST("hGammaIndices"), gamma.globalIndex()); - histos.fill(HIST("hCollIndices"), gamma.straCollisionId()); - histos.fill(HIST("h2dIndices"), gamma.straCollisionId(), gamma.globalIndex()); - } - } + for (auto& gamma : v0s) { + histos.fill(HIST("hGammaIndices"), gamma.globalIndex()); + histos.fill(HIST("hCollIndices"), gamma.straCollisionId()); + histos.fill(HIST("h2dIndices"), gamma.straCollisionId(), gamma.globalIndex()); + } + } void processMonteCarlo(aod::StraCollision const& coll, soa::Join const& v0s) { @@ -224,42 +224,45 @@ struct sigmaanalysis{ histos.fill(HIST("hEventVertexZMC"), coll.posZ()); - for (auto& gamma: v0s) { // selecting photons from Sigma0 + for (auto& gamma : v0s) { // selecting photons from Sigma0 - if ((gamma.pdgCode()!=22 || gamma.pdgCodeMother()!=3212) && (gamma.pdgCode()!=-22 || gamma.pdgCodeMother()!=-3212)) continue; + if ((gamma.pdgCode() != 22 || gamma.pdgCodeMother() != 3212) && (gamma.pdgCode() != -22 || gamma.pdgCodeMother() != -3212)) + continue; - for (auto& lambda: v0s){ // selecting lambdas from Sigma0 - if ((lambda.pdgCode()!=3122 || lambda.pdgCodeMother()!=3212) && (lambda.pdgCode()!=-3122 || lambda.pdgCodeMother()!=-3212)) continue; - if (gamma.motherMCPartId()!=lambda.motherMCPartId()) continue; // selecting pair from exactly the same mother + for (auto& lambda : v0s) { // selecting lambdas from Sigma0 + if ((lambda.pdgCode() != 3122 || lambda.pdgCodeMother() != 3212) && (lambda.pdgCode() != -3122 || lambda.pdgCodeMother() != -3212)) + continue; + if (gamma.motherMCPartId() != lambda.motherMCPartId()) + continue; // selecting pair from exactly the same mother // Exploratory Analysis histograms: - + // Lambda histos.fill(HIST("hMCLambdaCosPA"), lambda.v0cosPA()); histos.fill(HIST("hMCLambdaDCA_V0Dau"), TMath::Abs(lambda.dcaV0daughters())); histos.fill(HIST("hMCLambdaDCA_V0Pos"), TMath::Abs(lambda.dcapostopv())); histos.fill(HIST("hMCLambdaDCA_V0Neg"), TMath::Abs(lambda.dcanegtopv())); histos.fill(HIST("hMCLambda_V0Radius"), lambda.v0radius()); - + // Photon histos.fill(HIST("hMCPhoton_ConversionRadius"), gamma.v0radius()); histos.fill(HIST("hMCPhotonCosPA"), gamma.v0cosPA()); histos.fill(HIST("hMCPhotonDCA_V0Dau"), TMath::Abs(gamma.dcaV0daughters())); histos.fill(HIST("hMCPhotonDCA_V0Pos"), TMath::Abs(gamma.dcapostopv())); histos.fill(HIST("hMCPhotonDCA_V0Neg"), TMath::Abs(gamma.dcanegtopv())); - + // Armenteros-Polanski plot: histos.fill(HIST("h2dMCArmenterosPolanski"), gamma.alpha(), gamma.qtarm()); histos.fill(HIST("h2dMCArmenterosPolanski"), lambda.alpha(), lambda.qtarm()); - - if(!processSigmaCandidate(coll, lambda,gamma)) - continue; - SigmaCounter ++; + + if (!processSigmaCandidate(coll, lambda, gamma)) + continue; + SigmaCounter++; histos.fill(HIST("h2dLambdaRadiusVsPtMC"), sigmaCandidate.pT, lambda.v0radius()); histos.fill(HIST("h2dPhotonRadiusVsPtMC"), sigmaCandidate.pT, gamma.v0radius()); - //Inv Mass + // Inv Mass histos.fill(HIST("h2dLambdaMassVsPtMC"), sigmaCandidate.pT, lambda.mLambda()); histos.fill(HIST("h2dPhotonMassVsPtMC"), sigmaCandidate.pT, gamma.mGamma()); histos.fill(HIST("h2dSigmaMassVsPtMC"), sigmaCandidate.pT, sigmaCandidate.mass); @@ -268,29 +271,28 @@ struct sigmaanalysis{ histos.fill(HIST("hNSigmaCandidatesMC"), SigmaCounter); } - void processRealData(aod::StraCollision const& coll, soa::Join const& v0s) + void processRealData(aod::StraCollision const& coll, soa::Join const& v0s) { int SigmaCounter = 0; histos.fill(HIST("hEventVertexZ"), coll.posZ()); - for (auto& gamma: v0s) { // selecting photons from Sigma0 - for (auto& lambda: v0s){ // selecting lambdas from Sigma0 - if(!processSigmaCandidate(coll, lambda,gamma)) - continue; - SigmaCounter ++; + for (auto& gamma : v0s) { // selecting photons from Sigma0 + for (auto& lambda : v0s) { // selecting lambdas from Sigma0 + if (!processSigmaCandidate(coll, lambda, gamma)) + continue; + SigmaCounter++; histos.fill(HIST("h2dLambdaRadiusVsPt"), sigmaCandidate.pT, lambda.v0radius()); histos.fill(HIST("h2dPhotonRadiusVsPt"), sigmaCandidate.pT, gamma.v0radius()); - //Inv Mass + // Inv Mass histos.fill(HIST("h2dLambdaMassVsPt"), sigmaCandidate.pT, lambda.mLambda()); histos.fill(HIST("h2dPhotonMassVsPt"), sigmaCandidate.pT, gamma.mGamma()); histos.fill(HIST("h2dSigmaMassVsPt"), sigmaCandidate.pT, sigmaCandidate.mass); histos.fill(HIST("hMLOutputLambda"), lambda.lambdaBDTScore()); histos.fill(HIST("hMLOutputGamma"), gamma.gammaBDTScore()); - } } histos.fill(HIST("hNSigmaCandidates"), SigmaCounter); @@ -304,5 +306,4 @@ struct sigmaanalysis{ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{adaptAnalysisTask(cfgc)}; - } \ No newline at end of file From 760932e849999f8290cf77427fee180b0c743d2d Mon Sep 17 00:00:00 2001 From: ddobrigk Date: Fri, 12 Apr 2024 22:14:55 +0200 Subject: [PATCH 21/26] First batch of megalinter errors --- PWGLF/DataModel/LFSigmaTables.h | 2 +- PWGLF/DataModel/LFStrangenessMLTables.h | 2 +- .../cascadeMLSelectionTreeCreator.cxx | 2 +- .../lambdakzeroMLSelectionTreeCreator.cxx | 2 +- .../Strangeness/lambdakzerobuilder.cxx | 16 ++++++++-------- .../Strangeness/lambdakzeromlselection.cxx | 16 ++++++++-------- PWGLF/Tasks/Strangeness/sigmaanalysis.cxx | 2 +- 7 files changed, 21 insertions(+), 21 deletions(-) diff --git a/PWGLF/DataModel/LFSigmaTables.h b/PWGLF/DataModel/LFSigmaTables.h index dc901000cee..e2df7da8bbe 100644 --- a/PWGLF/DataModel/LFSigmaTables.h +++ b/PWGLF/DataModel/LFSigmaTables.h @@ -96,4 +96,4 @@ DECLARE_SOA_TABLE(V0SigmaMCCandidates, "AOD", "V0MCSIGMAS", v0SigmaMCCandidate::IsSigma); } // namespace o2::aod -#endif // PWGLF_DATAMODEL_LFSIGMATABLES_H_ \ No newline at end of file +#endif // PWGLF_DATAMODEL_LFSIGMATABLES_H_ diff --git a/PWGLF/DataModel/LFStrangenessMLTables.h b/PWGLF/DataModel/LFStrangenessMLTables.h index d40e058b396..c052ab70fdf 100644 --- a/PWGLF/DataModel/LFStrangenessMLTables.h +++ b/PWGLF/DataModel/LFStrangenessMLTables.h @@ -238,4 +238,4 @@ DECLARE_SOA_TABLE(CascMLCandidates, "AOD", "CAMLCANDIDATES", cascmlcandidates::IsOmegaPlus); } // namespace o2::aod -#endif // PWGLF_DATAMODEL_LFSTRANGENESSMLTABLES_H_ \ No newline at end of file +#endif // PWGLF_DATAMODEL_LFSTRANGENESSMLTABLES_H_ diff --git a/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx b/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx index 0162ff13f2e..e739126feaf 100644 --- a/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx +++ b/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx @@ -356,4 +356,4 @@ struct cascadeMLSelectionTreeCreator { WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{adaptAnalysisTask(cfgc)}; -} \ No newline at end of file +} diff --git a/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx b/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx index b693c5ae085..9791e9d3f24 100644 --- a/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx +++ b/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx @@ -289,4 +289,4 @@ struct lambdakzeroMLSelectionTreeCreator { WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{adaptAnalysisTask(cfgc)}; -} \ No newline at end of file +} diff --git a/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx b/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx index f61d0e67e6d..36d37b2ecb3 100644 --- a/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx +++ b/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx @@ -729,36 +729,36 @@ struct lambdakzeroBuilder { if (mlConfigurations.calculateLambdaScores) { bool retrieveSuccessLambda = ccdbApi.retrieveBlob(mlConfigurations.modelPathCCDB, ".", metadata, timeStampML, false, mlConfigurations.localModelPathLambda.value); - if (retrieveSuccessLambda) + if (retrieveSuccessLambda){ mlModelLambda.initModel(mlConfigurations.localModelPathLambda.value, mlConfigurations.enableOptimizations.value); - else { + }else { LOG(fatal) << "Error encountered while fetching/loading the Lambda model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?"; } } if (mlConfigurations.calculateAntiLambdaScores) { bool retrieveSuccessAntiLambda = ccdbApi.retrieveBlob(mlConfigurations.modelPathCCDB, ".", metadata, timeStampML, false, mlConfigurations.localModelPathAntiLambda.value); - if (retrieveSuccessAntiLambda) + if (retrieveSuccessAntiLambda){ mlModelAntiLambda.initModel(mlConfigurations.localModelPathAntiLambda.value, mlConfigurations.enableOptimizations.value); - else { + } else { LOG(fatal) << "Error encountered while fetching/loading the AntiLambda model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?"; } } if (mlConfigurations.calculateGammaScores) { bool retrieveSuccessGamma = ccdbApi.retrieveBlob(mlConfigurations.modelPathCCDB, ".", metadata, timeStampML, false, mlConfigurations.localModelPathGamma.value); - if (retrieveSuccessGamma) + if (retrieveSuccessGamma) { mlModelGamma.initModel(mlConfigurations.localModelPathGamma.value, mlConfigurations.enableOptimizations.value); - else { + } else { LOG(fatal) << "Error encountered while fetching/loading the Gamma model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?"; } } if (mlConfigurations.calculateK0ShortScores) { bool retrieveSuccessKZeroShort = ccdbApi.retrieveBlob(mlConfigurations.modelPathCCDB, ".", metadata, timeStampML, false, mlConfigurations.localModelPathK0Short.value); - if (retrieveSuccessKZeroShort) + if (retrieveSuccessKZeroShort) { mlModelK0Short.initModel(mlConfigurations.localModelPathK0Short.value, mlConfigurations.enableOptimizations.value); - else { + } else { LOG(fatal) << "Error encountered while fetching/loading the K0Short model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?"; } } diff --git a/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx b/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx index d50bd718d94..d08de4613d8 100644 --- a/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx +++ b/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx @@ -122,36 +122,36 @@ struct lambdakzeromlselection { if (PredictLambda) { bool retrieveSuccessLambda = ccdbApi.retrieveBlob(BDTPathCCDB.value, ".", metadata, timestampCCDB.value, false, BDTLocalPathLambda.value); - if (retrieveSuccessLambda) + if (retrieveSuccessLambda){ lambda_bdt.initModel(BDTLocalPathLambda.value, enableOptimizations.value); - else { + } else { LOG(fatal) << "Error encountered while fetching/loading the Lambda model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?"; } } if (PredictAntiLambda) { bool retrieveSuccessAntiLambda = ccdbApi.retrieveBlob(BDTPathCCDB.value, ".", metadata, timestampCCDB.value, false, BDTLocalPathAntiLambda.value); - if (retrieveSuccessAntiLambda) + if (retrieveSuccessAntiLambda) { antilambda_bdt.initModel(BDTLocalPathAntiLambda.value, enableOptimizations.value); - else { + } else { LOG(fatal) << "Error encountered while fetching/loading the AntiLambda model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?"; } } if (PredictGamma) { bool retrieveSuccessGamma = ccdbApi.retrieveBlob(BDTPathCCDB.value, ".", metadata, timestampCCDB.value, false, BDTLocalPathGamma.value); - if (retrieveSuccessGamma) + if (retrieveSuccessGamma) { gamma_bdt.initModel(BDTLocalPathGamma.value, enableOptimizations.value); - else { + } else { LOG(fatal) << "Error encountered while fetching/loading the Gamma model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?"; } } if (PredictKZeroShort) { bool retrieveSuccessKZeroShort = ccdbApi.retrieveBlob(BDTPathCCDB.value, ".", metadata, timestampCCDB.value, false, BDTLocalPathKZeroShort.value); - if (retrieveSuccessKZeroShort) + if (retrieveSuccessKZeroShort) { kzeroshort_bdt.initModel(BDTLocalPathKZeroShort.value, enableOptimizations.value); - else { + } else { LOG(fatal) << "Error encountered while fetching/loading the KZeroShort model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?"; } } diff --git a/PWGLF/Tasks/Strangeness/sigmaanalysis.cxx b/PWGLF/Tasks/Strangeness/sigmaanalysis.cxx index d58895bc27d..0dd66cdbefb 100644 --- a/PWGLF/Tasks/Strangeness/sigmaanalysis.cxx +++ b/PWGLF/Tasks/Strangeness/sigmaanalysis.cxx @@ -306,4 +306,4 @@ struct sigmaanalysis { WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{adaptAnalysisTask(cfgc)}; -} \ No newline at end of file +} From f4c32c9e288574ef468c471b2e2bb82bd30555de Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Fri, 12 Apr 2024 20:15:30 +0000 Subject: [PATCH 22/26] Please consider the following formatting changes --- PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx | 6 +++--- PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx b/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx index 36d37b2ecb3..8574c5cce0e 100644 --- a/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx +++ b/PWGLF/TableProducer/Strangeness/lambdakzerobuilder.cxx @@ -729,16 +729,16 @@ struct lambdakzeroBuilder { if (mlConfigurations.calculateLambdaScores) { bool retrieveSuccessLambda = ccdbApi.retrieveBlob(mlConfigurations.modelPathCCDB, ".", metadata, timeStampML, false, mlConfigurations.localModelPathLambda.value); - if (retrieveSuccessLambda){ + if (retrieveSuccessLambda) { mlModelLambda.initModel(mlConfigurations.localModelPathLambda.value, mlConfigurations.enableOptimizations.value); - }else { + } else { LOG(fatal) << "Error encountered while fetching/loading the Lambda model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?"; } } if (mlConfigurations.calculateAntiLambdaScores) { bool retrieveSuccessAntiLambda = ccdbApi.retrieveBlob(mlConfigurations.modelPathCCDB, ".", metadata, timeStampML, false, mlConfigurations.localModelPathAntiLambda.value); - if (retrieveSuccessAntiLambda){ + if (retrieveSuccessAntiLambda) { mlModelAntiLambda.initModel(mlConfigurations.localModelPathAntiLambda.value, mlConfigurations.enableOptimizations.value); } else { LOG(fatal) << "Error encountered while fetching/loading the AntiLambda model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?"; diff --git a/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx b/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx index d08de4613d8..d2a5070ac19 100644 --- a/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx +++ b/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx @@ -122,7 +122,7 @@ struct lambdakzeromlselection { if (PredictLambda) { bool retrieveSuccessLambda = ccdbApi.retrieveBlob(BDTPathCCDB.value, ".", metadata, timestampCCDB.value, false, BDTLocalPathLambda.value); - if (retrieveSuccessLambda){ + if (retrieveSuccessLambda) { lambda_bdt.initModel(BDTLocalPathLambda.value, enableOptimizations.value); } else { LOG(fatal) << "Error encountered while fetching/loading the Lambda model from CCDB! Maybe the model doesn't exist yet for this runnumber/timestamp?"; From a4545337cbb24fae0e7c1ba60d46ca28d0c1cfeb Mon Sep 17 00:00:00 2001 From: ddobrigk Date: Fri, 12 Apr 2024 22:24:17 +0200 Subject: [PATCH 23/26] Megalinter order errors fixed --- .../Strangeness/cascadeMLSelectionTreeCreator.cxx | 10 +++++----- .../Strangeness/lambdakzeroMLSelectionTreeCreator.cxx | 10 +++++----- PWGLF/TableProducer/Strangeness/sigma0builder.cxx | 10 +++++----- PWGLF/Tasks/Strangeness/sigmaanalysis.cxx | 10 +++++----- 4 files changed, 20 insertions(+), 20 deletions(-) diff --git a/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx b/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx index e739126feaf..d01ad3a2bd0 100644 --- a/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx +++ b/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx @@ -23,6 +23,11 @@ // david.dobrigkeit.chinellato@cern.ch // +#include // C system +#include // C++ system +#include // C++ system +#include // C++ system + #include "Framework/runDataProcessing.h" #include "Framework/RunningWorkflowInfo.h" #include "Framework/AnalysisTask.h" @@ -43,17 +48,12 @@ #include "CCDB/BasicCCDBManager.h" #include "CommonConstants/PhysicsConstants.h" #include "Common/TableProducer/PID/pidTOFBase.h" - #include #include #include #include -#include #include #include -#include -#include -#include using namespace o2; using namespace o2::framework; diff --git a/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx b/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx index 9791e9d3f24..19583ecf0ea 100644 --- a/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx +++ b/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx @@ -24,6 +24,11 @@ // david.dobrigkeit.chinellato@cern.ch // +#include // C system +#include // C++ system +#include // C++ system +#include // C++ system + #include "Framework/runDataProcessing.h" #include "Framework/RunningWorkflowInfo.h" #include "Framework/AnalysisTask.h" @@ -44,17 +49,12 @@ #include "CCDB/BasicCCDBManager.h" #include "CommonConstants/PhysicsConstants.h" #include "Common/TableProducer/PID/pidTOFBase.h" - #include #include #include #include -#include #include #include -#include -#include -#include using namespace o2; using namespace o2::framework; diff --git a/PWGLF/TableProducer/Strangeness/sigma0builder.cxx b/PWGLF/TableProducer/Strangeness/sigma0builder.cxx index 989de846377..e3d6e3442a2 100644 --- a/PWGLF/TableProducer/Strangeness/sigma0builder.cxx +++ b/PWGLF/TableProducer/Strangeness/sigma0builder.cxx @@ -12,6 +12,11 @@ // This is a task that employs the standard V0 tables and attempts to combine // two V0s into a Sigma0 -> Lambda + gamma candidate. +#include +#include +#include +#include + #include "Framework/runDataProcessing.h" #include "Framework/AnalysisTask.h" #include "Framework/AnalysisDataModel.h" @@ -30,17 +35,12 @@ #include "Common/DataModel/Centrality.h" #include "Common/DataModel/PIDResponse.h" #include "CCDB/BasicCCDBManager.h" - #include #include #include #include -#include #include #include -#include -#include -#include using namespace o2; using namespace o2::framework; diff --git a/PWGLF/Tasks/Strangeness/sigmaanalysis.cxx b/PWGLF/Tasks/Strangeness/sigmaanalysis.cxx index 0dd66cdbefb..a6eeb697198 100644 --- a/PWGLF/Tasks/Strangeness/sigmaanalysis.cxx +++ b/PWGLF/Tasks/Strangeness/sigmaanalysis.cxx @@ -12,6 +12,11 @@ // This is a task that employs the standard V0 tables and attempts to combine // two V0s into a Sigma0 -> Lambda + gamma candidate. +#include +#include +#include +#include + #include "Framework/runDataProcessing.h" #include "Framework/AnalysisTask.h" #include "Framework/AnalysisDataModel.h" @@ -30,17 +35,12 @@ #include "Common/DataModel/Centrality.h" #include "Common/DataModel/PIDResponse.h" #include "CCDB/BasicCCDBManager.h" - #include #include #include #include -#include #include #include -#include -#include -#include using namespace o2; using namespace o2::framework; From 491c2d835e0f4fdfaa58327decc2929313986ca8 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Fri, 12 Apr 2024 20:25:07 +0000 Subject: [PATCH 24/26] Please consider the following formatting changes --- .../Strangeness/cascadeMLSelectionTreeCreator.cxx | 6 +++--- .../Strangeness/lambdakzeroMLSelectionTreeCreator.cxx | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx b/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx index d01ad3a2bd0..f3bfc813c89 100644 --- a/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx +++ b/PWGLF/TableProducer/Strangeness/cascadeMLSelectionTreeCreator.cxx @@ -24,9 +24,9 @@ // #include // C system -#include // C++ system -#include // C++ system -#include // C++ system +#include // C++ system +#include // C++ system +#include // C++ system #include "Framework/runDataProcessing.h" #include "Framework/RunningWorkflowInfo.h" diff --git a/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx b/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx index 19583ecf0ea..90956918a3b 100644 --- a/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx +++ b/PWGLF/TableProducer/Strangeness/lambdakzeroMLSelectionTreeCreator.cxx @@ -25,9 +25,9 @@ // #include // C system -#include // C++ system -#include // C++ system -#include // C++ system +#include // C++ system +#include // C++ system +#include // C++ system #include "Framework/runDataProcessing.h" #include "Framework/RunningWorkflowInfo.h" From 0e7b6b1b3fc9cc41f346084b19a6835de5b2aaa2 Mon Sep 17 00:00:00 2001 From: ddobrigk Date: Fri, 12 Apr 2024 22:30:19 +0200 Subject: [PATCH 25/26] Fix one last ordering issue --- .../Strangeness/lambdakzeromlselection.cxx | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx b/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx index d2a5070ac19..53c353193a6 100644 --- a/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx +++ b/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx @@ -20,6 +20,11 @@ // david.dobrigkeit.chinellato@cern.ch // +#include +#include +#include +#include + #include "Framework/runDataProcessing.h" #include "Framework/AnalysisTask.h" #include "Framework/HistogramRegistry.h" @@ -38,18 +43,12 @@ #include "Common/DataModel/Centrality.h" #include "Common/DataModel/PIDResponse.h" #include "CCDB/BasicCCDBManager.h" - #include #include #include #include -#include #include #include -#include -#include -#include - #include "Tools/ML/MlResponse.h" #include "Tools/ML/model.h" From 21b7448441de1af33c5229eaffbb0315ec03ed05 Mon Sep 17 00:00:00 2001 From: ddobrigk Date: Fri, 12 Apr 2024 22:39:12 +0200 Subject: [PATCH 26/26] Fix LAST megalinter error phew phew --- PWGLF/TableProducer/Strangeness/sigma0builder.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGLF/TableProducer/Strangeness/sigma0builder.cxx b/PWGLF/TableProducer/Strangeness/sigma0builder.cxx index e3d6e3442a2..2a3974588ef 100644 --- a/PWGLF/TableProducer/Strangeness/sigma0builder.cxx +++ b/PWGLF/TableProducer/Strangeness/sigma0builder.cxx @@ -172,4 +172,4 @@ struct sigma0builder { WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{adaptAnalysisTask(cfgc)}; -} \ No newline at end of file +}