From b4fd67611117ee59036bc23c6c57eccc5410c0d2 Mon Sep 17 00:00:00 2001 From: jesgum Date: Thu, 24 Sep 2026 13:31:17 +0200 Subject: [PATCH 1/2] Add outer FT0C and FV0, and combined fit signals to centrality study --- Common/DataModel/Multiplicity.h | 21 +++++++- .../TableProducer/Converters/CMakeLists.txt | 5 ++ .../Converters/multBCs002Converter.cxx | 51 +++++++++++++++++++ .../TableProducer/multiplicityExtraTable.cxx | 24 +++++---- Common/Tasks/centralityStudy.cxx | 40 ++++++++++++--- 5 files changed, 124 insertions(+), 17 deletions(-) create mode 100644 Common/TableProducer/Converters/multBCs002Converter.cxx diff --git a/Common/DataModel/Multiplicity.h b/Common/DataModel/Multiplicity.h index c258fd0c426..d9b15e4f85e 100644 --- a/Common/DataModel/Multiplicity.h +++ b/Common/DataModel/Multiplicity.h @@ -103,6 +103,7 @@ DECLARE_SOA_COLUMN(TimeToNeNext, timeToNeNext, float); //! DECLARE_SOA_COLUMN(FT0TriggerMask, ft0TriggerMask, uint8_t); //! DECLARE_SOA_COLUMN(MultFV0AOuter, multFV0AOuter, float); //! FV0 without innermost ring DECLARE_SOA_COLUMN(MultFT0AOuter, multFT0AOuter, float); //! FT0A without innermost ring +DECLARE_SOA_COLUMN(MultFT0COuter, multFT0COuter, float); //! FT0C without innermost ring // Timing information DECLARE_SOA_COLUMN(TimeZNA, timeZNA, float); //! @@ -144,7 +145,7 @@ DECLARE_SOA_TABLE(MFTMults, "AOD", "MFTMULT", //! Multiplicity with MFT DECLARE_SOA_TABLE(FITExtraMults, "AOD", "FITEXTRAMULT", //! Extra information from FIT detectors mult::MultFV0AOuter, mult::MultFT0AOuter, - mult::FT0TriggerMask); + mult::MultFT0COuter); using BarrelMults = soa::Join; using Mults = soa::Join; @@ -311,6 +312,22 @@ DECLARE_SOA_TABLE_VERSIONED(MultBCs_001, "AOD", "MULTBC", 1, //! mult::MultFV0AOuter, mult::MultFT0AOuter); +DECLARE_SOA_TABLE_VERSIONED(MultBCs_002, "AOD", "MULTBC", 2, //! + mult::MultFT0A, + mult::MultFT0C, + mult::MultFV0A, + mult::MultFDDA, + mult::MultFDDC, + mult::MultZNA, + mult::MultZNC, + mult::MultZEM1, + mult::MultZEM2, + mult::MultZPA, + mult::MultZPC, + mult::MultFV0AOuter, + mult::MultFT0AOuter, + mult::MultFT0COuter); + DECLARE_SOA_TABLE(MultBcSel_000, "AOD", "MULTBCSEL", //! BC selection bits joinable with multBCs evsel::Selection); @@ -339,7 +356,7 @@ DECLARE_SOA_TABLE(TimeBCs, "AOD", "TIMEBC", //! mult::TimeZPA, mult::TimeZPC) -using MultBCs = MultBCs_001; +using MultBCs = MultBCs_002; using MultBcSel = MultBcSel_001; using MultBC = MultBCs::iterator; diff --git a/Common/TableProducer/Converters/CMakeLists.txt b/Common/TableProducer/Converters/CMakeLists.txt index a8b14efaca3..600dfea3d9b 100644 --- a/Common/TableProducer/Converters/CMakeLists.txt +++ b/Common/TableProducer/Converters/CMakeLists.txt @@ -118,3 +118,8 @@ o2physics_add_dpl_workflow(mult-bcs-converter SOURCES multBCsConverter.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore COMPONENT_NAME Analysis) + +o2physics_add_dpl_workflow(mult-bcs-002-converter + SOURCES multBCs002Converter.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME Analysis) diff --git a/Common/TableProducer/Converters/multBCs002Converter.cxx b/Common/TableProducer/Converters/multBCs002Converter.cxx new file mode 100644 index 00000000000..dfed7182c1a --- /dev/null +++ b/Common/TableProducer/Converters/multBCs002Converter.cxx @@ -0,0 +1,51 @@ +// 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 multBCs002Converter.cxx +/// \brief Converts MultBCs table from version 001 to 002 +/// \author Jesper Karlsson Gumrpecht + +#include "Common/DataModel/Multiplicity.h" + +#include +#include +#include +#include + +struct MultBCs002Converter { + o2::framework::Produces multBC; + static constexpr float DummyValue = -1.f; + void process(o2::aod::MultBCs_001 const& multBCs) + { + multBC.reserve(multBCs.size()); + for (const auto& multbc : multBCs) { + multBC(multbc.multFT0A(), + multbc.multFT0C(), + multbc.multFV0A(), + multbc.multFDDA(), + multbc.multFDDC(), + multbc.multZNA(), + multbc.multZNC(), + multbc.multZEM1(), + multbc.multZEM2(), + multbc.multZPA(), + multbc.multZPC(), + multbc.multFV0AOuter(), + multbc.multFT0AOuter(), + DummyValue /* dummy amplitude for FT0C Outer */); + } + } +}; + +o2::framework::WorkflowSpec defineDataProcessing(o2::framework::ConfigContext const& cfgc) +{ + return o2::framework::WorkflowSpec{adaptAnalysisTask(cfgc)}; +} diff --git a/Common/TableProducer/multiplicityExtraTable.cxx b/Common/TableProducer/multiplicityExtraTable.cxx index 3211b23a346..19a1280f60c 100644 --- a/Common/TableProducer/multiplicityExtraTable.cxx +++ b/Common/TableProducer/multiplicityExtraTable.cxx @@ -44,7 +44,6 @@ using namespace o2; using namespace o2::framework; using namespace o2::framework::expressions; using BCPattern = std::bitset; -const int nBCsPerOrbit = o2::constants::lhc::LHCMaxBunches; struct MultiplicityExtraTable { Produces multBC; @@ -62,6 +61,7 @@ struct MultiplicityExtraTable { Configurable bcDownscaleFactor{"bcDownscaleFactor", 2, "Downscale factor for BC table (0: save nothing, 1: save all)"}; Configurable minFT0CforBCTable{"minFT0CforBCTable", 25.0f, "Minimum FT0C amplitude to fill BC table to reduce data"}; Configurable saveOnlyBCsWithCollisions{"saveOnlyBCsWithCollisions", true, "save only BCs with collisions in them"}; + Configurable requestMinSignalForFT0C{"requestMinSignalForFT0C", true, "save only BCs with minimum FT0C signal"}; Configurable bcTableFloatPrecision{"bcTableFloatPrecision", 0.1, "float precision in bc table for data reduction"}; @@ -126,14 +126,14 @@ struct MultiplicityExtraTable { float multFT0C = 0.f; if (bc.has_ft0()) { auto ft0 = bc.ft0(); - for (const auto amplitude : ft0.amplitudeC()) { + for (const auto amplitude : ft0.amplitudeC()) { // o2-linter: disable=const-ref-in-for-loop (cheap float copy) multFT0C += amplitude; } } else { multFT0C = -999.0f; } - if (multFT0C < minFT0CforBCTable) { + if (requestMinSignalForFT0C && multFT0C < minFT0CforBCTable) { continue; // skip this event } @@ -166,6 +166,7 @@ struct MultiplicityExtraTable { float multFDDA = 0.f; float multFDDC = 0.f; float multFT0AOuter = 0.f; + float multFT0COuter = 0.f; float multFV0AOuter = 0.f; // ZDC amplitudes @@ -196,7 +197,7 @@ struct MultiplicityExtraTable { // initialize - from Arvind newRunNumber = bc.runNumber(); - int localBC = bc.globalBC() % nBCsPerOrbit; + int localBC = bc.globalBC() % o2::constants::lhc::LHCMaxBunches; if (newRunNumber != oldRunNumber) { auto soreor = o2::ccdb::BasicCCDBManager::getRunDuration(ccdbApi, newRunNumber); @@ -224,8 +225,12 @@ struct MultiplicityExtraTable { multFT0AOuter += ft0.amplitudeA()[ii]; } } - for (const auto amplitude : ft0.amplitudeC()) { - multFT0C += amplitude; + for (size_t ii = 0; ii < ft0.amplitudeC().size(); ++ii) { + multFT0C += ft0.amplitudeC()[ii]; + static constexpr int MaxChannelIdInnerRingFT0C = 48; + if (ft0.channelC()[ii] > MaxChannelIdInnerRingFT0C) { + multFT0COuter += ft0.amplitudeC()[ii]; + } } posZFT0 = ft0.posZ(); posZFT0valid = ft0.isValidTime(); @@ -261,10 +266,10 @@ struct MultiplicityExtraTable { std::bitset<8> fFDDTriggers = fdd.triggerMask(); multFDDTriggerBits = static_cast(fFDDTriggers.to_ulong()); - for (const auto amplitude : fdd.chargeA()) { + for (const auto amplitude : fdd.chargeA()) { // o2-linter: disable=const-ref-in-for-loop (cheap float copy) multFDDA += amplitude; } - for (const auto amplitude : fdd.chargeC()) { + for (const auto amplitude : fdd.chargeC()) { // o2-linter: disable=const-ref-in-for-loop (cheap float copy) multFDDC += amplitude; } @@ -313,7 +318,8 @@ struct MultiplicityExtraTable { tru(multZPA), tru(multZPC), tru(multFV0AOuter), - tru(multFT0AOuter)); + tru(multFT0AOuter), + tru(multFT0COuter)); multBcSel( bc.selection_raw(), diff --git a/Common/Tasks/centralityStudy.cxx b/Common/Tasks/centralityStudy.cxx index fab358689b1..9f8b85bc763 100644 --- a/Common/Tasks/centralityStudy.cxx +++ b/Common/Tasks/centralityStudy.cxx @@ -185,7 +185,7 @@ struct CentralityStudy { Configurable factorFT0C{"factorFT0C", 1.00f, "scale the raw FT0C signal for convenience"}; Configurable factorFV0A{"factorFV0A", 1.00f, "scale the raw FV0A signal for convenience"}; Configurable factorFT0M{"factorFT0M", 1.00f, "scale the raw FT0M signal for convenience"}; - Configurable factorFV0AT0C{"factorFV0AT0C", 1.00f, "scale the raw FV0A+FT0C signal for convenience"}; + Configurable factorFIT{"factorFIT", 1.00f, "scale the raw FV0A+FT0C signal for convenience"}; Configurable normFT0A{"normFT0A", 1.00f, "scale the self-normalised FT0A signal; scale.normFT0A * FT0A / "}; Configurable normFT0C{"normFT0C", 1.00f, "scale the self-normalised FT0C signal; scale.normFT0C * FT0C / "}; Configurable normFV0A{"normFV0A", 1.00f, "scale the self-normalised FV0A signal; scale.normFV0A * FV0A / "}; @@ -206,6 +206,7 @@ struct CentralityStudy { ConfigurableAxis axisFT0COccupancy{"axisFT0COccupancy", {50, 0, 80000}, "FT0C occupancy"}; // For one-dimensional plots, where binning is no issue + ConfigurableAxis axisMultUltraFineFIT{"axisMultUltraFineFIT", {60000, 0, 60000}, "FT0M + FV0 amplitude"}; ConfigurableAxis axisMultUltraFineFV0A{"axisMultUltraFineFV0A", {60000, 0, 60000}, "FV0A amplitude"}; ConfigurableAxis axisMultUltraFineFT0C{"axisMultUltraFineFT0C", {60000, 0, 60000}, "FT0C amplitude"}; ConfigurableAxis axisMultUltraFineFT0A{"axisMultUltraFineFT0A", {60000, 0, 60000}, "FT0A amplitude"}; @@ -273,8 +274,13 @@ struct CentralityStudy { histos.add("hFT0C_Collisions", "hFT0C_Collisions", kTH1D, {axisMultUltraFineFT0C}); histos.add("hFT0M_Collisions", "hFT0M_Collisions", kTH1D, {axisMultUltraFineFT0M}); histos.add("hFV0A_Collisions", "hFV0A_Collisions", kTH1D, {axisMultUltraFineFV0A}); + histos.add("hFV0AOuter_Collisions", "hFV0AOuter_Collisions", kTH1D, {axisMultUltraFineFV0A}); histos.add("hFT0AOuter_Collisions", "hFT0AOuter_Collisions", kTH1D, {axisMultUltraFineFT0A}); + histos.add("hFT0COuter_Collisions", "hFT0COuter_Collisions", kTH1D, {axisMultUltraFineFT0C}); histos.add("hFT0MOuterA_Collisions", "hFT0MOuterA_Collisions", kTH1D, {axisMultUltraFineFT0M}); + histos.add("hFIT_Collisions", "hFIT_Collisions", kTH1D, {axisMultUltraFineFIT}); + histos.add("hFIT_FullV0_Collisions", "hFIT_FullV0_Collisions", kTH1D, {axisMultUltraFineFIT}); + histos.add("hFIT_All_Collisions", "hFIT_All_Collisions", kTH1D, {axisMultUltraFineFIT}); histos.add("hNGlobalTracks", "hNGlobalTracks", kTH1D, {axisMultUltraFineGlobalTracks}); histos.add("hNMFTTracks", "hNMFTTracks", kTH1D, {axisMultUltraFineMFTTracks}); @@ -407,12 +413,17 @@ struct CentralityStudy { histos.get(HIST("hBCSelection"))->GetXaxis()->SetBinLabel(8, "zpac time"); histos.get(HIST("hBCSelection"))->GetXaxis()->SetBinLabel(9, "isFlangeEvent"); + histos.add("hFIT_BCs", "hFIT_BCs", kTH1D, {axisMultUltraFineFIT}); + histos.add("hFIT_FullV0_BCs", "hFIT_FullV0_BCs", kTH1D, {axisMultUltraFineFIT}); + histos.add("hFIT_All_BCs", "hFIT_All_BCs", kTH1D, {axisMultUltraFineFIT}); histos.add("hFT0C_BCs", "hFT0C_BCs", kTH1D, {axisMultUltraFineFT0C}); + histos.add("hFT0COuter_BCs", "hFT0COuter_BCs", kTH1D, {axisMultUltraFineFT0C}); histos.add("hFT0A_BCs", "hFT0A_BCs", kTH1D, {axisMultUltraFineFT0A}); histos.add("hFT0AOuter_BCs", "hFT0AOuter_BCs", kTH1D, {axisMultUltraFineFT0A}); histos.add("hFT0M_BCs", "hFT0M_BCs", kTH1D, {axisMultUltraFineFT0M}); histos.add("hFT0MOuterA_BCs", "hFT0MOuterA_BCs", kTH1D, {axisMultUltraFineFT0M}); histos.add("hFV0A_BCs", "hFV0A_BCs", kTH1D, {axisMultUltraFineFV0A}); + histos.add("hFV0AOuter_BCs", "hFV0AOuter_BCs", kTH1D, {axisMultUltraFineFV0A}); histos.add("hFV0AT0C_BCs", "hFV0AT0C_BCs", kTH1D, {axisMultUltraFineFV0AT0C}); histos.add("hScaledFT0M_BCs", "hScaledFT0M_BCs", kTH1D, {axisMultUltraFineScaledFT0M}); @@ -541,11 +552,17 @@ struct CentralityStudy { getHist(histPath + "hCollisionSelection")->GetXaxis()->SetBinLabel(19, "bcsel"); histPointers.insert({histPath + "hFT0C_Collisions", histos.add((histPath + "hFT0C_Collisions").c_str(), "hFT0C_Collisions", {kTH1D, {{axisMultUltraFineFT0C}}})}); + histPointers.insert({histPath + "hFT0COuter_Collisions", histos.add((histPath + "hFT0COuter_Collisions").c_str(), "hFT0COuter_Collisions", {kTH1D, {{axisMultUltraFineFT0C}}})}); histPointers.insert({histPath + "hFT0A_Collisions", histos.add((histPath + "hFT0A_Collisions").c_str(), "hFT0A_Collisions", {kTH1D, {{axisMultUltraFineFT0A}}})}); histPointers.insert({histPath + "hFT0AOuter_Collisions", histos.add((histPath + "hFT0AOuter_Collisions").c_str(), "hFT0AOuter_Collisions", {kTH1D, {{axisMultUltraFineFT0C}}})}); + histPointers.insert({histPath + "hFV0AOuter_Collisions", histos.add((histPath + "hFV0AOuter_Collisions").c_str(), "hFV0AOuter_Collisions", {kTH1D, {{axisMultUltraFineFV0A}}})}); histPointers.insert({histPath + "hFT0MOuterA_Collisions", histos.add((histPath + "hFT0MOuterA_Collisions").c_str(), "hFT0MOuterA_Collisions", {kTH1D, {{axisMultUltraFineFT0A}}})}); histPointers.insert({histPath + "hFT0M_Collisions", histos.add((histPath + "hFT0M_Collisions").c_str(), "hFT0M_Collisions", {kTH1D, {{axisMultUltraFineFT0M}}})}); histPointers.insert({histPath + "hFV0A_Collisions", histos.add((histPath + "hFV0A_Collisions").c_str(), "hFV0A_Collisions", {kTH1D, {{axisMultUltraFineFV0A}}})}); + histPointers.insert({histPath + "hFIT_Collisions", histos.add((histPath + "hFIT_Collisions").c_str(), "hFIT_Collisions", {kTH1D, {{axisMultUltraFineFIT}}})}); + histPointers.insert({histPath + "hFIT_FullV0_Collisions", histos.add((histPath + "hFIT_FullV0_Collisions").c_str(), "hFIT_FullV0_Collisions", {kTH1D, {{axisMultUltraFineFIT}}})}); + histPointers.insert({histPath + "hFIT_All_Collisions", histos.add((histPath + "hFIT_All_Collisions").c_str(), "hFIT_All_Collisions", {kTH1D, {{axisMultUltraFineFIT}}})}); + histPointers.insert({histPath + "hNGlobalTracks", histos.add((histPath + "hNGlobalTracks").c_str(), "hNGlobalTracks", {kTH1D, {{axisMultUltraFineGlobalTracks}}})}); histPointers.insert({histPath + "hNMFTTracks", histos.add((histPath + "hNMFTTracks").c_str(), "hNMFTTracks", {kTH1D, {{axisMultUltraFineMFTTracks}}})}); histPointers.insert({histPath + "hNPVContributors", histos.add((histPath + "hNPVContributors").c_str(), "hNPVContributors", {kTH1D, {{axisMultUltraFinePVContributors}}})}); @@ -1174,8 +1191,14 @@ struct CentralityStudy { if constexpr (requires { collision.has_multBC(); }) { if (collision.has_multBC()) { auto multbc = collision.template multBC_as>(); + histos.fill(HIST("hFV0AOuter_Collisions"), multbc.multFV0AOuter() * scale.factorFV0A); histos.fill(HIST("hFT0AOuter_Collisions"), multbc.multFT0AOuter() * scale.factorFT0A); histos.fill(HIST("hFT0MOuterA_Collisions"), multbc.multFT0AOuter() + multbc.multFT0C() * scale.factorFT0M); + + histos.fill(HIST("hFT0COuter_Collisions"), multbc.multFT0COuter() * scale.factorFT0C); + histos.fill(HIST("hFIT_Collisions"), (multbc.multFT0C() + multbc.multFT0AOuter() + multbc.multFV0AOuter()) * scale.factorFIT); + histos.fill(HIST("hFIT_FullV0_Collisions"), (multbc.multFT0C() + multbc.multFT0AOuter() + multbc.multFV0A()) * scale.factorFIT); + histos.fill(HIST("hFIT_All_Collisions"), (multbc.multFT0C() + multbc.multFT0A() + multbc.multFV0A()) * scale.factorFIT); if (studies.do2DPlots) { histos.fill(HIST("hFT0AOuterVsFT0C"), multbc.multFT0C() * scale.factorFT0C, multbc.multFT0AOuter() * scale.factorFT0A); } @@ -1192,6 +1215,7 @@ struct CentralityStudy { if (studies.doRunByRunHistograms) { getHist(histPath + "hInteractionRate")->Fill(interactionRate); getHist(histPath + "hFT0AOuter_Collisions")->Fill(multbc.multFT0AOuter() * scale.factorFT0A); + getHist(histPath + "hFV0AOuter_Collisions")->Fill(multbc.multFV0AOuter() * scale.factorFV0A); getHist(histPath + "hFT0MOuterA_Collisions")->Fill(multbc.multFT0AOuter() + multbc.multFT0C() * scale.factorFT0M); if (studies.do2DPlots) { getHist(histPath + "hFT0AOuterVsFT0C")->Fill(multbc.multFT0C() * scale.factorFT0C, multbc.multFT0AOuter() * scale.factorFT0A); @@ -1348,13 +1372,17 @@ struct CentralityStudy { // if we got here, we also finally fill the FT0C histogram, please histos.fill(HIST("hFT0C_BCs"), multbc.multFT0C() * scale.factorFT0C); + histos.fill(HIST("hFT0COuter_BCs"), multbc.multFT0COuter() * scale.factorFT0C); histos.fill(HIST("hFT0A_BCs"), multbc.multFT0A() * scale.factorFT0A); histos.fill(HIST("hFT0AOuter_BCs"), multbc.multFT0AOuter() * scale.factorFT0A); + histos.fill(HIST("hFV0AOuter_BCs"), multbc.multFV0AOuter() * scale.factorFV0A); histos.fill(HIST("hFT0M_BCs"), (multbc.multFT0A() + multbc.multFT0C()) * scale.factorFT0M); histos.fill(HIST("hFT0MOuterA_BCs"), (multbc.multFT0AOuter() + multbc.multFT0C()) * scale.factorFT0M); histos.fill(HIST("hFV0A_BCs"), multbc.multFV0A() * scale.factorFV0A); - histos.fill(HIST("hFV0AT0C_BCs"), (multbc.multFV0A() + multbc.multFT0C()) * scale.factorFV0AT0C); - + histos.fill(HIST("hFV0AT0C_BCs"), (multbc.multFV0A() + multbc.multFT0C()) * scale.factorFIT); + histos.fill(HIST("hFIT_BCs"), (multbc.multFT0C() + multbc.multFT0AOuter() + multbc.multFV0AOuter()) * scale.factorFIT); + histos.fill(HIST("hFIT_FullV0_BCs"), (multbc.multFT0C() + multbc.multFT0AOuter() + multbc.multFV0A()) * scale.factorFIT); + histos.fill(HIST("hFIT_All_BCs"), (multbc.multFT0C() + multbc.multFT0A() + multbc.multFV0A()) * scale.factorFIT); if (studies.do2DPlots) { histos.fill(HIST("hFT0AVsFT0C_BCs"), multbc.multFT0C() * scale.factorFT0C, multbc.multFT0A() * scale.factorFT0A); histos.fill(HIST("hFV0AVsFT0C_BCs"), multbc.multFT0C() * scale.factorFT0C, multbc.multFV0A() * scale.factorFV0A); @@ -1384,9 +1412,9 @@ struct CentralityStudy { continue; } - const float selfNormFV0A = scale.normFT0A * multbc.multFV0A() / histos.get(HIST("hFT0A_BCs"))->GetMean(); - const float selfNormFT0A = scale.normFV0A * multbc.multFT0A() / histos.get(HIST("hFT0C_BCs"))->GetMean(); - const float selfNormFT0C = scale.normFT0C * multbc.multFT0C() / histos.get(HIST("hFV0A_BCs"))->GetMean(); + const float selfNormFV0A = scale.normFV0A * multbc.multFV0A() / histos.get(HIST("hFV0A_BCs"))->GetMean(); + const float selfNormFT0A = scale.normFT0A * multbc.multFT0A() / histos.get(HIST("hFT0A_BCs"))->GetMean(); + const float selfNormFT0C = scale.normFT0C * multbc.multFT0C() / histos.get(HIST("hFT0C_BCs"))->GetMean(); histos.fill(HIST("hScaledFT0M_BCs"), selfNormFT0A + selfNormFT0C); histos.fill(HIST("hScaledFV0AT0C_BCs"), selfNormFV0A + selfNormFT0C); } From ac6d458da5be1c8ffb80e577ff31bf8f0ce8eb68 Mon Sep 17 00:00:00 2001 From: jesgum Date: Thu, 24 Sep 2026 13:45:28 +0200 Subject: [PATCH 2/2] FT0C+FV0AOuter --- Common/Tasks/centralityStudy.cxx | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Common/Tasks/centralityStudy.cxx b/Common/Tasks/centralityStudy.cxx index 9f8b85bc763..3746eb622d5 100644 --- a/Common/Tasks/centralityStudy.cxx +++ b/Common/Tasks/centralityStudy.cxx @@ -426,6 +426,7 @@ struct CentralityStudy { histos.add("hFV0AOuter_BCs", "hFV0AOuter_BCs", kTH1D, {axisMultUltraFineFV0A}); histos.add("hFV0AT0C_BCs", "hFV0AT0C_BCs", kTH1D, {axisMultUltraFineFV0AT0C}); + histos.add("hFV0AOuterT0C_BCs", "hFV0AOuterT0C_BCs", kTH1D, {axisMultUltraFineFV0AT0C}); histos.add("hScaledFT0M_BCs", "hScaledFT0M_BCs", kTH1D, {axisMultUltraFineScaledFT0M}); histos.add("hScaledFV0AT0C_BCs", "hScaledFV0AT0C_BCs", kTH1D, {axisMultUltraFineScaledFV0AT0C}); @@ -1380,6 +1381,7 @@ struct CentralityStudy { histos.fill(HIST("hFT0MOuterA_BCs"), (multbc.multFT0AOuter() + multbc.multFT0C()) * scale.factorFT0M); histos.fill(HIST("hFV0A_BCs"), multbc.multFV0A() * scale.factorFV0A); histos.fill(HIST("hFV0AT0C_BCs"), (multbc.multFV0A() + multbc.multFT0C()) * scale.factorFIT); + histos.fill(HIST("hFV0AOuterT0C_BCs"), (multbc.multFV0AOuter() + multbc.multFT0C()) * scale.factorFIT); histos.fill(HIST("hFIT_BCs"), (multbc.multFT0C() + multbc.multFT0AOuter() + multbc.multFV0AOuter()) * scale.factorFIT); histos.fill(HIST("hFIT_FullV0_BCs"), (multbc.multFT0C() + multbc.multFT0AOuter() + multbc.multFV0A()) * scale.factorFIT); histos.fill(HIST("hFIT_All_BCs"), (multbc.multFT0C() + multbc.multFT0A() + multbc.multFV0A()) * scale.factorFIT);