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::NaiveProcessor
Public Member Functions inherited from tpglibs::AbstractProcessor< std::array< int16_t, 16 > >
virtual	~AbstractProcessor ()=default
void	set_next_processor (std::shared_ptr< AbstractProcessor< std::array< int16_t, 16 > > > next_processor)
	Setter for next processor.

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.

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.

                                                                                                             {
  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 20 of file NaiveFrugalPedestalSubtractProcessor.cpp.

                                                                         {
  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