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/Geometry/BoundarySurfaceT.hpp"
#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/Geometry/GeometryIdentifier.hpp"
#include "Acts/Geometry/Layer.hpp"
#include "Acts/Geometry/Volume.hpp"
#include "Acts/Material/IVolumeMaterial.hpp"
#include "Acts/Surfaces/BoundaryCheck.hpp"
#include "Acts/Surfaces/Surface.hpp"
#include "Acts/Utilities/BinnedArray.hpp"
#include "Acts/Utilities/BoundingBox.hpp"
#include "Acts/Utilities/Definitions.hpp"
#include "Acts/Utilities/Frustum.hpp"
#include "Acts/Utilities/Logger.hpp"
#include "Acts/Utilities/Ray.hpp"

#include <functional>
#include <map>
#include <string>

namespace Acts {

class GlueVolumesDescriptor;
class VolumeBounds;

template <typename object_t>
struct NavigationOptions;

// 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>;

// Intersection with Layer
using LayerIntersection = ObjectIntersection<Layer, Surface>;

// Full intersection with surface
using BoundarySurface = BoundarySurfaceT<TrackingVolume>;
using BoundaryIntersection = ObjectIntersection<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 Transform3D& 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 Transform3D& 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 Transform3D& 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 Vector3D& position) const;

  std::vector<LayerIntersection> compatibleLayers(
      const GeometryContext& gctx, const Vector3D& position,
      const Vector3D& direction, const NavigationOptions<Layer>& options) const;

  std::vector<BoundaryIntersection> compatibleBoundaries(
      const GeometryContext& gctx, const Vector3D& position,
      const Vector3D& direction, const NavigationOptions<Surface>& options,
      LoggerWrapper logger = getDummyLogger()) const;

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

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

  const LayerArray* confinedLayers() const;

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

  const MutableTrackingVolumeVector denseVolumes() const;

  void visitSurfaces(
      const std::function<void(const Acts::Surface*)>& visitor) const;

  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 Transform3D& transform, VolumeBoundsPtr volbounds,
                 const std::shared_ptr<const TrackingVolumeArray>&
                     containedVolumeArray = nullptr,
                 const std::string& volumeName = "undefined");

  TrackingVolume(const Transform3D& 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 Transform3D& 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::map<std::string, const TrackingVolume*>& volumeMap,
                     size_t& vol);

  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;
}

#include "detail/TrackingVolume.ipp"

}  // namespace Acts