TgcRdoToPrepDataToolMT.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#include "TgcRdoToPrepDataToolMT.h"
 
#include <FourMomUtils/xAODP4Helpers.h>
 
#include <algorithm>
#include <cfloat>
#include <memory>
 
#include "GaudiKernel/ThreadLocalContext.h"
#include "GeoPrimitives/GeoPrimitivesHelpers.h"
#include "MuonDigitContainer/TgcDigit.h"
#include "MuonReadoutGeometry/TgcReadoutElement.h"
#include "MuonTrigCoinData/TgcCoinData.h"
#include "TrkSurfaces/Surface.h"
#include "xAODMuonPrepData/TgcStripAuxContainer.h"
 
namespace {
using namespace xAOD::P4Helpers;
}
//================ Initialization =================
 
StatusCode Muon::TgcRdoToPrepDataToolMT::initialize() {
    ATH_CHECK(m_idHelperSvc.retrieve());
 
    m_outputprepdataKeys.resize(NBC_HIT + 1);
    for (int ibc = 0; ibc < NBC_HIT + 1; ibc++) {
        int bcTag = ibc + 1;
        std::ostringstream location;
        location << m_outputCollectionLocation.value()
                 << (bcTag == TgcDigit::BC_PREVIOUS ? "PriorBC" : "")
                 << (bcTag == TgcDigit::BC_CURRENT ? "" : "")
                 << (bcTag == TgcDigit::BC_NEXT ? "NextBC" : "")
                 << (bcTag == (NBC_HIT + 1) ? "AllBCs" : "");
        m_outputprepdataKeys.at(ibc) = location.str();
    }
 
    m_outputCoinKeys.resize(NBC_TRIG);
    for (int ibc = 0; ibc < NBC_TRIG; ibc++) {
        int bcTag = ibc + 1;
        std::ostringstream location;
        location << m_outputCoinCollectionLocation.value()
                 << (bcTag == TgcDigit::BC_PREVIOUS ? "PriorBC" : "")
                 << (bcTag == TgcDigit::BC_NEXT ? "NextBC" : "")
                 << (bcTag == TgcDigit::BC_NEXTNEXT ? "NextNextBC" : "");
        m_outputCoinKeys.at(ibc) = location.str();
    }
 
    ATH_CHECK(m_outputCoinKeys.initialize());
    ATH_CHECK(m_outputprepdataKeys.initialize());
    ATH_CHECK(m_muDetMgrKey.initialize());
    ATH_CHECK(m_cablingKey.initialize());
 
    // check if initializing of DataHandle objects success
    ATH_CHECK(m_rdoContainerKey.initialize());
 
 
    // Build names for the keys same as done for output containers
    if (not m_prdContainerCacheKeyStr.empty()) {
        m_prdContainerCacheKeys.resize(NBC_HIT + 1);
        for (int ibc = 0; ibc < NBC_HIT + 1; ibc++) {
            int bcTag = ibc + 1;
            std::ostringstream location;
            location << m_prdContainerCacheKeyStr.value()
                     << (bcTag == TgcDigit::BC_PREVIOUS ? "PriorBC" : "")
                     << (bcTag == TgcDigit::BC_CURRENT ? "" : "")
                     << (bcTag == TgcDigit::BC_NEXT ? "NextBC" : "")
                     << (bcTag == (NBC_HIT + 1) ? "AllBCs" : "");
            m_prdContainerCacheKeys.at(ibc) = location.str();
            ATH_MSG_DEBUG(location.str());
        }
    }
 
    if (not m_coinContainerCacheKeyStr.empty()) {
        m_coinContainerCacheKeys.resize(NBC_TRIG);
        for (int ibc = 0; ibc < NBC_TRIG; ibc++) {
            int bcTag = ibc + 1;
            std::ostringstream location;
            location << m_coinContainerCacheKeyStr.value()
                     << (bcTag == TgcDigit::BC_PREVIOUS ? "PriorBC" : "")
                     << (bcTag == TgcDigit::BC_NEXT ? "NextBC" : "")
                     << (bcTag == TgcDigit::BC_NEXTNEXT ? "NextNextBC" : "");
            m_coinContainerCacheKeys.at(ibc) = location.str();
            ATH_MSG_DEBUG(location.str());
        }
    }
 
    // Only initialise if we passed in the cache name
    ATH_CHECK(m_prdContainerCacheKeys.initialize(
        not m_prdContainerCacheKeyStr.empty()));
    ATH_CHECK(m_coinContainerCacheKeys.initialize(
        not m_coinContainerCacheKeyStr.empty()));
 
    ATH_CHECK(m_xAODKey.initialize(!m_xAODKey.empty()));
    return StatusCode::SUCCESS;
}
 
//================ Finalization ===================
 
StatusCode Muon::TgcRdoToPrepDataToolMT::finalize() {
    ATH_MSG_INFO("finalize(): input RDOs->output PRDs ["
                 << "Hit: " << m_nHitRDOs << "->" << m_nHitPRDs << ", "
                 << "Tracklet: " << m_nTrackletRDOs << "->" << m_nTrackletPRDs
                 << ", " << "TrackletEIFI: " << m_nTrackletEIFIRDOs << "->"
                 << m_nTrackletEIFIPRDs << ", " << "HiPt: " << m_nHiPtRDOs
                 << "->" << m_nHiPtPRDs << ", " << "SL: " << m_nSLRDOs << "->"
                 << m_nSLPRDs << "]");
 
    return AthAlgTool::finalize();
}
 
//================ Decoding =================================================
StatusCode Muon::TgcRdoToPrepDataToolMT::decode(
    const EventContext&, const std::vector<uint32_t>& /*robIds*/) const {
    ATH_MSG_FATAL("ROB based decoding is not supported....");
    return StatusCode::FAILURE;
}
template <class ContType, class CollType>
StatusCode Muon::TgcRdoToPrepDataToolMT::transferData(
    ContType& container, std::vector<std::unique_ptr<CollType>>&& coll) const {
    for (std::unique_ptr<CollType>& toMove : coll) {
        if (!toMove) {
            continue;
        }
        const IdentifierHash hash = toMove->identifyHash();
        auto lock = container.getWriteHandle(hash);
        if (!lock.alreadyPresent()) {
            ATH_CHECK(lock.addOrDelete(std::move(toMove)));
        }
    }
    return StatusCode::SUCCESS;
}
 
StatusCode Muon::TgcRdoToPrepDataToolMT::provideEmptyContainer(
    const EventContext& ctx) const {
    if (!m_xAODKey.empty()) {
        SG::WriteHandle handle{m_xAODKey, ctx};
        ATH_CHECK(
            handle.record(std::make_unique<xAOD::TgcStripContainer>(),
                          std::make_unique<xAOD::TgcStripAuxContainer>()));
    }
    State state{};
    return setupState(ctx, state);
}
 
StatusCode Muon::TgcRdoToPrepDataToolMT::setupState(const EventContext& ctx,
                                                    State& state) const {
    const unsigned hashMax = m_idHelperSvc->tgcIdHelper().module_hash_max();
 
    for (unsigned int ibc = 0; ibc < NBC_HIT + 1; ibc++) {  //  +1 for AllBCs
        // initialize with false
        SG::WriteHandle handle{m_outputprepdataKeys[ibc], ctx};
 
        const bool externalCachePRD =
            m_prdContainerCacheKeys.size() > ibc &&
            !m_prdContainerCacheKeys[ibc].key().empty();
        if (!externalCachePRD) {
            // record the container in storeGate
            ATH_CHECK(
                handle.record(std::make_unique<TgcPrepDataContainer>(hashMax)));
            ATH_MSG_DEBUG(
                "TGC PrepData Container recorded in StoreGate with key "
                << m_outputprepdataKeys[ibc].key());
 
            // cache the pointer, storegate retains ownership
            state.tgcPrepDataContainer[ibc] = handle.ptr();
        } else {
            // use the cache to get the container
            SG::UpdateHandle update{m_prdContainerCacheKeys[ibc], ctx};
            ATH_CHECK(update.isValid());
 
            ATH_CHECK(handle.record(
                std::make_unique<Muon::TgcPrepDataContainer>(update.ptr())));
 
            state.tgcPrepDataContainer[ibc] = handle.ptr();
            ATH_MSG_DEBUG("Created container using cache for "
                          << m_prdContainerCacheKeys[ibc].key());
        }
        state.tgcPrepDataCollections[ibc].resize(hashMax);
    }

    for (unsigned int ibc = 0; ibc < NBC_TRIG; ibc++) {
        // prepare write handle for this BC
        SG::WriteHandle handle{m_outputCoinKeys[ibc], ctx};
 
        const bool externalCacheCoin =
            m_coinContainerCacheKeys.size() > ibc &&
            !m_coinContainerCacheKeys[ibc].key().empty();
        if (!externalCacheCoin) {
            // No cache (offline case), just record container into store gate
            ATH_CHECK(
                handle.record(std::make_unique<TgcCoinDataContainer>(hashMax)));
        } else {
            // Using the cache (trigger case)
            SG::UpdateHandle update{m_coinContainerCacheKeys[ibc], ctx};
            ATH_CHECK(update.isValid());
            ATH_CHECK(handle.record(
                std::make_unique<TgcCoinDataContainer>(update.ptr())));
            ATH_MSG_DEBUG("Created container using cache for "
                          << m_coinContainerCacheKeys[ibc].key());
 
        }  // external cache
 
        // cache the pointer for duration of function, storegate retains
        // ownership
        state.tgcCoinDataContainer[ibc] = handle.ptr();
        state.tgcCoinDataCollections[ibc].resize(hashMax);
 
    }  // loop on BC_TRIG
 
    ATH_CHECK(SG::get(state.muDetMgr, m_muDetMgrKey, ctx));
    ATH_CHECK(SG::get(state.cabling, m_cablingKey, ctx));
    return StatusCode::SUCCESS;
}
StatusCode Muon::TgcRdoToPrepDataToolMT::decode(
    const EventContext& ctx,
    const std::vector<IdentifierHash>& requestedIdHashVect) const {
    // Object to hold the containers for this decode call
    State state{};
    ATH_CHECK(setupState(ctx, state));
 
    SG::WriteHandle<xAOD::TgcStripContainer> xAODHandle{};
    if (!m_xAODKey.empty()) {
        xAODHandle = SG::WriteHandle<xAOD::TgcStripContainer>{m_xAODKey, ctx};
        ATH_CHECK(
            xAODHandle.record(std::make_unique<xAOD::TgcStripContainer>(),
                              std::make_unique<xAOD::TgcStripAuxContainer>()));
    }
 
    int sizeVectorRequested = requestedIdHashVect.size();
    ATH_MSG_DEBUG("decode for " << sizeVectorRequested
                                << " offline collections called");
 
    const TgcIdHelper& idHelper{m_idHelperSvc->tgcIdHelper()};
 
    std::set<const TgcRdo*> decodedRdoCollVec{}, rdoCollVec{};
    std::array<char, 24> decodedOnlineId{};
  
    // if TGC decoding is switched off stop here
    if (!m_decodeData) {
        ATH_MSG_DEBUG(
            "Stored empty container. Decoding TGC RDO into TGC PrepRawData is "
            "switched off");
        return StatusCode::SUCCESS;
    }
 
    ATH_MSG_DEBUG("Decoding TGC RDO into TGC PrepRawData");
 
    // retrieve the collection of RDO
    ATH_MSG_DEBUG("Retrieving TGC RDO container from the store");
    const TgcRdoContainer* rdoContainer{};
    ATH_CHECK(SG::get(rdoContainer, m_rdoContainerKey, ctx));
    if (rdoContainer->empty()) {
        // empty csm container - no tgc rdo in this event
        ATH_MSG_DEBUG("Empty rdo container - no tgc rdo in this event");
        return StatusCode::SUCCESS;
    }
 
    ATH_MSG_DEBUG(
        "Not empty rdo container in this event, the container size is "
        << rdoContainer->size());
 
    // select RDOs to be decoded when seeded mode is used
    if (sizeVectorRequested != 0) {
        unsigned int nRdo = 0;
        const IdContext tgcContext = m_idHelperSvc->tgcIdHelper().module_context();  // TGC context
   
        for (const IdentifierHash& offlineCollHash : requestedIdHashVect) {
            Identifier elementId;
            int subDetectorId = 0;  // 103(=0x67) for A side, 104(=0x68) for C side
            int rodId = 0;          // 1 to 12 (12-fold cabling)
            m_idHelperSvc->tgcIdHelper().get_id(offlineCollHash, elementId, &tgcContext);
            state.cabling->getReadoutIDfromElementID(elementId, subDetectorId, rodId);
            // onlineId: 0 to 11 on A side and 12 to 23 on C side (12-fold cabling)
            const uint16_t onlineId = TgcRdo::calculateOnlineId(subDetectorId, rodId);
 
            if (decodedOnlineId.at(onlineId)) {
                ATH_MSG_DEBUG("The ROB with onlineId "
                              << onlineId << " which contains hash "
                              << static_cast<unsigned int>(offlineCollHash)
                              << " is already decoded and skipped");
                continue;
            }
 
            decodedOnlineId.at(onlineId) = true;  // The ROB with this onlineId will be decoded only once
 
            for (const TgcRdo* rdoColl : *rdoContainer) {
                if (rdoColl->identify() == onlineId) {
                    if (!decodedRdoCollVec.count(rdoColl)) {
                        rdoCollVec.insert(rdoColl);
                        nRdo++;
                    }
                    break;
                }
            }
        }
        ATH_MSG_DEBUG("Number of RDOs to be converted is " << nRdo);
    }  // End of selection of RDOs to be decoded
 
    // Decode Hits
    if (sizeVectorRequested != 0) {
        ATH_MSG_DEBUG("Start loop over rdos - seeded mode");
        // for each RDO collection we collect up all the PRD collections and
        // then write them once filled need a vector because we have the
        // collections for the different bunch crosssings
        for (const TgcRdo* rdo : rdoCollVec) {
            for (const TgcRawData* rd : *rdo) {
                // Since OnlineIds are not unique, need some additional
                // filtering on offline hashId to avoid decoding RDO outside of
                // an RoI
                Identifier offlineId{};
                if (!state.cabling->getElementIDfromReadoutID(
                        offlineId, rd->subDetectorId(), rd->rodId(),
                        rd->sswId(), rd->slbId(), rd->bitpos())) {
                    continue;
                }
                const IdentifierHash tgcHashId =
                    m_idHelperSvc->moduleHash(offlineId);
                if (std::find(requestedIdHashVect.begin(),
                              requestedIdHashVect.end(),
                              tgcHashId) == requestedIdHashVect.end()) {
                    continue;
                }
                selectDecoder(state, *rd, rdo);
            }
            decodedRdoCollVec.insert(rdo);
        }
    } else {
        ATH_MSG_DEBUG("Start loop over rdos - unseeded mode");
        for (const TgcRdo* rdoColl : *rdoContainer) {
            if (rdoColl->empty() || decodedRdoCollVec.count(rdoColl) ||
                rdoCollVec.count(rdoColl)) {
                continue;
            }
            ATH_MSG_DEBUG(" Number of RawData in this rdo " << rdoColl->size());
            for (const TgcRawData* rd : *rdoColl) {
                selectDecoder(state, *rd, rdoColl);
            }
            decodedRdoCollVec.insert(rdoColl);
        }
    }
    // first collect up all the HashIDs in any of the containers
    std::set<IdentifierHash> hashesInAnyBC;
    for (unsigned int ibc = 0; ibc < NBC_HIT; ++ibc) {
 
        uint16_t bcBitMap = 0;
        if (ibc == 0) {
            bcBitMap = TgcPrepData::BCBIT_PREVIOUS;
        } else if (ibc == 1) {
            bcBitMap = TgcPrepData::BCBIT_CURRENT;
        } else if (ibc == 2) {
            bcBitMap = TgcPrepData::BCBIT_NEXT;
        }
 
        for (std::unique_ptr<TgcPrepDataCollection>& bcColl :
             state.tgcPrepDataCollections[ibc]) {
            if (!bcColl) {
                continue;
            }
            std::unique_ptr<TgcPrepDataCollection>& allBcColl =
                state.tgcPrepDataCollections[NBC_HIT][bcColl->identifyHash()];
            if (!allBcColl) {
                allBcColl = std::make_unique<TgcPrepDataCollection>(
                    bcColl->identifyHash());
                allBcColl->setIdentifier(bcColl->identify());
            }
            hashesInAnyBC.insert(bcColl->identifyHash());
            for (const TgcPrepData* prdToUpdate : *bcColl) {
                auto search_itr = std::find_if(
                    allBcColl->begin(), allBcColl->end(),
                    [prdToUpdate](const TgcPrepData* prd) {
                        return prd->identify() == prdToUpdate->identify();
                    });
                if (search_itr == allBcColl->end()) {
                    auto allBcPrd = std::make_unique<TgcPrepData>(*prdToUpdate);
                    allBcPrd->setHashAndIndex(allBcColl->identifyHash(),
                                              allBcColl->size());
                    allBcPrd->setBcBitMap(bcBitMap);
                    allBcColl->push_back(std::move(allBcPrd));
                } else {
                    TgcPrepData* allBcPrd = (*search_itr);
                    const uint16_t bcBitMap_current = allBcPrd->getBcBitMap();
                    ATH_MSG_VERBOSE(
                        m_idHelperSvc->toString(allBcPrd->identify())
                        << " Old bitmap " << bcBitMap_current << " adding "
                        << bcBitMap << " to get "
                        << (bcBitMap_current | bcBitMap));
                    allBcPrd->setBcBitMap((bcBitMap_current | bcBitMap));
                }
            }
        }
    }
 
    if (!m_xAODKey.empty()) {
        for (std::unique_ptr<TgcPrepDataCollection>& allBcColl :
             state.tgcPrepDataCollections[NBC_HIT]) {
            if (!allBcColl) {
                continue;
            }
            for (const TgcPrepData* allBcPrd : *allBcColl) {
                xAOD::TgcStrip* tgcStrip =
                    xAODHandle->push_back(std::make_unique<xAOD::TgcStrip>());
                tgcStrip->setMeasuresPhi(
                    idHelper.isStrip(allBcPrd->identify()));
                tgcStrip->setGasGap(idHelper.gasGap(allBcPrd->identify()));
                tgcStrip->setChannelNumber(
                    idHelper.channel(allBcPrd->identify()));
                tgcStrip->setBcBitMap(allBcPrd->getBcBitMap());
                tgcStrip->setIdentifier(allBcPrd->identify().get_compact());
                //  rotation from eta -> phi is clockwise  --> minus sign in prd
                //  creation
                const double locPos = (tgcStrip->measuresPhi() ? -1. : 1.) *
                                      allBcPrd->localPosition().x();
                tgcStrip->setMeasurement(
                    m_idHelperSvc->moduleHash(allBcPrd->identify()),
                    xAOD::MeasVector<1>(locPos),
                    xAOD::MeasMatrix<1>(allBcPrd->localCovariance()(0, 0)));
            }
        }
    }
 
    for (unsigned int k = 0; k < state.tgcPrepDataContainer.size(); ++k) {
        ATH_CHECK(transferData(*state.tgcPrepDataContainer[k],
                               std::move(state.tgcPrepDataCollections[k])));
    }
    for (unsigned int k = 0; k < state.tgcCoinDataContainer.size(); ++k) {
        ATH_CHECK(transferData(*state.tgcCoinDataContainer[k],
                               std::move(state.tgcCoinDataCollections[k])));
    }
    ATH_MSG_DEBUG("Found " << hashesInAnyBC.size()
                           << " hashes that must be added to AllBC container");
 
    return StatusCode::SUCCESS;
}
 
void Muon::TgcRdoToPrepDataToolMT::selectDecoder(State& state,
                                                 const TgcRawData& rd,
                                                 const TgcRdo* rdoColl) const {
 
    if (!rd.isCoincidence()) {
        if (!decodeHits(state, rd).isSuccess()) {
            ATH_MSG_WARNING("Cannot decode TGC Hits");
        }
    } else if (rd.isCoincidence() && m_fillCoinData) {  // coincidence start
        StatusCode status = StatusCode::SUCCESS;
        if (rd.type() == TgcRawData::TYPE_TRACKLET) {
            if (rd.slbType() == TgcRawData::SLB_TYPE_DOUBLET_WIRE ||
                rd.slbType() == TgcRawData::SLB_TYPE_DOUBLET_STRIP) {
                status = decodeTracklet(state, rd);
            } else if (rd.slbType() == TgcRawData::SLB_TYPE_INNER_WIRE ||
                       rd.slbType() == TgcRawData::SLB_TYPE_INNER_STRIP) {
                status = decodeTrackletEIFI(state, rd);
            }
        }  // rd.rodId()<13 for Run2, rd.rodId()>12 for Run3
        else if (rd.type() == TgcRawData::TYPE_HIPT &&
                 ((rd.isHipt() && rd.rodId() < 13) || rd.rodId() > 12)) {
            status = decodeHiPt(state, rd);
        } else if ((rd.rodId() < 13 && rd.type() == TgcRawData::TYPE_HIPT &&
                    (rd.sector() & 4) != 0) ||  // Run2
                   (rd.rodId() > 12 &&
                    (rd.type() == TgcRawData::TYPE_INNER_NSW ||     // Run3
                     rd.type() == TgcRawData::TYPE_INNER_BIS ||     // Run3
                     rd.type() == TgcRawData::TYPE_INNER_EIFI ||    // Run3
                     rd.type() == TgcRawData::TYPE_INNER_TMDB))) {  // Run3
            status = decodeInner(state, rd);
        } else if (rd.type() == TgcRawData::TYPE_SL) {
            status = decodeSL(state, rd, rdoColl);
        }
        if (!status.isSuccess()) {
            ATH_MSG_WARNING("Cannot decode TGC Coincidences");
        }
    }
}
 
StatusCode Muon::TgcRdoToPrepDataToolMT::decodeHits(
    State& state, const TgcRawData& rd) const {
    // The channel hit by hardware-ROD supports only three-bunch readout. Data
    // of TgcDigit::BC_NEXTNEXT should be skipped in this function.
    if (rd.bcTag() == TgcDigit::BC_NEXTNEXT) {
        return StatusCode::SUCCESS;
    }
 
    m_nHitRDOs++;  // Count the number of input Hit RDOs.
    bool isConverted{false}, isDuplicated{false}, isInvalid{false};
 
    ATH_MSG_DEBUG("decodeHits() :" << __LINE__ << " sub=" << rd.subDetectorId()
                                   << " rod=" << rd.rodId() << " ssw="
                                   << rd.sswId() << " slb=" << rd.slbId()
                                   << " bitpos=" << rd.bitpos());
 
    const TgcIdHelper& idHelper{m_idHelperSvc->tgcIdHelper()};
 
    // select current Hits, =0 for backward compatibility
    // BC_CURRENT=2, BC_UNDEFINED=0
    int locId = (rd.bcTag() == TgcDigit::BC_CURRENT ||
                 rd.bcTag() == TgcDigit::BC_UNDEFINED)
                    ? 1
                    : rd.bcTag() - 1;
 
    // repeat two times for ORed channel
    for (int iOr = 0; iOr < 2; iOr++) {
        bool orFlag = false;
        // check if this channel has ORed partner only when 2nd time
        if (iOr != 0) {
            bool o_found = state.cabling->isOredChannel(
                rd.subDetectorId(), rd.rodId(), rd.sswId(), rd.slbId(),
                rd.bitpos());
            // set OR flag
            if (o_found) {
                orFlag = true;
            } else {
                continue;
            }
        }
 
        // get element ID
        Identifier elementId{};
        bool e_found = state.cabling->getElementIDfromReadoutID(
            elementId, rd.subDetectorId(), rd.rodId(), rd.sswId(), rd.slbId(),
            rd.bitpos(), orFlag);
        if (!e_found) {
            if (!orFlag) {
                bool show_warning_level = true;
 
                /* One invalid channel in sector A09:
                   sub=103 rod=9 ssw=6 slb=20 bitpos=151 +offset=0 orFlag=0
                   was always seen in 2008 data, at least run 79772 - 91800.
                   bug #48828 */
                /* One invalid channel in sector A11:
                   sub=103 rod=11 ssw=2 slb=8 bitpos=41 orFlag=0
                   was seen 5 times in 1,059,867 events of run 159179. */
                /* EIFI of MC ByteStream without correction issue : bug 57051 */
                if ((rd.subDetectorId() == 103 && rd.rodId() == 9 &&
                     rd.sswId() == 6 && rd.slbId() == 20 &&
                     rd.bitpos() == 151) ||
                    (rd.subDetectorId() == 103 && rd.rodId() == 11 &&
                     rd.sswId() == 2 && rd.slbId() == 8 && rd.bitpos() == 41) ||
                    (rd.rodId() % 3 == 2 && rd.sswId() == 8)) {
                    show_warning_level =
                        m_show_warning_level_invalid_A09_SSW6_hit;
                    isInvalid = true;
                }
                if (msgLvl(show_warning_level ? MSG::WARNING : MSG::DEBUG)) {
                    msg(show_warning_level ? MSG::WARNING : MSG::DEBUG)
                        << "ElementID not found for "
                        << " sub=" << rd.subDetectorId()
                        << " rod=" << rd.rodId() << " ssw=" << rd.sswId()
                        << " slb=" << rd.slbId() << " bitpos=" << rd.bitpos()
                        << " orFlag=" << orFlag << endmsg;
                }
            }
            continue;
        }
        const IdentifierHash tgcHashId = m_idHelperSvc->moduleHash(elementId);
 
        Identifier channelId{};
        bool c_found = state.cabling->getOfflineIDfromReadoutID(
            channelId, rd.subDetectorId(), rd.rodId(), rd.sswId(), rd.slbId(),
            rd.bitpos(), orFlag);
        if (!c_found) {
            if (!orFlag) {
                ATH_MSG_WARNING(
                    "OfflineID not found for "
                    << " sub=" << rd.subDetectorId() << " rod=" << rd.rodId()
                    << " ssw=" << rd.sswId() << " slb=" << rd.slbId()
                    << " bitpos=" << rd.bitpos() << " orFlag=" << orFlag);
            }
            continue;
        }
 
        std::unique_ptr<TgcPrepDataCollection>& collection =
            state.tgcPrepDataCollections[locId][tgcHashId];
        if (!collection) {
            collection = std::make_unique<TgcPrepDataCollection>(tgcHashId);
            collection->setIdentifier(elementId);
        }
        const bool duplicate =
            std::find_if(collection->begin(), collection->end(),
                         [&channelId](const TgcPrepData* prd) {
                             return prd->identify() == channelId;
                         }) != collection->end();
        if (duplicate) {
            isDuplicated = true;  // A converted PRD of this RDO is duplicated.
            continue;
        }
 
        const MuonGM::TgcReadoutElement* descriptor =
            state.muDetMgr->getTgcReadoutElement(channelId);
        if (!isOfflineIdOKForTgcReadoutElement(descriptor, channelId)) {
            ATH_MSG_WARNING(
                "decodeHits: MuonGM::TgcReadoutElement is invalid.");
            continue;
        }
        ATH_MSG_DEBUG(
            "TGC RDO->PrepRawdata: " << m_idHelperSvc->toString(channelId));
 
        std::vector<Identifier> identifierList{channelId};
 
        Amg::Vector3D position = descriptor->channelPos(channelId);
        Amg::Vector2D hitPos{Amg::Vector2D::Zero()};
        bool onSurface = descriptor->surface(channelId).globalToLocal(
            position, position, hitPos);
        // the globalToLocal should not fail, if it does produce a WARNING
        if (!onSurface) {
            ATH_MSG_WARNING(
                "Muon::TgcRdoToPrepDataToolMT::decodeHits Amg::Vector2D* "
                "hitPos is null.");
            continue;
        }
 
        int gasGap = idHelper.gasGap(channelId);
        int channel = idHelper.channel(channelId);
        const double width = !idHelper.isStrip(channelId)
                                 ? descriptor->gangRadialLength(gasGap, channel)
                                 : descriptor->stripWidth(gasGap, channel);
 
        if (width < s_cutDropPrdsWithZeroWidth &&
            m_dropPrdsWithZeroWidth) {  // Invalid PRD's whose widths are zero
                                        // are dropped.
            ATH_MSG_WARNING("decodeHits: width= "
                            << width
                            << " is smaller than s_cutDropPrdsWithZeroWidth= "
                            << s_cutDropPrdsWithZeroWidth << " "
                            << m_idHelperSvc->toString(channelId));
            continue;
        }
        double errPos = width / std::sqrt(12.);
 
        Amg::MatrixX mat(1, 1);
        mat.setIdentity();
        mat *= errPos * errPos;
 
        // add the digit to the collection
        // new TgcPrepRawData
        TgcPrepData* newPrepData =
            new TgcPrepData(channelId,       // Readout ID -> Offline ID
                            tgcHashId,       // Readout ID -> Element ID -> Hash
                            hitPos,          // determined from channelId
                            identifierList,  // holds channelId only
                            mat,             // determined from channelId
                            descriptor);     // determined from channelId
        newPrepData->setHashAndIndex(collection->identifyHash(),
                                     collection->size());
        collection->push_back(newPrepData);
        isConverted = true;  // This RDO is converted to at least one PRD.
    }
 
    if (isConverted) {
        m_nHitPRDs++;  // Count the number of output Hit PRDs.
    } else if (isDuplicated || isInvalid) {
        m_nHitRDOs--;  // Reduce the number of input RDOs.
    }
 
    return StatusCode::SUCCESS;
}
 
StatusCode Muon::TgcRdoToPrepDataToolMT::decodeTracklet(
    State& state, const TgcRawData& rd) const {
    ++m_nTrackletRDOs;  // Count the number of input Tracklet RDOs.
 
    bool found = false;
 
    //*** Get OfflineId of pivot plane (TGC3) start ***//
    Identifier channelIdOut{};
    found = state.cabling->getOfflineIDfromLowPtCoincidenceID(
        channelIdOut, rd.subDetectorId(), rd.rodId(), rd.sswId(), rd.slbId(),
        rd.subMatrix(), rd.position(), false);
    if (!found) {
        ATH_MSG_DEBUG("decodeTracklet: can't get the OfflineIdOut");
        return StatusCode::SUCCESS;
    }
    //*** Get OfflineId of pivot plane (TGC3) end ***//
 
    //*** Get OfflineId of non-pivot plane (TGC2) start ***//
    int tmp_slbId{0}, tmp_subMatrix{0}, tmp_position{0};
    found = getTrackletInfo(rd, tmp_slbId, tmp_subMatrix, tmp_position);
    if (!found) {
        return StatusCode::SUCCESS;
    }
    Identifier channelIdIn{};
    found = state.cabling->getOfflineIDfromLowPtCoincidenceID(
        channelIdIn, rd.subDetectorId(), rd.rodId(), rd.sswId(), tmp_slbId,
        tmp_subMatrix, tmp_position, true);
    if (!found) {
        ATH_MSG_DEBUG("decodeTracklet: can't get the OfflineIdIn");
        return StatusCode::SUCCESS;
    }
    //*** Get OfflineId of non-pivot plane (TGC2) end ***//
 
    const IdentifierHash tgcHashId = m_idHelperSvc->moduleHash(channelIdOut);
 
    int locId = (rd.bcTag() == TgcDigit::BC_CURRENT ||
                 rd.bcTag() == TgcDigit::BC_UNDEFINED)
                    ? 1
                    : rd.bcTag() - 1;
 
    std::unique_ptr<Muon::TgcCoinDataCollection>& coincollection =
        state.tgcCoinDataCollections[locId][tgcHashId];
    if (!coincollection) {
        coincollection =
            std::make_unique<Muon::TgcCoinDataCollection>(tgcHashId);
        coincollection->setIdentifier(m_idHelperSvc->chamberId(channelIdOut));
    }
 
    int subMatrix = static_cast<int>(rd.subMatrix());
    int trackletId = static_cast<int>(2 * rd.slbId() + subMatrix);
    int delta = static_cast<int>(rd.delta());
 
    // Check duplicate digits
    for (const TgcCoinData* tgcCoinData : *coincollection) {
        if (TgcCoinData::TYPE_TRACKLET ==
                tgcCoinData->type() &&  // coincidence type
            channelIdOut ==
                tgcCoinData->identify() &&  // channelIdOut, identify returns
                                            // channelIdOut for Tracklet
            channelIdIn == tgcCoinData->channelIdIn() &&  // channelIdIn
            trackletId == tgcCoinData->trackletId() &&    // trackletId
            delta == tgcCoinData->delta() &&              // delta
            subMatrix == tgcCoinData->sub()) {            // subMatrix
 
            ATH_MSG_DEBUG("Duplicated TgcCoinData (Tracklet) = "
                          << m_idHelperSvc->toString(channelIdIn));
            return StatusCode::SUCCESS;
        }
    }
 
    ATH_MSG_DEBUG("TGC RDO->Coindata for LowPT: "
                  << m_idHelperSvc->toString(channelIdOut));
 
    //*** Get geometry of pivot plane (TGC3) start ***//
    const MuonGM::TgcReadoutElement* descriptor_o =
        state.muDetMgr->getTgcReadoutElement(channelIdOut);
    if (!isOfflineIdOKForTgcReadoutElement(descriptor_o, channelIdOut)) {
        return StatusCode::SUCCESS;
    }
 
    const TgcIdHelper& idHelper{m_idHelperSvc->tgcIdHelper()};
    int gasGap_o = idHelper.gasGap(channelIdOut);
    int channel_o = idHelper.channel(channelIdOut);
    double width_o = !idHelper.isStrip(channelIdOut)
                         ? descriptor_o->gangRadialLength(gasGap_o, channel_o)
                         : descriptor_o->stripWidth(gasGap_o, channel_o);
 
    if (width_o < s_cutDropPrdsWithZeroWidth &&
        m_dropPrdsWithZeroWidth) {  // Invalid PRD's whose widths are zero are
                                    // dropped.
        return StatusCode::SUCCESS;
    }
 
    Amg::Vector3D position_o = descriptor_o->channelPos(channelIdOut);
    Amg::Vector2D hitPos_o{Amg::Vector2D::Zero()};
    bool onSurface_o = descriptor_o->surface(channelIdOut)
                           .globalToLocal(position_o, position_o, hitPos_o);
    // the globalToLocal should not fail, if it does produce a WARNING
    if (!onSurface_o) {
        ATH_MSG_WARNING(
            "Muon::TgcRdoToPrepDataToolMT::decodeTracklet Amg::Vector2D* "
            "hitPos_o is null.");
        return StatusCode::SUCCESS;
    }
    //*** Get geometry of pivot plane (TGC3) end ***//
 
    //*** Get geometry of non-pivot plane (TGC2) start ***//
    const MuonGM::TgcReadoutElement* descriptor_i =
        state.muDetMgr->getTgcReadoutElement(channelIdIn);
    if (!isOfflineIdOKForTgcReadoutElement(descriptor_i, channelIdIn)) {
        return StatusCode::SUCCESS;
    }
 
    int gasGap_i = idHelper.gasGap(channelIdIn);
    int channel_i = idHelper.channel(channelIdIn);
    double width_i = !idHelper.isStrip(channelIdIn)
                         ? descriptor_i->gangRadialLength(gasGap_i, channel_i)
                         : descriptor_i->stripWidth(gasGap_i, channel_i);
 
    if (width_i < s_cutDropPrdsWithZeroWidth &&
        m_dropPrdsWithZeroWidth) {  // Invalid PRD's whose widths are zero are
                                    // dropped.
        return StatusCode::SUCCESS;
    }
 
    Amg::Vector3D position_i = descriptor_i->channelPos(channelIdIn);
    Amg::Vector2D hitPos_i{Amg::Vector2D::Zero()};
    bool onSurface_i = descriptor_i->surface(channelIdIn)
                           .globalToLocal(position_i, position_i, hitPos_i);
    // the globalToLocal should not fail, if it does produce a WARNING
    if (!onSurface_i) {
        ATH_MSG_WARNING(
            "Muon::TgcRdoToPrepDataToolMT::decodeTracklet Amg::Vector2D* "
            "hitPos_i is null.");
        return StatusCode::SUCCESS;
    }
    //*** Get geometry of non-pivot plane (TGC2) end ***//
    const Amg::Vector2D* hitPosition_o = new Amg::Vector2D(hitPos_o);
    const Amg::Vector2D* hitPosition_i = new Amg::Vector2D(hitPos_i);
    // Add the digit to the collection
    TgcCoinData* newCoinData =
        new TgcCoinData(channelIdIn, channelIdOut,
                        tgcHashId,     // determined from channelIdOut
                        descriptor_i,  // determined from channelIdIn
                        descriptor_o,  // determined from channelIdOut
                        TgcCoinData::TYPE_TRACKLET,
                        rd.subDetectorId() == ASIDE,         // isAside
                        idHelper.stationPhi(channelIdOut),   // phi
                        0,                                   // isInner
                        rd.sswId() == 7 || rd.sswId() == 2,  // isForward
                        idHelper.isStrip(channelIdOut),      // isStrip
                        trackletId,                          // trackletId
                        hitPosition_i,  // determined from channelIdIn
                        hitPosition_o,  // determined from channelIdOut
                        width_i,        // determined from channelIdIn
                        width_o,        // determined from channelIdOut
                        delta,          // delta
                        subMatrix,
                        0);  // subMatrix
    newCoinData->setHashAndIndex(coincollection->identifyHash(),
                                 coincollection->size());
    coincollection->push_back(newCoinData);
 
    ATH_MSG_DEBUG("coincollection->push_back done (for LowPT)");
 
    m_nTrackletPRDs++;  // Count the number of output Tracklet PRDs.
 
    return StatusCode::SUCCESS;
}
 
StatusCode Muon::TgcRdoToPrepDataToolMT::decodeTrackletEIFI(
    State& state, const TgcRawData& rd) const {
    // Count the number of input TrackletEIFI RDOs.
    m_nTrackletEIFIRDOs++;
 
    const TgcIdHelper& idHelper{m_idHelperSvc->tgcIdHelper()};
 
    // Determine chamber type
    bool isStrip = rd.slbType() == TgcRawData::SLB_TYPE_INNER_STRIP;
    bool isAside = rd.subDetectorId() == ASIDE;
    // https://twiki.cern.ch/twiki/pub/Main/TgcDocument/EIFI_PSB_SSW_ConnectionTable_v20080808.pdf
    bool isForward = (rd.slbId() % 2 == 0);
    // Assuming RXID in the above file is equal to slbId
    // rodId:     2                 5                 8                11
    // slbId FI:  0  2  4  6  8 10  0  2  4  6  8 10  0  2  4  6  8 10  0  2  4
    // 6  8 10
    //       EI:  1  3  5  7  9 11  1  3  5 XX  9 11  1  3  5  7  9 XX  1  3  5
    //       XX  9 11
    // slot:     24  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20
    // 21 22 23 stationPhi
    //       FI: 24  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20
    //       21 22 23 EI: 21  1  2  3  4  5  6  7  8 XX  9 10 11 12 13 14 15 XX
    //       16 17 18 XX 19 20
    int slot = ((rd.slbId() / 2) + (rd.rodId() - 2) * 2 + 23) % 24 + 1;
 
    bool isBackward = false;
    if (!isForward) {  // EI
        // Special case of EI11
        if (slot == 15) {
            isBackward = !isAside;
        } else if (slot == 16) {
            isBackward = isAside;
        } else {
            //  A-side phi0 F: phi1 F: phi2 B
            //  C-side phi0 B: phi1 B: phi2 F
            if (isAside) {
                isBackward = (slot % 3 == 2);
            } else {
                isBackward = (slot % 3 != 2);
            }
        }
    } else {  // FI
        isBackward = isAside;
    }
 
    // Determine bitpos based on wire/strip and subMatrix
    // Input is chosen so that gasGap is 1 and channel is 4,12,20,28.
    // One subMatrix covers 8 channels (=BIT_POS_ASD_SIZE/2)
    uint16_t bitpos = 0;
    if (!isStrip) {  // Wire
        // For wires, D-Input is gasGap=1
 
        int tmpsubMatrix = static_cast<int>(rd.subMatrix());
        if (!isForward) {  // If an edge channel of EI fires, subMatrix of the
                           // tracklet can be greater than one of the hit
                           // channel.
            if (tmpsubMatrix == 3) {
                if (slot == 1 || slot == 3 || slot == 4 || slot == 5 ||
                    slot == 6 || slot == 7 || slot == 8 || slot == 10 ||
                    slot == 11 || slot == 13 || slot == 18 || slot == 19 ||
                    slot == 20) {
                    // These slots have only 24 wire channels (=3 submatrixes)
                    tmpsubMatrix = 2;
                }
            } else if (tmpsubMatrix == 2) {
                if (slot == 2 || slot == 12 || slot == 14 || slot == 15 ||
                    slot == 16 || slot == 22 || slot == 23 || slot == 24) {
                    // These slots have only 16 wire channels (=2 submatrixes)
                    tmpsubMatrix = 1;
                }
            }
        }
 
        bitpos = BIT_POS_D_INPUT_ORIGIN - BIT_POS_INPUT_SIZE + 1 +
                 BIT_POS_ASD_SIZE / 4 * (tmpsubMatrix * 2 + 1);
    } else {  // Strip
        if (isBackward) {
            // For Backward chambers, B-Input is gasGap 1
            bitpos = BIT_POS_B_INPUT_ORIGIN - BIT_POS_INPUT_SIZE +
                     (isAside ? 1 : 0) +
                     BIT_POS_ASD_SIZE / 4 * (rd.subMatrix() * 2 + 1);
        } else {
            // For Forward  chambers, A-Input is gasGap 1
            bitpos = BIT_POS_A_INPUT_ORIGIN - BIT_POS_INPUT_SIZE +
                     (isAside ? 0 : 1) +
                     BIT_POS_ASD_SIZE / 4 * (rd.subMatrix() * 2 + 1);
        }
    }
 
    // Retrieve OfflineID from ReadoutID
    Identifier channelIdIn;
    bool o_found = state.cabling->getOfflineIDfromReadoutID(
        channelIdIn, rd.subDetectorId(), rd.rodId(), rd.sswId(), rd.slbId(),
        bitpos, false /*orflag*/);
    if (!o_found) {
        ATH_MSG_WARNING(
            "Muon::TgcRdoToPrepDataToolMT::decodeTrackletEIFI OfflineID not "
            "found for "
            << " subDetectorId=" << rd.subDetectorId() << " rodId="
            << rd.rodId() << " sswId=" << rd.sswId() << " slbId=" << rd.slbId()
            << " slbType=" << rd.slbType() << " subMatrix=" << rd.subMatrix()
            << " bitpos=" << bitpos << " isStrip=" << isStrip
            << " isAside=" << isAside << " isForward=" << isForward
            << " slot=" << slot << " isBackward=" << isBackward);
        return StatusCode::SUCCESS;
    }
 
    // Retrieve Hash from ElementID
    const IdentifierHash tgcHashId = m_idHelperSvc->moduleHash(channelIdIn);
    // Index is determined based on bcTag.
    int locId = (rd.bcTag() == TgcDigit::BC_CURRENT ||
                 rd.bcTag() == TgcDigit::BC_UNDEFINED)
                    ? 1
                    : rd.bcTag() - 1;
 
    std::unique_ptr<Muon::TgcCoinDataCollection>& coincollection =
        state.tgcCoinDataCollections[locId][tgcHashId];
    if (!coincollection) {
        coincollection =
            std::make_unique<Muon::TgcCoinDataCollection>(tgcHashId);
        coincollection->setIdentifier(m_idHelperSvc->chamberId(channelIdIn));
    }
 
    // Check duplicate digits
    for (const TgcCoinData* tgcCoinData : *coincollection) {
        if (TgcCoinData::TYPE_TRACKLET_EIFI ==
                tgcCoinData->type() &&                    // coincidence type
            channelIdIn == tgcCoinData->channelIdIn() &&  // channelIdIn
            static_cast<int>(rd.subMatrix()) == tgcCoinData->sub()) {  // sub
            ATH_MSG_DEBUG("Duplicated TgcCoinData (TrackletEIFI) = "
                          << m_idHelperSvc->toString(channelIdIn));
            return StatusCode::SUCCESS;
        }
    }
    // Get MuonGM::TgcReadoutElement from channelIdIn
    const MuonGM::TgcReadoutElement* descriptor =
        state.muDetMgr->getTgcReadoutElement(channelIdIn);
    if (!isOfflineIdOKForTgcReadoutElement(descriptor, channelIdIn)) {
        ATH_MSG_WARNING(
            "Muon::TgcRdoToPrepDataToolMT::decodeTrackletEIFI descriptor "
            "doesn't contain "
            << m_idHelperSvc->toString(channelIdIn));
        return StatusCode::SUCCESS;
    }
 
    // Get Amg::Vector2D from channelIdIn //here I am
    Amg::Vector3D position = descriptor->channelPos(channelIdIn);
    Amg::Vector2D hitPos{Amg::Vector2D::Zero()};
    bool onSurface = descriptor->surface(channelIdIn)
                         .globalToLocal(position, position, hitPos);
    // the globalToLocal should not fail, if it does produce a WARNING
    if (!onSurface) {
        ATH_MSG_WARNING(
            "Muon::TgcRdoToPrepDataToolMT::decodeTrackletEIFI Amg::Vector2D* "
            "hitPos is null.");
        return StatusCode::SUCCESS;
    }
 
    // Get width from channelIdIn, one subMatrix covers 8 channels per gasGap
    int gasGap = idHelper.gasGap(channelIdIn);    // 1
    int channel = idHelper.channel(channelIdIn);  // 4, 12, 20, 28
    double width{0};
    if (isStrip) {  // Strip
        double localZ = (descriptor->transform(channelIdIn).inverse() *
                         descriptor->channelPos(channelIdIn))
                            .z();
        double stripMaxX =
            descriptor->stripHighEdgeLocX(gasGap, channel + 4, localZ);
        double stripMinX =
            descriptor->stripLowEdgeLocX(gasGap, channel - 3, localZ);
        width = std::abs(stripMaxX - stripMinX);
    } else {  // Wire
        int positiveOffset = +4;
        if (isForward && (slot % 3 == 2) && channel == 28) {
            positiveOffset = +2;  // T10S has only 30 channels.
        }
        double gangMaxZ =
            descriptor->gangLongWidth(gasGap, channel + positiveOffset);
        double gangMinZ = descriptor->gangShortWidth(gasGap, channel - 3);
        width = std::abs(gangMaxZ - gangMinZ);
    }
 
    const Amg::Vector2D* hitPosition = new Amg::Vector2D(hitPos);
    // Add the digit to the collection
    TgcCoinData* newCoinData =
        new TgcCoinData(channelIdIn,
                        tgcHashId,   // determined from channelIdIn
                        descriptor,  // determined from channelIdIn
                        TgcCoinData::TYPE_TRACKLET_EIFI, isAside,
                        m_idHelperSvc->tgcIdHelper().stationPhi(channelIdIn),
                        isForward, isStrip,
                        hitPosition,  // determined from channelIdIn
                        width,        // determined from channelIdIn
                        static_cast<int>(rd.subMatrix()));  // subMatrix
    newCoinData->setHashAndIndex(coincollection->identifyHash(),
                                 coincollection->size());
    coincollection->push_back(newCoinData);
 
    // Count the number of output Tracklet EIFI PRDs.
    m_nTrackletEIFIPRDs++;
    return StatusCode::SUCCESS;
}
 
StatusCode Muon::TgcRdoToPrepDataToolMT::decodeHiPt(
    State& state, const TgcRawData& rd0) const {
    m_nHiPtRDOs++;  // Count the number of input HiPt RDOs.
 
    // conversion for Run3
    uint16_t tmprodId{}, tmpsector{};
    convertToRun2(rd0, tmprodId, tmpsector);
    const TgcRawData rd(rd0.bcTag(), rd0.subDetectorId(), tmprodId, rd0.l1Id(),
                        rd0.bcId(), rd0.isStrip(), rd0.isForward(), tmpsector,
                        rd0.chip(), rd0.index(), rd0.isHipt(), rd0.hitId(),
                        rd0.hsub(), rd0.delta(), rd0.inner());
 
    // Protection against invalid subDetectorId and isForward
    if ((rd.subDetectorId() != ASIDE && rd.subDetectorId() != CSIDE)) {
        ATH_MSG_DEBUG(
            "TgcRdoToPrepDataToolMT::decodeHiPt::Unknown subDetectorId!!");
        return StatusCode::SUCCESS;
    }
 
    // Protection against invalid hitId
    if (rd.hitId() == 0) {
        ATH_MSG_DEBUG(
            "Invalid hitId_rdo_hipt, hitId == 0!! skip to convert this RDO to "
            "PRD");
        return StatusCode::SUCCESS;
    }
    int slbsubMatrix = 0;
    bool isBackward = isBackwardBW(rd);  // Backward or Forward
    int deltaBeforeConvert = getDeltaBeforeConvert(rd);
 
    bool found = false;
 
    Identifier channelIdOut_tmp{};
    std::array<Identifier, 2> channelIdOut{};
    std::array<int, 2> bitpos_o{}, slbchannel_o{};
    int sswId_o{0}, sbLoc_o{0}, slbId_o{0};
 
    Identifier channelIdIn_tmp{};
    std::array<Identifier, 4> channelIdIn{};
    std::array<int, 4> bitpos_i{}, slbchannel_i{};
    int sswId_i{0}, sbLoc_i{0};
 
    std::array<int, 4> slbId_in{}, sbLoc_in{};  // only used for wire
 
    std::array<int, 4> gasGap_i{}, channel_i{};
    double width_i{0.}, hit_position_i{0};
    Amg::Vector2D tmp_hitPos_i{Amg::Vector2D::Zero()};
 
    std::array<int, 2> gasGap_o{}, channel_o{};
    double width_o{0.}, hit_position_o{0.};
    Amg::Vector2D tmp_hitPos_o{Amg::Vector2D::Zero()};
 
    const MuonGM::TgcReadoutElement* descriptor_ii = nullptr;
    const MuonGM::TgcReadoutElement* descriptor_oo = nullptr;
 
    //*** TGC3 start ***//
    // RDOHighPtID --> (Sim)HighPtID --> OfflineID --> ReadoutID --> getSLBID
    found = getHiPtIds(state, rd, sswId_o, sbLoc_o, slbId_o);
    if (!found) {
        return StatusCode::SUCCESS;
    }
 
    // get the OfflineID of cernter of ROI of TGC3
    if (!rd.isStrip()) {  // wire
        getBitPosOutWire(rd, slbsubMatrix, bitpos_o);
    } else {  // strip
        getBitPosOutStrip(rd, slbsubMatrix, bitpos_o);
    }
    for (int i = 0; i < 2; i++) {
        found = state.cabling->getOfflineIDfromReadoutID(
            channelIdOut[i], rd.subDetectorId(), rd.rodId(), sswId_o, sbLoc_o,
            bitpos_o[i]);
        if (!found) {
            ATH_MSG_DEBUG("Failed to get OfflineID from ReadoutID for Pivot "
                          << (rd.isStrip() ? "Strip" : "Wire") << ".");
            return StatusCode::SUCCESS;
        }
    }
 
    //}
    //*** TGC3 end ***//
 
    //*** TGC1 start ***//
    // get the OfflineID of cernter of ROI of TGC1
    if (!rd.isStrip()) {  // wire
        getBitPosInWire(rd, deltaBeforeConvert, bitpos_i, slbchannel_i,
                        slbId_in, sbLoc_in, sswId_i, bitpos_o, slbchannel_o,
                        slbId_o);
    } else {  // strip
        getBitPosInStrip(rd, deltaBeforeConvert, bitpos_i, slbchannel_i,
                         sbLoc_i, sswId_i, bitpos_o, slbchannel_o);
    }
    for (int i = 0; i < 4; i++) {
        found = state.cabling->getOfflineIDfromReadoutID(
            channelIdIn[i], rd.subDetectorId(), rd.rodId(), sswId_i,
            rd.isStrip() ? sbLoc_i : sbLoc_in[i], bitpos_i[i]);
        if (!found) {
            ATH_MSG_DEBUG("Failed to get OfflineID from ReadoutID for Pivot "
                          << (rd.isStrip() ? "Strip" : "Wire") << ".");
            return StatusCode::SUCCESS;
        }
    }
    //}
    //*** TGC1 end ***//
 
    ATH_MSG_DEBUG("TGC RDO->Coindata for HIPT: "
                  << m_idHelperSvc->toString(channelIdOut[1]));
 
    const IdentifierHash tgcHashId = m_idHelperSvc->moduleHash(channelIdOut[1]);
 
    int locId = (rd.bcTag() == TgcDigit::BC_CURRENT ||
                 rd.bcTag() == TgcDigit::BC_UNDEFINED)
                    ? 1
                    : rd.bcTag() - 1;
 
    std::unique_ptr<Muon::TgcCoinDataCollection>& coincollection =
        state.tgcCoinDataCollections[locId][tgcHashId];
    if (!coincollection) {
        coincollection =
            std::make_unique<Muon::TgcCoinDataCollection>(tgcHashId);
        coincollection->setIdentifier(
            m_idHelperSvc->chamberId(channelIdOut[1]));
    }
 
    //*** TGC3 start ***//
    // Get geometry of pivot plane
    std::array<const MuonGM::TgcReadoutElement*, 2> descriptor_o{
        state.muDetMgr->getTgcReadoutElement(channelIdOut[0]),
        state.muDetMgr->getTgcReadoutElement(channelIdOut[1])};
    for (int i = 0; i < 2; i++) {
        if (!isOfflineIdOKForTgcReadoutElement(descriptor_o[i],
                                               channelIdOut[i])) {
            return StatusCode::SUCCESS;
        }
    }
 
    const TgcIdHelper& idHelper{m_idHelperSvc->tgcIdHelper()};
    for (int i = 0; i < 2; i++) {
        gasGap_o[i] = idHelper.gasGap(channelIdOut[i]);
        channel_o[i] = idHelper.channel(channelIdOut[i]);
    }
 
    if (!rd.isStrip()) {  // wire
        found = getPosAndIdWireOut(descriptor_o, channelIdOut, gasGap_o,
                                   channel_o, width_o, hit_position_o,
                                   tmp_hitPos_o, channelIdOut_tmp);
    } else {  // strip
        found = getPosAndIdStripOut(descriptor_o, channelIdOut, gasGap_o,
                                    channel_o, width_o, hit_position_o,
                                    tmp_hitPos_o, channelIdOut_tmp, isBackward,
                                    rd.subDetectorId() == ASIDE);
    }
    if (!found) {
        return StatusCode::SUCCESS;
    }
    if (width_o < s_cutDropPrdsWithZeroWidth &&
        m_dropPrdsWithZeroWidth) {  // Invalid PRD's whose widths are zero are
                                    // dropped.
        return StatusCode::SUCCESS;
    }
 
    descriptor_oo = state.muDetMgr->getTgcReadoutElement(channelIdOut_tmp);
    if (!isOfflineIdOKForTgcReadoutElement(descriptor_oo, channelIdOut_tmp)) {
        return StatusCode::SUCCESS;
    }
    //}
    //*** TGC3 end ***//
 
    //*** TGC1 start ***//
    // Get geometry of non-pivot plane
    std::array<const MuonGM::TgcReadoutElement*, 4> descriptor_i{
        state.muDetMgr->getTgcReadoutElement(channelIdIn[0]),
        state.muDetMgr->getTgcReadoutElement(channelIdIn[1]),
        state.muDetMgr->getTgcReadoutElement(channelIdIn[2]),
        state.muDetMgr->getTgcReadoutElement(channelIdIn[3])};
    for (int i = 0; i < 4; i++) {
        if (!isOfflineIdOKForTgcReadoutElement(descriptor_i[i],
                                               channelIdIn[i])) {
            return StatusCode::SUCCESS;
        }
    }
    for (int i = 0; i < 4; i++) {
        gasGap_i[i] = idHelper.gasGap(channelIdIn[i]);
        channel_i[i] = idHelper.channel(channelIdIn[i]);
    }
 
    if (!rd.isStrip()) {  // WIRE
        found = getPosAndIdWireIn(descriptor_i, channelIdIn, gasGap_i,
                                  channel_i, width_i, hit_position_i,
                                  tmp_hitPos_i, channelIdIn_tmp);
    } else {  // STRIP
        found = getPosAndIdStripIn(descriptor_i, channelIdIn, gasGap_i,
                                   channel_i, width_i, hit_position_i,
                                   tmp_hitPos_i, channelIdIn_tmp, isBackward,
                                   (rd.subDetectorId() == ASIDE));
    }
    if (!found) {
        return StatusCode::SUCCESS;
    }
    if (width_i < s_cutDropPrdsWithZeroWidth &&
        m_dropPrdsWithZeroWidth) {  // Invalid PRD's whose widths are zero are
                                    // dropped.
        return StatusCode::SUCCESS;
    }
 
    descriptor_ii = state.muDetMgr->getTgcReadoutElement(channelIdIn_tmp);
    if (!isOfflineIdOKForTgcReadoutElement(descriptor_ii, channelIdIn_tmp)) {
        return StatusCode::SUCCESS;
    }
    //}
    //*** TGC1 end ***//
 
    int trackletId = 2 * sbLoc_o + slbsubMatrix;
    int delta = static_cast<int>(rd.delta());
    int hsub = static_cast<int>(rd.hsub());
    int inner = static_cast<int>(rd.inner());
 
    // check duplicate digits
    for (const TgcCoinData* tgcCoinData : *coincollection) {
        if ((TgcCoinData::TYPE_HIPT ==
             tgcCoinData->type()) &&  // Coincidence type
            (channelIdOut_tmp ==
             tgcCoinData->identify()) &&  // channelIdOut, identify returns
                                          // channelIdOut for HiPt
            (channelIdIn_tmp == tgcCoinData->channelIdIn()) &&  // channelIdIn
            (trackletId == tgcCoinData->trackletId()) &&        // trackletId
            (delta == tgcCoinData->delta()) &&                  // delta
            (hsub == tgcCoinData->sub()) &&                     // hsub
            (inner == tgcCoinData->inner())) {
            if (38 <= trackletId && trackletId <= 41) {
                // This drop is most probably due to the fix of the HiPt Endcap
                // Strip Board bug.
                m_nHiPtRDOs--;  // Reduce the number of input RDOs.
            }
            ATH_MSG_DEBUG("Duplicated TgcCoinData (HiPt) = "
                          << m_idHelperSvc->toString(channelIdOut_tmp));
            return StatusCode::SUCCESS;
        }
    }
 
    auto hitPos_o = std::make_unique<Amg::Vector2D>(tmp_hitPos_o);
    auto hitPos_i = std::make_unique<Amg::Vector2D>(tmp_hitPos_i);
 
    TgcCoinData* newCoinData = new TgcCoinData(
        channelIdIn_tmp, channelIdOut_tmp,
        tgcHashId,                    // determined from channelIdOut[1]
        descriptor_ii,                // determined from channelIdIn_tmp
        descriptor_oo,                // determined from channelIdOut_tmp
        TgcCoinData::TYPE_HIPT,       // Coincidence type
        rd.subDetectorId() == ASIDE,  // isAside
        idHelper.stationPhi(channelIdOut_tmp),  // phi
        0,                                      // isInner
        rd.isForward(),                         // isForward
        rd.isStrip(),                           // isStrip
        trackletId,                             // trackletId
        hitPos_i.release(), hitPos_o.release(), width_i, width_o,
        delta,  // delta
        hsub,   // hsub
        inner);
    // add the digit to the collection
    newCoinData->setHashAndIndex(coincollection->identifyHash(),
                                 coincollection->size());
    coincollection->push_back(newCoinData);
 
    ATH_MSG_DEBUG("coincollection->push_back done (for HIPT)");
 
    m_nHiPtPRDs++;  // Count the number of output HiPt PRDs.
 
    return StatusCode::SUCCESS;
}
 
StatusCode Muon::TgcRdoToPrepDataToolMT::decodeInner(
    State& state, const TgcRawData& rd) const {
    m_nHiPtRDOs++;  // Count the number of input HiPt RDOs.
 
 
    int subDetectorId = rd.subDetectorId();
    // Protection against invalid subDetectorId and isForward
    if (subDetectorId != ASIDE && subDetectorId != CSIDE) {
        ATH_MSG_DEBUG(
            "TgcRdoToPrepDataToolMT::decodeHiPt::Unknown subDetectorId!!");
        return StatusCode::SUCCESS;
    }
 
    bool isInner = ((rd.sector() & 4) != 0);  // Inner flag for EIFI and Tilecal
 
    Identifier channelIdIn{};
    Identifier channelIdOut{};
    int sswId_o = 9;
    int sbLoc_o = rd.sector() & 3;
    int inner = rd.inner();
    bool isStrip = rd.isStrip();
 
    int phi = 0;
    bool isAside = false;
    bool isEndcap = false;
    if (rd.rodId() < 13) {  // Run2
        state.cabling->getSLIDfromReadoutID(phi, isAside, isEndcap,
                                                  subDetectorId, rd.rodId(),
                                                  sswId_o, sbLoc_o);
    } else {  // Run3
        sbLoc_o = rd.sector();
        state.cabling->getSLIDfromSReadoutID(
            phi, isAside, subDetectorId, rd.rodId(), sbLoc_o, rd.isForward());
        isEndcap = !rd.isForward();
        if (rd.type() == TgcRawData::TYPE_INNER_NSW) {
            isInner = true;
            isStrip = false;
            inner = (rd.nsweta() << Muon::TgcCoinData::INNER_NSW_R_BITSHIFT) +
                    (rd.nswphi() << Muon::TgcCoinData::INNER_NSW_PHI_BITSHIFT) +
                    (rd.nswdtheta()
                     << Muon::TgcCoinData::INNER_NSW_DTHETA_BITSHIFT) +
                    (rd.nswphires()
                     << Muon::TgcCoinData::INNER_NSW_PHIRES_BITSHIFT) +
                    (rd.nswlowres()
                     << Muon::TgcCoinData::INNER_NSW_LOWRES_BITSHIFT) +
                    (rd.nswid() << Muon::TgcCoinData::INNER_NSW_ID_BITSHIFT) +
                    (((rd.nswcand() >> TgcRawData::NSW_BCID_BITSHIFT) &
                      TgcRawData::NSW_BCID_BIT)
                     << Muon::TgcCoinData::INNER_NSW_BCID_BITSHIFT) +
                    (((rd.nswcand() >> TgcRawData::NSW_INPUT_BITSHIFT) &
                      TgcRawData::NSW_INPUT_BIT)
                     << Muon::TgcCoinData::INNER_NSW_INPUT_BITSHIFT);
        } else if (rd.type() == TgcRawData::TYPE_INNER_BIS) {
            isInner = true;
            isStrip = true;
            inner =
                (rd.rpceta() << Muon::TgcCoinData::INNER_RPC_ETA_BITSHIFT) +
                (rd.rpcphi() << Muon::TgcCoinData::INNER_RPC_PHI_BITSHIFT) +
                (rd.rpcdeta() << Muon::TgcCoinData::INNER_RPC_DETA_BITSHIFT) +
                (rd.rpcdphi() << Muon::TgcCoinData::INNER_RPC_DPHI_BITSHIFT) +
                (((rd.rpcflag() >> TgcRawData::RPC_FLAG_BITSHIFT) &
                  TgcRawData::RPC_FLAG_BIT)
                 << Muon::TgcCoinData::INNER_RPC_FLAG_BITSHIFT) +
                (((rd.rpcflag() >> TgcRawData::RPC_BCID_BITSHIFT) &
                  TgcRawData::RPC_BCID_BIT)
                 << Muon::TgcCoinData::INNER_RPC_BCID_BITSHIFT);
        } else if (rd.type() == TgcRawData::TYPE_INNER_EIFI) {
            isInner = false;
            isStrip = false;
            inner = (rd.ei() << Muon::TgcCoinData::INNER_EIFI_EI_BITSHIFT) +
                    (rd.fi() << Muon::TgcCoinData::INNER_EIFI_FI_BITSHIFT) +
                    (rd.cid() << Muon::TgcCoinData::INNER_EIFI_CID_BITSHIFT);
        } else if (rd.type() == TgcRawData::TYPE_INNER_TMDB) {
            isInner = false;
            isStrip = true;
            inner =
                (rd.tmdbmod()
                 << Muon::TgcCoinData::INNER_TILE_MODULE_BITSHIFT) +
                (rd.tmdbbcid() << Muon::TgcCoinData::INNER_TILE_BCID_BITSHIFT);
        }
    }
 
    int locId = (rd.bcTag() == TgcDigit::BC_CURRENT ||
                 rd.bcTag() == TgcDigit::BC_UNDEFINED)
                    ? 1
                    : rd.bcTag() - 1;
 
    auto hitPos_o = std::make_unique<Amg::Vector2D>(Amg::Vector2D::Zero());
    auto hitPos_i = std::make_unique<Amg::Vector2D>(Amg::Vector2D::Zero());
 
    const MuonGM::TgcReadoutElement* descriptor_ii = nullptr;
    const MuonGM::TgcReadoutElement* descriptor_oo = nullptr;
 
    std::string stationName = "T3E";
    int stationEta = isAside ? 1 : -1;
    int stationPhi = phi;
    bool isValid{false};
    Identifier elementId = m_idHelperSvc->tgcIdHelper().elementID(
        stationName, stationEta, stationPhi, isValid);
    const IdentifierHash tgcHashId = m_idHelperSvc->moduleHash(elementId);
 
    std::unique_ptr<Muon::TgcCoinDataCollection>& coincollection =
        state.tgcCoinDataCollections[locId][tgcHashId];
    if (!coincollection) {
        coincollection =
            std::make_unique<Muon::TgcCoinDataCollection>(tgcHashId);
        coincollection->setIdentifier(elementId);
    }
 
    ATH_MSG_DEBUG("Inner Data Word, phi: "
                  << phi << " isAside: " << isAside << " isEndcap: " << isEndcap
                  << " subDetectorId: " << subDetectorId
                  << " isStrip: " << rd.isStrip() << " rodId: " << rd.rodId()
                  << " slbId: " << sbLoc_o << " inner:" << rd.inner());
 
    TgcCoinData* newCoinData = new TgcCoinData(
        channelIdIn,    // empty
        channelIdOut,   // empty
        tgcHashId,      // determined from channelIdOut[1]
        descriptor_ii,  // determined from channelIdIn_tmp
        descriptor_oo,  // determined from channelIdOut_tmp
        (rd.rodId() < 13)
            ? (TgcCoinData::TYPE_HIPT)
            : (TgcCoinData::TYPE_UNKNOWN),  // Coincidence type: rd.rodId()<13
                                            // for Run2, rd.rodId()>12 for Run3
        isAside,                            // isAside
        phi,                                // phi
        isInner,                            // Selection for NSW/BIS/EIFI/TMDB
        !isEndcap,                          // isForward
        isStrip,                            // Selection for NSW/BIS/EIFI/TMDB
        0,                                  // trackletId
        hitPos_i.release(), hitPos_o.release(),
        0.,  // width_i,
        0.,  // width_o,
        0,   // delta,
        0,   // hsub,
        inner);
    // add the digit to the collection
    newCoinData->setHashAndIndex(coincollection->identifyHash(),
                                 coincollection->size());
    coincollection->push_back(newCoinData);
 
    ATH_MSG_DEBUG("coincollection->push_back done (for Inner)");
 
    m_nHiPtPRDs++;  // Count the number of output HiPt PRDs.
 
    return StatusCode::SUCCESS;
}
 
StatusCode Muon::TgcRdoToPrepDataToolMT::decodeSL(State& state,
                                                  const TgcRawData& rd0,
                                                  const TgcRdo* rdoColl) const {
    m_nSLRDOs++;  // Count the number of input SL RDOs.
 
    // conversion for Run3
    uint16_t tmprodId, tmpsector;
    convertToRun2(rd0, tmprodId, tmpsector);
    const TgcRawData rd(rd0.bcTag(), rd0.subDetectorId(), tmprodId, rd0.l1Id(),
                        rd0.bcId(), rd0.isForward(), tmpsector, rd0.innerflag(),
                        rd0.coinflag(), rd0.isMuplus(), rd0.threshold(),
                        rd0.roi());
 
    // Protection against invalid subDetectorId
    if (rd.subDetectorId() != ASIDE && rd.subDetectorId() != CSIDE) {
        ATH_MSG_DEBUG(
            "TgcRdoToPrepDataToolMT::decodeSL::Unknown subDetectorId!!");
        return StatusCode::SUCCESS;
    }
 
    bool found = false;
 
    std::array<Identifier, 3> channelId_wire{};
    int index_w{0}, chip_w{0}, hitId_w{0}, sub_w{0}, sswId_w{0}, sbLoc_w{0},
        subMatrix_w{0};
    std::array<int, 3> bitpos_w{};
 
    //***  get OfflineID, center of ROI of R (wire) ***//
    found = getSLIds(state, false, rd, channelId_wire, index_w, chip_w, hitId_w, sub_w,
                     sswId_w, sbLoc_w, subMatrix_w, bitpos_w);
    if (!found) {
        return StatusCode::SUCCESS;
    }
 
    std::array<Identifier, 3> channelId_strip{};
    int index_s{0}, chip_s{0}, hitId_s{0}, sub_s{0}, sswId_s{0}, sbLoc_s{0},
        subMatrix_s{0};
    std::array<int, 3> bitpos_s{};
 
    //***  get OfflineID, center of ROI of phi (strip) ***//
    found = getSLIds(state, true, rd, channelId_strip, index_s, chip_s, hitId_s, sub_s,
                     sswId_s, sbLoc_s, subMatrix_s, bitpos_s,
                     isIncludedInChamberBoundary(rd), rdoColl, index_w, chip_w,
                     hitId_w, sub_w);
    if (!found) {
        return StatusCode::SUCCESS;
    }
 
    ATH_MSG_DEBUG("TGC RDO->TgcCoindata(SL): "
                  << m_idHelperSvc->toString(channelId_wire[1]));
 
    const IdentifierHash tgcHashId =
        m_idHelperSvc->moduleHash(channelId_wire[1]);
 
    int locId = (rd.bcTag() == TgcDigit::BC_CURRENT ||
                 rd.bcTag() == TgcDigit::BC_UNDEFINED)
                    ? 1
                    : rd.bcTag() - 1;
 
    std::unique_ptr<Muon::TgcCoinDataCollection>& coincollection =
        state.tgcCoinDataCollections[locId][tgcHashId];
    if (!coincollection) {
        coincollection =
            std::make_unique<Muon::TgcCoinDataCollection>(tgcHashId);
        coincollection->setIdentifier(
            m_idHelperSvc->chamberId(channelId_wire[1]));
    }
 
    int trackletId = 2 * sbLoc_w + subMatrix_w;
    int trackletIdStrip = 2 * sbLoc_s + subMatrix_s;
    int roi = static_cast<int>(rd.roi());
    int pt = static_cast<int>(rd.threshold());
    if (rd0.rodId() > 12) {  // Run3:  pT 4 bit, CoinFlag 3 bit, InnerFlag 4 bit
        pt += (static_cast<int>(rd.coinflag()) << 4);
        pt += (static_cast<int>(rd.innerflag()) << 7);
    }
    bool veto = rd.isVeto();
    bool isPositiveDeltaR =
        rd.isMuplus();  // Current SL sets isMuplus flag based on sign of
                        // deltaR. Postive deltaR gives isMuplus=true.
    // check duplicate digits
    for (const TgcCoinData* tgcCoinData : *coincollection) {
        if (TgcCoinData::TYPE_SL == tgcCoinData->type() &&
            channelId_wire[2] == tgcCoinData->identify() &&
            trackletId == tgcCoinData->trackletId() &&
            trackletIdStrip == tgcCoinData->trackletIdStrip() &&
            roi == tgcCoinData->roi() && pt == tgcCoinData->pt() &&
            veto == tgcCoinData->veto() &&
            isPositiveDeltaR == tgcCoinData->isPositiveDeltaR()) {
            ATH_MSG_DEBUG("Duplicated TgcCoinData (SL) = "
                          << m_idHelperSvc->toString(channelId_wire[2]));
            return StatusCode::SUCCESS;
        }
    }
 
    //*** R (wire) start ***//
    double width_w{0.}, tmp_r{0.}, tmp_wire_z{0.};
    found = getSLWireGeometry(channelId_wire, width_w, tmp_r, tmp_wire_z);
    if (!found) {
        return StatusCode::SUCCESS;
    }
    if (width_w < s_cutDropPrdsWithZeroWidth &&
        m_dropPrdsWithZeroWidth) {  // Invalid PRD's whose widths are zero are
                                    // dropped.
        return StatusCode::SUCCESS;
    }
 
    double tmp_eta = 0.;
    bool isGoodEta = getEtafromRZ(tmp_r, tmp_wire_z, tmp_eta);
    if (!isGoodEta) {
        ATH_MSG_WARNING(
            "Conversion from r and z to eta by "
            "Muon::TgcRdoToPrepDataToolMT::getEtafromRZ failed.");
        return StatusCode::SUCCESS;
    }
    if (tmp_wire_z < 0.) {
        tmp_eta *= -1.;
    }
    //*** R (wire) end ***//
 
    //*** Phi (strip) start ***//
    double width_s{0.}, tmp_phi{0.};
    found = getSLStripGeometry(channelId_strip, isBackwardBW(rd),
                               (rd.subDetectorId() == ASIDE), width_s, tmp_phi);
    if (!found) {
        return StatusCode::SUCCESS;
    }
    if (width_s < s_cutDropPrdsWithZeroWidth &&
        m_dropPrdsWithZeroWidth) {  // Invalid PRD's whose widths are zero are
                                    // dropped.
        return StatusCode::SUCCESS;
    }
    //*** Phi (strip) end ***//
    const MuonGM::TgcReadoutElement* descriptor_w2 =
        state.muDetMgr->getTgcReadoutElement(channelId_wire[2]);
    if (!isOfflineIdOKForTgcReadoutElement(descriptor_w2, channelId_wire[2])) {
        return StatusCode::SUCCESS;
    }
 
    Amg::Vector3D tmp_gp(tmp_r * std::cos(tmp_phi), tmp_r * std::sin(tmp_phi),
                         tmp_wire_z);
    Amg::Vector2D tmp_hitPos{Amg::Vector2D::Zero()};
    bool onSurface = descriptor_w2->surface(channelId_wire[2])
                         .globalToLocal(tmp_gp, tmp_gp, tmp_hitPos);
    // If TGC A-lines with rotations are used, the z-coordinate of a chamber
    // depends on position. In this case, the global to local conversion fails.
    // Obtain the local position in a different way.
    const Amg::Vector2D* hitPos = new Amg::Vector2D(!onSurface ? tmp_hitPos
                   : getSLLocalPosition(descriptor_w2, channelId_wire[2],
                                        tmp_eta, tmp_phi));
 
    Amg::MatrixX mat(2, 2);
    mat.setIdentity();
    mat(0, 0) = width_w;
    mat(1, 1) = width_s;
    const Amg::MatrixX* errMat = new Amg::MatrixX(std::move(mat));
 
    // new TgcCoinData
    TgcCoinData* newCoinData = new TgcCoinData(
        channelId_wire[2],
        tgcHashId,                    // determined from channelId_wire[1]
        descriptor_w2,                // determined from channelId_wire[2]
        TgcCoinData::TYPE_SL,         // Coincidence type
        rd.subDetectorId() == ASIDE,  // isAside
        m_idHelperSvc->tgcIdHelper().stationPhi(channelId_wire[2]),  // phi
        rd.isForward(),   // isForward
        trackletId,       // trackletId
        trackletIdStrip,  // trackletIdStrip
        hitPos, errMat,
        roi,                // roi from RDO
        pt,                 // threshold from RDO
        veto,               // veto flag from RDO
        isPositiveDeltaR);  // isMuplus from RDO
 
    // add the digit to the collection
    newCoinData->setHashAndIndex(coincollection->identifyHash(),
                                 coincollection->size());
    coincollection->push_back(newCoinData);
    ATH_MSG_DEBUG("coincollection->push_back done (for SL)");
 
    m_nSLPRDs++;  // Count the number of output SL PRDs.
    return StatusCode::SUCCESS;
}
 
int Muon::TgcRdoToPrepDataToolMT::getbitpos(int channel,
                                            TgcRawData::SlbType slbType) {
    int bitpos = -BIT_POS_INPUT_SIZE + 1;
    if (slbType == TgcRawData::SLB_TYPE_TRIPLET_WIRE) {
        if (channel < 0 || channel >= WT_MAP_SIZE) {
            return -1;  // Invalid channel
        }
 
        if (channel % 3 == 0) {
            bitpos += BIT_POS_C_INPUT_ORIGIN;  // C-Input
        } else if (channel % 3 == 1) {
            bitpos += BIT_POS_B_INPUT_ORIGIN;  // B-Input
        } else {
            bitpos += BIT_POS_A_INPUT_ORIGIN;  // A-Input
        }
        return bitpos + channel / 3;
    } else if (slbType == TgcRawData::SLB_TYPE_TRIPLET_STRIP ||
               slbType == TgcRawData::SLB_TYPE_DOUBLET_STRIP) {
        if (channel < 0 || channel >= ST_MAP_SIZE) {
            return -1;  // Invalid channel, SD_MAP_SIZE is equal to ST_MAP_SIZE.
        }
 
        if (channel % 2 == 0) {
            bitpos += BIT_POS_B_INPUT_ORIGIN;  // B-Input
        } else {
            bitpos += BIT_POS_A_INPUT_ORIGIN;  // A-Input
        }
        return bitpos + channel / 2;
    } else if (slbType == TgcRawData::SLB_TYPE_DOUBLET_WIRE) {
        if (channel < 0 || channel >= WD_MAP_SIZE) {
            return -1;  // Invalid channel
        }
 
        if (channel % 2 == 0) {
            bitpos += BIT_POS_B_INPUT_ORIGIN;  // B-Input
        } else {
            bitpos += BIT_POS_A_INPUT_ORIGIN;  // A-Input
        }
        return bitpos + channel / 2;
    } else {
        return -1;
    }
}
 
int Muon::TgcRdoToPrepDataToolMT::getchannel(int bitpos,
                                             TgcRawData::SlbType slbType) {
    int input = -1;
    if ((bitpos <= BIT_POS_A_INPUT_ORIGIN) &&
        (bitpos > BIT_POS_A_INPUT_ORIGIN - BIT_POS_INPUT_SIZE)) {
        input = 2;  // A-Input
    } else if ((bitpos <= BIT_POS_B_INPUT_ORIGIN) &&
               (bitpos > BIT_POS_B_INPUT_ORIGIN - BIT_POS_INPUT_SIZE)) {
        input = 1;  // B-Input
    } else if ((bitpos <= BIT_POS_C_INPUT_ORIGIN) &&
               (bitpos > BIT_POS_C_INPUT_ORIGIN - BIT_POS_INPUT_SIZE)) {
        input = 0;  // C-Input
    }
    // D-Input is not implemented yet.
    else {
        return -1;  // Invalid bitpos
    }
    if (input == 0 && slbType != TgcRawData::SLB_TYPE_TRIPLET_WIRE) {
        return -1;  // Only Wire Triplet has C-input.
    }
 
    int channel = 1 - BIT_POS_INPUT_SIZE;
    if (slbType == TgcRawData::SLB_TYPE_TRIPLET_WIRE) {
        if (input == 2) {
            channel += BIT_POS_A_INPUT_ORIGIN;  // A-input
        } else if (input == 1) {
            channel += BIT_POS_B_INPUT_ORIGIN;  // B-input
        } else {
            channel += BIT_POS_C_INPUT_ORIGIN;  // C-input
        }
        channel = 3 * (bitpos - channel) + input;
        return channel;  // C(0)->B(1)->A(2)->C(3)->B(4)->A(5)-> ...
                         // ->C(96-3)->B(96-2)->A(96-1)
    } else if (slbType == TgcRawData::SLB_TYPE_TRIPLET_STRIP ||
               slbType == TgcRawData::SLB_TYPE_DOUBLET_WIRE ||
               slbType == TgcRawData::SLB_TYPE_DOUBLET_STRIP) {
        if (input == 2) {
            channel += BIT_POS_A_INPUT_ORIGIN;  // A-input
        } else {
            channel += BIT_POS_B_INPUT_ORIGIN;  // B-input
        }
        channel = 2 * (bitpos - channel) + input - 1;
        return channel;  // B(0)->A(1)->B(2)->A(3)-> ... ->B(64-2)->A(64-1)
    } else {
        return -1;
    }
}
 
bool Muon::TgcRdoToPrepDataToolMT::getRfromEtaZ(const double eta,
                                                const double z, double& r) {
    r = exp(-eta);     // tan(theta/2)
    r = atan(r);       // theta/2
    r = tan(2. * r);   // tan(theta)
    r *= std::abs(z);  // r=|z|*tan(theta)
 
    return r >= 0.;
}
 
bool Muon::TgcRdoToPrepDataToolMT::getEtafromRZ(const double r, const double z,
                                                double& eta) {
    double r_tmp = std::abs(r);
    double z_tmp = std::abs(z);
 
    if ((r_tmp < std::numeric_limits<double>::epsilon()) &&
        (z_tmp < std::numeric_limits<double>::epsilon())) {
        return false;
    }
 
    eta = std::abs(atan2(r_tmp, z_tmp));  // theta
    eta = tan(eta / 2.);                  // tan(theta/2)
    eta = -log(eta);                      // rapidity=-log(tan(theta/2))
    return true;
}
 
bool Muon::TgcRdoToPrepDataToolMT::isOfflineIdOKForTgcReadoutElement(
    const MuonGM::TgcReadoutElement* descriptor,
    const Identifier channelId) const {
    if (!descriptor || !descriptor->containsId(channelId)) {
        ATH_MSG_DEBUG("Illegal OfflineID for TgcReadoutElement"
                      << m_idHelperSvc->toString(channelId));
        return false;
    }
    return true;
}
 
bool Muon::TgcRdoToPrepDataToolMT::getTrackletInfo(const TgcRawData& rd,
                                                   int& tmp_slbId,
                                                   int& tmp_subMatrix,
                                                   int& tmp_position) const {
    tmp_subMatrix = rd.subMatrix();
    if (tmp_subMatrix != 0 && tmp_subMatrix != 1) {
        ATH_MSG_DEBUG("getTrackletInfo: subMatrix " << tmp_subMatrix
                                                    << " is invalid.");
        return false;
    }
 
    int tmp_sswId = rd.sswId();
    tmp_slbId = rd.slbId();
    tmp_position = rd.position();
 
    int tmp_position_delta = tmp_position + rd.delta();
    int tmp_slbType = rd.slbType();
 
    if (tmp_position_delta >= BIT_POS_INPUT_SIZE) {
        tmp_position = tmp_position_delta - BIT_POS_INPUT_SIZE;
        if (tmp_subMatrix == 1) {
            if (tmp_slbType == TgcRawData::SLB_TYPE_DOUBLET_STRIP) {
                tmp_position = BIT_POS_INPUT_SIZE - 1;
                ATH_MSG_DEBUG(
                    "Expected TGC2 Strip position ("
                    << tmp_position_delta
                    << ") does not exist and is changed to the edge position "
                    << tmp_position);
            } else if ((tmp_slbType == TgcRawData::SLB_TYPE_DOUBLET_WIRE) &&
                       (tmp_sswId == 7) &&
                       ((tmp_slbId == 3) || (tmp_slbId == 11))) {
                // upper edge SLB of FWD:sbLoc3,11
                ATH_MSG_DEBUG("sbLoc " << tmp_slbId + 1
                                       << " doesn't exist for FWD!! (upper "
                                          "edge SLB of FWD:sbLoc3,11)");
                return false;
            } else if ((tmp_slbType == TgcRawData::SLB_TYPE_DOUBLET_WIRE) &&
                       (tmp_sswId != 7) && (tmp_slbId == 9)) {
                // upper edge SLB of EWD:sbLoc9
                ATH_MSG_DEBUG("sbLoc " << tmp_slbId + 1
                                       << " doesn't exist for EWD!! (upper "
                                          "edge SLB of EWD:sbLoc9)");
                return false;
            } else {
                // Valid sbLoc,delta,blockpos
                tmp_subMatrix = 0;
                tmp_slbId++;
            }
        } else {
            tmp_subMatrix = 1;
        }
    } else if (tmp_position_delta < 0) {
        tmp_position = tmp_position_delta + BIT_POS_INPUT_SIZE;
        if (tmp_subMatrix == 0) {
            if (tmp_slbType == TgcRawData::SLB_TYPE_DOUBLET_STRIP) {
                tmp_position = 0;
                ATH_MSG_DEBUG(
                    "Expected TGC2 Strip position ("
                    << tmp_position_delta
                    << ") does not exist and is changed to the edge position "
                    << tmp_position);
            } else if ((tmp_slbType == TgcRawData::SLB_TYPE_DOUBLET_WIRE) &&
                       (tmp_sswId == 7) &&
                       ((tmp_slbId == 0) || (tmp_slbId == 8))) {
                // bottom edge SLB of FWD:sbLoc0,8
                if (tmp_position_delta == -1) {  // This case is valid.
                    tmp_position = 0;
                } else {
                    ATH_MSG_DEBUG("sbLoc "
                                  << tmp_slbId - 1
                                  << " doesn't exist for FWD!! (bottom edge "
                                     "SLB of FWD:sbLoc0,8)");
                    return false;
                }
            } else if ((tmp_slbType == TgcRawData::SLB_TYPE_DOUBLET_WIRE) &&
                       (tmp_sswId != 7) && (tmp_slbId == 0)) {
                // bottom edge SLB of EWD:sbLoc0
                if (tmp_position_delta == -1) {  // This case is valid.
                    tmp_position = 0;
                } else {
                    ATH_MSG_DEBUG("sbLoc "
                                  << tmp_slbId - 1
                                  << " doesn't exist for EWD!! (bottom edge "
                                     "SLB of EWD:sbLoc0)");
                    return false;
                }
            } else {
                // Valid sbLoc,delta,
                tmp_subMatrix = 1;
                tmp_slbId--;
            }
        } else {
            tmp_subMatrix = 0;
        }
    } else {
        tmp_position = tmp_position_delta;
    }
 
    return true;
}
 
int Muon::TgcRdoToPrepDataToolMT::getRoiRow(const TgcRawData& rd) {
    int RoiRow = static_cast<int>(rd.roi() / 4);
    return RoiRow;
}
 
bool Muon::TgcRdoToPrepDataToolMT::isIncludedInChamberBoundary(
    const TgcRawData& rd) const {
    int RoiRow = getRoiRow(rd);
 
    if (!rd.isForward() &&
        (RoiRow == 3 || RoiRow == 4 ||    // SSC 2 : ROI 12-19
         RoiRow == 7 || RoiRow == 8 ||    // SSC 4 : ROI 28-35
         RoiRow == 11 || RoiRow == 12 ||  // SSC 6 : ROI 44-51
         RoiRow == 23 || RoiRow == 24     // SSC12 : ROI 92-99
         )) {
        return true;
    }
    return false;
}
 
void Muon::TgcRdoToPrepDataToolMT::getBitPosOutWire(
    const TgcRawData& rd, int& slbsubMatrix, std::array<int, 2>& bitpos_o) {
    // This method is used by decodeHiPt
    if ((rd.hitId() % 2) == 1) {  // 1,3,5
        slbsubMatrix = 0;
        if ((rd.hsub()) == 0) {
            bitpos_o[0] = BIT_POS_B_INPUT_LARGE_R_CH15;  //  78
            bitpos_o[1] = BIT_POS_A_INPUT_LARGE_R_CH08;  //  49
        } else if ((rd.hsub()) == 1) {
            bitpos_o[0] = BIT_POS_B_INPUT_LARGE_R_CH07;  //  86
            bitpos_o[1] = BIT_POS_A_INPUT_LARGE_R_CH00;  //  57
        }
    } else {  // 2,4,6
        slbsubMatrix = 1;
        if ((rd.hsub()) == 0) {
            bitpos_o[0] = BIT_POS_B_INPUT_SMALL_R_CH15;  //  94
            bitpos_o[1] = BIT_POS_A_INPUT_SMALL_R_CH08;  //  65
        } else if ((rd.hsub()) == 1) {
            bitpos_o[0] = BIT_POS_B_INPUT_SMALL_R_CH07;  // 102
            bitpos_o[1] = BIT_POS_A_INPUT_SMALL_R_CH00;  //  73
        }
    }
 
    // In case of WIRE, there are no bit assign.(EWD0 EWD4 FWD0
    // FWD1)----------------------------- EWD0 sbLoc = 0     bitpos = 102 : does
    // not exist and has 6 channels only (the largest  R, RoiRow== 0). EWD4
    // sbLoc = 9     bitpos =  73 : does not exist and has 4 channels only (the
    // smallest R, RoiRow==36). FWD0 sbLoc = 0, 8  bitpos =  78 : does not exist
    // and has 5 channels only (the largest  R, RoiRow== 0). FWD1 sbLoc = 3, 11
    // bitpos =  73 : does not exist and has 5 channels only (the smallest R,
    // RoiTow==15). fixed it by following description.
    if (!rd.isForward()) {  // Endcap
        if ((rd.chip() == 0) && (rd.hitId() == 1) && (rd.hsub() == 1)) {
            // chip 0 should have these values and means EWD0's position.
            slbsubMatrix = 1;
            bitpos_o[0] = BIT_POS_B_INPUT_SMALL_R_CH05;  // 104
            bitpos_o[1] = BIT_POS_A_INPUT_SMALL_R_CH00;  //  73
        } else if ((rd.chip() == 3) && (rd.hitId() == 6) &&
                   (rd.hsub() == 1)) {                   // EWD4's position
            bitpos_o[0] = BIT_POS_B_INPUT_SMALL_R_CH07;  // 102
            bitpos_o[1] = BIT_POS_A_INPUT_SMALL_R_CH04;  //  69
        }
    } else {  // Forward
        if ((rd.chip() == 0) && (rd.hitId() == 1) &&
            (rd.hsub() == 0)) {                          // FWD0
            bitpos_o[0] = BIT_POS_B_INPUT_LARGE_R_CH12;  //  81
            bitpos_o[1] = BIT_POS_A_INPUT_LARGE_R_CH08;  //  49
        } else if ((rd.chip() == 1) && (rd.hitId() == 2) &&
                   (rd.hsub() == 1)) {                   // FWD1
            bitpos_o[0] = BIT_POS_B_INPUT_SMALL_R_CH07;  // 102
            bitpos_o[1] = BIT_POS_A_INPUT_SMALL_R_CH03;  //  70
        }
    }  // end of Forward
    // end of fixed------------------------------------------------
}
 
void Muon::TgcRdoToPrepDataToolMT::getBitPosInWire(
    const TgcRawData& rd, const int deltaBeforeConvert,
    std::array<int, 4>& bitpos_i, std::array<int, 4>& slbchannel_i,
    std::array<int, 4>& slbId_in, std::array<int, 4>& sbLoc_in, int& sswId_i,
    const std::array<int, 2>& bitpos_o, std::array<int, 2>& slbchannel_o,
    const int slbId_o) const {
    // This method is used by decodeHiPt
    const int NUM_SLBID_SBLOC_OFFSET_WT =
        8;  // (see
            // https://twiki.cern.ch/twiki/pub/Main/TgcDocument/sbloc-070701.xls)
 
    /*** get bitpos for TGC1 Station ***/
 
    int rdochIn_max = 0;
    int rdochIn_min = 0;
    int offset_dt = 0;
    if (!rd.isForward()) {  // EWT
        rdochIn_max = 665;
        rdochIn_min = 78;
        offset_dt = 32;
    } else {  // FWT
        rdochIn_max = 312;
        rdochIn_min = 0;
        offset_dt = 0;
    }
 
    int tmp_rdochannel_i = 0;
    int tmp_rdochannel_i2 = 0;
    for (int i = 0; i < 2; i++) {
        slbchannel_o[i] =
            getchannel(bitpos_o[i], TgcRawData::SLB_TYPE_DOUBLET_WIRE);
        tmp_rdochannel_i = WD_MAP_SIZE * slbId_o + slbchannel_o[i] +
                           deltaBeforeConvert + offset_dt;
        if (tmp_rdochannel_i > rdochIn_max) {
            tmp_rdochannel_i = rdochIn_max;
        } else if (tmp_rdochannel_i < rdochIn_min) {
            tmp_rdochannel_i = rdochIn_min;
        }
 
        //                               Large R <-----------------> Small R
        // tmp_rdochannel_i           :  0  1  2  3  4  5  6  7  8  9 10 ...
        //-------------------------------------------------------------------
        // tmp_rdochannel_i/3         :  0  0  0  1  1  1  2  2  2  3  3 ...
        // (tmp_rdochannel_i/3)*3     :  0  0  0  3  3  3  6  6  6  9  9 ...
        // tmp_rdochannel_i2 (i==0)   :  2  2  2  5  5  5  8  8  8 11 11 ...
        //-------------------------------------------------------------------
        // tmp_rdochannel_i+1         :  1  2  3  4  5  6  7  8  9 10 11 ...
        // (tmp_rdochannel_i+1)/3     :  0  0  1  1  1  2  2  2  3  3  3 ...
        // ((tmp_rdochannel_i+1)/3)*3 :  0  0  3  3  3  6  6  6  9  9  9 ...
        // tmp_rdochannel_i2 (i==1)   : -1 -1  2  2  2  5  5  5  8  8  8 ...
 
        if (i == 0) {  // get the lower R channel on L3 nearest from bitpos_o[0]
            tmp_rdochannel_i2 = (tmp_rdochannel_i / 3) * 3 + 2;
        } else {  // get the higher R channel on L3 nearest from bitpos_o[1]
            tmp_rdochannel_i2 = ((tmp_rdochannel_i + 1) / 3) * 3 - 1;
        }
 
        if (tmp_rdochannel_i2 > rdochIn_max) {
            tmp_rdochannel_i2 = rdochIn_max;
        } else if (tmp_rdochannel_i2 < rdochIn_min) {
            tmp_rdochannel_i2 = rdochIn_min + 2;  // 2 is added for L3
        }
 
        slbId_in[i] = tmp_rdochannel_i / WT_MAP_SIZE;
        slbId_in[i + 2] = tmp_rdochannel_i2 / WT_MAP_SIZE;
 
        sbLoc_in[i] = slbId_in[i];
        sbLoc_in[i + 2] = slbId_in[i + 2];
        if (rd.sector() % 2 == 1) {
            // phi1 and phi3 have offset (see
            // https://twiki.cern.ch/twiki/pub/Main/TgcDocument/sbloc-070701.xls)
            // Endcap sector=1, 3 are phi1 and phi3, and Forward sector=1 is
            // phi2.
            sbLoc_in[i] += NUM_SLBID_SBLOC_OFFSET_WT;
            sbLoc_in[i + 2] += NUM_SLBID_SBLOC_OFFSET_WT;
        }
 
        slbchannel_i[i] = tmp_rdochannel_i % WT_MAP_SIZE;
        slbchannel_i[i + 2] = tmp_rdochannel_i2 % WT_MAP_SIZE;
 
        bitpos_i[i] =
            getbitpos(slbchannel_i[i], TgcRawData::SLB_TYPE_TRIPLET_WIRE);
        bitpos_i[i + 2] =
            getbitpos(slbchannel_i[i + 2], TgcRawData::SLB_TYPE_TRIPLET_WIRE);
    }
 
    if (!rd.isForward()) {  // EWT
        sswId_i = static_cast<int>(rd.sector() / 2);
    } else {  // FWT
        sswId_i = 2;
    }
}
 
void Muon::TgcRdoToPrepDataToolMT::getBitPosOutStrip(
    const TgcRawData& rd, int& slbsubMatrix, std::array<int, 2>& bitpos_o) {
    // This method is used by decodeHiPt
    if ((rd.hitId() % 2) == 1) {  // 1,3,5::hitId:1-6 for EC, 2-3 for Fw
        slbsubMatrix = 0;
        if ((rd.hsub()) == 0) {
            bitpos_o[0] =
                BIT_POS_B_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH15;  //  78
            bitpos_o[1] =
                BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH08;  //  49
        } else if ((rd.hsub()) == 1) {
            bitpos_o[0] =
                BIT_POS_B_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH07;  //  86
            bitpos_o[1] =
                BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH00;  //  57
        }
    } else {  // 2,4,6
        slbsubMatrix = 1;
        if ((rd.hsub()) == 0) {
            bitpos_o[0] =
                BIT_POS_B_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH15;  //  94
            bitpos_o[1] =
                BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH08;  //  65
        } else if ((rd.hsub()) == 1) {
            bitpos_o[0] =
                BIT_POS_B_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH07;  // 102
            bitpos_o[1] =
                BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH00;  //  73
        }
    }
}
 
void Muon::TgcRdoToPrepDataToolMT::getBitPosInStrip(
    const TgcRawData& rd, const int deltaBeforeConvert,
    std::array<int, 4>& bitpos_i, std::array<int, 4>& slbchannel_i,
    int& sbLoc_i, int& sswId_i, const std::array<int, 2>& bitpos_o,
    std::array<int, 2>& slbchannel_o) const {
    // This method is used by decodeHiPt
    //*** get bitpos for TGC1 Station ***//
    // ST
    int rdochIn_max = ST_MAP_SIZE - 1;
    int rdochIn_min = 0;
 
    if ((rd.sector() % 2) == 0) {
        if (rd.chip() == 0) {
            sbLoc_i = 16;  // EST0 (phi0 and phi2) or FST0 (phi0)
        } else if (rd.chip() == 1) {
            sbLoc_i = 17;  // EST1 (phi0 and phi2)
        }
    } else {
        if (rd.chip() == 0) {
            sbLoc_i = 24;  // EST0 (phi1 and phi3) or FST0 (phi2)
        } else if (rd.chip() == 1) {
            sbLoc_i = 25;  // EST1 (phi1 and phi3)
        }
    }
 
    for (int i = 0; i < 2; i++) {
        slbchannel_o[i] =
            getchannel(bitpos_o[i], TgcRawData::SLB_TYPE_DOUBLET_STRIP);
        slbchannel_i[i] = slbchannel_o[i] + deltaBeforeConvert;
        if (slbchannel_i[i] > rdochIn_max) {
            slbchannel_i[i] = rdochIn_max;
        } else if (slbchannel_i[i] < rdochIn_min) {
            slbchannel_i[i] = rdochIn_min;
        }
 
        if (i == 0) {
            slbchannel_i[i + 2] = slbchannel_i[i] + 1;
        } else {
            slbchannel_i[i + 2] = slbchannel_i[i] - 1;
        }
 
        if (slbchannel_i[i + 2] > rdochIn_max) {
            slbchannel_i[i + 2] = rdochIn_max;
        } else if (slbchannel_i[i + 2] < rdochIn_min) {
            slbchannel_i[i + 2] = rdochIn_min;
        }
 
        bitpos_i[i] =
            getbitpos(slbchannel_i[i], TgcRawData::SLB_TYPE_TRIPLET_STRIP);
        bitpos_i[i + 2] =
            getbitpos(slbchannel_i[i + 2], TgcRawData::SLB_TYPE_TRIPLET_STRIP);
    }
 
    if (!rd.isForward()) {  // EST
        sswId_i = static_cast<int>(rd.sector() / 2);
    } else {  // FST
        sswId_i = 2;
    }
}
 
void Muon::TgcRdoToPrepDataToolMT::getBitPosWire(
    const TgcRawData& rd, const int hitId_w, const int sub_w, int& subMatrix_w,
    std::array<int, 3>& bitpos_w) const {
    // This method is used by getSLIds
    // This method assumes sub_w is 0 or 1.
    // Protection for other possibility is needed.
 
    // 0 : Index for the largest R channel
    // 1 : Index for the smallest R channel
    // 2 : Index for the "center" channel
 
    int RoiRow = getRoiRow(rd);
    bool isForward = rd.isForward();
 
    if (RoiRow == 0 && !isForward) {  // EWD0,SLB0 exception (It has 6 channels
                                      // only, the largest R)
        subMatrix_w = 1;
        bitpos_w[0] = BIT_POS_B_INPUT_SMALL_R_CH05;  // 104
        bitpos_w[1] = BIT_POS_A_INPUT_SMALL_R_CH04;  //  69
        bitpos_w[2] = BIT_POS_A_INPUT_SMALL_R_CH00;  //  73
    } else if (RoiRow == 36 && !isForward) {  // EWD4,SLB1 exception (It has 4
                                              // channels only, the smallest R)
        subMatrix_w = 1;
        bitpos_w[0] = BIT_POS_B_INPUT_SMALL_R_CH07;  // 102
        bitpos_w[1] = BIT_POS_A_INPUT_SMALL_R_CH04;  //  69
        bitpos_w[2] = BIT_POS_A_INPUT_SMALL_R_CH04;  //  69
    } else if (RoiRow == 0 && isForward) {  // FWD0,SLB0 exception (It has 5
                                            // channels only, the largest R)
        subMatrix_w = 0;
        bitpos_w[0] = BIT_POS_B_INPUT_LARGE_R_CH12;  //  81
        bitpos_w[1] = BIT_POS_A_INPUT_LARGE_R_CH12;  //  45
        bitpos_w[2] = BIT_POS_A_INPUT_LARGE_R_CH08;  //  49
    } else if (RoiRow == 15 && isForward) {  // FWD1,SLB1 exception (It has 5
                                             // channels only, the smallest R)
        subMatrix_w = 1;
        bitpos_w[0] = BIT_POS_B_INPUT_SMALL_R_CH07;  // 102
        bitpos_w[1] = BIT_POS_A_INPUT_SMALL_R_CH04;  //  69
        bitpos_w[2] = BIT_POS_A_INPUT_SMALL_R_CH03;  //  70
    } else {
        if ((hitId_w % 2) == 0) {  // 0, 2, 4
            subMatrix_w = 0;
            if (sub_w == 0) {
                bitpos_w[0] = BIT_POS_B_INPUT_LARGE_R_CH15;  //  78
                bitpos_w[1] = BIT_POS_A_INPUT_LARGE_R_CH12;  //  45
                bitpos_w[2] = BIT_POS_A_INPUT_LARGE_R_CH08;  //  49
            } else if (sub_w == 1) {
                bitpos_w[0] = BIT_POS_B_INPUT_LARGE_R_CH07;  //  86
                bitpos_w[1] = BIT_POS_A_INPUT_LARGE_R_CH04;  //  53
                bitpos_w[2] = BIT_POS_A_INPUT_LARGE_R_CH00;  //  57
            }
        } else {  // 1, 3, 5
            subMatrix_w = 1;
            if (sub_w == 0) {
                bitpos_w[0] = BIT_POS_B_INPUT_SMALL_R_CH15;  //  94
                bitpos_w[1] = BIT_POS_A_INPUT_SMALL_R_CH12;  //  61
                bitpos_w[2] = BIT_POS_A_INPUT_SMALL_R_CH08;  //  65
            } else if (sub_w == 1) {
                bitpos_w[0] = BIT_POS_B_INPUT_SMALL_R_CH07;  // 102
                bitpos_w[1] = BIT_POS_A_INPUT_SMALL_R_CH04;  //  69
                bitpos_w[2] = BIT_POS_A_INPUT_SMALL_R_CH00;  //  73
            }
        }
    }
}
 
void Muon::TgcRdoToPrepDataToolMT::getBitPosStrip(
    const int hitId_s, const int sub_s, int& subMatrix_s,
    std::array<int, 3>& bitpos_s) {
    // This method is used by getSLIds
    // 0 : Index for the largest phi (for A-side forward and C-side backward)
    // channel 1 : Index for the smallest phi (for A-side forward and C-side
    // backward) channel 2 : Index for the "center" channel
 
    if ((hitId_s % 2) == 0) {  // 0, 2, 4
        subMatrix_s = 0;
        if (sub_s == 0) {
            bitpos_s[0] =
                BIT_POS_B_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH15;  //  78
            bitpos_s[1] =
                BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH12;  //  45
            bitpos_s[2] =
                BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH08;  //  49
        } else if (sub_s == 1) {
            bitpos_s[0] =
                BIT_POS_B_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH07;  //  86
            bitpos_s[1] =
                BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH04;  //  53
            bitpos_s[2] =
                BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH00;  //  57
        }
    } else if ((hitId_s % 2) == 1) {  // 1, 3, 5
        subMatrix_s = 1;
        if (sub_s == 0) {
            bitpos_s[0] =
                BIT_POS_B_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH15;  //  94
            bitpos_s[1] =
                BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH12;  //  61
            bitpos_s[2] =
                BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH08;  //  65
        } else if (sub_s == 1) {
            bitpos_s[0] =
                BIT_POS_B_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH07;  // 102
            bitpos_s[1] =
                BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH04;  //  69
            bitpos_s[2] =
                BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH00;  //  73
        }
    }
}
 
int Muon::TgcRdoToPrepDataToolMT::getDeltaBeforeConvert(const TgcRawData& rd) {
    int deltaBeforeConvert = 0;
 
    if (rd.isStrip()) {  // strip
        switch (rd.delta()) {
            case 5:
                deltaBeforeConvert = 6;
                break;
            case 6:
                deltaBeforeConvert = 8;
                break;
            case 7:
                deltaBeforeConvert = 10;
                break;
            case -4:
                deltaBeforeConvert = -5;
                break;
            case -5:
                deltaBeforeConvert = -7;
                break;
            case -6:
                deltaBeforeConvert = -9;
                break;
            case -7:
                deltaBeforeConvert = -12;
                break;
            default:
                deltaBeforeConvert = rd.delta();
                break;
        }
    } else {  // wire
        switch (rd.delta()) {
            case 11:
                deltaBeforeConvert = 12;
                break;
            case 12:
                deltaBeforeConvert = 14;
                break;
            case 13:
                deltaBeforeConvert = 16;
                break;
            case 14:
                deltaBeforeConvert = 18;
                break;
            case 15:
                deltaBeforeConvert = 20;
                break;
            case -12:
                deltaBeforeConvert = -13;
                break;
            case -13:
                deltaBeforeConvert = -15;
                break;
            case -14:
                deltaBeforeConvert = -17;
                break;
            case -15:
                deltaBeforeConvert = -19;
                break;
            default:
                deltaBeforeConvert = rd.delta();
                break;
        }
    }
 
    return deltaBeforeConvert;
}
 
bool Muon::TgcRdoToPrepDataToolMT::isBackwardBW(const TgcRawData& rd) {
    bool isBackward = false;
 
    if (!rd.isForward()) {  // Endcap
        if (((rd.subDetectorId() == ASIDE) && (rd.sector() % 2 == 1)) ||
            ((rd.subDetectorId() == CSIDE) && (rd.sector() % 2 == 0))) {
            // Aside,phi_odd::Backward
            // Cside,phi_even::Backward
            isBackward = true;
        } else {
            // Aside,phi_even::Forward
            // Cside,phi_odd::Forward
            isBackward = false;
        }
    } else {  // Forward
        // Aide::Backward
        // Cside::Forward
        isBackward = (rd.subDetectorId() == ASIDE);
    }
 
    return isBackward;
}
 
bool Muon::TgcRdoToPrepDataToolMT::getSLWireGeometry(
    const std::array<Identifier, 3>& channelId_wire, double& width_wire,
    double& r_wire, double& z_wire) const {
    SG::ReadCondHandle<MuonGM::MuonDetectorManager> muDetMgrHandle{
        m_muDetMgrKey};
    const MuonGM::MuonDetectorManager* muDetMgr = muDetMgrHandle.cptr();
    std::array<const MuonGM::TgcReadoutElement*, 3> descriptor_w{
        muDetMgr->getTgcReadoutElement(channelId_wire[0]),
        muDetMgr->getTgcReadoutElement(channelId_wire[1]),
        muDetMgr->getTgcReadoutElement(channelId_wire[2])};
    for (int i = 0; i < 3; i++) {
        if (!isOfflineIdOKForTgcReadoutElement(descriptor_w[i],
                                               channelId_wire[i])) {
            return false;
        }
    }
 
    Amg::Vector3D position_w = descriptor_w[2]->channelPos(channelId_wire[2]);
    Amg::Vector2D loc_hitPos_w{Amg::Vector2D::Zero()};
    bool onSurface_w = descriptor_w[2]
                           ->surface(channelId_wire[2])
                           .globalToLocal(position_w, position_w, loc_hitPos_w);
    if (!onSurface_w) {
        ATH_MSG_WARNING(
            "Muon::TgcRdoToPrepDataToolMT::getSLWireGeometry Amg::Vector2D* "
            "loc_hitPos_w is null.");
        return false;
    }
    Amg::Vector2D tmp_hitPos_w{Amg::Vector2D::Zero()};
 
    std::array<int, 3> gasGap_w{}, channel_w{};
    for (int i = 0; i < 3; i++) {
        gasGap_w[i] = m_idHelperSvc->tgcIdHelper().gasGap(channelId_wire[i]);
        channel_w[i] = m_idHelperSvc->tgcIdHelper().channel(channelId_wire[i]);
    }
 
    std::array<double, 3> tmp_r_w{}, tmp_phi_w{}, tmp_eta_w{};
 
    std::array<Amg::Vector3D, 3> tmp_position_w{
        make_array<Amg::Vector3D, 3>(Amg::Vector3D::Zero())};
    for (int i = 0; i < 3; i += 2) {  // i=0 and 2
        tmp_position_w[i] = descriptor_w[i]->channelPos(channelId_wire[i]);
        tmp_r_w[i] = tmp_position_w[i].perp();
        tmp_phi_w[i] = tmp_position_w[i].phi();
        tmp_eta_w[i] = tmp_position_w[i].eta();
 
        double half_width =
            descriptor_w[i]->gangRadialLength(gasGap_w[i], channel_w[i]) / 2.;
        if (half_width < s_cutDropPrdsWithZeroWidth / 2. &&
            m_dropPrdsWithZeroWidth) {  // Invalid PRD's whose widths are zero
                                        // are dropped.
            return false;
        }
        // add half widths of edge channels
        if (i == 0) {
            tmp_r_w[0] += half_width;
        } else if (i == 2) {
            tmp_r_w[2] -= half_width;
        }
    }
 
    bool flag_geteta_w =
        getEtafromRZ(tmp_r_w[0], tmp_position_w[0].z(), tmp_eta_w[0]);
    bool flag_getr_w =
        getRfromEtaZ(tmp_eta_w[0], tmp_position_w[2].z(), tmp_r_w[0]);
    if (!flag_geteta_w || !flag_getr_w) {
        ATH_MSG_DEBUG(
            "TgcRdoToPrepDataToolMT::getSLWireGeometry::failed to getR on "
            "L7!!");
        return false;
    }
    width_wire = tmp_r_w[0] - tmp_r_w[2];
    double gang = descriptor_w[2]->gangShortWidth(gasGap_w[2], channel_w[2]) +
                  width_wire / 2.;
    tmp_hitPos_w[Trk::locX] = gang;
    tmp_hitPos_w[Trk::locY] = ((loc_hitPos_w)[Trk::loc2]);
 
    Amg::Vector3D tmp_wire_gp;
    descriptor_w[2]
        ->surface(channelId_wire[2])
        .localToGlobal(tmp_hitPos_w, tmp_wire_gp, tmp_wire_gp);
    z_wire = tmp_wire_gp.z();
    r_wire = tmp_r_w[2] + width_wire / 2.;
 
    return true;
}
 
bool Muon::TgcRdoToPrepDataToolMT::getSLStripGeometry(
    const std::array<Identifier, 3>& channelId_strip, const bool isBackward,
    const bool isAside, double& width_strip, double& theta_strip) const {
    SG::ReadCondHandle<MuonGM::MuonDetectorManager> muDetMgrHandle{
        m_muDetMgrKey};
    const MuonGM::MuonDetectorManager* muDetMgr = muDetMgrHandle.cptr();
    std::array<const MuonGM::TgcReadoutElement*, 3> descriptor_s{
        muDetMgr->getTgcReadoutElement(channelId_strip[0]),
        muDetMgr->getTgcReadoutElement(channelId_strip[1]),
        muDetMgr->getTgcReadoutElement(channelId_strip[2])};
    for (int i = 0; i < 3; i++) {
        if (!isOfflineIdOKForTgcReadoutElement(descriptor_s[i],
                                               channelId_strip[i])) {
            return false;
        }
    }
 
    Amg::Vector3D position_s =
        Amg::Vector3D(descriptor_s[1]->channelPos(channelId_strip[1]));
    Amg::Vector2D loc_hitPos_s;
    bool onSurface_s = descriptor_s[1]
                           ->surface(channelId_strip[1])
                           .globalToLocal(position_s, position_s, loc_hitPos_s);
    if (!onSurface_s) {
        ATH_MSG_WARNING(
            "Muon::TgcRdoToPrepDataToolMT::getSLStripGeometry Amg::Vector2D* "
            "loc_hitPos_s is null.");
        return false;
    }
    Amg::Vector2D tmp_hitPos_s{Amg::Vector2D::Zero()};
 
    std::array<int, 3> gasGap_s, channel_s{};
    for (int i = 0; i < 3; i++) {
        gasGap_s[i] = m_idHelperSvc->tgcIdHelper().gasGap(channelId_strip[i]);
        channel_s[i] = m_idHelperSvc->tgcIdHelper().channel(channelId_strip[i]);
    }
 
    std::array<Amg::Vector3D, 3> localPos{Amg::Vector3D::Zero()};
    for (int i = 0; i < 3; i += 2) {  // i=0 and 2
        localPos[i] = descriptor_s[i]->transform(channelId_strip[i]).inverse() *
                      descriptor_s[i]->channelPos(channelId_strip[i]);
    }
 
    bool flag_reverse = false;
    std::array<int, 2> index_strip{};
 
    if (!isBackward) {  // Forward chamber
        if (isAside) {  // Aside/Forward Chamber
            index_strip[0] = 2;
            index_strip[1] = 0;
            flag_reverse = true;
        } else {  // Cside/Forward Chamber
            index_strip[0] = 0;
            index_strip[1] = 2;
            flag_reverse = false;
        }
    } else {            // Backward chamber
        if (isAside) {  // Aside/Backward Chamber
            index_strip[0] = 0;
            index_strip[1] = 2;
            flag_reverse = true;
        } else {  // Cside/Backward Chamber
            index_strip[0] = 2;
            index_strip[1] = 0;
            flag_reverse = false;
        }
    }
 
    double stripMaxX = descriptor_s[index_strip[0]]->stripHighEdgeLocX(
        gasGap_s[index_strip[0]], channel_s[index_strip[0]],
        localPos[index_strip[0]].z());
    double stripMinX = descriptor_s[index_strip[1]]->stripLowEdgeLocX(
        gasGap_s[index_strip[1]], channel_s[index_strip[1]],
        localPos[index_strip[1]].z());
    width_strip = stripMaxX - stripMinX;
    double strip = stripMinX + width_strip / 2.;
    if (flag_reverse) {
        strip *= -1.;
    }
 
    tmp_hitPos_s[Trk::locX] = strip;
    tmp_hitPos_s[Trk::locY] = loc_hitPos_s[Trk::loc2];
 
    int index_strip_gp = 0;
    if (!isBackward) {
        index_strip_gp = 0;
    } else {
        index_strip_gp = 2;
    }
    Amg::Vector3D tmp_strip_gp;
    descriptor_s[index_strip_gp]
        ->surface(channelId_strip[index_strip_gp])
        .localToGlobal(tmp_hitPos_s, tmp_strip_gp, tmp_strip_gp);
    theta_strip = atan2(tmp_strip_gp.y(), tmp_strip_gp.x());
 
    return true;
}
 
bool Muon::TgcRdoToPrepDataToolMT::getPosAndIdWireOut(
    const std::array<const MuonGM::TgcReadoutElement*, 2>& descriptor_o,
    const std::array<Identifier, 2>& channelIdOut,
    const std::array<int, 2>& gasGap_o, const std::array<int, 2>& channel_o,
    double& width_o, double& hit_position_o, Amg::Vector2D& tmp_hitPos_o,
    Identifier& channelIdOut_tmp) const {
    // This method is used by decodeHiPt
    std::array<Amg::Vector3D, 2> position_o{
        make_array<Amg::Vector3D, 2>(Amg::Vector3D::Zero())};
    std::array<double, 2> tmp_phi_o{}, tmp_eta_o{}, tmp_r_o{};
 
    for (int i = 0; i < 2; i++) {
        position_o[i] = descriptor_o[i]->channelPos(channelIdOut[i]);
        tmp_r_o[i] = position_o[i].perp();
        tmp_phi_o[i] = position_o[i].phi();
        tmp_eta_o[i] = position_o[i].phi();
        // add half widths of edge channels
        double half_width =
            descriptor_o[i]->gangRadialLength(gasGap_o[i], channel_o[i]) / 2.;
        if (half_width < s_cutDropPrdsWithZeroWidth / 2. &&
            m_dropPrdsWithZeroWidth) {  // Invalid PRD's whose widths are zero
                                        // are dropped.
            return false;
        }
        if (i == 0) {
            tmp_r_o[0] += half_width;
        } else {
            tmp_r_o[1] -= half_width;
        }
    }
 
    bool flag_geteta_o =
        getEtafromRZ(tmp_r_o[0], position_o[0].z(), tmp_eta_o[0]);
    bool flag_getr_o =
        getRfromEtaZ(tmp_eta_o[0], position_o[1].z(), tmp_r_o[0]);
    if (!flag_geteta_o || !flag_getr_o) {
        ATH_MSG_DEBUG(
            "TgcRdoToPrepDataToolMT::getPosAndIdWireOut::failed to getR on "
            "L7!!");
        return false;
    }
 
    width_o = tmp_r_o[0] - tmp_r_o[1];
    // X-coordinate
    hit_position_o =
        descriptor_o[1]->gangShortWidth(gasGap_o[1], channel_o[1]) +
        width_o / 2;
    tmp_hitPos_o[Trk::locX] = (hit_position_o);
    // Y-coordinate
    Amg::Vector3D position_out =
        Amg::Vector3D(descriptor_o[1]->channelPos(channelIdOut[1]));
    // dummy global pos
    Amg::Vector2D loc_hitPos_o;
    bool onSurface_o =
        descriptor_o[1]
            ->surface(channelIdOut[1])
            .globalToLocal(position_out, position_out, loc_hitPos_o);
    if (!onSurface_o) {
        ATH_MSG_WARNING(
            "Muon::TgcRdoToPrepDataToolMT::getPosAndIdWireOut Amg::Vector2D* "
            "loc_hitPos_o is null.");
        return false;
    }
    tmp_hitPos_o[Trk::locY] = loc_hitPos_o[Trk::loc2];
 
    channelIdOut_tmp = channelIdOut[1];
 
    return true;
}
 
bool Muon::TgcRdoToPrepDataToolMT::getPosAndIdStripOut(
    const std::array<const MuonGM::TgcReadoutElement*, 2>& descriptor_o,
    const std::array<Identifier, 2>& channelIdOut,
    const std::array<int, 2>& gasGap_o, const std::array<int, 2>& channel_o,
    double& width_o, double& hit_position_o, Amg::Vector2D& tmp_hitPos_o,
    Identifier& channelIdOut_tmp, const bool isBackward,
    const bool isAside) const {
    // This method is used by decodeHiPt
    // Currently, this method always returns true.
    std::array<Amg::Vector3D, 2> localpos_o{
        make_array<Amg::Vector3D, 2>(Amg::Vector3D::Zero())};
    for (int i = 0; i < 2; i++) {
        localpos_o[i] = descriptor_o[i]->transform(channelIdOut[i]).inverse() *
                        descriptor_o[i]->channelPos(channelIdOut[i]);
    }
 
    std::array<int, 3> index{};
    bool flag_reverse = false;
    if (!isBackward) {  // Forward chamber
        index[2] = 0;
        if (isAside) {  // Aside/Forward Chamber
            index[0] = 1;
            index[1] = 0;
            flag_reverse = true;
        } else {  // Cside/Forward Chamber
            index[0] = 0;
            index[1] = 1;
            flag_reverse = false;
        }
    } else {  // Backward chamber
        index[2] = 1;
        if (isAside) {  // Aside/Backward Chamber
            index[0] = 0;
            index[1] = 1;
            flag_reverse = true;
        } else {  // Cside/Backward Chamber
            index[0] = 1;
            index[1] = 0;
            flag_reverse = false;
        }
    }
 
    double stripMax = descriptor_o[index[0]]->stripHighEdgeLocX(
        gasGap_o[index[0]], channel_o[index[0]], localpos_o[index[0]].z());
    double stripMin = descriptor_o[index[1]]->stripLowEdgeLocX(
        gasGap_o[index[1]], channel_o[index[1]], localpos_o[index[1]].z());
    width_o = stripMax - stripMin;
    // X-coordinate
    hit_position_o = stripMin + width_o / 2.;
    if (flag_reverse) {
        hit_position_o *= -1.;
    }
    tmp_hitPos_o[Trk::locX] = hit_position_o;
    // Y-coordinate
    Amg::Vector3D position_out =
        Amg::Vector3D(descriptor_o[1]->channelPos(channelIdOut[1]));
    // dummy global pos
    Amg::Vector2D loc_hitPos_o{Amg::Vector2D::Zero()};
    bool onSurface_o =
        descriptor_o[1]
            ->surface(channelIdOut[1])
            .globalToLocal(position_out, position_out, loc_hitPos_o);
    if (!onSurface_o) {
        ATH_MSG_WARNING(
            "Muon::TgcRdoToPrepDataToolMT::getPosAndIdStripOut Amg::Vector2D* "
            "loc_hitPos_o is null.");
        return false;
    }
    tmp_hitPos_o[Trk::locY] = loc_hitPos_o[Trk::loc2];
 
    channelIdOut_tmp = channelIdOut[index[2]];
 
    return true;
}
 
bool Muon::TgcRdoToPrepDataToolMT::getPosAndIdWireIn(
    const std::array<const MuonGM::TgcReadoutElement*, 4>& descriptor_i,
    const std::array<Identifier, 4>& channelIdIn,
    const std::array<int, 4>& gasGap_i, const std::array<int, 4>& channel_i,
    double& width_i, double& hit_position_i, Amg::Vector2D& tmp_hitPos_i,
    Identifier& channelIdIn_tmp) const {
    // This method is used by decodeHiPt
    int flag_boundary_i = 0;
    if (descriptor_i[1]->chamberType() == descriptor_i[3]->chamberType()) {
        // in case lower edge is not chamber boundary
        if (gasGap_i[1] ==
            gasGap_i[3]) {  // in case that edge channel is on L3; use [1]
            flag_boundary_i = 1;
        } else {  // in case that edge channel is not on L3; use [3]
            flag_boundary_i = 3;
        }
    } else if (descriptor_i[0]->chamberType() ==
               descriptor_i[2]->chamberType()) {
        // in case higher edge is not chamber boundary
        if (gasGap_i[0] ==
            gasGap_i[2]) {  // in case that edge channel is on L3; use [0]
            flag_boundary_i = 0;
        } else {  // in case that edge channel is not on L3; use [2]
            flag_boundary_i = 2;
        }
    } else {
        ATH_MSG_DEBUG(
            "TgcRdoToPrepDataToolMT::getPosAndIdWireIn::ROI has 3 readout "
            "elements!!");
        return false;
    }
 
    channelIdIn_tmp = channelIdIn[flag_boundary_i];
    SG::ReadCondHandle<MuonGM::MuonDetectorManager> muDetMgrHandle{
        m_muDetMgrKey};
    const MuonGM::MuonDetectorManager* muDetMgr = muDetMgrHandle.cptr();
    const MuonGM::TgcReadoutElement* descriptor_iw =
        muDetMgr->getTgcReadoutElement(channelIdIn_tmp);
    if (!isOfflineIdOKForTgcReadoutElement(descriptor_iw, channelIdIn_tmp)) {
        return false;
    }
 
    std::array<double, 3> tmp_r_i{}, tmp_phi_i{}, tmp_eta_i{};
 
    std::array<Amg::Vector3D, 3> position_i{
        descriptor_i[0]->channelPos(channelIdIn[0]),
        descriptor_i[1]->channelPos(channelIdIn[1]),
        descriptor_iw->channelPos(channelIdIn_tmp)};
 
    for (int i = 0; i < 3; i++) {
        tmp_r_i[i] = position_i[i].perp();
        tmp_phi_i[i] = position_i[i].phi();
        tmp_eta_i[i] = position_i[i].eta();
 
        if (i < 2) {
            // add half widths of edge channels
            double half_width =
                descriptor_i[i]->gangRadialLength(gasGap_i[i], channel_i[i]) /
                2.;
            if (half_width < s_cutDropPrdsWithZeroWidth / 2. &&
                m_dropPrdsWithZeroWidth) {  // Invalid PRD's whose widths are
                                            // zero are dropped.
                return false;
            }
            if (i == 0) {
                tmp_r_i[0] += half_width;
            } else {
                tmp_r_i[1] -= half_width;
            }
 
            bool flag_geteta_i =
                getEtafromRZ(tmp_r_i[i], position_i[i].z(), tmp_eta_i[i]);
            bool flag_getr_i =
                getRfromEtaZ(tmp_eta_i[i], position_i[2].z(), tmp_r_i[i]);
 
            if (!flag_geteta_i || !flag_getr_i) {
                ATH_MSG_DEBUG(
                    "TgcRdoToPrepDataToolMT::getPosAndIdWireIn::failed to "
                    "getRIn"
                    << i << " on L3!!");
                return false;
            }
        }
    }
 
    width_i = tmp_r_i[0] - tmp_r_i[1];
    if (width_i < 0.) {
        ATH_MSG_DEBUG(
            "TgcRdoToPrepDataToolMT::getPosAndIdWireIn::minus value width_i = "
            << width_i);
        return false;
    }
 
    int gasGap_tmp = m_idHelperSvc->tgcIdHelper().gasGap(channelIdIn_tmp);
    int channel_tmp = m_idHelperSvc->tgcIdHelper().channel(channelIdIn_tmp);
    double half_width =
        descriptor_iw->gangRadialLength(gasGap_tmp, channel_tmp) / 2.;
    if (half_width < s_cutDropPrdsWithZeroWidth / 2. &&
        m_dropPrdsWithZeroWidth) {  // Invalid PRD's whose widths are zero are
                                    // dropped.
        return false;
    }
    if ((flag_boundary_i % 2) ==
        1) {  // in case lower edge is not chamber boundary
        tmp_r_i[2] -= half_width;
        hit_position_i =
            descriptor_iw->gangShortWidth(gasGap_tmp, channel_tmp) -
            (tmp_r_i[2] - tmp_r_i[1]) + width_i / 2.;
    } else {  // in case higher edge is not chamber boundary
        tmp_r_i[2] += half_width;
        hit_position_i = descriptor_iw->gangLongWidth(gasGap_tmp, channel_tmp) +
                         (tmp_r_i[0] - tmp_r_i[2]) - width_i / 2.;
    }
 
    // X-coordinate
    tmp_hitPos_i[Trk::locX] = hit_position_i;
    Amg::Vector3D position_in = descriptor_i[1]->channelPos(channelIdIn[1]);
    // dummy global pos
    Amg::Vector2D loc_hitPos_i{Amg::Vector2D::Zero()};
    bool onSurface_i =
        descriptor_i[1]
            ->surface(channelIdIn[1])
            .globalToLocal(position_in, position_in, loc_hitPos_i);
    if (!onSurface_i) {
        ATH_MSG_WARNING(
            "Muon::TgcRdoToPrepDataToolMT::getPosAndIdWireIn Amg::Vector2D* "
            "loc_hitPos_i is null.");
        return false;
    }
    // Y-coordinate
    tmp_hitPos_i[Trk::locY] = loc_hitPos_i[Trk::loc2];
 
    return true;
}
 
bool Muon::TgcRdoToPrepDataToolMT::getPosAndIdStripIn(
    const std::array<const MuonGM::TgcReadoutElement*, 4>& descriptor_i,
    const std::array<Identifier, 4>& channelIdIn,
    const std::array<int, 4>& gasGap_i, const std::array<int, 4>& channel_i,
    double& width_i, double& hit_position_i, Amg::Vector2D& tmp_hitPos_i,
    Identifier& channelIdIn_tmp, const bool isBackward,
    const bool isAside) const {
    // This method is used by decodeHiPt
    int flag_isL3 = -1;
    // which bitpos is Layer3?
    for (int i = 0; i < 4; i++) {
        if (gasGap_i[i] == 3) {
            flag_isL3 = i;
            break;
        }
    }
    if (flag_isL3 < 0 || flag_isL3 >= 4) {
        ATH_MSG_DEBUG("getPosAndIdStripIn: Any bitpos is not at Layer3!");
        return false;
    }
 
    channelIdIn_tmp = channelIdIn[flag_isL3];
    SG::ReadCondHandle<MuonGM::MuonDetectorManager> muDetMgrHandle{
        m_muDetMgrKey};
    const MuonGM::MuonDetectorManager* muDetMgr = muDetMgrHandle.cptr();
    const MuonGM::TgcReadoutElement* descriptor_is =
        muDetMgr->getTgcReadoutElement(channelIdIn_tmp);
    if (!isOfflineIdOKForTgcReadoutElement(descriptor_is, channelIdIn_tmp)) {
        return true;
    }
 
    std::array<double, 3> tmp_r_i{}, tmp_phi_i{}, tmp_eta_i{};
    std::array<Amg::Vector3D, 3> position_is{
        make_array<Amg::Vector3D, 3>(Amg::Vector3D::Zero())};
    for (int i = 0; i < 3; i++) {
        if (i < 2) {
            position_is[i] = descriptor_i[i]->channelPos(channelIdIn[i]);
        } else {
            position_is[i] = descriptor_is->channelPos(channelIdIn_tmp);
        }
        tmp_r_i[i] = position_is[i].perp();
        tmp_phi_i[i] = position_is[i].phi();
        tmp_eta_i[i] = position_is[i].eta();
    }
 
    std::array<int, 2> index{};
    bool flag_reverse = false;
    if (!isBackward) {  // Forward chamber
        if (isAside) {  // Aside/Forward Chamber
            index[0] = 1;
            index[1] = 0;
            flag_reverse = true;
        } else {  // Cside/Forward Chamber
            index[0] = 0;
            index[1] = 1;
            flag_reverse = false;
        }
    } else {            // Backward chamber
        if (isAside) {  // Aside/Backward Chamber
            index[0] = 0;
            index[1] = 1;
            flag_reverse = true;
        } else {  // Cside/Backward Chamber
            index[0] = 1;
            index[1] = 0;
            flag_reverse = false;
        }
    }
 
    std::array<Amg::Vector3D, 2> localpos_i{
        make_array<Amg::Vector3D, 2>(Amg::Vector3D::Zero())};
    for (int i = 0; i < 2; i++) {
        localpos_i[i] = descriptor_i[i]->transform(channelIdIn[i]).inverse() *
                        descriptor_i[i]->channelPos(channelIdIn[i]);
    }
    double stripMaxX = descriptor_i[index[0]]->stripHighEdgeLocX(
        gasGap_i[index[0]], channel_i[index[0]], localpos_i[index[0]].z());
    double stripMinX = descriptor_i[index[1]]->stripLowEdgeLocX(
        gasGap_i[index[1]], channel_i[index[1]], localpos_i[index[1]].z());
    width_i = stripMaxX - stripMinX;
    // X-coordinate
    hit_position_i = stripMinX + width_i / 2.;
    if (flag_reverse) {
        hit_position_i *= -1.;
    }
    tmp_hitPos_i[Trk::locX] = hit_position_i;
    // Y-coordinate
    Amg::Vector3D position_in =
        Amg::Vector3D(descriptor_i[1]->channelPos(channelIdIn[1]));
    // dummy global pos
    Amg::Vector2D loc_hitPos_i;
    bool onSurface_i =
        descriptor_i[1]
            ->surface(channelIdIn[1])
            .globalToLocal(position_in, position_in, loc_hitPos_i);
    if (!onSurface_i) {
        ATH_MSG_WARNING(
            "Muon::TgcRdoToPrepDataToolMT::getPosAndIdStripIn Amg::Vector2D* "
            "loc_hitPos_i is null.");
        return false;
    }
    tmp_hitPos_i[Trk::locY] = loc_hitPos_i[Trk::loc2];
 
    return true;
}
 
// RDOHighPtID --> (Sim)HighPtID --> OfflineID --> ReadoutID --> getSLBID
bool Muon::TgcRdoToPrepDataToolMT::getHiPtIds(const State& state, const TgcRawData& rd,
                                              int& sswId_o, int& sbLoc_o,
                                              int& slbId_o) const {
    int index = static_cast<int>(rd.index());
    int chip = static_cast<int>(rd.chip());
    int hitId = static_cast<int>(rd.hitId());
 
    // getSimHighPtIDfromRDOHighPtID changes index, chip and hitId.
    bool found = state.cabling->getSimHighPtIDfromRDOHighPtID(
        rd.isForward(), rd.isStrip(), index, chip, hitId);
    if (!found) {
        ATH_MSG_DEBUG("Failed to get SimHighPtID from RDOHighPtID for Pivot "
                      << (rd.isStrip() ? "Strip" : "Wire"));
        return false;
    }
 
    // conversion for Run3
    uint16_t tmprodId, tmpsector;
    convertToRun2(rd, tmprodId, tmpsector);
 
    Identifier dummyId;
    if (rd.rodId() > 12) {  // Run3
        found = state.cabling->getOfflineIDfromHighPtID(
            dummyId, rd.subDetectorId(), tmprodId, tmpsector, rd.isStrip(),
            rd.isForward(), index, chip, hitId, rd.hsub());
    } else {
        found = state.cabling->getOfflineIDfromHighPtID(
            dummyId, rd.subDetectorId(), rd.rodId(), rd.sector(), rd.isStrip(),
            rd.isForward(), index, chip, hitId, rd.hsub());
    }
 
    if (!found) {
        ATH_MSG_DEBUG("Failed to get offlineID from HighPtID for Pivot "
                      << (rd.isStrip() ? "Strip" : "Wire"));
        return false;
    }
 
    std::array<int, 3> dummy_i{};
    found = state.cabling->getReadoutIDfromOfflineID(
        dummyId, dummy_i[0], dummy_i[1], sswId_o, sbLoc_o, dummy_i[2]);
    if (!found) {
        ATH_MSG_DEBUG("Failed to get ReadoutID from OfflineID for Pivot "
                      << (rd.isStrip() ? "Strip" : "Wire"));
        return false;
    }
 
    std::array<int, 2> i_o{};
    std::array<bool, 2> b_o{false, false};
    if (rd.rodId() > 12) {  // Run3
        found = state.cabling->getSLBIDfromReadoutID(
            i_o[0], b_o[0], b_o[1], i_o[1], slbId_o, rd.subDetectorId(),
            tmprodId, sswId_o, sbLoc_o);
    } else {
        found = state.cabling->getSLBIDfromReadoutID(
            i_o[0], b_o[0], b_o[1], i_o[1], slbId_o, rd.subDetectorId(),
            rd.rodId(), sswId_o, sbLoc_o);
    }
    if (!found) {
        ATH_MSG_DEBUG("Failed to get SLBID from ReadoutID for Pivot "
                      << (rd.isStrip() ? "Strip" : "Wire"));
        return false;
    }
 
    return true;
}
bool Muon::TgcRdoToPrepDataToolMT::getSLIds(const State& state,
    const bool isStrip, const TgcRawData& rd,
    std::array<Identifier, 3>& channelId, int& index, int& chip, int& hitId,
    int& sub, int& sswId, int& sbLoc, int& subMatrix,
    std::array<int, 3>& bitpos, const bool isBoundary, const TgcRdo* rdoColl,
    const int index_w, const int chip_w, const int hitId_w,
    const int sub_w) const
 
{
    bool found = state.cabling->getHighPtIDfromROINumber(
        rd.roi(), rd.isForward(),
        isStrip,  // get HitID of HPT Board
        index, chip, hitId, sub);
    if (!found) {
        ATH_MSG_DEBUG("Failed to get HighPtID from ROINumber for "
                      << (!isStrip ? "Wire" : "Strip"));
        return false;
    }
 
    found = state.cabling->getSimHighPtIDfromRDOHighPtID(
        rd.isForward(), isStrip, index, chip, hitId);
    if (!found) {
        ATH_MSG_DEBUG("Failed to get SimHighPtID from RDOHighPtID for "
                      << (!isStrip ? "Wire" : "Strip"));
        return false;
    }
 
    Identifier offlineId;
    found = state.cabling->getOfflineIDfromHighPtID(
        offlineId, rd.subDetectorId(), rd.rodId(), rd.sector(), isStrip,
        rd.isForward(), index, chip, hitId, sub);
    if (!found) {
        ATH_MSG_DEBUG("Failed to get OfflineID from HighPtID for "
                      << (!isStrip ? "Wire" : "Strip"));
        return false;
    }
 
    if (!isStrip || !isBoundary) {  // Wire or strip whose ROI not including
                                    // chamber boundary
        channelId[1] = offlineId;
        std::array<int, 3> dummy_i{};
        found = state.cabling->getReadoutIDfromOfflineID(
            channelId[1], dummy_i[0], dummy_i[1], sswId, sbLoc, dummy_i[2]);
        if (!found) {
            ATH_MSG_DEBUG("Failed to get ReadoutID from OfflineID for "
                          << (!isStrip ? "Wire" : "Strip"));
            return false;
        }
    } else {                      // --> solving the chamber boundary of strip
        sswId = rd.sector() + 3;  // SSW3: M3-EC phi0, SSW4: M3-EC phi1, SSW5:
                                  // M3-EC phi2, SSW6: M3-EC phi3
 
        // Loop over all HiPt Strip to find an associated one to obtain sbLoc
        bool exist_hipt_s = getSbLocOfEndcapStripBoundaryFromHiPt(state,
            rd, sbLoc, rdoColl, index_w, chip_w, hitId_w, sub_w);
        if (!exist_hipt_s) {
            // Loop over all Tracklet Strip to find an associated one to obtain
            // sbLoc
            bool exist_tracklet_s = getSbLocOfEndcapStripBoundaryFromTracklet(state,
                rd, sbLoc, rdoColl, index_w, chip_w, hitId_w, sub_w);
            if (!exist_tracklet_s) {
                ATH_MSG_DEBUG(
                    "Failed to find correspond Tracklet_strip for SL!!");
                return false;
            }
        }
    }
 
    if (!isStrip) {  // wire
        getBitPosWire(rd, hitId, sub, subMatrix, bitpos);
    } else {  // strip
        getBitPosStrip(hitId, sub, subMatrix, bitpos);
    }
 
    for (int i = 0; i < 3; i++) {
        if (i == 1 && (!isStrip || !isBoundary)) {
            continue;
        }
 
        found = state.cabling->getOfflineIDfromReadoutID(
            channelId[i], rd.subDetectorId(), rd.rodId(), sswId, sbLoc,
            bitpos[i]);
        if (!found) {
            ATH_MSG_DEBUG("Failed to get OfflineID from ReadoutID for "
                          << (!isStrip ? "Wire" : "Strip"));
            if (!isStrip || i == 1) {
                ATH_MSG_DEBUG("subDetectorId = "
                              << rd.subDetectorId()
                              << ", rodId = " << rd.rodId()
                              << ", sswId = " << sswId << ", slbId = " << sbLoc
                              << ", bitpos_" << (!isStrip ? "w" : "s") << "["
                              << i << "] = " << bitpos[i]);
            }
            return false;
        }
    }
 
    return true;
}
 
bool Muon::TgcRdoToPrepDataToolMT::getSbLocOfEndcapStripBoundaryFromHiPt(const State& state,
    const TgcRawData& rd, int& sbLoc, const TgcRdo* rdoColl, const int index_w,
    const int chip_w, const int hitId_w, const int sub_w) const {
  
    bool exist_hipt_s = false;
 
    // Get trackletIds of three candidates
    int trackletIdStripFirst{-1}, trackletIdStripSecond{-1},
        trackletIdStripThird{-1};
    getEndcapStripCandidateTrackletIds(
        static_cast<int>(rd.roi()), trackletIdStripFirst, trackletIdStripSecond,
        trackletIdStripThird);
 
    // Loop over all HiPt Strip to find an associated one
    for (const TgcRawData* rdH0 : *rdoColl) {
 
        // conversion for Run3
        uint16_t tmprodId, tmpsector;
        convertToRun2(rdH0, tmprodId, tmpsector);
        const TgcRawData rdH(rdH0->bcTag(), rdH0->subDetectorId(), tmprodId,
                             rdH0->l1Id(), rdH0->bcId(), rdH0->isStrip(),
                             rdH0->isForward(), tmpsector, rdH0->chip(),
                             rdH0->index(), rdH0->isHipt(), rdH0->hitId(),
                             rdH0->hsub(), rdH0->delta(), rdH0->inner());
 
        if ((rdH.type() == TgcRawData::TYPE_HIPT) &&  // HiPt
            (rdH.isHipt()) &&                         // HiPt flag is required
            (rdH.isStrip()) &&                        // Strip
            (!rdH.isForward()) &&                     // Endcap
            (rdH.bcTag() == rd.bcTag()) &&            // The same timing
            (rdH.subDetectorId() == rd.subDetectorId()) &&  // The same side
            (rdH.rodId() == rd.rodId()) &&                  // The same ROD
            (rdH.sector() == rd.sector())  // The same sector (1/48 phi)
        ) {
 
            // Get sbLoc
            int sswId_o{0}, sbLoc_o{0}, slbId_o{0};
            bool found = getHiPtIds(state, rdH, sswId_o, sbLoc_o, slbId_o);
            if (!found) {
                continue;
            }
 
            // Get subMatrix
            int slbsubMatrix = 0;
            std::array<int, 2> bitpos_o{};
            getBitPosOutStrip(rdH, slbsubMatrix, bitpos_o);
 
            // Get trackletId
            int trackletIdStrip = 2 * sbLoc_o + slbsubMatrix;
 
            // Compare trackletIds
            if (trackletIdStrip != trackletIdStripFirst &&
                trackletIdStrip != trackletIdStripSecond &&
                trackletIdStrip != trackletIdStripThird) {
                continue;
            }
 
            // The third candidate is used only if any corresponding HiPt Strip
            // is found so far.
            if (exist_hipt_s && trackletIdStrip == trackletIdStripThird) {
                continue;
            }
 
            // getRDOHighPtIDfromSimHighPtID overwrites index, chip and hitId.
            int index_w_tmp = index_w;
            int chip_w_tmp = chip_w;
            int hitId_w_tmp = hitId_w;
            // Get RDO HighPt ID from SimHighPtID for wire
            found = state.cabling->getRDOHighPtIDfromSimHighPtID(
                false,  // false for endcap
                false,  // wire
                index_w_tmp, chip_w_tmp, hitId_w_tmp);
            if (!found) {
                ATH_MSG_DEBUG(
                    "Failed to get RDOHighPtID from SimHighPtID for Wire");
                continue;
            }
 
            // RDO High Pt ID of Strip
            int chip_s = static_cast<int>(rdH.chip());
            int hitId_s = static_cast<int>(rdH.hitId());
            int hsub_s = static_cast<int>(rdH.hsub());
 
            int roi = 0;
            found = state.cabling->getROINumberfromHighPtID(
                roi,
                false,        // false for Endcap
                index_w_tmp,  // hpb_wire (not used)
                chip_w_tmp,   // chip_wire
                hitId_w_tmp,  // hitId_wire
                sub_w,        // sub_wire
                chip_s,       // chip_strip (not used)
                hitId_s,      // hitId_strip
                hsub_s);      // sub_strip
            if (!found) {
                ATH_MSG_DEBUG(
                    "Failed to get ROINumber from HighPtID for Strip");
                continue;
            }
 
            if (roi == rd.roi()) {
                sbLoc = sbLoc_o;
                exist_hipt_s = true;
                if (trackletIdStrip == trackletIdStripFirst) {
                    break;  // If the first candidate is found, exit from this
                            // for loop
                }
            }
        }
    }
 
    return exist_hipt_s;
}
 
bool Muon::TgcRdoToPrepDataToolMT::getSbLocOfEndcapStripBoundaryFromTracklet(const State& state,
    const TgcRawData& rd, int& sbLoc, const TgcRdo* rdoColl, const int index_w,
    const int chip_w, const int hitId_w, const int sub_w) const {
 
    bool exist_tracklet_s = false;
 
    // Get trackletIds of three candidates
    int trackletIdStripFirst{-1}, trackletIdStripSecond{-1},
        trackletIdStripThird{-1};
    getEndcapStripCandidateTrackletIds(
        static_cast<int>(rd.roi()), trackletIdStripFirst, trackletIdStripSecond,
        trackletIdStripThird);
 
    // Loop over all Tracklet Strip to find an associated one
    for (const TgcRawData* rdS0 : *rdoColl) {
 
        // conversion for Run3
        uint16_t tmprodId{0}, tmpsector{0};
        convertToRun2(rdS0, tmprodId, tmpsector);
        const TgcRawData rdS(rdS0->bcTag(), rdS0->subDetectorId(), tmprodId,
                             rdS0->sswId(), rdS0->slbId(), rdS0->l1Id(),
                             rdS0->bcId(), rdS0->slbType(), rdS0->delta(),
                             rdS0->segment(), rdS0->subMatrix(),
                             rdS0->position());
 
        bool isForward_s = (rdS.sswId() == 7);  // Doublet, Forward
        if (isForward_s) {
            continue;  // Chamber boundaries exist in endcap only
        }
 
        if ((rdS.type() == TgcRawData::TYPE_TRACKLET) &&
            (rdS.slbType() == TgcRawData::SLB_TYPE_DOUBLET_STRIP) &&
            (rdS.bcTag() == rd.bcTag()) &&
            (rdS.subDetectorId() == rd.subDetectorId()) &&
            (rdS.rodId() == rd.rodId()) &&
            (rdS.sswId() - 3 ==
             rd.sector())  // SSW3: M3-EC phi0, SSW4: M3-EC phi1, SSW5: M3-EC
                           // phi2, SSW6: M3-EC phi3
        ) {
 
            // Compare trackletIds
            int trackletIdStrip = static_cast<int>(
                2 * rdS.slbId() +
                rdS.subMatrix());  // trackletId of Tracklet Strip
            if (trackletIdStrip != trackletIdStripFirst &&
                trackletIdStrip != trackletIdStripSecond &&
                trackletIdStrip != trackletIdStripThird) {
                continue;
            }
 
            // The third candidate is used only if any corresponding Tracklet
            // Strip is found so far.
            if (exist_tracklet_s && trackletIdStrip == trackletIdStripThird) {
                continue;
            }
 
            Identifier offlineId;
            bool found =
                state.cabling->getOfflineIDfromLowPtCoincidenceID(
                    offlineId, rdS.subDetectorId(), rdS.rodId(), rdS.sswId(),
                    rdS.slbId(), rdS.subMatrix(), rdS.position(), false);
            if (!found) {
                ATH_MSG_DEBUG(
                    "Failed to get OfflineID from LowPtCoincidenceID for "
                    "Strip");
                continue;
            }
 
            std::array<int, 7> i{};
            std::array<bool, 2> b{};
            found = state.cabling->getHighPtIDfromOfflineID(
                offlineId, i[0], i[1], i[2], b[0], b[1], i[3], i[4], i[5],
                i[6]);
            // i[0] subDetectorID, i[1] rodID, i[2] sectorInReadout, b[0]
            // isStrip, b[1] isForward, i[3] hpb, i[4] chip, i[5] hitID, i[6]
            // pos
 
            if (!found) {
                ATH_MSG_DEBUG(
                    "Failed to get HighPtID from OfflineID for Strip");
                continue;
            }
 
            // getRDOHighPtIDfromSimHighPtID overwrites index, chip and hitId.
            int index_w_tmp = index_w;
            int chip_w_tmp = chip_w;
            int hitId_w_tmp = hitId_w;
            found = state.cabling->getRDOHighPtIDfromSimHighPtID(
                rd.isForward(),  // false for endcap
                false,           // wire
                index_w_tmp,     // hpb-index
                chip_w_tmp,      // chip-chip
                hitId_w_tmp);    // hitID-hitId
            if (!found) {
                ATH_MSG_DEBUG(
                    "Failed to get RDOHighPtID from SimHighPtID for Wire");
                continue;
            }
 
            found = state.cabling->getRDOHighPtIDfromSimHighPtID(
                rd.isForward(),  // false for endcap
                true,            // strip
                i[3],            // hpb-index
                i[4],            // chip-chip
                i[5]);           // hitID-hitId
            if (!found) {
                ATH_MSG_DEBUG(
                    "Failed to get RDOHighPtID from SimHighPtID for Strip");
                continue;
            }
 
            int roi = 0;
            found = state.cabling->getROINumberfromHighPtID(
                roi,
                rd.isForward(),  // false for endcap
                index_w_tmp,     // hpb_wire (not used)
                chip_w_tmp,      // chip_wire
                hitId_w_tmp,     // hitId_wire
                sub_w,           // sub_wire
                i[4],            // chip_strip (not used)
                i[5],            // hitId_strip
                i[6]);           // sub_strip
            if (!found) {
                ATH_MSG_DEBUG(
                    "Failed to get ROINumber from HighPtID for Strip");
                continue;
            }
 
            if (roi == rd.roi()) {
                sbLoc = rdS.slbId();
                exist_tracklet_s = true;
                if (trackletIdStrip == trackletIdStripFirst) {
                    break;  // If the first candidate is found, exit from this
                            // for loop
                }
            }
        }
    }
 
    return exist_tracklet_s;
}
 
void Muon::TgcRdoToPrepDataToolMT::getEndcapStripCandidateTrackletIds(
    const int roi, int& trackletIdStripFirst, int& trackletIdStripSecond,
    int& trackletIdStripThird) {
    constexpr int T9SscMax = 2;   // SSC 0 to SSC 2
    constexpr int T8SscMax = 4;   // SSC 3 to SSC 4
    constexpr int T7SscMax = 6;   // SSC 5 to SSC 6
    constexpr int T6SscMax = 12;  // SSC 7 to SSC12
    constexpr int T5SscMax = 18;  // SSC13 to SSC18
 
    constexpr int T9Offset = 32 + 0;
    constexpr int T8Offset = 32 + 2;
    constexpr int T7Offset = 32 + 4;
    constexpr int T6Offset = 32 + 6;
    constexpr int T5Offset = 32 + 8;
 
    // ROI     :  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 ...
    // SSC     :  0  0  0  0  1  1  1  1  1  1  1  1  2  2  2  2  2  2 ...
    // Half SSC:  0  0  1  1  0  0  1  1  0  0  1  1  0  0  1  1  0  0 ...
    int ssc = (roi + 4) / 8;
    int halfSsc = (roi % 4) / 2;
 
    if (ssc < T9SscMax) {                           // SSC 0 to SSC 1
        trackletIdStripFirst = T9Offset + halfSsc;  // T9
        trackletIdStripSecond = -1;
        trackletIdStripThird = -1;
    } else if (ssc == T9SscMax) {                    // SSC 2 (boundary)
        trackletIdStripFirst = T8Offset + halfSsc;   // T8
        trackletIdStripSecond = T9Offset + halfSsc;  // T9
        trackletIdStripThird = -1;
    } else if (ssc < T8SscMax) {                    // SSC 3
        trackletIdStripFirst = T8Offset + halfSsc;  // T8
        trackletIdStripSecond = -1;
        trackletIdStripThird = -1;
    } else if (ssc == T8SscMax) {                    // SSC 4 (boundary)
        trackletIdStripFirst = T7Offset + halfSsc;   // T7
        trackletIdStripSecond = T8Offset + halfSsc;  // T8
        trackletIdStripThird = -1;
    } else if (ssc < T7SscMax) {                    // SSC 5
        trackletIdStripFirst = T7Offset + halfSsc;  // T7
        trackletIdStripSecond = -1;
        trackletIdStripThird = -1;
    } else if (ssc == T7SscMax) {                    // SSC 6 (boundary)
        trackletIdStripFirst = T6Offset + halfSsc;   // T6
        trackletIdStripSecond = T7Offset + halfSsc;  // T7
        trackletIdStripThird =
            T5Offset + halfSsc;   // T5, HiPt Endcap Strip board bug
    } else if (ssc < T6SscMax) {  // SSC 7 to SSC11
        trackletIdStripFirst = T6Offset + halfSsc;  // T6
        trackletIdStripSecond =
            T5Offset + halfSsc;  // T5, HiPt Endcap Strip board bug
        trackletIdStripThird = -1;
    } else if (ssc == T6SscMax) {                    // SSC12 (boundary)
        trackletIdStripFirst = T6Offset + halfSsc;   // T6
        trackletIdStripSecond = T5Offset + halfSsc;  // T5
        trackletIdStripThird = -1;
    } else if (ssc <= T5SscMax) {                   // SSC13 to SSC18
        trackletIdStripFirst = T5Offset + halfSsc;  // T5
        trackletIdStripSecond =
            T6Offset + halfSsc;  // T6, HiPt Endcap Strip board bug
        trackletIdStripThird = -1;
    } else {
        trackletIdStripFirst = -1;
        trackletIdStripSecond = -1;
        trackletIdStripThird = -1;
    }
}
 
 
 
Amg::Vector2D Muon::TgcRdoToPrepDataToolMT::getSLLocalPosition(
    const MuonGM::TgcReadoutElement* readout, const Identifier identify,
    const double eta, const double phi) {
    if (!readout) {
        return Amg::Vector2D::Zero();
    }
 
    // Obtain the local coordinate by the secant method
    constexpr double length = 100.;         // 100 mm
    constexpr unsigned int nRep = 10;       // 10 repetitions
    constexpr double dRAccuracy = 1.0E-20;  // recuqired dR accuracy
    constexpr double maxLocR = 10000.;      // 10 m
 
    double locX = 0.;
    double locY = 0.;
    for (unsigned int iRep = 0; iRep < nRep; iRep++) {
        Amg::Vector2D loc_hitPos_c(locX, locY);  // center or current position
        Amg::Vector3D tmp_glob_hitPos_c{Amg::Vector3D::Zero()};
        readout->surface(identify).localToGlobal(
            loc_hitPos_c, tmp_glob_hitPos_c, tmp_glob_hitPos_c);
        const Amg::Vector3D& glob_hitPos_c = tmp_glob_hitPos_c;
 
        double glob_eta_c = glob_hitPos_c.eta();
        double glob_phi_c = glob_hitPos_c.phi();
 
        Amg::Vector2D vector{eta - glob_eta_c, deltaPhi(phi, glob_phi_c)};
 
        double dR = std::hypot(vector[0], vector[1]);
        if (dR < dRAccuracy) {
            break;
        }
 
        Amg::Vector2D loc_hitPos_w(
            locX + length,
            locY);  // slightly shifted position in the wire direction
        Amg::Vector2D loc_hitPos_s(
            locX,
            locY + length);  // slightly shifted position in the strip direction
        Amg::Vector3D tmp_glob_hitPos_w{Amg::Vector3D::Zero()};
        readout->surface(identify).localToGlobal(
            loc_hitPos_w, tmp_glob_hitPos_w, tmp_glob_hitPos_w);
        const Amg::Vector3D& glob_hitPos_w = tmp_glob_hitPos_w;
        Amg::Vector3D tmp_glob_hitPos_s{Amg::Vector3D::Zero()};
        readout->surface(identify).localToGlobal(
            loc_hitPos_s, tmp_glob_hitPos_s, tmp_glob_hitPos_s);
        const Amg::Vector3D& glob_hitPos_s = tmp_glob_hitPos_s;
 
        AmgSymMatrix(2) matrix{AmgSymMatrix(2)::Identity()};
        matrix(0, 0) = glob_hitPos_w.eta() - glob_eta_c;
        matrix(1, 0) = deltaPhi(glob_hitPos_w.phi(), glob_phi_c);
        matrix(0, 1) = glob_hitPos_s.eta() - glob_eta_c;
        matrix(1, 1) = deltaPhi(glob_hitPos_s.phi(), glob_phi_c);
 
        bool invertible = matrix.determinant();
        if (invertible) {
            Amg::MatrixX invertedMatrix = matrix.inverse();
            Amg::Vector2D solution = invertedMatrix * vector;
            locX += length * solution(0, 0);
            locY += length * solution(1, 0);
 
            double locR = sqrt(locX * locX + locY * locY);
            if (locR > maxLocR) {
                locX *= maxLocR / locR;
                locY *= maxLocR / locR;
            }
        }
    }
 
    return Amg::Vector2D(locX, locY);
}
 
const double Muon::TgcRdoToPrepDataToolMT::s_cutDropPrdsWithZeroWidth =
    0.1;  // 0.1 mm