diff --git a/PWGDQ/Core/HistogramsLibrary.cxx b/PWGDQ/Core/HistogramsLibrary.cxx index d4e5e3eb2a8..1db3d47eea2 100644 --- a/PWGDQ/Core/HistogramsLibrary.cxx +++ b/PWGDQ/Core/HistogramsLibrary.cxx @@ -131,6 +131,7 @@ void o2::aod::dqhistograms::DefineHistograms(HistogramManager* hm, const char* h hm->AddHistogram(histClass, "MultFDDC", "MultFDDC", false, 1000, 0.0, 25000.0, VarManager::kMultFDDC); hm->AddHistogram(histClass, "MultTracklets", "MultTracklets", false, 250, 0.0, 250.0, VarManager::kMultTracklets); hm->AddHistogram(histClass, "VtxNContribReal", "Vtx n contributors", false, 150, 0.0, 150.0, VarManager::kVtxNcontribReal); + hm->AddHistogram(histClass, "kMultNtrkGlobal", "kMultNtrkGlobal", false, 150, 0.0, 150.0, VarManager::kMultNtrkGlobal); hm->AddHistogram(histClass, "VtxNContrib", "Vtx n contributors", false, 100, 0.0, 100.0, VarManager::kVtxNcontrib); hm->AddHistogram(histClass, "MultNTracksPVeta1", "MultNTracksPVeta1", false, 150, 0, 150.0, VarManager::kMultNTracksPVeta1); hm->AddHistogram(histClass, "MultNTracksPVetaHalf", "MultNTracksPVetaHalf", false, 150, 0, 150.0, VarManager::kMultNTracksPVetaHalf); @@ -153,6 +154,7 @@ void o2::aod::dqhistograms::DefineHistograms(HistogramManager* hm, const char* h hm->AddHistogram(histClass, "VtxZ_MultITSTPCWithPV", "VtxZ vs MultITSTPCWithPV", false, 240, -12.0, 12.0, VarManager::kVtxZ, 400, 0, 400.0, VarManager::kMultNTracksITSTPC); hm->AddHistogram(histClass, "VtxZ_MultITSOnly", "VtxZ vs MultITSOnly", false, 240, -12.0, 12.0, VarManager::kVtxZ, 400, 0, 400.0, VarManager::kMultNTracksITSOnly); hm->AddHistogram(histClass, "VtxZ_VtxNcontribReal", "VtxZ vs VtxNcontribReal", false, 100, -10.0, 10.0, VarManager::kVtxZ, 150, 0, 150.0, VarManager::kVtxNcontribReal); + hm->AddHistogram(histClass, "VtxZ_MultNtrkGlobal", "VtxZ vs MultNtrkGlobal", false, 100, -10.0, 10.0, VarManager::kVtxZ, 150, 0, 150.0, VarManager::kMultNtrkGlobal); hm->AddHistogram(histClass, "VtxZ_MultNTracksPVeta1", "VtxZ vs MultNTracksPVeta1", false, 100, -10.0, 10.0, VarManager::kVtxZ, 150, 0, 150.0, VarManager::kMultNTracksPVeta1); hm->AddHistogram(histClass, "VtxZ_MultNTracksPVetaHalf", "VtxZ vs MultNTracksPVetaHalf", false, 100, -10.0, 10.0, VarManager::kVtxZ, 150, 0, 150.0, VarManager::kMultNTracksPVetaHalf); hm->AddHistogram(histClass, "VtxZ_MultFV0A", "VtxZ vs MultFV0A", false, 20, -10.0, 10.0, VarManager::kVtxZ, 200, 0, 25000.0, VarManager::kMultFV0A); @@ -160,10 +162,14 @@ void o2::aod::dqhistograms::DefineHistograms(HistogramManager* hm, const char* h hm->AddHistogram(histClass, "VtxZ_MultFT0C", "VtxZ vs MultFT0C", false, 20, -10.0, 10.0, VarManager::kVtxZ, 200, 0, 25000.0, VarManager::kMultFT0C); hm->AddHistogram(histClass, "VtxZ_MultFDDA", "VtxZ vs MultFDDA", false, 20, -10.0, 10.0, VarManager::kVtxZ, 200, 0, 25000.0, VarManager::kMultFDDA); hm->AddHistogram(histClass, "VtxZ_MultFDDC", "VtxZ vs MultFDDC", false, 20, -10.0, 10.0, VarManager::kVtxZ, 200, 0, 25000.0, VarManager::kMultFDDC); + hm->AddHistogram(histClass, "MultNtrkGlobal_VtxNcontribReal", "MultNtrkGlobal vs VtxNcontribReal", false, 150, 0, 150.0, VarManager::kMultNtrkGlobal, 150, 0, 150.0, VarManager::kVtxNcontribReal); hm->AddHistogram(histClass, "MultNTracksPVetaHalf_MultMCNParticlesEta05", "MultNTracksPVetaHalf vs MultMCNParticlesEta05", false, 150, 0, 150.0, VarManager::kMultNTracksPVetaHalf, 150, 0, 150.0, VarManager::kMultMCNParticlesEta05); hm->AddHistogram(histClass, "VtxNcontribReal_MultMCNParticlesEta08", "VtxNcontribReal vs MultMCNParticlesEta08", false, 150, 0, 150.0, VarManager::kVtxNcontribReal, 150, 0, 150.0, VarManager::kMultMCNParticlesEta08); hm->AddHistogram(histClass, "MultNTracksPVeta1_MultMCNParticlesEta10", "MultNTracksPVeta1 vs MultMCNParticlesEta10", false, 150, 0, 150.0, VarManager::kMultNTracksPVeta1, 150, 0, 150.0, VarManager::kMultMCNParticlesEta10); - + hm->AddHistogram(histClass, "MultNtrkGlobal_MultMCNParticlesEta05", "MultNtrkGlobal vs MultMCNParticlesEta05", false, 150, 0, 150.0, VarManager::kMultNtrkGlobal, 150, 0, 150.0, VarManager::kMultMCNParticlesEta05); + hm->AddHistogram(histClass, "MultNtrkGlobal_MultMCNParticlesEta08", "MultNtrkGlobal vs MultMCNParticlesEta08", false, 150, 0, 150.0, VarManager::kMultNtrkGlobal, 150, 0, 150.0, VarManager::kMultMCNParticlesEta08); + hm->AddHistogram(histClass, "MultNtrkGlobal_MultMCNParticlesEta10", "MultNtrkGlobal vs MultMCNParticlesEta10", false, 150, 0, 150.0, VarManager::kMultNtrkGlobal, 150, 0, 150.0, VarManager::kMultMCNParticlesEta10); + hm->AddHistogram(histClass, "MultNtrkGlobal_MultMCNParticlesGlobal", "MultNtrkGlobal vs MultMCNParticlesEta10", false, 150, 0, 150.0, VarManager::kMultNtrkGlobal, 150, 0, 150.0, VarManager::kMultMCGlobalParticles); } else { hm->AddHistogram(histClass, "MultTPC", "MultTPC", false, 200, 0.0, 50000.0, VarManager::kMultTPC); hm->AddHistogram(histClass, "MultTPC_vsTimeSOR", "MultTPC vs time from SOR", true, 10000, 0.0, 1000.0, VarManager::kTimeFromSOR, 10, 0.0, 50000.0, VarManager::kMultTPC); @@ -177,6 +183,7 @@ void o2::aod::dqhistograms::DefineHistograms(HistogramManager* hm, const char* h hm->AddHistogram(histClass, "MultZNA_ZNC", "MultZNA vs ZNC", false, 400, 0.0, 400.0, VarManager::kMultZNA, 400, 0.0, 400.0, VarManager::kMultZNC); hm->AddHistogram(histClass, "MultTracklets", "MultTracklets", false, 100, 0.0, 25000.0, VarManager::kMultTracklets); hm->AddHistogram(histClass, "VtxNContribReal", "Vtx n contributors (real)", false, 100, 0.0, 5000.0, VarManager::kVtxNcontribReal); + hm->AddHistogram(histClass, "kMultNtrkGlobal", "kMultNtrkGlobal", false, 150, 0.0, 150.0, VarManager::kMultNtrkGlobal); hm->AddHistogram(histClass, "VtxNContribReal_vsTimeSOR", "VtxNContribReal vs time from SOR", true, 10000, 0.0, 1000.0, VarManager::kTimeFromSOR, 10, 0.0, 5000.0, VarManager::kVtxNcontribReal); hm->AddHistogram(histClass, "VtxNContrib", "Vtx n contributors", false, 100, 0.0, 20000.0, VarManager::kVtxNcontrib); hm->AddHistogram(histClass, "MultTPC_MultFV0A", "MultTPC vs MultFV0A", false, 100, 0, 50000.0, VarManager::kMultTPC, 100, 0, 300000.0, VarManager::kMultFV0A); @@ -271,6 +278,7 @@ void o2::aod::dqhistograms::DefineHistograms(HistogramManager* hm, const char* h hm->AddHistogram(histClass, "MultMCNParticlesEta05", "MultMCNParticlesEta05", false, 150, 0.0, 150.0, VarManager::kMultMCNParticlesEta05); hm->AddHistogram(histClass, "MultMCNParticlesEta08", "MultMCNParticlesEta08", false, 150, 0.0, 150.0, VarManager::kMultMCNParticlesEta08); hm->AddHistogram(histClass, "MultMCNParticlesEta10", "MultMCNParticlesEta10", false, 150, 0.0, 150.0, VarManager::kMultMCNParticlesEta10); + hm->AddHistogram(histClass, "MultMCGlobalParticles", "MultMCGlobalParticles", false, 150, 0.0, 150.0, VarManager::kMultMCGlobalParticles); } if (subGroupStr.Contains("subgen")) { hm->AddHistogram(histClass, "SubGenID", "SubGenerator ID", false, 11, -0.5, 10.5, VarManager::kMCEventSubGeneratorId); @@ -1405,6 +1413,11 @@ void o2::aod::dqhistograms::DefineHistograms(HistogramManager* hm, const char* h hm->AddHistogram(histClass, "Mass_VtxNcontribReal_VtxZ", "Mass vs VtxNcontribReal vs VtxZ", false, 200, 2.0, 5.0, VarManager::kMass, 150, 0, 150.0, VarManager::kVtxNcontribReal, 20, -10.0, 10.0, VarManager::kVtxZ); hm->AddHistogram(histClass, "VtxZ_VtxNcontribReal", "VtxZ vs VtxNcontribReal", false, 240, -12.0, 12.0, VarManager::kVtxZ, 200, 0, 200.0, VarManager::kVtxNcontribReal); } + if (subGroupStr.Contains("mult_global")) { + hm->AddHistogram(histClass, "Mass_MultGlobal", "Mass vs global tracks", false, 200, 0.0, 5.0, VarManager::kMass, 200, 0, 200.0, VarManager::kMultNtrkGlobal); + hm->AddHistogram(histClass, "Mass_MultGlobal_VtxZ", "Mass vs global tracks vs VtxZ", false, 200, 2.0, 5.0, VarManager::kMass, 150, 0, 150.0, VarManager::kMultNtrkGlobal, 20, -10.0, 10.0, VarManager::kVtxZ); + hm->AddHistogram(histClass, "VtxZ_MultGlobal", "VtxZ vs global tracks", false, 240, -12.0, 12.0, VarManager::kVtxZ, 200, 0, 200.0, VarManager::kMultNtrkGlobal); + } if (subGroupStr.Contains("alice3barrel")) { std::array pTBins = { 0.1, 0.5, 1.0, 1.25, 1.5, 2.0, 2.5, 3.0, diff --git a/PWGDQ/Core/VarManager.cxx b/PWGDQ/Core/VarManager.cxx index b85e284dd40..7299984bdfb 100644 --- a/PWGDQ/Core/VarManager.cxx +++ b/PWGDQ/Core/VarManager.cxx @@ -768,6 +768,8 @@ void VarManager::SetDefaultVarNames() fgVariableUnits[kVtxNcontrib] = ""; fgVariableNames[kVtxNcontribReal] = "Real Vtx contrib."; fgVariableUnits[kVtxNcontribReal] = ""; + fgVariableNames[kMultNtrkGlobal] = "Global tracks"; + fgVariableUnits[kMultNtrkGlobal] = ""; fgVariableNames[kVtxCovXX] = "Vtx covXX"; fgVariableUnits[kVtxCovXX] = "cm"; fgVariableNames[kVtxCovXY] = "Vtx covXY"; @@ -829,6 +831,7 @@ void VarManager::SetDefaultVarNames() fgVariableNames[kMultMCNParticlesEta05] = "MC Multiplicity Central Barrel for |eta| < 0.5"; fgVariableNames[kMultMCNParticlesEta08] = "MC Multiplicity Central Barrel for |eta| < 0.8"; fgVariableNames[kMultMCNParticlesEta10] = "MC Multiplicity Central Barrel for |eta| < 1.0"; + fgVariableNames[kMultMCGlobalParticles] = "MC Multiplicity corresponding to global track definition"; fgVariableUnits[kMCEventGeneratorId] = ""; fgVariableUnits[kMCEventSubGeneratorId] = ""; fgVariableUnits[kMCVtxX] = "cm"; @@ -842,6 +845,7 @@ void VarManager::SetDefaultVarNames() fgVariableUnits[kMultMCNParticlesEta05] = "Multiplicity_eta05"; fgVariableUnits[kMultMCNParticlesEta08] = "Multiplicity_eta08"; fgVariableUnits[kMultMCNParticlesEta10] = "Multiplicity_eta10"; + fgVariableUnits[kMultMCGlobalParticles] = "Multiplicity_globalTrk"; fgVariableNames[kTwoEvPosZ1] = "vtx-z_{1}"; fgVariableUnits[kTwoEvPosZ1] = "cm"; fgVariableNames[kTwoEvPosZ2] = "vtx-z_{2}"; @@ -2125,6 +2129,7 @@ void VarManager::SetDefaultVarNames() fgVarNamesMap["kVtxZ"] = kVtxZ; fgVarNamesMap["kVtxNcontrib"] = kVtxNcontrib; fgVarNamesMap["kVtxNcontribReal"] = kVtxNcontribReal; + fgVarNamesMap["kMultNtrkGlobal"] = kMultNtrkGlobal; fgVarNamesMap["kVtxCovXX"] = kVtxCovXX; fgVarNamesMap["kVtxCovXY"] = kVtxCovXY; fgVarNamesMap["kVtxCovXZ"] = kVtxCovXZ; @@ -2219,6 +2224,7 @@ void VarManager::SetDefaultVarNames() fgVarNamesMap["kMultMCNParticlesEta05"] = kMultMCNParticlesEta05; fgVarNamesMap["kMultMCNParticlesEta08"] = kMultMCNParticlesEta08; fgVarNamesMap["kMultMCNParticlesEta10"] = kMultMCNParticlesEta10; + fgVarNamesMap["kMultMCGlobalParticles"] = kMultMCGlobalParticles; fgVarNamesMap["kQ1ZNAX"] = kQ1ZNAX; fgVarNamesMap["kQ1ZNAY"] = kQ1ZNAY; fgVarNamesMap["kQ1ZNCX"] = kQ1ZNCX; diff --git a/PWGDQ/Core/VarManager.h b/PWGDQ/Core/VarManager.h index 99c049374e8..5b23a43b750 100644 --- a/PWGDQ/Core/VarManager.h +++ b/PWGDQ/Core/VarManager.h @@ -120,6 +120,8 @@ class VarManager : public TObject RapidityGapFilter = BIT(21), Fit = BIT(22), ReducedFit = BIT(23), + ReducedEventGlobalMult = BIT(24), + ReducedEventGlobalMultMC = BIT(25), Track = BIT(0), TrackCov = BIT(1), TrackExtra = BIT(2), @@ -254,6 +256,7 @@ class VarManager : public TObject kVtxZ, kVtxNcontrib, kVtxNcontribReal, + kMultNtrkGlobal, kVtxCovXX, kVtxCovXY, kVtxCovXZ, @@ -350,6 +353,7 @@ class VarManager : public TObject kMultMCNParticlesEta10, kMultMCNParticlesEta08, kMultMCNParticlesEta05, + kMultMCGlobalParticles, kQ1ZNAX, kQ1ZNAY, kQ1ZNCX, @@ -2664,6 +2668,14 @@ void VarManager::FillEvent(T const& event, float* values) FillZDC(event, values); } + if constexpr (requires { event.multNtrkGlobal(); }) { + values[kMultNtrkGlobal] = event.multNtrkGlobal(); + } + + if constexpr (requires { event.multMCGlobalParticles(); }) { + values[kMultMCGlobalParticles] = event.multMCGlobalParticles(); + } + if constexpr ((fillMap & ReducedFit) > 0) { values[kAmplitudeFT0A] = event.amplitudeFT0A(); values[kAmplitudeFT0C] = event.amplitudeFT0C(); diff --git a/PWGDQ/DataModel/ReducedInfoTables.h b/PWGDQ/DataModel/ReducedInfoTables.h index eeed55d4886..53ca9fb1c90 100644 --- a/PWGDQ/DataModel/ReducedInfoTables.h +++ b/PWGDQ/DataModel/ReducedInfoTables.h @@ -184,6 +184,28 @@ DECLARE_SOA_TABLE(ReducedEventsMultPV_000, "AOD", "REMULTPV", //! Multiplicity mult::MultNTracksITSOnly, mult::MultNTracksTPCOnly, mult::MultNTracksITSTPC, evsel::NumTracksInTimeRange); +namespace globalmult +{ +DECLARE_SOA_COLUMN(MultNtrkGlobal, multNtrkGlobal, int); +} // namespace globalmult + +DECLARE_SOA_TABLE(GlobalTrackMultiplicity, "AOD", "GLOBALTRKMULT", + globalmult::MultNtrkGlobal); + +DECLARE_SOA_TABLE(ReducedEventsGlobalTrk, "AOD", "REGLOBALTRK", + globalmult::MultNtrkGlobal); + +namespace mcglobalmult +{ +DECLARE_SOA_COLUMN(MultMCGlobalParticles, multMCGlobalParticles, int); +} // namespace mcglobalmult + +DECLARE_SOA_TABLE(McGlobalMultiplicities, "AOD", "MCGLOBALMULT", + mcglobalmult::MultMCGlobalParticles); + +DECLARE_SOA_TABLE(ReducedMCGlobalMultiplicities, "AOD", "REMCGLOBALMULT", + mcglobalmult::MultMCGlobalParticles); + DECLARE_SOA_TABLE_VERSIONED(ReducedEventsMultPV_001, "AOD", "REMULTPV", 1, //! Multiplicity information for primary vertex mult::MultNTracksHasITS, mult::MultNTracksHasTPC, mult::MultNTracksHasTOF, mult::MultNTracksHasTRD, mult::MultNTracksITSOnly, mult::MultNTracksTPCOnly, mult::MultNTracksITSTPC, @@ -873,21 +895,21 @@ DECLARE_SOA_COLUMN(BdtBackground, bdtBackground, float); DECLARE_SOA_COLUMN(BdtPrompt, bdtPrompt, float); //! BDT output score for the prompt class DECLARE_SOA_COLUMN(BdtNonprompt, bdtNonprompt, float); //! BDT output score for the nonprompt class // DECLARE_SOA_INDEX_COLUMN(ReducedMuon, reducedmuon2); //! -DECLARE_SOA_COLUMN(CosThetaHE, costhetaHE, float); //! Cosine in the helicity frame -DECLARE_SOA_COLUMN(PhiHE, phiHe, float); //! Phi in the helicity frame -DECLARE_SOA_COLUMN(PhiTildeHE, phiTildeHe, float); //! Tilde Phi in the helicity frame -DECLARE_SOA_COLUMN(CosThetaCS, costhetaCS, float); //! Cosine in the Collins-Soper frame -DECLARE_SOA_COLUMN(PhiCS, phiCS, float); //! Phi in the Collins-Soper frame -DECLARE_SOA_COLUMN(PhiTildeCS, phiTildeCS, float); //! Tilde Phi in the Collins-Soper frame -DECLARE_SOA_COLUMN(CosThetaPP, costhetaPP, float); //! Cosine in the Production Plane frame -DECLARE_SOA_COLUMN(PhiPP, phiPP, float); //! Phi in the Production Plane frame -DECLARE_SOA_COLUMN(PhiTildePP, phiTildePP, float); //! Tilde Phi in the Production Plane frame -DECLARE_SOA_COLUMN(CosThetaRM, costhetaRM, float); //! Cosine in the Random frame -DECLARE_SOA_COLUMN(CosThetaStarTPC, costhetaStarTPC, float); //! global polarization, event plane reconstructed from TPC tracks -DECLARE_SOA_COLUMN(CosThetaStarFT0A, costhetaStarFT0A, float); //! global polarization, event plane reconstructed from FT0A tracks -DECLARE_SOA_COLUMN(CosThetaStarFT0C, costhetaStarFT0C, float); //! global polarization, event plane reconstructed from FT0C tracks +DECLARE_SOA_COLUMN(CosThetaHE, costhetaHE, float); //! Cosine in the helicity frame +DECLARE_SOA_COLUMN(PhiHE, phiHe, float); //! Phi in the helicity frame +DECLARE_SOA_COLUMN(PhiTildeHE, phiTildeHe, float); //! Tilde Phi in the helicity frame +DECLARE_SOA_COLUMN(CosThetaCS, costhetaCS, float); //! Cosine in the Collins-Soper frame +DECLARE_SOA_COLUMN(PhiCS, phiCS, float); //! Phi in the Collins-Soper frame +DECLARE_SOA_COLUMN(PhiTildeCS, phiTildeCS, float); //! Tilde Phi in the Collins-Soper frame +DECLARE_SOA_COLUMN(CosThetaPP, costhetaPP, float); //! Cosine in the Production Plane frame +DECLARE_SOA_COLUMN(PhiPP, phiPP, float); //! Phi in the Production Plane frame +DECLARE_SOA_COLUMN(PhiTildePP, phiTildePP, float); //! Tilde Phi in the Production Plane frame +DECLARE_SOA_COLUMN(CosThetaRM, costhetaRM, float); //! Cosine in the Random frame +DECLARE_SOA_COLUMN(CosThetaStarTPC, costhetaStarTPC, float); //! global polarization, event plane reconstructed from TPC tracks +DECLARE_SOA_COLUMN(CosThetaStarFT0A, costhetaStarFT0A, float); //! global polarization, event plane reconstructed from FT0A tracks +DECLARE_SOA_COLUMN(CosThetaStarFT0C, costhetaStarFT0C, float); //! global polarization, event plane reconstructed from FT0C tracks DECLARE_SOA_COLUMN(CosThetaStarRandom, costhetaStarRandom, float); //! global polarization, event plane reconstructed from random tracks -DECLARE_SOA_DYNAMIC_COLUMN(Px, px, //! +DECLARE_SOA_DYNAMIC_COLUMN(Px, px, //! [](float pt, float phi) -> float { return pt * std::cos(phi); }); DECLARE_SOA_DYNAMIC_COLUMN(Py, py, //! [](float pt, float phi) -> float { return pt * std::sin(phi); }); diff --git a/PWGDQ/TableProducer/CMakeLists.txt b/PWGDQ/TableProducer/CMakeLists.txt index 5ba06a37cb5..bab26a5ffd1 100644 --- a/PWGDQ/TableProducer/CMakeLists.txt +++ b/PWGDQ/TableProducer/CMakeLists.txt @@ -50,3 +50,9 @@ o2physics_add_dpl_workflow(generated-quarkonia-mc REUSE_FROM DQAnalysisPCH PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2::DetectorsBase O2Physics::PWGDQCore COMPONENT_NAME Analysis) + +o2physics_add_dpl_workflow(global-track-estimator + SOURCES globalTrackEstimator.cxx + REUSE_FROM DQAnalysisPCH + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2::DetectorsBase O2Physics::PWGDQCore + COMPONENT_NAME Analysis) \ No newline at end of file diff --git a/PWGDQ/TableProducer/globalTrackEstimator.cxx b/PWGDQ/TableProducer/globalTrackEstimator.cxx new file mode 100644 index 00000000000..6a411ed5ef0 --- /dev/null +++ b/PWGDQ/TableProducer/globalTrackEstimator.cxx @@ -0,0 +1,290 @@ +// 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. +// +/// \author Alexander Tiekoetter , Muenster +/// \brief Global Track estimator with track-to-collision association +/// \file globalTrackEstimator.cxx + +#include "PWGDQ/Core/AnalysisCompositeCut.h" +#include "PWGDQ/Core/AnalysisCut.h" +#include "PWGDQ/Core/CutsLibrary.h" +#include "PWGDQ/Core/HistogramManager.h" +#include "PWGDQ/Core/HistogramsLibrary.h" +#include "PWGDQ/Core/MCSignal.h" +#include "PWGDQ/Core/MCSignalLibrary.h" +#include "PWGDQ/Core/VarManager.h" + +#include "Common/Core/trackUtilities.h" +#include "Common/DataModel/CollisionAssociationTables.h" +#include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/McCollisionExtra.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; +using namespace o2::aod; + +using MyEventsBasic = o2::soa::Join; +using MyBarrelTracks = o2::soa::Join; + +using MyEventsDirect = o2::soa::Join; +using MyTracksDirect = o2::soa::Join; +using MyEventsMcWithMults = soa::Join; + +constexpr static uint32_t GkEventFillMap = VarManager::ObjTypes::ReducedEvent | VarManager::ObjTypes::ReducedEventExtended; +constexpr static uint32_t GkTrackFillMap = VarManager::ObjTypes::ReducedTrackBarrel | VarManager::ObjTypes::ReducedTrackBarrelCov; + +constexpr static uint32_t GkEventDirectFillMap = VarManager::ObjTypes::Collision; +constexpr static uint32_t GkTrackDirectFillMap = VarManager::ObjTypes::Track | VarManager::ObjTypes::TrackExtra | VarManager::ObjTypes::TrackCov | VarManager::ObjTypes::TrackDCA; + +struct GlobalTrackEstimator { + Produces reducedEventsGlobalTrk; + Produces globalTrackMultiplicity; + + Produces reducedMCGlobalMultiplicities; + Produces mcGlobalMultiplicities; + + Service pdg; + + PresliceUnsorted mcTracksPerReducedEvent = aod::reducedtrackMC::reducedMCeventId; + + Configurable cfgShiftDCAxy{"cfgShiftDCAxy", 0.0105, "Constant shift of DCAxy paramterization"}; + Configurable cfgPtMagnitudeDCAxy{"cfgPtMagnitudeDCAxy", 0.035, "Magnitude of the pT dependency of the DCAxy paramterization"}; + Configurable cfgExponentDCAxy{"cfgExponentDCAxy", 1.1, "Exponent of the pT dependency of the DCAxy paramterization"}; + Configurable cfgMaxDCAz{"cfgMaxDCAz", 2.0, "Maximum DCAz"}; + Configurable cfgMinPt{"cfgMinPt", 0.1, "Minimum required pT"}; + Configurable cfgMinMCPt{"cfgMinMCPt", 0.0, "Minimum required pT for MC particles"}; + Configurable cfgEtaRange{"cfgEtaRange", 0.8, "Absolute pseudorapidity range"}; + Configurable cfgMinTPCCluster{"cfgMinTPCCluster", 70, "Minimum number of crossed TPC rows"}; + Configurable cfgRatioTPCClusterOverFindableCluster{"cfgRatioTPCClusterOverFindableCluster", 0.8, "Minimum ratio of crossed TPC rows over findable clusters"}; + Configurable cfgMaxChi2TPC{"cfgMaxChi2TPC", 4.0, "Maximum chi2 per cluster in TPC"}; + Configurable cfgMaxChi2ITS{"cfgMaxChi2ITS", 36.0, "Maximum chi2 per cluster in ITS"}; + Configurable cfgRequireITSibAny{"cfgRequireITSibAny", true, "Require a hit in the ITS inner barrel"}; + Configurable cfgRequirePVContributor{"cfgRequirePVContributor", false, "Require the track to be a PV contributor"}; + Configurable cfgRecalculateDCA{"cfgRecalculateDCA", true, "Recalculate DCA vector with associations"}; + + o2::framework::Preslice preslice = o2::aod::reducedtrack_association::reducedeventId; + o2::framework::Preslice presliceDirect = o2::aod::track_association::collisionId; + + void init(InitContext& context) + { + bool isSkimmedEnabled = context.mOptions.get("processGlobalTracksSkimmed") || context.mOptions.get("processMCSkimmed"); + bool isDirectEnabled = context.mOptions.get("processGlobalTracksDirect") || context.mOptions.get("processMCDirect"); + bool isDummyEnabled = context.mOptions.get("processDummy"); + + if (isDummyEnabled) { + if (isSkimmedEnabled || isDirectEnabled) { + LOG(fatal) << "You have enabled both the dummy process and at least one normal process function."; + } + return; + } + + if (!isSkimmedEnabled && !isDirectEnabled && !isDummyEnabled) { + LOG(fatal) << "No process function activated."; + return; + } + + if (isSkimmedEnabled && isDirectEnabled) { + LOG(fatal) << "Process functions for skimmed data model and direct data model can not run simultaneously."; + return; + } + } + + template + bool isTrackSelected(T& track, C const& event) + { + VarManager::ResetValues(VarManager::kNBarrelTrackVariables, VarManager::kNBarrelTrackVariables); + VarManager::FillTrack(track); + + if (cfgRecalculateDCA) { + VarManager::FillTrackCollision(track, event); + } + + if (track.pt() < cfgMinPt || abs(track.eta()) > cfgEtaRange) { + return false; + } + + if (cfgRequirePVContributor && !track.isPVContributor()) { + return false; + } + + if (track.tpcChi2NCl() > cfgMaxChi2TPC || track.itsChi2NCl() > cfgMaxChi2ITS) { + return false; + } + + const int nFindable = track.tpcNClsFindable(); + const int nCrossedRows = track.tpcNClsCrossedRows(); + + if (nCrossedRows < static_cast(cfgMinTPCCluster.value)) { + return false; + } + + if (nFindable <= 0) { + return false; + } + + const float crossedOverFindable = static_cast(nCrossedRows) / static_cast(nFindable); + + if (crossedOverFindable < cfgRatioTPCClusterOverFindableCluster.value) { + return false; + } + + if (cfgRequireITSibAny.value && ((track.itsClusterMap() & 0x7) == 0)) { + return false; + } + + if (std::abs(VarManager::fgValues[VarManager::kTrackDCAz]) > cfgMaxDCAz.value) { + return false; + } + + if (std::abs(VarManager::fgValues[VarManager::kTrackDCAxy]) > cfgShiftDCAxy + cfgPtMagnitudeDCAxy / pow(track.pt(), cfgExponentDCAxy)) { + return false; + } + + return true; + } + + template + int countMCGlobalParticles(TParticles const& particles) + { + int count = 0; + + for (auto const& particle : particles) { + if (!particle.isPhysicalPrimary() || particle.pt() < cfgMinMCPt.value || std::abs(particle.eta()) > cfgEtaRange.value) { + continue; + } + + const auto* pdgParticle = pdg->GetParticle(particle.pdgCode()); + if (pdgParticle == nullptr || std::abs(pdgParticle->Charge()) < 1.e-3) { + continue; + } + + ++count; + } + + return count; + } + + void processGlobalTracksSkimmed(MyEventsBasic const& events, ReducedTracksAssoc const& assocs, MyBarrelTracks const& tracks) + { + std::unordered_set selectedTrackIds; + selectedTrackIds.reserve(tracks.size()); + + for (auto const& track : tracks) { + selectedTrackIds.insert(track.globalIndex()); + } + + for (const auto& event : events) { + VarManager::ResetValues(0, VarManager::kNBarrelTrackVariables); + VarManager::FillEvent(event); + + auto groupedAssocs = assocs.sliceBy(preslice, event.globalIndex()); + + int nTrkGlobal = 0; + + for (auto const& assoc : groupedAssocs) { + if (selectedTrackIds.find(assoc.reducedtrackId()) == selectedTrackIds.end()) { + continue; + } + + auto track = assoc.template reducedtrack_as(); + + if (!isTrackSelected(track, event)) { + continue; + } + + ++nTrkGlobal; + } + + reducedEventsGlobalTrk(nTrkGlobal); + } + } + + PROCESS_SWITCH(GlobalTrackEstimator, processGlobalTracksSkimmed, "Count global tracks from skimmed data model", false); + + void processGlobalTracksDirect(MyEventsDirect const& events, TrackAssoc const& assocs, MyTracksDirect const& tracks) + { + std::unordered_set selectedTrackIds; + selectedTrackIds.reserve(tracks.size()); + + for (auto const& track : tracks) { + selectedTrackIds.insert(track.globalIndex()); + } + + for (const auto& event : events) { + VarManager::ResetValues(0, VarManager::kNBarrelTrackVariables); + VarManager::FillEvent(event); + + auto groupedAssocs = assocs.sliceBy(presliceDirect, event.globalIndex()); + + int nTrkGlobal = 0; + + for (auto const& assoc : groupedAssocs) { + if (selectedTrackIds.find(assoc.trackId()) == selectedTrackIds.end()) { + continue; + } + + auto track = assoc.template track_as(); + + if (!isTrackSelected(track, event)) { + continue; + } + + ++nTrkGlobal; + } + + globalTrackMultiplicity(nTrkGlobal); + } + } + + PROCESS_SWITCH(GlobalTrackEstimator, processGlobalTracksDirect, "Count global tracks from unskimmed data", false); + + void processMCSkimmed(ReducedMCEvents const& events, ReducedMCTracks const& particles) + { + for (auto const& event : events) { + auto eventParticles = particles.sliceBy(mcTracksPerReducedEvent, event.globalIndex()); + reducedMCGlobalMultiplicities(countMCGlobalParticles(eventParticles)); + } + } + + PROCESS_SWITCH(GlobalTrackEstimator, processMCSkimmed, "Count primary charged particles in DQ skimmed MC", false); + + void processMCDirect(McCollision const&, McParticles const& particles) + { + mcGlobalMultiplicities(countMCGlobalParticles(particles)); + } + + PROCESS_SWITCH(GlobalTrackEstimator, processMCDirect, "Count primary charged particles in unskimmed MC", false); + + void processDummy(MyEventsBasic const&) + { + // do nothing + } + + PROCESS_SWITCH(GlobalTrackEstimator, processDummy, "Dummy process function", true); +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{adaptAnalysisTask(cfgc)}; +} diff --git a/PWGDQ/Tasks/dqEfficiency_withAssoc.cxx b/PWGDQ/Tasks/dqEfficiency_withAssoc.cxx index 9b759f453e9..cd8c262a5c5 100644 --- a/PWGDQ/Tasks/dqEfficiency_withAssoc.cxx +++ b/PWGDQ/Tasks/dqEfficiency_withAssoc.cxx @@ -261,7 +261,9 @@ DECLARE_SOA_TABLE(OniaMCTruth, "AOD", "MCTRUTHONIA", dqanalysisflags::OniaPt, dq using MyEvents = soa::Join; using MyEventsSelected = soa::Join; using MyEventsVtxCov = soa::Join; +using MyEventsVtxCovGlobalMult = o2::soa::Join; using MyEventsVtxCovSelected = soa::Join; +using MyEventsVtxCovGlobalMultSelected = o2::soa::Join; using MyEventsVtxCovSelectedInfo = soa::Join; using MyEventsVtxCovSelectedMultExtra = soa::Join; using MyEventsVtxCovSelectedQvector = soa::Join; @@ -609,6 +611,11 @@ struct AnalysisEventSelection { runEventSelection(events, mcEvents); publishSelections(events); } + void processSkimmedWithGlobalMults(MyEventsVtxCovGlobalMult const& events, soa::Join const& mcEvents) + { + runEventSelection(events, mcEvents); + publishSelections(events); + } void processFillEvents(MyEvents const& events) // Used to forward the event table from tablemaker, typical use for now is jet analysis. { for (auto const& event : events) { @@ -628,6 +635,7 @@ struct AnalysisEventSelection { } PROCESS_SWITCH(AnalysisEventSelection, processSkimmed, "Run event selection on DQ skimmed events", false); + PROCESS_SWITCH(AnalysisEventSelection, processSkimmedWithGlobalMults, "Run event selection with global track multiplicity estimation", false); PROCESS_SWITCH(AnalysisEventSelection, processFillEvents, "Fill storedReducedEvents table for use in JE framework", false); PROCESS_SWITCH(AnalysisEventSelection, processDummy, "Dummy function", true); }; @@ -1805,7 +1813,7 @@ struct AnalysisSameEventPairing { bool isMCGen = context.mOptions.get("processMCGen") || context.mOptions.get("processMCGenWithGrouping") || context.mOptions.get("processBarrelOnlySkimmed"); VarManager::SetDefaultVarNames(); - fEnableBarrelHistos = context.mOptions.get("processAllSkimmed") || context.mOptions.get("processBarrelOnlySkimmed") || context.mOptions.get("processBarrelOnlyWithCollSkimmed"); + fEnableBarrelHistos = context.mOptions.get("processAllSkimmed") || context.mOptions.get("processBarrelOnlySkimmed") || context.mOptions.get("processBarrelOnlyWithGlobalMultSkimmed") || context.mOptions.get("processBarrelOnlyWithCollSkimmed"); fEnableMuonHistos = context.mOptions.get("processAllSkimmed") || context.mOptions.get("processMuonOnlySkimmed") || context.mOptions.get("processMuonOnlyVertexingSkimmed"); fEnableBarrelMuonHistos = context.mOptions.get("processElectronMuonSkimmed"); fEnableBarrelMuonMixingHistos = context.mOptions.get("processMixingElectronMuonSkimmed"); @@ -2367,7 +2375,7 @@ struct AnalysisSameEventPairing { uint8_t evSel = event.isEventSelected_raw(); // Reset the fValues array VarManager::ResetValues(0, VarManager::kNVars); - VarManager::FillEvent(event, dqefficiency_helpers::varValues()); + VarManager::FillEvent(event, dqefficiency_helpers::varValues()); VarManager::FillEvent(event.reducedMCevent(), dqefficiency_helpers::varValues()); auto groupedAssocs = assocs.sliceBy(preslice, event.globalIndex()); @@ -3185,6 +3193,14 @@ struct AnalysisSameEventPairing { runMCGen(events, mcEvents, mcTracks); } + void processBarrelOnlyWithGlobalMultSkimmed(MyEventsVtxCovGlobalMultSelected const& events, + soa::Join const& barrelAssocs, + MyBarrelTracksWithCovWithAmbiguities const& barrelTracks, ReducedMCEvents const& mcEvents, ReducedMCTracks const& mcTracks) + { + runSameEventPairing(events, trackAssocsPerCollision, barrelAssocs, barrelTracks, mcEvents, mcTracks); + runMCGen(events, mcEvents, mcTracks); + } + void processMuonOnlySkimmed(MyEventsVtxCovSelected const& events, soa::Join const& muonAssocs, MyMuonTracksWithCovWithAmbiguities const& muons, ReducedMCEvents const& mcEvents, ReducedMCTracks const& mcTracks) { @@ -3443,6 +3459,7 @@ struct AnalysisSameEventPairing { PROCESS_SWITCH(AnalysisSameEventPairing, processAllSkimmed, "Run all types of pairing, with skimmed tracks/muons", false); PROCESS_SWITCH(AnalysisSameEventPairing, processBarrelOnlySkimmed, "Run barrel only pairing, with skimmed tracks", false); + PROCESS_SWITCH(AnalysisSameEventPairing, processBarrelOnlyWithGlobalMultSkimmed, "Run barrel only pairing, with global tracks, with skimmed tracks", false); PROCESS_SWITCH(AnalysisSameEventPairing, processBarrelOnlyWithCollSkimmed, "Run barrel only pairing, with skimmed tracks and with collision information", false); PROCESS_SWITCH(AnalysisSameEventPairing, processMuonOnlySkimmed, "Run muon only pairing, with skimmed tracks", false); PROCESS_SWITCH(AnalysisSameEventPairing, processMuonOnlyVertexingSkimmed, "Run muon only pairing with two-prong vertexing, with skimmed tracks", false); diff --git a/PWGDQ/Tasks/dqEfficiency_withAssoc_direct.cxx b/PWGDQ/Tasks/dqEfficiency_withAssoc_direct.cxx index 82d99d1ed75..83a8e52f631 100644 --- a/PWGDQ/Tasks/dqEfficiency_withAssoc_direct.cxx +++ b/PWGDQ/Tasks/dqEfficiency_withAssoc_direct.cxx @@ -264,7 +264,9 @@ using MyMuonTracksWithCovWithAmbiguities = soa::Join; using MyEvents = soa::Join; using MyEventsSelected = soa::Join; +using MyEventsGlobalMult = soa::Join; using MyEventsWithCentAndMults = soa::Join; +using MyEventsGlobalMultSelected = soa::Join; using MyEventsSelectedWithCentAndMults = soa::Join; using MyBarrelTracksWithCov = soa::Join + template void runEventSelection(TEvents const& events, BCsWithTimestamps const& bcs, TEventsMC const& mcEvents) { LOG(info) << "AnalysisEventSelection::runEventSelection() called with " << events.size() << " events and " << bcs.size() << " BCs"; @@ -433,7 +435,7 @@ struct AnalysisEventSelection { VarManager::FillEvent(event); if (event.has_mcCollision()) { auto mcCollision = event.template mcCollision_as(); - VarManager::FillEvent(mcCollision); + VarManager::FillEvent(mcCollision); } // cout << "Filled event observables: " << endl; @@ -461,7 +463,7 @@ struct AnalysisEventSelection { for (const auto& event : mcEvents) { // Reset the fValues array and fill event observables VarManager::ResetValues(0, VarManager::kNEventWiseVariables); - VarManager::FillEvent(event); + VarManager::FillEvent(event); if (fConfigQA) { fHistMan->FillHistClass("EventsMC", static_cast(VarManager::fgValues)); } @@ -553,15 +555,21 @@ struct AnalysisEventSelection { void processDirect(MyEvents const& events, BCsWithTimestamps const& bcs, soa::Join const& mcEvents) { // cout << "AnalysisEventSelection::processDirect() called" << endl; - runEventSelection(events, bcs, mcEvents); + runEventSelection(events, bcs, mcEvents); publishSelections(events); // cout << "AnalysisEventSelection::processDirect() completed" << endl; } + void processDirectGlobalMult(MyEventsGlobalMult const& events, BCsWithTimestamps const& bcs, soa::Join const& mcEvents) + { + runEventSelection(events, bcs, mcEvents); + publishSelections(events); + } + void processPbPbDirect(MyEventsWithCentAndMults const& events, BCsWithTimestamps const& bcs, soa::Join const& mcEvents) { // cout << "AnalysisEventSelection::processPbPbDirect() called" << endl; - runEventSelection(events, bcs, mcEvents); + runEventSelection(events, bcs, mcEvents); publishSelections(events); // cout << "AnalysisEventSelection::processPbPbDirect() completed" << endl; } @@ -572,6 +580,7 @@ struct AnalysisEventSelection { } PROCESS_SWITCH(AnalysisEventSelection, processDirect, "Run event selection on framework AO2Ds", false); + PROCESS_SWITCH(AnalysisEventSelection, processDirectGlobalMult, "Run event selection on framework AO2Ds with global tracking counter", false); PROCESS_SWITCH(AnalysisEventSelection, processPbPbDirect, "Run PbPb event selection on framework AO2Ds", false); PROCESS_SWITCH(AnalysisEventSelection, processDummy, "Dummy function", true); }; @@ -1243,7 +1252,7 @@ struct AnalysisSameEventPairing { } VarManager::SetDefaultVarNames(); - fEnableBarrelHistos = context.mOptions.get("processBarrelOnly") || context.mOptions.get("processBarrelPbPbOnly"); + fEnableBarrelHistos = context.mOptions.get("processBarrelOnly") || context.mOptions.get("processBarrelPbPbOnly") || context.mOptions.get("processBarrelOnlyWithGlobalMults"); // fEnableMuonHistos = context.mOptions.get("processMuonOnlySkimmed"); // Keep track of all the histogram class names to avoid composing strings in the pairing loop @@ -2317,6 +2326,14 @@ struct AnalysisSameEventPairing { // cout << "AnalysisSameEventPairing::processBarrelOnly() completed" << endl; } + void processBarrelOnlyWithGlobalMults(MyEventsGlobalMultSelected const& events, BCsWithTimestamps const& bcs, + soa::Join const& barrelAssocs, + MyBarrelTracksWithCovWithAmbiguities const& barrelTracks, McCollisions const& mcEvents, McParticles const& mcTracks) + { + runSameEventPairing(events, bcs, trackAssocsPerCollision, barrelAssocs, barrelTracks, mcEvents, mcTracks); + runMCGen(events, mcEvents, mcTracks); + } + void processBarrelPbPbOnly(MyEventsSelectedWithCentAndMults const& events, BCsWithTimestamps const& bcs, soa::Join const& barrelAssocs, MyBarrelTracksWithCovWithAmbiguities const& barrelTracks, soa::Join const& mcEvents, McParticles const& mcTracks) @@ -2333,6 +2350,7 @@ struct AnalysisSameEventPairing { } PROCESS_SWITCH(AnalysisSameEventPairing, processBarrelOnly, "Run barrel only pairing", false); + PROCESS_SWITCH(AnalysisSameEventPairing, processBarrelOnlyWithGlobalMults, "Run barrel only pairing with global track estimation", false); PROCESS_SWITCH(AnalysisSameEventPairing, processBarrelPbPbOnly, "Run barrel PbPb only pairing", false); PROCESS_SWITCH(AnalysisSameEventPairing, processDummy, "Dummy function, enabled only if none of the others are enabled", true); }; diff --git a/PWGDQ/Tasks/tableReader_withAssoc.h b/PWGDQ/Tasks/tableReader_withAssoc.h index 1aff98249a4..70e78c84726 100644 --- a/PWGDQ/Tasks/tableReader_withAssoc.h +++ b/PWGDQ/Tasks/tableReader_withAssoc.h @@ -258,8 +258,11 @@ using MyEventsSelected = o2::soa::Join; using MyEventsVtxCovSelectedMultExtra = o2::soa::Join; using MyEventsHashSelected = o2::soa::Join; +using MyEventsWithGlobalMultHash = o2::soa::Join; using MyEventsVtxCov = o2::soa::Join; +using MyEventsVtxCovGlobalMult = o2::soa::Join; using MyEventsVtxCovSelected = o2::soa::Join; +using MyEventsVtxCovGlobalMultSelected = o2::soa::Join; using MyEventsVtxCovSelectedInfo = o2::soa::Join; using MyEventsVtxCovSelectedQvector = o2::soa::Join; using MyEventsVtxCovSelectedQvectorWithHash = o2::soa::Join; @@ -392,7 +395,7 @@ struct AnalysisEventSelection { void init(o2::framework::InitContext& context) { - bool isAnyProcessEnabled = context.mOptions.get("processSkimmed") || context.mOptions.get("processSkimmedBasic") || context.mOptions.get("processSkimmedWithZdc") || context.mOptions.get("processSkimmedWithMultExtra") || context.mOptions.get("processSkimmedWithMultExtraNoQvector") || context.mOptions.get("processSkimmedWithMultExtraZdc") || context.mOptions.get("processSkimmedWithMultExtraZdcFit") || context.mOptions.get("processSkimmedWithQvectorCentr") || context.mOptions.get("processSkimmedWithQvectorCentrMerge"); + bool isAnyProcessEnabled = context.mOptions.get("processSkimmed") || context.mOptions.get("processSkimmedBasic") || context.mOptions.get("processSkimmedWithZdc") || context.mOptions.get("processSkimmedWithGlobalMults") || context.mOptions.get("processSkimmedWithMultExtra") || context.mOptions.get("processSkimmedWithMultExtraNoQvector") || context.mOptions.get("processSkimmedWithMultExtraZdc") || context.mOptions.get("processSkimmedWithMultExtraZdcFit") || context.mOptions.get("processSkimmedWithQvectorCentr") || context.mOptions.get("processSkimmedWithQvectorCentrMerge"); bool isDummyEnabled = context.mOptions.get("processDummy"); if (isDummyEnabled) { @@ -692,6 +695,11 @@ struct AnalysisEventSelection { runEventSelection(events); publishSelections(events); } + void processSkimmedWithGlobalMults(MyEventsVtxCovGlobalMult const& events) + { + runEventSelection(events); + publishSelections(events); + } void processSkimmedWithMultExtra(MyEventsMultExtra const& events) { runEventSelection(events); @@ -744,6 +752,7 @@ struct AnalysisEventSelection { PROCESS_SWITCH(AnalysisEventSelection, processSkimmedBasic, "Run event selection on DQ skimmed events with basic tables", false); PROCESS_SWITCH(AnalysisEventSelection, processSkimmedWithZdc, "Run event selection on DQ skimmed events, with ZDC", false); PROCESS_SWITCH(AnalysisEventSelection, processSkimmedWithMultExtra, "Run event selection on DQ skimmed events, with mult extra", false); + PROCESS_SWITCH(AnalysisEventSelection, processSkimmedWithGlobalMults, "Run event selection with global track multiplicity estimation", false); PROCESS_SWITCH(AnalysisEventSelection, processSkimmedWithMultExtraNoQvector, "Run event selection on DQ skimmed events, with mult extra and without Q-vector", false); PROCESS_SWITCH(AnalysisEventSelection, processSkimmedWithMultExtraZdc, "Run event selection on DQ skimmed events, with mult extra and ZDC", false); PROCESS_SWITCH(AnalysisEventSelection, processSkimmedWithMultExtraZdcFit, "Run event selection on DQ skimmed events, with mult extra, ZDC and FIT", false); @@ -1574,8 +1583,8 @@ struct AnalysisSameEventPairing { void init(o2::framework::InitContext& context) { - fEnableBarrelHistos = context.mOptions.get("processAllSkimmed") || context.mOptions.get("processBarrelOnlySkimmed") || context.mOptions.get("processBarrelOnlyWithCollSkimmed") || context.mOptions.get("processBarrelOnlySkimmedNoCov") || context.mOptions.get("processBarrelOnlySkimmedNoCovWithMultExtra") || context.mOptions.get("processBarrelOnlyWithQvectorCentrSkimmedNoCov") || context.mOptions.get("processBarrelOnlyWithQvectorCentrSkimmed") || context.mOptions.get("processBarrelOnlyDiKaons") || context.mOptions.get("processBarrelOnlyDiProtons"); - fEnableBarrelMixingHistos = context.mOptions.get("processMixingAllSkimmed") || context.mOptions.get("processMixingBarrelSkimmed") || context.mOptions.get("processMixingBarrelSkimmedFlow") || context.mOptions.get("processMixingBarrelWithQvectorCentrSkimmedNoCov"); + fEnableBarrelHistos = context.mOptions.get("processAllSkimmed") || context.mOptions.get("processBarrelOnlySkimmed") || context.mOptions.get("processBarrelOnlySkimmedWithGlobalMult") || context.mOptions.get("processBarrelOnlyWithCollSkimmed") || context.mOptions.get("processBarrelOnlySkimmedNoCov") || context.mOptions.get("processBarrelOnlySkimmedNoCovWithMultExtra") || context.mOptions.get("processBarrelOnlyWithQvectorCentrSkimmedNoCov") || context.mOptions.get("processBarrelOnlyWithQvectorCentrSkimmed") || context.mOptions.get("processBarrelOnlyDiKaons") || context.mOptions.get("processBarrelOnlyDiProtons"); + fEnableBarrelMixingHistos = context.mOptions.get("processMixingAllSkimmed") || context.mOptions.get("processMixingBarrelSkimmed") || context.mOptions.get("processMixingBarrelSkimmedGlobalMult") || context.mOptions.get("processMixingBarrelSkimmedFlow") || context.mOptions.get("processMixingBarrelWithQvectorCentrSkimmedNoCov"); fEnableBarrelMixingHistos |= fConfigRunMixingAcrossTFs; fEnableMuonHistos = context.mOptions.get("processAllSkimmed") || context.mOptions.get("processMuonOnlySkimmed") || context.mOptions.get("processMuonOnlySkimmedMultExtra") || context.mOptions.get("processMuonOnlySkimmedFlow") || context.mOptions.get("processMuonOnlyVertexingSkimmed"); fEnableMuonMixingHistos = context.mOptions.get("processMixingAllSkimmed") || context.mOptions.get("processMixingMuonSkimmed") || context.mOptions.get("processMixingMuonSkimmedFlow"); @@ -3220,6 +3229,13 @@ struct AnalysisSameEventPairing { runSameEventPairing(events, trackAssocsPerCollision, barrelAssocs, barrelTracks); } + void processBarrelOnlySkimmedWithGlobalMult(MyEventsVtxCovGlobalMultSelected const& events, + o2::soa::Join const& barrelAssocs, + MyBarrelTracksWithCovWithAmbiguities const& barrelTracks) + { + runSameEventPairing(events, trackAssocsPerCollision, barrelAssocs, barrelTracks); + } + void processBarrelOnlySkimmedNoCovWithMultExtra(MyEventsMultExtraSelected const& events, o2::soa::Join const& barrelAssocs, MyBarrelTracksWithAmbiguities const& barrelTracks) @@ -3307,6 +3323,12 @@ struct AnalysisSameEventPairing { runSameSideMixing(events, trackAssocs, tracks, trackAssocsPerCollision); } + void processMixingBarrelSkimmedGlobalMult(o2::soa::Filtered& events, // o2-linter: disable=const-ref-in-process + o2::soa::Join const& trackAssocs, o2::aod::ReducedTracks const& tracks) + { + runSameSideMixing(events, trackAssocs, tracks, trackAssocsPerCollision); + } + void processMixingBarrelSkimmedFlow(o2::soa::Filtered& events, // o2-linter: disable=const-ref-in-process o2::soa::Join const& trackAssocs, o2::aod::ReducedTracks const& tracks) { @@ -3347,6 +3369,7 @@ struct AnalysisSameEventPairing { PROCESS_SWITCH(AnalysisSameEventPairing, processBarrelOnlySkimmed, "Run barrel only pairing, with skimmed tracks", false); PROCESS_SWITCH(AnalysisSameEventPairing, processBarrelOnlyWithCollSkimmed, "Run barrel only pairing, with skimmed tracks and with collision information", false); PROCESS_SWITCH(AnalysisSameEventPairing, processBarrelOnlySkimmedNoCov, "Run barrel only pairing (no covariances), with skimmed tracks and with collision information", false); + PROCESS_SWITCH(AnalysisSameEventPairing, processBarrelOnlySkimmedWithGlobalMult, "Run barrel only pairing, with skimmed tracks and global track estimation", false); PROCESS_SWITCH(AnalysisSameEventPairing, processBarrelOnlySkimmedNoCovWithMultExtra, "Run barrel only pairing (no covariances), with skimmed tracks, with collision information, with MultsExtra", false); PROCESS_SWITCH(AnalysisSameEventPairing, processBarrelOnlyWithQvectorCentrSkimmedNoCov, "Run barrel only pairing (no covariances), with skimmed tracks, with Qvector from central framework", false); PROCESS_SWITCH(AnalysisSameEventPairing, processBarrelOnlyWithQvectorCentrSkimmed, "Run barrel only pairing (no covariances), with skimmed tracks, with collision information, with Qvector from central framework", false); @@ -3361,6 +3384,7 @@ struct AnalysisSameEventPairing { PROCESS_SWITCH(AnalysisSameEventPairing, processMixingAllSkimmed, "Run all types of mixed pairing, with skimmed tracks/muons", false); PROCESS_SWITCH(AnalysisSameEventPairing, processMixingBarrelSkimmed, "Run barrel type mixing pairing, with skimmed tracks", false); PROCESS_SWITCH(AnalysisSameEventPairing, processMixingBarrelSkimmedFlow, "Run barrel type mixing pairing, with flow, with skimmed tracks", false); + PROCESS_SWITCH(AnalysisSameEventPairing, processMixingBarrelSkimmedGlobalMult, "Run barrel type mixing pairing, with global tracks, with skimmed tracks", false); PROCESS_SWITCH(AnalysisSameEventPairing, processMixingBarrelWithQvectorCentrSkimmedNoCov, "Run barrel type mixing pairing, with skimmed tracks and with Qvector from central framework", false); PROCESS_SWITCH(AnalysisSameEventPairing, processMixingMuonSkimmed, "Run muon type mixing pairing, with skimmed muons", false); PROCESS_SWITCH(AnalysisSameEventPairing, processMixingMuonSkimmedFlow, "Run muon type mixing pairing, with skimmed muons and flow", false); diff --git a/PWGDQ/Tasks/tableReader_withAssoc_direct.cxx b/PWGDQ/Tasks/tableReader_withAssoc_direct.cxx index 47a21cedcc9..1d6b9696f9c 100644 --- a/PWGDQ/Tasks/tableReader_withAssoc_direct.cxx +++ b/PWGDQ/Tasks/tableReader_withAssoc_direct.cxx @@ -224,8 +224,10 @@ DECLARE_SOA_TABLE(BmesonCandidates, "AOD", "DQBMESONS", // Using definitions (data-only) using MyEvents = soa::Join; +using MyEventsGlobalMult = soa::Join; using MyEventsQvectorCentr = soa::Join; using MyEventsSelected = soa::Join; +using MyEventsGlobalMultSelected = soa::Join; using MyEventsQvectorCentrSelected = soa::Join; using MyEventsHashSelected = soa::Join; using MyEventsHashSelectedQvectorCentr = soa::Join; @@ -631,6 +633,12 @@ struct AnalysisEventSelection { publishSelections(events); } + void processDirectGlobalMult(MyEventsGlobalMult const& events, BCsWithTimestamps const& bcs) + { + runEventSelection(events, bcs); + publishSelections(events); + } + void processDirectWithQvectorCentr(MyEventsQvectorCentr const& events, BCsWithTimestamps const& bcs) { runEventSelection(events, bcs); @@ -640,6 +648,7 @@ struct AnalysisEventSelection { void processDummy(aod::Collisions&) {} PROCESS_SWITCH(AnalysisEventSelection, processDirect, "Run event selection on framework AO2Ds", false); + PROCESS_SWITCH(AnalysisEventSelection, processDirectGlobalMult, "Run event selection with global track estimation on framework AO2Ds", false); PROCESS_SWITCH(AnalysisEventSelection, processDirectWithQvectorCentr, "Run event selection on skimmed data with Q-vector and centrality", false); PROCESS_SWITCH(AnalysisEventSelection, processDummy, "Dummy function", true); }; @@ -1389,7 +1398,7 @@ struct AnalysisSameEventPairing { } VarManager::SetDefaultVarNames(); - fEnableBarrelHistos = context.mOptions.get("processBarrelOnly") || context.mOptions.get("processBarrelOnlyWithQvectorCentr"); + fEnableBarrelHistos = context.mOptions.get("processBarrelOnly") || context.mOptions.get("processBarrelOnlyWithQvectorCentr") || context.mOptions.get("processBarrelOnlyWithGlobalMults"); fEnableBarrelMuonHistos = context.mOptions.get("processElectronMuonDirect"); // Keep track of all the histogram class names to avoid composing strings in the pairing loop @@ -2004,6 +2013,13 @@ struct AnalysisSameEventPairing { runSameEventPairing(events, bcs, trackAssocsPerCollision, barrelAssocs, barrelTracks); } + void processBarrelOnlyWithGlobalMults(MyEventsGlobalMultSelected const& events, BCsWithTimestamps const& bcs, + soa::Join const& barrelAssocs, + MyBarrelTracksWithCovWithAmbiguities const& barrelTracks) + { + runSameEventPairing(events, bcs, trackAssocsPerCollision, barrelAssocs, barrelTracks); + } + void processElectronMuonDirect( MyEventsSelected const& events, BCsWithTimestamps const& bcs, soa::Join const& barrelAssocs, @@ -2028,6 +2044,7 @@ struct AnalysisSameEventPairing { void processDummy(MyEvents&) { /* do nothing */ } PROCESS_SWITCH(AnalysisSameEventPairing, processBarrelOnly, "Run barrel only pairing", false); + PROCESS_SWITCH(AnalysisSameEventPairing, processBarrelOnlyWithGlobalMults, "Run barrel only pairing with global track estimation", false); PROCESS_SWITCH(AnalysisSameEventPairing, processElectronMuonDirect, "Run electron-muon pairing on AO2D tracks/fwd-tracks", false); PROCESS_SWITCH(AnalysisSameEventPairing, processBarrelOnlyWithQvectorCentr, "Run barrel only pairing with Q-vector and centrality", false); PROCESS_SWITCH(AnalysisSameEventPairing, processDummy, "Dummy function", true);