AmbiCounter< EnumType > Class Template Reference

#include <AmbiCounter.h>

Collaboration diagram for AmbiCounter< EnumType >:

Public Types
enum	RegionIndex {   iBarrel, iTransi, iEndcap, iFWD = 3,   nRegions =4, iForwrd = 3 }
enum	GlobalCounterIndices { nEvents, nInvalidTracks, nTracksWithoutParam, nGlobalCounters }
using	Categories = EnumType

Public Member Functions
	AmbiCounter (const std::vector< float > &eta_bounds)
size_t	idx (const Categories &categoryIndex) const
void	resetGlobalCounters ()
void	newEvent ()
int	numberOfEvents () const
void	increment (Categories category, unsigned int etaBinIdx)
AmbiCounter< EnumType > &	operator+= (const AmbiCounter< EnumType > &a)
void	incrementCounterByRegion (Categories categoryIdx, const Trk::Track *track)
std::string	dumpRegions (const std::string &head, Categories categoryIdx, const int iw=9) const
int	globalCount (GlobalCounterIndices i) const

Private Member Functions
std::optional< size_t >	etaBin (const double val)

Private Attributes
std::array< std::array< int, nRegions >, static_cast< size_t >Categories::kNCounter)>	m_counter {}
std::array< int, nGlobalCounters >	m_globalCounter {}
const std::vector< float > &	m_etaBounds
	eta intervals for internal monitoring More...

Detailed Description

template<class EnumType>
class AmbiCounter< EnumType >

Definition at line 17 of file AmbiCounter.h.

Member Typedef Documentation

Categories

template<class EnumType >

using AmbiCounter< EnumType >::Categories = EnumType

Definition at line 19 of file AmbiCounter.h.

Member Enumeration Documentation

GlobalCounterIndices

template<class EnumType >

enum AmbiCounter::GlobalCounterIndices

Enumerator
nEvents
nInvalidTracks
nTracksWithoutParam
nGlobalCounters

Definition at line 21 of file AmbiCounter.h.

                            {
    nEvents,
    nInvalidTracks,
    nTracksWithoutParam,
    nGlobalCounters,
  };

RegionIndex

template<class EnumType >

enum AmbiCounter::RegionIndex

Enumerator
iBarrel
iTransi
iEndcap
iFWD
nRegions
iForwrd

Definition at line 20 of file AmbiCounter.h.

{iBarrel , iTransi , iEndcap , iFWD = 3, nRegions=4, iForwrd = 3};

Constructor & Destructor Documentation

AmbiCounter()

template<class EnumType >

AmbiCounter< EnumType >::AmbiCounter ( const std::vector< float > &  eta_bounds )

inline

Definition at line 28 of file AmbiCounter.h.

                                                 : m_etaBounds(eta_bounds){
    const std::string errMsgPrefix = "In AmbiCounter.icc, eta_bounds size must be ";
    if (m_etaBounds.size()!=nRegions) throw std::runtime_error(errMsgPrefix + std::to_string(nRegions) + " elements long.");
    if (not std::is_sorted(m_etaBounds.begin(), m_etaBounds.end())){
      throw std::runtime_error(errMsgPrefix + "in ascending order.");
    }
  }

Member Function Documentation

dumpRegions()

template<class EnumType >

std::string AmbiCounter< EnumType >::dumpRegions ( const std::string &  head, Categories  categoryIdx, const int  iw = 9  ) const

inline

Definition at line 99 of file AmbiCounter.h.

                                                                                    {
    std::stringstream out;
    out << head;
    if (categoryIdx >= Categories::kNCounter) throw std::out_of_range("Array index out of range in AmbiCounter::inc by region");
    const auto & displayedArray = m_counter[idx(categoryIdx)];
    const auto allRegionCounts  = std::accumulate(displayedArray.begin(), displayedArray.end(),0);
    out << std::setiosflags(std::ios::dec) << std::setw(iw) << allRegionCounts;
    for (unsigned int etaBinIdx=0; etaBinIdx < nRegions; ++etaBinIdx) {
       out << std::setiosflags(std::ios::dec) << std::setw(iw) << m_counter[idx(categoryIdx)][etaBinIdx];
    }
    out << "\n";
    return out.str();
  }

etaBin()

template<class EnumType >

std::optional<size_t> AmbiCounter< EnumType >::etaBin ( const double  val )

inlineprivate

Definition at line 123 of file AmbiCounter.h.

                          {
    auto pVal =  std::lower_bound(m_etaBounds.begin(), m_etaBounds.end(), val);
    //if it's in bounds, return the value, otherwise return a nullopt
    return (pVal!=m_etaBounds.end()) ? std::optional<size_t>(std::distance(m_etaBounds.begin(), pVal)):std::nullopt;
  }

globalCount()

template<class EnumType >

int AmbiCounter< EnumType >::globalCount ( GlobalCounterIndices  i ) const

inline

Definition at line 114 of file AmbiCounter.h.

                                           {
    return m_globalCounter[i];
  }

idx()

template<class EnumType >

size_t AmbiCounter< EnumType >::idx ( const Categories &  categoryIndex ) const

inline

Definition at line 38 of file AmbiCounter.h.

                                             {
    return static_cast<size_t>(categoryIndex);
  }

increment()

template<class EnumType >

void AmbiCounter< EnumType >::increment ( Categories  category, unsigned int  etaBinIdx  )

inline

Definition at line 60 of file AmbiCounter.h.

                                                         {
    if ((category>= Categories::kNCounter) or (etaBinIdx >=nRegions)){
      throw std::out_of_range("in AmbiCounter.icc::increment()");
    }
    ++m_counter[idx(category)][etaBinIdx];
  }

incrementCounterByRegion()

template<class EnumType >

void AmbiCounter< EnumType >::incrementCounterByRegion ( Categories  categoryIdx, const Trk::Track *  track  )

inline

Definition at line 79 of file AmbiCounter.h.

                                                                             {
   // test
   if (!track) {
      ++m_globalCounter[nInvalidTracks];
      return;
   }
   // use first parameter
   if (!track->trackParameters()) {
      ++m_globalCounter[nTracksWithoutParam];
   } else {
      std::array<int, nRegions> &nTracks = m_counter.at(idx(categoryIdx));
      // @TODO make sure that list of track parameters is not empty
      const double absEta = std::abs(track->trackParameters()->front()->eta());
      if (const auto &possibleIdx{etaBin(absEta)}){//i.e. if it's within bounds
        ++nTracks[possibleIdx.value()];
      }
    }
  }

newEvent()

template<class EnumType >

void AmbiCounter< EnumType >::newEvent ( )

inline

Definition at line 49 of file AmbiCounter.h.

            {
    ++m_globalCounter[nEvents];
  }

numberOfEvents()

template<class EnumType >

int AmbiCounter< EnumType >::numberOfEvents ( ) const

inline

Definition at line 55 of file AmbiCounter.h.

                        {
    return m_globalCounter[nEvents];
  }

operator+=()

template<class EnumType >

AmbiCounter<EnumType>& AmbiCounter< EnumType >::operator+= ( const AmbiCounter< EnumType > &  a )

inline

Definition at line 67 of file AmbiCounter.h.

                                                                      {
  for (unsigned int i=0; i<nGlobalCounters; ++i) {
       m_globalCounter[i]+= a.m_globalCounter[i];
  }
  for (size_t categoryIdx=0; categoryIdx < idx(Categories::kNCounter); ++categoryIdx) {
     for (unsigned int etaBinIdx=0; etaBinIdx < a.m_counter[categoryIdx].size(); ++etaBinIdx) {
        m_counter[categoryIdx][etaBinIdx] += a.m_counter[categoryIdx][etaBinIdx];
     }
  }
  return *this;
}

resetGlobalCounters()

template<class EnumType >

void AmbiCounter< EnumType >::resetGlobalCounters ( )

inline

Definition at line 43 of file AmbiCounter.h.

                       {
    m_globalCounter.fill(0);
  }

Member Data Documentation

m_counter

template<class EnumType >

std::array<std::array<int, nRegions>,static_cast<size_t>Categories::kNCounter)> AmbiCounter< EnumType >::m_counter {}

private

Definition at line 119 of file AmbiCounter.h.

m_etaBounds

template<class EnumType >

const std::vector<float>& AmbiCounter< EnumType >::m_etaBounds

private

eta intervals for internal monitoring

Definition at line 121 of file AmbiCounter.h.

m_globalCounter

template<class EnumType >

std::array<int,nGlobalCounters> AmbiCounter< EnumType >::m_globalCounter {}

private

Definition at line 120 of file AmbiCounter.h.

---

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

• AmbiCounter.h