CylinderSurface.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/

// CylinderSurface.h, (c) ATLAS Detector software
 
#ifndef TRKSURFACES_CYLINDERSURFACE_H
#define TRKSURFACES_CYLINDERSURFACE_H
 
// Trk
#include "TrkEventPrimitives/LocalParameters.h"
#include "TrkEventPrimitives/ParamDefs.h"
#include "TrkParametersBase/ParametersT.h"
#include "TrkSurfaces/CylinderBounds.h"
#include "TrkSurfaces/Surface.h"
// Amg
#include "EventPrimitives/EventPrimitives.h"
#include "GeoPrimitives/GeoPrimitives.h"
 
#include <memory>
class MsgStream;
template<class SURFACE, class BOUNDS_CNV>
class BoundSurfaceCnv_p1;
template<class SURFACE, class BOUNDS_CNV>
class BoundSurfaceCnv_p2;
 
namespace Trk {
 
template<int DIM, class T, class S>
class ParametersT;

 
class CylinderSurface : public Surface
{
 
public:
  static constexpr SurfaceType staticType = SurfaceType::Cylinder;

  CylinderSurface();

  CylinderSurface(const CylinderSurface& csf);

  CylinderSurface& operator=(const CylinderSurface& csf);

  CylinderSurface(CylinderSurface&& csf) noexcept = default;

  CylinderSurface& operator=(CylinderSurface&& csf) noexcept = default;

  virtual ~CylinderSurface() = default;

  CylinderSurface(const Amg::Transform3D& htrans,
                  double radius,
                  double hlength);

  CylinderSurface(const Amg::Transform3D& htrans,
                  double radius,
                  double hphi,
                  double hlength);

  CylinderSurface(const Amg::Transform3D& htrans, std::shared_ptr<const CylinderBounds> cbounds);

  CylinderSurface(const Amg::Transform3D& htrans);

  CylinderSurface(double radius, double hlength);

  CylinderSurface(double radius, double hphi, double hlength);

  CylinderSurface(std::shared_ptr<const CylinderBounds> cbounds);

  CylinderSurface(const CylinderSurface& csf, const Amg::Transform3D& transf);

  virtual bool operator==(const Surface& sf) const override;
  bool operator==(const CylinderSurface& cf) const;

  virtual CylinderSurface* clone() const override;

  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 qop,
    std::optional<AmgSymMatrix(5)> cov = std::nullopt) const override final;

  virtual NeutralTrackParametersUniquePtr createUniqueNeutralParameters(
    const Amg::Vector3D& position,
    const Amg::Vector3D& momentum,
    double charge,
    std::optional<AmgSymMatrix(5)> cov = std::nullopt) const override final;

  template<int DIM, class T>
  std::unique_ptr<ParametersT<DIM, T, CylinderSurface>> 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, CylinderSurface>> createUniqueParameters(
    const Amg::Vector3D& position,
    const Amg::Vector3D& momentum,
    double charge,
    std::optional<AmgSymMatrix(DIM)> cov = std::nullopt) const;

  virtual Amg::RotationMatrix3D measurementFrame(
    const Amg::Vector3D& glopos,
    const Amg::Vector3D& glomom) const override final;

  constexpr virtual SurfaceType type() const override final;

  virtual const Amg::Vector3D& globalReferencePoint() const override final;
 
  // using from the base class
  using Trk::Surface::normal;
  virtual Amg::Vector3D normal(const Amg::Vector2D& locpo) const override final;

  virtual const Amg::Vector3D& rotSymmetryAxis() const;

  virtual const CylinderBounds& bounds() const override final;
 
  bool hasBounds() const;

  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 Amg::Vector2D localParametersToPosition(
    const LocalParameters& locpars) const override final;

  virtual void localToGlobal(const Amg::Vector2D& locp,
                             const Amg::Vector3D& mom,
                             Amg::Vector3D& glob) const override;

  virtual bool globalToLocal(const Amg::Vector3D& glob,
                             const Amg::Vector3D& mom,
                             Amg::Vector2D& loc) const override;

  virtual bool isOnSurface(const Amg::Vector3D& glopo,
                           const BoundaryCheck& bchk = true,
                           double tol1 = 0.,
                           double tol2 = 0.) const override;

  virtual Intersection straightLineIntersection(
    const Amg::Vector3D& pos,
    const Amg::Vector3D& dir,
    bool forceDir = false,
    Trk::BoundaryCheck bchk = false) const override final;

  virtual DistanceSolution straightLineDistanceEstimate(
    const Amg::Vector3D& pos,
    const Amg::Vector3D& dir) const override;

  virtual DistanceSolution straightLineDistanceEstimate(
    const Amg::Vector3D& pos,
    const Amg::Vector3D& dir,
    bool bound) const override;

  virtual double pathCorrection(const Amg::Vector3D& pos,
                                const Amg::Vector3D& mom) const override;

  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;

  std::shared_ptr<const CylinderBounds> m_bounds;
  CxxUtils::CachedUniquePtr<Amg::Vector3D> m_referencePoint;
  CxxUtils::CachedUniquePtr<Amg::Vector3D> m_rotSymmetryAxis;
};
 
} // end of namespace
#include "TrkSurfaces/CylinderSurface.icc"
 
#endif // TRKSURFACES_CYLINDERSURFACE_H