[Common,PWGLF] Add outer and rct info and converter to multBC table for centrality studies (#16516)

jesgum · alibuild · web-flow · commit 2a807a7b33f4 · 2026-06-15T14:24:43.000+02:00
Co-authored-by: ALICE Action Bot &lt;alibuild@cern.ch&gt;
diff --git a/Common/DataModel/Multiplicity.h b/Common/DataModel/Multiplicity.h
@@ -100,8 +100,9 @@ DECLARE_SOA_COLUMN(TimeToNext, timeToNext, float);               //!
 DECLARE_SOA_COLUMN(TimeToNeNext, timeToNeNext, float);           //!
 
 // Extra information from FIT detectors
-DECLARE_SOA_COLUMN(MultFV0AOuter, multFV0AOuter, float);     //! FV0 without innermost ring
 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
 
 } // namespace mult
 DECLARE_SOA_TABLE(FV0Mults, "AOD", "FV0MULT", //! Multiplicity with the FV0 detector
@@ -260,7 +261,7 @@ DECLARE_SOA_COLUMN(MultCollidingBC, multCollidingBC, bool);          //! CTP tri
 DECLARE_SOA_COLUMN(MultFT0PosZ, multFT0PosZ, float);          //! Position along Z computed with the FT0 information within the BC
 DECLARE_SOA_COLUMN(MultFT0PosZValid, multFT0PosZValid, bool); //! Validity of the position along Z computed with the FT0 information
 } // namespace mult
-DECLARE_SOA_TABLE(MultBCs, "AOD", "MULTBC", //!
+DECLARE_SOA_TABLE(MultBCs_000, "AOD", "MULTBC", //!
                   mult::MultFT0A,
                   mult::MultFT0C,
                   mult::MultFT0PosZ,
@@ -283,11 +284,44 @@ DECLARE_SOA_TABLE(MultBCs, "AOD", "MULTBC", //!
                   mult::MultCollidingBC,
                   timestamp::Timestamp,
                   bc::Flags);
-using MultBC = MultBCs::iterator;
 
-DECLARE_SOA_TABLE(MultBcSel, "AOD", "MULTBCSEL", //! BC selection bits joinable with multBCs
+DECLARE_SOA_TABLE_VERSIONED(MultBCs_001, "AOD", "MULTBC", 1, //!
+                            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);
+
+DECLARE_SOA_TABLE(MultBcSel_000, "AOD", "MULTBCSEL", //! BC selection bits joinable with multBCs
                   evsel::Selection);
 
+DECLARE_SOA_TABLE_VERSIONED(MultBcSel_001, "AOD", "MULTBCSEL", 1, //! BC selection bits joinable with multBCs
+                            evsel::Selection,
+                            evsel::Rct,
+                            bc::Flags,
+                            timestamp::Timestamp,
+                            mult::MultFT0PosZ,
+                            mult::MultFT0PosZValid,
+                            mult::MultV0triggerBits,
+                            mult::MultT0triggerBits,
+                            mult::MultFDDtriggerBits,
+                            mult::MultTriggerMask,
+                            mult::MultCollidingBC,
+                            mult::MultTVX,
+                            mult::MultFV0OrA);
+
+using MultBCs = MultBCs_001;
+using MultBcSel = MultBcSel_001;
+using MultBC = MultBCs::iterator;
+
 // crosslinks
 namespace mult
 {
diff --git a/Common/TableProducer/Converters/CMakeLists.txt b/Common/TableProducer/Converters/CMakeLists.txt
@@ -113,3 +113,8 @@ o2physics_add_dpl_workflow(run2-tiny-to-full-pid
                     SOURCES run2TinyToFullPID.cxx
                     PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore
                     COMPONENT_NAME Analysis)
+
+o2physics_add_dpl_workflow(mult-bcs-converter
+                    SOURCES multBCsConverter.cxx
+                    PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore
+                    COMPONENT_NAME Analysis)
diff --git a/Common/TableProducer/Converters/multBCsConverter.cxx b/Common/TableProducer/Converters/multBCsConverter.cxx
@@ -0,0 +1,74 @@
+// 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 multBCsConverter.cxx
+/// \brief Converts MultBCs and MultBcSel table from version 000 to 001
+/// \author Jesper Karlsson Gumrpecht
+
+#include "Common/DataModel/Multiplicity.h"
+
+#include <Framework/AnalysisDataModel.h>
+#include <Framework/AnalysisHelpers.h>
+#include <Framework/AnalysisTask.h>
+#include <Framework/runDataProcessing.h>
+
+using namespace o2;
+using namespace o2::framework;
+
+struct MultBCsConverter {
+  Produces<aod::MultBCs_001> multBC;
+  Produces<aod::MultBcSel_001> multBcSel;
+
+  static constexpr float DummyValue = -1.f;
+  static constexpr int DummyRct = 0;
+  void process(soa::Join<aod::MultBCs_000, aod::MultBcSel_000> const& multBCs)
+  {
+    multBC.reserve(multBCs.size());
+    multBcSel.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(),
+        DummyValue,  // dummy amplitude for FV0A Outer
+        DummyValue); // dummy amplitude for FT0A Outer
+
+      multBcSel(
+        multbc.selection_raw(),
+        DummyRct, // all flags to false
+        multbc.flags(),
+        multbc.timestamp(),
+        multbc.multFT0PosZ(),
+        multbc.multFT0PosZValid(),
+        multbc.multV0triggerBits(),
+        multbc.multT0triggerBits(),
+        multbc.multFDDtriggerBits(),
+        multbc.multTriggerMask(),
+        multbc.multCollidingBC(),
+        multbc.multTVX(),
+        multbc.multFV0OrA());
+    }
+  }
+};
+
+WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
+{
+  return WorkflowSpec{
+    adaptAnalysisTask<MultBCsConverter>(cfgc)};
+}
diff --git a/Common/TableProducer/multiplicityExtraTable.cxx b/Common/TableProducer/multiplicityExtraTable.cxx
@@ -155,6 +155,8 @@ struct MultiplicityExtraTable {
       float multFV0A = 0.f;
       float multFDDA = 0.f;
       float multFDDC = 0.f;
+      float multFT0AOuter = 0.f;
+      float multFV0AOuter = 0.f;
 
       // ZDC amplitudes
       float multZEM1 = -1.f;
@@ -195,8 +197,11 @@ struct MultiplicityExtraTable {
         multFT0TriggerBits = static_cast<uint8_t>(triggers.to_ulong());
 
         // calculate T0 charge
-        for (auto amplitude : ft0.amplitudeA()) {
-          multFT0A += amplitude;
+        for (size_t ii = 0; ii < ft0.amplitudeA().size(); ++ii) {
+          multFT0A += ft0.amplitudeA()[ii];
+          if (ft0.channelA()[ii] > 31) {
+            multFT0AOuter += ft0.amplitudeA()[ii];
+          }
         }
         for (auto amplitude : ft0.amplitudeC()) {
           multFT0C += amplitude;
@@ -212,8 +217,13 @@ struct MultiplicityExtraTable {
         std::bitset<8> fV0Triggers = fv0.triggerMask();
         multFV0TriggerBits = static_cast<uint8_t>(fV0Triggers.to_ulong());
 
-        for (auto amplitude : fv0.amplitude()) {
+        for (size_t ii = 0; ii < fv0.amplitude().size(); ii++) {
+          auto amplitude = fv0.amplitude()[ii];
+          auto channel = fv0.channel()[ii];
           multFV0A += amplitude;
+          if (channel > 7) {
+            multFV0AOuter += amplitude;
+          }
         }
         isFV0OrA = fV0Triggers[o2::fit::Triggers::bitA];
       } else {
@@ -254,15 +264,34 @@ struct MultiplicityExtraTable {
 
       bc2mult(bc2multArray[bc.globalIndex()]);
       multBC(
-        tru(multFT0A), tru(multFT0C),
-        tru(posZFT0), posZFT0valid, tru(multFV0A),
-        tru(multFDDA), tru(multFDDC), tru(multZNA), tru(multZNC), tru(multZEM1),
-        tru(multZEM2), tru(multZPA), tru(multZPC), Tvx, isFV0OrA,
-        multFV0TriggerBits, multFT0TriggerBits, multFDDTriggerBits, multBCTriggerMask, collidingBC,
+        tru(multFT0A),
+        tru(multFT0C),
+        tru(multFV0A),
+        tru(multFDDA),
+        tru(multFDDC),
+        tru(multZNA),
+        tru(multZNC),
+        tru(multZEM1),
+        tru(multZEM2),
+        tru(multZPA),
+        tru(multZPC),
+        tru(multFV0AOuter),
+        tru(multFT0AOuter));
+
+      multBcSel(
+        bc.selection_raw(),
+        bc.rct_raw(),
+        bc.flags(),
         bc.timestamp(),
-        bc.flags());
-
-      multBcSel(bc.selection_raw());
+        tru(posZFT0),
+        posZFT0valid,
+        multFV0TriggerBits,
+        multFT0TriggerBits,
+        multFDDTriggerBits,
+        multBCTriggerMask,
+        collidingBC,
+        Tvx,
+        isFV0OrA);
     }
   }
 
diff --git a/Common/Tasks/centralityStudy.cxx b/Common/Tasks/centralityStudy.cxx
@@ -344,7 +344,9 @@ struct centralityStudy {
 
       histos.add("hFT0C_BCs", "hFT0C_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("hInteractionRate_BCs", "hInteractionRate_BCs", kTH1D, {axisInteractionRate});
 
@@ -795,14 +797,18 @@ struct centralityStudy {
       getHist(TH1, histPath + "hCollisionSelection")->Fill(15);
     }
     if (evsel.rejectIsFlangeEvent) {
-      if constexpr (requires { collision.ft0TriggerMask(); }) {
-        constexpr int IsFlangeEventId = 7;
-        std::bitset<8> ft0TriggerMask = collision.ft0TriggerMask();
-        if (ft0TriggerMask[IsFlangeEventId]) {
-          return;
+      if constexpr (requires { collision.has_multBC(); }) {
+        if (collision.has_multBC()) {
+          auto multbc = collision.template multBC_as<soa::Join<aod::MultBCs, aod::MultBcSel>>();
+          constexpr int IsFlangeEventId = 7;
+          std::bitset<8> ft0TriggerMask = multbc.multT0triggerBits();
+          if (ft0TriggerMask[IsFlangeEventId]) {
+            return;
+          }
         }
       }
     }
+
     histos.fill(HIST("hCollisionSelection"), 16 /* reject flange events */);
     if (studies.doRunByRunHistograms) {
       getHist(TH1, histPath + "hCollisionSelection")->Fill(16);
@@ -949,7 +955,7 @@ struct centralityStudy {
 
     if constexpr (requires { collision.has_multBC(); }) {
       if (collision.has_multBC()) {
-        auto multbc = collision.template multBC_as<aod::MultBCs>();
+        auto multbc = collision.template multBC_as<soa::Join<aod::MultBCs, aod::MultBcSel>>();
         const uint64_t bcTimestamp = multbc.timestamp();
         const float interactionRate = mRateFetcher.fetch(ccdb.service, bcTimestamp, mRunNumber, ccdbSettings.irSource.value, ccdbSettings.irCrashOnNull) / 1000.; // kHz
         histos.fill(HIST("hInteractionRate"), interactionRate);
@@ -967,7 +973,7 @@ struct centralityStudy {
             getHist(TH2, histPath + "hFT0CVsTime")->Fill(hoursAfterStartOfRun, collision.multFT0C());
             getHist(TH2, histPath + "hFT0MVsTime")->Fill(hoursAfterStartOfRun, collision.multFT0M());
             getHist(TH2, histPath + "hFV0AVsTime")->Fill(hoursAfterStartOfRun, collision.multFV0A());
-            getHist(TH2, histPath + "hFV0AOuterVsTime")->Fill(hoursAfterStartOfRun, collision.multFV0AOuter());
+            getHist(TH2, histPath + "hFV0AOuterVsTime")->Fill(hoursAfterStartOfRun, multbc.multFV0AOuter());
             getHist(TH2, histPath + "hMFTTracksVsTime")->Fill(hoursAfterStartOfRun, collision.mftNtracks());
             getHist(TH2, histPath + "hNGlobalVsTime")->Fill(hoursAfterStartOfRun, collision.multNTracksGlobal());
             getHist(TH2, histPath + "hNTPVContributorsVsTime")->Fill(hoursAfterStartOfRun, collision.multPVTotalContributors());
@@ -980,22 +986,22 @@ struct centralityStudy {
     }
   }
 
-  void processCollisions(soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultsGlobal, aod::MultSelections, aod::Mults2BC, aod::FITExtraMults>::iterator const& collision, aod::MultBCs const&)
+  void processCollisions(soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultsGlobal, aod::MultSelections, aod::Mults2BC>::iterator const& collision, soa::Join<aod::MultBCs, aod::MultBcSel> const&)
   {
     genericProcessCollision(collision);
   }
 
-  void processCollisionsWithResolutionStudy(soa::Join<aod::MultsRun3, aod::MFTMults, aod::Mult2MCExtras, aod::MultsExtra, aod::MultsGlobal, aod::MultSelections, aod::Mults2BC, aod::FITExtraMults>::iterator const& collision, soa::Join<aod::MultMCExtras, aod::MultHepMCHIs> const&)
+  void processCollisionsWithResolutionStudy(soa::Join<aod::MultsRun3, aod::MFTMults, aod::Mult2MCExtras, aod::MultsExtra, aod::MultsGlobal, aod::MultSelections, aod::Mults2BC>::iterator const& collision, soa::Join<aod::MultMCExtras, aod::MultHepMCHIs> const&)
   {
     genericProcessCollision(collision);
   }
 
-  void processCollisionsWithCentrality(soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultSelections, aod::CentFT0Cs, aod::MultsGlobal, aod::Mults2BC, aod::FITExtraMults>::iterator const& collision, aod::MultBCs const&)
+  void processCollisionsWithCentrality(soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultSelections, aod::CentFT0Cs, aod::MultsGlobal, aod::Mults2BC>::iterator const& collision, soa::Join<aod::MultBCs, aod::MultBcSel> const&)
   {
     genericProcessCollision(collision);
   }
 
-  void processCollisionsWithCentralityWithNeighbours(soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultSelections, aod::CentFT0Cs, aod::MultsGlobal, aod::MultNeighs, aod::FITExtraMults>::iterator const& collision)
+  void processCollisionsWithCentralityWithNeighbours(soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultSelections, aod::CentFT0Cs, aod::MultsGlobal, aod::MultNeighs>::iterator const& collision)
   {
     genericProcessCollision(collision);
   }
@@ -1088,7 +1094,7 @@ struct centralityStudy {
     return true;
   }
 
-  void processBCs(soa::Join<aod::BC2Mults, aod::MultBCs, aod::MultBcSel> const& multbcs, soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultSelections, aod::CentFT0Cs, aod::MultsGlobal> const&)
+  void processBCs(soa::Join<aod::BC2Mults, aod::MultBCs, aod::MultBcSel> const& multbcs, soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultSelections, aod::MultsGlobal> const&)
   {
     // process BCs, calculate FT0C distribution
     for (const auto& multbc : multbcs) {
@@ -1099,7 +1105,9 @@ 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("hFT0A_BCs"), multbc.multFT0A() * scale.factorFT0A);
+      histos.fill(HIST("hFT0AOuter_BCs"), multbc.multFT0AOuter() * scale.factorFT0A);
       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);
 
@@ -1124,7 +1132,7 @@ struct centralityStudy {
       }
 
       if (multbc.has_ft0Mult()) {
-        auto multco = multbc.ft0Mult_as<soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultSelections, aod::CentFT0Cs, aod::MultsGlobal>>();
+        auto multco = multbc.ft0Mult_as<soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultSelections, aod::MultsGlobal>>();
         if (multbc.multFT0PosZValid()) {
           histos.fill(HIST("hVertexZ_BCvsCO"), multco.multPVz(), multbc.multFT0PosZ());
         }
diff --git a/PWGLF/Tasks/GlobalEventProperties/heavyionMultiplicity.cxx b/PWGLF/Tasks/GlobalEventProperties/heavyionMultiplicity.cxx
@@ -1008,7 +1008,7 @@ struct HeavyionMultiplicity {
     } // collision loop
   }
 
-  void processBcData(soa::Join<aod::BC2Mults, aod::MultBCs, aod::BCCentFT0Cs, aod::BCCentFT0Ms>::iterator const& multbc)
+  void processBcData(soa::Join<aod::BC2Mults, aod::MultBCs, aod::BCCentFT0Cs, aod::BCCentFT0Ms, aod::MultBcSel>::iterator const& multbc)
   {
     histos.fill(HIST("BcHist"), 1); // all BCs
     if (selectCollidingBCs && !multbc.multCollidingBC())

Original file line number	Diff line number	Diff line change
`@@ -344,7 +344,9 @@ struct centralityStudy {`
`344`	`344`
`345`	`345`	`histos.add("hFT0C_BCs", "hFT0C_BCs", kTH1D, {axisMultUltraFineFT0C});`
`346`	`346`	`histos.add("hFT0A_BCs", "hFT0A_BCs", kTH1D, {axisMultUltraFineFT0A});`
	`347`	`+ histos.add("hFT0AOuter_BCs", "hFT0AOuter_BCs", kTH1D, {axisMultUltraFineFT0A});`
`347`	`348`	`histos.add("hFT0M_BCs", "hFT0M_BCs", kTH1D, {axisMultUltraFineFT0M});`
	`349`	`+ histos.add("hFT0MOuterA_BCs", "hFT0MOuterA_BCs", kTH1D, {axisMultUltraFineFT0M});`
`348`	`350`	`histos.add("hFV0A_BCs", "hFV0A_BCs", kTH1D, {axisMultUltraFineFV0A});`
`349`	`351`	`histos.add("hInteractionRate_BCs", "hInteractionRate_BCs", kTH1D, {axisInteractionRate});`
`350`	`352`
`@@ -795,14 +797,18 @@ struct centralityStudy {`
`795`	`797`	`getHist(TH1, histPath + "hCollisionSelection")->Fill(15);`
`796`	`798`	`}`
`797`	`799`	`if (evsel.rejectIsFlangeEvent) {`
`798`		`- if constexpr (requires { collision.ft0TriggerMask(); }) {`
`799`		`- constexpr int IsFlangeEventId = 7;`
`800`		`- std::bitset<8> ft0TriggerMask = collision.ft0TriggerMask();`
`801`		`- if (ft0TriggerMask[IsFlangeEventId]) {`
`802`		`- return;`
	`800`	`+ if constexpr (requires { collision.has_multBC(); }) {`
	`801`	`+ if (collision.has_multBC()) {`
	`802`	`+ auto multbc = collision.template multBC_as<soa::Join<aod::MultBCs, aod::MultBcSel>>();`
	`803`	`+ constexpr int IsFlangeEventId = 7;`
	`804`	`+ std::bitset<8> ft0TriggerMask = multbc.multT0triggerBits();`
	`805`	`+ if (ft0TriggerMask[IsFlangeEventId]) {`
	`806`	`+ return;`
	`807`	`+ }`
`803`	`808`	`}`
`804`	`809`	`}`
`805`	`810`	`}`
	`811`	`+`
`806`	`812`	`histos.fill(HIST("hCollisionSelection"), 16 /* reject flange events */);`
`807`	`813`	`if (studies.doRunByRunHistograms) {`
`808`	`814`	`getHist(TH1, histPath + "hCollisionSelection")->Fill(16);`
`@@ -949,7 +955,7 @@ struct centralityStudy {`
`949`	`955`
`950`	`956`	`if constexpr (requires { collision.has_multBC(); }) {`
`951`	`957`	`if (collision.has_multBC()) {`
`952`		`- auto multbc = collision.template multBC_as<aod::MultBCs>();`
	`958`	`+ auto multbc = collision.template multBC_as<soa::Join<aod::MultBCs, aod::MultBcSel>>();`
`953`	`959`	`const uint64_t bcTimestamp = multbc.timestamp();`
`954`	`960`	`const float interactionRate = mRateFetcher.fetch(ccdb.service, bcTimestamp, mRunNumber, ccdbSettings.irSource.value, ccdbSettings.irCrashOnNull) / 1000.; // kHz`
`955`	`961`	`histos.fill(HIST("hInteractionRate"), interactionRate);`
`@@ -967,7 +973,7 @@ struct centralityStudy {`
`967`	`973`	`getHist(TH2, histPath + "hFT0CVsTime")->Fill(hoursAfterStartOfRun, collision.multFT0C());`
`968`	`974`	`getHist(TH2, histPath + "hFT0MVsTime")->Fill(hoursAfterStartOfRun, collision.multFT0M());`
`969`	`975`	`getHist(TH2, histPath + "hFV0AVsTime")->Fill(hoursAfterStartOfRun, collision.multFV0A());`
`970`		`- getHist(TH2, histPath + "hFV0AOuterVsTime")->Fill(hoursAfterStartOfRun, collision.multFV0AOuter());`
	`976`	`+ getHist(TH2, histPath + "hFV0AOuterVsTime")->Fill(hoursAfterStartOfRun, multbc.multFV0AOuter());`
`971`	`977`	`getHist(TH2, histPath + "hMFTTracksVsTime")->Fill(hoursAfterStartOfRun, collision.mftNtracks());`
`972`	`978`	`getHist(TH2, histPath + "hNGlobalVsTime")->Fill(hoursAfterStartOfRun, collision.multNTracksGlobal());`
`973`	`979`	`getHist(TH2, histPath + "hNTPVContributorsVsTime")->Fill(hoursAfterStartOfRun, collision.multPVTotalContributors());`
`@@ -980,22 +986,22 @@ struct centralityStudy {`
`980`	`986`	`}`
`981`	`987`	`}`
`982`	`988`
`983`		`- void processCollisions(soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultsGlobal, aod::MultSelections, aod::Mults2BC, aod::FITExtraMults>::iterator const& collision, aod::MultBCs const&)`
	`989`	`+ void processCollisions(soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultsGlobal, aod::MultSelections, aod::Mults2BC>::iterator const& collision, soa::Join<aod::MultBCs, aod::MultBcSel> const&)`
`984`	`990`	`{`
`985`	`991`	`genericProcessCollision(collision);`
`986`	`992`	`}`
`987`	`993`
`988`		`- void processCollisionsWithResolutionStudy(soa::Join<aod::MultsRun3, aod::MFTMults, aod::Mult2MCExtras, aod::MultsExtra, aod::MultsGlobal, aod::MultSelections, aod::Mults2BC, aod::FITExtraMults>::iterator const& collision, soa::Join<aod::MultMCExtras, aod::MultHepMCHIs> const&)`
	`994`	`+ void processCollisionsWithResolutionStudy(soa::Join<aod::MultsRun3, aod::MFTMults, aod::Mult2MCExtras, aod::MultsExtra, aod::MultsGlobal, aod::MultSelections, aod::Mults2BC>::iterator const& collision, soa::Join<aod::MultMCExtras, aod::MultHepMCHIs> const&)`
`989`	`995`	`{`
`990`	`996`	`genericProcessCollision(collision);`
`991`	`997`	`}`
`992`	`998`
`993`		`- void processCollisionsWithCentrality(soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultSelections, aod::CentFT0Cs, aod::MultsGlobal, aod::Mults2BC, aod::FITExtraMults>::iterator const& collision, aod::MultBCs const&)`
	`999`	`+ void processCollisionsWithCentrality(soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultSelections, aod::CentFT0Cs, aod::MultsGlobal, aod::Mults2BC>::iterator const& collision, soa::Join<aod::MultBCs, aod::MultBcSel> const&)`
`994`	`1000`	`{`
`995`	`1001`	`genericProcessCollision(collision);`
`996`	`1002`	`}`
`997`	`1003`
`998`		`- void processCollisionsWithCentralityWithNeighbours(soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultSelections, aod::CentFT0Cs, aod::MultsGlobal, aod::MultNeighs, aod::FITExtraMults>::iterator const& collision)`
	`1004`	`+ void processCollisionsWithCentralityWithNeighbours(soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultSelections, aod::CentFT0Cs, aod::MultsGlobal, aod::MultNeighs>::iterator const& collision)`
`999`	`1005`	`{`
`1000`	`1006`	`genericProcessCollision(collision);`
`1001`	`1007`	`}`
`@@ -1088,7 +1094,7 @@ struct centralityStudy {`
`1088`	`1094`	`return true;`
`1089`	`1095`	`}`
`1090`	`1096`
`1091`		`- void processBCs(soa::Join<aod::BC2Mults, aod::MultBCs, aod::MultBcSel> const& multbcs, soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultSelections, aod::CentFT0Cs, aod::MultsGlobal> const&)`
	`1097`	`+ void processBCs(soa::Join<aod::BC2Mults, aod::MultBCs, aod::MultBcSel> const& multbcs, soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultSelections, aod::MultsGlobal> const&)`
`1092`	`1098`	`{`
`1093`	`1099`	`// process BCs, calculate FT0C distribution`
`1094`	`1100`	`for (const auto& multbc : multbcs) {`
`@@ -1099,7 +1105,9 @@ struct centralityStudy {`
`1099`	`1105`	`// if we got here, we also finally fill the FT0C histogram, please`
`1100`	`1106`	`histos.fill(HIST("hFT0C_BCs"), multbc.multFT0C() * scale.factorFT0C);`
`1101`	`1107`	`histos.fill(HIST("hFT0A_BCs"), multbc.multFT0A() * scale.factorFT0A);`
	`1108`	`+ histos.fill(HIST("hFT0AOuter_BCs"), multbc.multFT0AOuter() * scale.factorFT0A);`
`1102`	`1109`	`histos.fill(HIST("hFT0M_BCs"), (multbc.multFT0A() + multbc.multFT0C()) * scale.factorFT0M);`
	`1110`	`+ histos.fill(HIST("hFT0MOuterA_BCs"), (multbc.multFT0AOuter() + multbc.multFT0C()) * scale.factorFT0M);`
`1103`	`1111`	`histos.fill(HIST("hFV0A_BCs"), multbc.multFV0A() * scale.factorFV0A);`
`1104`	`1112`	`histos.fill(HIST("hFV0AT0C_BCs"), (multbc.multFV0A() + multbc.multFT0C()) * scale.factorFV0AT0C);`
`1105`	`1113`
`@@ -1124,7 +1132,7 @@ struct centralityStudy {`
`1124`	`1132`	`}`
`1125`	`1133`
`1126`	`1134`	`if (multbc.has_ft0Mult()) {`
`1127`		`- auto multco = multbc.ft0Mult_as<soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultSelections, aod::CentFT0Cs, aod::MultsGlobal>>();`
	`1135`	`+ auto multco = multbc.ft0Mult_as<soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultSelections, aod::MultsGlobal>>();`
`1128`	`1136`	`if (multbc.multFT0PosZValid()) {`
`1129`	`1137`	`histos.fill(HIST("hVertexZ_BCvsCO"), multco.multPVz(), multbc.multFT0PosZ());`
`1130`	`1138`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1008,7 +1008,7 @@ struct HeavyionMultiplicity {`
`1008`	`1008`	`} // collision loop`
`1009`	`1009`	`}`
`1010`	`1010`
`1011`		`- void processBcData(soa::Join<aod::BC2Mults, aod::MultBCs, aod::BCCentFT0Cs, aod::BCCentFT0Ms>::iterator const& multbc)`
	`1011`	`+ void processBcData(soa::Join<aod::BC2Mults, aod::MultBCs, aod::BCCentFT0Cs, aod::BCCentFT0Ms, aod::MultBcSel>::iterator const& multbc)`
`1012`	`1012`	`{`
`1013`	`1013`	`histos.fill(HIST("BcHist"), 1); // all BCs`
`1014`	`1014`	`if (selectCollidingBCs && !multbc.multCollidingBC())`