LArAccumulatedDigit Class Reference

Data class for ADC samples and autocorr preprocessed by the DSP. More...

#include <LArAccumulatedDigit.h>

Collaboration diagram for LArAccumulatedDigit:

Public Member Functions
	LArAccumulatedDigit (HWIdentifier &channel_value, CaloGain::CaloGain gain_value, const std::vector< uint64_t > &sampleSum_value, const std::vector< uint64_t > &sampleSquare_value, uint32_t nTrigger_value)
	Constructor (first type)
	LArAccumulatedDigit (HWIdentifier &channel_value)
	Constructor (second type)
	~LArAccumulatedDigit ()=default
	Destructor.
	LArAccumulatedDigit ()
	default constructor for persistency
const HWIdentifier &	hardwareID () const
	Return HWIdentifier.
const HWIdentifier &	channelID () const
	Return channel ID.
CaloGain::CaloGain	gain () const
	return gain value
int	nsample () const
	return number of samples
const std::vector< uint64_t > &	sampleSum () const
	return the sample-sums
const std::vector< uint64_t > &	sampleSquare () const
	return a reference to a stl vector containing the sum of the squares of the sample
unsigned	nTrigger () const
	return the number of triggers
float	mean (int n_min=-1, int n_max=-1) const
	Calculates and returns the Mean value of ADC samples.
float	RMS (int n_min=-1, int n_max=-1) const
	Calculates and returns the RMS value of ADC samples.
void	getCov (std::vector< float > &cov, int normalize) const
	Compute the autocorrelation elements.
bool	setAddDigit (const std::vector< short > &digit)
	Accumulate single digit.
bool	setAddSubStep (const CaloGain::CaloGain gain_value, const HWIdentifier chid, const std::vector< uint64_t > &sampleSum, const std::vector< uint64_t > &sampleSquare, const unsigned nTrigger)
	Accumulate new values.
void	setAddSubStep (CaloGain::CaloGain gain_value, const std::vector< uint64_t > &sampleSum, const std::vector< uint64_t > &sampleSquare, unsigned nTrigger)
void	setAddSubStep (CaloGain::CaloGain gain_value, const std::vector< int64_t > &sampleSum, const std::vector< int64_t > &sampleSquare, unsigned nTrigger, int32_t base)
bool	setAddSubStep (const LArAccumulatedDigit &ad)

Private Attributes
HWIdentifier	m_hardwareID
	Online Identifier.
CaloGain::CaloGain	m_gain
	gain
std::vector< uint64_t >	m_sampleSum
	sampleSum over ntrigger*nsamples
std::vector< uint64_t >	m_sampleSquare
	vector(index: j from s_i*s_{i+j})
uint32_t	m_nTrigger
	number of total triggers

Detailed Description

Data class for ADC samples and autocorr preprocessed by the DSP.

Contains sum of ADC counts and the sum of the s_i*s_{i+j} adc counts plus gain, number of triggers and samples

Author

Remi Lafaye

Modifications: Walter Lampl, 27 Aug 2009: Remove storage of individual substeps. The class represents now exactly one substep or the sum of many substeps.

Definition at line 32 of file LArAccumulatedDigit.h.

Constructor & Destructor Documentation

LArAccumulatedDigit() [1/3]

LArAccumulatedDigit::LArAccumulatedDigit	(	HWIdentifier &	channel_value,
		CaloGain::CaloGain	gain_value,
		const std::vector< uint64_t > &	sampleSum_value,
		const std::vector< uint64_t > &	sampleSquare_value,
		uint32_t	nTrigger_value )

Constructor (first type)

Definition at line 14 of file LArAccumulatedDigit.cxx.

                                              :
  m_hardwareID(channel_value), m_gain(gain_value), m_nTrigger(nTrigger_value)  {
 
  const size_t nS=sampleSum_value.size();
  m_sampleSum.resize(nS);
  for (size_t i=0;i<nS;++i)
    m_sampleSum[i]=(uint64_t)sampleSum_value[i];
 
 
  const size_t nSS=sampleSquare_value.size();
  m_sampleSquare.resize(nSS);
  for (size_t i=0;i<nSS;++i)
    m_sampleSquare[i]=(uint64_t)sampleSquare_value[i];
}

LArAccumulatedDigit() [2/3]

LArAccumulatedDigit::LArAccumulatedDigit

(

HWIdentifier &

channel_value

)

Constructor (second type)

Definition at line 34 of file LArAccumulatedDigit.cxx.

  : m_hardwareID (channel_value),
    m_gain       ((CaloGain::CaloGain) 0),
    m_nTrigger   (0)
{
}

~LArAccumulatedDigit()

LArAccumulatedDigit::~LArAccumulatedDigit ( )

default

Destructor.

LArAccumulatedDigit() [3/3]

LArAccumulatedDigit::LArAccumulatedDigit

(

)

default constructor for persistency

Definition at line 10 of file LArAccumulatedDigit.cxx.

                                         :
  m_gain(CaloGain::UNKNOWNGAIN),  m_nTrigger(0)
{}

Member Function Documentation

channelID()

const HWIdentifier & LArAccumulatedDigit::channelID ( ) const

inline

Return channel ID.

Definition at line 73 of file LArAccumulatedDigit.h.

{ return m_hardwareID; }

gain()

CaloGain::CaloGain LArAccumulatedDigit::gain ( ) const

inline

return gain value

Definition at line 76 of file LArAccumulatedDigit.h.

{ return m_gain; }

getCov()

void LArAccumulatedDigit::getCov	(	std::vector< float > &	cov,
		int	normalize ) const

Compute the autocorrelation elements.

Definition at line 232 of file LArAccumulatedDigit.cxx.

{
  cov.clear();
  const double n    = m_nTrigger;
  const size_t nS=m_sampleSum.size();
  if(n<=0) return;
  if(m_sampleSquare.size()!=nS) return;
 
  std::vector<double> mean2;
  mean2.resize(nS);
  for(size_t i=1;i<nS;i++) {
    for(size_t j=i;j<nS;j++) {
      mean2[i] += m_sampleSum[j-i]*m_sampleSum[j];
    }
    mean2[i]/=n*n*(nS-i);
  }
  uint64_t temp_mean = 0;
  double mean;
  for(uint32_t i=0;i<nS;i++)
    temp_mean += m_sampleSum[i];
  mean = temp_mean/((double) n*nS);
 
  if(normalize!=1) { // No mormalization send as is
    for(size_t i=1;i<nS;i++)
      cov.push_back( m_sampleSquare[i]/(n*(nS-i)) - mean2[i] );
    mean2.clear();
    return;
  }
 
  //Normalize covariance elements if required
  const double norm = m_sampleSquare[0]/(n*nS)-mean*mean;
  //norm = sqrt(norm*norm);
  if (norm==0.0)
    cov.assign(nS-1,0.0);
  else {
    const double inv_norm = 1. / norm;
    for(uint32_t i=1;i<nS;i++) {
      cov.push_back((m_sampleSquare[i]/(n*(nS-i)) - mean2[i])*inv_norm);
    }
  }
 
  mean2.clear();
}

hardwareID()

const HWIdentifier & LArAccumulatedDigit::hardwareID ( ) const

inline

Return HWIdentifier.

Definition at line 70 of file LArAccumulatedDigit.h.

{return m_hardwareID; }

mean()

float LArAccumulatedDigit::mean	(	int	n_min = -1,
		int	n_max = -1 ) const

Calculates and returns the Mean value of ADC samples.

Definition at line 41 of file LArAccumulatedDigit.cxx.

                                                          {
  //float mean;
  unsigned imin=0;
  const size_t nS=m_sampleSum.size();
  if(nS==0) return 0.;
  if(n_min>0 && (unsigned)n_min<nS) imin=n_min;
  unsigned imax=nS-1;
  if(n_max>0 && n_max>n_min && (unsigned)n_max<nS) imax=n_max;
 
  const double n    = (imax-imin+1)*m_nTrigger;
  if(n<=0) return 0;
  uint64_t x=0;
  for(size_t i=imin;i<=imax;i++) {
    //std::cout << "Computing mean: " << x << " += " << m_sampleSum[i] << " [" << i << "] ";
    x += m_sampleSum[i];
    //std::cout << " = " << x << std::endl;
  }
  //std::cout << x << " /= " << n << std::endl;
  //mean = x/n;
  //std::cout << " = " << mean << std::endl;
  return x/n;
}

nsample()

int LArAccumulatedDigit::nsample ( ) const

inline

return number of samples

Definition at line 79 of file LArAccumulatedDigit.h.

{ return m_sampleSquare.size(); }

nTrigger()

unsigned LArAccumulatedDigit::nTrigger ( ) const

inline

return the number of triggers

Definition at line 88 of file LArAccumulatedDigit.h.

{return m_nTrigger;}

RMS()

float LArAccumulatedDigit::RMS	(	int	n_min = -1,
		int	n_max = -1 ) const

Calculates and returns the RMS value of ADC samples.

Definition at line 64 of file LArAccumulatedDigit.cxx.

{
  unsigned imin=0;
  const size_t nS=m_sampleSum.size();
  if(nS==0) return 0.;
  if(n_min>0 && (unsigned)n_min<nS) imin=n_min;
  unsigned imax=nS-1;
  if(n_max>0 && n_max>n_min && (unsigned)n_max<nS) imax=n_max;
 
  const double n    = (imax-imin+1)*m_nTrigger;
  if(n<=0) return 0;
  if(m_sampleSquare.empty()) return 0;
 
  uint64_t x=0;
  for(size_t i=imin;i<=imax;i++)
    x += m_sampleSum[i];
  const double inv_n = 1. / n;
  double mean2 = x * inv_n;
  mean2=mean2*mean2;
  const double rms2=m_sampleSquare[0]*inv_n - mean2;
  if (rms2<0.0) { //W.L 2010-12-07 protect against FPE due to rounding error
    //std::cout << "ERROR negative squareroot:" << rms2 <<  std::endl;
    return 0.0;
  }
  float  rms   = sqrt(rms2);
  return rms;
}

sampleSquare()

const std::vector< uint64_t > & LArAccumulatedDigit::sampleSquare ( ) const

inline

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

Definition at line 85 of file LArAccumulatedDigit.h.

{ return m_sampleSquare; }

sampleSum()

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

inline

return the sample-sums

Definition at line 82 of file LArAccumulatedDigit.h.

{ return m_sampleSum; };

setAddDigit()

bool LArAccumulatedDigit::setAddDigit

(

const std::vector< short > &

digit

)

Accumulate single digit.

Definition at line 92 of file LArAccumulatedDigit.cxx.

                                                                   {
  const size_t nS=digit.size();
  if(nS!=m_sampleSum.size() || nS!=m_sampleSquare.size()) {
    if (!m_nTrigger)
      return false;
    m_sampleSquare.resize(nS,0);
    m_sampleSum.resize(nS,0);
  }// end if object empty
 
 
  for (size_t i=0;i<nS;++i) {
    m_sampleSum[i]+=digit[i];
    for (size_t j=i;j<nS;++j)
      m_sampleSquare[j]+=digit[i]*digit[j];
  }
  ++m_nTrigger;
  return true;
}

setAddSubStep() [1/4]

void LArAccumulatedDigit::setAddSubStep	(	CaloGain::CaloGain	gain_value,
		const std::vector< int64_t > &	sampleSum,
		const std::vector< int64_t > &	sampleSquare,
		unsigned	nTrigger,
		int32_t	base )

Definition at line 188 of file LArAccumulatedDigit.cxx.

{
  int64_t  tmpBase;
  std::vector<uint64_t> tmpSum;
  std::vector<uint64_t> tmpSquare;
  unsigned i,n;
  const size_t nS=m_sampleSum.size();
  if(gain_value!=m_gain) {
    if(m_nTrigger!=0)
      return;
    m_gain=gain_value;
  }
  n = sampleSquare.size();
  if(n!=sampleSum.size())
    return; // Can not accumulate if nsamples differs
  if(n!=nS) {
    if(m_nTrigger!=0)
      return; // Can not accumulate if nsamples differs
    m_sampleSquare.resize(n,0);
    m_sampleSum.resize(n,0);
  }
  tmpBase = base;
  tmpSum.resize(n,0);
  for(i=0;i<n;i++) {
    tmpSum[i] = (uint64_t) (sampleSum[i]+tmpBase);
    m_sampleSum[i] += tmpSum[i];
  }
 
  tmpBase = static_cast<int64_t>(base)*base;
  tmpSquare.resize(n,0);
  for(i=0;i<n;i++) {
    tmpSquare[i] = (uint64_t) (sampleSquare[i]+tmpBase);
    m_sampleSquare[i] += tmpSquare[i];
  }
 
  m_nTrigger += nTrigger;
 
  tmpSum.clear();
  tmpSquare.clear();
}

setAddSubStep() [2/4]

void LArAccumulatedDigit::setAddSubStep	(	CaloGain::CaloGain	gain_value,
		const std::vector< uint64_t > &	sampleSum,
		const std::vector< uint64_t > &	sampleSquare,
		unsigned	nTrigger )

Definition at line 149 of file LArAccumulatedDigit.cxx.

{
  std::vector<uint64_t> tmpSum;
  std::vector<uint64_t> tmpSquare;
  unsigned i,n;
  const size_t nS=m_sampleSum.size();
  if(gain_value!=m_gain) {
    if(m_nTrigger!=0)
      return;
    m_gain=gain_value;
  }
  n = sampleSquare.size();
  if(n!=sampleSum.size())
    return; // Can not accumulate if nsamples differs
  if(n!=nS) {
    if(m_nTrigger!=0)
      return; // Can not accumulate if nsamples differs
    m_sampleSquare.resize(n,0);
    m_sampleSum.resize(n,0);
  }
 
  tmpSum.resize(n,0);
  for(i=0;i<n;i++) {
    tmpSum[i] = sampleSum[i];
    m_sampleSum[i] += sampleSum[i];
  }
 
  tmpSquare.resize(n,0);
  for(i=0;i<n;i++) {
    tmpSquare[i] = sampleSquare[i];
    m_sampleSquare[i] += sampleSquare[i];
  }
 
  m_nTrigger += nTrigger;
  tmpSum.clear();
  tmpSquare.clear();
}

setAddSubStep() [3/4]

bool LArAccumulatedDigit::setAddSubStep	(	const CaloGain::CaloGain	gain_value,
		const HWIdentifier	chid,
		const std::vector< uint64_t > &	sampleSum,
		const std::vector< uint64_t > &	sampleSquare,
		const unsigned	nTrigger )

Accumulate new values.

Definition at line 113 of file LArAccumulatedDigit.cxx.

{
  size_t i;
 
  if(gain_value!=m_gain || chid!=m_hardwareID) {
    if(m_nTrigger!=0)
      return false;
    m_gain=gain_value;
    m_hardwareID=chid;
  }
 
 
  const size_t n = sampleSquare.size();
  if(n!=sampleSum.size())
    return false; // Can not accumulate if nsamples differs
  if(n!=m_sampleSum.size() || n!=m_sampleSquare.size()) {
    if(m_nTrigger!=0)
      return false; // Can not accumulate if nsamples differs
    m_sampleSquare.resize(n,0);
    m_sampleSum.resize(n,0);
  }
  for(i=0;i<n;++i)
    m_sampleSum[i] += sampleSum[i];
 
  for(i=0;i<n;i++)
    m_sampleSquare[i] += sampleSquare[i];
 
  m_nTrigger += nTrigger;
  return true;
}

setAddSubStep() [4/4]

bool LArAccumulatedDigit::setAddSubStep ( const LArAccumulatedDigit & ad )

inline

Definition at line 117 of file LArAccumulatedDigit.h.

                                                    {
    return setAddSubStep(ad.gain(), ad.channelID(), ad.sampleSum(),ad.sampleSquare(),ad.nTrigger());
  };

Member Data Documentation

m_gain

CaloGain::CaloGain LArAccumulatedDigit::m_gain

private

gain

Definition at line 40 of file LArAccumulatedDigit.h.

m_hardwareID

HWIdentifier LArAccumulatedDigit::m_hardwareID

private

Online Identifier.

Definition at line 37 of file LArAccumulatedDigit.h.

m_nTrigger

uint32_t LArAccumulatedDigit::m_nTrigger

private

number of total triggers

Definition at line 49 of file LArAccumulatedDigit.h.

m_sampleSquare

std::vector<uint64_t> LArAccumulatedDigit::m_sampleSquare

private

vector(index: j from s_i*s_{i+j})

Definition at line 46 of file LArAccumulatedDigit.h.

m_sampleSum

std::vector<uint64_t> LArAccumulatedDigit::m_sampleSum

private

sampleSum over ntrigger*nsamples

Definition at line 43 of file LArAccumulatedDigit.h.

---

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

• LArAccumulatedDigit.h
• LArAccumulatedDigit.cxx