InDetDD::PixelDiodeMatrix Class Reference

Class used to describe the segmentation of the pixel and allow for conversion between cell id and position. More...

#include <PixelDiodeMatrix.h>

Collaboration diagram for InDetDD::PixelDiodeMatrix:

Public Types
enum	Direction { phiDir , etaDir }

Public Member Functions
	~PixelDiodeMatrix ()=default
	Destructor.
const PixelDiodeMatrix *	cellIdOfPosition (const Amg::Vector2D &position, SiCellId &cellId) const
	Return cell Id corresponding to a relative position within the matrix.
const PixelDiodeMatrix *	positionOfCell (const SiCellId &cellId, Amg::Vector2D &position) const
	Search diode matching the given cell id and compute its position.
double	phiWidth () const
	Width in phi (x) direction.
double	phiHalfWidth () const
double	phiWidthInverse () const
	Inverse of width in phi (x) direction.
double	etaWidth () const
	Width in eta (y) direction.
double	etaHalfWidth () const
double	etaWidthInverse () const
	Inverse of width in eta (y) direction.
int	phiCells () const
	Number of cells in phi (x) direction.
int	etaCells () const
	Number of cells in eta (y) direction.
bool	singleCell () const
	Query wether the matrix is just a single cell.
std::string	createDebugStringRepr () const
	Create debug representation.

Static Public Member Functions
static std::shared_ptr< const PixelDiodeMatrix >	construct (double phiWidth, double etaWidth)
	Construct method for just a single cell.
static std::shared_ptr< const PixelDiodeMatrix >	construct (Direction direction, std::shared_ptr< const PixelDiodeMatrix > lowerCell, std::shared_ptr< const PixelDiodeMatrix > middleCells, int numCells, std::shared_ptr< const PixelDiodeMatrix > upperCells)
	Construct method with multiple matrices.

Private Member Functions
	PixelDiodeMatrix ()
	Hidden constructor.
void	initialize (double phiWidth, double etaWidth)
	Initialize for just a single cell.
void	initialize (Direction direction, std::shared_ptr< const PixelDiodeMatrix > lowerCell, std::shared_ptr< const PixelDiodeMatrix > middleCells, int numCells, std::shared_ptr< const PixelDiodeMatrix > upperCells)
	Initialize for multiple matrices.
std::string	createDebugStringRepr (unsigned int level) const
	Create debug representation for a specific level.

Static Private Member Functions
static const PixelDiodeMatrix *	positionOfCell (const PixelDiodeMatrix *matrix, const SiCellId &cellId, Amg::Vector2D &position)
	Search diode matching the given cell id and compute its position.

Private Attributes
double	m_phiWidth = 0
double	m_phiWidthInverse = 0
double	m_etaWidth = 0
double	m_etaWidthInverse = 0
int	m_phiCells = 0
int	m_etaCells = 0
Direction	m_direction {}
int	m_numCells = 0
std::shared_ptr< const PixelDiodeMatrix >	m_lowerCell
std::shared_ptr< const PixelDiodeMatrix >	m_middleCells
std::shared_ptr< const PixelDiodeMatrix >	m_upperCell
bool	m_singleCell = false

Detailed Description

Class used to describe the segmentation of the pixel and allow for conversion between cell id and position.

The class PixelDiodeMatrix represents what it calls a cell. In the context of this class a cell can either be just a simple cell as one would normally think of a pixel cell (eg a 50x400um or 50x600um cell) or it can be a container of multiple cells. To allow for different size cells and layout, it contains a lower cell, an upper cell and multiple middle cells. The middle cells are all the same (so all have the same size), but the upper and lower cells can be different and can have different size or be left out if they are not needed. The direction of replication is also specified (eta or phi direction). The size of the cells in the direction orthoganal to the replication direction must all be the same (there is no check for this though).

To help understand the structure and its use, consider the current pixel geometry. The pixel module has two cell sizes short and long cells. These are refered to as normal and big bellow. The long cells are in the region at the edge of the the FE chips in order to cover the gap between FE chips.

The assembly of this structure is done when building the sensitive detector in GeoModel in the class GeoPixelSiCrystal.

• normalCell (short pixel cell) 50x400um
• bigCell (long pixel cell): 50x600um
• singleChipRow (represents one row associated to a FE)
  • Size: phiWidth = 50um, etaWidth = 600*2+400*16) um = 7.6 CLHEP::mm
  • upper cell: bigCell
  • middle cells: 16 x normalCell
  • lower cell: bigcell
  • direction: eta
• singleRow (represents a row of cells covering the full length of the module)
  • Size: phiWidth = 50um, etaWidth = 8 * (600*2+400*16) um = 60.8 CLHEP::mm
  • upper cell: none
  • middle cells: 8 x singleChipRow
  • lower cell: none
  • direction: eta
• fullMatrix (represents the full module)
  • Size: phiWidth = 50 * 328 um = 16.4 CLHEP::mm, etaWidth = 60.8 CLHEP::mm
  • upper cell: none
  • middle cells: 328 x singleRow
  • lower cell: non
  • direction: phi

Each cell knows its total size and total number of child cells in the phi and eta direction. This is determined by totaling up these quantities when the object is constructed.

The structure allows for efficient navigation from cell number to position and vice-versa. There are two main methods which allow for this navigation: cellIdOfPosition() (from cell id to position) and positionOfCell() (from position to cell id).

As it is assumed that child cells fill up completely its parent, there is no range check in these methods. The methods are called from PixelDiodeMap where it first checks that is within range of the top level cell (refered to as the top level matrix).

PixelDiodeMatrix might inherit std::shared_ptr but needs to return std::shared_ptr of this pointer. To do this, std::enable_shared_from_this and shared_from_this() have to be used. https://en.cppreference.com/w/cpp/memory/enable_shared_from_this

See the description of these methods for more details.

Author

Grant Gorfine

• modified & maintained: Nick Styles, Andreas Salzburger

Definition at line 93 of file PixelDiodeMatrix.h.

Member Enumeration Documentation

Direction

enum InDetDD::PixelDiodeMatrix::Direction

Enumerator
phiDir
etaDir

Definition at line 97 of file PixelDiodeMatrix.h.

{phiDir, etaDir};

Constructor & Destructor Documentation

~PixelDiodeMatrix()

InDetDD::PixelDiodeMatrix::~PixelDiodeMatrix ( )

default

Destructor.

PixelDiodeMatrix()

InDetDD::PixelDiodeMatrix::PixelDiodeMatrix ( )

inlineprivate

Hidden constructor.

Definition at line 161 of file PixelDiodeMatrix.h.

{};

Member Function Documentation

cellIdOfPosition()

const PixelDiodeMatrix * InDetDD::PixelDiodeMatrix::cellIdOfPosition	(	const Amg::Vector2D &	relPosition,
		SiCellId &	cellId ) const

Return cell Id corresponding to a relative position within the matrix.

Description.

The cellId is modified and returns the id relative to the passed cellId. That is, it adds the relative cellId to the cellId passed to the function. A pointer to the correspond cell is returned. This can be used to get the size of the cell.

Overview of algoritm:

• Before calling this method on the top level matrix the 2D position is calculated relative to the bottom left corner.
• The method cellIdOfPosition is always called with the position relative to bottom left of the cell and the cell id of bottom left child cell. For the top level matrix this is the position (-halfWidth, -halfLength) and a starting cell id of (0,0).
• It first checks if it is in the lower cell (if it exists).
• If not, it determines which cell by dividing the position relative to the start of the cell array by the pitch in that direction.
• If it is beyond the range of the middle cells it is taken as being in the upper cell.
• The cell number is added to the cellId that is passed to the method
• Once the cell is determined the function is called recursively until it reaches a single cell.

Definition at line 131 of file PixelDiodeMatrix.cxx.

{
  using Trk::distPhi;
  using Trk::distEta;
 
  if (m_singleCell) {
    return this;
  }
 
  double relPosDir = 0; // Relative position along m_direction
  int startIndex = 0;
  double pitch = 0;
  double pitchInverse = 0;
  int middleCells = 0;
 
  if (m_direction == phiDir) {
 
    relPosDir = relPosition[distPhi];
    pitch = m_middleCells->phiWidth();
    pitchInverse = m_middleCells->phiWidthInverse();
    middleCells = m_middleCells->phiCells();
 
    if (m_lowerCell) {
      if (relPosDir < m_lowerCell->phiWidth()) {
        return m_lowerCell->cellIdOfPosition(relPosition, cellId);
      } else {
        relPosDir  -= m_lowerCell->phiWidth();
        startIndex += m_lowerCell->phiCells();
      }
    }
  } else { // etaDir
 
    relPosDir = relPosition[distEta];
    pitch = m_middleCells->etaWidth();
    pitchInverse = m_middleCells->etaWidthInverse();
    middleCells = m_middleCells->etaCells();
 
    if (m_lowerCell) {
      if (relPosDir < m_lowerCell->etaWidth()) {
        return m_lowerCell->cellIdOfPosition(relPosition, cellId);
      } else {
        relPosDir  -= m_lowerCell->etaWidth();
        startIndex += m_lowerCell->etaCells();
      }
    }
  }
 
 
  int index = relPosDir * pitchInverse;
 
  const PixelDiodeMatrix *nextCell{};
 
  bool outOfBounds = index >= m_numCells;
  if (m_upperCell != nullptr && outOfBounds) {
    // We are in the upper cell.
    index = m_numCells;
    nextCell = m_upperCell.get();
  } else {
    // We are in the middle cells
    // Make sure its in range (in case of rounding errors)
    if (outOfBounds) index = m_numCells - 1;
    nextCell = m_middleCells.get();
  }
 
  if (index > 0) { // Make sure its in range (in case of rounding errors)
    relPosDir  -= index *  pitch;
    startIndex += index *  middleCells;
  }
 
  int newPhiIndex = cellId.phiIndex();
  int newEtaIndex = cellId.etaIndex();
  const PixelDiodeMatrix *cell{};
 
  if (m_direction == phiDir) {
    if (nextCell->singleCell()) {
      newPhiIndex += startIndex;
      cell = nextCell;
    } else {
      Amg::Vector2D newRelPos(relPosDir, relPosition[distEta]);
      SiCellId relId(0,0);
      cell = nextCell->cellIdOfPosition(newRelPos, relId);
      newPhiIndex += startIndex + relId.phiIndex();
      newEtaIndex += relId.etaIndex();
    }
  } else {
    if (nextCell->singleCell()) {
      newEtaIndex += startIndex;
      cell = nextCell;
    } else {
      Amg::Vector2D newRelPos(relPosition[distPhi], relPosDir);
      SiCellId relId(0,0);
      cell = nextCell->cellIdOfPosition(newRelPos, relId);
      newPhiIndex += relId.phiIndex();
      newEtaIndex += startIndex + relId.etaIndex();
    }
  }
 
  cellId = SiCellId(newPhiIndex, newEtaIndex);
  return cell;
}

construct() [1/2]

std::shared_ptr< const PixelDiodeMatrix > InDetDD::PixelDiodeMatrix::construct ( Direction direction, std::shared_ptr< const PixelDiodeMatrix > lowerCell, std::shared_ptr< const PixelDiodeMatrix > middleCells, int numCells, std::shared_ptr< const PixelDiodeMatrix > upperCells )

static

Construct method with multiple matrices.

There may be zero or one lower matrix (pointer can be 0). Multiple (numCells) middle matrics (must pass a non zero pointer). There may be zero or one upper matrix (pointer can be 0). These must all have the same width and cells in the non replicating direction.

Definition at line 38 of file PixelDiodeMatrix.cxx.

{
  class Helper : public PixelDiodeMatrix{};
  std::shared_ptr<PixelDiodeMatrix> ptr = std::make_shared<Helper>();
  ptr->initialize(direction,
                  std::move(lowerCell),
                  std::move(middleCells),
                  numCells,
                  std::move(upperCell));
  return ptr;
}

construct() [2/2]

std::shared_ptr< const PixelDiodeMatrix > InDetDD::PixelDiodeMatrix::construct ( double phiWidth, double etaWidth )

static

Construct method for just a single cell.

Definition at line 14 of file PixelDiodeMatrix.cxx.

{
  class Helper : public PixelDiodeMatrix{};
  std::shared_ptr<PixelDiodeMatrix> ptr = std::make_shared<Helper>();
  ptr->initialize(phiWidth, etaWidth);
  return ptr;
}

createDebugStringRepr() [1/2]

std::string InDetDD::PixelDiodeMatrix::createDebugStringRepr ( ) const

inline

Create debug representation.

Definition at line 249 of file PixelDiodeMatrix.h.

    {
      return this->createDebugStringRepr(0);
    }

createDebugStringRepr() [2/2]

std::string InDetDD::PixelDiodeMatrix::createDebugStringRepr ( unsigned int level ) const

private

Create debug representation for a specific level.

Definition at line 350 of file PixelDiodeMatrix.cxx.

{
  std::string prefix(level, ' ');
 
  // base case: single cell
  if (m_singleCell) {
    std::string cellSize = "";
    cellSize += prefix + "phi: " + std::to_string(m_phiWidth) + "\n";
    cellSize += prefix + "eta: " + std::to_string(m_etaWidth) + "\n";
    return cellSize;
  }
 
  std::string cellContent = "";
 
  if (m_lowerCell == nullptr && m_middleCells == nullptr && m_upperCell == nullptr) {
    cellContent += prefix + "completly empty (WARNING: there should always be at least one cell!)\n";
    return cellContent;
  }
 
  cellContent += prefix + "direction: ";
  if (m_direction == phiDir)      { cellContent += "phi\n"; }
  else if (m_direction == etaDir) { cellContent += "eta\n"; }
  else                            { cellContent += "unknown\n"; }
 
  // recursive call for nested cells
  if (m_lowerCell != nullptr) {
    cellContent += prefix + "lowerCell: \n";
    cellContent += m_lowerCell->createDebugStringRepr(level + 1);
  }
  if (m_middleCells != nullptr) {
    cellContent += prefix + "middleCells: " + std::to_string(m_numCells) + "x :\n";
    cellContent += m_middleCells->createDebugStringRepr(level + 1);
  }
  if (m_upperCell != nullptr) {
    cellContent += prefix + "upperCell: \n";
    cellContent += m_upperCell->createDebugStringRepr(level + 1);
  }
 
  return cellContent;
}

etaCells()

int InDetDD::PixelDiodeMatrix::etaCells ( ) const

inline

Number of cells in eta (y) direction.

Definition at line 239 of file PixelDiodeMatrix.h.

    { 
      return m_etaCells;
    }

etaHalfWidth()

double InDetDD::PixelDiodeMatrix::etaHalfWidth ( ) const

inline

Definition at line 224 of file PixelDiodeMatrix.h.

    {
      return m_etaWidth*0.5;
    }

etaWidth()

double InDetDD::PixelDiodeMatrix::etaWidth ( ) const

inline

Width in eta (y) direction.

Definition at line 219 of file PixelDiodeMatrix.h.

    {
      return m_etaWidth;
    }

etaWidthInverse()

double InDetDD::PixelDiodeMatrix::etaWidthInverse ( ) const

inline

Inverse of width in eta (y) direction.

Definition at line 229 of file PixelDiodeMatrix.h.

    { 
      return m_etaWidthInverse;
    }

initialize() [1/2]

void InDetDD::PixelDiodeMatrix::initialize ( Direction direction, std::shared_ptr< const PixelDiodeMatrix > lowerCell, std::shared_ptr< const PixelDiodeMatrix > middleCells, int numCells, std::shared_ptr< const PixelDiodeMatrix > upperCells )

private

Initialize for multiple matrices.

There may be zero or one lower matrix (pointer can be 0). Multiple (numCells) middle matrics (must pass a non zero pointer). There may be zero or one upper matrix (pointer can be 0). These must all have the same width and cells in the non replicating direction.

Definition at line 54 of file PixelDiodeMatrix.cxx.

{
  m_phiWidth = 0;
  m_etaWidth = 0;
  m_phiCells = 0;
  m_etaCells = 0;
  m_direction = direction;
  m_numCells = numCells;
  m_lowerCell = std::move(lowerCell);
  m_middleCells = std::move(middleCells);
  m_upperCell = std::move(upperCell);
  m_singleCell = false;
 
  // middleCells must be non zero.
  assert(m_middleCells);
 
  if (m_direction == phiDir) {
 
    // In eta direction widths must be all the same.
    if (m_middleCells){
      m_etaWidth = m_middleCells->etaWidth();
      m_etaCells = m_middleCells->etaCells();
    }
    // Check lower and upper are consistent
    // TODO.
 
    if (m_lowerCell) {
      m_phiWidth += m_lowerCell->phiWidth();
      m_phiCells += m_lowerCell->phiCells();
    }
 
    if (m_middleCells){
      m_phiWidth += m_numCells * m_middleCells->phiWidth();
      m_phiCells += m_numCells * m_middleCells->phiCells();
    }
 
    if (m_upperCell) {
      m_phiWidth += m_upperCell->phiWidth();
      m_phiCells += m_upperCell->phiCells();
    }
 
  } else { // eta Direction
 
    // In phi direction widths must be all the same.
    if (m_middleCells){
      m_phiWidth = m_middleCells->phiWidth();
      m_phiCells = m_middleCells->phiCells();
    }
    // Check lower and upper are consistent
    // TODO.
 
    if (m_lowerCell) {
      m_etaWidth += m_lowerCell->etaWidth();
      m_etaCells += m_lowerCell->etaCells();
    }
 
    if (m_middleCells){
      m_etaWidth += m_numCells * m_middleCells->etaWidth();
      m_etaCells += m_numCells * m_middleCells->etaCells();
    }
 
    if (m_upperCell) {
      m_etaWidth += m_upperCell->etaWidth();
      m_etaCells += m_upperCell->etaCells();
    }
 
  }
 
  m_phiWidthInverse = 1. / m_phiWidth;
  m_etaWidthInverse = 1. / m_etaWidth;
}

initialize() [2/2]

void InDetDD::PixelDiodeMatrix::initialize ( double phiWidth, double etaWidth )

private

Initialize for just a single cell.

Definition at line 22 of file PixelDiodeMatrix.cxx.

{
  m_phiWidth = phiWidth;
  m_phiWidthInverse = 1. / phiWidth;
  m_etaWidth = etaWidth;
  m_etaWidthInverse = 1. / etaWidth;
  m_phiCells = 1;
  m_etaCells = 1;
  m_direction = phiDir; // Irrelevant
  m_numCells = 0;
  m_lowerCell = nullptr;
  m_middleCells = nullptr;
  m_upperCell = nullptr;
  m_singleCell = true;
}

phiCells()

int InDetDD::PixelDiodeMatrix::phiCells ( ) const

inline

Number of cells in phi (x) direction.

Definition at line 234 of file PixelDiodeMatrix.h.

    { 
      return m_phiCells;
    }

phiHalfWidth()

double InDetDD::PixelDiodeMatrix::phiHalfWidth ( ) const

inline

Definition at line 209 of file PixelDiodeMatrix.h.

    {
      return m_phiWidth*0.5;
    }

phiWidth()

double InDetDD::PixelDiodeMatrix::phiWidth ( ) const

inline

Width in phi (x) direction.

Definition at line 204 of file PixelDiodeMatrix.h.

    {
      return m_phiWidth;
    }

phiWidthInverse()

double InDetDD::PixelDiodeMatrix::phiWidthInverse ( ) const

inline

Inverse of width in phi (x) direction.

Definition at line 214 of file PixelDiodeMatrix.h.

    { 
      return m_phiWidthInverse;
    }

positionOfCell() [1/2]

const PixelDiodeMatrix * InDetDD::PixelDiodeMatrix::positionOfCell ( const PixelDiodeMatrix * matrix, const SiCellId & cellId, Amg::Vector2D & dest_position )

staticprivate

Search diode matching the given cell id and compute its position.

Description.

Parameters

matrix	the diode matrix in which the search is started
cellId	the cell id relative to the given matrix
position	storage for the position of the diode.

Returns

pointer to the sub-matrix which is representative for the diode.

Overview of algoritm:

• It starts with the position of the bottom left corner of the cell. For the full matrix this is (-halfwidth,-halflength)
• It first checks if is in the lower cell (if it exists).
• If not it determines the bottom edge of the cell by multiplying the cell number by the pitch.
• If it is beyond the range of the middle cells it is taken as being in the upper cell.
• This position is then passed recursively to the same method until it reaches a single cell.
• At the end the 2D position is then transformed to the position relative to the module center.

Definition at line 255 of file PixelDiodeMatrix.cxx.

{
  using Trk::distPhi;
  using Trk::distEta;
  Amg::Vector2D position{
     -matrix->phiHalfWidth(),
     -matrix->etaHalfWidth()
  };
 
  int rel_phi_index = cellId.phiIndex();
  int rel_eta_index = cellId.etaIndex();
  for( ;!matrix->m_singleCell; ) {
 
     int relIndex = 0; // Relative index along m_direction
     double pitch = 0;
     int nMiddleCells = 0;
     double startPos = 0;
     const auto direction = matrix->m_direction;
 
     if (direction == PixelDiodeMatrix::phiDir) {
 
        relIndex = rel_phi_index;
 
        const PixelDiodeMatrix *lowerCell = matrix->m_lowerCell.get();
        if (lowerCell) {
           if (relIndex < lowerCell->phiCells()) {
              matrix = lowerCell;
              continue;
           } else {
              relIndex -=  lowerCell->phiCells();
          startPos +=  lowerCell->phiWidth();
           }
        }
        const PixelDiodeMatrix *middleCells = matrix->m_middleCells.get();
        assert(middleCells);
        pitch = middleCells->phiWidth();
        nMiddleCells = middleCells->phiCells();
 
     } else { // etaDir
 
        relIndex = rel_eta_index;
        const PixelDiodeMatrix *lowerCell = matrix->m_lowerCell.get();
        if (lowerCell) {
           if (relIndex < lowerCell->etaCells()) {
              matrix = lowerCell;
              continue;
           } else {
          relIndex -=  lowerCell->etaCells();
          startPos +=  lowerCell->etaWidth();
           }
        }
        const PixelDiodeMatrix *middleCells = matrix->m_middleCells.get();
        assert(middleCells);
        pitch = middleCells->etaWidth();
        nMiddleCells = middleCells->etaCells();
 
     }
 
     int index = std::min(relIndex / nMiddleCells,matrix->m_numCells); // @TODO upper bound correct ?
     relIndex -= index * nMiddleCells;
     startPos += index * pitch;
 
     matrix = (matrix->m_upperCell && index == matrix->m_numCells ) ? matrix->m_upperCell.get() : matrix->m_middleCells.get();
 
     if (direction == PixelDiodeMatrix::phiDir) {
        rel_phi_index = relIndex;
        position[distPhi] += startPos;
     } else {
        rel_eta_index = relIndex;
        position[distEta] += startPos;
     }
  }
  position[distPhi] += matrix->phiHalfWidth();
  position[distEta] += matrix->etaHalfWidth();
  dest_position = position;
  return matrix;
}

positionOfCell() [2/2]

const PixelDiodeMatrix * InDetDD::PixelDiodeMatrix::positionOfCell ( const SiCellId & cellId, Amg::Vector2D & position ) const

inline

Search diode matching the given cell id and compute its position.

Parameters

cellId	the cell id relative to this matrix
position	storage for the position of the diode relative to this matrix.

Returns

pointer to the sub-matrix which is representative for the diode. The position will be overwritten with newly computed diode position, and the position will be relative to this matrix.

Definition at line 255 of file PixelDiodeMatrix.h.

                                                                                          {
       return InDetDD::PixelDiodeMatrix::positionOfCell(this, cellId, position);
    }

singleCell()

bool InDetDD::PixelDiodeMatrix::singleCell ( ) const

inline

Query wether the matrix is just a single cell.

Mainly for internal use.

Definition at line 244 of file PixelDiodeMatrix.h.

    {
      return m_singleCell;
    }

Member Data Documentation

m_direction

Direction InDetDD::PixelDiodeMatrix::m_direction {}

private

Definition at line 195 of file PixelDiodeMatrix.h.

{};

m_etaCells

int InDetDD::PixelDiodeMatrix::m_etaCells = 0

private

Definition at line 194 of file PixelDiodeMatrix.h.

m_etaWidth

double InDetDD::PixelDiodeMatrix::m_etaWidth = 0

private

Definition at line 191 of file PixelDiodeMatrix.h.

m_etaWidthInverse

double InDetDD::PixelDiodeMatrix::m_etaWidthInverse = 0

private

Definition at line 192 of file PixelDiodeMatrix.h.

m_lowerCell

std::shared_ptr<const PixelDiodeMatrix> InDetDD::PixelDiodeMatrix::m_lowerCell

private

Definition at line 197 of file PixelDiodeMatrix.h.

m_middleCells

std::shared_ptr<const PixelDiodeMatrix> InDetDD::PixelDiodeMatrix::m_middleCells

private

Definition at line 198 of file PixelDiodeMatrix.h.

m_numCells

int InDetDD::PixelDiodeMatrix::m_numCells = 0

private

Definition at line 196 of file PixelDiodeMatrix.h.

m_phiCells

int InDetDD::PixelDiodeMatrix::m_phiCells = 0

private

Definition at line 193 of file PixelDiodeMatrix.h.

m_phiWidth

double InDetDD::PixelDiodeMatrix::m_phiWidth = 0

private

Definition at line 189 of file PixelDiodeMatrix.h.

m_phiWidthInverse

double InDetDD::PixelDiodeMatrix::m_phiWidthInverse = 0

private

Definition at line 190 of file PixelDiodeMatrix.h.

m_singleCell

bool InDetDD::PixelDiodeMatrix::m_singleCell = false

private

Definition at line 200 of file PixelDiodeMatrix.h.

m_upperCell

std::shared_ptr<const PixelDiodeMatrix> InDetDD::PixelDiodeMatrix::m_upperCell

private

Definition at line 199 of file PixelDiodeMatrix.h.

---

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

• PixelDiodeMatrix.h
• PixelDiodeMatrix.cxx