AuxiliaryMeasurementHandler.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ActsEvent_AuxiliaryMeasurementHandler_ICC
#define ActsEvent_AuxiliaryMeasurementHandler_ICC
 
#include "ActsGeoUtils/SurfaceEncoding.h"
namespace ActsTrk{
    template <class PropOwner> 
        AuxiliaryMeasurementHandler::AuxiliaryMeasurementHandler(PropOwner* owner):
            m_msgPrinter{[owner](const MSG::Level msg) -> MsgStream& {
                    return owner->msg(msg);
            }},
            m_msgLevel{[owner](const MSG::Level msg) { 
                return owner->msgLvl(msg);
            }},
            m_writeKey1D{owner, "AuxiliaryMeasKey1D", ""},
            m_writeKey2D{owner, "AuxiliaryMeasKey2D", ""},
            m_writeKey3D{owner, "AuxiliaryMeasKey3D", ""},
            m_surfaceKey{owner, "AuxiliarySurfaceKey", ""}{}
    
   
    template<size_t N> xAOD::AuxiliaryMeasurement* 
        AuxiliaryMeasurementHandler::MeasurementProvider::newMeasurement(const SurfacePtr_t& surface,
                                                                         const ProjectorType projector,
                                                                         const AmgSymMatrix(N)& locCov,
                                                                         const AmgVector(N) locPos) {
        xAOD::AuxiliaryMeasurement* meas{nullptr};
        static_assert(N>=1 && N<=3, "Invalid measurement dimension");
        if constexpr(N == 1) {
            meas = m_handle1D->push_back(std::make_unique<xAOD::AuxiliaryMeasurement>());
            assert(projector == ProjectorType::e1DimNoTime || 
                   projector == ProjectorType::e1DimRotNoTime);
        } else if constexpr(N == 2) {
            meas = m_handle2D->push_back(std::make_unique<xAOD::AuxiliaryMeasurement>());
            assert(projector == ProjectorType::e2DimNoTime || 
                   projector == ProjectorType::e1DimWithTime ||
                   projector == ProjectorType::e1DimRotWithTime);
        } else if constexpr(N == 3) { 
            meas = m_handle3D->push_back(std::make_unique<xAOD::AuxiliaryMeasurement>());
            assert(projector == ProjectorType::e2DimWithTime);
        }
        meas->setMeasurement<N>(0, xAOD::toStorage(locPos), xAOD::toStorage(locCov));
        meas->setProjector(projector);
        auto cached_itr = m_cachedSurfs.find(surface);
        if (cached_itr == m_cachedSurfs.end()) {
            auto persistSurf = m_surfaceContainer->push_back(std::make_unique<xAOD::TrackSurface>());
            encodeSurface(persistSurf, surface.get(), m_gctx);
 
            cached_itr = m_cachedSurfs.insert(std::make_pair(surface, persistSurf)).first;
        }
        xAOD::AuxiliaryMeasurement::SurfLink_t link{*m_surfaceContainer, cached_itr->second->index(), m_ctx};
        meas->setSurface(surface, std::move(link));
        return meas;
    }
}
 
#endif