Surface.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#include "CxxUtils/inline_hints.h"
namespace Trk {
 
inline bool
Surface::operator!=(const Surface& sf) const
{
  return !((*this) == sf);
}
 
inline const Amg::Transform3D*
Surface::cachedTransform() const
{
  return ((m_transforms) ? &(m_transforms->transform) : nullptr);
}
 
inline const Amg::Transform3D&
Surface::transform() const
{
  if (m_transforms) {
    return m_transforms->transform;
  }
  if (m_associatedDetElement && m_associatedDetElementId.is_valid()) {
    return m_associatedDetElement->transform(m_associatedDetElementId);
  }
  if (m_associatedDetElement) {
    return m_associatedDetElement->transform();
  }
  return s_idTransform;
}
 
inline const Amg::Vector3D&
Surface::center() const
{
  if (m_transforms) {
    return m_transforms->center;
  }
  if (m_associatedDetElement && m_associatedDetElementId.is_valid()) {
    return m_associatedDetElement->center(m_associatedDetElementId);
  }
  if (m_associatedDetElement) {
    return m_associatedDetElement->center();
  }
  return s_origin;
}
 
inline const Amg::Vector3D&
Surface::normal() const
{
  if (m_transforms) {
    return m_transforms->normal;
  }
  if (m_associatedDetElement && m_associatedDetElementId.is_valid()) {
    return m_associatedDetElement->normal(m_associatedDetElementId);
  }
  if (m_associatedDetElement) {
    return m_associatedDetElement->normal();
  }
  return s_zAxis;
}
 
// standard is to set non-defined parameters to 0, but can be changed for
// surface type
inline Amg::Vector2D
Surface::localParametersToPosition(const LocalParameters& locpars) const
{
  if (locpars.contains(Trk::loc1) && locpars.contains(Trk::loc2)) {
    return Amg::Vector2D(locpars[Trk::loc1], locpars[loc2]);
  }
  if (locpars.contains(Trk::loc1)) {
    return Amg::Vector2D(locpars[Trk::loc1], 0.);
  }
  if (locpars.contains(Trk::loc2)) {
    return Amg::Vector2D(0., locpars[loc2]);
  }
  return Amg::Vector2D(0., 0.);
}
 
// common to planar surfaces
inline double
Surface::pathCorrection(const Amg::Vector3D&, const Amg::Vector3D& mom) const
{
  Amg::Vector3D dir(mom.unit());
  double cosAlpha = dir.dot(normal());
  return (cosAlpha != 0 ? std::abs(1. / cosAlpha)
                        : 1.); // ST undefined for cosAlpha=0
}
 
//* the templated parameters on Surface method */
template<class T>
bool
Surface::onSurface(const T& pars, const Trk::BoundaryCheck& bcheck) const
{
  // surface pointer comparison as a first fast check (w/o transform)
  if ((&pars.associatedSurface() == this)) {
    return (bcheck ? insideBoundsCheck(pars.localPosition(), bcheck) : true);
  }
  return isOnSurface(pars.position(), bcheck);
}
 
/// Local to Global implementations
// From Local position
inline Amg::Vector3D
Surface::localToGlobal(const Amg::Vector2D& locpos) const
{
  Amg::Vector3D gPosition;
  localToGlobal(locpos, Amg::Vector3D(1., 1., 1.), gPosition);
  return gPosition;
}
 
// From local position and momentum
inline Amg::Vector3D
Surface::localToGlobal(const Amg::Vector2D& locpos,
                       const Amg::Vector3D& glomom) const
{
  Amg::Vector3D gPosition(0., 0., 0.);
  localToGlobal(locpos, glomom, gPosition);
  return gPosition;
}
 
// From Local parameters
inline Amg::Vector3D
Surface::localToGlobal(const LocalParameters& locpars) const
{
  Amg::Vector3D gPosition(0., 0., 0.);
  localToGlobal(
    localParametersToPosition(locpars), Amg::Vector3D(1., 1., 1.), gPosition);
  return gPosition;
}
 
// From Local parameters and momementum
inline Amg::Vector3D
Surface::localToGlobal(const LocalParameters& locpars,
                       const Amg::Vector3D& glomom) const
{
  Amg::Vector3D gPosition(0., 0., 0.);
  localToGlobal(localParametersToPosition(locpars), glomom, gPosition);
  return gPosition;
}
 
inline std::unique_ptr<Surface>
Surface::uniqueClone() const
{
  return std::unique_ptr<Surface>(clone());
}
 
// common to all surfaces, uses memory optized method
inline std::optional<Amg::Vector2D>
Surface::globalToLocal(const Amg::Vector3D& glopos, double) const
{
  Amg::Vector2D lPosition(0., 0.);
  if (globalToLocal(glopos, Amg::Vector3D(1., 1., 1.), lPosition)) {
    return lPosition;
  }
  return std::nullopt;
}
// common to all surfaces, uses memory optized method
inline std::optional<Amg::Vector2D>
Surface::globalToLocal(const Amg::Vector3D& glopos,
                       const Amg::Vector3D& glomom) const
{
  Amg::Vector2D lPosition(0., 0.);
  if (globalToLocal(glopos, glomom, lPosition)) {
    return lPosition;
  }
  return std::nullopt;
}
 
// take local position and return global direction
inline Amg::Vector3D
Surface::normal(const Amg::Vector2D&) const
{
  return Amg::Vector3D(normal());
}
 
inline const Amg::Vector3D&
Surface::globalReferencePoint() const
{
  return center();
}
 
inline const TrkDetElementBase*
Surface::associatedDetectorElement() const
{
  return m_associatedDetElement;
}
 
inline Identifier
Surface::associatedDetectorElementIdentifier() const
{
  if (!m_associatedDetElement)
    return Identifier(); // in invalid state
  if (m_associatedDetElementId.is_valid())
    return m_associatedDetElementId;
  return m_associatedDetElement->identify();
}
 
inline const Trk::Layer*
Surface::associatedLayer() const
{
  return (m_associatedLayer);
}
 
inline const Trk::MaterialLayer*
Surface::materialLayer() const
{
  return m_materialLayer.get();
}
 
inline Trk::MaterialLayer*
Surface::materialLayer()
{
  return m_materialLayer.get();
}
 
inline const Surface*
Surface::baseSurface() const
{
  return (this);
}
 
inline bool
Surface::isActive() const
{
  return (m_associatedDetElement != nullptr);
}
 
inline bool
Surface::isFree() const
{
  return (m_owner == Trk::noOwn);
}
 
inline void
Surface::setTransform(const Amg::Transform3D& trans)
{
  m_transforms = std::make_unique<Transforms>(trans);
}
 
inline void
Surface::setOwner(SurfaceOwner x)
{
  m_owner = x;
}
 
inline SurfaceOwner
Surface::owner() const
{
  return m_owner;
}
 
inline void
Surface::setMaterialLayer(std::shared_ptr<MaterialLayer> mlay)
{
  m_materialLayer = std::move(mlay);
}
 
inline void
Surface::associateLayer(const Layer& lay)
{
  m_associatedLayer = (&lay);
}
 
// Avoid out-of-line-eigen calls
ATH_FLATTEN
inline Amg::Transform3D
Surface::inverseTransformHelper() const
{
  return transform().inverse();
}
 
// Avoid out-of-line-eigen calls
ATH_FLATTEN
inline Amg::Vector3D
Surface::inverseTransformMultHelper(const Amg::Vector3D& pos) const
{
  return inverseTransformHelper() * pos;
}
 
} // end of namespace Trk