dunedaq::trgtools::EmulationUnit< T, U, V > Class Template Reference

#include <EmulationUnit.hpp>

Public Member Functions
uint64_t	emulate (const input_t &input, std::vector< output_t > &outputs)
std::unique_ptr< daqdataformats::Fragment >	emulate_vector (const std::vector< input_t > &inputs)
std::vector< output_t >	get_last_output_buffer ()
void	set_maker (std::unique_ptr< maker_t > &maker)
void	set_timing_file (const std::string &file_name)
void	write_csv_header (const std::string &header)

Private Types
using	input_t = T
using	output_t = U
using	maker_t = V

Private Attributes
std::unique_ptr< maker_t >	m_maker
std::vector< output_t >	m_last_output_buffer
std::string	m_timing_file_name

Detailed Description

template<typename T, typename U, typename V>
class dunedaq::trgtools::EmulationUnit< T, U, V >

Definition at line 27 of file EmulationUnit.hpp.

Member Typedef Documentation

input_t

template<typename T, typename U, typename V>

using dunedaq::trgtools::EmulationUnit< T, U, V >::input_t = T

private

Definition at line 29 of file EmulationUnit.hpp.

maker_t

template<typename T, typename U, typename V>

using dunedaq::trgtools::EmulationUnit< T, U, V >::maker_t = V

private

Definition at line 31 of file EmulationUnit.hpp.

output_t

template<typename T, typename U, typename V>

using dunedaq::trgtools::EmulationUnit< T, U, V >::output_t = U

private

Definition at line 30 of file EmulationUnit.hpp.

Member Function Documentation

emulate()

template<typename T, typename U, typename V>

uint64_t dunedaq::trgtools::EmulationUnit< T, U, V >::emulate	(	const input_t &	input,
		std::vector< output_t > &	outputs )

Definition at line 108 of file EmulationUnit.hxx.

                                                                     {
  auto time_start = std::chrono::steady_clock::now();
  (*m_maker)(input, outputs); // Feed TX into the TXMaker
  auto time_end = std::chrono::steady_clock::now();
 
  uint64_t time_diff = std::chrono::nanoseconds(time_end - time_start).count();
  return time_diff;
}

emulate_vector()

template<typename T, typename U, typename V>

std::unique_ptr< daqdataformats::Fragment > dunedaq::trgtools::EmulationUnit< T, U, V >::emulate_vector

(

const std::vector< input_t > &

inputs

)

Definition at line 18 of file EmulationUnit.hxx.

                                                                 {
  // Create the output.
  std::vector<U> output_buffer;
  std::vector<U> temp_buffer;
 
  // Create the output tp variables
  std::vector<uint64_t> time_diffs;
  // TODO: Figure out a way of saving channelid if TPs. TCs don't have it
  std::vector<uint64_t> tp_adc_integral;
  std::vector<uint64_t> tp_time_start;
  std::vector<int> is_last_tp_in_ta;
  // Only pre-allocate memory if we're actually saving the latencies
  if (!m_timing_file_name.empty()) {
    time_diffs.reserve(inputs.size());
    tp_adc_integral.reserve(inputs.size());
    tp_time_start.reserve(inputs.size());
    is_last_tp_in_ta.reserve(inputs.size());
  }
 
  for (const T& input : inputs) {
    size_t output_buffer_size = output_buffer.size();
    uint64_t time_diff = emulate(input, temp_buffer);
    if (temp_buffer.size() != 0) {
      output_buffer.insert(output_buffer.end(), temp_buffer.begin(), temp_buffer.end());
      temp_buffer.clear();
    }
    // 1 if it's the TP that creates a TA, 0 otherwise
    int last_tp_in_ta = (output_buffer_size == output_buffer.size()) ? 0 : 1;
 
    // Don't save any times if we're not saving latencies
    if (m_timing_file_name.empty())
      continue;
    time_diffs.push_back(time_diff);
 
    // Don't save time_start, number of TPs etc. unless it's TA latencies per TP
    if (!std::is_same<T, dunedaq::trgdataformats::TriggerPrimitive>::value)
      continue;
 
    tp_time_start.push_back(input.time_start);
    tp_adc_integral.push_back(input.adc_integral);
    is_last_tp_in_ta.push_back(last_tp_in_ta);
  }
 
  // Write the timings for each new TP in this fragment.
  if (!m_timing_file_name.empty()) {
    std::fstream timings;
    timings.open(m_timing_file_name, std::ios::out | std::ios::app);
    for (size_t i = 0; i < time_diffs.size(); i++) {
      if (std::is_same<T, dunedaq::trgdataformats::TriggerPrimitive>::value) {
        timings << tp_time_start[i] << "," << tp_adc_integral[i] << "," 
                << time_diffs[i] << "," << is_last_tp_in_ta[i] << "\n";
      }
      else {
        timings << time_diffs[i] << "\n";
      }
    }
    timings.close();
  }
 
  // Get the size to save on.
  size_t payload_size(0);
  for (const U& output : output_buffer) {
    payload_size += triggeralgs::get_overlay_nbytes(output);
  }
 
  // Don't save empty fragments.
  // The incomplete TX contents will get pushed onto the next fragment.
  if (payload_size == 0)
    return nullptr;
 
  // Awkward type conversion to avoid compiler complaints on void* arithmetic.
  char* payload = static_cast<char*>(malloc(payload_size));
  size_t payload_offset(0);
  for (const U& output : output_buffer) {
    triggeralgs::write_overlay(output, static_cast<void*>(payload + payload_offset));
    payload_offset += triggeralgs::get_overlay_nbytes(output);
  }
 
  // Hand it to a fragment,
  std::unique_ptr<daqdataformats::Fragment> frag
    = std::make_unique<daqdataformats::Fragment>(static_cast<void*>(payload), payload_size);
  // And release it.
  free(static_cast<void*>(payload));
 
  m_last_output_buffer = output_buffer;
  return frag;
}

get_last_output_buffer()

template<typename T, typename U, typename V>

std::vector< U > dunedaq::trgtools::EmulationUnit< T, U, V >::get_last_output_buffer

(

)

Definition at line 119 of file EmulationUnit.hxx.

                                               {
  return m_last_output_buffer;
}

set_maker()

template<typename T, typename U, typename V>

void dunedaq::trgtools::EmulationUnit< T, U, V >::set_maker ( std::unique_ptr< maker_t > & maker )

inline

Definition at line 42 of file EmulationUnit.hpp.

{ m_maker = std::move(maker); }

set_timing_file()

template<typename T, typename U, typename V>

void dunedaq::trgtools::EmulationUnit< T, U, V >::set_timing_file ( const std::string & file_name )

inline

Definition at line 43 of file EmulationUnit.hpp.

{ m_timing_file_name = file_name; }

write_csv_header()

template<typename T, typename U, typename V>

void dunedaq::trgtools::EmulationUnit< T, U, V >::write_csv_header ( const std::string & header )

inline

Definition at line 44 of file EmulationUnit.hpp.

                                                   {
      std::fstream file_header;
      file_header.open(m_timing_file_name, std::ios::out | std::ios::app);
      file_header << header << "\n";
      file_header.close();
    }

Member Data Documentation

m_last_output_buffer

template<typename T, typename U, typename V>

std::vector<output_t> dunedaq::trgtools::EmulationUnit< T, U, V >::m_last_output_buffer

private

Definition at line 35 of file EmulationUnit.hpp.

m_maker

template<typename T, typename U, typename V>

std::unique_ptr<maker_t> dunedaq::trgtools::EmulationUnit< T, U, V >::m_maker

private

Definition at line 34 of file EmulationUnit.hpp.

m_timing_file_name

template<typename T, typename U, typename V>

std::string dunedaq::trgtools::EmulationUnit< T, U, V >::m_timing_file_name

private

Definition at line 36 of file EmulationUnit.hpp.

---

The documentation for this class was generated from the following files:

• /github/workspace/dunedaq/sourcecode/trgtools/include/trgtools/EmulationUnit.hpp
• /github/workspace/dunedaq/sourcecode/trgtools/include/trgtools/detail/EmulationUnit.hxx