R3BDigitizingEngine.h

Go to the documentation of this file.

/******************************************************************************
 *   Copyright (C) 2019 GSI Helmholtzzentrum für Schwerionenforschung GmbH    *
 *   Copyright (C) 2019-2025 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.                                      *
 ******************************************************************************/
 
#ifndef NEULAND_DIGITIZING_ENGINE_H
#define NEULAND_DIGITIZING_ENGINE_H
 
#include "R3BDigitizingChannel.h"
#include "R3BDigitizingPaddle.h"
#include "R3BShared.h"
#include <algorithm>
#include <atomic>
#include <cmath>
#include <functional>
#include <memory>
#include <range/v3/algorithm/find_if.hpp>
#include <range/v3/view/take.hpp>
#include <range/v3/view/transform.hpp>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace R3B::Digitizing
{
    class EngineInterface
    {
      public:
        EngineInterface() = default;

        virtual ~EngineInterface() = default;

        EngineInterface(const EngineInterface& other) = delete;
        auto operator=(const EngineInterface& other) -> EngineInterface& = delete;
        EngineInterface(EngineInterface&& other) = delete;
        auto operator=(EngineInterface&& other) -> EngineInterface& = delete;

        void DepositLight(int paddle_id, double time, double energy_dep, double dist)
        {
            auto& paddle = add_paddle(paddle_id);
            paddle.DepositLight({ time, energy_dep, dist });
        }

        [[nodiscard]] auto GetTriggerTime() const -> double
        {
            auto paddles_view = ranges::views::take(paddles_, size_);
            auto min_element = std::min_element(paddles_view.begin(),
                                                paddles_view.end(),
                                                [](const auto& left, const auto& right)
                                                { return left->GetTrigTime() < right->GetTrigTime(); });
            return (min_element == paddles_view.end()) ? NAN : min_element->get()->GetTrigTime();
        }

        void Init(int initial_capacity = 1)
        {
            ExtraInit(initial_capacity);
            reserve_additional_paddles(initial_capacity);
        }

        void Reset()
        {
            ExtraReset();
            size_ = 0;
        }

        void Construct()
        {
            for (auto& paddle : ranges::views::take(paddles_, size_))
            {
                paddle->Construct();
            }
        }

        [[nodiscard]] auto get_capacity() const { return paddles_.size(); };

        template <typename Unary>
        void DoEachPaddle(Unary fnt) const
        {
            for (const auto& paddle : ranges::views::take(paddles_, size_))
            {
                fnt(*paddle);
            }
        }

        template <typename Unary>
        auto DoAllPaddles(Unary fnt) const
        {
            return fnt(ranges::views::take(paddles_, size_) |
                       ranges::views::transform([](auto& paddle) -> const AbstractPaddle& { return *paddle; }));
        }
 
      private:
        std::atomic<int> size_ = 0; 
        std::vector<std::unique_ptr<AbstractPaddle>>
            paddles_; 
 
        [[nodiscard]] virtual auto make_new_paddle() const -> std::unique_ptr<AbstractPaddle> = 0;
        virtual void ExtraInit(int initial_capacity) {}
        virtual void ExtraReset() {}

        void reserve_additional_paddles(int num)
        {
            {
                paddles_.reserve(num + get_capacity());
                for (int idx{}; idx < num; ++idx)
                {
                    paddles_.emplace_back(make_new_paddle());
                }
            }
        }
 
        auto add_paddle(int paddle_id) -> AbstractPaddle&
        {
            // find if a paddle with the paddle_id is already added
            auto valid_view = ranges::views::take(paddles_, size_);
            auto iter =
                ranges::find_if(valid_view, [paddle_id](auto& paddle) { return paddle->GetPaddleID() == paddle_id; });
            if (iter != valid_view.end())
            {
                return *(*iter);
            }
            // check if size is still smaller than capacity
            if (size_ >= get_capacity())
            {
                // underlying data storage need to grow
                reserve_additional_paddles(size_ / 2);
            }
            auto* new_paddle = paddles_.at(size_++).get();
            new_paddle->Reset();
            new_paddle->SetPaddleID(paddle_id);
            return *new_paddle;
        }
    };
 
    // factory classes for paddle and channel:
    template <typename ChannelClass, typename = std::enable_if_t<std::is_base_of_v<AbstractChannel, ChannelClass>>>
    struct UseChannel
    {
        template <typename... Args>
        explicit UseChannel(const Args&... args)
            : BuildChannel([=](Side side) { return std::make_unique<ChannelClass>(side, args...); })
        {
        }
        std::function<std::unique_ptr<ChannelClass>(Side)> BuildChannel;
    };
 
    template <typename PaddleClass, typename = std::enable_if_t<std::is_base_of_v<AbstractPaddle, PaddleClass>>>
    struct UsePaddle
    {
        template <typename... Args>
        explicit UsePaddle(const Args&... args)
            : BuildPaddle([=](int paddleID) { return std::make_unique<PaddleClass>(paddleID, args...); })
        {
        }
        std::function<std::unique_ptr<PaddleClass>(int)> BuildPaddle;
    };
 
    template <typename PaddleClass, typename ChannelClass, typename InitFunc = std::function<void()>>
    class Engine : public EngineInterface
    {
      public:
        Engine(
            const UsePaddle<PaddleClass>& p_paddleClass,
            const UseChannel<ChannelClass>& p_channelClass,
            InitFunc initFunc = []() {})
            : paddleClass_{ p_paddleClass }
            , channelClass_{ p_channelClass }
            , EngineInterface()
            , initFunc_{ initFunc }
        {
        }

        void SetInit(const InitFunc& initFunc) { initFunc_ = initFunc; }
        void ExtraReset() override {}
 
      private:
        UsePaddle<PaddleClass> paddleClass_;    
        UseChannel<ChannelClass> channelClass_; 
        InitFunc initFunc_;
 
        void ExtraInit(int /*initial_capacity*/) override { initFunc_(); }
        [[nodiscard]] auto make_new_paddle() const -> std::unique_ptr<AbstractPaddle> override
        {
            auto new_paddle = paddleClass_.BuildPaddle(-1);
            new_paddle->SetChannel(channelClass_.BuildChannel(R3B::Side::left));
            new_paddle->SetChannel(channelClass_.BuildChannel(R3B::Side::right));
            return new_paddle;
        }
    };
 
    // helper to create owning digitizingEngine:
    template <typename... Args>
    [[nodiscard]] auto CreateEngine(Args&&... args) -> std::unique_ptr<decltype(Engine{ std::forward<Args>(args)... })>
    {
        return std::make_unique<decltype(Engine{ std::forward<Args>(args)... })>(std::forward<Args>(args)...);
    }
 
} // namespace R3B::Digitizing
 
#endif // NEULAND_DIGITIZING_ENGINE_H