Iterator over a rectangular window of towers. More...

#include <CaloTowerSeg.h>

Inheritance diagram for CaloTowerSeg::SubSegIterator< TOWER_ITERATOR >:

Collaboration diagram for CaloTowerSeg::SubSegIterator< TOWER_ITERATOR >:

Public Member Functions
	SubSegIterator (const TOWER_ITERATOR &it, size_t nphi, size_t nphi_skip, size_t phipos)
	Constructor.
SubSegIterator &	operator++ ()
	Advance to the next tower in the window.
size_t	itower () const
	The tower index to which the iterator is referring.

Static Public Member Functions
static SubSegIterator	make (TOWER_ITERATOR beg, const SubSeg &subseg)
	Construct a new iterator for iterating over a window.

Private Attributes
size_t	m_nphi
size_t	m_nphi_skip
size_t	m_phipos
size_t	m_phipos2
size_t	m_itower

Detailed Description

template<class TOWER_ITERATOR>
class CaloTowerSeg::SubSegIterator< TOWER_ITERATOR >

Iterator over a rectangular window of towers.

This is based on an existing iterator over all towers, TOWER_ITERATOR. This iterator should supply operator++ and operator+=.

There is no end iterator defined; you need to count the iterations up to the size of the window.

This is a little complicated; we need to take phi wrapping into account too.

Here's some bad ascii art to help illustrate:

       *...............*
       * ! ! ! ! ! ! ! *
       *...*******.....*
       * ! *0|1|2* ! ! *        phi ->
       *...*-----*.....*
       * ! *3|4|5* ! ! *    eta
       *...*******.....*     |
       * ! ! ! ! ! ! ! *     v
       ***.........*****
       *2* ! ! ! ! *0|1*
       *-*.........*****
       *5* ! ! ! ! *3|4*
       ***.........*****
       *               *

Consider the upper window first. We initialize the base TOWER_ITERATOR pointing at the proper tower. Then m_phipos counts the phi index within the window; here from 0 to 2. When m_phipos reaches the window size, m_nphi, then we need go to the next row. We add m_nphi_skip to the tower iterator, reset the entries iterator appropriately, and reset m_phipos to 0.

For the case of phi-wrapping, this mostly still works: we just need to initialize m_phipos appropriately. In the example here of the lower window, m_phipos should start at 2. Then we apply the skip when we go across to the right half of the window, and we just wrap around at the right edge; here, we go from the tower numbered 1 to 5.

But this means that in this case, we don't visit the towers in order, so we need some way of getting the tower number within the window from the iterator, so that we can apply the mapping to the correct tower. That's done by m_itower and m_phipos2. m_phipos2 is similar to m_phipos, except that it always starts at 0. Thus, then m_phipos reaches m_nphi, we need to skip; when m_phipos2 reaches m_nphi, we're shifting down to the next eta row.

Definition at line 317 of file CaloTowerSeg.h.

Constructor & Destructor Documentation

◆ SubSegIterator()

template<class TOWER_ITERATOR>

CaloTowerSeg::SubSegIterator< TOWER_ITERATOR >::SubSegIterator	(	const TOWER_ITERATOR &	it,
		size_t	nphi,
		size_t	nphi_skip,
		size_t	phipos )

Constructor.

Parameters

it	Iterator of the starting tower.
entry	Iterator of the corresponding starting entry.
store	The CaloTowerStore within which we're iterating.
nphi	The phi size of the window.
nphi_skip	The number of towers to skip to go from the right edge of the window to the left. Should be (phi-size of store) - (phi-size of window) + 1
phipos	The starting phi position for the iteration. Should be 0 if there's no phi wrapping. Otherwise, it's the phi index (0-based) of the window tower at the left side of the store.

Definition at line 655 of file CaloTowerSeg.h.

  : TOWER_ITERATOR (it),
    m_nphi (nphi),
    m_nphi_skip (nphi_skip),
    m_phipos (phipos),
    m_phipos2 (0),
    m_itower (0)
{
}

Member Function Documentation

◆ itower()

template<class TOWER_ITERATOR>

size_t CaloTowerSeg::SubSegIterator< TOWER_ITERATOR >::itower ( ) const

inline

The tower index to which the iterator is referring.

This is the index within the window. 0-based.

Definition at line 713 of file CaloTowerSeg.h.

{
  return m_itower + m_phipos;
}

◆ make()

template<class TOWER_ITERATOR>

CaloTowerSeg::SubSegIterator< TOWER_ITERATOR > CaloTowerSeg::SubSegIterator< TOWER_ITERATOR >::make	(	TOWER_ITERATOR	beg,
		const SubSeg &	subseg )

static

Construct a new iterator for iterating over a window.

Parameters

beg	Tower iterator pointing at the start of the segmentation within which this window is defined.
subseg	The window over which we want to iterate.

Definition at line 608 of file CaloTowerSeg.h.

{
  const CaloTowerSeg& parent = subseg.parent();
  size_t itower;
  size_t phipos;
 
  if (subseg.phimax() < subseg.phimin()) {
    // phi wraparound case
    itower = parent.etaphi (subseg.etamin(), 1);
    phipos = subseg.nphi() - subseg.phimax();
  }
  else {
    // no phi wrapping
    itower = parent.etaphi (subseg.etamin(), subseg.phimin());
    phipos = 0;
  }
 
  // Should never happen, but check explicitly to prevent a coverity warning.
  if (itower == outOfRange) std::abort();
 
  beg += itower;
  return SubSegIterator (beg,
                         subseg.nphi(),
                         parent.nphi() - subseg.nphi() + 1,
                         phipos);
}

◆ operator++()

template<class TOWER_ITERATOR>

CaloTowerSeg::SubSegIterator< TOWER_ITERATOR > & CaloTowerSeg::SubSegIterator< TOWER_ITERATOR >::operator++ ( )

inline

Advance to the next tower in the window.

Note: The iteration may not visit the towers in index order. Use itower() to find the index of the tower to which the iterator is currently referring.

Definition at line 680 of file CaloTowerSeg.h.

{
  // Advance phi position.
  ++m_phipos;
  if (m_phipos < m_nphi) {
    // Not to the gap yet; just advance underlying iterator.
    TOWER_ITERATOR::operator++();
  }
  else {
    // At the gap.  Skip ahead by the size of the gap,
    // and reset the phi position.
    m_phipos = 0;
    TOWER_ITERATOR::operator+= (m_nphi_skip);
  }
  
  // Bump the tower index counter when we wrap around in phi.
  if (++m_phipos2 >= m_nphi) {
    m_phipos2 = 0;
    m_itower += m_nphi;
  }
 
  return *this;
}

Definition at line 375 of file CaloTowerSeg.h.

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

CaloTowerSeg.h

Public Member Functions

Static Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ SubSegIterator()

Member Function Documentation

◆ itower()

◆ make()

◆ operator++()

Member Data Documentation

◆ m_itower

◆ m_nphi

◆ m_nphi_skip

◆ m_phipos

◆ m_phipos2