Layer.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2016-2018 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/.

// Layer.h, Acts project

#pragma once

// Core module
#include <map>
#include "Acts/Geometry/AbstractVolume.hpp"
#include "Acts/Geometry/ApproachDescriptor.hpp"
#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/Geometry/GeometryID.hpp"
#include "Acts/Geometry/GeometryObject.hpp"
#include "Acts/Geometry/GeometryStatics.hpp"
#include "Acts/Material/IMaterialDecorator.hpp"
#include "Acts/Surfaces/SurfaceArray.hpp"
#include "Acts/Utilities/BinnedArray.hpp"
#include "Acts/Utilities/Definitions.hpp"
#include "Acts/Utilities/Intersection.hpp"

namespace Acts {

class Surface;
class ISurfaceMaterial;
class BinUtility;
class Volume;
class VolumeBounds;
class TrackingVolume;
class ApproachDescriptor;

// Simple surface intersection
using SurfaceIntersection = ObjectIntersection<Surface>;

// master typedef
class Layer;
using LayerPtr = std::shared_ptr<const Layer>;
using MutableLayerPtr = std::shared_ptr<Layer>;
using NextLayers = std::pair<const Layer*, const Layer*>;

enum LayerType { navigation = -1, passive = 0, active = 1 };

class Layer : public virtual GeometryObject {
  friend class TrackingVolume;

 public:
  Layer() = delete;

  Layer(const Layer&) = delete;

  virtual ~Layer() = default;

  Layer& operator=(const Layer&) = delete;

  const SurfaceArray* surfaceArray() const;

  SurfaceArray* surfaceArray();

  virtual const Surface& surfaceRepresentation() const = 0;

  // Non-const version
  virtual Surface& surfaceRepresentation() = 0;

  double thickness() const;

  virtual bool isOnLayer(const GeometryContext& gctx, const Vector3D& position,
                         const BoundaryCheck& bcheck = true) const;

  const ApproachDescriptor* approachDescriptor() const;

  ApproachDescriptor* approachDescriptor();

  template <typename options_t>
  bool resolve(const options_t& options) const {
    return resolve(options.resolveSensitive, options.resolveMaterial,
                   options.resolvePassive);
  }

  virtual bool resolve(bool resolveSensitive, bool resolveMaterial,
                       bool resolvePassive) const;

  template <typename options_t>
  std::vector<SurfaceIntersection> compatibleSurfaces(
      const GeometryContext& gctx, const Vector3D& position,
      const Vector3D& direction, const options_t& options) const;

  template <typename options_t>
  const SurfaceIntersection surfaceOnApproach(const GeometryContext& gctx,
                                              const Vector3D& position,
                                              const Vector3D& direction,
                                              const options_t& options) const;

  const Layer* nextLayer(const GeometryContext& gctx, const Vector3D& position,
                         const Vector3D& direction) const;

  const TrackingVolume* trackingVolume() const;

  const AbstractVolume* representingVolume() const;

  LayerType layerType() const;

 protected:
  Layer(std::unique_ptr<SurfaceArray> surfaceArray, double thickness = 0.,
        std::unique_ptr<ApproachDescriptor> ades = nullptr,
        LayerType laytyp = passive);

  void encloseTrackingVolume(const TrackingVolume& tvol);

  NextLayers m_nextLayers;

  const BinUtility* m_nextLayerUtility = nullptr;

  std::unique_ptr<const SurfaceArray> m_surfaceArray = nullptr;

  double m_layerThickness = 0.;

  std::unique_ptr<const ApproachDescriptor> m_approachDescriptor = nullptr;

  const TrackingVolume* m_trackingVolume = nullptr;

  std::unique_ptr<AbstractVolume> m_representingVolume = nullptr;

  LayerType m_layerType;

  int m_ssRepresentingSurface = 0;
  int m_ssSensitiveSurfaces = 0;
  int m_ssApproachSurfaces = 0;

 private:
  void closeGeometry(const IMaterialDecorator* materialDecorator,
                     const GeometryID& layerID);
};

using LayerArray = BinnedArray<LayerPtr>;

}  // namespace Acts

#include "Acts/Geometry/detail/Layer.ipp"