IxAODSegmentCnvTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONRECTOOLINTERFACESR4_IXAODSEGMENTCNVTOOL_H
#define MUONRECTOOLINTERFACESR4_IXAODSEGMENTCNVTOOL_H
 
#include <GaudiKernel/IAlgTool.h>
#include "StoreGate/WriteDecorHandleKey.h"
 
#include "MuonPatternEvent/MuonHoughDefs.h"
#include "MuonPatternEvent/Segment.h"
 
#include "xAODMuon/MuonSegmentContainer.h"
#include "xAODMuon/MuonSegmentAuxContainer.h"
#include "xAODMuonPrepData/CombinedMuonStripContainer.h"
#include "xAODMuonPrepData/CombinedMuonStripAuxContainer.h"
#include "xAODMuonViews/FillContainer.h"
#include "xAODMuonViews/ContainerDecorator.h"
 
#include "xAODMeasurementBase/UncalibratedMeasurementContainer.h" 
#include "ActsEvent/AuxiliaryMeasurementHandler.h"
 
namespace MuonR4{
 
    class IxAODSegmentCnvTool : virtual public IAlgTool {
        public:
            virtual ~IxAODSegmentCnvTool() = default;
            
            DeclareInterfaceID(IxAODSegmentCnvTool, 1, 0);

            struct DataShip {
                using DecorKey_t = SG::WriteDecorHandleKey<xAOD::MuonSegmentContainer>;
                StatusCode setupLocalParameters(const DecorKey_t& localParKey,
                                                const DecorKey_t& localCovKey,
                                                const EventContext& ctx) {
                    if (localParKey.empty() || localCovKey.empty()) {
                        return StatusCode::FAILURE;
                    }
                    dec_localSegPars.initialize(localParKey, ctx);
                    dec_localSegCov.initialize(localCovKey, ctx);
                    return StatusCode::SUCCESS;              
                }
   
                StatusCode setupMeasurementLink(const SG::WriteHandleKey<xAOD::CombinedMuonStripContainer>& combinedKey,
                                                const DecorKey_t& prdLinkKey,
                                                const DecorKey_t& prdStateKey,
                                                const EventContext& ctx) {
                    if (combinedKey.empty() || prdLinkKey.empty() || prdStateKey.empty()) {
                        return StatusCode::FAILURE;
                    }
                    dec_prdLinks.initialize(prdLinkKey, ctx);
                    dec_prdStates.initialize(prdStateKey, ctx);
                    return prdCombContainer.record(combinedKey, ctx);
                }

                StatusCode setupBeamSpotMeasurement(const ActsTrk::AuxiliaryMeasurementHandler& auxMeasProv,
                                                    const EventContext& ctx,
                                                    const ActsTrk::GeometryContext& gctx) {
                    beamSpotMeasCreator = auxMeasProv.makeHandle(ctx, gctx.context());
                    if (!beamSpotMeasCreator.ok()) {
                        return StatusCode::FAILURE;
                    }
                    return StatusCode::SUCCESS;
                }

                xAOD::FillContainer<xAOD::MuonSegmentContainer,
                                    xAOD::MuonSegmentAuxContainer> segmentContainer{};
                
                using SegPars_t = xAOD::PosAccessor<Acts::toUnderlying(SegmentFit::ParamDefs::nPars)>::element_type;
                using SegCov_t = xAOD::PosAccessor<Acts::sumUpToN(Acts::toUnderlying(SegmentFit::ParamDefs::nPars))>::element_type;
    
                xAOD::ContainerDecorator<xAOD::MuonSegmentContainer, SegPars_t> dec_localSegPars{};
                xAOD::ContainerDecorator<xAOD::MuonSegmentContainer, SegCov_t> dec_localSegCov{};
                
                Acts::Result<ActsTrk::AuxiliaryMeasurementHandler::MeasurementProvider, 
                            ActsTrk::AuxiliaryMeasurementHandler::HandleStatus> beamSpotMeasCreator{ActsTrk::AuxiliaryMeasurementHandler::HandleStatus::emptyKey};
                xAOD::FillContainer<xAOD::CombinedMuonStripContainer,
                                    xAOD::CombinedMuonStripAuxContainer> prdCombContainer{};
                const xAOD::UncalibratedMeasurement* beamSpot{};
 
                using PrdLink_t = ElementLink<xAOD::UncalibratedMeasurementContainer>;
                xAOD::ContainerDecorator<xAOD::MuonSegmentContainer, 
                                        std::vector<PrdLink_t>> dec_prdLinks{};
                xAOD::ContainerDecorator<xAOD::MuonSegmentContainer,
                                         std::vector<char>> dec_prdStates{}; 
            };

            virtual xAOD::MuonSegment* convertSegment(const EventContext& ctx,
                                                      const MuonR4::Segment& inSegment,
                                                      DataShip& ship) const = 0;
    };
}
 
#endif