tpglibs::AVXFrugalPedestalSubtractProcessor Class Reference

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

#include <AVXFrugalPedestalSubtractProcessor.hpp>

Inheritance diagram for tpglibs::AVXFrugalPedestalSubtractProcessor:

Collaboration diagram for tpglibs::AVXFrugalPedestalSubtractProcessor:

Public Member Functions
	AVXFrugalPedestalSubtractProcessor ()=default
	~AVXFrugalPedestalSubtractProcessor () noexcept=default
__m256i	process (const __m256i &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::AVXProcessor
Public Member Functions inherited from tpglibs::AbstractProcessor< __m256i >
virtual	~AbstractProcessor ()=default
ProcessorInternalStateBufferManager< __m256i > *	_get_internal_state_buffer_manager ()
ProcessorInternalStateNameRegistry< __m256i > *	_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< __m256i > > next_processor)
	Setter for next processor.
std::shared_ptr< AbstractProcessor< __m256i > >	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 ()

Protected Attributes
__m256i	m_pedestal = _mm256_set1_epi16(0x4000)
	Vector of estimated pedestals for each channel.
__m256i	m_accum = _mm256_setzero_si256()
	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.
Protected Attributes inherited from tpglibs::AbstractProcessor< __m256i >
ProcessorInternalStateBufferManager< __m256i >	m_internal_state_buffer_manager
ProcessorInternalStateNameRegistry< __m256i >	m_internal_state_name_registry
std::atomic< uint64_t >	m_samples
bool	m_collect_internal_state_flag
uint64_t	m_sample_period

Additional Inherited Members
Public Types inherited from tpglibs::AbstractProcessor< __m256i >
using	signal_type_t
	Signal type to process on. General __m256i.

Detailed Description

AVX 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 23 of file AVXFrugalPedestalSubtractProcessor.hpp.

Constructor & Destructor Documentation

AVXFrugalPedestalSubtractProcessor()

tpglibs::AVXFrugalPedestalSubtractProcessor::AVXFrugalPedestalSubtractProcessor ( )

default

~AVXFrugalPedestalSubtractProcessor()

tpglibs::AVXFrugalPedestalSubtractProcessor::~AVXFrugalPedestalSubtractProcessor ( )

defaultnoexcept

Member Function Documentation

configure()

void tpglibs::AVXFrugalPedestalSubtractProcessor::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< __m256i >.

Definition at line 15 of file AVXFrugalPedestalSubtractProcessor.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<__m256i>(&m_pedestal, [](auto*){}));
  m_internal_state_name_registry.register_internal_state("accum", 
    std::shared_ptr<__m256i>(&m_accum, [](auto*){}));
    
  configure_internal_state_collection(config);
  
  m_accum_limit = config["accum_limit"];
}

process()

__m256i tpglibs::AVXFrugalPedestalSubtractProcessor::process ( const __m256i & 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::AVXProcessor.

Definition at line 29 of file AVXFrugalPedestalSubtractProcessor.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();
  }
 
  // Find the channels that are above or below the pedestal.
  __m256i is_gt = _mm256_cmpgt_epi16(signal, m_pedestal);
  __m256i is_lt = _mm256_cmpgt_epi16(m_pedestal, signal);
 
  // Update m_accum.
  __m256i to_add = _mm256_setzero_si256();                                    // Assumes equal to pedestal.
  to_add = _mm256_blendv_epi8(to_add, _mm256_set1_epi16(1), is_gt);           // Set the above pedestal case.
  to_add = _mm256_blendv_epi8(to_add, _mm256_set1_epi16(-1), is_lt);          // Set the below pedestal case.
 
  m_accum = _mm256_add_epi16(m_accum, to_add);
 
  // Check the accum limit condition.
  is_gt = _mm256_cmpgt_epi16(m_accum, _mm256_set1_epi16(m_accum_limit));      // m_accum > +limit.
  is_lt = _mm256_cmpgt_epi16(_mm256_set1_epi16(-1*m_accum_limit), m_accum);   // m_accum < -limit = -limit > m_accum.
 
  to_add = _mm256_setzero_si256();
  to_add = _mm256_blendv_epi8(to_add, _mm256_set1_epi16(1), is_gt);
  to_add = _mm256_blendv_epi8(to_add, _mm256_set1_epi16(-1), is_lt);
 
  // Update pedestal.
  m_pedestal = _mm256_adds_epi16(m_pedestal, to_add);
 
  // Reset too high/low m_accum channels.
  __m256i need_reset = _mm256_or_si256(is_lt, is_gt);
  m_accum = _mm256_blendv_epi8(m_accum, _mm256_setzero_si256(), need_reset);
 
  return AVXProcessor::process(_mm256_sub_epi16(signal, m_pedestal));
}

Member Data Documentation

m_accum

__m256i tpglibs::AVXFrugalPedestalSubtractProcessor::m_accum = _mm256_setzero_si256()

protected

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

Definition at line 29 of file AVXFrugalPedestalSubtractProcessor.hpp.

m_accum_limit

int16_t tpglibs::AVXFrugalPedestalSubtractProcessor::m_accum_limit {10}

protected

Count limit before committing to a pedestal shift.

Definition at line 32 of file AVXFrugalPedestalSubtractProcessor.hpp.

{10};

m_pedestal

__m256i tpglibs::AVXFrugalPedestalSubtractProcessor::m_pedestal = _mm256_set1_epi16(0x4000)

protected

Vector of estimated pedestals for each channel.

Definition at line 26 of file AVXFrugalPedestalSubtractProcessor.hpp.

---

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

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