StripStereoAnnulusDesign.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef INDETREADOUTGEOMETRY_STRIPSTEREOANNULUSDESIGN_H
#define INDETREADOUTGEOMETRY_STRIPSTEREOANNULUSDESIGN_H
 
//
//    StereoAnnulus shaped sensor design.
//    Ref. N.P. Hessey "Building a Stereo-angle into strip-sensors for the ATLAS-Upgrade Inner-Tracker Endcaps"
//    2012.
//
//    Local reference system is centred on the beamline (i.e. not in the wafer centre; it is made in GeoModel as
//    an intersection of a tube with a (translated) generic trap. x is along the centre strip; y is in phi direction;
//    z is the depth direction. Strips are on the +ve z side.
//
//        /)       ^ y
//       /  )      |
//      )   )      --> x
//       \  )
//        \‍)       z towards you and you are looking at the strip side
//
//    A sensor can have many rows of strips, with varying numbers of strips in each row. Row-lengths can be different.
//
//    Strips are identified by a single index, starting at 0 in the inner-most row low-y side, 
//    and ending at totalNStrips - 1 
//    
//
 
// Base class
#include "SCT_ReadoutGeometry/SCT_ModuleSideDesign.h"
 
#include "ReadoutGeometryBase/SiCellId.h"
#include "TrkSurfaces/AnnulusBounds.h"
#include "TrkSurfaces/AnnulusBoundsPC.h"
 
#include "CLHEP/Geometry/Vector3D.h" // For unused phiMeasureSegment
#include "CLHEP/Geometry/Transform3D.h"
 
#include <vector>
#include <stdexcept> // For throw stuff
 
namespace Trk {
class SurfaceBounds;
}
 
namespace InDetDD {
class SiDiodesParameters;
//Vectors passed to constructor below will become single values once row is removed...
class StripStereoAnnulusDesign: public SCT_ModuleSideDesign {
public:
    StripStereoAnnulusDesign(const SiDetectorDesign::Axis &stripDirection,
                   const SiDetectorDesign::Axis &thicknessDirection,
                   const double &thickness,
                   const int &readoutSide,
                   const InDetDD::CarrierType &carrier,
                   const int &nRows,
                   const std::vector<int> &nStrips,
                   const std::vector<double> &pitch,
                   const std::vector<double> &stripStart,
                   const std::vector<double> &stripEnd,
                   const double &stereoAngle,
                   const double &centreR,
                   const bool &usePC,
                   InDetDD::DetectorType detectorType = InDetDD::Undefined);
 
StripStereoAnnulusDesign(const SiDetectorDesign::Axis &stripDirection,
                   const SiDetectorDesign::Axis &thicknessDirection,
                   const double &thickness,
                   const int &readoutSide,
                   const InDetDD::CarrierType &carrier,
                   const int &nRows,
                   const std::vector<int> &nStrips,
                   const std::vector<double> &pitch,
                   const std::vector<double> &stripStart,
                   const std::vector<double> &stripEnd,
                   const double &stereoAngle,
                   const double &centreR,//this is the centre radius for e.g. the local/global position
                   const double &waferCentreR,//this is the centre radius needed for calculating the bounds, It is common to all elements on the same wafer/module/sensor (i.e. with a common MotherDesign)
                   const bool &usePC,
                   InDetDD::DetectorType detectorType = InDetDD::Undefined);
 
    ~StripStereoAnnulusDesign() = default;
 
    SiLocalPosition beamToStrip(const SiLocalPosition &pos) const;
    SiLocalPosition beamToStripPC(const SiLocalPosition &pos) const;
    SiLocalPosition beamToStripPCpolar(const SiLocalPosition &pos) const;
    
    SiLocalPosition stripToBeam(const SiLocalPosition &pos) const;
    SiLocalPosition stripToBeamPC(const SiLocalPosition &pos) const;
    SiLocalPosition stripToBeamPCpolar(const SiLocalPosition &pos) const;
 
    virtual Amg::Vector3D sensorCenter() const override;
 
    // Copy constructor and assignment:
    StripStereoAnnulusDesign(const StripStereoAnnulusDesign &design);
    StripStereoAnnulusDesign &operator = (const StripStereoAnnulusDesign &design);
    std::pair<int,int> getStripRow(SiCellId cellId) const final;
    virtual int strip1Dim(int strip, int row) const override;
    SiLocalPosition stripPosAtR(int strip, int row, double r) const;
    virtual int diodesInRow(const int row) const override;
//
//    Pure virtual methods in base class:
//
    // Distance to nearest detector active edge (+ve = inside, -ve = outside)
    virtual void distanceToDetectorEdge(const SiLocalPosition &localPosition, double &etaDist,
                                        double &phiDist) const override;
 
    // check if the position is in active area
    virtual bool inActiveArea(const SiLocalPosition &chargePos, bool checkBondGap = true) const override;
 
    // Element boundary
    virtual const Trk::SurfaceBounds &bounds() const override;
 
    // Retrieve the two ends of a "strip"
    virtual std::pair<SiLocalPosition, SiLocalPosition> endsOfStrip(
        const SiLocalPosition &position) const override;
 
    // Phi-pitch (strip-width). Two names for same thing
    virtual double stripPitch(const SiLocalPosition &localPosition) const override;
    double stripPitch(const SiCellId &cellId) const;
    virtual double stripPitch() const override;
    virtual double phiPitch(const SiLocalPosition &localPosition) const override;
    double phiPitch(const SiCellId &cellId) const;
    virtual double phiPitch() const override;
 
 
    // above methods return mm
    // Use these methods if you're working with polar coordinates
    // AnnulusBoundsPC, in all other cases use phiPitch() from above
    double phiPitchPhi(const SiLocalPosition &localPosition) const;
    double phiPitchPhi(const SiCellId &cellId) const;
    double phiPitchPhi() const;
 
    // distance to the nearest diode in units of pitch, from 0.0 to 0.5,
    // this method should be fast as it is called for every surface charge
    // in the SCT_SurfaceChargesGenerator
    // an active area check, done in the Generator anyway, is removed here
    virtual double scaledDistanceToNearestDiode(const SiLocalPosition &chargePos) const override;
 
    // readout or diode id -> position, size
    virtual SiDiodesParameters parameters(const SiCellId &cellId) const override;
    virtual SiLocalPosition localPositionOfCell(const SiCellId &cellId) const override;
    virtual SiLocalPosition localPositionOfCluster(const SiCellId &cellId, int clusterSize) const override;
    
    // these return local position in STRIP PC
    // Use only if you work with the polar coordinates, in all other
    // cases, use the un-suffixes methods above
    SiLocalPosition localPositionOfCellPC(const SiCellId &cellId) const;
    SiLocalPosition localPositionOfClusterPC(const SiCellId &cellId, int clusterSize) const;
 
    // position -> id
    virtual SiCellId cellIdOfPosition(const SiLocalPosition &localPos) const override;
    // id to position
    SiLocalPosition positionFromStrip(const SiCellId &cellId) const;
    virtual SiLocalPosition positionFromStrip(const int stripNumber) const override;
 
    // row and strip from 1-dim strip number
    virtual int row(int stripId1Dim) const override;
    virtual int strip(int stripId1Dim) const override;
 
    // Find and fill a vector with all neighbour strips of a given cell
    virtual void neighboursOfCell(const SiCellId &cellId,
                                  std::vector<SiCellId> &neighbours) const override;
    virtual SiCellId cellIdInRange(const SiCellId &) const override;
 
    // For Strip sensors, readout cell == diode cell. Overload the SCT_ModuleSideDesign
    // member
    virtual SiReadoutCellId readoutIdOfCell(const SiCellId &cellId) const override;
 
    //Returns the wafer centre Radius (needed for annulus shape)
    double waferCentreR() const;
 
    //Returns the "element" centre radius - the same as above for elements
    //representing a full wafer with multiple rows,
    //different for elements where each row is its own element
    double centreR() const;
 
    InDetDD::DetectorType type() const override final;
 
    // ---------------------------------------------------------------------------------------
    // DEPRECATED at least for Strips
    virtual HepGeom::Vector3D<double> phiMeasureSegment(const SiLocalPosition &position) const override;
 
    // Method to calculate length of a strip. Which strip??
    virtual double length() const override;
 
    // Method to calculate average width of a module. What is it used for??
    virtual double width() const override;
 
    // Method to calculate minimum width of a module
    virtual double minWidth() const override;
 
    // Method to calculate maximum width of a module
    virtual double maxWidth() const override;
 
    // Pitch in eta direction Deprecated for strips: it varies in endcap
    virtual double etaPitch() const override;
 
    // Return true if hit local direction is the same as readout direction.
    virtual bool swapHitPhiReadoutDirection() const override;
    virtual bool swapHitEtaReadoutDirection() const override;
 
    virtual bool nearBondGap(const SiLocalPosition &, double) const override;

    virtual DetectorShape shape() const override;
 
    virtual double sinStripAngleReco(double phiCoord, double etaCoord) const override;
 
    // ------------------------------------------------------------------------------------------
 
//
//    Accessors
//
    double pitch(const SiCellId &cellId) const;
    double stripLength(const SiCellId &cellId) const;
 
    double minR() const;
    double maxR() const;
    double phiWidth() const;
    double stereo() const;
 
    // Give upper and lower boundaries, and length, of dead area
    virtual double deadAreaUpperBoundary() const override;
    virtual double deadAreaLowerBoundary() const override;
    virtual double deadAreaLength() const override;
private:
    const int m_nRows;
    const std::vector<int> m_nStrips;
    std::vector<int> m_firstStrip; // Length is one more than the number of rows; Last entry is total number of strips. 
    const std::vector<double> m_pitch;
    const std::vector<double> m_stripStartRadius;
    const std::vector<double> m_stripEndRadius;
    const double m_stereo;
    const double m_R;
    const double m_waferCentreR;
    const double m_lengthBF;
    std::unique_ptr<Trk::SurfaceBounds> m_bounds;
    //members to avoid repeating cos/sin calculations
    const double m_sinStereo;
    const double m_cosStereo;
    const double m_sinNegStereo;
    const double m_cosNegStereo;
    const bool m_usePC;
};

// Inline methods:
inline int  StripStereoAnnulusDesign::diodesInRow(const int row) const {
    return m_nStrips[row];
}
 
// Unfortunately SCT introduced the name stripPitch as an alternative to phiPitch so
// everything gets doubled
 
inline double StripStereoAnnulusDesign::stripPitch(const SiLocalPosition &pos) const {
    return phiPitch(pos);
}
 
inline double StripStereoAnnulusDesign::stripPitch(const SiCellId &cellId) const {
    return phiPitch(cellId);
}
 
inline double StripStereoAnnulusDesign::stripPitch() const { // Don't use; which strip?
    return phiPitch();
}
 
inline double StripStereoAnnulusDesign::phiPitch(const SiLocalPosition &pos) const {
// Return pitch in mm for the strip at this position, at this point's distance along the strip.
    const SiCellId cellId = cellIdOfPosition(pos);
    const int row = cellId.etaIndex();
    const double radius = (m_usePC) ? pos.xEta() : std::hypot(pos.xEta(), pos.xPhi());
    return m_pitch[row] * radius;
}
 
inline double StripStereoAnnulusDesign::phiPitch(const SiCellId &cellId) const {
// Return pitch in mm for centre of this strip.
    const int row = cellId.etaIndex();
    return m_pitch[row] * (m_stripStartRadius[row] + m_stripEndRadius[row])*0.5;
}
 
inline double StripStereoAnnulusDesign::phiPitch() const {
// Return pitch in mm for the row just below or including the centre
    const int middleRow = m_nRows*0.5;
    const int middleStrip = m_nStrips[middleRow]*0.5; 
    return phiPitch(SiCellId(middleStrip, middleRow));
}
 
inline double StripStereoAnnulusDesign::phiPitchPhi(const SiLocalPosition &pos) const {
  // even though SiLocalPosition might not be in PC, the etaIndex should be correct
  const SiCellId cellId = cellIdOfPosition(pos);
  const int row = cellId.etaIndex();
  return m_pitch[row];
}
 
inline double StripStereoAnnulusDesign::phiPitchPhi(const SiCellId &cellId) const {
  const int row = cellId.etaIndex();
  return m_pitch[row];
}
 
inline double StripStereoAnnulusDesign::phiPitchPhi() const {
  const int middleRow = m_nRows *0.5;
  const int middleStrip = m_nStrips[middleRow] *0.5; 
  return phiPitchPhi(SiCellId(middleStrip, middleRow));
}
 
inline bool StripStereoAnnulusDesign::nearBondGap(const SiLocalPosition &, double) const {
// No bond gap in strip modules
    return false;
}
 
inline SiReadoutCellId StripStereoAnnulusDesign::readoutIdOfCell(const SiCellId &cellId) const {
    int strip = cellId.phiIndex();
    int row = cellId.etaIndex();
 
    return SiReadoutCellId(strip, row);
}
 
 
inline double StripStereoAnnulusDesign::minR() const {
    return m_stripStartRadius[0];
}
 
inline double StripStereoAnnulusDesign::maxR() const {
    return m_stripEndRadius.back();
}
 
 
inline double StripStereoAnnulusDesign::phiWidth() const {
    return m_nStrips[0] * m_pitch[0];
}
 
inline double StripStereoAnnulusDesign::stereo() const {
    return m_stereo;
}
 
inline int StripStereoAnnulusDesign::row(int stripId1Dim) const {
 
  //This method is scheduled for deletion
    std::vector<int>::const_iterator endPtr = std::upper_bound(m_firstStrip.begin(), m_firstStrip.end(), stripId1Dim);
    int rowNum = std::distance(m_firstStrip.begin(), endPtr) - 1;
    if (rowNum < 0 || rowNum >= m_nRows) {
      const std::string errMsg=std::string("StripId1Dim index out of acceptable range ") + __FILE__+std::string(": ")+std::to_string(__LINE__);
        throw std::runtime_error(errMsg);
    }
    return rowNum;
}
 
inline int StripStereoAnnulusDesign::strip(int stripId1Dim) const {
    int rowNum = row(stripId1Dim);
 
    int strip2D = stripId1Dim - m_firstStrip[rowNum];
    if (strip2D < 0 || strip2D >= m_firstStrip[rowNum + 1]) {
        std::cout << "str1D " << stripId1Dim << " gives strip " << strip2D << " which is outside range 0 - " << 
                     m_firstStrip[rowNum + 1] << "\n";
    }
    return strip2D;
}
 
inline double StripStereoAnnulusDesign::waferCentreR() const {
    return m_waferCentreR;
}
 
inline double StripStereoAnnulusDesign::centreR() const {
    return m_R;
}
 
inline InDetDD::DetectorType StripStereoAnnulusDesign::type() const{
    return m_detectorType;
}

inline double StripStereoAnnulusDesign::deadAreaUpperBoundary() const {
    return 0.;
}
 
inline double StripStereoAnnulusDesign::deadAreaLowerBoundary() const {
    return 0.;
}
 
inline double StripStereoAnnulusDesign::deadAreaLength() const {
    return 0.;
}
 
inline bool StripStereoAnnulusDesign::swapHitPhiReadoutDirection() const {
    return false;
}
 
inline bool StripStereoAnnulusDesign::swapHitEtaReadoutDirection() const {
    return false;
 }
} // namespace InDetDD
#endif // INDETREADOUTGEOMETRY_STRIPSTEREOANNULUSDESIGN_H