TBProfiler.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
 
//#include <iostream>
 
template<typename T>
TBProfiler<T>::TBProfiler()
  : m_channelFill(false)
     , m_skipFlag(true)
     , m_deltaBin()
{ }
 
template<typename T>
TBProfiler<T>::TBProfiler(size_t theSize)
  : m_channelFill(true)
     , m_deltaBin()
{
  m_skipFlag = ! this->setupAction(theSize);
}
 
template<typename T>
TBProfiler<T>::TBProfiler(size_t storeSize, const T& lowerLimit, 
               const T& upperLimit)
  : m_channelFill(false),
    m_deltaBin()
{
  if ( storeSize > 0 && upperLimit > lowerLimit )
    {
      m_binLimits.resize(storeSize+1,0);
      m_binLimits[0] = lowerLimit;
      m_deltaBin     = ( upperLimit - lowerLimit ) / ((T)storeSize);
      for ( unsigned int i=1; i<m_binLimits.size(); i++ )
    {
      m_binLimits[i] = m_binLimits[i-1] + m_deltaBin;
    }
      m_skipFlag = ! this->setupAction(storeSize);
    }
  else
    {
      m_skipFlag = true;
    }
}
 
template<typename T>
TBProfiler<T>::~TBProfiler() 
{ }
 
template<typename T>
void TBProfiler<T>::addData(const T& theChannel, const T& theData)
{
  if ( ! m_skipFlag && ! m_channelFill )
    {
      size_t theIndex;
      if ( ( theIndex = this->getIndex(theChannel) ) != size_t(-1) )
    {
      this->addData(theIndex,theData);
    }
    }
}
 
template<typename T>
void TBProfiler<T>::addData(const std::vector<T>& theData)
{
  if ( m_skipFlag ) return;
 
  for ( size_t i=0; i<std::min(theData.size(),m_sum.size()); i++ )
    {
      m_sum[i]          += theData[i];
      m_sumOfSquares[i] += theData[i] * theData[i];
      m_entries[i]++;
    }
}
 
template<typename T>
 
void TBProfiler<T>::addData(size_t theIndex,const T& theData)
{
  if ( m_skipFlag ) return;
 
  if ( theIndex < m_sum.size() )
    {
      m_sum[theIndex]          += theData;
      m_sumOfSquares[theIndex] += theData * theData;
      m_entries[theIndex]++;
    }
}
 
template<typename T>
bool TBProfiler<T>::getAverages(std::vector<T>& theAverages) const
{
  if ( m_skipFlag ) return false;
 
  size_t changeCtr = 0;
  for ( size_t i=0; i<std::min(theAverages.size(),m_sum.size()); i++ )
    {
      if ( m_entries[i] > 0 )
    {
      changeCtr++;
      theAverages[i] = m_sum[i] / ((T)m_entries[i]);
    }
    }
  return changeCtr > 0;
}
 
template<typename T>
bool TBProfiler<T>::getAverages(size_t theIndex, T& theAverage) const
{
  if ( m_skipFlag ) return false;
 
  bool checkOut;
  if ( (checkOut = ( theIndex < m_sum.size() && m_entries[theIndex] > 0 ) ) )
    {
      theAverage = m_sum[theIndex]/((T)m_entries[theIndex]);
    } 
  return checkOut;
}
 
template<typename T>
bool TBProfiler<T>::getStandardDevs(std::vector<T>& theVariances) const
{
  if ( m_skipFlag ) return false;
 
  size_t changeCtr = 0;
  for ( size_t i=0; i<std::min(theVariances.size(),m_sum.size()); i++ )
    {
      if ( m_entries[i] > 0 )
    {
      changeCtr++;
      T theDiff = m_sumOfSquares[i] - m_sum[i] * m_sum[i];
      theVariances[i] = theDiff >=0  
        ? sqrt(theDiff) : -sqrt(fabs(theDiff));
    }
    }
  return changeCtr > 0;
}
 
template<typename T>
bool TBProfiler<T>::getStandardDevs(size_t theIndex,T& theVariance) const
{
  if ( m_skipFlag ) return false;
 
  bool checkOut;
  if (( checkOut = ( theIndex < m_sum.size() && m_entries[theIndex] > 0 ) ))
    {
      T theDev = m_sumOfSquares[theIndex] - m_sum[theIndex] * m_sum[theIndex];
      theVariance = theDev > 0 ? sqrt(theDev) : -sqrt(fabs(theDev));
    }
  return checkOut;
}
 
template<typename T>
bool TBProfiler<T>::getErrors(std::vector<T>& theErrors) const
{
  if ( m_skipFlag ) return false;
 
  size_t changeCtr = 0;
  std::vector<T> theDevs;
  if ( this->getStandardDevs(theDevs) )
    {
      for ( size_t i=0; i<std::min(theErrors.size(),m_sum.size()); i++ )
    {
      if ( m_entries[i] > 0 )
        {
          changeCtr++;
          theErrors[i] = theDevs[i] / sqrt((T)m_entries[i]);
        }
    }
    }
  return changeCtr > 0;
}
 
template<typename T> 
bool TBProfiler<T>::getErrors(size_t theIndex, T& theError) const
{
  if ( m_skipFlag ) return false;
 
  bool checkOut;
  if (( checkOut = this->getStandardDevs(theIndex,theError) ))
    {
      theError /= sqrt((T)m_entries[theIndex]);
    }
  return checkOut;
}
 
template<typename T>
bool TBProfiler<T>::getBinEntries(std::vector<size_t>& theEntries) const
{
  if ( m_skipFlag ) return false;
 
  theEntries.clear();
  theEntries.insert(++theEntries.begin(),m_entries.begin(),m_entries.end());
 
  return theEntries.size() > 0;
}
 
template<typename T>
bool TBProfiler<T>::getBinEntries(size_t theIndex,size_t& theEntries) const
{
  if ( m_skipFlag ) return false;
 
  if ( theIndex < m_entries.size() )
    {
      theEntries = m_entries[theIndex];
      return true;
    }
  else
    {
      return false;
    }
}
 
 
template<typename T>
const std::vector<T>& TBProfiler<T>::getSums() const
{
  return m_sum;
}
 
template<typename T>
const std::vector<T>& TBProfiler<T>::getSumOfSquares() const
{
  return m_sumOfSquares;
}
 
template<typename T>
const std::vector<size_t>& TBProfiler<T>::getEntries() const
{
  return m_entries;
}
 
template<typename T>
size_t TBProfiler<T>::getNumberOfChannels() const
{
  return m_binLimits.size()-1;
}
 
template<typename T>
T TBProfiler<T>::getChannelWidth() const
{
  return m_deltaBin;
}
 
template<typename T>
T TBProfiler<T>::getMinChannel() const
{
  return ! m_channelFill && ! m_skipFlag 
    ? m_binLimits[0]
    : 0;
}
 
template<typename T>
T TBProfiler<T>::getMaxChannel() const
{
  return ! m_channelFill && ! m_skipFlag
    ? m_binLimits[m_binLimits.size()-1]
    : 0;
}
 
template<typename T>
size_t TBProfiler<T>::getIndex(const T& theChannel) const
{
  if ( m_skipFlag ) return size_t(-1);
 
  return 
    ( theChannel >= m_binLimits[0] || 
      theChannel < m_binLimits[m_binLimits.size()-1] )
    ? (size_t)floor(( theChannel - m_binLimits[0] ) / m_deltaBin)
    : size_t(-1);
} 
 
template<typename T>
bool TBProfiler<T>::setupAction(size_t theSize)
{
  if ( theSize > 0 )
    {
      m_sum.resize(theSize,0);
      m_sumOfSquares.resize(theSize,0);
      m_entries.resize(theSize,0);
      return true;
    }
  else
    {
      return false;
    }
}