Fixed typos and scope issues

Author: wpierozak

Detectors/FIT/FT0/calibration/include/FT0Calibration/EventsPerBcCalibrator.h

@@ -9,7 +9,6 @@
 #include "DataFormatsFT0/SpectraInfoObject.h"
 #include "DetectorsCalibration/TimeSlotCalibration.h"
 #include "DetectorsCalibration/TimeSlot.h"
-#include "DataFormatsFT0/BcEvents.h"
 
 namespace o2::ft0
 {
@@ -34,22 +33,19 @@ namespace o2::ft0
         using TFType = o2::calibration::TFType;
 
         public:
-        EventsPerBcCalibrator()
-        {
-            setUpdateAtTheEndOfRunOnly();
-        }
+        EventsPerBcCalibrator() = default;
 
         bool hasEnoughData(const Slot& slot) const final { return true; }
         void initOutput() final;
         void finalizeSlot(Slot& slot) final;
         Slot& emplaceNewSlot(bool front, TFType tstart, TFType tend) final;
 
-        const TH1F* getTvxPerBc() { return mTvxPerBc.get(); }
-        const CcdbObjectInfo* getTvxPerBcCcdbInfo() { return mTvxPerBcInfo.get(); }
+        const std::vector<std::unique_ptr<TH1F>>& getTvxPerBc() { return mTvxPerBcs; }
+        std::vector<std::unique_ptr<o2::ccdb::CcdbObjectInfo>>& getTvxPerBcCcdbInfo() { return mTvxPerBcInfos; }
 
         private:
-        std::unique_ptr<TH1F> mTvxPerBc;
-        std::unique_ptr<CcdbObjectInfo> mTvxPerBcInfo;
+        std::vector<std::unique_ptr<TH1F>> mTvxPerBcs;
+        std::vector<std::unique_ptr<o2::ccdb::CcdbObjectInfo>> mTvxPerBcInfos;
     };
 }
 

Detectors/FIT/FT0/calibration/src/EventsPerBcCalibrator.cxx

@@ -4,7 +4,7 @@ namespace o2::ft0
 {
     void EventsPerBc::print() const
     {
-
+        LOG(info) << entries << " entries";
     }
 
     void EventsPerBc::fill(const gsl::span<const o2::ft0::Digit> data)
@@ -26,21 +26,21 @@ namespace o2::ft0
 
     void EventsPerBcCalibrator::initOutput() final
     {
-        mTvxPerBc.reset();
-        mTvxPerBcInfo.reset();
+        mTvxPerBc.clear();
+        mTvxPerBcInfo.clear();
     }
 
     void EventsPerBcCalibrator::finalizeSlot(EventsPerBcCalibrator::Slot& slot) final
     {
         o2::ft0::EventsPerBc* data = slot.getContainer();
-        mTvxPerBc = std::make_unique<TH1F>("TvxPerBc", "FT0 TVX per BC", o2::constants::lhc::LHCMaxBunches, 0, o2::constants::lhc::LHCMaxBunches - 1);
+        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++) {
-            tvxsHist->fill(bin, data->mTvx[bin]);
+            mTvxPerBcs.back()->fill(bin, data->mTvx[bin]);
         }
-        auto clName = o2::utils::MemFileHelper::getClassName(*tvxsHist);
+        auto clName = o2::utils::MemFileHelper::getClassName(*mTvxPerBcs.back());
         auto flName = o2::ccdb::CcdbApi::generateFileName(clName);
         std::map<std::string, std::string> metaData;
-        mTvxPerBcInfo = std::make_unique<CcdbObjectInfo>("FT0/Calib/TvxPerBc", clName, flName, metaData, slot.getStarTimeMs(), slot.getEndTimeStampMS());
+        mTvxPerBcInfos.emplace_back(std::make_unique<CcdbObjectInfo>("FT0/Calib/TvxPerBc", clName, flName, metaData, slot.getStarTimeMs(), slot.getEndTimeStampMS()));
     }
 
     EventsPerBcCalibrator::Slot& EventsPerBcCalibrator::emplaceNewSlot(bool front, TFType tstart, TFType tend) final

Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcProcessor-Workflow.cxx

@@ -5,64 +5,98 @@
 #include "Framework/DeviceSpec.h"
 #include "Framework/WorkflowSpec.h"
 #include "Framework/Task.h"
+#include "DetectorsCalibration/Utils.h"
 
 #include "DataFormatsFT0/Digit.h"
-#include "DataFormatsFT0/BcEvents.h"
 #include "FT0Calibration/EventsPerBcCalibrator.h"
 
-namespace o2::ft0
+
+namespace o2::calibration
 {
     class FT0EventsPerBcProcessor final : public o2::framework::Task
     {
+        public:
         void init(o2::framework::InitContext& ic) final
         {
-            mCalibrator = std::make_unique<EventsPerBcCalibrator>();
+            mCalibrator = std::make_unique<o2::ft0::EventsPerBcCalibrator>();
+            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(mOneObjectPerRun) {
+                mCalibrator->setUpdateAtTheEndOfRunOnly();
+            } else {
+                mCalibrator->setSlotLengthInSeconds(mSlotLenSec);
+            }
         }
 
-        void run(o2::framework::ProcessContext& pc) final
+        void run(o2::framework::ProcessingContext& pc) final
         {
             auto digits = pc.inputs().get<gsl::span<o2::ft0::Digit>>("digits");
             mCalibrator->process(digits);
+            if(mOneObjectPerRun == false) {
+                sendOutput(pc.outputs());
+            }
         }
 
         void endOfStream(o2::framework::EndOfStreamContext& ec) final 
         {
-            mCalibrator->chekSlotToFinalize();
+            mCalibrator->checkSlotsToFinalize();
             sendOutput(ec.outputs());
             mCalibrator->initOutput();    
         }
 
-        void sendOutput(DataAllocator& output)
+        void sendOutput(o2::framework::DataAllocator& output)
         {
-            TH1F* tvxHist = mCalibrator->getTvxPerBc();
-            CcdbObjectInfo* info = mCalibrator->getTvxPerBcCcdbInfo();
-            auto image = o2::ccdb::CcdbApi::createObjectImage(tvxHist, info);
-            LOG(info) << "Sending object to CCDB";
-            output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBPayload, "EVENTS_PER_BC_INFO", 0}, *image.get());
-            output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBWrapper, "EVENTS_PER_BC_INFO", 0}, info);
+            using o2::framework::Output;
+
+            const auto& tvxHists = mCalibrator->getTvxPerBc();
+            auto& infos = mCalibrator->getTvxPerBcCcdbInfo();
+            for(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, "EVENTS_PER_BC_INFO", 0), *image.get());
+                output.snapshot(Output(o2::calibration::Utils::gDataOriginCDBWrapper, "EVENTS_PER_BC_INFO", 0), *info.get());
+            }
         }
 
         private:
-        std::unique_ptr<EventsPerBcCalibrator> mCalibrator;
+        std::unique_ptr<o2::ft0::EventsPerBcCalibrator> mCalibrator;
+        bool mOneObjectPerRun;
+        uint32_t mSlotLenSec;
     };
 }
 
-WorkflowSpec defineDataProcessing(ConfigContext& const & cfgc)
+namespace o2::framework
+{
+WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
 {
     using namespace o2::framework;
+    using o2::calibration::FT0EventsPerBcProcessor;
     std::vector<InputSpec> inputs;
     inputs.emplace_back("digits", "FT0", "DIGITSBC");
     std::vector<OutputSpec> outputs;
-    outputs.emplace_back("eventsPerBcInfo", "FT0", "EVENTS_PER_BC_INFO")
+    outputs.emplace_back("eventsPerBcInfo", "FT0", "EVENTS_PER_BC_INFO");
     DataProcessorSpec dataProcessorSpec{
         "FT0EventsPerBcProcessor",
         inputs,
         outputs,
-        AlgorithmSpec(adaptFromTask<o2::ft0::FT0EventsPerBcProcessor>()),
-        Options{}
+        AlgorithmSpec(adaptFromTask<FT0EventsPerBcProcessor>()),
+        Options{
+            {"slot-len-sec", VariantType::UInt32, 3600u, "Time lenght of slot in seconds"},
+            {"one-object-per-run", VariantType::Bool, false, "If true, then one calibration object is created per run"}
+        }
     };
 
     WorkflowSpec workflow;
     workflow.emplace_back(dataProcessorSpec);
     return workflow;
+}
 }