FT0: executed clang-format

wpierozak · wpierozak · commit 986a12bbb935 · 2026-01-13T12:30:47.000+01:00
diff --git a/Detectors/FIT/FT0/calibration/include/FT0Calibration/EventsPerBcCalibrator.h b/Detectors/FIT/FT0/calibration/include/FT0Calibration/EventsPerBcCalibrator.h
@@ -20,22 +20,22 @@ namespace o2::ft0
 {
     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);
+      EventsPerBc(int32_t minAmplitudeSideA, int32_t minAmplitudeSideC) : mMinAmplitudeSideA(minAmplitudeSideA), mMinAmplitudeSideC(minAmplitudeSideC) {}
 
-        const int32_t mMinAmplitudeSideA;
-        const int32_t mMinAmplitudeSideC;
+      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);
 
-        std::array<double, o2::constants::lhc::LHCMaxBunches> mTvx{0.0};
-        size_t entries{0};
-        long startTimeStamp{0};
-        long stopTimeStamp{0};
+      const int32_t mMinAmplitudeSideA;
+      const int32_t mMinAmplitudeSideC;
 
-        ClassDefNV(EventsPerBc, 1);
+      std::array<double, o2::constants::lhc::LHCMaxBunches> mTvx{0.0};
+      size_t entries{0};
+      long startTimeStamp{0};
+      long stopTimeStamp{0};
+
+      ClassDefNV(EventsPerBc, 1);
     };
 
     class EventsPerBcCalibrator final : public o2::calibration::TimeSlotCalibration<o2::ft0::EventsPerBc>
@@ -44,25 +44,25 @@ namespace o2::ft0
         using TFType = o2::calibration::TFType;
 
         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;
+         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;
 
-        const std::vector<std::unique_ptr<TH1F>>& getTvxPerBc() { return mTvxPerBcs; }
-        std::vector<std::unique_ptr<o2::ccdb::CcdbObjectInfo>>& getTvxPerBcCcdbInfo() { return mTvxPerBcInfos; }
+         const std::vector<std::unique_ptr<TH1F>>& 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;
+         const uint32_t mMinNumberOfEntries;
+         const int32_t mMinAmplitudeSideA;
+         const int32_t mMinAmplitudeSideC;
 
-        std::vector<std::unique_ptr<TH1F>> mTvxPerBcs;
-        std::vector<std::unique_ptr<o2::ccdb::CcdbObjectInfo>> mTvxPerBcInfos;
+         std::vector<std::unique_ptr<TH1F>> mTvxPerBcs;
+         std::vector<std::unique_ptr<o2::ccdb::CcdbObjectInfo>> mTvxPerBcInfos;
 
-        ClassDefOverride(EventsPerBcCalibrator, 1);
+         ClassDefOverride(EventsPerBcCalibrator, 1);
     };
 }
 
diff --git a/Detectors/FIT/FT0/calibration/src/EventsPerBcCalibrator.cxx b/Detectors/FIT/FT0/calibration/src/EventsPerBcCalibrator.cxx
@@ -13,8 +13,8 @@ namespace o2::ft0
         size_t oldEntries = entries;
         for(const auto& digit: data) {
             double isVertex = digit.mTriggers.getVertex();
-            if(digit.mTriggers.getAmplA() < mMinAmplitudeSideA || digit.mTriggers.getAmplC() < mMinAmplitudeSideC) {
-                continue;
+            if (digit.mTriggers.getAmplA() < mMinAmplitudeSideA || digit.mTriggers.getAmplC() < mMinAmplitudeSideC) {
+              continue;
             }
             mTvx[digit.mIntRecord.bc] += isVertex;
             entries += isVertex;
@@ -36,12 +36,11 @@ namespace o2::ft0
         mTvxPerBcInfos.clear();
     }
 
-    
-    EventsPerBcCalibrator::EventsPerBcCalibrator(uint32_t minNumberOfEntries, int32_t minAmplitudeSideA, int32_t minAmplitudeSideC): mMinNumberOfEntries(minNumberOfEntries), mMinAmplitudeSideA(minAmplitudeSideA), mMinAmplitudeSideC(minAmplitudeSideC)
+    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;
+      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
@@ -51,17 +50,17 @@ namespace o2::ft0
 
     void EventsPerBcCalibrator::finalizeSlot(EventsPerBcCalibrator::Slot& slot)
     {
-        LOG(info) << "Finalizing slot from " << slot.getStartTimeMS()  << " to " << slot.getEndTimeMS();
+        LOG(info) << "Finalizing slot from " << slot.getStartTimeMS() << " to " << slot.getEndTimeMS();
         o2::ft0::EventsPerBc* data = slot.getContainer();
         mTvxPerBcs.emplace_back(std::make_unique<TH1F>("TvxPerBc", "FT0 TVX per BC", o2::constants::lhc::LHCMaxBunches, 0, o2::constants::lhc::LHCMaxBunches - 1));
-        for(int bin = 0; bin < o2::constants::lhc::LHCMaxBunches; bin++) {
+        for (int bin = 0; bin < o2::constants::lhc::LHCMaxBunches; bin++) {
             mTvxPerBcs.back()->Fill(bin, data->mTvx[bin]);
         }
         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/TvxPerBc", clName, flName, metaData, slot.getStartTimeMS(), slot.getEndTimeMS()));
-        LOG(info) << "Created new calibration object. Current number of objects: " << mTvxPerBcs.size();
+        LOG(info) << "Created object valid from " << mTvxPerBcInfos.back()->getStartValidityTimestamp() << " to " << TvxPerBcInfos.back()->getEndValidityTimestamp() << ""
     }
 
     EventsPerBcCalibrator::Slot& EventsPerBcCalibrator::emplaceNewSlot(bool front, TFType tstart, TFType tend)
diff --git a/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcProcessor-Workflow.cxx b/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcProcessor-Workflow.cxx
@@ -10,19 +10,17 @@ o2::framework::WorkflowSpec defineDataProcessing(o2::framework::ConfigContext co
     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>()),
-        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, std::numeric_limits<int32_t>::min(), {"Amplitude threshold for Side A events"}},
-            {"min-ampl-side-c", VariantType::Int, std::numeric_limits<int32_t>::min(), {"Amplitude threshold for Side C events"}}
-        }
-    };
+      "FT0EventsPerBcProcessor",
+      inputs,
+      outputs,
+      AlgorithmSpec(adaptFromTask<FT0EventsPerBcProcessor>()),
+      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, std::numeric_limits<int32_t>::min(), {"Amplitude threshold for Side A events"}},
+        {"min-ampl-side-c", VariantType::Int, std::numeric_limits<int32_t>::min(), {"Amplitude threshold for Side C events"}}}};
 
     WorkflowSpec workflow;
     workflow.emplace_back(dataProcessorSpec);
diff --git a/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcSpec.h b/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcSpec.h
@@ -24,39 +24,39 @@ namespace o2::calibration
         
         void init(o2::framework::InitContext& ic) final
         {
-            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");
-            }
+          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 run(o2::framework::ProcessingContext& pc) final
@@ -74,26 +74,26 @@ namespace o2::calibration
 
         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();    
+          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];
+            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.get(), 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.get(), 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()) {
