InDetDD::PixelDiodeTree Class Reference

Tree structure to find the position, index or pitch of a pixel on a semi-regular grid The grid is considered regular if sub grids resulting from consecutive splits in local-x and local-y direction have identical pitch. More...

#include <PixelDiodeTree.h>

Collaboration diagram for InDetDD::PixelDiodeTree:

Classes
struct	DiodeParam
	Parameters of a diode. More...
struct	DiodeProxy
	Helper class to access parameters of a diode. More...
struct	DiodeProxyWithPosition
	A diode proxy which caches the position of a diode. More...

Public Types
using	Vector2D = Amg::Vector2D
using	FloatType = Amg::Vector2D::Scalar
using	CellIndexType = int
using	IndexType = int
using	AttributeType = unsigned int

Public Member Functions
	PixelDiodeTree (const Vector2D &total_width)
unsigned int	addDiode (const Vector2D &width, AttributeType attribute)
void	setDiodeForSubMatrix (unsigned int sub_matrix_idx, unsigned int split_i, unsigned int diode_idx)
unsigned int	split (const std::array< CellIndexType, 2 > &idx_split, const Vector2D &pos_split, AttributeType an_attribute, unsigned int parent_idx=std::numeric_limits< unsigned int >::max(), unsigned int split_i=0)
template<typename T >
std::tuple< IndexType, IndexType, IndexType >	findFromT (const T &val, const std::vector< T > &split) const
	helper template to find the final node in a quad tree. More...
Vector2D	computePosition (PixelDiodeTree::IndexType sub_matrix_idx, PixelDiodeTree::IndexType diode_idx, const std::array< CellIndexType, 2 > &idx) const
	Compute the position of a certain diode in a certain sub-matrix. More...
std::array< CellIndexType, 2 >	computeIndex (PixelDiodeTree::IndexType sub_matrix_idx, PixelDiodeTree::IndexType diode_idx, const Vector2D &pos) const
	Compute the 2D index (row, column) of a certain diode in a certain sub-matrix. More...
Vector2D	findFromIdx (const std::array< CellIndexType, 2 > &idx) const
	find a diode by its 2D index (row, column) and compute the position relative to the center of the full diode matrix More...
DiodeProxy	diodeProxyFromIdx (const std::array< CellIndexType, 2 > &idx) const
	find a diode by its 2D index (row, column) the returned proxy allows to compute the position and provides access to the parameters of the diode More...
DiodeProxyWithPosition	diodeProxyFromIdxCachePosition (const std::array< CellIndexType, 2 > &idx) const
	find a diode by its 2D index (row, column) and compute the position of the diode the returned proxy caches the diode position and provides access to its parameters. More...
std::array< CellIndexType, 2 >	findFromPos (const Vector2D &pos) const
	Find a diode by the position relative to the center of the full diode matrix and compute its 2D index (row, column) More...
DiodeProxy	diodeProxyFromPos (const Vector2D &pos) const
	Find a diode by the position relative to the center of the full diode matrix. More...
bool	empty () const
	Return true if no sub-matrices are defined, indicates an invalid state. More...
const Vector2D &	totalWidth () const
	Return the total width of the diode matrix. More...
std::string	debugStringRepr () const
	Dump the diode tree structure into a string. More...
AttributeType	attribute (IndexType idx) const
	Get the attribute associated to a sub-matrix. More...
void	setAttribute (IndexType idx, AttributeType new_attribute)
	Set the attribute associated to a sub-matrix. More...
unsigned int	cloneSingleSplitsToUnusedHalf ()
	Clone half with valid split indices to "unused" half with invalid split indices. More...
PixelDiodeTree::Vector2D	computeTolerance (const std::array< PixelDiodeTree::CellIndexType, 2 > &matrix_dim) const
	Compute tolerance to ensure that a position is within the expected cell Due to limited floating point precision, positions may only yield the expected pixel index if they are not closer to the edge of the matrix or cell than this tolerance. More...
void	computeMatrixCorner (const std::array< PixelDiodeTree::CellIndexType, 2 > &matrix_dim)
	Compute the effective maximum lower and upper corner positions of the matrix. More...
bool	isInsideMatrix (const std::array< PixelDiodeTree::IndexType, 2 > &idx) const
	Return true if the given index describes a valid location inside the matrix. More...
bool	isInsideMatrix (const Amg::Vector2D &local_position) const
	Test whether the given local position is well within the matrix. More...

Static Public Member Functions
template<typename T >
static constexpr bool	validCellIndex (T cell_index)
	Test whether the cell_index either row or column index could be valid The index may still be outside the matrix. More...
template<typename T >
static constexpr std::array< PixelDiodeTree::CellIndexType, 2 >	makeCellIndex (T local_x_idx, T local_y_idx)
	Create a 2D cell index from the indices in local-x (phi, row) and local-y (eta, column) direction. More...
template<typename T_CellID >
static void	neighboursOfCell (const std::array< CellIndexType, 2 > &idx, const std::array< CellIndexType, 2 > &max_idx, std::vector< T_CellID > &neighbours)
	Get indices of all adjacent cells. More...

Static Public Attributes
static constexpr IndexType	s_invalid = std::numeric_limits<IndexType>::min()

Protected Attributes
std::vector< std::array< CellIndexType, 2 > >	m_idxSplit
std::vector< Vector2D >	m_posSplit
std::vector< AttributeType >	m_attribute
std::vector< std::array< IndexType, 4 > >	m_subMatrixIndex
DiodeParam	m_diodeParam
std::array< Vector2D, 2 >	m_matrixCorner {}
std::array< CellIndexType, 2 >	m_matrixDim {}

Detailed Description

Tree structure to find the position, index or pitch of a pixel on a semi-regular grid The grid is considered regular if sub grids resulting from consecutive splits in local-x and local-y direction have identical pitch.

Definition at line 32 of file PixelDiodeTree.h.

Member Typedef Documentation

AttributeType

using InDetDD::PixelDiodeTree::AttributeType = unsigned int

Definition at line 39 of file PixelDiodeTree.h.

CellIndexType

using InDetDD::PixelDiodeTree::CellIndexType = int

Definition at line 37 of file PixelDiodeTree.h.

FloatType

using InDetDD::PixelDiodeTree::FloatType = Amg::Vector2D::Scalar

Definition at line 36 of file PixelDiodeTree.h.

IndexType

using InDetDD::PixelDiodeTree::IndexType = int

Definition at line 38 of file PixelDiodeTree.h.

Vector2D

using InDetDD::PixelDiodeTree::Vector2D = Amg::Vector2D

Definition at line 35 of file PixelDiodeTree.h.

Constructor & Destructor Documentation

PixelDiodeTree()

InDetDD::PixelDiodeTree::PixelDiodeTree ( const Vector2D &  total_width )

inline

Definition at line 61 of file PixelDiodeTree.h.

                                               {
      m_diodeParam.addDiode(total_width); // dummy diode representing the total width of the entire diode matrix
   }

Member Function Documentation

addDiode()

unsigned int InDetDD::PixelDiodeTree::addDiode ( const Vector2D &  width, AttributeType  attribute  )

inline

Definition at line 66 of file PixelDiodeTree.h.

                                                                         {
      assert( m_diodeParam.m_width.size()>0);
      return m_diodeParam.addDiode(width, attribute);
   }

attribute()

AttributeType InDetDD::PixelDiodeTree::attribute ( IndexType  idx ) const

inline

Get the attribute associated to a sub-matrix.

Definition at line 328 of file PixelDiodeTree.h.

                                                {
      return m_attribute.at(idx);
   }

cloneSingleSplitsToUnusedHalf()

unsigned int InDetDD::PixelDiodeTree::cloneSingleSplitsToUnusedHalf

(

)

Clone half with valid split indices to "unused" half with invalid split indices.

For splits which only split one of the two axes, half of the sub-matrix indices will be invalid, to ensure that the position and index computation can be carried out also for indices or positions which are not well within the bounds of the matrix, the invalid indices of that half will be overwritten with indices of the half for which the indices are set.

Definition at line 11 of file PixelDiodeTree.cxx.

                                                           {
   unsigned int errors=0;
   constexpr std::array<IndexType,2> axis_offset{1,2};
   for (std::array<IndexType,4> &a_split : m_subMatrixIndex) {
      unsigned int n_invalid=0;
      IndexType good_idx=s_invalid;
      std::array<std::array<unsigned int,2>,2> n_invalid_halves{};
      for (unsigned int element_i=0; element_i<a_split.size(); ++element_i) {
         bool is_invalid = a_split.at(element_i)==s_invalid;
         unsigned int axis0=element_i/2;
         unsigned int axis1=element_i%2;
         n_invalid_halves[0][axis0]+=is_invalid;
         n_invalid_halves[1][axis1]+=is_invalid;
         if (is_invalid) ++n_invalid;
         else { good_idx=a_split[element_i]; }
      }
      if (n_invalid==3) {
         assert( good_idx != s_invalid);
         for (unsigned int element_i=0; element_i<a_split.size(); ++element_i) {
            a_split.at(element_i)=good_idx;
         }
      }
      else if (n_invalid==2) {
         unsigned int element_i=std::numeric_limits<unsigned int>::max();
         for (unsigned int axis_i=0; axis_i<2; ++axis_i) {
            for (unsigned int side_i=0; side_i<2; ++side_i) {
               if (n_invalid_halves[axis_i][side_i]==2 && n_invalid_halves[axis_i][side_i^1]==0) {
                  element_i=axis_offset[axis_i^1]*side_i;
                  IndexType other_element_i = axis_offset[axis_i^1]*(side_i==1 ? -1 : 1);
                  unsigned int element_end_i=element_i+axis_offset[axis_i]*2;
                  for(; element_i<element_end_i; element_i+=axis_offset[axis_i] ) {
                     a_split[ element_i ] = a_split[ element_i + other_element_i] ;
                  }
                  break;
               }
               if (element_i != std::numeric_limits<unsigned int>::max()) break;
            }
         }
         if (element_i == std::numeric_limits<unsigned int>::max()) {
            errors += 2;
         }
      }
      else if (n_invalid!=0) {
         errors +=2;
      }
   }
 
   return errors;
}

computeIndex()

std::array<CellIndexType,2> InDetDD::PixelDiodeTree::computeIndex ( PixelDiodeTree::IndexType  sub_matrix_idx, PixelDiodeTree::IndexType  diode_idx, const Vector2D &  pos  ) const

inline

Compute the 2D index (row, column) of a certain diode in a certain sub-matrix.

Parameters

sub_matrix_idx	the index of the sub-matrix whose "split-areas" refer to this diode
diode_idx	the index of the diode which gives access to the parameters of the this diode.
pos	the position of the diode relative to the center of the full matrix (not sub-matrix).

Returns

the 2D index of the diode (row,column)

Definition at line 162 of file PixelDiodeTree.h.

                                                                       {
      // pos = (idx - split-index) + 0.5) * pitch + split-position
      // idx = inr( (pos - split-position)/pitch - 0.5 + split-index + 0.5 (rounding) )
      std::array<CellIndexType,2> idx;
      assert( diode_idx>0);
      assert( static_cast<unsigned int>(diode_idx) < m_diodeParam.m_invWidth.size() ) ;
      assert( static_cast<unsigned int>(sub_matrix_idx) < m_idxSplit.size() );
      assert( static_cast<unsigned int>(sub_matrix_idx) < m_posSplit.size() );
      for (unsigned int axis_i=0; axis_i<2; ++axis_i) {
         assert( axis_i < m_diodeParam.m_invWidth[diode_idx].size() );
 
         idx[axis_i] = intFloor<CellIndexType>(    m_idxSplit[sub_matrix_idx][axis_i]
                                               +  (pos[axis_i]-m_posSplit[sub_matrix_idx][axis_i])
                                                   * m_diodeParam.m_invWidth[diode_idx][axis_i]);
      };
      return idx;
   }

computeMatrixCorner()

void InDetDD::PixelDiodeTree::computeMatrixCorner

(

const std::array< PixelDiodeTree::CellIndexType, 2 > &

matrix_dim

)

Compute the effective maximum lower and upper corner positions of the matrix.

The matrix will be shrunk to ensure that positions within the corners will yield valid indices. Note: needs to be called after the tree has been constructed, otherwise the isInsideMatrix calls will be undefined.

Definition at line 61 of file PixelDiodeTree.cxx.

                                                                                                  {
   assert( matrix_dim[0]>0 && matrix_dim[1]>0);
   m_matrixDim=matrix_dim;
   PixelDiodeTree::Vector2D tolerance = computeTolerance(matrix_dim);
   {
      DiodeProxyWithPosition lower_corner_proxy(diodeProxyFromIdxCachePosition(std::array<CellIndexType,2> {}));
      m_matrixCorner[0]=lower_corner_proxy.position() - lower_corner_proxy.width()*.5;
      for (unsigned int axis_i=0; axis_i<2; ++axis_i) {
         m_matrixCorner[0][axis_i] += tolerance[axis_i];
      }
   }
 
   {
      DiodeProxyWithPosition upper_corner_proxy(diodeProxyFromIdxCachePosition(std::array<PixelDiodeTree::CellIndexType,2> {matrix_dim[0]-1,
                                                                                                                            matrix_dim[1]-1}));
      m_matrixCorner[1]=upper_corner_proxy.position() + upper_corner_proxy.width()*.5 ;
      for (unsigned int axis_i=0; axis_i<2; ++axis_i) {
         m_matrixCorner[1][axis_i] -= tolerance[axis_i];
      }
   }
   if (!isInsideMatrix(findFromPos(m_matrixCorner[0])) || !isInsideMatrix(findFromPos(m_matrixCorner[1]))) {
      throw std::logic_error("Logic error! Matrix corner positions do not yield valid indices for this matrix!");
   }
}

computePosition()

Vector2D InDetDD::PixelDiodeTree::computePosition ( PixelDiodeTree::IndexType  sub_matrix_idx, PixelDiodeTree::IndexType  diode_idx, const std::array< CellIndexType, 2 > &  idx  ) const

inline

Compute the position of a certain diode in a certain sub-matrix.

Parameters

sub_matrix_idx	the index of the sub-matrix whose "split-areas" refer to this diode
diode_idx	the index of the diode which gives access to the parameters of the this diode.
idx	the 2D index of the diode (row,column)

Returns

the position of the diode relative to the center of the full matrix (not sub-matrix)

Definition at line 140 of file PixelDiodeTree.h.

                                                                        {
      // pos = (idx - split-index) + 0.5) * pitch + split-position
      Vector2D pos;
      assert( diode_idx>0);
      assert( static_cast<unsigned int>(diode_idx) < m_diodeParam.m_width.size() ) ;
      assert( static_cast<unsigned int>(sub_matrix_idx) < m_idxSplit.size() );
      for (unsigned int axis_i=0; axis_i<2; ++axis_i) {
         assert( axis_i < m_diodeParam.m_width[diode_idx].size() );
         pos[axis_i] = (    m_posSplit[sub_matrix_idx][axis_i]
                        + ((idx[axis_i]-m_idxSplit[sub_matrix_idx][axis_i])
                        + static_cast<FloatType>(.5)) * m_diodeParam.m_width[diode_idx][axis_i]);
      };
      return pos;
   }

computeTolerance()

PixelDiodeTree::Vector2D InDetDD::PixelDiodeTree::computeTolerance

(

const std::array< PixelDiodeTree::CellIndexType, 2 > &

matrix_dim

)

const

Compute tolerance to ensure that a position is within the expected cell Due to limited floating point precision, positions may only yield the expected pixel index if they are not closer to the edge of the matrix or cell than this tolerance.

Definition at line 86 of file PixelDiodeTree.cxx.

                                                                                                                       {
   PixelDiodeTree::Vector2D tolerance;
   for (unsigned int axis_i=0; axis_i<2; ++axis_i) {
      assert( matrix_dim[axis_i]>0 &&
              static_cast<unsigned int>(std::abs(matrix_dim[axis_i])) < std::numeric_limits<unsigned int>::max());
      unsigned int bits_i=0;
      for (; bits_i<16 && 1u<<bits_i < static_cast<unsigned int>(matrix_dim[axis_i])*3; ++bits_i);
      tolerance[axis_i]=(1u<<bits_i) * std::numeric_limits<PixelDiodeTree::FloatType>::epsilon();
   }
   return tolerance;
}

debugStringRepr()

std::string InDetDD::PixelDiodeTree::debugStringRepr

(

)

const

Dump the diode tree structure into a string.

Definition at line 98 of file PixelDiodeTree.cxx.

                                                {
   std::stringstream out;
   if (!m_diodeParam.m_width.empty()) {
      if (   m_idxSplit.size() != m_posSplit.size()
          || m_idxSplit.size() != m_subMatrixIndex.size()
          || m_idxSplit.size() != m_attribute.size()
          || m_diodeParam.m_width.size() != m_diodeParam.m_invWidth.size()
          || m_diodeParam.m_width.size() != m_diodeParam.m_attribute.size()) {
         // should never happer
         out << "PixelDiodeTree is inconsistent. Expected identical number of elements but has the following "
             << " container sizes:  index-split points : " << m_idxSplit.size()
             << " position split points : " << m_posSplit.size()
             << " submatrices : " << m_subMatrixIndex.size()
             << " attributes : " << m_attribute.size()
             << "; diodes : width : " << m_diodeParam.m_width.size()
             << " inverted width : " << m_diodeParam.m_invWidth.size()
             << " attributes : " << m_diodeParam.m_attribute.size()
             << ".\n";
      }
      else {
         out << "PixelDiodeTree total width : " << m_diodeParam.m_width[0][0] << "x" << m_diodeParam.m_width[0][1] << " mm^2" << "\n:";
         std::vector<std::pair<IndexType,unsigned int> > submatrix_stack;
         submatrix_stack.push_back(std::make_pair(0u,2u));
         while (!submatrix_stack.empty()) {
            auto [submatrix_idx, margin] = submatrix_stack.back();
            submatrix_stack.pop_back();
            out << std::setw(margin) << ' ';
            if (submatrix_idx < 0) {
               if (submatrix_idx!=s_invalid) {
                  unsigned int diode_idx=std::abs(submatrix_idx);
                  if (diode_idx<m_diodeParam.m_width.size()) {
                     out << " diode width " << m_diodeParam.m_width[diode_idx][0] << " x " << m_diodeParam.m_width[diode_idx][1]
                         << " attribute " << std::hex << m_diodeParam.m_attribute[diode_idx] << std::dec << "\n";
                  }
               }
            }
            else if (static_cast<std::size_t>(submatrix_idx) >= m_idxSplit.size()) {
               out << "Invalid sub-matrix index : " << submatrix_idx << "\n";
            }
            else {
               out << " split at (row,col) " << m_idxSplit[submatrix_idx][0] << " " << m_idxSplit[submatrix_idx][1]
                   << " , position (local-x/-y) " << m_posSplit[submatrix_idx][0] <<  " " << m_posSplit[submatrix_idx][1]
                   << " attribute " << std::hex << m_attribute[submatrix_idx] << std::dec
                   << " sub-matrices (diodes): ";
               for (unsigned int split_i=0; split_i<m_subMatrixIndex[submatrix_idx].size(); ++split_i) {
                  out << (split_i==2 ? " | " : " ");
                  if (m_subMatrixIndex[submatrix_idx][split_i] == s_invalid) {
                     out << "-";
                  }
                  else {
                     out << m_subMatrixIndex[submatrix_idx][split_i];
                  }
               }
               out << "\n";
               for (std::array<IndexType,4>::const_reverse_iterator iter = m_subMatrixIndex[submatrix_idx].rbegin();
                    iter != m_subMatrixIndex[submatrix_idx].rend();
                    ++iter) {
                  if (*iter != s_invalid) {
                     submatrix_stack.push_back( std::make_pair( *iter, margin+2));
                  }
               }
            }
         }
      }
   }
   else {
      out << "PixelDiodeTree with " << m_subMatrixIndex.size() << " has no diodes." << "\n";
   }
   return out.str();
}

diodeProxyFromIdx()

DiodeProxy InDetDD::PixelDiodeTree::diodeProxyFromIdx ( const std::array< CellIndexType, 2 > &  idx ) const

inline

find a diode by its 2D index (row, column) the returned proxy allows to compute the position and provides access to the parameters of the diode

Definition at line 270 of file PixelDiodeTree.h.

                                                                            {
      auto [sub_matrix_idx,diode_idx, submatrix_i] = findFromT(idx,m_idxSplit);
      return DiodeProxy{this, sub_matrix_idx, diode_idx};
   }

diodeProxyFromIdxCachePosition()

DiodeProxyWithPosition InDetDD::PixelDiodeTree::diodeProxyFromIdxCachePosition ( const std::array< CellIndexType, 2 > &  idx ) const

inline

find a diode by its 2D index (row, column) and compute the position of the diode the returned proxy caches the diode position and provides access to its parameters.

Definition at line 276 of file PixelDiodeTree.h.

                                                                                                     {
      auto [sub_matrix_idx,diode_idx, submatrix_i] = findFromT(idx,m_idxSplit);
      DiodeProxyWithPosition proxy(this, sub_matrix_idx, diode_idx, computePosition(sub_matrix_idx, diode_idx, idx));
      return proxy;
   }

diodeProxyFromPos()

DiodeProxy InDetDD::PixelDiodeTree::diodeProxyFromPos ( const Vector2D &  pos ) const

inline

Find a diode by the position relative to the center of the full diode matrix.

The returned proxy allows to compute the 2D index (row, column) and provides access to the parameters of the diode

Definition at line 288 of file PixelDiodeTree.h.

                                                           {
      auto [sub_matrix_idx,diode_idx, submatrix_i] = findFromT(pos,m_posSplit);
      return DiodeProxy{this, sub_matrix_idx, diode_idx};
   }

empty()

bool InDetDD::PixelDiodeTree::empty ( ) const

inline

Return true if no sub-matrices are defined, indicates an invalid state.

Definition at line 294 of file PixelDiodeTree.h.

{ return m_subMatrixIndex.empty(); }

findFromIdx()

Vector2D InDetDD::PixelDiodeTree::findFromIdx ( const std::array< CellIndexType, 2 > &  idx ) const

inline

find a diode by its 2D index (row, column) and compute the position relative to the center of the full diode matrix

Definition at line 264 of file PixelDiodeTree.h.

                                                                    {
      auto [sub_matrix_idx,diode_idx, submatrix_i] = findFromT(idx,m_idxSplit);
      return computePosition(sub_matrix_idx, diode_idx,idx);
   }

findFromPos()

std::array<CellIndexType,2> InDetDD::PixelDiodeTree::findFromPos ( const Vector2D &  pos ) const

inline

Find a diode by the position relative to the center of the full diode matrix and compute its 2D index (row, column)

Definition at line 282 of file PixelDiodeTree.h.

                                                                    {
      auto [sub_matrix_idx,diode_idx, submatrix_i] = findFromT(pos,m_posSplit);
      return computeIndex(sub_matrix_idx,diode_idx,pos);
   }

findFromT()

template<typename T >

std::tuple<IndexType,IndexType, IndexType> InDetDD::PixelDiodeTree::findFromT ( const T &  val, const std::vector< T > &  split  ) const

inline

helper template to find the final node in a quad tree.

Definition at line 119 of file PixelDiodeTree.h.

                                                {
      IndexType sub_matrix_idx=0;
      IndexType last_sub_matrix_idx=0;
      unsigned int submatrix_i=0;
      while (sub_matrix_idx>=0) {
         assert( static_cast<std::size_t>(sub_matrix_idx) < split.size() );
         last_sub_matrix_idx=sub_matrix_idx;
         submatrix_i = (val[0] >= split[sub_matrix_idx][0]) + (val[1] >= split[sub_matrix_idx][1])*2;
         sub_matrix_idx=m_subMatrixIndex[sub_matrix_idx][submatrix_i];
      }
      assert( sub_matrix_idx != s_invalid);
      assert( static_cast<size_t>(std::abs(sub_matrix_idx)) < m_diodeParam.m_width.size() );
      return std::make_tuple(last_sub_matrix_idx, std::abs(sub_matrix_idx), submatrix_i);
   }

isInsideMatrix() [1/2]

bool InDetDD::PixelDiodeTree::isInsideMatrix ( const Amg::Vector2D &  local_position ) const

inline

Test whether the given local position is well within the matrix.

Definition at line 364 of file PixelDiodeTree.h.

                                                                {
      // corner positions are moved to the inside of the matrix to account for floating point
      // tolerances so >= && <= means "well" inside the matrix.
      return (   local_position[0]>=m_matrixCorner[0][0] && local_position[0]<=m_matrixCorner[1][0]
              && local_position[1]>=m_matrixCorner[0][1] && local_position[1]<=m_matrixCorner[1][1]);
   }

isInsideMatrix() [2/2]

bool InDetDD::PixelDiodeTree::isInsideMatrix ( const std::array< PixelDiodeTree::IndexType, 2 > &  idx ) const

inline

Return true if the given index describes a valid location inside the matrix.

Definition at line 359 of file PixelDiodeTree.h.

                                                                             {
      return idx[0]>=0 && idx[1]>=0 && idx[0] < m_matrixDim[0] && idx[1] < m_matrixDim[1];
   }

makeCellIndex()

template<typename T >

static constexpr std::array<PixelDiodeTree::CellIndexType,2> InDetDD::PixelDiodeTree::makeCellIndex ( T  local_x_idx, T  local_y_idx  )

inlinestaticconstexpr

Create a 2D cell index from the indices in local-x (phi, row) and local-y (eta, column) direction.

Definition at line 320 of file PixelDiodeTree.h.

                                                                                                        {
      assert( validCellIndex(local_x_idx) && validCellIndex(local_y_idx) );
      return std::array<PixelDiodeTree::CellIndexType,2>{
         static_cast<PixelDiodeTree::CellIndexType>(local_x_idx),
         static_cast<PixelDiodeTree::CellIndexType>(local_y_idx)};
   }

neighboursOfCell()

template<typename T_CellID >

void InDetDD::PixelDiodeTree::neighboursOfCell ( const std::array< CellIndexType, 2 > &  idx, const std::array< CellIndexType, 2 > &  max_idx, std::vector< T_CellID > &  neighbours  )

static

Get indices of all adjacent cells.

Definition at line 389 of file PixelDiodeTree.h.

                                                                        {
   neighbours.reserve(8);
   std::array<std::array<PixelDiodeTree::CellIndexType,2>,2> outer_idx {
      std::array<PixelDiodeTree::CellIndexType,2>{idx[0]-1,idx[0]+1},
      std::array<PixelDiodeTree::CellIndexType,2>{idx[1]-1,idx[1]+1}
   };
 
   if (outer_idx[0][0]>=0          &&  outer_idx[1][0]>=0)         neighbours.emplace_back(outer_idx[0][0],outer_idx[1][0]);
   if (                                outer_idx[1][0]>=0)         neighbours.emplace_back(idx[0],         outer_idx[1][0]);
   if (outer_idx[0][1]<max_idx[0]  &&  outer_idx[1][0]>=0)         neighbours.emplace_back(outer_idx[0][1],outer_idx[1][0]);
   if (outer_idx[0][1]<max_idx[0])                                 neighbours.emplace_back(outer_idx[0][1],idx[1]);
   if (outer_idx[0][1]<max_idx[0]  &&  outer_idx[1][1]<max_idx[1]) neighbours.emplace_back(outer_idx[0][1],outer_idx[1][1]);
   if (                                outer_idx[1][1]<max_idx[1]) neighbours.emplace_back(idx[0],         outer_idx[1][1]);
   if (outer_idx[0][0]>=0          &&  outer_idx[1][1]<max_idx[1]) neighbours.emplace_back(outer_idx[0][0],outer_idx[1][1]);
   if (outer_idx[0][0]>=0                                        ) neighbours.emplace_back(outer_idx[0][0],idx[1]);
}

setAttribute()

void InDetDD::PixelDiodeTree::setAttribute ( IndexType  idx, AttributeType  new_attribute  )

inline

Set the attribute associated to a sub-matrix.

Parameters

idx	the index of the sub-matrix
new_attribute	the new attribute for the sub-matrix

Definition at line 334 of file PixelDiodeTree.h.

                                                                 {
      m_attribute.at(idx)=new_attribute;
   }

setDiodeForSubMatrix()

void InDetDD::PixelDiodeTree::setDiodeForSubMatrix ( unsigned int  sub_matrix_idx, unsigned int  split_i, unsigned int  diode_idx  )

inline

Definition at line 79 of file PixelDiodeTree.h.

                                                                                                         {
      assert( diode_idx > 0 && diode_idx < std::numeric_limits<IndexType>::max());
      assert( sub_matrix_idx < m_subMatrixIndex.size());
      assert( split_i <m_subMatrixIndex[sub_matrix_idx].size() );
      m_subMatrixIndex.at(sub_matrix_idx)[split_i]=-static_cast<IndexType>(diode_idx);
   }

split()

unsigned int InDetDD::PixelDiodeTree::split ( const std::array< CellIndexType, 2 > &  idx_split, const Vector2D &  pos_split, AttributeType  an_attribute, unsigned int  parent_idx = std::numeric_limits<unsigned int>::max(), unsigned int  split_i = 0  )

inline

Definition at line 92 of file PixelDiodeTree.h.

                                               {
      assert( m_idxSplit.size() == m_posSplit.size());
      assert( m_idxSplit.size() == m_subMatrixIndex.size());
      assert( m_idxSplit.size() == m_attribute.size());
      unsigned int this_submatrix_idx = m_idxSplit.size();
      m_idxSplit.push_back(idx_split);
      m_posSplit.push_back(pos_split);
      assert( PixelDiodeTree::s_invalid < 0);
      assert( -static_cast<IndexType>(m_diodeParam.m_width.size()) > PixelDiodeTree::s_invalid);
      m_subMatrixIndex.push_back(std::array<PixelDiodeTree::IndexType,4>{PixelDiodeTree::s_invalid, PixelDiodeTree::s_invalid,
                                                                         PixelDiodeTree::s_invalid, PixelDiodeTree::s_invalid});
      m_attribute.push_back(an_attribute);
      if (parent_idx != std::numeric_limits<unsigned int>::max()) {
         assert( split_i < m_subMatrixIndex[parent_idx].size());
         m_subMatrixIndex.at(parent_idx)[split_i]=this_submatrix_idx;
      }
 
      return this_submatrix_idx;
   }

totalWidth()

const Vector2D& InDetDD::PixelDiodeTree::totalWidth ( ) const

inline

Return the total width of the diode matrix.

Definition at line 297 of file PixelDiodeTree.h.

                                      {
      // constructor should store total width here, empty means that this diode tree is not properly constructed.
      assert(!m_diodeParam.m_width.empty());
      return m_diodeParam.m_width[0];
   }

validCellIndex()

template<typename T >

static constexpr bool InDetDD::PixelDiodeTree::validCellIndex ( T  cell_index )

inlinestaticconstexpr

Test whether the cell_index either row or column index could be valid The index may still be outside the matrix.

Definition at line 309 of file PixelDiodeTree.h.

                                                      {
      if constexpr( std::is_signed_v<T>) {
         return cell_index>= std::numeric_limits<CellIndexType>::min() && cell_index < std::numeric_limits<CellIndexType>::max();
      }
      else {
         return cell_index < std::numeric_limits<CellIndexType>::max();
      }
   }

Member Data Documentation

m_attribute

std::vector<AttributeType> InDetDD::PixelDiodeTree::m_attribute

protected

Definition at line 380 of file PixelDiodeTree.h.

m_diodeParam

DiodeParam InDetDD::PixelDiodeTree::m_diodeParam

protected

Definition at line 383 of file PixelDiodeTree.h.

m_idxSplit

std::vector<std::array<CellIndexType, 2> > InDetDD::PixelDiodeTree::m_idxSplit

protected

Definition at line 378 of file PixelDiodeTree.h.

m_matrixCorner

std::array<Vector2D,2> InDetDD::PixelDiodeTree::m_matrixCorner {}

protected

Definition at line 384 of file PixelDiodeTree.h.

m_matrixDim

std::array<CellIndexType,2> InDetDD::PixelDiodeTree::m_matrixDim {}

protected

Definition at line 385 of file PixelDiodeTree.h.

m_posSplit

std::vector<Vector2D > InDetDD::PixelDiodeTree::m_posSplit

protected

Definition at line 379 of file PixelDiodeTree.h.

m_subMatrixIndex

std::vector<std::array<IndexType, 4> > InDetDD::PixelDiodeTree::m_subMatrixIndex

protected

Definition at line 382 of file PixelDiodeTree.h.

s_invalid

constexpr IndexType InDetDD::PixelDiodeTree::s_invalid = std::numeric_limits<IndexType>::min()

staticconstexpr

Definition at line 40 of file PixelDiodeTree.h.

---

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

• PixelDiodeTree.h
• PixelDiodeTree.cxx