TPGenerator.hpp

Go to the documentation of this file.

 
#ifndef TPGLIBS_TPGENERATOR_HPP_
#define TPGLIBS_TPGENERATOR_HPP_
 
#include "tpglibs/AVXPipeline.hpp"
#include "tpglibs/AbstractProcessor.hpp"
 
#include "trgdataformats/Types.hpp"
 
#include <memory>
#include <utility>
#include <unordered_map>
 
 
namespace tpglibs {

class TPGenerator {
  static const uint8_t m_num_channels_per_pipeline = 16; // AVX2 with int16 data samples allows us to process 16 channels.
  bool m_configured {false};
  uint8_t m_num_pipelines = 0;  // Gets set inside configure.
  std::vector<AVXPipeline> m_tpg_pipelines;
  float m_sample_tick_difference = 0;
  std::vector<uint16_t> m_sot_minima{1,1,1};  // Defaults to 1 for all planes.
 
  public:
    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,
                   const float sample_tick_difference);

    void reset();

    void set_sot_minima(const std::vector<uint16_t>& sot_minima);

    std::vector<std::pair<std::shared_ptr<AbstractProcessor<__m256i>>, int>> get_all_processor_references_with_pipeline_index();

    template <typename T>
    std::vector<dunedaq::trgdataformats::TriggerPrimitive> operator()(const T* frame) {
      // Max number of TPs for a channel: number of time samples / 2.
      std::vector<dunedaq::trgdataformats::TriggerPrimitive> tp_aggr;
      tp_aggr.reserve(T::s_num_channels * T::s_time_samples_per_frame / 2);
 
      // Flatten the external 2-D C-array to a 1-D base pointer; traversal by row stride.
      const typename T::word_t* const words_base = &frame->adc_words[0][0];
      constexpr int row_stride = T::s_bits_per_adc;
      const uint64_t timestamp = frame->get_timestamp();
 
      const int register_alignment = T::s_bits_per_adc * m_num_channels_per_pipeline;
      // Loop in time.
      for (int t = 0; t < T::s_time_samples_per_frame; t++) {
        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
        const typename T::word_t *time_sample = words_base + t * row_stride;
        const char* cursor = reinterpret_cast<const char*>(time_sample); // Need to walk in terms of bytes/bits.
 
        // Loop in pipelines.
        for (int p = 0; p < m_num_pipelines; p++) {
          if (p == m_num_pipelines - 1) {
            // Take a step of 32 bit backwards for the last sub-frame.
            // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
            cursor -= 4;
          }
 
          __m256i regi = _mm256_lddqu_si256(reinterpret_cast<const __m256i*>(cursor));
 
          if (p == m_num_pipelines - 1) // Permute the row order to use the same operation.
            regi = _mm256_permutevar8x32_epi32(regi, _mm256_setr_epi32(1, 2, 3, 4, 5, 6, 7, 0));
 
          __m256i expanded_subframe = expand_frame(regi);
          std::vector<dunedaq::trgdataformats::TriggerPrimitive> tps = m_tpg_pipelines[p].process(expanded_subframe);
 
          for (auto tp : tps) {
            const auto offset_samples = static_cast<float>(t - tp.samples_over_threshold);
            tp.time_start =
                static_cast<int64_t>(offset_samples * m_sample_tick_difference) + timestamp;
            tp_aggr.push_back(tp);
          }
          // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
          cursor += register_alignment / 8; // Numerator is in bits. Need bytes.
        }
      }
 
      return tp_aggr;
    }
 
  private:
    __m256i expand_frame(const __m256i& regi); 
    __m256i old_expand_frame(const __m256i& regi); 
};
 
} // namespace tpglibs
 
#endif // TPGLIBS_TPGENERATOR_HPP_