TrackingVolume.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/

// TrackingVolume.h, (b) ATLAS Detector software
 
#ifndef TRKGEOMETRY_TRACKINGVOLUME_H
#define TRKGEOMETRY_TRACKINGVOLUME_H
 
// Amg
#include "GeoPrimitives/GeoPrimitives.h"
// Trk
#include "TrkDetDescrUtils/BinnedArray.h"
#include "TrkDetDescrUtils/GeometrySignature.h"
#include "TrkDetDescrUtils/ObjectAccessor.h"
#include <memory>
#include "TrkEventPrimitives/PropDirection.h"
#include "TrkGeometry/DetachedTrackingVolume.h"
#include "TrkGeometry/GlueVolumesDescriptor.h"
#include "TrkGeometry/LayerAttemptsCalculator.h"
#include "TrkGeometry/Material.h"
#include "TrkSurfaces/BoundaryCheck.h"
#include "TrkSurfaces/Surface.h"
#include "TrkVolumes/BoundaryCylinderSurface.h"
#include "TrkVolumes/BoundaryDiscSurface.h"
#include "TrkVolumes/BoundarySurface.h"
#include "TrkVolumes/BoundarySurfaceFace.h"
#include "TrkVolumes/Volume.h"
// STL
#include <string>
#include <span>
// ATH_MSG macros
#include "AthenaBaseComps/AthMsgStreamMacros.h"
 
#include "CxxUtils/CachedUniquePtr.h"
#include "CxxUtils/checker_macros.h"
#ifndef TRKGEOMETRY_MAXLAYERATTEMPTS
#define TRKGEOMETRY_MAXLAYERATTEMPTS 100
#endif
 
class MsgStream;
 
namespace Trk {
 
// classes
class Layer;
class PlaneLayer;
class TrackingVolume;
class DetachedTrackingVolume;
class VolumeBounds;
 
//Binned Array arrayObjects returns a span
typedef BinnedArray<Layer> LayerArray;
typedef BinnedArray<TrackingVolume> TrackingVolumeArray;
 
template<class T>
using ArraySpan = std::span<T>;
 
//Helper for const correct access to boundary surfaces  via a span
//We want const correct access to the underlying plain ptrs.
template<class T>
class ConstSharedPtrSpan
{
public:
  ConstSharedPtrSpan(const std::vector<std::shared_ptr<T>>& var)
    : m_span(var)
  {
  }
  // access the ptr
  const T * operator[](size_t i) const { return m_span[i].get(); }
  constexpr bool empty() const noexcept { return m_span.empty(); }
  constexpr size_t size() const noexcept { return m_span.size(); }
 
private:
  ArraySpan<const std::shared_ptr<T>> m_span;
};
 
 
template<class T>
using LayerIntersection = FullIntersection<Layer, Surface, T>;
template<class T>
using BoundaryIntersection =
  FullIntersection<BoundarySurface<TrackingVolume>, Surface, T>;

 
class TrackingVolume
  : public Volume
  , public Material
{

  friend class TrackingVolumeManipulator;

  friend class TrackingGeometry;

  friend class DetachedTrackingVolume;
 
public:
  TrackingVolume() = default;

  TrackingVolume(std::unique_ptr<Amg::Transform3D> htrans,
                 std::shared_ptr<VolumeBounds> volbounds,
                 std::unique_ptr<LayerArray> subLayers = nullptr,
                 std::unique_ptr<TrackingVolumeArray> subVolumes = nullptr,
                 const std::string& volumeName = "undefined");

  TrackingVolume(const Volume& volume,
                 const Material& matprop,
                 std::unique_ptr<LayerArray> subLayers = nullptr,
                 std::unique_ptr<TrackingVolumeArray> subVolumes = nullptr,
                 const std::string& volumeName = "undefined");

  TrackingVolume(std::unique_ptr<Amg::Transform3D> htrans,
                 std::shared_ptr<VolumeBounds> volbounds,
                 const Material& matprop,
                 std::unique_ptr<LayerArray> subLayers = nullptr,
                 std::unique_ptr<TrackingVolumeArray> subVolumes = nullptr,
                 const std::string& volumeName = "undefined");

  TrackingVolume(
    std::unique_ptr<Amg::Transform3D> htrans,
    std::shared_ptr<VolumeBounds> volbounds,
    const Material& matprop,
    std::unique_ptr<std::vector<DetachedTrackingVolume*>> detachedSubVolumes,
    const std::string& volumeName = "undefined");

  TrackingVolume(
    const Volume& volume,
    const Material& matprop,
    std::unique_ptr<std::vector<DetachedTrackingVolume*>> detachedSubVolumes,
    const std::string& volumeName = "undefined");

  TrackingVolume(std::unique_ptr<Amg::Transform3D> htrans,
                 std::shared_ptr<VolumeBounds> volbounds,
                 const Material& matprop,
                 std::unique_ptr<const std::vector<TrackingVolume*>> unorderedSubVolumes,
                 const std::string& volumeName = "undefined");

  TrackingVolume(const Volume& volume,
                 const Material& matprop,
                 std::unique_ptr<const std::vector<TrackingVolume*>> unorderedSubVolumes,
                 const std::string& volumeName = "undefined");

  TrackingVolume(std::unique_ptr<Amg::Transform3D> htrans,
                 std::shared_ptr<VolumeBounds> volbounds,
                 const Material& matprop,
                 std::unique_ptr<const std::vector<Layer*>> arbitraryLayers,
                 const std::string& volumeName = "undefined");

  TrackingVolume(const Volume& volume,
                 const Material& matprop,
                 std::unique_ptr<const std::vector<Layer*>> arbitraryLayers,
                 const std::string& volumeName = "undefined");

  TrackingVolume(std::unique_ptr<Amg::Transform3D> htrans,
                 std::shared_ptr<VolumeBounds> volbounds,
                 std::unique_ptr<const std::vector<Layer*>> arbitraryLayers,
                 std::unique_ptr<const std::vector<TrackingVolume*>> unorderedSubVolumes,
                 const Material& matprop,
                 const std::string& volumeName = "undefined");

  TrackingVolume(const Volume& volume,
                 std::unique_ptr<const std::vector<Layer*>> arbitraryLayers,
                 std::unique_ptr<const std::vector<TrackingVolume*>> unorderedSubVolumes,
                 const Material& matprop,
                 const std::string& volumeName = "undefined");

  TrackingVolume(const TrackingVolume& trVol, Amg::Transform3D& transform);

  virtual ~TrackingVolume() override;

  const Layer* associatedLayer(const Amg::Vector3D& gp) const;
  Layer* associatedLayer(const Amg::Vector3D& gp);
 

  const Layer* nextLayer(const Amg::Vector3D& gp,
                         const Amg::Vector3D& mom,
                         bool asres = true,
                         bool skipNavLayer = false) const;

  const Layer* entryLayer(const Amg::Vector3D& gp,
                          const Amg::Vector3D& dir) const;

  const Layer* exitLayer(const Amg::Vector3D& gp,
                         const Amg::Vector3D& dir) const;

  template<class T>
  std::vector<LayerIntersection<T>> materialLayersOrdered(
    const Layer* sLayer,
    const Layer* eLayer,
    const T& parameters,
    PropDirection pDir = alongMomentum,
    const BoundaryCheck& bchk = true,
    bool resolveSubSurfaces = false) const;

  LayerIntersection<Amg::Vector3D> closestMaterialLayer(
    const Amg::Vector3D& gp,
    const Amg::Vector3D& dir,
    PropDirection pDir = alongMomentum,
    const BoundaryCheck& bchk = true) const;

  const TrackingVolume* associatedSubVolume(const Amg::Vector3D& gp) const;
  TrackingVolume* associatedSubVolume(const Amg::Vector3D& gp);

  const TrackingVolume* nextVolume(const Amg::Vector3D& gp,
                                   const Amg::Vector3D& dir,
                                   PropDirection pDir = alongMomentum) const;

  const TrackingVolume* nextSubVolume(const Amg::Vector3D& gp,
                                      const Amg::Vector3D& dir) const;

  std::vector<const DetachedTrackingVolume*> assocDetachedSubVolumes(
    const Amg::Vector3D& gp,
    double tol) const;

  unsigned int layerAttempts(BoundarySurfaceFace exitFace) const;

  unsigned int maxLayerAttempts() const;

  const LayerArray* confinedLayers() const;

  LayerArray* confinedLayers();

  ArraySpan<Layer const * const> confinedArbitraryLayers() const;

  ArraySpan<Layer* const> confinedArbitraryLayers();

  const LayerArray* checkoutConfinedLayers() const;

  const TrackingVolumeArray* confinedVolumes() const;

  TrackingVolumeArray* confinedVolumes();

  ArraySpan<DetachedTrackingVolume const * const>  confinedDetachedVolumes() const;
  ArraySpan<DetachedTrackingVolume * const>  confinedDetachedVolumes();

  ArraySpan<TrackingVolume const * const> confinedDenseVolumes() const;
  ArraySpan<TrackingVolume * const> confinedDenseVolumes();

  const std::string& volumeName() const;

  std::vector<std::shared_ptr<BoundarySurface<TrackingVolume>>>& boundarySurfaces() ;
  ConstSharedPtrSpan<BoundarySurface<TrackingVolume>> boundarySurfaces() const;
  template<class T>
  std::vector<BoundaryIntersection<T>> boundarySurfacesOrdered(
    const T& parameters,
    PropDirection pDir = alongMomentum,
    bool startOffBoundary = false) const;

  const BoundarySurface<TrackingVolume>* boundarySurface(
    const ObjectAccessor::value_type& oa) const;

  template<class T>
  bool onVolumeBoundary(const T& pars) const;

 
  void registerOutsideGlueVolumes(GlueVolumesDescriptor* gvd);
 
  GlueVolumesDescriptor& glueVolumesDescriptor();
  const GlueVolumesDescriptor& glueVolumesDescriptor() const;

  void sign(GeometrySignature signat, GeometryType gtype = Static);

  GeometrySignature geometrySignature() const;

  GeometryType geometryType() const;

  void registerColorCode(unsigned int icolor);

  unsigned int colorCode() const;

  const TrackingVolume* getMotherVolume() const;

  void setMotherVolume(const TrackingVolume* mvol);

  void moveVolume(Amg::Transform3D& shift);

  void addMaterial(const Material& mat, float fact = 1.);
 
  virtual bool isAlignable() const;
 
  void screenDump(MsgStream& msg) const;
 
private:
  void indexContainedStaticLayers(GeometrySignature geoSig, int& offset);

  void indexContainedMaterialLayers(GeometrySignature geoSig, int& offset);

  void createBoundarySurfaces();

  void createLayerAttemptsCalculator();

  void compactify(size_t& rSurfaces, size_t& tSurfaces);

  void synchronizeLayers (MsgStream& msgstream, double envelope = 1.);

  void interlinkLayers ();

  static const Layer* closest(const Amg::Vector3D& pos,
                              const Amg::Vector3D& dir,
                              const Layer& first,
                              const Layer& second);

  void moveTV (Amg::Transform3D& transform);

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

  const TrackingVolume* m_motherVolume{nullptr};
  std::vector<std::shared_ptr<BoundarySurface<TrackingVolume>>> m_boundarySurfaces{nullptr};
  std::unique_ptr<LayerArray> m_confinedLayers{nullptr};
  std::unique_ptr<TrackingVolumeArray> m_confinedVolumes{nullptr};
  std::unique_ptr<const std::vector<DetachedTrackingVolume*>> m_confinedDetachedVolumes{nullptr};
  std::unique_ptr<const std::vector<TrackingVolume*>> m_confinedDenseVolumes{nullptr};
  std::unique_ptr<const std::vector<Layer*>> m_confinedArbitraryLayers{nullptr};
  CxxUtils::CachedUniquePtrT<GlueVolumesDescriptor> m_outsideGlueVolumes{nullptr};
  std::unique_ptr<LayerAttemptsCalculator> m_layerAttemptsCalculator{nullptr};
  GeometryType m_geometryType{Trk::NumberOfGeometryTypes};
  GeometrySignature m_geometrySignature{Trk::Unsigned};
  std::string m_name {"undefined"};       
  unsigned int m_colorCode{20} ; 
};
 
} // end of namespace
#include "TrkGeometry/TrackingVolume.icc"
#endif // TRKGEOMETRY_TRACKINGVOLUME_H