TransformStore.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#ifndef ACTSGEOMETRYINTERFACES_TrackingAlignStore_H
#define ACTSGEOMETRYINTERFACES_TrackingAlignStore_H

#include "ActsGeometryInterfaces/GeometryDefs.h"
 
#include "CxxUtils/CachedUniquePtr.h"
#include "CxxUtils/checker_macros.h"
 
#include <array>
#include <variant>
#include <cassert>
#include <iostream>
 
namespace ActsTrk::detail{
    class TransformStore {
        public:
            enum class Mode: std::uint8_t {
                LazyFill,   
                Block       
            };

            static std::string toString(const Mode m);
            inline friend std::ostream& operator<<(std::ostream&ostr, const Mode m){
                return ostr<<toString(m);
            }

            inline friend std::ostream& operator<<(std::ostream&ostr, const TransformStore& store){
                return store.print(ostr);
            }

            TransformStore(const DetectorType detType, const Mode m);
            TransformStore(TransformStore&& other) noexcept = default;
            TransformStore& operator=(TransformStore&& other) noexcept = default;
            TransformStore(const TransformStore& other) noexcept;
            TransformStore& operator=(const TransformStore& other) noexcept;
            const Amg::Transform3D* getTransform(const unsigned ticketNo) const;
            const Amg::Transform3D& setTransform(const unsigned int ticketNo, Amg::Transform3D && trf) const;
            const Amg::Transform3D& setTransform(const unsigned int ticketNo, Amg::Transform3D && trf);
            Mode mode() const;
            DetectorType detectorType() const;
            std::size_t size() const;
            std::size_t filled() const;
        private:
            using LazyStorage_t = std::vector<CxxUtils::CachedUniquePtr<Amg::Transform3D>>;
            using TrfVec_t = std::vector<Amg::Transform3D>;
            using CheckVec_t = std::vector<char>;
            using BlockStorage_t = std::pair<TrfVec_t, CheckVec_t>;
            using Storage_t = std::variant<LazyStorage_t, BlockStorage_t>;
            Storage_t m_storage{};
            DetectorType m_detType{ActsTrk::DetectorType::UnDefined};
            static Storage_t initStorage(const DetectorType dType,
                                         const Mode mode) noexcept;
            
            std::ostream& print(std::ostream& ostr) const;
 
    };

    class TrfStoreTicketCounter {
        public:
            static unsigned int drawTicket(const DetectorType detType);
            static unsigned int distributedTickets(const DetectorType detType);
            static void giveBackTicket(const DetectorType detType, unsigned int ticketNo);
 
 
            static constexpr unsigned s_techs{static_cast<unsigned>(DetectorType::UnDefined)};
            using TicketCounterArr =  std::array<std::atomic<unsigned>, s_techs>;
            using ReturnedTicketArr = std::array<std::vector<char>, s_techs>;
            using ReturnedHintArr = std::array<int, s_techs>;
 
        private:
            static TicketCounterArr s_clientCounter ATLAS_THREAD_SAFE;
            static ReturnedTicketArr s_returnedTickets ATLAS_THREAD_SAFE;
            static ReturnedHintArr s_returnedHints ATLAS_THREAD_SAFE;
    };
 
 
    inline const Amg::Transform3D* TransformStore::getTransform(const unsigned ticketNo) const {
        return std::visit([&](auto& store) -> const Amg::Transform3D* {
            using Store_t = std::decay_t<decltype(store)>;
            if constexpr(std::is_same_v<Store_t, LazyStorage_t>) {
                assert(ticketNo < store.size());
                return store[ticketNo].get();
            } else if constexpr(std::is_same_v<Store_t, BlockStorage_t>) {
                assert(ticketNo < store.first.size());
                return store.second[ticketNo] ? &store.first[ticketNo] : nullptr;
            } else {
                return nullptr;
            }
        }, m_storage);
    }
}
 
#ifndef SIMULATIONBASE 
ACTS_OSTREAM_FORMATTER(ActsTrk::detail::TransformStore::Mode);
#endif
#endif