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 <array>
#include <nlohmann/json.hpp>
#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_