DetectorVolume.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2022-2023 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/Common.hpp"
#include "Acts/Detector/PortalGenerators.hpp"
#include "Acts/Geometry/Extent.hpp"
#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/Geometry/GeometryIdentifier.hpp"
#include "Acts/Geometry/VolumeBounds.hpp"
#include "Acts/Material/IVolumeMaterial.hpp"
#include "Acts/Navigation/NavigationDelegates.hpp"
#include "Acts/Navigation/NavigationState.hpp"
#include "Acts/Surfaces/BoundaryCheck.hpp"
#include "Acts/Utilities/BoundingBox.hpp"
#include "Acts/Utilities/Delegate.hpp"
#include "Acts/Utilities/Helpers.hpp"

#include <algorithm>
#include <cstddef>
#include <memory>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>

namespace Acts {

class Surface;
class IVolumeMaterial;
class VolumeBounds;

namespace Experimental {

class DetectorVolume;
class Portal;
class Detector;

class DetectorVolume : public std::enable_shared_from_this<DetectorVolume> {
 public:
  using BoundingBox =
      Acts::AxisAlignedBoundingBox<Acts::Experimental::DetectorVolume,
                                   Acts::ActsScalar, 3>;

  friend class DetectorVolumeFactory;

  template <typename internal_type>
  struct ObjectStore {
    std::vector<internal_type> internal = {};

    std::vector<const typename internal_type::element_type*> external = {};

    ObjectStore(std::vector<internal_type> objects)
        : internal(std::move(objects)) {
      external = unpack_shared_const_vector(internal);
    }

    ObjectStore() = default;
  };

 protected:
  DetectorVolume(
      const GeometryContext& gctx, std::string name,
      const Transform3& transform, std::shared_ptr<VolumeBounds> bounds,
      std::vector<std::shared_ptr<Surface>> surfaces,
      std::vector<std::shared_ptr<DetectorVolume>> volumes,
      DetectorVolumeUpdator detectorVolumeUpdator,
      SurfaceCandidatesUpdator surfaceCandidateUpdator) noexcept(false);

  DetectorVolume(
      const GeometryContext& gctx, std::string name,
      const Transform3& transform, std::shared_ptr<VolumeBounds> bounds,
      SurfaceCandidatesUpdator surfaceCandidateUpdator) noexcept(false);

  static std::shared_ptr<DetectorVolume> makeShared(
      const GeometryContext& gctx, std::string name,
      const Transform3& transform, std::shared_ptr<VolumeBounds> bounds,
      std::vector<std::shared_ptr<Surface>> surfaces,
      std::vector<std::shared_ptr<DetectorVolume>> volumes,
      DetectorVolumeUpdator detectorVolumeUpdator,
      SurfaceCandidatesUpdator surfaceCandidateUpdator);

  static std::shared_ptr<DetectorVolume> makeShared(
      const GeometryContext& gctx, std::string name,
      const Transform3& transform, std::shared_ptr<VolumeBounds> bounds,
      SurfaceCandidatesUpdator surfaceCandidateUpdator);

 public:
  std::shared_ptr<DetectorVolume> getSharedPtr();

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

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

  Vector3 center(const GeometryContext& gctx = GeometryContext()) const;

  const VolumeBounds& volumeBounds() const;

  bool inside(const GeometryContext& gctx, const Vector3& position) const;

  bool exclusivelyInside(const GeometryContext& gctx,
                         const Vector3& position) const;

  Extent extent(const GeometryContext& gctx, size_t nseg = 1) const;

  void updateNavigationState(const GeometryContext& gctx,
                             NavigationState& nState) const;

  std::vector<std::shared_ptr<Portal>>& portalPtrs();

  std::vector<std::shared_ptr<Surface>>& surfacePtrs();

  std::vector<std::shared_ptr<DetectorVolume>>& volumePtrs();

  const std::vector<const Portal*>& portals() const;

  const std::vector<const Surface*>& surfaces() const;

  const std::vector<const DetectorVolume*>& volumes() const;

  const DetectorVolumeUpdator& detectorVolumeUpdator() const;

  void assignSurfaceCandidatesUpdator(
      SurfaceCandidatesUpdator surfaceCandidateUpdator,
      const std::vector<std::shared_ptr<Surface>>& surfaces = {},
      const std::vector<std::shared_ptr<DetectorVolume>>& volumes = {});

  const SurfaceCandidatesUpdator& surfaceCandidatesUpdator() const;

  void updatePortal(std::shared_ptr<Portal> portal,
                    unsigned int pIndex) noexcept(false);

  void closePortals();

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

  std::shared_ptr<IVolumeMaterial> volumeMaterialPtr();

  const IVolumeMaterial* volumeMaterial() const;

  const std::string& name() const;

  const GeometryIdentifier& geometryId() const;

  void assignGeometryId(const GeometryIdentifier& geoID);

  void assignDetector(const Detector& detector);

  const Detector* detector() const;

  const BoundingBox& getBoundingBox() const;

 private:
  void construct(const GeometryContext& gctx,
                 const PortalGenerator& portalGenerator) noexcept(false);

  // Check containment - only in debug mode
  bool checkContainment(const GeometryContext& gctx, size_t nseg = 1) const;

  void createBoundingBox(const GeometryContext& gctx);

  std::string m_name = "Unnamed";

  Transform3 m_transform = Transform3::Identity();

  std::shared_ptr<VolumeBounds> m_bounds = nullptr;

  ObjectStore<std::shared_ptr<Portal>> m_portals;

  ObjectStore<std::shared_ptr<Surface>> m_surfaces;

  ObjectStore<std::shared_ptr<DetectorVolume>> m_volumes;

  std::shared_ptr<const BoundingBox> m_boundingBox;

  DetectorVolumeUpdator m_detectorVolumeUpdator;

  SurfaceCandidatesUpdator m_surfaceCandidatesUpdator;

  std::shared_ptr<IVolumeMaterial> m_volumeMaterial = nullptr;

  GeometryIdentifier m_geometryId{0};

  const Detector* m_detector = nullptr;
};

class DetectorVolumeFactory {
 public:
  static std::shared_ptr<DetectorVolume> construct(
      const PortalGenerator& portalGenerator, const GeometryContext& gctx,
      const std::string& name, const Transform3& transform,
      std::shared_ptr<VolumeBounds> bounds,
      const std::vector<std::shared_ptr<Surface>>& surfaces,
      const std::vector<std::shared_ptr<DetectorVolume>>& volumes,
      DetectorVolumeUpdator detectorVolumeUpdator,
      SurfaceCandidatesUpdator surfaceCandidateUpdator) {
    auto dVolume = DetectorVolume::makeShared(
        gctx, name, transform, std::move(bounds), surfaces, volumes,
        std::move(detectorVolumeUpdator), std::move(surfaceCandidateUpdator));
    dVolume->construct(gctx, portalGenerator);
    return dVolume;
  }

  static std::shared_ptr<DetectorVolume> construct(
      const PortalGenerator& portalGenerator, const GeometryContext& gctx,
      std::string name, const Transform3& transform,
      std::shared_ptr<VolumeBounds> bounds,
      SurfaceCandidatesUpdator surfaceCandidateUpdator) {
    auto dVolume = DetectorVolume::makeShared(
        gctx, std::move(name), transform, std::move(bounds),
        std::move(surfaceCandidateUpdator));
    dVolume->construct(gctx, portalGenerator);
    return dVolume;
  }
};

struct AllPortalsExtractor {
  inline static const std::vector<const Portal*> extract(
      [[maybe_unused]] const GeometryContext& gctx,
      const NavigationState& nState) {
    if (nState.currentVolume == nullptr) {
      throw std::runtime_error(
          "AllPortalsExtractor: no detector volume given.");
    }
    return nState.currentVolume->portals();
  }
};

struct AllSurfacesExtractor {
  inline static const std::vector<const Surface*> extract(
      [[maybe_unused]] const GeometryContext& gctx,
      const NavigationState& nState,
      [[maybe_unused]] const std::vector<size_t>& indices = {}) {
    if (nState.currentVolume == nullptr) {
      throw std::runtime_error(
          "AllSurfacesExtractor: no detector volume given.");
    }
    return nState.currentVolume->surfaces();
  }
};

struct IndexedSurfacesExtractor {
  inline static const std::vector<const Surface*> extract(
      [[maybe_unused]] const GeometryContext& gctx,
      const NavigationState& nState, const std::vector<size_t>& indices) {
    if (nState.currentVolume == nullptr) {
      throw std::runtime_error(
          "IndexedSurfacesExtractor: no detector volume given.");
    }
    // Get the surface container
    const auto& surfaces = nState.currentVolume->surfaces();
    // The extracted surfaces
    std::vector<const Surface*> eSurfaces;
    eSurfaces.reserve(indices.size());
    std::for_each(indices.begin(), indices.end(),
                  [&](const auto& i) { eSurfaces.push_back(surfaces[i]); });
    return eSurfaces;
  }
};

struct AllSubVolumesExtractor {
  inline static const std::vector<const DetectorVolume*> extract(
      [[maybe_unused]] const GeometryContext& gctx,
      const NavigationState& nState,
      [[maybe_unused]] const std::vector<size_t>& indices = {}) {
    if (nState.currentVolume == nullptr) {
      throw std::runtime_error(
          "AllSubVolumesExtractor: no detector volume given.");
    }
    return nState.currentVolume->volumes();
  }
};

struct IndexedSubVolumesExtractor {
  inline static const std::vector<const DetectorVolume*> extract(
      [[maybe_unused]] const GeometryContext& gctx,
      const NavigationState& nState, const std::vector<size_t>& indices) {
    if (nState.currentVolume == nullptr) {
      throw std::runtime_error(
          "AllSubVolumesExtractor: no detector volume given.");
    }
    // Get the sub volumes container
    const auto& volumes = nState.currentVolume->volumes();
    // The extracted volumes
    std::vector<const DetectorVolume*> eVolumes;
    eVolumes.reserve(indices.size());
    std::for_each(indices.begin(), indices.end(),
                  [&](const auto& i) { eVolumes.push_back(volumes[i]); });
    return eVolumes;
  }
};

}  // namespace Experimental
}  // namespace Acts