InDetDD::PixelDiodeMap Class Reference

Class used to describe the diode segmentation of a pixel module. More...

#include <PixelDiodeMap.h>

Collaboration diagram for InDetDD::PixelDiodeMap:

Public Member Functions
	PixelDiodeMap (std::shared_ptr< const PixelDiodeMatrix > diodeMatrix)
	Constructor from Diode matrix description.
	PixelDiodeMap (const PixelDiodeMap &map)
	Copy constructor:
	~PixelDiodeMap ()
	Destructor.
PixelDiodeMap &	operator= (const PixelDiodeMap &map)
	Assignment operator.
SiDiodesParameters	parameters (const SiCellId &diodeId) const
	Get diodes parameters (position and size):
SiCellId	cellIdOfPosition (const Amg::Vector2D &localPosition) const
	cell id for a given local position
SiCellId	cellIdInRange (const SiCellId &cellId) const
	Check if cellId is within range.
void	neighboursOfCell (const SiCellId &cellId, std::vector< SiCellId > &neighbours) const
	Get the neighbouring PixelDiodes of a given PixelDiode: Cell for which the neighbours must be found List of cells which are neighbours of the given one.
double	intersectionLength (const SiCellId &diode1, const SiCellId &diode2) const
	Compute the intersection length of two diodes: return: the intersection length when the two diodes are projected on one of the two axis, or 0 in case of no intersection or problem nput: the two diodes for which the intersection length is computed.
double	leftColumn () const
double	rightColumn () const
double	leftRow () const
double	rightRow () const
double	width () const
double	length () const
int	phiDiodes () const
int	etaDiodes () const
int	diodes () const
void	setGeneralLayout ()
	Set general layout flag.
std::string	debugStringRepr () const
	Debug representation.
PixelDiodeParametersProxy	parametersProxy (const SiCellId &cellId) const
	Search diode for the given cell and return proxy to access its parameters.

Private Member Functions
void	neighboursOfCellGeneral (const SiCellId &cellId, std::vector< SiCellId > &neighbours) const
	Slower method.
double	intersectionLengthGeneral (const SiCellId &diode1, const SiCellId &diode2) const
	Slower method.

Static Private Member Functions
static double	intersectionLength1D (const double x1, const double dx1, const double x2, const double dx2)
	Compute the intersection length along one direction: return 0 if no intersection x1,x2 are the centers dx1,dx2 are the full lengths.

Private Attributes
std::shared_ptr< const PixelDiodeMatrix >	m_matrix
	diode matrix
bool	m_generalLayout
	Flag set to allow for dealing wth more general layouts.

Detailed Description

Class used to describe the diode segmentation of a pixel module.

• to get the position and size of a PixelDiode object
• to get a PixelDiode object containing a space point
• to get a PixelDiode object from a PixelModulePosition

Author

: David Calvet

• modified Davide Costanzo. Replace PixelModulePosition with SiCellId
• modified: Grant Gorfine, Andreas Salzburger

Definition at line 44 of file PixelDiodeMap.h.

Constructor & Destructor Documentation

PixelDiodeMap() [1/2]

InDetDD::PixelDiodeMap::PixelDiodeMap

(

std::shared_ptr< const PixelDiodeMatrix >

diodeMatrix

)

Constructor from Diode matrix description.

Definition at line 28 of file PixelDiodeMap.cxx.

                                                                         :
  m_matrix(std::move(matrix)),
  m_generalLayout(false) 
{
}

PixelDiodeMap() [2/2]

InDetDD::PixelDiodeMap::PixelDiodeMap

(

const PixelDiodeMap &

map

)

Copy constructor:

~PixelDiodeMap()

InDetDD::PixelDiodeMap::~PixelDiodeMap ( )

default

Destructor.

Member Function Documentation

cellIdInRange()

SiCellId InDetDD::PixelDiodeMap::cellIdInRange ( const SiCellId & cellId ) const

inline

Check if cellId is within range.

Definition at line 197 of file PixelDiodeMap.h.

    {
      if (!cellId.isValid() || 
          cellId.phiIndex() <0 || cellId.phiIndex() >= phiDiodes() ||
          cellId.etaIndex() <0 || cellId.etaIndex() >= etaDiodes()) return SiCellId(); // Invalid
      return cellId; 
    }

cellIdOfPosition()

SiCellId InDetDD::PixelDiodeMap::cellIdOfPosition

(

const Amg::Vector2D &

localPosition

)

const

cell id for a given local position

Definition at line 38 of file PixelDiodeMap.cxx.

{
  using std::abs;
  using Trk::distPhi;
  using Trk::distEta;
 
  // Check that we are in the bounds of the top level matrix
  // NB. edge is included in bounds.
 
  double halfWidth = 0.5*width();
  double halfLength = 0.5*length();
  if ( (abs(localPos[distPhi]) > halfWidth) || 
       (abs(localPos[distEta]) > halfLength) ) {
    return {}; // Invalid Id.
  }
 
  // position relative to bottom left corner.
  Amg::Vector2D relativePos = localPos + Amg::Vector2D(halfWidth, halfLength);
 
  // The cellId returned will be added to this so we must start with 0,0.
  SiCellId cellId(0,0);
 
  const PixelDiodeMatrix *cell = m_matrix->cellIdOfPosition(relativePos, cellId);
  // return invalid Id if there was a problem (don't expect this to be the case).
  if (cell==nullptr) {
    return {}; // Invalid id.
  } 
 
  return cellId;
  
}

debugStringRepr()

std::string InDetDD::PixelDiodeMap::debugStringRepr ( ) const

inline

Debug representation.

Definition at line 205 of file PixelDiodeMap.h.

    {
      return m_matrix->createDebugStringRepr();
    }

diodes()

int InDetDD::PixelDiodeMap::diodes ( ) const

inline

Definition at line 182 of file PixelDiodeMap.h.

    {
      return phiDiodes() * etaDiodes();
    }

etaDiodes()

int InDetDD::PixelDiodeMap::etaDiodes ( ) const

inline

Definition at line 192 of file PixelDiodeMap.h.

    {
      return m_matrix->etaCells();
    }

intersectionLength()

double InDetDD::PixelDiodeMap::intersectionLength	(	const SiCellId &	diode1,
		const SiCellId &	diode2 ) const

Compute the intersection length of two diodes: return: the intersection length when the two diodes are projected on one of the two axis, or 0 in case of no intersection or problem nput: the two diodes for which the intersection length is computed.

Definition at line 215 of file PixelDiodeMap.cxx.

{ 
  if(!diode1.isValid() || !diode2.isValid()) return 0;
  // If non regular layout revert to slower method
  if (m_generalLayout) return intersectionLengthGeneral(diode1, diode2);
 
  const SiLocalPosition size = parameters(diode1).width();
 
  int phiIndexDelta = std::abs(diode1.phiIndex() - diode2.phiIndex());
  int etaIndexDelta = std::abs(diode1.etaIndex() - diode2.etaIndex());
 
  // Intersection length is just the length or width of the diode depending on which neighbour.
  if (phiIndexDelta == 1 && etaIndexDelta == 0) return size.xEta();
  if (phiIndexDelta == 0 && etaIndexDelta == 1) return size.xPhi();
  // Will return 0 if it is a corner neighbour or if its not a neighbour or if they are oth the same diode.
  return 0;
}

intersectionLength1D()

double InDetDD::PixelDiodeMap::intersectionLength1D ( const double x1, const double dx1, const double x2, const double dx2 )

staticprivate

Compute the intersection length along one direction: return 0 if no intersection x1,x2 are the centers dx1,dx2 are the full lengths.

Definition at line 270 of file PixelDiodeMap.cxx.

{
  // compute distance between the two centers
  double distance=std::abs(x1-x2);
 
  // compute theoretical intersection
  double intersection=(dx1+dx2)/2-distance;
 
  // if intersection if negative, no intersection
  if (intersection<-1e-10) return intersection;
  else if (intersection<1e-10) return 0;
  else {
    // intersection cannot exceed size
    if (intersection>dx1) intersection=dx1;
    if (intersection>dx2) intersection=dx2;
    return intersection;
  }
}

intersectionLengthGeneral()

double InDetDD::PixelDiodeMap::intersectionLengthGeneral ( const SiCellId & diode1, const SiCellId & diode2 ) const

private

Slower method.

Called by intersectionLength if m_generalLayout set.

Definition at line 237 of file PixelDiodeMap.cxx.

{
  const SiDiodesParameters params1=parameters(diode1);
  const SiDiodesParameters params2=parameters(diode2);
  const SiLocalPosition center1=params1.centre();
  const SiLocalPosition center2=params2.centre();
  const SiLocalPosition size1=params1.width();
  const SiLocalPosition size2=params2.width();
  
  // compute intersection length on column direction
  const double intersectionColumn=intersectionLength1D(center1.xColumn(),
                      size1.xColumn(),
                      center2.xColumn(),
                      size2.xColumn());
  // compute intersection length on row direction
  const double intersectionRow=intersectionLength1D(center1.xRow(),
                       size1.xRow(),
                       center2.xRow(),
                       size2.xRow());
 
  // return the real intersection 
  // (if both directions intersect, there is a problem)
  if (intersectionColumn>0) {
    if (intersectionRow>0) return 0;
    return intersectionColumn;
  } else {
    return intersectionRow;
  }
}

leftColumn()

double InDetDD::PixelDiodeMap::leftColumn ( ) const

inline

Definition at line 162 of file PixelDiodeMap.h.

    {
      return -0.5*length();
    }

leftRow()

double InDetDD::PixelDiodeMap::leftRow ( ) const

inline

Definition at line 172 of file PixelDiodeMap.h.

    {
      return -0.5*width();
    }

length()

double InDetDD::PixelDiodeMap::length ( ) const

inline

Definition at line 152 of file PixelDiodeMap.h.

    {
      return m_matrix->etaWidth();
    }

neighboursOfCell()

void InDetDD::PixelDiodeMap::neighboursOfCell	(	const SiCellId &	cellId,
		std::vector< SiCellId > &	neighbours ) const

Get the neighbouring PixelDiodes of a given PixelDiode: Cell for which the neighbours must be found List of cells which are neighbours of the given one.

Definition at line 104 of file PixelDiodeMap.cxx.

{
  neighbours.clear();
 
  if (!cellId.isValid()) return;
 
  // If non regular layout revert to slower method
  if (m_generalLayout) return neighboursOfCellGeneral(cellId, neighbours);
 
  neighbours.reserve(8);
  // neighbours easily determined from cell number
  // normally 8 neighbours 4 edge and 4 corners
  
  int phiIndex = cellId.phiIndex();
  int etaIndex = cellId.etaIndex();
 
  // M = minus
  // P = plus
  int phiM = phiIndex-1;
  int phiP = phiIndex+1;
  int etaM = etaIndex-1;
  int etaP = etaIndex+1;
 
  // -,0
  if (phiM >= 0)                                 neighbours.emplace_back(phiM,etaIndex);
  // -,-
  if (phiM >= 0 && etaM >= 0)                    neighbours.emplace_back(phiM,etaM);
  // 0,-
  if (etaM >= 0)                                 neighbours.emplace_back(phiIndex,etaM);
  // +,-
  if (phiP < phiDiodes() && etaM >= 0)           neighbours.emplace_back(phiP,etaM);
  // +,0
  if (phiP < phiDiodes())                        neighbours.emplace_back(phiP,etaIndex);
  // -,+
  if (phiM >= 0 && etaP < etaDiodes())           neighbours.emplace_back(phiM,etaP);
  // 0,+
  if (etaP < etaDiodes())                        neighbours.emplace_back(phiIndex,etaP);
  // +,+
  if (phiP < phiDiodes() && etaP < etaDiodes())  neighbours.emplace_back(phiP,etaP);
}

neighboursOfCellGeneral()

void InDetDD::PixelDiodeMap::neighboursOfCellGeneral ( const SiCellId & cellId, std::vector< SiCellId > & neighbours ) const

private

Slower method.

Called by neighboursOfCell if m_generalLayout set.

Definition at line 149 of file PixelDiodeMap.cxx.

{
  // extract the diode spatial parameters
  const SiDiodesParameters params=parameters(cellId);
  const SiLocalPosition diodeCenter=params.centre();
  const SiLocalPosition diodeSize=params.width();
  const double &centerColumn=diodeCenter.xColumn();
  const double &centerRow=diodeCenter.xRow();
  const double halfSizeColumn=diodeSize.xColumn()/2;
  const double halfSizeRow=diodeSize.xRow()/2;
 
  // parameter
  const double epsilon=0.01;
 
  // compute the points to check
  const double left1=centerColumn-halfSizeColumn*(1+epsilon);
  const double right1=centerColumn+halfSizeColumn*(1+epsilon);
  const double left2=centerColumn-halfSizeColumn*(1-epsilon);
  const double right2=centerColumn+halfSizeColumn*(1-epsilon);
  const double top1=centerRow+halfSizeRow*(1+epsilon);
  const double bot1=centerRow-halfSizeRow*(1+epsilon);
  const double top2=centerRow+halfSizeRow*(1-epsilon);
  const double bot2=centerRow-halfSizeRow*(1-epsilon);
 
  // build the list of positions to check
  std::vector<SiLocalPosition> positions;
  positions.reserve(12);
  SiLocalPosition position;
  position.xRow(bot1); position.xColumn(left2); positions.push_back(position);
  position.xRow(bot1); position.xColumn(left1); positions.push_back(position);
  position.xRow(bot2); position.xColumn(left1); positions.push_back(position);
  position.xRow(top2); position.xColumn(left1); positions.push_back(position);
  position.xRow(top1); position.xColumn(left1); positions.push_back(position);
  position.xRow(top1); position.xColumn(left2); positions.push_back(position);
  position.xRow(bot1); position.xColumn(right2); positions.push_back(position);
  position.xRow(bot1); position.xColumn(right1); positions.push_back(position);
  position.xRow(bot2); position.xColumn(right1); positions.push_back(position);
  position.xRow(top2); position.xColumn(right1); positions.push_back(position);
  position.xRow(top1); position.xColumn(right1); positions.push_back(position);
  position.xRow(top1); position.xColumn(right2); positions.push_back(position);
 
  // build the list of neighbours
  neighbours.reserve(8);
 
  // loop on all positions to check
  for(const auto & position : positions) {
 
    // get the PixelDiode for this position
    SiCellId cellId_neighb = cellIdOfPosition(position);
 
    if (cellId.isValid()) {
      // check if the diode is already in the list
      //bool found=false;
      std::vector<SiCellId>::const_iterator foundIter
    = std::find(neighbours.begin(), neighbours.end(), cellId_neighb );
 
      // If not found add this diode to the list
      if (foundIter ==  neighbours.end()) neighbours.push_back(cellId_neighb);
            
    } 
  }
}

operator=()

PixelDiodeMap & InDetDD::PixelDiodeMap::operator=

(

const PixelDiodeMap &

map

)

Assignment operator.

parameters()

SiDiodesParameters InDetDD::PixelDiodeMap::parameters

(

const SiCellId &

diodeId

)

const

Get diodes parameters (position and size):

Definition at line 73 of file PixelDiodeMap.cxx.

{
 
  // Check we are in range
  
  if (!cellId.isValid() || 
      (cellId.phiIndex() < 0) || 
      (cellId.phiIndex() >= m_matrix->phiCells()) ||
      (cellId.etaIndex() < 0) ||
      (cellId.etaIndex() >= m_matrix->etaCells())) {
    return {};
  }
 
  //
  // Position is relative to left bottom corner.
  //
  Amg::Vector2D position;
  const PixelDiodeMatrix *cell = m_matrix->positionOfCell(cellId, position);
  if (cell != nullptr) {
    
    // get size
    Amg::Vector2D size(cell->phiWidth(), cell->etaWidth());
 
    // return parameters
    return SiDiodesParameters(position,size);
  }
 
  // return something in case of failure.
  return {};
}

parametersProxy()

PixelDiodeParametersProxy InDetDD::PixelDiodeMap::parametersProxy ( const SiCellId & cellId ) const

inline

Search diode for the given cell and return proxy to access its parameters.

Will search through the diode matrix, and compute the diode position at the same time. The position will be cached in the proxy. The proxy will provide access to parameters associated to the diode.

Definition at line 210 of file PixelDiodeMap.h.

                                                                                                {
       PixelDiodeParametersProxy ret;
       ret.cell_ptr() = m_matrix->positionOfCell(cellId, ret.position());
       return ret;
    }

phiDiodes()

int InDetDD::PixelDiodeMap::phiDiodes ( ) const

inline

Definition at line 187 of file PixelDiodeMap.h.

    {
      return m_matrix->phiCells();
    }

rightColumn()

double InDetDD::PixelDiodeMap::rightColumn ( ) const

inline

Definition at line 167 of file PixelDiodeMap.h.

    {
      return 0.5*length();  
    }

rightRow()

double InDetDD::PixelDiodeMap::rightRow ( ) const

inline

Definition at line 177 of file PixelDiodeMap.h.

    {
      return 0.5*width();
    }

setGeneralLayout()

void InDetDD::PixelDiodeMap::setGeneralLayout ( )

inline

Set general layout flag.

This can be set to true to allow handling of more complex layouts where cells are not lined up with each other such as bricking. Probably never will be needed.

Definition at line 107 of file PixelDiodeMap.h.

{m_generalLayout = true;}

width()

double InDetDD::PixelDiodeMap::width ( ) const

inline

Definition at line 157 of file PixelDiodeMap.h.

    {
      return m_matrix->phiWidth();  
    }

Member Data Documentation

m_generalLayout

bool InDetDD::PixelDiodeMap::m_generalLayout

private

Flag set to allow for dealing wth more general layouts.

Definition at line 145 of file PixelDiodeMap.h.

m_matrix

std::shared_ptr<const PixelDiodeMatrix> InDetDD::PixelDiodeMap::m_matrix

private

diode matrix

Definition at line 144 of file PixelDiodeMap.h.

---

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

• PixelDiodeMap.h
• PixelDiodeMap.cxx