DetachedTrackingVolume.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 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"
// Amg
#include "GeoPrimitives/GeoPrimitives.h"
#include <span>
namespace Trk {
class TrackingVolume;
class Surface;
class MaterialProperties;
class MagneticFieldProperties;

 
class DetachedTrackingVolume final{
  friend class TrackingVolume;
  friend class DetachedTrackingVolumeBuilder;
  friend class IDetachedTrackingVolumeBuilder;
 
 public:
  DetachedTrackingVolume();

  DetachedTrackingVolume(std::string name, std::unique_ptr<TrackingVolume> vol);

  DetachedTrackingVolume(std::string name,
                         std::unique_ptr<TrackingVolume> vol,
                         std::unique_ptr<Layer> layer,
                         std::unique_ptr<const std::vector<Layer*>> multilayer = nullptr);

  ~DetachedTrackingVolume();

  const TrackingVolume* trackingVolume() const;
  TrackingVolume* trackingVolume();

  const 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();

  std::span<Layer const * const>  multilayerRepresentation() const;
  std::span<Layer * const>  multilayerRepresentation();

  void sign(GeometrySignature signat, GeometryType geotype);

  GeometrySignature geometrySignature() const;

  GeometryType geometryType() const;

  void setBaseTransform(std::unique_ptr<Amg::Transform3D> transf = nullptr);
 
 private:
   void compactify(size_t& cSurfaces, size_t& tSurfaces);
   std::unique_ptr<TrackingVolume> m_trkVolume = nullptr;
   std::unique_ptr<Layer> m_layerRepresentation = nullptr;
   //We own also the elements in the vector
   std::unique_ptr<const std::vector<Layer*>> m_multilayerRepresentation = nullptr;
   const std::string m_name{"undefined"};
   // optional use (for alignment purpose)
   std::unique_ptr<Amg::Transform3D> m_baseTransform = nullptr;
};
 
inline const TrackingVolume* DetachedTrackingVolume::trackingVolume() const {
  return m_trkVolume.get();
}
 
inline TrackingVolume* DetachedTrackingVolume::trackingVolume(){
  return m_trkVolume.get();
}
 
inline const std::string& DetachedTrackingVolume::name() const { return (m_name); }
 
inline const Layer* DetachedTrackingVolume::layerRepresentation() const {
  return m_layerRepresentation.get();
}
 
inline Layer* DetachedTrackingVolume::layerRepresentation() {
  return m_layerRepresentation.get();
}
 
 
inline std::span<Layer const* const>
DetachedTrackingVolume::multilayerRepresentation() const
{
  if (m_multilayerRepresentation) {
    return std::span<Layer const* const>(m_multilayerRepresentation->begin(),
                                         m_multilayerRepresentation->end());
  }
  return {};
}
 
inline std::span<Layer* const>
DetachedTrackingVolume::multilayerRepresentation()
{
  if (m_multilayerRepresentation) {
    return std::span<Layer* const>(m_multilayerRepresentation->begin(),
                                   m_multilayerRepresentation->end());
  }
  return {};
}
 
}  // namespace Trk
 
#endif  // TRKGEOMETRY_DETACHEDTRACKINGVOLUME_H