#include <DAPHNEEthFrameProcessor.hpp>

Inheritance diagram for dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor:

Collaboration diagram for dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor:

Public Types
using	inherited = datahandlinglibs::TaskRawDataProcessorModel<types::DAPHNEEthTypeAdapter>

using	frameptr = types::DAPHNEEthTypeAdapter*

using	daphneframeptr = dunedaq::fddetdataformats::DAPHNEEthFrame*

using	timestamp_t = std::uint64_t

using	constframeptr = const types::DAPHNEEthTypeAdapter*

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
	DAPHNEEthFrameProcessor (std::unique_ptr< datahandlinglibs::FrameErrorRegistry > &error_registry, bool post_processing_enabled)

void	conf (const appmodel::DataHandlerModule *conf) override
	Set the emulator mode, if active, timestamps of processed packets are overwritten with new ones.

void	start (const appfwk::DAQModule::CommandData_t &args) override
	Start operation.

void	stop (const appfwk::DAQModule::CommandData_t &args) override
	Stop operation.

Public Member Functions inherited from dunedaq::datahandlinglibs::TaskRawDataProcessorModel< types::DAPHNEEthTypeAdapter >
	TaskRawDataProcessorModel (std::unique_ptr< FrameErrorRegistry > &error_registry, bool post_processing_enabled)

	~TaskRawDataProcessorModel ()

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 &) override
	Unconfigure.

void	start (const appfwk::DAQModule::CommandData_t &) override
	Start operation.

void	stop (const appfwk::DAQModule::CommandData_t &) override
	Stop operation.

void	reset_last_daq_time ()

std::uint64_t	get_last_daq_time () override
	Get newest timestamp of last seen packet.

void	preprocess_item (types::DAPHNEEthTypeAdapter *item) override
	Preprocess one element.

void	postprocess_item (const types::DAPHNEEthTypeAdapter *item) override
	Postprocess one element.

void	add_preprocess_task (Task &&task)

void	add_postprocess_task (Task &&task)

void	invoke_all_preprocess_functions (types::DAPHNEEthTypeAdapter *item)

void	launch_all_preprocess_functions (types::DAPHNEEthTypeAdapter *item)

Public Member Functions inherited from dunedaq::datahandlinglibs::RawDataProcessorConcept< types::DAPHNEEthTypeAdapter >
	RawDataProcessorConcept ()

	RawDataProcessorConcept (const RawDataProcessorConcept &)=delete
	RawDataProcessorConcept is not copy-constructible.

	RawDataProcessorConcept (RawDataProcessorConcept &&)=delete
	RawDataProcessorConcept is not move-constructible.

virtual	~RawDataProcessorConcept ()

RawDataProcessorConcept &	operator= (const RawDataProcessorConcept &)=delete
	RawDataProcessorConcept is not copy-assginable.

RawDataProcessorConcept &	operator= (RawDataProcessorConcept &&)=delete
	RawDataProcessorConcept is not move-assignable.

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
virtual void	generate_opmon_data () override

void	timestamp_check (frameptr)

void	frame_error_check (frameptr)

void	extract_tps (constframeptr fp)

Protected Member Functions inherited from dunedaq::datahandlinglibs::TaskRawDataProcessorModel< types::DAPHNEEthTypeAdapter >
void	run_post_processing_thread (std::function< void(const types::DAPHNEEthTypeAdapter )> &function, folly::ProducerConsumerQueue< const types::DAPHNEEthTypeAdapter > &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
timestamp_t	m_previous_ts = 0

timestamp_t	m_current_ts = 0

bool	m_first_ts_fake = true

bool	m_first_ts_missmatch = true

bool	m_problem_reported = false

std::atomic< int >	m_ts_error_ctr { 0 }

Protected Attributes inherited from dunedaq::datahandlinglibs::TaskRawDataProcessorModel< types::DAPHNEEthTypeAdapter >
std::vector< std::function< void(types::DAPHNEEthTypeAdapter *)> >	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 types::DAPHNEEthTypeAdapter *)> >	m_post_process_functions

std::vector< std::unique_ptr< folly::ProducerConsumerQueue< const types::DAPHNEEthTypeAdapter * > > >	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

Private Attributes
std::shared_ptr< detchannelmaps::PDSChannelMap >	m_channel_map

std::vector< std::pair< trgdataformats::channel_t, int16_t > >	m_channel_plane_numbers

uint32_t	m_det_id

uint32_t	m_crate_id

uint32_t	m_slot_id

uint32_t	m_stream_id

std::set< unsigned int >	m_channel_mask_set

uint32_t	m_def_adc_intg_thresh = 0

std::shared_ptr< iomanager::SenderConcept< std::vector< trigger::TriggerPrimitiveTypeAdapter > > >	m_tp_sink

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::atomic< uint64_t >	m_frame_counter { 0 }

std::chrono::time_point< std::chrono::high_resolution_clock >	m_t0

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

Detailed Description

Definition at line 48 of file DAPHNEEthFrameProcessor.hpp.

Member Typedef Documentation

◆ constframeptr

using dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::constframeptr = const types::DAPHNEEthTypeAdapter*

Definition at line 56 of file DAPHNEEthFrameProcessor.hpp.

◆ daphneframeptr

using dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::daphneframeptr = dunedaq::fddetdataformats::DAPHNEEthFrame*

Definition at line 54 of file DAPHNEEthFrameProcessor.hpp.

◆ frameptr

using dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::frameptr = types::DAPHNEEthTypeAdapter*

Definition at line 53 of file DAPHNEEthFrameProcessor.hpp.

◆ inherited

using dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::inherited = datahandlinglibs::TaskRawDataProcessorModel<types::DAPHNEEthTypeAdapter>

Definition at line 52 of file DAPHNEEthFrameProcessor.hpp.

◆ timestamp_t

using dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::timestamp_t = std::uint64_t

Definition at line 55 of file DAPHNEEthFrameProcessor.hpp.

Constructor & Destructor Documentation

◆ DAPHNEEthFrameProcessor()

dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::DAPHNEEthFrameProcessor	(	std::unique_ptr< datahandlinglibs::FrameErrorRegistry > &	error_registry,
		bool	post_processing_enabled )

inlineexplicit

Definition at line 59 of file DAPHNEEthFrameProcessor.hpp.

60 : datahandlinglibs::TaskRawDataProcessorModel<types::DAPHNEEthTypeAdapter>(error_registry, post_processing_enabled)

61 {}

Member Function Documentation

◆ conf()

void dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::conf ( const appmodel::DataHandlerModule * conf )

overridevirtual

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

Implements dunedaq::datahandlinglibs::RawDataProcessorConcept< types::DAPHNEEthTypeAdapter >.

Definition at line 31 of file DAPHNEEthFrameProcessor.cpp.

{
  TLOG() << "Looking for TP sink...";
 
  for (auto output : conf->get_outputs()) {
    TLOG() << "On outputs... (" << output->UID() << "," << output->get_data_type() << ")";
    try {
      if (output->get_data_type() == "TriggerPrimitiveVector") {
         TLOG() << "Found TP sink.";
         m_tp_sink = get_iom_sender<std::vector<trigger::TriggerPrimitiveTypeAdapter>>(output->UID());
         TLOG() << " SINK INITIALIZED for TriggerPrimitives with UID : " << output->UID();
      }
    } catch (const ers::Issue& excpt) {
      ers::error(datahandlinglibs::ResourceQueueError(ERS_HERE, "tp", "DefaultRequestHandlerModel", excpt));
    }
  }
 
  TLOG() << "Registering processing tasks...";
  inherited::add_preprocess_task(std::bind(&DAPHNEEthFrameProcessor::timestamp_check, this, std::placeholders::_1));
 
  auto dp = conf->get_module_configuration()->get_data_processor();
  if (dp == nullptr) {
    TLOG()<< " PDS Data processor does not exist.";
  } else {
    auto proc_conf = dp->cast<appmodel::PDSRawDataProcessor>();
    if (proc_conf == nullptr) {
      TLOG()<< "PDS RawDataProcessor does not exist.";
    } else { 
      m_def_adc_intg_thresh = proc_conf-> get_default_adc_intg_thresh();
      
      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();
      }    
    
      m_channel_map = dunedaq::detchannelmaps::make_pds_map(proc_conf->get_channel_map());
      const std::vector<unsigned int> channel_mask_vec = proc_conf->get_channel_mask();
    
      for (int chan = 0; chan < 48; chan++) {// 40 physical PDS channel 8 not. 0->7 contain light info, 8,9, additional info. 10-17 light, 18,19 not etc...  
        trgdataformats::channel_t off_channel = m_channel_map->get_offline_channel_from_det_crate_slot_stream_chan(m_det_id, m_crate_id, m_slot_id, m_stream_id, chan);
        if (std::find(channel_mask_vec.begin(), channel_mask_vec.end(), off_channel) != channel_mask_vec.end())
          m_channel_mask_set.insert(off_channel);//m_channel_mask will be a vector fille with random chanel which need to be masked.
      }
      
      if (m_post_processing_enabled) { 
        // Extract TPs back as a pre-processing task, due to LatencyBuffer post-proc issues using SkipList.
        inherited::add_preprocess_task(std::bind(&DAPHNEEthFrameProcessor::extract_tps, this, std::placeholders::_1));
      }
    }
  }
 
  TLOG() << "Calling parent conf.";
  inherited::conf(conf);
}

◆ extract_tps()

void dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::extract_tps ( constframeptr fp )

protected

Definition at line 155 of file DAPHNEEthFrameProcessor.cpp.

{
 
  if (!fp || fp==nullptr){
    return;
  }
    
/*
  auto nonconstframeptr = const_cast<frameptr>(fp);
  auto df_ptr = reinterpret_cast<dunedaq::fddetdataformats::DAPHNEEthFrame*>((uint8_t*)nonconstframeptr); // NOLINT
  std::vector<trigger::TriggerPrimitiveTypeAdapter> ttpp;
 
  for (size_t i=0; i<types::kDAPHNENumFrames; i++)
  {
    for(size_t j=0; j<fddetdataformats::DAPHNEEthFrame::PeakDescriptorData::max_peaks;j++)
    {
      if(df_ptr[i].peaks_data.is_found(j))
      { 
        int ch =  m_channel_map->get_offline_channel_from_det_crate_slot_stream_chan(df_ptr[i].daq_header.det_id, df_ptr[i].daq_header.crate_id, df_ptr[i].daq_header.slot_id, df_ptr[i].daq_header.link_id, df_ptr[i].get_channel());
        if (std::binary_search(m_channel_mask_set.begin(), m_channel_mask_set.end(), ch)) continue;
        if (df_ptr[i].peaks_data.get_adc_integral(j) < m_def_adc_intg_thresh) continue;
 
 
        trigger::TriggerPrimitiveTypeAdapter tpa;
        tpa.tp = peak_to_tp(df_ptr[i],j);// this is the trigger primitive
        //check for timestamps that are due to frame timestamps ~ ts=0, and ignore these peaks
        if(tpa.tp.time_start > 0xFFFFFFFFFFFF0000 || tpa.tp.time_start < 0xFFFF){
          ers::warning(PDSPeakIgnored(ERS_HERE, tpa.tp.time_start, tpa.tp.channel, i, j));
          continue;
        }
        
        tpa.tp.detid = df_ptr->daq_header.det_id;
        ttpp.push_back(tpa);
      }
    }
  }
 
  int num_new_tps = ttpp.size();
  if (num_new_tps > 0) {
 
    const auto s_ts_begin = ttpp.front().tp.time_start;
    const auto channel_begin = ttpp.front().tp.channel;
    const auto s_ts_end = ttpp.back().tp.time_start;
    const auto channel_end = ttpp.back().tp.channel;      
    
    if (!m_tp_sink->try_send(std::move(ttpp), iomanager::Sender::s_no_block)) {
      ers::warning(FailedToSendTPVector(ERS_HERE, s_ts_begin, channel_begin, s_ts_end, channel_end));
      m_tps_send_failed += num_new_tps;
    } else {
      m_num_new_tps += num_new_tps;
    }
  }
*/
  return;
}

◆ frame_error_check()

void dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::frame_error_check ( frameptr )

protected

Pipeline Stage 2.: Check DAPHNE headers for error flags

Definition at line 149 of file DAPHNEEthFrameProcessor.cpp.

{
  // check error fields
}

◆ generate_opmon_data()

void dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::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< types::DAPHNEEthTypeAdapter >.

Definition at line 212 of file DAPHNEEthFrameProcessor.cpp.

                                             {
 
  //right now, just fill some basic tp info...
  if (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 = 0; // not relevant for PDS TPs
    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);
    
    publish(std::move(tp_info));
 
    m_t0 = now;
 
  }
 
 inherited::generate_opmon_data();
  
}

◆ start()

void dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::start ( const appfwk::DAQModule::CommandData_t & args )

overridevirtual

Start operation.

Implements dunedaq::datahandlinglibs::RawDataProcessorConcept< types::DAPHNEEthTypeAdapter >.

Definition at line 89 of file DAPHNEEthFrameProcessor.cpp.

{
  // Reset timestamp check
  m_previous_ts = 0;
  m_current_ts = 0;
  m_first_ts_missmatch = true;
  m_ts_error_ctr = 0;
 
  // Reset stats
  m_t0 = std::chrono::high_resolution_clock::now();
  m_num_new_tps.exchange(0);
 
  inherited::start(args);
}

◆ stop()

void dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::stop ( const appfwk::DAQModule::CommandData_t & args )

overridevirtual

Stop operation.

Implements dunedaq::datahandlinglibs::RawDataProcessorConcept< types::DAPHNEEthTypeAdapter >.

Definition at line 104 of file DAPHNEEthFrameProcessor.cpp.

{
  inherited::stop(args);
}

◆ timestamp_check()

void dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::timestamp_check ( frameptr fp )

protected

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

Definition at line 112 of file DAPHNEEthFrameProcessor.cpp.

{
 
/*
  for (size_t i=0; i<types::kDAPHNENumFrames; i++){
    auto df_ptr = reinterpret_cast<dunedaq::fddetdataformats::DAPHNEEthFrame*>(fp);
 
    if(df_ptr[i].get_timestamp() > 0xFFFFFFFFFFFF0000 || df_ptr[i].get_timestamp() < 0xFFFF){
      ers::warning(PDSUnphysicalFrameTimestamp(ERS_HERE, df_ptr[i].get_timestamp(), df_ptr[i].get_channel(), i));
      // Force the TS to 0
      df_ptr[i].daq_header.timestamp_1 = df_ptr[i].daq_header.timestamp_2 = 0;
    }
  }
*/
 
  // Acquire timestamp
  m_current_ts = fp->get_timestamp();
  uint64_t k_clock_frequency = 62500000; // NOLINT(build/unsigned)
  TLOG_DEBUG(TLVL_FRAME_RECEIVED) << "Received DAPHNE frame timestamp value of " << m_current_ts << " ticks (..." << std::fixed << std::setprecision(8) << (static_cast<double>(m_current_ts % (k_clock_frequency*1000)) / static_cast<double>(k_clock_frequency)) << " sec)";// NOLINT
 
 
  if (m_ts_error_ctr > 1000) {
    if (!m_problem_reported) {
      std::cout << "*** Data Integrity ERROR *** Timestamp continuity is completely broken! "
             << "Something is wrong with the FE source or with the configuration!\n";
      m_problem_reported = true;
    }
  }
 
  m_previous_ts = m_current_ts;
  m_last_processed_daq_ts = m_current_ts;
}

Member Data Documentation

◆ m_channel_map

std::shared_ptr<detchannelmaps::PDSChannelMap> dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::m_channel_map

private

Definition at line 95 of file DAPHNEEthFrameProcessor.hpp.

◆ m_channel_mask_set

std::set<unsigned int> dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::m_channel_mask_set

private

Definition at line 103 of file DAPHNEEthFrameProcessor.hpp.

◆ m_channel_plane_numbers

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

private

Definition at line 96 of file DAPHNEEthFrameProcessor.hpp.

◆ m_crate_id

uint32_t dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::m_crate_id

private

Definition at line 99 of file DAPHNEEthFrameProcessor.hpp.

◆ m_current_ts

timestamp_t dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::m_current_ts = 0

protected

Definition at line 84 of file DAPHNEEthFrameProcessor.hpp.

◆ m_def_adc_intg_thresh

uint32_t dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::m_def_adc_intg_thresh = 0

private

Definition at line 104 of file DAPHNEEthFrameProcessor.hpp.

◆ m_det_id

uint32_t dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::m_det_id

private

Definition at line 98 of file DAPHNEEthFrameProcessor.hpp.

◆ m_first_ts_fake

bool dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::m_first_ts_fake = true

protected

Definition at line 85 of file DAPHNEEthFrameProcessor.hpp.

◆ m_first_ts_missmatch

bool dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::m_first_ts_missmatch = true

protected

Definition at line 86 of file DAPHNEEthFrameProcessor.hpp.

◆ m_frame_counter

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

private

Definition at line 113 of file DAPHNEEthFrameProcessor.hpp.

113{ 0 };

◆ m_num_new_tps

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

private

Definition at line 110 of file DAPHNEEthFrameProcessor.hpp.

110{ 0 }; // NOLINT(build/unsigned)

◆ m_previous_ts

timestamp_t dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::m_previous_ts = 0

protected

Definition at line 83 of file DAPHNEEthFrameProcessor.hpp.

◆ m_problem_reported

bool dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::m_problem_reported = false

protected

Definition at line 87 of file DAPHNEEthFrameProcessor.hpp.

◆ m_slot_id

uint32_t dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::m_slot_id

private

Definition at line 100 of file DAPHNEEthFrameProcessor.hpp.

◆ m_stream_id

uint32_t dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::m_stream_id

private

Definition at line 101 of file DAPHNEEthFrameProcessor.hpp.

◆ m_t0

std::chrono::time_point<std::chrono::high_resolution_clock> dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::m_t0

private

Definition at line 115 of file DAPHNEEthFrameProcessor.hpp.

◆ m_tp_sink

std::shared_ptr<iomanager::SenderConcept<std::vector<trigger::TriggerPrimitiveTypeAdapter> > > dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::m_tp_sink

private

Definition at line 108 of file DAPHNEEthFrameProcessor.hpp.

◆ m_tps_send_failed

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

private

Definition at line 112 of file DAPHNEEthFrameProcessor.hpp.

112{ 0 };

◆ m_tps_suppressed_too_long

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

private

Definition at line 111 of file DAPHNEEthFrameProcessor.hpp.

111{ 0 };

◆ m_ts_error_ctr

std::atomic<int> dunedaq::fdreadoutlibs::DAPHNEEthFrameProcessor::m_ts_error_ctr { 0 }

protected

Definition at line 88 of file DAPHNEEthFrameProcessor.hpp.

88{ 0 };

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

/github/workspace/dunedaq/sourcecode/fdreadoutlibs/include/fdreadoutlibs/daphneeth/DAPHNEEthFrameProcessor.hpp
/github/workspace/dunedaq/sourcecode/fdreadoutlibs/src/daphneeth/DAPHNEEthFrameProcessor.cpp

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ constframeptr

◆ daphneframeptr

◆ frameptr

◆ inherited

◆ timestamp_t

Constructor & Destructor Documentation

◆ DAPHNEEthFrameProcessor()

Member Function Documentation

◆ conf()

◆ extract_tps()

◆ frame_error_check()

◆ generate_opmon_data()

◆ start()

◆ stop()

◆ timestamp_check()

Member Data Documentation

◆ m_channel_map

◆ m_channel_mask_set

◆ m_channel_plane_numbers

◆ m_crate_id

◆ m_current_ts

◆ m_def_adc_intg_thresh

◆ m_det_id

◆ m_first_ts_fake

◆ m_first_ts_missmatch

◆ m_frame_counter

◆ m_num_new_tps

◆ m_previous_ts

◆ m_problem_reported

◆ m_slot_id

◆ m_stream_id

◆ m_t0

◆ m_tp_sink

◆ m_tps_send_failed

◆ m_tps_suppressed_too_long

◆ m_ts_error_ctr