PixelModuleDesign.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 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/PixelDiodeMap.h"
#include "ReadoutGeometryBase/PixelReadoutScheme.h"
#include "PixelReadoutDefinitions/PixelReadoutDefinitions.h"
 
// Other includes
#include "CxxUtils/CachedUniquePtr.h"
#include "InDetIdentifier/PixelID.h"
#include "TrkSurfaces/RectangleBounds.h"
 
#include <memory>
 
namespace Trk{
 class SurfaceBounds;
}
 
namespace InDetDD {
 
    class PixelDiodeMatrix;
    
    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,
                        std::shared_ptr<const PixelDiodeMatrix> matrix,
                        InDetDD::CarrierType carrierType,
                        int readoutSide = -1,
                        bool is3D=false,
                        InDetDD::DetectorType detectorType = InDetDD::Undefined);
 
//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,
                        std::shared_ptr<const PixelDiodeMatrix> matrix,
                        InDetDD::CarrierType carrierType,
                        int readoutSide = -1,
                        bool is3D=false,
                        InDetDD::DetectorType detectorType = InDetDD::Undefined);
    
      // 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;
    
      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;
    
      double sensorLeftColumn() const;
      double sensorRightColumn() const;
      double sensorLeftRow() const;
      double sensorRightRow() 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);
    
      void setGeneralLayout();
 
      std::string debugStringRepr() const;
 
 
      // Private methods:
    private:
    
      PixelModuleDesign();
    
      // Copy constructor:
      PixelModuleDesign(const PixelModuleDesign &design);
      
      // Assignment operator:
      PixelModuleDesign &operator=(const PixelModuleDesign &design);
     
      
      // Private data:
    private:
      PixelDiodeMap m_diodeMap;
      PixelReadoutScheme m_readoutScheme;
      CxxUtils::CachedUniquePtr<Trk::RectangleBounds> m_bounds;
      bool m_is3D;
      InDetDD::DetectorType m_detectorType;
    
    };
    
    // Inline methods:
    
    inline void PixelModuleDesign::addMultipleRowConnection(const int lowerRow,
                                const std::vector<int> &connections)
    {
      m_readoutScheme.addMultipleRowConnection(lowerRow,connections);
    }
    
    inline double PixelModuleDesign::sensorLeftColumn() const
    {
      return m_diodeMap.leftColumn();
    }
    
    inline double PixelModuleDesign::sensorRightColumn() const
    {
      return m_diodeMap.rightColumn();
    }
    
    inline double PixelModuleDesign::sensorLeftRow() const
    {
      return m_diodeMap.leftRow();
    }
    
    inline double PixelModuleDesign::sensorRightRow() const
    {
      return m_diodeMap.rightRow();
    }
    
    inline int PixelModuleDesign::numberOfDiodes() const
    {
      return m_diodeMap.diodes();
    }
    
    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
    {
      return m_diodeMap.neighboursOfCell(cellId, neighbours);
    }
    
    inline double PixelModuleDesign::intersectionLength(const SiCellId &diode1,
                                const SiCellId &diode2) const
    {
      return m_diodeMap.intersectionLength(diode1, diode2);
    }  
 
 
    
    inline bool PixelModuleDesign::is3D() const 
    { 
      return m_is3D; 
    } 
 
    inline PixelReadoutTechnology PixelModuleDesign::getReadoutTechnology() const {
      if (m_detectorType == InDetDD::DetectorType::PixelBarrel
          || m_detectorType == InDetDD::DetectorType::PixelEndcap
          || m_detectorType == InDetDD::DetectorType::PixelInclined
          || m_detectorType == InDetDD::DetectorType::PLR)
      {
        return PixelReadoutTechnology::RD53;
      }
 
      const int maxRow = m_readoutScheme.rowsPerCircuit();
      const int maxCol = m_readoutScheme.columnsPerCircuit();
      if (maxRow*maxCol>26000) { return PixelReadoutTechnology::FEI4; }
      else                     { return PixelReadoutTechnology::FEI3; }
    }
 
    inline std::string PixelModuleDesign::debugStringRepr() const
    {
      return m_diodeMap.debugStringRepr();
    }
 
} // namespace InDetDD
 
#endif // READOUTGEOMETRYBASE_PIXELMODULEDESIGN_H