From c1b57f27151d86cfed7352c6bbcdf1a6e312e7d7 Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Mon, 5 Feb 2024 17:39:34 +0900 Subject: [PATCH 1/9] First update tagging QA --- PWGJE/Core/JetTaggingUtilities.h | 34 ++- PWGJE/TableProducer/jettaggerhf.cxx | 28 +- PWGJE/Tasks/jettaggerhfQA.cxx | 396 ++++++++++++++++++++++++++++ 3 files changed, 446 insertions(+), 12 deletions(-) create mode 100644 PWGJE/Tasks/jettaggerhfQA.cxx diff --git a/PWGJE/Core/JetTaggingUtilities.h b/PWGJE/Core/JetTaggingUtilities.h index e0edfe7e611..7688b8bfee5 100644 --- a/PWGJE/Core/JetTaggingUtilities.h +++ b/PWGJE/Core/JetTaggingUtilities.h @@ -33,11 +33,14 @@ enum JetTaggingSpecies { beauty = 2, lightflavour = 3, lightquark = 4, - gluon = 5 + gluon = 5, + numberOfSpecies = 6 }; namespace jettaggingutilities { +const int cmTomum = 10000; // using cm -> #mum for impact parameter (dca) + /** * returns the globalIndex of the earliest mother of a particle in the shower. returns -1 if a suitable mother is not found * @@ -275,6 +278,35 @@ int jetOrigin(T const& jet, U const& particles, float dRMax = 0.25) return 0; } +/** + * return geometric sign which is calculated scalar product between jet axis with DCA (track propagated to PV ) + * positive and negative value are expected from primary vertex + * positive value is expected from secondary vertex + * + * @param collision which is needed external table of collision due to postion X and Y + * @param jet + * @param track which is needed each DCA_X and Y which is measured in jettaggerhfExtension.cxx + */ +template +int getGeoSign(T const& collision, U const& jet, V const& track) +{ + auto trackPar = getTrackPar(track); + auto xyz = trackPar.getXYZGlo(); + auto dcaX = xyz.X() - collision.posX(); + auto dcaY = xyz.Y() - collision.posY(); + auto sign = TMath::Sign(1, dcaX * jet.px() + dcaY * jet.py() + track.dcaZ() * jet.pz()); + if (sign < -1 || sign > 1) + LOGF(info, Form("Sign is %d", sign)); + return sign; +} + +void calculateDcaXYZ(float& dcaXYZ, float& sigmaDcaXYZ2, float dcaXY, float dcaZ, float cYY, float cZY, float cZZ, float sigmaDcaXY2, float sigmaDcaZ2) +{ + dcaXYZ = std::sqrt(dcaXY * dcaXY + dcaZ * dcaZ); + float dFdxy = 2 * dcaXY / dcaXYZ; + float dFdz = 2 * dcaZ / dcaXYZ; + sigmaDcaXYZ2 = std::abs(cYY * dFdxy * dFdxy + cZZ * dFdz * dFdz + 2 * cZY * dFdxy * dFdz); +} }; // namespace jettaggingutilities #endif // PWGJE_CORE_JETTAGGINGUTILITIES_H_ diff --git a/PWGJE/TableProducer/jettaggerhf.cxx b/PWGJE/TableProducer/jettaggerhf.cxx index da941c4825b..8e364762b34 100644 --- a/PWGJE/TableProducer/jettaggerhf.cxx +++ b/PWGJE/TableProducer/jettaggerhf.cxx @@ -12,6 +12,7 @@ // Task to produce a table joinable to the jet tables for hf jet tagging // /// \author Nima Zardoshti +/// \author Hanseo Park #include "Framework/AnalysisTask.h" #include "Framework/AnalysisDataModel.h" @@ -34,9 +35,10 @@ struct JetTaggerHFTask { Produces taggingTableData; Produces taggingTableMCD; - Configurable doAlgorithm1{"doAlgorithm1", false, "fill table for algoithm 1"}; - Configurable doAlgorithm2{"doAlgorithm2", false, "fill table for algoithm 2"}; - Configurable doAlgorithm3{"doAlgorithm3", false, "fill table for algoithm 3"}; + Configurable doWShower{"doWShower", false, "find jet origin included gluon spliting"}; // true:: remove gluon spliting + Configurable doTC{"doTC", false, "fill table for track counting algorithm"}; + Configurable doSV{"doSV", false, "fill table for secondary vertex algorithm"}; + Configurable doML{"doML", false, "fill table for machine learning"}; Configurable maxDeltaR{"maxDeltaR", 0.25, "maximum distance of jet axis from flavour initiating parton"}; void processDummy(JetCollisions const& collision) @@ -51,9 +53,9 @@ struct JetTaggerHFTask { int algorithm1 = jet.globalIndex(); // This needs to be changed. It is only done because O2Physics compilation breaks if jet is unused int algorithm2 = 0; int algorithm3 = 0; - // if (doAlgorithm1) algorithm1 = jettaggingutilities::Algorithm1((mcdjet, tracks); - // if (doAlgorithm2) algorithm2 = jettaggingutilities::Algorithm2((mcdjet, tracks); - // if (doAlgorithm3) algorithm3 = jettaggingutilities::Algorithm3((mcdjet, tracks); + // if (doTC) algorithm1 = jettaggingutilities::Algorithm1((mcdjet, tracks); + // if (doSV) algorithm2 = jettaggingutilities::Algorithm2((mcdjet, tracks); + // if (doML) algorithm3 = jettaggingutilities::Algorithm3((mcdjet, tracks); taggingTableData(0, algorithm1, algorithm2, algorithm3); } } @@ -62,14 +64,18 @@ struct JetTaggerHFTask { void processMCD(JetCollision const& collision, JetTableMCD const& mcdjets, JetTracksMCD const& tracks, JetParticles const& particles) { for (auto& mcdjet : mcdjets) { - - int origin = jettaggingutilities::mcdJetFromHFShower(mcdjet, tracks, particles, maxDeltaR); + typename JetTracksMCD::iterator hftrack; + int origin = 0; + if (!doWShower) + origin = jettaggingutilities::mcdJetFromHFShower(mcdjet, tracks, particles, maxDeltaR); + else + origin = jettaggingutilities::jetTrackFromHFShower(mcdjet, tracks, particles, hftrack); int algorithm1 = 0; int algorithm2 = 0; int algorithm3 = 0; - // if (doAlgorithm1) algorithm1 = jettaggingutilities::Algorithm1((mcdjet, tracks); - // if (doAlgorithm2) algorithm2 = jettaggingutilities::Algorithm2((mcdjet, tracks); - // if (doAlgorithm3) algorithm3 = jettaggingutilities::Algorithm3((mcdjet, tracks); + // if (doTC) algorithm1 = jettaggingutilities::Algorithm1((mcdjet, tracks); + // if (doSV) algorithm2 = jettaggingutilities::Algorithm2((mcdjet, tracks); + // if (doML) algorithm3 = jettaggingutilities::Algorithm3((mcdjet, tracks); taggingTableMCD(origin, algorithm1, algorithm2, algorithm3); } } diff --git a/PWGJE/Tasks/jettaggerhfQA.cxx b/PWGJE/Tasks/jettaggerhfQA.cxx new file mode 100644 index 00000000000..84a63f9eee4 --- /dev/null +++ b/PWGJE/Tasks/jettaggerhfQA.cxx @@ -0,0 +1,396 @@ +// 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 jettaggerhfQA.cxx +/// \brief Jet tagging general QA +/// +/// \author Hanseo Park + +#include "TF1.h" + +#include "Framework/AnalysisTask.h" +#include "Framework/AnalysisDataModel.h" +#include "Framework/ASoA.h" +#include "Framework/O2DatabasePDGPlugin.h" +#include "Framework/runDataProcessing.h" +#include "Common/Core/trackUtilities.h" + +#include "PWGHF/DataModel/CandidateReconstructionTables.h" + +#include "PWGJE/DataModel/Jet.h" +#include "PWGJE/DataModel/JetTagging.h" +#include "PWGJE/Core/JetFindingUtilities.h" +#include "PWGJE/Core/JetDerivedDataUtilities.h" +#include "PWGJE/Core/JetUtilities.h" +#include "PWGJE/Core/JetTaggingUtilities.h" + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; + +template +struct JetTaggerHFQA { + + // Cut configuration + Configurable eventSelections{"eventSelections", "sel8", "choose event selection"}; + Configurable trackSelections{"trackSelections", "globalTracks", "set track selections"}; + Configurable vertexZCut{"vertexZCut", 10.0f, "Accepted z-vertex range"}; + Configurable trackEtaMin{"trackEtaMin", -0.9, "minimum eta acceptance for tracks"}; + Configurable trackEtaMax{"trackEtaMax", 0.9, "maximum eta acceptance for tracks"}; + Configurable trackPtMin{"trackPtMin", 0.15, "minimum pT acceptance for tracks"}; + Configurable trackPtMax{"trackPtMax", 100.0, "maximum pT acceptance for tracks"}; + Configurable jetEtaMin{"jetEtaMin", -99.0, "minimum jet pseudorapidity"}; + Configurable jetEtaMax{"jetEtaMax", 99.0, "maximum jet pseudorapidity"}; + + // Binning + ConfigurableAxis binJetFlavour{"binJetFlavour", {6, -0.5, 5.5}, ""}; + ConfigurableAxis binJetPt{"binJetPt", {201, -0.5f, 200.5f}, ""}; + ConfigurableAxis binEta{"binEta", {100, -1.f, 1.f}, ""}; + ConfigurableAxis binPhi{"binPhi", {18 * 8, 0.f, 2. * TMath::Pi()}, ""}; + ConfigurableAxis binNtracks{"binNtracks", {100, -0.5, 99.5}, ""}; + ConfigurableAxis binTrackPt{"binTrackPt", {200, 0.f, 100.f}, ""}; + ConfigurableAxis binImpactParameterXY{"binImpactParameterXY", {801, -400.5f, 400.5f}, ""}; + ConfigurableAxis binImpactParameterXYSignificance{"binImpactParameterXYSignificance", {801, -40.5f, 40.5f}, ""}; // test + ConfigurableAxis binImpactParameterZ{"binImpactParameterZ", {801, -400.5f, 400.5f}, ""}; + ConfigurableAxis binImpactParameterZSignificance{"binImpactParameterZSignificance", {801, -40.5f, 40.5f}, ""}; // test + ConfigurableAxis binImpactParameterXYZ{"binImpactParameterXYZ", {2001, -1000.5f, 1000.5f}, ""}; + ConfigurableAxis binImpactParameterXYZSignificance{"binImpactParameterXYZSignificance", {2001, -1000.5f, 1000.5f}, ""}; + + // Axis + AxisSpec jetFlavourAxis = {binJetFlavour, "Jet flavour"}; + AxisSpec jetPtAxis = {binJetPt, "#it{p}_{T, jet}"}; + AxisSpec etaAxis = {binEta, "#eta"}; + AxisSpec phiAxis = {binPhi, "#phi"}; + AxisSpec ntracksAxis = {binNtracks, "#it{N}_{tracks}"}; + AxisSpec trackPtAxis = {binTrackPt, "#it{p}_{T}^{track}"}; + AxisSpec impactParameterXYAxis = {binImpactParameterXY, "IP_{XY} [#mum]"}; + AxisSpec impactParameterXYSignificanceAxis = {binImpactParameterXYSignificance, "IPs_{XY}"}; + AxisSpec impactParameterZAxis = {binImpactParameterZ, "IP_{Z} [#mum]"}; + AxisSpec impactParameterZSignificanceAxis = {binImpactParameterZSignificance, "IPs_{Z}"}; + AxisSpec impactParameterXYZAxis = {binImpactParameterXYZ, "IP_{XYZ} [#mum]"}; + AxisSpec impactParameterXYZSignificanceAxis = {binImpactParameterXYZSignificance, "IPs_{XYZ}"}; + + int eventSelection = -1; + int trackSelection = -1; + + HistogramRegistry registry{"registry", {}, OutputObjHandlingPolicy::AnalysisObject}; + + void init(InitContext const&) + { + eventSelection = jetderiveddatautilities::initialiseEventSelection(static_cast(eventSelections)); + trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); + + if (doprocessIPsData) { + registry.add("h3_jet_pt_track_pt_track_eta", "", {HistType::kTH3F, {{jetPtAxis}, {trackPtAxis}, {etaAxis}}}); + registry.add("h3_jet_pt_track_pt_track_phi", "", {HistType::kTH3F, {{jetPtAxis}, {trackPtAxis}, {phiAxis}}}); + registry.add("h3_jet_pt_track_pt_impact_parameter_xy", "", {HistType::kTH3F, {{jetPtAxis}, {trackPtAxis}, {impactParameterXYAxis}}}); + registry.add("h3_jet_pt_track_pt_sign_impact_parameter_xy", "", {HistType::kTH3F, {{jetPtAxis}, {trackPtAxis}, {impactParameterXYAxis}}}); + registry.add("h3_jet_pt_track_pt_impact_parameter_xy_significance", "", {HistType::kTH3F, {{jetPtAxis}, {trackPtAxis}, {impactParameterXYSignificanceAxis}}}); + registry.add("h3_jet_pt_track_pt_sign_impact_parameter_xy_significance", "", {HistType::kTH3F, {{jetPtAxis}, {trackPtAxis}, {impactParameterXYSignificanceAxis}}}); + + registry.add("h3_jet_pt_track_pt_impact_parameter_z", "", {HistType::kTH3F, {{jetPtAxis}, {trackPtAxis}, {impactParameterZAxis}}}); + registry.add("h3_jet_pt_track_pt_sign_impact_parameter_z", "", {HistType::kTH3F, {{jetPtAxis}, {trackPtAxis}, {impactParameterZAxis}}}); + registry.add("h3_jet_pt_track_pt_impact_parameter_z_significance", "", {HistType::kTH3F, {{jetPtAxis}, {trackPtAxis}, {impactParameterZSignificanceAxis}}}); + registry.add("h3_jet_pt_track_pt_sign_impact_parameter_z_significance", "", {HistType::kTH3F, {{jetPtAxis}, {trackPtAxis}, {impactParameterZSignificanceAxis}}}); + registry.add("h3_jet_pt_track_pt_impact_parameter_xyz", "", {HistType::kTH3F, {{jetPtAxis}, {trackPtAxis}, {impactParameterXYZAxis}}}); + registry.add("h3_jet_pt_track_pt_sign_impact_parameter_xyz", "", {HistType::kTH3F, {{jetPtAxis}, {trackPtAxis}, {impactParameterXYZAxis}}}); + registry.add("h3_jet_pt_track_pt_impact_parameter_xyz_significance", "", {HistType::kTH3F, {{jetPtAxis}, {trackPtAxis}, {impactParameterXYZSignificanceAxis}}}); + registry.add("h3_jet_pt_track_pt_sign_impact_parameter_xyz_significance", "", {HistType::kTH3F, {{jetPtAxis}, {trackPtAxis}, {impactParameterXYZSignificanceAxis}}}); + + // TC + registry.add("h3_jet_pt_track_pt_sign_impact_parameter_xy_significance_N1", "", {HistType::kTH3F, {{jetPtAxis}, {trackPtAxis}, {impactParameterXYSignificanceAxis}}}); + registry.add("h3_jet_pt_track_pt_sign_impact_parameter_xy_significance_N2", "", {HistType::kTH3F, {{jetPtAxis}, {trackPtAxis}, {impactParameterXYSignificanceAxis}}}); + registry.add("h3_jet_pt_track_pt_sign_impact_parameter_xy_significance_N3", "", {HistType::kTH3F, {{jetPtAxis}, {trackPtAxis}, {impactParameterXYSignificanceAxis}}}); + } + if (doprocessIPsMCD) { + registry.add("h3_jet_pt_track_pt_flavour", "", {HistType::kTH3F, {{jetPtAxis}, {trackPtAxis}, {jetFlavourAxis}}}); + registry.add("h3_jet_pt_track_eta_flavour", "", {HistType::kTH3F, {{jetPtAxis}, {etaAxis}, {jetFlavourAxis}}}); + registry.add("h3_jet_pt_track_phi_flavour", "", {HistType::kTH3F, {{jetPtAxis}, {phiAxis}, {jetFlavourAxis}}}); + registry.add("h3_jet_pt_impact_parameter_xy_flavour", "", {HistType::kTH3F, {{jetPtAxis}, {impactParameterXYAxis}, {jetFlavourAxis}}}); + registry.add("h3_jet_pt_sign_impact_parameter_xy_flavour", "", {HistType::kTH3F, {{jetPtAxis}, {impactParameterXYAxis}, {jetFlavourAxis}}}); + registry.add("h3_jet_pt_impact_parameter_xy_significance_flavour", "", {HistType::kTH3F, {{jetPtAxis}, {impactParameterXYSignificanceAxis}, {jetFlavourAxis}}}); + registry.add("h3_jet_pt_sign_impact_parameter_xy_significance_flavour", "", {HistType::kTH3F, {{jetPtAxis}, {impactParameterXYSignificanceAxis}, {jetFlavourAxis}}}); + registry.add("h3_jet_pt_impact_parameter_z_flavour", "", {HistType::kTH3F, {{jetPtAxis}, {impactParameterZAxis}, {jetFlavourAxis}}}); + registry.add("h3_jet_pt_sign_impact_parameter_z_flavour", "", {HistType::kTH3F, {{jetPtAxis}, {impactParameterZAxis}, {jetFlavourAxis}}}); + registry.add("h3_jet_pt_impact_parameter_z_significance_flavour", "", {HistType::kTH3F, {{jetPtAxis}, {impactParameterZSignificanceAxis}, {jetFlavourAxis}}}); + registry.add("h3_jet_pt_sign_impact_parameter_z_significance_flavour", "", {HistType::kTH3F, {{jetPtAxis}, {impactParameterZSignificanceAxis}, {jetFlavourAxis}}}); + registry.add("h3_jet_pt_impact_parameter_xyz_flavour", "", {HistType::kTH3F, {{jetPtAxis}, {impactParameterXYZAxis}, {jetFlavourAxis}}}); + registry.add("h3_jet_pt_sign_impact_parameter_xyz_flavour", "", {HistType::kTH3F, {{jetPtAxis}, {impactParameterXYZAxis}, {jetFlavourAxis}}}); + registry.add("h3_jet_pt_impact_parameter_xyz_significance_flavour", "", {HistType::kTH3F, {{jetPtAxis}, {impactParameterXYZSignificanceAxis}, {jetFlavourAxis}}}); + registry.add("h3_jet_pt_sign_impact_parameter_xyz_significance_flavour", "", {HistType::kTH3F, {{jetPtAxis}, {impactParameterXYZSignificanceAxis}, {jetFlavourAxis}}}); + + registry.add("h3_track_pt_impact_parameter_xy_flavour", "", {HistType::kTH3F, {{trackPtAxis}, {impactParameterXYAxis}, {jetFlavourAxis}}}); + registry.add("h3_track_pt_sign_impact_parameter_xy_flavour", "", {HistType::kTH3F, {{trackPtAxis}, {impactParameterXYSignificanceAxis}, {jetFlavourAxis}}}); + registry.add("h3_track_pt_impact_parameter_xy_significance_flavour", "", {HistType::kTH3F, {{trackPtAxis}, {impactParameterXYAxis}, {jetFlavourAxis}}}); + registry.add("h3_track_pt_sign_impact_parameter_xy_significance_flavour", "", {HistType::kTH3F, {{trackPtAxis}, {impactParameterXYSignificanceAxis}, {jetFlavourAxis}}}); + registry.add("h3_track_pt_impact_parameter_z_flavour", "", {HistType::kTH3F, {{trackPtAxis}, {impactParameterZAxis}, {jetFlavourAxis}}}); + registry.add("h3_track_pt_sign_impact_parameter_z_flavour", "", {HistType::kTH3F, {{trackPtAxis}, {impactParameterZSignificanceAxis}, {jetFlavourAxis}}}); + registry.add("h3_track_pt_impact_parameter_z_significance_flavour", "", {HistType::kTH3F, {{trackPtAxis}, {impactParameterZAxis}, {jetFlavourAxis}}}); + registry.add("h3_track_pt_sign_impact_parameter_z_significance_flavour", "", {HistType::kTH3F, {{trackPtAxis}, {impactParameterZSignificanceAxis}, {jetFlavourAxis}}}); + registry.add("h3_track_pt_impact_parameter_xyz_flavour", "", {HistType::kTH3F, {{trackPtAxis}, {impactParameterXYZAxis}, {jetFlavourAxis}}}); + registry.add("h3_track_pt_sign_impact_parameter_xyz_flavour", "", {HistType::kTH3F, {{trackPtAxis}, {impactParameterXYZSignificanceAxis}, {jetFlavourAxis}}}); + registry.add("h3_track_pt_impact_parameter_xyz_significance_flavour", "", {HistType::kTH3F, {{trackPtAxis}, {impactParameterXYZAxis}, {jetFlavourAxis}}}); + registry.add("h3_track_pt_sign_impact_parameter_xyz_significance_flavour", "", {HistType::kTH3F, {{trackPtAxis}, {impactParameterXYZSignificanceAxis}, {jetFlavourAxis}}}); + + // TC + registry.add("h3_jet_pt_sign_impact_parameter_xy_significance_flavour_N1", "", {HistType::kTH3F, {{jetPtAxis}, {impactParameterXYSignificanceAxis}, {jetFlavourAxis}}}); + registry.add("h3_jet_pt_sign_impact_parameter_xy_significance_flavour_N2", "", {HistType::kTH3F, {{jetPtAxis}, {impactParameterXYSignificanceAxis}, {jetFlavourAxis}}}); + registry.add("h3_jet_pt_sign_impact_parameter_xy_significance_flavour_N3", "", {HistType::kTH3F, {{jetPtAxis}, {impactParameterXYSignificanceAxis}, {jetFlavourAxis}}}); + registry.add("h3_jet_pt_sign_impact_parameter_z_significance_flavour_N1", "", {HistType::kTH3F, {{jetPtAxis}, {impactParameterZSignificanceAxis}, {jetFlavourAxis}}}); + registry.add("h3_jet_pt_sign_impact_parameter_z_significance_flavour_N2", "", {HistType::kTH3F, {{jetPtAxis}, {impactParameterZSignificanceAxis}, {jetFlavourAxis}}}); + registry.add("h3_jet_pt_sign_impact_parameter_z_significance_flavour_N3", "", {HistType::kTH3F, {{jetPtAxis}, {impactParameterZSignificanceAxis}, {jetFlavourAxis}}}); + registry.add("h3_jet_pt_sign_impact_parameter_xyz_significance_flavour_N1", "", {HistType::kTH3F, {{jetPtAxis}, {impactParameterXYZSignificanceAxis}, {jetFlavourAxis}}}); + registry.add("h3_jet_pt_sign_impact_parameter_xyz_significance_flavour_N2", "", {HistType::kTH3F, {{jetPtAxis}, {impactParameterXYZSignificanceAxis}, {jetFlavourAxis}}}); + registry.add("h3_jet_pt_sign_impact_parameter_xyz_significance_flavour_N3", "", {HistType::kTH3F, {{jetPtAxis}, {impactParameterXYZSignificanceAxis}, {jetFlavourAxis}}}); + } + } + + Filter trackCuts = (aod::jtrack::pt >= trackPtMin && aod::jtrack::pt < trackPtMax && aod::jtrack::eta > trackEtaMin && aod::jtrack::eta < trackEtaMax); + Filter eventCuts = (nabs(aod::jcollision::posZ) < vertexZCut); + + using JetTagTracksData = soa::Join; + using JetTagTracksMCD = soa::Join; + using OriTracksData = soa::Join; + using OriTracksMCD = soa::Join; + + template + void fillHistogramIPsData(T const& collision, U const& jets, V const& tracks) + { + for (auto& jet : jets) { + if (!jetfindingutilities::isInEtaAcceptance(jet, jetEtaMin, jetEtaMax, trackEtaMin, trackEtaMax)) { + continue; + } + std::vector> TracksImpXY, TracksSignImpXY, TracksImpXYSig, TracksSignImpXYSig; + std::vector> TracksImpZ, TracksSignImpZ, TracksImpZSig, TracksSignImpZSig; + std::vector> TracksImpXYZ, TracksSignImpXYZ, TracksImpXYZSig, TracksSignImpXYZSig; + for (auto& jtrack : jet.template tracks_as()) { + auto track = jtrack.template track_as(); + + // General parameters + registry.fill(HIST("h3_jet_pt_track_pt_track_eta"), jet.pt(), track.pt(), track.eta()); + registry.fill(HIST("h3_jet_pt_track_pt_track_phi"), jet.pt(), track.pt(), track.phi()); + + float varImpXY, varSignImpXY, varImpXYSig, varSignImpXYSig, varImpZ, varSignImpZ, varImpZSig, varSignImpZSig, varImpXYZ, varSignImpXYZ, varImpXYZSig, varSignImpXYZSig; + int geoSign = jettaggingutilities::getGeoSign(collision, jet, track); + varImpXY = track.dcaXY() * jettaggingutilities::cmTomum; + varSignImpXY = geoSign * TMath::Abs(track.dcaXY()) * jettaggingutilities::cmTomum; + varImpXYSig = track.dcaXY() / TMath::Sqrt(track.sigmaDcaXY2()); + varSignImpXYSig = geoSign * TMath::Abs(track.dcaXY()) / TMath::Sqrt(track.sigmaDcaXY2()); + varImpZ = track.dcaZ() * jettaggingutilities::cmTomum; + varSignImpZ = geoSign * TMath::Abs(track.dcaZ()) * jettaggingutilities::cmTomum; + varImpZSig = track.dcaZ() / TMath::Sqrt(track.sigmaDcaZ2()); + varSignImpZSig = geoSign * TMath::Abs(track.dcaZ()) / TMath::Sqrt(track.sigmaDcaZ2()); + float dcaXYZ, sigmaDcaXYZ2; + jettaggingutilities::calculateDcaXYZ(dcaXYZ, sigmaDcaXYZ2, track.dcaXY(), track.dcaZ(), track.cYY(), track.cZY(), track.cZZ(), track.sigmaDcaXY2(), track.sigmaDcaZ2()); + varImpXYZ = dcaXYZ * jettaggingutilities::cmTomum; + varSignImpXYZ = geoSign * TMath::Abs(dcaXYZ) * jettaggingutilities::cmTomum; + varImpXYZSig = dcaXYZ / TMath::Sqrt(sigmaDcaXYZ2); + varSignImpXYZSig = geoSign * TMath::Abs(dcaXYZ) / TMath::Sqrt(sigmaDcaXYZ2); + + registry.fill(HIST("h3_jet_pt_track_pt_impact_parameter_xy"), jet.pt(), track.pt(), varImpXY); + registry.fill(HIST("h3_jet_pt_track_pt_sign_impact_parameter_xy"), jet.pt(), track.pt(), varSignImpXY); + registry.fill(HIST("h3_jet_pt_track_pt_impact_parameter_xy_significance"), jet.pt(), track.pt(), varImpXYSig); + registry.fill(HIST("h3_jet_pt_track_pt_sign_impact_parameter_xy_significance"), jet.pt(), track.pt(), varSignImpXYSig); + + registry.fill(HIST("h3_jet_pt_track_pt_impact_parameter_z"), jet.pt(), track.pt(), varImpZ); + registry.fill(HIST("h3_jet_pt_track_pt_sign_impact_parameter_z"), jet.pt(), track.pt(), varSignImpZ); + registry.fill(HIST("h3_jet_pt_track_pt_impact_parameter_z_significance"), jet.pt(), track.pt(), varImpZSig); + registry.fill(HIST("h3_jet_pt_track_pt_sign_impact_parameter_z_significance"), jet.pt(), track.pt(), varSignImpZSig); + registry.fill(HIST("h3_jet_pt_track_pt_impact_parameter_xyz"), jet.pt(), track.pt(), varImpXYZ); + registry.fill(HIST("h3_jet_pt_track_pt_sign_impact_parameter_xyz"), jet.pt(), track.pt(), varSignImpXYZ); + registry.fill(HIST("h3_jet_pt_track_pt_impact_parameter_xyz_significance"), jet.pt(), track.pt(), varImpXYZSig); + registry.fill(HIST("h3_jet_pt_track_pt_sign_impact_parameter_xyz_significance"), jet.pt(), track.pt(), varSignImpXYZSig); + + TracksImpXY.push_back({varImpXY, track.pt()}); + TracksSignImpXY.push_back({varSignImpXY, track.pt()}); + TracksImpXYSig.push_back({varImpXYSig, track.pt()}); + TracksSignImpXYSig.push_back({varSignImpXYSig, track.pt()}); + } + auto sortImp = [](const std::vector& a, const std::vector& b) { + return a[0] > b[0]; + }; + + std::sort(TracksImpXY.begin(), TracksImpXY.end(), sortImp); + std::sort(TracksSignImpXY.begin(), TracksSignImpXY.end(), sortImp); + std::sort(TracksImpXYSig.begin(), TracksImpXYSig.end(), sortImp); + std::sort(TracksSignImpXYSig.begin(), TracksSignImpXYSig.end(), sortImp); + + if (TracksImpXY.size() > 0) { // N1 + registry.fill(HIST("h3_jet_pt_track_pt_sign_impact_parameter_xy_significance_N1"), jet.pt(), TracksSignImpXYSig[0][1], TracksSignImpXYSig[0][0]); + } + + if (TracksImpXY.size() > 1) { // N2 + registry.fill(HIST("h3_jet_pt_track_pt_sign_impact_parameter_xy_significance_N2"), jet.pt(), TracksSignImpXYSig[1][1], TracksSignImpXYSig[1][0]); + } + + if (TracksImpXY.size() > 2) { // N3 + registry.fill(HIST("h3_jet_pt_track_pt_sign_impact_parameter_xy_significance_N3"), jet.pt(), TracksSignImpXYSig[2][1], TracksSignImpXYSig[2][0]); + } + } + } + + template + void fillHistogramIPsMCD(T const& collision, U const& mcdjets, V const& tracks) + { + int numberOfJetFlavourSpecies = JetTaggingSpecies::numberOfSpecies; + for (auto& mcdjet : mcdjets) { + if (!jetfindingutilities::isInEtaAcceptance(mcdjet, jetEtaMin, jetEtaMax, trackEtaMin, trackEtaMax)) { + continue; + } + std::vector TracksImpXY[numberOfJetFlavourSpecies], TracksSignImpXY[numberOfJetFlavourSpecies], TracksImpXYSig[numberOfJetFlavourSpecies], TracksSignImpXYSig[numberOfJetFlavourSpecies]; + std::vector TracksImpZ[numberOfJetFlavourSpecies], TracksSignImpZ[numberOfJetFlavourSpecies], TracksImpZSig[numberOfJetFlavourSpecies], TracksSignImpZSig[numberOfJetFlavourSpecies]; + std::vector TracksImpXYZ[numberOfJetFlavourSpecies], TracksSignImpXYZ[numberOfJetFlavourSpecies], TracksImpXYZSig[numberOfJetFlavourSpecies], TracksSignImpXYZSig[numberOfJetFlavourSpecies]; + int jetflavour = mcdjet.origin(); + if (jetflavour == JetTaggingSpecies::none) { + LOGF(debug, "NOT DEFINE JET FLAVOR"); + } + for (auto& jtrack : mcdjet.template tracks_as()) { + auto track = jtrack.template track_as(); + // General parameters + registry.fill(HIST("h3_jet_pt_track_pt_flavour"), mcdjet.pt(), track.pt(), jetflavour); + registry.fill(HIST("h3_jet_pt_track_eta_flavour"), mcdjet.pt(), track.eta(), jetflavour); + registry.fill(HIST("h3_jet_pt_track_phi_flavour"), mcdjet.pt(), track.phi(), jetflavour); + + float varImpXY, varSignImpXY, varImpXYSig, varSignImpXYSig, varImpZ, varSignImpZ, varImpZSig, varSignImpZSig, varImpXYZ, varSignImpXYZ, varImpXYZSig, varSignImpXYZSig; + int geoSign = jettaggingutilities::getGeoSign(collision, mcdjet, track); + varImpXY = track.dcaXY() * jettaggingutilities::cmTomum; + varSignImpXY = geoSign * TMath::Abs(track.dcaXY()) * jettaggingutilities::cmTomum; + varImpXYSig = track.dcaXY() / TMath::Sqrt(track.sigmaDcaXY2()); + varSignImpXYSig = geoSign * TMath::Abs(track.dcaXY()) / TMath::Sqrt(track.sigmaDcaXY2()); + varImpZ = track.dcaZ() * jettaggingutilities::cmTomum; + varSignImpZ = geoSign * TMath::Abs(track.dcaZ()) * jettaggingutilities::cmTomum; + varImpZSig = track.dcaZ() / TMath::Sqrt(track.sigmaDcaZ2()); + varSignImpZSig = geoSign * TMath::Abs(track.dcaZ()) / TMath::Sqrt(track.sigmaDcaZ2()); + float dcaXYZ, sigmaDcaXYZ2; + jettaggingutilities::calculateDcaXYZ(dcaXYZ, sigmaDcaXYZ2, track.dcaXY(), track.dcaZ(), track.cYY(), track.cZY(), track.cZZ(), track.sigmaDcaXY2(), track.sigmaDcaZ2()); + varImpXYZ = dcaXYZ * jettaggingutilities::cmTomum; + varSignImpXYZ = geoSign * TMath::Abs(dcaXYZ) * jettaggingutilities::cmTomum; + varImpXYZSig = dcaXYZ / TMath::Sqrt(sigmaDcaXYZ2); + varSignImpXYZSig = geoSign * TMath::Abs(dcaXYZ) / TMath::Sqrt(sigmaDcaXYZ2); + + registry.fill(HIST("h3_jet_pt_impact_parameter_xy_flavour"), mcdjet.pt(), varImpXY, jetflavour); + registry.fill(HIST("h3_jet_pt_sign_impact_parameter_xy_flavour"), mcdjet.pt(), varSignImpXY, jetflavour); + registry.fill(HIST("h3_jet_pt_impact_parameter_xy_significance_flavour"), mcdjet.pt(), varImpXYSig, jetflavour); + registry.fill(HIST("h3_jet_pt_sign_impact_parameter_xy_significance_flavour"), mcdjet.pt(), varSignImpXYSig, jetflavour); + + registry.fill(HIST("h3_jet_pt_impact_parameter_z_flavour"), mcdjet.pt(), varImpZ, jetflavour); + registry.fill(HIST("h3_jet_pt_sign_impact_parameter_z_flavour"), mcdjet.pt(), varSignImpZ, jetflavour); + registry.fill(HIST("h3_jet_pt_impact_parameter_z_significance_flavour"), mcdjet.pt(), varImpZSig, jetflavour); + registry.fill(HIST("h3_jet_pt_sign_impact_parameter_z_significance_flavour"), mcdjet.pt(), varSignImpZSig, jetflavour); + registry.fill(HIST("h3_jet_pt_impact_parameter_xyz_flavour"), mcdjet.pt(), varImpXYZ, jetflavour); + registry.fill(HIST("h3_jet_pt_sign_impact_parameter_xyz_flavour"), mcdjet.pt(), varSignImpXYZ, jetflavour); + registry.fill(HIST("h3_jet_pt_impact_parameter_xyz_significance_flavour"), mcdjet.pt(), varImpXYZSig, jetflavour); + registry.fill(HIST("h3_jet_pt_sign_impact_parameter_xyz_significance_flavour"), mcdjet.pt(), varSignImpXYZSig, jetflavour); + registry.fill(HIST("h3_track_pt_impact_parameter_xy_flavour"), track.pt(), varImpXY, jetflavour); + registry.fill(HIST("h3_track_pt_sign_impact_parameter_xy_flavour"), track.pt(), varSignImpXY, jetflavour); + registry.fill(HIST("h3_track_pt_impact_parameter_xy_significance_flavour"), track.pt(), varImpXYSig, jetflavour); + registry.fill(HIST("h3_track_pt_sign_impact_parameter_xy_significance_flavour"), track.pt(), varSignImpXYSig, jetflavour); + registry.fill(HIST("h3_track_pt_impact_parameter_z_flavour"), track.pt(), varImpZ, jetflavour); + registry.fill(HIST("h3_track_pt_sign_impact_parameter_z_flavour"), track.pt(), varSignImpZ, jetflavour); + registry.fill(HIST("h3_track_pt_impact_parameter_z_significance_flavour"), track.pt(), varImpZSig, jetflavour); + registry.fill(HIST("h3_track_pt_sign_impact_parameter_z_significance_flavour"), track.pt(), varSignImpZSig, jetflavour); + registry.fill(HIST("h3_track_pt_impact_parameter_xyz_flavour"), track.pt(), varImpXYZ, jetflavour); + registry.fill(HIST("h3_track_pt_sign_impact_parameter_xyz_flavour"), track.pt(), varSignImpXYZ, jetflavour); + registry.fill(HIST("h3_track_pt_impact_parameter_xyz_significance_flavour"), track.pt(), varImpXYZSig, jetflavour); + registry.fill(HIST("h3_track_pt_sign_impact_parameter_xyz_significance_flavour"), track.pt(), varSignImpXYZSig, jetflavour); + + // For TC + TracksImpXY[jetflavour].push_back(varImpXY); + TracksSignImpXY[jetflavour].push_back(varSignImpXY); + TracksImpXYSig[jetflavour].push_back(varImpXYSig); + TracksSignImpXYSig[jetflavour].push_back(varSignImpXYSig); + TracksImpZ[jetflavour].push_back(varImpZ); + TracksSignImpZ[jetflavour].push_back(varSignImpZ); + TracksImpZSig[jetflavour].push_back(varImpZSig); + TracksSignImpZSig[jetflavour].push_back(varSignImpZSig); + TracksImpXYZ[jetflavour].push_back(varImpXYZ); + TracksSignImpXYZ[jetflavour].push_back(varSignImpXYZ); + TracksImpXYZSig[jetflavour].push_back(varImpXYZSig); + TracksSignImpXYZSig[jetflavour].push_back(varSignImpXYZSig); + } + + // For TC + sort(TracksImpXY[jetflavour].begin(), TracksImpXY[jetflavour].end(), std::greater()); + sort(TracksSignImpXY[jetflavour].begin(), TracksSignImpXY[jetflavour].end(), std::greater()); + sort(TracksImpXYSig[jetflavour].begin(), TracksImpXYSig[jetflavour].end(), std::greater()); + sort(TracksSignImpXYSig[jetflavour].begin(), TracksSignImpXYSig[jetflavour].end(), std::greater()); + sort(TracksImpZ[jetflavour].begin(), TracksImpZ[jetflavour].end(), std::greater()); + sort(TracksSignImpZ[jetflavour].begin(), TracksSignImpZ[jetflavour].end(), std::greater()); + sort(TracksImpZSig[jetflavour].begin(), TracksImpZSig[jetflavour].end(), std::greater()); + sort(TracksSignImpZSig[jetflavour].begin(), TracksSignImpZSig[jetflavour].end(), std::greater()); + sort(TracksImpXYZ[jetflavour].begin(), TracksImpXYZ[jetflavour].end(), std::greater()); + sort(TracksSignImpXYZ[jetflavour].begin(), TracksSignImpXYZ[jetflavour].end(), std::greater()); + sort(TracksImpXYZSig[jetflavour].begin(), TracksImpXYZSig[jetflavour].end(), std::greater()); + sort(TracksSignImpXYZSig[jetflavour].begin(), TracksSignImpXYZSig[jetflavour].end(), std::greater()); + + if (TracksImpXY[jetflavour].size() > 0) { // N1 + registry.fill(HIST("h3_jet_pt_sign_impact_parameter_xy_significance_flavour_N1"), mcdjet.pt(), TracksSignImpXYSig[jetflavour][0], jetflavour); + registry.fill(HIST("h3_jet_pt_sign_impact_parameter_z_significance_flavour_N1"), mcdjet.pt(), TracksSignImpZSig[jetflavour][0], jetflavour); + registry.fill(HIST("h3_jet_pt_sign_impact_parameter_xyz_significance_flavour_N1"), mcdjet.pt(), TracksSignImpXYZSig[jetflavour][0], jetflavour); + } + if (TracksImpXY[jetflavour].size() > 1) { // N2 + registry.fill(HIST("h3_jet_pt_sign_impact_parameter_xy_significance_flavour_N2"), mcdjet.pt(), TracksSignImpXYSig[jetflavour][1], jetflavour); + registry.fill(HIST("h3_jet_pt_sign_impact_parameter_z_significance_flavour_N2"), mcdjet.pt(), TracksSignImpZSig[jetflavour][1], jetflavour); + registry.fill(HIST("h3_jet_pt_sign_impact_parameter_xyz_significance_flavour_N2"), mcdjet.pt(), TracksSignImpXYZSig[jetflavour][1], jetflavour); + } + if (TracksImpXY[jetflavour].size() > 2) { // N3 + registry.fill(HIST("h3_jet_pt_sign_impact_parameter_xy_significance_flavour_N2"), mcdjet.pt(), TracksSignImpXYSig[jetflavour][2], jetflavour); + registry.fill(HIST("h3_jet_pt_sign_impact_parameter_z_significance_flavour_N2"), mcdjet.pt(), TracksSignImpZSig[jetflavour][2], jetflavour); + registry.fill(HIST("h3_jet_pt_sign_impact_parameter_xyz_significance_flavour_N2"), mcdjet.pt(), TracksSignImpXYZSig[jetflavour][2], jetflavour); + } + } + } + + void processDummy(aod::Collision const& collision, aod::Tracks const& tracks) + { + } + PROCESS_SWITCH(JetTaggerHFQA, processDummy, "Dummy process", true); + + void processIPsData(soa::Join::iterator const& jcollision, aod::Collisions&, JetTagTableData const& jets, JetTracks const& jtracks, OriTracksData const& tracks) + { + auto oricoll = jcollision.template collision_as(); + fillHistogramIPsData(oricoll, jets, tracks); + } + PROCESS_SWITCH(JetTaggerHFQA, processIPsData, "Fill impact parameter inpormation for data jets", false); + + void processIPsMCD(soa::Join::iterator const& jcollision, aod::Collisions&, JetTagTableMCD const& mcdjets, JetTracksMCD const& jtracks, OriTracksMCD const& tracks, JetParticles&) + { + auto oricoll = jcollision.template collision_as(); + fillHistogramIPsMCD(oricoll, mcdjets, tracks); + } + PROCESS_SWITCH(JetTaggerHFQA, processIPsMCD, "Fill impact parameter inpormation for mcd jets", false); +}; + +using JetTaggerQAChargedDataJets = soa::Join; +using JetTaggerQAChargedMCDJets = soa::Join; +using JetTaggerQAChargedMCPJets = soa::Join; + +using JetTaggerQACharged = JetTaggerHFQA; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + + std::vector tasks; + + tasks.emplace_back( + adaptAnalysisTask(cfgc, + SetDefaultProcesses{}, TaskName{"jet-taggerhf-tc-charged"})); + /* + tasks.emplace_back( + adaptAnalysisTask(cfgc, + SetDefaultProcesses{}, TaskName{"jet-taggerhf-tc-full"})); + + tasks.emplace_back( + adaptAnalysisTask(cfgc, + SetDefaultProcesses{}, TaskName{"jet-taggerhf-tc-neutral"})); + */ + return WorkflowSpec{tasks}; +} From 651794ad9b7d376205592e9bda266326c6fae562 Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Tue, 6 Feb 2024 11:17:10 +0900 Subject: [PATCH 2/9] add cmakelist for tagging qa --- PWGJE/Tasks/CMakeLists.txt | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/PWGJE/Tasks/CMakeLists.txt b/PWGJE/Tasks/CMakeLists.txt index fd677e0557e..056514427ce 100644 --- a/PWGJE/Tasks/CMakeLists.txt +++ b/PWGJE/Tasks/CMakeLists.txt @@ -112,4 +112,9 @@ if(FastJet_FOUND) SOURCES phiInJets.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(jet-taggerhf-qa + SOURCES jettaggerhfQA.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore + COMPONENT_NAME Analysis) + endif() From 591f702c0830760ec5a71f1e640c1cc8d9cc2500 Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Tue, 6 Feb 2024 23:57:56 +0900 Subject: [PATCH 3/9] remove num --- PWGJE/Core/JetTaggingUtilities.h | 1 - 1 file changed, 1 deletion(-) diff --git a/PWGJE/Core/JetTaggingUtilities.h b/PWGJE/Core/JetTaggingUtilities.h index 7688b8bfee5..94f2cd000f0 100644 --- a/PWGJE/Core/JetTaggingUtilities.h +++ b/PWGJE/Core/JetTaggingUtilities.h @@ -34,7 +34,6 @@ enum JetTaggingSpecies { lightflavour = 3, lightquark = 4, gluon = 5, - numberOfSpecies = 6 }; namespace jettaggingutilities From ea2081eeaa89e5dcef99d1d9e53924002d02ebc1 Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Wed, 7 Feb 2024 00:07:30 +0900 Subject: [PATCH 4/9] add line eof --- PWGJE/Tasks/jettaggerhfQA.cxx | 1 + 1 file changed, 1 insertion(+) diff --git a/PWGJE/Tasks/jettaggerhfQA.cxx b/PWGJE/Tasks/jettaggerhfQA.cxx index 84a63f9eee4..4bffdb41761 100644 --- a/PWGJE/Tasks/jettaggerhfQA.cxx +++ b/PWGJE/Tasks/jettaggerhfQA.cxx @@ -394,3 +394,4 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) */ return WorkflowSpec{tasks}; } + From 51796a22d25d8ed5171cb784764ea24eaaf37939 Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Wed, 7 Feb 2024 00:10:09 +0900 Subject: [PATCH 5/9] delete line --- PWGJE/Tasks/jettaggerhfQA.cxx | 1 - 1 file changed, 1 deletion(-) diff --git a/PWGJE/Tasks/jettaggerhfQA.cxx b/PWGJE/Tasks/jettaggerhfQA.cxx index 4bffdb41761..84a63f9eee4 100644 --- a/PWGJE/Tasks/jettaggerhfQA.cxx +++ b/PWGJE/Tasks/jettaggerhfQA.cxx @@ -394,4 +394,3 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) */ return WorkflowSpec{tasks}; } - From 5ecb02395717e9e6794b35b130f441e587d53e26 Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Wed, 7 Feb 2024 00:20:31 +0900 Subject: [PATCH 6/9] add line --- PWGJE/Tasks/jettaggerhfQA.cxx | 1 + 1 file changed, 1 insertion(+) diff --git a/PWGJE/Tasks/jettaggerhfQA.cxx b/PWGJE/Tasks/jettaggerhfQA.cxx index 84a63f9eee4..4bffdb41761 100644 --- a/PWGJE/Tasks/jettaggerhfQA.cxx +++ b/PWGJE/Tasks/jettaggerhfQA.cxx @@ -394,3 +394,4 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) */ return WorkflowSpec{tasks}; } + From c805f54920239449ba15f00761cea88ccc9ddce7 Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Wed, 7 Feb 2024 00:23:25 +0900 Subject: [PATCH 7/9] remove line --- PWGJE/Tasks/jettaggerhfQA.cxx | 1 - 1 file changed, 1 deletion(-) diff --git a/PWGJE/Tasks/jettaggerhfQA.cxx b/PWGJE/Tasks/jettaggerhfQA.cxx index 4bffdb41761..84a63f9eee4 100644 --- a/PWGJE/Tasks/jettaggerhfQA.cxx +++ b/PWGJE/Tasks/jettaggerhfQA.cxx @@ -394,4 +394,3 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) */ return WorkflowSpec{tasks}; } - From ab908317fbd36e7f8e348ead0cb1bbe5c7fac7ef Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Wed, 7 Feb 2024 12:16:05 +0900 Subject: [PATCH 8/9] remove comma --- PWGJE/Core/JetTaggingUtilities.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/PWGJE/Core/JetTaggingUtilities.h b/PWGJE/Core/JetTaggingUtilities.h index 94f2cd000f0..417fc74d6cd 100644 --- a/PWGJE/Core/JetTaggingUtilities.h +++ b/PWGJE/Core/JetTaggingUtilities.h @@ -33,7 +33,7 @@ enum JetTaggingSpecies { beauty = 2, lightflavour = 3, lightquark = 4, - gluon = 5, + gluon = 5 }; namespace jettaggingutilities @@ -306,6 +306,7 @@ void calculateDcaXYZ(float& dcaXYZ, float& sigmaDcaXYZ2, float dcaXY, float dcaZ float dFdz = 2 * dcaZ / dcaXYZ; sigmaDcaXYZ2 = std::abs(cYY * dFdxy * dFdxy + cZZ * dFdz * dFdz + 2 * cZY * dFdxy * dFdz); } + }; // namespace jettaggingutilities #endif // PWGJE_CORE_JETTAGGINGUTILITIES_H_ From c5eaffafd279dfa0813ee70390f78596d637ddba Mon Sep 17 00:00:00 2001 From: HANSEO PARK Date: Wed, 7 Feb 2024 17:19:27 +0900 Subject: [PATCH 9/9] remove species number --- 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 84a63f9eee4..c13be32db1b 100644 --- a/PWGJE/Tasks/jettaggerhfQA.cxx +++ b/PWGJE/Tasks/jettaggerhfQA.cxx @@ -240,7 +240,7 @@ struct JetTaggerHFQA { template void fillHistogramIPsMCD(T const& collision, U const& mcdjets, V const& tracks) { - int numberOfJetFlavourSpecies = JetTaggingSpecies::numberOfSpecies; + int numberOfJetFlavourSpecies = 6; for (auto& mcdjet : mcdjets) { if (!jetfindingutilities::isInEtaAcceptance(mcdjet, jetEtaMin, jetEtaMax, trackEtaMin, trackEtaMax)) { continue;