SurfacePlacement.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONREADOUTGEOMETRY_SurfacePlacement_H
#define MUONREADOUTGEOMETRY_SurfacePlacement_H
#ifndef SIMULATIONBASE
 
#include <GeoPrimitives/GeoPrimitivesHelpers.h>
#include <ActsGeoUtils/TransformCache.h>
#include <ActsGeometryInterfaces/ISurfacePlacement.h>
 
#include "Acts/Surfaces/SurfacePlacementBase.hpp"
#include "Acts/Surfaces/Surface.hpp"
#include "Acts/Surfaces/SurfaceBounds.hpp"
 
namespace Acts{
    class Surface;
}
namespace ActsTrk {

  class SurfacePlacement final: public ISurfacePlacement {
    public:
      template <typename Surface_t,
                typename Bounds_t>
      static std::shared_ptr<SurfacePlacement> makeShared(IReadoutSurfacePositioning& transformCache,
                                                          std::shared_ptr<Bounds_t>&& bounds)
                requires(std::is_base_of_v<Acts::SurfaceBounds, Bounds_t>);
 
      virtual ~SurfacePlacement() = default;

      SurfacePlacement(const SurfacePlacement& other) = delete;
      SurfacePlacement& operator=(const SurfacePlacement& other) = delete;
      SurfacePlacement(SurfacePlacement&& other) = delete;
      SurfacePlacement& operator=(SurfacePlacement&& other) = delete;
      const Acts::Transform3& localToGlobalTransform(const Acts::GeometryContext& tgContext) const override final;

      const Acts::Surface& surface() const override final;

      Acts::Surface& surface() override final;

      std::shared_ptr<Acts::Surface> getSurface() const;

      IdentifierHash hash() const;

      Identifier identify() const override final;

      DetectorType detectorType() const override final;
 
      const IDetectorElement* detectorElement() const override final;
    private:
      explicit SurfacePlacement(IReadoutSurfacePositioning* transformCache);
      const IReadoutSurfacePositioning* m_transformCache{nullptr};
  }; 
 
  template <typename Surface_t, typename Bounds_t>  
    std::shared_ptr<SurfacePlacement> 
        SurfacePlacement::makeShared(IReadoutSurfacePositioning& transformCache,
                                    std::shared_ptr<Bounds_t>&& bounds)
                requires(std::is_base_of_v<Acts::SurfaceBounds, Bounds_t>){
      if (transformCache.m_surface || transformCache.m_placement) {
          return nullptr;
      } 
      transformCache.m_placement.reset(new SurfacePlacement(&transformCache));
      transformCache.m_surface = Acts::Surface::makeShared<Surface_t>(std::move(bounds), *transformCache.m_placement);
      return transformCache.m_placement;
    }
}
 
#endif
#endif