From 612971cfdf0659d58cb5b065e5a3aef7589f9e6d Mon Sep 17 00:00:00 2001 From: Seul I Jeong Date: Tue, 17 Nov 2026 23:31:21 +0900 Subject: [PATCH] [PWGHF] Add signed-DCA histograms and PV refit in taskSingleElectron - Add DCA_xy x charge x sign(B) histograms for data - Add processDataPvRefit with PV refit QA --- PWGHF/HFL/Tasks/CMakeLists.txt | 2 +- PWGHF/HFL/Tasks/taskSingleElectron.cxx | 163 ++++++++++++++++++++++++- 2 files changed, 162 insertions(+), 3 deletions(-) diff --git a/PWGHF/HFL/Tasks/CMakeLists.txt b/PWGHF/HFL/Tasks/CMakeLists.txt index 925dc4e831d..b5cc802cc39 100644 --- a/PWGHF/HFL/Tasks/CMakeLists.txt +++ b/PWGHF/HFL/Tasks/CMakeLists.txt @@ -21,7 +21,7 @@ o2physics_add_dpl_workflow(task-muon-charm-beauty-separation o2physics_add_dpl_workflow(task-single-electron SOURCES taskSingleElectron.cxx - PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2::DetectorsVertexing COMPONENT_NAME Analysis) o2physics_add_dpl_workflow(task-single-muon diff --git a/PWGHF/HFL/Tasks/taskSingleElectron.cxx b/PWGHF/HFL/Tasks/taskSingleElectron.cxx index 3a66413094f..4f60da2373f 100644 --- a/PWGHF/HFL/Tasks/taskSingleElectron.cxx +++ b/PWGHF/HFL/Tasks/taskSingleElectron.cxx @@ -13,12 +13,21 @@ /// \brief task for electrons from heavy-flavour hadron decays /// \author Jonghan Park (Jeonbuk National University), Seul I Jeong (Pusan National University) +#include "PWGHF/DataModel/AliasTables.h" +#include "PWGHF/Utils/utilsBfieldCCDB.h" + +#include "Common/Core/trackUtilities.h" #include "Common/DataModel/EventSelection.h" #include "Common/DataModel/PIDResponseTOF.h" #include "Common/DataModel/PIDResponseTPC.h" #include "Common/DataModel/TrackSelectionTables.h" +#include #include +#include +#include +#include +#include #include #include #include @@ -29,10 +38,16 @@ #include #include #include +#include #include +#include +#include +#include #include +#include +#include using namespace o2; using namespace o2::constants::math; @@ -101,21 +116,37 @@ struct HfTaskSingleElectron { Configurable nSigmaTpcHadronMax{"nSigmaTpcHadronMax", -3, "max of tpc hadron nsigma"}; Configurable nSigmaTpcHadronMin{"nSigmaTpcHadronMin", -5, "min of tpc hadron nsigma"}; + Configurable bFieldSign{"bFieldSign", 1.f, "sign of the L3 magnetic field (+1 or -1), used in DCA_xy x charge x sign(B)"}; + + // PV refit (processDataPvRefit) + Configurable ccdbUrl{"ccdbUrl", "http://alice-ccdb.cern.ch", "URL of the CCDB repository"}; + Configurable ccdbPathLut{"ccdbPathLut", "GLO/Param/MatLUT", "CCDB path of the material LUT"}; + Configurable ccdbPathGrpMag{"ccdbPathGrpMag", "GLO/Config/GRPMagField", "CCDB path of the GRPMagField object"}; + // SliceCache SliceCache cache; + Service ccdb{}; + o2::base::MatLayerCylSet* lut{}; + o2::vertexing::PVertexer vertexer; + int runNumber{0}; + // using declarations using MyCollisions = soa::Join; using TracksEl = soa::Join; using McTracksEl = soa::Join; + using AllTracks = aod::TracksWCovDcaExtra; // Filter Filter collZFilter = nabs(aod::collision::posZ) < posZMax; // Partition + Partition pvContributors = ((aod::track::flags & static_cast(aod::track::PVContributor)) == static_cast(aod::track::PVContributor)); // ConfigurableAxis ConfigurableAxis axisPtEl{"axisPtEl", {VARIABLE_WIDTH, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.f, 1.1f, 1.2f, 1.3f, 1.4f, 1.5f, 1.75f, 2.0f, 2.25f, 2.5f, 2.75f, 3.f, 3.5f, 4.0f, 5.0f, 6.0f, 8.0f, 10.0f}, "electron pt bins"}; + ConfigurableAxis axisDcaSigned{"axisDcaSigned", {4000, -0.2, 0.2}, "DCA_xy x charge x sign(B) bins (cm)"}; + ConfigurableAxis axisNContrib{"axisNContrib", {VARIABLE_WIDTH, 0., 5., 10., 15., 20., 25., 30., 40., 50., 60., 80., 100., 150., 250.}, "number of PV contributors bins"}; // Histogram registry HistogramRegistry histos{"histos"}; @@ -191,6 +222,42 @@ struct HfTaskSingleElectron { histos.add("hDcaConv", "", kTH2D, {{axisPtEl}, {axisTrackIp}}); histos.add("hDcaHadron", "", kTH2D, {{axisPtEl}, {axisTrackIp}}); + // DCA_xy x q x sign(B) + const AxisSpec axisDcaSig{axisDcaSigned, "DCA_{xy} #times #it{q} #times sign(#it{B}) (cm)"}; + const AxisSpec axisNContribEvt{axisNContrib, "#it{N}_{contrib}"}; + histos.add("hDcaSignedTrack", "after electron identification;#it{p}_{T} (GeV/#it{c});DCA_{xy} #times #it{q} #times sign(#it{B}) (cm);#it{N}_{contrib}", kTH3D, {{axisPtEl}, {axisDcaSig}, {axisNContribEvt}}); + histos.add("hDcaSignedHadron", "TPC hadron band, before TOF selection;#it{p}_{T} (GeV/#it{c});DCA_{xy} #times #it{q} #times sign(#it{B}) (cm)", kTH2D, {{axisPtEl}, {axisDcaSig}}); + histos.add("hDcaSignedHadronAfterTofCut", "TPC hadron band, after TOF selection;#it{p}_{T} (GeV/#it{c});DCA_{xy} #times #it{q} #times sign(#it{B}) (cm)", kTH2D, {{axisPtEl}, {axisDcaSig}}); + + if (doprocessData && doprocessDataPvRefit) { + LOGF(fatal, "processData and processDataPvRefit cannot be enabled together"); + } + if (doprocessDataPvRefit) { + histos.add("hDcaSignedTrackPvRefit", "after electron identification, PV refit;#it{p}_{T} (GeV/#it{c});DCA_{xy} #times #it{q} #times sign(#it{B}) (cm);#it{N}_{contrib}", kTH3D, {{axisPtEl}, {axisDcaSig}, {axisNContribEvt}}); + histos.add("hDcaSignedHadronPvRefit", "TPC hadron band, before TOF selection, PV refit;#it{p}_{T} (GeV/#it{c});DCA_{xy} #times #it{q} #times sign(#it{B}) (cm)", kTH2D, {{axisPtEl}, {axisDcaSig}}); + histos.add("hDcaSignedHadronAfterTofCutPvRefit", "TPC hadron band, after TOF selection, PV refit;#it{p}_{T} (GeV/#it{c});DCA_{xy} #times #it{q} #times sign(#it{B}) (cm)", kTH2D, {{axisPtEl}, {axisDcaSig}}); + // PV refit QA + const AxisSpec axisCollisionNContrib{1000, 0, 1000, "Number of contributors"}; + const AxisSpec axisPvRefitDeltaX{1000, -0.05f, 0.05f, "#Delta x_{PV} (cm)"}; + const AxisSpec axisPvRefitDeltaY{1000, -0.05f, 0.05f, "#Delta y_{PV} (cm)"}; + const AxisSpec axisPvRefitDeltaZ{1000, -0.05f, 0.05f, "#Delta z_{PV} (cm)"}; + histos.add("PvRefit/hVerticesPerTrack", "", kTH1D, {{3, 0.5f, 3.5f, ""}}); + histos.add("PvRefit/hPvDeltaXvsNContrib", "", kTH2D, {axisCollisionNContrib, axisPvRefitDeltaX}); + histos.add("PvRefit/hPvDeltaYvsNContrib", "", kTH2D, {axisCollisionNContrib, axisPvRefitDeltaY}); + histos.add("PvRefit/hPvDeltaZvsNContrib", "", kTH2D, {axisCollisionNContrib, axisPvRefitDeltaZ}); + histos.add("PvRefit/hChi2vsNContrib", "", kTH2D, {axisCollisionNContrib, {102, -1.5, 100.5, "#chi^{2} PV refit"}}); + histos.add("PvRefit/hPvRefitXChi2Minus1", "PV refit with #it{#chi}^{2}==#minus1", kTH2D, {{100, -20.f, 20.f}, {100, -2.f, 2.f}}); + histos.add("PvRefit/hPvRefitYChi2Minus1", "PV refit with #it{#chi}^{2}==#minus1", kTH2D, {{100, -20.f, 20.f}, {100, -2.f, 2.f}}); + histos.add("PvRefit/hPvRefitZChi2Minus1", "PV refit with #it{#chi}^{2}==#minus1", kTH2D, {{100, -20.f, 20.f}, {100, -2.f, 2.f}}); + histos.add("PvRefit/hNContribPvRefitNotDoable", "N. contrib for PV refit not doable", kTH1D, {axisCollisionNContrib}); + histos.add("PvRefit/hNContribPvRefitChi2Minus1", "N. contrib for PV refit #it{#chi}^{2}==#minus1", kTH1D, {axisCollisionNContrib}); + ccdb->setURL(ccdbUrl); + ccdb->setCaching(true); + ccdb->setLocalObjectValidityChecking(); + lut = o2::base::MatLayerCylSet::rectifyPtrFromFile(ccdb->get(ccdbPathLut)); + o2::conf::ConfigurableParam::updateFromString("pvertexer.useMeanVertexConstraint=false"); + } + // QA plots for MC histos.add("hPdgC", "", kTH1D, {{10001, -0.5, 10000.5}}); histos.add("hPdgB", "", kTH1D, {{10001, -0.5, 10000.5}}); @@ -515,8 +582,8 @@ struct HfTaskSingleElectron { return Else; } - void processData(soa::Filtered::iterator const& collision, - TracksEl const& tracks) + template + void runData(TCollision const& collision, TTracks const& tracks) { float const flagAnalysedEvt = 0.5; @@ -531,6 +598,27 @@ struct HfTaskSingleElectron { histos.fill(HIST("hVtxZ"), collision.posZ()); histos.fill(HIST("hNEvents"), flagAnalysedEvt); + // PV refit: vertexer per collision + std::vector pvContribGlobId{}; + std::vector pvContribTrackParCov{}; + o2::dataformats::VertexBase primVtx; + bool pvRefitDoable = false; + if constexpr (DoPvRefit) { + initCCDB(collision.template bc_as(), runNumber, ccdb, ccdbPathGrpMag, lut, false); + auto pvContribColl = pvContributors->sliceByCached(aod::track::collisionId, collision.globalIndex(), cache); + for (const auto& contributor : pvContribColl) { + pvContribGlobId.push_back(contributor.globalIndex()); + pvContribTrackParCov.push_back(getTrackParCov(contributor)); + } + primVtx.setX(collision.posX()); + primVtx.setY(collision.posY()); + primVtx.setZ(collision.posZ()); + primVtx.setCov(collision.covXX(), collision.covXY(), collision.covYY(), collision.covXZ(), collision.covYZ(), collision.covZZ()); + vertexer.init(); + pvRefitDoable = vertexer.prepareVertexRefit(pvContribTrackParCov, primVtx); + } + std::vector pvContribUsed(pvContribGlobId.size(), true); + for (const auto& track : tracks) { fillTrackQaPreCut(track); @@ -554,12 +642,64 @@ struct HfTaskSingleElectron { histos.fill(HIST("hTpcNSigP"), track.p(), track.tpcNSigmaEl()); histos.fill(HIST("hTpcNSigPt"), track.pt(), track.tpcNSigmaEl()); + double const dcaSigned = track.dcaXY() * track.sign() * bFieldSign; + float dcaXYPvRefit = track.dcaXY(); + bool pvRefitDone = false; + [[maybe_unused]] auto getDcaSignedPvRefit = [&]() -> double { + if (!pvRefitDone) { + pvRefitDone = true; + const auto it = std::find(pvContribGlobId.begin(), pvContribGlobId.end(), track.globalIndex()); + if (track.isPVContributor() && it != pvContribGlobId.end()) { + histos.fill(HIST("PvRefit/hVerticesPerTrack"), 1); + if (!pvRefitDoable) { + histos.fill(HIST("PvRefit/hNContribPvRefitNotDoable"), collision.numContrib()); + } else { + histos.fill(HIST("PvRefit/hVerticesPerTrack"), 2); + const auto entry = std::distance(pvContribGlobId.begin(), it); + pvContribUsed[entry] = false; + const auto primVtxRefitted = vertexer.refitVertex(pvContribUsed, primVtx); + pvContribUsed[entry] = true; + histos.fill(HIST("PvRefit/hChi2vsNContrib"), primVtxRefitted.getNContributors(), primVtxRefitted.getChi2()); + if (primVtxRefitted.getChi2() < 0) { + histos.fill(HIST("PvRefit/hPvRefitXChi2Minus1"), primVtxRefitted.getX(), collision.posX()); + histos.fill(HIST("PvRefit/hPvRefitYChi2Minus1"), primVtxRefitted.getY(), collision.posY()); + histos.fill(HIST("PvRefit/hPvRefitZChi2Minus1"), primVtxRefitted.getZ(), collision.posZ()); + histos.fill(HIST("PvRefit/hNContribPvRefitChi2Minus1"), collision.numContrib()); + } else { + histos.fill(HIST("PvRefit/hVerticesPerTrack"), 3); + histos.fill(HIST("PvRefit/hPvDeltaXvsNContrib"), primVtxRefitted.getNContributors(), primVtx.getX() - primVtxRefitted.getX()); + histos.fill(HIST("PvRefit/hPvDeltaYvsNContrib"), primVtxRefitted.getNContributors(), primVtx.getY() - primVtxRefitted.getY()); + histos.fill(HIST("PvRefit/hPvDeltaZvsNContrib"), primVtxRefitted.getNContributors(), primVtx.getZ() - primVtxRefitted.getZ()); + auto trackPar = getTrackPar(track); + std::array dcaInfo{-999.f, -999.f}; + if (o2::base::Propagator::Instance()->propagateToDCABxByBz({primVtxRefitted.getX(), primVtxRefitted.getY(), primVtxRefitted.getZ()}, trackPar, 2.f, o2::base::Propagator::MatCorrType::USEMatCorrNONE, &dcaInfo)) { + dcaXYPvRefit = dcaInfo[0]; + } + } + } + } + } + return dcaXYPvRefit * track.sign() * bFieldSign; + }; + if (track.tpcNSigmaEl() < nSigmaTpcHadronMax && track.tpcNSigmaEl() > nSigmaTpcHadronMin) { + histos.fill(HIST("hDcaSignedHadron"), track.pt(), dcaSigned); + if constexpr (DoPvRefit) { + histos.fill(HIST("hDcaSignedHadronPvRefit"), track.pt(), getDcaSignedPvRefit()); + } + } + if (std::abs(track.tofNSigmaEl()) > nSigmaTofMax) { continue; } histos.fill(HIST("hTofNSigPtQA"), track.pt(), track.tofNSigmaEl()); histos.fill(HIST("hTpcNSigPAfterTofCut"), track.p(), track.tpcNSigmaEl()); histos.fill(HIST("hTpcNSigPtAfterTofCut"), track.pt(), track.tpcNSigmaEl()); + if (track.tpcNSigmaEl() < nSigmaTpcHadronMax && track.tpcNSigmaEl() > nSigmaTpcHadronMin) { + histos.fill(HIST("hDcaSignedHadronAfterTofCut"), track.pt(), dcaSigned); + if constexpr (DoPvRefit) { + histos.fill(HIST("hDcaSignedHadronAfterTofCutPvRefit"), track.pt(), getDcaSignedPvRefit()); + } + } if (track.tpcNSigmaEl() < nSigmaTpcMin || track.tpcNSigmaEl() > nSigmaTpcMax) { continue; @@ -573,10 +713,29 @@ struct HfTaskSingleElectron { histos.fill(HIST("hTpcNSigPtQA"), track.pt(), track.tpcNSigmaEl()); histos.fill(HIST("hDcaTrack"), track.pt(), track.dcaXY()); + histos.fill(HIST("hDcaSignedTrack"), track.pt(), dcaSigned, collision.numContrib()); + if constexpr (DoPvRefit) { + histos.fill(HIST("hDcaSignedTrackPvRefit"), track.pt(), getDcaSignedPvRefit(), collision.numContrib()); + } } } + + void processData(soa::Filtered::iterator const& collision, + TracksEl const& tracks) + { + runData(collision, tracks); + } PROCESS_SWITCH(HfTaskSingleElectron, processData, "For real data", true); + void processDataPvRefit(soa::Filtered::iterator const& collision, + TracksEl const& tracks, + AllTracks const&, + aod::BCsWithTimestamps const&) + { + runData(collision, tracks); + } + PROCESS_SWITCH(HfTaskSingleElectron, processDataPvRefit, "For real data, also with the DCA to the PV refitted without the track", false); + void processMc(soa::Filtered::iterator const& collision, McTracksEl const& tracks, aod::McParticles const&)