add R3BIOConnector and apply tapt

neuland/calibration/calLevel/R3BNeulandCalData2.h

@@ -24,6 +24,7 @@ namespace R3B::Neuland
     {
         ValueError<double> leading_time;        // ns
         ValueError<double> time_over_threshold; // ns
+        ValueError<double> trigger_time;   // ns
         ClassDefNV(CalDataSignal, 1)
     };
 
@@ -38,8 +39,6 @@ namespace R3B::Neuland
         unsigned int moduleID = 0; // 1 based bar ID
         std::vector<CalDataSignal> left;
         std::vector<CalDataSignal> right;
-        ValueError<double> left_trigger_time;  // ns
-        ValueError<double> right_trigger_time; // ns
         ClassDefNV(BarCalData, 1)
     };
 } // namespace R3B::Neuland

neuland/calibration/calLevel/R3BNeulandMapped2Cal2.cxx

@@ -75,6 +75,10 @@ namespace R3B::Neuland
     {
         SetPMTNum();
         SetCTFreq();
+        calData_.init();
+        // // Register output arrays in tree
+        // auto* rootMan = FairRootManager::Instance();
+        // rootMan->RegisterAny(calDataName_.c_str(), calDataPtr_, true);
     }
 
     void Mapped2Cal::SetPMTNum()
@@ -87,7 +91,7 @@ namespace R3B::Neuland
         else
         {
             total_pmt_nums_ = 2 * plane_num_ * BarsPerPlane;
-            R3BLOG(debug, fmt::format("total number of PMTs set to be {}", total_pmt_nums_).c_str());
+            R3BLOG(info, fmt::format("total number of PMTs set to be {}", total_pmt_nums_).c_str());
         }
     }
 
@@ -102,7 +106,7 @@ namespace R3B::Neuland
         else
         {
             coarse_time_frequency_ = ct_freq;
-            R3BLOG(debug, fmt::format("Coarse time frequency set to be {}", ct_freq).c_str());
+            R3BLOG(info, fmt::format("Coarse time frequency set to be {} MHz", ct_freq).c_str());
         }
     }
 
@@ -146,22 +150,30 @@ namespace R3B::Neuland
     {
         auto* calibrationPar = GetCalibrationPar();
         auto* calibrationTrigPar = GetCalibrationTrigPar();
-        const auto* trigMappedData = GetTrigMappedData();
+        const auto& trigMappedData = GetTrigMappedData();
 
         const auto& triggerMap = calibrationPar->GetTrigIDMap();
         auto triggerIDPair = triggerMap.find(moduleID);
         if (triggerIDPair == triggerMap.end())
         {
-            R3BLOG(error, fmt::format("Can't find the trigger ID for the module ID {}", moduleID));
+            const auto eventNum = GetEventHeader()->GetEventno();
+            R3BLOG(error,
+                   fmt::format("Can't find the trigger ID for the module ID {} in the event {}", moduleID, eventNum));
             return { -1., 0 };
         }
         const auto triggerID = (side == Side::left) ? triggerIDPair->second.first : triggerIDPair->second.second;
-        const auto trigData = std::find_if(trigMappedData->begin(),
-                                           trigMappedData->end(),
+        const auto trigData = std::find_if(trigMappedData.begin(),
+                                           trigMappedData.end(),
                                            [&triggerID](const auto& ele) { return ele.first == triggerID; });
-        if (trigData == trigMappedData->end())
+        if (trigData == trigMappedData.end())
         {
-            R3BLOG(error, fmt::format("No such trigger ID {} in mappedTrigData!", triggerID));
+            const auto eventNum = GetEventHeader()->GetEventno();
+            R3BLOG(error,
+                   fmt::format("No such trigger ID {} in mappedTrigData for moduleID {} in the event {}!",
+                               triggerID,
+                               moduleID,
+                               eventNum));
+            R3BLOG(error, fmt::format("Available trigIDs: {}", fmt::join(trigMappedData | ranges::views::keys, ", ")));
             return { -1., 0 };
         }
         return ConvertToRealTime(calibrationTrigPar, trigData->second.signal, FTType::trigger, trigData->first);
@@ -192,7 +204,13 @@ namespace R3B::Neuland
             (is_walk_enabled_) ? GetWalkCorrection(calDataSignal.time_over_threshold.value) : 0.;
         calDataSignal.leading_time =
             ConvertToRealTime(calibrationPar, dESignal.leading, ftType, moduleID) + walk_correction;
-        return CalDataSignal{};
+        calDataSignal.trigger_time = GetTriggerTime(moduleID, side);
+        R3BLOG(debug2,
+               fmt::format("Create a cal signal with tot: {}, lt: {} and trigT: {}",
+                           calDataSignal.time_over_threshold.value,
+                           calDataSignal.leading_time.value,
+                           calDataSignal.trigger_time.value));
+        return calDataSignal;
     }
 
     auto Mapped2Cal::MapBarSignal2CalSignals(const MapBarSignal& barSignal, unsigned int moduleID, R3B::Side side) const
@@ -211,9 +229,6 @@ namespace R3B::Neuland
 
     void Mapped2Cal::FillCalData(BarCalData& cal, const MapBarSignal& signals)
     {
-        cal.left_trigger_time = GetTriggerTime(cal.moduleID, Side::left);
-        cal.right_trigger_time = GetTriggerTime(cal.moduleID, Side::right);
-
         cal.left = MapBarSignal2CalSignals(signals, cal.moduleID, Side::left);
         cal.right = MapBarSignal2CalSignals(signals, cal.moduleID, Side::right);
 
@@ -223,15 +238,15 @@ namespace R3B::Neuland
 
     void Mapped2Cal::Calibration()
     {
-        const auto* mappedData = GetMappedData();
-        R3BLOG(debug2, fmt::format("mapped Data size: {}", mappedData->size()));
-        for (const auto& planeSignals : *mappedData)
+        const auto& mappedData = GetMappedData();
+        R3BLOG(debug2, fmt::format("mapped Data size: {}", mappedData.size()));
+        for (const auto& planeSignals : mappedData)
         {
             const auto planeNum = planeSignals.planeID;
             for (const auto& [barNum, barSignals] : planeSignals.bars)
             {
                 const auto moduleID = Neuland_PlaneBar2ModuleID(planeNum, barNum);
-                auto& cal = calData_.emplace_back(moduleID);
+                auto& cal = calData_.get().emplace_back(moduleID);
                 FillCalData(cal, barSignals);
             }
         }
@@ -241,13 +256,13 @@ namespace R3B::Neuland
     {
         auto& histograms = GetHistMonitor();
         const auto moduleID = cal.moduleID;
-        const auto triggerTime = (side == Side::left) ? cal.left_trigger_time.value : cal.right_trigger_time.value;
         const auto& calSignals = (side == Side::left) ? cal.left : cal.right;
 
         for (const auto& signal : calSignals)
         {
             const auto lTime = signal.leading_time.value;
             const auto time_over_thres = signal.time_over_threshold.value;
+            const auto triggerTime = signal.trigger_time.value;
             histograms.get("ToT")->Fill(time_over_thres);
             histograms.get("LeadingTime")->Fill(lTime);
             histograms.get("TriggerTime")->Fill(triggerTime);

neuland/calibration/calLevel/R3BNeulandMapped2Cal2.h

@@ -1,6 +1,7 @@
 #pragma once
 #include "R3BNeulandCalData2.h"
 #include "R3BNeulandMappedDataReader.h"
+#include <R3BIOConnector.h>
 #include <R3BNeulandCalData.h>
 #include <R3BNeulandCommon.h>
 
@@ -10,8 +11,6 @@ namespace R3B::Neuland
     class Mapped2Cal : public MappedDataReader
     {
       public:
-        using OutputDataType = R3BNeulandCalDataContainer;
-
         Mapped2Cal();
         Mapped2Cal(std::string_view name, int iVerbose);
         void SetPulserMode(bool pulser_mode = true) { is_pulse_mode_ = pulser_mode; }
@@ -28,7 +27,7 @@ namespace R3B::Neuland
         unsigned int plane_num_ = 0;
 
         // outputdata
-        OutputDataType calData_;
+        OutputVectorConnector<BarCalData> calData_{ "NeulandCalData" };
 
         void ExtraInit(FairRootManager* rootMan) override;
         void HistogramInit(HistMonitor& histograms) override;

neuland/calibration/calLevel/R3BNeulandMapped2CalPar2.cxx

@@ -82,24 +82,16 @@ namespace R3B::Neuland
 
     void Mapped2CalPar::RecordTrigMappingID()
     {
-        const auto* mappedData = GetMappedData();
-        const auto* trigMappedData = GetTrigMappedData();
-        if (mappedData == nullptr)
-        {
-            throw R3B::runtime_error("Nullptr: Cannot get valid map data!");
-        }
-        if (trigMappedData == nullptr)
-        {
-            throw R3B::runtime_error("Nullptr: Cannot get valid time trig map data!");
-        }
+        const auto& mappedData = GetMappedData();
+        const auto& trigMappedData = GetTrigMappedData();
 
-        for (const auto& planeSignals : *mappedData)
+        for (const auto& planeSignals : mappedData)
         {
             auto planeNum = planeSignals.planeID;
             for (const auto& [barID, barSignals] : planeSignals.bars)
             {
                 auto moduleID = Neuland_PlaneBar2ModuleID(planeNum, barID);
-                for (const auto& [trigID, trigSignal] : *trigMappedData)
+                for (const auto& [trigID, trigSignal] : trigMappedData)
                 {
                     trigIDMappingFinder_.add_id_pair(
                         std::make_pair(moduleID, trigID), Side::left, barSignals.left.size());
@@ -112,12 +104,8 @@ namespace R3B::Neuland
 
     void Mapped2CalPar::FillMapData()
     {
-        const auto* mappedData = GetMappedData();
-        if (mappedData == nullptr)
-        {
-            throw R3B::runtime_error("Nullptr: Cannot get valid map data!");
-        }
-        for (const auto& planeSignals : *mappedData)
+        const auto& mappedData = GetMappedData();
+        for (const auto& planeSignals : mappedData)
         {
             auto planeID = planeSignals.planeID;
             for (const auto& [barID, barSignals] : planeSignals.bars)
@@ -141,12 +129,8 @@ namespace R3B::Neuland
 
     void Mapped2CalPar::FillTrigMapData()
     {
-        const auto* trigMappedData = GetTrigMappedData();
-        if (trigMappedData == nullptr)
-        {
-            throw R3B::runtime_error("Nullptr: Cannot get valid time trig map data!");
-        }
-        for (const auto& [moduleID, moduleSignals] : *trigMappedData)
+        const auto& trigMappedData = GetTrigMappedData();
+        for (const auto& [moduleID, moduleSignals] : trigMappedData)
         {
             FillEngine(trigMapCalEngine_, FTType::trigger, moduleSignals.signal.fine, moduleID);
         }

neuland/calibration/calLevel/R3BNeulandMappedDataReader.cxx

@@ -1,4 +1,5 @@
 #include "R3BNeulandMappedDataReader.h"
+#include "R3BNeulandTriggerTypes.h"
 #include <FairRootManager.h>
 #include <FairRuntimeDb.h>
 #include <R3BEventHeader.h>
@@ -20,9 +21,8 @@ namespace R3B::Neuland
     {
         if (auto* rootMan = FairRootManager::Instance(); rootMan != nullptr)
         {
-            mappedData_ = rootMan->InitObjectAs<InputDataType*>(mappedDataName_.c_str());
-
-            trigMappedData_ = rootMan->InitObjectAs<InputTrigDataType*>(trigMappedDataName_.c_str());
+            mappedData_.init();
+            trigMappedData_.init();
 
             if (eventHeader_ = dynamic_cast<R3BEventHeader*>(rootMan->GetObject("EventHeader."));
                 eventHeader_ == nullptr)
@@ -39,9 +39,10 @@ namespace R3B::Neuland
             }
 
             ExtraInit(rootMan);
-            constexpr auto trigIDSize = 10;
-            histograms_.add<TH1I>("trigID", "trigger ID of each event", trigIDSize, -3.5, -3.5 + trigIDSize);
+            histograms_.add<TH1I>("trig_check", "check the triggered or passed events", 0, 0., 0.);
+            histograms_.add<TH1I>("condition_check", "check the condition", 0, 0., 0.);
             HistogramInit(histograms_);
+            R3BLOG(info, fmt::format("Neuland events trigger type is: {}", CalTrigger2Str(trig_type_)));
             return kSUCCESS;
         }
 
@@ -74,19 +75,25 @@ namespace R3B::Neuland
         {
             return true;
         }
-        const auto triggerID = eventHeader_->GetTrigger();
-        const auto trig_type = Int2CalTrigger(triggerID);
-        auto is_pass = trig_type != CalTrigger::unrecognised && trig_type == trig_type_;
-        return is_pass;
+        const auto tpatID = std::bitset<TPAT_BITSIZE>(eventHeader_->GetTpat());
+        auto is_trigged = (tpatID & CalTrigger2Tpat(trig_type_)).any();
+        return is_trigged;
     }
 
     void MappedDataReader::Exec(Option_t* /*option*/)
     {
-        if (!CheckTrigger() or !CheckConditions(mappedData_, trigMappedData_))
+        if (!CheckTrigger())
+        {
+            histograms_.get("trig_check")->Fill(fmt::format("{:016b}", eventHeader_->GetTpat()).c_str(), 1);
+            return;
+        }
+        histograms_.get("trig_check")->Fill("triggered", 1);
+        if (!CheckConditions(&mappedData_.get(), &trigMappedData_.get()))
         {
+            histograms_.get("condition_check")->Fill("failure", 1);
             return;
         }
-        histograms_.get("trigID")->Fill(eventHeader_->GetTrigger());
+        histograms_.get("condition_check")->Fill("success", 1);
         TriggeredExec();
     }
 

neuland/calibration/calLevel/R3BNeulandMappedDataReader.h

@@ -3,6 +3,7 @@
 #include "R3BTCalPar2.h"
 #include <FairTask.h>
 #include <R3BHistMonitor.h>
+#include <R3BIOConnector.h>
 #include <R3BPaddleTamexMappedData2.h>
 #include <map>
 #include <vector>
@@ -20,8 +21,9 @@ namespace R3B::Neuland
         MappedDataReader(std::string_view name, int iVerbose);
 
         // Getters:
-        [[nodiscard]] auto GetMappedData() const -> auto* { return mappedData_; }
-        [[nodiscard]] auto GetTrigMappedData() const -> auto* { return trigMappedData_; }
+        [[nodiscard]] auto GetEventHeader() const -> auto* { return eventHeader_; }
+        [[nodiscard]] auto GetMappedData() const -> const auto& { return mappedData_; }
+        [[nodiscard]] auto GetTrigMappedData() const -> const auto& { return trigMappedData_; }
         [[nodiscard]] auto GetCalibrationPar() const -> auto* { return calibrationPar_; }
         [[nodiscard]] auto GetCalibrationTrigPar() const -> auto* { return calibrationTrigPar_; }
         [[nodiscard]] auto GetHistMonitor() -> HistMonitor& { return histograms_; }
@@ -40,9 +42,8 @@ namespace R3B::Neuland
         std::string calibrationParName_ = "LandTCalPar";
         std::string calibrationTrigParName_ = "LandTrigTCalPar";
 
-        // input data is owned by FairRootManager
-        InputDataType* mappedData_ = nullptr;
-        InputTrigDataType* trigMappedData_ = nullptr;
+        InputConnector<InputDataType> mappedData_{ mappedDataName_ };
+        InputConnector<InputTrigDataType> trigMappedData_{ trigMappedDataName_ };
         R3BEventHeader* eventHeader_ = nullptr;
 
         // input parameters are owned by FairRuntimeDb

neuland/calibration/calLevel/R3BNeulandTriggerTypes.h

@@ -1,5 +1,10 @@
 #pragma once
 
+#include <R3BNeulandCommon.h>
+#include <bitset>
+
+constexpr auto TPAT_BITSIZE = 16;
+
 namespace R3B::Neuland
 {
     enum class CalTrigger
@@ -25,4 +30,33 @@ namespace R3B::Neuland
         }
     }
 
+    inline constexpr auto CalTrigger2Tpat(CalTrigger cal_trigger) -> std::bitset<TPAT_BITSIZE>
+    {
+        switch (cal_trigger)
+        {
+            case CalTrigger::onspill:
+                return std::bitset<TPAT_BITSIZE>{}.set(0);
+            case CalTrigger::offspill:
+                return std::bitset<TPAT_BITSIZE>{}.set(NeulandOffSpillTpatPos);
+            case CalTrigger::all:
+                return std::bitset<TPAT_BITSIZE>{}.set();
+            default:
+                return std::bitset<TPAT_BITSIZE>{};
+        }
+    }
+
+    inline auto CalTrigger2Str(CalTrigger cal_trigger) -> std::string
+    {
+        switch (cal_trigger)
+        {
+            case CalTrigger::onspill:
+                return std::string{ "onspill" };
+            case CalTrigger::offspill:
+                return std::string{ "offspill" };
+            case CalTrigger::all:
+                return std::string{ "all" };
+            default:
+                return std::string{ "error" };
+        }
+    }
 } // namespace R3B::Neuland

neuland/calibration/calLevel/R3BTrigIDMappingFinder.h

@@ -10,7 +10,7 @@ namespace R3B ::Neuland
 
     struct TrigIDMappingRecorder
     {
-        using Record = std::map<unsigned int, unsigned int>;
+        using Record = std::map<unsigned int, uint64_t>;
         Record left;
         Record right;
         void add(unsigned int trigID, R3B::Side side, unsigned int counts = 1);