@@ -166,8 +166,8 @@ struct OnTheFlyTofPid {
   std::array<std::array<std::shared_ptr<TH2>, NParticles>, NParticles> h2dOuterDeltaTrue;
 
   struct ParticleInfo {
-    std::string_view texName{};
-    std::string_view name{};
+    std::string_view texName;
+    std::string_view name;
     ParticleId type{};
     int pdgCode{};
     double mass{};
@@ -347,7 +347,7 @@ struct OnTheFlyTofPid {
           if (!doQaForParticle(Particles[iHyp].pdgCode)) {
             continue;
           }
-          const auto& pNameHypo = Particles[iHyp].texName;
+          const auto& pNameHypo = Particles[iHyp].name;
 
           const std::string nameTitleInner = std::format("h2dInnerNsigmaTrue{}Vs{}", pNameTrue, pNameHypo);
           const std::string nameTitleOuter = std::format("h2dOuterNsigmaTrue{}Vs{}", pNameTrue, pNameHypo);
 
@@ -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<TrackletMults, TPCMults, PVMults>;
 using Mults = soa::Join<BarrelMults, FV0Mults, FT0Mults, FDDMults, ZDCMults>;
@@ -216,6 +217,8 @@ DECLARE_SOA_TABLE_VERSIONED(MultMCExtras_001, "AOD", "MULTMCEXTRA", 1, //! Table
 using MultMCExtras = MultMCExtras_001;
 using MultMCExtra = MultMCExtras::iterator;
 using MultsExtraMC = MultMCExtras; // for backwards compatibility with previous naming scheme
+template <aod::is_origin_hash O>
+using MultsExtraMCFrom = MultMCExtras_001From<O>;
 
 // crosslinks
 namespace mult
@@ -311,6 +314,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 +358,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;
 
 
@@ -56,7 +56,8 @@ DECLARE_SOA_COLUMN(CentralityFt0c, centralityFt0c, float); //! Centrality
 DECLARE_SOA_COLUMN(CentralityFt0a, centralityFt0a, float); //! Centrality
 DECLARE_SOA_COLUMN(CentralityFt0m, centralityFt0m, float); //! Centrality
 DECLARE_SOA_COLUMN(Timestamp, timestamp, uint64_t);        //! Timestamp
-DECLARE_SOA_COLUMN(SelectionBits, selectionBits, uint8_t); //! Selection Flags
+DECLARE_SOA_COLUMN(SelectionBits, selectionBits, uint8_t); //! Selection flags x collisions
+DECLARE_SOA_COLUMN(BcMask, bcMask, uint8_t);               //! Selection flags x BC
 } // namespace zdclightions
 
 DECLARE_SOA_TABLE(ZDCLightIons, "AOD", "ZDCTABLELIGHTIONS",
@@ -92,7 +93,8 @@ DECLARE_SOA_TABLE(ZDCLightIons, "AOD", "ZDCTABLELIGHTIONS",
                   zdclightions::CentralityFt0a,
                   zdclightions::CentralityFt0m,
                   zdclightions::Timestamp,
-                  zdclightions::SelectionBits);
+                  zdclightions::SelectionBits,
+                  zdclightions::BcMask);
 } // namespace o2::aod
 
 #endif // COMMON_DATAMODEL_ZDCLIGHTIONS_H_
@@ -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)
@@ -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 <Framework/AnalysisDataModel.h>
+#include <Framework/AnalysisHelpers.h>
+#include <Framework/AnalysisTask.h>
+#include <Framework/runDataProcessing.h>
+
+struct MultBCs002Converter {
+  o2::framework::Produces<o2::aod::MultBCs_002> 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<MultBCs002Converter>(cfgc)};
+}
@@ -44,7 +44,6 @@ using namespace o2;
 using namespace o2::framework;
 using namespace o2::framework::expressions;
 using BCPattern = std::bitset<o2::constants::lhc::LHCMaxBunches>;
-const int nBCsPerOrbit = o2::constants::lhc::LHCMaxBunches;
 
 struct MultiplicityExtraTable {
   Produces<aod::MultBCs> multBC;
@@ -62,6 +61,7 @@ struct MultiplicityExtraTable {
   Configurable<float> bcDownscaleFactor{"bcDownscaleFactor", 2, "Downscale factor for BC table (0: save nothing, 1: save all)"};
   Configurable<float> minFT0CforBCTable{"minFT0CforBCTable", 25.0f, "Minimum FT0C amplitude to fill BC table to reduce data"};
   Configurable<bool> saveOnlyBCsWithCollisions{"saveOnlyBCsWithCollisions", true, "save only BCs with collisions in them"};
+  Configurable<bool> requestMinSignalForFT0C{"requestMinSignalForFT0C", true, "save only BCs with minimum FT0C signal"};
 
   Configurable<float> 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<uint8_t>(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(),
 
@@ -18,6 +18,9 @@
 #include "Common/DataModel/EventSelection.h"
 #include "Common/DataModel/ZDCLightIons.h"
 
+#include <CCDB/BasicCCDBManager.h>
+#include <CommonConstants/LHCConstants.h>
+#include <DataFormatsParameters/GRPLHCIFData.h>
 #include <Framework/AnalysisDataModel.h>
 #include <Framework/AnalysisHelpers.h>
 #include <Framework/AnalysisTask.h>
@@ -31,7 +34,10 @@
 #include <TH1.h>
 #include <TH2.h>
 
+#include <bitset>
 #include <cstdint>
+#include <map>
+#include <string>
 
 using namespace o2;
 using namespace o2::aod;
@@ -45,6 +51,14 @@ using ColEvSels = soa::Join<aod::Collisions, aod::EvSels, aod::CentFT0As, aod::C
 struct ZdcTaskLightIons {
 
   Produces<aod::ZDCLightIons> zdcTableLI;
+  Service<o2::ccdb::BasicCCDBManager> ccdb;
+  static const int nBCsPerOrbit = o2::constants::lhc::LHCMaxBunches;
+  std::bitset<nBCsPerOrbit> beamPatternA;
+  std::bitset<nBCsPerOrbit> beamPatternC;
+  std::bitset<nBCsPerOrbit> bcPatternB;
+  std::bitset<nBCsPerOrbit> bcPatternA;
+  std::bitset<nBCsPerOrbit> bcPatternC;
+  std::bitset<nBCsPerOrbit> bcPatternE;
 
   // Configurable parameters
   Configurable<int> nBinsTiming{"nBinsTiming", 200, "n bins for debunching histo"};
@@ -78,6 +92,14 @@ struct ZdcTaskLightIons {
     nEventSelections
   };
 
+  enum bcMaskBits {
+    bcMask_beamB,
+    bcMask_beamA,
+    bcMask_beamC,
+    bcMask_beamE,
+    nBits
+  };
+
   void init(InitContext const&)
   {
     registry.add("zdcDebunchHist", "ZN sum vs. diff; ZNA-ZNC (ns); ZNA+ZNC (ns)", {HistType::kTH2D, {{nBinsTiming, -20., 20.}, {nBinsTiming, -20., 20.}}});
@@ -158,9 +180,46 @@ struct ZdcTaskLightIons {
 
   void processZDCBC(BCsRun3 const& bcs, aod::Zdcs const& /*zdcs*/)
   {
+    auto& ccdbMgr = o2::ccdb::BasicCCDBManager::instance();
+    uint64_t timeStamp = bcs.iteratorAt(0).timestamp();
+    std::map<std::string, std::string> metadata;
+    // use getSpecific to set metadata to avoid crashes related to specific run number
+    auto grplhcif = ccdbMgr.getSpecific<o2::parameters::GRPLHCIFData>("GLO/Config/GRPLHCIF", timeStamp, metadata);
+    // auto grplhcif = ccdb->getForTimeStamp<o2::parameters::GRPLHCIFData>("GLO/Config/GRPLHCIF", timeStamp);
+    if (grplhcif == nullptr) {
+      LOG(fatal) << "GRPLHCIFData not in database, timestamp:" << timeStamp;
+    }
+
+    beamPatternA = grplhcif->getBunchFilling().getBeamPattern(0);
+    beamPatternC = grplhcif->getBunchFilling().getBeamPattern(1);
+    bcPatternB = grplhcif->getBunchFilling().getBCPattern();
+    bcPatternA = beamPatternA & ~beamPatternC;
+    bcPatternC = ~beamPatternA & beamPatternC;
+    bcPatternE = ~beamPatternA & ~beamPatternC;
+
     for (const auto& bc : bcs) {
+
       if (bc.has_zdc()) {
 
+        // int64_t timestamp = bc.timestamp();
+        auto timestampFromSOR = (bc.timestamp() - grplhcif->getFillNumberTime()) / 1e3; // Convert to seconds
+
+        int bcInOrbit = bc.globalBC() % nBCsPerOrbit;
+
+        uint8_t maskSel = 0;
+        if (bcPatternB[bcInOrbit]) {
+          maskSel |= (uint8_t)(0x1u << bcMask_beamB);
+        }
+        if (bcPatternA[bcInOrbit]) {
+          maskSel |= (uint8_t)(0x1u << bcMask_beamA);
+        }
+        if (bcPatternC[bcInOrbit]) {
+          maskSel |= (uint8_t)(0x1u << bcMask_beamC);
+        }
+        if (bcPatternE[bcInOrbit]) {
+          maskSel |= (uint8_t)(0x1u << bcMask_beamE);
+        }
+
         auto tdcZNA = bc.zdc().timeZNA();
         auto tdcZNC = bc.zdc().timeZNC();
         auto tdcZPA = bc.zdc().timeZPA();
@@ -225,8 +284,9 @@ struct ZdcTaskLightIons {
                    -1, -1, -1,
                    -1.,
                    -1, -1, -1,
-                   bc.timestamp(),
-                   -1);
+                   timestampFromSOR,
+                   0,
+                   maskSel);
       }
     }
   }
@@ -333,7 +393,8 @@ struct ZdcTaskLightIons {
                    zv,
                    centralityFT0C, centralityFT0A, centralityFT0M,
                    foundBC.timestamp(),
-                   evSelection);
+                   evSelection,
+                   0);
       }
     }
   }