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);
    
      // 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