FT0: created first sketch of implementation of generation of TVX per Event calibration object

Author: wpierozak

Detectors/FIT/FT0/calibration/CMakeLists.txt

@@ -33,3 +33,10 @@ o2_add_library(FT0Calibration
         PUBLIC_LINK_LIBRARIES
         O2::FT0Calibration
         )
+      o2_add_executable(ft0-events-per-bc-processor
+        COMPONENT_NAME calibration
+        SOURCES workflow/FT0EventsPerBcProcessor-Workflow.cxx
+        PUBLIC_LINK_LIBRARIES
+        O2::FT0Calibration
+      )
+      

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

@@ -0,0 +1,56 @@
+#ifndef O2_FT0TVXPERBCID
+#define O2_FT0TVXPERBCID
+
+#include <bitset>
+#include <array>
+
+#include "CommonDataFormat/FlatHisto2D.h"
+#include "CommonConstants/LHCConstants.h"
+#include "DataFormatsFT0/SpectraInfoObject.h"
+#include "DetectorsCalibration/TimeSlotCalibration.h"
+#include "DetectorsCalibration/TimeSlot.h"
+#include "DataFormatsFT0/BcEvents.h"
+
+namespace o2::ft0
+{
+    struct EventsPerBc
+    {
+        EventsPerBc() = default;
+        
+        size_t getEntries() const { return entries; }
+        void print() const;
+        void fill(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};
+    };
+
+    class EventsPerBcCalibrator final : public o2::calibration::TimeSlotCalibration<o2::ft0::EventsPerBc>
+    {
+        using Slot = o2::calibration::TimeSlot<o2::ft0::EventsPerBc>;
+        using TFType = o2::calibration::TFType;
+
+        public:
+        EventsPerBcCalibrator()
+        {
+            setUpdateAtTheEndOfRunOnly();
+        }
+        
+        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(); }
+
+        private:
+        std::unique_ptr<TH1F> mTvxPerBc;
+        std::unique_ptr<CcdbObjectInfo> mTvxPerBcInfo;
+    };
+}
+
+#endif

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

@@ -0,0 +1,53 @@
+#include "FT0Calibration/EventsPerBcCalibrator.h"
+
+namespace o2::ft0
+{
+    void EventsPerBc::print() const
+    {
+
+    }
+
+    void EventsPerBc::fill(const gsl::span<const o2::ft0::Digit> data)
+    {
+        for(const auto& digit: digits) {
+            double isVertex = digit.mTriggers.isVertex();
+            mTvx[digits.mIntRecord.bc] += isVertex;
+            entries += isVertex;
+        }
+    }
+
+    void EventsPerBc::merge(const EventsPerBc* prev)
+    {
+       for(int bc = 0; bc < o2::constants::lhc::LHCMaxBunches; bc++){
+            mTvx[bc] += prev->mTvx[bc];    
+       }
+       entries += prev->mEntries;
+    }
+
+    void EventsPerBcCalibrator::initOutput() final
+    {
+        mTvxPerBc.reset();
+        mTvxPerBcInfo.reset();
+    }
+
+    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);
+        for(int bin = 0; bin < o2::constants::lhc::LHCMaxBunches; bin++) {
+            tvxsHist->fill(bin, data->mTvx[bin]);
+        }
+        auto clName = o2::utils::MemFileHelper::getClassName(*tvxsHist);
+        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());
+    }
+
+    EventsPerBcCalibrator::Slot& EventsPerBcCalibrator::emplaceNewSlot(bool front, TFType tstart, TFType tend) final
+    {
+        auto& cont = getSlots();
+        auto& slot = front ? cont.emplace_front(tstart, tend) : cont.emplace_back(tstart, tend);
+        slot.setContainer(std::make_unique<EventsPerBc>());
+        return slot;
+    }
+}

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

@@ -0,0 +1,68 @@
+#include "Framework/runDataProcessing.h"
+#include "CommonUtils/ConfigurableParam.h"
+#include "Framework/ConfigParamSpec.h"
+#include <Framework/ConfigContext.h>
+#include "Framework/DeviceSpec.h"
+#include "Framework/WorkflowSpec.h"
+#include "Framework/Task.h"
+
+#include "DataFormatsFT0/Digit.h"
+#include "DataFormatsFT0/BcEvents.h"
+#include "FT0Calibration/EventsPerBcCalibrator.h"
+
+namespace o2::ft0
+{
+    class FT0EventsPerBcProcessor final : public o2::framework::Task
+    {
+        void init(o2::framework::InitContext& ic) final
+        {
+            mCalibrator = std::make_unique<EventsPerBcCalibrator>();
+        }
+
+        void run(o2::framework::ProcessContext& pc) final
+        {
+            auto digits = pc.inputs().get<gsl::span<o2::ft0::Digit>>("digits");
+            mCalibrator->process(digits);
+        }
+
+        void endOfStream(o2::framework::EndOfStreamContext& ec) final 
+        {
+            mCalibrator->chekSlotToFinalize();
+            sendOutput(ec.outputs());
+            mCalibrator->initOutput();    
+        }
+
+        void sendOutput(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);
+        }
+
+        private:
+        std::unique_ptr<EventsPerBcCalibrator> mCalibrator;
+    };
+}
+
+WorkflowSpec defineDataProcessing(ConfigContext& const & cfgc)
+{
+    using namespace o2::framework;
+    std::vector<InputSpec> inputs;
+    inputs.emplace_back("digits", "FT0", "DIGITSBC");
+    std::vector<OutputSpec> outputs;
+    outputs.emplace_back("eventsPerBcInfo", "FT0", "EVENTS_PER_BC_INFO")
+    DataProcessorSpec dataProcessorSpec{
+        "FT0EventsPerBcProcessor",
+        inputs,
+        outputs,
+        AlgorithmSpec(adaptFromTask<o2::ft0::FT0EventsPerBcProcessor>()),
+        Options{}
+    };
+
+    WorkflowSpec workflow;
+    workflow.emplace_back(dataProcessorSpec);
+    return workflow;
+}