ATLAS Offline Software
Public Types | Public Member Functions | Private Member Functions | Private Attributes | List of all members
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, nGlobalCountersm_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.

21  {
22  nEvents,
26  };

◆ RegionIndex

template<class EnumType >
enum AmbiCounter::RegionIndex
Enumerator
iBarrel 
iTransi 
iEndcap 
iFWD 
nRegions 
iForwrd 

Definition at line 20 of file AmbiCounter.h.

20 {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.

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

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.

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

◆ etaBin()

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

Definition at line 123 of file AmbiCounter.h.

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

◆ globalCount()

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

Definition at line 114 of file AmbiCounter.h.

114  {
115  return m_globalCounter[i];
116  }

◆ idx()

template<class EnumType >
size_t AmbiCounter< EnumType >::idx ( const Categories categoryIndex) const
inline

Definition at line 38 of file AmbiCounter.h.

38  {
39  return static_cast<size_t>(categoryIndex);
40  }

◆ increment()

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

Definition at line 60 of file AmbiCounter.h.

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

◆ incrementCounterByRegion()

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

Definition at line 79 of file AmbiCounter.h.

79  {
80  // test
81  if (!track) {
83  return;
84  }
85  // use first parameter
86  if (!track->trackParameters()) {
88  } else {
89  std::array<int, nRegions> &nTracks = m_counter.at(idx(categoryIdx));
90  // @TODO make sure that list of track parameters is not empty
91  const double absEta = std::abs(track->trackParameters()->front()->eta());
92  if (const auto &possibleIdx{etaBin(absEta)}){//i.e. if it's within bounds
93  ++nTracks[possibleIdx.value()];
94  }
95  }
96  }

◆ newEvent()

template<class EnumType >
void AmbiCounter< EnumType >::newEvent ( )
inline

Definition at line 49 of file AmbiCounter.h.

49  {
51  }

◆ numberOfEvents()

template<class EnumType >
int AmbiCounter< EnumType >::numberOfEvents ( ) const
inline

Definition at line 55 of file AmbiCounter.h.

55  {
56  return m_globalCounter[nEvents];
57  }

◆ operator+=()

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

Definition at line 67 of file AmbiCounter.h.

67  {
68  for (unsigned int i=0; i<nGlobalCounters; ++i) {
69  m_globalCounter[i]+= a.m_globalCounter[i];
70  }
71  for (size_t categoryIdx=0; categoryIdx < idx(Categories::kNCounter); ++categoryIdx) {
72  for (unsigned int etaBinIdx=0; etaBinIdx < a.m_counter[categoryIdx].size(); ++etaBinIdx) {
73  m_counter[categoryIdx][etaBinIdx] += a.m_counter[categoryIdx][etaBinIdx];
74  }
75  }
76  return *this;
77 }

◆ resetGlobalCounters()

template<class EnumType >
void AmbiCounter< EnumType >::resetGlobalCounters ( )
inline

Definition at line 43 of file AmbiCounter.h.

43  {
44  m_globalCounter.fill(0);
45  }

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::iEndcap
@ iEndcap
Definition: AmbiCounter.h:20
AmbiCounter::iFWD
@ iFWD
Definition: AmbiCounter.h:20
AmbiCounter::idx
size_t idx(const Categories &categoryIndex) const
Definition: AmbiCounter.h:38
AmbiCounter::iForwrd
@ iForwrd
Definition: AmbiCounter.h:20
AmbiCounter::nInvalidTracks
@ nInvalidTracks
Definition: AmbiCounter.h:23
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:70
AmbiCounter::iTransi
@ iTransi
Definition: AmbiCounter.h:20
AmbiCounter::nRegions
@ nRegions
Definition: AmbiCounter.h:20
TauGNNUtils::Variables::Scalar::absEta
bool absEta(const xAOD::TauJet &tau, float &out)
Definition: TauGNNUtils.cxx:107
AmbiCounter::m_globalCounter
std::array< int, nGlobalCounters > m_globalCounter
Definition: AmbiCounter.h:120
AmbiCounter::nTracksWithoutParam
@ nTracksWithoutParam
Definition: AmbiCounter.h:24
lumiFormat.i
int i
Definition: lumiFormat.py:85
ReweightUtils.category
category
Definition: ReweightUtils.py:15
AmbiCounter::m_counter
std::array< std::array< int, nRegions >, static_cast< size_t >Categories::kNCounter)> m_counter
Definition: AmbiCounter.h:119
AmbiCounter::etaBin
std::optional< size_t > etaBin(const double val)
Definition: AmbiCounter.h:123
head
std::string head(std::string s, const std::string &pattern)
head of a string
Definition: computils.cxx:312
AmbiCounter::nGlobalCounters
@ nGlobalCounters
Definition: AmbiCounter.h:25
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
AmbiCounter::nEvents
@ nEvents
Definition: AmbiCounter.h:22
runIDAlign.accumulate
accumulate
Update flags based on parser line args.
Definition: runIDAlign.py:107
AmbiCounter::iBarrel
@ iBarrel
Definition: AmbiCounter.h:20
a
TList * a
Definition: liststreamerinfos.cxx:10
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
AmbiCounter::m_etaBounds
const std::vector< float > & m_etaBounds
eta intervals for internal monitoring
Definition: AmbiCounter.h:121
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54