TgcPrepDataReplicationTool3BCtoAllBC.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
#include "TgcPrepDataReplicationTool3BCtoAllBC.h"
 
#include "EventPrimitives/EventPrimitives.h"
#include "MuonCnvToolInterfaces/IDC_Helper.h"
#include "MuonDigitContainer/TgcDigit.h"
#include "TgcPrepDataReplicationToolAllBCto3BC.h"
 
//================ Constructor =================================================
Muon::TgcPrepDataReplicationTool3BCtoAllBC::
    TgcPrepDataReplicationTool3BCtoAllBC(const std::string& t,
                                         const std::string& n,
                                         const IInterface* p)
    : base_class(t, n, p) {}
 
//================ Initialization ==============================================
StatusCode Muon::TgcPrepDataReplicationTool3BCtoAllBC::initialize() {
    ATH_CHECK(AthAlgTool::initialize());
    ATH_CHECK(m_idHelperSvc.retrieve());
 
    for (int ibc = 0; ibc < BC_ALL; ibc++) {
        std::ostringstream location;
        location << "TGC_Measurements" << (ibc == BC_PREVIOUS ? "PriorBC" : "")
                 << (ibc == BC_NEXT ? "NextBC" : "");
        m_3BCKeys.at(ibc) = location.str();
    }
 
    ATH_CHECK(m_3BCKeys.initialize());
 
    return StatusCode::SUCCESS;
}
 
StatusCode Muon::TgcPrepDataReplicationTool3BCtoAllBC::replicate(
    const EventContext& ctx) const {
    return convert3BCtoAllBC(ctx);
}
 
StatusCode Muon::TgcPrepDataReplicationTool3BCtoAllBC::convert3BCtoAllBC(
    const EventContext& ctx) const {
 
    SG::WriteHandle<TgcPrepDataContainer> tgcPrepDataContainerAll(m_AllBCKey,
                                                                  ctx);
    ATH_CHECK(
        tgcPrepDataContainerAll.record(std::make_unique<TgcPrepDataContainer>(
            m_idHelperSvc->tgcIdHelper().module_hash_max())));
 
    auto tgc3BCs = m_3BCKeys.makeHandles(ctx);
 
    // convert
    int ibc{0};
    for (SG::ReadHandle<TgcPrepDataContainer>& handle :
         m_3BCKeys.makeHandles(ctx)) {
        uint16_t bcBitMap = 0;
        if (ibc == BC_PREVIOUS) {
            bcBitMap = TgcPrepData::BCBIT_PREVIOUS;
        } else if (ibc == BC_CURRENT) {
            bcBitMap = TgcPrepData::BCBIT_CURRENT;
        } else if (ibc == BC_NEXT) {
            bcBitMap = TgcPrepData::BCBIT_NEXT;
        }
        ++ibc;
 
        if (!handle.isValid()) {
            ATH_MSG_FATAL("Cannot retrieve " << handle.key());
            return StatusCode::FAILURE;
        }
        for (const Muon::TgcPrepDataCollection* coll : *handle) {
 
            for (const Muon::TgcPrepData* to_copy : *coll) {
                const Identifier channelId = to_copy->identify();
                const Identifier elementId =
                    m_idHelperSvc->tgcIdHelper().elementID(channelId);
 
                Muon::TgcPrepDataCollection* collection =
                    Muon::IDC_Helper::getCollection<TgcPrepDataContainer,
                                                    TgcIdHelper>(
                        elementId, tgcPrepDataContainerAll.ptr(),
                        m_idHelperSvc->tgcIdHelper(), msg());
 
                Muon::TgcPrepDataCollection::iterator duplicateInAllBCs =
                    std::find_if(collection->begin(), collection->end(),
                                 [&channelId](const TgcPrepData* duplicate) {
                                     return channelId == duplicate->identify();
                                 });
                if (duplicateInAllBCs != collection->end()) {
                    TgcPrepData* prd = *duplicateInAllBCs;
                    prd->setBcBitMap(prd->getBcBitMap() | bcBitMap);
                } else {
                    Muon::TgcPrepData* newPrepData =
                        TgcPrepDataReplicationToolAllBCto3BC::makeTgcPrepData(
                            to_copy, bcBitMap);
                    newPrepData->setHashAndIndex(collection->identifyHash(),
                                                 collection->size());
                    collection->push_back(newPrepData);
                }
            }
        }
    }
 
    return StatusCode::SUCCESS;
}