InDetDD::PixelDiodeMatrix Class Reference

#include <PixelDiodeMatrix.h>

Collaboration diagram for InDetDD::PixelDiodeMatrix:

Public Types
enum	Direction { phiDir, etaDir }

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

Static Public Member Functions
static std::shared_ptr< const PixelDiodeMatrix >	construct (double phiWidth, double etaWidth)
	Construct method for just a single cell. More...
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. More...

Private Member Functions
	PixelDiodeMatrix ()
	Hidden constructor. More...
void	initialize (double phiWidth, double etaWidth)
	Initialize for just a single cell. More...
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. More...
std::string	createDebugStringRepr (unsigned int level) const
	Create debug representation for a specific level. More...

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 156 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 225 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 347 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 215 of file PixelDiodeMatrix.h.

    { 
      return m_etaCells;
    }

etaWidth()

double InDetDD::PixelDiodeMatrix::etaWidth ( ) const

inline

Width in eta (y) direction.

Definition at line 200 of file PixelDiodeMatrix.h.

    { 
      return m_etaWidth;
    }

etaWidthInverse()

double InDetDD::PixelDiodeMatrix::etaWidthInverse ( ) const

inline

Inverse of width in eta (y) direction.

Definition at line 205 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 210 of file PixelDiodeMatrix.h.

    { 
      return m_phiCells;
    }

phiWidth()

double InDetDD::PixelDiodeMatrix::phiWidth ( ) const

inline

Width in phi (x) direction.

Definition at line 190 of file PixelDiodeMatrix.h.

    { 
      return m_phiWidth;
    }

phiWidthInverse()

double InDetDD::PixelDiodeMatrix::phiWidthInverse ( ) const

inline

Inverse of width in phi (x) direction.

Definition at line 195 of file PixelDiodeMatrix.h.

    { 
      return m_phiWidthInverse;
    }

positionOfCell()

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

Return position correspong to cell with relative id withing the matrix.

Description.

Returns the relative position added to the position passed in. A pointer to the correspond cell is returned. This can be used to get the size of the cell.

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;
 
  if (m_singleCell) {
    position[distPhi] += 0.5*m_phiWidth;
    position[distEta] += 0.5*m_etaWidth;
    return this;
  }
 
  int relIndex = 0; // Relative index along m_direction
  double pitch = 0;
  int middleCells = 0;
  double startPos = 0;
 
  if (m_direction == phiDir) {
 
    relIndex = cellId.phiIndex();
    pitch = m_middleCells->phiWidth();
    middleCells = m_middleCells->phiCells();
 
    if (m_lowerCell) {
      if (relIndex < m_lowerCell->phiCells()) {
        return m_lowerCell->positionOfCell(cellId, position);
      } else {
        relIndex -=  m_lowerCell->phiCells();
          startPos +=  m_lowerCell->phiWidth();
      }
    }
 
  } else { // etaDir
 
    relIndex = cellId.etaIndex();
    pitch = m_middleCells->etaWidth();
    middleCells = m_middleCells->etaCells();
 
    if (m_lowerCell) {
      if (relIndex < m_lowerCell->etaCells()) {
        return m_lowerCell->positionOfCell(cellId, position);
      } else {
          relIndex -=  m_lowerCell->etaCells();
          startPos +=  m_lowerCell->etaWidth();
      }
    }
  }
 
  int index = relIndex / middleCells;
  if (index > m_numCells) index = m_numCells;
  relIndex -= index * middleCells;
  startPos += index * pitch;
 
  const PixelDiodeMatrix *nextCell{};
  if (m_upperCell && (index == m_numCells)) {
    // We are in the upper cell.
    nextCell = m_upperCell.get();
  } else {
    // We are in the middle cells
    nextCell = m_middleCells.get();
  }
 
  const PixelDiodeMatrix *cell{};
  if (m_direction == phiDir) {
    SiCellId relId(relIndex,cellId.etaIndex());
    position[distPhi] += startPos;
    cell = nextCell->positionOfCell(relId, position);
  } else {
    SiCellId relId(cellId.phiIndex(),relIndex);
    position[distEta] += startPos;
    cell = nextCell->positionOfCell(relId, position);
  }
 
  return cell;
}

singleCell()

bool InDetDD::PixelDiodeMatrix::singleCell ( ) const

inline

Query wether the matrix is just a single cell.

Mainly for internal use.

Definition at line 220 of file PixelDiodeMatrix.h.

    {
      return m_singleCell;
    }

Member Data Documentation

m_direction

Direction InDetDD::PixelDiodeMatrix::m_direction {}

private

Definition at line 181 of file PixelDiodeMatrix.h.

m_etaCells

int InDetDD::PixelDiodeMatrix::m_etaCells = 0

private

Definition at line 180 of file PixelDiodeMatrix.h.

m_etaWidth

double InDetDD::PixelDiodeMatrix::m_etaWidth = 0

private

Definition at line 177 of file PixelDiodeMatrix.h.

m_etaWidthInverse

double InDetDD::PixelDiodeMatrix::m_etaWidthInverse = 0

private

Definition at line 178 of file PixelDiodeMatrix.h.

m_lowerCell

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

private

Definition at line 183 of file PixelDiodeMatrix.h.

m_middleCells

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

private

Definition at line 184 of file PixelDiodeMatrix.h.

m_numCells

int InDetDD::PixelDiodeMatrix::m_numCells = 0

private

Definition at line 182 of file PixelDiodeMatrix.h.

m_phiCells

int InDetDD::PixelDiodeMatrix::m_phiCells = 0

private

Definition at line 179 of file PixelDiodeMatrix.h.

m_phiWidth

double InDetDD::PixelDiodeMatrix::m_phiWidth = 0

private

Definition at line 175 of file PixelDiodeMatrix.h.

m_phiWidthInverse

double InDetDD::PixelDiodeMatrix::m_phiWidthInverse = 0

private

Definition at line 176 of file PixelDiodeMatrix.h.

m_singleCell

bool InDetDD::PixelDiodeMatrix::m_singleCell = false

private

Definition at line 186 of file PixelDiodeMatrix.h.

m_upperCell

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

private

Definition at line 185 of file PixelDiodeMatrix.h.

---

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

• PixelDiodeMatrix.h
• PixelDiodeMatrix.cxx