PixelModuleDesign.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
// PixelModuleDesign.h
// (c) ATLAS Pixel Detector software
 
 
#ifndef PIXELREADOUTGEOMETRY_PIXELMODULEDESIGN_H
#define PIXELREADOUTGEOMETRY_PIXELMODULEDESIGN_H
 
// Base class
#include "InDetReadoutGeometry/SiDetectorDesign.h"
 
// Data member classes
#include "ReadoutGeometryBase/PixelDiodeTree.h"
#include "ReadoutGeometryBase/PixelReadoutScheme.h"
#include "PixelReadoutDefinitions/PixelReadoutDefinitions.h"
 
// Other includes
#include "CxxUtils/CachedUniquePtr.h"
#include "TrkSurfaces/RectangleBounds.h"
 
#include <memory>
 
namespace Trk{
 class SurfaceBounds;
}
 
namespace InDetDD {
 
    class PixelModuleDesign : public SiDetectorDesign {
      
      // Public methods:
    public:
    
      // Constructors/destructor:
      
      PixelModuleDesign(const double thickness,
                        const int circuitsPerColumn,
                        const int circuitsPerRow,
                        const int cellColumnsPerCircuit,
                        const int cellRowsPerCircuit,
                        const int diodeColumnsPerCircuit,
                        const int diodeRowsPerCircuit,
                        PixelDiodeTree &&diode_tree,
                        InDetDD::CarrierType carrierType,
                        int readoutSide /*= -1*/,
                        bool is3D/*=false*/,
                        InDetDD::DetectorType detectorType/* = InDetDD::Undefined*/,
                        PixelReadoutTechnology readoutTechnology);
 
//Allow also setting of symmetry parameters
      PixelModuleDesign(const double thickness,
                        const bool phiSymmetric,
                        const bool etaSymmetric,
                        const bool depthSymmetric,
                        const int circuitsPerColumn,
                        const int circuitsPerRow,
                        const int cellColumnsPerCircuit,
                        const int cellRowsPerCircuit,
                        const int diodeColumnsPerCircuit,
                        const int diodeRowsPerCircuit,
                        PixelDiodeTree &&diode_tree,
                        InDetDD::CarrierType carrierType,
                        int readoutSide,
                        bool is3D,
                        InDetDD::DetectorType detectorType,
                        PixelReadoutTechnology readoutTechnology);
 
      // Destructor:
      virtual ~PixelModuleDesign() = default;
      
      // Const methods:
    
      virtual void distanceToDetectorEdge(const SiLocalPosition & localPosition, 
                          double & etaDist, double & phiDist) const;
    
      virtual SiDiodesParameters parameters(const SiCellId & cellId) const;
      virtual SiLocalPosition localPositionOfCell(const SiCellId & cellId) const;
    
      virtual int numberOfConnectedCells(const SiReadoutCellId & readoutId) const;
      virtual SiCellId connectedCell(const SiReadoutCellId & readoutId, int number) const;
    
      virtual SiCellId gangedCell(const SiCellId & cellId) const;
    
      virtual SiReadoutCellId readoutIdOfCell(const SiCellId & cellId) const;
    
      virtual SiReadoutCellId readoutIdOfPosition(const SiLocalPosition & localPos) const;
      virtual SiCellId cellIdOfPosition(const SiLocalPosition & localPos) const;
    
      virtual SiCellId cellIdInRange(const SiCellId & cellId) const;
 
      bool isInsideMatrix(const SiCellId &cellId) const;
      bool isInsideMatrix(const std::array<InDetDD::PixelDiodeTree::IndexType,2> &idx) const;
      bool isInsideMatrix(const Amg::Vector2D &local_position) const;
    
      virtual HepGeom::Vector3D<double> phiMeasureSegment(const SiLocalPosition&) const;
    
      virtual std::pair<SiLocalPosition,SiLocalPosition> endsOfStrip(const SiLocalPosition &position) const;
    
       SiLocalPosition positionFromColumnRow(const int column, const int row) const;
      
      virtual void neighboursOfCell(const SiCellId & cellId,
                                    std::vector<SiCellId> &neighbours) const;
        
      double intersectionLength(const SiCellId &diode1, const SiCellId &diode2) const;
 
      int numberOfDiodes() const;
    
      int numberOfCircuits() const;
 
      int numberOfCircuitsPerColumn() const;
    
      int numberOfCircuitsPerRow() const;
 
      int columnsPerCircuit() const;
    
      int rowsPerCircuit() const;
    
      int columns() const;
    
      int rows() const;
    
      virtual double length() const;
     
      virtual double width() const;
     
      virtual double minWidth() const;
     
      virtual double maxWidth() const;
    
      virtual double phiPitch() const;
    
      virtual double phiPitch(const SiLocalPosition & localPosition) const;
    
      virtual double etaPitch() const;
    
      double widthFromColumnRange(const int colMin, const int colMax) const;
    
      double widthFromRowRange(const int rowMin, const int rowMax) const;
    
      virtual bool nearBondGap(const SiLocalPosition & localPosition, double etaTol) const;
    
      virtual bool swapHitPhiReadoutDirection() const;
      virtual bool swapHitEtaReadoutDirection() const;
    
      virtual const Trk::SurfaceBounds & bounds() const; 
    
      virtual bool is3D() const;
 
      PixelReadoutTechnology getReadoutTechnology() const;
 
      virtual DetectorType type() const final;
 
      // Non-const methods:
    
    
      void addMultipleRowConnection(const int lowerRow,
                    const std::vector<int> &connections);
    
      std::string debugStringRepr() const;
 
       PixelDiodeTree::DiodeProxy diodeProxyFromIdx(const std::array<PixelDiodeTree::IndexType,2> &idx) const {
         return m_diodeTree.diodeProxyFromIdx(idx);
      }
      PixelDiodeTree::DiodeProxyWithPosition diodeProxyFromIdxCachePosition(const std::array<PixelDiodeTree::IndexType,2> &idx) const {
         return m_diodeTree.diodeProxyFromIdxCachePosition(idx);
      }
      PixelDiodeTree::DiodeProxy diodeProxyFromPosition(const Amg::Vector2D &pos) const {
         return m_diodeTree.diodeProxyFromPos(pos);
      }
 
      static unsigned int getFE(const PixelDiodeTree::DiodeProxy &diode_proxy) {
         return diode_proxy.subMatrixAttribute();
      }
      static InDetDD::PixelDiodeType getDiodeType(const PixelDiodeTree::DiodeProxy &diode_proxy) {
         return static_cast<InDetDD::PixelDiodeType>(diode_proxy.diodeAttribute());
      }
 
      // Private methods:
    private:
    
      PixelModuleDesign();
    
      // Copy constructor:
      PixelModuleDesign(const PixelModuleDesign &design);
      
      // Assignment operator:
      PixelModuleDesign &operator=(const PixelModuleDesign &design);
     
      
      // Private data:
    private:
      PixelDiodeTree m_diodeTree;
      PixelReadoutScheme m_readoutScheme;
      CxxUtils::CachedUniquePtr<Trk::RectangleBounds> m_bounds;
      InDetDD::DetectorType m_detectorType;
      PixelReadoutTechnology m_readoutTechnology;
      bool m_is3D;
    };
    
    // Inline methods:
    
    inline void PixelModuleDesign::addMultipleRowConnection(const int lowerRow,
                                const std::vector<int> &connections)
    {
      m_readoutScheme.addMultipleRowConnection(lowerRow,connections);
    }
    
    inline int PixelModuleDesign::numberOfDiodes() const
    {
      return numberOfCircuits() * rowsPerCircuit() * columnsPerCircuit();
    }
    
    inline int PixelModuleDesign::numberOfCircuits() const
    {
      return m_readoutScheme.numberOfCircuits();
    }
 
    inline int PixelModuleDesign::numberOfCircuitsPerColumn() const
    {
      return m_readoutScheme.numberOfCircuitsPerColumn();
    }
 
    inline int PixelModuleDesign::numberOfCircuitsPerRow() const
    {
      return m_readoutScheme.numberOfCircuitsPerRow();
    }
 
    inline int PixelModuleDesign::columnsPerCircuit() const
    {
      return m_readoutScheme.columnsPerCircuit();
    }
    
    inline int PixelModuleDesign::rowsPerCircuit() const
    {
      return m_readoutScheme.rowsPerCircuit();
    }
    
    inline int PixelModuleDesign::columns() const
    {
      return m_readoutScheme.columns();
    }
    
    inline int PixelModuleDesign::rows() const
    {
      return m_readoutScheme.rows();
    }
    
    inline bool PixelModuleDesign::nearBondGap(const SiLocalPosition &, double) const
    {
      // No bond gap in pixel module
      return false;
    }
    
    inline bool PixelModuleDesign::swapHitPhiReadoutDirection() const
    {
      return true;
    }
    
    inline bool PixelModuleDesign::swapHitEtaReadoutDirection() const
    {
      return true;
    }
    
    
    inline void PixelModuleDesign::neighboursOfCell(const SiCellId & cellId,
                                                    std::vector<SiCellId> &neighbours) const
    {
 
       m_diodeTree.neighboursOfCell(PixelDiodeTree::makeCellIndex(cellId.phiIndex(),cellId.etaIndex()),
                                    PixelDiodeTree::makeCellIndex(rows(),columns()),
                                    neighbours);
    }
    
    inline double PixelModuleDesign::intersectionLength(const SiCellId &diode1,
                                                        const SiCellId &diode2) const
    {
      PixelDiodeTree::DiodeProxy diode1_proxy=diodeProxyFromIdx(PixelDiodeTree::makeCellIndex(diode1.phiIndex(),
                                                                                              diode1.etaIndex()));
      std::array<int,2> abs_delta;
      abs_delta[0] = std::abs(diode1.phiIndex() - diode2.phiIndex());
      abs_delta[1] = std::abs(diode1.etaIndex() - diode2.etaIndex());
 
      if (abs_delta[0]+abs_delta[1]==1) {
         // i.e. delta[0]=1 or delta[1]=1 since delta[0]>=0 and delta[1]>=0
         // diode1_proxy.width()[1] for delta[0]==1 && delta[1]==0 <= delta[0]==1 because sum delta[i]=1
         // diode1_proxy.width()[0] for delta[0]==0 && delta[1]==1 <= delta[0]!=1
         // ==
         return diode1_proxy.width() [ abs_delta[0]==1 ];
      }
      return 0.;
    }
 
    inline bool PixelModuleDesign::is3D() const
    { 
      return m_is3D; 
    } 
 
    inline PixelReadoutTechnology PixelModuleDesign::getReadoutTechnology() const {
      return m_readoutTechnology;
    }
 
    inline std::string PixelModuleDesign::debugStringRepr() const
    {
      return m_diodeTree.debugStringRepr();
    }
 
    inline bool PixelModuleDesign::isInsideMatrix(const SiCellId &cellId) const {
       return m_diodeTree.isInsideMatrix( std::array<PixelDiodeTree::CellIndexType,2>{cellId.phiIndex(),
                                                                                      cellId.etaIndex()});
    }
    inline bool PixelModuleDesign::isInsideMatrix(const std::array<PixelDiodeTree::IndexType,2> &idx) const {
       return m_diodeTree.isInsideMatrix(idx);
    }
    inline bool PixelModuleDesign::isInsideMatrix(const Amg::Vector2D &local_position) const {
       return m_diodeTree.isInsideMatrix(local_position);
    }
 
} // namespace InDetDD
 
#endif // READOUTGEOMETRYBASE_PIXELMODULEDESIGN_H