MuonDigitizationTool.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONDIGITIZATION_MUONDIGITIZATIONTOOL_ICC
#define MUONDIGITIZATION_MUONDIGITIZATIONTOOL_ICC
 
#include <StoreGate/ReadHandle.h>
#include <StoreGate/WriteHandle.h>
#include <StoreGate/ReadCondHandle.h>
 
namespace MuonR4{
    template <class DigitColl> 
        DigitColl* MuonDigitizationTool::fetchCollection(const Identifier& hitId,
                                                         OutDigitCache_t<DigitColl>& digitCache) const {
        const IdentifierHash hash{m_idHelperSvc->moduleHash(hitId)};
        
        if (static_cast<unsigned>(hash) >= digitCache.size()) {
            digitCache.resize(static_cast<unsigned>(hash) + 1);
        }
        std::unique_ptr<DigitColl>& coll = digitCache[static_cast<unsigned>(hash)];
        if (!coll) {
            coll = std::make_unique<DigitColl>(m_idHelperSvc->chamberId(hitId), hash);
        }
        return coll.get();
    }
    template <class DigitCont, class DigitColl> 
        StatusCode MuonDigitizationTool:: writeDigitContainer(const EventContext& ctx,
                                                              const SG::WriteHandleKey<DigitCont>& key,
                                                              OutDigitCache_t<DigitColl>&& digitCache,
                                                              unsigned int hashMax) const {
        SG::WriteHandle<DigitCont> writeHandle{key, ctx};
        ATH_CHECK(writeHandle.record(std::make_unique<DigitCont>(hashMax)));
        for (size_t coll_hash = 0; coll_hash < digitCache.size(); ++coll_hash) {
            if (digitCache[coll_hash] && digitCache[coll_hash]->size()) {
                ATH_CHECK(writeHandle->addCollection(digitCache[coll_hash].release(), coll_hash));
            }
        }
        return StatusCode::SUCCESS;
    }
}
#endif