Surface.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file Surface.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/Common.hpp"
#include "Acts/Definitions/Tolerance.hpp"
#include "Acts/Definitions/TrackParametrization.hpp"
#include "Acts/Geometry/DetectorElementBase.hpp"
#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/Geometry/GeometryObject.hpp"
#include "Acts/Geometry/Polyhedron.hpp"
#include "Acts/Surfaces/BoundaryCheck.hpp"
#include "Acts/Surfaces/SurfaceBounds.hpp"
#include "Acts/Surfaces/SurfaceError.hpp"
#include "Acts/Surfaces/detail/AlignmentHelper.hpp"
#include "Acts/Utilities/BinnedArray.hpp"
#include "Acts/Utilities/BinningType.hpp"
#include "Acts/Utilities/Intersection.hpp"
#include "Acts/Utilities/Result.hpp"

#include <array>
#include <cstddef>
#include <memory>
#include <ostream>
#include <string>
#include <tuple>
#include <utility>

namespace Acts {

class DetectorElementBase;
class SurfaceBounds;
class ISurfaceMaterial;
class Layer;
class TrackingVolume;
class IVisualization3D;
class Surface;

using SurfaceIntersection = ObjectIntersection<Surface>;
using SurfaceMultiIntersection = ObjectMultiIntersection<Surface>;

class Surface : public virtual GeometryObject,
                public std::enable_shared_from_this<Surface> {
 public:
  enum SurfaceType {
    Cone = 0,
    Cylinder = 1,
    Disc = 2,
    Perigee = 3,
    Plane = 4,
    Straw = 5,
    Curvilinear = 6,
    Other = 7
  };

  static std::array<std::string, SurfaceType::Other> s_surfaceTypeNames;

 protected:
  Surface(const Transform3& transform = Transform3::Identity());

  Surface(const Surface& other);

  Surface(const DetectorElementBase& detelement);

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

 public:
  virtual ~Surface();

  template <class T, typename... Args>
  static std::shared_ptr<T> makeShared(Args&&... args) {
    return std::shared_ptr<T>(new T(std::forward<Args>(args)...));
  }

  std::shared_ptr<Surface> getSharedPtr();

  std::shared_ptr<const Surface> getSharedPtr() const;

  Surface& operator=(const Surface& other);

  virtual bool operator==(const Surface& other) const;

  virtual bool operator!=(const Surface& sf) const;

 public:
  virtual SurfaceType type() const = 0;

  virtual const Transform3& transform(const GeometryContext& gctx) const;

  virtual Vector3 center(const GeometryContext& gctx) const;

  virtual Vector3 normal(const GeometryContext& gctx,
                         const Vector2& lposition) const = 0;


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

  //
  virtual Vector3 normal(const GeometryContext& gctx) const {
    return normal(gctx, center(gctx));
  }

  virtual const SurfaceBounds& bounds() const = 0;

  const DetectorElementBase* associatedDetectorElement() const;

  const Layer* associatedLayer() const;

  void associateLayer(const Layer& lay);

  const ISurfaceMaterial* surfaceMaterial() const;

  const std::shared_ptr<const ISurfaceMaterial>& surfaceMaterialSharedPtr()
      const;

  void assignDetectorElement(const DetectorElementBase& detelement);

  void assignSurfaceMaterial(std::shared_ptr<const ISurfaceMaterial> material);

  bool isOnSurface(const GeometryContext& gctx, const Vector3& position,
                   const Vector3& direction,
                   const BoundaryCheck& bcheck = true) const;

  virtual bool insideBounds(const Vector2& lposition,
                            const BoundaryCheck& bcheck = true) const;

  virtual Vector3 localToGlobal(const GeometryContext& gctx,
                                const Vector2& lposition,
                                const Vector3& direction) const = 0;

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

  virtual Acts::RotationMatrix3 referenceFrame(const GeometryContext& gctx,
                                               const Vector3& position,
                                               const Vector3& direction) const;

  virtual BoundToFreeMatrix boundToFreeJacobian(
      const GeometryContext& gctx, const BoundVector& boundParams) const;

  virtual FreeToBoundMatrix freeToBoundJacobian(
      const GeometryContext& gctx, const FreeVector& parameters) const;

  virtual FreeToPathMatrix freeToPathDerivative(
      const GeometryContext& gctx, const FreeVector& parameters) const;

  virtual double pathCorrection(const GeometryContext& gctx,
                                const Vector3& position,
                                const Vector3& direction) const = 0;

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

  virtual std::ostream& toStream(const GeometryContext& gctx,
                                 std::ostream& sl) const;

  std::string toString(const GeometryContext& gctx) const;

  virtual std::string name() const = 0;

  virtual Polyhedron polyhedronRepresentation(const GeometryContext& gctx,
                                              size_t lseg) const = 0;

  AlignmentToBoundMatrix alignmentToBoundDerivative(
      const GeometryContext& gctx, const FreeVector& parameters,
      const FreeVector& pathDerivative) const;

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

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

 protected:
  Transform3 m_transform = Transform3::Identity();

  const DetectorElementBase* m_associatedDetElement{nullptr};

  const Layer* m_associatedLayer{nullptr};

  const TrackingVolume* m_associatedTrackingVolume{nullptr};

  std::shared_ptr<const ISurfaceMaterial> m_surfaceMaterial;

 private:
  AlignmentToBoundMatrix alignmentToBoundDerivativeWithoutCorrection(
      const GeometryContext& gctx, const FreeVector& parameters) const;
};

inline std::ostream& operator<<(
    std::ostream& os,
    const std::tuple<const Surface&, const GeometryContext&>& tup) {
  const auto [surface, gctx] = tup;
  surface.toStream(gctx, os);
  return os;
}

}  // namespace Acts