TrackingVolume.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 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 "TrkDetDescrUtils/SharedObject.h"
#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/AbstractVolume.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;
 
// For local spans (typedef to make it easier for C++20 std:: one)
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>>& m_var)
    : m_span(&*(m_var.begin()), &*(m_var.end()))
  {
  }
  // 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();
 
  TrackingVolume(Amg::Transform3D* htrans,
                 VolumeBounds* volbounds,
                 LayerArray* subLayers = nullptr,
                 TrackingVolumeArray* subVolumes = nullptr,
                 const std::string& volumeName = "undefined");
 
  TrackingVolume(const Volume& volume,
                 const Material& matprop,
                 LayerArray* subLayers = nullptr,
                 TrackingVolumeArray* subVolumes = nullptr,
                 const std::string& volumeName = "undefined");
 
  TrackingVolume(Amg::Transform3D* htrans,
                 VolumeBounds* volbounds,
                 const Material& matprop,
                 LayerArray* subLayers = nullptr,
                 TrackingVolumeArray* subVolumes = nullptr,
                 const std::string& volumeName = "undefined");
 
  TrackingVolume(
    Amg::Transform3D* htrans,
    VolumeBounds* volbounds,
    const Material& matprop,
    std::vector<DetachedTrackingVolume*>* detachedSubVolumes,
    const std::string& volumeName = "undefined");
 
  TrackingVolume(
    const Volume& volume,
    const Material& matprop,
    std::vector<DetachedTrackingVolume*>* detachedSubVolumes,
    const std::string& volumeName = "undefined");
 
  TrackingVolume(Amg::Transform3D* htrans,
                 VolumeBounds* volbounds,
                 const Material& matprop,
                 const std::vector<TrackingVolume*>* unorderedSubVolumes,
                 const std::string& volumeName = "undefined");
 
  TrackingVolume(const Volume& volume,
                 const Material& matprop,
                 const std::vector<TrackingVolume*>* unorderedSubVolumes,
                 const std::string& volumeName = "undefined");
 
  TrackingVolume(Amg::Transform3D* htrans,
                 VolumeBounds* volbounds,
                 const Material& matprop,
                 const std::vector<Layer*>* arbitraryLayers,
                 const std::string& volumeName = "undefined");
 
  TrackingVolume(const Volume& volume,
                 const Material& matprop,
                 const std::vector<Layer*>* arbitraryLayers,
                 const std::string& volumeName = "undefined");
 
  TrackingVolume(Amg::Transform3D* htrans,
                 VolumeBounds* volbounds,
                 const std::vector<Layer*>* arbitraryLayers,
                 const std::vector<TrackingVolume*>* unorderedSubVolumes,
                 const Material& matprop,
                 const std::string& volumeName = "undefined");
 
  TrackingVolume(const Volume& volume,
                 const std::vector<Layer*>* arbitraryLayers,
                 const std::vector<TrackingVolume*>* unorderedSubVolumes,
                 const Material& matprop,
                 const std::string& volumeName = "undefined");
 
  TrackingVolume(const TrackingVolume& trVol, Amg::Transform3D& transform);
 
  ~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<SharedObject<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;
 
  void forceNavigationCheck();
 
  bool redoNavigation() 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 clear();
 
  void screenDump(MsgStream& msg) const;
 
protected:
  TrackingVolume* cloneTV (Amg::Transform3D& transform) 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; 
 
  std::vector<SharedObject<BoundarySurface<TrackingVolume>>> m_boundarySurfaces{};
  LayerArray* m_confinedLayers; 
  TrackingVolumeArray* m_confinedVolumes;
  const std::vector<DetachedTrackingVolume*>* m_confinedDetachedVolumes;
  
  
  const std::vector<TrackingVolume*>* m_confinedDenseVolumes; 
  //(b)
  const std::vector<Layer*>* m_confinedArbitraryLayers;
 
  CxxUtils::CachedUniquePtrT<GlueVolumesDescriptor> m_outsideGlueVolumes;
 
  LayerAttemptsCalculator* m_layerAttemptsCalculator;
 
  GeometrySignature m_geometrySignature;
  GeometryType m_geometryType;
 
  std::string m_name;       
  unsigned int m_colorCode; 
  bool m_redoNavigation; 
};
 
} // end of namespace
#include "TrkGeometry/TrackingVolume.icc"
#endif // TRKGEOMETRY_TRACKINGVOLUME_H