AuxiliaryMeasurementHandler.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 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/ActsGeometryContext.h"
 
#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);
            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 AuxiliaryMeasurementHandler* parent,
                                      xAOD::TrackSurfaceContainer& surfaceBackend);
                    StatusCode setupContainers();
 
                    const EventContext& m_ctx;
                    const AuxiliaryMeasurementHandler* m_parent{};
                    xAOD::TrackSurfaceContainer& m_surfaceContainer;
                    using WriteHandle_t = SG::WriteHandle<xAOD::AuxiliaryMeasurementContainer>;
                    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};
                    std::unordered_map<SurfacePtr_t, const xAOD::TrackSurface*> m_cachedSurfs{};
 
            };
        MeasurementProvider makeHandle(const EventContext& ctx,
                                       xAOD::TrackSurfaceContainer& surfaceBackend) const;
 
        private:
            using Key_t = SG::WriteHandleKey<xAOD::AuxiliaryMeasurementContainer>;
            MsgStream& m_msg;
            Key_t m_writeKey1D;
            Key_t m_writeKey2D;
            Key_t m_writeKey3D;
            ActsGeometryContext m_gctx{};
    };
}
#include "ActsEvent/AuxiliaryMeasurementHandler.icc"
#endif