PlaneSurface.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
// PlaneSurface.h, (c) ATLAS Detector software
 
#ifndef TRKSURFACES_PLANESURFACE_H
#define TRKSURFACES_PLANESURFACE_H
 
// Trk
#include "TrkDetDescrUtils/SharedObject.h"
#include "TrkParametersBase/ParametersT.h"
#include "TrkSurfaces/NoBounds.h"
#include "TrkSurfaces/Surface.h"
#include "TrkSurfaces/SurfaceBounds.h"
// Amg
#include "EventPrimitives/EventPrimitives.h"
#include "GeoPrimitives/GeoPrimitives.h"
 
class MsgStream;
class Identifier;
template<class SURFACE, class BOUNDS_CNV>
class BoundSurfaceCnv_p1;
template<class SURFACE, class BOUNDS_CNV>
class BoundSurfaceCnv_p2;
 
namespace Trk {
 
class LocalDirection;
class LocalParameters;
class TrkDetElementBase;
class RectangleBounds;
class TriangleBounds;
class AnnulusBounds;
class TrapezoidBounds;
class RotatedTrapezoidBounds;
class DiamondBounds;
class EllipseBounds;
class CurvilinearUVT;
template<int DIM, class T, class S>
class ParametersT;
 
class PlaneSurface : public Surface
{
public:
  static constexpr SurfaceType staticType = SurfaceType::Plane;
 
  PlaneSurface();
 
  PlaneSurface(const PlaneSurface& psf) = default;
 
  PlaneSurface& operator=(const PlaneSurface& psf) = default;
 
  PlaneSurface(PlaneSurface&& psf) noexcept = default;
 
  PlaneSurface& operator=(PlaneSurface&& psf) noexcept = default;
 
  virtual ~PlaneSurface() = default;
 
  PlaneSurface(const PlaneSurface& psf, const Amg::Transform3D& transf);
 
  PlaneSurface(const Amg::Vector3D& position, const CurvilinearUVT& curvUVT);
 
  PlaneSurface(const TrkDetElementBase& detelement,
               const Amg::Transform3D& transf);
 
  PlaneSurface(const TrkDetElementBase& detelement);
 
  PlaneSurface(const TrkDetElementBase& detelement,
               const Identifier& id,
               const Amg::Transform3D & transf);
 
  PlaneSurface(const TrkDetElementBase& detelement,
               const Identifier& id);
 
  PlaneSurface(const Amg::Transform3D& htrans);
 
 
  PlaneSurface(const Amg::Transform3D & htrans, double halephi, double haleta);
 
  PlaneSurface(const Amg::Transform3D & htrans,
               double minhalephi,
               double maxhalephi,
               double haleta);
 
  PlaneSurface(const Amg::Transform3D & htrans, const Trk::SurfaceBounds* rbounds);
 
  PlaneSurface(const Amg::Transform3D& htrans,
               const Trk::SharedObject<const Trk::SurfaceBounds>& sbounds);
 
  virtual bool operator==(const Surface& sf) const override;
  bool operator==(const PlaneSurface& cf) const;
 
  virtual PlaneSurface* clone() const override;
 
  constexpr virtual SurfaceType type() const override final;
 
  virtual Surface::ChargedTrackParametersUniquePtr createUniqueTrackParameters(
    double l1,
    double l2,
    double phi,
    double theta,
    double qop,
    std::optional<AmgSymMatrix(5)> cov = std::nullopt) const override final;
 
  virtual Surface::ChargedTrackParametersUniquePtr createUniqueTrackParameters(
    const Amg::Vector3D& position,
    const Amg::Vector3D& momentum,
    double charge,
    std::optional<AmgSymMatrix(5)> cov = std::nullopt) const override final;
 
  virtual NeutralTrackParametersUniquePtr createUniqueNeutralParameters(
    double l1,
    double l2,
    double phi,
    double theta,
    double oop,
    std::optional<AmgSymMatrix(5)> cov = std::nullopt) const override final;
 
  virtual NeutralTrackParametersUniquePtr createUniqueNeutralParameters(
    const Amg::Vector3D& position,
    const Amg::Vector3D& momentum,
    double charge = 0.,
    std::optional<AmgSymMatrix(5)> cov = std::nullopt) const override final;
 
  template<int DIM, class T>
  std::unique_ptr<ParametersT<DIM, T, PlaneSurface>> createUniqueParameters(
    double l1,
    double l2,
    double phi,
    double theta,
    double qop,
    std::optional<AmgSymMatrix(DIM)> cov = std::nullopt) const;
 
  template<int DIM, class T>
  std::unique_ptr<ParametersT<DIM, T, PlaneSurface>> createUniqueParameters(
    const Amg::Vector3D& position,
    const Amg::Vector3D& momentum,
    double charge,
    std::optional<AmgSymMatrix(DIM)> cov = std::nullopt) const;
 
  virtual const SurfaceBounds& bounds() const override final;
 
  virtual bool insideBounds(const Amg::Vector2D& locpos,
                            double tol1 = 0.,
                            double tol2 = 0.) const override;
 
  virtual bool insideBoundsCheck(
    const Amg::Vector2D& locpos,
    const BoundaryCheck& bchk) const override final;
 
  virtual bool isOnSurface(const Amg::Vector3D& glopo,
                           const BoundaryCheck& bchk = true,
                           double tol1 = 0.,
                           double tol2 = 0.) const override final;
 
  virtual void localToGlobal(const Amg::Vector2D& locp,
                             const Amg::Vector3D& mom,
                             Amg::Vector3D& glob) const override final;
 
  virtual bool globalToLocal(const Amg::Vector3D& glob,
                             const Amg::Vector3D& mom,
                             Amg::Vector2D& loc) const override final;
 
  void localToGlobalDirection(const Trk::LocalDirection& locdir,
                              Amg::Vector3D& globdir) const;
 
  void globalToLocalDirection(const Amg::Vector3D& glodir,
                              Trk::LocalDirection& locdir) const;
 
  virtual Intersection straightLineIntersection(
    const Amg::Vector3D& pos,
    const Amg::Vector3D& dir,
    bool forceDir,
    Trk::BoundaryCheck bchk) const override final;
 
  virtual DistanceSolution straightLineDistanceEstimate(
    const Amg::Vector3D& pos,
    const Amg::Vector3D& dir) const override final;
 
  virtual DistanceSolution straightLineDistanceEstimate(
    const Amg::Vector3D& pos,
    const Amg::Vector3D& dir,
    bool Bound) const override final;
 
  virtual std::string name() const override;
 
protected: 
  template<class SURFACE, class BOUNDS_CNV>
  friend class ::BoundSurfaceCnv_p1;
  template<class SURFACE, class BOUNDS_CNV>
  friend class ::BoundSurfaceCnv_p2;
 
  SharedObject<const SurfaceBounds> m_bounds; 
  static const NoBounds s_boundless;
};
 
} // end of namespace
 
#include "TrkSurfaces/PlaneSurface.icc"
#endif // TRKSURFACES_PLANESURFACE_H