diff --git a/ALICE3/DataModel/collisionAlice3.h b/ALICE3/DataModel/collisionAlice3.h index a1238e9e1d9..e0a9a2f7a76 100644 --- a/ALICE3/DataModel/collisionAlice3.h +++ b/ALICE3/DataModel/collisionAlice3.h @@ -32,6 +32,20 @@ DECLARE_SOA_TABLE(CollisionsAlice3, "AOD", "COLLALICE3", using CollisionAlice3 = CollisionsAlice3::iterator; +namespace mcmult_alice3 +{ +DECLARE_SOA_COLUMN(MultMC, multMC, int); //! Total MCTruth multiplicity +DECLARE_SOA_COLUMN(MultMC25, multMC25, int); //! MCTruth multiplicity in |eta| < 2.5 +DECLARE_SOA_COLUMN(MultMC125, multMC125, int); //! MCTruth multiplicity in |eta| < 1.25 +DECLARE_SOA_COLUMN(MultMC09, multMC09, int); //! MCTruth multiplicity in |eta| < 0.9 +} // namespace mcmult_alice3 +DECLARE_SOA_TABLE(MultsMCAlice3, "AOD", "MULTMCALICE3", + mcmult_alice3::MultMC, + mcmult_alice3::MultMC25, + mcmult_alice3::MultMC125, + mcmult_alice3::MultMC09); + +using MultMCAlice3 = MultsMCAlice3::iterator; } // namespace o2::aod #endif // ALICE3_DATAMODEL_COLLISIONALICE3_H_ diff --git a/ALICE3/DataModel/tracksAlice3.h b/ALICE3/DataModel/tracksAlice3.h index b6ccc587d91..afd491ab4b2 100644 --- a/ALICE3/DataModel/tracksAlice3.h +++ b/ALICE3/DataModel/tracksAlice3.h @@ -31,6 +31,7 @@ DECLARE_SOA_COLUMN(NSiliconHits, nSiliconHits, int); //! number of silico DECLARE_SOA_COLUMN(NTPCHits, nTPCHits, int); //! number of tpc hits DECLARE_SOA_COLUMN(PdgCode, pdgCode, int); //! PDG code of the linked truth MC particle DECLARE_SOA_COLUMN(TrackType, trackType, int); //! Type of the track +DECLARE_SOA_COLUMN(IsPVContributor, isPVContributor, bool); //! Has track contributed to the PV fit? } // namespace track_alice3 DECLARE_SOA_TABLE(TracksAlice3, "AOD", "TRACKSALICE3", track_alice3::IsReconstructed); @@ -43,7 +44,8 @@ using TrackAlice3Pdg = TracksAlice3Pdg::iterator; DECLARE_SOA_TABLE(TracksExtraA3, "AOD", "TracksExtraA3", track_alice3::NSiliconHits, track_alice3::NTPCHits, - track_alice3::TrackType); + track_alice3::TrackType, + track_alice3::IsPVContributor); using TrackExtraA3 = TracksExtraA3::iterator; namespace mcparticle_alice3 diff --git a/ALICE3/TableProducer/CMakeLists.txt b/ALICE3/TableProducer/CMakeLists.txt index c4494730197..ce2e49bea57 100644 --- a/ALICE3/TableProducer/CMakeLists.txt +++ b/ALICE3/TableProducer/CMakeLists.txt @@ -26,6 +26,11 @@ o2physics_add_dpl_workflow(alice3-centrality PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(alice3-multiplicity + SOURCES alice3Multiplicity.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(alice3-decaypreselector SOURCES alice3-decaypreselector.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2::DCAFitter diff --git a/ALICE3/TableProducer/OTF/onTheFlyTracker.cxx b/ALICE3/TableProducer/OTF/onTheFlyTracker.cxx index 45dee932571..f8c18ba2cb9 100644 --- a/ALICE3/TableProducer/OTF/onTheFlyTracker.cxx +++ b/ALICE3/TableProducer/OTF/onTheFlyTracker.cxx @@ -1776,7 +1776,7 @@ struct OnTheFlyTracker { trackParCov.getSigmaTgl2(), trackParCov.getSigma1PtY(), trackParCov.getSigma1PtZ(), trackParCov.getSigma1PtSnp(), trackParCov.getSigma1PtTgl(), trackParCov.getSigma1Pt2()); tableMcTrackLabels(trackParCov.mcLabel, 0); - tableTracksExtraA3(trackParCov.nSiliconHits, trackParCov.nTPCHits, trackParCov.trackType); + tableTracksExtraA3(trackParCov.nSiliconHits, trackParCov.nTPCHits, trackParCov.trackType, true); // populate extra tables if required to do so if (populateTracksExtra) { diff --git a/ALICE3/TableProducer/alice3Multiplicity.cxx b/ALICE3/TableProducer/alice3Multiplicity.cxx new file mode 100644 index 00000000000..baa2fed178c --- /dev/null +++ b/ALICE3/TableProducer/alice3Multiplicity.cxx @@ -0,0 +1,180 @@ +// Copyright 2019-2026 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. +// +/// \author Alexander Tiekoetter , Muenster +/// \brief Multiplicity task for ALICE3 +/// \file alice3Multiplicity.cxx + +#include "ALICE3/DataModel/collisionAlice3.h" +#include "ALICE3/DataModel/tracksAlice3.h" +#include "Common/DataModel/Multiplicity.h" +#include "Common/DataModel/TrackSelectionTables.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; + +using TracksAlice3 = soa::Join; + +struct Alice3Multiplicity { + Produces multPV; + Produces multGlobal; + Produces multMC; + + HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; + Configurable minEta{"minEta", -2.5f, "Minimum eta in range for global track counting"}; + Configurable maxEta{"maxEta", 2.5f, "Maximum eta in range for global track counting"}; + Configurable maxDCAxy{"maxDCAxy", 0.0025f, "Max DCAxy for global track counting"}; + Configurable maxDCAz{"maxDCAz", 0.0025f, "Max DCAz for global track counting"}; + Configurable minSiliconHits{"minSiliconHits", 5, "Minimum number of hits in silicon detector for global track counting"}; + Configurable requireReconstructed{"requireReconstructed", false, "Require track to be reconstructed for global track counting"}; + Configurable doQA{"doQA", true, "Fill QA histograms"}; + + ConfigurableAxis axisMult{"axisMult", {10000, 0, 10000}, "Reconstructed tracks"}; + + Service pdg; + + Filter trackFilter = (aod::track::eta >= minEta) && (aod::track::eta <= maxEta) && (nabs(aod::track::dcaXY) <= maxDCAxy) && (nabs(aod::track::dcaZ) <= maxDCAz) && (aod::track_alice3::nSiliconHits >= minSiliconHits) && (!requireReconstructed || aod::track_alice3::isReconstructed); + + void init(InitContext&) + { + if (doQA) { + histos.add("multiplicity/nTracksPV", "nTracksPV", kTH1D, {axisMult}); + histos.add("multiplicity/nTracksPVeta1", "nTracksPVeta1", kTH1D, {axisMult}); + histos.add("multiplicity/nTracksPVetaHalf", "nTracksPVetaHalf", kTH1D, {axisMult}); + + histos.add("multiplicity/nTracksGlobal", "nTracksGlobal", kTH1D, {axisMult}); + histos.add("multiplicity/nTracksGlobalPV", "nTracksGlobalPV", kTH1D, {axisMult}); + + histos.add("multiplicity/nTracksMC", "nTracksMC", kTH1D, {axisMult}); + histos.add("multiplicity/nTracksMCEta25", "nTracksMCEta25", kTH1D, {axisMult}); + histos.add("multiplicity/nTracksMCEta125", "nTracksMCEta125", kTH1D, {axisMult}); + histos.add("multiplicity/nTracksMCEta09", "nTracksMCEta09", kTH1D, {axisMult}); + } + } + + void processGlobalTracks(const aod::Collision& /*collision*/, const soa::Filtered& tracks) + { + int globalTracks = 0; + int globalTracksPV = 0; + + for (const auto& track : tracks) { + ++globalTracks; + if (track.isPVContributor()) + ++globalTracksPV; + } + + if (doQA) { + histos.fill(HIST("multiplicity/nTracksGlobal"), globalTracks); + histos.fill(HIST("multiplicity/nTracksGlobalPV"), globalTracksPV); + } + + multGlobal(globalTracks, globalTracksPV, 0, 0); + } + + void processPV(const aod::Collision& /*collision*/, const TracksAlice3& tracks) + { + int numTracksPV = 0; + int numTracksPVeta1 = 0; + int numTracksPVetaHalf = 0; + + for (const auto& track : tracks) { + if (track.isPVContributor()) { + ++numTracksPV; + if (std::abs(track.eta()) < 1.0) + ++numTracksPVeta1; + if (std::abs(track.eta()) < 0.5) + ++numTracksPVetaHalf; + } + } + + if (doQA) { + histos.fill(HIST("multiplicity/nTracksPV"), numTracksPV); + histos.fill(HIST("multiplicity/nTracksPVeta1"), numTracksPVeta1); + histos.fill(HIST("multiplicity/nTracksPVetaHalf"), numTracksPVetaHalf); + } + + multPV(numTracksPV, numTracksPVeta1, numTracksPVetaHalf); + } + + void processMC(aod::McCollision const& /*mcCollision*/, aod::McParticles const& mcParticles) + { + int numMCParticles = 0; + int numMCParticlesEta25 = 0; + int numMCParticlesEta125 = 0; + int numMCParticlesEta09 = 0; + + for (const auto& mcParticle : mcParticles) { + if (!mcParticle.isPhysicalPrimary()) { + continue; + } + + auto charge = 0.; + auto* p = pdg->GetParticle(mcParticle.pdgCode()); + if (p != nullptr) { + charge = p->Charge(); + } + if (std::abs(charge) < 1e-3) { + continue; + } + + ++numMCParticles; + if (std::abs(mcParticle.eta()) < 2.5) + ++numMCParticlesEta25; + if (std::abs(mcParticle.eta()) < 1.25) + ++numMCParticlesEta125; + if (std::abs(mcParticle.eta()) < 0.9) + ++numMCParticlesEta09; + } + + if (doQA) { + histos.fill(HIST("multiplicity/nTracksMC"), numMCParticles); + histos.fill(HIST("multiplicity/nTracksMCEta25"), numMCParticlesEta25); + histos.fill(HIST("multiplicity/nTracksMCEta125"), numMCParticlesEta125); + histos.fill(HIST("multiplicity/nTracksMCEta09"), numMCParticlesEta09); + } + + multMC(numMCParticles, numMCParticlesEta25, numMCParticlesEta125, numMCParticlesEta09); + } + + void processDummy(const aod::Collision&) + { + // do nothing + } + + PROCESS_SWITCH(Alice3Multiplicity, processGlobalTracks, "Process global track counter", false); + PROCESS_SWITCH(Alice3Multiplicity, processPV, "Process primary vertex contributor tracks", false); + PROCESS_SWITCH(Alice3Multiplicity, processMC, "Process MC truth information", false); + PROCESS_SWITCH(Alice3Multiplicity, processDummy, "Dummy proccess function", true); +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{adaptAnalysisTask(cfgc)}; +} diff --git a/ALICE3/TableProducer/alice3TrackingTranslator.cxx b/ALICE3/TableProducer/alice3TrackingTranslator.cxx index d9b2d3874f6..560e511e4f2 100644 --- a/ALICE3/TableProducer/alice3TrackingTranslator.cxx +++ b/ALICE3/TableProducer/alice3TrackingTranslator.cxx @@ -583,7 +583,8 @@ struct Alice3TrackingTranslator { tableTracksExtraA3(m_nMeasurements, // nSiliconHits (using m_nMeasurements as proxy) 0, // nTPCHits - 0); // trackType + 0, // trackType + false); // isPVContributor // Fill extra track info tableStoredTracksExtra(0.f, // TPCInnerParam