TransformCache.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#ifndef ActsGeoUtils_TransformCache_H
#define ActsGeoUtils_TransformCache_H
 
#include <GeoPrimitives/GeoPrimitivesHelpers.h>
#include <ActsGeometryInterfaces/IDetectorElement.h>
#include <Identifier/IdentifierHash.h>
#include <CxxUtils/CachedUniquePtr.h>
 
// Forward declaration
namespace Acts {
    class Surface;
}
namespace ActsTrk{
  class SurfacePlacement;  
}
 
 
namespace ActsTrk {
  /*** @brief The AlignableGeoPositioning manages the alignable transform handling of a surface from the 
   *          readout geometry, of a volume portal surface or of a volume. If the transform belongs to
   *          a surface, it always represents the transform from the local surface frame to the global
   *          ATLAS frame. In the case of volumes, both directions are possible.
   *
   *          The cache usually interacts with the @ref DetectorAlignStore to forward the aligned 
   *          transform to the requesting client. In case that there is no @DetectorAlignStore passed
   *          the class also holds an internal cache for a transform which is lazily populated with the
   *          nominal transform if needed, but also immediatley deleted as soon as a new DetectorAlignStore
   *          instance is shown to the class. If the refernce to the cached transform is queried via
   *
   *               const Amg::Transform3D& getTransform(const DetectorAlignStore* store) const;
   * 
   *          it is checked whether the (internal) store already hold the transform. If not, the asembly
   *          of the transform is queried via calling
   *
   *                     Amg::Transform3D fetchTransform(const DetectorAlignStore* store) const
   *
   *          which  is a pure interface function and needs to be implemented downstream */
  class AlignableGeoPositioning {
      public:
          explicit AlignableGeoPositioning(const IdentifierHash& cacheHash,
                                           const DetectorType type);
          AlignableGeoPositioning(const AlignableGeoPositioning& other) noexcept = delete;
          AlignableGeoPositioning& operator=(const AlignableGeoPositioning& other) noexcept = delete;
          AlignableGeoPositioning(AlignableGeoPositioning&& other) noexcept = delete;
          AlignableGeoPositioning& operator=(AlignableGeoPositioning& other) noexcept = delete;
          virtual ~AlignableGeoPositioning();
          IdentifierHash hash() const;
          const Amg::Transform3D& getTransform(const DetectorAlignStore* store) const;
          const Amg::Transform3D& getTransform(const GeometryContext& gctx) const;
          bool storeTransform(DetectorAlignStore& store) const;
#ifndef SIMULATIONBASE
          const Amg::Transform3D& getTransform(const Acts::GeometryContext& tgContext) const;
#endif
          virtual void releaseNominalCache() const;
          DetectorType detectorType() const;
      protected:
          virtual Amg::Transform3D fetchTransform(const DetectorAlignStore* store) const = 0;
      private:
          const IdentifierHash m_hash{};
          const DetectorType m_type{DetectorType::UnDefined};
          using TicketCounter = detail::TrfStoreTicketCounter;
          const unsigned int m_clientNo{TicketCounter::drawTicket(m_type)};
          mutable CxxUtils::CachedUniquePtrT<Amg::Transform3D> m_nomCache ATLAS_THREAD_SAFE{};
  };
 

  class IReadoutSurfacePositioning : public AlignableGeoPositioning {
    public:
      using AlignableGeoPositioning::AlignableGeoPositioning;
      virtual ~IReadoutSurfacePositioning();
      virtual Identifier identify() const = 0;
      virtual const IDetectorElement* parent() const = 0;
      virtual void releaseNominalCache() const final;
 
  #ifndef SIMULATIONBASE
      friend class SurfacePlacement;
      const SurfacePlacement* placement() const;
    private:
      std::shared_ptr<Acts::Surface> m_surface{};
      std::shared_ptr<SurfacePlacement> m_placement{};
  #endif
 
  };

  template<typename CachingDetectorEle> 
  class ReadoutSurfacePositioning: public IReadoutSurfacePositioning {
    public:
      explicit ReadoutSurfacePositioning(const IdentifierHash& hash, 
                                         const CachingDetectorEle* parentEle);
      const CachingDetectorEle* parent() const override final;
      Identifier identify() const override final;
    private:
       Amg::Transform3D fetchTransform(const DetectorAlignStore* store) const override final;
       const CachingDetectorEle* m_parent{nullptr};
  };
 
}
#include <ActsGeoUtils/TransformCache.icc>
#endif