From f9b2534a0f7d05bd0ffaeaa92fab9a621139d74a Mon Sep 17 00:00:00 2001 From: Maximiliano Puccio Date: Wed, 5 Feb 2025 18:56:48 +0100 Subject: [PATCH 01/30] [PWGLF] Rename `mDCA` to `motherDCA` for clarity (#9766) --- PWGLF/Tasks/Strangeness/nonPromptCascade.cxx | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/nonPromptCascade.cxx b/PWGLF/Tasks/Strangeness/nonPromptCascade.cxx index f501e909402..428b088166a 100644 --- a/PWGLF/Tasks/Strangeness/nonPromptCascade.cxx +++ b/PWGLF/Tasks/Strangeness/nonPromptCascade.cxx @@ -292,7 +292,7 @@ struct NonPromptCascadeTask { } template - void fillCascadeDCA(T const track, PR const& protonTrack, PI const& pionTrack, o2::dataformats::VertexBase primaryVertex, bool isOmega, motherDCA& mDCA) + void fillCascadeDCA(T const track, PR const& protonTrack, PI const& pionTrack, o2::dataformats::VertexBase primaryVertex, bool isOmega, motherDCA& motherDCA) { const auto matCorr = static_cast(cfgMaterialCorrection.value); auto trackCovTrk = getTrackParCov(track); @@ -317,8 +317,8 @@ struct NonPromptCascadeTask { registry.fill(HIST("h_dcavsr_Xi"), impactParameterTrk.getY(), std::hypot(track.x(), track.y())); } } - mDCA.DCAxy = impactParameterTrk.getY(); - mDCA.DCAz = impactParameterTrk.getZ(); + motherDCA.DCAxy = impactParameterTrk.getY(); + motherDCA.DCAz = impactParameterTrk.getZ(); } template @@ -580,8 +580,8 @@ struct NonPromptCascadeTask { invMassACV0->Fill(v0mass); registry.fill(HIST("h_massvspt_V0"), v0mass, track.pt()); - motherDCA mDCA; - fillCascadeDCA(track, protonTrack, pionTrack, primaryVertex, isOmega, mDCA); + motherDCA motherDCA; + fillCascadeDCA(track, protonTrack, pionTrack, primaryVertex, isOmega, motherDCA); daughtersDCA dDCA; fillDauDCA(trackedCascade, bachelor, protonTrack, pionTrack, primaryVertex, isOmega, dDCA); @@ -589,7 +589,7 @@ struct NonPromptCascadeTask { collision.numContrib(), collision.collisionTimeRes(), primaryVertex.getX(), primaryVertex.getY(), primaryVertex.getZ(), track.pt(), track.eta(), track.phi(), protonTrack.pt(), protonTrack.eta(), pionTrack.pt(), pionTrack.eta(), bachelor.pt(), bachelor.eta(), - mDCA.DCAxy, mDCA.DCAz, dDCA.protonDCAxy, dDCA.protonDCAz, dDCA.pionDCAxy, dDCA.pionDCAz, dDCA.bachDCAxy, dDCA.bachDCAz, + motherDCA.DCAxy, motherDCA.DCAz, dDCA.protonDCAxy, dDCA.protonDCAz, dDCA.pionDCAxy, dDCA.pionDCAz, dDCA.bachDCAxy, dDCA.bachDCAz, cascCpa, v0Cpa, massXi, massOmega, v0mass, std::hypot(trackedCascade.decayX(), trackedCascade.decayY()), std::hypot(v0Pos[0], v0Pos[1]), std::hypot(trackedCascade.decayX(), trackedCascade.decayY(), trackedCascade.decayZ()), std::hypot(v0Pos[0], v0Pos[1], v0Pos[2]), From 774f9321d43d636db3a5e3c8a6677ff331f3a436 Mon Sep 17 00:00:00 2001 From: nzardosh Date: Wed, 5 Feb 2025 22:18:51 +0100 Subject: [PATCH 02/30] [PWGJE] Adding missing event selection bit to sel8FullPbPb (#9771) --- PWGJE/Core/JetDerivedDataUtilities.h | 1 + 1 file changed, 1 insertion(+) diff --git a/PWGJE/Core/JetDerivedDataUtilities.h b/PWGJE/Core/JetDerivedDataUtilities.h index 5462d9623f8..c2c74bb1def 100644 --- a/PWGJE/Core/JetDerivedDataUtilities.h +++ b/PWGJE/Core/JetDerivedDataUtilities.h @@ -115,6 +115,7 @@ std::vector initialiseEventSelectionBits(std::string eventSelectionMasks) eventSelectionMaskBits.push_back(JCollisionSel::selNoSameBunchPileup); } if (eventSelectionMasksContainSelection(eventSelectionMasks, "sel8FullPbPb")) { + eventSelectionMaskBits.push_back(JCollisionSel::sel8); eventSelectionMaskBits.push_back(JCollisionSel::selNoCollInTimeRangeStandard); eventSelectionMaskBits.push_back(JCollisionSel::selNoCollInRofStandard); } From 787df17bfa5ffbb5bce34a42969604dfdec49e92 Mon Sep 17 00:00:00 2001 From: Zhiyong <71517277+Luzhiyongg@users.noreply.github.com> Date: Thu, 6 Feb 2025 05:50:59 +0800 Subject: [PATCH 03/30] [PWGCF] calculate v2 correction factor from MC (#9742) --- PWGCF/Flow/Tasks/CMakeLists.txt | 7 +- PWGCF/Flow/Tasks/flowMc.cxx | 323 ++++++++++++++++++++++++++ PWGCF/Flow/Tasks/flowPtEfficiency.cxx | 295 ++++++++++++++++++++++- 3 files changed, 623 insertions(+), 2 deletions(-) create mode 100644 PWGCF/Flow/Tasks/flowMc.cxx diff --git a/PWGCF/Flow/Tasks/CMakeLists.txt b/PWGCF/Flow/Tasks/CMakeLists.txt index 98daea3d4d5..d7bc12308eb 100644 --- a/PWGCF/Flow/Tasks/CMakeLists.txt +++ b/PWGCF/Flow/Tasks/CMakeLists.txt @@ -11,7 +11,7 @@ o2physics_add_dpl_workflow(flow-pt-efficiency SOURCES flowPtEfficiency.cxx - PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore O2Physics::GFWCore COMPONENT_NAME Analysis) o2physics_add_dpl_workflow(flow-task @@ -24,6 +24,11 @@ o2physics_add_dpl_workflow(flow-runby-run PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore O2Physics::AnalysisCCDB O2Physics::GFWCore COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(flow-mc + SOURCES flowMc.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore O2Physics::GFWCore + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(flow-gfw-task SOURCES flowGfwTask.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore O2Physics::GFWCore diff --git a/PWGCF/Flow/Tasks/flowMc.cxx b/PWGCF/Flow/Tasks/flowMc.cxx new file mode 100644 index 00000000000..18593cdd34b --- /dev/null +++ b/PWGCF/Flow/Tasks/flowMc.cxx @@ -0,0 +1,323 @@ +// 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. + +/// \file flowMc.cxx +/// \author Zhiyong Lu (zhiyong.lu@cern.ch) +/// \since Feb/5/2025 +/// \brief QC of synthetic flow exercise + +#include +#include +#include "Framework/AnalysisDataModel.h" +#include "Framework/AnalysisTask.h" +#include "Framework/HistogramRegistry.h" +#include "Framework/runDataProcessing.h" +#include "Framework/ASoAHelpers.h" +#include "Framework/RunningWorkflowInfo.h" +#include "Common/DataModel/TrackSelectionTables.h" +#include "Common/Core/TrackSelection.h" +#include "Common/Core/TrackSelectionDefaults.h" +#include "Common/Core/trackUtilities.h" +#include "ReconstructionDataFormats/Track.h" +#include "DataFormatsParameters/GRPObject.h" +#include "DataFormatsParameters/GRPMagField.h" +#include "PWGLF/DataModel/LFStrangenessTables.h" +#include "PWGMM/Mult/DataModel/Index.h" // for Particles2Tracks table +#include "GFWPowerArray.h" +#include "GFW.h" +#include "GFWCumulant.h" +#include "GFWWeights.h" + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; + +#define O2_DEFINE_CONFIGURABLE(NAME, TYPE, DEFAULT, HELP) Configurable NAME{#NAME, DEFAULT, HELP}; + +struct FlowMc { + HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; + + Configurable minB{"minB", 0.0f, "min impact parameter"}; + Configurable maxB{"maxB", 20.0f, "max impact parameter"}; + O2_DEFINE_CONFIGURABLE(cfgOutputNUAWeights, bool, false, "Fill and output NUA weights") + O2_DEFINE_CONFIGURABLE(cfgCutPtRefMin, float, 0.2f, "Minimal pT for ref tracks") + O2_DEFINE_CONFIGURABLE(cfgCutPtRefMax, float, 3.0f, "Maximal pT for ref tracks") + O2_DEFINE_CONFIGURABLE(cfgFlowAcceptance, std::string, "", "CCDB path to acceptance object") + O2_DEFINE_CONFIGURABLE(cfgFlowEfficiency, std::string, "", "CCDB path to efficiency object") + + ConfigurableAxis axisB{"axisB", {100, 0.0f, 20.0f}, ""}; + ConfigurableAxis axisPhi{"axisPhi", {100, 0.0f, constants::math::TwoPI}, ""}; + ConfigurableAxis axisNch{"axisNch", {300, 0.0f, 3000.0f}, "Nch in |eta|<0.8"}; + + ConfigurableAxis axisPt{"axisPt", {VARIABLE_WIDTH, 0.0f, 0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f, 1.1f, 1.2f, 1.3f, 1.4f, 1.5f, 1.6f, 1.7f, 1.8f, 1.9f, 2.0f, 2.2f, 2.4f, 2.6f, 2.8f, 3.0f, 3.2f, 3.4f, 3.6f, 3.8f, 4.0f, 4.4f, 4.8f, 5.2f, 5.6f, 6.0f, 6.5f, 7.0f, 7.5f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f}, "pt axis"}; + + // Corrections + TH1D* mEfficiency = nullptr; + GFWWeights* mAcceptance = nullptr; + bool correctionsLoaded = false; + + // Connect to ccdb + Service ccdb; + Configurable ccdbNoLaterThan{"ccdbNoLaterThan", std::chrono::duration_cast(std::chrono::system_clock::now().time_since_epoch()).count(), "latest acceptable timestamp of creation for the object"}; + Configurable ccdbUrl{"ccdbUrl", "http://alice-ccdb.cern.ch", "url of the ccdb repository"}; + + OutputObj fWeights{GFWWeights("weights")}; + + void init(InitContext&) + { + // pT histograms + histos.add("hImpactParameter", "hImpactParameter", HistType::kTH1D, {axisB}); + histos.add("hNchVsImpactParameter", "hNchVsImpactParameter", HistType::kTH2D, {axisB, axisNch}); + histos.add("hEventPlaneAngle", "hEventPlaneAngle", HistType::kTH1D, {axisPhi}); + histos.add("hPtVsPhiGenerated", "hPtVsPhiGenerated", HistType::kTH2D, {axisPhi, axisPt}); + histos.add("hPtVsPhiGlobal", "hPtVsPhiGlobal", HistType::kTH2D, {axisPhi, axisPt}); + histos.add("hBVsPtVsPhiGenerated", "hBVsPtVsPhiGenerated", HistType::kTH3D, {axisB, axisPhi, axisPt}); + histos.add("hBVsPtVsPhiGlobal", "hBVsPtVsPhiGlobal", HistType::kTH3D, {axisB, axisPhi, axisPt}); + histos.add("hBVsPtVsPhiAny", "hBVsPtVsPhiAny", HistType::kTH3D, {axisB, axisPhi, axisPt}); + histos.add("hBVsPtVsPhiTPCTrack", "hBVsPtVsPhiTPCTrack", HistType::kTH3D, {axisB, axisPhi, axisPt}); + histos.add("hBVsPtVsPhiITSTrack", "hBVsPtVsPhiITSTrack", HistType::kTH3D, {axisB, axisPhi, axisPt}); + histos.add("hBVsPtVsPhiITSABTrack", "hBVsPtVsPhiITSABTrack", HistType::kTH3D, {axisB, axisPhi, axisPt}); + + histos.add("hBVsPtVsPhiGeneratedK0Short", "hBVsPtVsPhiGeneratedK0Short", HistType::kTH3D, {axisB, axisPhi, axisPt}); + histos.add("hBVsPtVsPhiGlobalK0Short", "hBVsPtVsPhiGlobalK0Short", HistType::kTH3D, {axisB, axisPhi, axisPt}); + histos.add("hBVsPtVsPhiGeneratedLambda", "hBVsPtVsPhiGeneratedLambda", HistType::kTH3D, {axisB, axisPhi, axisPt}); + histos.add("hBVsPtVsPhiGlobalLambda", "hBVsPtVsPhiGlobalLambda", HistType::kTH3D, {axisB, axisPhi, axisPt}); + + histos.add("hBVsPtVsPhiGeneratedXi", "hBVsPtVsPhiGeneratedXi", HistType::kTH3D, {axisB, axisPhi, axisPt}); + histos.add("hBVsPtVsPhiGlobalXi", "hBVsPtVsPhiGlobalXi", HistType::kTH3D, {axisB, axisPhi, axisPt}); + histos.add("hBVsPtVsPhiGeneratedOmega", "hBVsPtVsPhiGeneratedOmega", HistType::kTH3D, {axisB, axisPhi, axisPt}); + histos.add("hBVsPtVsPhiGlobalOmega", "hBVsPtVsPhiGlobalOmega", HistType::kTH3D, {axisB, axisPhi, axisPt}); + + histos.add("hPhi", "#phi distribution", HistType::kTH1D, {axisPhi}); + histos.add("hPhiWeighted", "corrected #phi distribution", HistType::kTH1D, {axisPhi}); + + if (cfgOutputNUAWeights) { + o2::framework::AxisSpec axis = axisPt; + int nPtBins = axis.binEdges.size() - 1; + double* ptBins = &(axis.binEdges)[0]; + + fWeights->setPtBins(nPtBins, ptBins); + fWeights->init(true, false); + } + } + + void loadCorrections(uint64_t timestamp) + { + if (correctionsLoaded) + return; + if (cfgFlowAcceptance.value.empty() == false) { + mAcceptance = ccdb->getForTimeStamp(cfgFlowAcceptance, timestamp); + if (mAcceptance) + LOGF(info, "Loaded acceptance weights from %s (%p)", cfgFlowAcceptance.value.c_str(), (void*)mAcceptance); + else + LOGF(warning, "Could not load acceptance weights from %s (%p)", cfgFlowAcceptance.value.c_str(), (void*)mAcceptance); + } + if (cfgFlowEfficiency.value.empty() == false) { + mEfficiency = ccdb->getForTimeStamp(cfgFlowEfficiency, timestamp); + if (mEfficiency == nullptr) { + LOGF(fatal, "Could not load efficiency histogram for trigger particles from %s", cfgFlowEfficiency.value.c_str()); + } + LOGF(info, "Loaded efficiency histogram from %s (%p)", cfgFlowEfficiency.value.c_str(), (void*)mEfficiency); + } + correctionsLoaded = true; + } + + bool setCurrentParticleWeights(float& weight_nue, float& weight_nua, float phi, float eta, float pt, float vtxz) + { + float eff = 1.; + if (mEfficiency) + eff = mEfficiency->GetBinContent(mEfficiency->FindBin(pt)); + else + eff = 1.0; + if (eff == 0) + return false; + weight_nue = 1. / eff; + if (mAcceptance) + weight_nua = mAcceptance->getNUA(phi, eta, vtxz); + else + weight_nua = 1; + return true; + } + + using RecoTracks = soa::Join; + + void process(aod::McCollision const& mcCollision, soa::Join const& mcParticles, RecoTracks const&) + { + + float imp = mcCollision.impactParameter(); + float evPhi = mcCollision.eventPlaneAngle(); + float vtxz = mcCollision.posZ(); + if (evPhi < 0) + evPhi += constants::math::TwoPI; + + int64_t nCh = 0; + float weff = 1.; + float wacc = 1.; + auto bc = mcCollision.bc_as(); + loadCorrections(bc.timestamp()); + + if (imp > minB && imp < maxB) { + // event within range + histos.fill(HIST("hImpactParameter"), imp); + histos.fill(HIST("hEventPlaneAngle"), evPhi); + + for (auto const& mcParticle : mcParticles) { + // focus on bulk: e, mu, pi, k, p + int pdgCode = std::abs(mcParticle.pdgCode()); + if (pdgCode != 11 && pdgCode != 13 && pdgCode != 211 && pdgCode != 321 && pdgCode != 2212) + continue; + + if (!mcParticle.isPhysicalPrimary()) + continue; + if (std::fabs(mcParticle.eta()) > 0.8) // main acceptance + continue; + + float deltaPhi = mcParticle.phi() - mcCollision.eventPlaneAngle(); + if (deltaPhi < 0) + deltaPhi += constants::math::TwoPI; + if (deltaPhi > constants::math::TwoPI) + deltaPhi -= constants::math::TwoPI; + histos.fill(HIST("hPtVsPhiGenerated"), deltaPhi, mcParticle.pt()); + histos.fill(HIST("hBVsPtVsPhiGenerated"), imp, deltaPhi, mcParticle.pt()); + + nCh++; + + bool validGlobal = false; + bool validTrack = false; + bool validTPCTrack = false; + bool validITSTrack = false; + bool validITSABTrack = false; + if (mcParticle.has_tracks()) { + auto const& tracks = mcParticle.tracks_as(); + for (auto const& track : tracks) { + if (track.hasTPC() && track.hasITS()) { + validGlobal = true; + } + if (track.hasTPC() || track.hasITS()) { + validTrack = true; + } + if (track.hasTPC()) { + validTPCTrack = true; + } + if (track.hasITS() && track.itsChi2NCl() > -1e-6) { + validITSTrack = true; + } + if (track.hasITS() && track.itsChi2NCl() < -1e-6) { + validITSABTrack = true; + } + } + } + + bool withinPtRef = (cfgCutPtRefMin < mcParticle.pt()) && (mcParticle.pt() < cfgCutPtRefMax); // within RF pT range + if (cfgOutputNUAWeights && withinPtRef) + fWeights->fill(mcParticle.phi(), mcParticle.eta(), vtxz, mcParticle.pt(), 0, 0); + if (!setCurrentParticleWeights(weff, wacc, mcParticle.phi(), mcParticle.eta(), mcParticle.pt(), vtxz)) + continue; + if (withinPtRef) { + histos.fill(HIST("hPhi"), mcParticle.phi()); + histos.fill(HIST("hPhiWeighted"), mcParticle.phi(), wacc); + } + + // if valid global, fill + if (validGlobal) { + histos.fill(HIST("hPtVsPhiGlobal"), deltaPhi, mcParticle.pt(), wacc * weff); + histos.fill(HIST("hBVsPtVsPhiGlobal"), imp, deltaPhi, mcParticle.pt(), wacc * weff); + } + // if any track present, fill + if (validTrack) + histos.fill(HIST("hBVsPtVsPhiAny"), imp, deltaPhi, mcParticle.pt(), wacc * weff); + if (validTPCTrack) + histos.fill(HIST("hBVsPtVsPhiTPCTrack"), imp, deltaPhi, mcParticle.pt(), wacc * weff); + if (validITSTrack) + histos.fill(HIST("hBVsPtVsPhiITSTrack"), imp, deltaPhi, mcParticle.pt(), wacc * weff); + if (validITSABTrack) + histos.fill(HIST("hBVsPtVsPhiITSABTrack"), imp, deltaPhi, mcParticle.pt(), wacc * weff); + } + } + histos.fill(HIST("hNchVsImpactParameter"), imp, nCh); + } + + using LabeledCascades = soa::Join; + + void processCascade(aod::McParticle const& mcParticle, soa::SmallGroups const& cascades, RecoTracks const&, aod::McCollisions const&) + { + auto mcCollision = mcParticle.mcCollision(); + float imp = mcCollision.impactParameter(); + + int pdgCode = std::abs(mcParticle.pdgCode()); + if (pdgCode != 3312 && pdgCode != 3334) + return; + + if (!mcParticle.isPhysicalPrimary()) + return; + if (std::fabs(mcParticle.eta()) > 0.8) + return; + + float deltaPhi = mcParticle.phi() - mcCollision.eventPlaneAngle(); + if (deltaPhi < 0) + deltaPhi += constants::math::TwoPI; + if (deltaPhi > constants::math::TwoPI) + deltaPhi -= constants::math::TwoPI; + if (pdgCode == 3312) + histos.fill(HIST("hBVsPtVsPhiGeneratedXi"), imp, deltaPhi, mcParticle.pt()); + if (pdgCode == 3334) + histos.fill(HIST("hBVsPtVsPhiGeneratedOmega"), imp, deltaPhi, mcParticle.pt()); + + if (cascades.size() > 0) { + if (pdgCode == 3312) + histos.fill(HIST("hBVsPtVsPhiGlobalXi"), imp, deltaPhi, mcParticle.pt()); + if (pdgCode == 3334) + histos.fill(HIST("hBVsPtVsPhiGlobalOmega"), imp, deltaPhi, mcParticle.pt()); + } + } + PROCESS_SWITCH(FlowMc, processCascade, "Process cascades", true); + + using LabeledV0s = soa::Join; + + void processV0s(aod::McParticle const& mcParticle, soa::SmallGroups const& v0s, RecoTracks const&, aod::McCollisions const&) + { + auto mcCollision = mcParticle.mcCollision(); + float imp = mcCollision.impactParameter(); + + int pdgCode = std::abs(mcParticle.pdgCode()); + if (pdgCode != 310 && pdgCode != 3122) + return; + + if (!mcParticle.isPhysicalPrimary()) + return; + if (std::fabs(mcParticle.eta()) > 0.8) + return; + + float deltaPhi = mcParticle.phi() - mcCollision.eventPlaneAngle(); + if (deltaPhi < 0) + deltaPhi += constants::math::TwoPI; + if (deltaPhi > constants::math::TwoPI) + deltaPhi -= constants::math::TwoPI; + if (pdgCode == 310) + histos.fill(HIST("hBVsPtVsPhiGeneratedK0Short"), imp, deltaPhi, mcParticle.pt()); + if (pdgCode == 3122) + histos.fill(HIST("hBVsPtVsPhiGeneratedLambda"), imp, deltaPhi, mcParticle.pt()); + + if (v0s.size() > 0) { + if (pdgCode == 310) + histos.fill(HIST("hBVsPtVsPhiGlobalK0Short"), imp, deltaPhi, mcParticle.pt()); + if (pdgCode == 3122) + histos.fill(HIST("hBVsPtVsPhiGlobalLambda"), imp, deltaPhi, mcParticle.pt()); + } + } + PROCESS_SWITCH(FlowMc, processV0s, "Process V0s", true); +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{ + adaptAnalysisTask(cfgc)}; +} diff --git a/PWGCF/Flow/Tasks/flowPtEfficiency.cxx b/PWGCF/Flow/Tasks/flowPtEfficiency.cxx index fcd39a21dd0..4ed37f9b7a5 100644 --- a/PWGCF/Flow/Tasks/flowPtEfficiency.cxx +++ b/PWGCF/Flow/Tasks/flowPtEfficiency.cxx @@ -14,10 +14,13 @@ /// \since Jun/08/2023 /// \brief a task to calculate the pt efficiency +#include #include +#include #include "Framework/runDataProcessing.h" #include "Framework/AnalysisTask.h" #include "Framework/ASoAHelpers.h" +#include "Framework/RunningWorkflowInfo.h" #include "Framework/HistogramRegistry.h" #include "Common/DataModel/EventSelection.h" @@ -25,6 +28,14 @@ #include "Common/Core/TrackSelectionDefaults.h" #include "Common/DataModel/TrackSelectionTables.h" +#include "GFWPowerArray.h" +#include "GFW.h" +#include "GFWCumulant.h" +#include "GFWWeights.h" +#include "FlowContainer.h" +#include +#include + using namespace o2; using namespace o2::framework; using namespace o2::framework::expressions; @@ -48,9 +59,22 @@ struct FlowPtEfficiency { O2_DEFINE_CONFIGURABLE(cfgCutDCAxyppPass3Enabled, bool, false, "switch of ppPass3 DCAxy pt dependent cut") O2_DEFINE_CONFIGURABLE(cfgCutDCAzPtDepEnabled, bool, false, "switch of DCAz pt dependent cut") O2_DEFINE_CONFIGURABLE(cfgSelRunNumberEnabled, bool, false, "switch of run number selection") + O2_DEFINE_CONFIGURABLE(cfgFlowEnabled, bool, false, "switch of calculating flow") + O2_DEFINE_CONFIGURABLE(cfgFlowNbootstrap, int, 30, "Number of subsamples") + O2_DEFINE_CONFIGURABLE(cfgFlowCutPtPOIMin, float, 0.2f, "Minimal pT for poi tracks") + O2_DEFINE_CONFIGURABLE(cfgFlowCutPtPOIMax, float, 10.0f, "Maximal pT for poi tracks") + O2_DEFINE_CONFIGURABLE(cfgFlowCutPtRefMin, float, 0.2f, "Minimal pT for ref tracks") + O2_DEFINE_CONFIGURABLE(cfgFlowCutPtRefMax, float, 3.0f, "Maximal pT for ref tracks") + O2_DEFINE_CONFIGURABLE(cfgCentVsIPTruth, std::string, "", "CCDB path to centrality vs IP truth") + O2_DEFINE_CONFIGURABLE(cfgCentVsIPReco, std::string, "", "CCDB path to centrality vs IP reco") + O2_DEFINE_CONFIGURABLE(cfgFlowAcceptance, std::string, "", "CCDB path to acceptance object") + O2_DEFINE_CONFIGURABLE(cfgFlowEfficiency, std::string, "", "CCDB path to efficiency object") Configurable> cfgRunNumberList{"cfgRunNumberList", std::vector{-1}, "runnumber list in consideration for analysis"}; - ConfigurableAxis axisPt{"axisPt", {VARIABLE_WIDTH, 0.2, 0.25, 0.30, 0.40, 0.45, 0.50, 0.55, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95, 1.00, 1.10, 1.20, 1.30, 1.40, 1.50, 1.60, 1.70, 1.80, 1.90, 2.00, 2.20, 2.40, 2.60, 2.80, 3.00}, "pt axis for histograms"}; + ConfigurableAxis axisPt{"axisPt", {VARIABLE_WIDTH, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2, 2.2, 2.4, 2.6, 2.8, 3, 3.5, 4, 5, 6, 8, 10}, "pt axis for histograms"}; + ConfigurableAxis axisCentrality{"axisCentrality", {VARIABLE_WIDTH, 0, 5, 10, 20, 30, 40, 50, 60, 70, 80, 90}, "X axis for histograms"}; + ConfigurableAxis axisPhi{"axisPhi", {100, 0.0f, constants::math::TwoPI}, ""}; + ConfigurableAxis axisB{"axisB", {100, 0.0f, 20.0f}, "b (fm)"}; // Filter the tracks Filter trackFilter = (nabs(aod::track::eta) < cfgCutEta) && (aod::track::pt > cfgCutPtMin) && (aod::track::pt < cfgCutPtMax) && (aod::track::tpcChi2NCl < cfgCutChi2prTPCcls); @@ -71,8 +95,32 @@ struct FlowPtEfficiency { // Additional filters for tracks TrackSelection myTrackSel; + // Cent vs IP + TH1D* mCentVsIPTruth = nullptr; + bool centVsIPTruthLoaded = false; + TH1D* mCentVsIPReco = nullptr; + bool centVsIPRecoLoaded = false; + + // corrections + TH1D* mEfficiency = nullptr; + GFWWeights* mAcceptance = nullptr; + bool correctionsLoaded = false; + + // Connect to ccdb + Service ccdb; + Configurable ccdbNoLaterThan{"ccdbNoLaterThan", std::chrono::duration_cast(std::chrono::system_clock::now().time_since_epoch()).count(), "latest acceptable timestamp of creation for the object"}; + Configurable ccdbUrl{"ccdbUrl", "http://alice-ccdb.cern.ch", "url of the ccdb repository"}; + // Define the output HistogramRegistry registry{"registry"}; + OutputObj fFCTrue{FlowContainer("FlowContainerTrue")}; + OutputObj fFCReco{FlowContainer("FlowContainerReco")}; + OutputObj fWeights{GFWWeights("weights")}; + GFW* fGFWTrue = new GFW(); + GFW* fGFWReco = new GFW(); + TAxis* fPtAxis; + std::vector corrconfigs; + TRandom3* fRndm = new TRandom3(0); bool isStable(int pdg) { @@ -99,6 +147,58 @@ struct FlowPtEfficiency { registry.add("mcEventCounter", "Monte Carlo Truth EventCounter", kTH1F, {axisCounter}); registry.add("hPtMCGen", "Monte Carlo Truth", {HistType::kTH1D, {axisPt}}); + if (cfgFlowEnabled) { + registry.add("hImpactParameterReco", "hImpactParameterReco", {HistType::kTH1D, {axisB}}); + registry.add("hImpactParameterTruth", "hImpactParameterTruth", {HistType::kTH1D, {axisB}}); + registry.add("hPhi", "#phi distribution", {HistType::kTH1D, {axisPhi}}); + registry.add("hPhiWeighted", "corrected #phi distribution", {HistType::kTH1D, {axisPhi}}); + + o2::framework::AxisSpec axis = axisPt; + int nPtBins = axis.binEdges.size() - 1; + double* ptBins = &(axis.binEdges)[0]; + fPtAxis = new TAxis(nPtBins, ptBins); + + fWeights->setPtBins(nPtBins, ptBins); + fWeights->init(true, false); + + TObjArray* oba = new TObjArray(); + oba->Add(new TNamed("ChFull22", "ChFull22")); + for (auto i = 0; i < fPtAxis->GetNbins(); i++) + oba->Add(new TNamed(Form("ChFull22_pt_%i", i + 1), "ChFull22_pTDiff")); + oba->Add(new TNamed("Ch10Gap22", "Ch10Gap22")); + for (auto i = 0; i < fPtAxis->GetNbins(); i++) + oba->Add(new TNamed(Form("Ch10Gap22_pt_%i", i + 1), "Ch10Gap22_pTDiff")); + fFCTrue->SetName("FlowContainerTrue"); + fFCTrue->SetXAxis(fPtAxis); + fFCTrue->Initialize(oba, axisCentrality, cfgFlowNbootstrap); + fFCReco->SetName("FlowContainerReco"); + fFCReco->SetXAxis(fPtAxis); + fFCReco->Initialize(oba, axisCentrality, cfgFlowNbootstrap); + delete oba; + + fGFWTrue->AddRegion("full", -0.8, 0.8, 1, 1); + fGFWTrue->AddRegion("refN10", -0.8, -0.5, 1, 1); + fGFWTrue->AddRegion("refP10", 0.5, 0.8, 1, 1); + fGFWTrue->AddRegion("poiN10", -0.8, -0.5, 1 + fPtAxis->GetNbins(), 2); + fGFWTrue->AddRegion("poifull", -0.8, 0.8, 1 + fPtAxis->GetNbins(), 2); + fGFWTrue->AddRegion("olN10", -0.8, -0.5, 1, 4); + fGFWTrue->AddRegion("olfull", -0.8, 0.8, 1 + fPtAxis->GetNbins(), 4); + corrconfigs.push_back(fGFWTrue->GetCorrelatorConfig("full {2 -2}", "ChFull22", kFALSE)); + corrconfigs.push_back(fGFWTrue->GetCorrelatorConfig("poifull full | olfull {2 -2}", "ChFull22", kTRUE)); + corrconfigs.push_back(fGFWTrue->GetCorrelatorConfig("refN10 {2} refP10 {-2}", "Ch10Gap22", kFALSE)); + corrconfigs.push_back(fGFWTrue->GetCorrelatorConfig("poiN10 refN10 | olN10 {2} refP10 {-2}", "Ch10Gap22", kTRUE)); + fGFWTrue->CreateRegions(); + + fGFWReco->AddRegion("full", -0.8, 0.8, 1, 1); + fGFWReco->AddRegion("refN10", -0.8, -0.5, 1, 1); + fGFWReco->AddRegion("refP10", 0.5, 0.8, 1, 1); + fGFWReco->AddRegion("poiN10", -0.8, -0.5, 1 + fPtAxis->GetNbins(), 2); + fGFWReco->AddRegion("poifull", -0.8, 0.8, 1 + fPtAxis->GetNbins(), 2); + fGFWReco->AddRegion("olN10", -0.8, -0.5, 1, 4); + fGFWReco->AddRegion("olfull", -0.8, 0.8, 1 + fPtAxis->GetNbins(), 4); + fGFWReco->CreateRegions(); + } + if (cfgTrkSelRun3ITSMatch) { myTrackSel = getGlobalTrackSelectionRun3ITSMatch(TrackSelection::GlobalTrackRun3ITSMatching::Run3ITSall7Layers, TrackSelection::GlobalTrackRun3DCAxyCut::Default); } else { @@ -116,6 +216,125 @@ struct FlowPtEfficiency { myTrackSel.SetMaxDcaZ(cfgCutDCAz); } + template + void fillProfile(GFW* fGFW, const GFW::CorrConfig& corrconf, const ConstStr& tarName, const double& cent) + { + double dnx, val; + dnx = fGFW->Calculate(corrconf, 0, kTRUE).real(); + if (dnx == 0) + return; + if (!corrconf.pTDif) { + val = fGFW->Calculate(corrconf, 0, kFALSE).real() / dnx; + if (std::fabs(val) < 1) + registry.fill(tarName, cent, val, dnx); + return; + } + return; + } + + void fillFC(GFW* fGFW, bool isMCTruth, const GFW::CorrConfig& corrconf, const double& cent, const double& rndm) + { + double dnx, val; + dnx = fGFW->Calculate(corrconf, 0, kTRUE).real(); + if (dnx == 0) + return; + if (!corrconf.pTDif) { + val = fGFW->Calculate(corrconf, 0, kFALSE).real() / dnx; + if (std::fabs(val) < 1) { + if (isMCTruth) + fFCTrue->FillProfile(corrconf.Head.c_str(), cent, val, dnx, rndm); + else + fFCReco->FillProfile(corrconf.Head.c_str(), cent, val, dnx, rndm); + } + return; + } + for (auto i = 1; i <= fPtAxis->GetNbins(); i++) { + dnx = fGFW->Calculate(corrconf, i - 1, kTRUE).real(); + if (dnx == 0) + continue; + val = fGFW->Calculate(corrconf, i - 1, kFALSE).real() / dnx; + if (std::fabs(val) < 1) { + if (isMCTruth) + fFCTrue->FillProfile(Form("%s_pt_%i", corrconf.Head.c_str(), i), cent, val, dnx, rndm); + else + fFCReco->FillProfile(Form("%s_pt_%i", corrconf.Head.c_str(), i), cent, val, dnx, rndm); + } + } + return; + } + + void loadCentVsIPTruth(uint64_t timestamp) + { + if (centVsIPTruthLoaded) + return; + if (cfgCentVsIPTruth.value.empty() == false) { + mCentVsIPTruth = ccdb->getForTimeStamp(cfgCentVsIPTruth, timestamp); + if (mCentVsIPTruth) + LOGF(info, "Loaded CentVsIPTruth weights from %s (%p)", cfgCentVsIPTruth.value.c_str(), (void*)mCentVsIPTruth); + else + LOGF(fatal, "Failed to load CentVsIPTruth weights from %s", cfgCentVsIPTruth.value.c_str()); + + centVsIPTruthLoaded = true; + } else { + LOGF(fatal, "when calculate flow, Cent Vs IP distribution must be provided"); + } + } + + void loadCentVsIPReco(uint64_t timestamp) + { + if (centVsIPRecoLoaded) + return; + if (cfgCentVsIPReco.value.empty() == false) { + mCentVsIPReco = ccdb->getForTimeStamp(cfgCentVsIPReco, timestamp); + if (mCentVsIPReco) + LOGF(info, "Loaded CentVsIPReco weights from %s (%p)", cfgCentVsIPReco.value.c_str(), (void*)mCentVsIPReco); + else + LOGF(fatal, "Failed to load CentVsIPReco weights from %s", cfgCentVsIPReco.value.c_str()); + + centVsIPRecoLoaded = true; + } else { + LOGF(fatal, "when calculate flow, Cent Vs IP distribution must be provided"); + } + } + + void loadCorrections(uint64_t timestamp) + { + if (correctionsLoaded) + return; + if (cfgFlowAcceptance.value.empty() == false) { + mAcceptance = ccdb->getForTimeStamp(cfgFlowAcceptance, timestamp); + if (mAcceptance) + LOGF(info, "Loaded acceptance weights from %s (%p)", cfgFlowAcceptance.value.c_str(), (void*)mAcceptance); + else + LOGF(warning, "Could not load acceptance weights from %s (%p)", cfgFlowAcceptance.value.c_str(), (void*)mAcceptance); + } + if (cfgFlowEfficiency.value.empty() == false) { + mEfficiency = ccdb->getForTimeStamp(cfgFlowEfficiency, timestamp); + if (mEfficiency == nullptr) { + LOGF(fatal, "Could not load efficiency histogram for trigger particles from %s", cfgFlowEfficiency.value.c_str()); + } + LOGF(info, "Loaded efficiency histogram from %s (%p)", cfgFlowEfficiency.value.c_str(), (void*)mEfficiency); + } + correctionsLoaded = true; + } + + bool setCurrentParticleWeights(float& weight_nue, float& weight_nua, float phi, float eta, float pt, float vtxz) + { + float eff = 1.; + if (mEfficiency) + eff = mEfficiency->GetBinContent(mEfficiency->FindBin(pt)); + else + eff = 1.0; + if (eff == 0) + return false; + weight_nue = 1. / eff; + if (mAcceptance) + weight_nua = mAcceptance->getNUA(phi, eta, vtxz); + else + weight_nua = 1; + return true; + } + template bool trackSelected(TTrack track) { @@ -139,16 +358,61 @@ struct FlowPtEfficiency { if (!std::count(cfgRunNumberList.value.begin(), cfgRunNumberList.value.end(), runNumber)) return; } + + float imp; + bool impFetched = false; + float centrality = 0.; + float lRandom = fRndm->Rndm(); + float vtxz = collision.posZ(); + float wacc = 1.0f; + float weff = 1.0f; + if (cfgFlowEnabled) { + loadCentVsIPReco(bc.timestamp()); + loadCorrections(bc.timestamp()); + } + for (const auto& track : tracks) { if (!trackSelected(track)) continue; if (track.has_mcParticle()) { auto mcParticle = track.mcParticle(); + if (cfgFlowEnabled && !impFetched) { + auto mcCollision = mcParticle.mcCollision(); + imp = mcCollision.impactParameter(); + registry.fill(HIST("hImpactParameterReco"), imp); + centrality = mCentVsIPReco->GetBinContent(mCentVsIPReco->GetXaxis()->FindBin(imp)); + impFetched = true; + } if (isStable(mcParticle.pdgCode())) { registry.fill(HIST("hPtMCRec"), track.pt()); + + if (cfgFlowEnabled) { + bool withinPtPOI = (cfgFlowCutPtPOIMin < track.pt()) && (track.pt() < cfgFlowCutPtPOIMax); // within POI pT range + bool withinPtRef = (cfgFlowCutPtRefMin < track.pt()) && (track.pt() < cfgFlowCutPtRefMax); // within RF pT range + if (withinPtRef) + fWeights->fill(track.phi(), track.eta(), vtxz, track.pt(), centrality, 0); + if (!setCurrentParticleWeights(weff, wacc, track.phi(), track.eta(), track.pt(), vtxz)) + continue; + if (withinPtRef) { + registry.fill(HIST("hPhi"), track.phi()); + registry.fill(HIST("hPhiWeighted"), track.phi(), wacc); + } + if (withinPtRef) + fGFWReco->Fill(track.eta(), fPtAxis->FindBin(track.pt()) - 1, track.phi(), wacc * weff, 1); + if (withinPtPOI) + fGFWReco->Fill(track.eta(), fPtAxis->FindBin(track.pt()) - 1, track.phi(), wacc * weff, 2); + if (withinPtPOI && withinPtRef) + fGFWReco->Fill(track.eta(), fPtAxis->FindBin(track.pt()) - 1, track.phi(), wacc * weff, 4); + } } } } + if (cfgFlowEnabled) { + // Filling Flow Container + for (uint l_ind = 0; l_ind < corrconfigs.size(); l_ind++) { + fillFC(fGFWReco, false, corrconfigs.at(l_ind), centrality, lRandom); + } + } } PROCESS_SWITCH(FlowPtEfficiency, processReco, "process reconstructed information", true); @@ -160,11 +424,40 @@ struct FlowPtEfficiency { if (!std::count(cfgRunNumberList.value.begin(), cfgRunNumberList.value.end(), runNumber)) return; } + + float imp = collision.impactParameter(); + float centrality = 0.; + if (cfgFlowEnabled) { + registry.fill(HIST("hImpactParameterTruth"), imp); + auto bc = collision.bc_as(); + loadCentVsIPTruth(bc.timestamp()); + centrality = mCentVsIPTruth->GetBinContent(mCentVsIPTruth->GetXaxis()->FindBin(imp)); + } + float lRandom = fRndm->Rndm(); + float wacc = 1.0f; + float weff = 1.0f; + if (collisions.size() > -1) { registry.fill(HIST("mcEventCounter"), 0.5); for (const auto& mcParticle : mcParticles) { if (mcParticle.isPhysicalPrimary() && isStable(mcParticle.pdgCode())) { registry.fill(HIST("hPtMCGen"), mcParticle.pt()); + if (cfgFlowEnabled) { + bool withinPtPOI = (cfgFlowCutPtPOIMin < mcParticle.pt()) && (mcParticle.pt() < cfgFlowCutPtPOIMax); // within POI pT range + bool withinPtRef = (cfgFlowCutPtRefMin < mcParticle.pt()) && (mcParticle.pt() < cfgFlowCutPtRefMax); // within RF pT range + if (withinPtRef) + fGFWTrue->Fill(mcParticle.eta(), fPtAxis->FindBin(mcParticle.pt()) - 1, mcParticle.phi(), wacc * weff, 1); + if (withinPtPOI) + fGFWTrue->Fill(mcParticle.eta(), fPtAxis->FindBin(mcParticle.pt()) - 1, mcParticle.phi(), wacc * weff, 2); + if (withinPtPOI && withinPtRef) + fGFWTrue->Fill(mcParticle.eta(), fPtAxis->FindBin(mcParticle.pt()) - 1, mcParticle.phi(), wacc * weff, 4); + } + } + } + if (cfgFlowEnabled) { + // Filling Flow Container + for (uint l_ind = 0; l_ind < corrconfigs.size(); l_ind++) { + fillFC(fGFWTrue, true, corrconfigs.at(l_ind), centrality, lRandom); } } } From e4a85727904909637f69d49f859e697e315fd320 Mon Sep 17 00:00:00 2001 From: Noor Koster <82090643+cnkoster@users.noreply.github.com> Date: Wed, 5 Feb 2025 22:58:25 +0100 Subject: [PATCH 04/30] [PWGCF] Clean up table producer and task (#9768) Co-authored-by: ALICE Action Bot --- PWGCF/Flow/TableProducer/zdcQVectors.cxx | 343 +++++++++-------------- PWGCF/Flow/Tasks/flowSP.cxx | 79 ++++-- 2 files changed, 190 insertions(+), 232 deletions(-) diff --git a/PWGCF/Flow/TableProducer/zdcQVectors.cxx b/PWGCF/Flow/TableProducer/zdcQVectors.cxx index 80dc9c1ff20..ca5389167ce 100644 --- a/PWGCF/Flow/TableProducer/zdcQVectors.cxx +++ b/PWGCF/Flow/TableProducer/zdcQVectors.cxx @@ -65,7 +65,7 @@ using namespace o2::aod::track; using namespace o2::aod::evsel; // define my..... -using UsedCollisions = soa::Join; +using UsedCollisions = soa::Join; using BCsRun3 = soa::Join; namespace o2::analysis::qvectortask @@ -75,10 +75,6 @@ int counter = 0; // step0 -> Energy calib std::shared_ptr energyZN[10] = {{nullptr}}; -std::shared_ptr hQxvsQy[6] = {{nullptr}}; - -// and -std::shared_ptr hCOORDcorrelations[6][4] = {{nullptr}}; // Define histogrm names here to use same names for creating and later uploading and retrieving data from ccdb // Energy calibration: @@ -91,8 +87,9 @@ std::vector pxZDC = {-1.75, 1.75, -1.75, 1.75}; std::vector pyZDC = {-1.75, -1.75, 1.75, 1.75}; double alphaZDC = 0.395; -// step 0 tm 5 A&C -std::vector>> q(6, std::vector>(7, std::vector(4, 0.0))); // 5 iterations with 5 steps, each with 4 values +// q-vectors before (q) and after (qRec) recentering. +std::vector q(4); // start values of [QxA, QyA, QxC, QyC] +std::vector qRec(4); // Recentered values of [QxA, QyA, QxC, QyC] // for energy calibration std::vector eZN(8); // uncalibrated energy for the 2x4 towers (a1, a2, a3, a4, c1, c2, c3, c4) @@ -124,6 +121,12 @@ struct ZdcQVectors { ConfigurableAxis axisVy{"axisVy", {10, -0.01, 0.01}, "for Pos Y of collision"}; ConfigurableAxis axisVz{"axisVz", {10, -10, 1}, "for vz of collision"}; + // Centrality Estimators -> standard is FT0C + O2_DEFINE_CONFIGURABLE(cfgFT0Cvariant1, bool, false, "Set centrality estimator to cfgFT0Cvariant1"); + O2_DEFINE_CONFIGURABLE(cfgFT0M, bool, false, "Set centrality estimator to cfgFT0M"); + O2_DEFINE_CONFIGURABLE(cfgFV0A, bool, false, "Set centrality estimator to cfgFV0A"); + O2_DEFINE_CONFIGURABLE(cfgNGlobal, bool, false, "Set centrality estimator to cfgNGlobal"); + O2_DEFINE_CONFIGURABLE(cfgCutVertex, float, 10.0f, "Accepted z-vertex range") O2_DEFINE_CONFIGURABLE(cfgCutPtPOIMin, float, 0.2f, "Minimal.q pT for poi tracks") O2_DEFINE_CONFIGURABLE(cfgCutPtPOIMax, float, 10.0f, "Maximal pT for poi tracks") @@ -155,6 +158,11 @@ struct ZdcQVectors { int atIteration = 0; } cal; + enum FillType { + kBefore, + kAfter + }; + void init(InitContext const&) { ccdb->setURL("http://alice-ccdb.cern.ch"); @@ -173,20 +181,17 @@ struct ZdcQVectors { energyZN[tower] = registry.add(Form("Energy/%s", namesEcal[tower].Data()), Form("%s", namesEcal[tower].Data()), kTProfile2D, {{1, 0, 1}, axisCent}); } - // Qx_vs_Qy for each step for ZNA and ZNC - for (int step = 0; step < 6; step++) { - registry.add(Form("step%i/QA/hSPplaneA", step), "hSPplaneA", kTH2D, {{100, -4, 4}, axisCent10}); - registry.add(Form("step%i/QA/hSPplaneC", step), "hSPplaneC", kTH2D, {{100, -4, 4}, axisCent10}); - registry.add(Form("step%i/QA/hSPplaneFull", step), "hSPplaneFull", kTH2D, {{100, -4, 4}, axisCent10}); - for (const auto& side : sides) { - hQxvsQy[step] = registry.add(Form("step%i/hZN%s_Qx_vs_Qy", step, side), Form("hZN%s_Qx_vs_Qy", side), kTH2F, {axisQ, axisQ}); - } - int i = 0; + registry.add(Form("before/QA/hSPplaneA"), "hSPplaneA", kTH2D, {{100, -4, 4}, axisCent10}); + registry.add(Form("before/QA/hSPplaneC"), "hSPplaneC", kTH2D, {{100, -4, 4}, axisCent10}); + registry.add(Form("before/QA/hSPplaneFull"), "hSPplaneFull", kTH2D, {{100, -4, 4}, axisCent10}); + for (const auto& side : sides) { + registry.add(Form("before/hZN%s_Qx_vs_Qy", side), Form("hZN%s_Qx_vs_Qy", side), kTH2F, {axisQ, axisQ}); + } + for (const auto& COORD1 : capCOORDS) { for (const auto& COORD2 : capCOORDS) { // Now we get: & vs. Centrality - hCOORDcorrelations[step][i] = registry.add(Form("step%i/QA/hQ%sA_Q%sC_vs_cent", step, COORD1, COORD2), Form("hQ%sA_Q%sC_vs_cent", COORD1, COORD2), kTProfile, {axisCent10}); - i++; + registry.add(Form("before/QA/hQ%sA_Q%sC_vs_cent", COORD1, COORD2), Form("hQ%sA_Q%sC_vs_cent", COORD1, COORD2), kTProfile, {axisCent}); } } @@ -194,190 +199,76 @@ struct ZdcQVectors { // Sides is {A,C} and capcoords is {X,Y} for (const auto& side : sides) { for (const auto& coord : capCOORDS) { - registry.add(Form("step%i/QA/hQ%s%s_vs_cent", step, coord, side), Form("hQ%s%s_vs_cent", coord, side), {HistType::kTProfile, {axisCent10}}); - registry.add(Form("step%i/QA/hQ%s%s_vs_vx", step, coord, side), Form("hQ%s%s_vs_vx", coord, side), {HistType::kTProfile, {axisVx}}); - registry.add(Form("step%i/QA/hQ%s%s_vs_vy", step, coord, side), Form("hQ%s%s_vs_vy", coord, side), {HistType::kTProfile, {axisVy}}); - registry.add(Form("step%i/QA/hQ%s%s_vs_vz", step, coord, side), Form("hQ%s%s_vs_vz", coord, side), {HistType::kTProfile, {axisVz}}); - - if (step == 1 || step == 5) { - TString name = TString::Format("hQ%s%s_mean_Cent_V_run", coord, side); - registry.add(Form("step%i/%s", step, name.Data()), Form("hQ%s%s_mean_Cent_V_run", coord, side), {HistType::kTHnSparseD, {axisCent10, axisVxBig, axisVyBig, axisVzBig, axisQ}}); - if (step == 1) - names[step - 1].push_back(name); - } - if (step == 2) { - TString name = TString::Format("hQ%s%s_mean_cent_run", coord, side); - registry.add(Form("step%i/%s", step, name.Data()), Form("hQ%s%s_mean_cent_run", coord, side), kTProfile, {axisCent}); - names[step - 1].push_back(name); - } - if (step == 3) { - TString name = TString::Format("hQ%s%s_mean_vx_run", coord, side); - registry.add(Form("step%i/%s", step, name.Data()), Form("hQ%s%s_mean_vx_run", coord, side), kTProfile, {axisVx}); - names[step - 1].push_back(name); - } - if (step == 4) { - TString name = TString::Format("hQ%s%s_mean_vy_run", coord, side); - registry.add(Form("step%i/%s", step, name.Data()), Form("hQ%s%s_mean_vy_run", coord, side), kTProfile, {axisVy}); - names[step - 1].push_back(name); - } - if (step == 5) { - TString name = TString::Format("hQ%s%s_mean_vz_run", coord, side); - registry.add(Form("step%i/%s", step, name.Data()), Form("hQ%s%s_mean_vz_run", coord, side), kTProfile, {axisVz}); - names[step - 1].push_back(name); - } + registry.add(Form("before/QA/hQ%s%s_vs_cent", coord, side), Form("hQ%s%s_vs_cent", coord, side), {HistType::kTProfile, {axisCent10}}); + registry.add(Form("before/QA/hQ%s%s_vs_vx", coord, side), Form("hQ%s%s_vs_vx", coord, side), {HistType::kTProfile, {axisVx}}); + registry.add(Form("before/QA/hQ%s%s_vs_vy", coord, side), Form("hQ%s%s_vs_vy", coord, side), {HistType::kTProfile, {axisVy}}); + registry.add(Form("before/QA/hQ%s%s_vs_vz", coord, side), Form("hQ%s%s_vs_vz", coord, side), {HistType::kTProfile, {axisVz}}); + + names[0].push_back(TString::Format("hQ%s%s_mean_Cent_V_run", coord, side)); + names[1].push_back(TString::Format("hQ%s%s_mean_cent_run", coord, side)); + names[2].push_back(TString::Format("hQ%s%s_mean_vx_run", coord, side)); + names[3].push_back(TString::Format("hQ%s%s_mean_vy_run", coord, side)); + names[4].push_back(TString::Format("hQ%s%s_mean_vz_run", coord, side)); } // end of capCOORDS } // end of sides - } // end of sum over steps - // recentered q-vectors (to check what steps are finished in the end) - registry.add("hStep", "hStep", {HistType::kTH1D, {{10, 0., 10.}}}); - registry.add("hIteration", "hIteration", {HistType::kTH1D, {{10, 0., 10.}}}); + // recentered q-vectors (to check what steps are finished in the end) - registry.add("vmean/hvertex_vx", "hvertex_vx", kTProfile, {{1, 0., 1.}}); - registry.add("vmean/hvertex_vy", "hvertex_vy", kTProfile, {{1, 0., 1.}}); - registry.add("vmean/hvertex_vz", "hvertex_vz", kTProfile, {{1, 0., 1.}}); + registry.add("vmean/hvertex_vx", "hvertex_vx", kTProfile, {{1, 0., 1.}}); + registry.add("vmean/hvertex_vy", "hvertex_vy", kTProfile, {{1, 0., 1.}}); + registry.add("vmean/hvertex_vz", "hvertex_vz", kTProfile, {{1, 0., 1.}}); - registry.add("QA/centrality_before", "centrality_before", kTH1D, {{200, 0, 100}}); - registry.add("QA/centrality_after", "centrality_after", kTH1D, {{200, 0, 100}}); + registry.add("QA/centrality_before", "centrality_before", kTH1D, {{200, 0, 100}}); + registry.add("QA/centrality_after", "centrality_after", kTH1D, {{200, 0, 100}}); - registry.add("QA/ZNA_Energy", "ZNA_Energy", kTProfile, {{8, 0, 8}}); - registry.add("QA/ZNC_Energy", "ZNC_Energy", kTProfile, {{8, 0, 8}}); - } + registry.add("QA/ZNA_Energy", "ZNA_Energy", kTProfile, {{8, 0, 8}}); + registry.add("QA/ZNC_Energy", "ZNC_Energy", kTProfile, {{8, 0, 8}}); - inline void fillRegistry(int iteration, int step) - { - if (step == 0 && iteration == 1) { - registry.fill(HIST("hIteration"), iteration, 1); - - registry.fill(HIST("step1/hQXA_mean_Cent_V_run"), runnumber, centrality, v[0], v[1], v[2], q[0][step][0]); - registry.fill(HIST("step1/hQYA_mean_Cent_V_run"), runnumber, centrality, v[0], v[1], v[2], q[0][step][1]); - registry.fill(HIST("step1/hQXC_mean_Cent_V_run"), runnumber, centrality, v[0], v[1], v[2], q[0][step][2]); - registry.fill(HIST("step1/hQYC_mean_Cent_V_run"), runnumber, centrality, v[0], v[1], v[2], q[0][step][3]); - registry.fill(HIST("hStep"), step, 1); - } - - if (step == 1) { - registry.get(HIST("step2/hQXA_mean_cent_run"))->Fill(centrality, q[iteration][step][0]); - registry.get(HIST("step2/hQYA_mean_cent_run"))->Fill(centrality, q[iteration][step][1]); - registry.get(HIST("step2/hQXC_mean_cent_run"))->Fill(centrality, q[iteration][step][2]); - registry.get(HIST("step2/hQYC_mean_cent_run"))->Fill(centrality, q[iteration][step][3]); - registry.fill(HIST("hStep"), step, 1); - } - - if (step == 2) { - registry.get(HIST("step3/hQXA_mean_vx_run"))->Fill(v[0], q[iteration][step][0]); - registry.get(HIST("step3/hQYA_mean_vx_run"))->Fill(v[0], q[iteration][step][1]); - registry.get(HIST("step3/hQXC_mean_vx_run"))->Fill(v[0], q[iteration][step][2]); - registry.get(HIST("step3/hQYC_mean_vx_run"))->Fill(v[0], q[iteration][step][3]); - registry.fill(HIST("hStep"), step, 1); - } - - if (step == 3) { - registry.get(HIST("step4/hQXA_mean_vy_run"))->Fill(v[1], q[iteration][step][0]); - registry.get(HIST("step4/hQYA_mean_vy_run"))->Fill(v[1], q[iteration][step][1]); - registry.get(HIST("step4/hQXC_mean_vy_run"))->Fill(v[1], q[iteration][step][2]); - registry.get(HIST("step4/hQYC_mean_vy_run"))->Fill(v[1], q[iteration][step][3]); - registry.fill(HIST("hStep"), step, 1); - } - - if (step == 4) { - registry.get(HIST("step5/hQXA_mean_vz_run"))->Fill(v[2], q[iteration][step][0]); - registry.get(HIST("step5/hQYA_mean_vz_run"))->Fill(v[2], q[iteration][step][1]); - registry.get(HIST("step5/hQXC_mean_vz_run"))->Fill(v[2], q[iteration][step][2]); - registry.get(HIST("step5/hQYC_mean_vz_run"))->Fill(v[2], q[iteration][step][3]); - registry.fill(HIST("hStep"), step, 1); - } - - if (step == 5) { - registry.fill(HIST("step5/hQXA_mean_Cent_V_run"), centrality, v[0], v[1], v[2], q[iteration][step][0]); - registry.fill(HIST("step5/hQYA_mean_Cent_V_run"), centrality, v[0], v[1], v[2], q[iteration][step][1]); - registry.fill(HIST("step5/hQXC_mean_Cent_V_run"), centrality, v[0], v[1], v[2], q[iteration][step][2]); - registry.fill(HIST("step5/hQYC_mean_Cent_V_run"), centrality, v[0], v[1], v[2], q[iteration][step][3]); - registry.fill(HIST("hStep"), step, 1); - } + registry.addClone("before/", "after/"); } - inline void fillCommonRegistry(int iteration) + template + inline void fillCommonRegistry(double qxa, double qya, double qxc, double qyc, std::vector v, double centrality) { // loop for filling multiple histograms with different naming patterns // Always fill the uncentered "raw" Q-vector histos! + static constexpr std::string_view Time[] = {"before", "after"}; - registry.fill(HIST("step0/hZNA_Qx_vs_Qy"), q[0][0][0], q[0][0][1]); - registry.fill(HIST("step0/hZNC_Qx_vs_Qy"), q[0][0][2], q[0][0][3]); + registry.fill(HIST(Time[ft]) + HIST("/hZNA_Qx_vs_Qy"), qxa, qya); + registry.fill(HIST(Time[ft]) + HIST("/hZNC_Qx_vs_Qy"), qxc, qyc); - registry.fill(HIST("step0/QA/hQXA_QXC_vs_cent"), centrality, q[0][0][0] * q[0][0][2]); - registry.fill(HIST("step0/QA/hQYA_QYC_vs_cent"), centrality, q[0][0][1] * q[0][0][3]); - registry.fill(HIST("step0/QA/hQYA_QXC_vs_cent"), centrality, q[0][0][1] * q[0][0][2]); - registry.fill(HIST("step0/QA/hQXA_QYC_vs_cent"), centrality, q[0][0][0] * q[0][0][3]); + registry.fill(HIST(Time[ft]) + HIST("/QA/hQXA_QXC_vs_cent"), centrality, qxa * qxc); + registry.fill(HIST(Time[ft]) + HIST("/QA/hQYA_QYC_vs_cent"), centrality, qya * qyc); + registry.fill(HIST(Time[ft]) + HIST("/QA/hQYA_QXC_vs_cent"), centrality, qya * qxc); + registry.fill(HIST(Time[ft]) + HIST("/QA/hQXA_QYC_vs_cent"), centrality, qxa * qyc); - registry.fill(HIST("step0/QA/hQXA_vs_cent"), centrality, q[0][0][0]); - registry.fill(HIST("step0/QA/hQYA_vs_cent"), centrality, q[0][0][1]); - registry.fill(HIST("step0/QA/hQXC_vs_cent"), centrality, q[0][0][2]); - registry.fill(HIST("step0/QA/hQYC_vs_cent"), centrality, q[0][0][3]); + registry.fill(HIST(Time[ft]) + HIST("/QA/hQXA_vs_cent"), centrality, qxa); + registry.fill(HIST(Time[ft]) + HIST("/QA/hQYA_vs_cent"), centrality, qya); + registry.fill(HIST(Time[ft]) + HIST("/QA/hQXC_vs_cent"), centrality, qxc); + registry.fill(HIST(Time[ft]) + HIST("/QA/hQYC_vs_cent"), centrality, qyc); - registry.fill(HIST("step0/QA/hQXA_vs_vx"), v[0], q[0][0][0]); - registry.fill(HIST("step0/QA/hQYA_vs_vx"), v[0], q[0][0][1]); - registry.fill(HIST("step0/QA/hQXC_vs_vx"), v[0], q[0][0][2]); - registry.fill(HIST("step0/QA/hQYC_vs_vx"), v[0], q[0][0][3]); + registry.fill(HIST(Time[ft]) + HIST("/QA/hQXA_vs_vx"), v[0], qxa); + registry.fill(HIST(Time[ft]) + HIST("/QA/hQYA_vs_vx"), v[0], qya); + registry.fill(HIST(Time[ft]) + HIST("/QA/hQXC_vs_vx"), v[0], qxc); + registry.fill(HIST(Time[ft]) + HIST("/QA/hQYC_vs_vx"), v[0], qyc); - registry.fill(HIST("step0/QA/hQXA_vs_vy"), v[1], q[0][0][0]); - registry.fill(HIST("step0/QA/hQYA_vs_vy"), v[1], q[0][0][1]); - registry.fill(HIST("step0/QA/hQXC_vs_vy"), v[1], q[0][0][2]); - registry.fill(HIST("step0/QA/hQYC_vs_vy"), v[1], q[0][0][3]); + registry.fill(HIST(Time[ft]) + HIST("/QA/hQXA_vs_vy"), v[1], qxa); + registry.fill(HIST(Time[ft]) + HIST("/QA/hQYA_vs_vy"), v[1], qya); + registry.fill(HIST(Time[ft]) + HIST("/QA/hQXC_vs_vy"), v[1], qxc); + registry.fill(HIST(Time[ft]) + HIST("/QA/hQYC_vs_vy"), v[1], qyc); - registry.fill(HIST("step0/QA/hQXA_vs_vz"), v[2], q[0][0][0]); - registry.fill(HIST("step0/QA/hQYA_vs_vz"), v[2], q[0][0][1]); - registry.fill(HIST("step0/QA/hQXC_vs_vz"), v[2], q[0][0][2]); - registry.fill(HIST("step0/QA/hQYC_vs_vz"), v[2], q[0][0][3]); + registry.fill(HIST(Time[ft]) + HIST("/QA/hQXA_vs_vz"), v[2], qxa); + registry.fill(HIST(Time[ft]) + HIST("/QA/hQYA_vs_vz"), v[2], qya); + registry.fill(HIST(Time[ft]) + HIST("/QA/hQXC_vs_vz"), v[2], qxc); + registry.fill(HIST(Time[ft]) + HIST("/QA/hQYC_vs_vz"), v[2], qyc); // add psi!! - double psiA = 1.0 * std::atan2(q[0][0][2], q[0][0][0]); - registry.fill(HIST("step0/QA/hSPplaneA"), psiA, centrality, 1); - double psiC = 1.0 * std::atan2(q[0][0][3], q[0][0][1]); - registry.fill(HIST("step0/QA/hSPplaneC"), psiC, centrality, 1); - double psiFull = 1.0 * std::atan2(q[0][0][2] + q[0][0][3], q[0][0][0] + q[0][0][1]); - registry.fill(HIST("step0/QA/hSPplaneFull"), psiFull, centrality, 1); - - static constexpr std::string_view SubDir[] = {"step1/", "step2/", "step3/", "step4/", "step5/"}; - static_for<0, 4>([&](auto Ind) { - constexpr int Index = Ind.value; - int indexRt = Index + 1; - - registry.fill(HIST(SubDir[Index]) + HIST("hZNA_Qx_vs_Qy"), q[iteration][indexRt][0], q[iteration][indexRt][1]); - registry.fill(HIST(SubDir[Index]) + HIST("hZNC_Qx_vs_Qy"), q[iteration][indexRt][2], q[iteration][indexRt][3]); - - registry.fill(HIST(SubDir[Index]) + HIST("QA/hQXA_QXC_vs_cent"), centrality, q[iteration][indexRt][0] * q[iteration][indexRt][2]); - registry.fill(HIST(SubDir[Index]) + HIST("QA/hQYA_QYC_vs_cent"), centrality, q[iteration][indexRt][1] * q[iteration][indexRt][3]); - registry.fill(HIST(SubDir[Index]) + HIST("QA/hQYA_QXC_vs_cent"), centrality, q[iteration][indexRt][1] * q[iteration][indexRt][2]); - registry.fill(HIST(SubDir[Index]) + HIST("QA/hQXA_QYC_vs_cent"), centrality, q[iteration][indexRt][0] * q[iteration][indexRt][3]); - - registry.fill(HIST(SubDir[Index]) + HIST("QA/hQXA_vs_cent"), centrality, q[iteration][indexRt][0]); - registry.fill(HIST(SubDir[Index]) + HIST("QA/hQYA_vs_cent"), centrality, q[iteration][indexRt][1]); - registry.fill(HIST(SubDir[Index]) + HIST("QA/hQXC_vs_cent"), centrality, q[iteration][indexRt][2]); - registry.fill(HIST(SubDir[Index]) + HIST("QA/hQYC_vs_cent"), centrality, q[iteration][indexRt][3]); - - registry.fill(HIST(SubDir[Index]) + HIST("QA/hQXA_vs_vx"), v[0], q[iteration][indexRt][0]); - registry.fill(HIST(SubDir[Index]) + HIST("QA/hQYA_vs_vx"), v[0], q[iteration][indexRt][1]); - registry.fill(HIST(SubDir[Index]) + HIST("QA/hQXC_vs_vx"), v[0], q[iteration][indexRt][2]); - registry.fill(HIST(SubDir[Index]) + HIST("QA/hQYC_vs_vx"), v[0], q[iteration][indexRt][3]); - - registry.fill(HIST(SubDir[Index]) + HIST("QA/hQXA_vs_vy"), v[1], q[iteration][indexRt][0]); - registry.fill(HIST(SubDir[Index]) + HIST("QA/hQYA_vs_vy"), v[1], q[iteration][indexRt][1]); - registry.fill(HIST(SubDir[Index]) + HIST("QA/hQXC_vs_vy"), v[1], q[iteration][indexRt][2]); - registry.fill(HIST(SubDir[Index]) + HIST("QA/hQYC_vs_vy"), v[1], q[iteration][indexRt][3]); - - registry.fill(HIST(SubDir[Index]) + HIST("QA/hQXA_vs_vz"), v[2], q[iteration][indexRt][0]); - registry.fill(HIST(SubDir[Index]) + HIST("QA/hQYA_vs_vz"), v[2], q[iteration][indexRt][1]); - registry.fill(HIST(SubDir[Index]) + HIST("QA/hQXC_vs_vz"), v[2], q[iteration][indexRt][2]); - registry.fill(HIST(SubDir[Index]) + HIST("QA/hQYC_vs_vz"), v[2], q[iteration][indexRt][3]); - - psiA = 1.0 * std::atan2(q[iteration][indexRt][2], q[iteration][indexRt][0]); - registry.fill(HIST(SubDir[Index]) + HIST("QA/hSPplaneA"), psiA, centrality, 1); - psiC = 1.0 * std::atan2(q[iteration][indexRt][3], q[iteration][indexRt][1]); - registry.fill(HIST(SubDir[Index]) + HIST("QA/hSPplaneC"), psiC, centrality, 1); - psiFull = 1.0 * std::atan2(q[iteration][indexRt][2] + q[iteration][indexRt][3], q[iteration][indexRt][0] + q[iteration][indexRt][1]); - registry.fill(HIST(SubDir[Index]) + HIST("QA/hSPplaneFull"), psiFull, centrality, 1); - }); + double psiA = 1.0 * std::atan2(qxc, qxa); + registry.fill(HIST(Time[ft]) + HIST("/QA/hSPplaneA"), psiA, centrality, 1); + double psiC = 1.0 * std::atan2(qyc, qya); + registry.fill(HIST(Time[ft]) + HIST("/QA/hSPplaneC"), psiC, centrality, 1); + double psiFull = 1.0 * std::atan2(qxc + qyc, qxa + qya); + registry.fill(HIST(Time[ft]) + HIST("/QA/hSPplaneFull"), psiFull, centrality, 1); } void loadCalibrations(int iteration, int step, uint64_t timestamp, std::string ccdb_dir, std::vector names) @@ -505,13 +396,6 @@ struct ZdcQVectors { return calibConstant; } - void fillAllRegistries(int iteration, int step) - { - for (int s = 0; s <= step; s++) - fillRegistry(iteration, s); - fillCommonRegistry(iteration); - } - void process(UsedCollisions::iterator const& collision, BCsRun3 const& /*bcs*/, aod::Zdcs const& /*zdcs*/) @@ -524,7 +408,16 @@ struct ZdcQVectors { isSelected = true; + // TODO Implement other ZDC estimators auto cent = collision.centFT0C(); + if (cfgFT0Cvariant1) + cent = collision.centFT0CVariant1(); + if (cfgFT0M) + cent = collision.centFT0M(); + if (cfgFV0A) + cent = collision.centFV0A(); + if (cfgNGlobal) + cent = collision.centNGlobal(); if (cent < 0 || cent > 90) { isSelected = false; @@ -676,8 +569,8 @@ struct ZdcQVectors { // "QXA", "QYA", "QXC", "QYC" for (int i = 0; i < 2; ++i) { if (sumZN[i] > 0) { - q[0][0][i * 2] = xEnZN[i] / sumZN[i]; // for QXA[0] and QXC[2] - q[0][0][i * 2 + 1] = yEnZN[i] / sumZN[i]; // for QYA[1] and QYC[3] + q[i * 2] = xEnZN[i] / sumZN[i]; // for QXA[0] and QXC[2] + q[i * 2 + 1] = yEnZN[i] / sumZN[i]; // for QYA[1] and QYC[3] } } @@ -713,41 +606,59 @@ struct ZdcQVectors { if (counter < 1) LOGF(warning, "Calibation files missing!!! Output created with q-vectors right after energy gain eq. !!"); if (isSelected) - fillAllRegistries(0, 0); - spTableZDC(runnumber, centrality, v[0], v[1], v[2], q[0][0][0], q[0][0][1], q[0][0][2], q[0][0][3], isSelected, 0, 0); + fillCommonRegistry(q[0], q[1], q[2], q[3], v, centrality); + spTableZDC(runnumber, centrality, v[0], v[1], v[2], q[0], q[1], q[2], q[3], isSelected, 0, 0); counter++; return; - } else { - for (int iteration = 1; iteration <= cal.atIteration; iteration++) { - for (int step = 0; step < cal.atStep + 1; step++) { - if (cal.calibfilesLoaded[iteration][step]) { - for (int i = 0; i < 4; i++) { - if (step == 0) { - if (iteration == 1) { - q[iteration][step + 1][i] = q[0][0][i] - getCorrection(iteration, step, names[step][i].Data()); - } else { - q[iteration][step + 1][i] = q[iteration - 1][5][i] - getCorrection(iteration, step, names[step][i].Data()); - } - } else { - q[iteration][step + 1][i] = q[iteration][step][i] - getCorrection(iteration, step, names[step][i].Data()); - } - } - } else { - if (counter < 1) - LOGF(warning, "Something went wrong in calibration loop! File not loaded but bool set to tue"); - } // end of (cal.calibLoaded) - } // end of step - } // end of iteration + } else if (cal.atIteration == 5 && cal.atStep == 4) { + std::vector qRec(4); + fillCommonRegistry(q[0], q[1], q[2], q[3], v, centrality); + qRec = q; + + // vector of 4 + std::vector corrQxA; + std::vector corrQyA; + std::vector corrQxC; + std::vector corrQyC; + + int pb = 0; + + for (int it = 1; it < 6; it++) { + corrQxA.push_back(getCorrection(it, 0, names[0][0].Data())); + corrQyA.push_back(getCorrection(it, 0, names[0][1].Data())); + corrQxC.push_back(getCorrection(it, 0, names[0][2].Data())); + corrQyC.push_back(getCorrection(it, 0, names[0][3].Data())); + + pb++; + + for (int step = 1; step < 5; step++) { + corrQxA.push_back(getCorrection(it, step, names[step][0].Data())); + corrQyA.push_back(getCorrection(it, step, names[step][1].Data())); + corrQxC.push_back(getCorrection(it, step, names[step][2].Data())); + corrQyC.push_back(getCorrection(it, step, names[step][3].Data())); + pb++; + } + } + + for (int cor = 0; cor < pb; cor++) { + qRec[0] -= corrQxA[cor]; + qRec[1] -= corrQyA[cor]; + qRec[2] -= corrQxC[cor]; + qRec[3] -= corrQyC[cor]; + } if (counter < 1) LOGF(info, "Output created with q-vectors at iteration %i and step %i!!!!", cal.atIteration, cal.atStep + 1); if (isSelected) { - fillAllRegistries(cal.atIteration, cal.atStep + 1); + fillCommonRegistry(qRec[0], qRec[1], qRec[2], qRec[3], v, centrality); registry.fill(HIST("QA/centrality_after"), centrality); } - spTableZDC(runnumber, centrality, v[0], v[1], v[2], q[cal.atIteration][cal.atStep][0], q[cal.atIteration][cal.atStep][1], q[cal.atIteration][cal.atStep][2], q[cal.atIteration][cal.atStep][3], isSelected, cal.atIteration, cal.atStep); + spTableZDC(runnumber, centrality, v[0], v[1], v[2], qRec[0], qRec[1], qRec[2], qRec[3], isSelected, cal.atIteration, cal.atStep); counter++; return; + } else { + if (counter < 1) + LOGF(info, "Recentering not complete!! q-vectors at iteration %i and step %i!!!!", cal.atIteration, cal.atStep + 1); } LOGF(warning, "We return without saving table... -> THis is a problem"); } // end of process diff --git a/PWGCF/Flow/Tasks/flowSP.cxx b/PWGCF/Flow/Tasks/flowSP.cxx index 919e092f9b0..06de1e2ec4c 100644 --- a/PWGCF/Flow/Tasks/flowSP.cxx +++ b/PWGCF/Flow/Tasks/flowSP.cxx @@ -109,19 +109,26 @@ struct FlowSP { Filter collisionFilter = nabs(aod::collision::posZ) < cfgVtxZ; Filter trackFilter = nabs(aod::track::eta) < cfgEta && aod::track::pt > cfgPtmin&& aod::track::pt < cfgPtmax && ((requireGlobalTrackInFilter()) || (aod::track::isGlobalTrackSDD == (uint8_t) true)) && nabs(aod::track::dcaXY) < cfgDCAxy&& nabs(aod::track::dcaZ) < cfgDCAz; - using UsedCollisions = soa::Filtered>; + using UsedCollisions = soa::Filtered>; using UsedTracks = soa::Filtered>; // Connect to ccdb Service ccdb; - // from Generic Framework - // Adapted to hold weights for: inclusive, positive charged, negative charged + // struct to hold the correction histos/ struct Config { std::vector mEfficiency = {}; std::vector mAcceptance = {}; bool correctionsLoaded = false; int lastRunNumber = 0; + + TProfile* hcorrQQ = nullptr; + TProfile* hcorrQQx = nullptr; + TProfile* hcorrQQy = nullptr; + TProfile* hEvPlaneRes = nullptr; + bool clQQ = false; + bool clEvPlaneRes = false; + } cfg; // define output objects @@ -247,6 +254,11 @@ struct FlowSP { registry.add("incl/vnA_pt", "", kTProfile, {axisPt}); registry.add("incl/vnC_pt_odd", "", kTProfile, {axisPt}); registry.add("incl/vnA_pt_odd", "", kTProfile, {axisPt}); + registry.add("incl/vnCx_pt_odd", "", kTProfile, {axisPt}); + registry.add("incl/vnAx_pt_odd", "", kTProfile, {axisPt}); + registry.add("incl/vnCy_pt_odd", "", kTProfile, {axisPt}); + registry.add("incl/vnAy_pt_odd", "", kTProfile, {axisPt}); + registry.add("incl/vnA_pt_EP", "", kTProfile, {axisPt}); registry.add("incl/vnC_pt_EP", "", kTProfile, {axisPt}); registry.add("incl/vnFull_pt_EP", "", kTProfile, {axisPt}); @@ -630,12 +642,23 @@ struct FlowSP { registry.fill(HIST(Charge[ct]) + HIST("vnA_pt_odd"), track.pt(), -1.0 * (uy * qyA + ux * qxA) / std::sqrt(std::fabs(corrQQ)), wacc * weff); registry.fill(HIST(Charge[ct]) + HIST("vnC_pt_odd"), track.pt(), -1.0 * (uy * qyC + ux * qxC) / std::sqrt(std::fabs(corrQQ)), wacc * weff); + + registry.fill(HIST(Charge[ct]) + HIST("vnAx_pt_odd"), track.pt(), -1.0 * (ux * qxA) / std::sqrt(std::fabs(corrQQx)), wacc * weff); + registry.fill(HIST(Charge[ct]) + HIST("vnAy_pt_odd"), track.pt(), -1.0 * (uy * qyA) / std::sqrt(std::fabs(corrQQy)), wacc * weff); + registry.fill(HIST(Charge[ct]) + HIST("vnCx_pt_odd"), track.pt(), -1.0 * (ux * qxC) / std::sqrt(std::fabs(corrQQx)), wacc * weff); + registry.fill(HIST(Charge[ct]) + HIST("vnCy_pt_odd"), track.pt(), -1.0 * (uy * qyC) / std::sqrt(std::fabs(corrQQy)), wacc * weff); + } else { registry.fill(HIST(Charge[ct]) + HIST("vnA_cent_plusEta"), centrality, (uy * qyA + ux * qxA) / std::sqrt(std::fabs(corrQQ)), wacc * weff); registry.fill(HIST(Charge[ct]) + HIST("vnC_cent_plusEta"), centrality, (uy * qyC + ux * qxC) / std::sqrt(std::fabs(corrQQ)), wacc * weff); registry.fill(HIST(Charge[ct]) + HIST("vnA_pt_odd"), track.pt(), (uy * qyA + ux * qxA) / std::sqrt(std::fabs(corrQQ)), wacc * weff); registry.fill(HIST(Charge[ct]) + HIST("vnC_pt_odd"), track.pt(), (uy * qyC + ux * qxC) / std::sqrt(std::fabs(corrQQ)), wacc * weff); + + registry.fill(HIST(Charge[ct]) + HIST("vnAx_pt_odd"), track.pt(), (ux * qxA) / std::sqrt(std::fabs(corrQQx)), wacc * weff); + registry.fill(HIST(Charge[ct]) + HIST("vnAy_pt_odd"), track.pt(), (uy * qyA) / std::sqrt(std::fabs(corrQQy)), wacc * weff); + registry.fill(HIST(Charge[ct]) + HIST("vnCx_pt_odd"), track.pt(), (ux * qxC) / std::sqrt(std::fabs(corrQQx)), wacc * weff); + registry.fill(HIST(Charge[ct]) + HIST("vnCy_pt_odd"), track.pt(), (uy * qyC) / std::sqrt(std::fabs(corrQQy)), wacc * weff); } registry.fill(HIST(Charge[ct]) + HIST("vnAxCxUx_cent_MH"), centrality, (uxMH * qxA * qxC) / corrQQx, wacc * weff); @@ -685,7 +708,8 @@ struct FlowSP { centrality = collision.centFT0M(); if (cfgFV0A) centrality = collision.centFV0A(); - // if (cfgNGlobal) centrality = collision.centNGlobal(); + if (cfgNGlobal) + centrality = collision.centNGlobal(); if (!eventSelected(collision, tracks.size(), centrality)) return; @@ -732,21 +756,28 @@ struct FlowSP { double corrQQ = 1., corrQQx = 1., corrQQy = 1.; // Load correlations and SP resolution needed for Scalar Product and event plane methods. + // Only load once! // If not loaded set to 1 if (cfgLoadAverageQQ) { - TList* hcorrList = ccdb->getForTimeStamp(cfgCCDBdir.value, bc.timestamp()); - TProfile* hcorrQQ = reinterpret_cast(hcorrList->FindObject("qAqCXY")); - TProfile* hcorrQQx = reinterpret_cast(hcorrList->FindObject("qAqCX")); - TProfile* hcorrQQy = reinterpret_cast(hcorrList->FindObject("qAqCY")); - corrQQ = hcorrQQ->GetBinContent(hcorrQQ->FindBin(centrality)); - corrQQx = hcorrQQx->GetBinContent(hcorrQQx->FindBin(centrality)); - corrQQy = hcorrQQy->GetBinContent(hcorrQQy->FindBin(centrality)); + if (!cfg.clQQ) { + TList* hcorrList = ccdb->getForTimeStamp(cfgCCDBdir.value, bc.timestamp()); + cfg.hcorrQQ = reinterpret_cast(hcorrList->FindObject("qAqCXY")); + cfg.hcorrQQx = reinterpret_cast(hcorrList->FindObject("qAqCX")); + cfg.hcorrQQy = reinterpret_cast(hcorrList->FindObject("qAqCY")); + cfg.clQQ = true; + } + corrQQ = cfg.hcorrQQ->GetBinContent(cfg.hcorrQQ->FindBin(centrality)); + corrQQx = cfg.hcorrQQx->GetBinContent(cfg.hcorrQQx->FindBin(centrality)); + corrQQy = cfg.hcorrQQy->GetBinContent(cfg.hcorrQQy->FindBin(centrality)); } double evPlaneRes = 1.; if (cfgLoadSPPlaneRes) { - TProfile* hEvPlaneRes = ccdb->getForTimeStamp(cfgCCDBdir_SP.value, bc.timestamp()); - evPlaneRes = hEvPlaneRes->GetBinContent(hEvPlaneRes->FindBin(centrality)); + if (!cfg.clEvPlaneRes) { + cfg.hEvPlaneRes = ccdb->getForTimeStamp(cfgCCDBdir_SP.value, bc.timestamp()); + cfg.clEvPlaneRes = true; + } + evPlaneRes = cfg.hEvPlaneRes->GetBinContent(cfg.hEvPlaneRes->FindBin(centrality)); if (evPlaneRes < 0) LOGF(fatal, " > 0 for centrality %.2f! Cannot determine resolution.. Change centrality ranges!!!", centrality); evPlaneRes = std::sqrt(evPlaneRes); @@ -785,7 +816,7 @@ struct FlowSP { if (!pos && !setCurrentParticleWeights(kNegative, weffN, waccN, track.phi(), track.eta(), track.pt(), vtxz)) return; - registry.fill(HIST("QA/after/hPt_inclusive"), track.pt()); + registry.fill(HIST("QA/after/hPt_inclusive"), track.pt(), wacc * weff); // // constrain angle to 0 -> [0,0+2pi] auto phi = RecoDecay::constrainAngle(track.phi(), 0); @@ -816,13 +847,21 @@ struct FlowSP { } PROCESS_SWITCH(FlowSP, processData, "Process analysis for non-derived data", true); - void processMCReco(soa::Filtered>::iterator const& collision, aod::BCsWithTimestamps const&, soa::Filtered> const& tracks, aod::McParticles const&) + void processMCReco(soa::Filtered>::iterator const& collision, aod::BCsWithTimestamps const&, soa::Filtered> const& tracks, aod::McParticles const&) { auto bc = collision.template bc_as(); auto field = (cfgMagField == 99999) ? getMagneticField(bc.timestamp()) : cfgMagField; double vtxz = collision.posZ(); float centrality = collision.centFT0C(); + if (cfgFT0Cvariant1) + centrality = collision.centFT0CVariant1(); + if (cfgFT0M) + centrality = collision.centFT0M(); + if (cfgFV0A) + centrality = collision.centFV0A(); + if (cfgNGlobal) + centrality = collision.centNGlobal(); if (cfgFillQAHistos) fillEventQA(collision, tracks); @@ -865,13 +904,21 @@ struct FlowSP { PROCESS_SWITCH(FlowSP, processMCReco, "Process analysis for MC reconstructed events", false); Filter mcCollFilter = nabs(aod::mccollision::posZ) < cfgVtxZ; - void processMCGen(soa::Filtered::iterator const& mcCollision, soa::SmallGroups> const& collisions, aod::McParticles const& particles) + void processMCGen(soa::Filtered::iterator const& mcCollision, soa::SmallGroups> const& collisions, aod::McParticles const& particles) { if (collisions.size() != 1) return; float centrality = -1; for (const auto& collision : collisions) { centrality = collision.centFT0C(); + if (cfgFT0Cvariant1) + centrality = collision.centFT0CVariant1(); + if (cfgFT0M) + centrality = collision.centFT0M(); + if (cfgFV0A) + centrality = collision.centFV0A(); + if (cfgNGlobal) + centrality = collision.centNGlobal(); } if (particles.size() < 1) From 850bfcc6f051c8d9aae0f3a6296944a1be628f30 Mon Sep 17 00:00:00 2001 From: Yash Patley <52608802+yashpatley@users.noreply.github.com> Date: Thu, 6 Feb 2025 03:33:11 +0530 Subject: [PATCH 05/30] [PWGCF] Update lambdaR2Correlation.cxx (#9776) --- .../Tasks/lambdaR2Correlation.cxx | 357 ++++++------------ 1 file changed, 109 insertions(+), 248 deletions(-) diff --git a/PWGCF/TwoParticleCorrelations/Tasks/lambdaR2Correlation.cxx b/PWGCF/TwoParticleCorrelations/Tasks/lambdaR2Correlation.cxx index 32179a9813b..f21427c0a51 100644 --- a/PWGCF/TwoParticleCorrelations/Tasks/lambdaR2Correlation.cxx +++ b/PWGCF/TwoParticleCorrelations/Tasks/lambdaR2Correlation.cxx @@ -23,10 +23,12 @@ #include "Framework/ASoAHelpers.h" #include "Framework/runDataProcessing.h" #include "PWGLF/DataModel/LFStrangenessTables.h" +#include "PWGLF/DataModel/mcCentrality.h" #include "CommonConstants/PhysicsConstants.h" #include "Common/Core/RecoDecay.h" #include "CCDB/BasicCCDBManager.h" #include "TPDGCode.h" +#include "TRandom.h" using namespace o2; using namespace o2::framework; @@ -140,8 +142,8 @@ enum TrackLabels { kTracksBeforeHasMcParticle = 1, kAllV0Tracks, kPassV0DauTrackSel, + kPassV0KinCuts, kPassV0TopoSel, - kPassV0TopoKinCuts, kNotLambdaNotAntiLambda, kV0AsLambdaAntiLambda, kPassV0MassWinCuts, @@ -191,11 +193,6 @@ enum DMCType { kMC }; -enum SameMixType { - kSameEvent = 0, - kMixEvent -}; - struct LambdaTableProducer { Produces lambdaCollisionTable; @@ -224,22 +221,22 @@ struct LambdaTableProducer { Configurable cMinTpcCrossedRows{"cMinTpcCrossedRows", 70, "min crossed rows"}; Configurable cTpcNsigmaCut{"cTpcNsigmaCut", 2.0, "TPC NSigma Selection Cut"}; Configurable cTrackMinDcaXY{"cTrackMinDcaXY", 0.05, "Minimum DcaXY of Daughter Tracks"}; - Configurable cIsGlobalTrackWoDca{"cIsGlobalTrackWoDca", false, "Check for Global Track"}; + Configurable cIsGlobalTrackWoDca{"cIsGlobalTrackWoDca", true, "Check for Global Track"}; // V0s Configurable cMinV0DcaDaughters{"cMinV0DcaDaughters", 0., "Minimum DCA between V0 daughters"}; Configurable cMaxV0DcaDaughters{"cMaxV0DcaDaughters", 1., "Maximum DCA between V0 daughters"}; - Configurable cMinDcaPosToPV{"cMinDcaPosToPV", 0.06, "Minimum V0 Positive Track DCAr cut to PV"}; - Configurable cMinDcaNegToPV{"cMinDcaNegToPV", 0.06, "Minimum V0 Negative Track DCAr cut to PV"}; + Configurable cMinDcaPosToPV{"cMinDcaPosToPV", 0.05, "Minimum V0 Positive Track DCAr cut to PV"}; + Configurable cMinDcaNegToPV{"cMinDcaNegToPV", 0.05, "Minimum V0 Negative Track DCAr cut to PV"}; Configurable cMinDcaV0ToPV{"cMinDcaV0ToPV", 0.0, "Minimum DCA V0 to PV"}; Configurable cMaxDcaV0ToPV{"cMaxDcaV0ToPV", 999.0, "Maximum DCA V0 to PV"}; - Configurable cMinV0TransRadius{"cMinV0TransRadius", 0.2, "Minimum V0 radius from PV"}; + Configurable cMinV0TransRadius{"cMinV0TransRadius", 0.5, "Minimum V0 radius from PV"}; Configurable cMaxV0TransRadius{"cMaxV0TransRadius", 999.0, "Maximum V0 radius from PV"}; Configurable cMinV0CTau{"cMinV0CTau", 0.0, "Minimum ctau"}; Configurable cMaxV0CTau{"cMaxV0CTau", 30.0, "Maximum ctau"}; - Configurable cMinV0CosPA{"cMinV0CosPA", 0.998, "Minimum V0 CosPA to PV"}; + Configurable cMinV0CosPA{"cMinV0CosPA", 0.995, "Minimum V0 CosPA to PV"}; Configurable cLambdaMassWindow{"cLambdaMassWindow", 0.005, "Mass Window to select Lambda"}; - Configurable cKshortRejMassWindow{"cKshortRejMassWindow", 0.017, "Reject K0Short Candidates"}; + Configurable cKshortRejMassWindow{"cKshortRejMassWindow", 0.01, "Reject K0Short Candidates"}; Configurable cKshortRejFlag{"cKshortRejFlag", true, "K0short Mass Rej Flag"}; Configurable cArmPodCutValue{"cArmPodCutValue", 0.5, "Armentros-Podolanski Slope Parameter"}; Configurable cArmPodCutFlag{"cArmPodCutFlag", false, "Armentros-Podolanski Cut Flag"}; @@ -248,6 +245,7 @@ struct LambdaTableProducer { Configurable cMinV0Pt{"cMinV0Pt", 0.8, "Minimum V0 pT"}; Configurable cMaxV0Pt{"cMaxV0Pt", 2.8, "Minimum V0 pT"}; Configurable cMaxV0Rap{"cMaxV0Rap", 0.6, "|rap| cut"}; + Configurable cDoEtaAnalysis{"cDoEtaAnalysis", false, "Do Eta Analysis"}; // V0s MC Configurable cHasMcFlag{"cHasMcFlag", true, "Has Mc Tag"}; @@ -255,11 +253,12 @@ struct LambdaTableProducer { Configurable cRecPrimaryLambda{"cRecPrimaryLambda", false, "Primary Reconstructed Lambda"}; Configurable cRecSecondaryLambda{"cRecSecondaryLambda", false, "Secondary Reconstructed Lambda"}; Configurable cGenPrimaryLambda{"cGenPrimaryLambda", true, "Primary Generated Lambda"}; - Configurable cGenDecayChannel{"cGenDecayChannel", false, "Gen Level Decay Channel Flag"}; + Configurable cGenDecayChannel{"cGenDecayChannel", true, "Gen Level Decay Channel Flag"}; // Efficiency Correction Configurable cCorrectionFlag{"cCorrectionFlag", false, "Efficiency Correction Flag"}; Configurable cCorrFactHist{"cCorrFactHist", 0, "Correction Factor Histogram"}; + Configurable cDoEtaCorr{"cDoEtaCorr", false, "Do Eta Corr"}; // CCDB Configurable cUrlCCDB{"cUrlCCDB", "http://ccdb-test.cern.ch:8080", "url of ccdb"}; @@ -274,7 +273,9 @@ struct LambdaTableProducer { // initialize corr_factor objects std::vector> vCorrFactStrings = {{"hEffVsPtLambda", "hEffVsPtAntiLambda"}, {"hEffVsPtYLambda", "hEffVsPtYAntiLambda"}, - {"hEffVsPtYVzLambda", "hEffVsPtYVzAntiLambda"}}; + {"hEffVsPtEtaLambda", "hEffVsPtEtaAntiLambda"}, + {"hEffVsPtYVzLambda", "hEffVsPtYVzAntiLambda"}, + {"hEffVsPtEtaVzLambda", "hEffVsPtEtaVzAntiLambda"}}; void init(InitContext const&) { @@ -388,8 +389,8 @@ struct LambdaTableProducer { histos.get(HIST("Events/h1f_collisions_info"))->GetXaxis()->SetBinLabel(CollisionLabels::kPassSelCol, "kPassSelCol"); histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kAllV0Tracks, "kAllV0Tracks"); histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kPassV0DauTrackSel, "kPassV0DauTrackSel"); + histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kPassV0KinCuts, "kPassV0KinCuts"); histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kPassV0TopoSel, "kPassV0TopoSel"); - histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kPassV0TopoKinCuts, "kPassV0TopoKinCuts"); histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kNotLambdaNotAntiLambda, "kNotLambdaNotAntiLambda"); histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kV0AsLambdaAntiLambda, "kV0AsLambdaAntiLambda"); histos.get(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kPassV0MassWinCuts, "kPassV0MassWinCuts"); @@ -489,6 +490,18 @@ struct LambdaTableProducer { histos.fill(HIST("Tracks/h1f_tracks_info"), kPassV0DauTrackSel); + // pT cut + if (v0.pt() <= cMinV0Pt || v0.pt() >= cMaxV0Pt) { + return false; + } + + // rapidity cut + if (std::abs(v0.yLambda()) >= cMaxV0Rap) { + return false; + } + + histos.fill(HIST("Tracks/h1f_tracks_info"), kPassV0KinCuts); + if (v0.dcaV0daughters() <= cMinV0DcaDaughters || v0.dcaV0daughters() >= cMaxV0DcaDaughters) { return false; } @@ -522,16 +535,6 @@ struct LambdaTableProducer { histos.fill(HIST("Tracks/h1f_tracks_info"), kPassV0TopoSel); - // pT cut - if (v0.pt() <= cMinV0Pt || v0.pt() >= cMaxV0Pt) { - return false; - } - - // rapidity cut - if (std::abs(v0.yLambda()) >= cMaxV0Rap) { - return false; - } - // all selection criterion passed (Return True) return true; } @@ -607,6 +610,8 @@ struct LambdaTableProducer { return true; } + histos.fill(HIST("Tracks/h1f_tracks_info"), 23.5); + return false; } @@ -688,16 +693,17 @@ struct LambdaTableProducer { TObject* obj = reinterpret_cast(ccdbObj->FindObject(Form("%s", vCorrFactStrings[cCorrFactHist][part].c_str()))); TH1F* hist = reinterpret_cast(obj->Clone()); float retVal = 0.; + float rap = (cDoEtaCorr) ? v0.eta() : v0.yLambda(); if (std::string(obj->ClassName()) == "TH1F") { histos.fill(HIST("Tracks/h1f_tracks_info"), kEffCorrPt); retVal = hist->GetBinContent(hist->FindBin(v0.pt())); } else if (std::string(obj->ClassName()) == "TH2F") { histos.fill(HIST("Tracks/h1f_tracks_info"), kEffCorrPtRap); - retVal = hist->GetBinContent(hist->FindBin(v0.pt(), v0.yLambda())); + retVal = hist->GetBinContent(hist->FindBin(v0.pt(), rap)); } else if (std::string(obj->ClassName()) == "TH3F") { histos.fill(HIST("Tracks/h1f_tracks_info"), kEffCorrPtRapVz); - retVal = hist->GetBinContent(hist->FindBin(v0.pt(), v0.yLambda(), col.posZ())); + retVal = hist->GetBinContent(hist->FindBin(v0.pt(), rap, col.posZ())); } else { histos.fill(HIST("Tracks/h1f_tracks_info"), kNoEffCorr); LOGF(warning, "CCDB OBJECT IS NOT A HISTOGRAM !!!"); @@ -808,8 +814,6 @@ struct LambdaTableProducer { continue; } - histos.fill(HIST("Tracks/h1f_tracks_info"), kPassV0TopoKinCuts); - // select v0 as lambda / anti-lambda // armeteros-podolanski selection | kshort mass rejection hypothesis if (!selLambdaMassWindow(v0, tracks, v0type)) { @@ -888,7 +892,7 @@ struct LambdaTableProducer { PROCESS_SWITCH(LambdaTableProducer, processMCRecoRun2, "Process for Run2 MC Reconstructed", false); - void processMCGen(aod::McCollisions::iterator const& mcCollision, aod::McParticles const& mcParticles) + void processMCGen(soa::Join::iterator const& mcCollision, aod::McParticles const& mcParticles) { histos.fill(HIST("McGen/h1f_collisions_info"), 1.5); @@ -899,7 +903,7 @@ struct LambdaTableProducer { histos.fill(HIST("McGen/h1f_collisions_info"), 2.5); histos.fill(HIST("McGen/h1f_collision_posZ"), mcCollision.posZ()); - lambdaMCGenCollisionTable(-999., mcCollision.posX(), mcCollision.posY(), mcCollision.posZ()); + lambdaMCGenCollisionTable(mcCollision.centFT0M(), mcCollision.posX(), mcCollision.posY(), mcCollision.posZ()); // initialize track objects ParticleType v0type = kLambda; @@ -934,11 +938,19 @@ struct LambdaTableProducer { } auto dautracks = mcpart.template daughters_as(); std::vector daughterPDGs, daughterIDs; + bool dauKinCutFlag = true; for (auto const& dautrack : dautracks) { + // check kinematic selection on daughters as well + if (dautrack.pt() <= cTrackMinPt || dautrack.pt() >= cTrackMaxPt || std::abs(dautrack.eta()) >= cTrackEtaCut) { + dauKinCutFlag = false; + } daughterPDGs.push_back(dautrack.pdgCode()); daughterIDs.push_back(dautrack.globalIndex()); } - if (cGenDecayChannel && (std::abs(daughterPDGs[0]) != kProton || std::abs(daughterPDGs[1]) != kPiPlus)) { + if (!dauKinCutFlag) { // check daughter acceptance + continue; + } + if (cGenDecayChannel && (std::abs(daughterPDGs[0]) != kProton || std::abs(daughterPDGs[1]) != kPiPlus)) { // check decay channel continue; } @@ -1126,24 +1138,14 @@ struct LambdaR2Correlation { Configurable cNRapBins{"cNRapBins", 12, "N Rapidity Bins"}; Configurable cMinRap{"cMinRap", -0.6, "Minimum Rapidity"}; Configurable cMaxRap{"cMaxRap", 0.6, "Maximum Rapidity"}; - Configurable cNPhiBins{"cNPhiBins", 32, "N Phi Bins"}; + Configurable cNPhiBins{"cNPhiBins", 36, "N Phi Bins"}; - // Efficiency Correction Flags - Configurable cPairCorrectionFlag{"cPairCorrectionFlag", false, "Pair Correction Flag"}; - Configurable cPairCorrectionHist{"cPairCorrectionHist", 0, "Pair Correction Hist"}; - Configurable cCorrFactFlag{"cCorrFactFlag", false, "Correction Factor Flag (Pair or Product of Single)"}; + // Eta/Rap Analysis + Configurable cDoEtaAnalysis{"cDoEtaAnalysis", false, "Eta/Rap Analysis Flag"}; - // Event Mixing. - Configurable cNumMixEv{"cNumMixEv", 10, "Number of Events to be mixed"}; - ConfigurableAxis cMixVzBins{"cMixVzBins", {VARIABLE_WIDTH, -10.0f, -8.f, -6.f, -4.f, -2.f, 0.f, 2.f, 4.f, 6.f, 8.f, 10.f}, "Mixing Bins Vz"}; - ConfigurableAxis cMixMultBins{"cMixMultBins", {VARIABLE_WIDTH, 0.0f, 5.0f, 10.0f, 20.0f, 30.0f, 40.0f, 60.0f, 80.0f, 100.0f}, "Mixing Bins Multiplicity"}; - - // CCDB - Configurable cUrlCCDB{"cUrlCCDB", "http://ccdb-test.cern.ch:8080", "url of ccdb"}; - Configurable cPathCCDB{"cPathCCDB", "Users/y/ypatley/lambda_corr_fact", "Path for ccdb-object"}; - - // Initialize CCDB Service - Service ccdb; + // Rotation Angle Min/Max + Configurable cRotAngleMin{"cRotAngleMin", -0.12, "Rotation Angle Minimum"}; + Configurable cRotAngleMax{"cRotAngleMax", 0.12, "Rotation Angle Minimum"}; // Histogram Registry. HistogramRegistry histos{"histos", {}, OutputObjHandlingPolicy::AnalysisObject}; @@ -1158,19 +1160,10 @@ struct LambdaR2Correlation { float rapbinwidth = 0.; float phibinwidth = 0.; float q = 0., e = 0., qinv = 0.; - float dRap = 0., dPhi = 0.; - - // initialize corr_factor objects - std::vector vPairCorrFactStrings = {"hEffVsPtPtDRapLambdaAntiLambda", - "hEffVsPtPtDRapLambdaLambda", - "hEffVsPtPtDRapAntiLambdaAntiLambda"}; + TRandom* ran = new TRandom(); void init(InitContext const&) { - // Set CCDB url - ccdb->setURL(cUrlCCDB.value); - ccdb->setCaching(true); - // Set Density Histogram Attributes nrapbins = static_cast(cNRapBins); kminrap = static_cast(cMinRap); @@ -1185,30 +1178,27 @@ struct LambdaR2Correlation { float kmaxrapphi = knrapphibins; const AxisSpec axisCheck(1, 0, 1, ""); - const AxisSpec axisPosZ(200, -10, 10, "V_{z} (cm)"); - const AxisSpec axisCent(100, 0, 100, "FT0M (%)"); + const AxisSpec axisPosZ(220, -11, 11, "V_{z} (cm)"); + const AxisSpec axisCent(105, 0, 105, "FT0M (%)"); const AxisSpec axisMult(10, 0, 10, "N_{#Lambda}"); const AxisSpec axisMass(100, 1.06, 1.16, "Inv Mass (GeV/#it{c}^{2})"); const AxisSpec axisPt(cNPtBins, cMinPt, cMaxPt, "p_{T} (GeV/#it{c})"); - const AxisSpec axisEta(24, -1.2, 1.2, "#eta"); + const AxisSpec axisEta(cNRapBins, cMinRap, cMaxRap, "#eta"); const AxisSpec axisRap(cNRapBins, cMinRap, cMaxRap, "y"); const AxisSpec axisPhi(cNPhiBins, 0., TwoPI, "#phi (rad)"); const AxisSpec axisRapPhi(knrapphibins, kminrapphi, kmaxrapphi, "y #phi"); const AxisSpec axisQinv(100, 0, 10, "q_{inv} (GeV/#it{c})"); - const AxisSpec axisDRap(2 * cNRapBins - 1., 2 * cMinRap, 2 * cMaxRap, "#Deltay"); - const AxisSpec axisDPhi(cNPhiBins, -PIHalf, 3. * PIHalf, "#Delta#varphi"); const AxisSpec axisEfPt(cNPtBins, cMinPt, cMaxPt, "p_{T}"); + const AxisSpec axisEfEta(cNRapBins, cMinRap, cMaxRap, "#eta"); const AxisSpec axisEfRap(cNRapBins, cMinRap, cMaxRap, "y"); - const AxisSpec axisEfDRap(2 * cNRapBins, 2 * cMinRap, 2 * cMaxRap, "#Deltay"); const AxisSpec axisEfPosZ(10, -10., 10., "V_{Z}"); - const AxisSpec axisEfCent(10, 0, 100, "FT0M (%)"); + const AxisSpec axisEfCent(10, 0, 100, "FT0M(%)"); // Create Histograms. // Event histos.add("Event/Reco/h1f_collision_posz", "V_{Z} Distribution", kTH1F, {axisPosZ}); histos.add("Event/Reco/h1f_ft0m_mult_percentile", "FT0M (%)", kTH1F, {axisCent}); - histos.add("Event/Reco/h1f_mixevent_cntr", "Mix Event Counter", kTH1F, {axisCheck}); histos.add("Event/Reco/h1i_lambda_mult", "#Lambda - Multiplicity", kTH1I, {axisMult}); histos.add("Event/Reco/h1i_antilambda_mult", "#bar{#Lambda} - Multiplicity", kTH1I, {axisMult}); @@ -1216,19 +1206,15 @@ struct LambdaR2Correlation { // Single Particle Efficiencies histos.add("Reco/Efficiency/h1f_n1_pt_LaP", "#rho_{1}^{#Lambda}", kTH1F, {axisEfPt}); histos.add("Reco/Efficiency/h1f_n1_pt_LaM", "#rho_{1}^{#bar{#Lambda}}", kTH1F, {axisEfPt}); + histos.add("Reco/Efficiency/h2f_n1_pteta_LaP", "#rho_{1}^{#Lambda}", kTH2F, {axisEfPt, axisEfEta}); + histos.add("Reco/Efficiency/h2f_n1_pteta_LaM", "#rho_{1}^{#bar{#Lambda}}", kTH2F, {axisEfPt, axisEfEta}); histos.add("Reco/Efficiency/h2f_n1_ptrap_LaP", "#rho_{1}^{#Lambda}", kTH2F, {axisEfPt, axisEfRap}); histos.add("Reco/Efficiency/h2f_n1_ptrap_LaM", "#rho_{1}^{#bar{#Lambda}}", kTH2F, {axisEfPt, axisEfRap}); + histos.add("Reco/Efficiency/h4f_n1_ptetavzmult_LaP", "#rho_{1}^{#Lambda}", kTHnSparseF, {axisEfPt, axisEfEta, axisEfPosZ, axisEfCent}); + histos.add("Reco/Efficiency/h4f_n1_ptetavzmult_LaM", "#rho_{1}^{#bar{#Lambda}}", kTHnSparseF, {axisEfPt, axisEfEta, axisEfPosZ, axisEfCent}); histos.add("Reco/Efficiency/h4f_n1_ptrapvzmult_LaP", "#rho_{1}^{#Lambda}", kTHnSparseF, {axisEfPt, axisEfRap, axisEfPosZ, axisEfCent}); histos.add("Reco/Efficiency/h4f_n1_ptrapvzmult_LaM", "#rho_{1}^{#bar{#Lambda}}", kTHnSparseF, {axisEfPt, axisEfRap, axisEfPosZ, axisEfCent}); - // Two Particle Efficiencies - histos.add("Reco/Efficiency/h2f_n2_ptpt_LaP_LaM", "#rho_{2}^{#Lambda#bar{#Lambda}}", kTH2F, {axisEfPt, axisEfPt}); - histos.add("Reco/Efficiency/h2f_n2_ptpt_LaP_LaP", "#rho_{2}^{#Lambda#Lambda}", kTH2F, {axisEfPt, axisEfPt}); - histos.add("Reco/Efficiency/h2f_n2_ptpt_LaM_LaM", "#rho_{2}^{#bar{#Lambda}#bar{#Lambda}}", kTH2F, {axisEfPt, axisEfPt}); - histos.add("Reco/Efficiency/h3f_n2_ptptdrap_LaP_LaM", "#rho_{2}^{#Lambda#bar{#Lambda}}", kTH3F, {axisEfPt, axisEfPt, axisEfDRap}); - histos.add("Reco/Efficiency/h3f_n2_ptptdrap_LaP_LaP", "#rho_{2}^{#Lambda#Lambda}", kTH3F, {axisEfPt, axisEfPt, axisEfDRap}); - histos.add("Reco/Efficiency/h3f_n2_ptptdrap_LaM_LaM", "#rho_{2}^{#bar{#Lambda}#bar{#Lambda}}", kTH3F, {axisEfPt, axisEfPt, axisEfDRap}); - // Single and Two Particle Densities // 1D Histograms histos.add("Reco/h1d_n1_mass_LaP", "#rho_{1}^{#Lambda}", kTH1D, {axisMass}); @@ -1242,48 +1228,22 @@ struct LambdaR2Correlation { histos.add("Reco/h1d_n1_phi_LaP", "#rho_{1}^{#Lambda}", kTH1D, {axisPhi}); histos.add("Reco/h1d_n1_phi_LaM", "#rho_{1}^{#bar{#Lambda}}", kTH1D, {axisPhi}); - // 2D Histograms for Pairs - histos.add("Reco/h2d_n2_ptpt_LaP_LaM", "#rho_{2}^{#Lambda#bar{#Lambda}}", kTH2D, {axisPt, axisPt}); - histos.add("Reco/h2d_n2_ptpt_LaP_LaP", "#rho_{2}^{#Lambda#Lambda}", kTH2D, {axisPt, axisPt}); - histos.add("Reco/h2d_n2_ptpt_LaM_LaM", "#rho_{2}^{#bar{#Lambda}#bar{#Lambda}}", kTH2D, {axisPt, axisPt}); - histos.add("Reco/h2d_n2_raprap_LaP_LaM", "#rho_{2}^{#Lambda#bar{#Lambda}}", kTH2D, {axisRap, axisRap}); - histos.add("Reco/h2d_n2_raprap_LaP_LaP", "#rho_{2}^{#Lambda#Lambda}", kTH2D, {axisRap, axisRap}); - histos.add("Reco/h2d_n2_raprap_LaM_LaM", "#rho_{2}^{#bar{#Lambda}#bar{#Lambda}}", kTH2D, {axisRap, axisRap}); - histos.add("Reco/h2d_n2_phiphi_LaP_LaM", "#rho_{2}^{#Lambda#bar{#Lambda}}", kTH2D, {axisPhi, axisPhi}); - histos.add("Reco/h2d_n2_phiphi_LaP_LaP", "#rho_{2}^{#Lambda#Lambda}", kTH2D, {axisPhi, axisPhi}); - histos.add("Reco/h2d_n2_phiphi_LaM_LaM", "#rho_{2}^{#bar{#Lambda}#bar{#Lambda}}", kTH2D, {axisPhi, axisPhi}); - - // Rho1 for R2 rapphi Histograms + // rho1 for R2 RapPhi histograms histos.add("Reco/h2d_n1_rapphi_LaP", "#rho_{1}^{#Lambda}", kTH2D, {axisRap, axisPhi}); histos.add("Reco/h2d_n1_rapphi_LaM", "#rho_{1}^{#bar{#Lambda}}", kTH2D, {axisRap, axisPhi}); - // Rho1 for R2 qinv Histograms - histos.add("Reco/h2d_n1_ptrap_LaP", "#rho_{1}^{#Lambda}", kTH2D, {axisPt, axisRap}); - histos.add("Reco/h2d_n1_ptrap_LaM", "#rho_{1}^{#bar{#Lambda}}", kTH2D, {axisPt, axisRap}); - - // Rho2 for R2 rapphi Histograms - histos.add("Reco/h2d_n2_rapphi_LaP_LaM", "#rho_{2}^{#Lambda - #bar{#Lambda}}", kTH2D, {axisRapPhi, axisRapPhi}); - histos.add("Reco/h2d_n2_rapphi_LaP_LaP", "#rho_{2}^{#Lambda - #Lambda}", kTH2D, {axisRapPhi, axisRapPhi}); - histos.add("Reco/h2d_n2_rapphi_LaM_LaM", "#rho_{2}^{#bar{#Lambda} - #bar{#Lambda}}", kTH2D, {axisRapPhi, axisRapPhi}); - - // Rho2 for R2 Qinv Histograms - histos.add("Reco/h1d_n2_qinv_LaP_LaM", "#rho_{2}^{#Lambda-#bar{#Lambda}}", kTH1D, {axisQinv}); - histos.add("Reco/h1d_n2_qinv_LaP_LaP", "#rho_{2}^{#Lambda-#Lambda}", kTH1D, {axisQinv}); - histos.add("Reco/h1d_n2_qinv_LaM_LaM", "#rho_{2}^{#bar{#Lambda}-#bar{#Lambda}}", kTH1D, {axisQinv}); - - // Mixed Event Histograms - histos.add("Reco/Same/h2d_n2_drapdphi_LaP_LaM", "#rho_{2}^{#Lambda-#bar{#Lambda}}(#Deltay,#Delta#varphi)", kTH2D, {axisDRap, axisDPhi}); - histos.add("Reco/Same/h2d_n2_drapdphi_LaP_LaP", "#rho_{2}^{#Lambda-#Lambda}(#Deltay,#Delta#varphi)", kTH2D, {axisDRap, axisDPhi}); - histos.add("Reco/Same/h2d_n2_drapdphi_LaM_LaM", "#rho_{2}^{#bar{#Lambda}-#bar{#Lambda}}(#Deltay,#Delta#varphi)", kTH2D, {axisDRap, axisDPhi}); - histos.add("Reco/Same/h1d_n2_qinv_LaP_LaM", "#rho_{2}^{#Lambda-#bar{#Lambda}}(q_{inv})", kTH1D, {axisQinv}); - histos.add("Reco/Same/h1d_n2_qinv_LaP_LaP", "#rho_{2}^{#Lambda-#Lambda}(q_{inv})", kTH1D, {axisQinv}); - histos.add("Reco/Same/h1d_n2_qinv_LaM_LaM", "#rho_{2}^{#bar{#Lambda}-#bar{#Lambda}}(q_{inv})", kTH1D, {axisQinv}); - histos.add("Reco/Mixed/h2d_n2_drapdphi_LaP_LaM", "#rho_{2}^{#Lambda-#bar{#Lambda}}(#Deltay,#Delta#varphi)", kTH2D, {axisDRap, axisDPhi}); - histos.add("Reco/Mixed/h2d_n2_drapdphi_LaP_LaP", "#rho_{2}^{#Lambda-#Lambda}(#Deltay,#Delta#varphi)", kTH2D, {axisDRap, axisDPhi}); - histos.add("Reco/Mixed/h2d_n2_drapdphi_LaM_LaM", "#rho_{2}^{#bar{#Lambda}-#bar{#Lambda}}(#Deltay,#Delta#varphi)", kTH2D, {axisDRap, axisDPhi}); - histos.add("Reco/Mixed/h1d_n2_qinv_LaP_LaM", "#rho_{2}^{#Lambda-#bar{#Lambda}}(q_{inv})", kTH1D, {axisQinv}); - histos.add("Reco/Mixed/h1d_n2_qinv_LaP_LaP", "#rho_{2}^{#Lambda-#Lambda}(q_{inv})", kTH1D, {axisQinv}); - histos.add("Reco/Mixed/h1d_n2_qinv_LaM_LaM", "#rho_{2}^{#bar{#Lambda}-#bar{#Lambda}}(q_{inv})", kTH1D, {axisQinv}); + // rho2 for R2 Rap1Phi1Rap2Phi2 histograms + histos.add("Reco/h2d_n2_rapphi_LaP_LaM", "#rho_{2}^{#Lambda#bar{#Lambda}}", kTH2D, {axisRapPhi, axisRapPhi}); + histos.add("Reco/h2d_n2_rapphi_LaP_LaP", "#rho_{2}^{#Lambda#Lambda}", kTH2D, {axisRapPhi, axisRapPhi}); + histos.add("Reco/h2d_n2_rapphi_LaM_LaM", "#rho_{2}^{#bar{#Lambda}#bar{#Lambda}}", kTH2D, {axisRapPhi, axisRapPhi}); + + // rho2 for R2 Qinv histograms + histos.add("Reco/h1d_n2_qinv_LaP_LaM", "#rho_{2}^{#Lambda#bar{#Lambda}}", kTH1D, {axisQinv}); + histos.add("Reco/h1d_n2_qinv_LaP_LaP", "#rho_{2}^{#Lambda#Lambda}", kTH1D, {axisQinv}); + histos.add("Reco/h1d_n2_qinv_LaM_LaM", "#rho_{2}^{#bar{#Lambda}#bar{#Lambda}}", kTH1D, {axisQinv}); + histos.add("Reco/h1d_n1n1_qinv_LaP_LaM", "#rho_{2}^{#Lambda#bar{#Lambda}}", kTH1D, {axisQinv}); + histos.add("Reco/h1d_n1n1_qinv_LaP_LaP", "#rho_{2}^{#Lambda#Lambda}", kTH1D, {axisQinv}); + histos.add("Reco/h1d_n1n1_qinv_LaM_LaM", "#rho_{2}^{#bar{#Lambda}#bar{#Lambda}}", kTH1D, {axisQinv}); // MCGen if (doprocessMCGen) { @@ -1292,101 +1252,45 @@ struct LambdaR2Correlation { } } - template - float getPairCorrFactors(T const& p1, T const& p2) - { - // Check for efficiency correction flag and Rec/Gen Data - if (!cPairCorrectionFlag || rec_gen == kGen) { - return 1.; - } - - // Get from CCDB - auto ccdbObj = ccdb->getForTimeStamp(cPathCCDB.value, -1); - - // Check CCDB Object - if (!ccdbObj) { - LOGF(warning, "CCDB OBJECT NOT FOUND"); - return 1.; - } - - // get ccdb object - TObject* obj = reinterpret_cast(ccdbObj->FindObject(Form("%s", vPairCorrFactStrings[part_pair].c_str()))); - TH1F* hist = reinterpret_cast(obj->Clone()); - float retVal = 0., dRap = p1.rap() - p2.rap(); - - if (std::string(obj->ClassName()) == "TH2F") { - retVal = hist->GetBinContent(hist->FindBin(p1.pt(), p2.pt())); - } else if (std::string(obj->ClassName()) == "TH3F") { - retVal = hist->GetBinContent(hist->FindBin(p1.pt(), p2.pt(), dRap)); - } else { - LOGF(warning, "CCDB OBJECT IS NOT A HISTOGRAM !!!"); - retVal = 1.; - } - - delete hist; - return retVal; - } - template - void fillPairHistSameEventMethod(U& p1, U& p2) + void fillPairHistos(U& p1, U& p2) { static constexpr std::string_view SubDirRecGen[] = {"Reco/", "McGen/"}; static constexpr std::string_view SubDirHist[] = {"LaP_LaM", "LaP_LaP", "LaM_LaM"}; - int rapbin1 = static_cast((p1.rap() - kminrap) / rapbinwidth); - int rapbin2 = static_cast((p2.rap() - kminrap) / rapbinwidth); - int phibin1 = static_cast(p1.phi() / phibinwidth); - int phibin2 = static_cast(p2.phi() / phibinwidth); + float rap1 = (cDoEtaAnalysis) ? p1.eta() : p1.rap(); + float rap2 = (cDoEtaAnalysis) ? p2.eta() : p2.rap(); - float pairCorrFact = 1.; + int rapbin1 = static_cast((rap1 - kminrap) / rapbinwidth); + int rapbin2 = static_cast((rap2 - kminrap) / rapbinwidth); - if (!cCorrFactFlag) { - pairCorrFact = getPairCorrFactors(p1, p2); - } else { - pairCorrFact = p1.corrFact() * p2.corrFact(); - } - - // Efficiency Histograms - histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST("Efficiency/h2f_n2_ptpt_") + HIST(SubDirHist[part_pair]), p1.pt(), p2.pt()); - histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST("Efficiency/h3f_n2_ptptdrap_") + HIST(SubDirHist[part_pair]), p1.pt(), p2.pt(), (p1.rap() - p2.rap())); + int phibin1 = static_cast(p1.phi() / phibinwidth); + int phibin2 = static_cast(p2.phi() / phibinwidth); - // QA Histogrms - histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST("h2d_n2_ptpt_") + HIST(SubDirHist[part_pair]), p1.pt(), p2.pt(), pairCorrFact); - histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST("h2d_n2_raprap_") + HIST(SubDirHist[part_pair]), p1.rap(), p2.rap(), pairCorrFact); - histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST("h2d_n2_phiphi_") + HIST(SubDirHist[part_pair]), p1.phi(), p2.phi(), pairCorrFact); + float corfac = p1.corrFact() * p2.corrFact(); if (rapbin1 >= 0 && rapbin2 >= 0 && phibin1 >= 0 && phibin2 >= 0 && rapbin1 < nrapbins && rapbin2 < nrapbins && phibin1 < nphibins && phibin2 < nphibins) { int rapphix = rapbin1 * nphibins + phibin1; int rapphiy = rapbin2 * nphibins + phibin2; - histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST("h2d_n2_rapphi_") + HIST(SubDirHist[part_pair]), rapphix + 0.5, rapphiy + 0.5, pairCorrFact); + histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST("h2d_n2_rapphi_") + HIST(SubDirHist[part_pair]), rapphix + 0.5, rapphiy + 0.5, corfac); } - // Qinv Histograms + // qinv histograms q = RecoDecay::p((p1.px() - p2.px()), (p1.py() - p2.py()), (p1.pz() - p2.pz())); e = RecoDecay::e(p1.px(), p1.py(), p1.pz(), MassLambda0) - RecoDecay::e(p2.px(), p2.py(), p2.pz(), MassLambda0); qinv = std::sqrt(-RecoDecay::m2(q, e)); - histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST("h1d_n2_qinv_") + HIST(SubDirHist[part_pair]), qinv, pairCorrFact); - } - - template - void fillPairHistMixEventMethod(T const& p1, T const& p2) - { - static constexpr std::string_view SubDirRecGen[] = {"Reco/", "McGen/"}; - static constexpr std::string_view SubDirSameMix[] = {"Same/", "Mixed/"}; - static constexpr std::string_view SubDirHist[] = {"LaP_LaM", "LaP_LaP", "LaM_LaM"}; - - float corrFact = p1.corrFact() * p2.corrFact(); - - dRap = p1.rap() - p2.rap(); - dPhi = RecoDecay::constrainAngle((p1.phi() - p2.phi()), -PIHalf); - q = RecoDecay::p((p1.px() - p2.px()), (p1.py() - p2.py()), (p1.pz() - p2.pz())); - e = RecoDecay::e(p1.px(), p1.py(), p1.pz(), MassLambda0) - RecoDecay::e(p2.px(), p2.py(), p2.pz(), MassLambda0); + histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST("h1d_n2_qinv_") + HIST(SubDirHist[part_pair]), qinv, corfac); + + // Rotate momentum vector about z-axis to get N1N1_Qinv Histograms + float ranPhi = ran->Uniform(cRotAngleMin, cRotAngleMax); + float p2x = p2.pt() * std::cos(RecoDecay::constrainAngle((p2.phi() + ranPhi), 0)); + float p2y = p2.pt() * std::sin(RecoDecay::constrainAngle((p2.phi() + ranPhi), 0)); + q = RecoDecay::p((p1.px() - p2x), (p1.py() - p2y), (p1.pz() - p2.pz())); + e = RecoDecay::e(p1.px(), p1.py(), p1.pz(), MassLambda0) - RecoDecay::e(p2x, p2y, p2.pz(), MassLambda0); qinv = std::sqrt(-RecoDecay::m2(q, e)); - - histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST(SubDirSameMix[sm]) + HIST("h2d_n2_drapdphi_") + HIST(SubDirHist[part_pair]), dRap, dPhi, corrFact); - histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST(SubDirSameMix[sm]) + HIST("h1d_n2_qinv_") + HIST(SubDirHist[part_pair]), qinv, corrFact); + histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST("h1d_n1n1_qinv_") + HIST(SubDirHist[part_pair]), qinv, corfac); } template @@ -1408,13 +1312,14 @@ struct LambdaR2Correlation { histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST("h1d_n1_phi_") + HIST(SubDirHist[part]), track.phi(), track.corrFact()); histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST("h1d_n1_rap_") + HIST(SubDirHist[part]), track.rap(), track.corrFact()); - // Efficiency Calculation Plots + // Efficiency Plots histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST("Efficiency/h1f_n1_pt_") + HIST(SubDirHist[part]), track.pt()); + histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST("Efficiency/h2f_n1_pteta_") + HIST(SubDirHist[part]), track.pt(), track.eta()); histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST("Efficiency/h2f_n1_ptrap_") + HIST(SubDirHist[part]), track.pt(), track.rap()); + histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST("Efficiency/h4f_n1_ptetavzmult_") + HIST(SubDirHist[part]), track.pt(), track.eta(), col.posZ(), col.cent()); histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST("Efficiency/h4f_n1_ptrapvzmult_") + HIST(SubDirHist[part]), track.pt(), track.rap(), col.posZ(), col.cent()); - // Rho1 for R2 Calculation - histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST("h2d_n1_ptrap_") + HIST(SubDirHist[part]), track.pt(), track.rap(), track.corrFact()); + // Rho1 for N1RapPhi histos.fill(HIST(SubDirRecGen[rec_gen]) + HIST("h2d_n1_rapphi_") + HIST(SubDirHist[part]), track.rap(), track.phi(), track.corrFact()); } @@ -1428,47 +1333,20 @@ struct LambdaR2Correlation { } } - template - void analyzeSameEventPairs(T const& tracks1, T const& tracks2) + template + void analyzePairs(T const& trks_1, T const& trks_2) { - for (auto const& track1 : tracks1) { - for (auto const& track2 : tracks2) { + for (auto const& trk_1 : trks_1) { + for (auto const& trk_2 : trks_2) { // check for same index for Lambda-Lambda / AntiLambda-AntiLambda - if (samelambda && ((track1.index() == track2.index()))) { - continue; - } - fillPairHistMixEventMethod(track1, track2); - fillPairHistSameEventMethod(track1, track2); - } - } - } - - template - void analyzeMixEventPairs(T const& tracks1, T const& tracks2) - { - for (auto const& track1 : tracks1) { - if (!track1.trueLambdaFlag()) { // Check for True Lambda - continue; - } - for (auto const& track2 : tracks2) { - if (!track2.trueLambdaFlag()) { // Check for True Lambda - continue; - } - // Analyze Pairs - if (track1.v0Type() == kLambda && track2.v0Type() == kAntiLambda) { // Lambda-AntiLambda - fillPairHistMixEventMethod(track1, track2); - } else if (track1.v0Type() == kLambda && track2.v0Type() == kLambda) { // Lambda-Lambda - fillPairHistMixEventMethod(track1, track2); - } else if (track1.v0Type() == kAntiLambda && track2.v0Type() == kAntiLambda) { // AntiLambda-AntiLambda - fillPairHistMixEventMethod(track1, track2); - } else { + if (samelambda && ((trk_1.index() == trk_2.index()))) { continue; } + fillPairHistos(trk_1, trk_2); } } } - // Process Same Event Data and McRec using LambdaCollisions = aod::LambdaCollisions; using LambdaTracks = soa::Join; @@ -1486,31 +1364,13 @@ struct LambdaR2Correlation { analyzeSingles(collision, lambdaTracks); analyzeSingles(collision, antiLambdaTracks); - analyzeSameEventPairs(lambdaTracks, antiLambdaTracks); - analyzeSameEventPairs(lambdaTracks, lambdaTracks); - analyzeSameEventPairs(antiLambdaTracks, antiLambdaTracks); + analyzePairs(lambdaTracks, antiLambdaTracks); + analyzePairs(lambdaTracks, lambdaTracks); + analyzePairs(antiLambdaTracks, antiLambdaTracks); } PROCESS_SWITCH(LambdaR2Correlation, processDataReco, "Process for Data and MCReco", true); - // Process Mix Event Data and McRec - SliceCache cacheMix; - using BinningVzMult = ColumnBinningPolicy; - BinningVzMult binningOnVtxZAndMult{{cMixVzBins, cMixMultBins}, true}; - - void processDataRecoMix(aod::LambdaCollisions const& collisions, soa::Join const& lambdaTracks) - { - auto tracksTuple = std::make_tuple(lambdaTracks); - SameKindPair, BinningVzMult> pairs{binningOnVtxZAndMult, cNumMixEv, -1, collisions, tracksTuple, &cacheMix}; - for (auto const& [collision1, tracks1, collision2, tracks2] : pairs) { - analyzeMixEventPairs(tracks1, tracks2); - histos.fill(HIST("Event/Reco/h1f_mixevent_cntr"), 0.5); - } - } - - PROCESS_SWITCH(LambdaR2Correlation, processDataRecoMix, "Process for Data and MCReco Mixed Events", false); - - // Process Same Event McGen using LambdaMcGenCollisions = aod::LambdaMcGenCollisions; using LambdaMcGenTracks = aod::LambdaMcGenTracks; @@ -1521,15 +1381,16 @@ struct LambdaR2Correlation { void processMCGen(LambdaMcGenCollisions::iterator const& mcgencol, LambdaMcGenTracks const&) { histos.fill(HIST("Event/McGen/h1f_collision_posz"), mcgencol.posZ()); + histos.fill(HIST("Event/McGen/h1f_ft0m_mult_percentile"), mcgencol.cent()); auto lambdaMcGenTracks = partLambdaMcGenTracks->sliceByCached(aod::lambdamcgentrack::lambdaMcGenCollisionId, mcgencol.globalIndex(), cachemc); auto antiLambdaMcGenTracks = partAntiLambdaMcGenTracks->sliceByCached(aod::lambdamcgentrack::lambdaMcGenCollisionId, mcgencol.globalIndex(), cachemc); analyzeSingles(mcgencol, lambdaMcGenTracks); analyzeSingles(mcgencol, antiLambdaMcGenTracks); - analyzeSameEventPairs(lambdaMcGenTracks, antiLambdaMcGenTracks); - analyzeSameEventPairs(lambdaMcGenTracks, lambdaMcGenTracks); - analyzeSameEventPairs(antiLambdaMcGenTracks, antiLambdaMcGenTracks); + analyzePairs(lambdaMcGenTracks, antiLambdaMcGenTracks); + analyzePairs(lambdaMcGenTracks, lambdaMcGenTracks); + analyzePairs(antiLambdaMcGenTracks, antiLambdaMcGenTracks); } PROCESS_SWITCH(LambdaR2Correlation, processMCGen, "Process for MC Generated", false); From ce050cbcb2e7a8ec269110f2e0df8df7ae367ddd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= Date: Wed, 5 Feb 2025 23:54:23 +0100 Subject: [PATCH 06/30] [PWGLF] Update K0ME MC (#9774) --- PWGLF/Tasks/Strangeness/k0_mixed_events.cxx | 107 ++++++++++++-------- 1 file changed, 65 insertions(+), 42 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/k0_mixed_events.cxx b/PWGLF/Tasks/Strangeness/k0_mixed_events.cxx index 88283cf650c..b2218883cb8 100644 --- a/PWGLF/Tasks/Strangeness/k0_mixed_events.cxx +++ b/PWGLF/Tasks/Strangeness/k0_mixed_events.cxx @@ -39,6 +39,8 @@ #include "PWGCF/Femto3D/Core/femto3dPairTask.h" #include "Common/DataModel/Centrality.h" #include "PWGLF/DataModel/mcCentrality.h" +#include "Framework/O2DatabasePDGPlugin.h" +#include "PWGLF/Utils/inelGt.h" using namespace o2; using namespace o2::soa; @@ -128,7 +130,6 @@ struct K0MixedEvents { Configurable _dphi{"dphi", 1, "minimum allowed defference in phi_star between two tracks in a pair"}; Configurable _radiusTPC{"radiusTPC", 1.2, "TPC radius to calculate phi_star for"}; - Configurable useCentralityInvMass{"useCentralityInvMass", true, "Use the centrality vs inv. mass plots"}; Configurable doMixedEvent{"doMixedEvent", false, "Do the mixed event"}; Configurable _multbinwidth{"multbinwidth", 50, "width of multiplicity bins within which the mixing is done"}; Configurable _vertexbinwidth{"vertexbinwidth", 2, "width of vertexZ bins within which the mixing is done"}; @@ -203,20 +204,13 @@ struct K0MixedEvents { registry.add("VTXc", "VTXc", kTH1D, {{100, -20., 20., "vtx"}}); registry.add("VTX", "VTX", kTH1D, {{100, -20., 20., "vtx"}}); registry.add("multPerc", "multPerc", kTH1D, {multPercentileAxis}); + registry.add("SEcand", "SEcand", kTH1D, {{2, 0.5, 2.5}}); registry.add("SE", "SE", kTH1D, {invMassAxis}); registry.add("ME", "ME", kTH1D, {invMassAxis}); - if (useCentralityInvMass) { - registry.add("SEvsPt", "SEvsPt", kTH3F, {invMassAxis, ptAxis, multPercentileAxis}); - } else { - registry.add("SEvsPt", "SEvsPt", kTH2D, {invMassAxis, ptAxis}); - } + registry.add("SEvsPt", "SEvsPt", kTH3F, {invMassAxis, ptAxis, multPercentileAxis}); if (doMixedEvent) { - if (useCentralityInvMass) { - registry.add("MEvsPt", "MEvsPt", kTH3F, {invMassAxis, ptAxis, multPercentileAxis}); - } else { - registry.add("MEvsPt", "MEvsPt", kTH2D, {invMassAxis, ptAxis}); - } + registry.add("MEvsPt", "MEvsPt", kTH3F, {invMassAxis, ptAxis, multPercentileAxis}); } registry.add("eta", Form("eta_%i", _particlePDG_1.value), kTH2F, {ptAxis, {100, -10., 10., "#eta"}}); registry.add("p_first", Form("p_%i", _particlePDG_1.value), kTH1D, {ptAxis}); @@ -233,14 +227,14 @@ struct K0MixedEvents { registry.add("rapidity_second", Form("rapidity_%i", _particlePDG_2.value), kTH2F, {ptAxis, {100, -10., 10., Form("y(%s)", pdgToSymbol(_particlePDG_2))}}); } - if (!doprocessMCReco) { + if (!doprocessMC) { return; } - if (useCentralityInvMass) { - registry.add("MC/generatedInRecoEvs", "generatedInRecoEvs", kTH2D, {ptAxis, multPercentileAxis}); - } else { - registry.add("MC/generatedInRecoEvs", "generatedInRecoEvs", kTH2D, {ptAxis}); - } + registry.add("MC/multPerc", "multPerc", kTH1D, {multPercentileAxis}); + registry.add("MC/multPercMC", "multPercMC", kTH1D, {multPercentileAxis}); + registry.add("MC/generatedInRecoEvs", "generatedInRecoEvs", kTH2D, {ptAxis, multPercentileAxis}); + registry.add("MC/generatedInGenEvs", "generatedInGenEvs", kTH2D, {ptAxis, multPercentileAxis}); + registry.add("MC/SEvsPt", "SEvsPt", kTH3F, {invMassAxis, ptAxis, multPercentileAxis}); } template @@ -261,12 +255,8 @@ struct K0MixedEvents { continue; } registry.fill(HIST("SEcand"), 2.f); - registry.fill(HIST("SE"), Pair->getInvMass()); // close pair rejection and fillig the SE histo - if (useCentralityInvMass) { - registry.fill(HIST("SEvsPt"), Pair->getInvMass(), Pair->getPt(), centrality); // close pair rejection and fillig the SE histo - } else { - registry.fill(HIST("SEvsPt"), Pair->getInvMass(), Pair->getPt()); // close pair rejection and fillig the SE histo - } + registry.fill(HIST("SE"), Pair->getInvMass()); // close pair rejection and fillig the SE histo + registry.fill(HIST("SEvsPt"), Pair->getInvMass(), Pair->getPt(), centrality); // close pair rejection and fillig the SE histo } } } @@ -292,18 +282,10 @@ struct K0MixedEvents { if constexpr (isSameEvent) { registry.fill(HIST("SEcand"), 2.f); registry.fill(HIST("SE"), Pair->getInvMass()); - if (useCentralityInvMass) { - registry.fill(HIST("SEvsPt"), Pair->getInvMass(), Pair->getPt(), centrality); - } else { - registry.fill(HIST("SEvsPt"), Pair->getInvMass(), Pair->getPt()); - } + registry.fill(HIST("SEvsPt"), Pair->getInvMass(), Pair->getPt(), centrality); } else { registry.fill(HIST("ME"), Pair->getInvMass()); - if (useCentralityInvMass) { - registry.fill(HIST("MEvsPt"), Pair->getInvMass(), Pair->getPt(), centrality); - } else { - registry.fill(HIST("MEvsPt"), Pair->getInvMass(), Pair->getPt()); - } + registry.fill(HIST("MEvsPt"), Pair->getInvMass(), Pair->getPt(), centrality); } } } @@ -513,17 +495,35 @@ struct K0MixedEvents { using RecoMCCollisions = soa::Join; using GenMCCollisions = soa::Join; - // Service pdgDB; + Service pdgDB; Preslice perMCCol = aod::mcparticle::mcCollisionId; SliceCache cache; - void processMCReco(soa::Filtered const& collisions, - GenMCCollisions const&, - aod::McParticles const& mcParticles) + void processMC(soa::Filtered const& collisions, + // soa::Join const& tracks, + GenMCCollisions const& mcCollisions, + aod::McParticles const& mcParticles) { + + // Loop on reconstructed collisions for (const auto& col : collisions) { + if (!col.sel8()) { + continue; + } + if (std::abs(col.posZ()) > _vertexZ) { + continue; + } if (!col.has_mcCollision()) { continue; } + registry.fill(HIST("MC/multPerc"), col.centFT0M()); + // Loop on tracks + // MC / SEvsPt + + // Loop on particles const auto& mcCollision = col.mcCollision_as(); const auto& particlesInCollision = mcParticles.sliceByCached(aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); for (const auto& mcParticle : particlesInCollision) { @@ -539,16 +539,39 @@ struct K0MixedEvents { if (std::abs(mcParticle.y()) > 0.5) { continue; } - if (useCentralityInvMass) { - registry.fill(HIST("MC/generatedInRecoEvs"), mcParticle.pt(), col.centFT0M()); - } else { - registry.fill(HIST("MC/generatedInRecoEvs"), mcParticle.pt()); + registry.fill(HIST("MC/generatedInRecoEvs"), mcParticle.pt(), col.centFT0M()); + } + } + + // Loop on generated collisions + for (const auto& mcCollision : mcCollisions) { + if (std::abs(mcCollision.posZ()) > _vertexZ) { + continue; + } + const auto& particlesInCollision = mcParticles.sliceByCached(aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + if (!o2::pwglf::isINELgt0mc(particlesInCollision, pdgDB)) { + continue; + } + registry.fill(HIST("MC/multPercMC"), mcCollision.centFT0M()); + for (const auto& mcParticle : particlesInCollision) { + switch (mcParticle.pdgCode()) { + case 310: + break; + default: + continue; + } + if (mcParticle.pdgCode() != 310) { + LOG(fatal) << "Fatal in PDG"; + } + if (std::abs(mcParticle.y()) > 0.5) { + continue; } + registry.fill(HIST("MC/generatedInGenEvs"), mcParticle.pt(), mcCollision.centFT0M()); } } } - PROCESS_SWITCH(K0MixedEvents, processMCReco, "process mc", false); + PROCESS_SWITCH(K0MixedEvents, processMC, "process mc", false); }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) From 4e5fda780b72fa1ab80c9fbd8f8eab1ca4495648 Mon Sep 17 00:00:00 2001 From: alcaliva <32872606+alcaliva@users.noreply.github.com> Date: Thu, 6 Feb 2025 01:01:43 +0100 Subject: [PATCH 07/30] [PWGLF] updated jet selection (#9778) --- PWGLF/Tasks/Nuspex/nucleiInJets.cxx | 117 +++++++++++++++------------- 1 file changed, 65 insertions(+), 52 deletions(-) diff --git a/PWGLF/Tasks/Nuspex/nucleiInJets.cxx b/PWGLF/Tasks/Nuspex/nucleiInJets.cxx index b2cc0e58364..ef7c5eadc8c 100644 --- a/PWGLF/Tasks/Nuspex/nucleiInJets.cxx +++ b/PWGLF/Tasks/Nuspex/nucleiInJets.cxx @@ -98,6 +98,8 @@ struct NucleiInJets { Configurable nJetsPerEventMax{"nJetsPerEventMax", 1000, "Maximum number of jets per event"}; Configurable requireNoOverlap{"requireNoOverlap", true, "require no overlap between jets and UE cones"}; Configurable nGhosts{"nGhosts", 1000, "number of ghost particles"}; + Configurable alpha{"alpha", 1.0, "Alpha"}; + Configurable averagePtUE{"averagePtUE", 0.1, "Average pt of UE"}; // Track Parameters Configurable par0{"par0", 0.00164, "par 0"}; @@ -162,10 +164,12 @@ struct NucleiInJets { registryQC.add("sumPtUE", "sumPtUE", HistType::kTH1F, {{500, 0, 50, "#it{p}_{T} (GeV/#it{c})"}}); registryQC.add("nJets_found", "nJets_found", HistType::kTH1F, {{10, 0, 10, "#it{n}_{Jet}"}}); registryQC.add("nJets_selected", "nJets_selected", HistType::kTH1F, {{10, 0, 10, "#it{n}_{Jet}"}}); - registryQC.add("event_selection_jets", "event_selection_jets", HistType::kTH1F, {{10, 0, 10, "counter"}}); registryQC.add("dcaxy_vs_pt", "dcaxy_vs_pt", HistType::kTH2F, {{100, 0.0, 5.0, "#it{p}_{T} (GeV/#it{c})"}, {2000, -0.05, 0.05, "DCA_{xy} (cm)"}}); registryQC.add("dcaz_vs_pt", "dcaz_vs_pt", HistType::kTH2F, {{100, 0.0, 5.0, "#it{p}_{T} (GeV/#it{c})"}, {2000, -0.05, 0.05, "DCA_{z} (cm)"}}); + registryQC.add("jet_jet_overlaps", "jet_jet_overlaps", HistType::kTH2F, {{20, 0.0, 20.0, "#it{n}_{jet}"}, {200, 0.0, 200.0, "#it{n}_{overlaps}"}}); registryQC.add("jet_ue_overlaps", "jet_ue_overlaps", HistType::kTH2F, {{20, 0.0, 20.0, "#it{n}_{jet}"}, {200, 0.0, 200.0, "#it{n}_{overlaps}"}}); + registryQC.add("ue_ue_overlaps", "ue_ue_overlaps", HistType::kTH2F, {{20, 0.0, 20.0, "#it{n}_{jet}"}, {200, 0.0, 200.0, "#it{n}_{overlaps}"}}); + registryQC.add("tot_overlaps", "tot_overlaps", HistType::kTH2F, {{20, 0.0, 20.0, "#it{n}_{jet}"}, {200, 0.0, 200.0, "#it{n}_{overlaps}"}}); registryQC.add("hJetArea", "hJetArea", HistType::kTH1F, {{450, 0, 15, "Area"}}); // Event Counters @@ -243,7 +247,9 @@ struct NucleiInJets { registryMC.add("antiproton_eta_pt_ue", "antiproton_eta_pt_ue", HistType::kTH2F, {{200, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}, {20, -1.0, 1.0, "#it{#eta}"}}); // Detector Response Matrix - registryMC.add("detectorResponseMatrix", "detectorResponseMatrix", HistType::kTH2F, {{500, 0.0, 50.0, "#it{p}_{T}^{gen} (GeV/#it{c})"}, {500, 0.0, 50.0, "#it{p}_{T}^{rec} (GeV/#it{c})"}}); + if (doprocessDetResponseMatrix) { + registryMC.add("detectorResponseMatrix", "detectorResponseMatrix", HistType::kTH2F, {{5000, 0.0, 50.0, "#it{p}_{T}^{gen} (GeV/#it{c})"}, {5000, 0.0, 50.0, "#it{p}_{T}^{rec} (GeV/#it{c})"}}); + } } // ITS Hit @@ -443,6 +449,12 @@ struct NucleiInJets { return false; } + double getCorrectedPt(double ptRec) + { + // to be developed + return ptRec; + } + void getReweightingHistograms(o2::framework::Service const& ccdbObj, TString filepath, TString histname_antip_jet, TString histname_antip_ue) { TList* l = ccdbObj->get(filepath.Data()); @@ -469,7 +481,6 @@ struct NucleiInJets { { // Event Counter: before event selection registryData.fill(HIST("number_of_events_data"), 0.5); - registryQC.fill(HIST("event_selection_jets"), 0.5); // all events before jet selection // Event Selection if (!collision.sel8()) @@ -490,6 +501,7 @@ struct NucleiInJets { // List of Tracks std::vector trk; + std::vector ntrk; for (auto track : tracks) { // o2-linter: disable=[const-ref-in-for-loop] @@ -500,13 +512,20 @@ struct NucleiInJets { TVector3 momentum(track.px(), track.py(), track.pz()); trk.push_back(momentum); + ntrk.push_back(1); } + // Reject Empty Events + if (static_cast(trk.size()) < 1) + return; + registryData.fill(HIST("number_of_events_data"), 3.5); + // Anti-kt Jet Finder int nParticlesRemoved(0); std::vector jet; std::vector ue1; std::vector ue2; + std::vector nParticlesInjet; do { double dijMin(1e+06), diBmin(1e+06); @@ -532,11 +551,14 @@ struct NucleiInJets { } if (dijMin < diBmin) { trk[iMin] = trk[iMin] + trk[jMin]; + ntrk[iMin] = ntrk[iMin] + ntrk[jMin]; trk[jMin].SetXYZ(0, 0, 0); + ntrk[jMin] = 0; nParticlesRemoved++; } if (dijMin > diBmin) { jet.push_back(trk[iBmin]); + nParticlesInjet.push_back(ntrk[iBmin]); trk[iBmin].SetXYZ(0, 0, 0); nParticlesRemoved++; } @@ -546,14 +568,16 @@ struct NucleiInJets { // Jet Selection std::vector isSelected; - for (int i = 0; i < static_cast(jet.size()); i++) { // o2-linter: disable=[const-ref-in-for-loop] - isSelected.push_back(0); - } - int nJetsSelected(0); for (int i = 0; i < static_cast(jet.size()); i++) { // o2-linter: disable=[const-ref-in-for-loop] - if ((std::fabs(jet[i].Eta()) + rJet) > maxEta) + // Initialization + isSelected.push_back(0); + + // Jet fully contained inside acceptance + if ((std::fabs(jet[i].Eta()) + rJet) > (maxEta - 0.5)) + continue; + if (nParticlesInjet[i] < minNparticlesInJet) continue; // Perpendicular cones @@ -564,22 +588,13 @@ struct NucleiInJets { ue1.push_back(ueAxis1); ue2.push_back(ueAxis2); - double nPartJetPlusUE(0); - double nPartJet(0); - double nPartUE(0); - double ptJetPlusUE(0); - double ptJet(0); double ptUE(0); - for (auto track : tracks) { // o2-linter: disable=[const-ref-in-for-loop] if (!passedTrackSelectionForJetReconstruction(track)) continue; TVector3 selectedTrack(track.px(), track.py(), track.pz()); - double deltaEtaJet = selectedTrack.Eta() - jet[i].Eta(); - double deltaPhiJet = getDeltaPhi(selectedTrack.Phi(), jet[i].Phi()); - double deltaRjet = std::sqrt(deltaEtaJet * deltaEtaJet + deltaPhiJet * deltaPhiJet); double deltaEtaUe1 = selectedTrack.Eta() - ueAxis1.Eta(); double deltaPhiUe1 = getDeltaPhi(selectedTrack.Phi(), ueAxis1.Phi()); double deltaRUe1 = std::sqrt(deltaEtaUe1 * deltaEtaUe1 + deltaPhiUe1 * deltaPhiUe1); @@ -587,35 +602,24 @@ struct NucleiInJets { double deltaPhiUe2 = getDeltaPhi(selectedTrack.Phi(), ueAxis2.Phi()); double deltaRUe2 = std::sqrt(deltaEtaUe2 * deltaEtaUe2 + deltaPhiUe2 * deltaPhiUe2); - if (deltaRjet < rJet) { - registryQC.fill(HIST("deltaEtadeltaPhiJet"), deltaEtaJet, deltaPhiJet); - nPartJetPlusUE++; - ptJetPlusUE = ptJetPlusUE + selectedTrack.Pt(); - } - if (deltaRUe1 < rJet) { + if (deltaRUe1 < alpha * rJet) { registryQC.fill(HIST("deltaEtadeltaPhi_ue"), deltaEtaUe1, deltaPhiUe1); - nPartUE++; ptUE = ptUE + selectedTrack.Pt(); } - if (deltaRUe2 < rJet) { + if (deltaRUe2 < alpha * rJet) { registryQC.fill(HIST("deltaEtadeltaPhi_ue"), deltaEtaUe2, deltaPhiUe2); - nPartUE++; ptUE = ptUE + selectedTrack.Pt(); } } - nPartJet = nPartJetPlusUE - 0.5 * nPartUE; - ptJet = ptJetPlusUE - 0.5 * ptUE; - registryQC.fill(HIST("NchJetPlusUE"), nPartJetPlusUE); - registryQC.fill(HIST("NchJet"), nPartJet); - registryQC.fill(HIST("NchUE"), nPartUE); - registryQC.fill(HIST("sumPtJetPlusUE"), ptJetPlusUE); - registryQC.fill(HIST("sumPtJet"), ptJet); - registryQC.fill(HIST("sumPtUE"), ptUE); - - if (ptJet < minJetPt) - continue; - if (nPartJetPlusUE < minNparticlesInJet) + registryQC.fill(HIST("sumPtUE"), 0.5 * ptUE); + registryQC.fill(HIST("NchJetPlusUE"), nParticlesInjet[i]); + + double ptJetRec = jet[i].Pt() - averagePtUE; + double ptJetCorr = getCorrectedPt(ptJetRec); + + if (ptJetCorr < minJetPt) continue; + nJetsSelected++; isSelected[i] = 1; } @@ -623,34 +627,43 @@ struct NucleiInJets { if (nJetsSelected == 0) return; - registryData.fill(HIST("number_of_events_data"), 3.5); - registryQC.fill(HIST("event_selection_jets"), 1.5); // events with pTjet>10 GeV/c selected - //************************************************************************************************************************************ + registryData.fill(HIST("number_of_events_data"), 4.5); // Overlaps - int nOverlaps(0); - for (int i = 0; i < static_cast(jet.size()); i++) { // o2-linter: disable=[const-ref-in-for-loop] + int nOverlapsJetJet(0); + int nOverlapsJetUe(0); + int nOverlapsUeUe(0); + int nOverlapsTot(0); + for (int i = 0; i < static_cast(jet.size()); i++) { if (isSelected[i] == 0) continue; - for (int j = 0; j < static_cast(jet.size()); j++) { // o2-linter: disable=[const-ref-in-for-loop] - if (isSelected[j] == 0 || i == j) + for (int j = (i + 1); j < static_cast(jet.size()); j++) { + if (isSelected[j] == 0) continue; - if (overlap(jet[i], ue1[j], rJet) || overlap(jet[i], ue2[j], rJet) || overlap(jet[i], jet[j], rJet)) - nOverlaps++; + if (overlap(jet[i], jet[j], rJet)) + nOverlapsJetJet++; + if (overlap(jet[i], ue1[j], rJet) || overlap(jet[i], ue2[j], rJet)) + nOverlapsJetUe++; + if (overlap(ue1[i], ue1[j], rJet) || overlap(ue1[i], ue2[j], rJet) || overlap(ue2[i], ue2[j], rJet)) + nOverlapsUeUe++; } } - registryQC.fill(HIST("jet_ue_overlaps"), nJetsSelected, nOverlaps); + nOverlapsTot = nOverlapsJetJet + nOverlapsJetUe + nOverlapsUeUe; + registryQC.fill(HIST("jet_jet_overlaps"), nJetsSelected, nOverlapsJetJet); + registryQC.fill(HIST("jet_ue_overlaps"), nJetsSelected, nOverlapsJetUe); + registryQC.fill(HIST("ue_ue_overlaps"), nJetsSelected, nOverlapsUeUe); + registryQC.fill(HIST("tot_overlaps"), nJetsSelected, nOverlapsTot); if (nJetsSelected > nJetsPerEventMax) return; - registryData.fill(HIST("number_of_events_data"), 4.5); + registryData.fill(HIST("number_of_events_data"), 5.5); - if (requireNoOverlap && nOverlaps > 0) + if (requireNoOverlap && nOverlapsTot > 0) return; - registryData.fill(HIST("number_of_events_data"), 5.5); + registryData.fill(HIST("number_of_events_data"), 6.5); - //************************************************************************************************************************************ + //************************************************************************************************************** for (int i = 0; i < static_cast(jet.size()); i++) { // o2-linter: disable=[const-ref-in-for-loop] From 28d6501cc0ccdfc57a07cbd09013635425563aa9 Mon Sep 17 00:00:00 2001 From: Bong-Hwi Lim Date: Thu, 6 Feb 2025 02:09:15 +0100 Subject: [PATCH 08/30] [PWGLF] chk892Flow: Add new v0 selection cut (#9777) --- PWGLF/Tasks/Resonances/chk892Flow.cxx | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/PWGLF/Tasks/Resonances/chk892Flow.cxx b/PWGLF/Tasks/Resonances/chk892Flow.cxx index 3834e9dfd88..973a757d86b 100644 --- a/PWGLF/Tasks/Resonances/chk892Flow.cxx +++ b/PWGLF/Tasks/Resonances/chk892Flow.cxx @@ -176,6 +176,7 @@ struct Chk892Flow { Configurable cfgReturnFlag{"cfgReturnFlag", false, "Return Flag for debugging"}; Configurable cSecondaryRequire{"cSecondaryRequire", true, "Secondary cuts on/off"}; Configurable cSecondaryArmenterosCut{"cSecondaryArmenterosCut", true, "cut on Armenteros-Podolanski graph"}; + Configurable cSecondaryCrossMassHypothesisCut{"cSecondaryCrossMassHypothesisCut", false, "Apply cut based on the lambda mass hypothesis"}; Configurable cfgByPassDauPIDSelection{"cfgByPassDauPIDSelection", true, "Bypass Daughters PID selection"}; Configurable cSecondaryDauDCAMax{"cSecondaryDauDCAMax", 0.2, "Maximum DCA Secondary daughters to PV"}; @@ -190,7 +191,8 @@ struct Chk892Flow { Configurable cSecondaryDCAtoPVMax{"cSecondaryDCAtoPVMax", 0.4, "Maximum DCA Secondary to PV"}; Configurable cSecondaryProperLifetimeMax{"cSecondaryProperLifetimeMax", 20., "Maximum Secondary Lifetime"}; Configurable cSecondaryparamArmenterosCut{"cSecondaryparamArmenterosCut", 0.2, "parameter for Armenteros Cut"}; - Configurable cSecondaryMassWindow{"cSecondaryMassWindow", 0.03, "Secondary inv mass selciton window"}; + Configurable cSecondaryMassWindow{"cSecondaryMassWindow", 0.03, "Secondary inv mass selection window"}; + Configurable cSecondaryCrossMassCutWindow{"cSecondaryCrossMassCutWindow", 0.05, "Secondary inv mass selection window with (anti)lambda hypothesis"}; // K* selection Configurable cKstarMaxRap{"cKstarMaxRap", 0.5, "Kstar maximum rapidity"}; @@ -263,7 +265,7 @@ struct Chk892Flow { AxisSpec mcLabelAxis = {5, -0.5, 4.5, "MC Label"}; if (cfgReturnFlag) { - histos.add("QA/K0sCutCheck", "Check K0s cut", HistType::kTH1D, {AxisSpec{12, -0.5, 11.5, "Check"}}); + histos.add("QA/K0sCutCheck", "Check K0s cut", HistType::kTH1D, {AxisSpec{13, -0.5, 12.5, "Check"}}); } histos.add("QA/before/CentDist", "Centrality distribution", {HistType::kTH1D, {centAxis}}); histos.add("QA/before/VtxZ", "Centrality distribution", {HistType::kTH1D, {vtxzAxis}}); @@ -556,6 +558,8 @@ struct Chk892Flow { auto lCPA = candidate.v0cosPA(); auto lPropTauK0s = candidate.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * MassK0Short; auto lMk0s = candidate.mK0Short(); + auto lMLambda = candidate.mLambda(); + auto lMALambda = candidate.mAntiLambda(); auto checkCommonCuts = [&]() { if (lDauDCA > cSecondaryDauDCAMax) @@ -580,6 +584,9 @@ struct Chk892Flow { return false; if (std::fabs(lMk0s - MassK0Short) > cSecondaryMassWindow) return false; + if (cSecondaryCrossMassHypothesisCut && + ((std::fabs(lMLambda - MassLambda0) < cSecondaryCrossMassCutWindow) || (std::fabs(lMALambda - MassLambda0Bar) < cSecondaryCrossMassCutWindow))) + return false; return true; }; @@ -630,6 +637,11 @@ struct Chk892Flow { histos.fill(HIST("QA/K0sCutCheck"), 11); returnFlag = false; } + if (cSecondaryCrossMassHypothesisCut && + ((std::fabs(lMLambda - MassLambda0) < cSecondaryCrossMassCutWindow) || (std::fabs(lMALambda - MassLambda0Bar) < cSecondaryCrossMassCutWindow))) { + histos.fill(HIST("QA/K0sCutCheck"), 12); + returnFlag = false; + } return returnFlag; } else { // normal usage if (cSecondaryRequire) { From c9690129d35aaaadc6506ac97b0785ecca51d793 Mon Sep 17 00:00:00 2001 From: ilikmeta <152337132+ilikmeta@users.noreply.github.com> Date: Thu, 6 Feb 2025 04:16:49 +0200 Subject: [PATCH 09/30] [PWGCF] Fix FT0 low cut (#9779) Co-authored-by: ALICE Action Bot --- PWGCF/Flow/Tasks/flowGfwTask.cxx | 140 +++++++++++++++---------------- 1 file changed, 67 insertions(+), 73 deletions(-) diff --git a/PWGCF/Flow/Tasks/flowGfwTask.cxx b/PWGCF/Flow/Tasks/flowGfwTask.cxx index d62df4c340d..48e0bd1620a 100644 --- a/PWGCF/Flow/Tasks/flowGfwTask.cxx +++ b/PWGCF/Flow/Tasks/flowGfwTask.cxx @@ -61,27 +61,28 @@ struct FlowGfwTask { O2_DEFINE_CONFIGURABLE(cfgCutChi2prTPCcls, float, 2.5, "Chi2 per TPC clusters") O2_DEFINE_CONFIGURABLE(cfgCutTPCclu, float, 70.0f, "minimum TPC clusters") O2_DEFINE_CONFIGURABLE(cfgCutITSclu, float, 5.0f, "minimum ITS clusters") - O2_DEFINE_CONFIGURABLE(cfgUseAdditionalEventCut, bool, false, "Use additional event cut on mult correlations") - O2_DEFINE_CONFIGURABLE(cfgUseAdditionalTrackCut, bool, false, "Use additional track cut on phi") - O2_DEFINE_CONFIGURABLE(cfgUseNch, bool, false, "Use Nch for flow observables") + O2_DEFINE_CONFIGURABLE(cfgMinCentFT0C, float, 0.0f, "Minimum FT0C Centrality") + O2_DEFINE_CONFIGURABLE(cfgMaxCentFT0C, float, 100.0f, "Maximum FT0C Centrality") + O2_DEFINE_CONFIGURABLE(cfgUseAdditionalEventCut, bool, true, "Use additional event cut on mult correlations") + O2_DEFINE_CONFIGURABLE(cfgUseAdditionalTrackCut, bool, true, "Use additional track cut on phi") + O2_DEFINE_CONFIGURABLE(cfgUseNch, bool, true, "Use Nch for flow observables") O2_DEFINE_CONFIGURABLE(cfgNbootstrap, int, 10, "Number of subsamples") - O2_DEFINE_CONFIGURABLE(cfgOutputNUAWeights, bool, false, "Fill and output NUA weights") + O2_DEFINE_CONFIGURABLE(cfgOutputNUAWeights, bool, true, "Fill and output NUA weights") O2_DEFINE_CONFIGURABLE(cfgEfficiency, std::string, "", "CCDB path to efficiency object") O2_DEFINE_CONFIGURABLE(cfgAcceptance, std::string, "", "CCDB path to acceptance object") O2_DEFINE_CONFIGURABLE(cfgMagnetField, std::string, "GLO/Config/GRPMagField", "CCDB path to Magnet field object") - O2_DEFINE_CONFIGURABLE(cfgCutOccupancyHigh, int, 500, "High cut on TPC occupancy") + O2_DEFINE_CONFIGURABLE(cfgCutOccupancyHigh, int, 3000, "High cut on TPC occupancy") O2_DEFINE_CONFIGURABLE(cfgCutOccupancyLow, int, 0, "Low cut on TPC occupancy") O2_DEFINE_CONFIGURABLE(cfgCutDCAz, float, 2, "Custom DCA Z cut") O2_DEFINE_CONFIGURABLE(cfgCutDCAxy, float, 0.2f, "Custom DCA XY cut") - O2_DEFINE_CONFIGURABLE(cfgTVXinTRD, bool, false, "Use kTVXinTRD (reject TRD triggered events)"); - O2_DEFINE_CONFIGURABLE(cfgNoTimeFrameBorder, bool, false, "kNoTimeFrameBorder"); - O2_DEFINE_CONFIGURABLE(cfgNoITSROFrameBorder, bool, false, "kNoITSROFrameBorder"); - O2_DEFINE_CONFIGURABLE(cfgNoSameBunchPileup, bool, false, "kNoSameBunchPileup"); - O2_DEFINE_CONFIGURABLE(cfgIsGoodZvtxFT0vsPV, bool, false, "kIsGoodZvtxFT0vsPV"); - O2_DEFINE_CONFIGURABLE(cfgNoCollInTimeRangeStandard, bool, false, "kNoCollInTimeRangeStandard"); - O2_DEFINE_CONFIGURABLE(cfgEvSelkIsGoodITSLayersAll, bool, false, "kIsGoodITSLayersAll") - O2_DEFINE_CONFIGURABLE(cfgOccupancy, bool, false, "Bool for event selection on detector occupancy"); - O2_DEFINE_CONFIGURABLE(cfgMultCut, bool, false, "Use additional event cut on mult correlations"); + O2_DEFINE_CONFIGURABLE(cfgNoTimeFrameBorder, bool, true, "kNoTimeFrameBorder"); + O2_DEFINE_CONFIGURABLE(cfgNoITSROFrameBorder, bool, true, "kNoITSROFrameBorder"); + O2_DEFINE_CONFIGURABLE(cfgNoSameBunchPileup, bool, true, "kNoSameBunchPileup"); + O2_DEFINE_CONFIGURABLE(cfgIsGoodZvtxFT0vsPV, bool, true, "kIsGoodZvtxFT0vsPV"); + O2_DEFINE_CONFIGURABLE(cfgNoCollInTimeRangeStandard, bool, true, "kNoCollInTimeRangeStandard"); + O2_DEFINE_CONFIGURABLE(cfgEvSelkIsGoodITSLayersAll, bool, true, "kIsGoodITSLayersAll") + O2_DEFINE_CONFIGURABLE(cfgOccupancy, bool, true, "Bool for event selection on detector occupancy"); + O2_DEFINE_CONFIGURABLE(cfgMultCut, bool, true, "Use additional event cut on mult correlations"); O2_DEFINE_CONFIGURABLE(FineBinning, bool, false, "Manually change to fine binning") O2_DEFINE_CONFIGURABLE(cfgTrackSelRun3ITSMatch, bool, false, "System check: Run3ITSMatch") O2_DEFINE_CONFIGURABLE(cfgTrackSel, bool, false, "System check: track selection") @@ -98,9 +99,9 @@ struct FlowGfwTask { ConfigurableAxis axisT0C{"axisT0C", {70, 0, 70000}, "N_{ch} (T0C)"}; ConfigurableAxis axisT0A{"axisT0A", {200, 0, 200000}, "N_{ch} (T0A)"}; ConfigurableAxis axisT0M{"axisT0M", {70, 0, 70000}, "N_{ch} (T0M)"}; - ConfigurableAxis axisFT0CAmp{"axisFT0CAmp", {5000, 0, 5000}, "axisFT0CAmp"}; - ConfigurableAxis axisFT0AAmp{"axisFT0AAmp", {5000, 0, 5000}, "axisFT0AAmp"}; - ConfigurableAxis axisFT0MAmp{"axisFT0MAmp", {10000, 0, 10000}, "axisFT0MAmp"}; + ConfigurableAxis axisFT0CAmp{"axisFT0CAmp", {50000, 0, 50000}, "axisFT0CAmp"}; + ConfigurableAxis axisFT0AAmp{"axisFT0AAmp", {50000, 0, 50000}, "axisFT0AAmp"}; + ConfigurableAxis axisFT0MAmp{"axisFT0MAmp", {50000, 0, 50000}, "axisFT0MAmp"}; ConfigurableAxis axisNchPV{"axisNchPV", {4000, 0, 4000}, "N_{ch} (PV)"}; ConfigurableAxis axisDCAz{"axisDCAz", {200, -2, 2}, "DCA_{z} (cm)"}; ConfigurableAxis axisDCAxy{"axisDCAxy", {200, -1, 1}, "DCA_{xy} (cm)"}; @@ -111,7 +112,7 @@ struct FlowGfwTask { Configurable maxZP{"maxZP", 3099.5, "Max ZP signal"}; Configurable maxZEM{"maxZEM", 3099.5, "Max ZEM signal"}; Configurable nBinsFit{"nBinsFit", 1000, "nbinsFit"}; - Configurable maxMultFT0{"maxMultFT0", 3000, "Max FT0 signal"}; + Configurable maxMultFT0{"maxMultFT0", 5000, "Max FT0 signal"}; // Corrections TH1D* mEfficiency = nullptr; @@ -171,7 +172,6 @@ struct FlowGfwTask { kFILTERED, kSEL8, kOCCUPANCY, - kTVXINTRD, kNOTIMEFRAMEBORDER, kNOITSROFRAMEBORDER, kNOPSAMEBUNCHPILEUP, @@ -206,7 +206,6 @@ struct FlowGfwTask { registry.get(HIST("hEventCount"))->GetXaxis()->SetBinLabel(kFILTERED + 1, "Filtered events"); registry.get(HIST("hEventCount"))->GetXaxis()->SetBinLabel(kSEL8 + 1, "Sel8"); registry.get(HIST("hEventCount"))->GetXaxis()->SetBinLabel(kOCCUPANCY + 1, "Occupancy"); - registry.get(HIST("hEventCount"))->GetXaxis()->SetBinLabel(kTVXINTRD + 1, "kTVXinTRD"); registry.get(HIST("hEventCount"))->GetXaxis()->SetBinLabel(kNOTIMEFRAMEBORDER + 1, "kNoTimeFrameBorder"); registry.get(HIST("hEventCount"))->GetXaxis()->SetBinLabel(kNOITSROFRAMEBORDER + 1, "kNoITSROFrameBorder"); registry.get(HIST("hEventCount"))->GetXaxis()->SetBinLabel(kNOPSAMEBUNCHPILEUP + 1, "kNoSameBunchPileup"); @@ -257,14 +256,16 @@ struct FlowGfwTask { registry.add("ZPAcoll", "ZPAcoll; ZPA amplitude; Entries", {HistType::kTH1F, {{nBinsAmp, -0.5, maxZP}}}); registry.add("ZNCcoll", "ZNCcoll; ZNC amplitude; Entries", {HistType::kTH1F, {{nBinsAmp, -0.5, maxZN}}}); registry.add("ZPCcoll", "ZPCcoll; ZPC amplitude; Entries", {HistType::kTH1F, {{nBinsAmp, -0.5, maxZP}}}); - registry.add("ZNvsFT0correl", "ZNvsFT0correl", {HistType::kTH2F, {{{nBinsFit, 0., maxMultFT0}, {nBinsAmp, -0.5, 2. * maxZN}}}}); + registry.add("ZNvsFT0correl", "ZNvsFT0correl; FT0 amplitude; ZN", {HistType::kTH2F, {{{nBinsFit, 0., maxMultFT0}, {nBinsAmp, -0.5, 2. * maxZN}}}}); registry.add("ZDCAmp", "ZDC Amplitude; ZDC Amplitude; Events", {HistType::kTH1F, {{nBinsAmp, -0.5, maxZP}}}); - registry.add("ZNvsZEMcoll", "ZNvsZEMcoll; ZEM; ZNA+ZNC", {HistType::kTH2F, {{{nBinsAmp, -0.5, maxZEM}, {nBinsAmp, -0.5, 2. * maxZN}}}}); - registry.add("ZNvsZEMcoll05", "ZNvsZEMcoll; ZEM; ZNA+ZNC", {HistType::kTH2F, {{{nBinsAmp, -0.5, maxZEM}, {nBinsAmp, -0.5, 2. * maxZN}}}}); - registry.add("ZNvsZEMcoll510", "ZNvsZEMcoll; ZEM; ZNA+ZNC", {HistType::kTH2F, {{{nBinsAmp, -0.5, maxZEM}, {nBinsAmp, -0.5, 2. * maxZN}}}}); - registry.add("ZNvsZEMcoll1020", "ZNvsZEMcoll; ZEM; ZNA+ZNC", {HistType::kTH2F, {{{nBinsAmp, -0.5, maxZEM}, {nBinsAmp, -0.5, 2. * maxZN}}}}); - registry.add("ZNvsZEMcoll2030", "ZNvsZEMcoll; ZEM; ZNA+ZNC", {HistType::kTH2F, {{{nBinsAmp, -0.5, maxZEM}, {nBinsAmp, -0.5, 2. * maxZN}}}}); - registry.add("ZNvsZEMcollrest", "ZNvsZEMcoll; ZEM; ZNA+ZNC", {HistType::kTH2F, {{{nBinsAmp, -0.5, maxZEM}, {nBinsAmp, -0.5, 2. * maxZN}}}}); + registry.add("ZNAmp", "ZNA+ZNC Amplitude; ZN Amplitude; Events", {HistType::kTH1F, {{nBinsAmp, -0.5, maxZN}}}); + registry.add("ZPAmp", "ZPA+ZPC Amplitude; ZP Amplitude; Events", {HistType::kTH1F, {{nBinsAmp, -0.5, maxZP}}}); + registry.add("ZNvsZEMcoll", "ZNvsZEMcoll; ZEM; ZDC energy (GeV)", {HistType::kTH2F, {{{nBinsAmp, -0.5, maxZEM}, {nBinsAmp, -0.5, 2. * maxZN}}}}); + registry.add("ZNvsZEMcoll05", "ZNvsZEMcoll; ZEM; ZDC energy (GeV)", {HistType::kTH2F, {{{nBinsAmp, -0.5, maxZEM}, {nBinsAmp, -0.5, 2. * maxZN}}}}); + registry.add("ZNvsZEMcoll510", "ZNvsZEMcoll; ZEM; ZDC energy (GeV)", {HistType::kTH2F, {{{nBinsAmp, -0.5, maxZEM}, {nBinsAmp, -0.5, 2. * maxZN}}}}); + registry.add("ZNvsZEMcoll1020", "ZNvsZEMcoll; ZEM; ZDC energy (GeV)", {HistType::kTH2F, {{{nBinsAmp, -0.5, maxZEM}, {nBinsAmp, -0.5, 2. * maxZN}}}}); + registry.add("ZNvsZEMcoll2030", "ZNvsZEMcoll; ZEM; ZDC energy (GeV)", {HistType::kTH2F, {{{nBinsAmp, -0.5, maxZEM}, {nBinsAmp, -0.5, 2. * maxZN}}}}); + registry.add("ZNvsZEMcollrest", "ZNvsZEMcoll; ZEM; ZDC energy (GeV)", {HistType::kTH2F, {{{nBinsAmp, -0.5, maxZEM}, {nBinsAmp, -0.5, 2. * maxZN}}}}); // Track plots registry.add("Events_per_Centrality_Bin", "Events_per_Centrality_Bin;Centrality FT0C;No. of Events", kTH1F, {axisCentrality}); @@ -368,7 +369,7 @@ struct FlowGfwTask { fWeights->init(true, false); } - // add in FlowContainer to Get boostrap sample automatically + // add in FlowContainer to Get boostrap sample automatically -- Use post process flow task TObjArray* oba = new TObjArray(); fFC->SetXAxis(fPtAxis); fFC->SetName("FlowContainer"); @@ -518,13 +519,6 @@ struct FlowGfwTask { template bool eventSelected(o2::aod::mult::MultNTracksPV, TCollision collision, const int multTrk, const float centrality) { - if (cfgTVXinTRD) { - if (collision.alias_bit(kTVXinTRD)) { - // TRD triggered - return false; - } - registry.fill(HIST("hEventCount"), kTVXINTRD); - } if (cfgNoTimeFrameBorder) { if (!collision.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) { // reject collisions close to Time Frame borders @@ -566,7 +560,7 @@ struct FlowGfwTask { } if (cfgEvSelkIsGoodITSLayersAll) { if (cfgEvSelkIsGoodITSLayersAll && !collision.selection_bit(o2::aod::evsel::kIsGoodITSLayersAll)) { - // no other collisions in this Readout Frame with per-collision multiplicity above threshold + // removes dead staves of ITS return false; } registry.fill(HIST("hEventCount"), kISGOODITSLAYERSALL); @@ -650,7 +644,7 @@ struct FlowGfwTask { } // Apply process filters - Filter collisionFilter = nabs(aod::collision::posZ) < cfgCutVertex; + Filter collisionFilter = nabs(aod::collision::posZ) < cfgCutVertex && (aod::cent::centFT0C > cfgMinCentFT0C) && (aod::cent::centFT0C < cfgMaxCentFT0C); Filter trackFilter = (nabs(aod::track::eta) < cfgCutEta) && (aod::track::pt > cfgCutPtMin) && (aod::track::pt < cfgCutPtMax) && ((requireGlobalTrackInFilter()) || (aod::track::isGlobalTrackSDD == (uint8_t) true)) && (aod::track::tpcChi2NCl < cfgCutChi2prTPCcls) && (nabs(aod::track::dcaZ) < cfgCutDCAz) && (nabs(aod::track::dcaXY) < cfgCutDCAxy); using Colls = soa::Filtered>; // collisions filter @@ -668,6 +662,8 @@ struct FlowGfwTask { if (nTotal < 1) return; + const auto centrality = collision.centFT0C(); + // fill event QA before cuts registry.fill(HIST("BeforeCut_globalTracks_centT0C"), collision.centFT0C(), tracks.size()); registry.fill(HIST("BeforeCut_PVTracks_centT0C"), collision.centFT0C(), collision.multNTracksPV()); @@ -680,8 +676,6 @@ struct FlowGfwTask { registry.fill(HIST("BeforeCut_multFT0M_centFT0M"), collision.centFT0M(), collision.multFT0M()); registry.fill(HIST("hEventCount"), kSEL8); - const auto centrality = collision.centFT0C(); - if (cfgOccupancy) { int occupancy = collision.trackOccupancyInTimeRange(); if (occupancy < cfgCutOccupancyLow || occupancy > cfgCutOccupancyHigh) @@ -693,33 +687,6 @@ struct FlowGfwTask { return; } - if (centrality < 0 || centrality >= 70.) - return; - - float vtxz = collision.posZ(); - float lRandom = fRndm->Rndm(); - registry.fill(HIST("hVtxZ"), vtxz); - registry.fill(HIST("hMult"), nTotal); - registry.fill(HIST("hCent"), centrality); - registry.fill(HIST("cent_vs_Nch"), centrality, nTotal); - - fGFW->Clear(); - - auto bc = collision.bc_as(); - loadCorrections(bc.timestamp()); - registry.fill(HIST("hEventCount"), kCENTRALITY); - - // fill event QA after cuts - registry.fill(HIST("globalTracks_centT0C_Aft"), collision.centFT0C(), tracks.size()); - registry.fill(HIST("PVTracks_centT0C_Aft"), collision.centFT0C(), collision.multNTracksPV()); - registry.fill(HIST("globalTracks_PVTracks_Aft"), collision.multNTracksPV(), tracks.size()); - registry.fill(HIST("globalTracks_multT0A_Aft"), collision.multFT0A(), tracks.size()); - registry.fill(HIST("globalTracks_multV0A_Aft"), collision.multFV0A(), tracks.size()); - registry.fill(HIST("multV0A_multT0A_Aft"), collision.multFT0A(), collision.multFV0A()); - registry.fill(HIST("multT0C_centT0C_Aft"), collision.centFT0C(), collision.multFT0C()); - registry.fill(HIST("multT0A_centT0A_Aft"), collision.centFT0A(), collision.multFT0A()); - registry.fill(HIST("multFT0M_centFT0M_Aft"), collision.centFT0M(), collision.multFT0M()); - const auto& foundBC = collision.foundBC_as(); if (foundBC.has_zdc()) { registry.fill(HIST("hEventCounterForZDC"), 1); @@ -727,13 +694,13 @@ struct FlowGfwTask { // FT0 amplitude to use in fine binning double ft0aAmp = 0; double ft0cAmp = 0; + double ft0mAmp = 0; - if (collision.has_foundFT0()) { - auto ft0 = collision.foundFT0(); - for (const auto& amplitude : ft0.amplitudeA()) { + if (foundBC.has_ft0()) { + for (const auto& amplitude : foundBC.ft0().amplitudeA()) { ft0aAmp += amplitude; } - for (const auto& amplitude : ft0.amplitudeC()) { + for (const auto& amplitude : foundBC.ft0().amplitudeC()) { ft0cAmp += amplitude; } } else { @@ -743,7 +710,7 @@ struct FlowGfwTask { registry.fill(HIST("FT0AAmp"), ft0aAmp); registry.fill(HIST("FT0CAmp"), ft0cAmp); - double ft0mAmp = ft0aAmp + ft0cAmp; + ft0mAmp = ft0aAmp + ft0cAmp; registry.fill(HIST("FT0MAmp"), ft0mAmp); // ZDC amplitude to use in fine binning @@ -760,9 +727,12 @@ struct FlowGfwTask { registry.fill(HIST("ZPAcoll"), aZPA); registry.fill(HIST("ZPCcoll"), aZPC); + registry.fill(HIST("ZNvsFT0correl"), (ft0aAmp + ft0cAmp) / 100., aZNC + aZNA); + double aZDC = aZNC + aZNA + aZPA + aZPC; - registry.fill(HIST("ZNvsFT0correl"), (ft0aAmp + ft0aAmp) / 100., aZNC + aZNA); registry.fill(HIST("ZDCAmp"), aZDC); + registry.fill(HIST("ZNAmp"), aZNC + aZNA); + registry.fill(HIST("ZPAmp"), aZPA + aZPC); registry.fill(HIST("ZNvsZEMcoll"), aZEM1 + aZEM2, aZNA + aZNC); @@ -779,6 +749,30 @@ struct FlowGfwTask { } } // End of ZDC + float vtxz = collision.posZ(); + float lRandom = fRndm->Rndm(); + registry.fill(HIST("hVtxZ"), vtxz); + registry.fill(HIST("hMult"), nTotal); + registry.fill(HIST("hCent"), centrality); + registry.fill(HIST("cent_vs_Nch"), centrality, nTotal); + + fGFW->Clear(); + + auto bc = collision.bc_as(); + loadCorrections(bc.timestamp()); + registry.fill(HIST("hEventCount"), kCENTRALITY); + + // fill event QA after cuts + registry.fill(HIST("globalTracks_centT0C_Aft"), collision.centFT0C(), tracks.size()); + registry.fill(HIST("PVTracks_centT0C_Aft"), collision.centFT0C(), collision.multNTracksPV()); + registry.fill(HIST("globalTracks_PVTracks_Aft"), collision.multNTracksPV(), tracks.size()); + registry.fill(HIST("globalTracks_multT0A_Aft"), collision.multFT0A(), tracks.size()); + registry.fill(HIST("globalTracks_multV0A_Aft"), collision.multFV0A(), tracks.size()); + registry.fill(HIST("multV0A_multT0A_Aft"), collision.multFT0A(), collision.multFV0A()); + registry.fill(HIST("multT0C_centT0C_Aft"), collision.centFT0C(), collision.multFT0C()); + registry.fill(HIST("multT0A_centT0A_Aft"), collision.centFT0A(), collision.multFT0A()); + registry.fill(HIST("multFT0M_centFT0M_Aft"), collision.centFT0M(), collision.multFT0M()); + // track weights float weff = 1, wacc = 1; int magnetfield = 0; @@ -900,7 +894,7 @@ struct FlowGfwTask { } } // End of process - PROCESS_SWITCH(FlowGfwTask, processData, "Process analysis for Run 3 data", false); + PROCESS_SWITCH(FlowGfwTask, processData, "Process analysis for Run 3 data", true); // Filter the Reconstructed tracks Filter mytrackFilter = (nabs(aod::track::eta) < cfgCutEta) && (aod::track::pt > cfgCutPtMin) && (aod::track::pt < cfgCutPtMax) && (nabs(aod::track::dcaXY) < cfgCutDCAxy); From 7a51f813d63a9c75dede3dfad47ba35e15026ce2 Mon Sep 17 00:00:00 2001 From: SCHOTTER Romain <47983209+romainschotter@users.noreply.github.com> Date: Thu, 6 Feb 2025 04:58:06 +0100 Subject: [PATCH 10/30] [PWGLF] Add ctpRateFetcher service (#9780) --- PWGLF/Tasks/Strangeness/CMakeLists.txt | 2 +- .../derivedlambdakzeroanalysis.cxx | 45 +++++++++++++++++-- 2 files changed, 43 insertions(+), 4 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/CMakeLists.txt b/PWGLF/Tasks/Strangeness/CMakeLists.txt index 932448ce0e9..b10786a302b 100644 --- a/PWGLF/Tasks/Strangeness/CMakeLists.txt +++ b/PWGLF/Tasks/Strangeness/CMakeLists.txt @@ -16,7 +16,7 @@ o2physics_add_dpl_workflow(hyperon-reco-test o2physics_add_dpl_workflow(derivedlambdakzeroanalysis SOURCES derivedlambdakzeroanalysis.cxx - PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2Physics::MLCore + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2Physics::MLCore O2Physics::AnalysisCCDB COMPONENT_NAME Analysis) o2physics_add_dpl_workflow(lambdakzeroanalysis-mc diff --git a/PWGLF/Tasks/Strangeness/derivedlambdakzeroanalysis.cxx b/PWGLF/Tasks/Strangeness/derivedlambdakzeroanalysis.cxx index f3535c45f05..048ded5722f 100644 --- a/PWGLF/Tasks/Strangeness/derivedlambdakzeroanalysis.cxx +++ b/PWGLF/Tasks/Strangeness/derivedlambdakzeroanalysis.cxx @@ -42,6 +42,7 @@ #include "CommonConstants/MathConstants.h" #include "CommonConstants/PhysicsConstants.h" #include "Common/Core/trackUtilities.h" +#include "Common/CCDB/ctpRateFetcher.h" #include "PWGLF/DataModel/LFStrangenessTables.h" #include "PWGLF/DataModel/LFStrangenessMLTables.h" #include "PWGLF/DataModel/LFStrangenessPIDTables.h" @@ -80,6 +81,7 @@ struct derivedlambdakzeroanalysis { Configurable calculateFeeddownMatrix{"calculateFeeddownMatrix", true, "fill feeddown matrix if MC"}; Configurable doPPAnalysis{"doPPAnalysis", false, "if in pp, set to true"}; + Configurable irSource{"irSource", "T0VTX", "Estimator of the interaction rate (Recommended: pp --> T0VTX, Pb-Pb --> ZNC hadronic)"}; struct : ConfigurableGroup { Configurable requireSel8{"requireSel8", true, "require sel8 event selection"}; @@ -108,6 +110,9 @@ struct derivedlambdakzeroanalysis { // fast check on occupancy Configurable minOccupancy{"minOccupancy", -1, "minimum occupancy from neighbouring collisions"}; Configurable maxOccupancy{"maxOccupancy", -1, "maximum occupancy from neighbouring collisions"}; + // fast check on interaction rate + Configurable minIR{"minIR", -1, "minimum IR collisions"}; + Configurable maxIR{"maxIR", -1, "maximum IR collisions"}; } eventSelections; struct : ConfigurableGroup { @@ -208,6 +213,8 @@ struct derivedlambdakzeroanalysis { } ccdbConfigurations; o2::ccdb::CcdbApi ccdbApi; + Service ccdb; + ctpRateFetcher rateFetcher; int mRunNumber; std::map metadata; @@ -221,6 +228,7 @@ struct derivedlambdakzeroanalysis { ConfigurableAxis axisLambdaMass{"axisLambdaMass", {200, 1.101f, 1.131f}, ""}; ConfigurableAxis axisCentrality{"axisCentrality", {VARIABLE_WIDTH, 0.0f, 5.0f, 10.0f, 20.0f, 30.0f, 40.0f, 50.0f, 60.0f, 70.0f, 80.0f, 90.0f}, "Centrality"}; ConfigurableAxis axisNch{"axisNch", {500, 0.0f, +5000.0f}, "Number of charged particles"}; + ConfigurableAxis axisIRBinning{"axisIRBinning", {500, 0, 50}, "Binning for the interaction rate (kHz)"}; ConfigurableAxis axisRawCentrality{"axisRawCentrality", {VARIABLE_WIDTH, 0.000f, 52.320f, 75.400f, 95.719f, 115.364f, 135.211f, 155.791f, 177.504f, 200.686f, 225.641f, 252.645f, 281.906f, 313.850f, 348.302f, 385.732f, 426.307f, 470.146f, 517.555f, 568.899f, 624.177f, 684.021f, 748.734f, 818.078f, 892.577f, 973.087f, 1058.789f, 1150.915f, 1249.319f, 1354.279f, 1465.979f, 1584.790f, 1710.778f, 1844.863f, 1985.746f, 2134.643f, 2291.610f, 2456.943f, 2630.653f, 2813.959f, 3006.631f, 3207.229f, 3417.641f, 3637.318f, 3865.785f, 4104.997f, 4354.938f, 4615.786f, 4885.335f, 5166.555f, 5458.021f, 5762.584f, 6077.881f, 6406.834f, 6746.435f, 7097.958f, 7462.579f, 7839.165f, 8231.629f, 8635.640f, 9052.000f, 9484.268f, 9929.111f, 10389.350f, 10862.059f, 11352.185f, 11856.823f, 12380.371f, 12920.401f, 13476.971f, 14053.087f, 14646.190f, 15258.426f, 15890.617f, 16544.433f, 17218.024f, 17913.465f, 18631.374f, 19374.983f, 20136.700f, 20927.783f, 21746.796f, 22590.880f, 23465.734f, 24372.274f, 25314.351f, 26290.488f, 27300.899f, 28347.512f, 29436.133f, 30567.840f, 31746.818f, 32982.664f, 34276.329f, 35624.859f, 37042.588f, 38546.609f, 40139.742f, 41837.980f, 43679.429f, 45892.130f, 400000.000f}, "raw centrality signal"}; // for QA @@ -334,6 +342,11 @@ struct derivedlambdakzeroanalysis { void init(InitContext const&) { + // setting CCDB service + ccdb->setURL(ccdbConfigurations.ccdburl); + ccdb->setCaching(true); + ccdb->setFatalWhenNull(false); + // initialise bit masks maskTopological = (uint64_t(1) << selCosPA) | (uint64_t(1) << selRadius) | (uint64_t(1) << selDCANegToPV) | (uint64_t(1) << selDCAPosToPV) | (uint64_t(1) << selDCAV0Dau) | (uint64_t(1) << selRadiusMax); maskTopoNoV0Radius = (uint64_t(1) << selCosPA) | (uint64_t(1) << selDCANegToPV) | (uint64_t(1) << selDCAPosToPV) | (uint64_t(1) << selDCAV0Dau) | (uint64_t(1) << selRadiusMax); @@ -425,6 +438,8 @@ struct derivedlambdakzeroanalysis { histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(17, "Below min occup."); histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(18, "Above max occup."); } + histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(19, "Below min IR"); + histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(20, "Above max IR"); histos.add("hEventCentrality", "hEventCentrality", kTH1F, {{101, 0.0f, 101.0f}}); histos.add("hCentralityVsNch", "hCentralityVsNch", kTH2F, {{101, 0.0f, 101.0f}, axisNch}); @@ -443,6 +458,9 @@ struct derivedlambdakzeroanalysis { histos.add("hSelGapSide", "Selected gap side; Entries", kTH1F, {axisSelGap}); histos.add("hEventCentralityVsSelGapSide", ";Centrality (%); Selected gap side", kTH2F, {{101, 0.0f, 101.0f}, axisSelGap}); + histos.add("hInteractionRate", "hInteractionRate", kTH1F, {axisIRBinning}); + histos.add("hCentralityVsInteractionRate", "hCentralityVsInteractionRate", kTH2F, {{101, 0.0f, 101.0f}, axisIRBinning}); + // for QA and test purposes auto hRawCentrality = histos.add("hRawCentrality", "hRawCentrality", kTH1F, {axisRawCentrality}); @@ -1575,13 +1593,26 @@ struct derivedlambdakzeroanalysis { histos.fill(HIST("hEventSelection"), 17 /* Above max occupancy */); } + double interactionRate = rateFetcher.fetch(ccdb.service, collision.timestamp(), collision.runNumber(), irSource) * 1.e-3; + if (eventSelections.minIR >= 0 && interactionRate < eventSelections.minIR) { + return false; + } + if (fillHists) + histos.fill(HIST("hEventSelection"), 18 /* Below min IR */); + + if (eventSelections.maxIR >= 0 && interactionRate > eventSelections.maxIR) { + return false; + } + if (fillHists) + histos.fill(HIST("hEventSelection"), 19 /* Above max IR */); + return true; } // ______________________________________________________ // Simulated processing // Return the list of indices to the recoed collision associated to a given MC collision. - std::vector getListOfRecoCollIndices(soa::Join const& mcCollisions, soa::Join const& collisions) + std::vector getListOfRecoCollIndices(soa::Join const& mcCollisions, soa::Join const& collisions) { std::vector listBestCollisionIdx(mcCollisions.size()); for (auto const& mcCollision : mcCollisions) { @@ -1611,7 +1642,7 @@ struct derivedlambdakzeroanalysis { // ______________________________________________________ // Simulated processing // Fill generated event information (for event loss/splitting estimation) - void fillGeneratedEventProperties(soa::Join const& mcCollisions, soa::Join const& collisions) + void fillGeneratedEventProperties(soa::Join const& mcCollisions, soa::Join const& collisions) { std::vector listBestCollisionIdx(mcCollisions.size()); for (auto const& mcCollision : mcCollisions) { @@ -1690,6 +1721,7 @@ struct derivedlambdakzeroanalysis { centrality = hRawCentrality->GetBinContent(hRawCentrality->FindBin(doPPAnalysis ? collision.multFT0A() + collision.multFT0C() : collision.multFT0C())); } float collisionOccupancy = eventSelections.useFT0CbasedOccupancy ? collision.ft0cOccupancyInTimeRange() : collision.trackOccupancyInTimeRange(); + double interactionRate = rateFetcher.fetch(ccdb.service, collision.timestamp(), collision.runNumber(), irSource) * 1.e-3; // gap side int gapSide = collision.gapSide(); @@ -1713,6 +1745,9 @@ struct derivedlambdakzeroanalysis { histos.fill(HIST("hEventOccupancy"), collisionOccupancy); histos.fill(HIST("hCentralityVsOccupancy"), centrality, collisionOccupancy); + histos.fill(HIST("hInteractionRate"), interactionRate); + histos.fill(HIST("hCentralityVsInteractionRate"), centrality, interactionRate); + // __________________________________________ // perform main analysis int nK0Shorts = 0; @@ -1770,6 +1805,7 @@ struct derivedlambdakzeroanalysis { centrality = hRawCentrality->GetBinContent(hRawCentrality->FindBin(doPPAnalysis ? collision.multFT0A() + collision.multFT0C() : collision.multFT0C())); } float collisionOccupancy = eventSelections.useFT0CbasedOccupancy ? collision.ft0cOccupancyInTimeRange() : collision.trackOccupancyInTimeRange(); + double interactionRate = rateFetcher.fetch(ccdb.service, collision.timestamp(), collision.runNumber(), irSource) * 1.e-3; // gap side int gapSide = collision.gapSide(); @@ -1793,6 +1829,9 @@ struct derivedlambdakzeroanalysis { histos.fill(HIST("hEventOccupancy"), collisionOccupancy); histos.fill(HIST("hCentralityVsOccupancy"), centrality, collisionOccupancy); + histos.fill(HIST("hInteractionRate"), interactionRate); + histos.fill(HIST("hCentralityVsInteractionRate"), centrality, interactionRate); + // __________________________________________ // perform main analysis int nK0Shorts = 0; @@ -1863,7 +1902,7 @@ struct derivedlambdakzeroanalysis { // ______________________________________________________ // Simulated processing (subscribes to MC information too) - void processGenerated(soa::Join const& mcCollisions, soa::Join const& V0MCCores, soa::Join const& CascMCCores, soa::Join const& collisions) + void processGenerated(soa::Join const& mcCollisions, soa::Join const& V0MCCores, soa::Join const& CascMCCores, soa::Join const& collisions) { fillGeneratedEventProperties(mcCollisions, collisions); std::vector listBestCollisionIdx = getListOfRecoCollIndices(mcCollisions, collisions); From 1e12e464a33b025872aa00ecb9448caf062c085e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andrea=20Tavira=20Garc=C3=ADa?= <118979672+atavirag@users.noreply.github.com> Date: Thu, 6 Feb 2025 08:57:44 +0100 Subject: [PATCH 11/30] [PWGHF] Add ML variables in treeCreatorD0ToKPi (#9761) --- PWGHF/TableProducer/treeCreatorD0ToKPi.cxx | 158 ++++++++++++++++++--- 1 file changed, 142 insertions(+), 16 deletions(-) diff --git a/PWGHF/TableProducer/treeCreatorD0ToKPi.cxx b/PWGHF/TableProducer/treeCreatorD0ToKPi.cxx index bda9e624f1e..70277fc4d18 100644 --- a/PWGHF/TableProducer/treeCreatorD0ToKPi.cxx +++ b/PWGHF/TableProducer/treeCreatorD0ToKPi.cxx @@ -81,6 +81,12 @@ DECLARE_SOA_COLUMN(IsEventReject, isEventReject, int); DECLARE_SOA_COLUMN(RunNumber, runNumber, int); DECLARE_SOA_INDEX_COLUMN(McCollision, mcCollision); } // namespace full +namespace ml +{ +DECLARE_SOA_COLUMN(BdtOutputBkg, bdtOutputBkg, float); +DECLARE_SOA_COLUMN(BdtOutputPrompt, bdtOutputPrompt, float); +DECLARE_SOA_COLUMN(BdtOutputNonPrompt, bdtOutputNonPrompt, float); +} // namespace ml DECLARE_SOA_TABLE(HfCandD0Lites, "AOD", "HFCANDD0LITE", hf_cand::Chi2PCA, @@ -201,6 +207,11 @@ DECLARE_SOA_TABLE(HfCandD0FullPs, "AOD", "HFCANDD0FULLP", full::OriginMcGen, full::McParticleId); +DECLARE_SOA_TABLE(HfCandD0Mls, "AOD", "HFCANDD0ML", + ml::BdtOutputBkg, + ml::BdtOutputNonPrompt, + ml::BdtOutputPrompt); + } // namespace o2::aod /// Writes the full information in an output TTree @@ -209,6 +220,7 @@ struct HfTreeCreatorD0ToKPi { Produces rowCandidateFullEvents; Produces rowCandidateFullParticles; Produces rowCandidateLite; + Produces rowCandidateMl; Configurable fillCandidateLiteTable{"fillCandidateLiteTable", false, "Switch to fill lite table with candidate properties"}; // parameters for production of training samples @@ -219,7 +231,9 @@ struct HfTreeCreatorD0ToKPi { // using TracksWPid = soa::Join; using SelectedCandidatesMc = soa::Filtered>; + using SelectedCandidatesMcMl = soa::Filtered>; using SelectedCandidatesMcKf = soa::Filtered>; + using SelectedCandidatesMcKfMl = soa::Filtered>; using MatchedGenCandidatesMc = soa::Filtered>; Filter filterSelectCandidates = aod::hf_sel_candidate_d0::isSelD0 >= 1 || aod::hf_sel_candidate_d0::isSelD0bar >= 1; @@ -230,9 +244,17 @@ struct HfTreeCreatorD0ToKPi { Partition reconstructedCandSigKF = nabs(aod::hf_cand_2prong::flagMcMatchRec) == static_cast(BIT(aod::hf_cand_2prong::DecayType::D0ToPiK)); Partition reconstructedCandBkgKF = nabs(aod::hf_cand_2prong::flagMcMatchRec) != static_cast(BIT(aod::hf_cand_2prong::DecayType::D0ToPiK)); + Partition reconstructedCandSigMl = nabs(aod::hf_cand_2prong::flagMcMatchRec) == static_cast(BIT(aod::hf_cand_2prong::DecayType::D0ToPiK)); + Partition reconstructedCandBkgMl = nabs(aod::hf_cand_2prong::flagMcMatchRec) != static_cast(BIT(aod::hf_cand_2prong::DecayType::D0ToPiK)); + Partition reconstructedCandSigKFMl = nabs(aod::hf_cand_2prong::flagMcMatchRec) == static_cast(BIT(aod::hf_cand_2prong::DecayType::D0ToPiK)); + Partition reconstructedCandBkgKFMl = nabs(aod::hf_cand_2prong::flagMcMatchRec) != static_cast(BIT(aod::hf_cand_2prong::DecayType::D0ToPiK)); + void init(InitContext const&) { - std::array doprocess{doprocessDataWithDCAFitterN, doprocessDataWithKFParticle, doprocessMcWithDCAFitterOnlySig, doprocessMcWithDCAFitterOnlyBkg, doprocessMcWithDCAFitterAll, doprocessMcWithKFParticleOnlySig, doprocessMcWithKFParticleOnlyBkg, doprocessMcWithKFParticleAll}; + std::array doprocess{doprocessDataWithDCAFitterN, doprocessDataWithKFParticle, doprocessMcWithDCAFitterOnlySig, doprocessMcWithDCAFitterOnlyBkg, + doprocessMcWithDCAFitterAll, doprocessMcWithKFParticleOnlySig, doprocessMcWithKFParticleOnlyBkg, doprocessMcWithKFParticleAll, + doprocessDataWithDCAFitterNMl, doprocessDataWithKFParticleMl, doprocessMcWithDCAFitterOnlySigMl, doprocessMcWithDCAFitterOnlyBkgMl, + doprocessMcWithDCAFitterAllMl, doprocessMcWithKFParticleOnlySigMl, doprocessMcWithKFParticleOnlyBkgMl, doprocessMcWithKFParticleAllMl}; if (std::accumulate(doprocess.begin(), doprocess.end(), 0) != 1) { LOGP(fatal, "Only one process function can be enabled at a time."); } @@ -251,7 +273,7 @@ struct HfTreeCreatorD0ToKPi { runNumber); } - template + template auto fillTable(const T& candidate, int candFlag, double invMass, double cosThetaStar, double topoChi2, double ct, double y, double e, int8_t flagMc, int8_t origin) { @@ -356,9 +378,23 @@ struct HfTreeCreatorD0ToKPi { origin, candidate.globalIndex()); } + if constexpr (applyMl) { + if (candidate.isSelD0()) { + rowCandidateMl( + candidate.mlProbD0()[0], + candidate.mlProbD0()[1], + candidate.mlProbD0()[2]); + } + if (candidate.isSelD0bar()) { + rowCandidateMl( + candidate.mlProbD0bar()[0], + candidate.mlProbD0bar()[1], + candidate.mlProbD0bar()[2]); + } + } } - template + template void processData(aod::Collisions const& collisions, CandType const& candidates, aod::Tracks const&, aod::BCs const&) @@ -375,6 +411,9 @@ struct HfTreeCreatorD0ToKPi { } else { rowCandidateFull.reserve(candidates.size()); } + if constexpr (applyMl) { + rowCandidateMl.reserve(candidates.size()); + } for (const auto& candidate : candidates) { if (downSampleBkgFactor < 1.) { float pseudoRndm = candidate.ptProng0() * 1000. - static_cast(candidate.ptProng0() * 1000); @@ -396,10 +435,10 @@ struct HfTreeCreatorD0ToKPi { massD0bar = hfHelper.invMassD0barToKPi(candidate); } if (candidate.isSelD0()) { - fillTable(candidate, 0, massD0, hfHelper.cosThetaStarD0(candidate), topolChi2PerNdf, ctD, yD, eD, 0, 0); + fillTable(candidate, 0, massD0, hfHelper.cosThetaStarD0(candidate), topolChi2PerNdf, ctD, yD, eD, 0, 0); } if (candidate.isSelD0bar()) { - fillTable(candidate, 1, massD0bar, hfHelper.cosThetaStarD0bar(candidate), topolChi2PerNdf, ctD, yD, eD, 0, 0); + fillTable(candidate, 1, massD0bar, hfHelper.cosThetaStarD0bar(candidate), topolChi2PerNdf, ctD, yD, eD, 0, 0); } } } @@ -409,20 +448,38 @@ struct HfTreeCreatorD0ToKPi { aod::Tracks const& tracks, aod::BCs const& bcs) { - processData(collisions, candidates, tracks, bcs); + processData(collisions, candidates, tracks, bcs); } PROCESS_SWITCH(HfTreeCreatorD0ToKPi, processDataWithDCAFitterN, "Process data with DCAFitterN", true); + void processDataWithDCAFitterNMl(aod::Collisions const& collisions, + soa::Filtered> const& candidates, + aod::Tracks const& tracks, + aod::BCs const& bcs) + { + processData(collisions, candidates, tracks, bcs); + } + PROCESS_SWITCH(HfTreeCreatorD0ToKPi, processDataWithDCAFitterNMl, "Process data with DCAFitterN and ML", false); + void processDataWithKFParticle(aod::Collisions const& collisions, soa::Filtered> const& candidates, aod::Tracks const& tracks, aod::BCs const& bcs) { - processData(collisions, candidates, tracks, bcs); + processData(collisions, candidates, tracks, bcs); } PROCESS_SWITCH(HfTreeCreatorD0ToKPi, processDataWithKFParticle, "Process data with KFParticle", false); - template + void processDataWithKFParticleMl(aod::Collisions const& collisions, + soa::Filtered> const& candidates, + aod::Tracks const& tracks, + aod::BCs const& bcs) + { + processData(collisions, candidates, tracks, bcs); + } + PROCESS_SWITCH(HfTreeCreatorD0ToKPi, processDataWithKFParticleMl, "Process data with KFParticle and ML", false); + + template void processMc(aod::Collisions const& collisions, aod::McCollisions const&, CandType const& candidates, @@ -442,6 +499,9 @@ struct HfTreeCreatorD0ToKPi { } else { rowCandidateFull.reserve(candidates.size()); } + if constexpr (applyMl) { + rowCandidateMl.reserve(candidates.size()); + } for (const auto& candidate : candidates) { if constexpr (onlyBkg) { if (TESTBIT(std::abs(candidate.flagMcMatchRec()), aod::hf_cand_2prong::DecayType::D0ToPiK)) { @@ -473,10 +533,10 @@ struct HfTreeCreatorD0ToKPi { massD0bar = hfHelper.invMassD0barToKPi(candidate); } if (candidate.isSelD0()) { - fillTable(candidate, 0, massD0, hfHelper.cosThetaStarD0(candidate), topolChi2PerNdf, ctD, yD, eD, candidate.flagMcMatchRec(), candidate.originMcRec()); + fillTable(candidate, 0, massD0, hfHelper.cosThetaStarD0(candidate), topolChi2PerNdf, ctD, yD, eD, candidate.flagMcMatchRec(), candidate.originMcRec()); } if (candidate.isSelD0bar()) { - fillTable(candidate, 1, massD0bar, hfHelper.cosThetaStarD0bar(candidate), topolChi2PerNdf, ctD, yD, eD, candidate.flagMcMatchRec(), candidate.originMcRec()); + fillTable(candidate, 1, massD0bar, hfHelper.cosThetaStarD0bar(candidate), topolChi2PerNdf, ctD, yD, eD, candidate.flagMcMatchRec(), candidate.originMcRec()); } } @@ -504,10 +564,21 @@ struct HfTreeCreatorD0ToKPi { aod::Tracks const& tracks, aod::BCs const& bcs) { - processMc(collisions, mcCollisions, reconstructedCandSig, mcParticles, tracks, bcs); + processMc(collisions, mcCollisions, reconstructedCandSig, mcParticles, tracks, bcs); } PROCESS_SWITCH(HfTreeCreatorD0ToKPi, processMcWithDCAFitterOnlySig, "Process MC with DCAFitterN only for signals", false); + void processMcWithDCAFitterOnlySigMl(aod::Collisions const& collisions, + aod::McCollisions const& mcCollisions, + SelectedCandidatesMcMl const&, + MatchedGenCandidatesMc const& mcParticles, + aod::Tracks const& tracks, + aod::BCs const& bcs) + { + processMc(collisions, mcCollisions, reconstructedCandSigMl, mcParticles, tracks, bcs); + } + PROCESS_SWITCH(HfTreeCreatorD0ToKPi, processMcWithDCAFitterOnlySigMl, "Process MC with DCAFitterN only for signals and ML", false); + void processMcWithDCAFitterOnlyBkg(aod::Collisions const& collisions, aod::McCollisions const& mcCollisions, SelectedCandidatesMc const&, @@ -515,10 +586,21 @@ struct HfTreeCreatorD0ToKPi { aod::Tracks const& tracks, aod::BCs const& bcs) { - processMc(collisions, mcCollisions, reconstructedCandBkg, mcParticles, tracks, bcs); + processMc(collisions, mcCollisions, reconstructedCandBkg, mcParticles, tracks, bcs); } PROCESS_SWITCH(HfTreeCreatorD0ToKPi, processMcWithDCAFitterOnlyBkg, "Process MC with DCAFitterN only for background", false); + void processMcWithDCAFitterOnlyBkgMl(aod::Collisions const& collisions, + aod::McCollisions const& mcCollisions, + SelectedCandidatesMcMl const&, + MatchedGenCandidatesMc const& mcParticles, + aod::Tracks const& tracks, + aod::BCs const& bcs) + { + processMc(collisions, mcCollisions, reconstructedCandBkgMl, mcParticles, tracks, bcs); + } + PROCESS_SWITCH(HfTreeCreatorD0ToKPi, processMcWithDCAFitterOnlyBkgMl, "Process MC with DCAFitterN only for background with ML", false); + void processMcWithDCAFitterAll(aod::Collisions const& collisions, aod::McCollisions const& mcCollisions, SelectedCandidatesMc const& candidates, @@ -526,10 +608,21 @@ struct HfTreeCreatorD0ToKPi { aod::Tracks const& tracks, aod::BCs const& bcs) { - processMc(collisions, mcCollisions, candidates, mcParticles, tracks, bcs); + processMc(collisions, mcCollisions, candidates, mcParticles, tracks, bcs); } PROCESS_SWITCH(HfTreeCreatorD0ToKPi, processMcWithDCAFitterAll, "Process MC with DCAFitterN", false); + void processMcWithDCAFitterAllMl(aod::Collisions const& collisions, + aod::McCollisions const& mcCollisions, + SelectedCandidatesMcMl const& candidates, + MatchedGenCandidatesMc const& mcParticles, + aod::Tracks const& tracks, + aod::BCs const& bcs) + { + processMc(collisions, mcCollisions, candidates, mcParticles, tracks, bcs); + } + PROCESS_SWITCH(HfTreeCreatorD0ToKPi, processMcWithDCAFitterAllMl, "Process MC with DCAFitterN with ML", false); + void processMcWithKFParticleOnlySig(aod::Collisions const& collisions, aod::McCollisions const& mcCollisions, SelectedCandidatesMcKf const&, @@ -537,10 +630,21 @@ struct HfTreeCreatorD0ToKPi { aod::Tracks const& tracks, aod::BCs const& bcs) { - processMc(collisions, mcCollisions, reconstructedCandSigKF, mcParticles, tracks, bcs); + processMc(collisions, mcCollisions, reconstructedCandSigKF, mcParticles, tracks, bcs); } PROCESS_SWITCH(HfTreeCreatorD0ToKPi, processMcWithKFParticleOnlySig, "Process MC with KFParticle only for signals", false); + void processMcWithKFParticleOnlySigMl(aod::Collisions const& collisions, + aod::McCollisions const& mcCollisions, + SelectedCandidatesMcKfMl const&, + MatchedGenCandidatesMc const& mcParticles, + aod::Tracks const& tracks, + aod::BCs const& bcs) + { + processMc(collisions, mcCollisions, reconstructedCandSigKFMl, mcParticles, tracks, bcs); + } + PROCESS_SWITCH(HfTreeCreatorD0ToKPi, processMcWithKFParticleOnlySigMl, "Process MC with KFParticle only for signals with ML", false); + void processMcWithKFParticleOnlyBkg(aod::Collisions const& collisions, aod::McCollisions const& mcCollisions, SelectedCandidatesMcKf const&, @@ -548,10 +652,21 @@ struct HfTreeCreatorD0ToKPi { aod::Tracks const& tracks, aod::BCs const& bcs) { - processMc(collisions, mcCollisions, reconstructedCandBkgKF, mcParticles, tracks, bcs); + processMc(collisions, mcCollisions, reconstructedCandBkgKF, mcParticles, tracks, bcs); } PROCESS_SWITCH(HfTreeCreatorD0ToKPi, processMcWithKFParticleOnlyBkg, "Process MC with KFParticle only for background", false); + void processMcWithKFParticleOnlyBkgMl(aod::Collisions const& collisions, + aod::McCollisions const& mcCollisions, + SelectedCandidatesMcKfMl const&, + MatchedGenCandidatesMc const& mcParticles, + aod::Tracks const& tracks, + aod::BCs const& bcs) + { + processMc(collisions, mcCollisions, reconstructedCandBkgKFMl, mcParticles, tracks, bcs); + } + PROCESS_SWITCH(HfTreeCreatorD0ToKPi, processMcWithKFParticleOnlyBkgMl, "Process MC with KFParticle only for background with ML", false); + void processMcWithKFParticleAll(aod::Collisions const& collisions, aod::McCollisions const& mcCollisions, SelectedCandidatesMcKf const& candidates, @@ -559,9 +674,20 @@ struct HfTreeCreatorD0ToKPi { aod::Tracks const& tracks, aod::BCs const& bcs) { - processMc(collisions, mcCollisions, candidates, mcParticles, tracks, bcs); + processMc(collisions, mcCollisions, candidates, mcParticles, tracks, bcs); } PROCESS_SWITCH(HfTreeCreatorD0ToKPi, processMcWithKFParticleAll, "Process MC with KFParticle", false); + + void processMcWithKFParticleAllMl(aod::Collisions const& collisions, + aod::McCollisions const& mcCollisions, + SelectedCandidatesMcKfMl const& candidates, + MatchedGenCandidatesMc const& mcParticles, + aod::Tracks const& tracks, + aod::BCs const& bcs) + { + processMc(collisions, mcCollisions, candidates, mcParticles, tracks, bcs); + } + PROCESS_SWITCH(HfTreeCreatorD0ToKPi, processMcWithKFParticleAllMl, "Process MC with KFParticle with ML", false); }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) From bea3abfbc136fa64066fb780a8748d5b4b17afb7 Mon Sep 17 00:00:00 2001 From: prottayCMT <61418725+prottayCMT@users.noreply.github.com> Date: Thu, 6 Feb 2025 09:13:36 +0100 Subject: [PATCH 12/30] [PWGLF] updated event average to particle average (#9772) Co-authored-by: Prottay Das --- PWGLF/Tasks/Strangeness/lambdapolsp.cxx | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/PWGLF/Tasks/Strangeness/lambdapolsp.cxx b/PWGLF/Tasks/Strangeness/lambdapolsp.cxx index d7eee248764..7a1a84582ab 100644 --- a/PWGLF/Tasks/Strangeness/lambdapolsp.cxx +++ b/PWGLF/Tasks/Strangeness/lambdapolsp.cxx @@ -265,6 +265,15 @@ struct lambdapolsp { histos.add("hcentQxZDCC", "hcentQxZDCC", kTH2F, {{centAxis}, {qxZDCAxis}}); histos.add("hcentQyZDCC", "hcentQyZDCC", kTH2F, {{centAxis}, {qxZDCAxis}});*/ + histos.add("hSparseLambdaCosPsiA", "hSparseLambdaCosPsiA", HistType::kTHnSparseF, {thnAxisInvMass, configthnAxispT, configetaAxis, configthnAxisPol, configcentAxis}, true); + histos.add("hSparseLambdaSinPsiA", "hSparseLambdaSinPsiA", HistType::kTHnSparseF, {thnAxisInvMass, configthnAxispT, configetaAxis, configthnAxisPol, configcentAxis}, true); + histos.add("hSparseLambdaCosPsiC", "hSparseLambdaCosPsiC", HistType::kTHnSparseF, {thnAxisInvMass, configthnAxispT, configetaAxis, configthnAxisPol, configcentAxis}, true); + histos.add("hSparseLambdaSinPsiC", "hSparseLambdaSinPsiC", HistType::kTHnSparseF, {thnAxisInvMass, configthnAxispT, configetaAxis, configthnAxisPol, configcentAxis}, true); + histos.add("hSparseAntiLambdaCosPsiA", "hSparseAntiLambdaCosPsiA", HistType::kTHnSparseF, {thnAxisInvMass, configthnAxispT, configetaAxis, configthnAxisPol, configcentAxis}, true); + histos.add("hSparseAntiLambdaSinPsiA", "hSparseAntiLambdaSinPsiA", HistType::kTHnSparseF, {thnAxisInvMass, configthnAxispT, configetaAxis, configthnAxisPol, configcentAxis}, true); + histos.add("hSparseAntiLambdaCosPsiC", "hSparseAntiLambdaCosPsiC", HistType::kTHnSparseF, {thnAxisInvMass, configthnAxispT, configetaAxis, configthnAxisPol, configcentAxis}, true); + histos.add("hSparseAntiLambdaSinPsiC", "hSparseAntiLambdaSinPsiC", HistType::kTHnSparseF, {thnAxisInvMass, configthnAxispT, configetaAxis, configthnAxisPol, configcentAxis}, true); + histos.add("hSparseLambdaPolA", "hSparseLambdaPolA", HistType::kTHnSparseF, {thnAxisInvMass, configthnAxispT, configetaAxis, configthnAxisPol, configcentAxis}, true); histos.add("hSparseLambdaPolC", "hSparseLambdaPolC", HistType::kTHnSparseF, {thnAxisInvMass, configthnAxispT, configetaAxis, configthnAxisPol, configcentAxis}, true); histos.add("hSparseAntiLambdaPolA", "hSparseAntiLambdaPolA", HistType::kTHnSparseF, {thnAxisInvMass, configthnAxispT, configetaAxis, configthnAxisPol, configcentAxis}, true); @@ -473,6 +482,11 @@ struct lambdapolsp { // Fill histograms using constructed names if (tag2) { + histos.fill(HIST("hSparseAntiLambdaCosPsiA"), candmass, candpt, candeta, (TMath::Cos(GetPhiInRange(psiZDCA))), centrality); + histos.fill(HIST("hSparseAntiLambdaCosPsiC"), candmass, candpt, candeta, (TMath::Cos(GetPhiInRange(psiZDCC))), centrality); + histos.fill(HIST("hSparseAntiLambdaSinPsiA"), candmass, candpt, candeta, (TMath::Sin(GetPhiInRange(psiZDCA))), centrality); + histos.fill(HIST("hSparseAntiLambdaSinPsiC"), candmass, candpt, candeta, (TMath::Sin(GetPhiInRange(psiZDCC))), centrality); + histos.fill(HIST("hSparseAntiLambdaPolA"), candmass, candpt, candeta, PolA, centrality); histos.fill(HIST("hSparseAntiLambdaPolC"), candmass, candpt, candeta, PolC, centrality); histos.fill(HIST("hSparseAntiLambda_corr1a"), candmass, candpt, candeta, sinPhiStar, centrality); @@ -482,6 +496,11 @@ struct lambdapolsp { histos.fill(HIST("hSparseAntiLambda_corr2b"), candmass, candpt, candeta, sinThetaStarcosphiphiStar, centrality); } if (tag1) { + histos.fill(HIST("hSparseLambdaCosPsiA"), candmass, candpt, candeta, (TMath::Cos(GetPhiInRange(psiZDCA))), centrality); + histos.fill(HIST("hSparseLambdaCosPsiC"), candmass, candpt, candeta, (TMath::Cos(GetPhiInRange(psiZDCC))), centrality); + histos.fill(HIST("hSparseLambdaSinPsiA"), candmass, candpt, candeta, (TMath::Sin(GetPhiInRange(psiZDCA))), centrality); + histos.fill(HIST("hSparseLambdaSinPsiC"), candmass, candpt, candeta, (TMath::Sin(GetPhiInRange(psiZDCC))), centrality); + histos.fill(HIST("hSparseLambdaPolA"), candmass, candpt, candeta, PolA, centrality); histos.fill(HIST("hSparseLambdaPolC"), candmass, candpt, candeta, PolC, centrality); histos.fill(HIST("hSparseLambda_corr1a"), candmass, candpt, candeta, sinPhiStar, centrality); From a0d7b397fa540f3a6e616605c9a8e8737ff3528c Mon Sep 17 00:00:00 2001 From: Daiki Sekihata Date: Thu, 6 Feb 2025 20:31:32 +0900 Subject: [PATCH 13/30] [PWGEM/PhotonMeson] std::abs and std::fabs for PCM (#9785) --- .../TableProducer/photonconversionbuilder.cxx | 30 +++++-------------- PWGEM/PhotonMeson/Tasks/pcmQC.cxx | 4 +-- PWGEM/PhotonMeson/Tasks/pcmQCMC.cxx | 4 +-- PWGEM/PhotonMeson/Utils/PCMUtilities.h | 28 ++++++++--------- 4 files changed, 26 insertions(+), 40 deletions(-) diff --git a/PWGEM/PhotonMeson/TableProducer/photonconversionbuilder.cxx b/PWGEM/PhotonMeson/TableProducer/photonconversionbuilder.cxx index 9060bc9c9c2..836a6deccf0 100644 --- a/PWGEM/PhotonMeson/TableProducer/photonconversionbuilder.cxx +++ b/PWGEM/PhotonMeson/TableProducer/photonconversionbuilder.cxx @@ -102,8 +102,6 @@ struct PhotonConversionBuilder { Configurable max_frac_shared_clusters_tpc{"max_frac_shared_clusters_tpc", 999.f, "max fraction of shared clusters in TPC"}; Configurable dcanegtopv{"dcanegtopv", 0.1, "DCA Neg To PV"}; Configurable dcapostopv{"dcapostopv", 0.1, "DCA Pos To PV"}; - Configurable min_pt_leg_at_sv{"min_pt_leg_at_sv", 0.0, "min pT for v0 legs at SV"}; // this is obsolete. - Configurable max_mean_its_cluster_size{"max_mean_its_cluster_size", 16.f, "max. x cos(lambda) for ITSonly tracks"}; // this is to suppress random combination for V0s with ITSonly tracks. default 3 + 1 for skimming. Configurable maxX{"maxX", 83.1, "max X for track IU"}; Configurable min_pt_trackiu{"min_pt_trackiu", 0.05, "min pT for trackiu"}; // this comes from online processing. pT of track seed is above 50 MeV/c in B = 0.5 T, 20 MeV/c in B = 0.2 T. @@ -115,6 +113,7 @@ struct PhotonConversionBuilder { Configurable max_dcav0dau_itsibss{"max_dcav0dau_itsibss", 1.0, "max distance btween 2 legs to V0s with ITS hits on ITSib SS"}; Configurable max_dcav0dau_tpc_inner_fc{"max_dcav0dau_tpc_inner_fc", 1.5, "max distance btween 2 legs to V0s with ITS hits on TPC inner FC"}; Configurable min_v0radius{"min_v0radius", 1.0, "min v0 radius"}; + Configurable max_v0radius{"max_v0radius", 90.0, "max v0 radius"}; Configurable margin_r_its{"margin_r_its", 3.0, "margin for r cut in cm"}; Configurable margin_r_tpc{"margin_r_tpc", 7.0, "margin for r cut in cm"}; Configurable margin_r_itstpc_tpc{"margin_r_itstpc_tpc", 7.0, "margin for r cut in cm"}; @@ -320,21 +319,6 @@ struct PhotonConversionBuilder { return false; } } - - if (isITSonlyTrack(track)) { - uint32_t itsClusterSizes = track.itsClusterSizes(); - int total_cluster_size = 0, nl = 0; - for (unsigned int layer = 0; layer < 7; layer++) { - int cluster_size_per_layer = (itsClusterSizes >> (layer * 4)) & 0xf; - if (cluster_size_per_layer > 0) { - nl++; - } - total_cluster_size += cluster_size_per_layer; - } - if (static_cast(total_cluster_size) / static_cast(nl) * std::cos(std::atan(track.tgl())) > max_mean_its_cluster_size) { - return false; - } - } } return true; @@ -376,7 +360,7 @@ struct PhotonConversionBuilder { } template - void fillTrackTable(TTrack const& track, TShiftedTrack const& shiftedtrack, TKFParticle const& kfp, float dcaXY, float dcaZ) + void fillTrackTable(TTrack const& track, TShiftedTrack const& shiftedtrack, TKFParticle const& kfp, const float dcaXY, const float dcaZ) { v0legs(track.collisionId(), track.globalIndex(), track.sign(), kfp.GetPx(), kfp.GetPy(), kfp.GetPz(), dcaXY, dcaZ, @@ -422,6 +406,11 @@ struct PhotonConversionBuilder { // LOGF(info, "v0.collisionId() = %d , v0.posTrackId() = %d , v0.negTrackId() = %d", v0.collisionId(), v0.posTrackId(), v0.negTrackId()); + // if(isTPConlyTrack(ele)){ + // // LOGF(info, "TPConly: ele.globalIndex() = %d, ele.x() = %f, ele.y() = %f, ele.z() = %f, ele.tgl() = %f, ele.alpha() = %f, ele.snp() = %f, ele.signed1Pt() = %f", ele.globalIndex(), ele.x(), ele.y(), ele.z(), ele.tgl(), ele.alpha(), ele.snp(), ele.signed1Pt()); + // // LOGF(info, "TPConly: ele.globalIndex() = %d, ele.cYY() = %f, ele.cZY() = %f, ele.cZZ() = %f, ele.cSnpY() = %f, ele.cSnpZ() = %f, ele.cSnpSnp() = %f, ele.cTglY() = %f, ele.cTglZ() = %f, ele.cTglSnp() = %f, ele.cTglTgl() = %f, ele.c1PtY() = %f, ele.c1PtZ() = %f, ele.c1PtSnp() = %f, ele.c1PtTgl() = %f, ele.c1Pt21Pt2() = %f", ele.globalIndex(), ele.cYY(), ele.cZY(), ele.cZZ(), ele.cSnpY(), ele.cSnpZ(), ele.cSnpSnp(), ele.cTglY(), ele.cTglZ(), ele.cTglSnp(), ele.cTglTgl(), ele.c1PtY(), ele.c1PtZ(), ele.c1PtSnp(), ele.c1PtTgl(), ele.c1Pt21Pt2()); + // } + // Calculate DCA with respect to the collision associated to the v0, not individual tracks gpu::gpustd::array dcaInfo; @@ -498,7 +487,7 @@ struct PhotonConversionBuilder { if (rxy < std::fabs(gammaKF_DecayVtx.GetZ()) * std::tan(2 * std::atan(std::exp(-max_eta_v0))) - margin_z) { return; // RZ line cut } - if (rxy < min_v0radius) { + if (rxy < min_v0radius || max_v0radius < rxy) { return; } @@ -596,9 +585,6 @@ struct PhotonConversionBuilder { float pos_pt = RecoDecay::sqrtSumOfSquares(kfp_pos_DecayVtx.GetPx(), kfp_pos_DecayVtx.GetPy()); float ele_pt = RecoDecay::sqrtSumOfSquares(kfp_ele_DecayVtx.GetPx(), kfp_ele_DecayVtx.GetPy()); - if (pos_pt < min_pt_leg_at_sv || ele_pt < min_pt_leg_at_sv) { - return; - } if (isITSonlyTrack(pos) && pos_pt > maxpt_itsonly) { return; diff --git a/PWGEM/PhotonMeson/Tasks/pcmQC.cxx b/PWGEM/PhotonMeson/Tasks/pcmQC.cxx index e593e69e52f..5b4d9c6be48 100644 --- a/PWGEM/PhotonMeson/Tasks/pcmQC.cxx +++ b/PWGEM/PhotonMeson/Tasks/pcmQC.cxx @@ -134,7 +134,7 @@ struct PCMQC { // v0 info fRegistry.add("V0/hPt", "pT;p_{T,#gamma} (GeV/c)", kTH1F, {{2000, 0.0f, 20}}, false); - fRegistry.add("V0/hEtaPhi", "#eta vs. #varphi;#varphi (rad.);#eta", kTH2F, {{90, 0, 2 * M_PI}, {40, -1.0f, 1.0f}}, false); + fRegistry.add("V0/hEtaPhi", "#eta vs. #varphi;#varphi (rad.);#eta", kTH2F, {{90, 0, 2 * M_PI}, {200, -1.0f, 1.0f}}, false); fRegistry.add("V0/hRadius", "V0Radius; radius in Z (cm);radius in XY (cm)", kTH2F, {{200, -100, 100}, {200, 0.0f, 100.0f}}, false); fRegistry.add("V0/hCosPA", "V0CosPA;cosine pointing angle", kTH1F, {{100, 0.99f, 1.0f}}, false); fRegistry.add("V0/hCosPA_Rxy", "cos PA vs. R_{xy};R_{xy} (cm);cosine pointing angle", kTH2F, {{200, 0.f, 100.f}, {100, 0.99f, 1.0f}}, false); @@ -160,7 +160,7 @@ struct PCMQC { // v0leg info fRegistry.add("V0Leg/hPt", "pT;p_{T,e} (GeV/c)", kTH1F, {{1000, 0.0f, 10}}, false); fRegistry.add("V0Leg/hQoverPt", "q/pT;q/p_{T} (GeV/c)^{-1}", kTH1F, {{1000, -50, 50}}, false); - fRegistry.add("V0Leg/hEtaPhi", "#eta vs. #varphi;#varphi (rad.);#eta", kTH2F, {{90, 0, 2 * M_PI}, {40, -1.0f, 1.0f}}, false); + fRegistry.add("V0Leg/hEtaPhi", "#eta vs. #varphi;#varphi (rad.);#eta", kTH2F, {{90, 0, 2 * M_PI}, {200, -1.0f, 1.0f}}, false); fRegistry.add("V0Leg/hDCAxyz", "DCA xy vs. z;DCA_{xy} (cm);DCA_{z} (cm)", kTH2F, {{200, -50.0f, 50.0f}, {200, -50.0f, 50.0f}}, false); fRegistry.add("V0Leg/hNclsTPC", "number of TPC clusters", kTH1F, {{161, -0.5, 160.5}}, false); fRegistry.add("V0Leg/hNcrTPC", "number of TPC crossed rows", kTH1F, {{161, -0.5, 160.5}}, false); diff --git a/PWGEM/PhotonMeson/Tasks/pcmQCMC.cxx b/PWGEM/PhotonMeson/Tasks/pcmQCMC.cxx index 6005a6afbdc..bb050239175 100644 --- a/PWGEM/PhotonMeson/Tasks/pcmQCMC.cxx +++ b/PWGEM/PhotonMeson/Tasks/pcmQCMC.cxx @@ -176,7 +176,7 @@ struct PCMQCMC { // v0 info fRegistry.add("V0/primary/hPt", "pT;p_{T,#gamma} (GeV/c)", kTH1F, {{2000, 0.0f, 20}}, false); - fRegistry.add("V0/primary/hEtaPhi", "#eta vs. #varphi;#varphi (rad.);#eta", kTH2F, {{90, 0, 2 * M_PI}, {40, -1.0f, 1.0f}}, false); + fRegistry.add("V0/primary/hEtaPhi", "#eta vs. #varphi;#varphi (rad.);#eta", kTH2F, {{90, 0, 2 * M_PI}, {200, -1.0f, 1.0f}}, false); fRegistry.add("V0/primary/hRadius", "V0Radius; radius in Z (cm);radius in XY (cm)", kTH2F, {{200, -100, 100}, {200, 0.0f, 100.0f}}, false); fRegistry.add("V0/primary/hCosPA", "V0CosPA;cosine pointing angle", kTH1F, {{100, 0.99f, 1.0f}}, false); fRegistry.add("V0/primary/hCosPA_Rxy", "cos PA vs. R_{xy};R_{xy} (cm);cosine pointing angle", kTH2F, {{200, 0.f, 100.f}, {100, 0.99f, 1.0f}}, false); @@ -212,7 +212,7 @@ struct PCMQCMC { // v0leg info fRegistry.add("V0Leg/primary/hPt", "pT;p_{T,e} (GeV/c)", kTH1F, {{1000, 0.0f, 10}}, false); fRegistry.add("V0Leg/primary/hQoverPt", "q/pT;q/p_{T} (GeV/c)^{-1}", kTH1F, {{1000, -50, 50}}, false); - fRegistry.add("V0Leg/primary/hEtaPhi", "#eta vs. #varphi;#varphi (rad.);#eta", kTH2F, {{90, 0, 2 * M_PI}, {40, -3.0f, 1.0f}}, false); + fRegistry.add("V0Leg/primary/hEtaPhi", "#eta vs. #varphi;#varphi (rad.);#eta", kTH2F, {{90, 0, 2 * M_PI}, {200, -1.0f, 1.0f}}, false); fRegistry.add("V0Leg/primary/hDCAxyz", "DCA xy vs. z;DCA_{xy} (cm);DCA_{z} (cm)", kTH2F, {{200, -50.0f, 50.0f}, {200, -50.0f, 50.0f}}, false); fRegistry.add("V0Leg/primary/hNclsTPC", "number of TPC clusters", kTH1F, {{161, -0.5, 160.5}}, false); fRegistry.add("V0Leg/primary/hNcrTPC", "number of TPC crossed rows", kTH1F, {{161, -0.5, 160.5}}, false); diff --git a/PWGEM/PhotonMeson/Utils/PCMUtilities.h b/PWGEM/PhotonMeson/Utils/PCMUtilities.h index 63101c41418..625156cb373 100644 --- a/PWGEM/PhotonMeson/Utils/PCMUtilities.h +++ b/PWGEM/PhotonMeson/Utils/PCMUtilities.h @@ -24,7 +24,7 @@ //_______________________________________________________________________ inline bool checkAP(const float alpha, const float qt, const float alpha_max = 0.95, const float qt_max = 0.05) { - float ellipse = pow(alpha / alpha_max, 2) + pow(qt / qt_max, 2); + float ellipse = std::pow(alpha / alpha_max, 2) + std::pow(qt / qt_max, 2); if (ellipse < 1.0) { return true; } else { @@ -111,8 +111,8 @@ float getPtResolution(TV0 const& v0) float px = v0.px(); float py = v0.py(); float pt = v0.pt(); - float px_err = std::sqrt(fabs(v0.sigmaPx2())); - float py_err = std::sqrt(fabs(v0.sigmaPy2())); + float px_err = std::sqrt(std::fabs(v0.sigmaPx2())); + float py_err = std::sqrt(std::fabs(v0.sigmaPy2())); float pxy_err = v0.sigmaPxPy(); return std::sqrt(std::pow(px / pt * px_err, 2) + std::pow(py / pt * py_err, 2) + 2.f * px / pt * py / pt * pxy_err); } @@ -123,8 +123,8 @@ float getPhiResolution(TV0 const& v0) float px = v0.px(); float py = v0.py(); float pt = v0.pt(); - float px_err = std::sqrt(fabs(v0.sigmaPx2())); - float py_err = std::sqrt(fabs(v0.sigmaPy2())); + float px_err = std::sqrt(std::fabs(v0.sigmaPx2())); + float py_err = std::sqrt(std::fabs(v0.sigmaPy2())); float pxy_err = v0.sigmaPxPy(); return std::sqrt(std::pow(px / pt / pt * py_err, 2) + std::pow(py / pt / pt * px_err, 2) - 2.f * px / pt / pt * py / pt / pt * pxy_err); } @@ -137,9 +137,9 @@ float getThetaResolution(TV0 const& v0) float pz = v0.pz(); float pt = v0.pt(); float p = v0.p(); - float px_err = std::sqrt(fabs(v0.sigmaPx2())); - float py_err = std::sqrt(fabs(v0.sigmaPy2())); - float pz_err = std::sqrt(fabs(v0.sigmaPz2())); + float px_err = std::sqrt(std::fabs(v0.sigmaPx2())); + float py_err = std::sqrt(std::fabs(v0.sigmaPy2())); + float pz_err = std::sqrt(std::fabs(v0.sigmaPz2())); float pxy_err = v0.sigmaPxPy(); float pyz_err = v0.sigmaPyPz(); float pzx_err = v0.sigmaPzPx(); @@ -154,9 +154,9 @@ float getEtaResolution(TV0 const& v0) float pz = v0.pz(); float pt = v0.pt(); float p = v0.p(); - float px_err = std::sqrt(fabs(v0.sigmaPx2())); - float py_err = std::sqrt(fabs(v0.sigmaPy2())); - float pz_err = std::sqrt(fabs(v0.sigmaPz2())); + float px_err = std::sqrt(std::fabs(v0.sigmaPx2())); + float py_err = std::sqrt(std::fabs(v0.sigmaPy2())); + float pz_err = std::sqrt(std::fabs(v0.sigmaPz2())); float pxy_err = v0.sigmaPxPy(); float pyz_err = v0.sigmaPyPz(); float pzx_err = v0.sigmaPzPx(); @@ -170,9 +170,9 @@ float getPResolution(TV0 const& v0) float py = v0.py(); float pz = v0.pz(); float p = v0.p(); - float px_err = std::sqrt(fabs(v0.sigmaPx2())); - float py_err = std::sqrt(fabs(v0.sigmaPy2())); - float pz_err = std::sqrt(fabs(v0.sigmaPz2())); + float px_err = std::sqrt(std::fabs(v0.sigmaPx2())); + float py_err = std::sqrt(std::fabs(v0.sigmaPy2())); + float pz_err = std::sqrt(std::fabs(v0.sigmaPz2())); float pxy_err = v0.sigmaPxPy(); float pyz_err = v0.sigmaPyPz(); float pzx_err = v0.sigmaPzPx(); From 97a095922e1c41a063503173099db9305ed02ea8 Mon Sep 17 00:00:00 2001 From: alcaliva <32872606+alcaliva@users.noreply.github.com> Date: Thu, 6 Feb 2025 13:37:40 +0100 Subject: [PATCH 14/30] [PWGLF] updated jet selection in MC (#9787) --- PWGLF/Tasks/Nuspex/nucleiInJets.cxx | 247 +++++++++++++++------------- 1 file changed, 133 insertions(+), 114 deletions(-) diff --git a/PWGLF/Tasks/Nuspex/nucleiInJets.cxx b/PWGLF/Tasks/Nuspex/nucleiInJets.cxx index ef7c5eadc8c..8ef42f4c65c 100644 --- a/PWGLF/Tasks/Nuspex/nucleiInJets.cxx +++ b/PWGLF/Tasks/Nuspex/nucleiInJets.cxx @@ -100,6 +100,7 @@ struct NucleiInJets { Configurable nGhosts{"nGhosts", 1000, "number of ghost particles"}; Configurable alpha{"alpha", 1.0, "Alpha"}; Configurable averagePtUE{"averagePtUE", 0.1, "Average pt of UE"}; + Configurable averagePtUEMC{"averagePtUEMC", 0.1, "Average pt of UE in MC"}; // Track Parameters Configurable par0{"par0", 0.00164, "par 0"}; @@ -162,6 +163,7 @@ struct NucleiInJets { registryQC.add("sumPtJetPlusUE", "sumPtJetPlusUE", HistType::kTH1F, {{500, 0, 50, "#it{p}_{T} (GeV/#it{c})"}}); registryQC.add("sumPtJet", "sumPtJet", HistType::kTH1F, {{500, 0, 50, "#it{p}_{T} (GeV/#it{c})"}}); registryQC.add("sumPtUE", "sumPtUE", HistType::kTH1F, {{500, 0, 50, "#it{p}_{T} (GeV/#it{c})"}}); + registryQC.add("sumPtUE_MC", "sumPtUE_MC", HistType::kTH1F, {{500, 0, 50, "#it{p}_{T} (GeV/#it{c})"}}); registryQC.add("nJets_found", "nJets_found", HistType::kTH1F, {{10, 0, 10, "#it{n}_{Jet}"}}); registryQC.add("nJets_selected", "nJets_selected", HistType::kTH1F, {{10, 0, 10, "#it{n}_{Jet}"}}); registryQC.add("dcaxy_vs_pt", "dcaxy_vs_pt", HistType::kTH2F, {{100, 0.0, 5.0, "#it{p}_{T} (GeV/#it{c})"}, {2000, -0.05, 0.05, "DCA_{xy} (cm)"}}); @@ -985,21 +987,35 @@ struct NucleiInJets { // List of Tracks std::vector trk; + std::vector part; + std::vector ntrk; for (auto track : tracksPerColl) { // o2-linter: disable=[const-ref-in-for-loop] if (!passedTrackSelectionForJetReconstruction(track)) continue; + if (!track.has_mcParticle()) + continue; - TVector3 momentum(track.px(), track.py(), track.pz()); - trk.push_back(momentum); + const auto particle = track.mcParticle(); + TVector3 pRec(track.px(), track.py(), track.pz()); + TVector3 pGen(particle.px(), particle.py(), particle.pz()); + trk.push_back(pRec); + part.push_back(pGen); + ntrk.push_back(1); } + // Reject Empty Events + if (static_cast(trk.size()) < 1) + continue; + // Anti-kt Jet Finder int nParticlesRemoved(0); std::vector jet; + std::vector jetGen; std::vector ue1; std::vector ue2; + std::vector nParticlesInjet; do { double dijMin(1e+06), diBmin(1e+06); @@ -1025,26 +1041,35 @@ struct NucleiInJets { } if (dijMin < diBmin) { trk[iMin] = trk[iMin] + trk[jMin]; + ntrk[iMin] = ntrk[iMin] + ntrk[jMin]; + part[iMin] = part[iMin] + part[jMin]; trk[jMin].SetXYZ(0, 0, 0); + part[jMin].SetXYZ(0, 0, 0); + ntrk[jMin] = 0; nParticlesRemoved++; } if (dijMin > diBmin) { jet.push_back(trk[iBmin]); + jetGen.push_back(part[iBmin]); + nParticlesInjet.push_back(ntrk[iBmin]); trk[iBmin].SetXYZ(0, 0, 0); + part[iBmin].SetXYZ(0, 0, 0); nParticlesRemoved++; } } while (nParticlesRemoved < static_cast(trk.size())); // Jet Selection std::vector isSelected; - for (int i = 0; i < static_cast(jet.size()); i++) { // o2-linter: disable=[const-ref-in-for-loop] - isSelected.push_back(0); - } - int nJetsSelected(0); for (int i = 0; i < static_cast(jet.size()); i++) { // o2-linter: disable=[const-ref-in-for-loop] - if ((std::fabs(jet[i].Eta()) + rJet) > maxEta) + // Initialization + isSelected.push_back(0); + + // Jet fully contained inside acceptance + if ((std::fabs(jet[i].Eta()) + rJet) > (maxEta - 0.5)) + continue; + if (nParticlesInjet[i] < minNparticlesInJet) continue; // Perpendicular cones @@ -1055,20 +1080,16 @@ struct NucleiInJets { ue1.push_back(ueAxis1); ue2.push_back(ueAxis2); - double nPartJetPlusUE(0); - double ptJetPlusUE(0); - double ptJet(0); double ptUE(0); - for (auto track : tracksPerColl) { // o2-linter: disable=[const-ref-in-for-loop] if (!passedTrackSelectionForJetReconstruction(track)) continue; TVector3 selectedTrack(track.px(), track.py(), track.pz()); + if (!track.has_mcParticle()) + continue; - double deltaEtaJet = selectedTrack.Eta() - jet[i].Eta(); - double deltaPhiJet = getDeltaPhi(selectedTrack.Phi(), jet[i].Phi()); - double deltaRjet = std::sqrt(deltaEtaJet * deltaEtaJet + deltaPhiJet * deltaPhiJet); + const auto particle = track.mcParticle(); double deltaEtaUe1 = selectedTrack.Eta() - ueAxis1.Eta(); double deltaPhiUe1 = getDeltaPhi(selectedTrack.Phi(), ueAxis1.Phi()); double deltaRUe1 = std::sqrt(deltaEtaUe1 * deltaEtaUe1 + deltaPhiUe1 * deltaPhiUe1); @@ -1076,29 +1097,48 @@ struct NucleiInJets { double deltaPhiUe2 = getDeltaPhi(selectedTrack.Phi(), ueAxis2.Phi()); double deltaRUe2 = std::sqrt(deltaEtaUe2 * deltaEtaUe2 + deltaPhiUe2 * deltaPhiUe2); - if (deltaRjet < rJet) { - nPartJetPlusUE++; - ptJetPlusUE = ptJetPlusUE + selectedTrack.Pt(); - } - if (deltaRUe1 < rJet) { - ptUE = ptUE + selectedTrack.Pt(); - } - if (deltaRUe2 < rJet) { - ptUE = ptUE + selectedTrack.Pt(); + if ((deltaRUe1 < alpha * rJet) || (deltaRUe2 < alpha * rJet)) { + ptUE = ptUE + particle.pt(); } } - ptJet = ptJetPlusUE - 0.5 * ptUE; + registryQC.fill(HIST("sumPtUE_MC"), 0.5 * ptUE); - if (ptJet < minJetPt) - continue; - if (nPartJetPlusUE < minNparticlesInJet) + double ptJetCorr = jetGen[i].Pt() - averagePtUEMC; + + if (ptJetCorr < minJetPt) continue; + nJetsSelected++; isSelected[i] = 1; } if (nJetsSelected == 0) continue; - registryMC.fill(HIST("number_of_events_mc"), 6.5); + + // Overlaps + int nOverlapsJetJet(0); + int nOverlapsJetUe(0); + int nOverlapsUeUe(0); + int nOverlapsTot(0); + for (int i = 0; i < static_cast(jet.size()); i++) { + if (isSelected[i] == 0) + continue; + + for (int j = (i + 1); j < static_cast(jet.size()); j++) { + if (isSelected[j] == 0) + continue; + if (overlap(jet[i], jet[j], rJet)) + nOverlapsJetJet++; + if (overlap(jet[i], ue1[j], rJet) || overlap(jet[i], ue2[j], rJet)) + nOverlapsJetUe++; + if (overlap(ue1[i], ue1[j], rJet) || overlap(ue1[i], ue2[j], rJet) || overlap(ue2[i], ue2[j], rJet)) + nOverlapsUeUe++; + } + } + nOverlapsTot = nOverlapsJetJet + nOverlapsJetUe + nOverlapsUeUe; + if (nJetsSelected > nJetsPerEventMax) + continue; + if (requireNoOverlap && nOverlapsTot > 0) + continue; for (int i = 0; i < static_cast(jet.size()); i++) { // o2-linter: disable=[const-ref-in-for-loop] @@ -1167,6 +1207,7 @@ struct NucleiInJets { // List of Tracks std::vector trk; + std::vector ntrk; for (auto& particle : mcParticlesPerColl) { // o2-linter: disable=[const-ref-in-for-loop] if (particle.isPhysicalPrimary() && particle.pdgCode() == -2212) { @@ -1179,20 +1220,10 @@ struct NucleiInJets { double dz = particle.vz() - mccollision.posZ(); double dcaxy = std::sqrt(dx * dx + dy * dy); double dcaz = std::fabs(dz); - - if (setDCAselectionPtDep) { - if (dcaxy > (par0 + par1 / particle.pt())) - continue; - if (dcaz > (par0 + par1 / particle.pt())) - continue; - } - if (!setDCAselectionPtDep) { - if (dcaxy > maxDcaxy) - continue; - if (dcaz > maxDcaz) - continue; - } - + if (dcaxy > 0.25) + continue; + if (dcaz > 2.0) + continue; if (std::fabs(particle.eta()) > 0.8) continue; if (particle.pt() < 0.15) @@ -1205,6 +1236,7 @@ struct NucleiInJets { TVector3 momentum(particle.px(), particle.py(), particle.pz()); trk.push_back(momentum); + ntrk.push_back(1); } // Anti-kt Jet Finder @@ -1212,6 +1244,7 @@ struct NucleiInJets { std::vector jet; std::vector ue1; std::vector ue2; + std::vector nParticlesInjet; do { double dijMin(1e+06), diBmin(1e+06); @@ -1237,11 +1270,14 @@ struct NucleiInJets { } if (dijMin < diBmin) { trk[iMin] = trk[iMin] + trk[jMin]; + ntrk[iMin] = ntrk[iMin] + ntrk[jMin]; trk[jMin].SetXYZ(0, 0, 0); + ntrk[jMin] = 0; nParticlesRemoved++; } if (dijMin > diBmin) { jet.push_back(trk[iBmin]); + nParticlesInjet.push_back(ntrk[iBmin]); trk[iBmin].SetXYZ(0, 0, 0); nParticlesRemoved++; } @@ -1249,14 +1285,16 @@ struct NucleiInJets { // Jet Selection std::vector isSelected; - for (int i = 0; i < static_cast(jet.size()); i++) { // o2-linter: disable=[const-ref-in-for-loop] - isSelected.push_back(0); - } - int nJetsSelected(0); for (int i = 0; i < static_cast(jet.size()); i++) { // o2-linter: disable=[const-ref-in-for-loop] - if ((std::fabs(jet[i].Eta()) + rJet) > maxEta) + // Initialization + isSelected.push_back(0); + + // Jet fully contained inside acceptance + if ((std::fabs(jet[i].Eta()) + rJet) > (maxEta - 0.5)) + continue; + if (nParticlesInjet[i] < minNparticlesInJet) continue; // Perpendicular cones @@ -1267,76 +1305,40 @@ struct NucleiInJets { ue1.push_back(ueAxis1); ue2.push_back(ueAxis2); - double nPartJetPlusUE(0); - double ptJetPlusUE(0); - double ptJet(0); - double ptUE(0); - - for (auto& particle : mcParticlesPerColl) { // o2-linter: disable=[const-ref-in-for-loop] - - // Select Primary Particles - double dx = particle.vx() - mccollision.posX(); - double dy = particle.vy() - mccollision.posY(); - double dz = particle.vz() - mccollision.posZ(); - double dcaxy = std::sqrt(dx * dx + dy * dy); - double dcaz = std::fabs(dz); + double ptJetCorr = jet[i].Pt() - averagePtUEMC; + if (ptJetCorr < minJetPt) + continue; - if (setDCAselectionPtDep) { - if (dcaxy > (par0 + par1 / particle.pt())) - continue; - if (dcaz > (par0 + par1 / particle.pt())) - continue; - } - if (!setDCAselectionPtDep) { - if (dcaxy > maxDcaxy) - continue; - if (dcaz > maxDcaz) - continue; - } + nJetsSelected++; + isSelected[i] = 1; + } + if (nJetsSelected == 0) + continue; - if (std::fabs(particle.eta()) > 0.8) - continue; - if (particle.pt() < 0.15) - continue; + // Overlaps + int nOverlapsJetJet(0); + int nOverlapsJetUe(0); + int nOverlapsUeUe(0); + int nOverlapsTot(0); + for (int i = 0; i < static_cast(jet.size()); i++) { + if (isSelected[i] == 0) + continue; - // PDG Selection - int pdg = std::fabs(particle.pdgCode()); - if ((pdg != 11) && (pdg != 211) && (pdg != 321) && (pdg != 2212)) + for (int j = (i + 1); j < static_cast(jet.size()); j++) { + if (isSelected[j] == 0) continue; - - TVector3 selectedTrack(particle.px(), particle.py(), particle.pz()); - - double deltaEtaJet = selectedTrack.Eta() - jet[i].Eta(); - double deltaPhiJet = getDeltaPhi(selectedTrack.Phi(), jet[i].Phi()); - double deltaRjet = std::sqrt(deltaEtaJet * deltaEtaJet + deltaPhiJet * deltaPhiJet); - double deltaEtaUe1 = selectedTrack.Eta() - ueAxis1.Eta(); - double deltaPhiUe1 = getDeltaPhi(selectedTrack.Phi(), ueAxis1.Phi()); - double deltaRUe1 = std::sqrt(deltaEtaUe1 * deltaEtaUe1 + deltaPhiUe1 * deltaPhiUe1); - double deltaEtaUe2 = selectedTrack.Eta() - ueAxis2.Eta(); - double deltaPhiUe2 = getDeltaPhi(selectedTrack.Phi(), ueAxis2.Phi()); - double deltaRUe2 = std::sqrt(deltaEtaUe2 * deltaEtaUe2 + deltaPhiUe2 * deltaPhiUe2); - - if (deltaRjet < rJet) { - nPartJetPlusUE++; - ptJetPlusUE = ptJetPlusUE + selectedTrack.Pt(); - } - if (deltaRUe1 < rJet) { - ptUE = ptUE + selectedTrack.Pt(); - } - if (deltaRUe2 < rJet) { - ptUE = ptUE + selectedTrack.Pt(); - } + if (overlap(jet[i], jet[j], rJet)) + nOverlapsJetJet++; + if (overlap(jet[i], ue1[j], rJet) || overlap(jet[i], ue2[j], rJet)) + nOverlapsJetUe++; + if (overlap(ue1[i], ue1[j], rJet) || overlap(ue1[i], ue2[j], rJet) || overlap(ue2[i], ue2[j], rJet)) + nOverlapsUeUe++; } - ptJet = ptJetPlusUE - 0.5 * ptUE; - - if (ptJet < minJetPt) - continue; - if (nPartJetPlusUE < minNparticlesInJet) - continue; - nJetsSelected++; - isSelected[i] = 1; } - if (nJetsSelected == 0) + nOverlapsTot = nOverlapsJetJet + nOverlapsJetUe + nOverlapsUeUe; + if (nJetsSelected > nJetsPerEventMax) + continue; + if (requireNoOverlap && nOverlapsTot > 0) continue; for (int i = 0; i < static_cast(jet.size()); i++) { // o2-linter: disable=[const-ref-in-for-loop] @@ -1390,7 +1392,9 @@ struct NucleiInJets { TVector3 momentum(track.px(), track.py(), track.pz()); trk.push_back(momentum); } - // int nTracks = static_cast(trk.size()); + // Reject Empty Events + if (static_cast(trk.size()) < 1) + return; // Generate Ghosts for (int i = 0; i < nGhosts; i++) { // o2-linter: disable=[const-ref-in-for-loop] @@ -1451,8 +1455,14 @@ struct NucleiInJets { for (int i = 0; i < static_cast(jet.size()); i++) { // o2-linter: disable=[const-ref-in-for-loop] - if ((std::fabs(jet[i].Eta()) + rJet) > maxEta) + if ((std::fabs(jet[i].Eta()) + rJet) > (maxEta - 0.5)) continue; + + double ptJetRec = jet[i].Pt() - averagePtUE; + double ptJetCorr = getCorrectedPt(ptJetRec); + if (ptJetCorr < minJetPt) + continue; + registryQC.fill(HIST("hJetArea"), jetArea[i]); } } @@ -1469,6 +1479,7 @@ struct NucleiInJets { // List of Tracks and Particles std::vector trk; std::vector part; + std::vector ntrk; auto tracksPerColl = mcTracks.sliceBy(perCollision, collision.globalIndex()); for (auto track : tracksPerColl) { // o2-linter: disable=[const-ref-in-for-loop] @@ -1483,12 +1494,17 @@ struct NucleiInJets { TVector3 genMomentum(particle.px(), particle.py(), particle.pz()); trk.push_back(recMomentum); part.push_back(genMomentum); + ntrk.push_back(1); } + // Reject Empty Events + if (static_cast(trk.size()) < 1) + continue; // Anti-kt Jet Finder int nParticlesRemoved(0); std::vector jetRecMomentum; std::vector jetGenMomentum; + std::vector nParticlesInjet; do { double dijMin(1e+06), diBmin(1e+06); @@ -1514,13 +1530,16 @@ struct NucleiInJets { } if (dijMin < diBmin) { trk[iMin] = trk[iMin] + trk[jMin]; + ntrk[iMin] = ntrk[iMin] + ntrk[jMin]; part[iMin] = part[iMin] + part[jMin]; trk[jMin].SetXYZ(0, 0, 0); + ntrk[jMin] = 0; nParticlesRemoved++; } if (dijMin > diBmin) { jetRecMomentum.push_back(trk[iBmin]); jetGenMomentum.push_back(part[iBmin]); + nParticlesInjet.push_back(ntrk[iBmin]); trk[iBmin].SetXYZ(0, 0, 0); nParticlesRemoved++; } @@ -1528,7 +1547,7 @@ struct NucleiInJets { for (int i = 0; i < static_cast(jetRecMomentum.size()); i++) { // o2-linter: disable=[const-ref-in-for-loop] - if ((std::fabs(jetRecMomentum[i].Eta()) + rJet) > maxEta) + if ((std::fabs(jetRecMomentum[i].Eta()) + rJet) > (maxEta - 0.5)) continue; double ptGen = jetGenMomentum[i].Pt(); From 3441b67de7fe7d9b6b40c3fe34fea62bc25b2842 Mon Sep 17 00:00:00 2001 From: Zuzanna Chochulska <87480906+zchochul@users.noreply.github.com> Date: Thu, 6 Feb 2025 14:07:47 +0100 Subject: [PATCH 15/30] PWGCF: FemtoUniverse -- Removing unused configurables and commented code (#9788) Co-authored-by: Zuzanna Chochulska <01150674@pw.edu.pl> --- .../Tasks/femtoUniversePairTaskTrackPhi.cxx | 40 ------------------- 1 file changed, 40 deletions(-) diff --git a/PWGCF/FemtoUniverse/Tasks/femtoUniversePairTaskTrackPhi.cxx b/PWGCF/FemtoUniverse/Tasks/femtoUniversePairTaskTrackPhi.cxx index 6a3e2f2c5a7..4cc283b8505 100644 --- a/PWGCF/FemtoUniverse/Tasks/femtoUniversePairTaskTrackPhi.cxx +++ b/PWGCF/FemtoUniverse/Tasks/femtoUniversePairTaskTrackPhi.cxx @@ -58,10 +58,6 @@ struct FemtoUniversePairTaskTrackPhi { Service pdgMC; - // using FemtoFullParticles = soa::Join; - // Filter trackCutFilter = requireGlobalTrackInFilter(); // Global track cuts - // using FilteredFemtoFullParticles = soa::Filtered; - using FilteredFemtoFullParticles = soa::Join; SliceCache cache; @@ -70,14 +66,6 @@ struct FemtoUniversePairTaskTrackPhi { using FemtoRecoParticles = soa::Join; Preslice perColMC = aod::femtouniverseparticle::fdCollisionId; - // Efficiency - struct : o2::framework::ConfigurableGroup { - Configurable confEfficiencyTrackPath{"confEfficiencyTrackPath", "", "Local path to proton efficiency TH2F file"}; - Configurable confEfficiencyPhiPath{"confEfficiencyPhiPath", "", "Local path to Phi efficiency TH2F file"}; - Configurable confEfficiencyTrackTimestamp{"confEfficiencyTrackTimestamp", 0, "(int64_t) Timestamp for hadron"}; - Configurable confEfficiencyPhiTimestamp{"confEfficiencyPhiTimestamp", 0, "(int64_t) Timestamp for phi"}; - } ConfEff; - struct : o2::framework::ConfigurableGroup { Configurable confCPRIsEnabled{"confCPRIsEnabled", false, "Close Pair Rejection"}; Configurable confCPRPlotPerRadii{"confCPRPlotPerRadii", false, "Plot CPR per radii"}; @@ -99,9 +87,6 @@ struct FemtoUniversePairTaskTrackPhi { Configurable confPIDProtonNsigmaReject{"confPIDProtonNsigmaReject", 3.0, "Reject if particle could be a Proton combined nsigma value."}; Configurable confPIDPionNsigmaCombined{"confPIDPionNsigmaCombined", 3.0, "TPC and TOF Pion Sigma (combined) for momentum > 0.5"}; Configurable confPIDPionNsigmaTPC{"confPIDPionNsigmaTPC", 3.0, "TPC Pion Sigma for momentum < 0.5"}; - - // Configurable> confCutTable{"confCutTable", {cutsTable[0], NPart, NCuts, partNames, cutNames}, "Particle selections"}; //unused - // Configurable confNspecies{"confNspecies", 2, "Number of particle spieces with PID info"}; //unused Configurable confIsMC{"confIsMC", false, "Enable additional Histograms in the case of a MonteCarlo Run"}; Configurable> confTrkPIDnSigmaMax{"confTrkPIDnSigmaMax", std::vector{4.f, 3.f, 2.f}, "This configurable needs to be the same as the one used in the producer task"}; Configurable confUse3D{"confUse3D", false, "Enable three dimensional histogramms (to be used only for analysis with high statistics): k* vs mT vs multiplicity"}; @@ -212,10 +197,6 @@ struct FemtoUniversePairTaskTrackPhi { EfficiencyConfigurableGroup effConfGroup; EfficiencyCalculator efficiencyCalculator{&effConfGroup}; - // Service ccdb; - // TH2F* protoneff; - // TH2F* phieff; - /// @brief Counter for particle swapping int fNeventsProcessed = 0; bool swpart = 0; @@ -468,27 +449,6 @@ struct FemtoUniversePairTaskTrackPhi { if (ConfCPR.confCPRIsEnabled.value) { pairCloseRejection.init(&resultRegistry, &qaRegistry, ConfCPR.confCPRdeltaPhiCutMin.value, ConfCPR.confCPRdeltaPhiCutMax.value, ConfCPR.confCPRdeltaEtaCutMin.value, ConfCPR.confCPRdeltaEtaCutMax.value, ConfCPR.confCPRChosenRadii.value, ConfCPR.confCPRPlotPerRadii.value, ConfCPR.confCPRInvMassCutMin.value, ConfCPR.confCPRInvMassCutMax.value); } - - /// Initializing CCDB - // ccdb->setURL("http://alice-ccdb.cern.ch"); - // ccdb->setCaching(true); - // ccdb->setLocalObjectValidityChecking(); - - // int64_t now = std::chrono::duration_cast(std::chrono::system_clock::now().time_since_epoch()).count(); - // ccdb->setCreatedNotAfter(now); - - // if (!ConfEff.confEfficiencyTrackPath.value.empty()) { - // protoneff = ccdb->getForTimeStamp(ConfEff.confEfficiencyTrackPath.value.c_str(), ConfEff.confEfficiencyTrackTimestamp.value); - // if (!protoneff || protoneff->IsZombie()) { - // LOGF(fatal, "Could not load efficiency protoneff histogram from %s", ConfEff.confEfficiencyTrackPath.value.c_str()); - // } - // } - // if (!ConfEff.confEfficiencyPhiPath.value.empty()) { - // phieff = ccdb->getForTimeStamp(ConfEff.confEfficiencyPhiPath.value.c_str(), ConfEff.confEfficiencyPhiTimestamp.value); - // if (!phieff || phieff->IsZombie()) { - // LOGF(fatal, "Could not load efficiency phieff histogram from %s", ConfEff.confEfficiencyPhiPath.value.c_str()); - // } - // } } template From e2f5668bfd17e59fe0d98ef8dc1463217fad580c Mon Sep 17 00:00:00 2001 From: Artem Kotliarov <71133985+KotliarovAr@users.noreply.github.com> Date: Thu, 6 Feb 2025 14:46:42 +0100 Subject: [PATCH 16/30] [PWGJE] Hadron jet recoil (#9762) --- PWGJE/Tasks/recoilJets.cxx | 218 ++++++++++++++++++++----------------- 1 file changed, 119 insertions(+), 99 deletions(-) diff --git a/PWGJE/Tasks/recoilJets.cxx b/PWGJE/Tasks/recoilJets.cxx index 1ef4e89f543..ba1a2a08351 100644 --- a/PWGJE/Tasks/recoilJets.cxx +++ b/PWGJE/Tasks/recoilJets.cxx @@ -72,13 +72,10 @@ struct RecoilJets { Configurable trkPtMin{"trkPtMin", 0.15, "Minimum pT of acceptanced tracks"}; Configurable trkPtMax{"trkPtMax", 100., "Maximum pT of acceptanced tracks"}; - Configurable trkPhiMin{"trkPhiMin", -7., "Minimum phi angle of acceptanced tracks"}; - Configurable trkPhiMax{"trkPhiMax", 7., "Maximum phi angle of acceptanced tracks"}; - Configurable trkEtaCut{"trkEtaCut", 0.9, "Eta acceptance of TPC"}; Configurable jetR{"jetR", 0.4, "Jet cone radius"}; - Configurable triggerMasks{"triggerMasks", "", "Relevant trigger masks: fJetChLowPt,fJetChHighPt,fTrackLowPt,fTrackHighPt"}; + Configurable triggerMasks{"triggerMasks", "", "Relevant trigger masks: fTrackLowPt,fTrackHighPt"}; // List of configurable parameters for MC Configurable pTHatExponent{"pTHatExponent", 4.0, "Exponent of the event weight for the calculation of pTHat"}; @@ -97,10 +94,13 @@ struct RecoilJets { // Axes specification AxisSpec pT{histJetPt, 0.0, histJetPt * 1.0, "#it{p}_{T} (GeV/#it{c})"}; AxisSpec jetPTcorr{histJetPt + 20, -20., histJetPt * 1.0, "#it{p}_{T, jet}^{ch, corr} (GeV/#it{c})"}; - AxisSpec phiAngle{40, 0.0, constants::math::TwoPI, "#varphi (rad)"}; - AxisSpec deltaPhiAngle{52, 0.0, constants::math::PI, "#Delta#varphi (rad)"}; - AxisSpec pseudorap{40, -1., 1., "#eta"}; - AxisSpec rhoArea{60, 0.0, 30., "#rho #times #A_{jet}"}; + AxisSpec phiAngle{40, 0.0, constants::math::TwoPI, "#it{#varphi} (rad)"}; + AxisSpec deltaPhiAngle{52, 0.0, constants::math::PI, "#Delta#it{#varphi} (rad)"}; + AxisSpec pseudorap{40, -1., 1., "#it{#eta}"}; + AxisSpec pseudorapJets{20, -0.5, 0.5, "#it{#eta}_{jet}"}; + AxisSpec jetArea{50, 0.0, 5., "Area_{jet}"}; + AxisSpec rhoArea{60, 0.0, 60., "#it{#rho} #times Area_{jet}"}; + AxisSpec rho{50, 0.0, 50., "#it{#rho}"}; Preslice partJetsPerCollision = aod::jet::mcCollisionId; @@ -110,8 +110,9 @@ struct RecoilJets { Filter collisionFilter = nabs(aod::jcollision::posZ) < vertexZCut; Filter collisionFilterMC = nabs(aod::jmccollision::posZ) < vertexZCut; - // Declare filters on accepted tracks + // Declare filters on accepted tracks and MC particles (settings for jet reco are provided in the jet finder wagon) Filter trackFilter = aod::jtrack::pt > trkPtMin&& aod::jtrack::pt < trkPtMax&& nabs(aod::jtrack::eta) < trkEtaCut; + Filter partFilter = nabs(aod::jmcparticle::eta) < trkEtaCut; // Declare filter on jets Filter jetRadiusFilter = aod::jet::r == nround(jetR.node() * 100.); @@ -122,81 +123,91 @@ struct RecoilJets { int trackSelection = -1; std::vector triggerMaskBits; + Service pdg; + void init(InitContext const&) { - eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(evSel)); trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trkSel)); triggerMaskBits = jetderiveddatautilities::initialiseTriggerMaskBits(triggerMasks); - // List of raw distributions - spectra.add("vertexZ", "Z vertex of collisions", kTH1F, {{60, -12., 12.}}); + // List of raw and MC det. distributions + if (doprocessData || doprocessMCDetLevel || doprocessMCDetLevelWeighted) { + spectra.add("vertexZ", "Z vertex of collisions", kTH1F, {{60, -12., 12.}}); - spectra.add("hTrackPtEtaPhi", "Charact. of tracks", kTH3F, {pT, pseudorap, phiAngle}); - spectra.add("hNtrig", "Total number of selected triggers per class", kTH1F, {{2, 0.0, 2.}}); - spectra.get(HIST("hNtrig"))->GetXaxis()->SetBinLabel(1, "TT_{ref}"); - spectra.get(HIST("hNtrig"))->GetXaxis()->SetBinLabel(2, "TT_{sig}"); + spectra.add("hTrackPtEtaPhi", "Charact. of tracks", kTH3F, {pT, pseudorap, phiAngle}); + spectra.add("hNtrig", "Total number of selected triggers per class", kTH1F, {{2, 0.0, 2.}}); + spectra.get(HIST("hNtrig"))->GetXaxis()->SetBinLabel(1, "TT_{ref}"); + spectra.get(HIST("hNtrig"))->GetXaxis()->SetBinLabel(2, "TT_{sig}"); - spectra.add("hTTRef_per_event", "Number of TT_{Ref} per event", kTH1F, {{10, 0.0, 10.}}); - spectra.add("hTTSig_per_event", "Number of TT_{Sig} per event", kTH1F, {{5, 0.0, 5.}}); + spectra.add("hTTRef_per_event", "Number of TT_{Ref} per event", kTH1F, {{15, 0.5, 15.5}}); + spectra.add("hTTSig_per_event", "Number of TT_{Sig} per event", kTH1F, {{10, 0.5, 10.5}}); - spectra.add("hJetPtEtaPhiRhoArea", "Charact. of inclusive jets", kTHnSparseF, {pT, pseudorap, phiAngle, rhoArea}); + spectra.add("hJetPtEtaPhiRhoArea", "Charact. of inclusive jets", kTHnSparseF, {pT, pseudorapJets, phiAngle, rho, jetArea}); - spectra.add("hDPhi_JetPt_Corr_TTRef", "Events w. TT_{Ref}: #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH2F, {deltaPhiAngle, jetPTcorr}); - spectra.add("hDPhi_JetPt_Corr_TTSig", "Events w. TT_{Sig}: #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH2F, {deltaPhiAngle, jetPTcorr}); - spectra.add("hDPhi_JetPt_TTRef", "Events w. TT_{Ref}: #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH2F, {deltaPhiAngle, pT}); - spectra.add("hDPhi_JetPt_TTSig", "Events w. TT_{Sig}: #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH2F, {deltaPhiAngle, pT}); + spectra.add("hDPhi_JetPt_Corr_TTRef", "Events w. TT_{Ref}: #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH2F, {deltaPhiAngle, jetPTcorr}); + spectra.add("hDPhi_JetPt_Corr_TTSig", "Events w. TT_{Sig}: #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH2F, {deltaPhiAngle, jetPTcorr}); + spectra.add("hDPhi_JetPt_TTRef", "Events w. TT_{Ref}: #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH2F, {deltaPhiAngle, pT}); + spectra.add("hDPhi_JetPt_TTSig", "Events w. TT_{Sig}: #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH2F, {deltaPhiAngle, pT}); - spectra.add("hRecoil_JetPt_Corr_TTRef", "Events w. TT_{Ref}: #it{p}_{T} of recoil jets", kTH1F, {jetPTcorr}); - spectra.add("hRecoil_JetPt_Corr_TTSig", "Events w. TT_{Sig}: #it{p}_{T} of recoil jets", kTH1F, {jetPTcorr}); - spectra.add("hRecoil_JetPt_TTRef", "Events w. TT_{Ref}: #it{p}_{T} of recoil jets", kTH1F, {pT}); - spectra.add("hRecoil_JetPt_TTSig", "Events w. TT_{Sig}: #it{p}_{T} of recoil jets", kTH1F, {pT}); + spectra.add("hRecoil_JetPt_Corr_TTRef", "Events w. TT_{Ref}: #it{p}_{T} of recoil jets", kTH1F, {jetPTcorr}); + spectra.add("hRecoil_JetPt_Corr_TTSig", "Events w. TT_{Sig}: #it{p}_{T} of recoil jets", kTH1F, {jetPTcorr}); + spectra.add("hRecoil_JetPt_TTRef", "Events w. TT_{Ref}: #it{p}_{T} of recoil jets", kTH1F, {pT}); + spectra.add("hRecoil_JetPt_TTSig", "Events w. TT_{Sig}: #it{p}_{T} of recoil jets", kTH1F, {pT}); - spectra.add("hDPhi_JetPt_RhoArea_TTRef", "Events w. TT_{Ref}: #Delta#varphi & jet pT & #rho #times A_{jet}", kTH3F, {deltaPhiAngle, pT, rhoArea}); - spectra.add("hDPhi_JetPt_RhoArea_TTSig", "Events w. TT_{Sig}: #Delta#varphi & jet pT & #rho #times A_{jet}", kTH3F, {deltaPhiAngle, pT, rhoArea}); + spectra.add("hJetArea_JetPt_Rho_TTRef", "Events w. TT_{Ref}: A_{jet} & jet pT & #rho", kTH3F, {jetArea, pT, rho}); + spectra.add("hJetArea_JetPt_Rho_TTSig", "Events w. TT_{Sig}: A_{jet} & jet pT & #rho", kTH3F, {jetArea, pT, rho}); + } // List of MC particle level distributions - spectra.add("hPartPtEtaPhi", "Charact. of particles", kTH3F, {pT, pseudorap, phiAngle}); - spectra.add("hNtrig_Part", "Total number of selected triggers per class", kTH1F, {{2, 0.0, 2.}}); - spectra.add("hTTRef_per_event_Part", "Number of TT_{Ref} per event", kTH1F, {{10, 0.0, 10.}}); - spectra.add("hTTSig_per_event_Part", "Number of TT_{Sig} per event", kTH1F, {{5, 0.0, 5.}}); - - spectra.add("hJetPtEtaPhiRhoArea_Part", "Charact. of inclusive part. level jets", kTHnSparseF, {pT, pseudorap, phiAngle, rhoArea}); - - spectra.add("hDPhi_JetPt_Corr_TTRef_Part", "Events w. TT_{Ref}: #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH2F, {deltaPhiAngle, jetPTcorr}); - spectra.add("hDPhi_JetPt_Corr_TTSig_Part", "Events w. TT_{Sig}: #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH2F, {deltaPhiAngle, jetPTcorr}); - spectra.add("hDPhi_JetPt_TTRef_Part", "Events w. TT_{Ref}: #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH2F, {deltaPhiAngle, pT}); - spectra.add("hDPhi_JetPt_TTSig_Part", "Events w. TT_{Sig}: #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH2F, {deltaPhiAngle, pT}); - - spectra.add("hRecoil_JetPt_Corr_TTRef_Part", "Events w. TT_{Ref}: #it{p}_{T} of recoil jets", kTH1F, {jetPTcorr}); - spectra.add("hRecoil_JetPt_Corr_TTSig_Part", "Events w. TT_{Sig}: #it{p}_{T} of recoil jets", kTH1F, {jetPTcorr}); - spectra.add("hRecoil_JetPt_TTRef_Part", "Events w. TT_{Ref}: #it{p}_{T} of recoil jets", kTH1F, {pT}); - spectra.add("hRecoil_JetPt_TTSig_Part", "Events w. TT_{Sig}: #it{p}_{T} of recoil jets", kTH1F, {pT}); - - spectra.add("hDPhi_JetPt_RhoArea_TTRef_Part", "Events w. TT_{Ref}: #Delta#varphi & jet pT & #rho #times A_{jet}", kTH3F, {deltaPhiAngle, pT, rhoArea}); - spectra.add("hDPhi_JetPt_RhoArea_TTSig_Part", "Events w. TT_{Sig}: #Delta#varphi & jet pT & #rho #times A_{jet}", kTH3F, {deltaPhiAngle, pT, rhoArea}); - - // Response matrices, jet pT & jet phi resolution - spectra.add("hJetPt_PartLevel_vs_DetLevel", "Correlation jet pT at part. vs. det. levels", kTH2F, {pT, pT}); - // spectra.add("hJetPt_Corr_PartLevel_vs_DetLevel", "Correlation jet pT at part. vs. det. levels", kTH2F, {jetPTcorr, jetPTcorr}); - spectra.add("hJetPt_PartLevel_vs_DetLevel_RecoilJets", "Correlation recoil jet pT at part. vs. det. levels", kTH2F, {pT, pT}); - // spectra.add("hJetPt_Corr_PartLevel_vs_DetLevel_RecoilJets", "Correlation recoil jet pT at part. vs. det. levels", kTH2F, {jetPTcorr, jetPTcorr}); - - spectra.add("hMissedJets_pT", "Part. level jets w/o matched pair", kTH1F, {pT}); - // spectra.add("hMissedJets_Corr_pT", "Part. level jets w/o matched pair", kTH1F, {jetPTcorr}); - spectra.add("hMissedJets_pT_RecoilJets", "Part. level jets w/o matched pair", kTH1F, {pT}); - // spectra.add("hMissedJets_Corr_pT_RecoilJets", "Part. level jets w/o matched pair", kTH1F, {jetPTcorr}); - - spectra.add("hFakeJets_pT", "Det. level jets w/o matched pair", kTH1F, {pT}); - // spectra.add("hFakeJets_Corr_pT", "Det. level jets w/o matched pair", kTH1F, {jetPTcorr}); - spectra.add("hFakeJets_pT_RecoilJets", "Det. level jets w/o matched pair", kTH1F, {pT}); - // spectra.add("hFakeJets_Corr_pT_RecoilJets", "Det. level jets w/o matched pair", kTH1F, {jetPTcorr}); - - spectra.add("hJetPt_resolution", "Jet p_{T} relative resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{60, -1., 2.}, pT}); - spectra.add("hJetPt_resolution_RecoilJets", "Jet p_{T} relative resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{60, -1., 2.}, pT}); - - spectra.add("hJetPhi_resolution", "#varphi resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{40, -1., 1.}, pT}); - spectra.add("hJetPhi_resolution_RecoilJets", "#varphi resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{40, -1., 1.}, pT}); + if (doprocessMCPartLevel || doprocessMCPartLevelWeighted) { + spectra.add("hPartPtEtaPhi", "Charact. of particles", kTH3F, {pT, pseudorap, phiAngle}); + spectra.add("hNtrig_Part", "Total number of selected triggers per class", kTH1F, {{2, 0.0, 2.}}); + spectra.get(HIST("hNtrig_Part"))->GetXaxis()->SetBinLabel(1, "TT_{ref}"); + spectra.get(HIST("hNtrig_Part"))->GetXaxis()->SetBinLabel(2, "TT_{sig}"); + + spectra.add("hTTRef_per_event_Part", "Number of TT_{Ref} per event", kTH1F, {{15, 0.5, 15.5}}); + spectra.add("hTTSig_per_event_Part", "Number of TT_{Sig} per event", kTH1F, {{10, 0.5, 10.5}}); + + spectra.add("hJetPtEtaPhiRhoArea_Part", "Charact. of inclusive part. level jets", kTHnSparseF, {pT, pseudorapJets, phiAngle, rho, jetArea}); + + spectra.add("hDPhi_JetPt_Corr_TTRef_Part", "Events w. TT_{Ref}: #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH2F, {deltaPhiAngle, jetPTcorr}); + spectra.add("hDPhi_JetPt_Corr_TTSig_Part", "Events w. TT_{Sig}: #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH2F, {deltaPhiAngle, jetPTcorr}); + spectra.add("hDPhi_JetPt_TTRef_Part", "Events w. TT_{Ref}: #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH2F, {deltaPhiAngle, pT}); + spectra.add("hDPhi_JetPt_TTSig_Part", "Events w. TT_{Sig}: #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH2F, {deltaPhiAngle, pT}); + + spectra.add("hRecoil_JetPt_Corr_TTRef_Part", "Events w. TT_{Ref}: #it{p}_{T} of recoil jets", kTH1F, {jetPTcorr}); + spectra.add("hRecoil_JetPt_Corr_TTSig_Part", "Events w. TT_{Sig}: #it{p}_{T} of recoil jets", kTH1F, {jetPTcorr}); + spectra.add("hRecoil_JetPt_TTRef_Part", "Events w. TT_{Ref}: #it{p}_{T} of recoil jets", kTH1F, {pT}); + spectra.add("hRecoil_JetPt_TTSig_Part", "Events w. TT_{Sig}: #it{p}_{T} of recoil jets", kTH1F, {pT}); + + spectra.add("hJetArea_JetPt_Rho_TTRef_Part", "Events w. TT_{Ref}: A_{jet} & jet pT & #rho", kTH3F, {jetArea, pT, rho}); + spectra.add("hJetArea_JetPt_Rho_TTSig_Part", "Events w. TT_{Sig}: A_{jet} & jet pT & #rho", kTH3F, {jetArea, pT, rho}); + } + + // Jet matching: part. vs. det. + if (doprocessJetsMatched || doprocessJetsMatchedWeighted) { + spectra.add("hJetPt_PartLevel_vs_DetLevel", "Correlation jet pT at part. vs. det. levels", kTH2F, {{200, 0.0, 200.}, {200, 0.0, 200.}}); + // spectra.add("hJetPt_Corr_PartLevel_vs_DetLevel", "Correlation jet pT at part. vs. det. levels", kTH2F, {jetPTcorr, jetPTcorr}); + spectra.add("hJetPt_PartLevel_vs_DetLevel_RecoilJets", "Correlation recoil jet pT at part. vs. det. levels", kTH2F, {{200, 0.0, 200.}, {200, 0.0, 200.}}); + // spectra.add("hJetPt_Corr_PartLevel_vs_DetLevel_RecoilJets", "Correlation recoil jet pT at part. vs. det. levels", kTH2F, {jetPTcorr, jetPTcorr}); + + spectra.add("hMissedJets_pT", "Part. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}); + // spectra.add("hMissedJets_Corr_pT", "Part. level jets w/o matched pair", kTH1F, {jetPTcorr}); + // spectra.add("hMissedJets_pT_RecoilJets", "Part. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}); + // spectra.add("hMissedJets_Corr_pT_RecoilJets", "Part. level jets w/o matched pair", kTH1F, {jetPTcorr}); + + spectra.add("hFakeJets_pT", "Det. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}); + // spectra.add("hFakeJets_Corr_pT", "Det. level jets w/o matched pair", kTH1F, {jetPTcorr}); + spectra.add("hFakeJets_pT_RecoilJets", "Det. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}); + // spectra.add("hFakeJets_Corr_pT_RecoilJets", "Det. level jets w/o matched pair", kTH1F, {jetPTcorr}); + + spectra.add("hJetPt_resolution", "Jet p_{T} relative resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{100, -5., 5.}, pT}); + spectra.add("hJetPt_resolution_RecoilJets", "Jet p_{T} relative resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{100, -5., 5.}, pT}); + + spectra.add("hJetPhi_resolution", "#varphi resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{40, -1., 1.}, pT}); + spectra.add("hJetPhi_resolution_RecoilJets", "#varphi resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{40, -1., 1.}, pT}); + } } // Fill histograms with raw or MC det. level data @@ -217,7 +228,7 @@ struct RecoilJets { bSigEv = true; for (const auto& track : tracks) { - if (!jetderiveddatautilities::selectTrack(track, trackSelection)) + if (skipTrack(track)) continue; spectra.fill(HIST("hTrackPtEtaPhi"), track.pt(), track.eta(), track.phi(), weight); @@ -252,18 +263,18 @@ struct RecoilJets { if (bIsMC && (jet.pt() > pTHatMax * pTHat)) continue; - spectra.fill(HIST("hJetPtEtaPhiRhoArea"), jet.pt(), jet.eta(), jet.phi(), collision.rho() * jet.area(), weight); + spectra.fill(HIST("hJetPtEtaPhiRhoArea"), jet.pt(), jet.eta(), jet.phi(), collision.rho(), jet.area(), weight); if (nTT > 0) { - auto [dphi, bRecoil] = isRecoilJet(jet, phiTT); + auto [dphi, bRecoilJet] = isRecoilJet(jet, phiTT); if (bSigEv) { spectra.fill(HIST("hDPhi_JetPt_Corr_TTSig"), dphi, jet.pt() - collision.rho() * jet.area(), weight); spectra.fill(HIST("hDPhi_JetPt_TTSig"), dphi, jet.pt(), weight); - spectra.fill(HIST("hDPhi_JetPt_RhoArea_TTSig"), dphi, jet.pt(), collision.rho() * jet.area(), weight); + spectra.fill(HIST("hJetArea_JetPt_Rho_TTSig"), jet.area(), jet.pt(), collision.rho(), weight); - if (bRecoil) { + if (bRecoilJet) { spectra.fill(HIST("hRecoil_JetPt_Corr_TTSig"), jet.pt() - collision.rho() * jet.area(), weight); spectra.fill(HIST("hRecoil_JetPt_TTSig"), jet.pt(), weight); } @@ -271,9 +282,9 @@ struct RecoilJets { } else { spectra.fill(HIST("hDPhi_JetPt_Corr_TTRef"), dphi, jet.pt() - collision.rho() * jet.area(), weight); spectra.fill(HIST("hDPhi_JetPt_TTRef"), dphi, jet.pt(), weight); - spectra.fill(HIST("hDPhi_JetPt_RhoArea_TTRef"), dphi, jet.pt(), collision.rho() * jet.area(), weight); + spectra.fill(HIST("hJetArea_JetPt_Rho_TTRef"), jet.area(), jet.pt(), collision.rho(), weight); - if (bRecoil) { + if (bRecoilJet) { spectra.fill(HIST("hRecoil_JetPt_Corr_TTRef"), jet.pt() - collision.rho() * jet.area(), weight); spectra.fill(HIST("hRecoil_JetPt_TTRef"), jet.pt(), weight); } @@ -296,10 +307,13 @@ struct RecoilJets { bSigEv = true; for (const auto& particle : particles) { + auto pdgParticle = pdg->GetParticle(particle.pdgCode()); + if (!pdgParticle) + continue; - // Need charge and primary particles - bool bParticleNeutral = (static_cast(particle.e()) == 0); - if (bParticleNeutral || (!particle.isPhysicalPrimary())) + // Need charge and physical primary particles + bool bParticleNeutral = (static_cast(pdgParticle->Charge()) == 0); + if (bParticleNeutral || !particle.isPhysicalPrimary()) continue; spectra.fill(HIST("hPartPtEtaPhi"), particle.pt(), particle.eta(), particle.phi(), weight); @@ -333,19 +347,19 @@ struct RecoilJets { if (jet.pt() > pTHatMax * pTHat) continue; - spectra.fill(HIST("hJetPtEtaPhiRhoArea_Part"), jet.pt(), jet.eta(), jet.phi(), collision.rho() * jet.area(), weight); + spectra.fill(HIST("hJetPtEtaPhiRhoArea_Part"), jet.pt(), jet.eta(), jet.phi(), collision.rho(), jet.area(), weight); if (nTT > 0) { - auto [dphi, bRecoil] = isRecoilJet(jet, phiTT); + auto [dphi, bRecoilJet] = isRecoilJet(jet, phiTT); if (bSigEv) { spectra.fill(HIST("hDPhi_JetPt_Corr_TTSig_Part"), dphi, jet.pt() - collision.rho() * jet.area(), weight); spectra.fill(HIST("hDPhi_JetPt_TTSig_Part"), dphi, jet.pt(), weight); - spectra.fill(HIST("hDPhi_JetPt_RhoArea_TTSig_Part"), dphi, jet.pt(), collision.rho() * jet.area(), weight); + spectra.fill(HIST("hJetArea_JetPt_Rho_TTSig_Part"), jet.area(), jet.pt(), collision.rho(), weight); - if (bRecoil) { + if (bRecoilJet) { spectra.fill(HIST("hRecoil_JetPt_Corr_TTSig_Part"), jet.pt() - collision.rho() * jet.area(), weight); spectra.fill(HIST("hRecoil_JetPt_TTSig_Part"), jet.pt(), weight); } @@ -354,9 +368,9 @@ struct RecoilJets { spectra.fill(HIST("hDPhi_JetPt_Corr_TTRef_Part"), dphi, jet.pt() - collision.rho() * jet.area(), weight); spectra.fill(HIST("hDPhi_JetPt_TTRef_Part"), dphi, jet.pt(), weight); - spectra.fill(HIST("hDPhi_JetPt_RhoArea_TTRef_Part"), dphi, jet.pt(), collision.rho() * jet.area(), weight); + spectra.fill(HIST("hJetArea_JetPt_Rho_TTRef_Part"), jet.area(), jet.pt(), collision.rho(), weight); - if (bRecoil) { + if (bRecoilJet) { spectra.fill(HIST("hRecoil_JetPt_Corr_TTRef_Part"), jet.pt() - collision.rho() * jet.area(), weight); spectra.fill(HIST("hRecoil_JetPt_TTRef_Part"), jet.pt(), weight); } @@ -374,7 +388,7 @@ struct RecoilJets { float pTHat = getPtHat(weight); for (const auto& track : tracks) { - if (!jetderiveddatautilities::selectTrack(track, trackSelection)) + if (skipTrack(track)) continue; if (track.pt() > ptTTsigMin && track.pt() < ptTTsigMax) { @@ -390,7 +404,7 @@ struct RecoilJets { if (jet_det_level.pt() > pTHatMax * pTHat) continue; - bool bRecoil = get<1>(isRecoilJet(jet_det_level, phiTT)) && bTT; + bool bRecoilJet = get<1>(isRecoilJet(jet_det_level, phiTT)) && bTT; if (jet_det_level.has_matchedJetGeo()) { @@ -411,7 +425,7 @@ struct RecoilJets { spectra.fill(HIST("hJetPt_resolution"), (jet_matched_part_level.pt() - jet_det_level.pt()) / jet_matched_part_level.pt(), jet_matched_part_level.pt(), weight); spectra.fill(HIST("hJetPhi_resolution"), jet_matched_part_level.phi() - jet_det_level.phi(), jet_matched_part_level.pt(), weight); - if (bRecoil) { + if (bRecoilJet) { spectra.fill(HIST("hJetPt_PartLevel_vs_DetLevel_RecoilJets"), jet_det_level.pt(), jet_matched_part_level.pt(), weight); spectra.fill(HIST("hJetPt_resolution_RecoilJets"), (jet_matched_part_level.pt() - jet_det_level.pt()) / jet_matched_part_level.pt(), jet_matched_part_level.pt(), weight); spectra.fill(HIST("hJetPhi_resolution_RecoilJets"), jet_matched_part_level.phi() - jet_det_level.phi(), jet_matched_part_level.pt(), weight); @@ -419,7 +433,7 @@ struct RecoilJets { } } else { spectra.fill(HIST("hFakeJets_pT"), jet_det_level.pt(), weight); - if (bRecoil) + if (bRecoilJet) spectra.fill(HIST("hFakeJets_pT_RecoilJets"), jet_det_level.pt(), weight); } } @@ -445,8 +459,8 @@ struct RecoilJets { PROCESS_SWITCH(RecoilJets, processData, "process data", true); void processMCDetLevel(FilteredColl const& collision, - FilteredJetsDetLevel const& jets, - FilteredTracks const& tracks) + FilteredTracks const& tracks, + FilteredJetsDetLevel const& jets) { if (skipEvent(collision)) return; @@ -458,22 +472,22 @@ struct RecoilJets { void processMCDetLevelWeighted(FilteredCollDetLevelGetWeight const& collision, aod::JetMcCollisions const&, - FilteredJetsDetLevel const& jets, - FilteredTracks const& tracks) + FilteredTracks const& tracks, + FilteredJetsDetLevel const& jets) { if (skipEvent(collision)) return; /// \TODO: should we implement function to check whether Collision was reconstructed (has_mcCollision() function)? Example: https://github.com/AliceO2Group/O2Physics/blob/1cba330514ab47c15c0095d8cee9633723d8e2a7/PWGJE/Tasks/v0qa.cxx#L166? - auto weight = collision.mcCollision().weight(); // "mcCollision" where is defined? + auto weight = collision.mcCollision().weight(); spectra.fill(HIST("vertexZ"), collision.posZ(), weight); fillHistograms(collision, jets, tracks, true, weight); } PROCESS_SWITCH(RecoilJets, processMCDetLevelWeighted, "process MC detector level with event weight", false); void processMCPartLevel(FilteredCollPartLevel const& collision, - FilteredJetsPartLevel const& jets, - aod::JetParticles const& particles) + aod::JetParticles const& particles, + FilteredJetsPartLevel const& jets) { spectra.fill(HIST("vertexZ"), collision.posZ()); fillMCPHistograms(collision, jets, particles); @@ -481,8 +495,8 @@ struct RecoilJets { PROCESS_SWITCH(RecoilJets, processMCPartLevel, "process MC particle level", false); void processMCPartLevelWeighted(FilteredCollPartLevel const& collision, - FilteredJetsPartLevel const& jets, - aod::JetParticles const& particles) + aod::JetParticles const& particles, + FilteredJetsPartLevel const& jets) { auto weight = collision.weight(); spectra.fill(HIST("vertexZ"), collision.posZ(), weight); @@ -528,6 +542,12 @@ struct RecoilJets { return !jetderiveddatautilities::selectCollision(coll, eventSelectionBits) || !jetderiveddatautilities::selectTrigger(coll, triggerMaskBits); } + template + bool skipTrack(const Track& track) + { + return !jetderiveddatautilities::selectTrack(track, trackSelection); + } + template std::tuple isRecoilJet(const Jet& jet, double phiTT) From 609d1b9a0bef5fb92599c28c69700262a197174a Mon Sep 17 00:00:00 2001 From: omassen <55696099+omassen@users.noreply.github.com> Date: Thu, 6 Feb 2025 15:56:25 +0100 Subject: [PATCH 17/30] [PWGCF] Implement new Run3 centrality estimators and expand analysis (#9786) Co-authored-by: ALICE Action Bot --- .../Tasks/neutronProtonCorrZdc.cxx | 133 ++++++++++++++---- 1 file changed, 107 insertions(+), 26 deletions(-) diff --git a/PWGCF/TwoParticleCorrelations/Tasks/neutronProtonCorrZdc.cxx b/PWGCF/TwoParticleCorrelations/Tasks/neutronProtonCorrZdc.cxx index 1b51265f19e..aaff25b6b95 100644 --- a/PWGCF/TwoParticleCorrelations/Tasks/neutronProtonCorrZdc.cxx +++ b/PWGCF/TwoParticleCorrelations/Tasks/neutronProtonCorrZdc.cxx @@ -19,7 +19,6 @@ #include "Framework/ASoAHelpers.h" #include "Common/DataModel/TrackSelectionTables.h" #include "Common/DataModel/EventSelection.h" -#include "Common/DataModel/PIDResponse.h" #include "Common/DataModel/Centrality.h" #include "Common/DataModel/Multiplicity.h" #include "Framework/StaticFor.h" @@ -49,12 +48,14 @@ struct NeutronProtonCorrZdc { Configurable cfgAlphaZmin{"cfgAlphaZmin", -1, "Minimum value for ZDC asymmetry"}; Configurable cfgAlphaZmax{"cfgAlphaZmax", 1, "Maximum value for ZDC asymmetry"}; Configurable cfgMaxCentrality{"cfgMaxCentrality", 80, "Maximum collision centrality"}; + Configurable cfgCentralityEstimator{"cfgCentralityEstimator", 0, "Choice of centrality estimator"}; + Configurable cfgNBinsMultiplicity{"cfgNBinsMultiplicity", 1000, "N bins for multiplicity histograms"}; ConfigurableAxis cfgAxisCent{"cfgAxisCent", {VARIABLE_WIDTH, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0, 33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0, 49.0, 50.0, 51.0, 52.0, 53.0, 54.0, 55.0, 56.0, 57.0, 58.0, 59.0, 60.0, 61.0, 62.0, 63.0, 64.0, 65.0, 66.0, 67.0, 68.0, 69.0, 70.0, 71.0, 72.0, 73.0, 74.0, 75.0, 76.0, 77.0, 78.0, 79.0, 80.0, 81.0, 82.0, 83.0, 84.0, 85.0, 86.0, 87.0, 88.0, 89.0, 90.0, 91.0, 92.0, 93.0, 94.0, 95.0, 96.0, 97.0, 98.0, 99.0, 100.0}, "Centrality [%]"}; Filter collisionVtxZ = nabs(aod::collision::posZ) < 10.f; - using CentralitiesRun3 = aod::CentFT0Cs; + using CentralitiesRun3 = soa::Join; using CentralitiesRun2 = aod::CentRun2V0Ms; using BCsRun3 = soa::Join; @@ -72,6 +73,12 @@ struct NeutronProtonCorrZdc { const AxisSpec axisZPSignal{2 * cfgNBinsZP, cfgZPmin, 1.5 * cfgZPmax, "ZP (a.u.)"}; const AxisSpec axisAlphaZ{cfgNBinsAlpha, cfgAlphaZmin, cfgAlphaZmax, "#alpha_{spec}"}; const AxisSpec axisZDiffSignal{cfgNBinsZN, cfgDiffZmin, cfgDiffZmax, "#Delta E"}; + const AxisSpec axisMultiplicityF0A{cfgNBinsMultiplicity, 0, 200000, "F0A"}; + const AxisSpec axisMultiplicityF0C{cfgNBinsMultiplicity, 0, 100000, "F0C"}; + const AxisSpec axisMultiplicityF0M{cfgNBinsMultiplicity, 0, 300000, "F0M"}; + const AxisSpec axisMultiplicityFDD{cfgNBinsMultiplicity, 0, 50000, "FDD"}; + const AxisSpec axisMultiplicityTPC{cfgNBinsMultiplicity, 0, 100000, "TPC"}; + const AxisSpec axisMultiplicityMultNGlobal{cfgNBinsMultiplicity, 0, 3500, "MultsNGlobal"}; HistogramConfigSpec defaultZNSectorHist({HistType::kTH2F, {cfgAxisCent, axisZNSectorSignal}}); HistogramConfigSpec defaultZPSectorHist({HistType::kTH2F, {cfgAxisCent, axisZPSectorSignal}}); @@ -107,9 +114,49 @@ struct NeutronProtonCorrZdc { histos.add("CentvsAlphaZP", "CentvsAlphaZP", kTH2F, {cfgAxisCent, axisAlphaZ}); histos.add("CentvsDiffZNSignal", "CentvsDiffZNSignal", defaultZDCDiffHist); histos.add("CentvsDiffZPSignal", "CentvsDiffZPSignal", defaultZDCDiffHist); + histos.add("CentvsZNAvsZNC", "CentvsZNAvsZNC", kTH3F, {cfgAxisCent, axisZNASignal, axisZNCSignal}); + histos.add("CentvsZNAvsZPA", "CentvsZNAvsZPA", kTH3F, {cfgAxisCent, axisZNASignal, axisZPASignal}); + histos.add("CentvsZNAvsZPC", "CentvsZNAvsZPC", kTH3F, {cfgAxisCent, axisZNASignal, axisZPCSignal}); + histos.add("CentvsZPAvsZNC", "CentvsZPAvsZNC", kTH3F, {cfgAxisCent, axisZPASignal, axisZNCSignal}); + histos.add("CentvsZPAvsZPC", "CentvsZNAvsZPC", kTH3F, {cfgAxisCent, axisZPASignal, axisZPCSignal}); + histos.add("CentvsZNCvsZPC", "CentvsZNCvsZPC", kTH3F, {cfgAxisCent, axisZNCSignal, axisZPCSignal}); + histos.add("CentvsZNvsZP", "CentvsZNvsZP", kTH3F, {cfgAxisCent, axisZNSignal, axisZPSignal}); + + histos.add("MultiplicityHistograms/FV0A", "FV0A", kTH1F, {axisMultiplicityF0A}); + histos.add("MultiplicityHistograms/FT0A", "FT0A", kTH1F, {axisMultiplicityF0A}); + histos.add("MultiplicityHistograms/FT0C", "FT0C", kTH1F, {axisMultiplicityF0C}); + histos.add("MultiplicityHistograms/FDDA", "FDDA", kTH1F, {axisMultiplicityFDD}); + histos.add("MultiplicityHistograms/FDDC", "FDDC", kTH1F, {axisMultiplicityFDD}); + histos.add("MultiplicityHistograms/TPC", "TPC", kTH1F, {axisMultiplicityTPC}); + histos.add("MultiplicityHistograms/NGlobal", "NGlobal", kTH1F, {axisMultiplicityMultNGlobal}); + histos.add("MultiplicityHistograms/CentvsFT0C", "CentvsFT0C", kTH2F, {cfgAxisCent, axisMultiplicityF0C}); + histos.add("MultiplicityHistograms/CentvsFT0CVar1", "CentvsFT0CVar1", kTH2F, {cfgAxisCent, axisMultiplicityF0C}); + histos.add("MultiplicityHistograms/CentvsFT0M", "CentvsFT0M", kTH2F, {cfgAxisCent, axisMultiplicityF0M}); + histos.add("MultiplicityHistograms/CentvsFV0A", "CentvsFV0A", kTH2F, {cfgAxisCent, axisMultiplicityF0A}); + histos.add("MultiplicityHistograms/CentvsNGlobal", "CentvsNGlobal", kTH2F, {cfgAxisCent, axisMultiplicityMultNGlobal}); } + + template + void fillMultHistosRun3(const C& col) + { + static constexpr std::string_view MultLabels[] = {"FT0C", "FT0A", "FV0A", "FDDC", "FDDA", "TPC", "NGlobal"}; + std::array multarray = {col.multFT0C(), col.multFT0A(), col.multFV0A(), col.multFDDC(), col.multFDDA(), static_cast(col.multTPC()), static_cast(col.multNTracksGlobal())}; + + histos.fill(HIST("MultiplicityHistograms/") + HIST(MultLabels[mult]), multarray[mult]); + } + + template + void fillCentHistosRun3(const C& col) + { + static constexpr std::string_view CentLabels[] = {"CentvsFT0C", "CentvsFT0CVar1", "CentvsFT0M", "CentvsFV0A", "CentvsNGlobal"}; + std::array centarray = {col.centFT0C(), col.centFT0CVariant1(), col.centFT0M(), col.centFV0A(), col.centNGlobal()}; + std::array multarray = {col.multFT0C(), col.multFT0C(), col.multFT0C() + col.multFT0A(), col.multFV0A(), static_cast(col.multNTracksGlobal())}; + + histos.fill(HIST("MultiplicityHistograms/") + HIST(CentLabels[cent]), centarray[cent], multarray[cent]); + } + template - void fillZDCHistos(const float centr, const Z& zdc) + void fillZDCSideCommonHistos(const float centr, const Z& zdc) { static constexpr std::string_view SubDir[] = {"ASide/", "CSide/"}; @@ -118,52 +165,66 @@ struct NeutronProtonCorrZdc { std::array znEnergyResponseCommon = {zdc.energyCommonZNA(), zdc.energyCommonZNC()}; std::array zpEnergyResponseCommon = {zdc.energyCommonZPA(), zdc.energyCommonZPC()}; - // Fill Neutron ZDC historgrams - histos.fill(HIST(SubDir[side]) + HIST("CentvsZNSector0Signal"), centr, znEnergyResponse[side][0]); - histos.fill(HIST(SubDir[side]) + HIST("CentvsZNSector1Signal"), centr, znEnergyResponse[side][1]); - histos.fill(HIST(SubDir[side]) + HIST("CentvsZNSector2Signal"), centr, znEnergyResponse[side][2]); - histos.fill(HIST(SubDir[side]) + HIST("CentvsZNSector3Signal"), centr, znEnergyResponse[side][3]); - float sumZN = znEnergyResponse[side][0] + znEnergyResponse[side][1] + znEnergyResponse[side][2] + znEnergyResponse[side][3]; + float sumZP = zpEnergyResponse[side][0] + zpEnergyResponse[side][1] + zpEnergyResponse[side][2] + zpEnergyResponse[side][3]; histos.fill(HIST(SubDir[side]) + HIST("CentvsZNSignalSum"), centr, sumZN); histos.fill(HIST(SubDir[side]) + HIST("CentvsZNSignalCommon"), centr, znEnergyResponseCommon[side]); histos.fill(HIST(SubDir[side]) + HIST("CentvsdiffZNSignal"), centr, sumZN - znEnergyResponseCommon[side]); - - // Fill Proton ZDC histograms - histos.fill(HIST(SubDir[side]) + HIST("CentvsZPSector0Signal"), centr, zpEnergyResponse[side][0]); - histos.fill(HIST(SubDir[side]) + HIST("CentvsZPSector1Signal"), centr, zpEnergyResponse[side][1]); - histos.fill(HIST(SubDir[side]) + HIST("CentvsZPSector2Signal"), centr, zpEnergyResponse[side][2]); - histos.fill(HIST(SubDir[side]) + HIST("CentvsZPSector3Signal"), centr, zpEnergyResponse[side][3]); - - float sumZP = zpEnergyResponse[side][0] + zpEnergyResponse[side][1] + zpEnergyResponse[side][2] + zpEnergyResponse[side][3]; - histos.fill(HIST(SubDir[side]) + HIST("CentvsZPSignalSum"), centr, sumZP); histos.fill(HIST(SubDir[side]) + HIST("CentvsZPSignalCommon"), centr, zpEnergyResponseCommon[side]); histos.fill(HIST(SubDir[side]) + HIST("CentvsdiffZPSignal"), centr, sumZP - zpEnergyResponseCommon[side]); } - void processRun3(soa::Filtered>::iterator const& collision, BCsRun3 const&, aod::Zdcs const&) + template + void fillZDCSideSectorHistos(const float centr, const Z& zdc) + { + static constexpr std::string_view SubDir[] = {"ASide/", "CSide/"}; + static constexpr std::string_view ZNSector[] = {"CentvsZNSector0Signal", "CentvsZNSector1Signal", "CentvsZNSector2Signal", "CentvsZNSector3Signal"}; + static constexpr std::string_view ZPSector[] = {"CentvsZPSector0Signal", "CentvsZPSector1Signal", "CentvsZPSector2Signal", "CentvsZPSector3Signal"}; + + std::array, 2> znEnergyResponse = {zdc.energySectorZNA(), zdc.energySectorZNC()}; + std::array, 2> zpEnergyResponse = {zdc.energySectorZPA(), zdc.energySectorZPC()}; + + histos.fill(HIST(SubDir[side]) + HIST(ZNSector[sector]), centr, znEnergyResponse[side][sector]); + histos.fill(HIST(SubDir[side]) + HIST(ZPSector[sector]), centr, zpEnergyResponse[side][sector]); + } + + void processRun3(soa::Filtered>::iterator const& collision, BCsRun3 const&, aod::Zdcs const&) { histos.fill(HIST("eventCounter"), EventCounter::kNoSelection); if (!collision.sel8()) { return; } histos.fill(HIST("eventCounter"), EventCounter::kQualitySelection); - if (collision.centFT0C() > cfgMaxCentrality) { + + const float centArray[] = {collision.centFT0C(), collision.centFT0CVariant1(), collision.centFT0M(), collision.centFV0A(), collision.centNGlobal()}; + const auto cent = centArray[cfgCentralityEstimator]; + if (cent > cfgMaxCentrality) { return; } histos.fill(HIST("eventCounter"), EventCounter::kMaxCentralitySelection); + const auto& foundBC = collision.foundBC_as(); if (foundBC.has_zdc()) { const auto& zdcread = foundBC.zdc(); - const auto cent = collision.centFT0C(); - histos.fill(HIST("eventCounter"), EventCounter::kZDCSelection); histos.fill(HIST("CentralityPercentile"), cent); - fillZDCHistos<0>(cent, zdcread); // Fill A-side - fillZDCHistos<1>(cent, zdcread); // Fill C-side + static_for<0, 6>([&](auto i) { + fillMultHistosRun3(collision); // Fill multiplicity histograms + }); + + static_for<0, 4>([&](auto i) { + fillCentHistosRun3(collision); // Fill centrality histograms + }); + + static_for<0, 1>([&](auto i) { + fillZDCSideCommonHistos(cent, zdcread); // Fill i-side common histograms + static_for<0, 3>([&](auto j) { + fillZDCSideSectorHistos(cent, zdcread); // Fill i-side sector j histograms + }); + }); float sumZNC = (zdcread.energySectorZNC())[0] + (zdcread.energySectorZNC())[1] + (zdcread.energySectorZNC())[2] + (zdcread.energySectorZNC())[3]; float sumZNA = (zdcread.energySectorZNA())[0] + (zdcread.energySectorZNA())[1] + (zdcread.energySectorZNA())[2] + (zdcread.energySectorZNA())[3]; @@ -181,6 +242,14 @@ struct NeutronProtonCorrZdc { histos.fill(HIST("CentvsZPSignalCommon"), cent, (zdcread.energyCommonZPA() + zdcread.energyCommonZPC())); histos.fill(HIST("CentvsAlphaZN"), cent, alphaZN); histos.fill(HIST("CentvsAlphaZP"), cent, alphaZP); + + histos.fill(HIST("CentvsZNAvsZNC"), cent, sumZNA, sumZNC); + histos.fill(HIST("CentvsZNAvsZPA"), cent, sumZNA, sumZPA); + histos.fill(HIST("CentvsZNAvsZPC"), cent, sumZNA, sumZPC); + histos.fill(HIST("CentvsZPAvsZNC"), cent, sumZPA, sumZNC); + histos.fill(HIST("CentvsZPAvsZPC"), cent, sumZPA, sumZPC); + histos.fill(HIST("CentvsZNCvsZPC"), cent, sumZNC, sumZPC); + histos.fill(HIST("CentvsZNvsZP"), cent, sumZNA + sumZNC, sumZPA + sumZPC); } } PROCESS_SWITCH(NeutronProtonCorrZdc, processRun3, "Process analysis for Run 3 data", true); @@ -204,8 +273,12 @@ struct NeutronProtonCorrZdc { histos.fill(HIST("eventCounter"), EventCounter::kZDCSelection); histos.fill(HIST("CentralityPercentile"), cent); - fillZDCHistos<0>(cent, zdcread); // Fill A-side - fillZDCHistos<1>(cent, zdcread); // Fill C-side + static_for<0, 1>([&](auto i) { + fillZDCSideCommonHistos(cent, zdcread); // Fill i-side common channels + static_for<0, 3>([&](auto j) { + fillZDCSideSectorHistos(cent, zdcread); // Fill i-side sector j + }); + }); float sumZNC = (zdcread.energySectorZNC())[0] + (zdcread.energySectorZNC())[1] + (zdcread.energySectorZNC())[2] + (zdcread.energySectorZNC())[3]; float sumZNA = (zdcread.energySectorZNA())[0] + (zdcread.energySectorZNA())[1] + (zdcread.energySectorZNA())[2] + (zdcread.energySectorZNA())[3]; @@ -223,6 +296,14 @@ struct NeutronProtonCorrZdc { histos.fill(HIST("CentvsZPSignalCommon"), cent, (zdcread.energyCommonZPA() + zdcread.energyCommonZPC())); histos.fill(HIST("CentvsAlphaZN"), cent, alphaZN); histos.fill(HIST("CentvsAlphaZP"), cent, alphaZP); + + histos.fill(HIST("CentvsZNAvsZNC"), cent, sumZNA, sumZNC); + histos.fill(HIST("CentvsZNAvsZPA"), cent, sumZNA, sumZPA); + histos.fill(HIST("CentvsZNAvsZPC"), cent, sumZNA, sumZPC); + histos.fill(HIST("CentvsZPAvsZNC"), cent, sumZPA, sumZNC); + histos.fill(HIST("CentvsZPAvsZPC"), cent, sumZPA, sumZPC); + histos.fill(HIST("CentvsZNCvsZPC"), cent, sumZNC, sumZPC); + histos.fill(HIST("CentvsZNvsZP"), cent, sumZNA + sumZNC, sumZPA + sumZPC); } } PROCESS_SWITCH(NeutronProtonCorrZdc, processRun2, "Process analysis for Run 2 converted data", false); From 30059024a5cd6011bde5cce16f1587be2ef65998 Mon Sep 17 00:00:00 2001 From: JStaa <39123272+JStaa@users.noreply.github.com> Date: Thu, 6 Feb 2025 16:01:04 +0100 Subject: [PATCH 18/30] [PWGCF] Added a check to ensure the efficiency is greater than zero (#9784) --- .../Tasks/threeParticleCorrelations.cxx | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/PWGCF/MultiparticleCorrelations/Tasks/threeParticleCorrelations.cxx b/PWGCF/MultiparticleCorrelations/Tasks/threeParticleCorrelations.cxx index 68cd80461ad..f0d72cfccf8 100644 --- a/PWGCF/MultiparticleCorrelations/Tasks/threeParticleCorrelations.cxx +++ b/PWGCF/MultiparticleCorrelations/Tasks/threeParticleCorrelations.cxx @@ -482,7 +482,12 @@ struct ThreeParticleCorrelations { index = 1; } - return efficiencies[index]->GetBinContent(efficiencies[index]->FindBin(pT)); + double efficiency = efficiencies[index]->GetBinContent(efficiencies[index]->FindBin(pT)); + if (efficiency > 0) { + return efficiency; + } else { + return 1.0; + } } template @@ -706,7 +711,7 @@ struct ThreeParticleCorrelations { } } - if (std::abs(dPhiStar) <= 0.1) { + if (std::abs(dPhiStar) < 0.1) { return kFALSE; } @@ -723,7 +728,7 @@ struct ThreeParticleCorrelations { } }; -//========================================================================================================================================================================================================================================================================== +//============================================================================================================================================================================================================================================================================ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { @@ -731,4 +736,4 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) return workflow; } -//========================================================================================================================================================================================================================================================================== +//============================================================================================================================================================================================================================================================================ From 04613a1dd8291c7f6ff9984bfc020473a69f279b Mon Sep 17 00:00:00 2001 From: jaelpark Date: Thu, 6 Feb 2025 16:44:51 +0100 Subject: [PATCH 19/30] [PWGCF] new PbPb centrality estimators for correlations filter (#9789) --- PWGCF/TableProducer/filterCorrelations.cxx | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/PWGCF/TableProducer/filterCorrelations.cxx b/PWGCF/TableProducer/filterCorrelations.cxx index 3d424dc38bf..5166db4ead0 100644 --- a/PWGCF/TableProducer/filterCorrelations.cxx +++ b/PWGCF/TableProducer/filterCorrelations.cxx @@ -362,6 +362,14 @@ struct MultiplicitySelector { } PROCESS_SWITCH(MultiplicitySelector, processFT0C, "Select FT0C centrality as multiplicity", false); + void processFT0CVariant1(aod::CentFT0CVariant1s const& centralities) + { + for (auto& c : centralities) { + output(c.centFT0CVariant1()); + } + } + PROCESS_SWITCH(MultiplicitySelector, processFT0CVariant1, "Select FT0CVariant1 centrality as multiplicity", false); + void processFT0A(aod::CentFT0As const& centralities) { for (auto& c : centralities) { @@ -370,6 +378,14 @@ struct MultiplicitySelector { } PROCESS_SWITCH(MultiplicitySelector, processFT0A, "Select FT0A centrality as multiplicity", false); + void processCentNGlobal(aod::CentNGlobals const& centralities) + { + for (auto& c : centralities) { + output(c.centNGlobal()); + } + } + PROCESS_SWITCH(MultiplicitySelector, processCentNGlobal, "Select CentNGlobal centrality as multiplicity", false); + void processRun2V0M(aod::CentRun2V0Ms const& centralities) { for (auto& c : centralities) { From 122fe0f0760424771758ff37d444c55f342bf597 Mon Sep 17 00:00:00 2001 From: Francesco Mazzaschi <43742195+fmazzasc@users.noreply.github.com> Date: Thu, 6 Feb 2025 17:22:27 +0100 Subject: [PATCH 20/30] Fix process function for tracked MC candidates (#9793) Co-authored-by: Francesco Mazzaschi --- PWGLF/TableProducer/Nuspex/hyperRecoTask.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGLF/TableProducer/Nuspex/hyperRecoTask.cxx b/PWGLF/TableProducer/Nuspex/hyperRecoTask.cxx index 4f38b0bd350..5d176dfecba 100644 --- a/PWGLF/TableProducer/Nuspex/hyperRecoTask.cxx +++ b/PWGLF/TableProducer/Nuspex/hyperRecoTask.cxx @@ -256,7 +256,7 @@ struct hyperRecoTask { hEventsZorro->GetXaxis()->SetBinLabel(1, "Zorro before evsel"); hEventsZorro->GetXaxis()->SetBinLabel(2, "Zorro after evsel"); - if (doprocessMC) { + if (doprocessMC || doprocessMCTracked) { hDecayChannel = qaRegistry.add("hDecayChannel", ";Decay channel; ", HistType::kTH1D, {{2, -0.5, 1.5}}); hDecayChannel->GetXaxis()->SetBinLabel(1, "2-body"); hDecayChannel->GetXaxis()->SetBinLabel(2, "3-body"); From eeedbaa3531cd6e2bee1668b11a7fe01d9490d73 Mon Sep 17 00:00:00 2001 From: Zhiyong <71517277+Luzhiyongg@users.noreply.github.com> Date: Fri, 7 Feb 2025 00:55:21 +0800 Subject: [PATCH 21/30] [PWGCF] flow-runbyrun: retrieve code, wrong if-else logic (#9790) --- PWGCF/Flow/Tasks/flowRunbyRun.cxx | 7 ------- 1 file changed, 7 deletions(-) diff --git a/PWGCF/Flow/Tasks/flowRunbyRun.cxx b/PWGCF/Flow/Tasks/flowRunbyRun.cxx index 31f2c546450..d78a279f06e 100644 --- a/PWGCF/Flow/Tasks/flowRunbyRun.cxx +++ b/PWGCF/Flow/Tasks/flowRunbyRun.cxx @@ -329,13 +329,6 @@ struct FlowRunbyRun { } weight->fill(track.phi(), track.eta(), collision.posZ(), track.pt(), cent, 0); } - } else { - GFWWeights* weight = fGFWWeightsList->getGFWWeightsByRun(runNumber); - if (!weight) { - LOGF(fatal, "Could not find the weight for run %d", runNumber); - return; - } - weight->fill(track.phi(), track.eta(), collision.posZ(), track.pt(), cent, 0); } } From fc09600167efd6700b10f19c758ecb7e28477a55 Mon Sep 17 00:00:00 2001 From: Daiki Sekihata Date: Fri, 7 Feb 2025 03:04:52 +0900 Subject: [PATCH 22/30] [PWGEM/Dilepton] update 2vp task (#9791) --- .../TableProducer/filterDielectronEvent.cxx | 54 +++++++++---------- PWGEM/Dilepton/Tasks/eventQC.cxx | 42 ++++++--------- 2 files changed, 43 insertions(+), 53 deletions(-) diff --git a/PWGEM/Dilepton/TableProducer/filterDielectronEvent.cxx b/PWGEM/Dilepton/TableProducer/filterDielectronEvent.cxx index a3257b8715f..fcf1feb5c21 100644 --- a/PWGEM/Dilepton/TableProducer/filterDielectronEvent.cxx +++ b/PWGEM/Dilepton/TableProducer/filterDielectronEvent.cxx @@ -167,7 +167,7 @@ struct filterDielectronEvent { if (d_bz_input > -990) { d_bz = d_bz_input; o2::parameters::GRPMagField grpmag; - if (fabs(d_bz) > 1e-5) { + if (std::fabs(d_bz) > 1e-5) { grpmag.setL3Current(30000.f / (d_bz / 5.0f)); } o2::base::Propagator::initFieldFromGRP(&grpmag); @@ -250,11 +250,11 @@ struct filterDielectronEvent { float dcaXY = dcaInfo[0]; float dcaZ = dcaInfo[1]; - if (fabs(dcaXY) > dca_xy_max || fabs(dcaZ) > dca_z_max) { + if (std::fabs(dcaXY) > dca_xy_max || std::fabs(dcaZ) > dca_z_max) { return false; } - if (track_par_cov_recalc.getPt() < minpt || fabs(track_par_cov_recalc.getEta()) > maxeta) { + if (track_par_cov_recalc.getPt() < minpt || std::fabs(track_par_cov_recalc.getEta()) > maxeta) { return false; } @@ -264,7 +264,7 @@ struct filterDielectronEvent { dca_3d = 999.f; } else { float chi2 = (dcaXY * dcaXY * track_par_cov_recalc.getSigmaZ2() + dcaZ * dcaZ * track_par_cov_recalc.getSigmaY2() - 2. * dcaXY * dcaZ * track_par_cov_recalc.getSigmaZY()) / det; - dca_3d = std::sqrt(fabs(chi2) / 2.); + dca_3d = std::sqrt(std::fabs(chi2) / 2.); } if (dca_3d > dca_3d_sigma_max) { return false; @@ -294,7 +294,7 @@ struct filterDielectronEvent { if (minTPCNsigmaPr < track.tpcNSigmaPr() && track.tpcNSigmaPr() < maxTPCNsigmaPr) { return false; } - if (track.hasTOF() && (maxTOFNsigmaEl < fabs(track.tofNSigmaEl()))) { + if (track.hasTOF() && (maxTOFNsigmaEl < std::fabs(track.tofNSigmaEl()))) { return false; } return true; @@ -306,7 +306,7 @@ struct filterDielectronEvent { if (minTPCNsigmaPi < track.tpcNSigmaPi() && track.tpcNSigmaPi() < maxTPCNsigmaPi && track.tpcInnerParam() < max_pin_for_pion_rejection) { return false; } - return minTPCNsigmaEl < track.tpcNSigmaEl() && track.tpcNSigmaEl() < maxTPCNsigmaEl && fabs(track.tofNSigmaEl()) < maxTOFNsigmaEl; + return minTPCNsigmaEl < track.tpcNSigmaEl() && track.tpcNSigmaEl() < maxTPCNsigmaEl && std::fabs(track.tofNSigmaEl()) < maxTOFNsigmaEl; } template @@ -373,9 +373,9 @@ struct filterDielectronEvent { fRegistry.fill(HIST("Track/hRelSigma1Pt"), pt_recalc, std::sqrt(track_par_cov_recalc.getSigma1Pt2()) * pt_recalc); fRegistry.fill(HIST("Track/hEtaPhi"), phi_recalc, eta_recalc); fRegistry.fill(HIST("Track/hDCAxyz"), dcaXY, dcaZ); - fRegistry.fill(HIST("Track/hDCAxyzSigma"), dcaXY / sqrt(track_par_cov_recalc.getSigmaY2()), dcaZ / sqrt(track_par_cov_recalc.getSigmaZ2())); - fRegistry.fill(HIST("Track/hDCAxyRes_Pt"), pt_recalc, sqrt(track_par_cov_recalc.getSigmaY2()) * 1e+4); // convert cm to um - fRegistry.fill(HIST("Track/hDCAzRes_Pt"), pt_recalc, sqrt(track_par_cov_recalc.getSigmaZ2()) * 1e+4); // convert cm to um + fRegistry.fill(HIST("Track/hDCAxyzSigma"), dcaXY / std::sqrt(track_par_cov_recalc.getSigmaY2()), dcaZ / std::sqrt(track_par_cov_recalc.getSigmaZ2())); + fRegistry.fill(HIST("Track/hDCAxyRes_Pt"), pt_recalc, std::sqrt(track_par_cov_recalc.getSigmaY2()) * 1e+4); // convert cm to um + fRegistry.fill(HIST("Track/hDCAzRes_Pt"), pt_recalc, std::sqrt(track_par_cov_recalc.getSigmaZ2()) * 1e+4); // convert cm to um fRegistry.fill(HIST("Track/hNclsITS"), track.itsNCls()); fRegistry.fill(HIST("Track/hNclsTPC"), track.tpcNClsFound()); fRegistry.fill(HIST("Track/hNcrTPC"), track.tpcNClsCrossedRows()); @@ -415,7 +415,7 @@ struct filterDielectronEvent { } std::vector> stored_trackIds; - std::vector> stored_pairIds; + // std::vector> stored_pairIds; Filter trackFilter = o2::aod::track::pt > minpt&& nabs(o2::aod::track::eta) < maxeta&& o2::aod::track::tpcChi2NCl < maxchi2tpc&& o2::aod::track::itsChi2NCl < maxchi2its&& ncheckbit(aod::track::v001::detectorMap, (uint8_t)o2::aod::track::ITS) == true && ncheckbit(aod::track::v001::detectorMap, (uint8_t)o2::aod::track::TPC) == true; Filter pidFilter = minTPCNsigmaEl < o2::aod::pidtpc::tpcNSigmaEl && o2::aod::pidtpc::tpcNSigmaEl < maxTPCNsigmaEl; using MyFilteredTracks = soa::Filtered; @@ -512,8 +512,8 @@ struct filterDielectronEvent { stored_trackIds.clear(); stored_trackIds.shrink_to_fit(); - stored_pairIds.clear(); - stored_pairIds.shrink_to_fit(); + // stored_pairIds.clear(); + // stored_pairIds.shrink_to_fit(); } PROCESS_SWITCH(filterDielectronEvent, processRec_SA, "process reconstructed info only", true); // standalone @@ -645,8 +645,8 @@ struct filterDielectronEvent { stored_trackIds.clear(); stored_trackIds.shrink_to_fit(); - stored_pairIds.clear(); - stored_pairIds.shrink_to_fit(); + // stored_pairIds.clear(); + // stored_pairIds.shrink_to_fit(); } PROCESS_SWITCH(filterDielectronEvent, processRec_TTCA, "process reconstructed info only", false); // with TTCA @@ -743,8 +743,8 @@ struct filterDielectronEvent { stored_trackIds.clear(); stored_trackIds.shrink_to_fit(); - stored_pairIds.clear(); - stored_pairIds.shrink_to_fit(); + // stored_pairIds.clear(); + // stored_pairIds.shrink_to_fit(); } PROCESS_SWITCH(filterDielectronEvent, processRec_SA_SWT, "process reconstructed info only", false); // standalone @@ -879,8 +879,8 @@ struct filterDielectronEvent { stored_trackIds.clear(); stored_trackIds.shrink_to_fit(); - stored_pairIds.clear(); - stored_pairIds.shrink_to_fit(); + // stored_pairIds.clear(); + // stored_pairIds.shrink_to_fit(); } PROCESS_SWITCH(filterDielectronEvent, processRec_TTCA_SWT, "process reconstructed info only", false); // with TTCA @@ -977,8 +977,8 @@ struct filterDielectronEvent { stored_trackIds.clear(); stored_trackIds.shrink_to_fit(); - stored_pairIds.clear(); - stored_pairIds.shrink_to_fit(); + // stored_pairIds.clear(); + // stored_pairIds.shrink_to_fit(); } PROCESS_SWITCH(filterDielectronEvent, processMC_SA, "process reconstructed and MC info ", false); @@ -1108,8 +1108,8 @@ struct filterDielectronEvent { stored_trackIds.clear(); stored_trackIds.shrink_to_fit(); - stored_pairIds.clear(); - stored_pairIds.shrink_to_fit(); + // stored_pairIds.clear(); + // stored_pairIds.shrink_to_fit(); } PROCESS_SWITCH(filterDielectronEvent, processMC_TTCA, "process reconstructed info only", false); // with TTCA }; @@ -1195,7 +1195,7 @@ struct prefilterPrimaryElectron { if (d_bz_input > -990) { d_bz = d_bz_input; o2::parameters::GRPMagField grpmag; - if (fabs(d_bz) > 1e-5) { + if (std::fabs(d_bz) > 1e-5) { grpmag.setL3Current(30000.f / (d_bz / 5.0f)); } o2::base::Propagator::initFieldFromGRP(&grpmag); @@ -1268,15 +1268,15 @@ struct prefilterPrimaryElectron { gpu::gpustd::array dcaInfo; auto track_par_cov_recalc = getTrackParCov(track); - std::array pVec_recalc = {0, 0, 0}; // px, py, pz + // std::array pVec_recalc = {0, 0, 0}; // px, py, pz o2::base::Propagator::Instance()->propagateToDCABxByBz({collision.posX(), collision.posY(), collision.posZ()}, track_par_cov_recalc, 2.f, matCorr, &dcaInfo); - getPxPyPz(track_par_cov_recalc, pVec_recalc); + // getPxPyPz(track_par_cov_recalc, pVec_recalc); - if (fabs(dcaInfo[0]) > max_dcaxy || fabs(dcaInfo[1]) > max_dcaz) { + if (std::fabs(dcaInfo[0]) > max_dcaxy || std::fabs(dcaInfo[1]) > max_dcaz) { return false; } - if (track_par_cov_recalc.getPt() < minpt || fabs(track_par_cov_recalc.getEta()) > maxeta) { + if (track_par_cov_recalc.getPt() < minpt || std::fabs(track_par_cov_recalc.getEta()) > maxeta) { return false; } diff --git a/PWGEM/Dilepton/Tasks/eventQC.cxx b/PWGEM/Dilepton/Tasks/eventQC.cxx index 82ef2af7e63..4a3ac116cd5 100644 --- a/PWGEM/Dilepton/Tasks/eventQC.cxx +++ b/PWGEM/Dilepton/Tasks/eventQC.cxx @@ -316,22 +316,15 @@ struct eventQC { } if (cfgFillPID) { - int nbin_nsigma_tpc = 100; - float min_nsigma_tpc = -5.f; - float max_nsigma_tpc = +5.f; + fRegistry.add("Track/hTPCdEdx", "TPC dE/dx;p_{in} (GeV/c);TPC dE/dx (a.u.)", kTH2F, {{1000, 0, 10}, {200, 0, 200}}, false); + fRegistry.add("Track/hTPCNsigmaEl", "TPC n sigma el;p_{in} (GeV/c);n #sigma_{e}^{TPC}", kTH2F, {{1000, 0, 10}, {100, -5.f, +5.f}}, false); + fRegistry.add("Track/hTPCNsigmaMu", "TPC n sigma mu;p_{in} (GeV/c);n #sigma_{#mu}^{TPC}", kTH2F, {{1000, 0, 10}, {100, -5.f, +5.f}}, false); + fRegistry.add("Track/hTPCNsigmaPi", "TPC n sigma pi;p_{in} (GeV/c);n #sigma_{#pi}^{TPC}", kTH2F, {{1000, 0, 10}, {100, -5.f, +5.f}}, false); + fRegistry.add("Track/hTPCNsigmaKa", "TPC n sigma ka;p_{in} (GeV/c);n #sigma_{K}^{TPC}", kTH2F, {{1000, 0, 10}, {100, -5.f, +5.f}}, false); + fRegistry.add("Track/hTPCNsigmaPr", "TPC n sigma pr;p_{in} (GeV/c);n #sigma_{p}^{TPC}", kTH2F, {{1000, 0, 10}, {100, -5.f, +5.f}}, false); if (doprocessEventQC_V0_PID) { - nbin_nsigma_tpc = 200; - min_nsigma_tpc = -10.f; - max_nsigma_tpc = +10.f; + fRegistry.add("Track/hsEID", "TPC n sigma el;p_{in} (GeV/c);#eta;n #sigma_{e}^{TPC};", kTHnSparseF, {{200, 0, 10}, {20, -1, +1}, {100, -5, +5}}, false); } - - fRegistry.add("Track/hTPCdEdx", "TPC dE/dx;p_{in} (GeV/c);TPC dE/dx (a.u.)", kTH2F, {{1000, 0, 10}, {200, 0, 200}}, false); - fRegistry.add("Track/hTPCNsigmaEl", "TPC n sigma el;p_{in} (GeV/c);n #sigma_{e}^{TPC}", kTH2F, {{1000, 0, 10}, {nbin_nsigma_tpc, min_nsigma_tpc, max_nsigma_tpc}}, false); - fRegistry.add("Track/hTPCNsigmaMu", "TPC n sigma mu;p_{in} (GeV/c);n #sigma_{#mu}^{TPC}", kTH2F, {{1000, 0, 10}, {nbin_nsigma_tpc, min_nsigma_tpc, max_nsigma_tpc}}, false); - fRegistry.add("Track/hTPCNsigmaPi", "TPC n sigma pi;p_{in} (GeV/c);n #sigma_{#pi}^{TPC}", kTH2F, {{1000, 0, 10}, {nbin_nsigma_tpc, min_nsigma_tpc, max_nsigma_tpc}}, false); - fRegistry.add("Track/hTPCNsigmaKa", "TPC n sigma ka;p_{in} (GeV/c);n #sigma_{K}^{TPC}", kTH2F, {{1000, 0, 10}, {nbin_nsigma_tpc, min_nsigma_tpc, max_nsigma_tpc}}, false); - fRegistry.add("Track/hTPCNsigmaPr", "TPC n sigma pr;p_{in} (GeV/c);n #sigma_{p}^{TPC}", kTH2F, {{1000, 0, 10}, {nbin_nsigma_tpc, min_nsigma_tpc, max_nsigma_tpc}}, false); - fRegistry.add("Track/hTOFbeta", "TOF #beta;p_{pv} (GeV/c);#beta", kTH2F, {{1000, 0, 10}, {240, 0, 1.2}}, false); fRegistry.add("Track/hTOFNsigmaEl", "TOF n sigma el;p_{pv} (GeV/c);n #sigma_{e}^{TOF}", kTH2F, {{1000, 0, 10}, {100, -5, +5}}, false); fRegistry.add("Track/hTOFNsigmaMu", "TOF n sigma mu;p_{pv} (GeV/c);n #sigma_{#mu}^{TOF}", kTH2F, {{1000, 0, 10}, {100, -5, +5}}, false); @@ -357,8 +350,7 @@ struct eventQC { fRegistry.add("V0/hCosPA", "cos pointing angle", kTH1F, {{100, 0.99, 1}}, false); fRegistry.add("V0/hRadius", "radius", kTH1F, {{200, 0, 20}}, false); fRegistry.add("V0/K0S/pion/hTPCdEdx", "TPC dE/dx;p_{in} (GeV/c);TPC dE/dx (a.u.)", kTH2F, {{1000, 0, 10}, {200, 0, 200}}, false); - fRegistry.add("V0/K0S/pion/hTPCNsigmaEl", "TPC n sigma el;p_{in} (GeV/c);n #sigma_{e}^{TPC}", kTH2F, {{1000, 0, 10}, {200, -10, +10}}, false); - fRegistry.add("V0/K0S/pion/hTPCNsigmaPi", "TPC n sigma pi;p_{in} (GeV/c);n #sigma_{#pi}^{TPC}", kTH2F, {{1000, 0, 10}, {100, -10, +10}}, false); + fRegistry.add("V0/K0S/pion/hsEID", "TPC n sigma el;p_{in} (GeV/c);#eta;n #sigma_{e}^{TPC};", kTHnSparseF, {{200, 0, 10}, {20, -1, +1}, {100, -5, +5}}, false); fRegistry.add("V0/K0S/hMass", "mass vs. p_{T} of K^{0}_{S}", kTH2F, {{200, 0.4, 0.6}, {100, 0, 10}}, false); fRegistry.add("V0/Lambda/hMass", "mass vs. p_{T} of #Lambda", kTH2F, {{100, 1.08, 1.18}, {100, 0, 10}}, false); @@ -369,8 +361,7 @@ struct eventQC { fRegistry.add("V0/Photon/hChi2", "radius vs. KF chi2", kTH2F, {{100, 0, 100}, {100, 0, 100}}, false); fRegistry.add("V0/Photon/hXY", "photon conversion point;X (cm);Y(cm)", kTH2F, {{400, -100, +100}, {400, -100, 100}}, false); fRegistry.add("V0/Photon/electron/hTPCdEdx", "TPC dE/dx;p_{in} (GeV/c);TPC dE/dx (a.u.)", kTH2F, {{1000, 0, 10}, {200, 0, 200}}, false); - fRegistry.add("V0/Photon/electron/hTPCNsigmaEl", "TPC n sigma el;p_{in} (GeV/c);n #sigma_{e}^{TPC}", kTH2F, {{1000, 0, 10}, {200, -10, +10}}, false); - fRegistry.add("V0/Photon/electron/hTPCNsigmaPi", "TPC n sigma pi;p_{in} (GeV/c);n #sigma_{#pi}^{TPC}", kTH2F, {{1000, 0, 10}, {200, -10, +10}}, false); + fRegistry.add("V0/Photon/electron/hsEID", "TPC n sigma el;p_{in} (GeV/c);#eta;n #sigma_{e}^{TPC};", kTHnSparseF, {{200, 0, 10}, {20, -1, +1}, {100, -5, +5}}, false); } template @@ -424,6 +415,9 @@ struct eventQC { fRegistry.fill(HIST("Track/hITSNsigmaPr"), track.p(), track.itsNSigmaPr()); } } + if (doprocessEventQC_V0_PID) { + fRegistry.fill(HIST("Track/hsEID"), track.tpcInnerParam(), track.eta(), track.tpcNSigmaEl()); + } } template @@ -984,13 +978,11 @@ struct eventQC { if (isTPCOK_neg && isTOFOK_neg) { // K0S is tagged by neg and pos is probe. fRegistry.fill(HIST("V0/K0S/pion/hTPCdEdx"), pos.tpcInnerParam(), pos.tpcSignal()); - fRegistry.fill(HIST("V0/K0S/pion/hTPCNsigmaEl"), pos.tpcInnerParam(), pos.tpcNSigmaEl()); - fRegistry.fill(HIST("V0/K0S/pion/hTPCNsigmaPi"), pos.tpcInnerParam(), pos.tpcNSigmaPi()); + fRegistry.fill(HIST("V0/K0S/pion/hsEID"), pos.tpcInnerParam(), pos.eta(), pos.tpcNSigmaEl()); } if (isTPCOK_pos && isTOFOK_pos) { // K0S is tagged by pos and neg is probe. fRegistry.fill(HIST("V0/K0S/pion/hTPCdEdx"), neg.tpcInnerParam(), neg.tpcSignal()); - fRegistry.fill(HIST("V0/K0S/pion/hTPCNsigmaEl"), neg.tpcInnerParam(), neg.tpcNSigmaEl()); - fRegistry.fill(HIST("V0/K0S/pion/hTPCNsigmaPi"), neg.tpcInnerParam(), neg.tpcNSigmaPi()); + fRegistry.fill(HIST("V0/K0S/pion/hsEID"), neg.tpcInnerParam(), neg.eta(), neg.tpcNSigmaEl()); } } // end of K0S } // end of v0hadron loop @@ -1030,13 +1022,11 @@ struct eventQC { if (isTPCOK_neg && isTOFOK_neg) { // photon conversion is tagged by neg and pos is probe. fRegistry.fill(HIST("V0/Photon/electron/hTPCdEdx"), pos.tpcInnerParam(), pos.tpcSignal()); - fRegistry.fill(HIST("V0/Photon/electron/hTPCNsigmaEl"), pos.tpcInnerParam(), pos.tpcNSigmaEl()); - fRegistry.fill(HIST("V0/Photon/electron/hTPCNsigmaPi"), pos.tpcInnerParam(), pos.tpcNSigmaPi()); + fRegistry.fill(HIST("V0/Photon/electron/hsEID"), pos.tpcInnerParam(), pos.eta(), pos.tpcNSigmaEl()); } if (isTPCOK_pos && isTOFOK_pos) { // photon conversion is tagged by pos and neg is probe. fRegistry.fill(HIST("V0/Photon/electron/hTPCdEdx"), neg.tpcInnerParam(), neg.tpcSignal()); - fRegistry.fill(HIST("V0/Photon/electron/hTPCNsigmaEl"), neg.tpcInnerParam(), neg.tpcNSigmaEl()); - fRegistry.fill(HIST("V0/Photon/electron/hTPCNsigmaPi"), neg.tpcInnerParam(), neg.tpcNSigmaPi()); + fRegistry.fill(HIST("V0/Photon/electron/hsEID"), neg.tpcInnerParam(), neg.eta(), neg.tpcNSigmaEl()); } } // end of v0photon loop } // end of V0 PID From 3824f7853b4adccf52f1449f7d7d1d65f2ae5fb4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?V=C3=ADt=20Ku=C4=8Dera?= Date: Thu, 6 Feb 2025 19:05:58 +0100 Subject: [PATCH 23/30] [PWGHF] Add D+ derived-data creator (#9795) --- PWGHF/DataModel/DerivedTables.h | 131 +++++- PWGHF/TableProducer/CMakeLists.txt | 5 + .../derivedDataCreatorDplusToPiKPi.cxx | 391 ++++++++++++++++++ 3 files changed, 516 insertions(+), 11 deletions(-) create mode 100644 PWGHF/TableProducer/derivedDataCreatorDplusToPiKPi.cxx diff --git a/PWGHF/DataModel/DerivedTables.h b/PWGHF/DataModel/DerivedTables.h index ad4f787fd19..09b205eff6a 100644 --- a/PWGHF/DataModel/DerivedTables.h +++ b/PWGHF/DataModel/DerivedTables.h @@ -31,14 +31,15 @@ namespace o2::aod { // basic species: -// D0 -> K- + pi+ (done) -// Lc -> pi+ K- p -// D+ -> K- + pi+ + pi+ (3P table with adapted PID columns) -// Ds+ -> K- + K+ + pi+ (3P table with adapted PID columns) +// D0 → K− π+ +// Λc → p K− π+ +// D+ → K− π+ π+ +// Ds+ → K− K+ π+ (todo) + // composite species -// B0 -> D- + pi+ -// B+ -> D0 + pi+ (in progress) -// D*+ -> D0 + pi+ +// B0 → D− π+ (todo) +// B+ → D0 π+ +// D*+ → D0 π+ (todo) // ================ // Collision tables @@ -62,7 +63,7 @@ namespace hf_mc_coll DECLARE_SOA_INDEX_COLUMN(McCollision, mcCollision); //! original global index of the MC collision } // namespace hf_mc_coll -// Defines the collision table +// Declares the base table with reconstructed collisions (CollBases) and joinable tables (CollIds). #define DECLARE_COLL_TABLE(_hf_type_, _hf_description_) \ DECLARE_SOA_TABLE_STAGED(Hf##_hf_type_##CollBases, "HF" _hf_description_ "COLLBASE", \ o2::soa::Index<>, \ @@ -84,7 +85,7 @@ DECLARE_SOA_INDEX_COLUMN(McCollision, mcCollision); //! original global index of hf_cand::CollisionId, \ o2::soa::Marker); -// Defines the mc collision table +// Declares the base table with MC collisions (McCollBases) and joinable tables (McCollIds, McRCollIds). #define DECLARE_MCCOLL_TABLE(_hf_type_, _hf_description_, _hf_namespace_) \ namespace hf_mc_coll \ { \ @@ -111,10 +112,15 @@ DECLARE_SOA_INDEX_COLUMN(McCollision, mcCollision); //! original global index of DECLARE_SOA_TABLE_STAGED(Hf##_hf_type_##McRCollIds, "HF" _hf_description_ "MCRCOLLID", \ hf_mc_coll::der_##_hf_namespace_::Hf##_hf_type_##CollBaseIds); +// Declares all tables with reconstructed and MC collisions. #define DECLARE_COLL_TABLES(_hf_type_, _hf_description_, _hf_namespace_) \ DECLARE_COLL_TABLE(_hf_type_, _hf_description_) \ DECLARE_MCCOLL_TABLE(_hf_type_, _hf_description_, _hf_namespace_) +// ================ +// Candidate tables +// ================ + namespace hf_cand_base { DECLARE_SOA_COLUMN(Eta, eta, float); //! pseudorapidity @@ -161,6 +167,7 @@ DECLARE_SOA_COLUMN(OriginMcGen, originMcGen, int8_t); //! particle DECLARE_SOA_COLUMN(FlagMcDecayChanGen, flagMcDecayChanGen, int8_t); //! resonant decay channel flag, generator level } // namespace hf_mc_particle +// Declares the base table with candidates (Bases). #define DECLARE_CAND_BASE_TABLE(_hf_type_, _hf_description_, _hf_namespace_) \ namespace hf_cand_base \ { \ @@ -184,6 +191,7 @@ DECLARE_SOA_COLUMN(FlagMcDecayChanGen, flagMcDecayChanGen, int8_t); //! resonant hf_cand_base::P, \ o2::soa::Marker); +// Declares the table with global indices for 2-prong candidates (Ids). #define DECLARE_CAND_2P_ID_TABLE(_hf_type_, _hf_description_) \ DECLARE_SOA_TABLE_STAGED(Hf##_hf_type_##Ids, "HF" _hf_description_ "ID", \ hf_cand::CollisionId, \ @@ -191,6 +199,7 @@ DECLARE_SOA_COLUMN(FlagMcDecayChanGen, flagMcDecayChanGen, int8_t); //! resonant hf_track_index::Prong1Id, \ o2::soa::Marker); +// Declares the table with global indices for 3-prong candidates (Ids). #define DECLARE_CAND_3P_ID_TABLE(_hf_type_, _hf_description_) \ DECLARE_SOA_TABLE_STAGED(Hf##_hf_type_##Ids, "HF" _hf_description_ "ID", \ hf_cand::CollisionId, \ @@ -199,11 +208,17 @@ DECLARE_SOA_COLUMN(FlagMcDecayChanGen, flagMcDecayChanGen, int8_t); //! resonant hf_track_index::Prong2Id, \ o2::soa::Marker); +// Declares the table with candidate selection flags (Sels). #define DECLARE_CAND_SEL_TABLE(_hf_type_, _hf_description_) \ DECLARE_SOA_TABLE_STAGED(Hf##_hf_type_##Sels, "HF" _hf_description_ "SEL", \ hf_cand_sel::CandidateSelFlag, \ o2::soa::Marker); +// ================ +// MC particle tables +// ================ + +// Declares the base table with MC particles (PBases). #define DECLARE_MCCAND_BASE_TABLE(_hf_type_, _hf_description_, _hf_namespace_) \ namespace hf_mc_particle \ { \ @@ -227,12 +242,17 @@ DECLARE_SOA_COLUMN(FlagMcDecayChanGen, flagMcDecayChanGen, int8_t); //! resonant hf_cand_base::P, \ o2::soa::Marker); +// Declares the table with global indices for MC particles (PIds). #define DECLARE_MCCAND_ID_TABLE(_hf_type_, _hf_description_) \ DECLARE_SOA_TABLE_STAGED(Hf##_hf_type_##PIds, "HF" _hf_description_ "PID", \ hf_mc_particle::McCollisionId, \ hf_mc_particle::McParticleId, \ o2::soa::Marker); +// ================ +// Helper macros for combinations +// ================ + #define DECLARE_CAND_TABLES(_hf_type_, _hf_description_, _hf_namespace_) \ DECLARE_CAND_BASE_TABLE(_hf_type_, _hf_description_, _hf_namespace_) \ DECLARE_CAND_SEL_TABLE(_hf_type_, _hf_description_) \ @@ -257,12 +277,17 @@ DECLARE_SOA_COLUMN(FlagMcDecayChanGen, flagMcDecayChanGen, int8_t); //! resonant DECLARE_COLL_TABLES(_hf_type_, _hf_description_, _hf_namespace_) \ DECLARE_CAND_3P_TABLES(_hf_type_, _hf_description_, _hf_namespace_) +// ================ +// Declarations of common tables for individual species +// ================ + DECLARE_2P_TABLES(D0, "D0", d0, 2); DECLARE_3P_TABLES(Lc, "LC", lc, 3); -DECLARE_3P_TABLES(Bplus, "BP", bplus, 4); +DECLARE_3P_TABLES(Dplus, "DP", dplus, 4); +DECLARE_3P_TABLES(Bplus, "BP", bplus, 5); // ================ -// Candidate tables +// Additional species-specific candidate tables // ================ // Candidate properties used for selection @@ -417,6 +442,10 @@ DECLARE_SOA_COLUMN(MlScoreNonPromptCharm, mlScoreNonPromptCharm, float); // DECLARE_SOA_COLUMN(MlScoresCharm, mlScoresCharm, std::vector); //! vector of ML scores } // namespace hf_cand_mc_charm +// ---------------- +// D0 +// ---------------- + // candidates for removal: // PxProng0, PyProng0, PzProng0,... (same for 1, 2), we can keep Pt, Eta, Phi instead // XY: CpaXY, DecayLengthXY, ErrorDecayLengthXY @@ -482,6 +511,10 @@ DECLARE_SOA_TABLE_STAGED(HfD0Mcs, "HFD0MC", //! Table with MC candidate info hf_cand_mc::OriginMcRec, o2::soa::Marker); +// ---------------- +// B+ +// ---------------- + // candidates for removal: // PxProng0, PyProng0, PzProng0,... (same for 1, 2), we can keep Pt, Eta, Phi instead // XY: CpaXY, DecayLengthXY, ErrorDecayLengthXY @@ -558,6 +591,10 @@ DECLARE_SOA_TABLE_STAGED(HfBplusMcs, "HFBPMC", //! Table with MC candidate info hf_cand_mc::OriginMcRec, o2::soa::Marker); +// ---------------- +// Lc +// ---------------- + // candidates for removal: // PxProng0, PyProng0, PzProng0,... (same for 1, 2), we can keep Pt, Eta, Phi instead // XY: CpaXY, DecayLengthXY, ErrorDecayLengthXY @@ -632,6 +669,78 @@ DECLARE_SOA_TABLE_STAGED(HfLcMcs, "HFLCMC", //! Table with MC candidate info hf_cand_mc::IsCandidateSwapped, o2::soa::Marker); +// ---------------- +// D+ +// ---------------- + +// candidates for removal: +// PxProng0, PyProng0, PzProng0,... (same for 1, 2), we can keep Pt, Eta, Phi instead +// XY: CpaXY, DecayLengthXY, ErrorDecayLengthXY +// normalised: DecayLengthNormalised, DecayLengthXYNormalised, ImpactParameterNormalised0 +DECLARE_SOA_TABLE_STAGED(HfDplusPars, "HFDPPAR", //! Table with candidate properties used for selection + hf_cand::Chi2PCA, + hf_cand::NProngsContributorsPV, + hf_cand_par::Cpa, + hf_cand_par::CpaXY, + hf_cand_par::DecayLength, + hf_cand_par::DecayLengthXY, + hf_cand_par::DecayLengthNormalised, + hf_cand_par::DecayLengthXYNormalised, + hf_cand_par::PtProng0, + hf_cand_par::PtProng1, + hf_cand_par::PtProng2, + hf_cand::ImpactParameter0, + hf_cand::ImpactParameter1, + hf_cand::ImpactParameter2, + hf_cand_par::ImpactParameterNormalised0, + hf_cand_par::ImpactParameterNormalised1, + hf_cand_par::ImpactParameterNormalised2, + hf_cand_par::NSigTpcPi0, + hf_cand_par::NSigTofPi0, + hf_cand_par::NSigTpcTofPi0, + hf_cand_par::NSigTpcKa1, + hf_cand_par::NSigTofKa1, + hf_cand_par::NSigTpcTofKa1, + hf_cand_par::NSigTpcPi2, + hf_cand_par::NSigTofPi2, + hf_cand_par::NSigTpcTofPi2, + o2::soa::Marker); + +DECLARE_SOA_TABLE_STAGED(HfDplusParEs, "HFDPPARE", //! Table with additional candidate properties used for selection + hf_cand::XSecondaryVertex, + hf_cand::YSecondaryVertex, + hf_cand::ZSecondaryVertex, + hf_cand::ErrorDecayLength, + hf_cand::ErrorDecayLengthXY, + hf_cand_par::RSecondaryVertex, + hf_cand_par::PProng0, + hf_cand_par::PProng1, + hf_cand_par::PProng2, + hf_cand::PxProng0, + hf_cand::PyProng0, + hf_cand::PzProng0, + hf_cand::PxProng1, + hf_cand::PyProng1, + hf_cand::PzProng1, + hf_cand::PxProng2, + hf_cand::PyProng2, + hf_cand::PzProng2, + hf_cand::ErrorImpactParameter0, + hf_cand::ErrorImpactParameter1, + hf_cand::ErrorImpactParameter2, + hf_cand_par::Ct, + o2::soa::Marker); + +DECLARE_SOA_TABLE_STAGED(HfDplusMls, "HFDPML", //! Table with candidate selection ML scores + hf_cand_mc::MlScores, + o2::soa::Marker); + +DECLARE_SOA_TABLE_STAGED(HfDplusMcs, "HFDPMC", //! Table with MC candidate info + hf_cand_mc::FlagMcMatchRec, + hf_cand_mc::OriginMcRec, + hf_cand_mc::IsCandidateSwapped, // useless + o2::soa::Marker); + } // namespace o2::aod #endif // PWGHF_DATAMODEL_DERIVEDTABLES_H_ diff --git a/PWGHF/TableProducer/CMakeLists.txt b/PWGHF/TableProducer/CMakeLists.txt index 550343621db..9bda43b8229 100644 --- a/PWGHF/TableProducer/CMakeLists.txt +++ b/PWGHF/TableProducer/CMakeLists.txt @@ -305,6 +305,11 @@ o2physics_add_dpl_workflow(derived-data-creator-d0-to-k-pi PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(derived-data-creator-dplus-to-pi-k-pi + SOURCES derivedDataCreatorDplusToPiKPi.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(derived-data-creator-lc-to-p-k-pi SOURCES derivedDataCreatorLcToPKPi.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore diff --git a/PWGHF/TableProducer/derivedDataCreatorDplusToPiKPi.cxx b/PWGHF/TableProducer/derivedDataCreatorDplusToPiKPi.cxx new file mode 100644 index 00000000000..0eb5b010a32 --- /dev/null +++ b/PWGHF/TableProducer/derivedDataCreatorDplusToPiKPi.cxx @@ -0,0 +1,391 @@ +// 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. + +/// \file derivedDataCreatorDplusToPiKPi.cxx +/// \brief Producer of derived tables of Dplus candidates, collisions and MC particles +/// \note Based on derivedDataCreatorLcToPKPi.cxx +/// +/// \author Vít Kučera , Inha University + +#include +#include +#include + +#include "CommonConstants/PhysicsConstants.h" +#include "Framework/AnalysisTask.h" +#include "Framework/runDataProcessing.h" + +#include "Common/Core/RecoDecay.h" +#include "Common/DataModel/Centrality.h" +#include "Common/DataModel/Multiplicity.h" + +#include "PWGLF/DataModel/mcCentrality.h" + +#include "PWGHF/Core/HfHelper.h" +#include "PWGHF/DataModel/CandidateReconstructionTables.h" +#include "PWGHF/DataModel/CandidateSelectionTables.h" +#include "PWGHF/DataModel/DerivedTables.h" +#include "PWGHF/Utils/utilsDerivedData.h" + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; +using namespace o2::analysis::hf_derived; + +/// Writes the full information in an output TTree +struct HfDerivedDataCreatorDplusToPiKPi { + HfProducesDerivedData< + o2::aod::HfDplusBases, + o2::aod::HfDplusCollBases, + o2::aod::HfDplusCollIds, + o2::aod::HfDplusMcCollBases, + o2::aod::HfDplusMcCollIds, + o2::aod::HfDplusMcRCollIds, + o2::aod::HfDplusPBases, + o2::aod::HfDplusPIds> + rowsCommon; + // Candidates + Produces rowCandidatePar; + Produces rowCandidateParE; + Produces rowCandidateSel; + Produces rowCandidateMl; + Produces rowCandidateId; + Produces rowCandidateMc; + + // Switches for filling tables + HfConfigurableDerivedData confDerData; + Configurable fillCandidatePar{"fillCandidatePar", true, "Fill candidate parameters"}; + Configurable fillCandidateParE{"fillCandidateParE", true, "Fill candidate extended parameters"}; + Configurable fillCandidateSel{"fillCandidateSel", true, "Fill candidate selection flags"}; + Configurable fillCandidateMl{"fillCandidateMl", true, "Fill candidate selection ML scores"}; + Configurable fillCandidateId{"fillCandidateId", true, "Fill original indices from the candidate table"}; + Configurable fillCandidateMc{"fillCandidateMc", true, "Fill candidate MC info"}; + // Parameters for production of training samples + Configurable downSampleBkgFactor{"downSampleBkgFactor", 1., "Fraction of background candidates to keep for ML trainings"}; + Configurable ptMaxForDownSample{"ptMaxForDownSample", 10., "Maximum pt for the application of the downsampling factor"}; + + HfHelper hfHelper; + SliceCache cache; + static constexpr double mass{o2::constants::physics::MassDPlus}; + + using CollisionsWCentMult = soa::Join; + using CollisionsWMcCentMult = soa::Join; + using TracksWPid = soa::Join; + using SelectedCandidates = soa::Filtered>; + using SelectedCandidatesMc = soa::Filtered>; + using SelectedCandidatesMl = soa::Filtered>; + using SelectedCandidatesMcMl = soa::Filtered>; + using MatchedGenCandidatesMc = soa::Filtered>; + using TypeMcCollisions = soa::Join; + + Filter filterSelectCandidates = aod::hf_sel_candidate_dplus::isSelDplusToPiKPi >= 1; + Filter filterMcGenMatching = nabs(aod::hf_cand_3prong::flagMcMatchGen) == static_cast(BIT(aod::hf_cand_3prong::DecayType::DplusToPiKPi)); + + Preslice candidatesPerCollision = aod::hf_cand::collisionId; + Preslice candidatesMcPerCollision = aod::hf_cand::collisionId; + Preslice candidatesMlPerCollision = aod::hf_cand::collisionId; + Preslice candidatesMcMlPerCollision = aod::hf_cand::collisionId; + Preslice mcParticlesPerMcCollision = aod::mcparticle::mcCollisionId; + + // trivial partitions for all candidates to allow "->sliceByCached" inside processCandidates + Partition candidatesAll = aod::hf_sel_candidate_dplus::isSelDplusToPiKPi >= 0; + Partition candidatesMcAll = aod::hf_sel_candidate_dplus::isSelDplusToPiKPi >= 0; + Partition candidatesMlAll = aod::hf_sel_candidate_dplus::isSelDplusToPiKPi >= 0; + Partition candidatesMcMlAll = aod::hf_sel_candidate_dplus::isSelDplusToPiKPi >= 0; + // partitions for signal and background + Partition candidatesMcSig = nabs(aod::hf_cand_3prong::flagMcMatchRec) == static_cast(BIT(aod::hf_cand_3prong::DecayType::DplusToPiKPi)); + Partition candidatesMcBkg = nabs(aod::hf_cand_3prong::flagMcMatchRec) != static_cast(BIT(aod::hf_cand_3prong::DecayType::DplusToPiKPi)); + Partition candidatesMcMlSig = nabs(aod::hf_cand_3prong::flagMcMatchRec) == static_cast(BIT(aod::hf_cand_3prong::DecayType::DplusToPiKPi)); + Partition candidatesMcMlBkg = nabs(aod::hf_cand_3prong::flagMcMatchRec) != static_cast(BIT(aod::hf_cand_3prong::DecayType::DplusToPiKPi)); + + void init(InitContext const&) + { + std::array doprocess{doprocessData, doprocessMcSig, doprocessMcBkg, doprocessMcAll, doprocessDataMl, doprocessMcMlSig, doprocessMcMlBkg, doprocessMcMlAll, doprocessMcGenOnly}; + if (std::accumulate(doprocess.begin(), doprocess.end(), 0) != 1) { + LOGP(fatal, "Only one process function can be enabled at a time."); + } + rowsCommon.init(confDerData); + } + + template + void fillTablesCandidate(const T& candidate, const U& prong0, const U& prong1, const U& prong2, int candFlag, double invMass, + double ct, double y, int8_t flagMc, int8_t origin, int8_t swapping, const std::vector& mlScores) + { + rowsCommon.fillTablesCandidate(candidate, invMass, y); + if (fillCandidatePar) { + rowCandidatePar( + candidate.chi2PCA(), + candidate.nProngsContributorsPV(), + candidate.cpa(), + candidate.cpaXY(), + candidate.decayLength(), + candidate.decayLengthXY(), + candidate.decayLengthNormalised(), + candidate.decayLengthXYNormalised(), + candidate.ptProng0(), + candidate.ptProng1(), + candidate.ptProng2(), + candidate.impactParameter0(), + candidate.impactParameter1(), + candidate.impactParameter2(), + candidate.impactParameterNormalised0(), + candidate.impactParameterNormalised1(), + candidate.impactParameterNormalised2(), + prong0.tpcNSigmaPi(), + prong0.tofNSigmaPi(), + prong0.tpcTofNSigmaPi(), + prong1.tpcNSigmaKa(), + prong1.tofNSigmaKa(), + prong1.tpcTofNSigmaKa(), + prong2.tpcNSigmaPi(), + prong2.tofNSigmaPi(), + prong2.tpcTofNSigmaPi()); + } + if (fillCandidateParE) { + rowCandidateParE( + candidate.xSecondaryVertex(), + candidate.ySecondaryVertex(), + candidate.zSecondaryVertex(), + candidate.errorDecayLength(), + candidate.errorDecayLengthXY(), + candidate.rSecondaryVertex(), + RecoDecay::p(candidate.pxProng0(), candidate.pyProng0(), candidate.pzProng0()), + RecoDecay::p(candidate.pxProng1(), candidate.pyProng1(), candidate.pzProng1()), + RecoDecay::p(candidate.pxProng2(), candidate.pyProng2(), candidate.pzProng2()), + candidate.pxProng0(), + candidate.pyProng0(), + candidate.pzProng0(), + candidate.pxProng1(), + candidate.pyProng1(), + candidate.pzProng1(), + candidate.pxProng2(), + candidate.pyProng2(), + candidate.pzProng2(), + candidate.errorImpactParameter0(), + candidate.errorImpactParameter1(), + candidate.errorImpactParameter2(), + ct); + } + if (fillCandidateSel) { + rowCandidateSel( + BIT(candFlag)); + } + if (fillCandidateMl) { + rowCandidateMl( + mlScores); + } + if (fillCandidateId) { + rowCandidateId( + candidate.collisionId(), + candidate.prong0Id(), + candidate.prong1Id(), + candidate.prong2Id()); + } + if (fillCandidateMc) { + rowCandidateMc( + flagMc, + origin, + swapping); + } + } + + template + void processCandidates(CollType const& collisions, + Partition& candidates, + TracksWPid const&, + aod::BCs const&) + { + // Fill collision properties + if constexpr (isMc) { + if (confDerData.fillMcRCollId) { + rowsCommon.matchedCollisions.clear(); + } + } + auto sizeTableColl = collisions.size(); + rowsCommon.reserveTablesColl(sizeTableColl); + for (const auto& collision : collisions) { + auto thisCollId = collision.globalIndex(); + auto candidatesThisColl = candidates->sliceByCached(aod::hf_cand::collisionId, thisCollId, cache); // FIXME + auto sizeTableCand = candidatesThisColl.size(); + LOGF(debug, "Rec. collision %d has %d candidates", thisCollId, sizeTableCand); + // Skip collisions without HF candidates (and without HF particles in matched MC collisions if saving indices of reconstructed collisions matched to MC collisions) + bool mcCollisionHasMcParticles{false}; + if constexpr (isMc) { + mcCollisionHasMcParticles = confDerData.fillMcRCollId && collision.has_mcCollision() && rowsCommon.hasMcParticles[collision.mcCollisionId()]; + LOGF(debug, "Rec. collision %d has MC collision %d with MC particles? %s", thisCollId, collision.mcCollisionId(), mcCollisionHasMcParticles ? "yes" : "no"); + } + if (sizeTableCand == 0 && (!confDerData.fillMcRCollId || !mcCollisionHasMcParticles)) { + LOGF(debug, "Skipping rec. collision %d", thisCollId); + continue; + } + LOGF(debug, "Filling rec. collision %d at derived index %d", thisCollId, rowsCommon.rowCollBase.lastIndex() + 1); + rowsCommon.fillTablesCollision(collision); + + // Fill candidate properties + rowsCommon.reserveTablesCandidates(sizeTableCand); + reserveTable(rowCandidatePar, fillCandidatePar, sizeTableCand); + reserveTable(rowCandidateParE, fillCandidateParE, sizeTableCand); + reserveTable(rowCandidateSel, fillCandidateSel, sizeTableCand); + reserveTable(rowCandidateMl, fillCandidateMl, sizeTableCand); + reserveTable(rowCandidateId, fillCandidateId, sizeTableCand); + if constexpr (isMc) { + reserveTable(rowCandidateMc, fillCandidateMc, sizeTableCand); + } + int8_t flagMcRec = 0, origin = 0, swapping = 0; + for (const auto& candidate : candidatesThisColl) { + if constexpr (isMc) { + flagMcRec = candidate.flagMcMatchRec(); + origin = candidate.originMcRec(); + swapping = candidate.isCandidateSwapped(); + if constexpr (onlyBkg) { + if (TESTBIT(std::abs(flagMcRec), aod::hf_cand_3prong::DecayType::DplusToPiKPi)) { + continue; + } + if (downSampleBkgFactor < 1.) { + float pseudoRndm = candidate.ptProng0() * 1000. - static_cast(candidate.ptProng0() * 1000); + if (candidate.pt() < ptMaxForDownSample && pseudoRndm >= downSampleBkgFactor) { + continue; + } + } + } + if constexpr (onlySig) { + if (!TESTBIT(std::abs(flagMcRec), aod::hf_cand_3prong::DecayType::DplusToPiKPi)) { + continue; + } + } + } + auto prong0 = candidate.template prong0_as(); + auto prong1 = candidate.template prong1_as(); + auto prong2 = candidate.template prong2_as(); + double ct = hfHelper.ctDplus(candidate); + double y = hfHelper.yDplus(candidate); + float massDplusToPiKPi = hfHelper.invMassDplusToPiKPi(candidate); + std::vector mlScoresDplusToPiKPi; + if constexpr (isMl) { + std::copy(candidate.mlProbDplusToPiKPi().begin(), candidate.mlProbDplusToPiKPi().end(), std::back_inserter(mlScoresDplusToPiKPi)); + } + if (candidate.isSelDplusToPiKPi()) { + fillTablesCandidate(candidate, prong0, prong1, prong2, 0, massDplusToPiKPi, ct, y, flagMcRec, origin, swapping, mlScoresDplusToPiKPi); + } + } + } + } + + void processData(CollisionsWCentMult const& collisions, + SelectedCandidates const&, + TracksWPid const& tracks, + aod::BCs const& bcs) + { + processCandidates(collisions, candidatesAll, tracks, bcs); + } + PROCESS_SWITCH(HfDerivedDataCreatorDplusToPiKPi, processData, "Process data", true); + + void processMcSig(CollisionsWMcCentMult const& collisions, + SelectedCandidatesMc const&, + TypeMcCollisions const& mcCollisions, + MatchedGenCandidatesMc const& mcParticles, + TracksWPid const& tracks, + aod::BCs const& bcs) + { + rowsCommon.preProcessMcCollisions(mcCollisions, mcParticlesPerMcCollision, mcParticles); + processCandidates(collisions, candidatesMcSig, tracks, bcs); + rowsCommon.processMcParticles(mcCollisions, mcParticlesPerMcCollision, mcParticles, mass); + } + PROCESS_SWITCH(HfDerivedDataCreatorDplusToPiKPi, processMcSig, "Process MC only for signals", false); + + void processMcBkg(CollisionsWMcCentMult const& collisions, + SelectedCandidatesMc const&, + TypeMcCollisions const& mcCollisions, + MatchedGenCandidatesMc const& mcParticles, + TracksWPid const& tracks, + aod::BCs const& bcs) + { + rowsCommon.preProcessMcCollisions(mcCollisions, mcParticlesPerMcCollision, mcParticles); + processCandidates(collisions, candidatesMcBkg, tracks, bcs); + rowsCommon.processMcParticles(mcCollisions, mcParticlesPerMcCollision, mcParticles, mass); + } + PROCESS_SWITCH(HfDerivedDataCreatorDplusToPiKPi, processMcBkg, "Process MC only for background", false); + + void processMcAll(CollisionsWMcCentMult const& collisions, + SelectedCandidatesMc const&, + TypeMcCollisions const& mcCollisions, + MatchedGenCandidatesMc const& mcParticles, + TracksWPid const& tracks, + aod::BCs const& bcs) + { + rowsCommon.preProcessMcCollisions(mcCollisions, mcParticlesPerMcCollision, mcParticles); + processCandidates(collisions, candidatesMcAll, tracks, bcs); + rowsCommon.processMcParticles(mcCollisions, mcParticlesPerMcCollision, mcParticles, mass); + } + PROCESS_SWITCH(HfDerivedDataCreatorDplusToPiKPi, processMcAll, "Process MC", false); + + // ML versions + + void processDataMl(CollisionsWCentMult const& collisions, + SelectedCandidatesMl const&, + TracksWPid const& tracks, + aod::BCs const& bcs) + { + processCandidates(collisions, candidatesMlAll, tracks, bcs); + } + PROCESS_SWITCH(HfDerivedDataCreatorDplusToPiKPi, processDataMl, "Process data with ML", false); + + void processMcMlSig(CollisionsWMcCentMult const& collisions, + SelectedCandidatesMcMl const&, + TypeMcCollisions const& mcCollisions, + MatchedGenCandidatesMc const& mcParticles, + TracksWPid const& tracks, + aod::BCs const& bcs) + { + rowsCommon.preProcessMcCollisions(mcCollisions, mcParticlesPerMcCollision, mcParticles); + processCandidates(collisions, candidatesMcMlSig, tracks, bcs); + rowsCommon.processMcParticles(mcCollisions, mcParticlesPerMcCollision, mcParticles, mass); + } + PROCESS_SWITCH(HfDerivedDataCreatorDplusToPiKPi, processMcMlSig, "Process MC with ML only for signals", false); + + void processMcMlBkg(CollisionsWMcCentMult const& collisions, + SelectedCandidatesMcMl const&, + TypeMcCollisions const& mcCollisions, + MatchedGenCandidatesMc const& mcParticles, + TracksWPid const& tracks, + aod::BCs const& bcs) + { + rowsCommon.preProcessMcCollisions(mcCollisions, mcParticlesPerMcCollision, mcParticles); + processCandidates(collisions, candidatesMcMlBkg, tracks, bcs); + rowsCommon.processMcParticles(mcCollisions, mcParticlesPerMcCollision, mcParticles, mass); + } + PROCESS_SWITCH(HfDerivedDataCreatorDplusToPiKPi, processMcMlBkg, "Process MC with ML only for background", false); + + void processMcMlAll(CollisionsWMcCentMult const& collisions, + SelectedCandidatesMcMl const&, + TypeMcCollisions const& mcCollisions, + MatchedGenCandidatesMc const& mcParticles, + TracksWPid const& tracks, + aod::BCs const& bcs) + { + rowsCommon.preProcessMcCollisions(mcCollisions, mcParticlesPerMcCollision, mcParticles); + processCandidates(collisions, candidatesMcMlAll, tracks, bcs); + rowsCommon.processMcParticles(mcCollisions, mcParticlesPerMcCollision, mcParticles, mass); + } + PROCESS_SWITCH(HfDerivedDataCreatorDplusToPiKPi, processMcMlAll, "Process MC with ML", false); + + void processMcGenOnly(TypeMcCollisions const& mcCollisions, + MatchedGenCandidatesMc const& mcParticles) + { + rowsCommon.processMcParticles(mcCollisions, mcParticlesPerMcCollision, mcParticles, mass); + } + PROCESS_SWITCH(HfDerivedDataCreatorDplusToPiKPi, processMcGenOnly, "Process MC gen. only", false); +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{adaptAnalysisTask(cfgc)}; +} From d311d705c9c4646e4bc054dfd4421843f3208eb9 Mon Sep 17 00:00:00 2001 From: Noor Koster <82090643+cnkoster@users.noreply.github.com> Date: Thu, 6 Feb 2025 20:12:41 +0100 Subject: [PATCH 24/30] [PWGCF] Fixed bug and added some QA histos (#9797) Co-authored-by: ALICE Action Bot --- PWGCF/Flow/Tasks/flowSP.cxx | 41 ++++++++++++++++++++++++++++++++----- 1 file changed, 36 insertions(+), 5 deletions(-) diff --git a/PWGCF/Flow/Tasks/flowSP.cxx b/PWGCF/Flow/Tasks/flowSP.cxx index 06de1e2ec4c..027cbc43ce4 100644 --- a/PWGCF/Flow/Tasks/flowSP.cxx +++ b/PWGCF/Flow/Tasks/flowSP.cxx @@ -162,6 +162,16 @@ struct FlowSP { nEventSelections }; + enum TrackSelections { + trackSel_FilteredTracks, + trackSel_NCls, + trackSel_FshCls, + trackSel_TPCBoundary, + trackSel_ZeroCharge, + trackSel_ParticleWeights, + nTrackSelections + }; + enum ChargeType { kInclusive, kPositive, @@ -190,6 +200,8 @@ struct FlowSP { AxisSpec t0cAxis = {70, 0, 70000, "N_{ch} (T0C)"}; AxisSpec t0aAxis = {200, 0, 200, "N_{ch}"}; AxisSpec multpvAxis = {4000, 0, 4000, "N_{ch} (PV)"}; + AxisSpec shclAxis = {200, 0, 1, "Fraction shared cl. TPC"}; + AxisSpec clAxis = {160, 0, 160, "Number of cl. TPC"}; int ptbins = ptbinning.size() - 1; @@ -315,8 +327,10 @@ struct FlowSP { registry.add("incl/QA/hPhiCorrected", "", kTH1D, {axisPhi}); registry.add("incl/QA/hEta", "", kTH1D, {axisEta}); registry.add("incl/QA/hPhi_Eta_vz", "", kTH3D, {axisPhi, axisEta, axisVz}); - registry.add("incl/QA/hDCAxy", "", kTH1D, {axisDCAxy}); - registry.add("incl/QA/hDCAz", "", kTH1D, {axisDCAz}); + registry.add("incl/QA/hDCAxy_pt", "", kTH2D, {axisPt, axisDCAxy}); + registry.add("incl/QA/hDCAz_pt", "", kTH2D, {axisPt, axisDCAz}); + registry.add("incl/QA/hSharedClusters_pt", "", {HistType::kTH2D, {axisPt, shclAxis}}); + registry.add("incl/QA/hCrossedRows_pt", "", {HistType::kTH2D, {axisPt, clAxis}}); registry.addClone("incl/", "pos/"); registry.addClone("incl/", "neg/"); @@ -340,6 +354,14 @@ struct FlowSP { registry.get(HIST("hEventCount"))->GetXaxis()->SetBinLabel(evSel_kIsGoodITSLayersAll + 1, "kkIsGoodITSLayersAll"); registry.get(HIST("hEventCount"))->GetXaxis()->SetBinLabel(evSel_isSelectedZDC + 1, "isSelected"); + registry.add("hTrackCount", "Number of Tracks; Cut; #Tracks Passed Cut", {HistType::kTH1D, {{nTrackSelections, 0, nTrackSelections}}}); + registry.get(HIST("hTrackCount"))->GetXaxis()->SetBinLabel(trackSel_FilteredTracks + 1, "Filtered Track"); + registry.get(HIST("hTrackCount"))->GetXaxis()->SetBinLabel(trackSel_NCls + 1, "nClusters TPC"); + registry.get(HIST("hTrackCount"))->GetXaxis()->SetBinLabel(trackSel_FshCls + 1, "Frac. sh. Cls TPC"); + registry.get(HIST("hTrackCount"))->GetXaxis()->SetBinLabel(trackSel_TPCBoundary + 1, "TPC Boundary"); + registry.get(HIST("hTrackCount"))->GetXaxis()->SetBinLabel(trackSel_ZeroCharge + 1, "Only charged"); + registry.get(HIST("hTrackCount"))->GetXaxis()->SetBinLabel(trackSel_ParticleWeights + 1, "Apply weights"); + if (cfgUseAdditionalEventCut) { fMultPVCutLow = new TF1("fMultPVCutLow", "[0]+[1]*x+[2]*x*x+[3]*x*x*x+[4]*x*x*x*x - 3.5*([5]+[6]*x+[7]*x*x+[8]*x*x*x+[9]*x*x*x*x)", 0, 100); fMultPVCutLow->SetParameters(3257.29, -121.848, 1.98492, -0.0172128, 6.47528e-05, 154.756, -1.86072, -0.0274713, 0.000633499, -3.37757e-06); @@ -535,9 +557,11 @@ struct FlowSP { if (track.tpcNClsFound() < cfgNcls) return false; + registry.fill(HIST("hTrackCount"), trackSel_NCls); - if (track.tpcFractionSharedCls() < cfgFshcls) + if (track.tpcFractionSharedCls() > cfgFshcls) return false; + registry.fill(HIST("hTrackCount"), trackSel_FshCls); double phimodn = track.phi(); if (field < 0) // for negative polarity field @@ -556,6 +580,7 @@ struct FlowSP { return false; // reject track } registry.fill(HIST("QA/after/pt_phi"), track.pt(), phimodn); + registry.fill(HIST("hTrackCount"), trackSel_TPCBoundary); return true; } @@ -679,8 +704,10 @@ struct FlowSP { registry.fill(HIST(Charge[ct]) + HIST("QA/hPhiCorrected"), track.phi(), wacc * weff); registry.fill(HIST(Charge[ct]) + HIST("QA/hEta"), track.eta()); registry.fill(HIST(Charge[ct]) + HIST("QA/hPhi_Eta_vz"), track.phi(), track.eta(), vz); - registry.fill(HIST(Charge[ct]) + HIST("QA/hDCAxy"), track.dcaXY()); - registry.fill(HIST(Charge[ct]) + HIST("QA/hDCAz"), track.dcaZ()); + registry.fill(HIST(Charge[ct]) + HIST("QA/hDCAxy_pt"), track.pt(), track.dcaXY()); + registry.fill(HIST(Charge[ct]) + HIST("QA/hDCAz_pt"), track.pt(), track.dcaZ()); + registry.fill(HIST(Charge[ct]) + HIST("QA/hSharedClusters_pt"), track.pt(), track.tpcFractionSharedCls()); + registry.fill(HIST(Charge[ct]) + HIST("QA/hCrossedRows_pt"), track.pt(), track.tpcNClsFound()); } void processData(UsedCollisions::iterator const& collision, aod::BCsWithTimestamps const&, UsedTracks const& tracks) @@ -785,6 +812,7 @@ struct FlowSP { for (const auto& track : tracks) { registry.fill(HIST("QA/before/hPt_inclusive"), track.pt()); + registry.fill(HIST("hTrackCount"), trackSel_FilteredTracks); float weff = 1, wacc = 1; float weffP = 1, waccP = 1; @@ -795,6 +823,7 @@ struct FlowSP { if (track.sign() == 0.0) return; + registry.fill(HIST("hTrackCount"), trackSel_ZeroCharge); bool pos = (track.sign() > 0) ? true : false; // Fill NUA weights @@ -816,6 +845,8 @@ struct FlowSP { if (!pos && !setCurrentParticleWeights(kNegative, weffN, waccN, track.phi(), track.eta(), track.pt(), vtxz)) return; + registry.fill(HIST("hTrackCount"), trackSel_ParticleWeights); + registry.fill(HIST("QA/after/hPt_inclusive"), track.pt(), wacc * weff); // // constrain angle to 0 -> [0,0+2pi] From 40cc98458b5ae3e932800f5aae66c08604c81f4c Mon Sep 17 00:00:00 2001 From: hernasab Date: Thu, 6 Feb 2025 13:52:12 -0600 Subject: [PATCH 25/30] [PWGCF] added event selection (#9800) Co-authored-by: Sabrina Hernandez --- PWGCF/Flow/Tasks/flowZdcTask.cxx | 31 ++++++++++++++++++++++++++----- 1 file changed, 26 insertions(+), 5 deletions(-) diff --git a/PWGCF/Flow/Tasks/flowZdcTask.cxx b/PWGCF/Flow/Tasks/flowZdcTask.cxx index 6ef4d78d9ca..a3497dac4c0 100644 --- a/PWGCF/Flow/Tasks/flowZdcTask.cxx +++ b/PWGCF/Flow/Tasks/flowZdcTask.cxx @@ -44,7 +44,7 @@ using namespace o2::framework::expressions; using namespace o2::aod::mult; using namespace o2::aod::evsel; using ColEvSels = soa::Join; -using AodCollisions = soa::Filtered>; +using AodCollisions = soa::Filtered>; using AodTracks = soa::Filtered>; using BCsRun3 = soa::Join; using AodZDCs = soa::Join; @@ -124,6 +124,7 @@ struct FlowZdcTask { ConfigurableAxis axisFT0MAmp{"axisFT0MAmp", {10000, 0, 10000}, "axisFT0MAmp"}; ConfigurableAxis ft0cMultHistBin{"ft0cMultHistBin", {501, -0.5, 500.5}, ""}; ConfigurableAxis multHistBin{"multHistBin", {501, -0.5, 500.5}, ""}; + ConfigurableAxis axisCent{"axisCent", {10, 0, 100}, "axisCent"}; Filter collisionFilter = nabs(aod::collision::posZ) < cfgCutVertex; Filter trackFilter = (nabs(aod::track::eta) < cfgCutEta) && (aod::track::pt > cfgCutPtMin) && (aod::track::pt < cfgCutPtMax) && ((requireGlobalTrackInFilter()) || (aod::track::isGlobalTrackSDD == (uint8_t) true)) && (aod::track::tpcChi2NCl < cfgCutChi2prTPCcls) && (nabs(aod::track::dcaZ) < cfgCutDCAz) && (nabs(aod::track::dcaXY) < cfgCutDCAxy); @@ -175,10 +176,9 @@ struct FlowZdcTask { AxisSpec axisVtxcounts{2, -0.5f, 1.5f, "Vtx info (0=no, 1=yes)"}; AxisSpec axisVtxZ{40, -20, 20, "Vertex Z", "VzAxis"}; AxisSpec axisZvert{120, -30.f, 30.f, "Vtx z (cm)"}; - AxisSpec axisCent{8, 0.f, 105.f, "centrality"}; AxisSpec axisCentBins{{0, 5., 10., 20., 30., 40., 50., 60., 70., 80.}, "centrality percentile"}; AxisSpec axisPtBins{{0., 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0, 2.25, 2.5, 2.75, 3.0, 3.5, 4.0, 4.5, 5.0, 6.0, 8.0, 10., 13., 16., 20.}, "p_{T} (GeV/c)"}; - AxisSpec axisEvent{6, 0.5, 6.5, "#Event", "EventAxis"}; + AxisSpec axisEvent{11, 0.5, 11.5, "#Event", "EventAxis"}; AxisSpec axisMult = {multHistBin, "Mult", "MultAxis"}; AxisSpec axisFT0CMult = {ft0cMultHistBin, "ft0c", "FT0CMultAxis"}; @@ -225,6 +225,10 @@ struct FlowZdcTask { xAxis->SetBinLabel(4, "kIsGoodZvtxFT0vsPV"); // small difference between z-vertex from PV and from FT0 xAxis->SetBinLabel(5, "kIsVertexITSTPC"); // at least one ITS-TPC track (reject vertices built from ITS-only tracks) xAxis->SetBinLabel(6, "kIsGoodITSLayersAll"); //"Centrality based on no other collisions in this Readout Frame with per-collision multiplicity above threshold tracks" + xAxis->SetBinLabel(7, "kIsApplyVertexTOFmatched"); + xAxis->SetBinLabel(8, "kIsVertexTRDmatched"); + xAxis->SetBinLabel(9, "centrality selection"); + xAxis->SetBinLabel(10, "isApplyExtraCorrCut"); histos.add("GlobalMult_vs_FT0C", "GlobalMult_vs_FT0C", kTH2F, {axisMult, axisFT0CMult}); histos.add("VtxZHist", "VtxZHist", kTH1D, {axisVtxZ}); @@ -299,6 +303,25 @@ struct FlowZdcTask { return false; } histos.fill(HIST("eventSelectionSteps"), 6); + if (isApplyVertexTOFmatched && !col.selection_bit(o2::aod::evsel::kIsVertexTOFmatched)) { + return false; + } + histos.fill(HIST("eventSelectionSteps"), 7); + + if (isApplyVertexTRDmatched && !col.selection_bit(o2::aod::evsel::kIsVertexTRDmatched)) { + return false; + } + histos.fill(HIST("eventSelectionSteps"), 8); + if (col.centFT0C() < 0. || col.centFT0C() > 100.) { + return false; + } + histos.fill(HIST("eventSelectionSteps"), 9); + + if (isApplyExtraCorrCut && col.multNTracksPV() > npvTracksCut && col.multFT0C() < (10 * col.multNTracksPV() - ft0cCut)) { + return false; + } + histos.fill(HIST("eventSelectionSteps"), 10); + histos.fill(HIST("eventSelectionSteps"), 11); return true; } @@ -315,8 +338,6 @@ struct FlowZdcTask { // this is the q vector for the TPC data. it is a complex function double qTpcReal = 0.0; // Initialize qTPC_real double qTpcIm = 0.0; // init qTPC_imaginary - if (cent < 0.0 && cent > 70) - return; std::complex qTPC(0, 0); // Starting with a q-vector of zero int nTot{0}; // Tracks are already filtered with GlobalTrack || GlobalTrackSDD for (const auto& track : tracks) { From 4beab51df49e7c608e20e40dd5b06db66ce1076a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dawid=20Karpi=C5=84ski?= <40724893+davkk@users.noreply.github.com> Date: Thu, 6 Feb 2025 21:17:26 +0100 Subject: [PATCH 26/30] [PWGCF/FemtoUniverse] Add more flags to efficiency calculator script + fix configurable for timestamps (#9798) --- .../Core/FemtoUniverseEfficiencyCalculator.h | 4 +- .../femto_universe_efficiency_calculator.py | 122 ++++++++++++------ 2 files changed, 84 insertions(+), 42 deletions(-) diff --git a/PWGCF/FemtoUniverse/Core/FemtoUniverseEfficiencyCalculator.h b/PWGCF/FemtoUniverse/Core/FemtoUniverseEfficiencyCalculator.h index 2cde8f14422..05794b5c477 100644 --- a/PWGCF/FemtoUniverse/Core/FemtoUniverseEfficiencyCalculator.h +++ b/PWGCF/FemtoUniverse/Core/FemtoUniverseEfficiencyCalculator.h @@ -40,7 +40,7 @@ struct EfficiencyConfigurableGroup : ConfigurableGroup { Configurable confEfficiencyApplyCorrections{"confEfficiencyApplyCorrections", false, "Should apply corrections from efficiency"}; Configurable> confEfficiencyCCDBLabels{"confEfficiencyCCDBLabels", {}, "Custom labels for efficiency objects in CCDB"}; Configurable confCCDBTrainNumber{"confCCDBTrainNumber", -1, "Train number for which to query CCDB objects (set to -1 to ignore)"}; - ConfigurableAxis confEfficiencyCCDBTimestamps{"confEfficiencyCCDBTimestamps", {-1, -1}, "Timestamps in CCDB, to query for specific objects (default: -1 for both)"}; + Configurable> confEfficiencyCCDBTimestamps{"confEfficiencyCCDBTimestamps", {"-1", "-1"}, "Timestamps in CCDB, to query for specific objects (default: -1 for both, the latest valid object)"}; // NOTE: in the future we might move the below configurables to a separate struct, eg. CCDBConfigurableGroup Configurable confCCDBUrl{"confCCDBUrl", "http://alice-ccdb.cern.ch", "CCDB URL to be used"}; @@ -119,7 +119,7 @@ class EfficiencyCalculator } auto timestamp = partNo - 1 < config->confEfficiencyCCDBTimestamps->size() - ? static_cast(config->confEfficiencyCCDBTimestamps.value[partNo - 1]) + ? std::stoll(config->confEfficiencyCCDBTimestamps.value[partNo - 1]) : -1; auto hEff = ccdb.getSpecific(config->confCCDBPath, timestamp, metadata); diff --git a/PWGCF/FemtoUniverse/Scripts/femto_universe_efficiency_calculator.py b/PWGCF/FemtoUniverse/Scripts/femto_universe_efficiency_calculator.py index b85344ebe00..2a0b822d215 100755 --- a/PWGCF/FemtoUniverse/Scripts/femto_universe_efficiency_calculator.py +++ b/PWGCF/FemtoUniverse/Scripts/femto_universe_efficiency_calculator.py @@ -25,52 +25,82 @@ import ROOT # pylint: disable=import-error -parser = argparse.ArgumentParser(description="A tool to calculate efficiency and upload it to CCDB") + +class CustomHelpFormatter(argparse.HelpFormatter): + "Add default value to help format" + + def _get_help_string(self, action): + help_str = action.help + if help_str is not None and action.default not in [argparse.SUPPRESS, None]: + help_str += f" (default: {action.default})" + return help_str + + +parser = argparse.ArgumentParser( + description="A tool to calculate efficiency and upload it to CCDB", + formatter_class=CustomHelpFormatter, +) parser.add_argument( - "run_dir", + "--alien-path", type=Path, - help="Path to run directory with analysis results", + help="path to train run's directory in Alien with analysis results " + "[example: /alice/cern.ch/user/a/alihyperloop/outputs/0033/332611/70301]", +) +parser.add_argument( + "--mc-reco", + type=str, + nargs="+", + help="paths to MC Reco histograms, separated by space [example: task/mcreco_one/hPt task/mcreco_two/hPt]", + required=True, ) parser.add_argument( - "--task", - "-t", + "--mc-truth", type=str, - help="Task name to query histograms from", + nargs="+", + help="paths to MC Truth histograms, separated by space [example: task/mctruth_one/hPt task/mctruth_one/hPt]", required=True, ) parser.add_argument( "--ccdb-path", - "-P", type=str, - help="Path where to save in CCDB", + help="location in CCDB to where objects will be uploaded", required=True, ) parser.add_argument( "--ccdb-url", - "-U", type=str, - help="Path where to save in CCDB", + help="URL to CCDB", default="http://ccdb-test.cern.ch:8080", ) parser.add_argument( "--ccdb-labels", - "-L", type=str, nargs="+", - help="Labels for objects' metadata in CCDB", - default=[""] * 2, + help="custom labels to add to objects' metadata in CCDB [example: label1 label2]", + default=[], ) parser.add_argument( "--ccdb-lifetime", - "-T", type=int, - help="How long should the objects' validity in CCDB last (default: 1 year)", + help="how long should objects in CCDB remain valid (milliseconds)", default=365 * 24 * 60 * 60 * 1000, # one year ) args = parser.parse_args() +if len(args.mc_reco) != len(args.mc_truth): + print("[!] Provided number of histograms with MC Reco must match MC Truth", file=sys.stderr) + sys.exit(1) + +if len(args.ccdb_labels) > 0 and len(args.ccdb_labels) != len(args.mc_reco): + print("[!] You must provide labels for all particles", file=sys.stderr) + sys.exit(1) + +if len(args.ccdb_labels) == 0: + # if flag is not provided, fill with empty strings to match size + args.ccdb_labels = [""] * len(args.mc_reco) + ANALYSIS_RESULTS = "AnalysisResults.root" -results_path = args.run_dir / ANALYSIS_RESULTS +results_path = args.alien_path / ANALYSIS_RESULTS job_id = results_path.parent.name train_number = results_path.parent.parent.name @@ -81,7 +111,7 @@ # get file from alien if not res_dest.is_file(): - print(f"[↓] Downloading analysis results from Alien to {res_dest} ...", file=sys.stderr) + print(f"[↓] Downloading analysis results from Alien to '{res_dest}' ...", file=sys.stderr) ROOT.TGrid.Connect("alien://") try: subprocess.run( @@ -92,14 +122,15 @@ print("[-] Download complete!", file=sys.stderr) except subprocess.CalledProcessError as error: print(f"[!] Error while downloading results file: {error.stderr}", file=sys.stderr) - sys.exit(0) + sys.exit(1) else: print( - f"[-] Skipping download from Alien, since {res_dest} is already present", + f"[-] Skipping download from Alien, since '{res_dest}' is already present", file=sys.stderr, ) -particles = {1: "one", 2: "two"} +print() + histos_to_upload = [] # get reco & truth histos @@ -107,26 +138,28 @@ ROOT.TFile.Open(res_dest.as_uri()) as res_file, ROOT.TFile.Open(eff_dest.as_uri(), "recreate") as eff_file, ): - for idx, part_num in particles.items(): - reco = res_file.Get(f"{args.task}/Tracks_{part_num}_MC/hPt") - truth = res_file.Get(f"{args.task}/MCTruthTracks_{part_num}/hPt") - if not reco and not truth: - print( - f"[-] No MC Reco nor MC Truth histogram found for particle {part_num}", - file=sys.stderr, - ) - continue + for idx, (mc_reco, mc_truth) in enumerate(zip(args.mc_reco, args.mc_truth)): + hist_reco = res_file.Get(mc_reco) + if not hist_reco: + print(f"[!] Cannot find MC Reco histogram in '{mc_reco}', aborting", file=sys.stderr) + sys.exit(1) - num_bins = reco.GetNbinsX() - x_max = reco.GetXaxis().GetBinLowEdge(num_bins) + reco.GetXaxis().GetBinWidth(num_bins) + hist_truth = res_file.Get(mc_truth) + if not hist_truth: + print(f"[!] Cannot find MC Truth histogram in '{mc_truth}', aborting", file=sys.stderr) + sys.exit(1) - hist_name = f"Efficiency_part{idx}" + num_bins = hist_reco.GetNbinsX() + x_max = hist_reco.GetXaxis().GetBinLowEdge(num_bins) + x_max += hist_reco.GetXaxis().GetBinWidth(num_bins) + + hist_name = f"Efficiency_part{idx + 1}" # calculate efficiency eff = ROOT.TH1F(hist_name, "", num_bins, 0, x_max) for bin_idx in range(len(eff)): - denom = truth.GetBinContent(bin_idx) - eff.SetBinContent(bin_idx, reco.GetBinContent(bin_idx) / denom if denom > 0 else 0) + denom = hist_truth.GetBinContent(bin_idx) + eff.SetBinContent(bin_idx, hist_reco.GetBinContent(bin_idx) / denom if denom > 0 else 0) # save efficiency object to file eff_file.WriteObject(eff, hist_name) @@ -134,7 +167,7 @@ if len(histos_to_upload) == 0: print("[-] Exiting, since there is nothing to upload", file=sys.stderr) - sys.exit(0) + sys.exit(1) # upload objects to ccdb try: @@ -142,7 +175,7 @@ timestamp_start = int(time.time() * 1000) timestamp_end = timestamp_start + args.ccdb_lifetime - print(f"[↑] Uploading {key} to CCDB ... ", file=sys.stderr, end="") + print(f"[↑] Uploading {key} to {args.ccdb_url} ... ", file=sys.stderr, end="") upload_cmd = [ "o2-ccdb-upload", "--file", @@ -161,14 +194,23 @@ f"trainNumber={train_number};label={args.ccdb_labels[idx]}", ] result = subprocess.run(upload_cmd, capture_output=True, check=True) + + if "html" in result.stdout.decode("utf-8"): + print( + f"\n[!] Something went wrong with upload request: {result.stdout.decode('utf-8')}", + file=sys.stderr, + ) + sys.exit(1) + if result.stderr: - print(f"[!] Error while uploading: {result.stderr.decode('utf-8')}", file=sys.stderr) - sys.exit(0) + print(f"\n[!] Error while uploading: {result.stderr.decode('utf-8')}", file=sys.stderr) + sys.exit(1) print("complete!", file=sys.stderr) except subprocess.CalledProcessError as error: - print(f"[!] Error while uploading: {error.stderr.decode('utf-8')}", file=sys.stderr) - sys.exit(0) + print(f"\n[!] Error while uploading: {error.stderr.decode('utf-8')}", file=sys.stderr) + sys.exit(1) +print() print("[✓] Success!", file=sys.stderr) From 8dac72b5f3a844544f145273ef2fa57fb90b785d Mon Sep 17 00:00:00 2001 From: omvazque Date: Thu, 6 Feb 2025 14:50:20 -0600 Subject: [PATCH 27/30] [PWGLF] Analyze per collision v2 (#9796) --- PWGLF/Tasks/GlobalEventProperties/uccZdc.cxx | 425 ++++++++++++------- 1 file changed, 261 insertions(+), 164 deletions(-) diff --git a/PWGLF/Tasks/GlobalEventProperties/uccZdc.cxx b/PWGLF/Tasks/GlobalEventProperties/uccZdc.cxx index 8f8ec7d6ffa..0234463ec6b 100644 --- a/PWGLF/Tasks/GlobalEventProperties/uccZdc.cxx +++ b/PWGLF/Tasks/GlobalEventProperties/uccZdc.cxx @@ -26,6 +26,7 @@ #include "Common/DataModel/Multiplicity.h" #include "Common/DataModel/TrackSelectionTables.h" #include "CommonConstants/MathConstants.h" +#include "Framework/ASoAHelpers.h" // required for Filter op. #include "Framework/AnalysisDataModel.h" #include "Framework/AnalysisTask.h" #include "Framework/HistogramRegistry.h" @@ -43,13 +44,20 @@ using namespace o2::aod::evsel; using namespace o2::constants::physics; using namespace o2::constants::math; -using ColEvSels = soa::Join; -// o2::aod::BCsWithTimestamps = soa::Join -using BCsRun3 = soa::Join; - -using SimCollisions = soa::Join; -using SimTracks = soa::Join; -using TableTracks = soa::Join; +namespace o2::aod +{ +using ColEvSels = soa::Join; +using BCsRun3 = + soa::Join; +using TracksSel = + soa::Join; +} // namespace o2::aod + +using SimCollisions = soa::Join; +using SimTracks = soa::Join; struct UccZdc { // Event selection @@ -58,27 +66,31 @@ struct UccZdc { Configurable maxT0CcentCut{"maxT0CcentCut", 90.0, "Max T0C Cent. cut"}; // Track selection settings - Configurable minItsNclusters{"minItsNclusters", 5, "minimum number of ITS clusters"}; - Configurable minTpcNclusters{"minTpcNclusters", 70, "minimum number of TPC clusters"}; + Configurable minItsNclusters{"minItsNclusters", 5, + "minimum number of ITS clusters"}; + Configurable minTpcNclusters{"minTpcNclusters", 70, + "minimum number of TPC clusters"}; Configurable minTpcNcrossedRows{"minTpcNcrossedRows", 70, "minimum number of TPC crossed pad rows"}; Configurable maxChiSquareTpc{"maxChiSquareTpc", 4.0, "maximum TPC chi^2/Ncls"}; - Configurable maxChiSquareIts{"maxChiSquareIts", 36.0, "maximum ITS chi^2/Ncls"}; + Configurable maxChiSquareIts{"maxChiSquareIts", 36.0, + "maximum ITS chi^2/Ncls"}; Configurable minPt{"minPt", 0.1, "minimum pt of the tracks"}; Configurable maxPt{"maxPt", 50., "maximum pt of the tracks"}; Configurable minEta{"minEta", -0.8, "minimum eta"}; Configurable maxEta{"maxEta", +0.8, "maximum eta"}; Configurable maxDcaxy{"maxDcaxy", 0.05, "Maximum DCAxy"}; Configurable maxDcaz{"maxDcaz", 0.05, "Maximum DCAz"}; - Configurable setDCAselectionPtDep{"setDCAselectionPtDep", true, "require pt dependent selection"}; + Configurable setDCAselectionPtDep{"setDCAselectionPtDep", true, + "require pt dependent selection"}; Configurable par0{"par0", 0.0105, "par 0"}; Configurable par1{"par1", 0.035, "par 1"}; // Configurables, binning - Configurable nBinsAmpFV0{"nBinsAmpFV0", 1000, "Number of bins FV0 amplitude"}; + Configurable nBinsAmpFV0{"nBinsAmpFV0", 1000, + "Number of bins FV0 amplitude"}; Configurable maxAmpFV0{"maxAmpFV0", 3000, "Max FV0 amplitude"}; - Configurable nBinsAmpFT0{"nBinsAmpFT0", 1000, "Number of bins FT0 amplitude"}; + Configurable nBinsAmpFT0{"nBinsAmpFT0", 1000, + "Number of bins FT0 amplitude"}; Configurable maxAmpFT0{"maxAmpFT0", 3000, "Max FT0 amplitude"}; - Configurable nBinsNchT0{"nBinsNchT0", 1000, "nBinsNchT0"}; - Configurable maxNchFT0{"maxNchFT0", 1000, "Max Nch in the FT0"}; Configurable nBinsNch{"nBinsNch", 2500, "# of bins for midrapidity Nch"}; Configurable maxNch{"maxNch", 2500, "Max Nch at midrapidity"}; Configurable nBinsZDC{"nBinsZDC", 1025, "nBinsZDC"}; @@ -86,17 +98,34 @@ struct UccZdc { Configurable maxZP{"maxZP", 3099.5, "Max ZP signal"}; Configurable maxZEM{"maxZEM", 3099.5, "Max ZEM signal"}; Configurable nBinsTDC{"nBinsTDC", 480, "nbinsTDC"}; + Configurable minTdc{"minTdc", -15.0, "minimum TDC"}; + Configurable maxTdc{"maxTdc", 15.0, "maximum TDC"}; + Configurable minMeanpT{"minMeanpT", 0.5, "minimum [pT]"}; + Configurable maxMeanpT{"maxMeanpT", 1.1, "maximum [pT]"}; + Configurable nBinsMeanpT{"nBinsMeanpT", 160, "# bins [pT]"}; ConfigurableAxis binsPt{"binsPt", {VARIABLE_WIDTH, 0., 0.1, 0.25, 0.5, 1., 2., 4., 6., 8., 10., 20.}, "Binning of the pT axis"}; ConfigurableAxis binsCent{"binsCent", {VARIABLE_WIDTH, 0., 10., 20., 30., 40., 50., 60., 70., 80., 90., 100.}, "T0C centrality binning"}; // Configurable flags ZDC - Configurable isTDCcut{"isTDCcut", false, "Flag for TDC cut"}; + Configurable isTDCcut{"isTDCcut", false, "Use TDC cut?"}; + Configurable isZEMcut{"isZEMcut", true, "Use ZEM cut?"}; + Configurable zemCut{"zemCut", 1000.0, "ZEM cut"}; Configurable tdcCut{"tdcCut", 1.0, "TDC cut"}; Configurable tdcZNmincut{"tdcZNmincut", -4.0, "Min ZN TDC cut"}; Configurable tdcZNmaxcut{"tdcZNmaxcut", -4.0, "Max ZN TDC cut"}; Configurable tdcZPmincut{"tdcZPmincut", -4.0, "Min ZP TDC cut"}; Configurable tdcZPmaxcut{"tdcZPmaxcut", -4.0, "Max ZP TDC cut"}; + // Filters + Filter collFilter = (nabs(aod::collision::posZ) < posZcut); + Filter trackFilter = (requireGlobalTrackInFilter()); + + // Apply Filters + using TheFilteredCollisions = soa::Filtered; + using TheFilteredCollision = TheFilteredCollisions::iterator; + using TheFilteredTracks = soa::Filtered; + // using TheFilteredTrack = TheFilteredTracks::iterator; + // Histograms: Data HistogramRegistry registryData{ "registryData", @@ -116,7 +145,7 @@ struct UccZdc { void init(InitContext const&) { // define axes you want to use - const AxisSpec axisEvent{3, 0., +3.0, ""}; + const AxisSpec axisEvent{10, 0., +10.0, ""}; const AxisSpec axisEta{30, -1.5, +1.5, "#eta"}; const AxisSpec axisPt{binsPt, "#it{p}_{T} (GeV/#it{c})"}; const AxisSpec axisDeltaPt{100, -1.0, +1.0, "#Delta(p_{T})"}; @@ -127,14 +156,35 @@ struct UccZdc { {{{axisEta}, {100, -0.1 * PI, +2.1 * PI}}}); registryData.add("etaHistogram", "etaHistogram", kTH1F, {axisEta}); registryData.add("ptHistogram", "ptHistogram", kTH1F, {axisPt}); + registryData.add("dcaXYvspT", ";DCA_{xy};p_{T};", + {HistType::kTH2F, {{{50, -1., 1.}, {axisPt}}}}); registryData.add("hT0C_cent", ";T0C centrality;Entries", kTH1F, {axisCent}); registryData.add("hEventCounter", "Event counter", kTH1F, {axisEvent}); - registryData.add("NchT0A", "NchT0A; Nch T0A; Entries", - {HistType::kTH1F, {{nBinsNchT0, -0.5, maxNchFT0}}}); - registryData.add("NchT0C", "NchT0C; Nch T0C; Entries", - {HistType::kTH1F, {{nBinsNchT0, -0.5, maxNchFT0}}}); - + registryData.get(HIST("hEventCounter")) + ->GetXaxis() + ->SetBinLabel(1, "total"); + registryData.get(HIST("hEventCounter")) + ->GetXaxis() + ->SetBinLabel(2, "sel8?"); + registryData.get(HIST("hEventCounter")) + ->GetXaxis() + ->SetBinLabel(3, "zdc?"); + registryData.get(HIST("hEventCounter")) + ->GetXaxis() + ->SetBinLabel(4, "t0?"); + registryData.get(HIST("hEventCounter")) + ->GetXaxis() + ->SetBinLabel(5, "v0a?"); + registryData.get(HIST("hEventCounter")) + ->GetXaxis() + ->SetBinLabel(6, "TDC cut"); + registryData.get(HIST("hEventCounter")) + ->GetXaxis() + ->SetBinLabel(7, "zem cut"); + registryData.get(HIST("hEventCounter")) + ->GetXaxis() + ->SetBinLabel(8, "min < t0c < max"); registryData.add("ZNAcomm", "; ZNA common energy; Entries", {HistType::kTH1F, {{nBinsZDC, -0.5, maxZN}}}); registryData.add("ZNCcomm", "; ZNC common energy; Entries", @@ -168,25 +218,28 @@ struct UccZdc { {{{nBinsZDC, -0.5, maxZP}, {nBinsZDC, -0.5, maxZN}}}}); registryData.add("ZNCvstdc", "ZNCvstdc; time ZNC; ZNC", {HistType::kTH2F, - {{{nBinsTDC, -13.5, 11.45}, {nBinsZDC, -0.5, maxZN}}}}); + {{{nBinsTDC, minTdc, maxTdc}, {nBinsZDC, -0.5, maxZN}}}}); registryData.add("ZNAvstdc", "ZNAvstdc; time ZNA; ZNA", {HistType::kTH2F, - {{{nBinsTDC, -13.5, 11.45}, {nBinsZDC, -0.5, maxZN}}}}); + {{{nBinsTDC, minTdc, maxTdc}, {nBinsZDC, -0.5, maxZN}}}}); registryData.add("ZPCvstdc", "ZPCvstdc; time ZPC; ZPC", {HistType::kTH2F, - {{{nBinsTDC, -13.5, 11.45}, {nBinsZDC, -0.5, maxZP}}}}); + {{{nBinsTDC, minTdc, maxTdc}, {nBinsZDC, -0.5, maxZP}}}}); registryData.add("ZPAvstdc", "ZPAvstdc; time ZPA; ZPA", {HistType::kTH2F, - {{{nBinsTDC, -13.5, 11.45}, {nBinsZDC, -0.5, maxZP}}}}); - registryData.add("ZEM1vstdc", "ZEM1vstdc; time ZEM1; ZEM1", - {HistType::kTH2F, - {{{nBinsTDC, -13.5, 11.45}, {nBinsZDC, -0.5, maxZEM}}}}); - registryData.add("ZEM2vstdc", "ZEM2vstdc; time ZEM2; ZEM2", - {HistType::kTH2F, - {{{nBinsTDC, -13.5, 11.45}, {nBinsZDC, -0.5, maxZEM}}}}); - registryData.add("debunch", - "ZN sum vs. ZN diff.; t_{ZNA}-t_{ZNC}; t_{ZNA}+t_{ZNC}", - {HistType::kTH2F, {{{240, -12., 12.}, {240, -12., 12.}}}}); + {{{nBinsTDC, minTdc, maxTdc}, {nBinsZDC, -0.5, maxZP}}}}); + registryData.add( + "ZEM1vstdc", "ZEM1vstdc; time ZEM1; ZEM1", + {HistType::kTH2F, + {{{nBinsTDC, minTdc, maxTdc}, {nBinsZDC, -0.5, maxZEM}}}}); + registryData.add( + "ZEM2vstdc", "ZEM2vstdc; time ZEM2; ZEM2", + {HistType::kTH2F, + {{{nBinsTDC, minTdc, maxTdc}, {nBinsZDC, -0.5, maxZEM}}}}); + registryData.add( + "debunch", "ZN sum vs. ZN diff.; t_{ZDC}-t_{ZDA}; t_{ZDC}+t_{ZDA}", + {HistType::kTH2F, + {{{nBinsTDC, minTdc, maxTdc}, {nBinsTDC, minTdc, maxTdc}}}}); registryData.add( "ZNvsFV0A", "ZNvsFV0A", {HistType::kTH2F, @@ -195,17 +248,27 @@ struct UccZdc { "ZNvsFT0", "FT0", {HistType::kTH2F, {{{nBinsAmpFT0, 0., maxAmpFT0}, {nBinsZDC, -0.5, maxZN}}}}); - registryData.add("ZNCvsNch", ";Nch (|#eta|<0.8);ZNC", {HistType::kTH2F, {{{nBinsNch, -0.5, maxNch}, {nBinsZDC, -0.5, maxZN}}}}); registryData.add("ZNAvsNch", ";Nch (|#eta|<0.8);ZNA", {HistType::kTH2F, {{{nBinsNch, -0.5, maxNch}, {nBinsZDC, -0.5, maxZN}}}}); + registryData.add("ZNCvsNchvspT", ";Nch (|#eta|<0.8);ZNC;[p_{T}]", + {HistType::kTH3F, + {{{nBinsNch, -0.5, maxNch}, + {nBinsZDC, -0.5, maxZN}, + {nBinsMeanpT, minMeanpT, maxMeanpT}}}}); + registryData.add("ZNAvsNchvspT", ";Nch (|#eta|<0.8);ZNA;[p_{T}]", + {HistType::kTH3F, + {{{nBinsNch, -0.5, maxNch}, + {nBinsZDC, -0.5, maxZN}, + {nBinsMeanpT, minMeanpT, maxMeanpT}}}}); // MC Histograms registrySim.add("hEvent_MC_rec", "Event counter", kTH1F, {axisEvent}); - registrySim.add("hT0C_cent_rec", ";T0C centrality;Entries", kTH1F, {axisCent}); + registrySim.add("hT0C_cent_rec", ";T0C centrality;Entries", kTH1F, + {axisCent}); registrySim.add("Pt_MC_rec_ch", ";p_{T};Entries;", kTH1F, {axisPt}); registrySim.add("Pt_MC_rec_pi", ";p_{T};Entries;", kTH1F, {axisPt}); registrySim.add("Pt_MC_rec_ka", ";p_{T};Entries;", kTH1F, {axisPt}); @@ -247,137 +310,158 @@ struct UccZdc { kTH1F, {axisPt}); } - void processZdcCollAss(ColEvSels const& cols, BCsRun3 const& /*bcs*/, + void processZdcCollAss(TheFilteredCollision const& collision, + o2::aod::BCsRun3 const& /*bcs*/, aod::Zdcs const& /*zdcs*/, aod::FV0As const& /*fv0as*/, - aod::FT0s const& /*ft0s*/, TableTracks const& tracks) + aod::FT0s const& /*ft0s*/, + TheFilteredTracks const& tracks) { - // Collision loop - for (const auto& collision : cols) { - registryData.fill(HIST("hEventCounter"), 0.5); - if (!collision.sel8()) { - return; + registryData.fill(HIST("hEventCounter"), 0.5); + if (!collision.sel8()) { + return; + } + registryData.fill(HIST("hEventCounter"), 1.5); + + const auto& foundBC = collision.foundBC_as(); + // Does the event has ZDC? + if (!foundBC.has_zdc()) { + return; + } + registryData.fill(HIST("hEventCounter"), 2.5); + + auto aZNA = foundBC.zdc().amplitudeZNA(); + auto aZNC = foundBC.zdc().amplitudeZNC(); + auto aZPA = foundBC.zdc().amplitudeZPA(); + auto aZPC = foundBC.zdc().amplitudeZPC(); + auto aZEM1 = foundBC.zdc().amplitudeZEM1(); + auto aZEM2 = foundBC.zdc().amplitudeZEM2(); + auto tZEM1 = foundBC.zdc().timeZEM1(); + auto tZEM2 = foundBC.zdc().timeZEM2(); + auto tZNA = foundBC.zdc().timeZNA(); + auto tZNC = foundBC.zdc().timeZNC(); + auto tZPA = foundBC.zdc().timeZPA(); + auto tZPC = foundBC.zdc().timeZPC(); + double tZDCdif{tZNC + tZPC - tZNA - tZPA}; + double tZDCsum{tZNC + tZPC + tZNA + tZPA}; + float sumZNs{aZNA + aZNC}; + float sumT0s{0.}; + float aT0A{0.}; + float aT0C{0.}; + float aV0A{0.}; + double sumZEMs{0.}; + sumZEMs = aZEM1 + aZEM2; + float nchTPC = collision.multTPC(); + + if (foundBC.has_ft0()) { + for (const auto& amplitude : foundBC.ft0().amplitudeA()) { + aT0A += amplitude; + } + for (const auto& amplitude : foundBC.ft0().amplitudeC()) { + aT0C += amplitude; } + sumT0s = aT0A + aT0C; + registryData.fill(HIST("hEventCounter"), 3.5); + } else { + aT0A = aT0C = -999.; + sumT0s = -999.; + } - registryData.fill(HIST("hEventCounter"), 1.5); + if (foundBC.has_fv0a()) { + for (const auto& amplitude : foundBC.fv0a().amplitude()) { + aV0A += amplitude; + } + registryData.fill(HIST("hEventCounter"), 4.5); + } else { + aV0A = -999.; + } - const auto& foundBC = collision.foundBC_as(); - if (foundBC.has_zdc()) { - registryData.fill(HIST("hEventCounter"), 2.5); - - const auto& zdcread = foundBC.zdc(); - auto aZNA = zdcread.amplitudeZNA(); - auto aZNC = zdcread.amplitudeZNC(); - auto aZPA = zdcread.amplitudeZPA(); - auto aZPC = zdcread.amplitudeZPC(); - auto aZEM1 = zdcread.amplitudeZEM1(); - auto aZEM2 = zdcread.amplitudeZEM2(); - auto tZEM1 = zdcread.timeZEM1(); - auto tZEM2 = zdcread.timeZEM2(); - auto tZNA = zdcread.timeZNA(); - auto tZNC = zdcread.timeZNC(); - auto tZPA = zdcread.timeZPA(); - auto tZPC = zdcread.timeZPC(); - float tZNdif{tZNA - tZNC}; - float tZNsum{tZNA + tZNC}; - float sumZNs{aZNA + aZNC}; - float sumZEMs{aZEM1 + aZEM2}; - float sumT0s{0.}; - float aT0A{0.}; - float aT0C{0.}; - float aV0A{0.}; - float nchT0A{0.}; - float nchT0C{0.}; - float nchTPC = collision.multTPC(); - - if (foundBC.has_ft0()) { - for (const auto& amplitude : foundBC.ft0().amplitudeA()) { - aT0A += amplitude; - } - for (const auto& amplitude : foundBC.ft0().amplitudeC()) { - aT0C += amplitude; - } - sumT0s = aT0A + aT0C; - nchT0A = collision.multZeqFT0A(); - nchT0C = collision.multZeqFT0C(); - } else { - aT0A = aT0C = -999.; - sumT0s = -999.; - } + // TDC cut + if (isTDCcut) { + if (std::sqrt(std::pow(tZDCdif, 2.) + std::pow(tZDCsum, 2.)) > tdcCut) { + return; + } + } + registryData.fill(HIST("hEventCounter"), 5.5); - if (foundBC.has_fv0a()) { - for (const auto& amplitude : foundBC.fv0a().amplitude()) { - aV0A += amplitude; - } - } else { - aV0A = -999.; - } + // ZEM cut + if (isZEMcut) { + if (sumZEMs < zemCut) { + return; + } + } + registryData.fill(HIST("hEventCounter"), 6.5); - if (isTDCcut) { - if (std::sqrt(std::pow(tZNdif, 2.) + std::pow(tZNsum, 2.)) > tdcCut) { - return; - } - } + // T0C centrality cut + if (collision.centFT0C() < minT0CcentCut || + collision.centFT0C() > maxT0CcentCut) { + return; + } - // T0C centrality cut - if (collision.centFT0C() < minT0CcentCut || collision.centFT0C() > maxT0CcentCut) { - continue; - } + registryData.fill(HIST("hEventCounter"), 7.5); + registryData.fill(HIST("hT0C_cent"), collision.centFT0C()); + registryData.get(HIST("ZNA"))->Fill(aZNA); + registryData.get(HIST("ZNC"))->Fill(aZNC); + registryData.get(HIST("ZPA"))->Fill(aZPA); + registryData.get(HIST("ZPC"))->Fill(aZPC); + registryData.get(HIST("ZNAvsZNC"))->Fill(aZNC, aZNA); + registryData.get(HIST("ZNAvsZPA"))->Fill(aZPA, aZNA); + registryData.get(HIST("ZNCvsZPC"))->Fill(aZPC, aZNC); + registryData.get(HIST("ZPAvsZPC"))->Fill(aZPC, aZPA); + registryData.get(HIST("ZNAvsNch"))->Fill(nchTPC, aZNA); + registryData.get(HIST("ZNCvsNch"))->Fill(nchTPC, aZNC); + registryData.get(HIST("ZNvsZEM"))->Fill(sumZEMs, sumZNs); + registryData.get(HIST("ZNvsFV0A"))->Fill(aV0A / 100., sumZNs); + registryData.get(HIST("ZNvsFT0"))->Fill(sumT0s / 100., sumZNs); + registryData.get(HIST("ZNAcomm")) + ->Fill(foundBC.zdc().energyCommonZNA()); + registryData.get(HIST("ZNCcomm")) + ->Fill(foundBC.zdc().energyCommonZNC()); + registryData.get(HIST("ZEM1"))->Fill(aZEM1); + registryData.get(HIST("ZEM2"))->Fill(aZEM2); + registryData.get(HIST("ZNCvstdc"))->Fill(tZNC, aZNC); + registryData.get(HIST("ZNAvstdc"))->Fill(tZNA, aZNA); + registryData.get(HIST("ZPCvstdc"))->Fill(tZPC, aZPC); + registryData.get(HIST("ZPAvstdc"))->Fill(tZPA, aZPA); + registryData.get(HIST("ZEM1vstdc"))->Fill(tZEM1, aZEM1); + registryData.get(HIST("ZEM2vstdc"))->Fill(tZEM2, aZEM2); + registryData.get(HIST("debunch"))->Fill(tZDCdif, tZDCsum); + + float meanpT{0.0}; + const int64_t nch{tracks.size()}; + for (const auto& track : tracks) { + // Track Selection + // if (!track.isGlobalTrack()) { + // continue; + // } + + // if (track.pt() < minPt || track.pt() > maxPt) { + // continue; + // } + // if (!passedTrackSelection(track)) { + // continue; + // } + meanpT += track.pt(); + registryData.fill(HIST("EtaVsPhi"), track.eta(), track.phi()); + registryData.fill(HIST("etaHistogram"), track.eta()); + registryData.fill(HIST("ptHistogram"), track.pt()); + registryData.fill(HIST("dcaXYvspT"), track.dcaXY(), track.pt()); + } - registryData.fill(HIST("hT0C_cent"), collision.centFT0C()); - registryData.get(HIST("ZNA"))->Fill(aZNA); - registryData.get(HIST("ZNC"))->Fill(aZNC); - registryData.get(HIST("ZPA"))->Fill(aZPA); - registryData.get(HIST("ZPC"))->Fill(aZPC); - registryData.get(HIST("ZNAvsZNC"))->Fill(aZNC, aZNA); - registryData.get(HIST("ZNAvsZPA"))->Fill(aZPA, aZNA); - registryData.get(HIST("ZNCvsZPC"))->Fill(aZPC, aZNC); - registryData.get(HIST("ZPAvsZPC"))->Fill(aZPC, aZPA); - registryData.get(HIST("ZNAvsNch"))->Fill(nchTPC, aZNA); - registryData.get(HIST("ZNCvsNch"))->Fill(nchTPC, aZNC); - registryData.get(HIST("ZNvsZEM"))->Fill(sumZEMs, sumZNs); - registryData.get(HIST("ZNvsFV0A"))->Fill(aV0A / 100., sumZNs); - registryData.get(HIST("ZNvsFT0"))->Fill(sumT0s / 100., sumZNs); - registryData.get(HIST("ZNAcomm"))->Fill(zdcread.energyCommonZNA()); - registryData.get(HIST("ZNCcomm"))->Fill(zdcread.energyCommonZNC()); - registryData.get(HIST("ZEM1"))->Fill(aZEM1); - registryData.get(HIST("ZEM2"))->Fill(aZEM2); - registryData.get(HIST("ZNCvstdc"))->Fill(tZNC, aZNC); - registryData.get(HIST("ZNAvstdc"))->Fill(tZNA, aZNA); - registryData.get(HIST("ZPCvstdc"))->Fill(tZPC, aZPC); - registryData.get(HIST("ZPAvstdc"))->Fill(tZPA, aZPA); - registryData.get(HIST("ZEM1vstdc"))->Fill(tZEM1, aZEM1); - registryData.get(HIST("ZEM2vstdc"))->Fill(tZEM2, aZEM2); - registryData.get(HIST("debunch"))->Fill(tZNdif, tZNsum); - registryData.get(HIST("NchT0A"))->Fill(nchT0A); - registryData.get(HIST("NchT0C"))->Fill(nchT0C); - - for (const auto& track : tracks) { - // Track Selection - if (!track.isGlobalTrack()) { - continue; - } - - if (track.pt() < minPt || track.pt() > maxPt) { - continue; - } - // if (!passedTrackSelection(track)) { - // continue; - // } - registryData.fill(HIST("EtaVsPhi"), track.eta(), track.phi()); - registryData.fill(HIST("etaHistogram"), track.eta()); - registryData.fill(HIST("ptHistogram"), track.pt()); - } - } // foundBC.has_zdc() + if (nch > 0) { + meanpT /= nch; } + registryData.get(HIST("ZNCvsNchvspT"))->Fill(nch, aZNC, meanpT); + registryData.get(HIST("ZNAvsNchvspT"))->Fill(nch, aZNA, meanpT); } PROCESS_SWITCH(UccZdc, processZdcCollAss, "Processing ZDC w. collision association", true); Preslice perMCCollision = aod::mcparticle::mcCollisionId; Preslice perCollision = aod::track::collisionId; - void processMC(aod::McCollisions const& mcCollisions, BCsRun3 const& /*bcs*/, - aod::Zdcs const& /*zdcs*/, aod::FT0s const& /*ft0s*/, - aod::FV0As const& /*fv0as*/, SimCollisions const& collisions, + void processMC(aod::McCollisions const& mcCollisions, + o2::aod::BCsRun3 const& /*bcs*/, aod::Zdcs const& /*zdcs*/, + aod::FT0s const& /*ft0s*/, aod::FV0As const& /*fv0as*/, + SimCollisions const& collisions, aod::McParticles const& mcParticles, SimTracks const& simTracks) { @@ -402,15 +486,22 @@ struct UccZdc { continue; } registrySim.fill(HIST("Pt_MC_tru_ch"), particle.pt()); - if (particle.pdgCode() == PDG_t::kPiPlus || particle.pdgCode() == PDG_t::kPiMinus) { // pion + if (particle.pdgCode() == PDG_t::kPiPlus || + particle.pdgCode() == PDG_t::kPiMinus) { // pion registrySim.fill(HIST("Pt_MC_tru_pi"), particle.pt()); - } else if (particle.pdgCode() == PDG_t::kKPlus || particle.pdgCode() == PDG_t::kKMinus) { // kaon + } else if (particle.pdgCode() == PDG_t::kKPlus || + particle.pdgCode() == PDG_t::kKMinus) { // kaon registrySim.fill(HIST("Pt_MC_tru_ka"), particle.pt()); - } else if (particle.pdgCode() == PDG_t::kProton || particle.pdgCode() == PDG_t::kProtonBar) { // proton + } else if (particle.pdgCode() == PDG_t::kProton || + particle.pdgCode() == PDG_t::kProtonBar) { // proton registrySim.fill(HIST("Pt_MC_tru_pr"), particle.pt()); - } else if (particle.pdgCode() == PDG_t::kSigmaPlus || particle.pdgCode() == PDG_t::kSigmaBarMinus) { // positive sigma + } else if (particle.pdgCode() == PDG_t::kSigmaPlus || + particle.pdgCode() == + PDG_t::kSigmaBarMinus) { // positive sigma registrySim.fill(HIST("Pt_MC_tru_sigpos"), particle.pt()); - } else if (particle.pdgCode() == PDG_t::kSigmaMinus || particle.pdgCode() == PDG_t::kSigmaBarPlus) { // negative sigma + } else if (particle.pdgCode() == PDG_t::kSigmaMinus || + particle.pdgCode() == + PDG_t::kSigmaBarPlus) { // negative sigma registrySim.fill(HIST("Pt_MC_tru_signeg"), particle.pt()); } else { // rest registrySim.fill(HIST("Pt_MC_tru_re"), particle.pt()); @@ -441,14 +532,15 @@ struct UccZdc { } // T0C centrality cut - if (collision.centFT0C() < minT0CcentCut || collision.centFT0C() > maxT0CcentCut) { + if (collision.centFT0C() < minT0CcentCut || + collision.centFT0C() > maxT0CcentCut) { continue; } registrySim.fill(HIST("hEvent_MC_rec"), 2.5); registrySim.fill(HIST("hZpos_MC_rec"), collision.posZ()); - const auto& foundBC = collision.foundBC_as(); + const auto& foundBC = collision.foundBC_as(); if (foundBC.has_zdc()) { return; } @@ -501,15 +593,20 @@ struct UccZdc { const auto particle = track.mcParticle(); registrySim.fill(HIST("Pt_MC_rec_ch"), track.pt()); - if (particle.pdgCode() == PDG_t::kPiPlus || particle.pdgCode() == PDG_t::kPiMinus) { + if (particle.pdgCode() == PDG_t::kPiPlus || + particle.pdgCode() == PDG_t::kPiMinus) { registrySim.fill(HIST("Pt_MC_rec_pi"), track.pt()); - } else if (particle.pdgCode() == PDG_t::kKPlus || particle.pdgCode() == PDG_t::kKMinus) { + } else if (particle.pdgCode() == PDG_t::kKPlus || + particle.pdgCode() == PDG_t::kKMinus) { registrySim.fill(HIST("Pt_MC_rec_ka"), track.pt()); - } else if (particle.pdgCode() == PDG_t::kProton || particle.pdgCode() == PDG_t::kProtonBar) { + } else if (particle.pdgCode() == PDG_t::kProton || + particle.pdgCode() == PDG_t::kProtonBar) { registrySim.fill(HIST("Pt_MC_rec_pr"), track.pt()); - } else if (particle.pdgCode() == PDG_t::kSigmaPlus || particle.pdgCode() == PDG_t::kSigmaBarMinus) { + } else if (particle.pdgCode() == PDG_t::kSigmaPlus || + particle.pdgCode() == PDG_t::kSigmaBarMinus) { registrySim.fill(HIST("Pt_MC_rec_sigpos"), track.pt()); - } else if (particle.pdgCode() == PDG_t::kSigmaMinus || particle.pdgCode() == PDG_t::kSigmaBarPlus) { + } else if (particle.pdgCode() == PDG_t::kSigmaMinus || + particle.pdgCode() == PDG_t::kSigmaBarPlus) { registrySim.fill(HIST("Pt_MC_rec_signeg"), track.pt()); } else { registrySim.fill(HIST("Pt_MC_rec_re"), track.pt()); From a36ec1a4f86dead6069cb6864fec0f14d89c8b2b Mon Sep 17 00:00:00 2001 From: Fabrizio Date: Thu, 6 Feb 2025 22:18:24 +0100 Subject: [PATCH 28/30] [PWGHF,Trigger] Add option to select only signal in MC and improve MC matching (#9801) --- .../PWGHF/HFFilterPrepareMLSamples.cxx | 31 +++++++++++++++---- 1 file changed, 25 insertions(+), 6 deletions(-) diff --git a/EventFiltering/PWGHF/HFFilterPrepareMLSamples.cxx b/EventFiltering/PWGHF/HFFilterPrepareMLSamples.cxx index 5e62416a75d..f85a7c215d7 100644 --- a/EventFiltering/PWGHF/HFFilterPrepareMLSamples.cxx +++ b/EventFiltering/PWGHF/HFFilterPrepareMLSamples.cxx @@ -55,7 +55,7 @@ struct HfFilterPrepareMlSamples { // Main struct Produces train3P; // parameters for production of training samples - Configurable fillSignal{"fillSignal", true, "Flag to fill derived tables with signal for ML trainings"}; + Configurable fillOnlySignal{"fillOnlySignal", true, "Flag to fill derived tables with signal for ML trainings"}; Configurable fillOnlyBackground{"fillOnlyBackground", true, "Flag to fill derived tables with background for ML trainings"}; Configurable downSampleBkgFactor{"downSampleBkgFactor", 1., "Fraction of background candidates to keep for ML trainings"}; Configurable massSbLeftMin{"massSbLeftMin", 1.72, "Left Sideband Lower Minv limit 2 Prong"}; @@ -78,6 +78,10 @@ struct HfFilterPrepareMlSamples { // Main struct void init(InitContext&) { + if (fillOnlySignal && fillOnlyBackground) { + LOGP(fatal, "fillOnlySignal and fillOnlyBackground cannot be activated simultaneously, exit"); + } + ccdb->setURL(url.value); ccdb->setCaching(true); ccdb->setLocalObjectValidityChecking(); @@ -268,7 +272,15 @@ struct HfFilterPrepareMlSamples { // Main struct // D0(bar) → π± K∓ bool isInCorrectColl{false}; - auto indexRec = RecoDecay::getMatchedMCRec(mcParticles, std::array{trackPos, trackNeg}, o2::constants::physics::Pdg::kD0, std::array{+kPiPlus, -kKPlus}, true, &sign); + auto indexRec = RecoDecay::getMatchedMCRec(mcParticles, std::array{trackPos, trackNeg}, o2::constants::physics::Pdg::kD0, std::array{+kPiPlus, -kKPlus}, true, &sign); + + if (fillOnlySignal && indexRec < 0) { + continue; + } + if (fillOnlyBackground && indexRec >= 0) { + continue; + } + if (indexRec > -1) { auto particle = mcParticles.rawIteratorAt(indexRec); flag = RecoDecay::getCharmHadronOrigin(mcParticles, particle); @@ -355,32 +367,39 @@ struct HfFilterPrepareMlSamples { // Main struct int8_t channel = -1; // D± → π± K∓ π± - auto indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughters, o2::constants::physics::Pdg::kDPlus, std::array{+kPiPlus, -kKPlus, +kPiPlus}, true, &sign, 2); + auto indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughters, o2::constants::physics::Pdg::kDPlus, std::array{+kPiPlus, -kKPlus, +kPiPlus}, true, &sign, 2); if (indexRec >= 0) { channel = kDplus; } if (indexRec < 0) { // Ds± → K± K∓ π± - indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughters, o2::constants::physics::Pdg::kDS, std::array{+kKPlus, -kKPlus, +kPiPlus}, true, &sign, 2); + indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughters, o2::constants::physics::Pdg::kDS, std::array{+kKPlus, -kKPlus, +kPiPlus}, true, &sign, 2); if (indexRec >= 0) { channel = kDs; } } if (indexRec < 0) { // Λc± → p± K∓ π± - indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughters, o2::constants::physics::Pdg::kLambdaCPlus, std::array{+kProton, -kKPlus, +kPiPlus}, true, &sign, 2); + indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughters, o2::constants::physics::Pdg::kLambdaCPlus, std::array{+kProton, -kKPlus, +kPiPlus}, true, &sign, 2); if (indexRec >= 0) { channel = kLc; } } if (indexRec < 0) { // Ξc± → p± K∓ π± - indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughters, o2::constants::physics::Pdg::kXiCPlus, std::array{+kProton, -kKPlus, +kPiPlus}, true, &sign, 2); + indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughters, o2::constants::physics::Pdg::kXiCPlus, std::array{+kProton, -kKPlus, +kPiPlus}, true, &sign, 2); if (indexRec >= 0) { channel = kXic; } } + if (fillOnlySignal && indexRec < 0) { + continue; + } + if (fillOnlyBackground && indexRec >= 0) { + continue; + } + bool isInCorrectColl{false}; if (indexRec > -1) { auto particle = mcParticles.rawIteratorAt(indexRec); From c6a5b235618733114222d6bc7000851e9ec0303d Mon Sep 17 00:00:00 2001 From: Maximiliano Puccio Date: Thu, 6 Feb 2025 23:13:01 +0100 Subject: [PATCH 29/30] [PWGLF] Store centrality for non-reconstructed candidates (#9802) --- PWGLF/TableProducer/Nuspex/lnnRecoTask.cxx | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/PWGLF/TableProducer/Nuspex/lnnRecoTask.cxx b/PWGLF/TableProducer/Nuspex/lnnRecoTask.cxx index 6d8e13e69a6..bb7bfc984d3 100644 --- a/PWGLF/TableProducer/Nuspex/lnnRecoTask.cxx +++ b/PWGLF/TableProducer/Nuspex/lnnRecoTask.cxx @@ -207,6 +207,7 @@ struct lnnRecoTask { std::vector filledMothers; // vector to keep track of the collisions passing the event selection in the MC std::vector isGoodCollision; + std::vector collisionFT0Ccent; // vector to armazenade h3Track Preslice perCollision = o2::aod::v0::collisionId; @@ -623,6 +624,8 @@ struct lnnRecoTask { isGoodCollision.clear(); isGoodCollision.resize(mcCollisions.size(), false); + collisionFT0Ccent.clear(); + collisionFT0Ccent.resize(mcCollisions.size(), -1.f); for (const auto& collision : collisions) { lnnCandidates.clear(); @@ -643,6 +646,7 @@ struct lnnRecoTask { if (collision.has_mcCollision()) { isGoodCollision[collision.mcCollisionId()] = true; + collisionFT0Ccent[collision.mcCollisionId()] = collision.centFT0C(); } const uint64_t collIdx = collision.globalIndex(); @@ -727,7 +731,7 @@ struct lnnRecoTask { lnnCand.posTrackID = -1; lnnCand.negTrackID = -1; lnnCand.isSignal = true; - outputMCTable(-1, -1, -1, + outputMCTable(-1, collisionFT0Ccent[mcPart.mcCollisionId()], -1, -1, -1, -1, 0, -1, -1, -1, From 7d73e3f92e79391341edbdcbd5dd1cd30001a569 Mon Sep 17 00:00:00 2001 From: nzardosh Date: Thu, 6 Feb 2025 23:42:52 +0100 Subject: [PATCH 30/30] [PWGJE] refactoring the derived data writer (#9693) --- PWGJE/Core/JetCandidateUtilities.h | 24 +- PWGJE/Core/JetDQUtilities.h | 12 +- PWGJE/Core/JetHFUtilities.h | 12 +- PWGJE/DataModel/JetReducedDataSelector.h | 39 + PWGJE/TableProducer/CMakeLists.txt | 29 +- .../derivedDataProducerDummy.cxx | 82 -- .../derivedDataProducerDummyBplus.cxx | 69 - .../derivedDataProducerDummyCharged.cxx | 84 -- .../derivedDataProducerDummyD0.cxx | 71 - .../derivedDataProducerDummyDielectron.cxx | 79 -- .../derivedDataProducerDummyLc.cxx | 71 - PWGJE/TableProducer/derivedDataSelector.cxx | 331 +++++ PWGJE/TableProducer/derivedDataWriter.cxx | 1250 +++++------------ PWGJE/Tasks/jetSubstructureHFOutput.cxx | 17 +- PWGJE/Tasks/jetSubstructureOutput.cxx | 5 + 15 files changed, 759 insertions(+), 1416 deletions(-) create mode 100644 PWGJE/DataModel/JetReducedDataSelector.h delete mode 100644 PWGJE/TableProducer/derivedDataProducerDummy.cxx delete mode 100644 PWGJE/TableProducer/derivedDataProducerDummyBplus.cxx delete mode 100644 PWGJE/TableProducer/derivedDataProducerDummyCharged.cxx delete mode 100644 PWGJE/TableProducer/derivedDataProducerDummyD0.cxx delete mode 100644 PWGJE/TableProducer/derivedDataProducerDummyDielectron.cxx delete mode 100644 PWGJE/TableProducer/derivedDataProducerDummyLc.cxx create mode 100644 PWGJE/TableProducer/derivedDataSelector.cxx diff --git a/PWGJE/Core/JetCandidateUtilities.h b/PWGJE/Core/JetCandidateUtilities.h index 6c5c0328ef5..8b31b11634e 100644 --- a/PWGJE/Core/JetCandidateUtilities.h +++ b/PWGJE/Core/JetCandidateUtilities.h @@ -373,42 +373,42 @@ float getCandidateInvariantMass(T const& candidate) } template -void fillCandidateCollisionTable(T const& collision, U const& /*candidates*/, V& CandiateCollisionTable, int32_t& CandidateCollisionTableIndex) +void fillCandidateCollisionTable(T const& collision, U const& /*candidates*/, V& CandiateCollisionTable) { if constexpr (jethfutilities::isHFTable()) { - jethfutilities::fillHFCollisionTable(collision, CandiateCollisionTable, CandidateCollisionTableIndex); + jethfutilities::fillHFCollisionTable(collision, CandiateCollisionTable); } else if constexpr (jetdqutilities::isDielectronTable()) { - jetdqutilities::fillDielectronCollisionTable(collision, CandiateCollisionTable, CandidateCollisionTableIndex); // if more dilepton tables are added we would need a fillDQCollisionTable + jetdqutilities::fillDielectronCollisionTable(collision, CandiateCollisionTable); // if more dilepton tables are added we would need a fillDQCollisionTable } } template -void fillCandidateMcCollisionTable(T const& mcCollision, U const& /*candidates*/, V& CandiateMcCollisionTable, int32_t& CandidateMcCollisionTableIndex) +void fillCandidateMcCollisionTable(T const& mcCollision, U const& /*candidates*/, V& CandiateMcCollisionTable) { if constexpr (jethfutilities::isHFMcTable()) { - jethfutilities::fillHFMcCollisionTable(mcCollision, CandiateMcCollisionTable, CandidateMcCollisionTableIndex); + jethfutilities::fillHFMcCollisionTable(mcCollision, CandiateMcCollisionTable); } else if constexpr (jetdqutilities::isDielectronMcTable()) { - jetdqutilities::fillDielectronMcCollisionTable(mcCollision, CandiateMcCollisionTable, CandidateMcCollisionTableIndex); + jetdqutilities::fillDielectronMcCollisionTable(mcCollision, CandiateMcCollisionTable); } } template -void fillCandidateTable(T const& candidate, int32_t collisionIndex, U& BaseTable, V& HFParTable, M& HFParETable, N& HFParDaughterTable, O& HFSelectionFlagTable, P& HFMlTable, Q& HFMlDaughterTable, S& HFMCDTable, int32_t& candidateTableIndex) +void fillCandidateTable(T const& candidate, int32_t collisionIndex, U& BaseTable, V& HFParTable, M& HFParETable, N& HFParDaughterTable, O& HFSelectionFlagTable, P& HFMlTable, Q& HFMlDaughterTable, S& HFMCDTable) { if constexpr (jethfutilities::isHFCandidate()) { - jethfutilities::fillHFCandidateTable(candidate, collisionIndex, BaseTable, HFParTable, HFParETable, HFParDaughterTable, HFSelectionFlagTable, HFMlTable, HFMlDaughterTable, HFMCDTable, candidateTableIndex); + jethfutilities::fillHFCandidateTable(candidate, collisionIndex, BaseTable, HFParTable, HFParETable, HFParDaughterTable, HFSelectionFlagTable, HFMlTable, HFMlDaughterTable, HFMCDTable); } else if constexpr (jetdqutilities::isDielectronCandidate()) { - jetdqutilities::fillDielectronCandidateTable(candidate, collisionIndex, BaseTable, candidateTableIndex); + jetdqutilities::fillDielectronCandidateTable(candidate, collisionIndex, BaseTable); } } template -void fillCandidateMcTable(T const& candidate, int32_t mcCollisionIndex, U& BaseMcTable, int32_t& candidateTableIndex) +void fillCandidateMcTable(T const& candidate, int32_t mcCollisionIndex, U& BaseMcTable) { if constexpr (jethfutilities::isHFMcCandidate()) { - jethfutilities::fillHFCandidateMcTable(candidate, mcCollisionIndex, BaseMcTable, candidateTableIndex); + jethfutilities::fillHFCandidateMcTable(candidate, mcCollisionIndex, BaseMcTable); } else if constexpr (jetdqutilities::isDielectronMcCandidate()) { - jetdqutilities::fillDielectronCandidateMcTable(candidate, mcCollisionIndex, BaseMcTable, candidateTableIndex); + jetdqutilities::fillDielectronCandidateMcTable(candidate, mcCollisionIndex, BaseMcTable); } } diff --git a/PWGJE/Core/JetDQUtilities.h b/PWGJE/Core/JetDQUtilities.h index 91b4c3cdd30..cc26582ca53 100644 --- a/PWGJE/Core/JetDQUtilities.h +++ b/PWGJE/Core/JetDQUtilities.h @@ -312,31 +312,27 @@ uint8_t setDielectronParticleDecayBit(T const& particles, U const& particle) } template -void fillDielectronCollisionTable(T const& collision, U& DielectronCollisionTable, int32_t& DielectronCollisionTableIndex) +void fillDielectronCollisionTable(T const& collision, U& DielectronCollisionTable) { DielectronCollisionTable(collision.tag_raw(), collision.runNumber(), collision.posX(), collision.posY(), collision.posZ(), collision.numContrib(), collision.collisionTime(), collision.collisionTimeRes()); - DielectronCollisionTableIndex = DielectronCollisionTable.lastIndex(); } template -void fillDielectronMcCollisionTable(T const& mcCollision, U& DielectronMcCollisionTable, int32_t& DielectronMcCollisionTableIndex) +void fillDielectronMcCollisionTable(T const& mcCollision, U& DielectronMcCollisionTable) { DielectronMcCollisionTable(mcCollision.posX(), mcCollision.posY(), mcCollision.posZ()); - DielectronMcCollisionTableIndex = DielectronMcCollisionTable.lastIndex(); } template -void fillDielectronCandidateTable(T const& candidate, int32_t collisionIndex, U& DielectronTable, int32_t& DielectronCandidateTableIndex) +void fillDielectronCandidateTable(T const& candidate, int32_t collisionIndex, U& DielectronTable) { DielectronTable(collisionIndex, candidate.mass(), candidate.pt(), candidate.eta(), candidate.phi(), candidate.sign(), candidate.filterMap_raw(), candidate.mcDecision()); - DielectronCandidateTableIndex = DielectronTable.lastIndex(); } template -void fillDielectronCandidateMcTable(T const& candidate, int32_t mcCollisionIndex, U& DielectronMcTable, int32_t& DielectronCandidateTableIndex) +void fillDielectronCandidateMcTable(T const& candidate, int32_t mcCollisionIndex, U& DielectronMcTable) { DielectronMcTable(mcCollisionIndex, candidate.pt(), candidate.eta(), candidate.phi(), candidate.y(), candidate.e(), candidate.m(), candidate.pdgCode(), candidate.getGenStatusCode(), candidate.getHepMCStatusCode(), candidate.isPhysicalPrimary(), candidate.decayFlag(), candidate.origin()); - DielectronCandidateTableIndex = DielectronMcTable.lastIndex(); } }; // namespace jetdqutilities diff --git a/PWGJE/Core/JetHFUtilities.h b/PWGJE/Core/JetHFUtilities.h index 1334d8ad6f6..b281da526c0 100644 --- a/PWGJE/Core/JetHFUtilities.h +++ b/PWGJE/Core/JetHFUtilities.h @@ -481,17 +481,15 @@ float getHFCandidateInvariantMass(T const& candidate) } template -void fillHFCollisionTable(T const& collision, U& HFCollisionTable, int32_t& HFCollisionTableIndex) +void fillHFCollisionTable(T const& collision, U& HFCollisionTable) { HFCollisionTable(collision.posX(), collision.posY(), collision.posZ(), collision.numContrib(), collision.centFT0A(), collision.centFT0C(), collision.centFT0M(), collision.centFV0A(), collision.multZeqNTracksPV()); - HFCollisionTableIndex = HFCollisionTable.lastIndex(); } template -void fillHFMcCollisionTable(T const& mcCollision, U& HFMcCollisionTable, int32_t& HFMcCollisionTableIndex) +void fillHFMcCollisionTable(T const& mcCollision, U& HFMcCollisionTable) { HFMcCollisionTable(mcCollision.posX(), mcCollision.posY(), mcCollision.posZ(), mcCollision.centFT0M()); - HFMcCollisionTableIndex = HFMcCollisionTable.lastIndex(); } template @@ -706,10 +704,9 @@ void fillBplusCandidateTable(T const& candidate, U& BplusParTable, V& BplusParET } template -void fillHFCandidateTable(T const& candidate, int32_t collisionIndex, U& HFBaseTable, V& HFParTable, M& HFParETable, N& HFParDaughterTable, O& HFSelectionFlagTable, P& HFMlTable, Q& HFMlDaughterTable, S& HFMCDTable, int32_t& HFCandidateTableIndex) +void fillHFCandidateTable(T const& candidate, int32_t collisionIndex, U& HFBaseTable, V& HFParTable, M& HFParETable, N& HFParDaughterTable, O& HFSelectionFlagTable, P& HFMlTable, Q& HFMlDaughterTable, S& HFMCDTable) { HFBaseTable(collisionIndex, candidate.pt(), candidate.eta(), candidate.phi(), candidate.m(), candidate.y()); - HFCandidateTableIndex = HFBaseTable.lastIndex(); HFSelectionFlagTable(candidate.candidateSelFlag()); if constexpr (isD0Candidate()) { @@ -724,10 +721,9 @@ void fillHFCandidateTable(T const& candidate, int32_t collisionIndex, U& HFBaseT } template -void fillHFCandidateMcTable(T const& candidate, int32_t mcCollisionIndex, U& BaseMcTable, int32_t& candidateTableIndex) +void fillHFCandidateMcTable(T const& candidate, int32_t mcCollisionIndex, U& BaseMcTable) { BaseMcTable(mcCollisionIndex, candidate.pt(), candidate.eta(), candidate.phi(), candidate.y(), candidate.flagMcMatchGen(), candidate.originMcGen()); - candidateTableIndex = BaseMcTable.lastIndex(); } }; // namespace jethfutilities diff --git a/PWGJE/DataModel/JetReducedDataSelector.h b/PWGJE/DataModel/JetReducedDataSelector.h new file mode 100644 index 00000000000..4e6b07a955b --- /dev/null +++ b/PWGJE/DataModel/JetReducedDataSelector.h @@ -0,0 +1,39 @@ +// 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. + +/// +/// \brief Table definitions for selectors for writing out reduced data model for jets +/// +/// \author Nima Zardoshti + +#ifndef PWGJE_DATAMODEL_JETREDUCEDDATASELECTOR_H_ +#define PWGJE_DATAMODEL_JETREDUCEDDATASELECTOR_H_ + +#include +#include +#include "Framework/AnalysisDataModel.h" + +namespace o2::aod +{ +namespace jetreduceddataselector +{ +DECLARE_SOA_COLUMN(IsCollisionSelected, isCollisionSelected, bool); +DECLARE_SOA_COLUMN(IsMcCollisionSelected, isMcCollisionSelected, bool); + +} // namespace jetreduceddataselector +DECLARE_SOA_TABLE(JCollisionSelections, "AOD", "JCOLLSELECTION", + jetreduceddataselector::IsCollisionSelected); + +DECLARE_SOA_TABLE(JMcCollisionSelections, "AOD", "JMCCOLLSELECTION", + jetreduceddataselector::IsMcCollisionSelected); +} // namespace o2::aod + +#endif // PWGJE_DATAMODEL_JETREDUCEDDATASELECTOR_H_ diff --git a/PWGJE/TableProducer/CMakeLists.txt b/PWGJE/TableProducer/CMakeLists.txt index c946a8722e5..85083da0801 100644 --- a/PWGJE/TableProducer/CMakeLists.txt +++ b/PWGJE/TableProducer/CMakeLists.txt @@ -23,33 +23,8 @@ o2physics_add_dpl_workflow(jet-deriveddata-trigger-producer PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore COMPONENT_NAME Analysis) -o2physics_add_dpl_workflow(jet-deriveddata-producer-dummy - SOURCES derivedDataProducerDummy.cxx - PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore - COMPONENT_NAME Analysis) - -o2physics_add_dpl_workflow(jet-deriveddata-producer-dummy-charged - SOURCES derivedDataProducerDummyCharged.cxx - PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore - COMPONENT_NAME Analysis) - -o2physics_add_dpl_workflow(jet-deriveddata-producer-dummy-d0 - SOURCES derivedDataProducerDummyD0.cxx - PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore - COMPONENT_NAME Analysis) - -o2physics_add_dpl_workflow(jet-deriveddata-producer-dummy-lc - SOURCES derivedDataProducerDummyLc.cxx - PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore - COMPONENT_NAME Analysis) - -o2physics_add_dpl_workflow(jet-deriveddata-producer-dummy-bplus - SOURCES derivedDataProducerDummyBplus.cxx - PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore - COMPONENT_NAME Analysis) - -o2physics_add_dpl_workflow(jet-deriveddata-producer-dummy-dielectron - SOURCES derivedDataProducerDummyDielectron.cxx +o2physics_add_dpl_workflow(jet-deriveddata-selector + SOURCES derivedDataSelector.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore COMPONENT_NAME Analysis) diff --git a/PWGJE/TableProducer/derivedDataProducerDummy.cxx b/PWGJE/TableProducer/derivedDataProducerDummy.cxx deleted file mode 100644 index c5a68c7c6b8..00000000000 --- a/PWGJE/TableProducer/derivedDataProducerDummy.cxx +++ /dev/null @@ -1,82 +0,0 @@ -// 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. - -// temporary task to produce HF and DQ tables needed when making inclusive derived data - should become obsolete when tables are able to be prouduced based on a configurable -// -/// \author Nima Zardoshti - -#include "Framework/AnalysisTask.h" -#include "Framework/AnalysisDataModel.h" -#include "Framework/ASoA.h" -#include "Framework/runDataProcessing.h" -#include "PWGJE/DataModel/JetReducedData.h" -#include "PWGHF/DataModel/DerivedTables.h" -#include "PWGDQ/DataModel/ReducedInfoTables.h" - -using namespace o2; -using namespace o2::framework; -using namespace o2::framework::expressions; - -struct JetDerivedDataProducerDummyTask { - - Produces d0CollisionsTable; - Produces d0CollisionsMatchingTable; - Produces d0sTable; - Produces d0ParsTable; - Produces d0ParExtrasTable; - Produces d0SelsTable; - Produces d0MlsTable; - Produces d0McsTable; - Produces d0McCollisionsTable; - Produces d0ParticlesTable; - - Produces lcCollisionsTable; - Produces lcCollisionsMatchingTable; - Produces lcsTable; - Produces lcParsTable; - Produces lcParExtrasTable; - Produces lcSelsTable; - Produces lcMlsTable; - Produces lcMcsTable; - Produces lcMcCollisionsTable; - Produces lcParticlesTable; - - Produces bplusCollisionsTable; - Produces bplusCollisionsMatchingTable; - Produces bplussTable; - Produces bplusParsTable; - Produces bplusParExtrasTable; - Produces bplusParD0sTable; - Produces bplusSelsTable; - Produces bplusMlsTable; - Produces bplusMlD0sTable; - Produces bplusMcsTable; - Produces bplusMcCollisionsTable; - Produces bplusParticlesTable; - - Produces dielectronCollisionsTable; - Produces dielectronTable; - - void init(InitContext const&) - { - } - - void processDummy(aod::JDummys const&) - { - } - PROCESS_SWITCH(JetDerivedDataProducerDummyTask, processDummy, "leaves all tables empty", true); -}; - -WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) -{ - return WorkflowSpec{ - adaptAnalysisTask(cfgc, TaskName{"jet-deriveddata-producer-dummy"})}; -} diff --git a/PWGJE/TableProducer/derivedDataProducerDummyBplus.cxx b/PWGJE/TableProducer/derivedDataProducerDummyBplus.cxx deleted file mode 100644 index 8f3e238710a..00000000000 --- a/PWGJE/TableProducer/derivedDataProducerDummyBplus.cxx +++ /dev/null @@ -1,69 +0,0 @@ -// 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. - -// temporary task to produce HF and DQ tables needed when making B+ jet derived data - should become obsolete when tables are able to be prouduced based on a configurable -// -/// \author Nima Zardoshti - -#include "Framework/AnalysisTask.h" -#include "Framework/AnalysisDataModel.h" -#include "Framework/ASoA.h" -#include "Framework/runDataProcessing.h" -#include "PWGJE/DataModel/JetReducedData.h" -#include "PWGHF/DataModel/DerivedTables.h" -#include "PWGDQ/DataModel/ReducedInfoTables.h" - -using namespace o2; -using namespace o2::framework; -using namespace o2::framework::expressions; - -struct JetDerivedDataProducerDummyTask { - - Produces d0CollisionsTable; - Produces d0CollisionsMatchingTable; - Produces d0sTable; - Produces d0ParsTable; - Produces d0ParExtrasTable; - Produces d0SelsTable; - Produces d0MlsTable; - Produces d0McsTable; - Produces d0McCollisionsTable; - Produces d0ParticlesTable; - - Produces lcCollisionsTable; - Produces lcCollisionsMatchingTable; - Produces lcsTable; - Produces lcParsTable; - Produces lcParExtrasTable; - Produces lcSelsTable; - Produces lcMlsTable; - Produces lcMcsTable; - Produces lcMcCollisionsTable; - Produces lcParticlesTable; - - Produces dielectronCollisionsTable; - Produces dielectronTable; - - void init(InitContext const&) - { - } - - void processDummy(aod::JDummys const&) - { - } - PROCESS_SWITCH(JetDerivedDataProducerDummyTask, processDummy, "leaves all tables empty", true); -}; - -WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) -{ - return WorkflowSpec{ - adaptAnalysisTask(cfgc, TaskName{"jet-deriveddata-producer-dummy"})}; -} diff --git a/PWGJE/TableProducer/derivedDataProducerDummyCharged.cxx b/PWGJE/TableProducer/derivedDataProducerDummyCharged.cxx deleted file mode 100644 index 28cfa369b73..00000000000 --- a/PWGJE/TableProducer/derivedDataProducerDummyCharged.cxx +++ /dev/null @@ -1,84 +0,0 @@ -// 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. - -// temporary task to produce HF, DQ and EMCal tables needed when making inclusive derived data - should become obsolete when tables are able to be prouduced based on a configurable -// -/// \author Nima Zardoshti - -#include "Framework/AnalysisTask.h" -#include "Framework/AnalysisDataModel.h" -#include "Framework/ASoA.h" -#include "Framework/runDataProcessing.h" -#include "PWGJE/DataModel/JetReducedData.h" -#include "PWGHF/DataModel/DerivedTables.h" -#include "PWGDQ/DataModel/ReducedInfoTables.h" - -using namespace o2; -using namespace o2::framework; -using namespace o2::framework::expressions; - -struct JetDerivedDataProducerDummyChargedTask { - - Produces d0CollisionsTable; - Produces d0CollisionsMatchingTable; - Produces d0sTable; - Produces d0ParsTable; - Produces d0ParExtrasTable; - Produces d0SelsTable; - Produces d0MlsTable; - Produces d0McsTable; - Produces d0McCollisionsTable; - Produces d0ParticlesTable; - - Produces lcCollisionsTable; - Produces lcCollisionsMatchingTable; - Produces lcsTable; - Produces lcParsTable; - Produces lcParExtrasTable; - Produces lcSelsTable; - Produces lcMlsTable; - Produces lcMcsTable; - Produces lcMcCollisionsTable; - Produces lcParticlesTable; - - Produces bplusCollisionsTable; - Produces bplusCollisionsMatchingTable; - Produces bplussTable; - Produces bplusParsTable; - Produces bplusParExtrasTable; - Produces bplusParD0sTable; - Produces bplusSelsTable; - Produces bplusMlsTable; - Produces bplusMlD0sTable; - Produces bplusMcsTable; - Produces bplusMcCollisionsTable; - Produces bplusParticlesTable; - - Produces dielectronCollisionsTable; - Produces dielectronTable; - - Produces jClustersCorrectedEnergiesTable; - - void init(InitContext const&) - { - } - - void processDummy(aod::JDummys const&) - { - } - PROCESS_SWITCH(JetDerivedDataProducerDummyChargedTask, processDummy, "leaves all tables empty", true); -}; - -WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) -{ - return WorkflowSpec{ - adaptAnalysisTask(cfgc, TaskName{"jet-deriveddata-producer-dummy-charged"})}; -} diff --git a/PWGJE/TableProducer/derivedDataProducerDummyD0.cxx b/PWGJE/TableProducer/derivedDataProducerDummyD0.cxx deleted file mode 100644 index 4cbbfdeedea..00000000000 --- a/PWGJE/TableProducer/derivedDataProducerDummyD0.cxx +++ /dev/null @@ -1,71 +0,0 @@ -// 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. - -// temporary task to produce HF and DQ tables needed when making D0 jet derived data - should become obsolete when tables are able to be prouduced based on a configurable -// -/// \author Nima Zardoshti - -#include "Framework/AnalysisTask.h" -#include "Framework/AnalysisDataModel.h" -#include "Framework/ASoA.h" -#include "Framework/runDataProcessing.h" -#include "PWGJE/DataModel/JetReducedData.h" -#include "PWGHF/DataModel/DerivedTables.h" -#include "PWGDQ/DataModel/ReducedInfoTables.h" - -using namespace o2; -using namespace o2::framework; -using namespace o2::framework::expressions; - -struct JetDerivedDataProducerDummyD0Task { - - Produces lcCollisionsTable; - Produces lcCollisionsMatchingTable; - Produces lcsTable; - Produces lcParsTable; - Produces lcParExtrasTable; - Produces lcSelsTable; - Produces lcMlsTable; - Produces lcMcsTable; - Produces lcMcCollisionsTable; - Produces lcParticlesTable; - - Produces bplusCollisionsTable; - Produces bplusCollisionsMatchingTable; - Produces bplussTable; - Produces bplusParsTable; - Produces bplusParExtrasTable; - Produces bplusParD0sTable; - Produces bplusSelsTable; - Produces bplusMlsTable; - Produces bplusMlD0sTable; - Produces bplusMcsTable; - Produces bplusMcCollisionsTable; - Produces bplusParticlesTable; - - Produces dielectronCollisionsTable; - Produces dielectronTable; - - void init(InitContext const&) - { - } - - void processDummy(aod::JDummys const&) - { - } - PROCESS_SWITCH(JetDerivedDataProducerDummyD0Task, processDummy, "leaves all tables empty", true); -}; - -WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) -{ - return WorkflowSpec{ - adaptAnalysisTask(cfgc, TaskName{"jet-deriveddata-producer-dummy-d0"})}; -} diff --git a/PWGJE/TableProducer/derivedDataProducerDummyDielectron.cxx b/PWGJE/TableProducer/derivedDataProducerDummyDielectron.cxx deleted file mode 100644 index c24cf13bd41..00000000000 --- a/PWGJE/TableProducer/derivedDataProducerDummyDielectron.cxx +++ /dev/null @@ -1,79 +0,0 @@ -// 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. - -// temporary task to produce HF tables needed when making dielectron jet derived data - should become obsolete when tables are able to be prouduced based on a configurable -// -/// \author Nima Zardoshti - -#include "Framework/AnalysisTask.h" -#include "Framework/AnalysisDataModel.h" -#include "Framework/ASoA.h" -#include "Framework/runDataProcessing.h" -#include "PWGJE/DataModel/JetReducedData.h" -#include "PWGHF/DataModel/DerivedTables.h" -#include "PWGDQ/DataModel/ReducedInfoTables.h" - -using namespace o2; -using namespace o2::framework; -using namespace o2::framework::expressions; - -struct JetDerivedDataProducerDummyDielectronTask { - - Produces d0CollisionsTable; - Produces d0CollisionsMatchingTable; - Produces d0sTable; - Produces d0ParsTable; - Produces d0ParExtrasTable; - Produces d0SelsTable; - Produces d0MlsTable; - Produces d0McsTable; - Produces d0McCollisionsTable; - Produces d0ParticlesTable; - - Produces lcCollisionsTable; - Produces lcCollisionsMatchingTable; - Produces lcsTable; - Produces lcParsTable; - Produces lcParExtrasTable; - Produces lcSelsTable; - Produces lcMlsTable; - Produces lcMcsTable; - Produces lcMcCollisionsTable; - Produces lcParticlesTable; - - Produces bplusCollisionsTable; - Produces bplusCollisionsMatchingTable; - Produces bplussTable; - Produces bplusParsTable; - Produces bplusParExtrasTable; - Produces bplusParD0sTable; - Produces bplusSelsTable; - Produces bplusMlsTable; - Produces bplusMlD0sTable; - Produces bplusMcsTable; - Produces bplusMcCollisionsTable; - Produces bplusParticlesTable; - - void init(InitContext const&) - { - } - - void processDummy(aod::JDummys const&) - { - } - PROCESS_SWITCH(JetDerivedDataProducerDummyDielectronTask, processDummy, "leaves all tables empty", true); -}; - -WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) -{ - return WorkflowSpec{ - adaptAnalysisTask(cfgc, TaskName{"jet-deriveddata-producer-dummy-dielectron"})}; -} diff --git a/PWGJE/TableProducer/derivedDataProducerDummyLc.cxx b/PWGJE/TableProducer/derivedDataProducerDummyLc.cxx deleted file mode 100644 index 9913e1da37f..00000000000 --- a/PWGJE/TableProducer/derivedDataProducerDummyLc.cxx +++ /dev/null @@ -1,71 +0,0 @@ -// 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. - -// temporary task to produce HF and DQ tables needed when making Lc jet derived data - should become obsolete when tables are able to be prouduced based on a configurable -// -/// \author Nima Zardoshti - -#include "Framework/AnalysisTask.h" -#include "Framework/AnalysisDataModel.h" -#include "Framework/ASoA.h" -#include "Framework/runDataProcessing.h" -#include "PWGJE/DataModel/JetReducedData.h" -#include "PWGHF/DataModel/DerivedTables.h" -#include "PWGDQ/DataModel/ReducedInfoTables.h" - -using namespace o2; -using namespace o2::framework; -using namespace o2::framework::expressions; - -struct JetDerivedDataProducerDummyLcTask { - - Produces d0CollisionsTable; - Produces d0CollisionsMatchingTable; - Produces d0sTable; - Produces d0ParsTable; - Produces d0ParExtrasTable; - Produces d0SelsTable; - Produces d0MlsTable; - Produces d0McsTable; - Produces d0McCollisionsTable; - Produces d0ParticlesTable; - - Produces bplusCollisionsTable; - Produces bplusCollisionsMatchingTable; - Produces bplussTable; - Produces bplusParsTable; - Produces bplusParExtrasTable; - Produces bplusParD0sTable; - Produces bplusSelsTable; - Produces bplusMlsTable; - Produces bplusMlD0sTable; - Produces bplusMcsTable; - Produces bplusMcCollisionsTable; - Produces bplusParticlesTable; - - Produces dielectronCollisionsTable; - Produces dielectronTable; - - void init(InitContext const&) - { - } - - void processDummy(aod::JDummys const&) - { - } - PROCESS_SWITCH(JetDerivedDataProducerDummyLcTask, processDummy, "leaves all tables empty", true); -}; - -WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) -{ - return WorkflowSpec{ - adaptAnalysisTask(cfgc, TaskName{"jet-deriveddata-producer-dummy-lc"})}; -} diff --git a/PWGJE/TableProducer/derivedDataSelector.cxx b/PWGJE/TableProducer/derivedDataSelector.cxx new file mode 100644 index 00000000000..88398f796f5 --- /dev/null +++ b/PWGJE/TableProducer/derivedDataSelector.cxx @@ -0,0 +1,331 @@ +// 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. + +/// \file jetderiveddataselector.cxx +/// \brief Task to store decision of which events to skim for producing jet framework tables (aod::JetCollisions, aod::JetTracks, aod::JetClusters, ...) +/// while adjusting indices accordingly +/// +/// \author Nima Zardoshti +/// \author Jochen Klein + +#include +#include +#include +#include + +#include + +#include "Framework/AnalysisTask.h" +#include "Framework/AnalysisDataModel.h" +#include "Framework/ASoA.h" +#include "Framework/runDataProcessing.h" + +#include "PWGJE/DataModel/Jet.h" +#include "PWGJE/DataModel/JetReducedData.h" +#include "PWGJE/DataModel/JetReducedDataSelector.h" + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; + +struct JetDerivedDataSelector { + + Produces collisionSelectionsTable; + Produces mcCollisionSelectionsTable; + + struct : ConfigurableGroup { + Configurable thresholdChargedJetPtMin{"thresholdChargedJetPtMin", 0.0, "Minimum charged jet pt to accept event"}; + Configurable thresholdChargedEventWiseSubtractedJetPtMin{"thresholdChargedEventWiseSubtractedJetPtMin", 0.0, "Minimum charged event-wise subtracted jet pt to accept event"}; + Configurable thresholdChargedMCPJetPtMin{"thresholdChargedMCPJetPtMin", 0.0, "Minimum charged mcp jet pt to accept event"}; + Configurable thresholdNeutralJetPtMin{"thresholdNeutralJetPtMin", 0.0, "Minimum neutral jet pt to accept event"}; + Configurable thresholdNeutralMCPJetPtMin{"thresholdNeutralMCPJetPtMin", 0.0, "Minimum neutal mcp jet pt to accept event"}; + Configurable thresholdFullJetPtMin{"thresholdFullJetPtMin", 0.0, "Minimum full jet pt to accept event"}; + Configurable thresholdFullMCPJetPtMin{"thresholdFullMCPJetPtMin", 0.0, "Minimum full mcp jet pt to accept event"}; + Configurable thresholdChargedD0JetPtMin{"thresholdChargedD0JetPtMin", 0.0, "Minimum charged D0 jet pt to accept event"}; + Configurable thresholdChargedEventWiseSubtractedD0JetPtMin{"thresholdChargedEventWiseSubtractedD0JetPtMin", 0.0, "Minimum charged event-wise subtracted D0 jet pt to accept event"}; + Configurable thresholdChargedD0MCPJetPtMin{"thresholdChargedD0MCPJetPtMin", 0.0, "Minimum charged D0 mcp jet pt to accept event"}; + Configurable thresholdChargedLcJetPtMin{"thresholdChargedLcJetPtMin", 0.0, "Minimum charged Lc jet pt to accept event"}; + Configurable thresholdChargedEventWiseSubtractedLcJetPtMin{"thresholdChargedEventWiseSubtractedLcJetPtMin", 0.0, "Minimum charged event-wise subtracted Lc jet pt to accept event"}; + Configurable thresholdChargedLcMCPJetPtMin{"thresholdChargedLcMCPJetPtMin", 0.0, "Minimum charged Lc mcp jet pt to accept event"}; + Configurable thresholdChargedBplusJetPtMin{"thresholdChargedBplusJetPtMin", 0.0, "Minimum charged Bplus jet pt to accept event"}; + Configurable thresholdChargedEventWiseSubtractedBplusJetPtMin{"thresholdChargedEventWiseSubtractedBplusJetPtMin", 0.0, "Minimum charged event-wise subtracted Bplus jet pt to accept event"}; + Configurable thresholdChargedBplusMCPJetPtMin{"thresholdChargedBplusMCPJetPtMin", 0.0, "Minimum charged Bplus mcp jet pt to accept event"}; + Configurable thresholdChargedDielectronJetPtMin{"thresholdChargedDielectronJetPtMin", 0.0, "Minimum charged Dielectron jet pt to accept event"}; + Configurable thresholdChargedEventWiseSubtractedDielectronJetPtMin{"thresholdChargedEventWiseSubtractedDielectronJetPtMin", 0.0, "Minimum charged event-wise subtracted Dielectron jet pt to accept event"}; + Configurable thresholdChargedDielectronMCPJetPtMin{"thresholdChargedDielectronMCPJetPtMin", 0.0, "Minimum charged Dielectron mcp jet pt to accept event"}; + Configurable thresholdTriggerTrackPtMin{"thresholdTriggerTrackPtMin", 0.0, "Minimum trigger track pt to accept event"}; + Configurable thresholdClusterEnergyMin{"thresholdClusterEnergyMin", 0.0, "Minimum cluster energy to accept event"}; + Configurable downscaleFactor{"downscaleFactor", 1, "random downscale of selected events"}; + + Configurable vertexZCut{"vertexZCut", 10.0, "z-vertex cut on event"}; + Configurable centralityMin{"centralityMin", -999.0, "minimum centrality"}; + Configurable centralityMax{"centralityMax", 999.0, "maximum centrality"}; + Configurable trackOccupancyInTimeRangeMax{"trackOccupancyInTimeRangeMax", 999999, "maximum occupancy of tracks in neighbouring collisions in a given time range"}; + Configurable performTrackSelection{"performTrackSelection", true, "only save tracks that pass one of the track selections"}; + Configurable trackPtSelectionMin{"trackPtSelectionMin", 0.15, "only save tracks that have a pT larger than this pT"}; + Configurable trackEtaSelectionMax{"trackEtaSelectionMax", 0.9, "only save tracks that have an eta smaller than this eta"}; + + Configurable triggerMasks{"triggerMasks", "", "possible JE Trigger masks: fJetChLowPt,fJetChHighPt,fTrackLowPt,fTrackHighPt,fJetD0ChLowPt,fJetD0ChHighPt,fJetLcChLowPt,fJetLcChHighPt,fEMCALReadout,fJetFullHighPt,fJetFullLowPt,fJetNeutralHighPt,fJetNeutralLowPt,fGammaVeryHighPtEMCAL,fGammaVeryHighPtDCAL,fGammaHighPtEMCAL,fGammaHighPtDCAL,fGammaLowPtEMCAL,fGammaLowPtDCAL,fGammaVeryLowPtEMCAL,fGammaVeryLowPtDCAL"}; + } config; + + std::vector collisionFlag; + std::vector McCollisionFlag; + + TRandom3 randomNumber; + + std::vector triggerMaskBits; + void init(InitContext&) + { + randomNumber.SetSeed(0); + triggerMaskBits = jetderiveddatautilities::initialiseTriggerMaskBits(config.triggerMasks); + } + + PresliceUnsorted> CollisionsPerMcCollision = aod::jmccollisionlb::mcCollisionId; + + void processSetupCollisions(aod::JCollisions const& collisions) + { + collisionFlag.clear(); + collisionFlag.resize(collisions.size(), false); + } + + void processSetupMcCollisions(aod::JMcCollisions const& mcCollisions) + { + McCollisionFlag.clear(); + McCollisionFlag.resize(mcCollisions.size(), false); + } + + void processSelectMcCollisionsPerCollision(aod::JMcCollisions const& mcCollisions, soa::Join const& collisions) + { + for (auto mcCollision : mcCollisions) { + const auto collisionsPerMcCollision = collisions.sliceBy(CollisionsPerMcCollision, mcCollision.globalIndex()); + for (auto collision : collisionsPerMcCollision) { + if (collisionFlag[collision.globalIndex()]) { + McCollisionFlag[mcCollision.globalIndex()] = true; + } + } + } + } + + void processSelectCollisionsPerMcCollision(soa::Join::iterator const& collision) + { + if (McCollisionFlag[collision.mcCollisionId()]) { + collisionFlag[collision.globalIndex()] = true; + } + } + + void processSetupAllCollisionsWithDownscaling(aod::JCollisions const& collisions) + { + collisionFlag.clear(); + collisionFlag.resize(collisions.size(), false); + for (const auto& collision : collisions) { + if (randomNumber.Integer(config.downscaleFactor) == 0) { + collisionFlag[collision.globalIndex()] = true; + } + } + } + + void processSetupAllMcCollisionsWithDownscaling(aod::JMcCollisions const& mcCollisions) + { + McCollisionFlag.clear(); + McCollisionFlag.resize(mcCollisions.size(), false); + for (const auto& mcCollision : mcCollisions) { + if (randomNumber.Integer(config.downscaleFactor) == 0) { + McCollisionFlag[mcCollision.globalIndex()] = true; + } + } + } + + template + void processDoDownscaling(T const& collisions) + { + for (const auto& collision : collisions) { + if constexpr (std::is_same_v, aod::JCollisions>) { + if (collisionFlag[collision.globalIndex()] && randomNumber.Integer(config.downscaleFactor) != 0) { + collisionFlag[collision.globalIndex()] = false; + } + } + if constexpr (std::is_same_v, aod::JMcCollisions>) { + if (McCollisionFlag[collision.globalIndex()] && randomNumber.Integer(config.downscaleFactor) != 0) { + McCollisionFlag[collision.globalIndex()] = false; + } + } + } + } + + void processSetupEventTriggering(aod::JCollision const& collision) + { + if (jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) { + collisionFlag[collision.globalIndex()] = true; + } + } + + void processDoCollisionSelections(aod::JCollision const& collision) + { // can also add event selection like sel8 but goes a little against the derived data idea + if (collision.centrality() < config.centralityMin || collision.centrality() >= config.centralityMax || collision.trackOccupancyInTimeRange() > config.trackOccupancyInTimeRangeMax || std::abs(collision.posZ()) > config.vertexZCut) { + collisionFlag[collision.globalIndex()] = false; + } + } + + template + void processSelectionObjects(T& selectionObjects) + { + float selectionObjectPtMin = 0.0; + if constexpr (std::is_same_v, aod::ChargedJets> || std::is_same_v, aod::ChargedMCDetectorLevelJets>) { + selectionObjectPtMin = config.thresholdChargedJetPtMin; + } else if constexpr (std::is_same_v, aod::ChargedEventWiseSubtractedJets> || std::is_same_v, aod::ChargedMCDetectorLevelEventWiseSubtractedJets>) { + selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedJetPtMin; + } else if constexpr (std::is_same_v, aod::ChargedMCParticleLevelJets>) { + selectionObjectPtMin = config.thresholdChargedMCPJetPtMin; + } else if constexpr (std::is_same_v, aod::NeutralJets> || std::is_same_v, aod::NeutralMCDetectorLevelJets>) { + selectionObjectPtMin = config.thresholdNeutralJetPtMin; + } else if constexpr (std::is_same_v, aod::NeutralMCParticleLevelJets>) { + selectionObjectPtMin = config.thresholdNeutralMCPJetPtMin; + } else if constexpr (std::is_same_v, aod::FullJets> || std::is_same_v, aod::FullMCDetectorLevelJets>) { + selectionObjectPtMin = config.thresholdFullJetPtMin; + } else if constexpr (std::is_same_v, aod::FullMCParticleLevelJets>) { + selectionObjectPtMin = config.thresholdFullMCPJetPtMin; + } else if constexpr (std::is_same_v, aod::D0ChargedJets> || std::is_same_v, aod::D0ChargedMCDetectorLevelJets>) { + selectionObjectPtMin = config.thresholdChargedD0JetPtMin; + } else if constexpr (std::is_same_v, aod::D0ChargedEventWiseSubtractedJets> || std::is_same_v, aod::D0ChargedMCDetectorLevelEventWiseSubtractedJets>) { + selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedD0JetPtMin; + } else if constexpr (std::is_same_v, aod::D0ChargedMCParticleLevelJets>) { + selectionObjectPtMin = config.thresholdChargedD0MCPJetPtMin; + } else if constexpr (std::is_same_v, aod::LcChargedJets> || std::is_same_v, aod::LcChargedMCDetectorLevelJets>) { + selectionObjectPtMin = config.thresholdChargedLcJetPtMin; + } else if constexpr (std::is_same_v, aod::LcChargedEventWiseSubtractedJets> || std::is_same_v, aod::LcChargedMCDetectorLevelEventWiseSubtractedJets>) { + selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedLcJetPtMin; + } else if constexpr (std::is_same_v, aod::LcChargedMCParticleLevelJets>) { + selectionObjectPtMin = config.thresholdChargedLcMCPJetPtMin; + } else if constexpr (std::is_same_v, aod::BplusChargedJets> || std::is_same_v, aod::BplusChargedMCDetectorLevelJets>) { + selectionObjectPtMin = config.thresholdChargedBplusJetPtMin; + } else if constexpr (std::is_same_v, aod::BplusChargedEventWiseSubtractedJets> || std::is_same_v, aod::BplusChargedMCDetectorLevelEventWiseSubtractedJets>) { + selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedBplusJetPtMin; + } else if constexpr (std::is_same_v, aod::BplusChargedMCParticleLevelJets>) { + selectionObjectPtMin = config.thresholdChargedBplusMCPJetPtMin; + } else if constexpr (std::is_same_v, aod::DielectronChargedJets> || std::is_same_v, aod::DielectronChargedMCDetectorLevelJets>) { + selectionObjectPtMin = config.thresholdChargedDielectronJetPtMin; + } else if constexpr (std::is_same_v, aod::DielectronChargedEventWiseSubtractedJets> || std::is_same_v, aod::DielectronChargedMCDetectorLevelEventWiseSubtractedJets>) { + selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedDielectronJetPtMin; + } else if constexpr (std::is_same_v, aod::DielectronChargedMCParticleLevelJets>) { + selectionObjectPtMin = config.thresholdChargedDielectronMCPJetPtMin; + } else if constexpr (std::is_same_v, aod::JTracks>) { + selectionObjectPtMin = config.thresholdTriggerTrackPtMin; + } else if constexpr (std::is_same_v, aod::JClusters>) { + selectionObjectPtMin = config.thresholdClusterEnergyMin; + } else { + selectionObjectPtMin = 0.0; + } + for (const auto& selectionObject : selectionObjects) { + bool isTriggerObject = false; + if constexpr (std::is_same_v, aod::JClusters>) { + if (selectionObject.energy() >= selectionObjectPtMin) { + isTriggerObject = true; + } + } else { + if constexpr (std::is_same_v, aod::JTracks>) { + if (config.performTrackSelection && !(selectionObject.trackSel() & ~(1 << jetderiveddatautilities::JTrackSel::trackSign))) { + continue; + } + if (selectionObject.pt() < config.trackPtSelectionMin || std::abs(selectionObject.eta()) > config.trackEtaSelectionMax) { + continue; + } + } + if (selectionObject.pt() >= selectionObjectPtMin) { + isTriggerObject = true; + } + } + if (isTriggerObject) { + if constexpr (std::is_same_v, aod::ChargedMCParticleLevelJets> || std::is_same_v, aod::NeutralMCParticleLevelJets> || std::is_same_v, aod::FullMCParticleLevelJets> || std::is_same_v, aod::D0ChargedMCParticleLevelJets> || std::is_same_v, aod::LcChargedMCParticleLevelJets> || std::is_same_v, aod::BplusChargedMCParticleLevelJets> || std::is_same_v, aod::DielectronChargedMCParticleLevelJets>) { + if (selectionObject.mcCollisionId() >= 0) { + McCollisionFlag[selectionObject.mcCollisionId()] = true; + } + } else { + if (selectionObject.collisionId() >= 0) { + collisionFlag[selectionObject.collisionId()] = true; + } + } + } + } + } + // Todo : Check memory consumption of having so many Process Switches + PROCESS_SWITCH(JetDerivedDataSelector, processSetupCollisions, "setup the writing for data and MCD based on collisions", true); + PROCESS_SWITCH(JetDerivedDataSelector, processSetupMcCollisions, "setup the writing for MCP based on mcCollisions", false); + PROCESS_SWITCH(JetDerivedDataSelector, processSetupAllCollisionsWithDownscaling, "setup the writing of untriggered collisions with downscaling", false); + PROCESS_SWITCH(JetDerivedDataSelector, processSetupAllMcCollisionsWithDownscaling, "setup the writing of untriggered mccollisions with downscaling", false); + PROCESS_SWITCH(JetDerivedDataSelector, processSetupEventTriggering, "process software triggers", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingChargedJets, "process charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingChargedEventWiseSubtractedJets, "process charged event-wise subtracted jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingChargedMCDJets, "process charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingChargedMCDetectorLevelEventWiseSubtractedJets, "process charged event-wise subtracted mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingChargedMCPJets, "process charged mcp jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingNeutralJets, "process neutral jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingNeutralMCDJets, "process neutral mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingNeutralMCPJets, "process neutral mcp jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingFullJets, "process full jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingFullMCDJets, "process full mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingFullMCPJets, "process full mcp jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingD0ChargedJets, "process D0 charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingD0ChargedEventWiseSubtractedJets, "process D0 event-wise subtracted charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingD0ChargedMCDJets, "process D0 charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingD0ChargedMCDetectorLevelEventWiseSubtractedJets, "process D0 event-wise subtracted charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingD0ChargedMCPJets, "process D0 charged mcp jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingLcChargedJets, "process Lc charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingLcChargedEventWiseSubtractedJets, "process Lc event-wise subtracted charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingLcChargedMCDJets, "process Lc charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingLcChargedMCDetectorLevelEventWiseSubtractedJets, "process Lc event-wise subtracted charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingLcChargedMCPJets, "process Lc charged mcp jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingBplusChargedJets, "process Bplus charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingBplusChargedEventWiseSubtractedJets, "process Bplus event-wise subtracted charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingBplusChargedMCDJets, "process Bplus charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingBplusChargedMCDetectorLevelEventWiseSubtractedJets, "process Bplus event-wise subtracted charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingBplusChargedMCPJets, "process Bplus charged mcp jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingDielectronChargedJets, "process Dielectron charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingDielectronChargedEventWiseSubtractedJets, "process Dielectron event-wise subtracted charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingDielectronChargedMCDJets, "process Dielectron charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingDielectronChargedMCDetectorLevelEventWiseSubtractedJets, "process Dielectron event-wise subtracted charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingDielectronChargedMCPJets, "process Dielectron charged mcp jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingClusters, "process EMCal clusters", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingTracks, "process high pt tracks", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processDoDownscaling, processCollisionDownscaling, "process downsaling of triggered collisions", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processDoDownscaling, processMcCollisionDownscaling, "process downsaling of triggered mccollisions", false); + PROCESS_SWITCH(JetDerivedDataSelector, processDoCollisionSelections, "process event selections for saved events", false); + PROCESS_SWITCH(JetDerivedDataSelector, processSelectMcCollisionsPerCollision, "select McCollisions due to a triggered reconstructed collision", false); + PROCESS_SWITCH(JetDerivedDataSelector, processSelectCollisionsPerMcCollision, "select collisions due to a triggered McCollision", false); + + void processStoreCollisionDecision(aod::JCollision const& collision) + { + if (collisionFlag[collision.globalIndex()]) { + collisionSelectionsTable(true); + } else { + collisionSelectionsTable(false); + } + } + PROCESS_SWITCH(JetDerivedDataSelector, processStoreCollisionDecision, "write out decision of storing collision", true); + + void processStoreMcCollisionDecision(aod::JMcCollision const& mcCollision) + { + if (McCollisionFlag[mcCollision.globalIndex()]) { + mcCollisionSelectionsTable(true); + } else { + mcCollisionSelectionsTable(false); + } + } + PROCESS_SWITCH(JetDerivedDataSelector, processStoreMcCollisionDecision, "write out decision of storing mcCollision", false); +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + std::vector tasks; + + tasks.emplace_back(adaptAnalysisTask(cfgc, TaskName{"jet-deriveddata-selector"})); + + return WorkflowSpec{tasks}; +} diff --git a/PWGJE/TableProducer/derivedDataWriter.cxx b/PWGJE/TableProducer/derivedDataWriter.cxx index ee4eeea7c10..234cc219b8b 100644 --- a/PWGJE/TableProducer/derivedDataWriter.cxx +++ b/PWGJE/TableProducer/derivedDataWriter.cxx @@ -18,8 +18,8 @@ #include #include - -#include +#include +#include #include "Framework/AnalysisTask.h" #include "Framework/AnalysisDataModel.h" @@ -30,6 +30,7 @@ #include "PWGJE/Core/JetDQUtilities.h" #include "PWGJE/DataModel/Jet.h" #include "PWGJE/DataModel/JetReducedData.h" +#include "PWGJE/DataModel/JetReducedDataSelector.h" using namespace o2; using namespace o2::framework; @@ -38,42 +39,9 @@ using namespace o2::framework::expressions; struct JetDerivedDataWriter { struct : ConfigurableGroup { - Configurable thresholdChargedJetPtMin{"thresholdChargedJetPtMin", 0.0, "Minimum charged jet pt to accept event"}; - Configurable thresholdChargedEventWiseSubtractedJetPtMin{"thresholdChargedEventWiseSubtractedJetPtMin", 0.0, "Minimum charged event-wise subtracted jet pt to accept event"}; - Configurable thresholdChargedMCPJetPtMin{"thresholdChargedMCPJetPtMin", 0.0, "Minimum charged mcp jet pt to accept event"}; - Configurable thresholdNeutralJetPtMin{"thresholdNeutralJetPtMin", 0.0, "Minimum neutral jet pt to accept event"}; - Configurable thresholdNeutralMCPJetPtMin{"thresholdNeutralMCPJetPtMin", 0.0, "Minimum neutal mcp jet pt to accept event"}; - Configurable thresholdFullJetPtMin{"thresholdFullJetPtMin", 0.0, "Minimum full jet pt to accept event"}; - Configurable thresholdFullMCPJetPtMin{"thresholdFullMCPJetPtMin", 0.0, "Minimum full mcp jet pt to accept event"}; - Configurable thresholdChargedD0JetPtMin{"thresholdChargedD0JetPtMin", 0.0, "Minimum charged D0 jet pt to accept event"}; - Configurable thresholdChargedEventWiseSubtractedD0JetPtMin{"thresholdChargedEventWiseSubtractedD0JetPtMin", 0.0, "Minimum charged event-wise subtracted D0 jet pt to accept event"}; - Configurable thresholdChargedD0MCPJetPtMin{"thresholdChargedD0MCPJetPtMin", 0.0, "Minimum charged D0 mcp jet pt to accept event"}; - Configurable thresholdChargedLcJetPtMin{"thresholdChargedLcJetPtMin", 0.0, "Minimum charged Lc jet pt to accept event"}; - Configurable thresholdChargedEventWiseSubtractedLcJetPtMin{"thresholdChargedEventWiseSubtractedLcJetPtMin", 0.0, "Minimum charged event-wise subtracted Lc jet pt to accept event"}; - Configurable thresholdChargedLcMCPJetPtMin{"thresholdChargedLcMCPJetPtMin", 0.0, "Minimum charged Lc mcp jet pt to accept event"}; - Configurable thresholdChargedBplusJetPtMin{"thresholdChargedBplusJetPtMin", 0.0, "Minimum charged Bplus jet pt to accept event"}; - Configurable thresholdChargedEventWiseSubtractedBplusJetPtMin{"thresholdChargedEventWiseSubtractedBplusJetPtMin", 0.0, "Minimum charged event-wise subtracted Bplus jet pt to accept event"}; - Configurable thresholdChargedBplusMCPJetPtMin{"thresholdChargedBplusMCPJetPtMin", 0.0, "Minimum charged Bplus mcp jet pt to accept event"}; - Configurable thresholdChargedDielectronJetPtMin{"thresholdChargedDielectronJetPtMin", 0.0, "Minimum charged Dielectron jet pt to accept event"}; - Configurable thresholdChargedEventWiseSubtractedDielectronJetPtMin{"thresholdChargedEventWiseSubtractedDielectronJetPtMin", 0.0, "Minimum charged event-wise subtracted Dielectron jet pt to accept event"}; - Configurable thresholdChargedDielectronMCPJetPtMin{"thresholdChargedDielectronMCPJetPtMin", 0.0, "Minimum charged Dielectron mcp jet pt to accept event"}; - Configurable thresholdTriggerTrackPtMin{"thresholdTriggerTrackPtMin", 0.0, "Minimum trigger track pt to accept event"}; - Configurable thresholdClusterEnergyMin{"thresholdClusterEnergyMin", 0.0, "Minimum cluster energy to accept event"}; - Configurable downscaleFactor{"downscaleFactor", 1, "random downscale of selected events"}; - - Configurable vertexZCut{"vertexZCut", 10.0, "z-vertex cut on event"}; - Configurable centralityMin{"centralityMin", -999.0, "minimum centrality"}; - Configurable centralityMax{"centralityMax", 999.0, "maximum centrality"}; - Configurable trackOccupancyInTimeRangeMax{"trackOccupancyInTimeRangeMax", 999999, "maximum occupancy of tracks in neighbouring collisions in a given time range"}; Configurable performTrackSelection{"performTrackSelection", true, "only save tracks that pass one of the track selections"}; Configurable trackPtSelectionMin{"trackPtSelectionMin", 0.15, "only save tracks that have a pT larger than this pT"}; Configurable trackEtaSelectionMax{"trackEtaSelectionMax", 0.9, "only save tracks that have an eta smaller than this eta"}; - Configurable saveBCsTable{"saveBCsTable", true, "save the bunch crossing table to the output"}; - Configurable saveClustersTable{"saveClustersTable", false, "save the clusters table to the output"}; - Configurable saveD0Table{"saveD0Table", false, "save the D0 tables to the output"}; - Configurable saveLcTable{"saveLcTable", false, "save the Lc tables to the output"}; - Configurable saveBplusTable{"saveBplusTable", false, "save the Bplus tables to the output"}; - Configurable saveDielectronTable{"saveDielectronTable", false, "save the Dielectron tables to the output"}; Configurable triggerMasks{"triggerMasks", "", "possible JE Trigger masks: fJetChLowPt,fJetChHighPt,fTrackLowPt,fTrackHighPt,fJetD0ChLowPt,fJetD0ChHighPt,fJetLcChLowPt,fJetLcChHighPt,fEMCALReadout,fJetFullHighPt,fJetFullLowPt,fJetNeutralHighPt,fJetNeutralLowPt,fGammaVeryHighPtEMCAL,fGammaVeryHighPtDCAL,fGammaHighPtEMCAL,fGammaHighPtDCAL,fGammaLowPtEMCAL,fGammaLowPtDCAL,fGammaVeryLowPtEMCAL,fGammaVeryLowPtDCAL"}; } config; @@ -165,994 +133,482 @@ struct JetDerivedDataWriter { Produces storedDielectronParticleIdsTable; } products; - PresliceUnsorted> CollisionsPerMcCollision = aod::jmccollisionlb::mcCollisionId; - PresliceUnsorted> ParticlesPerMcCollision = aod::jmcparticle::mcCollisionId; + Preslice> TracksPerCollisionData = aod::jtrack::collisionId; + + Preslice> ParticlesPerMcCollision = aod::jmcparticle::mcCollisionId; Preslice> TracksPerCollision = aod::jtrack::collisionId; - Preslice> ClustersPerCollision = aod::jcluster::collisionId; - Preslice> D0McCollisionsPerMcCollision = aod::jd0indices::mcCollisionId; - Preslice> LcMcCollisionsPerMcCollision = aod::jlcindices::mcCollisionId; - Preslice> BplusMcCollisionsPerMcCollision = aod::jbplusindices::mcCollisionId; + Preslice D0McCollisionsPerMcCollision = aod::jd0indices::mcCollisionId; + Preslice LcMcCollisionsPerMcCollision = aod::jlcindices::mcCollisionId; + Preslice BplusMcCollisionsPerMcCollision = aod::jbplusindices::mcCollisionId; Preslice DielectronMcCollisionsPerMcCollision = aod::jdielectronindices::mcCollisionId; - Preslice D0CollisionsPerCollision = aod::jd0indices::collisionId; - Preslice LcCollisionsPerCollision = aod::jlcindices::collisionId; - Preslice BplusCollisionsPerCollision = aod::jbplusindices::collisionId; - Preslice DielectronCollisionsPerCollision = aod::jdielectronindices::collisionId; - Preslice D0sPerCollision = aod::jd0indices::collisionId; - Preslice LcsPerCollision = aod::jlcindices::collisionId; - Preslice BplussPerCollision = aod::jbplusindices::collisionId; - Preslice DielectronsPerCollision = aod::jdielectronindices::collisionId; + Preslice D0ParticlesPerMcCollision = aod::jd0indices::mcCollisionId; + Preslice LcParticlesPerMcCollision = aod::jlcindices::mcCollisionId; + Preslice BplusParticlesPerMcCollision = aod::jbplusindices::mcCollisionId; PresliceUnsorted EMCTrackPerTrack = aod::jemctrack::trackId; - std::vector collisionFlag; - std::vector McCollisionFlag; - std::vector bcIndicies; - uint32_t precisionPositionMask; uint32_t precisionMomentumMask; - TRandom3 randomNumber; - - std::vector triggerMaskBits; void init(InitContext&) { precisionPositionMask = 0xFFFFFC00; // 13 bits precisionMomentumMask = 0xFFFFFC00; // 13 bits this is currently keept at 13 bits wihich gives roughly a resolution of 1/8000. This can be increased to 15 bits if really needed - randomNumber.SetSeed(0); - triggerMaskBits = jetderiveddatautilities::initialiseTriggerMaskBits(config.triggerMasks); } - bool acceptCollision(aod::JCollision const&) + template + bool trackSelection(T const& track) { + if (config.performTrackSelection && !(track.trackSel() & ~(1 << jetderiveddatautilities::JTrackSel::trackSign))) { // skips tracks that pass no selections. This might cause a problem with tracks matched with clusters. We should generate a track selection purely for cluster matched tracks so that they are kept. This includes also the track pT selction. + return false; + } + if (track.pt() < config.trackPtSelectionMin || std::abs(track.eta()) > config.trackEtaSelectionMax) { + return false; + } return true; } - void processSetupCollisions(aod::JCollisions const& collisions) + template + void storeD0(soa::Join::iterator const& collision, aod::JTracks const&, aod::CollisionsD0 const& D0Collisions, T const& D0s) { - collisionFlag.clear(); - collisionFlag.resize(collisions.size()); - std::fill(collisionFlag.begin(), collisionFlag.end(), false); - } - void processSetupMcCollisions(aod::JMcCollisions const& McCollisions) - { - McCollisionFlag.clear(); - McCollisionFlag.resize(McCollisions.size()); - std::fill(McCollisionFlag.begin(), McCollisionFlag.end(), false); + if (collision.isCollisionSelected()) { + for (const auto& D0Collision : D0Collisions) { // should only ever be one + jethfutilities::fillHFCollisionTable(D0Collision, products.storedD0CollisionsTable); + products.storedD0CollisionIdsTable(collisionMapping[collision.globalIndex()]); + } + for (const auto& D0 : D0s) { + jethfutilities::fillHFCandidateTable(D0, products.storedD0CollisionsTable.lastIndex(), products.storedD0sTable, products.storedD0ParsTable, products.storedD0ParExtrasTable, products.storedD0ParDaughtersDummyTable, products.storedD0SelsTable, products.storedD0MlsTable, products.storedD0MlDughtersDummyTable, products.storedD0McsTable); + products.storedD0IdsTable(collisionMapping[collision.globalIndex()], trackMapping[D0.prong0Id()], trackMapping[D0.prong1Id()]); + } + } } - void processSetupAllCollisionsWithDownscaling(aod::JCollisions const& collisions) + template + void storeLc(soa::Join::iterator const& collision, aod::JTracks const&, aod::CollisionsLc const& LcCollisions, T const& Lcs) { - collisionFlag.clear(); - collisionFlag.resize(collisions.size()); - for (const auto& collision : collisions) { - if (randomNumber.Integer(config.downscaleFactor) == 0) { - collisionFlag[collision.globalIndex()] = true; - } else { - collisionFlag[collision.globalIndex()] = false; + if (collision.isCollisionSelected()) { + for (const auto& LcCollision : LcCollisions) { // should only ever be one + jethfutilities::fillHFCollisionTable(LcCollision, products.storedLcCollisionsTable); + products.storedLcCollisionIdsTable(collisionMapping[collision.globalIndex()]); + } + for (const auto& Lc : Lcs) { + jethfutilities::fillHFCandidateTable(Lc, products.storedLcCollisionsTable.lastIndex(), products.storedLcsTable, products.storedLcParsTable, products.storedLcParExtrasTable, products.storedLcParDaughtersDummyTable, products.storedLcSelsTable, products.storedLcMlsTable, products.storedLcMlDughtersDummyTable, products.storedLcMcsTable); + products.storedLcIdsTable(collisionMapping[collision.globalIndex()], trackMapping[Lc.prong0Id()], trackMapping[Lc.prong1Id()], trackMapping[Lc.prong2Id()]); } } } - void processSetupAllMcCollisionsWithDownscaling(aod::JMcCollisions const& McCollisions) + template + void storeBplus(soa::Join::iterator const& collision, aod::JTracks const&, aod::CollisionsBplus const& BplusCollisions, T const& Bpluss) { - McCollisionFlag.clear(); - McCollisionFlag.resize(McCollisions.size()); - for (const auto& mcCollision : McCollisions) { - if (randomNumber.Integer(config.downscaleFactor) == 0) { - McCollisionFlag[mcCollision.globalIndex()] = true; - } else { - McCollisionFlag[mcCollision.globalIndex()] = false; + if (collision.isCollisionSelected()) { + for (const auto& BplusCollision : BplusCollisions) { // should only ever be one + jethfutilities::fillHFCollisionTable(BplusCollision, products.storedBplusCollisionsTable); + products.storedBplusCollisionIdsTable(collisionMapping[collision.globalIndex()]); + } + for (const auto& Bplus : Bpluss) { + jethfutilities::fillHFCandidateTable(Bplus, products.storedBplusCollisionsTable.lastIndex(), products.storedBplussTable, products.storedBplusParsTable, products.storedBplusParExtrasTable, products.storedBplusParD0sTable, products.storedBplusSelsTable, products.storedBplusMlsTable, products.storedBplusMlD0sTable, products.storedBplusMcsTable); + products.storedBplusIdsTable(collisionMapping[collision.globalIndex()], trackMapping[Bplus.prong0Id()], trackMapping[Bplus.prong1Id()], trackMapping[Bplus.prong2Id()]); } } } - template - void processDoDownscaling(T const& collisions) + void processDummyTable(aod::JDummys const&) { - for (const auto& collision : collisions) { - if constexpr (std::is_same_v, aod::JCollisions>) { - if (collisionFlag[collision.globalIndex()] && randomNumber.Integer(config.downscaleFactor) != 0) { - collisionFlag[collision.globalIndex()] = false; - } - } - if constexpr (std::is_same_v, aod::JMcCollisions>) { - if (McCollisionFlag[collision.globalIndex()] && randomNumber.Integer(config.downscaleFactor) != 0) { - McCollisionFlag[collision.globalIndex()] = false; + products.storedJDummysTable(1); + } + PROCESS_SWITCH(JetDerivedDataWriter, processDummyTable, "write out dummy output table", true); + + std::vector collisionMapping; + std::vector bcMapping; + std::vector trackMapping; + std::vector mcCollisionMapping; + std::vector particleMapping; + std::vector d0McCollisionMapping; + std::vector lcMcCollisionMapping; + std::vector bplusMcCollisionMapping; + std::vector dielectronMcCollisionMapping; + + void processBCs(soa::Join const& collisions, soa::Join const& bcs) + { + std::vector bcIndicies; + bcMapping.clear(); + bcMapping.resize(bcs.size(), -1); + + for (auto const& collision : collisions) { + if (collision.isCollisionSelected()) { + auto bc = collision.bc_as>(); + if (std::find(bcIndicies.begin(), bcIndicies.end(), bc.globalIndex()) == bcIndicies.end()) { + products.storedJBCsTable(bc.runNumber(), bc.globalBC(), bc.timestamp(), bc.alias_raw(), bc.selection_raw()); + products.storedJBCParentIndexTable(bc.bcId()); + bcIndicies.push_back(bc.globalIndex()); + bcMapping[bc.globalIndex()] = products.storedJBCsTable.lastIndex(); } } } } + PROCESS_SWITCH(JetDerivedDataWriter, processBCs, "write out output tables for Bunch crossings", true); - void processSetupEventTriggering(aod::JCollision const& collision) + void processColllisons(soa::Join const& collisions) { - if (jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) { - collisionFlag[collision.globalIndex()] = true; - } - } + collisionMapping.clear(); + collisionMapping.resize(collisions.size(), -1); + + for (auto const& collision : collisions) { + if (collision.isCollisionSelected()) { - void processDoCollisionSelections(aod::JCollision const& collision) - { // can also add event selection like sel8 but goes a little against the derived data idea - if (collision.centrality() < config.centralityMin || collision.centrality() >= config.centralityMax || collision.trackOccupancyInTimeRange() > config.trackOccupancyInTimeRangeMax || std::abs(collision.posZ()) > config.vertexZCut) { - collisionFlag[collision.globalIndex()] = false; + products.storedJCollisionsTable(collision.posX(), collision.posY(), collision.posZ(), collision.multiplicity(), collision.centrality(), collision.trackOccupancyInTimeRange(), collision.eventSel(), collision.alias_raw(), collision.triggerSel()); + collisionMapping[collision.globalIndex()] = products.storedJCollisionsTable.lastIndex(); + products.storedJCollisionMcInfosTable(collision.weight(), collision.subGeneratorId()); + products.storedJCollisionsParentIndexTable(collision.collisionId()); + if (doprocessBCs) { + products.storedJCollisionsBunchCrossingIndexTable(bcMapping[collision.bcId()]); + } + } } } + PROCESS_SWITCH(JetDerivedDataWriter, processColllisons, "write out output tables for collisions", true); - template - void processSelectionObjects(T& selectionObjects) + void processTracks(soa::Join const& collisions, soa::Join const& tracks) { - float selectionObjectPtMin = 0.0; - if constexpr (std::is_same_v, aod::ChargedJets> || std::is_same_v, aod::ChargedMCDetectorLevelJets>) { - selectionObjectPtMin = config.thresholdChargedJetPtMin; - } else if constexpr (std::is_same_v, aod::ChargedEventWiseSubtractedJets> || std::is_same_v, aod::ChargedMCDetectorLevelEventWiseSubtractedJets>) { - selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedJetPtMin; - } else if constexpr (std::is_same_v, aod::ChargedMCParticleLevelJets>) { - selectionObjectPtMin = config.thresholdChargedMCPJetPtMin; - } else if constexpr (std::is_same_v, aod::NeutralJets> || std::is_same_v, aod::NeutralMCDetectorLevelJets>) { - selectionObjectPtMin = config.thresholdNeutralJetPtMin; - } else if constexpr (std::is_same_v, aod::NeutralMCParticleLevelJets>) { - selectionObjectPtMin = config.thresholdNeutralMCPJetPtMin; - } else if constexpr (std::is_same_v, aod::FullJets> || std::is_same_v, aod::FullMCDetectorLevelJets>) { - selectionObjectPtMin = config.thresholdFullJetPtMin; - } else if constexpr (std::is_same_v, aod::FullMCParticleLevelJets>) { - selectionObjectPtMin = config.thresholdFullMCPJetPtMin; - } else if constexpr (std::is_same_v, aod::D0ChargedJets> || std::is_same_v, aod::D0ChargedMCDetectorLevelJets>) { - selectionObjectPtMin = config.thresholdChargedD0JetPtMin; - } else if constexpr (std::is_same_v, aod::D0ChargedEventWiseSubtractedJets> || std::is_same_v, aod::D0ChargedMCDetectorLevelEventWiseSubtractedJets>) { - selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedD0JetPtMin; - } else if constexpr (std::is_same_v, aod::D0ChargedMCParticleLevelJets>) { - selectionObjectPtMin = config.thresholdChargedD0MCPJetPtMin; - } else if constexpr (std::is_same_v, aod::LcChargedJets> || std::is_same_v, aod::LcChargedMCDetectorLevelJets>) { - selectionObjectPtMin = config.thresholdChargedLcJetPtMin; - } else if constexpr (std::is_same_v, aod::LcChargedEventWiseSubtractedJets> || std::is_same_v, aod::LcChargedMCDetectorLevelEventWiseSubtractedJets>) { - selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedLcJetPtMin; - } else if constexpr (std::is_same_v, aod::LcChargedMCParticleLevelJets>) { - selectionObjectPtMin = config.thresholdChargedLcMCPJetPtMin; - } else if constexpr (std::is_same_v, aod::BplusChargedJets> || std::is_same_v, aod::BplusChargedMCDetectorLevelJets>) { - selectionObjectPtMin = config.thresholdChargedBplusJetPtMin; - } else if constexpr (std::is_same_v, aod::BplusChargedEventWiseSubtractedJets> || std::is_same_v, aod::BplusChargedMCDetectorLevelEventWiseSubtractedJets>) { - selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedBplusJetPtMin; - } else if constexpr (std::is_same_v, aod::BplusChargedMCParticleLevelJets>) { - selectionObjectPtMin = config.thresholdChargedBplusMCPJetPtMin; - } else if constexpr (std::is_same_v, aod::DielectronChargedJets> || std::is_same_v, aod::DielectronChargedMCDetectorLevelJets>) { - selectionObjectPtMin = config.thresholdChargedDielectronJetPtMin; - } else if constexpr (std::is_same_v, aod::DielectronChargedEventWiseSubtractedJets> || std::is_same_v, aod::DielectronChargedMCDetectorLevelEventWiseSubtractedJets>) { - selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedDielectronJetPtMin; - } else if constexpr (std::is_same_v, aod::DielectronChargedMCParticleLevelJets>) { - selectionObjectPtMin = config.thresholdChargedDielectronMCPJetPtMin; - } else if constexpr (std::is_same_v, aod::JTracks>) { - selectionObjectPtMin = config.thresholdTriggerTrackPtMin; - } else if constexpr (std::is_same_v, aod::JClusters>) { - selectionObjectPtMin = config.thresholdClusterEnergyMin; - } else { - selectionObjectPtMin = 0.0; - } - for (const auto& selectionObject : selectionObjects) { - bool isTriggerObject = false; - if constexpr (std::is_same_v, aod::JClusters>) { - if (selectionObject.energy() >= selectionObjectPtMin) { - isTriggerObject = true; - } - } else { - if constexpr (std::is_same_v, aod::JTracks>) { - if (config.performTrackSelection && !(selectionObject.trackSel() & ~(1 << jetderiveddatautilities::JTrackSel::trackSign))) { + trackMapping.clear(); + trackMapping.resize(tracks.size(), -1); + + for (auto const& collision : collisions) { + if (collision.isCollisionSelected()) { + const auto tracksPerCollision = tracks.sliceBy(TracksPerCollisionData, collision.globalIndex()); + for (const auto& track : tracksPerCollision) { + if (!trackSelection(track)) { // skips tracks that pass no selections. This might cause a problem with tracks matched with clusters. We should generate a track selection purely for cluster matched tracks so that they are kept. This includes also the track pT selction. continue; } - } - if (selectionObject.pt() >= selectionObjectPtMin) { - isTriggerObject = true; - } - } - if (isTriggerObject) { - if constexpr (std::is_same_v, aod::ChargedMCParticleLevelJets> || std::is_same_v, aod::NeutralMCParticleLevelJets> || std::is_same_v, aod::FullMCParticleLevelJets> || std::is_same_v, aod::D0ChargedMCParticleLevelJets> || std::is_same_v, aod::LcChargedMCParticleLevelJets> || std::is_same_v, aod::BplusChargedMCParticleLevelJets> || std::is_same_v, aod::DielectronChargedMCParticleLevelJets>) { - if (selectionObject.mcCollisionId() >= 0) { - McCollisionFlag[selectionObject.mcCollisionId()] = true; - } - } else { - if (selectionObject.collisionId() >= 0) { - collisionFlag[selectionObject.collisionId()] = true; - } + products.storedJTracksTable(collisionMapping[collision.globalIndex()], o2::math_utils::detail::truncateFloatFraction(track.pt(), precisionMomentumMask), o2::math_utils::detail::truncateFloatFraction(track.eta(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.phi(), precisionPositionMask), track.trackSel()); + products.storedJTracksExtraTable(o2::math_utils::detail::truncateFloatFraction(track.dcaX(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.dcaY(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.dcaZ(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.dcaXY(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.dcaXYZ(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.sigmadcaZ(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.sigmadcaXY(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.sigmadcaXYZ(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.sigma1Pt(), precisionMomentumMask)); + products.storedJTracksParentIndexTable(track.trackId()); + trackMapping[track.globalIndex()] = products.storedJTracksTable.lastIndex(); } } } } - // Todo : Check memory consumption of having so many Process Switches - PROCESS_SWITCH(JetDerivedDataWriter, processSetupCollisions, "setup the writing for data and MCD based on collisions", true); - PROCESS_SWITCH(JetDerivedDataWriter, processSetupMcCollisions, "setup the writing for MCP based on mcCollisions", false); - PROCESS_SWITCH(JetDerivedDataWriter, processSetupAllCollisionsWithDownscaling, "setup the writing of untriggered collisions with downscaling", false); - PROCESS_SWITCH(JetDerivedDataWriter, processSetupAllMcCollisionsWithDownscaling, "setup the writing of untriggered mccollisions with downscaling", false); - PROCESS_SWITCH(JetDerivedDataWriter, processSetupEventTriggering, "process software triggers", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingChargedJets, "process charged jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingChargedEventWiseSubtractedJets, "process charged event-wise subtracted jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingChargedMCDJets, "process charged mcd jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingChargedMCDetectorLevelEventWiseSubtractedJets, "process charged event-wise subtracted mcd jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingChargedMCPJets, "process charged mcp jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingNeutralJets, "process neutral jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingNeutralMCDJets, "process neutral mcd jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingNeutralMCPJets, "process neutral mcp jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingFullJets, "process full jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingFullMCDJets, "process full mcd jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingFullMCPJets, "process full mcp jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingD0ChargedJets, "process D0 charged jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingD0ChargedEventWiseSubtractedJets, "process D0 event-wise subtracted charged jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingD0ChargedMCDJets, "process D0 charged mcd jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingD0ChargedMCDetectorLevelEventWiseSubtractedJets, "process D0 event-wise subtracted charged mcd jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingD0ChargedMCPJets, "process D0 charged mcp jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingLcChargedJets, "process Lc charged jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingLcChargedEventWiseSubtractedJets, "process Lc event-wise subtracted charged jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingLcChargedMCDJets, "process Lc charged mcd jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingLcChargedMCDetectorLevelEventWiseSubtractedJets, "process Lc event-wise subtracted charged mcd jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingLcChargedMCPJets, "process Lc charged mcp jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingBplusChargedJets, "process Bplus charged jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingBplusChargedEventWiseSubtractedJets, "process Bplus event-wise subtracted charged jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingBplusChargedMCDJets, "process Bplus charged mcd jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingBplusChargedMCDetectorLevelEventWiseSubtractedJets, "process Bplus event-wise subtracted charged mcd jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingBplusChargedMCPJets, "process Bplus charged mcp jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingDielectronChargedJets, "process Dielectron charged jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingDielectronChargedEventWiseSubtractedJets, "process Dielectron event-wise subtracted charged jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingDielectronChargedMCDJets, "process Dielectron charged mcd jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingDielectronChargedMCDetectorLevelEventWiseSubtractedJets, "process Dielectron event-wise subtracted charged mcd jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingDielectronChargedMCPJets, "process Dielectron charged mcp jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingClusters, "process EMCal clusters", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingTracks, "process high pt tracks", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processDoDownscaling, processCollisionDownscaling, "process downsaling of triggered collisions", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processDoDownscaling, processMcCollisionDownscaling, "process downsaling of triggered mccollisions", false); - PROCESS_SWITCH(JetDerivedDataWriter, processDoCollisionSelections, "process event selections for saved events", false); + PROCESS_SWITCH(JetDerivedDataWriter, processTracks, "write out output tables for tracks", true); - void processStoreDummyTable(aod::JDummys const&) + void processClusters(soa::Join::iterator const& collision, aod::JTracks const&, aod::JEMCTracks const& emcTracks, soa::Join const& clusters) { - products.storedJDummysTable(1); + if (collision.isCollisionSelected()) { + products.storedJCollisionsEMCalLabelTable(collision.isAmbiguous(), collision.isEmcalReadout()); + for (const auto& cluster : clusters) { + products.storedJClustersTable(collisionMapping[collision.globalIndex()], cluster.id(), cluster.energy(), cluster.coreEnergy(), cluster.rawEnergy(), + cluster.eta(), cluster.phi(), cluster.m02(), cluster.m20(), cluster.nCells(), cluster.time(), cluster.isExotic(), cluster.distanceToBadChannel(), + cluster.nlm(), cluster.definition(), cluster.leadingCellEnergy(), cluster.subleadingCellEnergy(), cluster.leadingCellNumber(), cluster.subleadingCellNumber()); + products.storedJClustersCorrectedEnergiesTable(cluster.energyCorrectedOneTrack1(), cluster.energyCorrectedOneTrack2(), cluster.energyCorrectedAllTracks1(), cluster.energyCorrectedAllTracks2()); + products.storedJClustersParentIndexTable(cluster.clusterId()); + + std::vector clusterStoredJTrackIDs; + for (const auto& clusterTrack : cluster.matchedTracks_as()) { + clusterStoredJTrackIDs.push_back(trackMapping[clusterTrack.globalIndex()]); + auto emcTracksPerTrack = emcTracks.sliceBy(EMCTrackPerTrack, clusterTrack.globalIndex()); + auto emcTrackPerTrack = emcTracksPerTrack.iteratorAt(0); + products.storedJTracksEMCalTable(trackMapping[clusterTrack.globalIndex()], emcTrackPerTrack.etaEmcal(), emcTrackPerTrack.phiEmcal()); + } + products.storedJClustersMatchedTracksTable(clusterStoredJTrackIDs); + } + } } - PROCESS_SWITCH(JetDerivedDataWriter, processStoreDummyTable, "write out dummy output table", true); + PROCESS_SWITCH(JetDerivedDataWriter, processClusters, "write out output tables for clusters", false); + + //!!!!!!!!!! need to add the hadronic corrected energy and delete the new dummy process function - void processStoreData(soa::Join::iterator const& collision, soa::Join const&, soa::Join const& tracks, aod::JEMCTracks const& emcTracks, soa::Join const& clusters, aod::CollisionsD0 const& D0Collisions, aod::CandidatesD0Data const& D0s, aod::CollisionsLc const& LcCollisions, aod::CandidatesLcData const& Lcs, aod::CollisionsBplus const& BplusCollisions, aod::CandidatesBplusData const& Bpluss, aod::CollisionsDielectron const& DielectronCollisions, aod::CandidatesDielectronData const& Dielectrons) + void processD0Data(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsD0 const& D0Collisions, aod::CandidatesD0Data const& D0s) { - std::map bcMapping; - std::map trackMapping; + storeD0(collision, tracks, D0Collisions, D0s); + } + PROCESS_SWITCH(JetDerivedDataWriter, processD0Data, "write out data output tables for D0", false); - if (collisionFlag[collision.globalIndex()]) { - if (config.saveBCsTable) { - auto bc = collision.bc_as>(); - if (std::find(bcIndicies.begin(), bcIndicies.end(), bc.globalIndex()) == bcIndicies.end()) { - products.storedJBCsTable(bc.runNumber(), bc.globalBC(), bc.timestamp(), bc.alias_raw(), bc.selection_raw()); - products.storedJBCParentIndexTable(bc.bcId()); - bcIndicies.push_back(bc.globalIndex()); - bcMapping.insert(std::make_pair(bc.globalIndex(), products.storedJBCsTable.lastIndex())); - } - } + void processD0MCD(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsD0 const& D0Collisions, aod::CandidatesD0MCD const& D0s) + { + storeD0(collision, tracks, D0Collisions, D0s); + } + PROCESS_SWITCH(JetDerivedDataWriter, processD0MCD, "write out mcd output tables for D0", false); - products.storedJCollisionsTable(collision.posX(), collision.posY(), collision.posZ(), collision.multiplicity(), collision.centrality(), collision.trackOccupancyInTimeRange(), collision.eventSel(), collision.alias_raw(), collision.triggerSel()); - products.storedJCollisionMcInfosTable(collision.weight(), collision.subGeneratorId()); - products.storedJCollisionsParentIndexTable(collision.collisionId()); - if (config.saveBCsTable) { - int32_t storedBCID = -1; - auto JBCIndex = bcMapping.find(collision.bcId()); - if (JBCIndex != bcMapping.end()) { - storedBCID = JBCIndex->second; - } - products.storedJCollisionsBunchCrossingIndexTable(storedBCID); - } - if (config.saveClustersTable) { - products.storedJCollisionsEMCalLabelTable(collision.isAmbiguous(), collision.isEmcalReadout()); - } + void processLcData(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsLc const& LcCollisions, aod::CandidatesLcData const& Lcs) + { + storeLc(collision, tracks, LcCollisions, Lcs); + } + PROCESS_SWITCH(JetDerivedDataWriter, processLcData, "write out data output tables for Lc", false); - for (const auto& track : tracks) { - if (config.performTrackSelection && !(track.trackSel() & ~(1 << jetderiveddatautilities::JTrackSel::trackSign))) { // skips tracks that pass no selections. This might cause a problem with tracks matched with clusters. We should generate a track selection purely for cluster matched tracks so that they are kept. This includes also the track pT selction. - continue; - } - if (track.pt() < config.trackPtSelectionMin || std::abs(track.eta()) > config.trackEtaSelectionMax) { - continue; - } - products.storedJTracksTable(products.storedJCollisionsTable.lastIndex(), o2::math_utils::detail::truncateFloatFraction(track.pt(), precisionMomentumMask), o2::math_utils::detail::truncateFloatFraction(track.eta(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.phi(), precisionPositionMask), track.trackSel()); - products.storedJTracksExtraTable(o2::math_utils::detail::truncateFloatFraction(track.dcaX(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.dcaY(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.dcaZ(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.dcaXY(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.dcaXYZ(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.sigmadcaZ(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.sigmadcaXY(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.sigmadcaXYZ(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.sigma1Pt(), precisionMomentumMask)); - products.storedJTracksParentIndexTable(track.trackId()); - trackMapping.insert(std::make_pair(track.globalIndex(), products.storedJTracksTable.lastIndex())); - } - if (config.saveClustersTable) { - for (const auto& cluster : clusters) { - products.storedJClustersTable(products.storedJCollisionsTable.lastIndex(), cluster.id(), cluster.energy(), cluster.coreEnergy(), cluster.rawEnergy(), - cluster.eta(), cluster.phi(), cluster.m02(), cluster.m20(), cluster.nCells(), cluster.time(), cluster.isExotic(), cluster.distanceToBadChannel(), - cluster.nlm(), cluster.definition(), cluster.leadingCellEnergy(), cluster.subleadingCellEnergy(), cluster.leadingCellNumber(), cluster.subleadingCellNumber()); - products.storedJClustersCorrectedEnergiesTable(cluster.energyCorrectedOneTrack1(), cluster.energyCorrectedOneTrack2(), cluster.energyCorrectedAllTracks1(), cluster.energyCorrectedAllTracks2()); - products.storedJClustersParentIndexTable(cluster.clusterId()); + void processLcMCD(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsLc const& LcCollisions, aod::CandidatesLcMCD const& Lcs) + { + storeLc(collision, tracks, LcCollisions, Lcs); + } + PROCESS_SWITCH(JetDerivedDataWriter, processLcMCD, "write out mcd output tables for Lc", false); - std::vector clusterStoredJTrackIDs; - for (const auto& clusterTrack : cluster.matchedTracks_as>()) { - auto JtrackIndex = trackMapping.find(clusterTrack.globalIndex()); - if (JtrackIndex != trackMapping.end()) { - clusterStoredJTrackIDs.push_back(JtrackIndex->second); - auto emcTracksPerTrack = emcTracks.sliceBy(EMCTrackPerTrack, clusterTrack.globalIndex()); - auto emcTrackPerTrack = emcTracksPerTrack.iteratorAt(0); - products.storedJTracksEMCalTable(JtrackIndex->second, emcTrackPerTrack.etaEmcal(), emcTrackPerTrack.phiEmcal()); - } - } - products.storedJClustersMatchedTracksTable(clusterStoredJTrackIDs); - } - } + void processBplusData(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsBplus const& BplusCollisions, aod::CandidatesBplusData const& Bpluss) + { + storeBplus(collision, tracks, BplusCollisions, Bpluss); + } + PROCESS_SWITCH(JetDerivedDataWriter, processBplusData, "write out data output tables for bplus", false); - if (config.saveD0Table) { - int32_t collisionD0Index = -1; - for (const auto& D0Collision : D0Collisions) { // should only ever be one - jethfutilities::fillHFCollisionTable(D0Collision, products.storedD0CollisionsTable, collisionD0Index); - products.storedD0CollisionIdsTable(products.storedJCollisionsTable.lastIndex()); - } - for (const auto& D0 : D0s) { - int32_t D0Index = -1; - jethfutilities::fillHFCandidateTable(D0, collisionD0Index, products.storedD0sTable, products.storedD0ParsTable, products.storedD0ParExtrasTable, products.storedD0ParDaughtersDummyTable, products.storedD0SelsTable, products.storedD0MlsTable, products.storedD0MlDughtersDummyTable, products.storedD0McsTable, D0Index); + void processBplusMCD(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsBplus const& BplusCollisions, aod::CandidatesBplusMCD const& Bpluss) + { + storeBplus(collision, tracks, BplusCollisions, Bpluss); + } + PROCESS_SWITCH(JetDerivedDataWriter, processBplusMCD, "write out mcd output tables for bplus", false); - int32_t prong0Id = -1; - int32_t prong1Id = -1; - auto JtrackIndex = trackMapping.find(D0.prong0Id()); - if (JtrackIndex != trackMapping.end()) { - prong0Id = JtrackIndex->second; - } - JtrackIndex = trackMapping.find(D0.prong1Id()); - if (JtrackIndex != trackMapping.end()) { - prong1Id = JtrackIndex->second; - } - products.storedD0IdsTable(products.storedJCollisionsTable.lastIndex(), prong0Id, prong1Id); - } + void processDielectron(soa::Join::iterator const& collision, aod::JTracks const&, aod::CollisionsDielectron const& DielectronCollisions, aod::CandidatesDielectronData const& Dielectrons) + { + if (collision.isCollisionSelected()) { + for (const auto& DielectronCollision : DielectronCollisions) { // should only ever be one + jetdqutilities::fillDielectronCollisionTable(DielectronCollision, products.storedDielectronCollisionsTable); + products.storedDielectronCollisionIdsTable(collisionMapping[collision.globalIndex()]); } - - if (config.saveLcTable) { - int32_t collisionLcIndex = -1; - for (const auto& LcCollision : LcCollisions) { // should only ever be one - jethfutilities::fillHFCollisionTable(LcCollision, products.storedLcCollisionsTable, collisionLcIndex); - products.storedLcCollisionIdsTable(products.storedJCollisionsTable.lastIndex()); - } - for (const auto& Lc : Lcs) { - int32_t LcIndex = -1; - jethfutilities::fillHFCandidateTable(Lc, collisionLcIndex, products.storedLcsTable, products.storedLcParsTable, products.storedLcParExtrasTable, products.storedLcParDaughtersDummyTable, products.storedLcSelsTable, products.storedLcMlsTable, products.storedLcMlDughtersDummyTable, products.storedLcMcsTable, LcIndex); - - int32_t prong0Id = -1; - int32_t prong1Id = -1; - int32_t prong2Id = -1; - auto JtrackIndex = trackMapping.find(Lc.prong0Id()); - if (JtrackIndex != trackMapping.end()) { - prong0Id = JtrackIndex->second; - } - JtrackIndex = trackMapping.find(Lc.prong1Id()); - if (JtrackIndex != trackMapping.end()) { - prong1Id = JtrackIndex->second; - } - JtrackIndex = trackMapping.find(Lc.prong2Id()); - if (JtrackIndex != trackMapping.end()) { - prong2Id = JtrackIndex->second; - } - products.storedLcIdsTable(products.storedJCollisionsTable.lastIndex(), prong0Id, prong1Id, prong2Id); - } + for (const auto& Dielectron : Dielectrons) { + jetdqutilities::fillDielectronCandidateTable(Dielectron, products.storedDielectronCollisionsTable.lastIndex(), products.storedDielectronsTable); + products.storedDielectronIdsTable(collisionMapping[collision.globalIndex()], trackMapping[Dielectron.prong0Id()], trackMapping[Dielectron.prong1Id()]); } - if (config.saveBplusTable) { - int32_t collisionBplusIndex = -1; - for (const auto& BplusCollision : BplusCollisions) { // should only ever be one - jethfutilities::fillHFCollisionTable(BplusCollision, products.storedBplusCollisionsTable, collisionBplusIndex); - products.storedBplusCollisionIdsTable(products.storedJCollisionsTable.lastIndex()); - } - for (const auto& Bplus : Bpluss) { - int32_t BplusIndex = -1; - jethfutilities::fillHFCandidateTable(Bplus, collisionBplusIndex, products.storedBplussTable, products.storedBplusParsTable, products.storedBplusParExtrasTable, products.storedBplusParD0sTable, products.storedBplusSelsTable, products.storedBplusMlsTable, products.storedBplusMlD0sTable, products.storedBplusMcsTable, BplusIndex); + } + } + PROCESS_SWITCH(JetDerivedDataWriter, processDielectron, "write out data output tables for dielectrons", false); - int32_t prong0Id = -1; - int32_t prong1Id = -1; - int32_t prong2Id = -1; - auto JtrackIndex = trackMapping.find(Bplus.prong0Id()); - if (JtrackIndex != trackMapping.end()) { - prong0Id = JtrackIndex->second; - } - JtrackIndex = trackMapping.find(Bplus.prong1Id()); - if (JtrackIndex != trackMapping.end()) { - prong1Id = JtrackIndex->second; - } - JtrackIndex = trackMapping.find(Bplus.prong2Id()); - if (JtrackIndex != trackMapping.end()) { - prong2Id = JtrackIndex->second; - } - products.storedBplusIdsTable(products.storedJCollisionsTable.lastIndex(), prong0Id, prong1Id, prong2Id); - } - } - if (config.saveDielectronTable) { - int32_t collisionDielectronIndex = -1; - for (const auto& DielectronCollision : DielectronCollisions) { // should only ever be one - jetdqutilities::fillDielectronCollisionTable(DielectronCollision, products.storedDielectronCollisionsTable, collisionDielectronIndex); - products.storedDielectronCollisionIdsTable(products.storedJCollisionsTable.lastIndex()); - } - for (const auto& Dielectron : Dielectrons) { - int32_t DielectronIndex = -1; - jetdqutilities::fillDielectronCandidateTable(Dielectron, collisionDielectronIndex, products.storedDielectronsTable, DielectronIndex); + void processMcCollisions(soa::Join const& mcCollisions) + { + mcCollisionMapping.clear(); + mcCollisionMapping.resize(mcCollisions.size(), -1); + for (auto const& mcCollision : mcCollisions) { + if (mcCollision.isMcCollisionSelected()) { - int32_t prong0Id = -1; - int32_t prong1Id = -1; - auto JtrackIndex = trackMapping.find(Dielectron.prong0Id()); - if (JtrackIndex != trackMapping.end()) { - prong0Id = JtrackIndex->second; - } - JtrackIndex = trackMapping.find(Dielectron.prong1Id()); - if (JtrackIndex != trackMapping.end()) { - prong1Id = JtrackIndex->second; - } - products.storedDielectronIdsTable(products.storedJCollisionsTable.lastIndex(), prong0Id, prong1Id); - } + products.storedJMcCollisionsTable(mcCollision.posX(), mcCollision.posY(), mcCollision.posZ(), mcCollision.weight(), mcCollision.subGeneratorId()); + products.storedJMcCollisionsParentIndexTable(mcCollision.mcCollisionId()); + mcCollisionMapping[mcCollision.globalIndex()] = products.storedJMcCollisionsTable.lastIndex(); } } } - // process switch for output writing must be last - // to run after all jet selections - PROCESS_SWITCH(JetDerivedDataWriter, processStoreData, "write out data output tables", false); + PROCESS_SWITCH(JetDerivedDataWriter, processMcCollisions, "write out mcCollision output tables", false); - void processStoreMC(soa::Join const& mcCollisions, soa::Join const& collisions, soa::Join const&, soa::Join const& tracks, aod::JEMCTracks const& emcTracks, soa::Join const& clusters, soa::Join const& particles, aod::CollisionsD0 const& D0Collisions, aod::CandidatesD0MCD const& D0s, soa::Join const& D0McCollisions, aod::CandidatesD0MCP const& D0Particles, aod::CollisionsLc const& LcCollisions, aod::CandidatesLcMCD const& Lcs, soa::Join const& LcMcCollisions, aod::CandidatesLcMCP const& LcParticles, aod::CollisionsBplus const& BplusCollisions, aod::CandidatesBplusMCD const& Bpluss, soa::Join const& BplusMcCollisions, aod::CandidatesBplusMCP const& BplusParticles, aod::CollisionsDielectron const& DielectronCollisions, aod::CandidatesDielectronMCD const& Dielectrons, aod::McCollisionsDielectron const& DielectronMcCollisions, aod::CandidatesDielectronMCP const& DielectronParticles) + void processMcParticles(soa::Join const& mcCollisions, soa::Join const& particles) { - std::map bcMapping; - std::map paticleMapping; - std::map mcCollisionMapping; - std::map D0CollisionMapping; - std::map LcCollisionMapping; - std::map BplusCollisionMapping; + particleMapping.clear(); + particleMapping.resize(particles.size(), -1); int particleTableIndex = 0; - for (auto mcCollision : mcCollisions) { - bool collisionSelected = false; - const auto collisionsPerMcCollision = collisions.sliceBy(CollisionsPerMcCollision, mcCollision.globalIndex()); - for (auto collision : collisionsPerMcCollision) { - if (collisionFlag[collision.globalIndex()]) { - collisionSelected = true; - } - } - - if (McCollisionFlag[mcCollision.globalIndex()] || collisionSelected) { + for (auto const& mcCollision : mcCollisions) { + if (mcCollision.isMcCollisionSelected()) { const auto particlesPerMcCollision = particles.sliceBy(ParticlesPerMcCollision, mcCollision.globalIndex()); - products.storedJMcCollisionsTable(mcCollision.posX(), mcCollision.posY(), mcCollision.posZ(), mcCollision.weight(), mcCollision.subGeneratorId()); - products.storedJMcCollisionsParentIndexTable(mcCollision.mcCollisionId()); - mcCollisionMapping.insert(std::make_pair(mcCollision.globalIndex(), products.storedJMcCollisionsTable.lastIndex())); - for (auto particle : particlesPerMcCollision) { - paticleMapping.insert(std::make_pair(particle.globalIndex(), particleTableIndex)); + particleMapping[particle.globalIndex()] = particleTableIndex; particleTableIndex++; } for (auto particle : particlesPerMcCollision) { - std::vector mothersId; + std::vector mothersIds; if (particle.has_mothers()) { auto mothersIdTemps = particle.mothersIds(); for (auto mothersIdTemp : mothersIdTemps) { - - auto JMotherIndex = paticleMapping.find(mothersIdTemp); - if (JMotherIndex != paticleMapping.end()) { - mothersId.push_back(JMotherIndex->second); - } + mothersIds.push_back(particleMapping[mothersIdTemp]); } } - int daughtersId[2] = {-1, -1}; + int daughtersIds[2] = {-1, -1}; auto i = 0; if (particle.has_daughters()) { for (auto daughterId : particle.daughtersIds()) { if (i > 1) { break; } - auto JDaughterIndex = paticleMapping.find(daughterId); - if (JDaughterIndex != paticleMapping.end()) { - daughtersId[i] = JDaughterIndex->second; - } + daughtersIds[i] = particleMapping[daughterId]; i++; } } - products.storedJMcParticlesTable(products.storedJMcCollisionsTable.lastIndex(), o2::math_utils::detail::truncateFloatFraction(particle.pt(), precisionMomentumMask), o2::math_utils::detail::truncateFloatFraction(particle.eta(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(particle.phi(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(particle.y(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(particle.e(), precisionMomentumMask), particle.pdgCode(), particle.getGenStatusCode(), particle.getHepMCStatusCode(), particle.isPhysicalPrimary(), mothersId, daughtersId); + products.storedJMcParticlesTable(mcCollisionMapping[mcCollision.globalIndex()], o2::math_utils::detail::truncateFloatFraction(particle.pt(), precisionMomentumMask), o2::math_utils::detail::truncateFloatFraction(particle.eta(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(particle.phi(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(particle.y(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(particle.e(), precisionMomentumMask), particle.pdgCode(), particle.getGenStatusCode(), particle.getHepMCStatusCode(), particle.isPhysicalPrimary(), mothersIds, daughtersIds); products.storedJParticlesParentIndexTable(particle.mcParticleId()); } + } + } + } + PROCESS_SWITCH(JetDerivedDataWriter, processMcParticles, "write out mcParticle output tables", false); - if (config.saveD0Table) { - const auto d0McCollisionsPerMcCollision = D0McCollisions.sliceBy(D0McCollisionsPerMcCollision, mcCollision.globalIndex()); - int32_t mcCollisionD0Index = -1; - for (const auto& d0McCollisionPerMcCollision : d0McCollisionsPerMcCollision) { // should only ever be one - jethfutilities::fillHFMcCollisionTable(d0McCollisionPerMcCollision, products.storedD0McCollisionsTable, mcCollisionD0Index); - products.storedD0McCollisionIdsTable(products.storedJMcCollisionsTable.lastIndex()); - } - for (const auto& D0Particle : D0Particles) { - int32_t D0ParticleIndex = -1; - jethfutilities::fillHFCandidateMcTable(D0Particle, mcCollisionD0Index, products.storedD0ParticlesTable, D0ParticleIndex); - int32_t D0ParticleId = -1; - auto JParticleIndex = paticleMapping.find(D0Particle.mcParticleId()); - if (JParticleIndex != paticleMapping.end()) { - D0ParticleId = JParticleIndex->second; - } - products.storedD0ParticleIdsTable(products.storedJMcCollisionsTable.lastIndex(), D0ParticleId); - } - } - - if (config.saveLcTable) { - const auto lcMcCollisionsPerMcCollision = LcMcCollisions.sliceBy(LcMcCollisionsPerMcCollision, mcCollision.globalIndex()); - int32_t mcCollisionLcIndex = -1; - for (const auto& lcMcCollisionPerMcCollision : lcMcCollisionsPerMcCollision) { // should only ever be one - jethfutilities::fillHFMcCollisionTable(lcMcCollisionPerMcCollision, products.storedLcMcCollisionsTable, mcCollisionLcIndex); - products.storedLcMcCollisionIdsTable(products.storedJMcCollisionsTable.lastIndex()); - } - for (const auto& LcParticle : LcParticles) { - int32_t LcParticleIndex = -1; - jethfutilities::fillHFCandidateMcTable(LcParticle, mcCollisionLcIndex, products.storedLcParticlesTable, LcParticleIndex); - int32_t LcParticleId = -1; - auto JParticleIndex = paticleMapping.find(LcParticle.mcParticleId()); - if (JParticleIndex != paticleMapping.end()) { - LcParticleId = JParticleIndex->second; - } - products.storedLcParticleIdsTable(products.storedJMcCollisionsTable.lastIndex(), LcParticleId); - } - } - if (config.saveBplusTable) { - const auto lcMcCollisionsPerMcCollision = BplusMcCollisions.sliceBy(BplusMcCollisionsPerMcCollision, mcCollision.globalIndex()); - int32_t mcCollisionBplusIndex = -1; - for (const auto& lcMcCollisionPerMcCollision : lcMcCollisionsPerMcCollision) { // should only ever be one - jethfutilities::fillHFMcCollisionTable(lcMcCollisionPerMcCollision, products.storedBplusMcCollisionsTable, mcCollisionBplusIndex); - products.storedBplusMcCollisionIdsTable(products.storedJMcCollisionsTable.lastIndex()); - } - for (const auto& BplusParticle : BplusParticles) { - int32_t BplusParticleIndex = -1; - jethfutilities::fillHFCandidateMcTable(BplusParticle, mcCollisionBplusIndex, products.storedBplusParticlesTable, BplusParticleIndex); - int32_t BplusParticleId = -1; - auto JParticleIndex = paticleMapping.find(BplusParticle.mcParticleId()); - if (JParticleIndex != paticleMapping.end()) { - BplusParticleId = JParticleIndex->second; - } - products.storedBplusParticleIdsTable(products.storedJMcCollisionsTable.lastIndex(), BplusParticleId); - } - } - if (config.saveDielectronTable) { - const auto dielectronMcCollisionsPerMcCollision = DielectronMcCollisions.sliceBy(DielectronMcCollisionsPerMcCollision, mcCollision.globalIndex()); - int32_t mcCollisionDielectronIndex = -1; - for (const auto& dielectronMcCollisionPerMcCollision : dielectronMcCollisionsPerMcCollision) { // should only ever be one - jetdqutilities::fillDielectronMcCollisionTable(dielectronMcCollisionPerMcCollision, products.storedDielectronMcCollisionsTable, mcCollisionDielectronIndex); - products.storedDielectronMcCollisionIdsTable(products.storedJMcCollisionsTable.lastIndex()); - } - for (const auto& DielectronParticle : DielectronParticles) { - int32_t DielectronParticleIndex = -1; - jetdqutilities::fillDielectronCandidateMcTable(DielectronParticle, mcCollisionDielectronIndex, products.storedDielectronParticlesTable, DielectronParticleIndex); - int32_t DielectronParticleId = -1; - auto JParticleIndex = paticleMapping.find(DielectronParticle.mcParticleId()); - if (JParticleIndex != paticleMapping.end()) { - DielectronParticleId = JParticleIndex->second; - } - std::vector DielectronMothersId; - int DielectronDaughtersId[2]; - if (DielectronParticle.has_mothers()) { - for (auto const& DielectronMother : DielectronParticle.template mothers_as>()) { - auto JDielectronMotherIndex = paticleMapping.find(DielectronMother.globalIndex()); - if (JDielectronMotherIndex != paticleMapping.end()) { - DielectronMothersId.push_back(JDielectronMotherIndex->second); - } - } - } - auto i = 0; - if (DielectronParticle.has_daughters()) { - for (auto const& DielectronDaughter : DielectronParticle.template daughters_as>()) { - if (i > 1) { - break; - } - auto JDielectronDaughterIndex = paticleMapping.find(DielectronDaughter.globalIndex()); - if (JDielectronDaughterIndex != paticleMapping.end()) { - DielectronDaughtersId[i] = JDielectronDaughterIndex->second; - } - i++; - } - } - products.storedDielectronParticleIdsTable(products.storedJMcCollisionsTable.lastIndex(), DielectronParticleId, DielectronMothersId, DielectronDaughtersId); - } + void processD0MCP(soa::Join const& mcCollisions, aod::McCollisionsD0 const& D0McCollisions, aod::CandidatesD0MCP const& D0Particles) + { + d0McCollisionMapping.clear(); + d0McCollisionMapping.resize(D0McCollisions.size(), -1); + for (auto const& mcCollision : mcCollisions) { + if (mcCollision.isMcCollisionSelected()) { + const auto d0McCollisionsPerMcCollision = D0McCollisions.sliceBy(D0McCollisionsPerMcCollision, mcCollision.globalIndex()); + for (const auto& d0McCollisionPerMcCollision : d0McCollisionsPerMcCollision) { + jethfutilities::fillHFMcCollisionTable(d0McCollisionPerMcCollision, products.storedD0McCollisionsTable); + products.storedD0McCollisionIdsTable(mcCollisionMapping[mcCollision.globalIndex()]); + d0McCollisionMapping[d0McCollisionPerMcCollision.globalIndex()] = products.storedD0McCollisionsTable.lastIndex(); + } + const auto d0ParticlesPerMcCollision = D0Particles.sliceBy(D0ParticlesPerMcCollision, mcCollision.globalIndex()); + for (const auto& D0Particle : d0ParticlesPerMcCollision) { + jethfutilities::fillHFCandidateMcTable(D0Particle, products.storedD0McCollisionsTable.lastIndex(), products.storedD0ParticlesTable); + products.storedD0ParticleIdsTable(mcCollisionMapping[mcCollision.globalIndex()], particleMapping[D0Particle.mcParticleId()]); } } } + } + PROCESS_SWITCH(JetDerivedDataWriter, processD0MCP, "write out D0 mcp output tables", false); - for (auto mcCollision : mcCollisions) { - bool collisionSelected = false; - const auto collisionsPerMcCollision = collisions.sliceBy(CollisionsPerMcCollision, mcCollision.globalIndex()); - for (auto collision : collisionsPerMcCollision) { - if (collisionFlag[collision.globalIndex()]) { - collisionSelected = true; + void processLcMCP(soa::Join const& mcCollisions, aod::McCollisionsLc const& LcMcCollisions, aod::CandidatesLcMCP const& LcParticles) + { + lcMcCollisionMapping.clear(); + lcMcCollisionMapping.resize(LcMcCollisions.size(), -1); + for (auto const& mcCollision : mcCollisions) { + if (mcCollision.isMcCollisionSelected()) { + const auto lcMcCollisionsPerMcCollision = LcMcCollisions.sliceBy(LcMcCollisionsPerMcCollision, mcCollision.globalIndex()); + for (const auto& lcMcCollisionPerMcCollision : lcMcCollisionsPerMcCollision) { // should only ever be one + jethfutilities::fillHFMcCollisionTable(lcMcCollisionPerMcCollision, products.storedLcMcCollisionsTable); + products.storedLcMcCollisionIdsTable(mcCollisionMapping[mcCollision.globalIndex()]); + lcMcCollisionMapping[lcMcCollisionPerMcCollision.globalIndex()] = products.storedLcMcCollisionsTable.lastIndex(); + } + const auto lcParticlesPerMcCollision = LcParticles.sliceBy(LcParticlesPerMcCollision, mcCollision.globalIndex()); + for (const auto& LcParticle : lcParticlesPerMcCollision) { + jethfutilities::fillHFCandidateMcTable(LcParticle, products.storedLcMcCollisionsTable.lastIndex(), products.storedLcParticlesTable); + products.storedLcParticleIdsTable(mcCollisionMapping[mcCollision.globalIndex()], particleMapping[LcParticle.mcParticleId()]); } } + } + } - if (McCollisionFlag[mcCollision.globalIndex()] || collisionSelected) { - - for (auto collision : collisionsPerMcCollision) { - std::map trackMapping; - if (config.saveBCsTable) { - auto bc = collision.bc_as>(); - if (std::find(bcIndicies.begin(), bcIndicies.end(), bc.globalIndex()) == bcIndicies.end()) { - products.storedJBCsTable(bc.runNumber(), bc.globalBC(), bc.timestamp(), bc.alias_raw(), bc.selection_raw()); - products.storedJBCParentIndexTable(bc.bcId()); - bcIndicies.push_back(bc.globalIndex()); - bcMapping.insert(std::make_pair(bc.globalIndex(), products.storedJBCsTable.lastIndex())); - } - } - - products.storedJCollisionsTable(collision.posX(), collision.posY(), collision.posZ(), collision.multiplicity(), collision.centrality(), collision.trackOccupancyInTimeRange(), collision.eventSel(), collision.alias_raw(), collision.triggerSel()); - products.storedJCollisionMcInfosTable(collision.weight(), collision.subGeneratorId()); - products.storedJCollisionsParentIndexTable(collision.collisionId()); - - auto JMcCollisionIndex = mcCollisionMapping.find(mcCollision.globalIndex()); - if (JMcCollisionIndex != mcCollisionMapping.end()) { - products.storedJMcCollisionsLabelTable(JMcCollisionIndex->second); - } - if (config.saveBCsTable) { - int32_t storedBCID = -1; - auto JBCIndex = bcMapping.find(collision.bcId()); - if (JBCIndex != bcMapping.end()) { - storedBCID = JBCIndex->second; - } - products.storedJCollisionsBunchCrossingIndexTable(storedBCID); - } - if (config.saveClustersTable) { - products.storedJCollisionsEMCalLabelTable(collision.isAmbiguous(), collision.isEmcalReadout()); - } - - const auto tracksPerCollision = tracks.sliceBy(TracksPerCollision, collision.globalIndex()); - for (const auto& track : tracksPerCollision) { - if (config.performTrackSelection && !(track.trackSel() & ~(1 << jetderiveddatautilities::JTrackSel::trackSign))) { // skips tracks that pass no selections. This might cause a problem with tracks matched with clusters. We should generate a track selection purely for cluster matched tracks so that they are kept - continue; - } - if (track.pt() < config.trackPtSelectionMin || std::abs(track.eta()) > config.trackEtaSelectionMax) { - continue; - } - products.storedJTracksTable(products.storedJCollisionsTable.lastIndex(), o2::math_utils::detail::truncateFloatFraction(track.pt(), precisionMomentumMask), o2::math_utils::detail::truncateFloatFraction(track.eta(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.phi(), precisionPositionMask), track.trackSel()); - products.storedJTracksExtraTable(o2::math_utils::detail::truncateFloatFraction(track.dcaX(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.dcaY(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.dcaZ(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.dcaXY(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.dcaXYZ(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.sigmadcaZ(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.sigmadcaXY(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.sigmadcaXYZ(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.sigma1Pt(), precisionMomentumMask)); - products.storedJTracksParentIndexTable(track.trackId()); - - if (track.has_mcParticle()) { - auto JParticleIndex = paticleMapping.find(track.mcParticleId()); - if (JParticleIndex != paticleMapping.end()) { - products.storedJMcTracksLabelTable(JParticleIndex->second); - } else { - products.storedJMcTracksLabelTable(-1); // this can happen because there are some tracks that are reconstucted in a wrong collision, but their original McCollision did not pass the required cuts so that McParticle is not saved. These are very few but we should look into them further and see what to do about them - } - } else { - products.storedJMcTracksLabelTable(-1); - } - trackMapping.insert(std::make_pair(track.globalIndex(), products.storedJTracksTable.lastIndex())); - } - if (config.saveClustersTable) { - const auto clustersPerCollision = clusters.sliceBy(ClustersPerCollision, collision.globalIndex()); - for (const auto& cluster : clustersPerCollision) { - products.storedJClustersTable(products.storedJCollisionsTable.lastIndex(), cluster.id(), cluster.energy(), cluster.coreEnergy(), cluster.rawEnergy(), - cluster.eta(), cluster.phi(), cluster.m02(), cluster.m20(), cluster.nCells(), cluster.time(), cluster.isExotic(), cluster.distanceToBadChannel(), - cluster.nlm(), cluster.definition(), cluster.leadingCellEnergy(), cluster.subleadingCellEnergy(), cluster.leadingCellNumber(), cluster.subleadingCellNumber()); - products.storedJClustersCorrectedEnergiesTable(cluster.energyCorrectedOneTrack1(), cluster.energyCorrectedOneTrack2(), cluster.energyCorrectedAllTracks1(), cluster.energyCorrectedAllTracks2()); - products.storedJClustersParentIndexTable(cluster.clusterId()); - - std::vector clusterStoredJTrackIDs; - for (const auto& clusterTrack : cluster.matchedTracks_as>()) { - auto JtrackIndex = trackMapping.find(clusterTrack.globalIndex()); - if (JtrackIndex != trackMapping.end()) { - clusterStoredJTrackIDs.push_back(JtrackIndex->second); - const auto emcTracksPerTrack = emcTracks.sliceBy(EMCTrackPerTrack, clusterTrack.globalIndex()); - auto emcTrackPerTrack = emcTracksPerTrack.iteratorAt(0); - products.storedJTracksEMCalTable(JtrackIndex->second, emcTrackPerTrack.etaEmcal(), emcTrackPerTrack.phiEmcal()); - } - } - products.storedJClustersMatchedTracksTable(clusterStoredJTrackIDs); - - std::vector clusterStoredJParticleIDs; - for (const auto& clusterParticleId : cluster.mcParticlesIds()) { - auto JParticleIndex = paticleMapping.find(clusterParticleId); - if (JParticleIndex != paticleMapping.end()) { - clusterStoredJParticleIDs.push_back(JParticleIndex->second); - } - } - std::vector amplitudeA; - auto amplitudeASpan = cluster.amplitudeA(); - std::copy(amplitudeASpan.begin(), amplitudeASpan.end(), std::back_inserter(amplitudeA)); - products.storedJMcClustersLabelTable(clusterStoredJParticleIDs, amplitudeA); - } - } - - if (config.saveD0Table) { - const auto d0CollisionsPerCollision = D0Collisions.sliceBy(D0CollisionsPerCollision, collision.globalIndex()); - int32_t collisionD0Index = -1; - for (const auto& d0CollisionPerCollision : d0CollisionsPerCollision) { // should only ever be one - jethfutilities::fillHFCollisionTable(d0CollisionPerCollision, products.storedD0CollisionsTable, collisionD0Index); - products.storedD0CollisionIdsTable(products.storedJCollisionsTable.lastIndex()); - D0CollisionMapping.insert(std::make_pair(d0CollisionPerCollision.globalIndex(), products.storedD0CollisionsTable.lastIndex())); - } - const auto d0sPerCollision = D0s.sliceBy(D0sPerCollision, collision.globalIndex()); - for (const auto& D0 : d0sPerCollision) { - int32_t D0Index = -1; - jethfutilities::fillHFCandidateTable(D0, collisionD0Index, products.storedD0sTable, products.storedD0ParsTable, products.storedD0ParExtrasTable, products.storedD0ParDaughtersDummyTable, products.storedD0SelsTable, products.storedD0MlsTable, products.storedD0MlDughtersDummyTable, products.storedD0McsTable, D0Index); - - int32_t prong0Id = -1; - int32_t prong1Id = -1; - auto JtrackIndex = trackMapping.find(D0.prong0Id()); - if (JtrackIndex != trackMapping.end()) { - prong0Id = JtrackIndex->second; - } - JtrackIndex = trackMapping.find(D0.prong1Id()); - if (JtrackIndex != trackMapping.end()) { - prong1Id = JtrackIndex->second; - } - products.storedD0IdsTable(products.storedJCollisionsTable.lastIndex(), prong0Id, prong1Id); - } - } - - if (config.saveLcTable) { - const auto lcCollisionsPerCollision = LcCollisions.sliceBy(LcCollisionsPerCollision, collision.globalIndex()); - int32_t collisionLcIndex = -1; - for (const auto& lcCollisionPerCollision : lcCollisionsPerCollision) { // should only ever be one - jethfutilities::fillHFCollisionTable(lcCollisionPerCollision, products.storedLcCollisionsTable, collisionLcIndex); - products.storedLcCollisionIdsTable(products.storedJCollisionsTable.lastIndex()); - LcCollisionMapping.insert(std::make_pair(lcCollisionPerCollision.globalIndex(), products.storedLcCollisionsTable.lastIndex())); - } - const auto lcsPerCollision = Lcs.sliceBy(LcsPerCollision, collision.globalIndex()); - for (const auto& Lc : lcsPerCollision) { - int32_t LcIndex = -1; - jethfutilities::fillHFCandidateTable(Lc, collisionLcIndex, products.storedLcsTable, products.storedLcParsTable, products.storedLcParExtrasTable, products.storedLcParDaughtersDummyTable, products.storedLcSelsTable, products.storedLcMlsTable, products.storedLcMlDughtersDummyTable, products.storedLcMcsTable, LcIndex); - - int32_t prong0Id = -1; - int32_t prong1Id = -1; - int32_t prong2Id = -1; - auto JtrackIndex = trackMapping.find(Lc.prong0Id()); - if (JtrackIndex != trackMapping.end()) { - prong0Id = JtrackIndex->second; - } - JtrackIndex = trackMapping.find(Lc.prong1Id()); - if (JtrackIndex != trackMapping.end()) { - prong1Id = JtrackIndex->second; - } - JtrackIndex = trackMapping.find(Lc.prong2Id()); - if (JtrackIndex != trackMapping.end()) { - prong2Id = JtrackIndex->second; - } - products.storedLcIdsTable(products.storedJCollisionsTable.lastIndex(), prong0Id, prong1Id, prong2Id); - } - } - - if (config.saveBplusTable) { - const auto lcCollisionsPerCollision = BplusCollisions.sliceBy(BplusCollisionsPerCollision, collision.globalIndex()); - int32_t collisionBplusIndex = -1; - for (const auto& lcCollisionPerCollision : lcCollisionsPerCollision) { // should only ever be one - jethfutilities::fillHFCollisionTable(lcCollisionPerCollision, products.storedBplusCollisionsTable, collisionBplusIndex); - products.storedBplusCollisionIdsTable(products.storedJCollisionsTable.lastIndex()); - BplusCollisionMapping.insert(std::make_pair(lcCollisionPerCollision.globalIndex(), products.storedBplusCollisionsTable.lastIndex())); - } - const auto lcsPerCollision = Bpluss.sliceBy(BplussPerCollision, collision.globalIndex()); - for (const auto& Bplus : lcsPerCollision) { - int32_t BplusIndex = -1; - jethfutilities::fillHFCandidateTable(Bplus, collisionBplusIndex, products.storedBplussTable, products.storedBplusParsTable, products.storedBplusParExtrasTable, products.storedBplusParD0sTable, products.storedBplusSelsTable, products.storedBplusMlsTable, products.storedBplusMlD0sTable, products.storedBplusMcsTable, BplusIndex); - - int32_t prong0Id = -1; - int32_t prong1Id = -1; - int32_t prong2Id = -1; - auto JtrackIndex = trackMapping.find(Bplus.prong0Id()); - if (JtrackIndex != trackMapping.end()) { - prong0Id = JtrackIndex->second; - } - JtrackIndex = trackMapping.find(Bplus.prong1Id()); - if (JtrackIndex != trackMapping.end()) { - prong1Id = JtrackIndex->second; - } - JtrackIndex = trackMapping.find(Bplus.prong2Id()); - if (JtrackIndex != trackMapping.end()) { - prong2Id = JtrackIndex->second; - } - products.storedBplusIdsTable(products.storedJCollisionsTable.lastIndex(), prong0Id, prong1Id, prong2Id); - } - } - - if (config.saveDielectronTable) { - const auto dielectronCollisionsPerCollision = DielectronCollisions.sliceBy(DielectronCollisionsPerCollision, collision.globalIndex()); - int32_t collisionDielectronIndex = -1; - for (const auto& dielectronCollisionPerCollision : dielectronCollisionsPerCollision) { // should only ever be one - jetdqutilities::fillDielectronCollisionTable(dielectronCollisionPerCollision, products.storedDielectronCollisionsTable, collisionDielectronIndex); - products.storedDielectronCollisionIdsTable(products.storedJCollisionsTable.lastIndex()); - // D0CollisionMapping.insert(std::make_pair(d0CollisionPerCollision.globalIndex(), products.storedD0CollisionsTable.lastIndex())); // if DielectronMCCollisions are indexed to Dielectron Collisions then this can be added - } - const auto dielectronsPerCollision = Dielectrons.sliceBy(DielectronsPerCollision, collision.globalIndex()); - for (const auto& Dielectron : dielectronsPerCollision) { - int32_t DielectronIndex = -1; - jetdqutilities::fillDielectronCandidateTable(Dielectron, collisionDielectronIndex, products.storedDielectronsTable, DielectronIndex); + PROCESS_SWITCH(JetDerivedDataWriter, processLcMCP, "write out Lc mcp output tables", false); - int32_t prong0Id = -1; - int32_t prong1Id = -1; - auto JtrackIndex = trackMapping.find(Dielectron.prong0Id()); - if (JtrackIndex != trackMapping.end()) { - prong0Id = JtrackIndex->second; - } - JtrackIndex = trackMapping.find(Dielectron.prong1Id()); - if (JtrackIndex != trackMapping.end()) { - prong1Id = JtrackIndex->second; - } - products.storedDielectronIdsTable(products.storedJCollisionsTable.lastIndex(), prong0Id, prong1Id); - } - } + void processBplusMCP(soa::Join const& mcCollisions, aod::McCollisionsBplus const& BplusMcCollisions, aod::CandidatesBplusMCP const& BplusParticles) + { + bplusMcCollisionMapping.clear(); + bplusMcCollisionMapping.resize(BplusMcCollisions.size(), -1); + for (auto const& mcCollision : mcCollisions) { + if (mcCollision.isMcCollisionSelected()) { + const auto bplusMcCollisionsPerMcCollision = BplusMcCollisions.sliceBy(BplusMcCollisionsPerMcCollision, mcCollision.globalIndex()); + for (const auto& bplusMcCollisionPerMcCollision : bplusMcCollisionsPerMcCollision) { // should only ever be one + jethfutilities::fillHFMcCollisionTable(bplusMcCollisionPerMcCollision, products.storedBplusMcCollisionsTable); + products.storedBplusMcCollisionIdsTable(mcCollisionMapping[mcCollision.globalIndex()]); + bplusMcCollisionMapping[bplusMcCollisionPerMcCollision.globalIndex()] = products.storedBplusMcCollisionsTable.lastIndex(); + } + const auto bplusParticlesPerMcCollision = BplusParticles.sliceBy(BplusParticlesPerMcCollision, mcCollision.globalIndex()); + for (const auto& BplusParticle : bplusParticlesPerMcCollision) { + jethfutilities::fillHFCandidateMcTable(BplusParticle, products.storedBplusMcCollisionsTable.lastIndex(), products.storedBplusParticlesTable); + products.storedBplusParticleIdsTable(mcCollisionMapping[mcCollision.globalIndex()], particleMapping[BplusParticle.mcParticleId()]); } + } + } + } + PROCESS_SWITCH(JetDerivedDataWriter, processBplusMCP, "write out Bplus mcp output tables", false); - if (config.saveD0Table) { - const auto d0McCollisionsPerMcCollision = D0McCollisions.sliceBy(D0McCollisionsPerMcCollision, mcCollision.globalIndex()); - for (const auto& d0McCollisionPerMcCollision : d0McCollisionsPerMcCollision) { // should just be one - std::vector d0CollisionIDs; - for (auto const& d0CollisionPerMcCollision : d0McCollisionPerMcCollision.template hfCollBases_as()) { - auto d0CollisionIndex = D0CollisionMapping.find(d0CollisionPerMcCollision.globalIndex()); - if (d0CollisionIndex != D0CollisionMapping.end()) { - d0CollisionIDs.push_back(d0CollisionIndex->second); - } - } - products.storedD0McCollisionsMatchingTable(d0CollisionIDs); - } - } + void processDielectronMCP(soa::Join::iterator const& mcCollision, aod::JMcParticles const&, aod::McCollisionsDielectron const& DielectronMcCollisions, aod::CandidatesDielectronMCP const& DielectronParticles) + { + if (mcCollision.isMcCollisionSelected()) { - if (config.saveLcTable) { - const auto lcMcCollisionsPerMcCollision = LcMcCollisions.sliceBy(LcMcCollisionsPerMcCollision, mcCollision.globalIndex()); - for (const auto& lcMcCollisionPerMcCollision : lcMcCollisionsPerMcCollision) { // should just be one - std::vector lcCollisionIDs; - for (auto const& lcCollisionPerMcCollision : lcMcCollisionPerMcCollision.template hfCollBases_as()) { - auto lcCollisionIndex = LcCollisionMapping.find(lcCollisionPerMcCollision.globalIndex()); - if (lcCollisionIndex != LcCollisionMapping.end()) { - lcCollisionIDs.push_back(lcCollisionIndex->second); - } - } - products.storedLcMcCollisionsMatchingTable(lcCollisionIDs); + const auto dielectronMcCollisionsPerMcCollision = DielectronMcCollisions.sliceBy(DielectronMcCollisionsPerMcCollision, mcCollision.globalIndex()); + for (const auto& dielectronMcCollisionPerMcCollision : dielectronMcCollisionsPerMcCollision) { // should only ever be one + jetdqutilities::fillDielectronMcCollisionTable(dielectronMcCollisionPerMcCollision, products.storedDielectronMcCollisionsTable); + products.storedDielectronMcCollisionIdsTable(mcCollisionMapping[mcCollision.globalIndex()]); + } + for (const auto& DielectronParticle : DielectronParticles) { + jetdqutilities::fillDielectronCandidateMcTable(DielectronParticle, products.storedDielectronMcCollisionsTable.lastIndex(), products.storedDielectronParticlesTable); + std::vector DielectronMothersIds; + int DielectronDaughtersId[2]; + if (DielectronParticle.has_mothers()) { + for (auto const& DielectronMother : DielectronParticle.template mothers_as()) { + DielectronMothersIds.push_back(particleMapping[DielectronMother.globalIndex()]); } } - - if (config.saveBplusTable) { - const auto lcMcCollisionsPerMcCollision = BplusMcCollisions.sliceBy(BplusMcCollisionsPerMcCollision, mcCollision.globalIndex()); - for (const auto& lcMcCollisionPerMcCollision : lcMcCollisionsPerMcCollision) { // should just be one - std::vector lcCollisionIDs; - for (auto const& lcCollisionPerMcCollision : lcMcCollisionPerMcCollision.template hfCollBases_as()) { - auto lcCollisionIndex = BplusCollisionMapping.find(lcCollisionPerMcCollision.globalIndex()); - if (lcCollisionIndex != BplusCollisionMapping.end()) { - lcCollisionIDs.push_back(lcCollisionIndex->second); - } + auto i = 0; + if (DielectronParticle.has_daughters()) { + for (auto const& DielectronDaughter : DielectronParticle.template daughters_as()) { + if (i > 1) { + break; } - products.storedBplusMcCollisionsMatchingTable(lcCollisionIDs); + DielectronDaughtersId[i] = particleMapping[DielectronDaughter.globalIndex()]; + i++; } } + products.storedDielectronParticleIdsTable(mcCollisionMapping[mcCollision.globalIndex()], particleMapping[DielectronParticle.mcParticleId()], DielectronMothersIds, DielectronDaughtersId); } } } - // process switch for output writing must be last - // to run after all jet selections - PROCESS_SWITCH(JetDerivedDataWriter, processStoreMC, "write out data output tables for mc", false); + PROCESS_SWITCH(JetDerivedDataWriter, processDielectronMCP, "write out Dielectron mcp output tables", false); - void processStoreMCP(soa::Join const& mcCollisions, soa::Join const& particles, aod::McCollisionsD0 const& D0McCollisions, aod::CandidatesD0MCP const& D0Particles, aod::McCollisionsLc const& LcMcCollisions, aod::CandidatesLcMCP const& LcParticles, aod::McCollisionsBplus const& BplusMcCollisions, aod::CandidatesBplusMCP const& BplusParticles, aod::McCollisionsDielectron const& DielectronMcCollisions, aod::CandidatesDielectronMCP const& DielectronParticles) + void processColllisonsMcCollisionLabel(soa::Join::iterator const& collision) { + if (collision.isCollisionSelected()) { + products.storedJMcCollisionsLabelTable(mcCollisionMapping[collision.mcCollisionId()]); + } + } + PROCESS_SWITCH(JetDerivedDataWriter, processColllisonsMcCollisionLabel, "write out collision mcCollision label output tables", false); - int particleTableIndex = 0; - for (auto mcCollision : mcCollisions) { - if (McCollisionFlag[mcCollision.globalIndex()]) { // you can also check if any of its detector level counterparts are correct - std::map paticleMapping; - - products.storedJMcCollisionsTable(mcCollision.posX(), mcCollision.posY(), mcCollision.posZ(), mcCollision.weight(), mcCollision.subGeneratorId()); - products.storedJMcCollisionsParentIndexTable(mcCollision.mcCollisionId()); - - const auto particlesPerMcCollision = particles.sliceBy(ParticlesPerMcCollision, mcCollision.globalIndex()); - - for (auto particle : particlesPerMcCollision) { - paticleMapping.insert(std::make_pair(particle.globalIndex(), particleTableIndex)); - particleTableIndex++; + void processTracksMcParticleLabel(soa::Join::iterator const& collision, soa::Join const& tracks) + { + if (collision.isCollisionSelected()) { + for (const auto& track : tracks) { + if (!trackSelection(track)) { + continue; } - for (auto particle : particlesPerMcCollision) { - std::vector mothersId; - int daughtersId[2]; - if (particle.has_mothers()) { - for (auto const& mother : particle.template mothers_as>()) { - auto JMotherIndex = paticleMapping.find(mother.globalIndex()); - if (JMotherIndex != paticleMapping.end()) { - mothersId.push_back(JMotherIndex->second); - } - } - } - auto i = 0; - if (particle.has_daughters()) { - for (auto const& daughter : particle.template daughters_as>()) { - if (i > 1) { - break; - } - auto JDaughterIndex = paticleMapping.find(daughter.globalIndex()); - if (JDaughterIndex != paticleMapping.end()) { - daughtersId[i] = JDaughterIndex->second; - } - i++; - } - } - products.storedJMcParticlesTable(products.storedJMcCollisionsTable.lastIndex(), o2::math_utils::detail::truncateFloatFraction(particle.pt(), precisionMomentumMask), o2::math_utils::detail::truncateFloatFraction(particle.eta(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(particle.phi(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(particle.y(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(particle.e(), precisionMomentumMask), particle.pdgCode(), particle.getGenStatusCode(), particle.getHepMCStatusCode(), particle.isPhysicalPrimary(), mothersId, daughtersId); - products.storedJParticlesParentIndexTable(particle.mcParticleId()); + if (track.has_mcParticle()) { + products.storedJMcTracksLabelTable(particleMapping[track.mcParticleId()]); + } else { + products.storedJMcTracksLabelTable(-1); } + } + } + } + PROCESS_SWITCH(JetDerivedDataWriter, processTracksMcParticleLabel, "write out track mcParticle label output tables", false); - if (config.saveD0Table) { - const auto d0McCollisionsPerMcCollision = D0McCollisions.sliceBy(D0McCollisionsPerMcCollision, mcCollision.globalIndex()); - int32_t mcCollisionD0Index = -1; - for (const auto& d0McCollisionPerMcCollision : d0McCollisionsPerMcCollision) { // should only ever be one - jethfutilities::fillHFMcCollisionTable(d0McCollisionPerMcCollision, products.storedD0McCollisionsTable, mcCollisionD0Index); - products.storedD0McCollisionIdsTable(products.storedJMcCollisionsTable.lastIndex()); - } - for (const auto& D0Particle : D0Particles) { - int32_t D0ParticleIndex = -1; - jethfutilities::fillHFCandidateMcTable(D0Particle, mcCollisionD0Index, products.storedD0ParticlesTable, D0ParticleIndex); - int32_t D0ParticleId = -1; - auto JParticleIndex = paticleMapping.find(D0Particle.mcParticleId()); - if (JParticleIndex != paticleMapping.end()) { - D0ParticleId = JParticleIndex->second; - } - products.storedD0ParticleIdsTable(products.storedJMcCollisionsTable.lastIndex(), D0ParticleId); - } - } - if (config.saveLcTable) { - const auto lcMcCollisionsPerMcCollision = LcMcCollisions.sliceBy(LcMcCollisionsPerMcCollision, mcCollision.globalIndex()); - int32_t mcCollisionLcIndex = -1; - for (const auto& lcMcCollisionPerMcCollision : lcMcCollisionsPerMcCollision) { // should only ever be one - jethfutilities::fillHFMcCollisionTable(lcMcCollisionPerMcCollision, products.storedLcMcCollisionsTable, mcCollisionLcIndex); - products.storedLcMcCollisionIdsTable(products.storedJMcCollisionsTable.lastIndex()); - } - for (const auto& LcParticle : LcParticles) { - int32_t LcParticleIndex = -1; - jethfutilities::fillHFCandidateMcTable(LcParticle, mcCollisionLcIndex, products.storedLcParticlesTable, LcParticleIndex); - int32_t LcParticleId = -1; - auto JParticleIndex = paticleMapping.find(LcParticle.mcParticleId()); - if (JParticleIndex != paticleMapping.end()) { - LcParticleId = JParticleIndex->second; - } - products.storedLcParticleIdsTable(products.storedJMcCollisionsTable.lastIndex(), LcParticleId); - } + void processClusterMcLabel(soa::Join::iterator const& collision, soa::Join const& clusters) + { + if (collision.isCollisionSelected()) { + for (const auto& cluster : clusters) { + std::vector clusterStoredJParticleIDs; + for (const auto& clusterParticleId : cluster.mcParticlesIds()) { + clusterStoredJParticleIDs.push_back(particleMapping[clusterParticleId]); + } + std::vector amplitudeA; + auto amplitudeASpan = cluster.amplitudeA(); + std::copy(amplitudeASpan.begin(), amplitudeASpan.end(), std::back_inserter(amplitudeA)); + products.storedJMcClustersLabelTable(clusterStoredJParticleIDs, amplitudeA); + } + } + } + PROCESS_SWITCH(JetDerivedDataWriter, processClusterMcLabel, "write out cluster mc label output tables", false); + + void processD0McCollisionMatch(soa::Join::iterator const& mcCollision, soa::Join const& D0McCollisions, aod::CollisionsD0 const&) + { + if (mcCollision.isMcCollisionSelected()) { + for (const auto& D0McCollision : D0McCollisions) { // should just be one + std::vector d0CollisionIDs; + for (auto const& d0CollisionPerMcCollision : D0McCollision.hfCollBases_as()) { + d0CollisionIDs.push_back(d0McCollisionMapping[d0CollisionPerMcCollision.globalIndex()]); } - if (config.saveBplusTable) { - const auto lcMcCollisionsPerMcCollision = BplusMcCollisions.sliceBy(BplusMcCollisionsPerMcCollision, mcCollision.globalIndex()); - int32_t mcCollisionBplusIndex = -1; - for (const auto& lcMcCollisionPerMcCollision : lcMcCollisionsPerMcCollision) { // should only ever be one - jethfutilities::fillHFMcCollisionTable(lcMcCollisionPerMcCollision, products.storedBplusMcCollisionsTable, mcCollisionBplusIndex); - products.storedBplusMcCollisionIdsTable(products.storedJMcCollisionsTable.lastIndex()); - } - for (const auto& BplusParticle : BplusParticles) { - int32_t BplusParticleIndex = -1; - jethfutilities::fillHFCandidateMcTable(BplusParticle, mcCollisionBplusIndex, products.storedBplusParticlesTable, BplusParticleIndex); - int32_t BplusParticleId = -1; - auto JParticleIndex = paticleMapping.find(BplusParticle.mcParticleId()); - if (JParticleIndex != paticleMapping.end()) { - BplusParticleId = JParticleIndex->second; - } - products.storedBplusParticleIdsTable(products.storedJMcCollisionsTable.lastIndex(), BplusParticleId); - } + products.storedD0McCollisionsMatchingTable(d0CollisionIDs); + } + } + } + PROCESS_SWITCH(JetDerivedDataWriter, processD0McCollisionMatch, "write out D0 McCollision collision label output tables", false); + + void processLcMcCollisionMatch(soa::Join::iterator const& mcCollision, soa::Join const& LcMcCollisions, aod::CollisionsLc const&) + { + if (mcCollision.isMcCollisionSelected()) { + for (const auto& LcMcCollision : LcMcCollisions) { // should just be one + std::vector lcCollisionIDs; + for (auto const& lcCollisionPerMcCollision : LcMcCollision.hfCollBases_as()) { + lcCollisionIDs.push_back(lcMcCollisionMapping[lcCollisionPerMcCollision.globalIndex()]); } - if (config.saveDielectronTable) { - const auto dielectronMcCollisionsPerMcCollision = DielectronMcCollisions.sliceBy(DielectronMcCollisionsPerMcCollision, mcCollision.globalIndex()); - int32_t mcCollisionDielectronIndex = -1; - for (const auto& dielectronMcCollisionPerMcCollision : dielectronMcCollisionsPerMcCollision) { // should only ever be one - jetdqutilities::fillDielectronMcCollisionTable(dielectronMcCollisionPerMcCollision, products.storedDielectronMcCollisionsTable, mcCollisionDielectronIndex); - products.storedDielectronMcCollisionIdsTable(products.storedJMcCollisionsTable.lastIndex()); - } - for (const auto& DielectronParticle : DielectronParticles) { - int32_t DielectronParticleIndex = -1; - jetdqutilities::fillDielectronCandidateMcTable(DielectronParticle, mcCollisionDielectronIndex, products.storedDielectronParticlesTable, DielectronParticleIndex); - int32_t DielectronParticleId = -1; - auto JParticleIndex = paticleMapping.find(DielectronParticle.mcParticleId()); - if (JParticleIndex != paticleMapping.end()) { - DielectronParticleId = JParticleIndex->second; - } - std::vector DielectronMothersId; - int DielectronDaughtersId[2]; - if (DielectronParticle.has_mothers()) { - for (auto const& DielectronMother : DielectronParticle.template mothers_as>()) { - auto JDielectronMotherIndex = paticleMapping.find(DielectronMother.globalIndex()); - if (JDielectronMotherIndex != paticleMapping.end()) { - DielectronMothersId.push_back(JDielectronMotherIndex->second); - } - } - } - auto i = 0; - if (DielectronParticle.has_daughters()) { - for (auto const& DielectronDaughter : DielectronParticle.template daughters_as>()) { - if (i > 1) { - break; - } - auto JDielectronDaughterIndex = paticleMapping.find(DielectronDaughter.globalIndex()); - if (JDielectronDaughterIndex != paticleMapping.end()) { - DielectronDaughtersId[i] = JDielectronDaughterIndex->second; - } - i++; - } - } - products.storedDielectronParticleIdsTable(products.storedJMcCollisionsTable.lastIndex(), DielectronParticleId, DielectronMothersId, DielectronDaughtersId); - } + products.storedLcMcCollisionsMatchingTable(lcCollisionIDs); + } + } + } + PROCESS_SWITCH(JetDerivedDataWriter, processLcMcCollisionMatch, "write out Lc McCollision collision label output tables", false); + + void processBplusMcCollisionMatch(soa::Join::iterator const& mcCollision, soa::Join const& BplusMcCollisions, aod::CollisionsBplus const&) + { + if (mcCollision.isMcCollisionSelected()) { + for (const auto& BplusMcCollision : BplusMcCollisions) { // should just be one + std::vector bplusCollisionIDs; + for (auto const& bplusCollisionPerMcCollision : BplusMcCollision.hfCollBases_as()) { + bplusCollisionIDs.push_back(bplusMcCollisionMapping[bplusCollisionPerMcCollision.globalIndex()]); } + products.storedBplusMcCollisionsMatchingTable(bplusCollisionIDs); } } } - // process switch for output writing must be last - // to run after all jet selections - PROCESS_SWITCH(JetDerivedDataWriter, processStoreMCP, "write out data output tables for mcp", false); + PROCESS_SWITCH(JetDerivedDataWriter, processBplusMcCollisionMatch, "write out Bplus McCollision collision label output tables", false); }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) diff --git a/PWGJE/Tasks/jetSubstructureHFOutput.cxx b/PWGJE/Tasks/jetSubstructureHFOutput.cxx index 667ad11ef65..fd2c3e327c8 100644 --- a/PWGJE/Tasks/jetSubstructureHFOutput.cxx +++ b/PWGJE/Tasks/jetSubstructureHFOutput.cxx @@ -15,6 +15,9 @@ // #include +#include +#include +#include #include "Framework/AnalysisTask.h" #include "Framework/AnalysisDataModel.h" @@ -203,21 +206,21 @@ struct JetSubstructureHFOutputTask { continue; } int32_t candidateCollisionIndex = -1; - int32_t candidateIndex = -1; if constexpr (isMCP) { auto hfMcCollisionIndex = candidateMcCollisionMapping.find(jetcandidateutilities::getMcCandidateCollisionId(candidate)); if (hfMcCollisionIndex != candidateMcCollisionMapping.end()) { candidateCollisionIndex = hfMcCollisionIndex->second; } - jetcandidateutilities::fillCandidateMcTable(candidate, candidateCollisionIndex, hfParticlesTable, candidateIndex); + jetcandidateutilities::fillCandidateMcTable(candidate, candidateCollisionIndex, hfParticlesTable); + candidateMap.insert(std::make_pair(candidate.globalIndex(), hfParticlesTable.lastIndex())); } else { auto hfCollisionIndex = candidateCollisionMapping.find(jetcandidateutilities::getCandidateCollisionId(candidate)); if (hfCollisionIndex != candidateCollisionMapping.end()) { candidateCollisionIndex = hfCollisionIndex->second; } - jetcandidateutilities::fillCandidateTable(candidate, candidateCollisionIndex, candidateTable, candidateParsTable, candidateParExtrasTable, candidateParsDaughterTable, candidateSelsTable, candidateMlsTable, candidateMlsDaughterTable, candidateMcsTable, candidateIndex); + jetcandidateutilities::fillCandidateTable(candidate, candidateCollisionIndex, candidateTable, candidateParsTable, candidateParExtrasTable, candidateParsDaughterTable, candidateSelsTable, candidateMlsTable, candidateMlsDaughterTable, candidateMcsTable); + candidateMap.insert(std::make_pair(candidate.globalIndex(), candidateTable.lastIndex())); } - candidateMap.insert(std::make_pair(candidate.globalIndex(), candidateIndex)); } } } @@ -331,13 +334,12 @@ struct JetSubstructureHFOutputTask { for (const auto& collision : collisions) { if (collisionFlag[collision.globalIndex()]) { const auto hfCollisionsPerCollision = jetcandidateutilities::slicedPerCandidateCollision(hfCollisions, candidates, collision, D0CollisionsPerCollision, LcCollisionsPerCollision, BplusCollisionsPerCollision, DielectronCollisionsPerCollision); // add Bplus later - int32_t candidateCollisionIndex = -1; for (const auto& hfCollisionPerCollision : hfCollisionsPerCollision) { // should only ever be one auto hfCollisionTableIndex = candidateCollisionMapping.find(hfCollisionPerCollision.globalIndex()); if (hfCollisionTableIndex != candidateCollisionMapping.end()) { continue; } - jetcandidateutilities::fillCandidateCollisionTable(hfCollisionPerCollision, candidates, hfCollisionsTable, candidateCollisionIndex); + jetcandidateutilities::fillCandidateCollisionTable(hfCollisionPerCollision, candidates, hfCollisionsTable); candidateCollisionMapping.insert(std::make_pair(hfCollisionPerCollision.globalIndex(), hfCollisionsTable.lastIndex())); } } @@ -347,13 +349,12 @@ struct JetSubstructureHFOutputTask { for (const auto& mcCollision : mcCollisions) { if (mcCollisionFlag[mcCollision.globalIndex()]) { const auto hfMcCollisionsPerMcCollision = jetcandidateutilities::slicedPerCandidateCollision(hfMcCollisions, candidatesMCP, mcCollision, D0McCollisionsPerMcCollision, LcMcCollisionsPerMcCollision, BplusMcCollisionsPerMcCollision, DielectronMcCollisionsPerMcCollision); // add Bplus later - int32_t candidateMcCollisionIndex = -1; for (const auto& hfMcCollisionPerMcCollision : hfMcCollisionsPerMcCollision) { // should only ever be one auto hfMcCollisionTableIndex = candidateMcCollisionMapping.find(hfMcCollisionPerMcCollision.globalIndex()); if (hfMcCollisionTableIndex != candidateMcCollisionMapping.end()) { continue; } - jetcandidateutilities::fillCandidateMcCollisionTable(hfMcCollisionPerMcCollision, candidatesMCP, hfMcCollisionsTable, candidateMcCollisionIndex); + jetcandidateutilities::fillCandidateMcCollisionTable(hfMcCollisionPerMcCollision, candidatesMCP, hfMcCollisionsTable); candidateMcCollisionMapping.insert(std::make_pair(hfMcCollisionPerMcCollision.globalIndex(), hfMcCollisionsTable.lastIndex())); if constexpr (!isMCPOnly && (jethfutilities::isHFTable

() || jethfutilities::isHFMcTable())) { // the matching of mcCollision to Collision is only done for HF tables std::vector hfCollisionIDs; diff --git a/PWGJE/Tasks/jetSubstructureOutput.cxx b/PWGJE/Tasks/jetSubstructureOutput.cxx index ca20d891b95..602c6526523 100644 --- a/PWGJE/Tasks/jetSubstructureOutput.cxx +++ b/PWGJE/Tasks/jetSubstructureOutput.cxx @@ -14,6 +14,11 @@ /// \author Nima Zardoshti // +#include +#include +#include +#include + #include "Framework/ASoA.h" #include "Framework/AnalysisDataModel.h" #include "Framework/AnalysisTask.h"