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 0deff6d1c8e..5cd2c72412f 100644 --- a/ALICE3/TableProducer/OTF/onTheFlyTracker.cxx +++ b/ALICE3/TableProducer/OTF/onTheFlyTracker.cxx @@ -275,6 +275,7 @@ struct OnTheFlyTracker { const float time = 0, const float timeError = 1, bool decayDauInput = false, + bool isPVContributorInput = false, bool weakDecayDauInput = false, int isUsedInCascadingInput = 0, int nSiliconHitsInput = 0, @@ -283,19 +284,21 @@ struct OnTheFlyTracker { mcLabel{label}, timeEst{time, timeError}, isDecayDau(decayDauInput), + isPVContributor(isPVContributorInput), isWeakDecayDau(weakDecayDauInput), isUsedInCascading(isUsedInCascadingInput), nSiliconHits(nSiliconHitsInput), nTPCHits(nTPCHitsInput), trackType(trackTypeInput) {} const TimeEst& getTimeMUS() const { return timeEst; } - int64_t mcLabel = -1; ///< MC label of the track - TimeEst timeEst{}; ///< time estimate in ns - bool isDecayDau = false; ///< is a decay daughter - bool isWeakDecayDau = false; ///< is a weak decay daughter - int isUsedInCascading = 0; ///< 0: not at all, 1: is a cascade, 2: is a bachelor, 3: is a pion, 4: is a proton - int nSiliconHits = 0; ///< number of silicon hits - int nTPCHits = 0; ///< number of TPC hits + int64_t mcLabel = -1; ///< MC label of the track + TimeEst timeEst{}; ///< time estimate in ns + bool isDecayDau = false; ///< is a decay daughter + bool isPVContributor = false; ///< track is PV contributor + bool isWeakDecayDau = false; ///< is a weak decay daughter + int isUsedInCascading = 0; ///< 0: not at all, 1: is a cascade, 2: is a bachelor, 3: is a pion, 4: is a proton + int nSiliconHits = 0; ///< number of silicon hits + int nTPCHits = 0; ///< number of TPC hits TrackType trackType; }; @@ -1004,13 +1007,13 @@ struct OnTheFlyTracker { thisCascade.cascadeTrackId = trackTableOffset + 4; float trackTime = (eventCollisionTimeNS + gRandom->Gaus(0., timeResolutionNs)) * nsToMus; - tracksCascadeProngs.push_back(TrackAlice3{xiDaughterTrackParCovsPerfect[0], mcParticle.globalIndex(), trackTime, timeResolutionUs, true, true, 1, -1, -1, TrackType::kGenCascDaug}); + tracksCascadeProngs.push_back(TrackAlice3{xiDaughterTrackParCovsPerfect[0], mcParticle.globalIndex(), trackTime, timeResolutionUs, true, false, true, 1, -1, -1, TrackType::kGenCascDaug}); trackTime = (eventCollisionTimeNS + gRandom->Gaus(0., timeResolutionNs)) * nsToMus; - tracksCascadeProngs.push_back(TrackAlice3{xiDaughterTrackParCovsPerfect[1], mcParticle.globalIndex(), trackTime, timeResolutionUs, true, true, 2, -1, -1, TrackType::kGenCascDaug}); + tracksCascadeProngs.push_back(TrackAlice3{xiDaughterTrackParCovsPerfect[1], mcParticle.globalIndex(), trackTime, timeResolutionUs, true, false, true, 2, -1, -1, TrackType::kGenCascDaug}); trackTime = (eventCollisionTimeNS + gRandom->Gaus(0., timeResolutionNs)) * nsToMus; - tracksCascadeProngs.push_back(TrackAlice3{xiDaughterTrackParCovsPerfect[2], mcParticle.globalIndex(), trackTime, timeResolutionUs, true, true, 3, -1, -1, TrackType::kGenCascDaug}); + tracksCascadeProngs.push_back(TrackAlice3{xiDaughterTrackParCovsPerfect[2], mcParticle.globalIndex(), trackTime, timeResolutionUs, true, false, true, 3, -1, -1, TrackType::kGenCascDaug}); trackTime = (eventCollisionTimeNS + gRandom->Gaus(0., timeResolutionNs)) * nsToMus; - tracksCascadeProngs.push_back(TrackAlice3{perfectCascadeTrack, mcParticle.globalIndex(), trackTime, timeResolutionUs, true, true, 3, -1, -1, TrackType::kGenCascDaug}); + tracksCascadeProngs.push_back(TrackAlice3{perfectCascadeTrack, mcParticle.globalIndex(), trackTime, timeResolutionUs, true, false, true, 3, -1, -1, TrackType::kGenCascDaug}); for (int i = 0; i < kCascProngs; i++) { isReco[i] = false; @@ -1061,7 +1064,7 @@ struct OnTheFlyTracker { trackTime = (eventCollisionTimeNS + gRandom->Gaus(0., timeResolutionNs)) * nsToMus; // TODO: add flag for whether it's a ghost track or not, currently assuming all are reconstructed tracks if they pass the fast tracker requirements TrackType trackType = isReco[i] ? TrackType::kRecoCascDaug : TrackType::kGenCascDaug; - tracksCascadeProngs[i] = TrackAlice3{xiDaughterTrackParCovsTracked[i], mcParticle.globalIndex(), trackTime, timeResolutionUs, true, true, i + 2, nSiliconHitsCascadeProngs[i], nTPCHitsCascadeProngs[i], trackType}; + tracksCascadeProngs[i] = TrackAlice3{xiDaughterTrackParCovsTracked[i], mcParticle.globalIndex(), trackTime, timeResolutionUs, true, false, true, i + 2, nSiliconHitsCascadeProngs[i], nTPCHitsCascadeProngs[i], trackType}; } bool tryKinkReco = false; @@ -1272,7 +1275,7 @@ struct OnTheFlyTracker { return; // We didn't find enough hits for strangeness tracking } } - tracksCascadeProngs[kCascProngs] = TrackAlice3{cascadeTrack, mcParticle.globalIndex(), trackTime, timeResolutionUs, false, false, 1, thisCascade.foundClusters, TrackType::kGenCascDaug}; + tracksCascadeProngs[kCascProngs] = TrackAlice3{cascadeTrack, mcParticle.globalIndex(), trackTime, timeResolutionUs, false, false, false, 1, thisCascade.foundClusters, TrackType::kGenCascDaug}; fillCascadeTable = true; } } @@ -1342,7 +1345,10 @@ struct OnTheFlyTracker { std::array{o2::constants::physics::MassPionCharged, o2::constants::physics::MassLambda}); newCascadeTrack.setPID(pdgCodeToPID(PDG_t::kXiMinus)); // FIXME: not OK for omegas float trackTime = (eventCollisionTimeNS + gRandom->Gaus(0., timeResolutionNs)) * nsToMus; - tracksCascadeProngs[kCascProngs + 1] = TrackAlice3{newCascadeTrack, mcParticle.globalIndex(), trackTime, timeResolutionUs, false, false, 1, thisCascade.foundClusters, 0, TrackType::kRecoCascDaug}; + if (reconstructedCascade) { + tracksCascadeProngs[kCascProngs + 1] = TrackAlice3{newCascadeTrack, mcParticle.globalIndex(), trackTime, timeResolutionUs, false, false, false, 1, thisCascade.foundClusters, TrackType::kRecoCascDaug}; + } + tracksCascadeProngs[kCascProngs + 1] = TrackAlice3{newCascadeTrack, mcParticle.globalIndex(), trackTime, timeResolutionUs, false, false, false, 1, thisCascade.foundClusters, 0, TrackType::kRecoCascDaug}; fillCascadeTable = true; } // end fitter OK } // end cascade found @@ -1490,9 +1496,12 @@ struct OnTheFlyTracker { // Store not reconstructed daughters, will update them in case reconstruction is successful float trackTime = (eventCollisionTimeNS + gRandom->Gaus(0., timeResolutionNs)) * nsToMus; - tracksV0Daugs.push_back(TrackAlice3{v0DaughterTrackParCovsPerfect[0], mcParticle.globalIndex(), 0.f, timeResolutionUs, true, true, 1, 0, 0, TrackType::kGhostV0Daug}); + tracksV0Daugs.push_back(TrackAlice3{v0DaughterTrackParCovsPerfect[0], mcParticle.globalIndex(), 0.f, timeResolutionUs, true, false, true, 1, TrackType::kGhostV0Daug}); + trackTime = (eventCollisionTimeNS + gRandom->Gaus(0., timeResolutionNs)) * nsToMus; + tracksV0Daugs.push_back(TrackAlice3{v0DaughterTrackParCovsPerfect[1], mcParticle.globalIndex(), 0.f, timeResolutionUs, true, false, true, 1, TrackType::kGhostV0Daug}); + tracksV0Daugs.push_back(TrackAlice3{v0DaughterTrackParCovsPerfect[0], mcParticle.globalIndex(), 0.f, timeResolutionUs, true, false, true, 1, 0, 0, TrackType::kGhostV0Daug}); trackTime = (eventCollisionTimeNS + gRandom->Gaus(0., timeResolutionNs)) * nsToMus; - tracksV0Daugs.push_back(TrackAlice3{v0DaughterTrackParCovsPerfect[1], mcParticle.globalIndex(), 0.f, timeResolutionUs, true, true, 1, 0, 0, TrackType::kGhostV0Daug}); + tracksV0Daugs.push_back(TrackAlice3{v0DaughterTrackParCovsPerfect[1], mcParticle.globalIndex(), 0.f, timeResolutionUs, true, false, true, 1, 0, 0, TrackType::kGhostV0Daug}); bool fillV0Table{false}; for (int i = 0; i < kv0Prongs; i++) { @@ -1529,7 +1538,7 @@ struct OnTheFlyTracker { trackTime = (eventCollisionTimeNS + gRandom->Gaus(0., timeResolutionNs)) * nsToMus; // TODO: flag to separate ghost and reco tracks TrackType trackType = isV0Reco[i] ? TrackType::kRecoV0Daug : TrackType::kGhostV0Daug; - tracksV0Daugs[i] = TrackAlice3{v0DaughterTrackParCovsTracked[i], mcParticle.globalIndex(), trackTime, timeResolutionUs, true, true, i + 2, trackType}; + tracksV0Daugs[i] = TrackAlice3{v0DaughterTrackParCovsTracked[i], mcParticle.globalIndex(), trackTime, timeResolutionUs, true, false, true, i + 2, trackType}; } if (v0DecaySettings.doV0QA) { if (isV0Reco[0] && isV0Reco[1]) { @@ -1680,8 +1689,8 @@ struct OnTheFlyTracker { /// \param prmTrks the vector of tracks to be used for vertex reconstruction /// \param primaryVertex the output variable where the computed primary vertex will be stored /// \param icfg index of the current configuration, used for histogram filling - template - void computeVertex(McCollisionType& mcCollision, const std::vector& prmTrks, o2::vertexing::PVertex& primaryVertex, const int icfg) + template + void computeVertex(McCollisionType& mcCollision, std::vector& prmTrks, o2::vertexing::PVertex& primaryVertex, const int icfg) { if (!enablePrimaryVertexing) { @@ -1733,7 +1742,18 @@ struct OnTheFlyTracker { largestVertex = iv; } } + primaryVertex = vertices[largestVertex]; + + const auto& contributorRef = v2tRefs[largestVertex]; + const int first = contributorRef.getFirstEntry(); + const int end = first + contributorRef.getEntries(); + + for (int i = first; i < end; ++i) { + const auto trackIndex = vertexTrackIDs[i].getIndex(); + prmTrks[trackIndex].isPVContributor = true; + } + if (doExtraQA) { histos.fill(HIST("h2dVerticesVsContributors"), primaryVertex.getNContributors(), n_vertices); } @@ -1784,7 +1804,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, trackParCov.isPVContributor); // populate extra tables if required to do so if (populateTracksExtra) { @@ -1977,10 +1997,11 @@ struct OnTheFlyTracker { // Time associated to the mcParticle: collision time + smearing float trackTime = (eventCollisionTimeNS + gRandom->Gaus(0., timeResolutionNs)) * nsToMus; TrackType trackType = reconstructed ? TrackType::kRecoPrimary : TrackType::kGhostPrimary; + bool isPVContributor = trackType == TrackType::kRecoPrimary; if (reconstructed) { - recoPrimaries.push_back(TrackAlice3{trackParCov, mcParticle.globalIndex(), trackTime, timeResolutionUs, isDecayDaughter, false, 0, nTrkHits, trackType}); + recoPrimaries.push_back(TrackAlice3{trackParCov, mcParticle.globalIndex(), trackTime, timeResolutionUs, isDecayDaughter, isPVContributor, false, 0, nTrkHits, trackType}); } else { - ghostPrimaries.push_back(TrackAlice3{trackParCov, mcParticle.globalIndex(), trackTime, timeResolutionUs, isDecayDaughter, false, 0, nTrkHits, trackType}); + ghostPrimaries.push_back(TrackAlice3{trackParCov, mcParticle.globalIndex(), trackTime, timeResolutionUs, isDecayDaughter, isPVContributor, false, 0, nTrkHits, trackType}); } } @@ -2202,10 +2223,10 @@ struct OnTheFlyTracker { } if (reconstructed) { - tracksAlice3.push_back(TrackAlice3{trackParCov, mcParticle.globalIndex(), time, timeResolutionUs, isSecondary, false, 0, nTrkHits, kRecoPrimary}); + tracksAlice3.push_back(TrackAlice3{trackParCov, mcParticle.globalIndex(), time, timeResolutionUs, isSecondary, true, false, 0, nTrkHits, kRecoPrimary}); getHist(histPath + "hPtReconstructedPr")->Fill(trackParCov.getPt()); } else { - ghostTracksAlice3.push_back(TrackAlice3{trackParCov, mcParticle.globalIndex(), time, timeResolutionUs, isSecondary, false, 0, nTrkHits, kGhostPrimary}); + ghostTracksAlice3.push_back(TrackAlice3{trackParCov, mcParticle.globalIndex(), time, timeResolutionUs, isSecondary, false, false, false, 0, nTrkHits, kGhostPrimary}); } } 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 7e44fec2522..ccdcbcf2ac0 100644 --- a/ALICE3/TableProducer/alice3TrackingTranslator.cxx +++ b/ALICE3/TableProducer/alice3TrackingTranslator.cxx @@ -710,7 +710,8 @@ struct Alice3TrackingTranslator { std::cout << "Filling TracksAlice3 and TracksAlice3Pdg tables" << std::endl; tableTracksExtraA3(m_nMeasurements, // nSiliconHits (using m_nMeasurements as proxy) 0, // nTPCHits - 0); // trackType + 0, // trackType + false); // isPVContributor std::cout << "Filling TracksExtraA3 table" << std::endl; // Fill extra track info tableStoredTracksExtra(0.f, // TPCInnerParam