From 3254b2b44eab2257df83cc7073a8207fca915b9d Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Thu, 22 Jan 2026 11:30:16 +0900 Subject: [PATCH 01/12] Being developing mult of b-jet --- PWGJE/Tasks/bjetMultiplicity.cxx | 565 +++++++++++++++++++++++++++++++ 1 file changed, 565 insertions(+) create mode 100644 PWGJE/Tasks/bjetMultiplicity.cxx diff --git a/PWGJE/Tasks/bjetMultiplicity.cxx b/PWGJE/Tasks/bjetMultiplicity.cxx new file mode 100644 index 00000000000..bf84d972450 --- /dev/null +++ b/PWGJE/Tasks/bjetMultiplicity.cxx @@ -0,0 +1,565 @@ +// 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 bjetMultiplicity.cxx +/// \brief bjet multiplicity analysis +/// +/// \author Hanseo Park + +#include "PWGJE/Core/JetDerivedDataUtilities.h" +#include "PWGJE/Core/JetFindingUtilities.h" +#include "PWGJE/Core/JetTaggingUtilities.h" +#include "PWGJE/DataModel/Jet.h" +#include "PWGJE/DataModel/JetReducedData.h" +#include "PWGJE/DataModel/JetTagging.h" + +#include "Common/DataModel/Multiplicity.h" + +#include "Framework/ASoA.h" +#include "Framework/AnalysisDataModel.h" +#include "Framework/AnalysisTask.h" +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; + +template +struct BjetMultTask { + + // task on/off configuration + Configurable fillGeneralSVQA{"fillGeneralSVQA", true, "process of general QA for sv"}; + Configurable fillSVxyz{"fillSVxyz", true, "process of decay lenngth of xyz for sv"}; + + // Cut configuration + Configurable vertexZCut{"vertexZCut", 10.0f, "Accepted z-vertex range"}; + Configurable> trackCuts{"trackCuts", std::vector{0.15, 100.0, -0.9, 0.9}, "Track cuts: ptMin, ptMax, etaMin, etaMax"}; + Configurable trackDcaXYMax{"trackDcaXYMax", 1, "minimum DCA xy acceptance for tracks [cm]"}; + Configurable trackDcaZMax{"trackDcaZMax", 2, "minimum DCA z acceptance for tracks [cm]"}; + Configurable maxDeltaR{"maxDeltaR", 0.25, "maximum distance of jet axis from flavour initiating parton"}; + Configurable> jetEtaCuts{"jetEtaCuts", std::vector{-99.0, 99.0}, "Jet cuts: etaMin, etaMax"}; + Configurable> prongCuts{"prongCuts", std::vector{1, 100, 100, 100, 0.008, 1}, "prong cuts: chi2PCAMin, chi2PCAMax, sigmaLxyMax, sigmaLxyzMax, IPxyMin, IPxyMax"}; + Configurable svDispersionMax{"svDispersionMax", 0.03f, "maximum dispersion of sv"}; + Configurable numFlavourSpecies{"numFlavourSpecies", 6, "number of jet flavour species"}; + Configurable numOrder{"numOrder", 6, "number of ordering"}; + Configurable pTHatMaxMCD{"pTHatMaxMCD", 999.0, "maximum fraction of hard scattering for jet acceptance in detector MC"}; + Configurable pTHatMaxMCP{"pTHatMaxMCP", 999.0, "maximum fraction of hard scattering for jet acceptance in particle MC"}; + Configurable pTHatExponent{"pTHatExponent", 6.0, "exponent of the event weight for the calculation of pTHat"}; + Configurable pTHatAbsoluteMin{"pTHatAbsoluteMin", -99.0, "minimum value of pTHat"}; + Configurable jetAreaFractionMin{"jetAreaFractionMin", -99.0, "used to make a cut on the jet areas"}; + Configurable leadingConstituentPtMin{"leadingConstituentPtMin", -99.0, "minimum pT selection on jet constituent"}; + Configurable leadingConstituentPtMax{"leadingConstituentPtMax", 9999.0, "maximum pT selection on jet constituent"}; + Configurable checkMcCollisionIsMatched{"checkMcCollisionIsMatched", false, "0: count whole MCcollisions, 1: select MCcollisions which only have their correspond collisions"}; + Configurable trackOccupancyInTimeRangeMax{"trackOccupancyInTimeRangeMax", 999999, "maximum occupancy of tracks in neighbouring collisions in a given time range; only applied to reconstructed collisions (data and mcd jets), not mc collisions (mcp jets)"}; + Configurable trackOccupancyInTimeRangeMin{"trackOccupancyInTimeRangeMin", -999999, "minimum occupancy of tracks in neighbouring collisions in a given time range; only applied to reconstructed collisions (data and mcd jets), not mc collisions (mcp jets)"}; + Configurable meanFT0A{"meanFT0A", -1., "Mean value of FT0A signal"}; + Configurable meanFT0C{"meanFT0C", -1., "Mean value of FT0C signal"}; + + Configurable eventSelections{"eventSelections", "sel8", "choose event selection"}; + Configurable trackSelections{"trackSelections", "globalTracks", "set track selections"}; + + // Binning + ConfigurableAxis binJetFlavour{"binJetFlavour", {6, -0.5, 5.5}, ""}; + ConfigurableAxis binJetPt{"binJetPt", {200, 0., 200.}, ""}; + ConfigurableAxis binEta{"binEta", {100, -1.f, 1.f}, ""}; + ConfigurableAxis binPhi{"binPhi", {18 * 8, 0.f, o2::constants::math::TwoPI}, ""}; + ConfigurableAxis binNtracks{"binNtracks", {100, 0., 100.}, ""}; + ConfigurableAxis binTrackPt{"binTrackPt", {200, 0.f, 100.f}, ""}; + ConfigurableAxis binNprongs{"binNprongs", {100, 0., 100.}, ""}; + ConfigurableAxis binLxy{"binLxy", {200, 0, 20.f}, ""}; + ConfigurableAxis binSxy{"binSxy", {1000, 0, 1000.f}, ""}; + ConfigurableAxis binLxyz{"binLxyz", {200, 0, 20.f}, ""}; + ConfigurableAxis binSxyz{"binSxyz", {1000, 0, 1000.f}, ""}; + ConfigurableAxis binMass{"binMass", {50, 0, 10.f}, ""}; + ConfigurableAxis binSigmaLxy{"binSigmaLxy", {100, 0., 0.1}, ""}; + ConfigurableAxis binSigmaLxyz{"binSigmaLxyz", {100, 0., 0.1}, ""}; + ConfigurableAxis binMultScaledFT0M{"binMultScaledFT0M", {100, 0, 20.f}, "scaled FT0M"}; + ConfigurableAxis binMultScaledFT0MClass{"binMultScaledFT0MClass", {VARIABLE_WIDTH, 0, 0.2, 0.3, 0.4, 0.6, 0.8, 1., 1.4, 1.8, 2.4, 3.6, 5., 20.}, "Percentiles of scaled FT0M: 100-90%, 90-80%, 80-70%, 70-60%, 60-50%, 50-40%, 40-30%, 30-20%, 20-10%, 10-1%, 1-0.1%"}; + + int numberOfJetFlavourSpecies = 6; + std::vector eventSelectionBits; + int trackSelection = -1; + + HistogramRegistry registry{"registry", {}, OutputObjHandlingPolicy::AnalysisObject}; + + void init(InitContext const&) + { + numberOfJetFlavourSpecies = static_cast(numFlavourSpecies); + + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); + trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); + // Axis + AxisSpec axisJetFlavour = {binJetFlavour, "Jet flavour"}; + AxisSpec axisJetPt = {binJetPt, "#it{p}_{T, jet}"}; + AxisSpec axisMCDJetPt = {binJetPt, "#it{p}_{T, jet}^{rec}"}; + AxisSpec axisMCPJetPt = {binJetPt, "#it{p}_{T, jet}^{gen}"}; + AxisSpec axisEta = {binEta, "#eta"}; + AxisSpec axisPhi = {binPhi, "#phi"}; + AxisSpec axisNTracks = {binNtracks, "#it{N}_{tracks}"}; + AxisSpec axisTrackPt = {binTrackPt, "#it{p}_{T}^{track}"}; + AxisSpec axisNprongs = {binNprongs, "#it{N}_{SV}"}; + AxisSpec axisLxy = {binLxy, "L_{XY} [cm]"}; + AxisSpec axisSxy = {binSxy, "S_{XY}"}; + AxisSpec axisLxyz = {binLxyz, "L_{XYZ} [cm]"}; + AxisSpec axisSxyz = {binSxyz, "S_{XYZ}"}; + AxisSpec axisMass = {binMass, "#it{m}_{SV}"}; + AxisSpec axisSigmaLxy = {binSigmaLxy, "#sigma_{L_{XY}} [cm]"}; + AxisSpec axisSigmaLxyz = {binSigmaLxyz, "#sigma_{L_{XYZ}} [cm]"}; + AxisSpec axisFracSecPt = {100, 0, 1, "#frac{#Sigma#it{p}_{T}^{secondary track}}{#it{p}_{T, jet}}"}; + AxisSpec axisMultScaledFT0M = {binMultScaledFT0M, "Multiplicity classes"}; + AxisSpec axisMultScaledFT0MClass = {binMultScaledFT0MClass, "Multiplicity classes"}; + AxisSpec axisCentrality = {110, -5., 105., "Centrality"}; + + if (doprocessSV3ProngDataMult) { + registry.add("h_event_mult", "", {HistType::kTH1F, {{axisMultScaledFT0M}}}); + registry.add("h_event_mult_class", "", {HistType::kTH1F, {{axisMultScaledFT0MClass}}}); + registry.add("h2_jet_pt_mult", "", {HistType::kTH2F, {{axisJetPt}, {axisMultScaledFT0MClass}}}); + registry.add("h2_jet_eta_mult", "", {HistType::kTH2F, {{axisEta}, {axisMultScaledFT0MClass}}}); + registry.add("h2_jet_phi_mult", "", {HistType::kTH2F, {{axisPhi}, {axisMultScaledFT0MClass}}}); + if (fillGeneralSVQA) { + registry.add("h2_3prong_nprongs_mult", "", {HistType::kTH2F, {{axisNprongs}, {axisMultScaledFT0MClass}}}); + registry.add("hn_jet_3prong_Sxy_mult", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisLxy}, {axisSigmaLxy}, {axisSxy}, {axisMultScaledFT0MClass}}}); + if (fillSVxyz) { + registry.add("hn_jet_3prong_Sxyz_mult", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisLxyz}, {axisSigmaLxyz}, {axisSxyz}, {axisMultScaledFT0MClass}}}); + } + } + registry.add("hn_jet_3prong_Sxy_N1_mult", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisSxy}, {axisMass}, {axisMultScaledFT0MClass}}}); + registry.add("hn_taggedjet_3prong_Sxy_N1_mult", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisSxy}, {axisMass}, {axisMultScaledFT0MClass}}}); + if (fillSVxyz) { + registry.add("hn_jet_3prong_Sxyz_N1_mult", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisSxyz}, {axisMass}, {axisMultScaledFT0MClass}}}); + registry.add("hn_taggedjet_3prong_Sxyz_N1_mult", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisSxyz}, {axisMass}, {axisMultScaledFT0MClass}}}); + } + } + if (doprocessSV3ProngMCDMult || doprocessSV3ProngMCDMultWeighted || doprocessSV3ProngMCPMCDMatchedMult || doprocessSV3ProngMCPMCDMatchedMultWeighted) { + registry.add("h_event_mult", "", {HistType::kTH1F, {{axisMultScaledFT0M}}}); + registry.add("h_event_mult_class", "", {HistType::kTH1F, {{axisMultScaledFT0MClass}}}); + registry.add("h_cent", "mcd collision centrality; centrality; counts", {HistType::kTH1F, {axisCentrality}}); + registry.add("h3_jet_pt_mult_flavour", "", {HistType::kTH3F, {{axisJetPt}, {axisMultScaledFT0MClass}, {axisJetFlavour}}}); + registry.add("h3_jet_eta_mult_flavour", "", {HistType::kTH3F, {{axisEta}, {axisMultScaledFT0MClass}, {axisJetFlavour}}}); + registry.add("h3_jet_phi_mult_flavour", "", {HistType::kTH3F, {{axisPhi}, {axisMultScaledFT0MClass}, {axisJetFlavour}}}); + if (fillGeneralSVQA) { + registry.add("h3_3prong_nprongs_mult_flavour", "", {HistType::kTH3F, {{axisNprongs}, {axisMultScaledFT0MClass}, {axisJetFlavour}}}); + registry.add("hn_jet_3prong_Sxy_mult_flavour", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisLxy}, {axisSigmaLxy}, {axisSxy}, {axisMultScaledFT0MClass}, {axisJetFlavour}}}); + if (fillSVxyz) { + registry.add("hn_jet_3prong_Sxyz_mult_flavour", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisLxyz}, {axisSigmaLxyz}, {axisSxyz}, {axisMultScaledFT0MClass}, {axisJetFlavour}}}); + } + } + registry.add("hn_jet_3prong_Sxy_N1_mult_flavour", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisSxy}, {axisMass}, {axisMultScaledFT0MClass}, {axisJetFlavour}}}); + registry.add("hn_taggedjet_3prong_Sxy_N1_mult_flavour", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisSxy}, {axisSxyz}, {axisMass}, {axisMultScaledFT0MClass}, {axisJetFlavour}}}); + if (fillSVxyz) { + registry.add("hn_jet_3prong_Sxyz_N1_mult_flavour", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisSxyz}, {axisMass}, {axisMultScaledFT0MClass}, {axisJetFlavour}}}); + registry.add("hn_taggedjet_3prong_Sxyz_N1_mult_flavour", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisSxy}, {axisSxyz}, {axisMass}, {axisMultScaledFT0MClass}, {axisJetFlavour}}}); + } + } + } + + // Filter trackCuts = (aod::jtrack::pt >= trackCuts->at(0) && aod::jtrack::pt < trackCuts->at(1) && aod::jtrack::eta > trackCuts->at(2) && aod::jtrack::eta < trackCuts->at(3)); + Filter eventCuts = (nabs(aod::jcollision::posZ) < vertexZCut); + PresliceUnsorted> collisionsPerMCPCollision = aod::jmccollisionlb::mcCollisionId; + PresliceUnsorted> McCollisionsPerMCPCollision = aod::jmccollision::mcCollisionId; + Preslice particlesPerCollision = aod::jmcparticle::mcCollisionId; + + using JetTagTracksData = soa::Join; + using JetTagTracksMCD = soa::Join; + + std::function&, const std::vector&)> sortImp = + [](const std::vector& a, const std::vector& b) { + return a[0] > b[0]; + }; + + template + bool isAcceptedJet(U const& jet) + { + const float noJetAreaFractionFilter = -98.0; + const float noConstituentPtMinFilter = -98.0; + const float noConstituentPtMaxFilter = 9998.0; + if (jetAreaFractionMin > noJetAreaFractionFilter) { + if (jet.area() < jetAreaFractionMin * o2::constants::math::PI * (jet.r() / 100.0) * (jet.r() / 100.0)) { + return false; + } + } + bool checkConstituentPt = true; + bool checkConstituentMinPt = (leadingConstituentPtMin > noConstituentPtMinFilter); + bool checkConstituentMaxPt = (leadingConstituentPtMax < noConstituentPtMaxFilter); + if (!checkConstituentMinPt && !checkConstituentMaxPt) { + checkConstituentPt = false; + } + + if (checkConstituentPt) { + bool isMinLeadingConstituent = !checkConstituentMinPt; + bool isMaxLeadingConstituent = true; + + for (const auto& constituent : jet.template tracks_as()) { + double pt = constituent.pt(); + + if (checkConstituentMinPt && pt >= leadingConstituentPtMin) { + isMinLeadingConstituent = true; + } + if (checkConstituentMaxPt && pt > leadingConstituentPtMax) { + isMaxLeadingConstituent = false; + } + } + return isMinLeadingConstituent && isMaxLeadingConstituent; + } + + return true; + } + + template + bool trackAcceptance(T const& track) + { + if (track.pt() < trackCuts->at(0) || track.pt() > trackCuts->at(1)) + return false; + + return true; + } + + float getScaledFT0A(const float multFT0A) + { + return multFT0A / meanFT0A; + } + + float getScaledFT0C(const float multFT0C) + { + return multFT0C / meanFT0C; + } + + float getScaledFT0M(const float multFT0A, const float multFT0C) + { + return 0.5 * (getScaledFT0A(multFT0A) + getScaledFT0C(multFT0C)); + } + + template + void fillHistogramMCP(T const& mcpjet, float eventWeight = 1.0, float pTHat = 999.) + { + if (mcpjet.pt() > pTHatMaxMCP * pTHat || pTHat < pTHatAbsoluteMin) { + return; + } + int jetflavour = mcpjet.origin(); + if (jetflavour == JetTaggingSpecies::none) { + LOGF(debug, "NOT DEFINE JET FLAVOR"); + } + registry.fill(HIST("h2_jet_pt_part_flavour"), mcpjet.pt(), jetflavour, eventWeight); + registry.fill(HIST("h2_jet_eta_part_flavour"), mcpjet.eta(), jetflavour, eventWeight); + registry.fill(HIST("h2_jet_phi_part_flavour"), mcpjet.phi(), jetflavour, eventWeight); + } + + template + void fillHistogramSV3ProngDataMult(T const& collision, U const& jet, V const& /*prongs*/) + { + if (jet.template secondaryVertices_as().size() < 1) + return; + float multFT0A = collision.multFT0A(); + float multFT0C = collision.multFT0C(); + float scaledFT0M = getScaledFT0M(multFT0A, multFT0C); + registry.fill(HIST("h2_jet_pt_mult"), jet.pt(), scaledFT0M); + registry.fill(HIST("h2_jet_eta_mult"), jet.eta(), scaledFT0M); + registry.fill(HIST("h2_jet_phi_mult"), jet.phi(), scaledFT0M); + if (fillGeneralSVQA) { + registry.fill(HIST("h2_3prong_nprongs_mult"), jet.template secondaryVertices_as().size(), scaledFT0M); + for (const auto& prong : jet.template secondaryVertices_as()) { + registry.fill(HIST("hn_jet_3prong_Sxy_mult"), jet.pt(), prong.decayLengthXY(), prong.errorDecayLengthXY(), prong.decayLengthXY() / prong.errorDecayLengthXY(), scaledFT0M); + if (fillSVxyz) { + registry.fill(HIST("hn_jet_3prong_Sxyz_mult"), jet.pt(), prong.decayLength(), prong.errorDecayLength(), prong.decayLength() / prong.errorDecayLength(), scaledFT0M); + } + } + } + bool checkSv = false; + auto bjetCand = jettaggingutilities::jetFromProngMaxDecayLength(jet, prongCuts->at(0), prongCuts->at(1), prongCuts->at(2), prongCuts->at(4), prongCuts->at(5), false, &checkSv); + if (checkSv && jettaggingutilities::svAcceptance(bjetCand, svDispersionMax)) { + auto maxSxy = bjetCand.decayLengthXY() / bjetCand.errorDecayLengthXY(); + auto massSV = bjetCand.m(); + registry.fill(HIST("hn_jet_3prong_Sxy_N1_mult"), jet.pt(), maxSxy, massSV, scaledFT0M); + if (jet.isTagged(BJetTaggingMethod::SV)) { + registry.fill(HIST("hn_taggedjet_3prong_Sxy_N1_mult"), jet.pt(), maxSxy, massSV, scaledFT0M); + } + } + if (fillSVxyz) { + checkSv = false; + auto bjetCandXYZ = jettaggingutilities::jetFromProngMaxDecayLength(jet, prongCuts->at(0), prongCuts->at(1), prongCuts->at(3), prongCuts->at(4), prongCuts->at(5), true, &checkSv); + if (checkSv && jettaggingutilities::svAcceptance(bjetCandXYZ, svDispersionMax)) { + auto maxSxyz = bjetCandXYZ.decayLength() / bjetCandXYZ.errorDecayLength(); + auto massSV = bjetCandXYZ.m(); + registry.fill(HIST("hn_jet_3prong_Sxyz_N1_mult"), jet.pt(), maxSxyz, massSV, scaledFT0M); + if (jet.isTagged(BJetTaggingMethod::SV3D)) { + registry.fill(HIST("hn_taggedjet_3prong_Sxyz_N1_mult"), jet.pt(), maxSxyz, massSV, scaledFT0M); + } + } + } + } + + template + void fillHistogramSV3ProngMCDMult(T const& collision, U const& mcdjet, V const& /*prongs*/, float eventWeight = 1.0) + { + float pTHat = 10. / (std::pow(eventWeight, 1.0 / pTHatExponent)); + if (mcdjet.pt() > pTHatMaxMCD * pTHat) { + return; + } + auto origin = mcdjet.origin(); + float multFT0A = collision.multFT0A(); + float multFT0C = collision.multFT0C(); + float scaledFT0M = getScaledFT0M(multFT0A, multFT0C); + if (mcdjet.template secondaryVertices_as().size() < 1) + return; + registry.fill(HIST("h3_jet_pt_mult_flavour"), mcdjet.pt(), scaledFT0M, origin, eventWeight); + registry.fill(HIST("h3_jet_eta_mult_flavour"), mcdjet.eta(), scaledFT0M, origin, eventWeight); + registry.fill(HIST("h3_jet_phi_mult_flavour"), mcdjet.phi(), scaledFT0M, origin, eventWeight); + if (fillGeneralSVQA) { + registry.fill(HIST("h3_3prong_nprongs_mult_flavour"), mcdjet.template secondaryVertices_as().size(), scaledFT0M, origin, eventWeight); + for (const auto& prong : mcdjet.template secondaryVertices_as()) { + registry.fill(HIST("hn_jet_3prong_Sxy_mult_flavour"), mcdjet.pt(), prong.decayLengthXY(), prong.errorDecayLengthXY(), prong.decayLengthXY() / prong.errorDecayLengthXY(), scaledFT0M, origin, eventWeight); + if (fillSVxyz) { + registry.fill(HIST("hn_jet_3prong_Sxyz_mult_flavour"), mcdjet.pt(), prong.decayLength(), prong.errorDecayLength(), prong.decayLength() / prong.errorDecayLength(), scaledFT0M, origin, eventWeight); + } + } + } + bool checkSv = false; + auto bjetCand = jettaggingutilities::jetFromProngMaxDecayLength(mcdjet, prongCuts->at(0), prongCuts->at(1), prongCuts->at(2), prongCuts->at(4), prongCuts->at(5), false, &checkSv); + if (checkSv && jettaggingutilities::svAcceptance(bjetCand, svDispersionMax)) { + auto maxSxy = bjetCand.decayLengthXY() / bjetCand.errorDecayLengthXY(); + auto massSV = bjetCand.m(); + registry.fill(HIST("hn_jet_3prong_Sxy_N1_mult_flavour"), mcdjet.pt(), maxSxy, massSV, scaledFT0M, origin, eventWeight); + if (mcdjet.isTagged(BJetTaggingMethod::SV)) { + registry.fill(HIST("hn_taggedjet_3prong_Sxy_N1_mult_flavour"), mcdjet.pt(), maxSxy, massSV, scaledFT0M, origin, eventWeight); + } + } + if (fillSVxyz) { + auto bjetCandXYZ = jettaggingutilities::jetFromProngMaxDecayLength(mcdjet, prongCuts->at(0), prongCuts->at(1), prongCuts->at(3), prongCuts->at(4), prongCuts->at(5), true, &checkSv); + if (checkSv && jettaggingutilities::svAcceptance(bjetCandXYZ, svDispersionMax)) { + auto maxSxyz = bjetCandXYZ.decayLength() / bjetCandXYZ.errorDecayLength(); + auto massSV = bjetCandXYZ.m(); + registry.fill(HIST("hn_jet_3prong_Sxyz_N1_mult_flavour"), mcdjet.pt(), maxSxyz, massSV, scaledFT0M, origin, eventWeight); + if (mcdjet.isTagged(BJetTaggingMethod::SV3D)) { + registry.fill(HIST("hn_taggedjet_3prong_Sxyz_N1_mult_flavour"), mcdjet.pt(), maxSxyz, massSV, scaledFT0M, origin, eventWeight); + } + } + } + } + + void processDummy(aod::Collision const&, aod::Tracks const&) + { + } + PROCESS_SWITCH(BjetMultTask, processDummy, "Dummy process", true); + + void processMCP(JetTableMCP const& mcpjets, aod::JetParticles const&, soa::Join const& mcCollisions, soa::Filtered const& collisions) + { + for (auto const& mcpjet : mcpjets) { + if (!jetfindingutilities::isInEtaAcceptance(mcpjet, jetEtaCuts->at(0), jetEtaCuts->at(1), trackCuts->at(2), trackCuts->at(3))) { + continue; + } + if (!isAcceptedJet(mcpjet)) { + continue; + } + auto mcCollision = mcCollisions.sliceBy(McCollisionsPerMCPCollision, mcpjet.mcCollisionId()); + if (checkMcCollisionIsMatched) { + auto collisionspermcpjet = collisions.sliceBy(collisionsPerMCPCollision, mcpjet.mcCollisionId()); + if (collisionspermcpjet.size() >= 1 && jetderiveddatautilities::selectCollision(collisionspermcpjet.begin(), eventSelectionBits)) { + fillHistogramMCP(mcpjet, 1., mcCollision.begin().ptHard()); + } + } else { + fillHistogramMCP(mcpjet, 1., mcCollision.begin().ptHard()); + } + } + } + PROCESS_SWITCH(BjetMultTask, processMCP, "Fill impact parameter imformation for mcp jets", false); + + void processMCPWeighted(JetTableMCP const& mcpjets, aod::JetParticles const&, soa::Join const& mcCollisions, soa::Filtered> const& collisions) + { + for (auto const& mcpjet : mcpjets) { + if (!jetfindingutilities::isInEtaAcceptance(mcpjet, jetEtaCuts->at(0), jetEtaCuts->at(1), trackCuts->at(2), trackCuts->at(3))) { + continue; + } + if (!isAcceptedJet(mcpjet)) { + continue; + } + auto mcCollision = mcCollisions.sliceBy(McCollisionsPerMCPCollision, mcpjet.mcCollisionId()); + if (mcCollision.size() == 1) { + if (checkMcCollisionIsMatched) { + auto collisionspermcpjet = collisions.sliceBy(collisionsPerMCPCollision, mcpjet.mcCollisionId()); + if (collisionspermcpjet.size() >= 1 && jetderiveddatautilities::selectCollision(collisionspermcpjet.begin(), eventSelectionBits) && !collisionspermcpjet.begin().isOutlier()) { + fillHistogramMCP(mcpjet, mcCollision.begin().weight(), mcCollision.begin().ptHard()); + } + } else { + fillHistogramMCP(mcpjet, mcCollision.begin().weight(), mcCollision.begin().ptHard()); + } + } + } + } + PROCESS_SWITCH(BjetMultTask, processMCPWeighted, "Fill impact parameter imformation for mcp jets weighted", false); + + void processSV3ProngDataMult(soa::Filtered::iterator const& collision, soa::Join const& jets, aod::DataSecondaryVertex3Prongs const& prongs) + { + if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { + return; + } + float multFT0A = collision.multFT0A(); + float multFT0C = collision.multFT0C(); + float scaledFT0M = getScaledFT0M(multFT0A, multFT0C); + registry.fill(HIST("h_event_mult"), scaledFT0M); + registry.fill(HIST("h_event_mult_class"), scaledFT0M); + for (auto const& jet : jets) { + if (!jetfindingutilities::isInEtaAcceptance(jet, jetEtaCuts->at(0), jetEtaCuts->at(1), trackCuts->at(2), trackCuts->at(3))) { + continue; + } + if (!isAcceptedJet(jet)) { + continue; + } + fillHistogramSV3ProngDataMult(collision, jet, prongs); + } + } + PROCESS_SWITCH(BjetMultTask, processSV3ProngDataMult, "Fill 3prong imformation for data jets", false); + +// void processSV3ProngDataMult(soa::Filtered::iterator const& collision, soa::Join const& jets, aod::DataSecondaryVertex3Prongs const& prongs) +// { +// if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { +// return; +// } +// } +// PROCESS_SWITCH(BjetMultTask, processSV3ProngDataMult, "Fill 3prong imformation for data jets", false); + +// void processJetsRhoAreaSubMultData() +// { +// } +// PROCESS_SWITCH(BjetMultTask, processJetsRhoAreaSubMultData, "Fill 3prong imformation for mcd jets with multiplicity", false); + + void processSV3ProngMCDMult(soa::Filtered::iterator const& collision, soa::Join const& mcdjets, aod::MCDSecondaryVertex3Prongs const& prongs) + { + if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { + return; + } + float multFT0A = collision.multFT0A(); + float multFT0C = collision.multFT0C(); + float centFT0A = collision.centFT0A(); + float centFT0C = collision.centFT0C(); + float scaledFT0M = getScaledFT0M(multFT0A, multFT0C); + std::cout << "FT0A: " << multFT0A << " FT0C: " << multFT0C << " centFT0A: " << centFT0A << " centFT0C: " << centFT0C << std::endl; + registry.fill(HIST("h_event_mult"), scaledFT0M); + registry.fill(HIST("h_event_mult_class"), scaledFT0M); + for (auto const& mcdjet : mcdjets) { + if (!jetfindingutilities::isInEtaAcceptance(mcdjet, jetEtaCuts->at(0), jetEtaCuts->at(1), trackCuts->at(2), trackCuts->at(3))) { + continue; + } + if (!isAcceptedJet(mcdjet)) { + continue; + } + fillHistogramSV3ProngMCDMult(collision, mcdjet, prongs); + } + } + PROCESS_SWITCH(BjetMultTask, processSV3ProngMCDMult, "Fill 3prong imformation for mcd jets with multiplicity", false); + + void processSV3ProngMCDMultWeighted(soa::Filtered>::iterator const& collision, soa::Join const& mcdjets, aod::MCDSecondaryVertex3Prongs const& prongs) + { + if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { + return; + } + if (collision.isOutlier()) { + return; + } + float multFT0A = collision.multFT0A(); + float multFT0C = collision.multFT0C(); + float scaledFT0M = getScaledFT0M(multFT0A, multFT0C); + registry.fill(HIST("h_event_mult"), scaledFT0M); + registry.fill(HIST("h_event_mult_class"), scaledFT0M); + for (auto const& mcdjet : mcdjets) { + if (!jetfindingutilities::isInEtaAcceptance(mcdjet, jetEtaCuts->at(0), jetEtaCuts->at(1), trackCuts->at(2), trackCuts->at(3))) { + continue; + } + if (!isAcceptedJet(mcdjet)) { + continue; + } + fillHistogramSV3ProngMCDMult(collision, mcdjet, prongs, collision.weight()); + } + } + PROCESS_SWITCH(BjetMultTask, processSV3ProngMCDMultWeighted, "Fill 3prong imformation for mcd jets with multiplicity weighted", false); + + void processSV3ProngMCPMCDMatchedMult(soa::Filtered>::iterator const& collision, soa::Join const& mcdjets, soa::Join const& /*mcpjets*/, aod::MCDSecondaryVertex3Prongs const& prongs) + { + if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { + return; + } + float multFT0A = collision.multFT0A(); + float multFT0C = collision.multFT0C(); + float scaledFT0M = getScaledFT0M(multFT0A, multFT0C); + registry.fill(HIST("h_event_mult"), scaledFT0M); + registry.fill(HIST("h_event_mult_class"), scaledFT0M); + for (auto const& mcdjet : mcdjets) { + if (!jetfindingutilities::isInEtaAcceptance(mcdjet, jetEtaCuts->at(0), jetEtaCuts->at(1), trackCuts->at(2), trackCuts->at(3))) { + continue; + } + if (!isAcceptedJet(mcdjet)) { + continue; + } + if (!mcdjet.has_matchedJetGeo()) { + continue; + } + if (!doprocessSV3ProngMCDMult) + fillHistogramSV3ProngMCDMult(collision, mcdjet, prongs); + } + } + PROCESS_SWITCH(BjetMultTask, processSV3ProngMCPMCDMatchedMult, "Fill 3prong imformation for mcd jets matched with multiplicity", false); + + void processSV3ProngMCPMCDMatchedMultWeighted(soa::Filtered>::iterator const& collision, soa::Join const& mcdjets, soa::Join const& /*mcpjets*/, aod::MCDSecondaryVertex3Prongs const& prongs) + { + if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { + return; + } + if (collision.isOutlier()) { + return; + } + float multFT0A = collision.multFT0A(); + float multFT0C = collision.multFT0C(); + float scaledFT0M = getScaledFT0M(multFT0A, multFT0C); + float cent = collision.centFT0M(); + registry.fill(HIST("h_event_mult"), scaledFT0M); + registry.fill(HIST("h_event_mult_class"), scaledFT0M); + registry.fill(HIST("h_cent"), cent); + for (auto const& mcdjet : mcdjets) { + if (!jetfindingutilities::isInEtaAcceptance(mcdjet, jetEtaCuts->at(0), jetEtaCuts->at(1), trackCuts->at(2), trackCuts->at(3))) { + continue; + } + if (!isAcceptedJet(mcdjet)) { + continue; + } + if (!mcdjet.has_matchedJetGeo()) { + continue; + } + if (!doprocessSV3ProngMCDMultWeighted) + fillHistogramSV3ProngMCDMult(collision, mcdjet, prongs, collision.weight()); + } + } + PROCESS_SWITCH(BjetMultTask, processSV3ProngMCPMCDMatchedMultWeighted, "Fill 3prong imformation for mcd jets matched with multiplicity weightd", false); +}; + +using BjetMultChargedDataJets = soa::Join; +using BjetMultChargedMCDJets = soa::Join; +using BjetMultChargedMCPJets = soa::Join; + +using BjetMultCharged = BjetMultTask; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{ + adaptAnalysisTask(cfgc, TaskName{"bjet-multiplicity-charged"})}; // o2-linter: disable=name/o2-task (templated struct) +} From 9f9e67a6bd6cfa8421c891ebac6704ed21bd0f11 Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Mon, 2 Feb 2026 19:41:36 +0900 Subject: [PATCH 02/12] Add bjet multiplcity analysis --- PWGJE/Tasks/CMakeLists.txt | 3 + PWGJE/Tasks/bjetMultiplicity.cxx | 565 ------------------------------- 2 files changed, 3 insertions(+), 565 deletions(-) delete mode 100644 PWGJE/Tasks/bjetMultiplicity.cxx diff --git a/PWGJE/Tasks/CMakeLists.txt b/PWGJE/Tasks/CMakeLists.txt index 0275a7a66ed..52a684a35ee 100644 --- a/PWGJE/Tasks/CMakeLists.txt +++ b/PWGJE/Tasks/CMakeLists.txt @@ -397,6 +397,9 @@ if(FastJet_FOUND) COMPONENT_NAME Analysis) o2physics_add_dpl_workflow(jet-ds-spectrum-subs SOURCES jetDsSpectrumAndSubstructure.cxx + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(bjet-cent-mult + SOURCES bjetCentMult.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore COMPONENT_NAME Analysis) o2physics_add_dpl_workflow(jet-d0-ang-substructure diff --git a/PWGJE/Tasks/bjetMultiplicity.cxx b/PWGJE/Tasks/bjetMultiplicity.cxx deleted file mode 100644 index bf84d972450..00000000000 --- a/PWGJE/Tasks/bjetMultiplicity.cxx +++ /dev/null @@ -1,565 +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. - -/// \file bjetMultiplicity.cxx -/// \brief bjet multiplicity analysis -/// -/// \author Hanseo Park - -#include "PWGJE/Core/JetDerivedDataUtilities.h" -#include "PWGJE/Core/JetFindingUtilities.h" -#include "PWGJE/Core/JetTaggingUtilities.h" -#include "PWGJE/DataModel/Jet.h" -#include "PWGJE/DataModel/JetReducedData.h" -#include "PWGJE/DataModel/JetTagging.h" - -#include "Common/DataModel/Multiplicity.h" - -#include "Framework/ASoA.h" -#include "Framework/AnalysisDataModel.h" -#include "Framework/AnalysisTask.h" -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include - -using namespace o2; -using namespace o2::framework; -using namespace o2::framework::expressions; - -template -struct BjetMultTask { - - // task on/off configuration - Configurable fillGeneralSVQA{"fillGeneralSVQA", true, "process of general QA for sv"}; - Configurable fillSVxyz{"fillSVxyz", true, "process of decay lenngth of xyz for sv"}; - - // Cut configuration - Configurable vertexZCut{"vertexZCut", 10.0f, "Accepted z-vertex range"}; - Configurable> trackCuts{"trackCuts", std::vector{0.15, 100.0, -0.9, 0.9}, "Track cuts: ptMin, ptMax, etaMin, etaMax"}; - Configurable trackDcaXYMax{"trackDcaXYMax", 1, "minimum DCA xy acceptance for tracks [cm]"}; - Configurable trackDcaZMax{"trackDcaZMax", 2, "minimum DCA z acceptance for tracks [cm]"}; - Configurable maxDeltaR{"maxDeltaR", 0.25, "maximum distance of jet axis from flavour initiating parton"}; - Configurable> jetEtaCuts{"jetEtaCuts", std::vector{-99.0, 99.0}, "Jet cuts: etaMin, etaMax"}; - Configurable> prongCuts{"prongCuts", std::vector{1, 100, 100, 100, 0.008, 1}, "prong cuts: chi2PCAMin, chi2PCAMax, sigmaLxyMax, sigmaLxyzMax, IPxyMin, IPxyMax"}; - Configurable svDispersionMax{"svDispersionMax", 0.03f, "maximum dispersion of sv"}; - Configurable numFlavourSpecies{"numFlavourSpecies", 6, "number of jet flavour species"}; - Configurable numOrder{"numOrder", 6, "number of ordering"}; - Configurable pTHatMaxMCD{"pTHatMaxMCD", 999.0, "maximum fraction of hard scattering for jet acceptance in detector MC"}; - Configurable pTHatMaxMCP{"pTHatMaxMCP", 999.0, "maximum fraction of hard scattering for jet acceptance in particle MC"}; - Configurable pTHatExponent{"pTHatExponent", 6.0, "exponent of the event weight for the calculation of pTHat"}; - Configurable pTHatAbsoluteMin{"pTHatAbsoluteMin", -99.0, "minimum value of pTHat"}; - Configurable jetAreaFractionMin{"jetAreaFractionMin", -99.0, "used to make a cut on the jet areas"}; - Configurable leadingConstituentPtMin{"leadingConstituentPtMin", -99.0, "minimum pT selection on jet constituent"}; - Configurable leadingConstituentPtMax{"leadingConstituentPtMax", 9999.0, "maximum pT selection on jet constituent"}; - Configurable checkMcCollisionIsMatched{"checkMcCollisionIsMatched", false, "0: count whole MCcollisions, 1: select MCcollisions which only have their correspond collisions"}; - Configurable trackOccupancyInTimeRangeMax{"trackOccupancyInTimeRangeMax", 999999, "maximum occupancy of tracks in neighbouring collisions in a given time range; only applied to reconstructed collisions (data and mcd jets), not mc collisions (mcp jets)"}; - Configurable trackOccupancyInTimeRangeMin{"trackOccupancyInTimeRangeMin", -999999, "minimum occupancy of tracks in neighbouring collisions in a given time range; only applied to reconstructed collisions (data and mcd jets), not mc collisions (mcp jets)"}; - Configurable meanFT0A{"meanFT0A", -1., "Mean value of FT0A signal"}; - Configurable meanFT0C{"meanFT0C", -1., "Mean value of FT0C signal"}; - - Configurable eventSelections{"eventSelections", "sel8", "choose event selection"}; - Configurable trackSelections{"trackSelections", "globalTracks", "set track selections"}; - - // Binning - ConfigurableAxis binJetFlavour{"binJetFlavour", {6, -0.5, 5.5}, ""}; - ConfigurableAxis binJetPt{"binJetPt", {200, 0., 200.}, ""}; - ConfigurableAxis binEta{"binEta", {100, -1.f, 1.f}, ""}; - ConfigurableAxis binPhi{"binPhi", {18 * 8, 0.f, o2::constants::math::TwoPI}, ""}; - ConfigurableAxis binNtracks{"binNtracks", {100, 0., 100.}, ""}; - ConfigurableAxis binTrackPt{"binTrackPt", {200, 0.f, 100.f}, ""}; - ConfigurableAxis binNprongs{"binNprongs", {100, 0., 100.}, ""}; - ConfigurableAxis binLxy{"binLxy", {200, 0, 20.f}, ""}; - ConfigurableAxis binSxy{"binSxy", {1000, 0, 1000.f}, ""}; - ConfigurableAxis binLxyz{"binLxyz", {200, 0, 20.f}, ""}; - ConfigurableAxis binSxyz{"binSxyz", {1000, 0, 1000.f}, ""}; - ConfigurableAxis binMass{"binMass", {50, 0, 10.f}, ""}; - ConfigurableAxis binSigmaLxy{"binSigmaLxy", {100, 0., 0.1}, ""}; - ConfigurableAxis binSigmaLxyz{"binSigmaLxyz", {100, 0., 0.1}, ""}; - ConfigurableAxis binMultScaledFT0M{"binMultScaledFT0M", {100, 0, 20.f}, "scaled FT0M"}; - ConfigurableAxis binMultScaledFT0MClass{"binMultScaledFT0MClass", {VARIABLE_WIDTH, 0, 0.2, 0.3, 0.4, 0.6, 0.8, 1., 1.4, 1.8, 2.4, 3.6, 5., 20.}, "Percentiles of scaled FT0M: 100-90%, 90-80%, 80-70%, 70-60%, 60-50%, 50-40%, 40-30%, 30-20%, 20-10%, 10-1%, 1-0.1%"}; - - int numberOfJetFlavourSpecies = 6; - std::vector eventSelectionBits; - int trackSelection = -1; - - HistogramRegistry registry{"registry", {}, OutputObjHandlingPolicy::AnalysisObject}; - - void init(InitContext const&) - { - numberOfJetFlavourSpecies = static_cast(numFlavourSpecies); - - eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); - trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); - // Axis - AxisSpec axisJetFlavour = {binJetFlavour, "Jet flavour"}; - AxisSpec axisJetPt = {binJetPt, "#it{p}_{T, jet}"}; - AxisSpec axisMCDJetPt = {binJetPt, "#it{p}_{T, jet}^{rec}"}; - AxisSpec axisMCPJetPt = {binJetPt, "#it{p}_{T, jet}^{gen}"}; - AxisSpec axisEta = {binEta, "#eta"}; - AxisSpec axisPhi = {binPhi, "#phi"}; - AxisSpec axisNTracks = {binNtracks, "#it{N}_{tracks}"}; - AxisSpec axisTrackPt = {binTrackPt, "#it{p}_{T}^{track}"}; - AxisSpec axisNprongs = {binNprongs, "#it{N}_{SV}"}; - AxisSpec axisLxy = {binLxy, "L_{XY} [cm]"}; - AxisSpec axisSxy = {binSxy, "S_{XY}"}; - AxisSpec axisLxyz = {binLxyz, "L_{XYZ} [cm]"}; - AxisSpec axisSxyz = {binSxyz, "S_{XYZ}"}; - AxisSpec axisMass = {binMass, "#it{m}_{SV}"}; - AxisSpec axisSigmaLxy = {binSigmaLxy, "#sigma_{L_{XY}} [cm]"}; - AxisSpec axisSigmaLxyz = {binSigmaLxyz, "#sigma_{L_{XYZ}} [cm]"}; - AxisSpec axisFracSecPt = {100, 0, 1, "#frac{#Sigma#it{p}_{T}^{secondary track}}{#it{p}_{T, jet}}"}; - AxisSpec axisMultScaledFT0M = {binMultScaledFT0M, "Multiplicity classes"}; - AxisSpec axisMultScaledFT0MClass = {binMultScaledFT0MClass, "Multiplicity classes"}; - AxisSpec axisCentrality = {110, -5., 105., "Centrality"}; - - if (doprocessSV3ProngDataMult) { - registry.add("h_event_mult", "", {HistType::kTH1F, {{axisMultScaledFT0M}}}); - registry.add("h_event_mult_class", "", {HistType::kTH1F, {{axisMultScaledFT0MClass}}}); - registry.add("h2_jet_pt_mult", "", {HistType::kTH2F, {{axisJetPt}, {axisMultScaledFT0MClass}}}); - registry.add("h2_jet_eta_mult", "", {HistType::kTH2F, {{axisEta}, {axisMultScaledFT0MClass}}}); - registry.add("h2_jet_phi_mult", "", {HistType::kTH2F, {{axisPhi}, {axisMultScaledFT0MClass}}}); - if (fillGeneralSVQA) { - registry.add("h2_3prong_nprongs_mult", "", {HistType::kTH2F, {{axisNprongs}, {axisMultScaledFT0MClass}}}); - registry.add("hn_jet_3prong_Sxy_mult", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisLxy}, {axisSigmaLxy}, {axisSxy}, {axisMultScaledFT0MClass}}}); - if (fillSVxyz) { - registry.add("hn_jet_3prong_Sxyz_mult", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisLxyz}, {axisSigmaLxyz}, {axisSxyz}, {axisMultScaledFT0MClass}}}); - } - } - registry.add("hn_jet_3prong_Sxy_N1_mult", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisSxy}, {axisMass}, {axisMultScaledFT0MClass}}}); - registry.add("hn_taggedjet_3prong_Sxy_N1_mult", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisSxy}, {axisMass}, {axisMultScaledFT0MClass}}}); - if (fillSVxyz) { - registry.add("hn_jet_3prong_Sxyz_N1_mult", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisSxyz}, {axisMass}, {axisMultScaledFT0MClass}}}); - registry.add("hn_taggedjet_3prong_Sxyz_N1_mult", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisSxyz}, {axisMass}, {axisMultScaledFT0MClass}}}); - } - } - if (doprocessSV3ProngMCDMult || doprocessSV3ProngMCDMultWeighted || doprocessSV3ProngMCPMCDMatchedMult || doprocessSV3ProngMCPMCDMatchedMultWeighted) { - registry.add("h_event_mult", "", {HistType::kTH1F, {{axisMultScaledFT0M}}}); - registry.add("h_event_mult_class", "", {HistType::kTH1F, {{axisMultScaledFT0MClass}}}); - registry.add("h_cent", "mcd collision centrality; centrality; counts", {HistType::kTH1F, {axisCentrality}}); - registry.add("h3_jet_pt_mult_flavour", "", {HistType::kTH3F, {{axisJetPt}, {axisMultScaledFT0MClass}, {axisJetFlavour}}}); - registry.add("h3_jet_eta_mult_flavour", "", {HistType::kTH3F, {{axisEta}, {axisMultScaledFT0MClass}, {axisJetFlavour}}}); - registry.add("h3_jet_phi_mult_flavour", "", {HistType::kTH3F, {{axisPhi}, {axisMultScaledFT0MClass}, {axisJetFlavour}}}); - if (fillGeneralSVQA) { - registry.add("h3_3prong_nprongs_mult_flavour", "", {HistType::kTH3F, {{axisNprongs}, {axisMultScaledFT0MClass}, {axisJetFlavour}}}); - registry.add("hn_jet_3prong_Sxy_mult_flavour", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisLxy}, {axisSigmaLxy}, {axisSxy}, {axisMultScaledFT0MClass}, {axisJetFlavour}}}); - if (fillSVxyz) { - registry.add("hn_jet_3prong_Sxyz_mult_flavour", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisLxyz}, {axisSigmaLxyz}, {axisSxyz}, {axisMultScaledFT0MClass}, {axisJetFlavour}}}); - } - } - registry.add("hn_jet_3prong_Sxy_N1_mult_flavour", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisSxy}, {axisMass}, {axisMultScaledFT0MClass}, {axisJetFlavour}}}); - registry.add("hn_taggedjet_3prong_Sxy_N1_mult_flavour", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisSxy}, {axisSxyz}, {axisMass}, {axisMultScaledFT0MClass}, {axisJetFlavour}}}); - if (fillSVxyz) { - registry.add("hn_jet_3prong_Sxyz_N1_mult_flavour", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisSxyz}, {axisMass}, {axisMultScaledFT0MClass}, {axisJetFlavour}}}); - registry.add("hn_taggedjet_3prong_Sxyz_N1_mult_flavour", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisSxy}, {axisSxyz}, {axisMass}, {axisMultScaledFT0MClass}, {axisJetFlavour}}}); - } - } - } - - // Filter trackCuts = (aod::jtrack::pt >= trackCuts->at(0) && aod::jtrack::pt < trackCuts->at(1) && aod::jtrack::eta > trackCuts->at(2) && aod::jtrack::eta < trackCuts->at(3)); - Filter eventCuts = (nabs(aod::jcollision::posZ) < vertexZCut); - PresliceUnsorted> collisionsPerMCPCollision = aod::jmccollisionlb::mcCollisionId; - PresliceUnsorted> McCollisionsPerMCPCollision = aod::jmccollision::mcCollisionId; - Preslice particlesPerCollision = aod::jmcparticle::mcCollisionId; - - using JetTagTracksData = soa::Join; - using JetTagTracksMCD = soa::Join; - - std::function&, const std::vector&)> sortImp = - [](const std::vector& a, const std::vector& b) { - return a[0] > b[0]; - }; - - template - bool isAcceptedJet(U const& jet) - { - const float noJetAreaFractionFilter = -98.0; - const float noConstituentPtMinFilter = -98.0; - const float noConstituentPtMaxFilter = 9998.0; - if (jetAreaFractionMin > noJetAreaFractionFilter) { - if (jet.area() < jetAreaFractionMin * o2::constants::math::PI * (jet.r() / 100.0) * (jet.r() / 100.0)) { - return false; - } - } - bool checkConstituentPt = true; - bool checkConstituentMinPt = (leadingConstituentPtMin > noConstituentPtMinFilter); - bool checkConstituentMaxPt = (leadingConstituentPtMax < noConstituentPtMaxFilter); - if (!checkConstituentMinPt && !checkConstituentMaxPt) { - checkConstituentPt = false; - } - - if (checkConstituentPt) { - bool isMinLeadingConstituent = !checkConstituentMinPt; - bool isMaxLeadingConstituent = true; - - for (const auto& constituent : jet.template tracks_as()) { - double pt = constituent.pt(); - - if (checkConstituentMinPt && pt >= leadingConstituentPtMin) { - isMinLeadingConstituent = true; - } - if (checkConstituentMaxPt && pt > leadingConstituentPtMax) { - isMaxLeadingConstituent = false; - } - } - return isMinLeadingConstituent && isMaxLeadingConstituent; - } - - return true; - } - - template - bool trackAcceptance(T const& track) - { - if (track.pt() < trackCuts->at(0) || track.pt() > trackCuts->at(1)) - return false; - - return true; - } - - float getScaledFT0A(const float multFT0A) - { - return multFT0A / meanFT0A; - } - - float getScaledFT0C(const float multFT0C) - { - return multFT0C / meanFT0C; - } - - float getScaledFT0M(const float multFT0A, const float multFT0C) - { - return 0.5 * (getScaledFT0A(multFT0A) + getScaledFT0C(multFT0C)); - } - - template - void fillHistogramMCP(T const& mcpjet, float eventWeight = 1.0, float pTHat = 999.) - { - if (mcpjet.pt() > pTHatMaxMCP * pTHat || pTHat < pTHatAbsoluteMin) { - return; - } - int jetflavour = mcpjet.origin(); - if (jetflavour == JetTaggingSpecies::none) { - LOGF(debug, "NOT DEFINE JET FLAVOR"); - } - registry.fill(HIST("h2_jet_pt_part_flavour"), mcpjet.pt(), jetflavour, eventWeight); - registry.fill(HIST("h2_jet_eta_part_flavour"), mcpjet.eta(), jetflavour, eventWeight); - registry.fill(HIST("h2_jet_phi_part_flavour"), mcpjet.phi(), jetflavour, eventWeight); - } - - template - void fillHistogramSV3ProngDataMult(T const& collision, U const& jet, V const& /*prongs*/) - { - if (jet.template secondaryVertices_as().size() < 1) - return; - float multFT0A = collision.multFT0A(); - float multFT0C = collision.multFT0C(); - float scaledFT0M = getScaledFT0M(multFT0A, multFT0C); - registry.fill(HIST("h2_jet_pt_mult"), jet.pt(), scaledFT0M); - registry.fill(HIST("h2_jet_eta_mult"), jet.eta(), scaledFT0M); - registry.fill(HIST("h2_jet_phi_mult"), jet.phi(), scaledFT0M); - if (fillGeneralSVQA) { - registry.fill(HIST("h2_3prong_nprongs_mult"), jet.template secondaryVertices_as().size(), scaledFT0M); - for (const auto& prong : jet.template secondaryVertices_as()) { - registry.fill(HIST("hn_jet_3prong_Sxy_mult"), jet.pt(), prong.decayLengthXY(), prong.errorDecayLengthXY(), prong.decayLengthXY() / prong.errorDecayLengthXY(), scaledFT0M); - if (fillSVxyz) { - registry.fill(HIST("hn_jet_3prong_Sxyz_mult"), jet.pt(), prong.decayLength(), prong.errorDecayLength(), prong.decayLength() / prong.errorDecayLength(), scaledFT0M); - } - } - } - bool checkSv = false; - auto bjetCand = jettaggingutilities::jetFromProngMaxDecayLength(jet, prongCuts->at(0), prongCuts->at(1), prongCuts->at(2), prongCuts->at(4), prongCuts->at(5), false, &checkSv); - if (checkSv && jettaggingutilities::svAcceptance(bjetCand, svDispersionMax)) { - auto maxSxy = bjetCand.decayLengthXY() / bjetCand.errorDecayLengthXY(); - auto massSV = bjetCand.m(); - registry.fill(HIST("hn_jet_3prong_Sxy_N1_mult"), jet.pt(), maxSxy, massSV, scaledFT0M); - if (jet.isTagged(BJetTaggingMethod::SV)) { - registry.fill(HIST("hn_taggedjet_3prong_Sxy_N1_mult"), jet.pt(), maxSxy, massSV, scaledFT0M); - } - } - if (fillSVxyz) { - checkSv = false; - auto bjetCandXYZ = jettaggingutilities::jetFromProngMaxDecayLength(jet, prongCuts->at(0), prongCuts->at(1), prongCuts->at(3), prongCuts->at(4), prongCuts->at(5), true, &checkSv); - if (checkSv && jettaggingutilities::svAcceptance(bjetCandXYZ, svDispersionMax)) { - auto maxSxyz = bjetCandXYZ.decayLength() / bjetCandXYZ.errorDecayLength(); - auto massSV = bjetCandXYZ.m(); - registry.fill(HIST("hn_jet_3prong_Sxyz_N1_mult"), jet.pt(), maxSxyz, massSV, scaledFT0M); - if (jet.isTagged(BJetTaggingMethod::SV3D)) { - registry.fill(HIST("hn_taggedjet_3prong_Sxyz_N1_mult"), jet.pt(), maxSxyz, massSV, scaledFT0M); - } - } - } - } - - template - void fillHistogramSV3ProngMCDMult(T const& collision, U const& mcdjet, V const& /*prongs*/, float eventWeight = 1.0) - { - float pTHat = 10. / (std::pow(eventWeight, 1.0 / pTHatExponent)); - if (mcdjet.pt() > pTHatMaxMCD * pTHat) { - return; - } - auto origin = mcdjet.origin(); - float multFT0A = collision.multFT0A(); - float multFT0C = collision.multFT0C(); - float scaledFT0M = getScaledFT0M(multFT0A, multFT0C); - if (mcdjet.template secondaryVertices_as().size() < 1) - return; - registry.fill(HIST("h3_jet_pt_mult_flavour"), mcdjet.pt(), scaledFT0M, origin, eventWeight); - registry.fill(HIST("h3_jet_eta_mult_flavour"), mcdjet.eta(), scaledFT0M, origin, eventWeight); - registry.fill(HIST("h3_jet_phi_mult_flavour"), mcdjet.phi(), scaledFT0M, origin, eventWeight); - if (fillGeneralSVQA) { - registry.fill(HIST("h3_3prong_nprongs_mult_flavour"), mcdjet.template secondaryVertices_as().size(), scaledFT0M, origin, eventWeight); - for (const auto& prong : mcdjet.template secondaryVertices_as()) { - registry.fill(HIST("hn_jet_3prong_Sxy_mult_flavour"), mcdjet.pt(), prong.decayLengthXY(), prong.errorDecayLengthXY(), prong.decayLengthXY() / prong.errorDecayLengthXY(), scaledFT0M, origin, eventWeight); - if (fillSVxyz) { - registry.fill(HIST("hn_jet_3prong_Sxyz_mult_flavour"), mcdjet.pt(), prong.decayLength(), prong.errorDecayLength(), prong.decayLength() / prong.errorDecayLength(), scaledFT0M, origin, eventWeight); - } - } - } - bool checkSv = false; - auto bjetCand = jettaggingutilities::jetFromProngMaxDecayLength(mcdjet, prongCuts->at(0), prongCuts->at(1), prongCuts->at(2), prongCuts->at(4), prongCuts->at(5), false, &checkSv); - if (checkSv && jettaggingutilities::svAcceptance(bjetCand, svDispersionMax)) { - auto maxSxy = bjetCand.decayLengthXY() / bjetCand.errorDecayLengthXY(); - auto massSV = bjetCand.m(); - registry.fill(HIST("hn_jet_3prong_Sxy_N1_mult_flavour"), mcdjet.pt(), maxSxy, massSV, scaledFT0M, origin, eventWeight); - if (mcdjet.isTagged(BJetTaggingMethod::SV)) { - registry.fill(HIST("hn_taggedjet_3prong_Sxy_N1_mult_flavour"), mcdjet.pt(), maxSxy, massSV, scaledFT0M, origin, eventWeight); - } - } - if (fillSVxyz) { - auto bjetCandXYZ = jettaggingutilities::jetFromProngMaxDecayLength(mcdjet, prongCuts->at(0), prongCuts->at(1), prongCuts->at(3), prongCuts->at(4), prongCuts->at(5), true, &checkSv); - if (checkSv && jettaggingutilities::svAcceptance(bjetCandXYZ, svDispersionMax)) { - auto maxSxyz = bjetCandXYZ.decayLength() / bjetCandXYZ.errorDecayLength(); - auto massSV = bjetCandXYZ.m(); - registry.fill(HIST("hn_jet_3prong_Sxyz_N1_mult_flavour"), mcdjet.pt(), maxSxyz, massSV, scaledFT0M, origin, eventWeight); - if (mcdjet.isTagged(BJetTaggingMethod::SV3D)) { - registry.fill(HIST("hn_taggedjet_3prong_Sxyz_N1_mult_flavour"), mcdjet.pt(), maxSxyz, massSV, scaledFT0M, origin, eventWeight); - } - } - } - } - - void processDummy(aod::Collision const&, aod::Tracks const&) - { - } - PROCESS_SWITCH(BjetMultTask, processDummy, "Dummy process", true); - - void processMCP(JetTableMCP const& mcpjets, aod::JetParticles const&, soa::Join const& mcCollisions, soa::Filtered const& collisions) - { - for (auto const& mcpjet : mcpjets) { - if (!jetfindingutilities::isInEtaAcceptance(mcpjet, jetEtaCuts->at(0), jetEtaCuts->at(1), trackCuts->at(2), trackCuts->at(3))) { - continue; - } - if (!isAcceptedJet(mcpjet)) { - continue; - } - auto mcCollision = mcCollisions.sliceBy(McCollisionsPerMCPCollision, mcpjet.mcCollisionId()); - if (checkMcCollisionIsMatched) { - auto collisionspermcpjet = collisions.sliceBy(collisionsPerMCPCollision, mcpjet.mcCollisionId()); - if (collisionspermcpjet.size() >= 1 && jetderiveddatautilities::selectCollision(collisionspermcpjet.begin(), eventSelectionBits)) { - fillHistogramMCP(mcpjet, 1., mcCollision.begin().ptHard()); - } - } else { - fillHistogramMCP(mcpjet, 1., mcCollision.begin().ptHard()); - } - } - } - PROCESS_SWITCH(BjetMultTask, processMCP, "Fill impact parameter imformation for mcp jets", false); - - void processMCPWeighted(JetTableMCP const& mcpjets, aod::JetParticles const&, soa::Join const& mcCollisions, soa::Filtered> const& collisions) - { - for (auto const& mcpjet : mcpjets) { - if (!jetfindingutilities::isInEtaAcceptance(mcpjet, jetEtaCuts->at(0), jetEtaCuts->at(1), trackCuts->at(2), trackCuts->at(3))) { - continue; - } - if (!isAcceptedJet(mcpjet)) { - continue; - } - auto mcCollision = mcCollisions.sliceBy(McCollisionsPerMCPCollision, mcpjet.mcCollisionId()); - if (mcCollision.size() == 1) { - if (checkMcCollisionIsMatched) { - auto collisionspermcpjet = collisions.sliceBy(collisionsPerMCPCollision, mcpjet.mcCollisionId()); - if (collisionspermcpjet.size() >= 1 && jetderiveddatautilities::selectCollision(collisionspermcpjet.begin(), eventSelectionBits) && !collisionspermcpjet.begin().isOutlier()) { - fillHistogramMCP(mcpjet, mcCollision.begin().weight(), mcCollision.begin().ptHard()); - } - } else { - fillHistogramMCP(mcpjet, mcCollision.begin().weight(), mcCollision.begin().ptHard()); - } - } - } - } - PROCESS_SWITCH(BjetMultTask, processMCPWeighted, "Fill impact parameter imformation for mcp jets weighted", false); - - void processSV3ProngDataMult(soa::Filtered::iterator const& collision, soa::Join const& jets, aod::DataSecondaryVertex3Prongs const& prongs) - { - if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { - return; - } - float multFT0A = collision.multFT0A(); - float multFT0C = collision.multFT0C(); - float scaledFT0M = getScaledFT0M(multFT0A, multFT0C); - registry.fill(HIST("h_event_mult"), scaledFT0M); - registry.fill(HIST("h_event_mult_class"), scaledFT0M); - for (auto const& jet : jets) { - if (!jetfindingutilities::isInEtaAcceptance(jet, jetEtaCuts->at(0), jetEtaCuts->at(1), trackCuts->at(2), trackCuts->at(3))) { - continue; - } - if (!isAcceptedJet(jet)) { - continue; - } - fillHistogramSV3ProngDataMult(collision, jet, prongs); - } - } - PROCESS_SWITCH(BjetMultTask, processSV3ProngDataMult, "Fill 3prong imformation for data jets", false); - -// void processSV3ProngDataMult(soa::Filtered::iterator const& collision, soa::Join const& jets, aod::DataSecondaryVertex3Prongs const& prongs) -// { -// if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { -// return; -// } -// } -// PROCESS_SWITCH(BjetMultTask, processSV3ProngDataMult, "Fill 3prong imformation for data jets", false); - -// void processJetsRhoAreaSubMultData() -// { -// } -// PROCESS_SWITCH(BjetMultTask, processJetsRhoAreaSubMultData, "Fill 3prong imformation for mcd jets with multiplicity", false); - - void processSV3ProngMCDMult(soa::Filtered::iterator const& collision, soa::Join const& mcdjets, aod::MCDSecondaryVertex3Prongs const& prongs) - { - if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { - return; - } - float multFT0A = collision.multFT0A(); - float multFT0C = collision.multFT0C(); - float centFT0A = collision.centFT0A(); - float centFT0C = collision.centFT0C(); - float scaledFT0M = getScaledFT0M(multFT0A, multFT0C); - std::cout << "FT0A: " << multFT0A << " FT0C: " << multFT0C << " centFT0A: " << centFT0A << " centFT0C: " << centFT0C << std::endl; - registry.fill(HIST("h_event_mult"), scaledFT0M); - registry.fill(HIST("h_event_mult_class"), scaledFT0M); - for (auto const& mcdjet : mcdjets) { - if (!jetfindingutilities::isInEtaAcceptance(mcdjet, jetEtaCuts->at(0), jetEtaCuts->at(1), trackCuts->at(2), trackCuts->at(3))) { - continue; - } - if (!isAcceptedJet(mcdjet)) { - continue; - } - fillHistogramSV3ProngMCDMult(collision, mcdjet, prongs); - } - } - PROCESS_SWITCH(BjetMultTask, processSV3ProngMCDMult, "Fill 3prong imformation for mcd jets with multiplicity", false); - - void processSV3ProngMCDMultWeighted(soa::Filtered>::iterator const& collision, soa::Join const& mcdjets, aod::MCDSecondaryVertex3Prongs const& prongs) - { - if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { - return; - } - if (collision.isOutlier()) { - return; - } - float multFT0A = collision.multFT0A(); - float multFT0C = collision.multFT0C(); - float scaledFT0M = getScaledFT0M(multFT0A, multFT0C); - registry.fill(HIST("h_event_mult"), scaledFT0M); - registry.fill(HIST("h_event_mult_class"), scaledFT0M); - for (auto const& mcdjet : mcdjets) { - if (!jetfindingutilities::isInEtaAcceptance(mcdjet, jetEtaCuts->at(0), jetEtaCuts->at(1), trackCuts->at(2), trackCuts->at(3))) { - continue; - } - if (!isAcceptedJet(mcdjet)) { - continue; - } - fillHistogramSV3ProngMCDMult(collision, mcdjet, prongs, collision.weight()); - } - } - PROCESS_SWITCH(BjetMultTask, processSV3ProngMCDMultWeighted, "Fill 3prong imformation for mcd jets with multiplicity weighted", false); - - void processSV3ProngMCPMCDMatchedMult(soa::Filtered>::iterator const& collision, soa::Join const& mcdjets, soa::Join const& /*mcpjets*/, aod::MCDSecondaryVertex3Prongs const& prongs) - { - if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { - return; - } - float multFT0A = collision.multFT0A(); - float multFT0C = collision.multFT0C(); - float scaledFT0M = getScaledFT0M(multFT0A, multFT0C); - registry.fill(HIST("h_event_mult"), scaledFT0M); - registry.fill(HIST("h_event_mult_class"), scaledFT0M); - for (auto const& mcdjet : mcdjets) { - if (!jetfindingutilities::isInEtaAcceptance(mcdjet, jetEtaCuts->at(0), jetEtaCuts->at(1), trackCuts->at(2), trackCuts->at(3))) { - continue; - } - if (!isAcceptedJet(mcdjet)) { - continue; - } - if (!mcdjet.has_matchedJetGeo()) { - continue; - } - if (!doprocessSV3ProngMCDMult) - fillHistogramSV3ProngMCDMult(collision, mcdjet, prongs); - } - } - PROCESS_SWITCH(BjetMultTask, processSV3ProngMCPMCDMatchedMult, "Fill 3prong imformation for mcd jets matched with multiplicity", false); - - void processSV3ProngMCPMCDMatchedMultWeighted(soa::Filtered>::iterator const& collision, soa::Join const& mcdjets, soa::Join const& /*mcpjets*/, aod::MCDSecondaryVertex3Prongs const& prongs) - { - if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { - return; - } - if (collision.isOutlier()) { - return; - } - float multFT0A = collision.multFT0A(); - float multFT0C = collision.multFT0C(); - float scaledFT0M = getScaledFT0M(multFT0A, multFT0C); - float cent = collision.centFT0M(); - registry.fill(HIST("h_event_mult"), scaledFT0M); - registry.fill(HIST("h_event_mult_class"), scaledFT0M); - registry.fill(HIST("h_cent"), cent); - for (auto const& mcdjet : mcdjets) { - if (!jetfindingutilities::isInEtaAcceptance(mcdjet, jetEtaCuts->at(0), jetEtaCuts->at(1), trackCuts->at(2), trackCuts->at(3))) { - continue; - } - if (!isAcceptedJet(mcdjet)) { - continue; - } - if (!mcdjet.has_matchedJetGeo()) { - continue; - } - if (!doprocessSV3ProngMCDMultWeighted) - fillHistogramSV3ProngMCDMult(collision, mcdjet, prongs, collision.weight()); - } - } - PROCESS_SWITCH(BjetMultTask, processSV3ProngMCPMCDMatchedMultWeighted, "Fill 3prong imformation for mcd jets matched with multiplicity weightd", false); -}; - -using BjetMultChargedDataJets = soa::Join; -using BjetMultChargedMCDJets = soa::Join; -using BjetMultChargedMCPJets = soa::Join; - -using BjetMultCharged = BjetMultTask; - -WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) -{ - return WorkflowSpec{ - adaptAnalysisTask(cfgc, TaskName{"bjet-multiplicity-charged"})}; // o2-linter: disable=name/o2-task (templated struct) -} From 5d87074d2112b81ae50837aef32ac62cd328f4cd Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Mon, 2 Feb 2026 20:53:17 +0900 Subject: [PATCH 03/12] fix CMakeList --- PWGJE/Tasks/CMakeLists.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/PWGJE/Tasks/CMakeLists.txt b/PWGJE/Tasks/CMakeLists.txt index 52a684a35ee..572c37d7450 100644 --- a/PWGJE/Tasks/CMakeLists.txt +++ b/PWGJE/Tasks/CMakeLists.txt @@ -397,6 +397,7 @@ if(FastJet_FOUND) COMPONENT_NAME Analysis) o2physics_add_dpl_workflow(jet-ds-spectrum-subs SOURCES jetDsSpectrumAndSubstructure.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore COMPONENT_NAME Analysis) o2physics_add_dpl_workflow(bjet-cent-mult SOURCES bjetCentMult.cxx From b3167efac0cb2e09f7e70c8c34f32f020597c343 Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Thu, 16 Apr 2026 13:31:06 +0900 Subject: [PATCH 04/12] update bkg sub b-jet mult --- PWGJE/Tasks/bjetCentMult.cxx | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/PWGJE/Tasks/bjetCentMult.cxx b/PWGJE/Tasks/bjetCentMult.cxx index 576afeb4ac0..3d843198edc 100644 --- a/PWGJE/Tasks/bjetCentMult.cxx +++ b/PWGJE/Tasks/bjetCentMult.cxx @@ -513,6 +513,25 @@ struct BjetCentMultTask { } PROCESS_SWITCH(BjetCentMultTask, processSV3ProngData, "Fill 3prong imformation for data jets", false); + void processRhoAreaSubSV3ProngData(soa::Filtered>::iterator const& collision, soa::Join const& jets, aod::DataSecondaryVertex3Prongs const& prongs) + { + if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { + return; + } + float centrality = collision.centFT0M(); + registry.fill(HIST("h_event_centrality"), centrality); + for (auto const& jet : jets) { + if (!jetfindingutilities::isInEtaAcceptance(jet, jetEtaCuts->at(0), jetEtaCuts->at(1), trackCuts->at(2), trackCuts->at(3))) { + continue; + } + if (!isAcceptedJet(jet)) { + continue; + } + fillHistogramSV3ProngData(jet, prongs, centrality); + } + } + PROCESS_SWITCH(BjetCentMultTask, processRhoAreaSubSV3ProngData, "Fill 3prong imformation for data jets with background subtraction", false); + void processSV3ProngMCD(soa::Filtered>::iterator const& collision, soa::Join const& mcdjets, aod::MCDSecondaryVertex3Prongs const& prongs) { if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { From f8dcc12317b1174d17274c8f5a34e5cd8fb8d6d6 Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Fri, 17 Apr 2026 13:16:01 +0900 Subject: [PATCH 05/12] fix to complict rebase --- PWGJE/Tasks/CMakeLists.txt | 4 ---- 1 file changed, 4 deletions(-) diff --git a/PWGJE/Tasks/CMakeLists.txt b/PWGJE/Tasks/CMakeLists.txt index 572c37d7450..355f5b656c4 100644 --- a/PWGJE/Tasks/CMakeLists.txt +++ b/PWGJE/Tasks/CMakeLists.txt @@ -407,8 +407,4 @@ if(FastJet_FOUND) SOURCES jetD0AngSubstructure.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore COMPONENT_NAME Analysis) - o2physics_add_dpl_workflow(bjet-cent-mult - SOURCES bjetCentMult.cxx - PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore - COMPONENT_NAME Analysis) endif() From b7049a215e3c7b5340097550b892c745c0242e66 Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Fri, 17 Apr 2026 17:15:31 +0900 Subject: [PATCH 06/12] modificaiton validation of flavour and seconday contamition --- .../secondaryVertexReconstruction.cxx | 32 +++++++++---------- PWGJE/Tasks/jetTaggerHFQA.cxx | 9 +++--- 2 files changed, 20 insertions(+), 21 deletions(-) diff --git a/PWGJE/TableProducer/secondaryVertexReconstruction.cxx b/PWGJE/TableProducer/secondaryVertexReconstruction.cxx index e2f2246b21b..401aad121ee 100644 --- a/PWGJE/TableProducer/secondaryVertexReconstruction.cxx +++ b/PWGJE/TableProducer/secondaryVertexReconstruction.cxx @@ -22,22 +22,22 @@ #include "Common/Core/trackUtilities.h" #include "Common/DataModel/TrackSelectionTables.h" +#include "CommonConstants/PhysicsConstants.h" +#include "DCAFitter/DCAFitterN.h" +#include "Framework/ASoA.h" +#include "Framework/AnalysisDataModel.h" +#include "Framework/AnalysisTask.h" +#include "ReconstructionDataFormats/DCA.h" #include -#include -#include #include #include -#include -#include #include -#include #include #include #include #include #include #include -#include #include #include @@ -74,12 +74,12 @@ struct SecondaryVertexReconstruction { Configurable propagateToPCA{"propagateToPCA", true, "create tracks version propagated to PCA"}; Configurable useAbsDCA{"useAbsDCA", false, "Minimise abs. distance rather than chi2"}; Configurable useWeightedFinalPCA{"useWeightedFinalPCA", false, "Recalculate vertex position using track covariances, effective only if useAbsDCA is true"}; - Configurable maxR{"maxR", 200., "reject PCA's above this radius"}; - Configurable maxDZIni{"maxDZIni", 4., "reject (if>0) PCA candidate if tracks DZ exceeds threshold"}; - Configurable maxRsv{"maxRsv", 999., "max. radius of the reconstruced SV"}; - Configurable maxZsv{"maxZsv", 999., "max. Z coordinates of the reconstruced SV"}; - Configurable minParamChange{"minParamChange", 1.e-3, "stop iterations if largest change of any X is smaller than this"}; - Configurable minRelChi2Change{"minRelChi2Change", 0.9, "stop iterations is chi2/chi2old > this"}; + Configurable maxR{"maxR", 200., "reject PCA's above this radius"}; + Configurable maxDZIni{"maxDZIni", 4., "reject (if>0) PCA candidate if tracks DZ exceeds threshold"}; + Configurable maxRsv{"maxRsv", 999., "max. radius of the reconstruced SV"}; + Configurable maxZsv{"maxZsv", 999., "max. Z coordinates of the reconstruced SV"}; + Configurable minParamChange{"minParamChange", 1.e-3, "stop iterations if largest change of any X is smaller than this"}; + Configurable minRelChi2Change{"minRelChi2Change", 0.9, "stop iterations is chi2/chi2old > this"}; Configurable ptMinTrack{"ptMinTrack", -1., "min. track pT"}; Configurable etaMinTrack{"etaMinTrack", -99999., "min. pseudorapidity"}; Configurable etaMaxTrack{"etaMaxTrack", 4., "max. pseudorapidity"}; @@ -94,7 +94,7 @@ struct SecondaryVertexReconstruction { o2::vertexing::DCAFitterN<2> df2; // 2-prong vertex fitter o2::vertexing::DCAFitterN<3> df3; // 3-prong vertex fitter Service ccdb; - o2::base::MatLayerCylSet* lut; + o2::base::MatLayerCylSet* lut = nullptr; HistogramRegistry registry{"registry"}; @@ -216,7 +216,7 @@ struct SecondaryVertexReconstruction { auto covMatrixPV = primaryVertex.getCov(); // Get track momenta and impact parameters - std::array, numProngs> arrayMomenta; + std::array, numProngs> arrayMomenta{}; std::array impactParameters; for (unsigned int inum = 0; inum < numProngs; ++inum) { trackParVars[inum].getPxPyPzGlo(arrayMomenta[inum]); @@ -236,9 +236,9 @@ struct SecondaryVertexReconstruction { auto errorDecayLengthXY = std::sqrt(getRotatedCovMatrixXX(covMatrixPV, phi, 0.) + getRotatedCovMatrixXX(covMatrixPCA, phi, 0.)); // calculate invariant mass - std::array massArray; + std::array massArray{}; std::fill(massArray.begin(), massArray.end(), o2::constants::physics::MassPiPlus); - double massSV = RecoDecay::m(std::move(arrayMomenta), massArray); + double massSV = RecoDecay::m(arrayMomenta, massArray); // fill candidate table rows if ((doprocessData3Prongs || doprocessData3ProngsExternalMagneticField) && numProngs == 3) { diff --git a/PWGJE/Tasks/jetTaggerHFQA.cxx b/PWGJE/Tasks/jetTaggerHFQA.cxx index 1dd147c0ff7..dac7777daf7 100644 --- a/PWGJE/Tasks/jetTaggerHFQA.cxx +++ b/PWGJE/Tasks/jetTaggerHFQA.cxx @@ -165,7 +165,7 @@ struct JetTaggerHFQA { } } if (doprocessTracksInJetsData) { - registry.add("h2_track_pt_impact_parameter_xy", "", {HistType::kTH2F, {{axisTrackPt}, {axisImpactParameterXY}}}); + registry.add("h3_jet_pt_track_pt_impact_parameter_xy", "", {HistType::kTH3F, {{axisJetPt}, {axisTrackPt}, {axisImpactParameterXY}}}); } if (doprocessSecondaryContaminationMCD) { registry.add("hn_jet_pt_track_pt_impact_parameter_xy_physical_primary_flavour", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisTrackPt}, {axisImpactParameterXY}, {axisJetFlavour}}}); @@ -1158,7 +1158,7 @@ struct JetTaggerHFQA { } for (auto const& track : jet.template tracks_as()) { float varImpXY = track.dcaXY() * jettaggingutilities::cmTomum; - registry.fill(HIST("h2_track_pt_impact_parameter_xy"), track.pt(), varImpXY); + registry.fill(HIST("h3_jet_pt_track_pt_impact_parameter_xy"), jet.pt(), track.pt(), varImpXY); } } } @@ -1179,7 +1179,7 @@ struct JetTaggerHFQA { if (!isAcceptedJet(mcdjet)) { continue; } - auto eventWeight = collision.mcCollision_as>().weight(); + auto eventWeight = collision.weight(); float pTHat = 10. / (std::pow(eventWeight, 1.0 / pTHatExponent)); if (mcdjet.pt() > pTHatMaxMCD * pTHat) { continue; @@ -1224,8 +1224,7 @@ struct JetTaggerHFQA { if (!isAcceptedJet(mcdjet)) { continue; } - auto eventWeight = collision.mcCollision_as>().weight(); - fillValidationFlavourDefMCD>(mcdjet, tracks, particles, particlesPerColl, eventWeight); + fillValidationFlavourDefMCD>(mcdjet, tracks, particles, particlesPerColl, collision.weight()); } } PROCESS_SWITCH(JetTaggerHFQA, processValFlavourDefMCD, "to check the validation of jet-flavour definition when compared to distance for mcd jets", false); From a670bf843a054e695049f688edc97f70196273c5 Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Fri, 17 Apr 2026 17:32:51 +0900 Subject: [PATCH 07/12] fix CMakeList --- PWGJE/Tasks/CMakeLists.txt | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/PWGJE/Tasks/CMakeLists.txt b/PWGJE/Tasks/CMakeLists.txt index 355f5b656c4..0275a7a66ed 100644 --- a/PWGJE/Tasks/CMakeLists.txt +++ b/PWGJE/Tasks/CMakeLists.txt @@ -399,12 +399,12 @@ if(FastJet_FOUND) SOURCES jetDsSpectrumAndSubstructure.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore COMPONENT_NAME Analysis) - o2physics_add_dpl_workflow(bjet-cent-mult - SOURCES bjetCentMult.cxx - PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore - COMPONENT_NAME Analysis) o2physics_add_dpl_workflow(jet-d0-ang-substructure SOURCES jetD0AngSubstructure.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(bjet-cent-mult + SOURCES bjetCentMult.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore + COMPONENT_NAME Analysis) endif() From 4ac9922b62330fe374b1124f33f9aa86bd4cefd7 Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Fri, 17 Apr 2026 18:05:23 +0900 Subject: [PATCH 08/12] update background subtraction of b-jets for multiplicity --- PWGJE/Tasks/bjetCentMult.cxx | 63 +++++++++++++++++++++++++++++++++++- 1 file changed, 62 insertions(+), 1 deletion(-) diff --git a/PWGJE/Tasks/bjetCentMult.cxx b/PWGJE/Tasks/bjetCentMult.cxx index 3d843198edc..8bd8111b200 100644 --- a/PWGJE/Tasks/bjetCentMult.cxx +++ b/PWGJE/Tasks/bjetCentMult.cxx @@ -162,6 +162,25 @@ struct BjetCentMultTask { registry.add("hn_taggedjet_3prong_Sxyz_N1_centrality", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisSxyz}, {axisMass}, {axisCentrality}}}); } } + if (doprocessRhoAreaSubSV3ProngData) { + registry.add("h_event_centrality", "", {HistType::kTH1F, {{axisCentrality}}}); + registry.add("h2_jet_pt_rhoareasubtracted_centrality", "", {HistType::kTH2F, {{axisJetPt}, {axisCentrality}}}); + registry.add("h2_jet_eta_rhoareasubtracted_centrality", "", {HistType::kTH2F, {{axisEta}, {axisCentrality}}}); + registry.add("h2_jet_phi_rhoareasubtracted_centrality", "", {HistType::kTH2F, {{axisPhi}, {axisCentrality}}}); + if (fillGeneralSVQA) { + registry.add("h2_3prong_nprongs_rhoareasubtracted_centrality", "", {HistType::kTH2F, {{axisNprongs}, {axisCentrality}}}); + registry.add("hn_jet_3prong_Sxy_rhoareasubtracted_centrality", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisLxy}, {axisSigmaLxy}, {axisSxy}, {axisCentrality}}}); + if (fillSVxyz) { + registry.add("hn_jet_3prong_Sxyz_rhoareasubtracted_centrality", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisLxyz}, {axisSigmaLxyz}, {axisSxyz}, {axisCentrality}}}); + } + } + registry.add("hn_jet_3prong_Sxy_N1_rhoareasubtracted_centrality", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisSxy}, {axisMass}, {axisCentrality}}}); + registry.add("hn_taggedjet_3prong_Sxy_N1_rhoareasubtracted_centrality", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisSxy}, {axisMass}, {axisCentrality}}}); + if (fillSVxyz) { + registry.add("hn_jet_3prong_Sxyz_N1_rhoareasubtracted_centrality", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisSxyz}, {axisMass}, {axisCentrality}}}); + registry.add("hn_taggedjet_3prong_Sxyz_N1_rhoareasubtracted_centrality", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisSxyz}, {axisMass}, {axisCentrality}}}); + } + } if (doprocessSV3ProngMCD || doprocessSV3ProngMCPMCDMatched) { registry.add("h_event_centrality", "", {HistType::kTH1F, {{axisCentrality}}}); registry.add("h3_jet_pt_centrality_flavour", "", {HistType::kTH3F, {{axisJetPt}, {axisCentrality}, {axisJetFlavour}}}); @@ -312,6 +331,47 @@ struct BjetCentMultTask { registry.fill(HIST("h2_jet_phi_part_flavour"), mcpjet.phi(), jetflavour, eventWeight); } + template + void fillRhoAreaSubtractedHistogramSV3ProngData(T const& jet, U const& /*prongs*/, float centrality, float rho) + { + if (jet.template secondaryVertices_as().size() < 1) + return; + registry.fill(HIST("h2_jet_pt_rhoareasubtracted_centrality"), jet.pt() - (rho * jet.area()), centrality); + registry.fill(HIST("h2_jet_eta_rhoareasubtracted_centrality"), jet.eta(), centrality); + registry.fill(HIST("h2_jet_phi_rhoareasubtracted_centrality"), jet.phi(), centrality); + if (fillGeneralSVQA) { + registry.fill(HIST("h2_3prong_nprongs_rhoareasubtracted_centrality"), jet.template secondaryVertices_as().size(), centrality); + for (const auto& prong : jet.template secondaryVertices_as()) { + registry.fill(HIST("hn_jet_3prong_Sxy_rhoareasubtracted_centrality"), jet.pt() - (rho * jet.area()), prong.decayLengthXY(), prong.errorDecayLengthXY(), prong.decayLengthXY() / prong.errorDecayLengthXY(), centrality); + if (fillSVxyz) { + registry.fill(HIST("hn_jet_3prong_Sxyz_rhoareasubtracted_centrality"), jet.pt() - (rho * jet.area()), prong.decayLength(), prong.errorDecayLength(), prong.decayLength() / prong.errorDecayLength(), centrality); + } + } + } + bool checkSv = false; + auto bjetCand = jettaggingutilities::jetFromProngMaxDecayLength(jet, prongCuts->at(0), prongCuts->at(1), prongCuts->at(2), prongCuts->at(4), prongCuts->at(5), false, &checkSv); + if (checkSv && jettaggingutilities::svAcceptance(bjetCand, svDispersionMax)) { + auto maxSxy = bjetCand.decayLengthXY() / bjetCand.errorDecayLengthXY(); + auto massSV = bjetCand.m(); + registry.fill(HIST("hn_jet_3prong_Sxy_N1_rhoareasubtracted_centrality"), jet.pt() - (rho * jet.area()), maxSxy, massSV, centrality); + if (jet.isTagged(BJetTaggingMethod::SV)) { + registry.fill(HIST("hn_taggedjet_3prong_Sxy_N1_rhoareasubtracted_centrality"), jet.pt() - (rho * jet.area()), maxSxy, massSV, centrality); + } + } + if (fillSVxyz) { + checkSv = false; + auto bjetCandXYZ = jettaggingutilities::jetFromProngMaxDecayLength(jet, prongCuts->at(0), prongCuts->at(1), prongCuts->at(3), prongCuts->at(4), prongCuts->at(5), true, &checkSv); + if (checkSv && jettaggingutilities::svAcceptance(bjetCandXYZ, svDispersionMax)) { + auto maxSxyz = bjetCandXYZ.decayLength() / bjetCandXYZ.errorDecayLength(); + auto massSV = bjetCandXYZ.m(); + registry.fill(HIST("hn_jet_3prong_Sxyz_N1_rhoareasubtracted_centrality"), jet.pt() - (rho * jet.area()), maxSxyz, massSV, centrality); + if (jet.isTagged(BJetTaggingMethod::SV3D)) { + registry.fill(HIST("hn_taggedjet_3prong_Sxyz_N1_rhoareasubtracted_centrality"), jet.pt() - (rho * jet.area()), maxSxyz, massSV, centrality); + } + } + } + } + template void fillHistogramSV3ProngData(T const& jet, U const& /*prongs*/, float centrality) { @@ -519,6 +579,7 @@ struct BjetCentMultTask { return; } float centrality = collision.centFT0M(); + float rho = collision.rho(); registry.fill(HIST("h_event_centrality"), centrality); for (auto const& jet : jets) { if (!jetfindingutilities::isInEtaAcceptance(jet, jetEtaCuts->at(0), jetEtaCuts->at(1), trackCuts->at(2), trackCuts->at(3))) { @@ -527,7 +588,7 @@ struct BjetCentMultTask { if (!isAcceptedJet(jet)) { continue; } - fillHistogramSV3ProngData(jet, prongs, centrality); + fillRhoAreaSubtractedHistogramSV3ProngData(jet, prongs, centrality, rho); } } PROCESS_SWITCH(BjetCentMultTask, processRhoAreaSubSV3ProngData, "Fill 3prong imformation for data jets with background subtraction", false); From 38b0955aed97b08e313156b76553f4d5dda19089 Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Fri, 17 Apr 2026 18:29:13 +0900 Subject: [PATCH 09/12] fix o2linter --- PWGJE/TableProducer/secondaryVertexReconstruction.cxx | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/PWGJE/TableProducer/secondaryVertexReconstruction.cxx b/PWGJE/TableProducer/secondaryVertexReconstruction.cxx index 401aad121ee..d4a4686ccf9 100644 --- a/PWGJE/TableProducer/secondaryVertexReconstruction.cxx +++ b/PWGJE/TableProducer/secondaryVertexReconstruction.cxx @@ -101,6 +101,8 @@ struct SecondaryVertexReconstruction { int runNumber{0}; float toMicrometers = 10000.; // from cm to µm double bz{0.}; + constexpr int TwoProngCount = 2; + constexpr int ThreeProngCount = 3; void init(InitContext const&) { @@ -241,7 +243,7 @@ struct SecondaryVertexReconstruction { double massSV = RecoDecay::m(arrayMomenta, massArray); // fill candidate table rows - if ((doprocessData3Prongs || doprocessData3ProngsExternalMagneticField) && numProngs == 3) { + if ((doprocessData3Prongs || doprocessData3ProngsExternalMagneticField) && numProngs == ThreeProngCount) { sv3prongTableData(analysisJet.globalIndex(), primaryVertex.getX(), primaryVertex.getY(), primaryVertex.getZ(), secondaryVertex[0], secondaryVertex[1], secondaryVertex[2], @@ -250,7 +252,7 @@ struct SecondaryVertexReconstruction { arrayMomenta[0][2] + arrayMomenta[1][2] + arrayMomenta[2][2], energySV, massSV, chi2PCA, dispersion, errorDecayLength, errorDecayLengthXY); svIndices.push_back(sv3prongTableData.lastIndex()); - } else if ((doprocessData2Prongs || doprocessData2ProngsExternalMagneticField) && numProngs == 2) { + } else if ((doprocessData2Prongs || doprocessData2ProngsExternalMagneticField) && numProngs == TwoProngCount) { sv2prongTableData(analysisJet.globalIndex(), primaryVertex.getX(), primaryVertex.getY(), primaryVertex.getZ(), secondaryVertex[0], secondaryVertex[1], secondaryVertex[2], @@ -259,7 +261,7 @@ struct SecondaryVertexReconstruction { arrayMomenta[0][2] + arrayMomenta[1][2], energySV, massSV, chi2PCA, dispersion, errorDecayLength, errorDecayLengthXY); svIndices.push_back(sv2prongTableData.lastIndex()); - } else if ((doprocessMCD3Prongs || doprocessMCD3ProngsExternalMagneticField) && numProngs == 3) { + } else if ((doprocessMCD3Prongs || doprocessMCD3ProngsExternalMagneticField) && numProngs == ThreeProngCount) { sv3prongTableMCD(analysisJet.globalIndex(), primaryVertex.getX(), primaryVertex.getY(), primaryVertex.getZ(), secondaryVertex[0], secondaryVertex[1], secondaryVertex[2], @@ -268,7 +270,7 @@ struct SecondaryVertexReconstruction { arrayMomenta[0][2] + arrayMomenta[1][2] + arrayMomenta[2][2], energySV, massSV, chi2PCA, dispersion, errorDecayLength, errorDecayLengthXY); svIndices.push_back(sv3prongTableMCD.lastIndex()); - } else if ((doprocessMCD2Prongs || doprocessMCD2ProngsExternalMagneticField) && numProngs == 2) { + } else if ((doprocessMCD2Prongs || doprocessMCD2ProngsExternalMagneticField) && numProngs == TwoProngCount) { sv2prongTableMCD(analysisJet.globalIndex(), primaryVertex.getX(), primaryVertex.getY(), primaryVertex.getZ(), secondaryVertex[0], secondaryVertex[1], secondaryVertex[2], From e827389b073ae036b62be1549eec54f81e1e624d Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Fri, 17 Apr 2026 18:42:26 +0900 Subject: [PATCH 10/12] fix o2linter --- PWGJE/TableProducer/secondaryVertexReconstruction.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGJE/TableProducer/secondaryVertexReconstruction.cxx b/PWGJE/TableProducer/secondaryVertexReconstruction.cxx index d4a4686ccf9..4158ebe37b3 100644 --- a/PWGJE/TableProducer/secondaryVertexReconstruction.cxx +++ b/PWGJE/TableProducer/secondaryVertexReconstruction.cxx @@ -401,5 +401,5 @@ struct SecondaryVertexReconstruction { WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { - return WorkflowSpec{adaptAnalysisTask(cfgc, TaskName{"jet-sv-reconstruction-charged"})}; // o2-linter: disable=name/o2-task + return WorkflowSpec{adaptAnalysisTask(cfgc)}; } From 2ec4bde1bb11c4426c38663e8e9a859a9d25fbbb Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Fri, 17 Apr 2026 18:45:21 +0900 Subject: [PATCH 11/12] fix magic number --- PWGJE/TableProducer/secondaryVertexReconstruction.cxx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/PWGJE/TableProducer/secondaryVertexReconstruction.cxx b/PWGJE/TableProducer/secondaryVertexReconstruction.cxx index 4158ebe37b3..09f955c4018 100644 --- a/PWGJE/TableProducer/secondaryVertexReconstruction.cxx +++ b/PWGJE/TableProducer/secondaryVertexReconstruction.cxx @@ -101,8 +101,8 @@ struct SecondaryVertexReconstruction { int runNumber{0}; float toMicrometers = 10000.; // from cm to µm double bz{0.}; - constexpr int TwoProngCount = 2; - constexpr int ThreeProngCount = 3; + static constexpr int TwoProngCount = 2; + static constexpr int ThreeProngCount = 3; void init(InitContext const&) { From b6a2eff1e5bac9d2e287b97f91b5eb5e05d70b7b Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Fri, 17 Apr 2026 18:53:50 +0900 Subject: [PATCH 12/12] fix o2linter --- PWGJE/TableProducer/secondaryVertexReconstruction.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGJE/TableProducer/secondaryVertexReconstruction.cxx b/PWGJE/TableProducer/secondaryVertexReconstruction.cxx index 09f955c4018..1afe05455f2 100644 --- a/PWGJE/TableProducer/secondaryVertexReconstruction.cxx +++ b/PWGJE/TableProducer/secondaryVertexReconstruction.cxx @@ -401,5 +401,5 @@ struct SecondaryVertexReconstruction { WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { - return WorkflowSpec{adaptAnalysisTask(cfgc)}; + return WorkflowSpec{adaptAnalysisTask(cfgc, TaskName{"jet-sv-reconstruction-charged"})}; // o2-linter: disable=name/o2-task (templated struct) }