TruthMeasMarkerAlg.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
#include "TruthMeasMarkerAlg.h"
 
#include "StoreGate/ReadDecorHandle.h"
#include "StoreGate/ReadHandle.h"
#include "StoreGate/WriteDecorHandle.h"
#include "DerivationFrameworkMuons/Utils.h"
#include "MuonTruthHelpers/MuonSimHitHelpers.h"
#include "xAODMuonPrepData/UtilFunctions.h"
 
namespace MuonR4 {
    using PrdCont_t = xAOD::UncalibratedMeasurementContainer;
    using SegLink_t = ElementLink<xAOD::MuonSegmentContainer>;
    using SegLinkVec_t = std::vector<SegLink_t>;
 
    using MarkerHandle_t = SG::WriteDecorHandle<PrdCont_t, bool>;
    using LinkHandle_t = SG::WriteDecorHandle<PrdCont_t, SegLinkVec_t>;
    
    using WriteDecorKey_t = SG::WriteDecorHandleKey<xAOD::UncalibratedMeasurementContainer>;
    using namespace DerivationFramework;
 
    StatusCode TruthMeasMarkerAlg::initialize() {
        ATH_CHECK(m_segKey.initialize());
        if (m_measKeys.empty()) {
            ATH_MSG_FATAL("Please configure the measurement containers to decorate.");
            return StatusCode::FAILURE;
        }
        ATH_CHECK(m_measKeys.initialize());
        for (const auto& key : m_measKeys) {
            m_writeMarkKeys.emplace_back(key, m_writeMarker);
            m_writeSegLinkKeys.emplace_back(key, m_segLink);
        }
        ATH_CHECK(m_writeMarkKeys.initialize());
        ATH_CHECK(m_writeSegLinkKeys.initialize());
        return StatusCode::SUCCESS; 
    }
    StatusCode TruthMeasMarkerAlg::execute(const EventContext& ctx) const {
        const xAOD::MuonSegmentContainer* segContainer{nullptr};
        ATH_CHECK(SG::get(segContainer, m_segKey, ctx));
 
        std::unordered_map<const SG::AuxVectorData*, MarkerHandle_t> markers{};
        std::unordered_map<Muon::MuonStationIndex::TechnologyIndex, std::vector<const PrdCont_t*>> techConts{};
        for (const WriteDecorKey_t& key : m_writeMarkKeys) {
            const xAOD::UncalibratedMeasurementContainer* measContainer{nullptr};
            ATH_CHECK(SG::get(measContainer, key.contHandleKey(), ctx));
            if (measContainer->empty()) {
                continue;
            }
            MarkerHandle_t decor{makeHandle(ctx, key, false)};
            markers.insert(std::make_pair(measContainer, std::move(decor)));
            const Muon::MuonStationIndex::TechnologyIndex techIdx = 
                 m_idHelperSvc->technologyIndex(xAOD::identify(measContainer->at(0)));
            techConts[techIdx].push_back(measContainer);
        }
        std::unordered_map<const SG::AuxVectorData*, LinkHandle_t> links{};
        for (const WriteDecorKey_t& key : m_writeSegLinkKeys) {
            const xAOD::UncalibratedMeasurementContainer* measContainer{nullptr};
            ATH_CHECK(SG::get(measContainer, key.contHandleKey(), ctx));
            if (measContainer->empty()) {
                continue;
            }
            LinkHandle_t decor{makeHandle(ctx, key,SegLinkVec_t{})};
            links.insert(std::make_pair(measContainer, std::move(decor)));
        }
        
        auto fetchPrd = [&techConts,this](const xAOD::MuonSimHit* hit) -> const xAOD::UncalibratedMeasurement*{
            for (const PrdCont_t* prdCont : techConts[m_idHelperSvc->technologyIndex(hit->identify())]){
                for (const xAOD::UncalibratedMeasurement* prd : *prdCont) {
                    if (getTruthMatchedHit(*prd) == hit){
                        ATH_MSG_VERBOSE("Found hit matched to "<<m_idHelperSvc->toString(hit->identify()));
                        return prd;
                    }
                }
            }
            ATH_MSG_VERBOSE("Nothing could be matched to "<<m_idHelperSvc->toString(hit->identify()));
            return nullptr;
        };
        
        for (const xAOD::MuonSegment* segment : *segContainer) {
            const auto truthHits{getMatchingSimHits(*segment)};
            
            SegLink_t segLink{segContainer, segment->index()};
            for (const xAOD::MuonSimHit* simHit : truthHits) {
                const xAOD::UncalibratedMeasurement* prd = fetchPrd(simHit);
                if (!prd) {
                    continue;
                }
                markers.at(prd->container())(*prd) = true;
                links.at(prd->container())(*prd).push_back(segLink);
            }
        }
        return StatusCode::SUCCESS;
    }
 
}