dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter > Class Template Reference

#include <TPCEthFrameProcessor.hpp>

Inheritance diagram for dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >:

Collaboration diagram for dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >:

Public Types
using	inherited = datahandlinglibs::TaskRawDataProcessorModel<ReadoutTypeAdapter>
using	frameptr = ReadoutTypeAdapter*
using	constframeptr = const ReadoutTypeAdapter*
using	tpcframeptr = ReadoutTypeAdapter::FrameType*
Public Types inherited from dunedaq::opmonlib::MonitorableObject
using	NodePtr = std::weak_ptr<MonitorableObject>
using	NewNodePtr = std::shared_ptr<MonitorableObject>
using	ElementId = std::string

Public Member Functions
	TPCEthFrameProcessor (std::unique_ptr< datahandlinglibs::FrameErrorRegistry > &error_registry, bool processing_enabled)
void	start (const appfwk::DAQModule::CommandData_t &args) override
	Start operation.
void	stop (const appfwk::DAQModule::CommandData_t &args) override
	Stop operation.
void	conf (const appmodel::DataHandlerModule *conf) override
	Set the emulator mode, if active, timestamps of processed packets are overwritten with new ones.
void	scrap (const appfwk::DAQModule::CommandData_t &cfg) override
	Unconfigure.
Public Member Functions inherited from dunedaq::datahandlinglibs::TaskRawDataProcessorModel< ReadoutTypeAdapter >
	TaskRawDataProcessorModel (std::unique_ptr< FrameErrorRegistry > &error_registry, bool post_processing_enabled)
	~TaskRawDataProcessorModel ()
void	reset_last_daq_time ()
std::uint64_t	get_last_daq_time () override
	Get newest timestamp of last seen packet.
void	preprocess_item (ReadoutTypeAdapter *item) override
	Preprocess one element.
void	postprocess_item (const ReadoutTypeAdapter *item) override
	Postprocess one element.
void	invoke_postprocess_schedule_timeout_policy (std::uint64_t accumilated_timeout_ticks) override
	Handle postprocess timeout event.
void	add_preprocess_task (Task &&task)
void	add_postprocess_task (Task &&task)
void	invoke_all_preprocess_functions (ReadoutTypeAdapter *item)
void	launch_all_preprocess_functions (ReadoutTypeAdapter *item)
Public Member Functions inherited from dunedaq::datahandlinglibs::RawDataProcessorConcept< ReadoutType >
	RawDataProcessorConcept ()
virtual	~RawDataProcessorConcept ()
	RawDataProcessorConcept (const RawDataProcessorConcept &)=delete
	RawDataProcessorConcept is not copy-constructible.
RawDataProcessorConcept &	operator= (const RawDataProcessorConcept &)=delete
	RawDataProcessorConcept is not copy-assginable.
	RawDataProcessorConcept (RawDataProcessorConcept &&)=delete
	RawDataProcessorConcept is not move-constructible.
RawDataProcessorConcept &	operator= (RawDataProcessorConcept &&)=delete
	RawDataProcessorConcept is not move-assignable.
virtual void	preprocess_item (ReadoutType *item)=0
	Preprocess one element.
virtual void	postprocess_item (const ReadoutType *item)=0
	Postprocess one element.
Public Member Functions inherited from dunedaq::opmonlib::MonitorableObject
	MonitorableObject (const MonitorableObject &)=delete
MonitorableObject &	operator= (const MonitorableObject &)=delete
	MonitorableObject (MonitorableObject &&)=delete
MonitorableObject &	operator= (MonitorableObject &&)=delete
virtual	~MonitorableObject ()=default
auto	get_opmon_id () const noexcept
auto	get_opmon_level () const noexcept

Protected Member Functions
void	generate_opmon_data () override
void	configure_source_and_geo_ids (const appmodel::DataHandlerModule *conf)
void	configure_preprocessing (const appmodel::DataHandlerModule *conf)
void	configure_postprocessing (const appmodel::DataHandlerModule *conf)
void	configure_channel_plane_numbers (const appmodel::TPCRawDataProcessor *proc_conf)
void	configure_find_tps (const appmodel::DataHandlerModule *conf, const appmodel::TPCRawDataProcessor *proc_conf)
void	scrap_source_and_geo_ids ()
void	scrap_preprocessing ()
void	scrap_postprocessing ()
void	scrap_channel_plane_numbers ()
void	scrap_find_tps ()
void	sequence_check (frameptr fp)
void	timestamp_check (frameptr fp)
void	find_tps (constframeptr fp)
Protected Member Functions inherited from dunedaq::datahandlinglibs::TaskRawDataProcessorModel< ReadoutTypeAdapter >
void	run_post_processing_thread (std::function< void(const ReadoutTypeAdapter *)> &function, folly::ProducerConsumerQueue< const ReadoutTypeAdapter * > &queue)
Protected Member Functions inherited from dunedaq::opmonlib::MonitorableObject
	MonitorableObject ()=default
void	register_node (ElementId name, NewNodePtr)
void	publish (google::protobuf::Message &&, CustomOrigin &&co={}, OpMonLevel l=to_level(EntryOpMonLevel::kDefault)) const noexcept

Protected Attributes
bool	m_emulator_mode = false
bool	m_first_frame = true
dunedaq::daqdataformats::timestamp_t	m_previous_ts = 0
dunedaq::daqdataformats::timestamp_t	m_current_ts = 0
dunedaq::daqdataformats::timestamp_t	m_pattern_generator_previous_ts = 0
dunedaq::daqdataformats::timestamp_t	m_pattern_generator_current_ts = 0
bool	m_first_ts_missmatch = true
bool	m_ts_problem_reported = false
bool	m_ts_error_state = false
std::atomic< uint64_t >	m_ts_error_ctr { 0 }
uint16_t	m_previous_seq_id = 0
uint16_t	m_current_seq_id = 0
bool	m_first_seq_id_mismatch = true
bool	m_seq_id_problem_reported = false
bool	m_seq_id_error_state = false
std::atomic< uint64_t >	m_seq_id_error_ctr { 0 }
std::atomic< int16_t >	m_seq_id_min_jump { 0 }
std::atomic< int16_t >	m_seq_id_max_jump { 0 }
std::unique_ptr< tpglibs::TPGenerator >	m_tp_generator
std::vector< std::pair< std::string, nlohmann::json > >	m_tpg_configs
std::unordered_map< unsigned int, std::vector< trigger::TriggerPrimitiveTypeAdapter > >	m_plane_to_tpa_vector_map
std::unordered_map< unsigned int, std::shared_ptr< iomanager::SenderConcept< std::vector< trigger::TriggerPrimitiveTypeAdapter > > > >	m_plane_to_tp_sink_map
uint32_t	m_tp_count_limit = 0
uint32_t	m_frame_count_limit = 0
uint32_t	m_current_tp_count = 0
uint32_t	m_frame_count_at_last_send = 0
bool	m_tp_limit_enabled = false
bool	m_frame_limit_enabled = false
std::set< unsigned int >	m_channel_mask_set
std::set< unsigned int >	m_plane_numbers_set
std::vector< std::pair< trgdataformats::channel_t, int16_t > >	m_channel_plane_numbers
std::unordered_map< trgdataformats::channel_t, unsigned int >	m_channel_plane_map
bool	m_tpg_metric_collect_enabled { false }
uint32_t	m_metric_collect_opmon_period { 128 }
std::map< uint, std::atomic< int > >	m_tp_channel_rate_map
std::atomic< uint64_t >	m_num_new_tps { 0 }
std::atomic< uint64_t >	m_tps_suppressed_too_long { 0 }
std::atomic< uint64_t >	m_tps_send_failed { 0 }
std::chrono::time_point< std::chrono::high_resolution_clock >	m_t0
std::atomic< uint64_t >	m_frame_counter { 0 }
uint32_t	m_det_id
uint32_t	m_crate_id
uint32_t	m_slot_id
uint32_t	m_stream_id
daqdataformats::SourceID	m_sourceid
Protected Attributes inherited from dunedaq::datahandlinglibs::TaskRawDataProcessorModel< ReadoutTypeAdapter >
std::vector< std::function< void(ReadoutTypeAdapter *)> >	m_preprocess_functions
std::unique_ptr< FrameErrorRegistry > &	m_error_registry
bool	m_post_processing_enabled
std::atomic< bool >	m_run_marker
std::vector< std::function< void(const ReadoutTypeAdapter *)> >	m_post_process_functions
std::vector< std::unique_ptr< folly::ProducerConsumerQueue< const ReadoutTypeAdapter * > > >	m_items_to_postprocess_queues
std::vector< std::unique_ptr< utilities::ReusableThread > >	m_post_process_threads
size_t	m_postprocess_queue_sizes
daqdataformats::SourceID	m_sourceid
std::atomic< uint64_t >	m_last_processed_daq_ts

Additional Inherited Members
Static Public Member Functions inherited from dunedaq::opmonlib::MonitorableObject
static bool	publishable_metric (OpMonLevel entry, OpMonLevel system) noexcept

Detailed Description

template<class ReadoutTypeAdapter>
class dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >

Definition at line 60 of file TPCEthFrameProcessor.hpp.

Member Typedef Documentation

constframeptr

template<class ReadoutTypeAdapter>

using dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::constframeptr = const ReadoutTypeAdapter*

Definition at line 66 of file TPCEthFrameProcessor.hpp.

frameptr

template<class ReadoutTypeAdapter>

using dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::frameptr = ReadoutTypeAdapter*

Definition at line 65 of file TPCEthFrameProcessor.hpp.

inherited

template<class ReadoutTypeAdapter>

using dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::inherited = datahandlinglibs::TaskRawDataProcessorModel<ReadoutTypeAdapter>

Definition at line 64 of file TPCEthFrameProcessor.hpp.

tpcframeptr

template<class ReadoutTypeAdapter>

using dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::tpcframeptr = ReadoutTypeAdapter::FrameType*

Definition at line 67 of file TPCEthFrameProcessor.hpp.

Constructor & Destructor Documentation

TPCEthFrameProcessor()

template<class ReadoutTypeAdapter>

dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::TPCEthFrameProcessor ( std::unique_ptr< datahandlinglibs::FrameErrorRegistry > & error_registry, bool processing_enabled )

explicit

Definition at line 11 of file TPCEthFrameProcessor.hxx.

  : datahandlinglibs::TaskRawDataProcessorModel<ReadoutTypeAdapter>(error_registry, processing_enabled)
{
}

Member Function Documentation

conf()

template<class ReadoutTypeAdapter>

void dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::conf ( const appmodel::DataHandlerModule * conf )

overridevirtual

Set the emulator mode, if active, timestamps of processed packets are overwritten with new ones.

Reimplemented from dunedaq::datahandlinglibs::TaskRawDataProcessorModel< ReadoutTypeAdapter >.

Definition at line 259 of file TPCEthFrameProcessor.hxx.

{
  configure_source_and_geo_ids(conf);
 
  configure_preprocessing(conf);
 
  if (this->m_post_processing_enabled) {
    configure_postprocessing(conf);
  }
 
  inherited::conf(conf);
}

configure_channel_plane_numbers()

template<class ReadoutTypeAdapter>

void dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::configure_channel_plane_numbers ( const appmodel::TPCRawDataProcessor * proc_conf )

protected

Definition at line 100 of file TPCEthFrameProcessor.hxx.

{
  const std::shared_ptr<detchannelmaps::TPCChannelMap> channel_map =
    dunedaq::detchannelmaps::make_tpc_map(proc_conf->get_channel_map());
  const std::vector<unsigned int> channel_mask_vec = proc_conf->get_channel_mask();
 
  for (int chan = 0; chan < 64; chan++) {
    trgdataformats::channel_t off_channel = channel_map->get_offline_channel_from_det_crate_slot_stream_chan(
      m_det_id, m_crate_id, m_slot_id, m_stream_id, chan);
    int16_t plane = channel_map->get_plane_from_offline_channel(off_channel);
    m_channel_plane_numbers.push_back(std::make_pair(off_channel, plane));
 
    // This processor only needs to handle some (maybe 0) of the masked channels.
    // Only get those relevant channels for the later check.
    // Only get the planes for the channels that are not masked.
    if (std::find(channel_mask_vec.begin(), channel_mask_vec.end(), off_channel) != channel_mask_vec.end()) {
      m_channel_mask_set.insert(off_channel);
    } else {
      m_channel_plane_map[off_channel] = plane;
      m_plane_numbers_set.insert(plane);
    }
  }
}

configure_find_tps()

template<class ReadoutTypeAdapter>

void dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::configure_find_tps ( const appmodel::DataHandlerModule * conf, const appmodel::TPCRawDataProcessor * proc_conf )

protected

Definition at line 127 of file TPCEthFrameProcessor.hxx.

{
  // Setting TP sinks.
  // Configurations currently have the sinks iterate in order, but there may be more sinks than planes.
  int plane_number = 0;
  for (auto output : conf->get_outputs()) {
    try {
      if (output->get_data_type() == "TriggerPrimitiveVector") {
        if (m_plane_numbers_set.contains(plane_number)) {
          m_plane_to_tp_sink_map[plane_number] =
            get_iom_sender<std::vector<trigger::TriggerPrimitiveTypeAdapter>>(output->UID());
        }
        plane_number++;
      }
    } catch (const ers::Issue& excpt) {
      ers::error(datahandlinglibs::ResourceQueueError(ERS_HERE, "tp", "DefaultRequestHandlerModel", excpt));
    }
  }
 
  // We do need a coverage for all planes.
  if (m_plane_numbers_set.size() > m_plane_to_tp_sink_map.size()) {
    ers::error(DetectorPlaneToTPSinkMismatch(ERS_HERE, m_plane_numbers_set.size(), m_plane_to_tp_sink_map.size()));
  }
 
  m_tp_generator = std::make_unique<tpglibs::TPGenerator>();
 
  // Set the minimum TP samples over threshold.
  auto conf_sot_minima = proc_conf->get_sot_minima();
  std::vector<uint16_t> sot_minima{ conf_sot_minima->get_sot_minimum_plane0(),
                                    conf_sot_minima->get_sot_minimum_plane1(),
                                    conf_sot_minima->get_sot_minimum_plane2() };
  m_tp_generator->set_sot_minima(sot_minima);
 
  std::vector<const appmodel::ProcessingStep*> processing_steps = proc_conf->get_processing_steps();
  for (auto step : processing_steps) {
    m_tpg_configs.push_back(std::make_pair(step->class_name(), step->to_json(false).back()));
  }
 
  // Let the TPG generator configure
  m_tp_generator->configure(m_tpg_configs, m_channel_plane_numbers, ReadoutTypeAdapter::samples_tick_difference);
 
  // Set the limits on when to send TPs and check that we can actually send on these limits.
  m_frame_count_limit = proc_conf->get_frame_count_limit();
  m_tp_count_limit = proc_conf->get_tp_count_limit();
  m_frame_limit_enabled = m_frame_count_limit > 0;
  m_tp_limit_enabled = m_tp_count_limit > 0;
 
  if (!m_frame_limit_enabled && !m_tp_limit_enabled) {
    throw FrameAndTPCountersDisabled(ERS_HERE);
  }
 
  m_metric_collect_opmon_period = proc_conf->get_metric_collect_opmon_period();
 
#ifdef TPGLIBS_ENABLE_STATE_MONITORING
  // Monitoring enabled at build time — set up harvester
  // Still read toggle_state for backwards compat (honor it for now)
  m_tpg_metric_collect_enabled = false;
  for (const auto& name_config : m_tpg_configs) {
    if (name_config.second.contains("metric_collect_toggle_state") &&
        name_config.second["metric_collect_toggle_state"] == true) {
      m_tpg_metric_collect_enabled = true;
      break;
    }
  }
 
  if (m_tpg_metric_collect_enabled) {
    auto processsor_references = m_tp_generator->get_all_processor_references_with_pipeline_index();
 
    m_state_harvester = std::make_unique<fdreadoutlibs::TPGInternalStateHarvester>();
 
    const uint8_t channels_per_pipeline = 16;
    const uint8_t pipelines = static_cast<uint8_t>(m_channel_plane_numbers.size() / channels_per_pipeline);
 
    TLOG_DEBUG(TLVL_BOOKKEEPING) << "Configuring state harvester with " << static_cast<int>(channels_per_pipeline)
                                 << " channels per pipeline, " << static_cast<int>(pipelines) << " pipelines, "
                                 << processsor_references.size() << " processor references";
 
    m_state_harvester->update_channel_plane_numbers(m_channel_plane_numbers, channels_per_pipeline, pipelines);
    m_state_harvester->set_processor_references(processsor_references);
 
    m_state_harvester->start_collection_thread();
 
    TLOG_DEBUG(TLVL_BOOKKEEPING) << "State harvester configured and started successfully";
  }
 
#else
  // Monitoring disabled at build time
  m_tpg_metric_collect_enabled = false;
 
  // Warn if per-processor monitoring params are configured but will have no effect
  bool warned_build_off = false;
  for (const auto& name_config : m_tpg_configs) {
    // Check if any of the monitoring configs are not the default values: someone is requesting them.
    const bool toggle_state_set = name_config.second.value("metric_collect_toggle_state", false) == true;
    const bool time_sample_period_set =
      name_config.second.value("metric_collect_time_sample_period", uint64_t{ 256 }) != 256;
    const bool requested_internal_states_set =
      !name_config.second.value("requested_internal_states", std::string{}).empty();
    if (!warned_build_off && (toggle_state_set || time_sample_period_set || requested_internal_states_set)) {
      // warn only once.
      ers::warning(TPGStateMonitoringConfigIgnored(ERS_HERE));
      warned_build_off = true;
    }
  }
#endif
 
  inherited::add_postprocess_task(
    std::bind(&TPCEthFrameProcessor<ReadoutTypeAdapter>::find_tps, this, std::placeholders::_1));
}

configure_postprocessing()

template<class ReadoutTypeAdapter>

void dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::configure_postprocessing ( const appmodel::DataHandlerModule * conf )

protected

Definition at line 240 of file TPCEthFrameProcessor.hxx.

{
  const appmodel::DataProcessor* dp = conf->get_module_configuration()->get_data_processor();
  if (dp == nullptr) {
    return;
  }
 
  const appmodel::TPCRawDataProcessor* proc_conf = dp->cast<appmodel::TPCRawDataProcessor>();
  if (proc_conf == nullptr) {
    return;
  }
 
  // Need TPCRawDataProcessor configurations to configure the following.
  configure_channel_plane_numbers(proc_conf);
  configure_find_tps(conf, proc_conf);
}

configure_preprocessing()

template<class ReadoutTypeAdapter>

void dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::configure_preprocessing ( const appmodel::DataHandlerModule * conf )

protected

Definition at line 86 of file TPCEthFrameProcessor.hxx.

{
  m_emulator_mode = conf->get_emulation_mode();
  if (!m_emulator_mode) {
    inherited::add_preprocess_task(
      std::bind(&TPCEthFrameProcessor<ReadoutTypeAdapter>::sequence_check, this, std::placeholders::_1));
  }
 
  inherited::add_preprocess_task(
    std::bind(&TPCEthFrameProcessor<ReadoutTypeAdapter>::timestamp_check, this, std::placeholders::_1));
}

configure_source_and_geo_ids()

template<class ReadoutTypeAdapter>

void dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::configure_source_and_geo_ids ( const appmodel::DataHandlerModule * conf )

protected

Definition at line 71 of file TPCEthFrameProcessor.hxx.

{
  m_sourceid.id = conf->get_source_id();
  m_sourceid.subsystem = ReadoutTypeAdapter::subsystem;
  auto geo_id = conf->get_geo_id();
  if (geo_id != nullptr) {
    m_det_id = geo_id->get_detector_id();
    m_crate_id = geo_id->get_crate_id();
    m_slot_id = geo_id->get_slot_id();
    m_stream_id = geo_id->get_stream_id();
  }
}

find_tps()

template<class ReadoutTypeAdapter>

void dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::find_tps ( constframeptr fp )

protected

Pipeline Stage 2.: Do software TPG

Definition at line 719 of file TPCEthFrameProcessor.hxx.

{
  if (!fp)
    return;
  auto wfptr = reinterpret_cast<tpcframeptr>((uint8_t*)fp); // NOLINT
 
  std::vector<trgdataformats::TriggerPrimitive> tps = (*m_tp_generator)(wfptr);
 
  uint64_t current_frame_count = m_frame_counter.fetch_add(1, std::memory_order_relaxed) + 1;
 
#ifdef TPGLIBS_ENABLE_STATE_MONITORING
  if (m_tpg_metric_collect_enabled && m_state_harvester && current_frame_count % m_metric_collect_opmon_period == 0) {
    m_state_harvester->trigger_harvest();
  }
#endif
 
  for (const auto& tp : tps) {
    // If this TP is on a masked channel, skip it.
    if (std::binary_search(m_channel_mask_set.begin(), m_channel_mask_set.end(), uint32_t(tp.channel)))
      continue;
    // Need to move into a type adapter.
    trigger::TriggerPrimitiveTypeAdapter tpa;
    tpa.tp = tp;
 
    tpa.tp.detid = m_det_id; // Last missing piece.
    m_plane_to_tpa_vector_map[m_channel_plane_map[uint32_t(tp.channel)]].push_back(tpa);
    m_tp_channel_rate_map[uint32_t(tp.channel)]++;
    m_current_tp_count++;
  }
 
  const bool frame_limit_reached =
    m_frame_limit_enabled && (current_frame_count - m_frame_count_at_last_send >= m_frame_count_limit);
  const bool tp_limit_reached = m_tp_limit_enabled && (m_current_tp_count >= m_tp_count_limit);
 
  if (frame_limit_reached || tp_limit_reached) [[unlikely]] {
    m_current_tp_count = 0;
    m_frame_count_at_last_send = current_frame_count;
    for (auto& [plane_num, tpa_vector] : m_plane_to_tpa_vector_map) {
      int num_new_tps = tpa_vector.size();
      if (num_new_tps == 0) {
        continue;
      }
      const auto ts_begin = tpa_vector.front().tp.time_start;
      const auto channel_begin = tpa_vector.front().tp.channel;
      const auto ts_end = tpa_vector.back().tp.time_start;
      const auto channel_end = tpa_vector.back().tp.channel;
      if (!m_plane_to_tp_sink_map[plane_num]->try_send(std::move(tpa_vector), iomanager::Sender::s_no_block)) {
        ers::warning(FailedToSendTPVector(ERS_HERE, ts_begin, channel_begin, ts_end, channel_end));
        m_tps_send_failed++;
      } else {
        m_num_new_tps += num_new_tps;
      }
    }
  }
  return;
}

generate_opmon_data()

template<class ReadoutTypeAdapter>

void dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::generate_opmon_data ( )

overrideprotectedvirtual

Hook for customisable pubblication. The function can throw, exception will be caught by the monitoring thread

Reimplemented from dunedaq::datahandlinglibs::TaskRawDataProcessorModel< ReadoutTypeAdapter >.

Definition at line 366 of file TPCEthFrameProcessor.hxx.

{
  datahandlinglibs::opmon::FixedRateDataProcessorInfo info;
 
  info.set_num_seq_id_errors(m_seq_id_error_ctr.load());
  info.set_min_seq_id_jump(m_seq_id_min_jump.exchange(0));
  info.set_max_seq_id_jump(m_seq_id_max_jump.exchange(0));
 
  info.set_num_ts_errors(m_ts_error_ctr.load());
 
  this->publish(std::move(info));
 
  this->m_error_registry->log_registered_errors();
 
  if (this->m_post_processing_enabled) {
    auto now = std::chrono::high_resolution_clock::now();
    int num_new_tps = m_num_new_tps.exchange(0);
    int num_new_tps_suppressed_too_long = m_tps_suppressed_too_long.exchange(0);
    int num_new_tps_send_failed = m_tps_send_failed.exchange(0);
    double seconds = std::chrono::duration_cast<std::chrono::microseconds>(now - m_t0).count() / 1000000.;
    TLOG_DEBUG(TLVL_BOOKKEEPING) << "TP rate: " << std::to_string(num_new_tps / seconds / 1000.) << " [kHz]";
    TLOG_DEBUG(TLVL_BOOKKEEPING) << "Total new TPs: " << num_new_tps;
 
    datahandlinglibs::opmon::HitFindingInfo tp_info;
    tp_info.set_rate_tp_hits(num_new_tps / seconds / 1000.);
 
    tp_info.set_num_tps_sent(num_new_tps);
    tp_info.set_num_tps_suppressed_too_long(num_new_tps_suppressed_too_long);
    tp_info.set_num_tps_send_failed(num_new_tps_send_failed);
 
    this->publish(std::move(tp_info));
    // Find the channels with the top TP rates
    // Create a vector of pairs to store the map elements
    std::vector<std::pair<uint, int>> channel_tp_rate_vec(m_tp_channel_rate_map.begin(), m_tp_channel_rate_map.end());
    // Sort the vector in descending order of the value of the pairs
    sort(channel_tp_rate_vec.begin(), channel_tp_rate_vec.end(), [](std::pair<uint, int>& a, std::pair<uint, int>& b) {
      return a.second > b.second;
    });
    // Add the metrics to opmon
    // For convenience we are selecting only the top 10 elements
    if (channel_tp_rate_vec.size() != 0) {
      int top_highest_values = 10;
      if (channel_tp_rate_vec.size() < 10) {
        top_highest_values = channel_tp_rate_vec.size();
      }
      // datahandlinglibs::opmon::TPChannelsInfo channels_info;
      for (int i = 0; i < top_highest_values; i++) {
        datahandlinglibs::opmon::TPChannelInfo tpc_info;
        tpc_info.set_number_of_tps(channel_tp_rate_vec[i].second);
        tpc_info.set_channel_id(channel_tp_rate_vec[i].first);
        this->publish(std::move(tpc_info), { { "channel", std::to_string(channel_tp_rate_vec[i].first) } });
      }
    }
 
    // Reset the counter in the channel rate map
    for (auto& el : m_tp_channel_rate_map) {
      el.second = 0;
    }
    m_t0 = now;
 
#ifdef TPGLIBS_ENABLE_STATE_MONITORING
    if (m_tpg_metric_collect_enabled && m_state_harvester) {
      publish_processor_metric_to_opmon();
      publish_processor_metric_to_opmon_with_aggregation();
    }
#endif
  }
 
  inherited::generate_opmon_data();
}

scrap()

template<class ReadoutTypeAdapter>

void dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::scrap ( const appfwk::DAQModule::CommandData_t & args )

overridevirtual

Unconfigure.

Reimplemented from dunedaq::datahandlinglibs::TaskRawDataProcessorModel< ReadoutTypeAdapter >.

Definition at line 352 of file TPCEthFrameProcessor.hxx.

{
  scrap_source_and_geo_ids();
  scrap_preprocessing();
 
  if (this->m_post_processing_enabled) {
    scrap_postprocessing();
  }
 
  inherited::scrap(cfg);
}

scrap_channel_plane_numbers()

template<class ReadoutTypeAdapter>

void dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::scrap_channel_plane_numbers ( )

protected

scrap_find_tps()

template<class ReadoutTypeAdapter>

void dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::scrap_find_tps ( )

protected

scrap_postprocessing()

template<class ReadoutTypeAdapter>

void dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::scrap_postprocessing ( )

protected

Definition at line 319 of file TPCEthFrameProcessor.hxx.

{
  // Channel-plane variables
  m_channel_mask_set.clear();
  m_plane_numbers_set.clear();
  m_channel_plane_numbers.clear();
  m_channel_plane_map.clear();
 
  // TP variables
  m_tp_generator->reset();
  m_tpg_configs.clear();
  m_plane_to_tpa_vector_map.clear();
  m_plane_to_tp_sink_map.clear();
 
  m_frame_limit_enabled = false;
  m_tp_limit_enabled = false;
  m_current_tp_count = 0;
  m_tp_count_limit = 0;
  m_frame_count_at_last_send = 0;
 
  // OpMon variables
  m_tpg_metric_collect_enabled = false;
  m_metric_collect_opmon_period = 128;
  m_tp_channel_rate_map.clear();
  m_num_new_tps.exchange(0);
  m_tps_suppressed_too_long.exchange(0);
  m_tps_send_failed.exchange(0);
  m_frame_counter.exchange(0);
  m_t0 = std::chrono::high_resolution_clock::now();
}

scrap_preprocessing()

template<class ReadoutTypeAdapter>

void dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::scrap_preprocessing ( )

protected

Definition at line 286 of file TPCEthFrameProcessor.hxx.

{
  m_emulator_mode = false;
  m_first_frame = true;
 
  // Timestamps.
  m_previous_ts = 0;
  m_current_ts = 0;
 
  m_pattern_generator_previous_ts = 0;
  m_pattern_generator_current_ts = 0;
 
  m_first_ts_missmatch = true;
  m_ts_problem_reported = false;
  m_ts_error_state = false;
  m_ts_error_ctr = 0;
 
  // Sequence ID.
  m_previous_seq_id = 0;
  m_current_seq_id = 0;
 
  m_first_seq_id_mismatch = true;
  m_seq_id_problem_reported = false;
  m_seq_id_error_state = false;
  m_seq_id_error_ctr = 0;
  m_seq_id_min_jump = 0;
  m_seq_id_max_jump = 0;
 
  // The preprocessing tasks scrap is handled by inherited::scrap().
}

scrap_source_and_geo_ids()

template<class ReadoutTypeAdapter>

void dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::scrap_source_and_geo_ids ( )

protected

Definition at line 274 of file TPCEthFrameProcessor.hxx.

{
  m_sourceid = daqdataformats::SourceID();
 
  m_det_id = 0;
  m_crate_id = 0;
  m_slot_id = 0;
  m_stream_id = 0;
}

sequence_check()

template<class ReadoutTypeAdapter>

void dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::sequence_check ( frameptr fp )

protected

Pipeline Stage 1.: Check proper sequence id increments in DAQ Eth header

Pipeline Stage 1.: Check proper timestamp increments in TPC frame

Definition at line 605 of file TPCEthFrameProcessor.hxx.

{
  // Acquire timestamp
  auto wfptr = reinterpret_cast<tpcframeptr>(fp); // NOLINT
  m_current_seq_id = wfptr->daq_header.seq_id;
 
  // Check that the system is properly configured from the first frame.
  if (m_first_frame) [[unlikely]] {
    if (wfptr->daq_header.crate_id != m_crate_id || wfptr->daq_header.slot_id != m_slot_id ||
        wfptr->daq_header.stream_id != m_stream_id) {
      ers::error(LinkMisconfiguration(ERS_HERE,
                                      wfptr->daq_header.crate_id,
                                      wfptr->daq_header.slot_id,
                                      wfptr->daq_header.stream_id,
                                      m_crate_id,
                                      m_slot_id,
                                      m_stream_id));
    }
 
    m_first_frame = false;
  }
 
  // Check sequence id
  // Calculate the next sequence id (12 bits)
  uint16_t expected_seq_id = (m_previous_seq_id + fp->get_num_frames()) & 0xfff;
  int16_t delta_seq_id = m_current_seq_id - expected_seq_id;
  if (delta_seq_id > 0x800) {
    delta_seq_id -= 0x1000;
  } else if (delta_seq_id < -0x7ff) {
    delta_seq_id += 0x1000;
  }
 
  if (delta_seq_id == 0) {
    m_seq_id_error_state = false;
  } else {
    // uint16_t delta_seq_id = (m_current_seq_id-expected_seq_id);
    ++m_seq_id_error_ctr;
    m_seq_id_max_jump = std::max(delta_seq_id, m_seq_id_max_jump.load());
    m_seq_id_min_jump = std::min(delta_seq_id, m_seq_id_min_jump.load());
 
    if (m_first_seq_id_mismatch) { // log once
      TLOG_DEBUG(TLVL_BOOKKEEPING) << "First sequence id MISMATCH! -> | previous: " << std::to_string(m_previous_seq_id)
                                   << " current: " + std::to_string(m_current_seq_id);
      m_first_seq_id_mismatch = false;
    } else {
      if (!m_seq_id_error_state) {
        this->m_error_registry->add_error(
          "Sequence ID jump", datahandlinglibs::FrameErrorRegistry::ErrorInterval(expected_seq_id, m_current_seq_id));
        m_seq_id_error_state = true;
      }
    }
  }
 
  if (m_seq_id_error_ctr > 1000) {
    if (!m_seq_id_problem_reported) {
      TLOG() << "*** Data Integrity ERROR *** Sequence ID continuity is completely broken! "
             << "Something is wrong with the FE source or with the configuration!";
      m_seq_id_problem_reported = true;
    }
  }
 
  m_previous_seq_id = m_current_seq_id;
}

start()

template<class ReadoutTypeAdapter>

void dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::start ( const appfwk::DAQModule::CommandData_t & args )

overridevirtual

Start operation.

Reimplemented from dunedaq::datahandlinglibs::TaskRawDataProcessorModel< ReadoutTypeAdapter >.

Definition at line 20 of file TPCEthFrameProcessor.hxx.

{
  // Reset software TPG resources
  if (this->m_post_processing_enabled) {
    m_tps_suppressed_too_long = 0;
    m_tps_send_failed = 0;
  }
 
  // Reset timestamp check
  m_previous_ts = 0;
  m_current_ts = 0;
  m_first_ts_missmatch = true;
  m_ts_problem_reported = false;
  m_ts_error_state = false;
  m_ts_error_ctr = 0;
 
  m_first_seq_id_mismatch = true;
  m_seq_id_problem_reported = false;
  m_seq_id_error_state = false;
  m_seq_id_error_ctr = 0;
 
  // Reset stats
  m_t0 = std::chrono::high_resolution_clock::now();
  m_num_new_tps.exchange(0);
 
#ifdef TPGLIBS_ENABLE_STATE_MONITORING
  if (m_state_harvester && m_tpg_metric_collect_enabled) {
    m_state_harvester->start_collection_thread();
  }
#endif
  inherited::start(args);
}

stop()

template<class ReadoutTypeAdapter>

void dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::stop ( const appfwk::DAQModule::CommandData_t & args )

overridevirtual

Stop operation.

Reimplemented from dunedaq::datahandlinglibs::TaskRawDataProcessorModel< ReadoutTypeAdapter >.

Definition at line 55 of file TPCEthFrameProcessor.hxx.

{
  inherited::stop(args);
  if (this->m_post_processing_enabled) {
#ifdef TPGLIBS_ENABLE_STATE_MONITORING
    if (m_state_harvester) {
      m_state_harvester->stop_collection_thread();
    }
#endif
    // Clears the pipelines and resets with the given configs.
    m_tp_generator->configure(m_tpg_configs, m_channel_plane_numbers, ReadoutTypeAdapter::samples_tick_difference);
  }
}

timestamp_check()

template<class ReadoutTypeAdapter>

void dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::timestamp_check ( frameptr fp )

protected

Pipeline Stage 1.: Check proper timestamp increments in DAQ Eth header

Pipeline Stage 1.: Check proper timestamp increments in TPC frame

Definition at line 674 of file TPCEthFrameProcessor.hxx.

{
 
  uint16_t tpceth_tick_difference = ReadoutTypeAdapter::expected_tick_difference;
  uint16_t tpceth_frame_tick_difference = tpceth_tick_difference * fp->get_num_frames();
 
  auto wfptr = reinterpret_cast<tpcframeptr>(fp); // NOLINT
  m_current_ts = wfptr->get_timestamp();
 
  // Check timestamp
  if (m_previous_ts > 0 && m_current_ts - m_previous_ts != tpceth_frame_tick_difference) [[unlikely]] {
    ++m_ts_error_ctr;
    if (m_first_ts_missmatch) { // log once
      TLOG_DEBUG(TLVL_BOOKKEEPING) << "First timestamp MISMATCH! -> | previous: " << std::to_string(m_previous_ts)
                                   << " current: " + std::to_string(m_current_ts);
      m_first_ts_missmatch = false;
    } else {
      if (!m_ts_error_state) {
        this->m_error_registry->add_error("Timestamp jump",
                                          datahandlinglibs::FrameErrorRegistry::ErrorInterval(
                                            m_previous_ts + tpceth_frame_tick_difference, m_current_ts));
        m_ts_error_state = true;
      }
    }
  } else {
    m_ts_error_state = false;
  }
 
  if (m_ts_error_ctr > 1000) {
    if (!m_ts_problem_reported) {
      TLOG() << "*** Data Integrity ERROR *** Timestamp continuity is completely broken! "
             << "Something is wrong with the FE source or with the configuration!";
      m_ts_problem_reported = true;
    }
  }
 
  m_previous_ts = m_current_ts;
  this->m_last_processed_daq_ts = m_current_ts;
}

Member Data Documentation

m_channel_mask_set

template<class ReadoutTypeAdapter>

std::set<unsigned int> dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_channel_mask_set

protected

Definition at line 181 of file TPCEthFrameProcessor.hpp.

m_channel_plane_map

template<class ReadoutTypeAdapter>

std::unordered_map<trgdataformats::channel_t, unsigned int> dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_channel_plane_map

protected

Definition at line 184 of file TPCEthFrameProcessor.hpp.

m_channel_plane_numbers

template<class ReadoutTypeAdapter>

std::vector<std::pair<trgdataformats::channel_t, int16_t> > dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_channel_plane_numbers

protected

Definition at line 183 of file TPCEthFrameProcessor.hpp.

m_crate_id

template<class ReadoutTypeAdapter>

uint32_t dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_crate_id

protected

Definition at line 202 of file TPCEthFrameProcessor.hpp.

m_current_seq_id

template<class ReadoutTypeAdapter>

uint16_t dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_current_seq_id = 0

protected

Definition at line 151 of file TPCEthFrameProcessor.hpp.

m_current_tp_count

template<class ReadoutTypeAdapter>

uint32_t dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_current_tp_count = 0

protected

Definition at line 174 of file TPCEthFrameProcessor.hpp.

m_current_ts

template<class ReadoutTypeAdapter>

dunedaq::daqdataformats::timestamp_t dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_current_ts = 0

protected

Definition at line 139 of file TPCEthFrameProcessor.hpp.

m_det_id

template<class ReadoutTypeAdapter>

uint32_t dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_det_id

protected

Definition at line 201 of file TPCEthFrameProcessor.hpp.

m_emulator_mode

template<class ReadoutTypeAdapter>

bool dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_emulator_mode = false

protected

Definition at line 134 of file TPCEthFrameProcessor.hpp.

m_first_frame

template<class ReadoutTypeAdapter>

bool dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_first_frame = true

protected

Definition at line 135 of file TPCEthFrameProcessor.hpp.

m_first_seq_id_mismatch

template<class ReadoutTypeAdapter>

bool dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_first_seq_id_mismatch = true

protected

Definition at line 153 of file TPCEthFrameProcessor.hpp.

m_first_ts_missmatch

template<class ReadoutTypeAdapter>

bool dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_first_ts_missmatch = true

protected

Definition at line 144 of file TPCEthFrameProcessor.hpp.

m_frame_count_at_last_send

template<class ReadoutTypeAdapter>

uint32_t dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_frame_count_at_last_send = 0

protected

Definition at line 175 of file TPCEthFrameProcessor.hpp.

m_frame_count_limit

template<class ReadoutTypeAdapter>

uint32_t dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_frame_count_limit = 0

protected

Definition at line 173 of file TPCEthFrameProcessor.hpp.

m_frame_counter

template<class ReadoutTypeAdapter>

std::atomic<uint64_t> dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_frame_counter { 0 }

protected

Definition at line 198 of file TPCEthFrameProcessor.hpp.

m_frame_limit_enabled

template<class ReadoutTypeAdapter>

bool dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_frame_limit_enabled = false

protected

Definition at line 178 of file TPCEthFrameProcessor.hpp.

m_metric_collect_opmon_period

template<class ReadoutTypeAdapter>

uint32_t dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_metric_collect_opmon_period { 128 }

protected

Definition at line 188 of file TPCEthFrameProcessor.hpp.

m_num_new_tps

template<class ReadoutTypeAdapter>

std::atomic<uint64_t> dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_num_new_tps { 0 }

protected

Definition at line 192 of file TPCEthFrameProcessor.hpp.

m_pattern_generator_current_ts

template<class ReadoutTypeAdapter>

dunedaq::daqdataformats::timestamp_t dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_pattern_generator_current_ts = 0

protected

Definition at line 142 of file TPCEthFrameProcessor.hpp.

m_pattern_generator_previous_ts

template<class ReadoutTypeAdapter>

dunedaq::daqdataformats::timestamp_t dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_pattern_generator_previous_ts = 0

protected

Definition at line 141 of file TPCEthFrameProcessor.hpp.

m_plane_numbers_set

template<class ReadoutTypeAdapter>

std::set<unsigned int> dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_plane_numbers_set

protected

Definition at line 182 of file TPCEthFrameProcessor.hpp.

m_plane_to_tp_sink_map

template<class ReadoutTypeAdapter>

std::unordered_map<unsigned int, std::shared_ptr<iomanager::SenderConcept<std::vector<trigger::TriggerPrimitiveTypeAdapter> > > > dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_plane_to_tp_sink_map

protected

Definition at line 170 of file TPCEthFrameProcessor.hpp.

m_plane_to_tpa_vector_map

template<class ReadoutTypeAdapter>

std::unordered_map<unsigned int, std::vector<trigger::TriggerPrimitiveTypeAdapter> > dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_plane_to_tpa_vector_map

protected

Definition at line 167 of file TPCEthFrameProcessor.hpp.

m_previous_seq_id

template<class ReadoutTypeAdapter>

uint16_t dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_previous_seq_id = 0

protected

Definition at line 150 of file TPCEthFrameProcessor.hpp.

m_previous_ts

template<class ReadoutTypeAdapter>

dunedaq::daqdataformats::timestamp_t dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_previous_ts = 0

protected

Definition at line 138 of file TPCEthFrameProcessor.hpp.

m_seq_id_error_ctr

template<class ReadoutTypeAdapter>

std::atomic<uint64_t> dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_seq_id_error_ctr { 0 }

protected

Definition at line 156 of file TPCEthFrameProcessor.hpp.

m_seq_id_error_state

template<class ReadoutTypeAdapter>

bool dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_seq_id_error_state = false

protected

Definition at line 155 of file TPCEthFrameProcessor.hpp.

m_seq_id_max_jump

template<class ReadoutTypeAdapter>

std::atomic<int16_t> dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_seq_id_max_jump { 0 }

protected

Definition at line 158 of file TPCEthFrameProcessor.hpp.

m_seq_id_min_jump

template<class ReadoutTypeAdapter>

std::atomic<int16_t> dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_seq_id_min_jump { 0 }

protected

Definition at line 157 of file TPCEthFrameProcessor.hpp.

m_seq_id_problem_reported

template<class ReadoutTypeAdapter>

bool dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_seq_id_problem_reported = false

protected

Definition at line 154 of file TPCEthFrameProcessor.hpp.

m_slot_id

template<class ReadoutTypeAdapter>

uint32_t dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_slot_id

protected

Definition at line 203 of file TPCEthFrameProcessor.hpp.

m_sourceid

template<class ReadoutTypeAdapter>

daqdataformats::SourceID dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_sourceid

protected

Definition at line 206 of file TPCEthFrameProcessor.hpp.

m_stream_id

template<class ReadoutTypeAdapter>

uint32_t dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_stream_id

protected

Definition at line 204 of file TPCEthFrameProcessor.hpp.

m_t0

template<class ReadoutTypeAdapter>

std::chrono::time_point<std::chrono::high_resolution_clock> dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_t0

protected

Definition at line 196 of file TPCEthFrameProcessor.hpp.

m_tp_channel_rate_map

template<class ReadoutTypeAdapter>

std::map<uint, std::atomic<int> > dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_tp_channel_rate_map

protected

Definition at line 190 of file TPCEthFrameProcessor.hpp.

m_tp_count_limit

template<class ReadoutTypeAdapter>

uint32_t dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_tp_count_limit = 0

protected

Definition at line 172 of file TPCEthFrameProcessor.hpp.

m_tp_generator

template<class ReadoutTypeAdapter>

std::unique_ptr<tpglibs::TPGenerator> dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_tp_generator

protected

Definition at line 161 of file TPCEthFrameProcessor.hpp.

m_tp_limit_enabled

template<class ReadoutTypeAdapter>

bool dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_tp_limit_enabled = false

protected

Definition at line 177 of file TPCEthFrameProcessor.hpp.

m_tpg_configs

template<class ReadoutTypeAdapter>

std::vector<std::pair<std::string, nlohmann::json> > dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_tpg_configs

protected

Definition at line 165 of file TPCEthFrameProcessor.hpp.

m_tpg_metric_collect_enabled

template<class ReadoutTypeAdapter>

bool dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_tpg_metric_collect_enabled { false }

protected

Definition at line 187 of file TPCEthFrameProcessor.hpp.

m_tps_send_failed

template<class ReadoutTypeAdapter>

std::atomic<uint64_t> dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_tps_send_failed { 0 }

protected

Definition at line 194 of file TPCEthFrameProcessor.hpp.

m_tps_suppressed_too_long

template<class ReadoutTypeAdapter>

std::atomic<uint64_t> dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_tps_suppressed_too_long { 0 }

protected

Definition at line 193 of file TPCEthFrameProcessor.hpp.

m_ts_error_ctr

template<class ReadoutTypeAdapter>

std::atomic<uint64_t> dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_ts_error_ctr { 0 }

protected

Definition at line 147 of file TPCEthFrameProcessor.hpp.

m_ts_error_state

template<class ReadoutTypeAdapter>

bool dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_ts_error_state = false

protected

Definition at line 146 of file TPCEthFrameProcessor.hpp.

m_ts_problem_reported

template<class ReadoutTypeAdapter>

bool dunedaq::fdreadoutlibs::TPCEthFrameProcessor< ReadoutTypeAdapter >::m_ts_problem_reported = false

protected

Definition at line 145 of file TPCEthFrameProcessor.hpp.

---

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

• /github/workspace/dunedaq/sourcecode/fdreadoutlibs/include/fdreadoutlibs/TPCEthFrameProcessor.hpp
• /github/workspace/dunedaq/sourcecode/fdreadoutlibs/include/fdreadoutlibs/detail/TPCEthFrameProcessor.hxx