TrackingVolume.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file TrackingVolume.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/.

#pragma once

#include "Acts/Definitions/Algebra.hpp"
#include "Acts/Geometry/AbstractVolume.hpp"
#include "Acts/Geometry/BoundarySurfaceFace.hpp"
#include "Acts/Geometry/BoundarySurfaceT.hpp"
#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/Geometry/GeometryIdentifier.hpp"
#include "Acts/Geometry/Layer.hpp"
#include "Acts/Geometry/SurfaceVisitorConcept.hpp"
#include "Acts/Geometry/Volume.hpp"
#include "Acts/Material/IVolumeMaterial.hpp"
#include "Acts/Surfaces/BoundaryCheck.hpp"
#include "Acts/Surfaces/Surface.hpp"
#include "Acts/Surfaces/SurfaceArray.hpp"
#include "Acts/Utilities/BinnedArray.hpp"
#include "Acts/Utilities/BoundingBox.hpp"
#include "Acts/Utilities/Concepts.hpp"
#include "Acts/Utilities/Frustum.hpp"
#include "Acts/Utilities/Intersection.hpp"
#include "Acts/Utilities/Logger.hpp"
#include "Acts/Utilities/Ray.hpp"

#include <cstddef>
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>

#include <boost/container/small_vector.hpp>

namespace Acts {

class GlueVolumesDescriptor;
class VolumeBounds;
template <typename object_t>
struct NavigationOptions;
class GeometryIdentifier;
class IMaterialDecorator;
class ISurfaceMaterial;
class IVolumeMaterial;
class Surface;
class TrackingVolume;
struct GeometryIdentifierHook;

// master typedefs
using TrackingVolumePtr = std::shared_ptr<const TrackingVolume>;
using MutableTrackingVolumePtr = std::shared_ptr<TrackingVolume>;

using TrackingVolumeBoundaryPtr =
    std::shared_ptr<const BoundarySurfaceT<TrackingVolume>>;
using TrackingVolumeBoundaries = std::vector<TrackingVolumeBoundaryPtr>;

// possible contained
using TrackingVolumeArray = BinnedArray<TrackingVolumePtr>;
using TrackingVolumeVector = std::vector<TrackingVolumePtr>;
using MutableTrackingVolumeVector = std::vector<MutableTrackingVolumePtr>;
using LayerArray = BinnedArray<LayerPtr>;
using LayerVector = std::vector<LayerPtr>;

using LayerIntersection = ObjectIntersection<Layer, Surface>;
using LayerMultiIntersection = ObjectMultiIntersection<Layer, Surface>;

using BoundarySurface = BoundarySurfaceT<TrackingVolume>;
using BoundaryIntersection = ObjectIntersection<BoundarySurface, Surface>;
using BoundaryMultiIntersection =
    ObjectMultiIntersection<BoundarySurface, Surface>;

class TrackingVolume : public Volume {
  friend class TrackingGeometry;

 public:
  TrackingVolume() = delete;
  ~TrackingVolume() override;
  TrackingVolume(const TrackingVolume&) = delete;
  TrackingVolume& operator=(const TrackingVolume&) = delete;

  static MutableTrackingVolumePtr create(
      const Transform3& transform, VolumeBoundsPtr volumeBounds,
      const std::shared_ptr<const TrackingVolumeArray>& containedVolumes =
          nullptr,
      const std::string& volumeName = "undefined") {
    return MutableTrackingVolumePtr(new TrackingVolume(
        transform, std::move(volumeBounds), containedVolumes, volumeName));
  }

  static MutableTrackingVolumePtr create(
      const Transform3& transform, VolumeBoundsPtr volbounds,
      std::vector<std::unique_ptr<Volume::BoundingBox>> boxStore,
      std::vector<std::unique_ptr<const Volume>> descendants,
      const Volume::BoundingBox* top,
      std::shared_ptr<const IVolumeMaterial> volumeMaterial,
      const std::string& volumeName = "undefined") {
    return MutableTrackingVolumePtr(new TrackingVolume(
        transform, std::move(volbounds), std::move(boxStore),
        std::move(descendants), top, std::move(volumeMaterial), volumeName));
  }

  static MutableTrackingVolumePtr create(
      const Transform3& transform, VolumeBoundsPtr volumeBounds,
      std::shared_ptr<const IVolumeMaterial> volumeMaterial,
      std::unique_ptr<const LayerArray> containedLayers = nullptr,
      std::shared_ptr<const TrackingVolumeArray> containedVolumes = nullptr,
      MutableTrackingVolumeVector denseVolumes = {},
      const std::string& volumeName = "undefined") {
    return MutableTrackingVolumePtr(new TrackingVolume(
        transform, std::move(volumeBounds), std::move(volumeMaterial),
        std::move(containedLayers), std::move(containedVolumes),
        std::move(denseVolumes), volumeName));
  }

  const Layer* associatedLayer(const GeometryContext& gctx,
                               const Vector3& position) const;

  boost::container::small_vector<LayerIntersection, 10> compatibleLayers(
      const GeometryContext& gctx, const Vector3& position,
      const Vector3& direction, const NavigationOptions<Layer>& options) const;

  boost::container::small_vector<BoundaryIntersection, 4> compatibleBoundaries(
      const GeometryContext& gctx, const Vector3& position,
      const Vector3& direction, const NavigationOptions<Surface>& options,
      const Logger& logger = getDummyLogger()) const;

  std::vector<SurfaceIntersection> compatibleSurfacesFromHierarchy(
      const GeometryContext& gctx, const Vector3& position,
      const Vector3& direction, double angle,
      const NavigationOptions<Surface>& options) const;

  const TrackingVolume* lowestTrackingVolume(const GeometryContext& gctx,
                                             const Vector3& position,
                                             const double tol = 0.) const;

  const LayerArray* confinedLayers() const;

  std::shared_ptr<const TrackingVolumeArray> confinedVolumes() const;

  const MutableTrackingVolumeVector denseVolumes() const;

  template <ACTS_CONCEPT(SurfaceVisitor) visitor_t>
  void visitSurfaces(visitor_t&& visitor) const {
    if (!m_confinedVolumes) {
      // no sub volumes => loop over the confined layers
      if (m_confinedLayers) {
        for (const auto& layer : m_confinedLayers->arrayObjects()) {
          if (layer->surfaceArray() == nullptr) {
            // no surface array (?)
            continue;
          }
          for (const auto& srf : layer->surfaceArray()->surfaces()) {
            visitor(srf);
          }
        }
      }
    } else {
      // contains sub volumes
      for (const auto& volume : m_confinedVolumes->arrayObjects()) {
        volume->visitSurfaces(visitor);
      }
    }
  }

  const std::string& volumeName() const;

  const TrackingVolumeBoundaries& boundarySurfaces() const;

  const IVolumeMaterial* volumeMaterial() const;

  const std::shared_ptr<const IVolumeMaterial>& volumeMaterialSharedPtr() const;

  void assignBoundaryMaterial(
      std::shared_ptr<const ISurfaceMaterial> surfaceMaterial,
      BoundarySurfaceFace bsFace);

  void assignVolumeMaterial(std::shared_ptr<const IVolumeMaterial> material);

  void glueTrackingVolume(const GeometryContext& gctx,
                          BoundarySurfaceFace bsfMine, TrackingVolume* neighbor,
                          BoundarySurfaceFace bsfNeighbor);

  void glueTrackingVolumes(
      const GeometryContext& gctx, BoundarySurfaceFace bsfMine,
      const std::shared_ptr<TrackingVolumeArray>& neighbors,
      BoundarySurfaceFace bsfNeighbor);

  void updateBoundarySurface(
      BoundarySurfaceFace bsf,
      std::shared_ptr<const BoundarySurfaceT<TrackingVolume>> bs,
      bool checkmaterial = true);

  void registerGlueVolumeDescriptor(GlueVolumesDescriptor* gvd);

  GlueVolumesDescriptor& glueVolumesDescriptor();

  bool hasBoundingVolumeHierarchy() const;

  void registerColorCode(unsigned int icolor);

  unsigned int colorCode() const;

  const TrackingVolume* motherVolume() const;

  void setMotherVolume(const TrackingVolume* mvol);

 protected:
  TrackingVolume(const Transform3& transform, VolumeBoundsPtr volbounds,
                 const std::shared_ptr<const TrackingVolumeArray>&
                     containedVolumeArray = nullptr,
                 const std::string& volumeName = "undefined");

  TrackingVolume(const Transform3& transform, VolumeBoundsPtr volbounds,
                 std::vector<std::unique_ptr<Volume::BoundingBox>> boxStore,
                 std::vector<std::unique_ptr<const Volume>> descendants,
                 const Volume::BoundingBox* top,
                 std::shared_ptr<const IVolumeMaterial> volumeMaterial,
                 const std::string& volumeName = "undefined");

  TrackingVolume(
      const Transform3& transform, VolumeBoundsPtr volumeBounds,
      std::shared_ptr<const IVolumeMaterial> volumeMaterial,
      std::unique_ptr<const LayerArray> staticLayerArray = nullptr,
      std::shared_ptr<const TrackingVolumeArray> containedVolumeArray = nullptr,
      MutableTrackingVolumeVector denseVolumeVector = {},
      const std::string& volumeName = "undefined");

 private:
  void connectDenseBoundarySurfaces(
      MutableTrackingVolumeVector& confinedDenseVolumes);

  void createBoundarySurfaces();

  void synchronizeLayers(double envelope = 1.) const;

  void closeGeometry(
      const IMaterialDecorator* materialDecorator,
      std::unordered_map<GeometryIdentifier, const TrackingVolume*>& volumeMap,
      size_t& vol, const GeometryIdentifierHook& hook,
      const Logger& logger = getDummyLogger());

  void interlinkLayers();

  std::shared_ptr<const IVolumeMaterial> m_volumeMaterial{nullptr};

  const TrackingVolume* m_motherVolume{nullptr};

  // the boundary surfaces
  std::vector<TrackingVolumeBoundaryPtr> m_boundarySurfaces;

  std::unique_ptr<const LayerArray> m_confinedLayers = nullptr;

  std::shared_ptr<const TrackingVolumeArray> m_confinedVolumes = nullptr;

  MutableTrackingVolumeVector m_confinedDenseVolumes;

  GlueVolumesDescriptor* m_glueVolumeDescriptor{nullptr};

  std::string m_name;

  unsigned int m_colorCode{20};

  std::vector<std::unique_ptr<const Volume::BoundingBox>> m_boundingBoxes;
  std::vector<std::unique_ptr<const Volume>> m_descendantVolumes;
  const Volume::BoundingBox* m_bvhTop{nullptr};
};

inline const std::string& TrackingVolume::volumeName() const {
  return m_name;
}

inline const IVolumeMaterial* TrackingVolume::volumeMaterial() const {
  return m_volumeMaterial.get();
}

inline const std::shared_ptr<const IVolumeMaterial>&
TrackingVolume::volumeMaterialSharedPtr() const {
  return m_volumeMaterial;
}

inline void TrackingVolume::assignVolumeMaterial(
    std::shared_ptr<const IVolumeMaterial> material) {
  m_volumeMaterial = std::move(material);
}

inline const LayerArray* TrackingVolume::confinedLayers() const {
  return m_confinedLayers.get();
}

inline const MutableTrackingVolumeVector TrackingVolume::denseVolumes() const {
  return m_confinedDenseVolumes;
}

inline std::shared_ptr<const TrackingVolumeArray>
TrackingVolume::confinedVolumes() const {
  return m_confinedVolumes;
}

inline void TrackingVolume::registerColorCode(unsigned int icolor) {
  m_colorCode = icolor;
}

inline unsigned int TrackingVolume::colorCode() const {
  return m_colorCode;
}

inline const TrackingVolume* TrackingVolume::motherVolume() const {
  return m_motherVolume;
}

inline void TrackingVolume::setMotherVolume(const TrackingVolume* mvol) {
  m_motherVolume = mvol;
}

inline bool TrackingVolume::hasBoundingVolumeHierarchy() const {
  return m_bvhTop != nullptr;
}

#ifndef DOXYGEN
#include "Acts/Geometry/detail/TrackingVolume.ipp"
#endif

}  // namespace Acts