AuxiliaryMeasurementHandler.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#ifndef ActsEvent_AuxiliaryMeasurementHandler_H
#define ActsEvent_AuxiliaryMeasurementHandler_H
 
#include "xAODAuxiliaryMeasurement/AuxiliaryMeasurementContainer.h"
#include "AthenaBaseComps/AthMessaging.h"
#include "StoreGate/WriteHandleKey.h"
#include "StoreGate/WriteHandle.h"
#include "ActsGeometryInterfaces/GeometryContext.h"
#include "Acts/Utilities/Result.hpp"
 
#include <unordered_map>
 
namespace ActsTrk{
    class AuxiliaryMeasurementHandler {
        public:
            using SurfacePtr_t = xAOD::AuxiliaryMeasurement::SurfacePtr_t; 
            template <class PropOwner> 
                AuxiliaryMeasurementHandler(PropOwner* owner);
            StatusCode initialize(const std::string& preFix,
                                  bool used = true);

            class MeasurementProvider {
                public:
                    friend class AuxiliaryMeasurementHandler;
                    ~MeasurementProvider() = default;
                    MeasurementProvider(MeasurementProvider&& other) = default;
                    MeasurementProvider& operator=(MeasurementProvider&& other) = delete;
                    MeasurementProvider(const MeasurementProvider& other) = delete;
                    MeasurementProvider& operator=(const MeasurementProvider& other) = delete;
 
                    using ProjectorType = xAOD::AuxiliaryMeasurement::ProjectorType;
                    template<size_t N>
                        xAOD::AuxiliaryMeasurement* newMeasurement(const SurfacePtr_t&  surface,
                                                                   const ProjectorType projector,
                                                                   const AmgSymMatrix(N)& locCov,
                                                                   const AmgVector(N) locPos = AmgVector(N)::Zero());
                
                private:
                    MeasurementProvider(const EventContext& ctx,
                                        const Acts::GeometryContext& gctx,
                                        const AuxiliaryMeasurementHandler* parent);
                    StatusCode setupContainers();
                    template<typename AuxCont_t, typename Cont_t>
                        StatusCode recordContainer(SG::WriteHandle<Cont_t>& handle);
 
 
                    const EventContext& m_ctx;
                    const Acts::GeometryContext m_gctx;
                    const AuxiliaryMeasurementHandler* m_parent{};
                    using WriteHandle_t = SG::WriteHandle<xAOD::AuxiliaryMeasurementContainer>;
                    using SurfaceHandle_t = SG::WriteHandle<xAOD::TrackSurfaceContainer>;
                    
                    WriteHandle_t m_viewHandle{m_parent->m_viewKey, m_ctx};
                    WriteHandle_t m_handle1D{m_parent->m_writeKey1D, m_ctx};
                    WriteHandle_t m_handle2D{m_parent->m_writeKey2D, m_ctx};
                    WriteHandle_t m_handle3D{m_parent->m_writeKey3D, m_ctx};
                    SurfaceHandle_t m_surfaceContainer{m_parent->m_surfaceKey, m_ctx};
                    std::unordered_map<SurfacePtr_t, const xAOD::TrackSurface*> m_cachedSurfs{};
 
            };
 
            enum class HandleStatus: std::uint8_t{
                ok = 0,
                emptyKey = 1,
                recordFail = 2,
            };
            using HandleReturn_t = Acts::Result<MeasurementProvider, HandleStatus>;
           
            HandleReturn_t makeHandle(const EventContext& ctx,
                                      const Acts::GeometryContext& gctx) const;
 
        private:
            using Key_t = SG::WriteHandleKey<xAOD::AuxiliaryMeasurementContainer>;
            std::function<MsgStream&(const MSG::Level)> m_msgPrinter{};
            std::function<bool(const MSG::Level)> m_msgLevel{};
            Key_t m_viewKey;
            Key_t m_writeKey1D;
            Key_t m_writeKey2D;
            Key_t m_writeKey3D;
            SG::WriteHandleKey<xAOD::TrackSurfaceContainer> m_surfaceKey;
            MsgStream& msg(const MSG::Level lvl) const;
            bool msgLvl(const MSG::Level lvl) const;
    };
}
#include "ActsEvent/AuxiliaryMeasurementHandler.icc"
#endif