CylinderLayer.h

Go to the documentation of this file.

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

// CylinderLayer.h, (c) ATLAS Detector software
 
#ifndef TRKGEOMETRY_CYLINDERLAYER_H
#define TRKGEOMETRY_CYLINDERLAYER_H
 
class MsgStream;
 
// Amg
#include "GeoPrimitives/GeoPrimitives.h"
// Trk
#include "TrkDetDescrUtils/BinnedArray.h"
#include "TrkEventPrimitives/PropDirection.h"
#include "TrkGeometry/ApproachDescriptor.h"
#include "TrkGeometry/Layer.h"
#include "TrkSurfaces/CylinderSurface.h"
// STL sorting
#include <algorithm>
 
namespace Trk {
 
class CylinderBounds;
class LayerMaterialProperties;
class OverlapDescriptor;

 
class CylinderLayer final
  : public CylinderSurface
  , public Layer
{
public:
  CylinderLayer() {}

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

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

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

  CylinderLayer(const Amg::Transform3D& transform,
                std::shared_ptr<const CylinderBounds> cbounds,
                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));

  CylinderLayer(std::shared_ptr<const CylinderBounds> cbounds,
                const LayerMaterialProperties& laymatprop,
                double thickness = 0.,
                std::unique_ptr<OverlapDescriptor> od = nullptr,
                int laytyp = int(Trk::active));

  CylinderLayer(std::shared_ptr<const CylinderBounds> cbounds,
                std::unique_ptr<SurfaceArray> surfaceArray,
                double thickness = 0.,
                std::unique_ptr<OverlapDescriptor> od = nullptr,
                IApproachDescriptor* ad = nullptr,
                int laytyp = int(Trk::active));

  CylinderLayer(std::shared_ptr<const CylinderBounds> cbounds,
                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));

  CylinderLayer(const CylinderLayer& cla);

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

  CylinderLayer& operator=(const CylinderLayer&);

  virtual ~CylinderLayer() = default;

  virtual const CylinderSurface& surfaceRepresentation() const override final;
  virtual CylinderSurface& surfaceRepresentation() 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 const Surface& surfaceOnApproach(
      const Amg::Vector3D& pos, const Amg::Vector3D& dir, PropDirection pdir,
      const BoundaryCheck& bcheck, bool resolveSubSurfaces = 0,
      const ICompatibilityEstimator* ice = nullptr) 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 envelope) override final;
 
 
 private:
  const Surface& approachSurface(const Amg::Vector3D& pos,
                                 const Amg::Vector3D& dir,
                                 const BoundaryCheck& bcheck) const;

  void buildApproachDescriptor();
 
 protected:
  std::unique_ptr<IApproachDescriptor> m_approachDescriptor;
};

 
class CylinderLayerSorterR {
 public:
  CylinderLayerSorterR() {}
 
  bool operator()(const CylinderLayer* one, const CylinderLayer* two) const {
    return (one->surfaceRepresentation().bounds().r() <
            two->surfaceRepresentation().bounds().r());
  }
};
 
}  // namespace Trk
 
#endif  // TRKGEOMETY_CYLINDERLAYER_H