R3BDigitizingChannel.h

Go to the documentation of this file.

/******************************************************************************
 *   Copyright (C) 2019 GSI Helmholtzzentrum für Schwerionenforschung GmbH    *
 *   Copyright (C) 2019 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.                                      *
 ******************************************************************************/
 
#pragma once
#include "R3BShared.h"
#include <TRandom3.h>
#include <fmt/core.h>
#include <vector>
 
namespace R3B::Digitizing
{
    class AbstractPaddle;
    const double MAXTIME = 1e100;
 
    // output data structure of channel
    struct ChannelHit
    {
        double qdc{};
        double tdc{ MAXTIME };
        double qdcUnSat{};
        R3B::Side side{};
        ChannelHit() = default;
    };
 
    // output data structure for Cal Data
    struct ChannelCalSignal
    {
        double tot{};
        double tle{};
        R3B::Side side{};
        ChannelCalSignal() = default;
    };
 
    // input data structure of channel
    struct ChannelSignal
    {
        double time{};      
        double intensity{}; 

        ChannelSignal() = default;

        ChannelSignal(double time_val, double intensity_val)
            : time{ time_val }
            , intensity{ intensity_val }
        {
        }

        auto operator<(const ChannelSignal& rhs) const -> bool { return (time < rhs.time); }
    };
 
    class AbstractChannel
    {
      public:
        using Hit = ChannelHit;
        using CalSignal = ChannelCalSignal;
        using Signal = ChannelSignal;
        using Hits = std::vector<Hit>;
        using CalSignals = std::vector<CalSignal>;
 
        explicit AbstractChannel(R3B::Side side, bool has_cal_output = false);
 
        // rule of 5
        virtual ~AbstractChannel() = default;
        AbstractChannel(const AbstractChannel& other) = delete;
        auto operator=(const AbstractChannel& other) -> AbstractChannel& = delete;
        AbstractChannel(AbstractChannel&& other) = default;
        auto operator=(AbstractChannel&& other) -> AbstractChannel& = delete;
 
        void Construct();

        void Reset();
 
        void AddSignal(const Signal& signal)
        {
            ++signal_size_;
            add_signal(signal);
        }
        virtual auto HasFired() -> bool { return not hits_.empty(); }
 
        void EnableCal(bool is_enabled = true) { has_cal_output_ = is_enabled; }
 
        // Getters:
        [[nodiscard]] auto GetSide() const -> R3B::Side { return side_; }
        [[nodiscard]] auto GetPaddle() const -> AbstractPaddle* { return paddle_; }
        [[nodiscard]] auto GetSignalSize() const -> int { return signal_size_; }
 
        [[nodiscard]] auto GetCalSignals() const -> const CalSignals& { return cal_signals_; }
        [[nodiscard]] auto GetHits() const -> const Hits& { return hits_; }
        [[nodiscard]] auto GetTrigTime() const -> double { return trig_time_; }
 
        void SetPaddle(AbstractPaddle* v_paddle) { paddle_ = v_paddle; }
        void AttachToPaddle(AbstractPaddle* paddle) { paddle_ = paddle; };
        static auto GetDefaultRandomGen() -> TRandom3&;
 
      private:
        bool has_cal_output_ = false;      
        R3B::Side side_;                   
        double trig_time_ = 0.;            
        int signal_size_{};                
        AbstractPaddle* paddle_ = nullptr; 
        Hits hits_;                        
        CalSignals cal_signals_;           
 
        virtual void construct_hits(Hits& signals) = 0;
        virtual void construct_cal_signals(CalSignals& cal_signals) const {};
        virtual void extra_reset() {}
        virtual void pre_construct() {}
        virtual void add_signal(Signal signal) = 0;
 
        void calculate_trig_time();
    };
} // namespace R3B::Digitizing
 
template <>
class fmt::formatter<R3B::Digitizing::ChannelHit>
{
  public:
    static constexpr auto parse(format_parse_context& ctx) { return ctx.end(); }
    template <typename FmtContent>
    constexpr auto format(const R3B::Digitizing::ChannelHit& signal, FmtContent& ctn) const
    {
        return format_to(ctn.out(),
                         "{{qdc: {}, tdc: {}, adcUnSat: {}, side: {}}}",
                         signal.qdc,
                         signal.tdc,
                         signal.qdcUnSat,
                         signal.side);
    }
};
 
template <>
class fmt::formatter<R3B::Digitizing::ChannelCalSignal>
{
  public:
    static constexpr auto parse(format_parse_context& ctx) { return ctx.end(); }
    template <typename FmtContent>
    constexpr auto format(const R3B::Digitizing::ChannelCalSignal& signal, FmtContent& ctn) const
    {
        return format_to(ctn.out(), "{{ToT: {}, Leading edge: {}, side: {}}}", signal.tot, signal.tle, signal.side);
    }
};
 
template <>
class fmt::formatter<R3B::Digitizing::ChannelSignal>
{
  public:
    static constexpr auto parse(format_parse_context& ctx) { return ctx.end(); }
    template <typename FmtContent>
    constexpr auto format(const R3B::Digitizing::ChannelSignal& hit, FmtContent& ctn) const
    {
        return format_to(ctn.out(), "{{time: {} ns, light dep: {} MeV}}", hit.time, hit.intensity);
    }
};