TrackingGeometry.h

Go to the documentation of this file.

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

// TrackingGeometry.h, (c) ATLAS Detector software
 
#ifndef TRKGEOMETRY_TRACKINGGEOMETRY_H
#define TRKGEOMETRY_TRACKINGGEOMETRY_H
 
// Amg
#include "GeoPrimitives/GeoPrimitives.h"
// Trk
#include "TrkDetDescrUtils/GeometrySignature.h"
#include "TrkGeometry/TrackingVolume.h"
// CLASS DEF
#include "AthenaKernel/CLASS_DEF.h"
// STL
#include <map>
// ATH_MSG macros
#include "AthenaBaseComps/AthMsgStreamMacros.h"
//boost
#include <ranges>
#include <memory>
 
#include "CxxUtils/checker_macros.h"
 
class MsgStream;
 
// must be known to declare friend class
namespace Muon {
class MuonTrackingGeometryBuilderCond;
}
 
namespace Trk {

 
enum NavigationLevel
{
  noNavigation = 0,
  globalSearch = 1,
  association = 2
};
 
class TrackingVolume;
class Layer;
class MaterialProperties;

class TrackingGeometry
{

  friend class GeometryBuilder;
 
  friend class GeometryBuilderCond;
 
public:

  TrackingGeometry(TrackingVolume* highestVolume,
                   NavigationLevel navlevel = globalSearch);
  virtual ~TrackingGeometry();

  const TrackingVolume* highestTrackingVolume() const;
  TrackingVolume* highestTrackingVolume();
 

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

  std::vector<const Trk::DetachedTrackingVolume*>
  lowestDetachedTrackingVolumes(const Amg::Vector3D& gp) const;

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

  const TrackingVolume* trackingVolume(const std::string& name) const;

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

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

  template<class T>
  LayerIntersection<Amg::Vector3D> closestMaterialLayer(const T& pars,
                                                        PropDirection pDir = Trk::alongMomentum,
                                                        const BoundaryCheck& bchk = true) const;
  static bool atVolumeBoundary(const Amg::Vector3D& gp,
                               const TrackingVolume* vol,
                               double tol);

  static bool atVolumeBoundary(const Amg::Vector3D& gp,
                               const Amg::Vector3D& mom,
                               const TrackingVolume* vol,
                               const TrackingVolume*& nextVol,
                               Trk::PropDirection dir,
                               double tol);

  const std::map<Layer*, int>& boundaryLayers() ;
  auto  boundaryLayers() const;
 
  size_t  numBoundaryLayers() const;
  NavigationLevel navigationLevel() const;

  void printVolumeHierarchy(MsgStream& msgstream) const;

  void indexStaticLayers(GeometrySignature geosit, int offset = 0);
 
  void dump(MsgStream& out, const std::string& head) const;
 
  // get ownership of Muon Tracking Geometry Elements
  void addToGarbage(std::vector<std::unique_ptr<Trk::DetachedTrackingVolume>>&& garbageVec);
  void addToGarbage(std::vector<std::unique_ptr<Trk::TrackingVolume>>&& garbageVec);
 
 
 private:
  void sign(GeometrySignature geosit, GeometryType geotype = Static);

  void compactify(MsgStream& msgstream, TrackingVolume* vol = nullptr);

  void synchronizeLayers(MsgStream& msgstream, TrackingVolume* vol = nullptr);

  void registerNavigationLevel(NavigationLevel navlevel);

  void registerTrackingVolumes(TrackingVolume& tvol,
                               TrackingVolume* mvol = nullptr,
                               int lvl = 0);

  TrackingVolume* checkoutHighestTrackingVolume();

  void printVolumeInformation(MsgStream& msgstream,
                              const TrackingVolume& tvol,
                              int lvl) const;
 
  static void dumpLayer(MsgStream& out,
                        const std::string& head,
                        const Layer* layer);

  std::unique_ptr<TrackingVolume> m_world;

  std::map<Layer*, int> m_boundaryLayers;

  std::map<const std::string, const TrackingVolume*> m_trackingVolumes;

  NavigationLevel m_navigationLevel;

  std::vector<std::unique_ptr<DetachedTrackingVolume>> m_detachedVolGarbage{};
  std::vector<std::unique_ptr<TrackingVolume>> m_trkVolumeGarbage{};
 
};
 
} // end of namespace
#include "TrkGeometry/TrackingGeometry.icc"
CLASS_DEF(Trk::TrackingGeometry, 167645219, 1)
#include "AthenaKernel/CondCont.h"
CONDCONT_MIXED_DEF(Trk::TrackingGeometry, 119021535);
 
#endif // TRKGEOMETRY_TRACKINGGEOMETRY_H