Add outer and rct info and converter to multBC table for centrality studies

jesgum · jesgum · commit 29362f065079 · 2026-06-02T15:37:22.000+02:00
diff --git a/Common/DataModel/Multiplicity.h b/Common/DataModel/Multiplicity.h
@@ -100,8 +100,10 @@ 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 +262,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 +285,46 @@ 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)
+  {
+    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,36 @@ 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
@@ -331,7 +331,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});
 
@@ -711,14 +713,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);
@@ -865,7 +871,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>>();
         uint64_t bcTimestamp = multbc.timestamp();
         const float interactionRate = mRateFetcher.fetch(ccdb.service, bcTimestamp, mRunNumber, irSource.value, irCrashOnNull) / 1000.; // kHz
         histos.fill(HIST("hInteractionRate"), interactionRate);
@@ -877,7 +883,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());
@@ -890,22 +896,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);
   }
@@ -998,7 +1004,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) {
@@ -1009,7 +1015,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);
 
@@ -1034,7 +1042,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
`@@ -331,7 +331,9 @@ struct centralityStudy {`
`331`	`331`
`332`	`332`	`histos.add("hFT0C_BCs", "hFT0C_BCs", kTH1D, {axisMultUltraFineFT0C});`
`333`	`333`	`histos.add("hFT0A_BCs", "hFT0A_BCs", kTH1D, {axisMultUltraFineFT0A});`
	`334`	`+ histos.add("hFT0AOuter_BCs", "hFT0AOuter_BCs", kTH1D, {axisMultUltraFineFT0A});`
`334`	`335`	`histos.add("hFT0M_BCs", "hFT0M_BCs", kTH1D, {axisMultUltraFineFT0M});`
	`336`	`+ histos.add("hFT0MOuterA_BCs", "hFT0MOuterA_BCs", kTH1D, {axisMultUltraFineFT0M});`
`335`	`337`	`histos.add("hFV0A_BCs", "hFV0A_BCs", kTH1D, {axisMultUltraFineFV0A});`
`336`	`338`	`histos.add("hInteractionRate_BCs", "hInteractionRate_BCs", kTH1D, {axisInteractionRate});`
`337`	`339`
`@@ -711,14 +713,18 @@ struct centralityStudy {`
`711`	`713`	`getHist(TH1, histPath + "hCollisionSelection")->Fill(15);`
`712`	`714`	`}`
`713`	`715`	`if (evsel.rejectIsFlangeEvent) {`
`714`		`- if constexpr (requires { collision.ft0TriggerMask(); }) {`
`715`		`- constexpr int IsFlangeEventId = 7;`
`716`		`- std::bitset<8> ft0TriggerMask = collision.ft0TriggerMask();`
`717`		`- if (ft0TriggerMask[IsFlangeEventId]) {`
`718`		`- return;`
	`716`	`+ if constexpr (requires { collision.has_multBC(); }) {`
	`717`	`+ if (collision.has_multBC()) {`
	`718`	`+ auto multbc = collision.template multBC_as<soa::Join<aod::MultBCs, aod::MultBcSel>>();`
	`719`	`+ constexpr int IsFlangeEventId = 7;`
	`720`	`+ std::bitset<8> ft0TriggerMask = multbc.multT0triggerBits();`
	`721`	`+ if (ft0TriggerMask[IsFlangeEventId]) {`
	`722`	`+ return;`
	`723`	`+ }`
`719`	`724`	`}`
`720`	`725`	`}`
`721`	`726`	`}`
	`727`	`+`
`722`	`728`	`histos.fill(HIST("hCollisionSelection"), 16 /* reject flange events */);`
`723`	`729`	`if (studies.doRunByRunHistograms) {`
`724`	`730`	`getHist(TH1, histPath + "hCollisionSelection")->Fill(16);`
`@@ -865,7 +871,7 @@ struct centralityStudy {`
`865`	`871`
`866`	`872`	`if constexpr (requires { collision.has_multBC(); }) {`
`867`	`873`	`if (collision.has_multBC()) {`
`868`		`- auto multbc = collision.template multBC_as<aod::MultBCs>();`
	`874`	`+ auto multbc = collision.template multBC_as<soa::Join<aod::MultBCs, aod::MultBcSel>>();`
`869`	`875`	`uint64_t bcTimestamp = multbc.timestamp();`
`870`	`876`	`const float interactionRate = mRateFetcher.fetch(ccdb.service, bcTimestamp, mRunNumber, irSource.value, irCrashOnNull) / 1000.; // kHz`
`871`	`877`	`histos.fill(HIST("hInteractionRate"), interactionRate);`
`@@ -877,7 +883,7 @@ struct centralityStudy {`
`877`	`883`	`getHist(TH2, histPath + "hFT0CVsTime")->Fill(hoursAfterStartOfRun, collision.multFT0C());`
`878`	`884`	`getHist(TH2, histPath + "hFT0MVsTime")->Fill(hoursAfterStartOfRun, collision.multFT0M());`
`879`	`885`	`getHist(TH2, histPath + "hFV0AVsTime")->Fill(hoursAfterStartOfRun, collision.multFV0A());`
`880`		`- getHist(TH2, histPath + "hFV0AOuterVsTime")->Fill(hoursAfterStartOfRun, collision.multFV0AOuter());`
	`886`	`+ getHist(TH2, histPath + "hFV0AOuterVsTime")->Fill(hoursAfterStartOfRun, multbc.multFV0AOuter());`
`881`	`887`	`getHist(TH2, histPath + "hMFTTracksVsTime")->Fill(hoursAfterStartOfRun, collision.mftNtracks());`
`882`	`888`	`getHist(TH2, histPath + "hNGlobalVsTime")->Fill(hoursAfterStartOfRun, collision.multNTracksGlobal());`
`883`	`889`	`getHist(TH2, histPath + "hNTPVContributorsVsTime")->Fill(hoursAfterStartOfRun, collision.multPVTotalContributors());`
`@@ -890,22 +896,22 @@ struct centralityStudy {`
`890`	`896`	`}`
`891`	`897`	`}`
`892`	`898`
`893`		`- void processCollisions(soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultsGlobal, aod::MultSelections, aod::Mults2BC, aod::FITExtraMults>::iterator const& collision, aod::MultBCs const&)`
	`899`	`+ 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&)`
`894`	`900`	`{`
`895`	`901`	`genericProcessCollision(collision);`
`896`	`902`	`}`
`897`	`903`
`898`		`- 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&)`
	`904`	`+ 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&)`
`899`	`905`	`{`
`900`	`906`	`genericProcessCollision(collision);`
`901`	`907`	`}`
`902`	`908`
`903`		`- 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&)`
	`909`	`+ 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&)`
`904`	`910`	`{`
`905`	`911`	`genericProcessCollision(collision);`
`906`	`912`	`}`
`907`	`913`
`908`		`- void processCollisionsWithCentralityWithNeighbours(soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultSelections, aod::CentFT0Cs, aod::MultsGlobal, aod::MultNeighs, aod::FITExtraMults>::iterator const& collision)`
	`914`	`+ void processCollisionsWithCentralityWithNeighbours(soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultSelections, aod::CentFT0Cs, aod::MultsGlobal, aod::MultNeighs>::iterator const& collision)`
`909`	`915`	`{`
`910`	`916`	`genericProcessCollision(collision);`
`911`	`917`	`}`
`@@ -998,7 +1004,7 @@ struct centralityStudy {`
`998`	`1004`	`return true;`
`999`	`1005`	`}`
`1000`	`1006`
`1001`		`- 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&)`
	`1007`	`+ 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&)`
`1002`	`1008`	`{`
`1003`	`1009`	`// process BCs, calculate FT0C distribution`
`1004`	`1010`	`for (const auto& multbc : multbcs) {`
`@@ -1009,7 +1015,9 @@ struct centralityStudy {`
`1009`	`1015`	`// if we got here, we also finally fill the FT0C histogram, please`
`1010`	`1016`	`histos.fill(HIST("hFT0C_BCs"), multbc.multFT0C() * scale.factorFT0C);`
`1011`	`1017`	`histos.fill(HIST("hFT0A_BCs"), multbc.multFT0A() * scale.factorFT0A);`
	`1018`	`+ histos.fill(HIST("hFT0AOuter_BCs"), multbc.multFT0AOuter() * scale.factorFT0A);`
`1012`	`1019`	`histos.fill(HIST("hFT0M_BCs"), (multbc.multFT0A() + multbc.multFT0C()) * scale.factorFT0M);`
	`1020`	`+ histos.fill(HIST("hFT0MOuterA_BCs"), (multbc.multFT0AOuter() + multbc.multFT0C()) * scale.factorFT0M);`
`1013`	`1021`	`histos.fill(HIST("hFV0A_BCs"), multbc.multFV0A() * scale.factorFV0A);`
`1014`	`1022`	`histos.fill(HIST("hFV0AT0C_BCs"), (multbc.multFV0A() + multbc.multFT0C()) * scale.factorFV0AT0C);`
`1015`	`1023`
`@@ -1034,7 +1042,7 @@ struct centralityStudy {`
`1034`	`1042`	`}`
`1035`	`1043`
`1036`	`1044`	`if (multbc.has_ft0Mult()) {`
`1037`		`- auto multco = multbc.ft0Mult_as<soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultSelections, aod::CentFT0Cs, aod::MultsGlobal>>();`
	`1045`	`+ auto multco = multbc.ft0Mult_as<soa::Join<aod::MultsRun3, aod::MFTMults, aod::MultsExtra, aod::MultSelections, aod::MultsGlobal>>();`
`1038`	`1046`	`if (multbc.multFT0PosZValid()) {`
`1039`	`1047`	`histos.fill(HIST("hVertexZ_BCvsCO"), multco.multPVz(), multbc.multFT0PosZ());`
`1040`	`1048`	`}`
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())`