DiscSurface.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file DiscSurface.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2016-2020 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#pragma once

#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/Geometry/GeometryStatics.hpp"
#include "Acts/Geometry/Polyhedron.hpp"
#include "Acts/Surfaces/DiscBounds.hpp"
#include "Acts/Surfaces/InfiniteBounds.hpp"
#include "Acts/Surfaces/Surface.hpp"
#include "Acts/Surfaces/detail/PlanarHelper.hpp"
#include "Acts/Utilities/Definitions.hpp"
#include "Acts/Utilities/Helpers.hpp"

namespace Acts {

class DetectorElementBase;

class DiscSurface : public Surface {
  friend Surface;

 protected:
  DiscSurface(const Transform3D& transform, double rmin, double rmax,
              double hphisec = M_PI);

  DiscSurface(const Transform3D& transform, double minhalfx, double maxhalfx,
              double minR, double maxR, double avephi = 0., double stereo = 0.);

  DiscSurface(const Transform3D& transform,
              std::shared_ptr<const DiscBounds> dbounds = nullptr);

  DiscSurface(const std::shared_ptr<const DiscBounds>& dbounds,
              const DetectorElementBase& detelement);

  DiscSurface(const DiscSurface& other);

  DiscSurface(const GeometryContext& gctx, const DiscSurface& other,
              const Transform3D& shift);

 public:
  ~DiscSurface() override = default;
  DiscSurface() = delete;

  DiscSurface& operator=(const DiscSurface& other);

  SurfaceType type() const override;

  Vector3D normal(const GeometryContext& gctx,
                  const Vector2D& lposition) const final;

  using Surface::normal;

  Vector3D binningPosition(const GeometryContext& gctx,
                           BinningValue bValue) const final;

  const SurfaceBounds& bounds() const final;

  Vector3D localToGlobal(const GeometryContext& gctx, const Vector2D& lposition,
                         const Vector3D& momentum) const final;

  Result<Vector2D> globalToLocal(const GeometryContext& gctx,
                                 const Vector3D& position,
                                 const Vector3D& momentum) const final;

  Vector2D localPolarToCartesian(const Vector2D& lpolar) const;

  Vector2D localCartesianToPolar(const Vector2D& lcart) const;

  Vector2D localPolarToLocalCartesian(const Vector2D& locpol) const;

  Vector3D localCartesianToGlobal(const GeometryContext& gctx,
                                  const Vector2D& lposition) const;

  Vector2D globalToLocalCartesian(const GeometryContext& gctx,
                                  const Vector3D& position,
                                  double tol = 0.) const;

  void initJacobianToGlobal(const GeometryContext& gctx,
                            BoundToFreeMatrix& jacobian,
                            const Vector3D& position, const Vector3D& direction,
                            const BoundVector& pars) const final;

  RotationMatrix3D initJacobianToLocal(const GeometryContext& gctx,
                                       FreeToBoundMatrix& jacobian,
                                       const Vector3D& position,
                                       const Vector3D& direction) const final;

  double pathCorrection(const GeometryContext& gctx, const Vector3D& position,
                        const Vector3D& direction) const final;

  SurfaceIntersection intersect(
      const GeometryContext& gctx, const Vector3D& position,
      const Vector3D& direction,
      const BoundaryCheck& bcheck = false) const final;

  double binningPositionValue(const GeometryContext& gctx,
                              BinningValue bValue) const final;

  std::string name() const override;

  Polyhedron polyhedronRepresentation(const GeometryContext& gctx,
                                      size_t lseg) const override;

  LocalCartesianToBoundLocalMatrix localCartesianToBoundLocalDerivative(
      const GeometryContext& gctx, const Vector3D& position) const final;

 protected:
  std::shared_ptr<const DiscBounds> m_bounds;  
};

#include "Acts/Surfaces/detail/DiscSurface.ipp"

}  // end of namespace Acts