tpglibs::NaiveFrugalPedestalSubtractProcessor Class Reference

Naive signal processor: Estimates the pedestal and subtracts. More...

#include <NaiveFrugalPedestalSubtractProcessor.hpp>

Inheritance diagram for tpglibs::NaiveFrugalPedestalSubtractProcessor:

Collaboration diagram for tpglibs::NaiveFrugalPedestalSubtractProcessor:

Public Member Functions
naive_array_t	process (const naive_array_t &signal) override
	Estimate the pedestal using the given signal and subtract.
void	configure (const nlohmann::json &config, const int16_t *plane_numbers) override
	Configure the accumulation limit according to plane number.
Public Member Functions inherited from tpglibs::AbstractProcessor< std::array< int16_t, 16 > >
virtual	~AbstractProcessor ()=default
ProcessorInternalStateBufferManager< std::array< int16_t, 16 > > *	_get_internal_state_buffer_manager ()
ProcessorInternalStateNameRegistry< std::array< int16_t, 16 > > *	_get_internal_state_name_registry ()
virtual void	configure_internal_state_collection (const nlohmann::json &config)
	Configure common internal state collection parameters.
void	set_next_processor (std::shared_ptr< AbstractProcessor< std::array< int16_t, 16 > > > next_processor)
	Setter for next processor.
std::shared_ptr< AbstractProcessor< std::array< int16_t, 16 > > >	get_next_processor ()
	Getter for next processor.
virtual std::vector< std::string >	get_requested_internal_state_names () const
	Get the names of requested internal states (delegates to registry).
virtual ProcessorMetricArray< std::array< int16_t, 16 > >	read_internal_states_as_integer_array ()

Private Attributes
naive_array_t	m_pedestal {}
	Vector of estimated pedestals for each channel.
naive_array_t	m_accum {}
	Vector of counts that a channel's signal was above or below m_pedestal.
int16_t	m_accum_limit {10}
	Count limit before committing to a pedestal shift.

Additional Inherited Members
Public Types inherited from tpglibs::NaiveProcessor
using	naive_array_t = std::array<int16_t, 16>
	The naive version uses a standard array instead of __m256i.
Public Types inherited from tpglibs::AbstractProcessor< std::array< int16_t, 16 > >
using	signal_type_t
	Signal type to process on. General __m256i.
Protected Attributes inherited from tpglibs::AbstractProcessor< std::array< int16_t, 16 > >
ProcessorInternalStateBufferManager< std::array< int16_t, 16 > >	m_internal_state_buffer_manager
ProcessorInternalStateNameRegistry< std::array< int16_t, 16 > >	m_internal_state_name_registry
std::atomic< uint64_t >	m_samples
bool	m_collect_internal_state_flag
uint64_t	m_sample_period

Detailed Description

Naive signal processor: Estimates the pedestal and subtracts.

Given a history of signals, this estimates the pedestal by shifting the current estimate when it is wrong in the same direction m_accum_limit times. For example, if the input signal is greater (less) than the estimated pedestal 10 (configurable) times in a row, then increment (decrement) the pedestal.

Definition at line 22 of file NaiveFrugalPedestalSubtractProcessor.hpp.

Member Function Documentation

configure()

void tpglibs::NaiveFrugalPedestalSubtractProcessor::configure ( const nlohmann::json & config, const int16_t * plane_numbers )

overridevirtual

Configure the accumulation limit according to plane number.

Parameters

config	JSON config for the accumulation limits per plane.
plane_numbers	Array of plane numbers. Gives the channels to apply the accumulation limit.

Implements tpglibs::AbstractProcessor< std::array< int16_t, 16 > >.

Definition at line 15 of file NaiveFrugalPedestalSubtractProcessor.cpp.

                                                                                                             {
  // Configure common metric collection parameters
  // Register pointers to the ACTUAL member variables, not copies
  // Use shared_ptr with no-op deleter to avoid double-free
  m_internal_state_name_registry.register_internal_state("pedestal", 
    std::shared_ptr<naive_array_t>(&m_pedestal, [](auto*){}));
  m_internal_state_name_registry.register_internal_state("accum", 
    std::shared_ptr<naive_array_t>(&m_accum, [](auto*){}));
    
  configure_internal_state_collection(config);
  
  m_accum_limit = config["accum_limit"];
}

process()

NaiveFrugalPedestalSubtractProcessor::naive_array_t tpglibs::NaiveFrugalPedestalSubtractProcessor::process ( const naive_array_t & signal )

overridevirtual

Estimate the pedestal using the given signal and subtract.

Parameters

signal

A vector of channel signals.

Returns

The input signal minus the estimated pedestal.

Reimplemented from tpglibs::NaiveProcessor.

Definition at line 30 of file NaiveFrugalPedestalSubtractProcessor.cpp.

                                                                         {
  // Update sample counter and write internal states to buffer for harvesting
  m_samples++;
  if (m_collect_internal_state_flag && (m_samples % m_sample_period == 0)) {
    m_internal_state_buffer_manager.write_to_active_buffer();
  }
 
  naive_array_t subtracted_signal;
  for (int i = 0; i < 16; i++) {
    // Increment if above.
    if (signal[i] > m_pedestal[i])
      m_accum[i]++;
 
    // Decrement if below.
    if (signal[i] < m_pedestal[i])
      m_accum[i]--;
 
    // Increment pedestal if we've hit the top limit.
    if (m_accum[i] > m_accum_limit) {
      m_pedestal[i]++;
      m_accum[i] = 0;
    }
 
    // Decrement pedestal if we've hit the low limit.
    if (m_accum[i] < -1*m_accum_limit) {
      m_pedestal[i]--;
      m_accum[i] = 0;
    }
 
    subtracted_signal[i] = signal[i] - m_pedestal[i];
  }
 
  return NaiveProcessor::process(subtracted_signal);
}

Member Data Documentation

m_accum

naive_array_t tpglibs::NaiveFrugalPedestalSubtractProcessor::m_accum {}

private

Vector of counts that a channel's signal was above or below m_pedestal.

Definition at line 27 of file NaiveFrugalPedestalSubtractProcessor.hpp.

{};

m_accum_limit

int16_t tpglibs::NaiveFrugalPedestalSubtractProcessor::m_accum_limit {10}

private

Count limit before committing to a pedestal shift.

Definition at line 30 of file NaiveFrugalPedestalSubtractProcessor.hpp.

{10};

m_pedestal

naive_array_t tpglibs::NaiveFrugalPedestalSubtractProcessor::m_pedestal {}

private

Vector of estimated pedestals for each channel.

Definition at line 24 of file NaiveFrugalPedestalSubtractProcessor.hpp.

{};

---

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

• /github/workspace/dunedaq/sourcecode/tpglibs/include/tpglibs/NaiveFrugalPedestalSubtractProcessor.hpp
• /github/workspace/dunedaq/sourcecode/tpglibs/src/NaiveFrugalPedestalSubtractProcessor.cpp