LArCalibTriggerAccumulator.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
// Dear emacs, this is -*-c++-*-
 
 
#ifndef LARCALIBTRIGGERACCUMULATOR
#define LARCALIBTRIGGERACCUMULATOR
 
 
#include <vector>
#include "stdint.h"
#include <limits>
#include <cstddef>
 
class LArCalibTriggerAccumulator {
 
private:
 
  std::vector<uint64_t> m_sampleSum;   
   
  std::vector<uint64_t> m_sample2Sum;   
 
  uint32_t m_nTrigger;
 
 
 public:
 
  enum ERRTYPE {
    NoError=0,
    WrongNSamples,
    NumericOverflow
  };
    
 
  LArCalibTriggerAccumulator();
 
  LArCalibTriggerAccumulator(const std::vector<uint64_t>& sampleSum, 
                 const std::vector<uint64_t>& sample2Sum, uint32_t m_nTrigger);
 
 
  uint32_t nTriggers() const {return m_nTrigger;}
 
  size_t nsamples() const {return m_sampleSum.size();}
 
  const std::vector < uint64_t > & sampleSum() const { return m_sampleSum; }
 
  const std::vector < uint64_t > & sample2Sum() const { return m_sample2Sum; }
 
  ERRTYPE add(const std::vector<short>& digits);
 
 
  template<class INTTYPE>
  ERRTYPE add(const std::vector<INTTYPE>& sampleSum, 
          const std::vector<INTTYPE>& sample2Sum, const uint32_t nTrigger);
 
  std::vector<float> mean() const;
 
  std::vector<float> RMS() const;
 
 
  double mean(const size_t i) const;
 
  double RMS(const size_t i) const;
 
}; 
 
 
template<class INTTYPE>
LArCalibTriggerAccumulator::ERRTYPE LArCalibTriggerAccumulator::add(const std::vector<INTTYPE>& sampleSum, 
                                    const std::vector<INTTYPE>& sample2Sum, const uint32_t nTrigger) {
  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;
}
 
#endif