opdet::SharedWaveformBaseline Class Reference

Extracts a common baseline from waveforms. More...

#include <SharedWaveformBaseline.h>

Classes
struct	BaselineInfo_t
	Type for algorithm result. More...
struct	Params_t
	Algorithm configuration parameters. More...

Public Member Functions
	SharedWaveformBaseline (Params_t params, std::string logCategory)
BaselineInfo_t	operator() (std::vector< raw::OpDetWaveform const * > const &waveforms) const
	Returns a common baseline from all the specified waveforms. More...
Params_t const &	parameters () const
	Returns the set of configuration parameters of this algorithm. More...

Private Attributes
Params_t	fParams
	Algorithm parameters. More...
std::string	fLogCategory
	Name of stream category for console messages. More...

Detailed Description

Extracts a common baseline from waveforms.

This algorithm processes a group of waveforms at a time, and returns a common baseline for them. The baseline is learned by looking at a fixed size of the beginning of each of the waveforms, as follows:

1. the RMS of the first portion of each baseline is computed;
2. the median of the samples on the same samples is also computed;
3. an acceptance range is constructed, using the median of the sample as the center and nRMS times the median of the RMS as maximum distance from that center in either direction;
4. as a second pass, if in the first portion of a waveform there are at least nExcessSamples samples in a row that are outside of the acceptance range, that waveform is excluded;
5. all the samples in the first portion of the remaining waveforms are averaged to obtain the final estimation of the baseline; this last step should increase the resolution of the baseline beyond the median that was obtained at step 2.

The parameters are specified at algorithm construction time and are contained in the Params_t object.

Definition at line 52 of file SharedWaveformBaseline.h.

Constructor & Destructor Documentation

opdet::SharedWaveformBaseline::SharedWaveformBaseline ( Params_t  params, std::string  logCategory  )

inline

Definition at line 99 of file SharedWaveformBaseline.h.

                                                                :
      fParams{ std::move(params) }
    , fLogCategory{ std::move(logCategory) }
    {}

Member Function Documentation

auto opdet::SharedWaveformBaseline::operator()

(

std::vector< raw::OpDetWaveform const * > const &

waveforms

)

const

Returns a common baseline from all the specified waveforms.

Definition at line 120 of file SharedWaveformBaseline.cxx.

{
  if (waveforms.empty()) return {};
  
  //
  // first pass: find statistics
  //
  std::vector<raw::ADC_Count_t> samples;
  samples.reserve(fParams.nSample * waveforms.size());
  std::vector<double> RMSs;
  RMSs.reserve(waveforms.size());
  
  for (raw::OpDetWaveform const* waveform: waveforms) {
    
    mf::LogTrace{ fLogCategory } << "Now processing: " << waveformIntro(waveform);
    
    if (waveform->size() < fParams.nSample) {
      mf::LogTrace{ fLogCategory } << waveformIntro(waveform)
        << ": skipped because shorter than " << fParams.nSample
        << " samples";
      continue;
    }
    
    auto const begin = waveform->cbegin();
    auto const end = std::next(begin, fParams.nSample);
    
    lar::util::StatCollector<double> stats;
    for (auto it = begin; it != end; ++it) stats.add(*it);
    RMSs.push_back(stats.RMS());
    
    std::copy(waveform->begin(), waveform->end(), back_inserter(samples));
  } // for
  
  double const medRMS = median(RMSs.cbegin(), RMSs.cend());
  raw::ADC_Count_t const med = median(samples.cbegin(), samples.cend());
  
  mf::LogTrace{ fLogCategory } << "Stats of channel "
    << waveforms.front()->ChannelNumber() << " from "
    << fParams.nSample << " starting samples of " << waveforms.size()
    << " waveforms: median=" << med << " ADC, median RMS of each waveform="
    << medRMS << " ADC";
  
  //
  // collect the samples
  //
  raw::ADC_Count_t const aboveThreshold
    = med + static_cast<raw::ADC_Count_t>(std::round(medRMS * fParams.nRMS));
  raw::ADC_Count_t const belowThreshold
    = med - static_cast<raw::ADC_Count_t>(std::round(medRMS * fParams.nRMS));
  
  auto const sampleOutOfBoundary
    = [this, aboveThreshold, belowThreshold](auto begin, auto end)
    {
      return findOutOfBoundary(begin, end,
                               belowThreshold, aboveThreshold,
                               fParams.nExcessSamples, fParams.nExcessSamples);
    };
  
  lar::util::StatCollector<double> stats;
  unsigned int nUsedWaveforms = 0U;
  for (raw::OpDetWaveform const* waveform: waveforms) {
    
    auto const begin = waveform->cbegin();
    auto const end = std::next(begin, fParams.nSample);
    
    //
    // check whether to use this waveform
    //
    auto const firstExcess = sampleOutOfBoundary(begin, end);
    if (firstExcess != end) {
      
      mf::LogTrace log { fLogCategory };
      log
        << waveformIntro(waveform) << " has " << fParams.nExcessSamples
        << " samples in a row out of [ " << belowThreshold << " ; "
        << aboveThreshold << " ] ADC starting at sample #"
        << (firstExcess - begin) << ":";
      for (
        auto it = firstExcess; it != firstExcess + fParams.nExcessSamples; ++it
      )
        log << " " << *it;
      
      // should we try to recover part of the waveform here? e.g.
      /*
      if (((firstExcess - begin) < fParams.nSample*3/5) || (waveforms.size() >= 5))
        continue;
      end = begin + fParams.nSample / 2;
       */
      
    } // if
    
    //
    // include it
    //
    ++nUsedWaveforms;
    stats.add_unweighted(begin, end);
    
  } // for
  
  return {
      stats.Average()           // baseline
    , medRMS                    // RMS
    , nUsedWaveforms            // nWaveforms
    , (unsigned int) stats.N()  // nSamples
    };
  
} // opdet::SharedWaveformBaseline::operator()

Params_t const& opdet::SharedWaveformBaseline::parameters ( ) const

inline

Returns the set of configuration parameters of this algorithm.

Definition at line 109 of file SharedWaveformBaseline.h.

{ return fParams; }

Member Data Documentation

std::string opdet::SharedWaveformBaseline::fLogCategory

private

Name of stream category for console messages.

Definition at line 114 of file SharedWaveformBaseline.h.

Params_t opdet::SharedWaveformBaseline::fParams

private

Algorithm parameters.

Definition at line 112 of file SharedWaveformBaseline.h.

---

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

• SharedWaveformBaseline.h
• SharedWaveformBaseline.cxx