From bf9e193b38905642f367c0fb0f570e747a237f4f Mon Sep 17 00:00:00 2001 From: Alberto Caliva Date: Fri, 4 Jul 2025 12:27:39 +0200 Subject: [PATCH 1/2] [PWGLF] Fixed zorro, addec cut on ITS cls + some refactoring --- PWGLF/Tasks/QC/trackedCascadeProperties.cxx | 194 +++++++++----------- 1 file changed, 90 insertions(+), 104 deletions(-) diff --git a/PWGLF/Tasks/QC/trackedCascadeProperties.cxx b/PWGLF/Tasks/QC/trackedCascadeProperties.cxx index d87d0750e15..9025396ba08 100644 --- a/PWGLF/Tasks/QC/trackedCascadeProperties.cxx +++ b/PWGLF/Tasks/QC/trackedCascadeProperties.cxx @@ -54,51 +54,47 @@ using namespace o2; using namespace o2::framework; using namespace o2::framework::expressions; using namespace o2::constants::physics; +using namespace o2::constants::math; using std::array; +// Define type aliases for joined tables using SelectedCollisions = soa::Join; - using FullTracks = soa::Join; struct TrackedCascadeProperties { + // Instantiate the CCDB manager service and API interface Service ccdb; o2::ccdb::CcdbApi ccdbApi; + // Instantiate the main Zorro processing object and define an output to store summary information Zorro zorro; OutputObj zorroSummary{"zorroSummary"}; - // QC Histograms - HistogramRegistry registryQC{ - "registryQC", - {}, - OutputObjHandlingPolicy::AnalysisObject, - true, - true}; - - // Analysis Histograms: Data - HistogramRegistry registryData{ - "registryData", - {}, - OutputObjHandlingPolicy::AnalysisObject, - true, - true}; + // Histogram registry for quality control + HistogramRegistry registryQC{"registryQC", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + + // Histogram registry for data + HistogramRegistry registryData{"registryData", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; // Global Parameters Configurable zVtx{"zVtx", 10.0f, "z vertex cut"}; Configurable cfgSkimmedProcessing{"cfgSkimmedProcessing", false, "Skimmed dataset processing"}; - Configurable cfgTriggerName{"cfgTriggerName", "fOmega", "trigger Name"}; + Configurable triggerList{"triggerList", "fTrackedOmega, fTrackedXi, fOmegaLargeRadius, fDoubleOmega, fOmegaHighMult, fSingleXiYN, fQuadrupleXi, fDoubleXi, fhadronOmega, fOmegaXi, fTripleXi, fOmega", "Trigger list"}; - // Mass Cuts + // Analysis Selections + Configurable minItsClustersCasc{"minItsClustersCasc", 4, "min ITS Clusters"}; Configurable massMinXi{"massMinXi", 1.315f, "mMin Xi"}; Configurable massMaxXi{"massMaxXi", 1.328f, "mMax Xi"}; Configurable massMinOmega{"massMinOmega", 1.665f, "mMin Omega"}; Configurable massMaxOmega{"massMaxOmega", 1.680f, "mMax Omega"}; + // Initialize CCDB access and histogram registry for Zorro processing void initCCDB(aod::BCsWithTimestamps::iterator const& bc) { if (cfgSkimmedProcessing) { zorro.initCCDB(ccdb.service, bc.runNumber(), bc.timestamp(), cfgTriggerName.value); + zorro.populateHistRegistry(registryData, bc.runNumber()); } } @@ -108,45 +104,41 @@ struct TrackedCascadeProperties { zorroSummary.setObject(zorro.getZorroSummary()); } + // Quality Control Histograms registryQC.add("matchingChi2", "matching Chi2", HistType::kTH1F, {{200, 0, 1000, "#chi^{2}_{matching}"}}); registryQC.add("topologyChi2", "topology Chi2", HistType::kTH1F, {{500, 0, 0.5, "#chi^{2}_{topology}"}}); registryQC.add("nITScls_vs_p_xi", "nITS Xi", HistType::kTH2F, {{100, 0, 10, "#it{p} (GeV/#it{c})"}, {8, 0, 8, "n_{ITS}^{cls}"}}); registryQC.add("nITScls_vs_p_omega", "nITS Omega", HistType::kTH2F, {{100, 0, 10, "#it{p} (GeV/#it{c})"}, {8, 0, 8, "n_{ITS}^{cls}"}}); registryQC.add("decayXY", "decayXY", HistType::kTH2F, {{500, -50, 50, "x"}, {500, -50, 50, "y"}}); - registryQC.add("deltaClsSize", "deltaClsSize", HistType::kTH1F, {{40, -20, 20, "#DeltaClsSize"}}); - registryQC.add("deltaP", "deltaP", HistType::kTH1F, {{1000, -1, 1, "#Deltap"}}); - registryQC.add("deltaEta", "deltaEta", HistType::kTH1F, {{200, -0.5, 0.5, "#Delta#eta"}}); - registryQC.add("deltaNclsITS", "deltaNclsITS", HistType::kTH1F, {{20, -10, 10, "#DeltaN"}}); - registryQC.add("deltaNclsITS_track", "deltaNclsITS_track", HistType::kTH1F, {{20, -10, 10, "#DeltaN"}}); - registryQC.add("deltaNclsITS_itstrack", "deltaNclsITS_itstrack", HistType::kTH1F, {{20, -10, 10, "#DeltaN"}}); + // Event Counter registryData.add("number_of_events_data", "number of events in data", HistType::kTH1F, {{5, 0, 5, "Event Cuts"}}); - registryData.add("xi_pos_avgclustersize", "xi_pos_avgclustersize", HistType::kTH3F, {{100, 0.0, 10.0, "#it{p} (GeV/#it{c})"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT"}, {16, -0.8, 0.8, "#eta"}}); - registryData.add("xi_neg_avgclustersize", "xi_neg_avgclustersize", HistType::kTH3F, {{100, 0.0, 10.0, "#it{p} (GeV/#it{c})"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT"}, {16, -0.8, 0.8, "#eta"}}); - registryData.add("omega_pos_avgclustersize", "omega_pos_avgclustersize", HistType::kTH3F, {{100, 0.0, 10.0, "#it{p} (GeV/#it{c})"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT"}, {16, -0.8, 0.8, "#eta"}}); - registryData.add("omega_neg_avgclustersize", "omega_neg_avgclustersize", HistType::kTH3F, {{100, 0.0, 10.0, "#it{p} (GeV/#it{c})"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT"}, {16, -0.8, 0.8, "#eta"}}); - registryData.add("xi_pos_avgclustersize_cosL", "xi_pos_avgclustersize_cosL", HistType::kTH2F, {{100, 0.0, 10.0, "#it{p} (GeV/#it{c})"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT cos(#lambda)"}}); - registryData.add("xi_neg_avgclustersize_cosL", "xi_neg_avgclustersize_cosL", HistType::kTH2F, {{100, 0.0, 10.0, "#it{p} (GeV/#it{c})"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT cos(#lambda)"}}); - registryData.add("omega_pos_avgclustersize_cosL", "omega_pos_avgclustersize_cosL", HistType::kTH2F, {{100, 0.0, 10.0, "#it{p} (GeV/#it{c})"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT cos(#lambda)"}}); - registryData.add("omega_neg_avgclustersize_cosL", "omega_neg_avgclustersize_cosL", HistType::kTH2F, {{100, 0.0, 10.0, "#it{p} (GeV/#it{c})"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT cos(#lambda)"}}); + // Average cluster size vs momentum + registryData.add("xi_pos_avgclustersize_cosL_vs_p", "xi_pos_avgclustersize_cosL_vs_p", HistType::kTH2F, {{100, 0.0, 10.0, "#it{p} (GeV/#it{c})"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT cos(#lambda)"}}); + registryData.add("xi_neg_avgclustersize_cosL_vs_p", "xi_neg_avgclustersize_cosL_vs_p", HistType::kTH2F, {{100, 0.0, 10.0, "#it{p} (GeV/#it{c})"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT cos(#lambda)"}}); + registryData.add("omega_pos_avgclustersize_cosL_vs_p", "omega_pos_avgclustersize_cosL_vs_p", HistType::kTH2F, {{100, 0.0, 10.0, "#it{p} (GeV/#it{c})"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT cos(#lambda)"}}); + registryData.add("omega_neg_avgclustersize_cosL_vs_p", "omega_neg_avgclustersize_cosL_vs_p", HistType::kTH2F, {{100, 0.0, 10.0, "#it{p} (GeV/#it{c})"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT cos(#lambda)"}}); + // Average cluster size vs betagamma registryData.add("xi_pos_avgclustersize_cosL_vs_betagamma", "xi_pos_avgclustersize_cosL_vs_betagamma", HistType::kTH2F, {{200, 0.0, 10.0, "#beta#gamma"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT cos(#lambda)"}}); registryData.add("xi_neg_avgclustersize_cosL_vs_betagamma", "xi_neg_avgclustersize_cosL_vs_betagamma", HistType::kTH2F, {{200, 0.0, 10.0, "#beta#gamma"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT cos(#lambda)"}}); registryData.add("omega_pos_avgclustersize_cosL_vs_betagamma", "omega_pos_avgclustersize_cosL_vs_betagamma", HistType::kTH2F, {{200, 0.0, 10.0, "#beta#gamma"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT cos(#lambda)"}}); registryData.add("omega_neg_avgclustersize_cosL_vs_betagamma", "omega_neg_avgclustersize_cosL_vs_betagamma", HistType::kTH2F, {{200, 0.0, 10.0, "#beta#gamma"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT cos(#lambda)"}}); - // Cluster size using truncated mean - registryData.add("xi_pos_avgclustersize_trunc_cosL", "xi_pos_avgclustersize_trunc_cosL", HistType::kTH2F, {{100, 0.0, 10.0, "#it{p} (GeV/#it{c})"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT cos(#lambda)"}}); - registryData.add("xi_neg_avgclustersize_trunc_cosL", "xi_neg_avgclustersize_trunc_cosL", HistType::kTH2F, {{100, 0.0, 10.0, "#it{p} (GeV/#it{c})"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT cos(#lambda)"}}); - registryData.add("omega_pos_avgclustersize_trunc_cosL", "omega_pos_avgclustersize_trunc_cosL", HistType::kTH2F, {{100, 0.0, 10.0, "#it{p} (GeV/#it{c})"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT cos(#lambda)"}}); - registryData.add("omega_neg_avgclustersize_trunc_cosL", "omega_neg_avgclustersize_trunc_cosL", HistType::kTH2F, {{100, 0.0, 10.0, "#it{p} (GeV/#it{c})"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT cos(#lambda)"}}); + // Cluster size using truncated mean vs momentum + registryData.add("xi_pos_avgclustersize_trunc_cosL_vs_p", "xi_pos_avgclustersize_trunc_cosL_vs_p", HistType::kTH2F, {{100, 0.0, 10.0, "#it{p} (GeV/#it{c})"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT cos(#lambda)"}}); + registryData.add("xi_neg_avgclustersize_trunc_cosL_vs_p", "xi_neg_avgclustersize_trunc_cosL_vs_p", HistType::kTH2F, {{100, 0.0, 10.0, "#it{p} (GeV/#it{c})"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT cos(#lambda)"}}); + registryData.add("omega_pos_avgclustersize_trunc_cosL_vs_p", "omega_pos_avgclustersize_trunc_cosL_vs_p", HistType::kTH2F, {{100, 0.0, 10.0, "#it{p} (GeV/#it{c})"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT cos(#lambda)"}}); + registryData.add("omega_neg_avgclustersize_trunc_cosL_vs_p", "omega_neg_avgclustersize_trunc_cosL_vs_p", HistType::kTH2F, {{100, 0.0, 10.0, "#it{p} (GeV/#it{c})"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT cos(#lambda)"}}); + // Cluster size using truncated mean vs betagamma registryData.add("xi_pos_avgclustersize_trunc_cosL_vs_betagamma", "xi_pos_avgclustersize_trunc_cosL_vs_betagamma", HistType::kTH2F, {{200, 0.0, 10.0, "#beta#gamma"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT cos(#lambda)"}}); registryData.add("xi_neg_avgclustersize_trunc_cosL_vs_betagamma", "xi_neg_avgclustersize_trunc_cosL_vs_betagamma", HistType::kTH2F, {{200, 0.0, 10.0, "#beta#gamma"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT cos(#lambda)"}}); registryData.add("omega_pos_avgclustersize_trunc_cosL_vs_betagamma", "omega_pos_avgclustersize_trunc_cosL_vs_betagamma", HistType::kTH2F, {{200, 0.0, 10.0, "#beta#gamma"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT cos(#lambda)"}}); registryData.add("omega_neg_avgclustersize_trunc_cosL_vs_betagamma", "omega_neg_avgclustersize_trunc_cosL_vs_betagamma", HistType::kTH2F, {{200, 0.0, 10.0, "#beta#gamma"}, {100, 0.0, 20.0, "#LT ITS cluster size #GT cos(#lambda)"}}); + // mass histograms registryData.add("xi_mass_pos", "xi_mass_pos", HistType::kTH2F, {{100, 0.0, 10.0, "#it{p} (GeV/#it{c})"}, {200, 1.28, 1.36, "m_{p#pi#pi} (GeV/#it{c}^{2})"}}); registryData.add("xi_mass_neg", "xi_mass_neg", HistType::kTH2F, {{100, 0.0, 10.0, "#it{p} (GeV/#it{c})"}, {200, 1.28, 1.36, "m_{p#pi#pi} (GeV/#it{c}^{2})"}}); registryData.add("omega_mass_pos", "omega_mass_pos", HistType::kTH2F, {{100, 0.0, 10.0, "#it{p} (GeV/#it{c})"}, {200, 1.63, 1.71, "m_{p#piK} (GeV/#it{c}^{2})"}}); @@ -157,10 +149,10 @@ struct TrackedCascadeProperties { { double lambda(0); double theta = 2.0 * std::atan(std::exp(-eta)); - if (theta <= o2::constants::math::PIHalf) - lambda = o2::constants::math::PIHalf - theta; - if (theta > o2::constants::math::PIHalf) - lambda = theta - o2::constants::math::PIHalf; + if (theta <= PIHalf) + lambda = PIHalf - theta; + if (theta > PIHalf) + lambda = theta - PIHalf; return lambda; } @@ -175,89 +167,83 @@ struct TrackedCascadeProperties { } void processData(SelectedCollisions::iterator const& collision, aod::AssignedTrackedCascades const& trackedCascades, - aod::Cascades const&, FullTracks const&) + aod::Cascades const&, FullTracks const&, aod::BCsWithTimestamps const&) { + // Number of events before any selection registryData.fill(HIST("number_of_events_data"), 0.5); + // Retrieve the bunch crossing information with timestamps from the collision auto bc = collision.template bc_as(); initCCDB(bc); + + // If skimmed processing is enabled, apply Zorro trigger selection if (cfgSkimmedProcessing && !zorro.isSelected(collision.template bc_as().globalBC())) { return; } - registryData.fill(HIST("number_of_events_data"), 1.5); + // Number of events after skimming selection + registryData.fill(HIST("number_of_events_data"), 1.5); if (!collision.sel8()) return; + // Number of events after sel8 registryData.fill(HIST("number_of_events_data"), 2.5); if (std::abs(collision.posZ()) > zVtx) return; + // Number of events after zVtx cut registryData.fill(HIST("number_of_events_data"), 3.5); + // radii of ITS layers std::vector edgesItsLayers = {0.0, 2.2, 2.8, 3.6, 20.0, 22.0, 37.0, 39.0, 100.0}; + // Loop over tracked cascades for (const auto& trackedCascade : trackedCascades) { + // Get tracked cascade const auto track = trackedCascade.track_as(); const auto trackITS = trackedCascade.itsTrack_as(); - - // Comparison between track and ITStrack - registryQC.fill(HIST("deltaP"), track.p() - trackITS.p()); - registryQC.fill(HIST("deltaEta"), track.eta() - trackITS.eta()); - registryQC.fill(HIST("deltaNclsITS"), track.itsNCls() - trackITS.itsNCls()); - - const int nItsLayers = 7; - for (int i = 0; i < nItsLayers; i++) { - registryQC.fill(HIST("deltaClsSize"), track.itsClsSizeInLayer(i) - trackITS.itsClsSizeInLayer(i)); - } - const auto& casc = trackedCascade.cascade(); const auto& btrack = casc.bachelor_as(); double dx = trackedCascade.decayX(); double dy = trackedCascade.decayY(); double r = std::sqrt(dx * dx + dy * dy); - int nClsCascade = findBin(edgesItsLayers, r); + int nItsLayersCrossed = findBin(edgesItsLayers, r); + // Fill QC histograms registryQC.fill(HIST("matchingChi2"), trackedCascade.matchingChi2()); registryQC.fill(HIST("topologyChi2"), trackedCascade.topologyChi2()); registryQC.fill(HIST("decayXY"), dx, dy); - // Calculate (Average) Cluster Size - double averageClusterSize(0); - int nCls(0); - for (int i = 0; i < nClsCascade; i++) { - int clusterSize = trackITS.itsClsSizeInLayer(i); - averageClusterSize += static_cast(clusterSize); - if (clusterSize > 0) - nCls++; - } - averageClusterSize = averageClusterSize / static_cast(nCls); - - // Average cluster size using truncated mean + // Compute average cluster size and truncated mean + double sumClusterSize = 0.0; + double sumClusterSizeTrunc = 0.0; + double maxClusterSize = 0.0; + double averageClusterSize = 0.0; double averageClusterSizeTrunc = 0.0; - int nClsTrunc = 0; - double clusterSizeMax = 0.0; + int nCls = 0; - for (int i = 0; i < nClsCascade; i++) { + for (int i = 0; i < nItsLayersCrossed; i++) { double clusterSize = static_cast(trackITS.itsClsSizeInLayer(i)); - if (clusterSize > clusterSizeMax) { - clusterSizeMax = clusterSize; + if (clusterSize > 0) { + sumClusterSize += clusterSize; + sumClusterSizeTrunc += clusterSize; + nCls++; + if (clusterSize > maxClusterSize) { + maxClusterSize = clusterSize; + } } - - averageClusterSizeTrunc += clusterSize; - if (clusterSize > 0) - nClsTrunc++; } - - if (nClsTrunc > 1) { - averageClusterSizeTrunc = (averageClusterSizeTrunc - clusterSizeMax) / static_cast(nClsTrunc - 1); - } else { - averageClusterSizeTrunc = 0.0; + if (nCls > 0) { + averageClusterSize = sumClusterSize / static_cast(nCls); + } + if (nCls > 1) { + averageClusterSizeTrunc = (sumClusterSizeTrunc - maxClusterSize) / static_cast(nCls - 1); } - registryQC.fill(HIST("deltaNclsITS_track"), nCls - track.itsNCls()); - registryQC.fill(HIST("deltaNclsITS_itstrack"), nCls - trackITS.itsNCls()); + // Apply selection on number of ITS clusters + if (nCls < minItsClustersCasc) + continue; // Xi Mass if (btrack.sign() > 0) { @@ -267,25 +253,27 @@ struct TrackedCascadeProperties { registryData.fill(HIST("xi_mass_neg"), track.p(), trackedCascade.xiMass()); } - // Track Inclination + // Variables double lambda = trackInclination(track.eta()); + double clsSizeCosL = averageClusterSize * std::cos(lambda); + double clsSizeCosLtrunc = averageClusterSizeTrunc * std::cos(lambda); + double bgXi = track.p() / MassXiPlusBar; + double bgOmega = track.p() / MassOmegaPlusBar; // Xi if (trackedCascade.xiMass() > massMinXi && trackedCascade.xiMass() < massMaxXi) { registryQC.fill(HIST("nITScls_vs_p_xi"), track.p(), trackITS.itsNCls()); if (btrack.sign() > 0) { - registryData.fill(HIST("xi_pos_avgclustersize"), track.p(), averageClusterSize, track.eta()); - registryData.fill(HIST("xi_pos_avgclustersize_cosL"), track.p(), averageClusterSize * std::cos(lambda)); - registryData.fill(HIST("xi_pos_avgclustersize_cosL_vs_betagamma"), track.p() / o2::constants::physics::MassXiPlusBar, averageClusterSize * std::cos(lambda)); - registryData.fill(HIST("xi_pos_avgclustersize_trunc_cosL"), track.p(), averageClusterSizeTrunc * std::cos(lambda)); - registryData.fill(HIST("xi_pos_avgclustersize_trunc_cosL_vs_betagamma"), track.p() / o2::constants::physics::MassXiPlusBar, averageClusterSizeTrunc * std::cos(lambda)); + registryData.fill(HIST("xi_pos_avgclustersize_cosL_vs_p"), track.p(), clsSizeCosL); + registryData.fill(HIST("xi_pos_avgclustersize_cosL_vs_betagamma"), bgXi, clsSizeCosL); + registryData.fill(HIST("xi_pos_avgclustersize_trunc_cosL_vs_p"), track.p(), clsSizeCosLtrunc); + registryData.fill(HIST("xi_pos_avgclustersize_trunc_cosL_vs_betagamma"), bgXi, clsSizeCosLtrunc); } if (btrack.sign() < 0) { - registryData.fill(HIST("xi_neg_avgclustersize"), track.p(), averageClusterSize, track.eta()); - registryData.fill(HIST("xi_neg_avgclustersize_cosL"), track.p(), averageClusterSize * std::cos(lambda)); - registryData.fill(HIST("xi_neg_avgclustersize_cosL_vs_betagamma"), track.p() / o2::constants::physics::MassXiMinus, averageClusterSize * std::cos(lambda)); - registryData.fill(HIST("xi_neg_avgclustersize_trunc_cosL"), track.p(), averageClusterSizeTrunc * std::cos(lambda)); - registryData.fill(HIST("xi_neg_avgclustersize_trunc_cosL_vs_betagamma"), track.p() / o2::constants::physics::MassXiPlusBar, averageClusterSizeTrunc * std::cos(lambda)); + registryData.fill(HIST("xi_neg_avgclustersize_cosL_vs_p"), track.p(), clsSizeCosL); + registryData.fill(HIST("xi_neg_avgclustersize_cosL_vs_betagamma"), bgXi, clsSizeCosL); + registryData.fill(HIST("xi_neg_avgclustersize_trunc_cosL_vs_p"), track.p(), clsSizeCosLtrunc); + registryData.fill(HIST("xi_neg_avgclustersize_trunc_cosL_vs_betagamma"), bgXi, clsSizeCosLtrunc); } continue; } @@ -302,18 +290,16 @@ struct TrackedCascadeProperties { if (trackedCascade.omegaMass() > massMinOmega && trackedCascade.omegaMass() < massMaxOmega) { registryQC.fill(HIST("nITScls_vs_p_omega"), track.p(), trackITS.itsNCls()); if (btrack.sign() > 0) { - registryData.fill(HIST("omega_pos_avgclustersize"), track.p(), averageClusterSize, track.eta()); - registryData.fill(HIST("omega_pos_avgclustersize_cosL"), track.p(), averageClusterSize * std::cos(lambda)); - registryData.fill(HIST("omega_pos_avgclustersize_cosL_vs_betagamma"), track.p() / o2::constants::physics::MassOmegaPlusBar, averageClusterSize * std::cos(lambda)); - registryData.fill(HIST("omega_pos_avgclustersize_trunc_cosL"), track.p(), averageClusterSizeTrunc * std::cos(lambda)); - registryData.fill(HIST("omega_pos_avgclustersize_trunc_cosL_vs_betagamma"), track.p() / o2::constants::physics::MassXiPlusBar, averageClusterSizeTrunc * std::cos(lambda)); + registryData.fill(HIST("omega_pos_avgclustersize_cosL_vs_p"), track.p(), clsSizeCosL); + registryData.fill(HIST("omega_pos_avgclustersize_cosL_vs_betagamma"), bgOmega, clsSizeCosL); + registryData.fill(HIST("omega_pos_avgclustersize_trunc_cosL_vs_p"), track.p(), clsSizeCosLtrunc); + registryData.fill(HIST("omega_pos_avgclustersize_trunc_cosL_vs_betagamma"), bgOmega, clsSizeCosLtrunc); } if (btrack.sign() < 0) { - registryData.fill(HIST("omega_neg_avgclustersize"), track.p(), averageClusterSize, track.eta()); - registryData.fill(HIST("omega_neg_avgclustersize_cosL"), track.p(), averageClusterSize * std::cos(lambda)); - registryData.fill(HIST("omega_neg_avgclustersize_cosL_vs_betagamma"), track.p() / o2::constants::physics::MassOmegaMinus, averageClusterSize * std::cos(lambda)); - registryData.fill(HIST("omega_neg_avgclustersize_trunc_cosL"), track.p(), averageClusterSizeTrunc * std::cos(lambda)); - registryData.fill(HIST("omega_neg_avgclustersize_trunc_cosL_vs_betagamma"), track.p() / o2::constants::physics::MassXiPlusBar, averageClusterSizeTrunc * std::cos(lambda)); + registryData.fill(HIST("omega_neg_avgclustersize_cosL_vs_p"), track.p(), clsSizeCosL); + registryData.fill(HIST("omega_neg_avgclustersize_cosL_vs_betagamma"), bgOmega, clsSizeCosL); + registryData.fill(HIST("omega_neg_avgclustersize_trunc_cosL_vs_p"), track.p(), clsSizeCosLtrunc); + registryData.fill(HIST("omega_neg_avgclustersize_trunc_cosL_vs_betagamma"), bgOmega, clsSizeCosLtrunc); } } } From 30e12223be99e12753953123be95e8c3e03ff403 Mon Sep 17 00:00:00 2001 From: Alberto Caliva Date: Fri, 4 Jul 2025 13:44:35 +0200 Subject: [PATCH 2/2] fixed trigger list name --- PWGLF/Tasks/QC/trackedCascadeProperties.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGLF/Tasks/QC/trackedCascadeProperties.cxx b/PWGLF/Tasks/QC/trackedCascadeProperties.cxx index 9025396ba08..489e37e2608 100644 --- a/PWGLF/Tasks/QC/trackedCascadeProperties.cxx +++ b/PWGLF/Tasks/QC/trackedCascadeProperties.cxx @@ -93,7 +93,7 @@ struct TrackedCascadeProperties { void initCCDB(aod::BCsWithTimestamps::iterator const& bc) { if (cfgSkimmedProcessing) { - zorro.initCCDB(ccdb.service, bc.runNumber(), bc.timestamp(), cfgTriggerName.value); + zorro.initCCDB(ccdb.service, bc.runNumber(), bc.timestamp(), triggerList); zorro.populateHistRegistry(registryData, bc.runNumber()); } }