InDetDD Namespace Reference

Message Stream Member. More...

Namespaces
namespace	detail
namespace	HGTDDetEl
namespace	ITk

Classes
class	AthenaComps
	Class to hold various Athena components. More...
class	BCM_Builder
class	BCMPrimeDetectorManager
class	BCMPrimeGmxInterface
class	BLM_Builder
class	DetectorDesign
	Base class for the detector design classes for ITk and HGTD. More...
class	DetectorFactoryBase
class	DistortedMaterialManager
class	ExtendedAlignableTransform
	Class to hold alignable transform plus a pointer to the child volume and optionally a frame volume. More...
class	ExtraMaterial
class	GenericTubeMaker
class	HGTD_DetectorElement
	Class to hold geometrical description of an HGTD detector element. More...
class	HGTD_ModuleDesign
	Class used to describe the design of a module (diode segmentation and readout scheme) More...
class	InDetDetectorManager
	Virtual base class for all ID detector managers. More...
class	InDetServMatManager
class	IPixelReadoutManager
class	PairIndexMap
	Class to store map between pair of two ints and an int. More...
class	PconZone
class	PixelDetectorManager
	Dedicated detector manager extending the functionality of the SiDetectorManager with dedicated pixel information, access. More...
class	PixelDiodeMap
	Class used to describe the diode segmentation of a pixel module. More...
class	PixelDiodeMatrix
	Class used to describe the segmentation of the pixel and allow for conversion between cell id and position. More...
class	PixelDiodeParametersProxy
	Helper class to cache a pixel diode position, and provide access to diode parameters. More...
class	PixelDiodeTree
	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...
class	PixelModuleDesign
	Class used to describe the design of a module (diode segmentation and readout scheme) More...
class	PixelMultipleConnection1D
	Class used to handle connection of multiple diodes to the same readout cell. More...
class	PixelReadoutManager
class	PixelReadoutScheme
	Class used to describe the connection scheme of a diode matrix to a set of readout circuits. More...
class	PLRGmxInterface
class	Point
class	Ray
class	SCT_BarrelModuleSideDesign
	Barrel module design description for the SCT. More...
class	SCT_DetectorManager
	Dedicated detector manager extending the functionality of the SiDetectorManager with dedicated SCT information, access. More...
class	SCT_ForwardFrameTransformation
	Class that connect cartesian and pokar coordinates. More...
class	SCT_ForwardModuleSideDesign
	Design descriptor for forward modules in the SCT, carries the bounds, and readout information. More...
class	SCT_ForwardModuleSideGeometry
	Geometry descriptor holding strig number, crystel inner and outer half length & radius. More...
class	SCT_ForwardPolarPosition
	2D position in polar coordinates for the polar frame in the SCT endcaps. More...
class	SCT_ModuleSideDesign
	Base class for the SCT module side design, extended by the Forward and Barrel module design. More...
class	SCT_ReadoutScheme
	Definition of the readout scheme in the SCT detector describing, number of sides, cells, crystals per module. More...
class	Segment
class	SegmentList
class	SegmentSplitter
class	ServiceVolume
class	ServiceVolumeMaker
class	ServiceVolumeMakerMgr
class	ServiceVolumeSchema
class	SiCellId
	Identifier for the strip or pixel cell. More...
class	SiCommonItems
	Helper class to concentrate common items, such as the pointer to the IdHelper, the lorentzAngle tool or the information about the solenoidal frame. More...
class	SiDetectorDesign
	Base class for the detector design classes for Pixel and SCT. More...
class	SiDetectorElement
	Class to hold geometrical description of a silicon detector element. More...
class	SiDetectorElementCollection
	Class to hold the SiDetectorElement objects to be put in the detector store. More...
class	SiDetectorManager
	Base class for Pixel and SCT Detector managers. More...
class	SiDiodesParameters
	Class to handle the position of the centre and the width of a diode or a cluster of diodes Version 1.1 15/08/2001 David Calvet. More...
class	SiIntersect
	class to run intersection tests More...
class	SiLocalPosition
	Class to represent a position in the natural frame of a silicon sensor, for Pixel and SCT For Pixel: eta=column, phi=row. More...
class	SiNumerology
	Class to extract numerology for Pixel and SCT. More...
class	SiReadoutCellId
	Identifier for the strip or pixel readout cell. More...
class	SolidStateDetectorElementBase
	Class to hold geometrical description of a solid state detector element. More...
class	StripAnnulusDesign
class	StripBoxDesign
class	StripStereoAnnulusDesign
class	SubDetectorFactoryBase
class	SurfaceCache
class	SurfaceCacheBase
	These are for internal use in TRT_RedoutGeometry. More...
class	TRT_BarrelCode
	bit definitions to decode TRT straws in barrel More...
class	TRT_BarrelDescriptor
	Local Straw Positions (from the center of the module.) More...
class	TRT_BarrelElement
	Extended TRT_BaseElement to describe a TRT readout element, this is a planar layer with n ( order of 20 ) straws, in one of the 32 sectors of the TRT barrel. More...
class	TRT_BaseElement
	Virtual base class of TRT readout elements. More...
class	TRT_Conditions
	This class is an interface to conditions objects. More...
class	TRT_DetectorManager
	The Detector Manager for all TRT Detector elements, it acts as the interface to the detector elements which can be retrieved from the TRT_DetectorManager either via numerology or Identifier access. More...
class	TRT_DetElementCollection
	Class to hold collection of TRT detector elements. More...
class	TRT_DetElementContainer
	Class to hold different TRT detector elements structures. More...
class	TRT_EndcapCode
	bit definitions to decode TRT straws in endcap More...
class	TRT_EndcapDescriptor
	class TRT_EndcapDescriptor More...
class	TRT_EndcapElement
	Extended class of a TRT_BaseElement to describe a readout elment in the endcap. More...
class	TRT_Numerology
	Helper class to organize the straw elements on TRT readout elements. More...
class	TubeVolData
	Helper class to read in generic TUBE, TUBS, CONS or PCON type volumes. More...
class	TubeZone
class	UnboundedZone
class	Version
	Class to hold version information consisting of tag, name layout and description as strings, such as their integer regpresentation in the major-minor-tag scheme. More...
class	VolumeBuilder
class	VolumeSplitter
class	Zone

Typedefs
using	AttributeRefiner
using	HGTD_DetectorElementCollection = DataVector<HGTD_DetectorElement>
using	GeoShapeHolder = GeoIntrusivePtr<const GeoShape>
using	PhysVolPtr = VolumeBuilder::PhysVolPtr
typedef std::map< std::string, const void * >	RawAlignmentObjects

Enumerations
enum	DetectorShape {   Box =0 , Trapezoid , Annulus , Other ,   PolarAnnulus }
enum	DetectorType {   Undefined =0 , PixelBarrel , PixelEndcap , PixelInclined ,   StripBarrel , StripEndcap , BCMPrime , PLR ,   HGTD }
enum	FrameType { local , global , other }
enum	CarrierType { holes , electrons }
enum	AlignFolderType { none = -1 , static_run1 = 0 , timedependent_run2 = 1 }
enum class	PixelModuleType {   NONE =-1 , DBM , IBL_PLANAR , IBL_3D ,   PIX_BARREL , PIX_ENDCAP , N_PIXELMODULETYPES }
enum class	PixelDiodeType {   NONE =-1 , NORMAL , LONG , GANGED ,   LARGE , N_DIODETYPES }
enum class	PixelReadoutTechnology {   NONE =-1 , FEI3 , FEI4 , RD53 ,   N_TECHNOLOGIES }

Functions
PixelDiodeTree	createPixelDiodeTree (const std::array< unsigned int, 2 > &chip_dim, const std::array< unsigned int, 2 > &chip_matrix_dim, const PixelDiodeTree::Vector2D &pitch, const std::array< std::array< unsigned int, 2 >, 2 > &edge_dim, const std::array< PixelDiodeTree::Vector2D, 2 > &edge_pitch, const std::array< std::array< unsigned int, 2 >, 2 > &dead_zone, const AttributeRefiner &func_compute_attribute, std::ostream *debug_out=nullptr)
	Create a pixel diode tree.
std::ostream &	operator<< (std::ostream &os, const SiCellId &cellId)
SiLocalPosition	operator+ (const SiLocalPosition &position1, const SiLocalPosition &position2)
SiLocalPosition	operator* (const SiLocalPosition &position, const double factor)
SiLocalPosition	operator* (const double factor, const SiLocalPosition &position)
SiLocalPosition	operator/ (const SiLocalPosition &position, const double factor)
std::ostream &	operator<< (std::ostream &os, const InDetDD::Point &point)
std::ostream &	operator<< (std::ostream &os, const InDetDD::Ray &ray)
template<typename T>
constexpr std::size_t	enum2uint (T n, std::string_view callingFunctionName="")
	Convert an enum class to size_t for use as an array index.
std::string	PixelModuleTypeName (const PixelModuleType &t)
std::string	PixelDiodeTypeName (const PixelDiodeType &t)
std::string	PixelReadoutTechnologyName (const PixelReadoutTechnology &t)
void TRT_DetectorManager::addKey	ATLAS_NOT_THREAD_SAFE (const std::string &key, int level)

Variables
constexpr uint32_t	invalidRow = 0xFFFFFFFF
constexpr uint32_t	invalidColumn = 0xFFFFFFFF
constexpr uint32_t	invalidFrontEnd = 0xFFFFFFFF
const int	FIRST_HIGHER_LEVEL = 1

Detailed Description

Message Stream Member.

Authors: John Alison (johnd.nosp@m.a@he.nosp@m.p.upe.nosp@m.nn.e.nosp@m.du)

Base class.

Helper class to make general tubes used mainly for services.

Takes as input a DB table which has the following columns Handles numberouse cases Simple tubes: Rmin2, Rmax2 <=0. Cones: Uses Rmin2 and Rmax2. Tube and cone sectors: Uses phi start and phi delta. If RadialDiv > 0 then simulates the CLHEP::radial dependence of tubes/cables going outward CLHEP::radially.

Date: 22 Aug 2008

Description: This algorithm loops over the Inner Detector elements and prints thier local frames to a text file (IDLocalFrames.txt)

Date: 22 Aug 2008

Description: This algorithm loops over the Inner Detector elements and prints thier global positions to a text file (IDgeometryTextFile.txt)

Typedef Documentation

AttributeRefiner

using InDetDD::AttributeRefiner

Initial value:

 std::function<std::tuple<PixelDiodeTree::AttributeType,PixelDiodeTree::AttributeType>
                     (const std::array<PixelDiodeTree::IndexType,2> & ,
                      const PixelDiodeTree::Vector2D & ,
                      const std::array<bool,4> &                      ,
                      unsigned int                                    ,
                      PixelDiodeTree::AttributeType                   ,
                      PixelDiodeTree::AttributeType                     )>

Definition at line 39 of file PixelDiodeTreeBuilder.h.

GeoShapeHolder

using InDetDD::GeoShapeHolder = GeoIntrusivePtr<const GeoShape>

Definition at line 22 of file InDetGeoModelUtils/InDetGeoModelUtils/ServiceVolume.h.

HGTD_DetectorElementCollection

using InDetDD::HGTD_DetectorElementCollection = DataVector<HGTD_DetectorElement>

Definition at line 20 of file HGTD_DetectorElementCollection.h.

PhysVolPtr

using InDetDD::PhysVolPtr = VolumeBuilder::PhysVolPtr

Definition at line 19 of file VolumeBuilder.cxx.

RawAlignmentObjects

typedef std::map<std::string, const void*> InDetDD::RawAlignmentObjects

Definition at line 43 of file InDetDetectorManager.h.

Enumeration Type Documentation

AlignFolderType

enum InDetDD::AlignFolderType

Enumerator
none
static_run1
timedependent_run2

Definition at line 19 of file InDetDD_Defs.h.

{none = -1, static_run1 = 0, timedependent_run2 = 1};

CarrierType

enum InDetDD::CarrierType

Enumerator
holes
electrons

Definition at line 17 of file InDetDD_Defs.h.

{holes, electrons};

DetectorShape

enum InDetDD::DetectorShape

Enumerator
Box
Trapezoid
Annulus
Other
PolarAnnulus

Definition at line 41 of file DetectorDesign.h.

                   {
  Box=0, Trapezoid, Annulus,Other,PolarAnnulus
};

DetectorType

enum InDetDD::DetectorType

Enumerator
Undefined
PixelBarrel
PixelEndcap
PixelInclined
StripBarrel
StripEndcap
BCMPrime
PLR
HGTD

Definition at line 45 of file DetectorDesign.h.

                  {
    Undefined=0,PixelBarrel,PixelEndcap,PixelInclined,StripBarrel,StripEndcap,BCMPrime,PLR,HGTD
};

FrameType

enum InDetDD::FrameType

Enumerator
local
global
other

Definition at line 16 of file InDetDD_Defs.h.

{local, global, other};

PixelDiodeType

enum class InDetDD::PixelDiodeType

strong

Enumerator
NONE
NORMAL
LONG
GANGED
LARGE
N_DIODETYPES

Definition at line 28 of file PixelReadoutDefinitions.h.

                           {
    NONE=-1,
    NORMAL,
    LONG,
    GANGED,
    LARGE,
    N_DIODETYPES
  };

PixelModuleType

enum class InDetDD::PixelModuleType

strong

Enumerator
NONE
DBM
IBL_PLANAR
IBL_3D
PIX_BARREL
PIX_ENDCAP
N_PIXELMODULETYPES

Definition at line 18 of file PixelReadoutDefinitions.h.

                            {
    NONE =-1,
    DBM,
    IBL_PLANAR,
    IBL_3D,
    PIX_BARREL,
    PIX_ENDCAP,
    N_PIXELMODULETYPES
  };

PixelReadoutTechnology

enum class InDetDD::PixelReadoutTechnology

strong

Enumerator
NONE
FEI3
FEI4
RD53
N_TECHNOLOGIES

Definition at line 37 of file PixelReadoutDefinitions.h.

                                   {
    NONE =-1,
    FEI3,
    FEI4,
    RD53,
    N_TECHNOLOGIES
  };

Function Documentation

ATLAS_NOT_THREAD_SAFE()

void TRT_DetectorManager::addKey InDetDD::ATLAS_NOT_THREAD_SAFE	(	const std::string &	key,
		int	level )

Definition at line 224 of file TRT_DetectorManager.cxx.

    {
        if(msgLvl(MSG::DEBUG))
            msg(MSG::DEBUG) << "Registering alignmentCallback with key " << key << ", at level " << level
            << endmsg;
 
        const DataHandle<AlignableTransform> transformCollection;
        if (m_detStore->regFcn(&TRT_DetectorManager::alignmentCallback, this, transformCollection, key).isFailure()) {
          ATH_MSG_ERROR("Cannot register callback with DetectorStore");
        }
        addKey(key, level, InDetDD::other);
    }

createPixelDiodeTree()

PixelDiodeTree InDetDD::createPixelDiodeTree	(	const std::array< unsigned int, 2 > &	chip_dim,
		const std::array< unsigned int, 2 > &	chip_matrix_dim,
		const PixelDiodeTree::Vector2D &	pitch,
		const std::array< std::array< unsigned int, 2 >, 2 > &	edge_dim,
		const std::array< PixelDiodeTree::Vector2D, 2 > &	edge_pitch,
		const std::array< std::array< unsigned int, 2 >, 2 > &	dead_zone,
		const AttributeRefiner &	func_compute_attribute,
		std::ostream *	debug_out = nullptr )

Create a pixel diode tree.

Parameters

chip_dim	the number of circuits in local-x (phi, row) and local-y (eta, column) direction.
chip_matrix_dim	the width of a matrix in number of pixels in local-x(phi, row) and local-y (eta, column) direction.
pitch	the pitch of regular pixels in local-x (phi, row) and local-y (eta, column) direction.
edge_dim	the width of the outer, and inner edge of the sub-matrix associated to one circuit.
edge_pitch	the pitch of diodes in the outer or inner edge of a sub-matrix in local-x and local-y direction.
dead_zone	the width of a "dead" zone at the the outside of an outer or inner edge in pixels.
func_compute_attribute	a functional to "compute" attributes to diodes and sub-matrices.
debug_out	nullptr or a valid output stream to get debug output. Will create a diode tree to compute diode positions or indices from indices or positions and

Definition at line 224 of file PixelDiodeTreeBuilder.cxx.

                                                             {
   // strategy :
   //  split the entire pixel matrix first by circuit, then by special pixel areas
   //  add new diodes for sub matrices only composed of a single diode type, where the
   //  diode type is defined by the area i.e. it is located on one of the outer edges of the full matrix,
   //  one of the inner edges i.e. areas "between" circuits, in the "dead" zone between circuits
   //  or on the regular matrix.
   //
   //  1) first split circuit arrays in roughly by half until all sub-matrices span only a single circuit
   //  2) split sub-matrices until the sub matrix only contains pixel of an outer edge, inner edge
   //     or the "normal" pixels. Inner-edge sub-matrices are split further if there is a dead zone.
   //  @TODO split by circuit and edge type independently per axis, to reduce number of unused splits
   //        original pixel matrix (Run 1-Run 3)
 
   std::array<unsigned int,2> dim{};
   PixelDiodeTree::Vector2D width(PixelDiodeTree::Vector2D::Zero());
   // compute total width of diode matrix
   for (unsigned int axis_i=0; axis_i<2; ++axis_i) {
      dim[axis_i] = chip_dim[axis_i] * chip_matrix_dim[axis_i];
      unsigned int n_inner_edges = chip_dim[axis_i]*2-2 ;
      constexpr unsigned int n_outer_edges = 2;
      width[axis_i] = (  (  chip_dim[axis_i]*chip_matrix_dim[axis_i]
                          - edge_dim[kInner][axis_i]*n_inner_edges
                          - edge_dim[kOuter][axis_i]*n_outer_edges   ) * pitch[axis_i]
                       + edge_dim[kInner][axis_i]*edge_pitch[kInner][axis_i]*n_inner_edges
                       + edge_dim[kOuter][axis_i]*edge_pitch[kOuter][axis_i]*n_outer_edges);
   }
   PixelDiodeTree diode_tree(width);
   std::unordered_map<unsigned int, DiodeInfo > diode_idx;
 
   std::array<std::string,SubMatrixData::kDeadZoneInner+1> edgeName {
      std::string("Outer"),
      std::string("Inner"),
      std::string("Internal"),
      std::string("DeadZoneOuter"),
      std::string("DeadZoneInner")
   };
 
 
   std::vector< SubMatrixData > stack;
   stack.emplace_back(width,dim, chip_dim);
   while (!stack.empty()) {
      SubMatrixData current_submatrix = std::move(stack.back());
      const std::array<unsigned int,2 > &split_chip_dim = current_submatrix.m_chipDim;
      stack.pop_back();
 
      std::array<PixelDiodeTree::Vector2D,2> split_width{current_submatrix.m_width,
                                                         PixelDiodeTree::Vector2D::Zero()};         // default for no splitting
      std::array<unsigned int,2> split_idx{current_submatrix.m_idx[0]+current_submatrix.m_dim[0],   //set split point to outside outermost cell
                                           current_submatrix.m_idx[1]+current_submatrix.m_dim[1]};
      std::array<std::array<unsigned int,2>,2 > new_chip_dim{ split_chip_dim, split_chip_dim};
      unsigned int n_sub_matrices=0;
 
      if (debug_out) {
         *debug_out << "Split : " << std::setw(4) << current_submatrix.m_idx[0] << ", " << std::setw(4) << current_submatrix.m_idx[1]
                    << " " << std::setw(4) << current_submatrix.m_dim[0] << " x " << std::setw(4) << current_submatrix.m_dim[1]
                    << " pos " << std::setw(6) << current_submatrix.m_pos[0] << " , " <<  std::setw(6) << current_submatrix.m_pos[1]
                    << "  w " << std::setw(6) << current_submatrix.m_width[0] << " , " <<  std::setw(6) << current_submatrix.m_width[1]
                    << " chips " << current_submatrix.m_chipDim[0] << " x " << current_submatrix.m_chipDim[1]
                    << " edges: " << edgeName[current_submatrix.m_edgeType[0] ] <<  " | " << edgeName[current_submatrix.m_edgeType[1] ]
                    << " , " << edgeName[current_submatrix.m_edgeType[2] ] <<  " | " << edgeName[current_submatrix.m_edgeType[3] ]
                    << std::endl;
      }
 
      // 1) split circuits until sub-matrix composed of a single circuit
      for (unsigned int axis_i=0; axis_i<2; ++axis_i) {
         if (current_submatrix.m_chipDim[axis_i]>1) {
            n_sub_matrices+=2;
            unsigned int odd = current_submatrix.m_chipDim[axis_i] & 1;
            unsigned int axis_idx= current_submatrix.m_idx[axis_i];
 
            for (unsigned int part_i=0; part_i<2; ++part_i) {
               unsigned n_chips = (current_submatrix.m_chipDim[axis_i] + odd)/2;
               new_chip_dim[part_i][axis_i]=n_chips;
               unsigned int n_outer_edges=(current_submatrix.m_edgeType[axis_i*2+part_i]==SubMatrixData::kOuter);
               unsigned int n_inner_edges=n_chips*2-n_outer_edges;
               split_idx[axis_i]=axis_idx;
               split_width[part_i][axis_i] = (  n_chips*chip_matrix_dim[axis_i]
                                              - edge_dim[kInner][axis_i]*n_inner_edges
                                              - edge_dim[kOuter][axis_i]*n_outer_edges   ) * pitch[axis_i]
                                             + n_inner_edges*edge_dim[kInner][axis_i]*edge_pitch[kInner][axis_i]
                                             + n_outer_edges*edge_dim[kOuter][axis_i]*edge_pitch[kOuter][axis_i];
               axis_idx += n_chips * chip_matrix_dim[axis_i];
               odd=0u;
            }
         }
      }
      std::array<bool,2> dead_zone_split{};
      // composed of a single circuit split off special pixel edges, or split off dead zone
      if (n_sub_matrices<=1) {
         if (debug_out){
            (*debug_out) << "Split circuit arrays into " << n_sub_matrices << " sub arrays." << std::endl;
         }
         n_sub_matrices=0;
         for (unsigned int axis_i=0; axis_i<2; ++axis_i) {
            // compute the dimension of the edges on both sides
            std::array<unsigned int, 2> axis_edge_dim{0,0};
            for (unsigned int side_i=0; side_i<2; ++side_i) {
               new_chip_dim[side_i][axis_i]=0u;
               if (current_submatrix.m_edgeType[axis_i*2+side_i]<SubMatrixData::kInternal) {
                  axis_edge_dim[side_i]=edge_dim[ kOuter + (current_submatrix.m_edgeType[axis_i*2+side_i]==SubMatrixData::kInner) ][axis_i];
               }
            }
 
            if (debug_out) {
               (*debug_out) << "Split submatrix " << (axis_i == 0 ? "x: " : "y: ")
                            << edgeName[current_submatrix.m_edgeType[axis_i*2]]
                            << " | "
                            << edgeName[current_submatrix.m_edgeType[axis_i*2+1]]
                            << " -> " << axis_edge_dim[0] << " , "  << axis_edge_dim[1]
                            << std::endl;
            }
            unsigned int axis_dim = std::min(current_submatrix.m_dim[axis_i],chip_matrix_dim[axis_i]);
            split_idx[axis_i]=current_submatrix.m_idx[axis_i]+axis_dim;
 
            // loop over the two sides until one side has an edge or dead zone that can be split off
            if (axis_edge_dim[0]+axis_edge_dim[1]>0 ) { // if either side has a margin tht needs to be split off
               for (unsigned int side_i=0; side_i<2; ++side_i) {
                  split_width[side_i][axis_i]=0.;
                  if (axis_edge_dim[side_i] > 0 ) {
                     unsigned int inner_outer = kOuter + (current_submatrix.m_edgeType[axis_i*2+side_i]==SubMatrixData::kInner);
                     ++n_sub_matrices;
                     split_idx[axis_i]=current_submatrix.m_idx[axis_i];
                     if (side_i==0) {
                        split_idx[axis_i] += std::min(axis_edge_dim[side_i], current_submatrix.m_dim[axis_i]);
                        // if there is no split check whether the edge has a dead zone
                        if (split_idx[axis_i] == current_submatrix.m_idx[axis_i] + axis_dim
                            && axis_dim == edge_dim[inner_outer][axis_i]
                            && dead_zone[inner_outer][axis_i]>0u ) {
                           split_idx[axis_i] = current_submatrix.m_idx[axis_i] + dead_zone[inner_outer][axis_i];
                           split_width[side_i][axis_i]=dead_zone[inner_outer][axis_i]*edge_pitch[inner_outer][axis_i];
                           split_width[side_i^1][axis_i]=(edge_dim[inner_outer][axis_i] - dead_zone[inner_outer][axis_i])*edge_pitch[inner_outer][axis_i];
                           dead_zone_split[axis_i]=true;
                           break;
                        }
                     }
                     else {
                        split_idx[axis_i] += axis_dim - std::min(axis_edge_dim[side_i],current_submatrix.m_dim[axis_i]) ;
                        // if there is no split check whether the edge has a dead zone
                        if (split_idx[axis_i] == current_submatrix.m_idx[axis_i]
                            && axis_dim == axis_edge_dim[side_i]
                            && dead_zone[inner_outer][axis_i]>0u ) {
                           split_idx[axis_i] = current_submatrix.m_idx[axis_i] + current_submatrix.m_dim[axis_i] - dead_zone[inner_outer][axis_i];
                           split_width[side_i][axis_i]=dead_zone[inner_outer][axis_i]*edge_pitch[inner_outer][axis_i];
                           split_width[side_i^1][axis_i]=(edge_dim[inner_outer][axis_i] - dead_zone[inner_outer][axis_i])*edge_pitch[inner_outer][axis_i];
                           dead_zone_split[axis_i]=true;
                           break;
                        }
                        // lower side only
                     }
                     if (split_idx[axis_i]<current_submatrix.m_idx[axis_i]
                         || split_idx[axis_i]>current_submatrix.m_idx[axis_i]+current_submatrix.m_dim[axis_i]
                         || (current_submatrix.m_dim[axis_i] < edge_dim[kOuter][axis_i] && current_submatrix.m_dim[axis_i] < edge_dim[kInner][axis_i])
                         ) {
                        throw std::logic_error("invalid split index.");
                     }
                     split_width[side_i][axis_i]=axis_edge_dim[side_i] * edge_pitch[inner_outer][axis_i];
                     // only edges on side 0 here
                     unsigned int n_inner_edges = current_submatrix.m_edgeType[axis_i*2+(side_i^1)]==SubMatrixData::kInner;
                     unsigned int n_outer_edges = current_submatrix.m_edgeType[axis_i*2+(side_i^1)]==SubMatrixData::kOuter;
                     split_width[side_i^1][axis_i] = (  (  axis_dim
                                                           // edges on both sides here
                                                           - edge_dim[kInner][axis_i]*(n_inner_edges+current_submatrix.m_edgeType[axis_i*2+side_i]==SubMatrixData::kInner)
                                                           - edge_dim[kOuter][axis_i]*(n_outer_edges+current_submatrix.m_edgeType[axis_i*2+side_i]==SubMatrixData::kOuter))
                                                        * pitch[axis_i]
                                                        + edge_dim[kInner][axis_i]*edge_pitch[kInner][axis_i]*n_inner_edges
                                                        + edge_dim[kOuter][axis_i]*edge_pitch[kOuter][axis_i]*n_outer_edges);
                     break;
                  }
               }
            }
         }
         if (n_sub_matrices>0) {
            if(    (split_idx[0]>=current_submatrix.m_idx[0]+current_submatrix.m_dim[0] || split_idx[0]==current_submatrix.m_idx[0])
                && (split_idx[1]>=current_submatrix.m_idx[1]+current_submatrix.m_dim[1] || split_idx[1]==current_submatrix.m_idx[1])) {
               // nothing to split
               n_sub_matrices=0;
            }
         }
      }
 
      if (n_sub_matrices>0)
      {
         // split current matrix further into sub-matrices
         if (debug_out) {
            (*debug_out)  << "Split : " << current_submatrix.m_idx[0] << " , " << current_submatrix.m_idx[1] << " " << current_submatrix.m_dim[0] << "x" << current_submatrix.m_dim[1]
                          << " split at  " << split_idx[0] << ", " << split_idx[1]
                          << "  " << (split_idx[0] - current_submatrix.m_idx[0]) << "|" << (current_submatrix.m_idx[0]+current_submatrix.m_dim[0]-split_idx[0])
                          << ", " << (split_idx[1] - current_submatrix.m_idx[1]) << "|" << (current_submatrix.m_idx[1]+current_submatrix.m_dim[1]-split_idx[1])
                          << " width " << split_width[0][0] << ", " << split_width[0][1] << "; " << split_width[1][0] << ", " << split_width[1][1]
                          << std::endl;
         }
         std::size_t stack_size=stack.size();
         splitMatrix(current_submatrix,
                     split_idx,
                     split_width,
                     new_chip_dim,
                     dead_zone_split,
                     std::array<std::array<PixelDiodeTree::AttributeType, 2>,2>  {std::array<PixelDiodeTree::AttributeType, 2>{SubMatrixData::s_defaultMatrixAttribute,
                                                                                                                               SubMatrixData::s_defaultMatrixAttribute},
                                                                                  std::array<PixelDiodeTree::AttributeType, 2>{SubMatrixData::s_defaultMatrixAttribute,
                                                                                                                               SubMatrixData::s_defaultMatrixAttribute}},
                     stack,
                     diode_tree,
                     debug_out,
                     &edgeName);
         if (stack_size == stack.size()) {
            // split surprisingly resulted in zero new sub-matrices. @TODO is this possible ? Should this be a logic error ?
            n_sub_matrices=0;
         }
      }
 
      // if the current matrix was not split into further sub-matrices
      // register and assign a diode for it.
      if (n_sub_matrices==0) {
 
         // if the diode tree is still empty
         // create a dummy split of which only the first area is used.
         if (diode_tree.empty()) {
            assert( stack.empty() ); // this can only happen if no matrix has been split yet, and then the stack must also be empty
            assert( chip_dim[0]==1 && chip_dim[1]==1); // should only happen for single chip modules
            assert( current_submatrix.m_subMatrixIdx==std::numeric_limits<unsigned int>::max());
            current_submatrix.m_subMatrixIdx
               = diode_tree.split( std::array<PixelDiodeTree::CellIndexType,2>{ static_cast< PixelDiodeTree::CellIndexType>(current_submatrix.m_dim[0]),
                                                                              static_cast< PixelDiodeTree::CellIndexType>(current_submatrix.m_dim[1]) },
                                   current_submatrix.m_pos+current_submatrix.m_width,
                                   current_submatrix.m_attribute);
         }
 
         // determine diode type by evaluating whether it is on an inner, or outer edge, a dead zone or just a normal pixel diode
         PixelDiodeTree::Vector2D diode_width(PixelDiodeTree::Vector2D::Zero());
         PixelDiodeTree::AttributeType full_diode_type{};
         for (unsigned int axis_i=0; axis_i<2; ++axis_i) {
            // count inner and outer edges of the current sub matrix
            unsigned int axis_inner_edges = (  (current_submatrix.m_edgeType[axis_i*2] == SubMatrixData::kInner)
                                             + (current_submatrix.m_edgeType[axis_i*2+1] == SubMatrixData::kInner));
            unsigned int axis_outer_edges = (  (current_submatrix.m_edgeType[axis_i*2] == SubMatrixData::kOuter)
                                             + (current_submatrix.m_edgeType[axis_i*2+1] == SubMatrixData::kOuter));
 
            // set corresponding bit in diode type if sub-matrix has a non empty inner or outer edge
            // in principle only one of the two should be true per axis
            unsigned int diode_type = ((axis_inner_edges * edge_dim[kInner][axis_i]) > 0) << (kInner+1);
            diode_type |= ((axis_outer_edges * edge_dim[kOuter][axis_i]) > 0) << (kOuter+1);
            bool ganged=false;
            unsigned int n = 0;
            // special handling if this is an edge with a dead zone
            // @TODO should distinguish inner or outer edges adjacent to dead zone from actual dead zones.
            if (   current_submatrix.m_edgeType[axis_i*2]>SubMatrixData::kInternal
                || current_submatrix.m_edgeType[axis_i*2+1]>SubMatrixData::kInternal) {
               diode_type =   ((current_submatrix.m_edgeType[axis_i*2]==SubMatrixData::kDeadZoneInner) << (kInner+1))
                            | ((current_submatrix.m_edgeType[axis_i*2+1]==SubMatrixData::kDeadZoneInner) << (kInner+1))
                            | ((current_submatrix.m_edgeType[axis_i*2]==SubMatrixData::kDeadZoneOuter) << (kOuter+1))
                            | ((current_submatrix.m_edgeType[axis_i*2+1]==SubMatrixData::kDeadZoneOuter) << (kOuter+1));
               ganged=true;
            }
            else {
               n = current_submatrix.m_dim[axis_i] - edge_dim[kOuter][axis_i] *axis_outer_edges - edge_dim[kInner][axis_i] * axis_inner_edges;
            }
            diode_type |= (n>0) << 0u;
            if (debug_out) {
               *debug_out << (axis_i==0 ? "x: " : "y:" )
                          << " outer " <<  axis_outer_edges << " * " << edge_dim[kOuter][axis_i] << " * " << edge_pitch[kOuter][axis_i]
                          << " inner "  << axis_inner_edges << " * " << edge_dim[kInner][axis_i] << " * " << edge_pitch[kInner][axis_i]
                          << " normal " << n
                          << " -> " << diode_type
                          << std::endl;
            }
            // determine diode width depending on diode type
            switch (diode_type) {
            case (1u<<0):
               diode_width[axis_i]=pitch[axis_i];
               break;
            case (1u<<(kOuter+1)):
               diode_width[axis_i]=edge_pitch[kOuter][axis_i];
               break;
            case (1u<<(kInner+1)):
               diode_width[axis_i]=edge_pitch[kInner][axis_i];
               break;
            default:
               throw std::logic_error("Invalid diode type. Matrix not fully split.");
            }
 
            // one byte per axis
            full_diode_type<<=8;
            diode_type|=ganged<<3u;
            full_diode_type|=(diode_type&0xff);
         }
         // first two elements whether the diode is in a ganged area in one of the two directions
         // second two elements whether
         // if the diode is adjacent to an inner or outer edge it is in the dead zone if the diode is marked ganged.
         std::array<bool,4> ganged_flags{ (static_cast<std::size_t>(full_diode_type) & (1u<<3u)) != 0u,
                                          (static_cast<std::size_t>(full_diode_type) & (1u<<(3u+8u))) != 0u,
                                          current_submatrix.m_edgeType[0]==SubMatrixData::kInner
                                          || current_submatrix.m_edgeType[0+1]==SubMatrixData::kInner
                                          || current_submatrix.m_edgeType[0]==SubMatrixData::kOuter
                                          || current_submatrix.m_edgeType[0+1]==SubMatrixData::kOuter,
                                          current_submatrix.m_edgeType[2]==SubMatrixData::kInner
                                          || current_submatrix.m_edgeType[2+1]==SubMatrixData::kInner
                                          || current_submatrix.m_edgeType[2]==SubMatrixData::kOuter
                                          || current_submatrix.m_edgeType[2+1]==SubMatrixData::kOuter};
         // cannot be in a dead-zone if the pixel is not marked ganged.
         ganged_flags[2]=ganged_flags[2]&ganged_flags[0];
         ganged_flags[3]=ganged_flags[3]&ganged_flags[1];
 
         PixelDiodeTree::AttributeType current_sub_matrix_attribute=diode_tree.attribute(current_submatrix.m_subMatrixIdx);
         auto [new_sub_matrix_attribute, new_diode_attribute]
            = func_compute_attribute(std::array<PixelDiodeTree::CellIndexType,2>{ static_cast<PixelDiodeTree::CellIndexType>(current_submatrix.m_idx[0]),
                                                                                  static_cast<PixelDiodeTree::CellIndexType>(current_submatrix.m_idx[1])},
                                     diode_width,
                                     ganged_flags,
                                     current_submatrix.m_splitIdx,
                                     current_sub_matrix_attribute,
                                     full_diode_type);
 
         std::pair< std::unordered_map<unsigned int, DiodeInfo >::iterator, bool>
            ret = diode_idx.insert( std::make_pair(full_diode_type, DiodeInfo(std::numeric_limits<unsigned int>::max(),new_diode_attribute)));
         if (ret.second) {
            unsigned int diode_idx = diode_tree.addDiode(diode_width,
                                                         new_diode_attribute);
            assert( diode_idx < std::numeric_limits<PixelDiodeTree::IndexType>::max());
            ret.first->second.setIndex( diode_idx );
         }
         assert( ret.second || ret.first->second.attributeAgrees(new_diode_attribute) );
         diode_tree.setAttribute(current_submatrix.m_subMatrixIdx, new_sub_matrix_attribute);
         assert(   current_sub_matrix_attribute==SubMatrixData::s_defaultMatrixAttribute
                || current_sub_matrix_attribute==new_sub_matrix_attribute);
 
         diode_tree.setDiodeForSubMatrix(current_submatrix.m_subMatrixIdx, current_submatrix.m_splitIdx,ret.first->second.diodeIndex());
         if (debug_out) {
            (*debug_out) << "Created Diode "
                         << current_submatrix.m_idx[0] << ", " << current_submatrix.m_idx[1] << " "
                         << current_submatrix.m_dim[0] << " x " << current_submatrix.m_dim[1]
                         << " attr: " << new_sub_matrix_attribute
                         << " : diode_pitch " << diode_width[0] << ", " << diode_width[1]
                         << " sub-matrix index " << current_submatrix.m_subMatrixIdx
                         << " split index " << current_submatrix.m_splitIdx
                         << " -> " << -static_cast<PixelDiodeTree::IndexType>(ret.first->second.diodeIndex())
                         << " attribute " << full_diode_type << " -> " << new_diode_attribute
                         << std::endl;
         }
      }
   }
   if (diode_tree.cloneSingleSplitsToUnusedHalf()>0) {
      throw std::logic_error("Some splits have invalid indices. That should not happen.");
   }
   // set the positions of the upper and lower corner of the matrix
   diode_tree.computeMatrixCorner(PixelDiodeTree::makeCellIndex(dim[0],dim[1]));
   return diode_tree;
}

enum2uint()

template<typename T>

std::size_t InDetDD::enum2uint ( T n, std::string_view callingFunctionName = "" )

constexpr

Convert an enum class to size_t for use as an array index.

Definition at line 51 of file PixelReadoutDefinitions.h.

                                                         {
    if (n==T::NONE){
      throw std::out_of_range(std::format("{} InDetDD::enum2uint: 'NONE' type is out of range for {}", callingFunctionName, typeid(T).name()));
    }
    return static_cast<size_t>(n);
  }

operator*() [1/2]

SiLocalPosition InDetDD::operator* ( const double factor, const SiLocalPosition & position )

inline

Definition at line 186 of file SiLocalPosition.h.

{
  return position*factor;
}

operator*() [2/2]

SiLocalPosition InDetDD::operator*	(	const SiLocalPosition &	position,
		const double	factor )

Definition at line 98 of file SiLocalPosition.cxx.

{
  SiLocalPosition result(position);
  result*=factor;
  return result;
}

operator+()

SiLocalPosition InDetDD::operator+	(	const SiLocalPosition &	position1,
		const SiLocalPosition &	position2 )

Definition at line 90 of file SiLocalPosition.cxx.

{
  SiLocalPosition result(position1);
  result+=position2;
  return result;
}

operator/()

SiLocalPosition InDetDD::operator/	(	const SiLocalPosition &	position,
		const double	factor )

Definition at line 105 of file SiLocalPosition.cxx.

{
  SiLocalPosition result(position);
  result/=factor;
  return result;
}

operator<<() [1/3]

std::ostream & InDetDD::operator<<	(	std::ostream &	os,
		const InDetDD::Point &	point )

Definition at line 423 of file VolumeSplitterUtils.cxx.

                                                          {
    if (!point.valid()) {
      os << "INVALID";
    } else {
      os << "(" << point.z() << ", " << point.r() << ")";
    }
    return os;
  }

operator<<() [2/3]

std::ostream & InDetDD::operator<<	(	std::ostream &	os,
		const InDetDD::Ray &	ray )

Definition at line 413 of file VolumeSplitterUtils.cxx.

                                                      {
    if (!ray.valid()) {
      os << "INVALID";
    } else {
      os << ray.start() << " --> " << ray.end();
    }
    return os;
  }

operator<<() [3/3]

std::ostream & InDetDD::operator<<	(	std::ostream &	os,
		const SiCellId &	cellId )

Definition at line 8 of file SiCellId.cxx.

    {
        if (cellId.isValid()){
            return os << "[" << cellId.phiIndex() << "." << cellId.etaIndex() << "]";
        } else {
            return os << "[INVALID]";
        }
    }

PixelDiodeTypeName()

std::string InDetDD::PixelDiodeTypeName

(

const PixelDiodeType &

t

)

Definition at line 19 of file PixelReadoutDefinitions.cxx.

                                              {
    if (t==PixelDiodeType::NONE) return "unknown";
    static const std::array<std::string, enum2uint(PixelDiodeType::N_DIODETYPES)> PixelDiodeTypeNames{
        "NORMAL", "LONG", "GANGED", "LARGE"
    };
    return PixelDiodeTypeNames[enum2uint(t)];
  }

PixelModuleTypeName()

std::string InDetDD::PixelModuleTypeName

(

const PixelModuleType &

t

)

Definition at line 10 of file PixelReadoutDefinitions.cxx.

                                                {
    if (t==PixelModuleType::NONE) return "unknown";
    static const std::array<std::string, enum2uint(PixelModuleType::N_PIXELMODULETYPES)> PixelModuleTypeNames{
    "DBM", "IBL_PLANAR", "IBL_3D", "PIX_BARREL", "PIX_ENDCAP"
    };
    return PixelModuleTypeNames[enum2uint(t)];
  }

PixelReadoutTechnologyName()

std::string InDetDD::PixelReadoutTechnologyName

(

const PixelReadoutTechnology &

t

)

Definition at line 28 of file PixelReadoutDefinitions.cxx.

                                                              {
    if (t==PixelReadoutTechnology::NONE) return "unknown";
    static const std::array<std::string, enum2uint(PixelReadoutTechnology::N_TECHNOLOGIES)> PixelReadoutTechnologyNames{
      "FEI3", "FEI4", "RD53"
    };
    return PixelReadoutTechnologyNames[enum2uint(t)];
  }

Variable Documentation

FIRST_HIGHER_LEVEL

const int InDetDD::FIRST_HIGHER_LEVEL = 1

Definition at line 22 of file PixelDetectorManager.cxx.

invalidColumn

uint32_t InDetDD::invalidColumn = 0xFFFFFFFF

constexpr

Definition at line 46 of file PixelReadoutDefinitions.h.

invalidFrontEnd

uint32_t InDetDD::invalidFrontEnd = 0xFFFFFFFF

constexpr

Definition at line 47 of file PixelReadoutDefinitions.h.

invalidRow

uint32_t InDetDD::invalidRow = 0xFFFFFFFF

constexpr

Definition at line 45 of file PixelReadoutDefinitions.h.