From 605d10f18b1175122b6ad692b56877b8b9d92779 Mon Sep 17 00:00:00 2001 From: Changhwan Choi Date: Wed, 12 Feb 2025 15:04:07 +0900 Subject: [PATCH 1/6] Added analysis code for b-jet tagging using GNN (bjetTaggingGNN.cxx) --- PWGJE/Tasks/CMakeLists.txt | 4 + PWGJE/Tasks/bjetTaggingGNN.cxx | 525 +++++++++++++++++++++++++++++++++ 2 files changed, 529 insertions(+) create mode 100644 PWGJE/Tasks/bjetTaggingGNN.cxx diff --git a/PWGJE/Tasks/CMakeLists.txt b/PWGJE/Tasks/CMakeLists.txt index 727ed4f4d76..1f6fc108176 100644 --- a/PWGJE/Tasks/CMakeLists.txt +++ b/PWGJE/Tasks/CMakeLists.txt @@ -248,4 +248,8 @@ o2physics_add_dpl_workflow(jet-substructure-bplus SOURCES dijetFinderQA.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(bjet-tagging-gnn + SOURCES bjetTaggingGNN.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore + COMPONENT_NAME Analysis) endif() \ No newline at end of file diff --git a/PWGJE/Tasks/bjetTaggingGNN.cxx b/PWGJE/Tasks/bjetTaggingGNN.cxx new file mode 100644 index 00000000000..b3a33c1cd01 --- /dev/null +++ b/PWGJE/Tasks/bjetTaggingGNN.cxx @@ -0,0 +1,525 @@ +// 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 bjetTaggingGNN.cxx +/// \brief b-jet tagging using GNN +/// +/// \author Changhwan Choi , Pusan National University + +#include +#include + +#include "Framework/AnalysisDataModel.h" +#include "Framework/AnalysisTask.h" +#include "Framework/ASoA.h" +#include "Framework/HistogramRegistry.h" +#include "Framework/runDataProcessing.h" +#include "PWGJE/Core/JetUtilities.h" +#include "PWGJE/Core/JetDerivedDataUtilities.h" +#include "PWGJE/Core/JetTaggingUtilities.h" +#include "PWGJE/DataModel/JetTagging.h" +#include "PWGJE/DataModel/Jet.h" + +#include "Common/Core/trackUtilities.h" +#include "Common/Core/TrackSelection.h" +#include "Common/Core/TrackSelectionDefaults.h" +#include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/TrackSelectionTables.h" +#include "Common/Core/RecoDecay.h" + +#include "Framework/Logger.h" + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; + +struct BjetTaggingGNN { + + HistogramRegistry registry; + + // event level configurables + Configurable vertexZCut{"vertexZCut", 10.0f, "Accepted z-vertex range"}; + Configurable eventSelections{"eventSelections", "sel8", "choose event selection"}; + Configurable useEventWeight{"useEventWeight", true, "Flag whether to scale histograms with the event weight"}; + + 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"}; + + // track level configurables + Configurable trackPtMin{"trackPtMin", 0.5, "minimum track pT"}; + Configurable trackPtMax{"trackPtMax", 1000.0, "maximum track pT"}; + Configurable trackEtaMin{"trackEtaMin", -0.9, "minimum track eta"}; + Configurable trackEtaMax{"trackEtaMax", 0.9, "maximum track eta"}; + + Configurable trackNppCrit{"trackNppCrit", 0.95, "track not physical primary ratio"}; + + // track level configurables + Configurable svPtMin{"svPtMin", 0.5, "minimum SV pT"}; + + // Configurable prongsigmaLxyMax{"prongsigmaLxyMax", 100, "maximum sigma of decay length of prongs on xy plane"}; + // // Configurable prongsigmaLxyzMax{"prongsigmaLxyzMax", 100, "maximum sigma of decay length of prongs on xyz plane"}; + // Configurable prongIPxyMin{"prongIPxyMin", 0.008, "minimum impact paramter of prongs on xy plane [cm]"}; + // Configurable prongIPxyMax{"prongIPxyMax", 1, "maximum impact parmeter of prongs on xy plane [cm]"}; + // Configurable prongChi2PCAMin{"prongChi2PCAMin", 4, "minimum Chi2 PCA of decay length of prongs"}; + // Configurable prongChi2PCAMax{"prongChi2PCAMax", 100, "maximum Chi2 PCA of decay length of prongs"}; + + // jet level configurables + Configurable jetPtMin{"jetPtMin", 5.0, "minimum jet pT"}; + Configurable jetPtMax{"jetPtMax", 1000.0, "maximum jet pT"}; + Configurable jetEtaMin{"jetEtaMin", -99.0, "minimum jet pseudorapidity"}; + Configurable jetEtaMax{"jetEtaMax", 99.0, "maximum jet pseudorapidity"}; + + Configurable> jetRadii{"jetRadii", std::vector{0.4}, "jet resolution parameters"}; + + Configurable doDataDriven{"doDataDriven", false, "Flag whether to use fill THnSpase for data driven methods"}; + + std::vector eventSelectionBits; + + std::vector jetRadiiValues; + + void init(InitContext const&) + { + // Seed the random number generator using current time + // std::srand(static_cast(std::time(nullptr))); + // std::srand(42); + + jetRadiiValues = (std::vector)jetRadii; + + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); + + registry.add("h_vertexZ", "Vertex Z;#it{Z} (cm)", {HistType::kTH1F, {{40, -20.0, 20.0}}}); + + const AxisSpec axisJetpT{200, 0., 200., "#it{p}_{T} (GeV/#it{c})"}; + const AxisSpec axisDb{200, -10., 20., "#it{D}_{b}"}; + const AxisSpec axisDbFine{3000, -10., 20., "#it{D}_{b}"}; + const AxisSpec axisSVMass{200, 0., 10., "#it{m}_{SV} (GeV/#it{c}^{2})"}; + const AxisSpec axisSVEnergy{200, 0., 100., "#it{E}_{SV} (GeV)"}; + const AxisSpec axisSLxy{200, 0., 100., "#it{SL}_{xy}"}; + const AxisSpec axisJetMass{200, 0., 50., "#it{m}_{jet} (GeV/#it{c}^{2})"}; + const AxisSpec axisJetProb{200, 0., 40., "-ln(JP)"}; + const AxisSpec axisNTracks{42, 0, 42, "#it{n}_{tracks}"}; + + registry.add("h_jetpT", "", {HistType::kTH1F, {axisJetpT}}); + registry.add("h_Db", "", {HistType::kTH1F, {axisDbFine}}); + registry.add("h2_jetpT_Db", "", {HistType::kTH2F, {axisJetpT, axisDb}}); + registry.add("h2_jetpT_SVMass", "", {HistType::kTH2F, {axisJetpT, axisSVMass}}); + registry.add("h2_jetpT_SVEnergy", "", {HistType::kTH2F, {axisJetpT, axisSVEnergy}}); + registry.add("h2_jetpT_SLxy", "", {HistType::kTH2F, {axisJetpT, axisSLxy}}); + registry.add("h2_jetpT_jetMass", "", {HistType::kTH2F, {axisJetpT, axisJetMass}}); + registry.add("h2_jetpT_jetProb", "", {HistType::kTH2F, {axisJetpT, axisJetProb}}); + registry.add("h2_jetpT_nTracks", "", {HistType::kTH2F, {axisJetpT, axisNTracks}}); + + registry.add("h3_jetpT_nTracks_Db", "", {HistType::kTH3F, {axisJetpT, axisNTracks, axisDb}}); + registry.add("h3_mSV_eSV_slXY", ";m_{SV};E_{SV};SL_{XY}", {HistType::kTH3F, {{110, -2., 20.}, {110, -2., 20.}, {102, -2., 100.}}}); + + if (doprocessMCJets) { + registry.add("h_jetpT_b", "b-jet", {HistType::kTH1F, {axisJetpT}}); + registry.add("h_jetpT_c", "c-jet", {HistType::kTH1F, {axisJetpT}}); + registry.add("h_jetpT_lf", "lf-jet", {HistType::kTH1F, {axisJetpT}}); + registry.add("h_Db_b", "b-jet", {HistType::kTH1F, {axisDbFine}}); + registry.add("h_Db_c", "c-jet", {HistType::kTH1F, {axisDbFine}}); + registry.add("h_Db_lf", "lf-jet", {HistType::kTH1F, {axisDbFine}}); + registry.add("h2_jetpT_Db_b", "b-jet", {HistType::kTH2F, {axisJetpT, axisDb}}); + registry.add("h2_jetpT_Db_c", "c-jet", {HistType::kTH2F, {axisJetpT, axisDb}}); + registry.add("h2_jetpT_Db_lf", "lf-jet", {HistType::kTH2F, {axisJetpT, axisDb}}); + registry.add("h2_jetpT_SVMass_b", "b-jet", {HistType::kTH2F, {axisJetpT, axisSVMass}}); + registry.add("h2_jetpT_SVMass_c", "c-jet", {HistType::kTH2F, {axisJetpT, axisSVMass}}); + registry.add("h2_jetpT_SVMass_lf", "lf-jet", {HistType::kTH2F, {axisJetpT, axisSVMass}}); + registry.add("h2_jetpT_SVEnergy_b", "b-jet", {HistType::kTH2F, {axisJetpT, axisSVEnergy}}); + registry.add("h2_jetpT_SVEnergy_c", "c-jet", {HistType::kTH2F, {axisJetpT, axisSVEnergy}}); + registry.add("h2_jetpT_SVEnergy_lf", "lf-jet", {HistType::kTH2F, {axisJetpT, axisSVEnergy}}); + registry.add("h2_jetpT_SLxy_b", "b-jet", {HistType::kTH2F, {axisJetpT, axisSLxy}}); + registry.add("h2_jetpT_SLxy_c", "c-jet", {HistType::kTH2F, {axisJetpT, axisSLxy}}); + registry.add("h2_jetpT_SLxy_lf", "lf-jet", {HistType::kTH2F, {axisJetpT, axisSLxy}}); + registry.add("h2_jetpT_jetMass_b", "b-jet", {HistType::kTH2F, {axisJetpT, axisJetMass}}); + registry.add("h2_jetpT_jetMass_c", "c-jet", {HistType::kTH2F, {axisJetpT, axisJetMass}}); + registry.add("h2_jetpT_jetMass_lf", "lf-jet", {HistType::kTH2F, {axisJetpT, axisJetMass}}); + registry.add("h2_jetpT_jetProb_b", "b-jet", {HistType::kTH2F, {axisJetpT, axisJetProb}}); + registry.add("h2_jetpT_jetProb_c", "c-jet", {HistType::kTH2F, {axisJetpT, axisJetProb}}); + registry.add("h2_jetpT_jetProb_lf", "lf-jet", {HistType::kTH2F, {axisJetpT, axisJetProb}}); + registry.add("h2_jetpT_nTracks_b", "b-jet", {HistType::kTH2F, {axisJetpT, axisNTracks}}); + registry.add("h2_jetpT_nTracks_c", "c-jet", {HistType::kTH2F, {axisJetpT, axisNTracks}}); + registry.add("h2_jetpT_nTracks_lf", "lf-jet", {HistType::kTH2F, {axisJetpT, axisNTracks}}); + registry.add("h2_Response_DetjetpT_PartjetpT", "", {HistType::kTH2F, {axisJetpT, axisJetpT}}); + registry.add("h2_Response_DetjetpT_PartjetpT_b", "b-jet", {HistType::kTH2F, {axisJetpT, axisJetpT}}); + registry.add("h2_Response_DetjetpT_PartjetpT_c", "c-jet", {HistType::kTH2F, {axisJetpT, axisJetpT}}); + registry.add("h2_Response_DetjetpT_PartjetpT_lf", "lf-jet", {HistType::kTH2F, {axisJetpT, axisJetpT}}); + registry.add("h2_jetpT_Db_lf_none", "lf-jet (none)", {HistType::kTH2F, {axisJetpT, axisDb}}); + registry.add("h2_jetpT_Db_lf_matched", "lf-jet (matched)", {HistType::kTH2F, {axisJetpT, axisDb}}); + registry.add("h2_jetpT_Db_npp", "NotPhysPrim", {HistType::kTH2F, {axisJetpT, axisDb}}); + registry.add("h2_jetpT_Db_npp_b", "NotPhysPrim b-jet", {HistType::kTH2F, {axisJetpT, axisDb}}); + registry.add("h2_jetpT_Db_npp_c", "NotPhysPrim c-jet", {HistType::kTH2F, {axisJetpT, axisDb}}); + registry.add("h2_jetpT_Db_npp_lf", "NotPhysPrim lf-jet", {HistType::kTH2F, {axisJetpT, axisDb}}); + registry.add("h_Db_npp", "NotPhysPrim", {HistType::kTH1F, {axisDbFine}}); + registry.add("h_Db_npp_b", "NotPhysPrim b-jet", {HistType::kTH1F, {axisDbFine}}); + registry.add("h_Db_npp_c", "NotPhysPrim c-jet", {HistType::kTH1F, {axisDbFine}}); + registry.add("h_Db_npp_lf", "NotPhysPrim lf-jet", {HistType::kTH1F, {axisDbFine}}); + } + + if (doprocessMCTruthJets) { + registry.add("h_jetpT_particle", "", {HistType::kTH1F, {axisJetpT}}); + registry.add("h_jetpT_particle_b", "particle b-jet", {HistType::kTH1F, {axisJetpT}}); + registry.add("h_jetpT_particle_c", "particle c-jet", {HistType::kTH1F, {axisJetpT}}); + registry.add("h_jetpT_particle_lf", "particle lf-jet", {HistType::kTH1F, {axisJetpT}}); + } + + if (doDataDriven) { + registry.add("hSparse_Incljets", "", {HistType::kTHnSparseF, {axisJetpT, axisDbFine, axisSVMass, axisSVEnergy, axisSLxy, axisJetMass, axisJetProb, axisNTracks}}); + if (doprocessMCJets) { + registry.add("hSparse_bjets", "", {HistType::kTHnSparseF, {axisJetpT, axisDbFine, axisSVMass, axisSVEnergy, axisSLxy, axisJetMass, axisJetProb, axisNTracks}}); + registry.add("hSparse_cjets", "", {HistType::kTHnSparseF, {axisJetpT, axisDbFine, axisSVMass, axisSVEnergy, axisSLxy, axisJetMass, axisJetProb, axisNTracks}}); + registry.add("hSparse_lfjets", "", {HistType::kTHnSparseF, {axisJetpT, axisDbFine, axisSVMass, axisSVEnergy, axisSLxy, axisJetMass, axisJetProb, axisNTracks}}); + registry.add("hSparse_lfjets_none", "", {HistType::kTHnSparseF, {axisJetpT, axisDbFine, axisSVMass, axisSVEnergy, axisSLxy, axisJetMass, axisJetProb, axisNTracks}}); + registry.add("hSparse_lfjets_matched", "", {HistType::kTHnSparseF, {axisJetpT, axisDbFine, axisSVMass, axisSVEnergy, axisSLxy, axisJetMass, axisJetProb, axisNTracks}}); + } + } + } + + Filter collisionFilter = nabs(aod::jcollision::posZ) < vertexZCut; + Filter trackCuts = (aod::jtrack::pt > trackPtMin && aod::jtrack::pt < trackPtMax && aod::jtrack::eta > trackEtaMin && aod::jtrack::eta < trackEtaMax); + Filter jetFilter = (aod::jet::pt >= jetPtMin && aod::jet::pt <= jetPtMax && aod::jet::eta < jetEtaMax - aod::jet::r / 100.f && aod::jet::eta > jetEtaMin + aod::jet::r / 100.f); + + using FilteredCollision = soa::Filtered>; + using DataJets = soa::Filtered>; + using JetTrackswID = soa::Filtered>; + using JetTracksMCDwID = soa::Filtered>; + using SVTable = aod::DataSecondaryVertex3Prongs; + using MCDSVTable = aod::MCDSecondaryVertex3Prongs; + + template + int analyzeJetTrackInfo(AnyCollision const& /*collision*/, AnalysisJet const& analysisJet, AnyTracks const& /*allTracks*/, int8_t jetFlavor = 0, double weight = 1.0) + { + int nTracks = 0; + for (auto& constituent : analysisJet.template tracks_as()) { + + if (constituent.pt() < trackPtMin) { + continue; + } + + ++nTracks; + } + return nTracks; + } + + template + SecondaryVertices::iterator analyzeJetSVInfo(AnalysisJet const& analysisJet, SecondaryVertices const& allSVs, bool& checkSV, int8_t jetFlavor = 0, double weight = 1.0) + { + using SVType = typename SecondaryVertices::iterator; + + // Min-heap to store the top 30 SVs by decayLengthXY/errorDecayLengthXY + auto compare = [](SVType& sv1, SVType& sv2) { + return (sv1.decayLengthXY() / sv1.errorDecayLengthXY()) > (sv2.decayLengthXY() / sv2.errorDecayLengthXY()); + }; + + auto svs = analysisJet.template secondaryVertices_as(); + + // Sort the SVs based on their decay length significance in descending order + // This is needed in order to select longest SVs since some jets could have thousands of SVs + std::sort(svs.begin(), svs.end(), compare); + + checkSV = false; + for (const auto& candSV : svs) { + + if (candSV.pt() < svPtMin) { + continue; + } + + checkSV = true; + return candSV; + + // double deltaRJetSV = jetutilities::deltaR(myJet, candSV); + // double massSV = candSV.m(); + // double energySV = candSV.e(); + } + + // No SV found + return *allSVs.begin(); + + // auto isValidSV = [this](const SVType& sv) { + // return sv.pt() > this->svPtMin; + // }; + // auto compare = [&isValidSV](const SVType& sv1, const SVType& sv2) { + // return (sv1.decayLengthXY() / sv1.errorDecayLengthXY() < sv2.decayLengthXY() / sv2.errorDecayLengthXY() && isValidSV(sv2)) || (!isValidSV(sv1) && isValidSV(sv2)); + // }; + + // auto svs = analysisJet.template secondaryVertices_as(); + // auto maxSV = std::max_element(svs.begin(), svs.end(), compare); + // checkSV = (maxSV != svs.end()) && isValidSV(*maxSV); + + // return *maxSV; + } + + void processDummy(FilteredCollision::iterator const& /*collision*/) + { + } + PROCESS_SWITCH(BjetTaggingGNN, processDummy, "Dummy process function turned on by default", true); + + void processDataJets(FilteredCollision::iterator const& collision, DataJets const& alljets, JetTrackswID const& allTracks, SVTable const& allSVs) + { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { + return; + } + + registry.fill(HIST("h_vertexZ"), collision.posZ()); + + for (const auto& analysisJet : alljets) { + + bool jetIncluded = false; + for (const auto& jetR : jetRadiiValues) { + if (analysisJet.r() == static_cast(jetR * 100)) { + jetIncluded = true; + break; + } + } + + if (!jetIncluded) { + continue; + } + + int nTracks = analyzeJetTrackInfo(collision, analysisJet, allTracks); + + float mSV = -1.f; + float eSV = -1.f; + float slXY = -1.f; + + bool checkSV; + // auto sv = jettaggingutilities::jetFromProngMaxDecayLength(analysisJet, prongChi2PCAMin, prongChi2PCAMax, prongsigmaLxyMax, prongIPxyMin, prongIPxyMax, false, &checkSV); + auto sv = analyzeJetSVInfo(analysisJet, allSVs, checkSV); + + if (checkSV) { + mSV = sv.m(); + eSV = sv.e(); + slXY = sv.decayLengthXY() / sv.errorDecayLengthXY(); + } + + registry.fill(HIST("h_jetpT"), analysisJet.pt()); + registry.fill(HIST("h_Db"), analysisJet.scoreML()); + registry.fill(HIST("h2_jetpT_Db"), analysisJet.pt(), analysisJet.scoreML()); + registry.fill(HIST("h2_jetpT_SVMass"), analysisJet.pt(), mSV); + registry.fill(HIST("h2_jetpT_SVEnergy"), analysisJet.pt(), eSV); + registry.fill(HIST("h2_jetpT_SLxy"), analysisJet.pt(), slXY); + registry.fill(HIST("h2_jetpT_jetMass"), analysisJet.pt(), analysisJet.mass()); + registry.fill(HIST("h2_jetpT_jetProb"), analysisJet.pt(), analysisJet.jetProb()); + registry.fill(HIST("h2_jetpT_nTracks"), analysisJet.pt(), nTracks); + + if (doDataDriven) { + registry.fill(HIST("hSparse_Incljets"), analysisJet.pt(), analysisJet.scoreML(), mSV, eSV, slXY, analysisJet.mass(), analysisJet.jetProb(), nTracks); + } + } + } + PROCESS_SWITCH(BjetTaggingGNN, processDataJets, "jet information in Data", false); + + using MCDJetTable = soa::Filtered>; + using MCPJetTable = soa::Filtered>; + using FilteredCollisionMCD = soa::Filtered>; + + void processMCJets(FilteredCollisionMCD::iterator const& collision, MCDJetTable const& MCDjets, MCPJetTable const& /*MCPjets*/, JetTracksMCDwID const& allTracks, MCDSVTable const& allSVs, aod::JetParticles const& /*MCParticles*/) + { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { + return; + } + + registry.fill(HIST("h_vertexZ"), collision.posZ()); + + for (const auto& analysisJet : MCDjets) { + + bool jetIncluded = false; + for (const auto& jetR : jetRadiiValues) { + if (analysisJet.r() == static_cast(jetR * 100)) { + jetIncluded = true; + break; + } + } + + if (!jetIncluded) { + continue; + } + + float weight = useEventWeight ? analysisJet.eventWeight() : 1.f; + float pTHat = 10. / (std::pow(analysisJet.eventWeight(), 1.0 / pTHatExponent)); + if (analysisJet.pt() > pTHatMaxMCD * pTHat) { + continue; + } + + int8_t jetFlavor = analysisJet.origin(); + + int nTracks = analyzeJetTrackInfo(collision, analysisJet, allTracks, jetFlavor, weight); + + int nNppTracks = 0; + for (auto& constituent : analysisJet.template tracks_as()) { + if (!constituent.has_mcParticle() || !constituent.template mcParticle_as().isPhysicalPrimary() || constituent.pt() < trackPtMin) { + ++nNppTracks; + } + } + + float mSV = -1.f; + float eSV = -1.f; + float slXY = -1.f; + + bool checkSV; + // auto sv = jettaggingutilities::jetFromProngMaxDecayLength(analysisJet, prongChi2PCAMin, prongChi2PCAMax, prongsigmaLxyMax, prongIPxyMin, prongIPxyMax, false, &checkSV); + auto sv = analyzeJetSVInfo(analysisJet, allSVs, checkSV, jetFlavor, weight); + + if (checkSV) { + mSV = sv.m(); + eSV = sv.e(); + slXY = sv.decayLengthXY() / sv.errorDecayLengthXY(); + registry.fill(HIST("h3_mSV_eSV_slXY"), mSV, eSV, slXY, weight); + } + + registry.fill(HIST("h_jetpT"), analysisJet.pt(), weight); + registry.fill(HIST("h_Db"), analysisJet.scoreML(), weight); + registry.fill(HIST("h2_jetpT_Db"), analysisJet.pt(), analysisJet.scoreML(), weight); + registry.fill(HIST("h2_jetpT_SVMass"), analysisJet.pt(), mSV, weight); + registry.fill(HIST("h2_jetpT_SVEnergy"), analysisJet.pt(), eSV, weight); + registry.fill(HIST("h2_jetpT_SLxy"), analysisJet.pt(), slXY, weight); + registry.fill(HIST("h2_jetpT_jetMass"), analysisJet.pt(), analysisJet.mass(), weight); + registry.fill(HIST("h2_jetpT_jetProb"), analysisJet.pt(), analysisJet.jetProb(), weight); + registry.fill(HIST("h2_jetpT_nTracks"), analysisJet.pt(), nTracks, weight); + + registry.fill(HIST("h3_jetpT_nTracks_Db"), analysisJet.pt(), nTracks, analysisJet.scoreML(), weight); + + if (jetFlavor == JetTaggingSpecies::beauty) { + registry.fill(HIST("h_jetpT_b"), analysisJet.pt(), weight); + registry.fill(HIST("h_Db_b"), analysisJet.scoreML(), weight); + registry.fill(HIST("h2_jetpT_Db_b"), analysisJet.pt(), analysisJet.scoreML(), weight); + registry.fill(HIST("h2_jetpT_SVMass_b"), analysisJet.pt(), mSV, weight); + registry.fill(HIST("h2_jetpT_SVEnergy_b"), analysisJet.pt(), eSV, weight); + registry.fill(HIST("h2_jetpT_SLxy_b"), analysisJet.pt(), slXY, weight); + registry.fill(HIST("h2_jetpT_jetMass_b"), analysisJet.pt(), analysisJet.mass(), weight); + registry.fill(HIST("h2_jetpT_jetProb_b"), analysisJet.pt(), analysisJet.jetProb(), weight); + registry.fill(HIST("h2_jetpT_nTracks_b"), analysisJet.pt(), nTracks, weight); + } else if (jetFlavor == JetTaggingSpecies::charm) { + registry.fill(HIST("h_jetpT_c"), analysisJet.pt(), weight); + registry.fill(HIST("h_Db_c"), analysisJet.scoreML(), weight); + registry.fill(HIST("h2_jetpT_Db_c"), analysisJet.pt(), analysisJet.scoreML(), weight); + registry.fill(HIST("h2_jetpT_SVMass_c"), analysisJet.pt(), mSV, weight); + registry.fill(HIST("h2_jetpT_SVEnergy_c"), analysisJet.pt(), eSV, weight); + registry.fill(HIST("h2_jetpT_SLxy_c"), analysisJet.pt(), slXY, weight); + registry.fill(HIST("h2_jetpT_jetMass_c"), analysisJet.pt(), analysisJet.mass(), weight); + registry.fill(HIST("h2_jetpT_jetProb_c"), analysisJet.pt(), analysisJet.jetProb(), weight); + registry.fill(HIST("h2_jetpT_nTracks_c"), analysisJet.pt(), nTracks, weight); + } else { + registry.fill(HIST("h_jetpT_lf"), analysisJet.pt(), weight); + registry.fill(HIST("h_Db_lf"), analysisJet.scoreML(), weight); + registry.fill(HIST("h2_jetpT_Db_lf"), analysisJet.pt(), analysisJet.scoreML(), weight); + registry.fill(HIST("h2_jetpT_SVMass_lf"), analysisJet.pt(), mSV, weight); + registry.fill(HIST("h2_jetpT_SVEnergy_lf"), analysisJet.pt(), eSV, weight); + registry.fill(HIST("h2_jetpT_SLxy_lf"), analysisJet.pt(), slXY, weight); + registry.fill(HIST("h2_jetpT_jetMass_lf"), analysisJet.pt(), analysisJet.mass(), weight); + registry.fill(HIST("h2_jetpT_jetProb_lf"), analysisJet.pt(), analysisJet.jetProb(), weight); + registry.fill(HIST("h2_jetpT_nTracks_lf"), analysisJet.pt(), nTracks, weight); + if (jetFlavor == JetTaggingSpecies::none) { + registry.fill(HIST("h2_jetpT_Db_lf_none"), analysisJet.pt(), analysisJet.scoreML(), weight); + } else { + registry.fill(HIST("h2_jetpT_Db_lf_matched"), analysisJet.pt(), analysisJet.scoreML(), weight); + } + } + + if (static_cast(nNppTracks) / nTracks > trackNppCrit) { + registry.fill(HIST("h_Db_npp"), analysisJet.scoreML(), weight); + registry.fill(HIST("h2_jetpT_Db_npp"), analysisJet.pt(), analysisJet.scoreML(), weight); + if (jetFlavor == JetTaggingSpecies::beauty) { + registry.fill(HIST("h_Db_npp_b"), analysisJet.scoreML(), weight); + registry.fill(HIST("h2_jetpT_Db_npp_b"), analysisJet.pt(), analysisJet.scoreML(), weight); + } else if (jetFlavor == JetTaggingSpecies::charm) { + registry.fill(HIST("h_Db_npp_c"), analysisJet.scoreML(), weight); + registry.fill(HIST("h2_jetpT_Db_npp_c"), analysisJet.pt(), analysisJet.scoreML(), weight); + } else { + registry.fill(HIST("h_Db_npp_lf"), analysisJet.scoreML(), weight); + registry.fill(HIST("h2_jetpT_Db_npp_lf"), analysisJet.pt(), analysisJet.scoreML(), weight); + } + } + + if (doDataDriven) { + registry.fill(HIST("hSparse_Incljets"), analysisJet.pt(), analysisJet.scoreML(), mSV, eSV, slXY, analysisJet.mass(), analysisJet.jetProb(), nTracks, weight); + if (jetFlavor == JetTaggingSpecies::beauty) { + registry.fill(HIST("hSparse_bjets"), analysisJet.pt(), analysisJet.scoreML(), mSV, eSV, slXY, analysisJet.mass(), analysisJet.jetProb(), nTracks, weight); + } else if (jetFlavor == JetTaggingSpecies::charm) { + registry.fill(HIST("hSparse_cjets"), analysisJet.pt(), analysisJet.scoreML(), mSV, eSV, slXY, analysisJet.mass(), analysisJet.jetProb(), nTracks, weight); + } else { + registry.fill(HIST("hSparse_lfjets"), analysisJet.pt(), analysisJet.scoreML(), mSV, eSV, slXY, analysisJet.mass(), analysisJet.jetProb(), nTracks, weight); + if (jetFlavor == JetTaggingSpecies::none) { + registry.fill(HIST("hSparse_lfjets_none"), analysisJet.pt(), analysisJet.scoreML(), mSV, eSV, slXY, analysisJet.mass(), analysisJet.jetProb(), nTracks, weight); + } else { + registry.fill(HIST("hSparse_lfjets_matched"), analysisJet.pt(), analysisJet.scoreML(), mSV, eSV, slXY, analysisJet.mass(), analysisJet.jetProb(), nTracks, weight); + } + } + } + + for (const auto& mcpjet : analysisJet.template matchedJetGeo_as()) { + if (mcpjet.pt() > pTHatMaxMCP * pTHat) { + continue; + } + + registry.fill(HIST("h2_Response_DetjetpT_PartjetpT"), analysisJet.pt(), mcpjet.pt(), weight); + if (jetFlavor == JetTaggingSpecies::beauty) { + registry.fill(HIST("h2_Response_DetjetpT_PartjetpT_b"), analysisJet.pt(), mcpjet.pt(), weight); + } else if (jetFlavor == JetTaggingSpecies::charm) { + registry.fill(HIST("h2_Response_DetjetpT_PartjetpT_c"), analysisJet.pt(), mcpjet.pt(), weight); + } else { + registry.fill(HIST("h2_Response_DetjetpT_PartjetpT_lf"), analysisJet.pt(), mcpjet.pt(), weight); + } + } + } + } + PROCESS_SWITCH(BjetTaggingGNN, processMCJets, "jet information in MC", false); + + Filter mccollisionFilter = nabs(aod::jmccollision::posZ) < vertexZCut; + using FilteredCollisionMCP = soa::Filtered; + + void processMCTruthJets(FilteredCollisionMCP::iterator const& /*collision*/, MCPJetTable const& MCPjets, aod::JetParticles const& /*MCParticles*/) + { + + for (const auto& mcpjet : MCPjets) { + + bool jetIncluded = false; + for (const auto& jetR : jetRadiiValues) { + if (mcpjet.r() == static_cast(jetR * 100)) { + jetIncluded = true; + break; + } + } + + if (!jetIncluded) { + continue; + } + + float weight = useEventWeight ? mcpjet.eventWeight() : 1.0; + float pTHat = 10. / (std::pow(mcpjet.eventWeight(), 1.0 / pTHatExponent)); + if (mcpjet.pt() > pTHatMaxMCP * pTHat) { + continue; + } + + int8_t jetFlavor = mcpjet.origin(); + + registry.fill(HIST("h_jetpT_particle"), mcpjet.pt(), weight); + + if (jetFlavor == JetTaggingSpecies::beauty) { + registry.fill(HIST("h_jetpT_particle_b"), mcpjet.pt(), weight); + } else if (jetFlavor == JetTaggingSpecies::charm) { + registry.fill(HIST("h_jetpT_particle_c"), mcpjet.pt(), weight); + } else { + registry.fill(HIST("h_jetpT_particle_lf"), mcpjet.pt(), weight); + } + } + } + PROCESS_SWITCH(BjetTaggingGNN, processMCTruthJets, "truth jet information", false); + +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{ + adaptAnalysisTask(cfgc, TaskName{"bjet-tagging-gnn"}) + }; +} From 7422dc34ab7910e6abee82377cc3fb43482225eb Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Wed, 12 Feb 2025 06:28:02 +0000 Subject: [PATCH 2/6] Please consider the following formatting changes --- PWGJE/Tasks/bjetTaggingGNN.cxx | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/PWGJE/Tasks/bjetTaggingGNN.cxx b/PWGJE/Tasks/bjetTaggingGNN.cxx index b3a33c1cd01..d4e12960219 100644 --- a/PWGJE/Tasks/bjetTaggingGNN.cxx +++ b/PWGJE/Tasks/bjetTaggingGNN.cxx @@ -514,12 +514,10 @@ struct BjetTaggingGNN { } } PROCESS_SWITCH(BjetTaggingGNN, processMCTruthJets, "truth jet information", false); - }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{ - adaptAnalysisTask(cfgc, TaskName{"bjet-tagging-gnn"}) - }; + adaptAnalysisTask(cfgc, TaskName{"bjet-tagging-gnn"})}; } From 0e086fb19e350c03e0834aa3d6d3bb41c69df882 Mon Sep 17 00:00:00 2001 From: Changhwan Choi Date: Wed, 12 Feb 2025 16:15:39 +0900 Subject: [PATCH 3/6] Resolved MegaLinter issues, changed HnSparse inputs --- PWGJE/Tasks/bjetTaggingGNN.cxx | 62 ++++++++++++---------------------- 1 file changed, 21 insertions(+), 41 deletions(-) diff --git a/PWGJE/Tasks/bjetTaggingGNN.cxx b/PWGJE/Tasks/bjetTaggingGNN.cxx index d4e12960219..e1f2cb0f818 100644 --- a/PWGJE/Tasks/bjetTaggingGNN.cxx +++ b/PWGJE/Tasks/bjetTaggingGNN.cxx @@ -16,6 +16,8 @@ #include #include +#include +#include #include "Framework/AnalysisDataModel.h" #include "Framework/AnalysisTask.h" @@ -82,19 +84,15 @@ struct BjetTaggingGNN { Configurable doDataDriven{"doDataDriven", false, "Flag whether to use fill THnSpase for data driven methods"}; - std::vector eventSelectionBits; + int eventSelection = -1; std::vector jetRadiiValues; void init(InitContext const&) { - // Seed the random number generator using current time - // std::srand(static_cast(std::time(nullptr))); - // std::srand(42); - jetRadiiValues = (std::vector)jetRadii; - eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); + eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); registry.add("h_vertexZ", "Vertex Z;#it{Z} (cm)", {HistType::kTH1F, {{40, -20.0, 20.0}}}); @@ -173,13 +171,13 @@ struct BjetTaggingGNN { } if (doDataDriven) { - registry.add("hSparse_Incljets", "", {HistType::kTHnSparseF, {axisJetpT, axisDbFine, axisSVMass, axisSVEnergy, axisSLxy, axisJetMass, axisJetProb, axisNTracks}}); + registry.add("hSparse_Incljets", "", {HistType::kTHnSparseF, {axisJetpT, axisDbFine, axisSVMass, axisJetMass, axisNTracks}}); if (doprocessMCJets) { - registry.add("hSparse_bjets", "", {HistType::kTHnSparseF, {axisJetpT, axisDbFine, axisSVMass, axisSVEnergy, axisSLxy, axisJetMass, axisJetProb, axisNTracks}}); - registry.add("hSparse_cjets", "", {HistType::kTHnSparseF, {axisJetpT, axisDbFine, axisSVMass, axisSVEnergy, axisSLxy, axisJetMass, axisJetProb, axisNTracks}}); - registry.add("hSparse_lfjets", "", {HistType::kTHnSparseF, {axisJetpT, axisDbFine, axisSVMass, axisSVEnergy, axisSLxy, axisJetMass, axisJetProb, axisNTracks}}); - registry.add("hSparse_lfjets_none", "", {HistType::kTHnSparseF, {axisJetpT, axisDbFine, axisSVMass, axisSVEnergy, axisSLxy, axisJetMass, axisJetProb, axisNTracks}}); - registry.add("hSparse_lfjets_matched", "", {HistType::kTHnSparseF, {axisJetpT, axisDbFine, axisSVMass, axisSVEnergy, axisSLxy, axisJetMass, axisJetProb, axisNTracks}}); + registry.add("hSparse_bjets", "", {HistType::kTHnSparseF, {axisJetpT, axisDbFine, axisSVMass, axisJetMass, axisNTracks}}); + registry.add("hSparse_cjets", "", {HistType::kTHnSparseF, {axisJetpT, axisDbFine, axisSVMass, axisJetMass, axisNTracks}}); + registry.add("hSparse_lfjets", "", {HistType::kTHnSparseF, {axisJetpT, axisDbFine, axisSVMass, axisJetMass, axisNTracks}}); + registry.add("hSparse_lfjets_none", "", {HistType::kTHnSparseF, {axisJetpT, axisDbFine, axisSVMass, axisJetMass, axisNTracks}}); + registry.add("hSparse_lfjets_matched", "", {HistType::kTHnSparseF, {axisJetpT, axisDbFine, axisSVMass, axisJetMass, axisNTracks}}); } } } @@ -205,6 +203,8 @@ struct BjetTaggingGNN { continue; } + // ... + ++nTracks; } return nTracks; @@ -215,15 +215,12 @@ struct BjetTaggingGNN { { using SVType = typename SecondaryVertices::iterator; - // Min-heap to store the top 30 SVs by decayLengthXY/errorDecayLengthXY auto compare = [](SVType& sv1, SVType& sv2) { return (sv1.decayLengthXY() / sv1.errorDecayLengthXY()) > (sv2.decayLengthXY() / sv2.errorDecayLengthXY()); }; auto svs = analysisJet.template secondaryVertices_as(); - // Sort the SVs based on their decay length significance in descending order - // This is needed in order to select longest SVs since some jets could have thousands of SVs std::sort(svs.begin(), svs.end(), compare); checkSV = false; @@ -235,27 +232,10 @@ struct BjetTaggingGNN { checkSV = true; return candSV; - - // double deltaRJetSV = jetutilities::deltaR(myJet, candSV); - // double massSV = candSV.m(); - // double energySV = candSV.e(); } // No SV found return *allSVs.begin(); - - // auto isValidSV = [this](const SVType& sv) { - // return sv.pt() > this->svPtMin; - // }; - // auto compare = [&isValidSV](const SVType& sv1, const SVType& sv2) { - // return (sv1.decayLengthXY() / sv1.errorDecayLengthXY() < sv2.decayLengthXY() / sv2.errorDecayLengthXY() && isValidSV(sv2)) || (!isValidSV(sv1) && isValidSV(sv2)); - // }; - - // auto svs = analysisJet.template secondaryVertices_as(); - // auto maxSV = std::max_element(svs.begin(), svs.end(), compare); - // checkSV = (maxSV != svs.end()) && isValidSV(*maxSV); - - // return *maxSV; } void processDummy(FilteredCollision::iterator const& /*collision*/) @@ -265,7 +245,7 @@ struct BjetTaggingGNN { void processDataJets(FilteredCollision::iterator const& collision, DataJets const& alljets, JetTrackswID const& allTracks, SVTable const& allSVs) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { return; } @@ -312,7 +292,7 @@ struct BjetTaggingGNN { registry.fill(HIST("h2_jetpT_nTracks"), analysisJet.pt(), nTracks); if (doDataDriven) { - registry.fill(HIST("hSparse_Incljets"), analysisJet.pt(), analysisJet.scoreML(), mSV, eSV, slXY, analysisJet.mass(), analysisJet.jetProb(), nTracks); + registry.fill(HIST("hSparse_Incljets"), analysisJet.pt(), analysisJet.scoreML(), mSV, analysisJet.mass(), nTracks); } } } @@ -324,7 +304,7 @@ struct BjetTaggingGNN { void processMCJets(FilteredCollisionMCD::iterator const& collision, MCDJetTable const& MCDjets, MCPJetTable const& /*MCPjets*/, JetTracksMCDwID const& allTracks, MCDSVTable const& allSVs, aod::JetParticles const& /*MCParticles*/) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { return; } @@ -441,17 +421,17 @@ struct BjetTaggingGNN { } if (doDataDriven) { - registry.fill(HIST("hSparse_Incljets"), analysisJet.pt(), analysisJet.scoreML(), mSV, eSV, slXY, analysisJet.mass(), analysisJet.jetProb(), nTracks, weight); + registry.fill(HIST("hSparse_Incljets"), analysisJet.pt(), analysisJet.scoreML(), mSV, analysisJet.mass(), nTracks, weight); if (jetFlavor == JetTaggingSpecies::beauty) { - registry.fill(HIST("hSparse_bjets"), analysisJet.pt(), analysisJet.scoreML(), mSV, eSV, slXY, analysisJet.mass(), analysisJet.jetProb(), nTracks, weight); + registry.fill(HIST("hSparse_bjets"), analysisJet.pt(), analysisJet.scoreML(), mSV, analysisJet.mass(), nTracks, weight); } else if (jetFlavor == JetTaggingSpecies::charm) { - registry.fill(HIST("hSparse_cjets"), analysisJet.pt(), analysisJet.scoreML(), mSV, eSV, slXY, analysisJet.mass(), analysisJet.jetProb(), nTracks, weight); + registry.fill(HIST("hSparse_cjets"), analysisJet.pt(), analysisJet.scoreML(), mSV, analysisJet.mass(), nTracks, weight); } else { - registry.fill(HIST("hSparse_lfjets"), analysisJet.pt(), analysisJet.scoreML(), mSV, eSV, slXY, analysisJet.mass(), analysisJet.jetProb(), nTracks, weight); + registry.fill(HIST("hSparse_lfjets"), analysisJet.pt(), analysisJet.scoreML(), mSV, analysisJet.mass(), nTracks, weight); if (jetFlavor == JetTaggingSpecies::none) { - registry.fill(HIST("hSparse_lfjets_none"), analysisJet.pt(), analysisJet.scoreML(), mSV, eSV, slXY, analysisJet.mass(), analysisJet.jetProb(), nTracks, weight); + registry.fill(HIST("hSparse_lfjets_none"), analysisJet.pt(), analysisJet.scoreML(), mSV, analysisJet.mass(), nTracks, weight); } else { - registry.fill(HIST("hSparse_lfjets_matched"), analysisJet.pt(), analysisJet.scoreML(), mSV, eSV, slXY, analysisJet.mass(), analysisJet.jetProb(), nTracks, weight); + registry.fill(HIST("hSparse_lfjets_matched"), analysisJet.pt(), analysisJet.scoreML(), mSV, analysisJet.mass(), nTracks, weight); } } } From 443a7437d0a8f1930aaaa1cd2e2637aa64b76b8a Mon Sep 17 00:00:00 2001 From: Changhwan Choi Date: Wed, 12 Feb 2025 17:18:01 +0900 Subject: [PATCH 4/6] Corrected usage of jetderiveddatautilities::selectCollision --- PWGJE/Tasks/bjetTaggingGNN.cxx | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/PWGJE/Tasks/bjetTaggingGNN.cxx b/PWGJE/Tasks/bjetTaggingGNN.cxx index e1f2cb0f818..64f4ee9e92a 100644 --- a/PWGJE/Tasks/bjetTaggingGNN.cxx +++ b/PWGJE/Tasks/bjetTaggingGNN.cxx @@ -84,7 +84,7 @@ struct BjetTaggingGNN { Configurable doDataDriven{"doDataDriven", false, "Flag whether to use fill THnSpase for data driven methods"}; - int eventSelection = -1; + std::vector eventSelectionBits; std::vector jetRadiiValues; @@ -92,7 +92,7 @@ struct BjetTaggingGNN { { jetRadiiValues = (std::vector)jetRadii; - eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); registry.add("h_vertexZ", "Vertex Z;#it{Z} (cm)", {HistType::kTH1F, {{40, -20.0, 20.0}}}); @@ -245,7 +245,7 @@ struct BjetTaggingGNN { void processDataJets(FilteredCollision::iterator const& collision, DataJets const& alljets, JetTrackswID const& allTracks, SVTable const& allSVs) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } @@ -304,7 +304,7 @@ struct BjetTaggingGNN { void processMCJets(FilteredCollisionMCD::iterator const& collision, MCDJetTable const& MCDjets, MCPJetTable const& /*MCPjets*/, JetTracksMCDwID const& allTracks, MCDSVTable const& allSVs, aod::JetParticles const& /*MCParticles*/) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } From 1858a7a884da5579f719811f1347faacb861bc6f Mon Sep 17 00:00:00 2001 From: Changhwan Choi Date: Wed, 12 Feb 2025 19:07:47 +0900 Subject: [PATCH 5/6] Deactivated unused variables (for temporary) --- PWGJE/Tasks/bjetTaggingGNN.cxx | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/PWGJE/Tasks/bjetTaggingGNN.cxx b/PWGJE/Tasks/bjetTaggingGNN.cxx index 64f4ee9e92a..1dc482f01d5 100644 --- a/PWGJE/Tasks/bjetTaggingGNN.cxx +++ b/PWGJE/Tasks/bjetTaggingGNN.cxx @@ -194,7 +194,7 @@ struct BjetTaggingGNN { using MCDSVTable = aod::MCDSecondaryVertex3Prongs; template - int analyzeJetTrackInfo(AnyCollision const& /*collision*/, AnalysisJet const& analysisJet, AnyTracks const& /*allTracks*/, int8_t jetFlavor = 0, double weight = 1.0) + int analyzeJetTrackInfo(AnyCollision const& /*collision*/, AnalysisJet const& analysisJet, AnyTracks const& /*allTracks*//*, int8_t jetFlavor = 0, double weight = 1.0*/) { int nTracks = 0; for (auto& constituent : analysisJet.template tracks_as()) { @@ -211,7 +211,7 @@ struct BjetTaggingGNN { } template - SecondaryVertices::iterator analyzeJetSVInfo(AnalysisJet const& analysisJet, SecondaryVertices const& allSVs, bool& checkSV, int8_t jetFlavor = 0, double weight = 1.0) + SecondaryVertices::iterator analyzeJetSVInfo(AnalysisJet const& analysisJet, SecondaryVertices const& allSVs, bool& checkSV/*, int8_t jetFlavor = 0, double weight = 1.0*/) { using SVType = typename SecondaryVertices::iterator; @@ -332,7 +332,7 @@ struct BjetTaggingGNN { int8_t jetFlavor = analysisJet.origin(); - int nTracks = analyzeJetTrackInfo(collision, analysisJet, allTracks, jetFlavor, weight); + int nTracks = analyzeJetTrackInfo(collision, analysisJet, allTracks/*, jetFlavor, weight*/); int nNppTracks = 0; for (auto& constituent : analysisJet.template tracks_as()) { @@ -347,7 +347,7 @@ struct BjetTaggingGNN { bool checkSV; // auto sv = jettaggingutilities::jetFromProngMaxDecayLength(analysisJet, prongChi2PCAMin, prongChi2PCAMax, prongsigmaLxyMax, prongIPxyMin, prongIPxyMax, false, &checkSV); - auto sv = analyzeJetSVInfo(analysisJet, allSVs, checkSV, jetFlavor, weight); + auto sv = analyzeJetSVInfo(analysisJet, allSVs, checkSV/*, jetFlavor, weight*/); if (checkSV) { mSV = sv.m(); From 0b10dcb33548cabd5f587f5a29d951a3ae66bfa5 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Wed, 12 Feb 2025 10:08:40 +0000 Subject: [PATCH 6/6] Please consider the following formatting changes --- PWGJE/Tasks/bjetTaggingGNN.cxx | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/PWGJE/Tasks/bjetTaggingGNN.cxx b/PWGJE/Tasks/bjetTaggingGNN.cxx index 1dc482f01d5..a3e453435db 100644 --- a/PWGJE/Tasks/bjetTaggingGNN.cxx +++ b/PWGJE/Tasks/bjetTaggingGNN.cxx @@ -194,7 +194,7 @@ struct BjetTaggingGNN { using MCDSVTable = aod::MCDSecondaryVertex3Prongs; template - int analyzeJetTrackInfo(AnyCollision const& /*collision*/, AnalysisJet const& analysisJet, AnyTracks const& /*allTracks*//*, int8_t jetFlavor = 0, double weight = 1.0*/) + int analyzeJetTrackInfo(AnyCollision const& /*collision*/, AnalysisJet const& analysisJet, AnyTracks const& /*allTracks*/ /*, int8_t jetFlavor = 0, double weight = 1.0*/) { int nTracks = 0; for (auto& constituent : analysisJet.template tracks_as()) { @@ -211,7 +211,7 @@ struct BjetTaggingGNN { } template - SecondaryVertices::iterator analyzeJetSVInfo(AnalysisJet const& analysisJet, SecondaryVertices const& allSVs, bool& checkSV/*, int8_t jetFlavor = 0, double weight = 1.0*/) + SecondaryVertices::iterator analyzeJetSVInfo(AnalysisJet const& analysisJet, SecondaryVertices const& allSVs, bool& checkSV /*, int8_t jetFlavor = 0, double weight = 1.0*/) { using SVType = typename SecondaryVertices::iterator; @@ -332,7 +332,7 @@ struct BjetTaggingGNN { int8_t jetFlavor = analysisJet.origin(); - int nTracks = analyzeJetTrackInfo(collision, analysisJet, allTracks/*, jetFlavor, weight*/); + int nTracks = analyzeJetTrackInfo(collision, analysisJet, allTracks /*, jetFlavor, weight*/); int nNppTracks = 0; for (auto& constituent : analysisJet.template tracks_as()) { @@ -347,7 +347,7 @@ struct BjetTaggingGNN { bool checkSV; // auto sv = jettaggingutilities::jetFromProngMaxDecayLength(analysisJet, prongChi2PCAMin, prongChi2PCAMax, prongsigmaLxyMax, prongIPxyMin, prongIPxyMax, false, &checkSV); - auto sv = analyzeJetSVInfo(analysisJet, allSVs, checkSV/*, jetFlavor, weight*/); + auto sv = analyzeJetSVInfo(analysisJet, allSVs, checkSV /*, jetFlavor, weight*/); if (checkSV) { mSV = sv.m();