LArCalibTriggerAccumulator Class Reference

Helper class to accumulate calibration triggers. More...

#include <LArCalibTriggerAccumulator.h>

Collaboration diagram for LArCalibTriggerAccumulator:

Public Types
enum	ERRTYPE { NoError =0 , WrongNSamples , NumericOverflow }

Public Member Functions
	LArCalibTriggerAccumulator ()
	LArCalibTriggerAccumulator (const std::vector< uint64_t > &sampleSum, const std::vector< uint64_t > &sample2Sum, uint32_t m_nTrigger)
uint32_t	nTriggers () const
	return the number of triggers
size_t	nsamples () const
	return number of samples
const std::vector< uint64_t > &	sampleSum () const
	return a reference to a stl vector containing the sample-sums
const std::vector< uint64_t > &	sample2Sum () const
	return a reference to a stl vector containing the sum of the squares of the sample
ERRTYPE	add (const std::vector< short > &digits)
	accumulated individual set of digits.
template<class INTTYPE>
ERRTYPE	add (const std::vector< INTTYPE > &sampleSum, const std::vector< INTTYPE > &sample2Sum, const uint32_t nTrigger)
	accumulated pre-accumulated digits.
std::vector< float >	mean () const
	Calculates and returns the Mean value of each ADC sample.
std::vector< float >	RMS () const
	Calculates and returns the RMS value of each ADC sample.
double	mean (const size_t i) const
	Calculates and returns the Mean value for one ADC sample.
double	RMS (const size_t i) const
	Calculates and returns the RMS value for one ADC sample.

Private Attributes
std::vector< uint64_t >	m_sampleSum
	sum of samples
std::vector< uint64_t >	m_sample2Sum
	sum of squares of samples
uint32_t	m_nTrigger
	number of triggers

Detailed Description

Helper class to accumulate calibration triggers.

Contains sum of ADC counts and the sum of the squares of ADC counts So far only used by the Ramp builder. Could be used for Delay runs

Author

Walter Lampl

Definition at line 30 of file LArCalibTriggerAccumulator.h.

Member Enumeration Documentation

ERRTYPE

enum LArCalibTriggerAccumulator::ERRTYPE

Enumerator
NoError
WrongNSamples
NumericOverflow

Definition at line 46 of file LArCalibTriggerAccumulator.h.

               {
    NoError=0,
    WrongNSamples,
    NumericOverflow
  };

Constructor & Destructor Documentation

LArCalibTriggerAccumulator() [1/2]

LArCalibTriggerAccumulator::LArCalibTriggerAccumulator

(

)

Definition at line 8 of file LArCalibTriggerAccumulator.cxx.

: m_nTrigger(0) {}

LArCalibTriggerAccumulator() [2/2]

LArCalibTriggerAccumulator::LArCalibTriggerAccumulator	(	const std::vector< uint64_t > &	sampleSum,
		const std::vector< uint64_t > &	sample2Sum,
		uint32_t	m_nTrigger )

Definition at line 10 of file LArCalibTriggerAccumulator.cxx.

                                                  :
  m_sampleSum(sampleSum), m_sample2Sum(sample2Sum), m_nTrigger(nTrigger) {}

Member Function Documentation

add() [1/2]

template<class INTTYPE>

LArCalibTriggerAccumulator::ERRTYPE LArCalibTriggerAccumulator::add	(	const std::vector< INTTYPE > &	sampleSum,
		const std::vector< INTTYPE > &	sample2Sum,
		const uint32_t	nTrigger )

accumulated pre-accumulated digits.

Templated to allow 32 and 64 bit ints as input. Can return an error

Definition at line 97 of file LArCalibTriggerAccumulator.h.

                                                                                                   {
  const size_t nS=sampleSum.size();
  if (m_sampleSum.size()==0 && m_sample2Sum.size()==0) {
    m_sampleSum.resize(nS);
    m_sample2Sum.resize(nS);
  }
  else if (m_sampleSum.size()!=nS || m_sample2Sum.size()!=nS || sample2Sum.size()!=nS) 
    return WrongNSamples; //ERROR: Inconsistent number of samples
 
  for (size_t i=0;i<nS;++i) {
    if (m_sample2Sum[i]>=std::numeric_limits<uint64_t>::max()-sample2Sum[i]) {
      //ERROR: Numeric overflow!
      //Roll back changes:
      for (size_t j=0;j<i;++j) {
    m_sampleSum[j]-=sampleSum[j];
    m_sample2Sum[j]-=sample2Sum[j];
      }
      return NumericOverflow;
    }
    m_sampleSum[i]+=sampleSum[i];
    m_sample2Sum[i]+=sample2Sum[i];
  }
  m_nTrigger+=nTrigger;
 
  return NoError;
}

add() [2/2]

LArCalibTriggerAccumulator::ERRTYPE LArCalibTriggerAccumulator::add

(

const std::vector< short > &

digits

)

accumulated individual set of digits.

Can return an error

Definition at line 17 of file LArCalibTriggerAccumulator.cxx.

                                                                                                {
  const size_t nS=digits.size();
  if (nS==0) return WrongNSamples;
  
  if (m_sampleSum.empty() && m_sample2Sum.empty()) {
    m_sampleSum.resize(nS);
    m_sample2Sum.resize(nS);
  }
  else if (m_sampleSum.size()!=nS || m_sample2Sum.size()!=nS) 
    return WrongNSamples; //Inconsistent number of samples
 
  for (size_t i=0;i<nS;++i) {
    const uint32_t& dg=digits[i];
    if (m_sample2Sum[i]>=std::numeric_limits<uint64_t>::max()-dg) {
      //ERROR: Numeric overflow
      //Roll back changes:
      for (size_t j=0;j<i;++j) {
    m_sampleSum[j]-=digits[j];
    m_sample2Sum[j]-=digits[j]*digits[j];
      }
      return NumericOverflow;
    }
 
    m_sampleSum[i]+=dg;
    m_sample2Sum[i]+=dg*dg;
  }
  ++m_nTrigger;
  return NoError;
}

mean() [1/2]

std::vector< float > LArCalibTriggerAccumulator::mean

(

)

const

Calculates and returns the Mean value of each ADC sample.

Definition at line 68 of file LArCalibTriggerAccumulator.cxx.

                                                        {
 
  const size_t nS=m_sampleSum.size();
  std::vector<float> mean;
  if (m_nTrigger==0)
    return mean;
  else {
    mean.resize(nS,0.0);
    for (size_t i=0;i<nS;++i)
      mean[i]=((double)m_sampleSum[i])/((double)m_nTrigger);
    return mean;
  }
}

mean() [2/2]

double LArCalibTriggerAccumulator::mean

(

const size_t

i

)

const

Calculates and returns the Mean value for one ADC sample.

Definition at line 49 of file LArCalibTriggerAccumulator.cxx.

                                                            {
 
  if (i<m_sampleSum.size() && i<m_sample2Sum.size() && m_nTrigger>0)
    return ((double)m_sampleSum[i])/((double)m_nTrigger);
  else
    return 0.0;
}

nsamples()

size_t LArCalibTriggerAccumulator::nsamples ( ) const

inline

return number of samples

Definition at line 63 of file LArCalibTriggerAccumulator.h.

{return m_sampleSum.size();}

nTriggers()

uint32_t LArCalibTriggerAccumulator::nTriggers ( ) const

inline

return the number of triggers

Definition at line 60 of file LArCalibTriggerAccumulator.h.

{return m_nTrigger;}

RMS() [1/2]

std::vector< float > LArCalibTriggerAccumulator::RMS

(

)

const

Calculates and returns the RMS value of each ADC sample.

Definition at line 82 of file LArCalibTriggerAccumulator.cxx.

                                                       {
  std::vector<float> rms;  
  const size_t nS=m_sampleSum.size();
  if (m_sample2Sum.size()!=nS || m_nTrigger==0) 
    return rms;// ERROR, return emtpy vector
  
  double mean;
  rms.resize(nS,0.0);
  
  for (size_t i=0;i<nS;++i) {
      mean=((double)m_sampleSum[i])/((double)m_nTrigger);
      rms[i]=sqrt(((double)m_sample2Sum[i])/((double)m_nTrigger)-mean*mean);
  }
  return rms;
}

RMS() [2/2]

double LArCalibTriggerAccumulator::RMS

(

const size_t

i

)

const

Calculates and returns the RMS value for one ADC sample.

Definition at line 57 of file LArCalibTriggerAccumulator.cxx.

                                                           {
 
  if (i<m_sampleSum.size() && i<m_sample2Sum.size() && m_nTrigger>0) {
    const double mean=((double)m_sampleSum[i])/((double)m_nTrigger);
    return sqrt(((double)m_sample2Sum[i])/((double)m_nTrigger)-mean*mean);
  }
  else
    return 0.0;
}

sample2Sum()

const std::vector< uint64_t > & LArCalibTriggerAccumulator::sample2Sum ( ) const

inline

return a reference to a stl vector containing the sum of the squares of the sample

Definition at line 69 of file LArCalibTriggerAccumulator.h.

{ return m_sample2Sum; }

sampleSum()

const std::vector< uint64_t > & LArCalibTriggerAccumulator::sampleSum ( ) const

inline

return a reference to a stl vector containing the sample-sums

Definition at line 66 of file LArCalibTriggerAccumulator.h.

{ return m_sampleSum; }

Member Data Documentation

m_nTrigger

uint32_t LArCalibTriggerAccumulator::m_nTrigger

private

number of triggers

Definition at line 41 of file LArCalibTriggerAccumulator.h.

m_sample2Sum

std::vector<uint64_t> LArCalibTriggerAccumulator::m_sample2Sum

private

sum of squares of samples

Definition at line 38 of file LArCalibTriggerAccumulator.h.

m_sampleSum

std::vector<uint64_t> LArCalibTriggerAccumulator::m_sampleSum

private

sum of samples

Definition at line 35 of file LArCalibTriggerAccumulator.h.

---

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

• LArCalibTriggerAccumulator.h
• LArCalibTriggerAccumulator.cxx