ATLAS Offline Software
Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h
Go to the documentation of this file.
1 
3 /*
4  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
5 */
6 
7 #ifndef CALOEVENT_CALOTOWERCONTAINER_H
8 #define CALOEVENT_CALOTOWERCONTAINER_H
9 /********************************************************************
10 
11 NAME: CaloTowerContainer.h
12 PACKAGE: offline/Calorimeter/CaloRec
13 
14 AUTHORS: H. Ma, S. Rajagopalan
15 CREATED: Oct, 2000
16  Originally it is LArTowerContainer in LArClusterRec
17  Moved to CaloRec package on Feb 5, 2001
18 
19 PURPOSE: container class for CaloTower objects.
20  Baseclass: ObjectVector<CaloTower>.
21  The tower objects are stored as CaloTower in DataVector
22  In addition to providing iterators over all towers,
23  the towers (and their et and energy) can be accessed with
24  index (ieta,iphi), or in real (eta,phi) space.
25 
26  There are two ways of using this container. In standard usage,
27  the towers are in a strict rectangular grid as defined
28  by the CaloTowerSeg object passed to the constructor.
29  In this case, the container itself creates all the contained
30  towers. Clients should not attempt to modify the container
31  itself.
32 
33  For efficiency, all the contained towers are either stored
34  in a single vector or in a DataPool (depending on whether
35  or not CALOTOWERCONTAINER_USES_DATAPOOL is defined).
36  In the former case, the DataVector elements are then
37  set to point into that vector.
38 
39  The other usage is simply as a list of towers (this is provided
40  for the use of trigger software). In this case, the default
41  constructor must be used, and the ownership mode should
42  be set to VIEW_ELEMENTS. The only operations that modify
43  the container that are supported are insert(), push_back(),
44  and clear().
45 
46 
47 UPDATE: MAY-11-01
48  add CLID
49 
50 ********************************************************************/
51 
52 // If CALOTOWERCONTAINER_USES_DATAPOOL is set, then CaloTowers
53 // will be allocated from a DataPool.
54 // Otherwise, they will be allocated in an internal vector.
55 //
56 // This needs to be disabled for Hive
57 
58 #define CALOTOWERCONTAINER_USES_DATAPOOL
59 
60 // INCLUDE HEADER FILES:
62 #include "AthenaKernel/CLASS_DEF.h"
63 
65 
66 #include "CaloEvent/CaloTower.h"
67 #include "CaloEvent/CaloTowerSeg.h"
70 
71 #include "boost/iterator/iterator_adaptor.hpp"
72 #include <utility>
73 #include <vector>
74 
75 
76 class CaloTowerContainer : public DataVector<CaloTower>
77 {
78 public:
80 
82  typedef size_t index_t;
83 
85  // Constructors/Destructor //
87 
105  CaloTowerContainer(const CaloTowerSeg& tseg, bool noTowers = false);
106 
109 
112 
114  void swap (CaloTowerContainer& other);
115 
118 
119 
121  // Initialization //
123 
128  void init();
129 
130 
132  // Tower Information //
134 
143  void setCalo(const CaloCell_ID::SUBCALO& nCalo);
151  size_t getCalos(std::vector<CaloCell_ID::SUBCALO>& theCalos) const;
153  size_t getNumberOfCalos() const;
154 
156  double etamin() const;
158  double phimin() const;
160  double deta() const;
162  double dphi() const;
164  size_t neta() const;
166  size_t nphi() const;
167 
169  const CaloTowerSeg& towerseg() const;
170 
172  // Kinematics //
174 
182  double et(double theEta, double thePhi) const;
190  double et(index_t etaIndex, index_t phiIndex) const;
195  double et(int etaIndex, int phiIndex) const
196  { return et((index_t)etaIndex,(index_t)phiIndex); } // temp fix!
197 
205  double e(double theEta, double thePhi) const
206  { return this->energy(theEta,thePhi); }
214  double e(index_t etaIndex, index_t phiIndex) const
215  { return this->energy(etaIndex,phiIndex); }
220  double e(int etaIndex, int phiIndex) const
221  { return this->energy(etaIndex,phiIndex); }
222 
230  double energy(double theEta, double thePhi) const;
238  double energy(index_t etaIndex, index_t phiIndex) const;
243  double energy(int etaIndex, int phiIndex) const
244  { return energy((index_t)etaIndex,(index_t)phiIndex); }
245 
247  // Container Management //
249 
256  index_t getTowerIndex(const CaloTower* aTower) const;
265  index_t getTowerIndex(index_t etaIndex, index_t phiIndex) const;
274  index_t getTowerIndex(double theEta, double thePhi) const;
281  index_t getTowerEtaIndex(const CaloTower* aTower) const;
289  index_t getTowerEtaIndex(double theEta) const;
296  index_t getTowerEtaIndex(index_t towerIndex) const;
303  index_t getTowerPhiIndex(const CaloTower* aTower) const;
311  index_t getTowerPhiIndex(double thePhi) const;
318  index_t getTowerPhiIndex(index_t towerIndex) const;
319 
331  bool getTowerIndices(const CaloTower* aTower,
332  index_t& indexEta,
333  index_t& indexPhi) const;
348  bool getTowerIndices(double theEta, double thePhi,
349  index_t& indexEta,
350  index_t& indexPhi) const;
351 
366  const CaloTower* getTower(index_t eta, index_t phi) const;
373  { return this->getTower(index_t(eta), index_t(phi)); }
379  const CaloTower* getTower(int eta, int phi) const
380  { return this->getTower(index_t(eta), index_t(phi)); }
389  CaloTower* getTower(double eta, double phi);
395  const CaloTower* getTower(double eta, double phi) const;
396 
404  {
405  return theIndex < this->size()
406  ? (this->operator[])(theIndex)
407  : (CaloTower*)0;
408  }
413  const CaloTower* getTower( index_t theIndex ) const
414  {
415  return theIndex < this->size()
416  ? (this->operator[])(theIndex)
417  : (const CaloTower*)0;
418  }
419 
421  index_t flagOutOfRange() const;
428  bool isOutOfRange(index_t anIndex) const;
429 
430 
431 public:
432  //***********************************************************************
433  // We don't want to allow clients to change pointers in the container.
434  // So change DataVector operations that return lvalues to return
435  // instead rvalues.
436 
437  using Base::operator[];
439 
440  using Base::at;
441  CaloTower* at (size_type n);
442 
443  using Base::front;
444  CaloTower* front ();
445 
446  using Base::back;
447  CaloTower* back ();
448 
449 
459  class iterator
460  : public boost::iterator_adaptor<iterator,
461  Base::iterator,
462  Base::value_type,
463  Base::iterator::iterator_category,
464  // Reference
465  Base::value_type>
466  {
467  private:
468  // Shorthand for the base class type.
469  typedef boost::iterator_adaptor<iterator,
472  Base::iterator::iterator_category,
475 
476  public:
477  iterator() {}
479 
480  operator const_iterator() const
481  { return const_iterator (this->base()); }
482  };
483 
484 
485  typedef std::reverse_iterator<iterator> reverse_iterator;
486 
487 
488  using Base::begin;
489  using Base::end;
490  iterator begin();
491  iterator end();
492 
493  using Base::rbegin;
494  using Base::rend;
497 
498 
499  //***********************************************************************
500  // We'll be disallowing most operations that modify the container.
501  // However, these operations are needed by trigger code.
502  // They are only allowed when the segmentation is null and
503  // the ownership policy is set to @c VIEW_ELEMENTS.
504 
505  void insert(iterator position, iterator first, iterator last);
507  void push_back(value_type pElem);
508 
509 
510 private:
512 
513 
518 
520  std::vector<unsigned int> m_caloRegions;
521 
522 #ifndef CALOTOWERCONTAINER_USES_DATAPOOL
523 
524  std::vector<CaloTower> m_towers;
525 
526  void setTowers();
527 #endif
528 
530  static const index_t m_outOfRange = static_cast<index_t>(-1);
531 
532 
533 private:
534  // Hide methods from DataVector that modify the container.
535  template <class InputIterator>
536  void assign(InputIterator first, InputIterator last);
537  iterator insert(iterator position, value_type pElem);
538  template <class InputIterator>
539  void insert(iterator position, InputIterator first, InputIterator last);
542  void sort();
543  template <class COMPARE>
544  void sort(COMPARE comp);
545  void swapElement(size_type index, value_type newElem, reference oldElem);
548  void pop_back();
549  void clear();
550 };
551 
554 
556 // Inline Functions //
558 
559 // included calorimeter
560 inline size_t CaloTowerContainer::getNumberOfCalos() const
561 {
562  return m_caloRegions.size();
563 }
564 
565 // tower binning
566 inline double CaloTowerContainer::etamin() const
567 {
568  return m_towerSeg.etamin();
569 }
570 inline double CaloTowerContainer::deta() const
571 {
572  return m_towerSeg.deta();
573 }
574 inline size_t CaloTowerContainer::neta() const
575 {
576  return m_towerSeg.neta();
577 }
578 inline double CaloTowerContainer::phimin() const
579 {
580  return m_towerSeg.phimin();
581 }
582 
583 inline double CaloTowerContainer::dphi() const
584 {
585  return m_towerSeg.dphi();
586 }
587 inline size_t CaloTowerContainer::nphi() const
588 {
589  return m_towerSeg.nphi();
590 }
592 {
593  return m_towerSeg;
594 }
595 
596 // tower indices
599 {
600  return aTower != 0
601  ? this->getTowerIndex(aTower->eta(),aTower->phi())
602  : m_outOfRange;
603 }
606 {
607  return m_towerSeg.etaphi(etaIndex,phiIndex);
608 }
610 CaloTowerContainer::getTowerIndex(double theEta, double thePhi) const
611 {
612  return this->getTowerIndex(this->getTowerEtaIndex(theEta),
613  this->getTowerPhiIndex(thePhi));
614 }
617 {
618  return aTower != 0
619  ? this->getTowerEtaIndex(aTower->eta())
620  : m_outOfRange;
621 }
624 {
625  return m_towerSeg.etaIndex(theEta);
626 }
629 {
630  return m_towerSeg.etaIndex(combinedIndex);
631 }
634 {
635  return aTower != 0
636  ? this->getTowerPhiIndex(aTower->phi())
637  : m_outOfRange;
638 }
641 {
642  return m_towerSeg.phiIndex(thePhi);
643 }
646 {
647  return m_towerSeg.phiIndex(combinedIndex);
648 }
649 
650 // useful help
652 {
653  return m_outOfRange;
654 }
655 inline bool CaloTowerContainer::isOutOfRange(index_t anIndex) const
656 {
657  return anIndex >= this->size() || anIndex == m_outOfRange;
658 }
659 
661 {
662  return Base::operator[](n);
663 }
664 
666 {
667  return Base::at(n);
668 }
669 
671 {
672  return Base::front();
673 }
674 
676 {
677  return Base::back();
678 }
679 
681 {
682  return iterator (Base::begin());
683 }
684 
686 {
687  return iterator (Base::end());
688 }
689 
691 {
692  return reverse_iterator (end());
693 }
694 
696 {
697  return reverse_iterator (begin());
698 }
699 
700 
722 #endif
plotting.yearwise_luminosity_vs_mu.comp
comp
Definition: yearwise_luminosity_vs_mu.py:23
base
std::string base
Definition: hcg.cxx:78
CaloTowerContainer::et
double et(double theEta, double thePhi) const
Return the tower transverse energy at a given grid position.
Definition: CaloTowerContainer.cxx:223
CaloTowerContainer::getTower
CaloTower * getTower(index_t eta, index_t phi)
Returns a pointer to a tower with given indices.
Definition: CaloTowerContainer.cxx:266
CaloTowerContainer::neta
size_t neta() const
Return number of bins.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:574
CaloTowerContainer::back
CaloTower * back()
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:675
CaloTowerContainer::push_back
void push_back(value_type pElem)
Definition: CaloTowerContainer.cxx:315
fitman.sz
sz
Definition: fitman.py:527
CaloTowerContainer::rbegin
reverse_iterator rbegin()
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:690
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
CaloTowerContainer::e
double e(int etaIndex, int phiIndex) const
Return the tower energy at a given grid position.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:220
DataVector< CaloTower >::iterator
DataModel_detail::iterator< DataVector > iterator
Standard iterator.
Definition: DataVector.h:841
CaloTowerContainer::dphi
double dphi() const
Return bin size .
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:583
DataVector< CaloTower >::const_iterator
DataModel_detail::const_iterator< DataVector > const_iterator
Standard const_iterator.
Definition: DataVector.h:837
DataVector< CaloTower >::rend
const_reverse_iterator rend() const noexcept
Return a const_reverse_iterator pointing at the beginning of the collection.
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
index
Definition: index.py:1
CaloTowerContainerCnv_p1
Definition: CaloTowerContainerCnv_p1.h:22
CaloTowerContainer::operator=
CaloTowerContainer & operator=(const CaloTowerContainer &other)
Assignment.
Definition: CaloTowerContainer.cxx:80
CaloTowerDataVector.h
CaloTowerContainer::insert
void insert(iterator position, InputIterator first, InputIterator last)
CaloTowerContainer::end
iterator end()
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:685
skel.it
it
Definition: skel.GENtoEVGEN.py:396
CaloTowerContainer::insert
void insert(iterator position, iterator first, iterator last)
Definition: CaloTowerContainer.cxx:303
CaloTowerContainer::resize
void resize(size_type sz)
CaloTowerContainer::Base
DataVector< CaloTower > Base
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:79
CaloTowerContainer::iterator
Iterator class for which the reference type is not an lvalue.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:466
CaloTowerSeg::neta
index_t neta() const
Retrieve number of bins.
Definition: CaloTowerSeg.h:423
CaloTowerContainer::nphi
size_t nphi() const
Return number of bins.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:587
CaloTowerSeg.h
CaloTowerSeg::deta
double deta() const
Retrieve bin size .
Definition: CaloTowerSeg.h:433
CaloTowerContainer::init
void init()
Initializes the CaloTowerContainer.
Definition: CaloTowerContainer.cxx:107
CaloTowerContainer::getTower
const CaloTower * getTower(int eta, int phi) const
Returns a const pointer to a tower with given indices.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:379
CaloTowerContainer::m_caloRegions
std::vector< unsigned int > m_caloRegions
Vector of calorimeter regions contributing to the tower signals.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:520
CaloTowerContainer::getTowerIndex
index_t getTowerIndex(const CaloTower *aTower) const
Returns the combined index of a tower on the grid.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:598
CaloTowerSeg::nphi
index_t nphi() const
Retrieve number of bins.
Definition: CaloTowerSeg.h:428
CaloCell_ID.h
SG::OwnershipPolicy
OwnershipPolicy
describes the possible element ownership policies (see e.g. DataVector)
Definition: OwnershipPolicy.h:16
CaloTowerContainer::rend
reverse_iterator rend()
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:695
CaloTowerContainer::CaloTowerContainer
CaloTowerContainer()
Default constructor.
Definition: CaloTowerContainer.cxx:46
CaloTowerContainer::assign
void assign(InputIterator first, InputIterator last)
CaloTowerSeg::phimin
double phimin() const
Retrieve lower boundary value range.
Definition: CaloTowerSeg.h:453
CaloTowerContainer::e
double e(index_t etaIndex, index_t phiIndex) const
Return the tower energy at a given grid position.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:214
CaloTowerContainer::operator[]
CaloTower * operator[](size_type n)
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:660
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
CaloTowerContainer
Storable container class for CaloTower.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:77
CaloTowerContainer::iterator::iterator
iterator(Base::iterator it)
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:478
CaloTower::phi
virtual double phi() const override final
get phi data member
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTower.h:144
DataModel_detail::iterator
(Non-const) Iterator class for DataVector/DataList.
Definition: DVLIterator.h:184
CaloTowerSeg::dphi
double dphi() const
Retrieve bin size .
Definition: CaloTowerSeg.h:438
CaloTowerContainer::energy
double energy(int etaIndex, int phiIndex) const
Return the tower energy at a given grid position.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:243
beamspotman.n
n
Definition: beamspotman.py:731
CaloTowerContainer::erase
iterator erase(iterator first, iterator last)
CaloTowerContainer::sort
void sort()
INavigable4MomentumCollection.h
CaloCell_Base_ID::SUBCALO
SUBCALO
enumeration of sub calorimeters
Definition: CaloCell_Base_ID.h:46
CaloTowerContainer::insert
iterator insert(iterator position, value_type pElem)
CaloTowerContainer::getTowerIndices
bool getTowerIndices(const CaloTower *aTower, index_t &indexEta, index_t &indexPhi) const
Returns both and indices for a given tower.
Definition: CaloTowerContainer.cxx:235
CaloTowerContainer::getTowerEtaIndex
index_t getTowerEtaIndex(const CaloTower *aTower) const
Returns the index for a given tower.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:616
CaloTowerContainer::reverse_iterator
std::reverse_iterator< iterator > reverse_iterator
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:485
DataVector< CaloTower >::front
const CaloTower * front() const
Access the first element in the collection as an rvalue.
CaloTowerContainer::iterator::iterator
iterator()
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:477
CaloTowerContainer::getTower
CaloTower * getTower(index_t theIndex)
Returns a pointer to a tower with a given combined index.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:403
DataVector< CaloTower >::back
const CaloTower * back() const
Access the last element in the collection as an rvalue.
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
CaloTowerContainer::etamin
double etamin() const
Return lower value range boundary.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:566
DataVector< CaloTower >::rbegin
const_reverse_iterator rbegin() const noexcept
Return a const_reverse_iterator pointing past the end of the collection.
DataVector< CaloTower >::operator[]
const CaloTower * operator[](size_type n) const
Access an element, as an rvalue.
CaloTowerContainer::getCalos
size_t getCalos(std::vector< CaloCell_ID::SUBCALO > &theCalos) const
Retrieve the list of used calorimeters.
Definition: CaloTowerContainer.cxx:180
CaloTower
Data class for calorimeter cell towers.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTower.h:55
CaloTowerContainer::towerseg
const CaloTowerSeg & towerseg() const
Return a copy of the attached CaloTowerSeg.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:591
CaloTowerContainer::getTower
CaloTower * getTower(int eta, int phi)
Returns a pointer to a tower with given indices.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:372
CaloTowerContainer::erase
iterator erase(iterator position)
CaloTowerSeg::phiIndex
index_t phiIndex(double phiVal) const
Returns index for a given value.
Definition: CaloTowerSeg.h:499
CaloTowerContainer::getNumberOfCalos
size_t getNumberOfCalos() const
Returns the number of included calorimeters.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:560
CaloTowerSeg::etaphi
index_t etaphi(index_t etaInd, index_t phiInd) const
Returns combined continous index from , indices.
Definition: CaloTowerSeg.h:481
CaloTowerContainer::~CaloTowerContainer
virtual ~CaloTowerContainer()
Destructor.
CaloTowerContainer::isOutOfRange
bool isOutOfRange(index_t anIndex) const
Checks if an index is out of range.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:655
CaloTowerSeg::etamin
double etamin() const
Retrieve lower boundary value range.
Definition: CaloTowerSeg.h:443
eflowRec::phiIndex
unsigned int phiIndex(float phi, float binsize)
calculate phi index for a given phi
Definition: EtaPhiLUT.cxx:23
DataVector< CaloTower >::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
CaloTowerContainer::index_t
size_t index_t
Tower map index type.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:82
DataVector.h
An STL vector of pointers that by default owns its pointed-to elements.
CaloTowerContainer::at
CaloTower * at(size_type n)
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:665
InDetDD::other
@ other
Definition: InDetDD_Defs.h:16
CaloTowerContainer::clear
void clear()
CaloTowerContainer::m_towerSeg
CaloTowerSeg m_towerSeg
Tower grid descriptor.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:517
CLASS_DEF
#define CLASS_DEF(NAME, CID, VERSION)
associate a clid and a version to a type eg
Definition: Control/AthenaKernel/AthenaKernel/CLASS_DEF.h:64
DeMoScan.first
bool first
Definition: DeMoScan.py:536
CaloTowerContainer::swap
void swap(CaloTowerContainer &other)
Swap.
Definition: CaloTowerContainer.cxx:95
CaloTowerContainer::energy
double energy(double theEta, double thePhi) const
Return the tower energy at a given grid position.
Definition: CaloTowerContainer.cxx:208
CaloTowerContainer::m_outOfRange
static const index_t m_outOfRange
Index overflow indicator.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:530
CaloTowerSeg
Data object stores CaloTower segmentation.
Definition: CaloTowerSeg.h:37
CaloTowerContainer::deta
double deta() const
Return bin size .
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:570
CaloTowerContainer::reserve
void reserve(size_type n)
CaloTowerContainer::e
double e(double theEta, double thePhi) const
Return the tower energy at a given grid position.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:205
CaloTowerContainer::getTowerPhiIndex
index_t getTowerPhiIndex(const CaloTower *aTower) const
Returns the index for a given tower.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:633
CaloTowerContainer::pop_back
void pop_back()
DataVector< CaloTower >::at
const CaloTower * at(size_type n) const
Access an element, as an rvalue.
CaloTowerContainer::et
double et(int etaIndex, int phiIndex) const
Return the tower transverse energy at a given grid position.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:195
DataVector< CaloTower >::size_type
BASE::size_type size_type
Definition: DataVector.h:813
CaloTowerSeg::etaIndex
index_t etaIndex(double etaVal) const
Returns index for a given value.
Definition: CaloTowerSeg.h:489
SG_BASE
SG_BASE(CaloTowerContainer, DataVector< CaloTower >)
CaloTowerContainer::sort
void sort(COMPARE comp)
CaloTowerContainer::swapElement
void swapElement(size_type index, value_type newElem, reference oldElem)
CaloTowerContainer::setCalo
void setCalo(const CaloCell_ID::SUBCALO &nCalo)
Adds a calorimeter index to the tower.
Definition: CaloTowerContainer.cxx:169
DataVector< CaloTower >::size
size_type size() const noexcept
Returns the number of elements in the collection.
CaloTowerContainer::getTower
const CaloTower * getTower(index_t theIndex) const
Returns a const pointer to a tower with a given combined index.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:413
DataVector< CaloTower >::value_type
CaloTower * value_type
Definition: DataVector.h:815
CLASS_DEF.h
macros to associate a CLID to a type
CaloTowerContainer::begin
iterator begin()
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:680
CaloTowerContainer::phimin
double phimin() const
Return lower value range boundary.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:578
DataVector< CaloTower >::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
CaloTower::eta
virtual double eta() const override final
get eta data member
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTower.h:141
CaloTowerContainer::flagOutOfRange
index_t flagOutOfRange() const
Returns the index out-of-range indicator.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:651
CaloTowerContainer::iterator::iterator_adaptor_
boost::iterator_adaptor< iterator, Base::iterator, Base::value_type, Base::iterator::iterator_category, Base::value_type > iterator_adaptor_
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:474
CaloTowerContainer::front
CaloTower * front()
Definition: Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h:670