DiscLayer.h

Go to the documentation of this file.

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

// DiscLayer.h, (c) ATLAS Detector software
 
#ifndef TRKGEOMETRY_DISCLAYER_H
#define TRKGEOMETRY_DISCLAYER_H
 
class MsgStream;
 
// Amg
#include "GeoPrimitives/GeoPrimitives.h"
// Trk
#include "TrkGeometry/Layer.h"
#include "TrkSurfaces/DiscSurface.h"
//
#include "TrkEventPrimitives/PropDirection.h"
#include "TrkGeometry/ApproachDescriptor.h"
// STL sorting
#include <algorithm>
#include <memory>
namespace Trk {
 
class DiscBounds;
class VolumeBounds;
class LayerMaterialProperties;
class OverlapDescriptor;

 
class DiscLayer final
  : public DiscSurface
  , public Layer
{
  friend class TrackingVolume;
 
public:
  DiscLayer() = default;

  DiscLayer(const Amg::Transform3D& transform,
            std::shared_ptr<const DiscBounds> dbounds,
            const LayerMaterialProperties& laymatprop,
            double thickness = 0.,
            std::unique_ptr<OverlapDescriptor> od = nullptr,
            int laytyp = int(Trk::active));

  DiscLayer(DiscSurface* disc,
            const LayerMaterialProperties& laymatprop,
            double thickness = 0.,
            std::unique_ptr<OverlapDescriptor> od = nullptr,
            int laytyp = int(Trk::active));

  DiscLayer(const Amg::Transform3D& transform,
            std::shared_ptr<const DiscBounds> dbounds,
            std::unique_ptr<SurfaceArray> surfaceArray,
            double isontolerance = 0.,
            std::unique_ptr<OverlapDescriptor> od = nullptr,
            IApproachDescriptor* ad = nullptr,
            int laytyp = int(Trk::active));

  DiscLayer(const Amg::Transform3D& transform,
            std::shared_ptr<const DiscBounds> dbounds,
            std::unique_ptr<SurfaceArray> surfaceArray,
            const LayerMaterialProperties& laymatprop,
            double thickness = 0.,
            std::unique_ptr<OverlapDescriptor> od = nullptr,
            IApproachDescriptor* ad = nullptr,
            int laytyp = int(Trk::active));

  DiscLayer(const DiscLayer& cla);

  DiscLayer(const DiscLayer& cla, const Amg::Transform3D& tr);

  DiscLayer& operator=(const DiscLayer&);

  virtual ~DiscLayer() = default;

  virtual const DiscSurface& surfaceRepresentation() const override final;
  virtual DiscSurface& surfaceRepresentation() override final;

  virtual const Surface& surfaceOnApproach(
      const Amg::Vector3D& pos, const Amg::Vector3D& mom, PropDirection pdir,
      const BoundaryCheck& bcheck, bool resolveSubSurfaces = 0,
      const ICompatibilityEstimator* ice = nullptr) const override final;

  virtual double preUpdateMaterialFactor(
      const Trk::TrackParameters& par,
      Trk::PropDirection dir) const override final;

  virtual double postUpdateMaterialFactor(
      const Trk::TrackParameters& par,
      Trk::PropDirection dir) const override final;

  virtual void moveLayer(Amg::Transform3D& shift) override final;

  virtual void resizeLayer(const VolumeBounds& vBounds,
                           double envelope) override final;

  virtual void resizeAndRepositionLayer(const VolumeBounds& vBounds,
                                        const Amg::Vector3D& cCenter,
                                        double envelop) override final;
 
 private:
  void buildApproachDescriptor();

  const Surface& approachSurface(const Amg::Vector3D& pos,
                                 const Amg::Vector3D& dir,
                                 const BoundaryCheck& bcheck) const;
 
 protected:
  std::unique_ptr<IApproachDescriptor> m_approachDescriptor;
};

class DiscLayerSorterZ {
 public:
  bool operator()(const DiscLayer* one, const DiscLayer* two) const {
    return (one->center().z() < two->center().z());
  }
};
 
}  // namespace Trk
 
#endif  // TRKGEOMETY_DISCLAYER_H