SolidStateDetectorElementBase.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
/**
 * @file SolidStateDetectorElementBase.icc
 **/
 
namespace InDetDD {
 
  ///////////////////////////////////////////////////////////////////
  // Inline methods:
  ///////////////////////////////////////////////////////////////////
 
  inline Trk::DetectorElemType SolidStateDetectorElementBase::detectorType() const{
     return  Trk::DetectorElemType::SolidState;
  }
 
  inline void SolidStateDetectorElementBase::invalidate()
  {
    m_cache.reset();
  }
 
  inline const SiCommonItems* SolidStateDetectorElementBase::getCommonItems() const
  {
    return m_commonItems;
  }
 
  inline Identifier SolidStateDetectorElementBase::identify() const
  {
    return m_id;
  }
 
  inline IdentifierHash SolidStateDetectorElementBase::identifyHash() const
  {
    return m_idHash;
  }
 
  inline const AtlasDetectorID* SolidStateDetectorElementBase::getIdHelper() const
  {
    return m_commonItems->getIdHelper();
  }
 
  inline Trk::Surface& SolidStateDetectorElementBase::surface()
  {
    return *m_surface;
  }
 
  inline const Trk::Surface& SolidStateDetectorElementBase::surface() const
  {
    return *m_surface;
  }
 
  inline const Trk::Surface& SolidStateDetectorElementBase::surface(const Identifier&) const
  {
    return surface();
  }
 
  inline const Amg::Transform3D& SolidStateDetectorElementBase::transform() const
  {
    if (!m_cache.isValid()) {
      updateCache();
    }
    return m_cache.ptr()->m_transform;
  }
 
  inline const Amg::Transform3D& SolidStateDetectorElementBase::transform(const Identifier&) const
  {
    return transform();
  }
 
  inline double SolidStateDetectorElementBase::hitDepthDirection() const
  {
    return depthDirection() ? 1 : -1;
  }
 
  inline double SolidStateDetectorElementBase::hitPhiDirection() const
  {
    return phiDirection() ? 1 : -1;
  }
 
  inline double SolidStateDetectorElementBase::hitEtaDirection() const
  {
    return etaDirection() ? 1 : -1;
  }
 
  inline const Amg::Vector3D& SolidStateDetectorElementBase::normal() const
  {
    if (!m_cache.isValid()) {
      updateCache();
    }
    return m_cache.ptr()->m_normal;
  }
 
  inline const Amg::Vector3D& SolidStateDetectorElementBase::center() const
  {
    if (!m_cache.isValid()) {
      updateCache();
    }
    return m_cache.ptr()->m_center;
  }
 
  inline const Amg::Vector3D& SolidStateDetectorElementBase::normal(const Identifier&) const
  {
    return normal();
  }
 
  inline const Amg::Vector3D& SolidStateDetectorElementBase::center(const Identifier&) const
  {
    return center();
  }
 
  inline const GeoTrf::Transform3D& SolidStateDetectorElementBase::transformHit() const
  {
    if (!m_cache.isValid()) {
      updateCache();
    }
    return m_cache.ptr()->m_transformHit;
  }
 
  inline HepGeom::Point3D<double> SolidStateDetectorElementBase::globalPositionHit(const HepGeom::Point3D<double>& simulationLocalPos) const
  {
    return Amg::EigenTransformToCLHEP(transformHit())*simulationLocalPos;
  }
 
  inline Amg::Vector3D SolidStateDetectorElementBase::globalPositionHit(const Amg::Vector3D& simulationLocalPos) const
  {
    return transformHit() * simulationLocalPos;
  }
 
  inline HepGeom::Point3D<double> SolidStateDetectorElementBase::globalPosition(const HepGeom::Point3D<double>& localPos) const
  {
    return transformCLHEP() * localPos;
  }
 
  inline Amg::Vector3D SolidStateDetectorElementBase::globalPosition(const Amg::Vector3D& localPos) const
  {
    return transform() * localPos;
  }
  //NB - these methods use "origin" not "center" - these are equivalent for most cases
  //For ITk Strip endcaps they differ because of the local sensor frame being defined with respect to the beamline, due to the sensor shape
  //Therefore, "local" positions for these elements will have large r components
 
  inline Amg::Vector3D SolidStateDetectorElementBase::globalPosition(const Amg::Vector2D& localPos) const
  {
    if (!m_cache.isValid()) updateCache();
    const CachedVals& cache = *m_cache.ptr();
    return cache.m_origin + localPos[Trk::distEta] * cache.m_etaAxis + localPos[Trk::distPhi] * cache.m_phiAxis;
  }
 
  inline Amg::Vector2D SolidStateDetectorElementBase::localPosition(const HepGeom::Point3D<double>& globalPosition) const
  {
    if (!m_cache.isValid()) updateCache();
    const CachedVals& cache = *m_cache.ptr();
    HepGeom::Vector3D<double> relativePos = globalPosition - cache.m_centerCLHEP;
    return Amg::Vector2D(relativePos.dot(cache.m_phiAxisCLHEP), relativePos.dot(cache.m_etaAxisCLHEP));
  }
 
  inline Amg::Vector2D SolidStateDetectorElementBase::localPosition(const Amg::Vector3D& globalPosition) const
  {
    if (!m_cache.isValid()) updateCache();
    const CachedVals& cache = *m_cache.ptr();
    Amg::Vector3D relativePos = globalPosition - cache.m_center;
    return Amg::Vector2D(relativePos.dot(cache.m_phiAxis), relativePos.dot(cache.m_etaAxis));
  }
 
  inline double SolidStateDetectorElementBase::rMin() const
  {
    if (!m_cache.isValid()) updateCache();
    return m_cache.ptr()->m_minR;
  }
 
  inline double SolidStateDetectorElementBase::rMax() const
  {
    if (!m_cache.isValid()) updateCache();
    return m_cache.ptr()->m_maxR;
  }
 
  inline double SolidStateDetectorElementBase::zMin() const
  {
    if (!m_cache.isValid()) updateCache();
    return m_cache.ptr()->m_minZ;
  }
 
  inline double SolidStateDetectorElementBase::zMax() const
  {
    if (!m_cache.isValid()) updateCache();
    return m_cache.ptr()->m_maxZ;
  }
 
  inline double SolidStateDetectorElementBase::phiMin() const
  {
    if (!m_cache.isValid()) updateCache();
    return m_cache.ptr()->m_minPhi;
  }
 
  inline double SolidStateDetectorElementBase::phiMax() const
  {
    if (!m_cache.isValid()) updateCache();
    return m_cache.ptr()->m_maxPhi;
  }
 
  inline const DetectorDesign& SolidStateDetectorElementBase::design() const
  {
    return *m_design;
  }
 
  inline const Trk::SurfaceBounds& SolidStateDetectorElementBase::bounds(const Identifier&) const
  {
    return bounds();
  }
 
  inline double SolidStateDetectorElementBase::width() const
  {
    return m_design->width();
  }
 
  inline double SolidStateDetectorElementBase::minWidth() const
  {
    return m_design->minWidth();
  }
 
  inline double SolidStateDetectorElementBase::maxWidth() const
  {
    return m_design->maxWidth();
  }
 
  inline double SolidStateDetectorElementBase::length() const
  {
    return m_design->length();
  }
 
  inline double SolidStateDetectorElementBase::thickness() const
  {
    return m_design->thickness();
  }
 
  inline double SolidStateDetectorElementBase::etaPitch() const
  {
    return m_design->etaPitch();
  }
 
  inline double SolidStateDetectorElementBase::phiPitch() const
  {
    return m_design->phiPitch();
  }
 
  inline InDetDD::CarrierType SolidStateDetectorElementBase::carrierType() const
  {
    return m_design->carrierType();
  }
 
  inline bool SolidStateDetectorElementBase::swapPhiReadoutDirection() const
  {
    bool dir = phiDirection();
    // equivalent to (m_design->swapHitPhiReadoutDirection() xor !m_phiDirection)
    return (!m_design->swapHitPhiReadoutDirection() && !dir)
        || (m_design->swapHitPhiReadoutDirection() &&  dir);
  }
 
  inline bool SolidStateDetectorElementBase::swapEtaReadoutDirection() const
  {
    bool dir = etaDirection();
    // equivalent to (m_design->swapHitEtaReadoutDirection() xor !m_etaDirection)
    return ((!m_design->swapHitEtaReadoutDirection() && !dir)
          || (m_design->swapHitEtaReadoutDirection() &&  dir));
  }
 
  inline MsgStream& SolidStateDetectorElementBase::msg(MSG::Level lvl) const
  {
    return m_commonItems->msg(lvl);
  }
 
  inline bool SolidStateDetectorElementBase::msgLvl(MSG::Level lvl) const
  {
    return m_commonItems->msgLvl(lvl);
  }
 
  inline bool SolidStateDetectorElementBase::depthDirection() const
  {
    if (!m_axisDir.isValid()) updateCache();
    return m_axisDir.ptr()->m_depthDirection;
  }
 
  inline bool SolidStateDetectorElementBase::etaDirection() const
  {
    if (!m_axisDir.isValid()) updateCache();
    return m_axisDir.ptr()->m_etaDirection;
  }
 
  inline bool SolidStateDetectorElementBase::phiDirection() const
  {
    if (!m_axisDir.isValid()) updateCache();
    return m_axisDir.ptr()->m_phiDirection;
  }
 
  inline double SolidStateDetectorElementBase::depthAngle() const
  {
    if (!m_axisDir.isValid()) updateCache();
    return m_axisDir.ptr()->m_depthAngle;
  }
 
  inline double SolidStateDetectorElementBase::etaAngle() const
  {
    if (!m_axisDir.isValid()) updateCache();
    return m_axisDir.ptr()->m_etaAngle;
  }
 
  inline double SolidStateDetectorElementBase::phiAngle() const
  {
    if (!m_axisDir.isValid()) updateCache();
    return m_axisDir.ptr()->m_phiAngle;
  }
 
} // namespace InDetDD