VolumePlacement.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#ifndef ActsGeoUtils_VolumePlacement_H
#define ActsGeoUtils_VolumePlacement_H
#ifndef SIMULATIONBASE
 
#include "ActsGeoUtils/TransformCache.h"
#include "ActsGeometryInterfaces/IDetectorElement.h"
#include "ActsGeometryInterfaces/IVolumePlacement.h"
 
#include "GeoModelKernel/GeoAlignableTransform.h"
#include "GeoModelKernel/GeoIntrusivePtr.h"
 
#include <optional>
#include <variant>
 
namespace ActsTrk{
    class VolumePlacement: public IVolumePlacement {
        public:
            using AlignableNode_t = GeoIntrusivePtr<GeoAlignableTransform>;
            using Parent_t = std::variant<AlignableNode_t, 
                                          const IDetectorElement*,
                                          const VolumePlacement*>;
            explicit VolumePlacement(const DetectorType detType,
                                     const AlignableNode_t parentNode,
                                     const std::optional<Amg::Transform3D> & addShift = std::nullopt);
            explicit VolumePlacement(const IDetectorElement& parentElement,
                                     const std::optional<Amg::Transform3D> & addShift = std::nullopt);
            explicit VolumePlacement(const VolumePlacement& parentPlacement,
                                     const std::optional<Amg::Transform3D> & addShift = std::nullopt);
            void addChild(std::unique_ptr<VolumePlacement>&& child);
            void connectCenterSurface(std::shared_ptr<Acts::RegularSurface> surface);
            DetectorType detectorType() const override final;
            unsigned storeAlignedTransforms(DetectorAlignStore& store) const override final;
            void makePortalsAlignable(const Acts::GeometryContext& gctx,
                                      const std::vector<std::shared_ptr<Acts::RegularSurface>>& portalsToAlign) override final;
            const Acts::Transform3& localToGlobalTransform(const Acts::GeometryContext& gctx) const override final; 
            const Amg::Transform3D& localToGlobalTransform(const GeometryContext& gctx) const;
             const Acts::Transform3& globalToLocalTransform(const Acts::GeometryContext& gctx) const override final;
            const Amg::Transform3D& globalToLocalTransform(const GeometryContext& gctx) const;
            const Acts::Transform3& portalLocalToGlobal(const Acts::GeometryContext& gctx, 
                                                        const std::size_t portalIdx) const override final;
        private:
            Amg::Transform3D localToGlobalTransform(const DetectorAlignStore* store) const;
            class VolumeGeoPositioning: public AlignableGeoPositioning {
                public:
                    enum class CacheFlags: std::uint8_t {
                        volumeLocToGlob, // Local -> global transform of the volume
                        volumeGlobToLoc, // Global -> local transform of the volume
                        portalLocToGlob  // Local -> global transform of the associated portal
                    };

                    explicit VolumeGeoPositioning(const CacheFlags flags,
                                                  const DetectorType type,
                                                  const VolumePlacement* parent);
                    explicit VolumeGeoPositioning(const VolumePlacement* parent,
                                                  const std::size_t portalIdx);
                    virtual Amg::Transform3D fetchTransform(const DetectorAlignStore* store) const override;
                private:
                    const VolumePlacement* m_parent{nullptr};
                    CacheFlags m_flags{CacheFlags::portalLocToGlob};
            };

            Parent_t m_parent{};
            GeoIntrusivePtr<GeoTransform> m_refShift{}; 
            std::unique_ptr<VolumeGeoPositioning> m_locToGlobCache{};
            std::unique_ptr<VolumeGeoPositioning> m_globToLocCache{};
            std::vector<std::unique_ptr<VolumeGeoPositioning>> m_portalCaches{};
            std::vector<std::shared_ptr<VolumePlacement>> m_children{};
            std::shared_ptr<Acts::detail::PortalPlacement> m_surfacePlacement{};
    };
}
 
#endif
#endif