TPGPipeline.hpp

Go to the documentation of this file.

 
#ifndef TPGLIBS_TPGPIPELINE_HPP_
#define TPGLIBS_TPGPIPELINE_HPP_
 
#include "tpglibs/AbstractFactory.hpp"
#include "tpglibs/AbstractProcessor.hpp"
 
#include "trgdataformats/TriggerPrimitive.hpp"
#include "trgdataformats/Types.hpp"
 
#include <nlohmann/json.hpp>
#include <array>
#include <vector>
 
namespace tpglibs {

template <typename T, typename U>
class TPGPipeline {
  public:
    using processor_t = T;
    using signal_t = U;
 
    virtual ~TPGPipeline() = default;

    virtual void configure(const std::vector<std::pair<std::string, nlohmann::json>> configs, const std::vector<std::pair<dunedaq::trgdataformats::channel_t, int16_t>> channel_plane_numbers) {
      std::shared_ptr<processor_t> prev_processor = nullptr;
 
      for (int i = 0; i < 16; i++) {
        m_channels.at(i) = channel_plane_numbers[i].first;
        m_plane_numbers.at(i) = channel_plane_numbers[i].second;
      }
 
      for (const auto& name_config : configs) {
        // Get the requested processor.
        std::shared_ptr<processor_t> processor = m_factory->create_processor(name_config.first);
 
        // Configure it.
        processor->configure(name_config.second, m_plane_numbers.data());
 
        // If it's the first one, make it the head.
        if (!prev_processor) {
          m_processor_head = processor;
          prev_processor = processor;
          continue;
        }
 
        // Otherwise, start linking the chain.
        prev_processor->set_next_processor(processor);
        prev_processor = processor;
      }
    }

    virtual std::vector<dunedaq::trgdataformats::TriggerPrimitive> process(const signal_t& signal) {
      signal_t tp_mask = save_state(m_processor_head->process(signal));
 
      std::vector<dunedaq::trgdataformats::TriggerPrimitive> tps;
      if (check_for_tps(tp_mask))
        tps = generate_tps(tp_mask);
 
      return tps;
    }

    virtual bool check_for_tps(const signal_t& tp_mask) = 0;

    virtual signal_t save_state(const signal_t& processed_signal) = 0;

    virtual std::vector<dunedaq::trgdataformats::TriggerPrimitive> generate_tps(const signal_t& tp_mask) = 0;

    virtual std::vector<std::shared_ptr<AbstractProcessor<signal_t>>> get_all_processor_references() {
      std::vector<std::shared_ptr<AbstractProcessor<signal_t>>> processor_references;
      if (m_processor_head == nullptr) return processor_references;
 
      auto current_processor = std::static_pointer_cast<AbstractProcessor<signal_t>>(m_processor_head);
      while (current_processor != nullptr) {
        processor_references.push_back(current_processor);
        current_processor = current_processor->get_next_processor();
      }
      return processor_references;
    }

    virtual void set_sot_minima(const std::vector<uint16_t>& sot_minima) {
      int idx = 0;
      for (auto sot_minimum : sot_minima) {
        m_sot_minima.at(idx++) = sot_minimum;
      }
    }
 
  protected:
    signal_t m_adc_integral_lo{};
    signal_t m_adc_integral_hi{};
    signal_t m_adc_peak{};
    signal_t m_samples_over_threshold{};
    signal_t m_samples_to_peak{};
    std::array<dunedaq::trgdataformats::channel_t, 16> m_channels;
    std::array<int16_t, 16> m_plane_numbers;
    std::array<uint16_t, 3> m_sot_minima;
    std::shared_ptr<AbstractFactory<processor_t>> m_factory = AbstractFactory<processor_t>::get_instance();
    std::shared_ptr<processor_t> m_processor_head;
};
 
} // namespace tpglibs
 
#endif // TPGLIBS_TPGPIPELINE_HPP_