R3BNeulandDigitizer.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.                                      *
 ******************************************************************************/
 
#pragma once
#include "FairTask.h"
#include "Filterable.h"
#include "NeulandParticleFilter.h"
#include "NeulandSimCalData.h"
#include "R3BDataMonitor.h"
#include "R3BDigitizingPaddle.h"
#include "R3BDigitizingPaddleNeuland.h"
#include "R3BDigitizingTacQuila.h"
#include "R3BDigitizingTamex.h"
#include "R3BIOConnector.h"
#include "R3BNeulandGeoPar.h"
#include "R3BNeulandHit.h"
#include "R3BNeulandPoint.h"
#include <Rtypes.h>
#include <RtypesCore.h>
#include <TClonesArray.h>
#include <TH1.h>
#include <memory>
#include <string>
#include <string_view>
#include <unordered_map>
#include <utility>
 
class TGeoNode;
class TH1F;
class TH2F;

 
namespace R3B::Digitizing
{
    class EngineInterface;
}
namespace R3B::Neuland
{
    struct DigiTaskOptions
    {
        bool enable = false;                   
        std::string name = "NeulandDigitizer"; 
        std::string channel = "tamex";
        std::string paddle = "neuland";
        bool enable_sim_cal = false;
        bool enable_hit_par = false;
        bool enable_size_monitor = false;
        ParticleFilter::Options point_filter; 
        R3B::Digitizing::Neuland::Tamex::Params tamex_par{
            R3B::Digitizing::Neuland::Tamex::Channel::GetDefaultRandomGen()
        }; 

        Digitizing::Neuland::Tamex::PeakPileUpStrategy pileup_strategy = Digitizing::Neuland::Tamex::
            PeakPileUpStrategy::width;                    
        std::string read = "NeulandPoints;NeulandHitPar"; 
        std::string write = "NeulandHits;NeulandSimCal";  
 
        ClassDefNV(DigiTaskOptions, 1); // NOLINT
    };

    class Digitizer : public FairTask
    {
      public:
        using NeulandPaddle = Digitizing::Neuland::Paddle;
        using TacquilaChannel = Digitizing::Neuland::TacQuila::Channel;
        using TamexChannel = Digitizing::Neuland::Tamex::Channel;

        Digitizer();
 
        Digitizer(const Digitizer&) = delete;
        Digitizer(Digitizer&&) = delete;
        auto operator=(const Digitizer&) -> Digitizer& = delete;
        auto operator=(Digitizer&&) -> Digitizer& = delete;
        ~Digitizer() override;

        explicit Digitizer(std::unique_ptr<Digitizing::EngineInterface> engine,
                           std::string_view points_name = "NeulandPoints",
                           std::string_view hits_name = "NeulandHits",
                           std::string_view cal_hits_name = "NeulandSimCal");

        static auto Create(const R3B::Neuland::DigiTaskOptions& option, FairRun* run) -> std::unique_ptr<Digitizer>;

        void SetEngine(std::unique_ptr<Digitizing::EngineInterface> engine);

        void AddFilter(const Filterable<R3BNeulandHit&>::Filter& filter) { hit_filters_.Add(filter); }

        void AddFilterCal(const Filterable<R3B::Neuland::SimCalData&>::Filter& filter) { cal_hit_filter_.Add(filter); }

        void SetPointFilter(R3B::Neuland::ParticleFilter filter) { neuland_point_filter_ = std::move(filter); }

        void EnableCalDataOutput(bool is_enabled) { has_cal_output_ = is_enabled; }

        void EnableSizeMonitor(bool is_enabled = true) { has_size_monitor_ = is_enabled; }

        [[nodiscard]] auto HasCalDataOutput() const -> bool { return has_cal_output_; }
 
      private:
        bool has_cal_output_ = false;
        bool has_size_monitor_ = false;
 
        R3B::InputVectorConnector<R3BNeulandPoint> neuland_points_{ "NeulandPoints" };
        R3B::OutputVectorConnector<R3BNeulandHit> neuland_hits_{ "NeulandHits" };
        R3B::OutputVectorConnector<R3B::Neuland::SimCalData> neuland_cal_hits_{ "NeulandSimCal" };
 
        std::unique_ptr<Digitizing::EngineInterface> digitizing_engine_; // owning
 
        R3B::Neuland::ParticleFilter neuland_point_filter_;
        Filterable<R3BNeulandHit&> hit_filters_;
        Filterable<R3B::Neuland::SimCalData&> cal_hit_filter_;
 
        R3BNeulandGeoPar* neuland_geo_par_ = nullptr; // non-owning
        std::unordered_map<int, int>
            point_size_tracker_; //<! Tracker to calculate point number per paddle with the paddle number as the key
 
        R3B::DataMonitor data_monitor_;
        TH1I* hist_multi_one_ = nullptr;
        TH1I* hist_multi_two_ = nullptr;
        TH1F* hist_rl_time_to_trig_ = nullptr;
 
        TH1D* hist_point_size_ = nullptr;
        TH1D* hist_channel_signal_size_ = nullptr;
        TH1D* hist_channel_hit_size_ = nullptr;
        TH1D* hist_paddle_hit_size_ = nullptr;
 
        void fill_points_to_engine();
        void fill_cal_data(const R3B::Digitizing::AbstractPaddle& paddle);
        void fill_hit_data(const R3B::Digitizing::AbstractPaddle& paddle);
        void fill_histograms();
        void fill_size_histograms(const Digitizing::AbstractPaddle& paddle);
        void init_histograms();
 
        auto Init() -> InitStatus override;
        void FinishTask() override;
        void FinishEvent() override;
        void SetParContainers() override;
        void Exec(Option_t* /*option*/) override;
 
      public:
        ClassDefOverride(Digitizer, 1) // NOLINT
    };
 
} // namespace R3B::Neuland
 
using R3BNeulandDigitizer = R3B::Neuland::Digitizer;