From 52394f12fa647566bf02502cc214cb5ca1cc1b0b Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Fri, 7 Mar 2025 22:58:49 +0900 Subject: [PATCH 01/10] add validation function and small fix --- PWGJE/Tasks/jetTaggerHFQA.cxx | 96 ++++++++++++++++++++++++++++++++++- 1 file changed, 94 insertions(+), 2 deletions(-) diff --git a/PWGJE/Tasks/jetTaggerHFQA.cxx b/PWGJE/Tasks/jetTaggerHFQA.cxx index b2d1261e335..2f51f5e787f 100644 --- a/PWGJE/Tasks/jetTaggerHFQA.cxx +++ b/PWGJE/Tasks/jetTaggerHFQA.cxx @@ -59,6 +59,7 @@ struct JetTaggerHFQA { Configurable trackPtMax{"trackPtMax", 100.0, "maximum pT acceptance for tracks"}; 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 jetEtaMin{"jetEtaMin", -99.0, "minimum jet pseudorapidity"}; Configurable jetEtaMax{"jetEtaMax", 99.0, "maximum jet pseudorapidity"}; Configurable prongChi2PCAMin{"prongChi2PCAMin", 1, "minimum Chi2 PCA of decay length of prongs"}; @@ -155,6 +156,18 @@ struct JetTaggerHFQA { registry.add("h_impact_parameter_xyz", "", {HistType::kTH1F, {{axisImpactParameterXYZ}}}); registry.add("h_impact_parameter_xyz_significance", "", {HistType::kTH1F, {{axisImpactParameterXYZSignificance}}}); } + if (doprocessValFlavourDefMCD) { + registry.add("h2_flavour_dist_quark_flavour_dist_hadron", "", {HistType::kTH2F, {{axisJetFlavour}, {axisJetFlavour}}}); + registry.add("h2_flavour_const_quark_flavour_const_hadron", "", {HistType::kTH2F, {{axisJetFlavour}, {axisJetFlavour}}}); + registry.add("h2_flavour_const_hadron_flavour_dist_hadron", "", {HistType::kTH2F, {{axisJetFlavour}, {axisJetFlavour}}}); + registry.add("h2_flavour_const_quark_flavour_dist_quark", "", {HistType::kTH2F, {{axisJetFlavour}, {axisJetFlavour}}}); + } + if (doprocessValFlavourDefMCP) { + registry.add("h2_part_flavour_dist_quark_part_flavour_dist_hadron", "", {HistType::kTH2F, {{axisJetFlavour}, {axisJetFlavour}}}); + registry.add("h2_part_flavour_const_quark_part_flavour_const_hadron", "", {HistType::kTH2F, {{axisJetFlavour}, {axisJetFlavour}}}); + registry.add("h2_part_flavour_const_hadron_part_flavour_dist_hadron", "", {HistType::kTH2F, {{axisJetFlavour}, {axisJetFlavour}}}); + registry.add("h2_part_flavour_const_quark_part_flavour_dist_quark", "", {HistType::kTH2F, {{axisJetFlavour}, {axisJetFlavour}}}); + } if (doprocessIPsData) { registry.add("h_jet_pt", "", {HistType::kTH1F, {{axisJetPt}}}); registry.add("h_jet_eta", "", {HistType::kTH1F, {{axisEta}}}); @@ -443,6 +456,47 @@ struct JetTaggerHFQA { return true; } + template + void fillValidationFlavourDefMCD(T const& mcdjet, V const& tracks, W const& particles, X const& particlesPerColl, float eventWeight = 1.0) + { + float pTHat = 10. / (std::pow(eventWeight, 1.0 / pTHatExponent)); + if (mcdjet.pt() > pTHatMaxMCD * pTHat) { + return; + } + typename V::iterator hftrack; + int jetflavourConstQuark = jettaggingutilities::mcdJetFromHFShower(mcdjet, tracks, particles, maxDeltaR, true); + int jetflavourConstHadron = jettaggingutilities::mcdJetFromHFShower(mcdjet, tracks, particles, maxDeltaR, false); + int jetflavourDistQuark = -1; + int jetflavourDistHadron = -1; + for (auto const& mcpjet : mcdjet.template matchedJetGeo_as()) { + jetflavourDistQuark = jettaggingutilities::getJetFlavor(mcpjet, particlesPerColl); + jetflavourDistHadron = jettaggingutilities::getJetFlavorHadron(mcpjet, particlesPerColl); + } + if (jetflavourDistQuark < 0 || jetflavourDistHadron < 0) + return; + registry.fill(HIST("h2_flavour_dist_quark_flavour_dist_hadron"), jetflavourDistQuark, jetflavourDistHadron, eventWeight); + registry.fill(HIST("h2_flavour_const_quark_flavour_const_hadron"), jetflavourConstQuark, jetflavourConstHadron, eventWeight); + registry.fill(HIST("h2_flavour_const_hadron_flavour_dist_hadron"), jetflavourConstHadron, jetflavourDistHadron, eventWeight); + registry.fill(HIST("h2_flavour_const_quark_flavour_dist_quark"), jetflavourConstQuark, jetflavourDistQuark, eventWeight); + } + + template + void fillValidationFlavourDefMCP(T const& mcpjet, U const& particles, V const& particlesPerColl, float eventWeight = 1.0) + { + float pTHat = 10. / (std::pow(eventWeight, 1.0 / pTHatExponent)); + if (mcpjet.pt() > pTHatMaxMCP * pTHat) { + return; + } + int jetflavourConstQuark = jettaggingutilities::mcpJetFromHFShower(mcpjet, particles, maxDeltaR, true); + int jetflavourConstHadron = jettaggingutilities::mcpJetFromHFShower(mcpjet, particles, maxDeltaR, false); + int jetflavourDistQuark = jettaggingutilities::getJetFlavor(mcpjet, particlesPerColl); + int jetflavourDistHadron = jettaggingutilities::getJetFlavorHadron(mcpjet, particlesPerColl); + registry.fill(HIST("h2_part_flavour_dist_quark_part_flavour_dist_hadron"), jetflavourDistQuark, jetflavourDistHadron, eventWeight); + registry.fill(HIST("h2_part_flavour_const_quark_part_flavour_const_hadron"), jetflavourConstQuark, jetflavourConstHadron, eventWeight); + registry.fill(HIST("h2_part_flavour_const_hadron_part_flavour_dist_hadron"), jetflavourConstHadron, jetflavourDistHadron, eventWeight); + registry.fill(HIST("h2_part_flavour_const_quark_part_flavour_dist_quark"), jetflavourConstQuark, jetflavourDistQuark, eventWeight); + } + template void fillHistogramIPsData(T const& jet, U const& /*tracks*/) { @@ -1013,6 +1067,44 @@ struct JetTaggerHFQA { } PROCESS_SWITCH(JetTaggerHFQA, processTracksDca, "Fill inclusive tracks' imformation for data", false); + void processValFlavourDefMCD(soa::Filtered>::iterator const& collision, soa::Join const& mcdjets, soa::Join const& /*mcpjets*/, JetTagTracksMCD const& tracks, aod::JetParticles const& particles) + { + if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { + return; + } + for (auto const& mcdjet : mcdjets) { + auto const particlesPerColl = particles.sliceBy(particlesPerCollision, collision.mcCollisionId()); + if (!jetfindingutilities::isInEtaAcceptance(mcdjet, jetEtaMin, jetEtaMax, trackEtaMin, trackEtaMax)) { + continue; + } + if (!isAcceptedJet(mcdjet)) { + continue; + } + fillValidationFlavourDefMCD>(mcdjet, tracks, particles, particlesPerColl, mcdjet.eventWeight()); + } + } + PROCESS_SWITCH(JetTaggerHFQA, processValFlavourDefMCD, "to check the validation of jet-flavour definition when compared to distance for mcd jets", false); + + void processValFlavourDefMCP(soa::Join const& mcpjets, aod::JetParticles const& particles, aod::JetMcCollisions const&) + { + for (auto const& mcpjet : mcpjets) { + auto const particlesPerColl = particles.sliceBy(particlesPerCollision, mcpjet.globalIndex()); + if (!jetfindingutilities::isInEtaAcceptance(mcpjet, jetEtaMin, jetEtaMax, trackEtaMin, trackEtaMax)) { + continue; + } + if (!isAcceptedJet(mcpjet)) { + continue; + } + int eventWeight = mcpjet.eventWeight(); + float pTHat = 10. / (std::pow(eventWeight, 1.0 / pTHatExponent)); + if (mcpjet.pt() > pTHatMaxMCD * pTHat) { + return; + } + fillValidationFlavourDefMCP(mcpjet, particles, particlesPerColl); + } + } + PROCESS_SWITCH(JetTaggerHFQA, processValFlavourDefMCP, "to check the validation of jet-flavour definition when compared to distance for mcp jets", false); + void processIPsData(soa::Filtered::iterator const& collision, soa::Join const& jets, JetTagTracksData const& tracks) { if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { @@ -1119,7 +1211,7 @@ struct JetTaggerHFQA { if (!mcdjet.has_matchedJetGeo()) continue; for (auto const& mcpjet : mcdjet.template matchedJetGeo_as>()) { - registry.fill(HIST("h3_jet_pt_jet_pt_part_matchedgeo_flavour"), mcpjet.pt(), mcdjet.pt(), mcdjet.origin()); + registry.fill(HIST("h3_jet_pt_jet_pt_part_matchedgeo_flavour"), mcdjet.pt(), mcpjet.pt(), mcdjet.origin()); } if (!doprocessIPsMCD) fillHistogramIPsMCD(mcdjet, tracks); @@ -1150,7 +1242,7 @@ struct JetTaggerHFQA { if (mcpjet.pt() > pTHatMaxMCP * pTHat) { continue; } - registry.fill(HIST("h3_jet_pt_jet_pt_part_matchedgeo_flavour"), mcpjet.pt(), mcdjet.pt(), mcdjet.origin(), mcdjet.eventWeight()); + registry.fill(HIST("h3_jet_pt_jet_pt_part_matchedgeo_flavour"), mcdjet.pt(), mcpjet.pt(), mcdjet.origin(), mcdjet.eventWeight()); } if (!doprocessIPsMCDWeighted) fillHistogramIPsMCD(mcdjet, tracks, mcdjet.eventWeight()); From f542f109410ec75c3776851279fde19bd73dc134 Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Sat, 14 Jun 2025 12:00:23 +0900 Subject: [PATCH 02/10] fix axis name --- PWGJE/Tasks/jetTaggerHFQA.cxx | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/PWGJE/Tasks/jetTaggerHFQA.cxx b/PWGJE/Tasks/jetTaggerHFQA.cxx index 2f51f5e787f..15fd2e7d860 100644 --- a/PWGJE/Tasks/jetTaggerHFQA.cxx +++ b/PWGJE/Tasks/jetTaggerHFQA.cxx @@ -125,6 +125,8 @@ struct JetTaggerHFQA { // 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}"}; @@ -269,7 +271,7 @@ struct JetTaggerHFQA { registry.add("h2_jet_phi_part_flavour", "", {HistType::kTH2F, {{axisPhi}, {axisJetFlavour}}}); } if (doprocessIPsMCPMCDMatched || doprocessIPsMCPMCDMatchedWeighted) { - registry.add("h3_jet_pt_jet_pt_part_matchedgeo_flavour", "", {HistType::kTH3F, {{axisJetPt}, {axisJetPt}, {axisJetFlavour}}}); + registry.add("h3_jet_pt_jet_pt_part_matchedgeo_flavour", "", {HistType::kTH3F, {{axisMCDJetPt}, {axisMCPJetPt}, {axisJetFlavour}}}); } if (doprocessJPData) { if (!doprocessIPsData && !doprocessSV2ProngData && !doprocessSV3ProngData) { From 059be8ef9093dc90927a7ed99b9e9bf49569e935 Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Mon, 4 Aug 2025 18:41:09 +0900 Subject: [PATCH 03/10] update secondary contamination inside jets --- PWGJE/Tasks/jetTaggerHFQA.cxx | 38 +++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/PWGJE/Tasks/jetTaggerHFQA.cxx b/PWGJE/Tasks/jetTaggerHFQA.cxx index 09bf3d9b615..7b8a1e97955 100644 --- a/PWGJE/Tasks/jetTaggerHFQA.cxx +++ b/PWGJE/Tasks/jetTaggerHFQA.cxx @@ -166,6 +166,10 @@ struct JetTaggerHFQA { registry.add("h_impact_parameter_xyz_significance", "", {HistType::kTH1F, {{axisImpactParameterXYZSignificance}}}); } } + if (doprocessSecondaryContamination) { + registry.add("h2_impact_parameter_xy_physical_primary_flavour", "", {HistType::kTH2F, {{axisImpactParameterXY}, {axisJetFlavour}}}); + registry.add("h2_impact_parameter_xy_secondary_flavour", "", {HistType::kTH2F, {{axisImpactParameterXY}, {axisJetFlavour}}}); + } if (doprocessValFlavourDefMCD) { registry.add("h2_flavour_dist_quark_flavour_dist_hadron", "", {HistType::kTH2F, {{axisJetFlavour}, {axisJetFlavour}}}); registry.add("h2_flavour_const_quark_flavour_const_hadron", "", {HistType::kTH2F, {{axisJetFlavour}, {axisJetFlavour}}}); @@ -1095,6 +1099,40 @@ struct JetTaggerHFQA { } PROCESS_SWITCH(JetTaggerHFQA, processTracksDca, "Fill inclusive tracks' imformation for data", false); + void processSecondaryContamination(soa::Filtered>::iterator const& collision, soa::Join const& mcdjets, soa::Join const& /*mcpjets*/, JetTagTracksMCD const& tracks, aod::JetParticles const& /*particles*/) + { + if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { + return; + } + for (auto const& mcdjet : mcdjets) { + if (!jetfindingutilities::isInEtaAcceptance(mcdjet, jetEtaMin, jetEtaMax, trackEtaMin, trackEtaMax)) { + continue; + } + if (!isAcceptedJet(mcdjet)) { + continue; + } + if (!mcdjet.has_matchedJetGeo()) { + continue; + } + float pTHat = 10. / (std::pow(mcdjet.eventWeight(), 1.0 / pTHatExponent)); + if (mcdjet.pt() > pTHatMaxMCD * pTHat) { + continue; + } + int jetflavour = mcdjet.origin(); + for (auto const& track : mcdjet.template tracks_as()) { + float varImpXY = track.dcaXY() * jettaggingutilities::cmTomum; + if (!track.has_mcParticle()) continue; + auto mcParticle = track.mcParticle(); + if (mcParticle.isPhysicalPrimary()) { + registry.fill(HIST("h2_impact_parameter_xy_physical_primary_flavour"), varImpXY, jetflavour, mcdjet.eventWeight()); + } else { + registry.fill(HIST("h2_impact_parameter_xy_secondary_flavour"), varImpXY, jetflavour, mcdjet.eventWeight()); + } + } + } + } + PROCESS_SWITCH(JetTaggerHFQA, processSecondaryContamination, "Fill QA comtamination of secondary-track inside jets", false); + void processValFlavourDefMCD(soa::Filtered>::iterator const& collision, soa::Join const& mcdjets, soa::Join const& /*mcpjets*/, JetTagTracksMCD const& tracks, aod::JetParticles const& particles) { if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { From b9e68df9ae44a0d619a66cf558ef38064afdcc01 Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Sun, 10 Aug 2025 21:45:18 +0900 Subject: [PATCH 04/10] add secondary track inside jet when comapred to data with mc for systematic uncertainty --- PWGJE/Tasks/jetTaggerHFQA.cxx | 50 ++++++++++++++++++++++++++++------- 1 file changed, 40 insertions(+), 10 deletions(-) diff --git a/PWGJE/Tasks/jetTaggerHFQA.cxx b/PWGJE/Tasks/jetTaggerHFQA.cxx index 7b8a1e97955..0b502584e60 100644 --- a/PWGJE/Tasks/jetTaggerHFQA.cxx +++ b/PWGJE/Tasks/jetTaggerHFQA.cxx @@ -151,6 +151,7 @@ struct JetTaggerHFQA { 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}}"}; if (doprocessTracksDca) { if (fillIPxy) { @@ -166,9 +167,13 @@ struct JetTaggerHFQA { registry.add("h_impact_parameter_xyz_significance", "", {HistType::kTH1F, {{axisImpactParameterXYZSignificance}}}); } } - if (doprocessSecondaryContamination) { - registry.add("h2_impact_parameter_xy_physical_primary_flavour", "", {HistType::kTH2F, {{axisImpactParameterXY}, {axisJetFlavour}}}); - registry.add("h2_impact_parameter_xy_secondary_flavour", "", {HistType::kTH2F, {{axisImpactParameterXY}, {axisJetFlavour}}}); + if (doprocessTracksInJetsData) { + registry.add("h3_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}}}); + registry.add("hn_jet_pt_track_pt_impact_parameter_xy_secondary_flavour", "", {HistType::kTHnSparseF, {{axisJetPt}, {axisTrackPt}, {axisImpactParameterXY}, {axisJetFlavour}}}); + registry.add("h3_jet_pt_frac_secondary_pt_per_jet_flavour", "", {HistType::kTH3F, {{axisJetPt}, {axisFracSecPt}, {axisJetFlavour}}}); } if (doprocessValFlavourDefMCD) { registry.add("h2_flavour_dist_quark_flavour_dist_hadron", "", {HistType::kTH2F, {{axisJetFlavour}, {axisJetFlavour}}}); @@ -1099,7 +1104,27 @@ struct JetTaggerHFQA { } PROCESS_SWITCH(JetTaggerHFQA, processTracksDca, "Fill inclusive tracks' imformation for data", false); - void processSecondaryContamination(soa::Filtered>::iterator const& collision, soa::Join const& mcdjets, soa::Join const& /*mcpjets*/, JetTagTracksMCD const& tracks, aod::JetParticles const& /*particles*/) + void processTracksInJetsData(soa::Filtered::iterator const& collision, soa::Join const& jets) + { + if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { + return; + } + for (auto const& jet : jets) { + if (!jetfindingutilities::isInEtaAcceptance(jet, jetEtaMin, jetEtaMax, trackEtaMin, trackEtaMax)) { + continue; + } + if (!isAcceptedJet(jet)) { + continue; + } + 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); + } + } + } + PROCESS_SWITCH(JetTaggerHFQA, processTracksInJetsData, "Fill QA comtamination of secondary-track inside jets for data jets", false); + + void processSecondaryContaminationMCD(soa::Filtered>::iterator const& collision, soa::Join const& mcdjets, JetTagTracksMCD const& /*tracks*/, aod::JetParticles const& /*particles*/) { if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { return; @@ -1111,27 +1136,32 @@ struct JetTaggerHFQA { if (!isAcceptedJet(mcdjet)) { continue; } - if (!mcdjet.has_matchedJetGeo()) { - continue; - } float pTHat = 10. / (std::pow(mcdjet.eventWeight(), 1.0 / pTHatExponent)); if (mcdjet.pt() > pTHatMaxMCD * pTHat) { continue; } int jetflavour = mcdjet.origin(); + float secondaryPt = 0; + float totalJetPt = 0; for (auto const& track : mcdjet.template tracks_as()) { float varImpXY = track.dcaXY() * jettaggingutilities::cmTomum; if (!track.has_mcParticle()) continue; auto mcParticle = track.mcParticle(); + totalJetPt += track.pt(); if (mcParticle.isPhysicalPrimary()) { - registry.fill(HIST("h2_impact_parameter_xy_physical_primary_flavour"), varImpXY, jetflavour, mcdjet.eventWeight()); + registry.fill(HIST("hn_jet_pt_track_pt_impact_parameter_xy_physical_primary_flavour"), mcdjet.pt(), track.pt(), varImpXY, jetflavour, mcdjet.eventWeight()); } else { - registry.fill(HIST("h2_impact_parameter_xy_secondary_flavour"), varImpXY, jetflavour, mcdjet.eventWeight()); + registry.fill(HIST("hn_jet_pt_track_pt_impact_parameter_xy_secondary_flavour"), mcdjet.pt(), track.pt(), varImpXY, jetflavour, mcdjet.eventWeight()); + secondaryPt += track.pt(); } } + if (totalJetPt > 0) { + float fracSecondary = secondaryPt / totalJetPt; + registry.fill(HIST("h3_jet_pt_frac_secondary_pt_per_jet_flavour"), mcdjet.pt(), fracSecondary, jetflavour, mcdjet.eventWeight()); + } } } - PROCESS_SWITCH(JetTaggerHFQA, processSecondaryContamination, "Fill QA comtamination of secondary-track inside jets", false); + PROCESS_SWITCH(JetTaggerHFQA, processSecondaryContaminationMCD, "Fill QA comtamination of secondary-track inside jets for mcd jets", false); void processValFlavourDefMCD(soa::Filtered>::iterator const& collision, soa::Join const& mcdjets, soa::Join const& /*mcpjets*/, JetTagTracksMCD const& tracks, aod::JetParticles const& particles) { From edb921fa0b86532af83be5871c12e5bd2402db30 Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Sun, 10 Aug 2025 22:12:25 +0900 Subject: [PATCH 05/10] fix clang-format and o2-linter --- PWGJE/Tasks/jetTaggerHFQA.cxx | 31 +++++++++++++++++++------------ 1 file changed, 19 insertions(+), 12 deletions(-) diff --git a/PWGJE/Tasks/jetTaggerHFQA.cxx b/PWGJE/Tasks/jetTaggerHFQA.cxx index 0b502584e60..5ebbd7cedef 100644 --- a/PWGJE/Tasks/jetTaggerHFQA.cxx +++ b/PWGJE/Tasks/jetTaggerHFQA.cxx @@ -113,6 +113,12 @@ struct JetTaggerHFQA { ConfigurableAxis binSigmaLxyz{"binSigmaLxyz", {100, 0., 0.1}, ""}; int numberOfJetFlavourSpecies = 6; + int firstTaggerForTrackCounting = 0; + int secondTaggerForTrackCounting = 1; + int thirdTaggerForTrackCounting = 2; + float kUnsetJetAreaFraction = -98.0; + float kUnsetConstituentPtMin = -98.0; + float kUnsetConstituentPtMax = 9998.0; std::vector eventSelectionBits; int trackSelection = -1; @@ -446,14 +452,14 @@ struct JetTaggerHFQA { template bool isAcceptedJet(U const& jet) { - if (jetAreaFractionMin > -98.0) { + if (jetAreaFractionMin > kUnsetJetAreaFraction) { if (jet.area() < jetAreaFractionMin * o2::constants::math::PI * (jet.r() / 100.0) * (jet.r() / 100.0)) { return false; } } bool checkConstituentPt = true; - bool checkConstituentMinPt = (leadingConstituentPtMin > -98.0); - bool checkConstituentMaxPt = (leadingConstituentPtMax < 9998.0); + bool checkConstituentMinPt = (leadingConstituentPtMin > kUnsetConstituentPtMin); + bool checkConstituentMaxPt = (leadingConstituentPtMax < kUnsetConstituentPtMax); if (!checkConstituentMinPt && !checkConstituentMaxPt) { checkConstituentPt = false; } @@ -596,7 +602,7 @@ struct JetTaggerHFQA { if (fillIPxyz) std::sort(vecSignImpXYZSig.begin(), vecSignImpXYZSig.end(), sortImp); - if (vecSignImpXYSig.size() > 0) { // N1 + if (vecSignImpXYSig.size() > firstTaggerForTrackCounting) { // N1 if (fillIPxy) registry.fill(HIST("h2_jet_pt_sign_impact_parameter_xy_significance_N1"), jet.pt(), vecSignImpXYSig[0][0]); if (fillIPz) @@ -604,7 +610,7 @@ struct JetTaggerHFQA { if (fillIPxyz) registry.fill(HIST("h2_jet_pt_sign_impact_parameter_xyz_significance_N1"), jet.pt(), vecSignImpXYZSig[0][0]); } - if (vecSignImpXYSig.size() > 1) { // N2 + if (vecSignImpXYSig.size() > secondTaggerForTrackCounting) { // N2 if (fillIPxy) registry.fill(HIST("h2_jet_pt_sign_impact_parameter_xy_significance_N2"), jet.pt(), vecSignImpXYSig[1][0]); if (fillIPz) @@ -612,7 +618,7 @@ struct JetTaggerHFQA { if (fillIPxyz) registry.fill(HIST("h2_jet_pt_sign_impact_parameter_xyz_significance_N2"), jet.pt(), vecSignImpXYZSig[1][0]); } - if (vecSignImpXYSig.size() > 2) { // N3 + if (vecSignImpXYSig.size() > thirdTaggerForTrackCounting) { // N3 if (fillIPxy) registry.fill(HIST("h2_jet_pt_sign_impact_parameter_xy_significance_N3"), jet.pt(), vecSignImpXYSig[2][0]); if (fillIPz) @@ -750,7 +756,7 @@ struct JetTaggerHFQA { sort(vecSignImpZSig[jetflavour].begin(), vecSignImpZSig[jetflavour].end(), std::greater()); sort(vecSignImpXYZSig[jetflavour].begin(), vecSignImpXYZSig[jetflavour].end(), std::greater()); - if (vecImpXY[jetflavour].size() > 0) { // N1 + if (vecImpXY[jetflavour].size() > firstTaggerForTrackCounting) { // N1 if (fillIPxy) registry.fill(HIST("h3_jet_pt_sign_impact_parameter_xy_significance_flavour_N1"), mcdjet.pt(), vecSignImpXYSig[jetflavour][0], jetflavour, eventWeight); if (fillIPz) @@ -758,7 +764,7 @@ struct JetTaggerHFQA { if (fillIPxyz) registry.fill(HIST("h3_jet_pt_sign_impact_parameter_xyz_significance_flavour_N1"), mcdjet.pt(), vecSignImpXYZSig[jetflavour][0], jetflavour, eventWeight); } - if (vecImpXY[jetflavour].size() > 1) { // N2 + if (vecImpXY[jetflavour].size() > secondTaggerForTrackCounting) { // N2 if (fillIPxy) registry.fill(HIST("h3_jet_pt_sign_impact_parameter_xy_significance_flavour_N2"), mcdjet.pt(), vecSignImpXYSig[jetflavour][1], jetflavour, eventWeight); if (fillIPz) @@ -766,7 +772,7 @@ struct JetTaggerHFQA { if (fillIPxyz) registry.fill(HIST("h3_jet_pt_sign_impact_parameter_xyz_significance_flavour_N2"), mcdjet.pt(), vecSignImpXYZSig[jetflavour][1], jetflavour, eventWeight); } - if (vecImpXY[jetflavour].size() > 2) { // N3 + if (vecImpXY[jetflavour].size() > thirdTaggerForTrackCounting) { // N3 if (fillIPxy) registry.fill(HIST("h3_jet_pt_sign_impact_parameter_xy_significance_flavour_N3"), mcdjet.pt(), vecSignImpXYSig[jetflavour][2], jetflavour, eventWeight); if (fillIPz) @@ -1142,10 +1148,11 @@ struct JetTaggerHFQA { } int jetflavour = mcdjet.origin(); float secondaryPt = 0; - float totalJetPt = 0; + float totalJetPt = 0; for (auto const& track : mcdjet.template tracks_as()) { float varImpXY = track.dcaXY() * jettaggingutilities::cmTomum; - if (!track.has_mcParticle()) continue; + if (!track.has_mcParticle()) + continue; auto mcParticle = track.mcParticle(); totalJetPt += track.pt(); if (mcParticle.isPhysicalPrimary()) { @@ -1633,5 +1640,5 @@ using JetTaggerhfQACharged = JetTaggerHFQA(cfgc, TaskName{"jet-taggerhf-qa-charged"})}; // o2-linter: disable=name/o2-task + adaptAnalysisTask(cfgc, TaskName{"jet-taggerhf-qa-charged"})}; // o2-linter: disable=name/o2-task (wrong hyphenation) } From 93b1062c5cd8fe1e0f193485fc5c84984291ac89 Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Fri, 15 Aug 2025 20:34:42 +0900 Subject: [PATCH 06/10] change int to std::size_t --- PWGJE/Tasks/jetTaggerHFQA.cxx | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/PWGJE/Tasks/jetTaggerHFQA.cxx b/PWGJE/Tasks/jetTaggerHFQA.cxx index 5ebbd7cedef..08712885e75 100644 --- a/PWGJE/Tasks/jetTaggerHFQA.cxx +++ b/PWGJE/Tasks/jetTaggerHFQA.cxx @@ -113,9 +113,9 @@ struct JetTaggerHFQA { ConfigurableAxis binSigmaLxyz{"binSigmaLxyz", {100, 0., 0.1}, ""}; int numberOfJetFlavourSpecies = 6; - int firstTaggerForTrackCounting = 0; - int secondTaggerForTrackCounting = 1; - int thirdTaggerForTrackCounting = 2; + std::size_t firstTaggerForTrackCounting = 0; + std::size_t secondTaggerForTrackCounting = 1; + std::size_t thirdTaggerForTrackCounting = 2; float kUnsetJetAreaFraction = -98.0; float kUnsetConstituentPtMin = -98.0; float kUnsetConstituentPtMax = 9998.0; From 111dae5caf9ff46add139e7cd3f04aa3e562205d Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Tue, 19 Aug 2025 14:10:00 +0900 Subject: [PATCH 07/10] update issue of o2-linter ofr task name --- PWGJE/Tasks/jetTaggerHFQA.cxx | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/PWGJE/Tasks/jetTaggerHFQA.cxx b/PWGJE/Tasks/jetTaggerHFQA.cxx index 08712885e75..9b926238aed 100644 --- a/PWGJE/Tasks/jetTaggerHFQA.cxx +++ b/PWGJE/Tasks/jetTaggerHFQA.cxx @@ -1635,10 +1635,11 @@ using JetTaggerQAChargedDataJets = soa::Join; using JetTaggerQAChargedMCPJets = soa::Join; -using JetTaggerhfQACharged = JetTaggerHFQA; +using JetTaggerhfQaCharged = JetTaggerHFQA; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{ - adaptAnalysisTask(cfgc, TaskName{"jet-taggerhf-qa-charged"})}; // o2-linter: disable=name/o2-task (wrong hyphenation) + // adaptAnalysisTask(cfgc, TaskName{"jet-taggerhf-qa-charged"})}; // it will be added when full jets are updated + adaptAnalysisTask(cfgc)}; } From 082f5406909e0b2d1dd3c71475ebc9ab57b104aa Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Tue, 26 Aug 2025 13:47:27 +0900 Subject: [PATCH 08/10] reduce member of struct because of limit under 100 and add o2-linter option again --- PWGJE/Tasks/jetTaggerHFQA.cxx | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/PWGJE/Tasks/jetTaggerHFQA.cxx b/PWGJE/Tasks/jetTaggerHFQA.cxx index 9b926238aed..2a559870bfa 100644 --- a/PWGJE/Tasks/jetTaggerHFQA.cxx +++ b/PWGJE/Tasks/jetTaggerHFQA.cxx @@ -113,9 +113,6 @@ struct JetTaggerHFQA { ConfigurableAxis binSigmaLxyz{"binSigmaLxyz", {100, 0., 0.1}, ""}; int numberOfJetFlavourSpecies = 6; - std::size_t firstTaggerForTrackCounting = 0; - std::size_t secondTaggerForTrackCounting = 1; - std::size_t thirdTaggerForTrackCounting = 2; float kUnsetJetAreaFraction = -98.0; float kUnsetConstituentPtMin = -98.0; float kUnsetConstituentPtMax = 9998.0; @@ -537,6 +534,9 @@ struct JetTaggerHFQA { template void fillHistogramIPsData(T const& jet, U const& /*tracks*/) { + std::size_t firstTaggerForTrackCounting = 0; + std::size_t secondTaggerForTrackCounting = 1; + std::size_t thirdTaggerForTrackCounting = 2; float eventWeight = 1.0; float pTHat = 10. / (std::pow(eventWeight, 1.0 / pTHatExponent)); if (jet.pt() > pTHatMaxMCD * pTHat) { @@ -655,6 +655,9 @@ struct JetTaggerHFQA { template void fillHistogramIPsMCD(T const& mcdjet, U const& /*tracks*/, float eventWeight = 1.0) { + std::size_t firstTaggerForTrackCounting = 0; + std::size_t secondTaggerForTrackCounting = 1; + std::size_t thirdTaggerForTrackCounting = 2; float pTHat = 10. / (std::pow(eventWeight, 1.0 / pTHatExponent)); if (mcdjet.pt() > pTHatMaxMCD * pTHat) { return; @@ -1640,6 +1643,5 @@ using JetTaggerhfQaCharged = JetTaggerHFQA(cfgc, TaskName{"jet-taggerhf-qa-charged"})}; // it will be added when full jets are updated - adaptAnalysisTask(cfgc)}; + adaptAnalysisTask(cfgc, TaskName{"jet-taggerhf-qa-charged"})}; // o2-linter: disable=name/o2-task (wrong hyphenation) } From 94fbaf6a6fa03463eaae2df4d3cad6803c426d98 Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Wed, 3 Sep 2025 14:30:14 +0900 Subject: [PATCH 09/10] change comment for o2-linter --- PWGJE/Tasks/jetTaggerHFQA.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGJE/Tasks/jetTaggerHFQA.cxx b/PWGJE/Tasks/jetTaggerHFQA.cxx index 2a559870bfa..f47df984ef3 100644 --- a/PWGJE/Tasks/jetTaggerHFQA.cxx +++ b/PWGJE/Tasks/jetTaggerHFQA.cxx @@ -1643,5 +1643,5 @@ using JetTaggerhfQaCharged = JetTaggerHFQA(cfgc, TaskName{"jet-taggerhf-qa-charged"})}; // o2-linter: disable=name/o2-task (wrong hyphenation) + adaptAnalysisTask(cfgc, TaskName{"jet-taggerhf-qa-charged"})}; // o2-linter: disable=name/o2-task (templated struct) } From f4391eeb9b39fe3076de75dbd1dfda05cbddc894 Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Fri, 5 Sep 2025 00:34:04 +0900 Subject: [PATCH 10/10] change the name of const variable and move them in function --- PWGJE/Tasks/jetTaggerHFQA.cxx | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/PWGJE/Tasks/jetTaggerHFQA.cxx b/PWGJE/Tasks/jetTaggerHFQA.cxx index f47df984ef3..1cba0c2cad8 100644 --- a/PWGJE/Tasks/jetTaggerHFQA.cxx +++ b/PWGJE/Tasks/jetTaggerHFQA.cxx @@ -113,9 +113,6 @@ struct JetTaggerHFQA { ConfigurableAxis binSigmaLxyz{"binSigmaLxyz", {100, 0., 0.1}, ""}; int numberOfJetFlavourSpecies = 6; - float kUnsetJetAreaFraction = -98.0; - float kUnsetConstituentPtMin = -98.0; - float kUnsetConstituentPtMax = 9998.0; std::vector eventSelectionBits; int trackSelection = -1; @@ -449,14 +446,17 @@ struct JetTaggerHFQA { template bool isAcceptedJet(U const& jet) { - if (jetAreaFractionMin > kUnsetJetAreaFraction) { + 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 > kUnsetConstituentPtMin); - bool checkConstituentMaxPt = (leadingConstituentPtMax < kUnsetConstituentPtMax); + bool checkConstituentMinPt = (leadingConstituentPtMin > noConstituentPtMinFilter); + bool checkConstituentMaxPt = (leadingConstituentPtMax < noConstituentPtMaxFilter); if (!checkConstituentMinPt && !checkConstituentMaxPt) { checkConstituentPt = false; }