Layer.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
// Layer.h, (c) ATLAS Detector software
 
#ifndef TRKGEOMETRY_LAYER_H
#define TRKGEOMETRY_LAYER_H
 
class MsgStream;
 
// Amg
#include "GeoPrimitives/GeoPrimitives.h"
// Trk
#include "CxxUtils/checker_macros.h"
#include "TrkDetDescrUtils/BinnedArray.h"
#include "TrkDetDescrUtils/Intersection.h"
#include "TrkDetDescrUtils/LayerIndex.h"
#include "TrkGeometry/LayerMaterialProperties.h"
#include "TrkGeometry/OverlapDescriptor.h"
#include "TrkNeutralParameters/NeutralParameters.h"
#include "TrkParameters/TrackParameters.h"
//
#include <memory>
 
namespace Trk {
 
class Surface;
class MaterialProperties;
class BinUtility;
class Volume;
class VolumeBounds;
class TrackingVolume;
class DetachedTrackingVolume;
class ICompatibilityEstimator;
 
typedef ObjectIntersection<Surface> SurfaceIntersection;
typedef BinnedArray<Surface> SurfaceArray;
 
enum LayerType { passive = 0, active = 1 };
 
class Layer {
 public:
  Layer() = default;
  virtual ~Layer() = default;
 
 
  Layer(const LayerMaterialProperties& laymatprop, double thickness = 0.,
        std::unique_ptr<OverlapDescriptor> od = nullptr,
        int ltype = int(passive));
 
  Layer(std::unique_ptr<SurfaceArray> surfaceArray, double thickness = 0.,
        std::unique_ptr<OverlapDescriptor> = nullptr, int ltype = int(passive));
 
  Layer(std::unique_ptr<SurfaceArray> surfaceArray, const LayerMaterialProperties& laymatprop,
        double thickness = 0., std::unique_ptr<OverlapDescriptor> od = nullptr,
        int ltype = int(passive));
 
  const SurfaceArray* surfaceArray() const;
 
  SurfaceArray* surfaceArray();
 
  const Surface* subSurface(const Amg::Vector3D& gp) const;
 
  const Surface* subSurface(const Amg::Vector2D& lp) const;
 
  const Surface* subSurfaceReference(unsigned int idx = 0) const;
 
  virtual const Surface& surfaceRepresentation() const = 0;
  virtual Surface& surfaceRepresentation()  = 0;
 
 
  double thickness() const;
 
  template <class T>
  bool onLayer(const T& parameters,
               const BoundaryCheck& bcheck = BoundaryCheck(true)) const;
 
  virtual bool isOnLayer(
      const Amg::Vector3D& gp,
      const BoundaryCheck& bcheck = BoundaryCheck(true)) const;
 
  const LayerMaterialProperties* layerMaterialProperties() const;
 
  const MaterialProperties* fullUpdateMaterialProperties(
      const TrackParameters& par) const;
 
  virtual double preUpdateMaterialFactor(const TrackParameters&,
                                         PropDirection) const {
    return 1.;
  }
 
  virtual double postUpdateMaterialFactor(const TrackParameters&,
                                          PropDirection) const {
    return 0.;
  }
 
  const OverlapDescriptor* overlapDescriptor() const;
  const Layer* previousLayer(bool skipNavLayer = false) const;
  void setPreviousLayer(const Layer*);
 
  const Layer* nextLayer(const Amg::Vector3D& gp,
                         const Amg::Vector3D& udir) const;
  const Layer* nextLayer(bool skipNavLayer = false) const;
  void setNextLayer(const Layer*);
 
  const BinUtility* binUtility() const;
  void setBinUtility(const BinUtility*);
 
  virtual const Surface& surfaceOnApproach(
      const Amg::Vector3D& pos, const Amg::Vector3D& dir, PropDirection pdir,
      const BoundaryCheck& bcheck, bool resolveSubSurfaces = 0,
      const ICompatibilityEstimator* ice = nullptr) const;
 
  size_t compatibleSurfaces(std::vector<SurfaceIntersection>& cSurfaces,
                            const TrackParameters& pars, PropDirection pdir,
                            const BoundaryCheck& bcheck,
                            bool materialSurfacesOnly = true,
                            const Surface* startSurface = nullptr,
                            const Surface* endSurface = nullptr,
                            const ICompatibilityEstimator* ice = nullptr) const;
 
  size_t compatibleSurfaces(std::vector<SurfaceIntersection>& cSurfaces,
                            const NeutralParameters& pars, PropDirection pdir,
                            const BoundaryCheck& bcheck,
                            bool materialSurfacesOnly = true,
                            const Surface* startSurface = nullptr,
                            const Surface* endSurface = nullptr,
                            const ICompatibilityEstimator* ice = nullptr) const;
 
  virtual bool hasSubStructure(bool resolveSensitive = false) const;
 
  const TrackingVolume* enclosingTrackingVolume() const;
 
  const DetachedTrackingVolume* enclosingDetachedTrackingVolume() const;
 
  const LayerIndex& layerIndex() const;
 
  int layerType() const;
 
  void setLayerType(int identifier);
 
  void assignMaterialProperties(const LayerMaterialProperties&,
                                double scale = 1.0);
 
  virtual void moveLayer(Amg::Transform3D&) = 0;
 
  void registerRepresentingVolume(const Volume* theVol);
 
  const Volume* representingVolume() const;
 
  void setRef(double);
 
  double getRef() const;
 
  void encloseTrackingVolume(const TrackingVolume& tvol);
  void encloseDetachedTrackingVolume(const DetachedTrackingVolume& tvol);
 
  template <class T>
  size_t getCompatibleSurfaces(
      std::vector<SurfaceIntersection>& cSurfaces, const T& pars,
      PropDirection pdir, const BoundaryCheck& bcheck,
      bool materialSurfacesOnly = true, const Surface* startSurface = nullptr,
      const Surface* endSurface = nullptr,
      const ICompatibilityEstimator* ice = nullptr) const;
 
  void compactify(size_t& cSurfaces, size_t& tSurfaces);
 
  void registerLayerIndex(const LayerIndex& lIdx);
 
  virtual void resizeLayer(const VolumeBounds&, double) = 0;
 
  virtual void resizeAndRepositionLayer(const VolumeBounds& vBounds,
                                        const Amg::Vector3D& vCenter,
                                        double envelope = 1.) = 0;
 
 protected:
  Layer(const Layer& lay);
  Layer& operator=(const Layer& lay);
 
  std::unique_ptr<SurfaceArray> m_surfaceArray{};
  std::unique_ptr<LayerMaterialProperties> m_layerMaterialProperties{};
  double m_layerThickness{};
  std::unique_ptr<OverlapDescriptor> m_overlapDescriptor{};
 
  // These are stored by not owning pointers belong to the  Volume
  const Layer* m_previousLayer = nullptr;
  const Layer* m_nextLayer = nullptr;
  const BinUtility* m_binUtility = nullptr;
  const TrackingVolume* m_enclosingTrackingVolume = nullptr;
  const DetachedTrackingVolume* m_enclosingDetachedTrackingVolume = nullptr;
 
  LayerIndex m_index{-1};  
  int m_layerType{Trk::active}; 
  double m_ref{};  
};
 
}  // namespace Trk
#include "Layer.icc"
#endif  // TRKGEOMETRY_LAYER_H