add new calData type

neuland/calibration/calLevel/NeulandCalLevelLinkDef.h

@@ -22,11 +22,14 @@
 #pragma link off all classes;
 #pragma link off all functions;
 
-#pragma link C++ class R3B::ValueError<double>+;
 #pragma link C++ class R3B::FTChannel2TimeRelation+;
 #pragma link C++ class R3B::TCalModuleInfo+;
 #pragma link C++ class R3B::Neuland::Mapped2CalPar+;
 #pragma link C++ class R3B::TCalPar+;
 #pragma link C++ class R3B::TCalVFTXModulePar+;
 #pragma link C++ class unordered_map<unsigned int, R3B::TCalVFTXModulePar>+;
+#pragma link C++ class R3B::Neuland::CalDataSignal+;
+#pragma link C++ class vector<R3B::Neuland::CalDataSignal>+;
+#pragma link C++ class R3B::Neuland::BarCalData+;
+#pragma link C++ class vector<R3B::Neuland::BarCalData>+;
 #endif

neuland/calibration/calLevel/R3BFTCalEngine.cxx

@@ -50,7 +50,7 @@ namespace R3B::Neuland::calibration
     {
         using ValueErrors = FTCalStrategy::ValueErrors;
         constexpr unsigned int uniform_err_divider = 12;
-        const auto uniform_err_divider_sqrt = std::sqrt(12);
+        constexpr auto uniform_err_divider_sqrt = SQRT_12;
         const auto sqrt_3 = std::sqrt(3);
 
         struct InputInfo

neuland/calibration/calLevel/R3BNeulandCalData2.h

@@ -0,0 +1,47 @@
+#pragma once
+
+/******************************************************************************
+ *   Copyright (C) 2019 GSI Helmholtzzentrum für Schwerionenforschung GmbH    *
+ *   Copyright (C) 2019-2023 Members of R3B Collaboration                     *
+ *                                                                            *
+ *             This software is distributed under the terms of the            *
+ *                 GNU General Public Licence (GPL) version 3,                *
+ *                    copied verbatim in the file "LICENSE".                  *
+ *                                                                            *
+ * In applying this license GSI does not waive the privileges and immunities  *
+ * granted to it by virtue of its status as an Intergovernmental Organization *
+ * or submit itself to any jurisdiction.                                      *
+ ******************************************************************************/
+
+#include <R3BShared.h>
+#include <TObject.h>
+#include <vector>
+
+namespace R3B::Neuland
+{
+
+    struct CalDataSignal
+    {
+        ValueError<double> leading_time;        // ns
+        ValueError<double> time_over_threshold; // ns
+        ClassDefNV(CalDataSignal, 1)
+    };
+
+    struct BarCalData
+    {
+      public:
+        BarCalData() = default;
+        explicit BarCalData(unsigned int mID)
+            : moduleID{ mID }
+        {
+        }
+        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
+  //
+using R3BNeulandCalDataContainer = std::vector<R3B::Neuland::BarCalData>;

neuland/calibration/calLevel/R3BNeulandMapped2Cal2.cxx

@@ -180,30 +180,45 @@ namespace R3B::Neuland
                                            : time_over_thres + 1000. * coarse_time_max_num_ / coarse_time_frequency_;
     }
 
-    void Mapped2Cal::FillCalData(const BarSignal& signals, unsigned int moduleID, Side side)
+    auto Mapped2Cal::DoubleEdgeSignal2CalSignal(const DoubleEdgeSignal& dESignal,
+                                                R3B::Side side,
+                                                unsigned int moduleID) const -> CalDataSignal
     {
         auto* calibrationPar = GetCalibrationPar();
-        for (const auto& dESignals : signals.get(side))
-        {
-            const auto ftType = (side == R3B::Side::left) ? FTType::leftleading : FTType::lefttrailing;
-            const auto triggerTime = GetTriggerTime(moduleID, side);
-            const auto time_over_thres = GetToT(dESignals, moduleID, side);
-            const auto walk_correction = (is_walk_enabled_) ? GetWalkCorrection(time_over_thres.value) : 0.;
-            const auto ltime = ConvertToRealTime(calibrationPar, dESignals.leading, ftType, moduleID);
-
-            R3BLOG(
-                debug2,
-                fmt::format(
-                    "Create a calLevel data with moduleID: {}, side: {}, leading time: {}, trigger time: {}, tot: {}",
-                    moduleID,
-                    toIndex(side),
-                    ltime.value,
-                    triggerTime.value,
-                    time_over_thres.value));
-            const auto& cal =
-                calData_.emplace_back(moduleID, toIndex(side), ltime.value + walk_correction, triggerTime.value, time_over_thres.value);
-            HistogramMonitor(cal);
-        }
+        auto calDataSignal = CalDataSignal{};
+        const auto ftType = (side == R3B::Side::left) ? FTType::leftleading : FTType::rightleading;
+        calDataSignal.time_over_threshold = GetToT(dESignal, moduleID, side);
+        const auto walk_correction =
+            (is_walk_enabled_) ? GetWalkCorrection(calDataSignal.time_over_threshold.value) : 0.;
+        calDataSignal.leading_time =
+            ConvertToRealTime(calibrationPar, dESignal.leading, ftType, moduleID) + walk_correction;
+        return CalDataSignal{};
+    }
+
+    auto Mapped2Cal::MapBarSignal2CalSignals(const MapBarSignal& barSignal, unsigned int moduleID, R3B::Side side) const
+        -> std::vector<CalDataSignal>
+    {
+        const auto& signals = (side == Side::left) ? barSignal.left : barSignal.right;
+        auto calSignals = std::vector<CalDataSignal>{};
+        calSignals.reserve(signals.size());
+        std::transform(signals.begin(),
+                       signals.end(),
+                       std::back_inserter(calSignals),
+                       [moduleID, side, this](const auto& dESignal)
+                       { return DoubleEdgeSignal2CalSignal(dESignal, side, moduleID); });
+        return calSignals;
+    }
+
+    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);
+
+        HistogramMonitor(cal, Side::left);
+        HistogramMonitor(cal, Side::right);
     }
 
     void Mapped2Cal::Calibration()
@@ -216,37 +231,39 @@ namespace R3B::Neuland
             for (const auto& [barNum, barSignals] : planeSignals.bars)
             {
                 const auto moduleID = Neuland_PlaneBar2ModuleID(planeNum, barNum);
-                FillCalData(barSignals, moduleID, Side::left);
-                FillCalData(barSignals, moduleID, Side::right);
+                auto& cal = calData_.emplace_back(moduleID);
+                FillCalData(cal, barSignals);
             }
         }
     }
 
-    void Mapped2Cal::HistogramMonitor(const R3BNeulandCalData& cal)
+    void Mapped2Cal::HistogramMonitor(const BarCalData& cal, Side side)
     {
         auto& histograms = GetHistMonitor();
-        auto moduleID = cal.GetBarId();
-        auto side = IndexToSide(cal.GetSide());
-        auto lTime = cal.GetTime();
-        auto triggerTime = cal.GetTriggerTime();
-        auto time_over_thres = cal.GetQdc();
-
-        histograms.get("ToT")->Fill(time_over_thres);
-        histograms.get("LeadingTime")->Fill(lTime);
-        histograms.get("TriggerTime")->Fill(triggerTime);
-        histograms.get("Leading_minus_trigger")->Fill(lTime - triggerTime);
-
-        if (side == Side::left)
-        {
-            histograms.get("TimeLVsBar")->Fill(moduleID, lTime - triggerTime);
-            histograms.get("ToTLVsBar")->Fill(moduleID, time_over_thres);
-            histograms.get("Bar_hitNum_l")->Fill(moduleID);
-        }
-        else
+        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)
         {
-            histograms.get("TimeRVsBar")->Fill(moduleID, lTime - triggerTime);
-            histograms.get("ToTRVsBar")->Fill(moduleID, time_over_thres);
-            histograms.get("Bar_hitNum_r")->Fill(moduleID);
+            const auto lTime = signal.leading_time.value;
+            const auto time_over_thres = signal.time_over_threshold.value;
+            histograms.get("ToT")->Fill(time_over_thres);
+            histograms.get("LeadingTime")->Fill(lTime);
+            histograms.get("TriggerTime")->Fill(triggerTime);
+            histograms.get("Leading_minus_trigger")->Fill(lTime - triggerTime);
+            if (side == Side::left)
+            {
+                histograms.get("TimeLVsBar")->Fill(moduleID, lTime - triggerTime);
+                histograms.get("ToTLVsBar")->Fill(moduleID, time_over_thres);
+                histograms.get("Bar_hitNum_l")->Fill(moduleID);
+            }
+            else
+            {
+                histograms.get("TimeRVsBar")->Fill(moduleID, lTime - triggerTime);
+                histograms.get("ToTRVsBar")->Fill(moduleID, time_over_thres);
+                histograms.get("Bar_hitNum_r")->Fill(moduleID);
+            }
         }
     }
 

neuland/calibration/calLevel/R3BNeulandMapped2Cal2.h

@@ -1,4 +1,5 @@
 #pragma once
+#include "R3BNeulandCalData2.h"
 #include "R3BNeulandMappedDataReader.h"
 #include <R3BNeulandCalData.h>
 #include <R3BNeulandCommon.h>
@@ -38,8 +39,14 @@ namespace R3B::Neuland
         void SetCTFreq();
         void SampleParameters();
         void Calibration();
-        void HistogramMonitor(const R3BNeulandCalData& cal);
-        void FillCalData(const BarSignal& signals, unsigned int moduleID, R3B::Side side);
+        void HistogramMonitor(const BarCalData& cal, Side side);
+        void FillCalData(BarCalData& cal, const MapBarSignal& signals);
+        [[nodiscard]] auto DoubleEdgeSignal2CalSignal(const DoubleEdgeSignal& dESignal,
+                                                      R3B::Side side,
+                                                      unsigned int moduleID) const -> CalDataSignal;
+        [[nodiscard]] auto MapBarSignal2CalSignals(const MapBarSignal& barSignal,
+                                                   unsigned int moduleID,
+                                                   R3B::Side side) const -> std::vector<CalDataSignal>;
         [[nodiscard]] auto ConvertToRealTime(R3BTCalPar2* calPar,
                                              SingleEdgeSignal signal,
                                              FTType ftType,

neuland/calibration/calLevel/R3BTCalPar2.h

@@ -8,40 +8,6 @@
 
 namespace R3B
 {
-    template <typename DataType>
-    struct ValueError
-    {
-        DataType value{};
-        DataType error{};
-
-        template <typename OtherType>
-        auto operator+(OtherType val) const -> ValueError<DataType>
-        {
-            auto new_value = value + val;
-            return { new_value, error };
-        }
-
-        ClassDefNV(ValueError, 1);
-    };
-
-    template <typename DataType>
-    auto operator+(ValueError<DataType> left, ValueError<DataType> right) -> ValueError<DataType>
-    {
-        auto new_value = left.value + right.value;
-        // TODO: not the fastest way
-        auto new_err = std::sqrt(left.error * left.error + right.error * right.error);
-        return { new_value, new_err };
-    }
-
-    template <typename DataType>
-    auto operator-(ValueError<DataType> left, ValueError<DataType> right) -> ValueError<DataType>
-    {
-        auto new_value = left.value - right.value;
-        // TODO: not the fastest way
-        auto new_err = std::sqrt(left.error * left.error + right.error * right.error);
-        return { new_value, new_err };
-    }
-
     struct FTChannel2TimeRelation
     {
         double hist_overflow{};

neuland/shared/R3BNeulandCommon.h

@@ -12,6 +12,7 @@
  ******************************************************************************/
 
 #pragma once
+#include <TObject.h>
 #include <cassert>
 #include <cmath>
 #include <cstdint>
@@ -22,7 +23,7 @@ namespace R3B::Neuland
 {
     // Constants
 
-    constexpr auto __sqrt12 = 3.464101615;
+    constexpr auto SQRT_12 = 3.464101615;
     constexpr auto NaN = std::numeric_limits<double>::quiet_NaN();
     constexpr auto Inf = std::numeric_limits<double>::infinity();
 
@@ -62,9 +63,9 @@ namespace R3B::Neuland
     // Geometry & Material Constants
 
     constexpr auto BarSize_XY = 5.0;                                  // cm NeuLAND parameter
-    constexpr auto BarUncertainty_XY = BarSize_XY / __sqrt12;         // cm NeuLAND parameter
+    constexpr auto BarUncertainty_XY = BarSize_XY / SQRT_12;          // cm NeuLAND parameter
     constexpr auto BarSize_Z = 5.0;                                   // cm NeuLAND parameter
-    constexpr auto BarUncertainty_Z = BarSize_Z / __sqrt12;           // cm NeuLAND parameter
+    constexpr auto BarUncertainty_Z = BarSize_Z / SQRT_12;            // cm NeuLAND parameter
     constexpr auto BarLength = 250.0;                                 // cm NeuLAND parameter
     constexpr auto LightGuideLength = 10.0;                           // cm NeuLAND parameter
     constexpr auto TotalBarLength = BarLength + 2 * LightGuideLength; // cm NeuLAND parameter, Bar including Light Guide

r3bbase/BaseLinkDef.h

@@ -34,4 +34,5 @@
 #pragma link C++ class R3BMSOffsetContFact+;
 #pragma link C++ class R3BMSOffsetPar+;
 #pragma link C++ class R3BMSOffsetFinder+;
+#pragma link C++ class R3B::ValueError<double>+;
 #endif

r3bbase/R3BShared.h

@@ -119,5 +119,40 @@ namespace R3B
         return Side::right;
     }
     // -------------------------------------------------------------------------
+    // value error pair
 
+    template <typename DataType>
+    struct ValueError
+    {
+        DataType value{};
+        DataType error{};
+
+        template <typename OtherType>
+        auto operator+(OtherType val) const -> ValueError<DataType>
+        {
+            auto new_value = value + val;
+            return { new_value, error };
+        }
+
+        ClassDefNV(ValueError, 1);
+    };
+
+    template <typename DataType>
+    auto operator+(ValueError<DataType> left, ValueError<DataType> right) -> ValueError<DataType>
+    {
+        auto new_value = left.value + right.value;
+        // TODO: not the fastest way
+        auto new_err = std::sqrt(left.error * left.error + right.error * right.error);
+        return { new_value, new_err };
+    }
+
+    template <typename DataType>
+    auto operator-(ValueError<DataType> left, ValueError<DataType> right) -> ValueError<DataType>
+    {
+        auto new_value = left.value - right.value;
+        // TODO: not the fastest way
+        auto new_err = std::sqrt(left.error * left.error + right.error * right.error);
+        return { new_value, new_err };
+    }
+    // -------------------------------------------------------------------------
 } // namespace R3B

r3bdata/DataLinkDef.h

@@ -138,7 +138,7 @@
 #pragma link C++ class R3BPaddleTamexMappedData+;
 #pragma link C++ class R3B::SingleEdgeSignal+;
 #pragma link C++ class R3B::DoubleEdgeSignal+;
-#pragma link C++ class R3B::BarSignal+;
+#pragma link C++ class R3B::MapBarSignal+;
 #pragma link C++ class R3BPaddleTamexTrigMappedData+;
 #pragma link C++ class R3BPaddleTamexMappedData2+;
 #pragma link C++ class map<unsigned int, R3BPaddleTamexTrigMappedData>+;

r3bdata/neulandData/R3BNeulandCalData.h

@@ -43,6 +43,4 @@ class R3BNeulandCalData : public TObject
 
 std::ostream& operator<<(std::ostream&, const R3BNeulandCalData&); // Support easy printing
 
-using R3BNeulandCalDataContainer = std::vector<R3BNeulandCalData>;
-
 #endif // R3BNEULANDCALDATA_H

r3bdata/neulandData/R3BPaddleTamexMappedData2.cxx

@@ -15,8 +15,8 @@
 
 namespace R3B
 {
-    BarSignal::BarSignal(R3B::Side side, const DoubleEdgeSignal& signal)
-        : BarSignal{}
+    MapBarSignal::MapBarSignal(R3B::Side side, const DoubleEdgeSignal& signal)
+        : MapBarSignal{}
     {
         push_back(side, signal);
     }
@@ -35,10 +35,10 @@ namespace R3B
         }
         else
         {
-            bars.insert(std::make_pair(barID, R3B::BarSignal{ side, signal }));
+            bars.insert(std::make_pair(barID, R3B::MapBarSignal{ side, signal }));
         }
     }
 } // namespace R3B
 
-ClassImp(R3B::BarSignal);
+ClassImp(R3B::MapBarSignal);
 ClassImp(R3B::PaddleTamexMappedData)