CylinderSurface.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file CylinderSurface.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/Definitions/Algebra.hpp"
#include "Acts/Definitions/Alignment.hpp"
#include "Acts/Definitions/Tolerance.hpp"
#include "Acts/Definitions/TrackParametrization.hpp"
#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/Geometry/Polyhedron.hpp"
#include "Acts/Surfaces/BoundaryCheck.hpp"
#include "Acts/Surfaces/CylinderBounds.hpp"
#include "Acts/Surfaces/Surface.hpp"
#include "Acts/Utilities/BinningType.hpp"
#include "Acts/Utilities/Result.hpp"
#include "Acts/Utilities/detail/RealQuadraticEquation.hpp"

#include <cmath>
#include <cstddef>
#include <memory>
#include <string>

namespace Acts {
class DetectorElementBase;


class CylinderSurface : public Surface {
#ifndef DOXYGEN
  friend Surface;
#endif

 protected:
  CylinderSurface(const Transform3& transform, double radius, double halfz,
                  double halfphi = M_PI, double avphi = 0.,
                  double bevelMinZ = 0., double bevelMaxZ = 0.);

  CylinderSurface(const Transform3& transform,
                  std::shared_ptr<const CylinderBounds> cbounds);

  CylinderSurface(std::shared_ptr<const CylinderBounds> cbounds,
                  const DetectorElementBase& detelement);

  CylinderSurface(const CylinderSurface& other);

  CylinderSurface(const GeometryContext& gctx, const CylinderSurface& other,
                  const Transform3& shift);

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

  CylinderSurface& operator=(const CylinderSurface& other);

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

  RotationMatrix3 referenceFrame(const GeometryContext& gctx,
                                 const Vector3& position,
                                 const Vector3& direction) const final;

  SurfaceType type() const override;

  Vector3 normal(const GeometryContext& gctx,
                 const Vector2& lposition) const final;

  Vector3 normal(const GeometryContext& gctx,
                 const Vector3& position) const final;

  using Surface::normal;

  virtual Vector3 rotSymmetryAxis(const GeometryContext& gctx) const;

  const CylinderBounds& bounds() const final;

  Vector3 localToGlobal(const GeometryContext& gctx, const Vector2& lposition,
                        const Vector3& direction) const final;

  Result<Vector2> globalToLocal(
      const GeometryContext& gctx, const Vector3& position,
      const Vector3& direction,
      double tolerance = s_onSurfaceTolerance) const final;

  SurfaceMultiIntersection intersect(
      const GeometryContext& gctx, const Vector3& position,
      const Vector3& direction, const BoundaryCheck& bcheck = false,
      ActsScalar tolerance = s_onSurfaceTolerance) const final;

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

  std::string name() const override;

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

  AlignmentToPathMatrix alignmentToPathDerivative(
      const GeometryContext& gctx, const FreeVector& parameters) const final;

  ActsMatrix<2, 3> localCartesianToBoundLocalDerivative(
      const GeometryContext& gctx, const Vector3& position) const final;

 protected:
  std::shared_ptr<const CylinderBounds> m_bounds;  

 private:
  detail::RealQuadraticEquation intersectionSolver(
      const Transform3& transform, const Vector3& position,
      const Vector3& direction) const;
};

}  // namespace Acts