DetachedTrackingVolume.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
// DetachedTrackingVolume.h, (c) ATLAS Detector software
 
#ifndef TRKGEOMETRY_DETACHEDTRACKINGVOLUME_H
#define TRKGEOMETRY_DETACHEDTRACKINGVOLUME_H
 
class MsgStream;
 
#include "TrkDetDescrUtils/GeometrySignature.h"
#include "TrkGeometry/Layer.h"
#include "TrkGeometry/OverlapDescriptor.h"
#include "TrkGeometry/PlaneLayer.h"
#include "TrkSurfaces/Surface.h"
//CxxUtils
#include "CxxUtils/checker_macros.h"
// Amg
#include "GeoPrimitives/GeoPrimitives.h"
 
 
#include <span>
namespace Trk {
class TrackingVolume;
class Surface;
class MaterialProperties;
class MagneticFieldProperties;
 
// For local spans (typedef to make it easier for C++20 std:: one)
template<class T>
using ArraySpan = std::span<T>;
 
 
class DetachedTrackingVolume {
  friend class TrackingVolume;
  friend class DetachedTrackingVolumeBuilder;
  friend class IDetachedTrackingVolumeBuilder;
 
 public:
  DetachedTrackingVolume();
 
  DetachedTrackingVolume(std::string name, TrackingVolume* vol);
 
  DetachedTrackingVolume(std::string name,
                         TrackingVolume* vol,
                         Layer* layer,
                         const std::vector<Layer*>* multilayer = nullptr);
 
  ~DetachedTrackingVolume();
 
  const TrackingVolume* trackingVolume() const;
  TrackingVolume* trackingVolume();
 
  std::string name() const;
 
  void move (Amg::Transform3D& shift);
 
  DetachedTrackingVolume* clone(const std::string& name,
                                      Amg::Transform3D& shift) const;
 
  const Layer* layerRepresentation() const;
  Layer* layerRepresentation();
 
  ArraySpan<Layer const * const>  multilayerRepresentation() const;
  ArraySpan<Layer * const>  multilayerRepresentation();
 
  void sign(GeometrySignature signat, GeometryType geotype);
 
  GeometrySignature geometrySignature() const;
 
  GeometryType geometryType() const;
 
  void saveConstituents(
      const std::vector<std::pair<std::unique_ptr<const Trk::Volume>, float>>*);
  const std::vector<std::pair<std::unique_ptr<const Trk::Volume>, float>>*
  constituents() const;
 
  void setBaseTransform(Amg::Transform3D* transf = nullptr);
 
 private:
   void compactify(size_t& cSurfaces, size_t& tSurfaces);
 
   TrackingVolume* m_trkVolume;
   const std::string m_name;
   Layer* m_layerRepresentation;
   const std::vector<Layer*>* m_multilayerRepresentation;
   Amg::Transform3D* m_baseTransform; // optional use (for alignment purpose)
   const std::vector<std::pair<std::unique_ptr<const Trk::Volume>, float>>*
     m_constituents;
};
 
inline const TrackingVolume* DetachedTrackingVolume::trackingVolume() const {
  return (m_trkVolume);
}
 
inline TrackingVolume* DetachedTrackingVolume::trackingVolume(){
  return (m_trkVolume);
}
 
 
inline std::string DetachedTrackingVolume::name() const { return (m_name); }
 
inline const Layer* DetachedTrackingVolume::layerRepresentation() const {
  return (m_layerRepresentation);
}
 
inline Layer* DetachedTrackingVolume::layerRepresentation() {
  return (m_layerRepresentation);
}
 
inline ArraySpan<Layer const* const>
DetachedTrackingVolume::multilayerRepresentation() const
{
  if (m_multilayerRepresentation) {
    return ArraySpan<Layer const* const>(&*m_multilayerRepresentation->begin(),
                                         &*m_multilayerRepresentation->end());
  }
  return {};
}
 
inline ArraySpan<Layer* const>
DetachedTrackingVolume::multilayerRepresentation()
{
  if (m_multilayerRepresentation) {
    return ArraySpan<Layer* const>(&*m_multilayerRepresentation->begin(),
                                   &*m_multilayerRepresentation->end());
  }
  return {};
}
 
inline void DetachedTrackingVolume::saveConstituents(
    const std::vector<std::pair<std::unique_ptr<const Trk::Volume>, float>>*
        constituents) {
  m_constituents = constituents;
}
 
inline const std::vector<std::pair<std::unique_ptr<const Trk::Volume>, float>>*
DetachedTrackingVolume::constituents() const {
  return m_constituents;
}
 
 
}  // namespace Trk
 
#endif  // TRKGEOMETRY_DETACHEDTRACKINGVOLUME_H