diff --git a/PWGDQ/Core/HistogramsLibrary.cxx b/PWGDQ/Core/HistogramsLibrary.cxx index d4e5e3eb2a8..6d0d5650e86 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); @@ -163,7 +164,9 @@ void o2::aod::dqhistograms::DefineHistograms(HistogramManager* hm, const char* h 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); } 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 +180,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); @@ -1405,6 +1409,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 445dabf000c..43be973c408 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"; @@ -2123,6 +2125,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; diff --git a/PWGDQ/Core/VarManager.h b/PWGDQ/Core/VarManager.h index 7a395a9dcfb..e56b2499bbf 100644 --- a/PWGDQ/Core/VarManager.h +++ b/PWGDQ/Core/VarManager.h @@ -120,6 +120,7 @@ class VarManager : public TObject RapidityGapFilter = BIT(21), Fit = BIT(22), ReducedFit = BIT(23), + ReducedEventGlobalMult = BIT(24), Track = BIT(0), TrackCov = BIT(1), TrackExtra = BIT(2), @@ -251,6 +252,7 @@ class VarManager : public TObject kVtxZ, kVtxNcontrib, kVtxNcontribReal, + kMultNtrkGlobal, kVtxCovXX, kVtxCovXY, kVtxCovXZ, @@ -2660,6 +2662,10 @@ void VarManager::FillEvent(T const& event, float* values) FillZDC(event, values); } + if constexpr ((fillMap & ReducedEventGlobalMult) > 0) { + values[kMultNtrkGlobal] = event.multNtrkGlobal(); + } + 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..a6a72b9805f 100644 --- a/PWGDQ/DataModel/ReducedInfoTables.h +++ b/PWGDQ/DataModel/ReducedInfoTables.h @@ -157,6 +157,14 @@ DECLARE_SOA_COLUMN(Psi2Random, psi2random, float); //! Event plane angle from r DECLARE_SOA_COLUMN(Psi2A, psi2a, float); //! Event plane angle from Q-vector A DECLARE_SOA_COLUMN(Psi2B, psi2b, float); //! Event plane angle from Q-vector B DECLARE_SOA_COLUMN(Psi2C, psi2c, float); //! Event plane angle from Q-vector C + +DECLARE_SOA_COLUMN(MultNtrkGlobal, multNtrkGlobal, int); + +DECLARE_SOA_COLUMN(MultNtrkGlobalToward, multNtrkGlobalToward, int); +DECLARE_SOA_COLUMN(MultNtrkGlobalTransverseRight, multNtrkGlobalTransverseRight, int); +DECLARE_SOA_COLUMN(MultNtrkGlobalTransverseLeft, multNtrkGlobalTransverseLeft, int); +DECLARE_SOA_COLUMN(MultNtrkGlobalBackward, multNtrkGlobalBackward, int); + } // namespace reducedevent DECLARE_SOA_TABLE_STAGED(ReducedEvents, "REDUCEDEVENT", //! Main event information table @@ -184,6 +192,13 @@ DECLARE_SOA_TABLE(ReducedEventsMultPV_000, "AOD", "REMULTPV", //! Multiplicity mult::MultNTracksITSOnly, mult::MultNTracksTPCOnly, mult::MultNTracksITSTPC, evsel::NumTracksInTimeRange); +DECLARE_SOA_TABLE(ReducedEventsGlobalTrk, "AOD", "REGLOBALTRK", + reducedevent::MultNtrkGlobal); + +DECLARE_SOA_TABLE(ReducedEventsMultAzimuth, "AOD", "REMULTAZIMUTH", + reducedevent::MultNtrkGlobalToward, reducedevent::MultNtrkGlobalTransverseRight, + reducedevent::MultNtrkGlobalTransverseLeft, reducedevent::MultNtrkGlobalBackward); + 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 +888,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..eb5b0e19f2e --- /dev/null +++ b/PWGDQ/TableProducer/globalTrackEstimator.cxx @@ -0,0 +1,156 @@ +// 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 +#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; + +constexpr static uint32_t GkEventFillMap = VarManager::ObjTypes::ReducedEvent | VarManager::ObjTypes::ReducedEventExtended; +constexpr static uint32_t GkTrackFillMap = VarManager::ObjTypes::ReducedTrackBarrel | VarManager::ObjTypes::ReducedTrackBarrelCov; + +struct GlobalTrackEstimator { + Produces reducedEventsGlobalTrk; + Produces reducedEventsMultAzimuth; + + Configurable cfgMaxDCAxy{"cfgMaxDCAxy", 2.0, "Maximum DCAxy"}; + Configurable cfgMaxDCAz{"cfgMaxDCAz", 2.0, "Maximum DCAz"}; + Configurable cfgMinPt{"cfgMinPt", 0.1, "Minimum required pT"}; + Configurable cfgEtaRange{"cfgEtaRange", 0.8, "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, "Pseudorapidity range"}; + + o2::framework::Preslice preslice = o2::aod::reducedtrack_association::reducedeventId; + + o2::framework::expressions::Filter trackFilter = (o2::aod::reducedtrack::pt >= cfgMinPt) && (nabs(o2::aod::reducedtrack::eta) <= cfgEtaRange) && (o2::aod::track::tpcChi2NCl <= cfgMaxChi2TPC) && (o2::aod::track::itsChi2NCl <= cfgMaxChi2ITS); + + void init(InitContext& context) + { + LOGF(info, "Started global track counting"); + + bool isAnyProcessEnabled = context.mOptions.get("processGlobalTracksSkimmed") || context.mOptions.get("processGlobalTracksSkimmed"); + bool isDummyEnabled = context.mOptions.get("processDummy"); + + if (isDummyEnabled) { + if (isAnyProcessEnabled) { + LOG(fatal) << "You have enabled both the dummy process and at least one normal process function! Check your config!"; + } + return; + } + + if (!isAnyProcessEnabled) { + return; + } + } + + void processGlobalTracksSkimmed(MyEventsBasic const& events, o2::aod::ReducedTracksAssoc const& assocs, o2::soa::Filtered 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>(); + + VarManager::FillTrack(track); + VarManager::FillTrackCollision(track, event); + + const int nFindable = track.tpcNClsFindable(); + const int nCrossedRows = track.tpcNClsCrossedRows(); + + if (nCrossedRows < static_cast(cfgMinTPCCluster.value)) { + continue; + } + + if (nFindable <= 0) { + continue; + } + + const float crossedOverFindable = static_cast(nCrossedRows) / static_cast(nFindable); + + if (crossedOverFindable < cfgRatioTPCClusterOverFindableCluster.value) { + continue; + } + + if (cfgRequireITSibAny.value && ((track.itsClusterMap() & 0x7) == 0)) { + continue; + } + + if (std::abs(VarManager::fgValues[VarManager::kTrackDCAxy]) > cfgMaxDCAxy.value || std::abs(VarManager::fgValues[VarManager::kTrackDCAz]) > cfgMaxDCAz.value) { + continue; + } + + ++nTrkGlobal; + } + + reducedEventsGlobalTrk(nTrkGlobal); + } + } + + PROCESS_SWITCH(GlobalTrackEstimator, processGlobalTracksSkimmed, "Count global tracks from skimmed data model", 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..03f6f3de1b9 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; @@ -285,6 +287,7 @@ using MyMuonTracksWithCovWithAmbiguities = soa::Join(events, mcEvents); publishSelections(events); } + void processSkimmedWithGlobalMults(MyEventsVtxCovGlobalMult const& events, aod::ReducedMCEvents 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 +636,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 +1814,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 +2376,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 +3194,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 +3460,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/tableReader_withAssoc.h b/PWGDQ/Tasks/tableReader_withAssoc.h index 354e9fe815d..67242602666 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; @@ -299,6 +302,7 @@ constexpr static uint32_t gkEventFillMapWithMultExtraWithQVector = VarManager::O // constexpr static uint32_t gkEventFillMapWithMultExtraWithQVector = VarManager::ObjTypes::ReducedEvent | VarManager::ObjTypes::ReducedEventExtended | VarManager::ObjTypes::ReducedEventMultExtra | VarManager::ObjTypes::ReducedEventQvector; constexpr static uint32_t gkEventFillMapWithMultExtraZdc = VarManager::ObjTypes::ReducedEvent | VarManager::ObjTypes::ReducedEventExtended | VarManager::ObjTypes::ReducedEventMultExtra | VarManager::ReducedZdc; constexpr static uint32_t gkEventFillMapWithMultExtraZdcFit = VarManager::ObjTypes::ReducedEvent | VarManager::ObjTypes::ReducedEventExtended | VarManager::ObjTypes::ReducedEventMultExtra | VarManager::ReducedZdc | VarManager::ReducedFit; +constexpr static uint32_t gkEventFillMapGlobalMult = VarManager::ObjTypes::ReducedEvent | VarManager::ObjTypes::ReducedEventExtended | VarManager::ObjTypes::ReducedEventVtxCov | VarManager::ReducedEventGlobalMult; constexpr static uint32_t gkEventFillMapWithCovZdcFitMultExtra = VarManager::ObjTypes::ReducedEvent | VarManager::ObjTypes::ReducedEventExtended | VarManager::ObjTypes::ReducedEventVtxCov | VarManager::ReducedZdc | VarManager::ReducedFit | VarManager::ReducedEventMultExtra; constexpr static uint32_t gkEventFillMapWithQvectorCentr = VarManager::ObjTypes::ReducedEvent | VarManager::ObjTypes::ReducedEventExtended | VarManager::ObjTypes::CollisionQvect | VarManager::ObjTypes::ReducedEventMultExtra; // constexpr static uint32_t gkEventFillMapWithQvector = VarManager::ObjTypes::ReducedEvent | VarManager::ObjTypes::ReducedEventExtended | VarManager::ObjTypes::ReducedEventQvector; @@ -392,7 +396,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 +696,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 +753,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); @@ -1573,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"); - 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"); + 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"); @@ -3224,6 +3234,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) @@ -3297,6 +3314,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) { @@ -3337,6 +3360,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); @@ -3349,6 +3373,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);