TrackingGeometry.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 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 <boost/iterator/transform_iterator.hpp>
#include <boost/range.hpp>
 
#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;
 
 
  class constTransformLayerMap
  {
  public:
    std::pair<const Trk::Layer*, int> operator()(
      const std::pair<Trk::Layer*, int>& in) const
    {
      return std::pair<const Trk::Layer*, int>{ in.first, in.second };
    }
  };
 
  using iterator_convert_const_t =
    boost::transform_iterator<constTransformLayerMap,
                              std::map<Trk::Layer*, int>::const_iterator>;
 
public:
 
  using constMapRange_t = boost::iterator_range<iterator_convert_const_t>;
  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() ;
  constMapRange_t  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);
 
  TrackingVolume* m_world{};
 
  std::map<Layer*, int> m_boundaryLayers;
 
  std::map<const std::string, const TrackingVolume*> m_trackingVolumes;
 
  NavigationLevel m_navigationLevel;
 
  // muon chambers
  std::vector<std::shared_ptr<DetachedTrackingVolume>> m_detachedVolGarbage{};  
  std::vector<std::shared_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