diff --git a/Detectors/FIT/FT0/calibration/include/FT0Calibration/EventsPerBcCalibrator.h b/Detectors/FIT/FT0/calibration/include/FT0Calibration/EventsPerBcCalibrator.h
index be5cefe5d915b..2afdf33980428 100644
--- a/Detectors/FIT/FT0/calibration/include/FT0Calibration/EventsPerBcCalibrator.h
+++ b/Detectors/FIT/FT0/calibration/include/FT0Calibration/EventsPerBcCalibrator.h
@@ -18,53 +18,52 @@
 
 namespace o2::ft0
 {
-    struct EventsPerBc
-    {
-      EventsPerBc(int32_t minAmplitudeSideA, int32_t minAmplitudeSideC) : mMinAmplitudeSideA(minAmplitudeSideA), mMinAmplitudeSideC(minAmplitudeSideC) {}
+struct EventsPerBc {
+  EventsPerBc(int32_t minAmplitudeSideA, int32_t minAmplitudeSideC) : mMinAmplitudeSideA(minAmplitudeSideA), mMinAmplitudeSideC(minAmplitudeSideC) {}
 
-      size_t getEntries() const { return entries; }
-      void print() const;
-      void fill(const o2::dataformats::TFIDInfo& ti, const gsl::span<const o2::ft0::Digit> data);
-      void merge(const EventsPerBc* prev);
+  size_t getEntries() const { return entries; }
+  void print() const;
+  void fill(const o2::dataformats::TFIDInfo& ti, const gsl::span<const o2::ft0::Digit> data);
+  void merge(const EventsPerBc* prev);
 
-      const int32_t mMinAmplitudeSideA;
-      const int32_t mMinAmplitudeSideC;
+  const int32_t mMinAmplitudeSideA;
+  const int32_t mMinAmplitudeSideC;
 
-      std::array<double, o2::constants::lhc::LHCMaxBunches> mTvx{0.0};
-      size_t entries{0};
-      long startTimeStamp{0};
-      long stopTimeStamp{0};
+  std::array<double, o2::constants::lhc::LHCMaxBunches> mTvx{0.0};
+  size_t entries{0};
+  long startTimeStamp{0};
+  long stopTimeStamp{0};
 
-      ClassDefNV(EventsPerBc, 1);
-    };
+  ClassDefNV(EventsPerBc, 1);
+};
 
-    class EventsPerBcCalibrator final : public o2::calibration::TimeSlotCalibration<o2::ft0::EventsPerBc>
-    {
-        using Slot = o2::calibration::TimeSlot<o2::ft0::EventsPerBc>;
-        using TFType = o2::calibration::TFType;
-        using EventsHistogram = std::array<double, o2::constants::lhc::LHCMaxBunches>;
+class EventsPerBcCalibrator final : public o2::calibration::TimeSlotCalibration<o2::ft0::EventsPerBc>
+{
+  using Slot = o2::calibration::TimeSlot<o2::ft0::EventsPerBc>;
+  using TFType = o2::calibration::TFType;
+  using EventsHistogram = std::array<double, o2::constants::lhc::LHCMaxBunches>;
 
-       public:
-        EventsPerBcCalibrator(uint32_t minNumberOfEntries, int32_t minAmplitudeSideA, int32_t minAmplitudeSideC);
+ public:
+  EventsPerBcCalibrator(uint32_t minNumberOfEntries, int32_t minAmplitudeSideA, int32_t minAmplitudeSideC);
 
-        bool hasEnoughData(const Slot& slot) const override;
-        void initOutput() override;
-        void finalizeSlot(Slot& slot) override;
-        Slot& emplaceNewSlot(bool front, TFType tstart, TFType tend) override;
+  bool hasEnoughData(const Slot& slot) const override;
+  void initOutput() override;
+  void finalizeSlot(Slot& slot) override;
+  Slot& emplaceNewSlot(bool front, TFType tstart, TFType tend) override;
 
-        const std::vector<EventsHistogram>& getTvxPerBc() { return mTvxPerBcs; }
-        std::vector<std::unique_ptr<o2::ccdb::CcdbObjectInfo>>& getTvxPerBcCcdbInfo() { return mTvxPerBcInfos; }
+  const std::vector<EventsHistogram>& getTvxPerBc() { return mTvxPerBcs; }
+  std::vector<std::unique_ptr<o2::ccdb::CcdbObjectInfo>>& getTvxPerBcCcdbInfo() { return mTvxPerBcInfos; }
 
-       private:
-        const uint32_t mMinNumberOfEntries;
-        const int32_t mMinAmplitudeSideA;
-        const int32_t mMinAmplitudeSideC;
+ private:
+  const uint32_t mMinNumberOfEntries;
+  const int32_t mMinAmplitudeSideA;
+  const int32_t mMinAmplitudeSideC;
 
-        std::vector<EventsHistogram> mTvxPerBcs;
-        std::vector<std::unique_ptr<o2::ccdb::CcdbObjectInfo>> mTvxPerBcInfos;
+  std::vector<EventsHistogram> mTvxPerBcs;
+  std::vector<std::unique_ptr<o2::ccdb::CcdbObjectInfo>> mTvxPerBcInfos;
 
-        ClassDefOverride(EventsPerBcCalibrator, 1);
-    };
-}
+  ClassDefOverride(EventsPerBcCalibrator, 1);
+};
+} // namespace o2::ft0
 
 #endif
diff --git a/Detectors/FIT/FT0/calibration/src/EventsPerBcCalibrator.cxx b/Detectors/FIT/FT0/calibration/src/EventsPerBcCalibrator.cxx
index 99b0f0f8a9726..e8e6eff79283f 100644
--- a/Detectors/FIT/FT0/calibration/src/EventsPerBcCalibrator.cxx
+++ b/Detectors/FIT/FT0/calibration/src/EventsPerBcCalibrator.cxx
@@ -3,70 +3,70 @@
 
 namespace o2::ft0
 {
-    void EventsPerBc::print() const
-    {
-        LOG(info) << entries << " entries";
-    }
+void EventsPerBc::print() const
+{
+  LOG(info) << entries << " entries";
+}
 
-    void EventsPerBc::fill(const o2::dataformats::TFIDInfo& ti, const gsl::span<const o2::ft0::Digit> data)
-    {
-        size_t oldEntries = entries;
-        for(const auto& digit: data) {
-          double isVertex = digit.mTriggers.getVertex();
-          if (digit.mTriggers.getAmplA() < mMinAmplitudeSideA || digit.mTriggers.getAmplC() < mMinAmplitudeSideC) {
-            continue;
-          }
-            mTvx[digit.mIntRecord.bc] += isVertex;
-            entries += isVertex;
-        }
-        LOG(debug) << "Container is filled with " << entries - oldEntries << " new events";
+void EventsPerBc::fill(const o2::dataformats::TFIDInfo& ti, const gsl::span<const o2::ft0::Digit> data)
+{
+  size_t oldEntries = entries;
+  for (const auto& digit : data) {
+    double isVertex = digit.mTriggers.getVertex();
+    if (digit.mTriggers.getAmplA() < mMinAmplitudeSideA || digit.mTriggers.getAmplC() < mMinAmplitudeSideC) {
+      continue;
     }
+    mTvx[digit.mIntRecord.bc] += isVertex;
+    entries += isVertex;
+  }
+  LOG(debug) << "Container is filled with " << entries - oldEntries << " new events";
+}
 
-    void EventsPerBc::merge(const EventsPerBc* prev)
-    {
-       for(int bc = 0; bc < o2::constants::lhc::LHCMaxBunches; bc++){
-            mTvx[bc] += prev->mTvx[bc];    
-       }
-       entries += prev->entries;
-    }
+void EventsPerBc::merge(const EventsPerBc* prev)
+{
+  for (int bc = 0; bc < o2::constants::lhc::LHCMaxBunches; bc++) {
+    mTvx[bc] += prev->mTvx[bc];
+  }
+  entries += prev->entries;
+}
 
-    void EventsPerBcCalibrator::initOutput()
-    {
-        mTvxPerBcs.clear();
-        mTvxPerBcInfos.clear();
-    }
+void EventsPerBcCalibrator::initOutput()
+{
+  mTvxPerBcs.clear();
+  mTvxPerBcInfos.clear();
+}
 
-    EventsPerBcCalibrator::EventsPerBcCalibrator(uint32_t minNumberOfEntries, int32_t minAmplitudeSideA, int32_t minAmplitudeSideC) : mMinNumberOfEntries(minNumberOfEntries), mMinAmplitudeSideA(minAmplitudeSideA), mMinAmplitudeSideC(minAmplitudeSideC)
-    {
-      LOG(info) << "Defined threshold for number of entires per slot: " << mMinNumberOfEntries;
-      LOG(info) << "Defined threshold for side A amplitude for event: " << mMinAmplitudeSideA;
-      LOG(info) << "Defined threshold for side C amplitude for event: " << mMinAmplitudeSideC;
-    }
+EventsPerBcCalibrator::EventsPerBcCalibrator(uint32_t minNumberOfEntries, int32_t minAmplitudeSideA, int32_t minAmplitudeSideC) : mMinNumberOfEntries(minNumberOfEntries), mMinAmplitudeSideA(minAmplitudeSideA), mMinAmplitudeSideC(minAmplitudeSideC)
+{
+  LOG(info) << "Defined threshold for number of entires per slot: " << mMinNumberOfEntries;
+  LOG(info) << "Defined threshold for side A amplitude for event: " << mMinAmplitudeSideA;
+  LOG(info) << "Defined threshold for side C amplitude for event: " << mMinAmplitudeSideC;
+}
 
-    bool EventsPerBcCalibrator::hasEnoughData(const EventsPerBcCalibrator::Slot& slot) const
-    { 
-        return slot.getContainer()->entries > mMinNumberOfEntries;
-    }
+bool EventsPerBcCalibrator::hasEnoughData(const EventsPerBcCalibrator::Slot& slot) const
+{
+  return slot.getContainer()->entries > mMinNumberOfEntries;
+}
 
-    void EventsPerBcCalibrator::finalizeSlot(EventsPerBcCalibrator::Slot& slot)
-    {
-        LOG(info) << "Finalizing slot from " << slot.getStartTimeMS() << " to " << slot.getEndTimeMS();
-        o2::ft0::EventsPerBc* data = slot.getContainer();
-        mTvxPerBcs.emplace_back(std::move(data->mTvx));
+void EventsPerBcCalibrator::finalizeSlot(EventsPerBcCalibrator::Slot& slot)
+{
+  LOG(info) << "Finalizing slot from " << slot.getStartTimeMS() << " to " << slot.getEndTimeMS();
+  o2::ft0::EventsPerBc* data = slot.getContainer();
+  mTvxPerBcs.emplace_back(std::move(data->mTvx));
 
-        auto clName = o2::utils::MemFileHelper::getClassName(mTvxPerBcs.back());
-        auto flName = o2::ccdb::CcdbApi::generateFileName(clName);
+  auto clName = o2::utils::MemFileHelper::getClassName(mTvxPerBcs.back());
+  auto flName = o2::ccdb::CcdbApi::generateFileName(clName);
 
-        std::map<std::string, std::string> metaData;
-        mTvxPerBcInfos.emplace_back(std::make_unique<o2::ccdb::CcdbObjectInfo>("FT0/Calib/EventsPerBc", clName, flName, metaData, slot.getStartTimeMS(), slot.getEndTimeMS()));
-        LOG(info) << "Created object valid from " << mTvxPerBcInfos.back()->getStartValidityTimestamp() << " to " << mTvxPerBcInfos.back()->getEndValidityTimestamp();
-    }
+  std::map<std::string, std::string> metaData;
+  mTvxPerBcInfos.emplace_back(std::make_unique<o2::ccdb::CcdbObjectInfo>("FT0/Calib/EventsPerBc", clName, flName, metaData, slot.getStartTimeMS(), slot.getEndTimeMS()));
+  LOG(info) << "Created object valid from " << mTvxPerBcInfos.back()->getStartValidityTimestamp() << " to " << mTvxPerBcInfos.back()->getEndValidityTimestamp();
+}
 
-    EventsPerBcCalibrator::Slot& EventsPerBcCalibrator::emplaceNewSlot(bool front, TFType tstart, TFType tend)
-    {
-        auto& cont = getSlots();
-        auto& slot = front ? cont.emplace_front(tstart, tend) : cont.emplace_back(tstart, tend);
-        slot.setContainer(std::make_unique<EventsPerBc>(mMinAmplitudeSideA, mMinAmplitudeSideC));
-        return slot;
-    }
-}
\ No newline at end of file
+EventsPerBcCalibrator::Slot& EventsPerBcCalibrator::emplaceNewSlot(bool front, TFType tstart, TFType tend)
+{
+  auto& cont = getSlots();
+  auto& slot = front ? cont.emplace_front(tstart, tend) : cont.emplace_back(tstart, tend);
+  slot.setContainer(std::make_unique<EventsPerBc>(mMinAmplitudeSideA, mMinAmplitudeSideC));
+  return slot;
+}
+} // namespace o2::ft0
\ No newline at end of file
diff --git a/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcProcessor-Workflow.cxx b/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcProcessor-Workflow.cxx
index 50b2b8d144da4..d6c4459c29b79 100644
--- a/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcProcessor-Workflow.cxx
+++ b/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcProcessor-Workflow.cxx
@@ -2,34 +2,34 @@
 #include <limits>
 o2::framework::WorkflowSpec defineDataProcessing(o2::framework::ConfigContext const& cfgc)
 {
-    using namespace o2::framework;
-    using o2::calibration::FT0EventsPerBcProcessor;
-    std::vector<InputSpec> inputs;
-    auto ccdbRequest = std::make_shared<o2::base::GRPGeomRequest>(true,                           // orbitResetTime
-                                                                false,                           // GRPECS=true
+  using namespace o2::framework;
+  using o2::calibration::FT0EventsPerBcProcessor;
+  std::vector<InputSpec> inputs;
+  auto ccdbRequest = std::make_shared<o2::base::GRPGeomRequest>(true,                           // orbitResetTime
+                                                                false,                          // GRPECS=true
                                                                 false,                          // GRPLHCIF
                                                                 false,                          // GRPMagField
                                                                 false,                          // askMatLUT
                                                                 o2::base::GRPGeomRequest::None, // geometry
                                                                 inputs);
-    inputs.emplace_back("digits", "FT0", "DIGITSBC");
-    std::vector<OutputSpec> outputs;
-    outputs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBWrapper, "EventsPerBc"}, Lifetime::Sporadic);
-    outputs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBPayload, "EventsPerBc"}, Lifetime::Sporadic);
-    DataProcessorSpec dataProcessorSpec{
-      "FT0EventsPerBcProcessor",
-      inputs,
-      outputs,
-      AlgorithmSpec(adaptFromTask<FT0EventsPerBcProcessor>(ccdbRequest)),
-      Options{
-        {"slot-len-sec", VariantType::UInt32, 3600u, {"Duration of each slot in seconds"}},
-        {"slot-len-tf", VariantType::UInt32, 0u, {"Slot length in Time Frames (TFs)"}},
-        {"one-object-per-run", VariantType::Bool, false, {"If set, workflow creates only one calibration object per run"}},
-        {"min-entries-number", VariantType::UInt32, 0u, {"Minimum number of entries required for a slot to be valid"}},
-        {"min-ampl-side-a", VariantType::Int, 0, {"Amplitude threshold for Side A events"}},
-        {"min-ampl-side-c", VariantType::Int, 0, {"Amplitude threshold for Side C events"}}}};
+  inputs.emplace_back("digits", "FT0", "DIGITSBC");
+  std::vector<OutputSpec> outputs;
+  outputs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBWrapper, "EventsPerBc"}, Lifetime::Sporadic);
+  outputs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBPayload, "EventsPerBc"}, Lifetime::Sporadic);
+  DataProcessorSpec dataProcessorSpec{
+    "FT0EventsPerBcProcessor",
+    inputs,
+    outputs,
+    AlgorithmSpec(adaptFromTask<FT0EventsPerBcProcessor>(ccdbRequest)),
+    Options{
+      {"slot-len-sec", VariantType::UInt32, 3600u, {"Duration of each slot in seconds"}},
+      {"slot-len-tf", VariantType::UInt32, 0u, {"Slot length in Time Frames (TFs)"}},
+      {"one-object-per-run", VariantType::Bool, false, {"If set, workflow creates only one calibration object per run"}},
+      {"min-entries-number", VariantType::UInt32, 0u, {"Minimum number of entries required for a slot to be valid"}},
+      {"min-ampl-side-a", VariantType::Int, 0, {"Amplitude threshold for Side A events"}},
+      {"min-ampl-side-c", VariantType::Int, 0, {"Amplitude threshold for Side C events"}}}};
 
-    WorkflowSpec workflow;
-    workflow.emplace_back(dataProcessorSpec);
-    return workflow;
+  WorkflowSpec workflow;
+  workflow.emplace_back(dataProcessorSpec);
+  return workflow;
 }
\ No newline at end of file
diff --git a/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcSpec.h b/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcSpec.h
index 33826a76be3d2..53bef2a3979ac 100644
--- a/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcSpec.h
+++ b/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcSpec.h
@@ -15,109 +15,108 @@
 #include "DataFormatsFT0/Digit.h"
 #include "FT0Calibration/EventsPerBcCalibrator.h"
 
-
 namespace o2::calibration
 {
-    class FT0EventsPerBcProcessor final : public o2::framework::Task
-    {
-        public:
-        FT0EventsPerBcProcessor(std::shared_ptr<o2::base::GRPGeomRequest> request): mCCDBRequest(request) {}
-        
-        void init(o2::framework::InitContext& ic) final
-        {
-          o2::base::GRPGeomHelper::instance().setRequest(mCCDBRequest);
-          if (ic.options().hasOption("slot-len-sec")) {
-            mSlotLenSec = ic.options().get<uint32_t>("slot-len-sec");
-          }
-          if (ic.options().hasOption("one-object-per-run")) {
-            mOneObjectPerRun = ic.options().get<bool>("one-object-per-run");
-          }
-          if (ic.options().hasOption("slot-len-tf")) {
-            mSlotLen = ic.options().get<o2::calibration::TFType>("slot-len-tf");
-          }
-          if (ic.options().hasOption("min-entries-number")) {
-            mMinNumberOfEntries = ic.options().get<uint32_t>("min-entries-number");
-          }
-          if (ic.options().hasOption("min-ampl-side-a")) {
-            mMinAmplitudeSideA = ic.options().get<int32_t>("min-ampl-side-a");
-          }
-          if (ic.options().hasOption("min-ampl-side-c")) {
-            mMinAmplitudeSideC = ic.options().get<int32_t>("min-ampl-side-c");
-          }
+class FT0EventsPerBcProcessor final : public o2::framework::Task
+{
+ public:
+  FT0EventsPerBcProcessor(std::shared_ptr<o2::base::GRPGeomRequest> request) : mCCDBRequest(request) {}
+
+  void init(o2::framework::InitContext& ic) final
+  {
+    o2::base::GRPGeomHelper::instance().setRequest(mCCDBRequest);
+    if (ic.options().hasOption("slot-len-sec")) {
+      mSlotLenSec = ic.options().get<uint32_t>("slot-len-sec");
+    }
+    if (ic.options().hasOption("one-object-per-run")) {
+      mOneObjectPerRun = ic.options().get<bool>("one-object-per-run");
+    }
+    if (ic.options().hasOption("slot-len-tf")) {
+      mSlotLen = ic.options().get<o2::calibration::TFType>("slot-len-tf");
+    }
+    if (ic.options().hasOption("min-entries-number")) {
+      mMinNumberOfEntries = ic.options().get<uint32_t>("min-entries-number");
+    }
+    if (ic.options().hasOption("min-ampl-side-a")) {
+      mMinAmplitudeSideA = ic.options().get<int32_t>("min-ampl-side-a");
+    }
+    if (ic.options().hasOption("min-ampl-side-c")) {
+      mMinAmplitudeSideC = ic.options().get<int32_t>("min-ampl-side-c");
+    }
 
-          mCalibrator = std::make_unique<o2::ft0::EventsPerBcCalibrator>(mMinNumberOfEntries, mMinAmplitudeSideA, mMinAmplitudeSideC);
+    mCalibrator = std::make_unique<o2::ft0::EventsPerBcCalibrator>(mMinNumberOfEntries, mMinAmplitudeSideA, mMinAmplitudeSideC);
 
-          if (mOneObjectPerRun) {
-            LOG(info) << "Only one object will be created at the end of run";
-            mCalibrator->setUpdateAtTheEndOfRunOnly();
-          }
-          if (mOneObjectPerRun == false && mSlotLen == 0) {
-            LOG(info) << "Defined slot interval to " << mSlotLenSec << " seconds";
-            mCalibrator->setSlotLengthInSeconds(mSlotLenSec);
-          }
-          if (mOneObjectPerRun == false && mSlotLen != 0) {
-            LOG(info) << "Defined slot interval to " << mSlotLen << " TFS";
-            mCalibrator->setSlotLength(mSlotLen);
-          }
-        }
+    if (mOneObjectPerRun) {
+      LOG(info) << "Only one object will be created at the end of run";
+      mCalibrator->setUpdateAtTheEndOfRunOnly();
+    }
+    if (mOneObjectPerRun == false && mSlotLen == 0) {
+      LOG(info) << "Defined slot interval to " << mSlotLenSec << " seconds";
+      mCalibrator->setSlotLengthInSeconds(mSlotLenSec);
+    }
+    if (mOneObjectPerRun == false && mSlotLen != 0) {
+      LOG(info) << "Defined slot interval to " << mSlotLen << " TFS";
+      mCalibrator->setSlotLength(mSlotLen);
+    }
+  }
 
-        void finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj)
-        {
-          o2::base::GRPGeomHelper::instance().finaliseCCDB(matcher, obj);
-        }
+  void finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj)
+  {
+    o2::base::GRPGeomHelper::instance().finaliseCCDB(matcher, obj);
+  }
 
-        void run(o2::framework::ProcessingContext& pc) final
-        {
-            o2::base::GRPGeomHelper::instance().checkUpdates(pc);
-            auto digits = pc.inputs().get<gsl::span<o2::ft0::Digit>>("digits");
-            o2::base::TFIDInfoHelper::fillTFIDInfo(pc, mCalibrator->getCurrentTFInfo());
-            if(digits.size() == 0) {
-                return;
-            }
-            mCalibrator->process(digits);
-            if(mOneObjectPerRun == false) {
-                sendOutput(pc.outputs());
-            }
-        }
+  void run(o2::framework::ProcessingContext& pc) final
+  {
+    o2::base::GRPGeomHelper::instance().checkUpdates(pc);
+    auto digits = pc.inputs().get<gsl::span<o2::ft0::Digit>>("digits");
+    o2::base::TFIDInfoHelper::fillTFIDInfo(pc, mCalibrator->getCurrentTFInfo());
+    if (digits.size() == 0) {
+      return;
+    }
+    mCalibrator->process(digits);
+    if (mOneObjectPerRun == false) {
+      sendOutput(pc.outputs());
+    }
+  }
 
-        void endOfStream(o2::framework::EndOfStreamContext& ec) final
-        {
-          LOG(info) << "Received end-of-stream, checking for slot to finalize...";
-          mCalibrator->checkSlotsToFinalize();
-          sendOutput(ec.outputs());
-          mCalibrator->initOutput();
-        }
+  void endOfStream(o2::framework::EndOfStreamContext& ec) final
+  {
+    LOG(info) << "Received end-of-stream, checking for slot to finalize...";
+    mCalibrator->checkSlotsToFinalize();
+    sendOutput(ec.outputs());
+    mCalibrator->initOutput();
+  }
 
-        void sendOutput(o2::framework::DataAllocator& output)
-        {
-            using o2::framework::Output;
-            const auto& tvxHists = mCalibrator->getTvxPerBc();
-            auto& infos = mCalibrator->getTvxPerBcCcdbInfo();
-            for (unsigned int idx = 0; idx < tvxHists.size(); idx++) {
-              auto& info = infos[idx];
-              const auto& payload = tvxHists[idx];
+  void sendOutput(o2::framework::DataAllocator& output)
+  {
+    using o2::framework::Output;
+    const auto& tvxHists = mCalibrator->getTvxPerBc();
+    auto& infos = mCalibrator->getTvxPerBcCcdbInfo();
+    for (unsigned int idx = 0; idx < tvxHists.size(); idx++) {
+      auto& info = infos[idx];
+      const auto& payload = tvxHists[idx];
 
-              auto image = o2::ccdb::CcdbApi::createObjectImage(&payload, info.get());
-              LOG(info) << "Sending object " << info->getPath() << "/" << info->getFileName() << " of size " << image->size()
-                        << " bytes, valid for " << info->getStartValidityTimestamp() << " : " << info->getEndValidityTimestamp();
-              output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBPayload, "EventsPerBc", idx}, *image.get());
-              output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBWrapper, "EventsPerBc", idx}, *info.get());
-            }
+      auto image = o2::ccdb::CcdbApi::createObjectImage(&payload, info.get());
+      LOG(info) << "Sending object " << info->getPath() << "/" << info->getFileName() << " of size " << image->size()
+                << " bytes, valid for " << info->getStartValidityTimestamp() << " : " << info->getEndValidityTimestamp();
+      output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBPayload, "EventsPerBc", idx}, *image.get());
+      output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBWrapper, "EventsPerBc", idx}, *info.get());
+    }
 
-            if(tvxHists.size()) {
-                mCalibrator->initOutput();
-            }
-        }
+    if (tvxHists.size()) {
+      mCalibrator->initOutput();
+    }
+  }
 
-        private:
-        std::shared_ptr<o2::base::GRPGeomRequest> mCCDBRequest;
-        std::unique_ptr<o2::ft0::EventsPerBcCalibrator> mCalibrator;
-        bool mOneObjectPerRun;
-        uint32_t mSlotLenSec;
-        o2::calibration::TFType mSlotLen;
-        uint32_t mMinNumberOfEntries;
-        int32_t mMinAmplitudeSideA;
-        int32_t mMinAmplitudeSideC;
-    };
-}
+ private:
+  std::shared_ptr<o2::base::GRPGeomRequest> mCCDBRequest;
+  std::unique_ptr<o2::ft0::EventsPerBcCalibrator> mCalibrator;
+  bool mOneObjectPerRun;
+  uint32_t mSlotLenSec;
+  o2::calibration::TFType mSlotLen;
+  uint32_t mMinNumberOfEntries;
+  int32_t mMinAmplitudeSideA;
+  int32_t mMinAmplitudeSideC;
+};
+} // namespace o2::calibration
 #endif
\ No newline at end of file