TgcRdoToPrepDataToolMT.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONTGC_CNVTOOLS_TGCRDOTOPREPDATATOOLMT_H
#define MUONTGC_CNVTOOLS_TGCRDOTOPREPDATATOOLMT_H
 
#include <atomic>
#include <string>
#include <vector>
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "CxxUtils/CachedValue.h"
#include "GaudiKernel/ServiceHandle.h"
#include "MuonCnvToolInterfaces/IMuonRdoToPrepDataTool.h"
#include "MuonIdHelpers/IMuonIdHelperSvc.h"
#include "MuonPrepRawData/MuonPrepDataCollection_Cache.h"
#include "MuonPrepRawData/MuonPrepDataContainer.h"
#include "MuonRDO/TgcRdo.h"
#include "MuonRDO/TgcRdoContainer.h"
#include "MuonReadoutGeometry/MuonDetectorManager.h"
#include "MuonTGC_Cabling/TgcCablingMap.h"
#include "MuonTrigCoinData/MuonTrigCoinData_Cache.h"
#include "MuonTrigCoinData/TgcCoinDataContainer.h"
#include "StoreGate/HandleKeyArray.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "StoreGate/UpdateHandle.h"
#include "StoreGate/UpdateHandleKey.h"
#include "xAODMuonPrepData/TgcStripContainer.h"
 
namespace MuonGM {
class TgcReadoutElement;
}
 
namespace Muon {
// Typedef the two update handle arrays that can be used to match handle key
// functionality Requested to not use StoreGate template for
// UpdateHandleKeyArray
typedef SG::HandleKeyArray<SG::UpdateHandle<TgcPrepDataCollection_Cache>,
                           SG::UpdateHandleKey<TgcPrepDataCollection_Cache>,
                           Gaudi::DataHandle::Reader>
    TgcPrdUpdateHandles;
typedef SG::HandleKeyArray<SG::UpdateHandle<TgcCoinDataCollection_Cache>,
                           SG::UpdateHandleKey<TgcCoinDataCollection_Cache>,
                           Gaudi::DataHandle::Reader>
    TgcCoinUpdateHandles;

 
class TgcRdoToPrepDataToolMT
    : public extends<AthAlgTool, IMuonRdoToPrepDataTool> {
   public:
    using base_class::base_class;

    virtual ~TgcRdoToPrepDataToolMT() = default;

    virtual StatusCode initialize() override;
    virtual StatusCode finalize() override;

    virtual StatusCode decode(
        const EventContext& ctx,
        const std::vector<IdentifierHash>& idVect) const override;
 
    virtual StatusCode provideEmptyContainer(
        const EventContext& ctx) const override;
 
   private:
    static constexpr int NBC_HIT = 3;
    /* Run1,2: The number of recorded Bunch Crossings (BCs) FOR TRIGGER (HPT/SL)
     * is 3 (Previous, Current, Next BCs) */
    /* Run3: The number of recorded Bunch Crossings (BCs) FOR TRIGGER (HPT/SL)
     * is 4 (Previous, Current, Next, and Next-to-Next BCs) */
    static constexpr int NBC_TRIG = 4;
 
    struct State {
        std::array<TgcPrepDataContainer*, NBC_HIT + 1>
            tgcPrepDataContainer{};  // +1 for AllBCs
 
        using TempPrepDataContainer =
            std::vector<std::unique_ptr<TgcPrepDataCollection>>;
        std::array<TempPrepDataContainer, NBC_HIT + 1> tgcPrepDataCollections{};
        std::array<TgcCoinDataContainer*, NBC_TRIG> tgcCoinDataContainer{};
 
        using TempCoinDataContainer =
            std::vector<std::unique_ptr<TgcCoinDataCollection>>;
        std::array<TempCoinDataContainer, NBC_TRIG> tgcCoinDataCollections{};

        SG::WriteHandle<xAOD::TgcStripContainer> m_xaodHandle{};
 
        const MuonGM::MuonDetectorManager* muDetMgr{nullptr};
 
        const TgcCablingMap* cabling{nullptr};
    };
    template <class ContType, class CollType>
    StatusCode transferData(
        ContType& container,
        std::vector<std::unique_ptr<CollType>>&& coll) const;
 
    StatusCode setupState(const EventContext& ctx, State& state) const;

    enum SUB_DETCTOR_ID { ASIDE = 103, CSIDE = 104 };

    enum BIT_POS {
        BIT_POS_ASD_SIZE = 16,
        BIT_POS_NUM_ASD = 2,
        BIT_POS_INPUT_SIZE = BIT_POS_ASD_SIZE * BIT_POS_NUM_ASD,
        BIT_POS_OFFSET_LARGE_R = BIT_POS_ASD_SIZE,
        BIT_POS_OFFSET_LARGE_PHIFOR_A_FWD_C_BWD = BIT_POS_OFFSET_LARGE_R,
        BIT_POS_A_INPUT_ORIGIN = 73,
        BIT_POS_B_INPUT_ORIGIN = 109,
        BIT_POS_C_INPUT_ORIGIN = 149,
        BIT_POS_D_INPUT_ORIGIN = 193,
 
        /* CHannel starts from 00 at the small R side (the same as ASD). */
        BIT_POS_B_INPUT_LARGE_R_CH15 =
            BIT_POS_B_INPUT_ORIGIN - BIT_POS_OFFSET_LARGE_R - 15,  //  78
        BIT_POS_A_INPUT_LARGE_R_CH08 =
            BIT_POS_A_INPUT_ORIGIN - BIT_POS_OFFSET_LARGE_R - 8,  //  49
        BIT_POS_B_INPUT_LARGE_R_CH07 =
            BIT_POS_B_INPUT_ORIGIN - BIT_POS_OFFSET_LARGE_R - 7,  //  86
        BIT_POS_A_INPUT_LARGE_R_CH00 =
            BIT_POS_A_INPUT_ORIGIN - BIT_POS_OFFSET_LARGE_R,         //  57
        BIT_POS_B_INPUT_SMALL_R_CH15 = BIT_POS_B_INPUT_ORIGIN - 15,  //  94
        BIT_POS_A_INPUT_SMALL_R_CH08 = BIT_POS_A_INPUT_ORIGIN - 8,   //  65
        BIT_POS_B_INPUT_SMALL_R_CH07 = BIT_POS_B_INPUT_ORIGIN - 7,   // 102
        BIT_POS_A_INPUT_SMALL_R_CH00 = BIT_POS_A_INPUT_ORIGIN,       //  73
 
        BIT_POS_B_INPUT_SMALL_R_CH05 = BIT_POS_B_INPUT_ORIGIN - 5,  // 104
        BIT_POS_A_INPUT_SMALL_R_CH03 = BIT_POS_A_INPUT_ORIGIN - 3,  //  70
        BIT_POS_B_INPUT_LARGE_R_CH12 =
            BIT_POS_B_INPUT_ORIGIN - BIT_POS_OFFSET_LARGE_R - 12,  //  81
 
        BIT_POS_A_INPUT_SMALL_R_CH04 = BIT_POS_A_INPUT_ORIGIN - 4,  //  69
        BIT_POS_A_INPUT_LARGE_R_CH12 =
            BIT_POS_A_INPUT_ORIGIN - BIT_POS_OFFSET_LARGE_R - 12,  //  45
        BIT_POS_A_INPUT_LARGE_R_CH04 =
            BIT_POS_A_INPUT_ORIGIN - BIT_POS_OFFSET_LARGE_R - 4,     //  53
        BIT_POS_A_INPUT_SMALL_R_CH12 = BIT_POS_A_INPUT_ORIGIN - 12,  //  61
 
        /* CHannel starts from 00
           at the small phi side for A side forward chambers and C side backward
           chambers and at the large phi side for A side backward chambers and C
           side forward chambers (the same as ASD). */
        BIT_POS_B_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH15 =
            BIT_POS_B_INPUT_LARGE_R_CH15,  //  78
        BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH08 =
            BIT_POS_A_INPUT_LARGE_R_CH08,  //  49
        BIT_POS_B_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH07 =
            BIT_POS_B_INPUT_LARGE_R_CH07,  //  86
        BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH00 =
            BIT_POS_A_INPUT_LARGE_R_CH00,  //  57
        BIT_POS_B_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH15 =
            BIT_POS_B_INPUT_SMALL_R_CH15,  //  94
        BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH08 =
            BIT_POS_A_INPUT_SMALL_R_CH08,  //  65
        BIT_POS_B_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH07 =
            BIT_POS_B_INPUT_SMALL_R_CH07,  // 102
        BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH00 =
            BIT_POS_A_INPUT_SMALL_R_CH00,  //  73
 
        BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH12 =
            BIT_POS_A_INPUT_LARGE_R_CH12,  //  45
        BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH04 =
            BIT_POS_A_INPUT_LARGE_R_CH04,  //  53
        BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH12 =
            BIT_POS_A_INPUT_SMALL_R_CH12,  //  61
        BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH04 =
            BIT_POS_A_INPUT_SMALL_R_CH04  //  69
    };

    enum MAP_SIZE {
        WT_MAP_SIZE = 3 * BIT_POS_INPUT_SIZE,
        ST_MAP_SIZE = 2 * BIT_POS_INPUT_SIZE,
        SD_MAP_SIZE = 2 * BIT_POS_INPUT_SIZE,
        WD_MAP_SIZE = 2 * BIT_POS_INPUT_SIZE
    };

    void selectDecoder(State& state, const TgcRawData& rd,
                       const TgcRdo* rdoColl) const;

    StatusCode decodeHits(State& state, const TgcRawData& rd) const;
    StatusCode decodeTracklet(State& state, const TgcRawData& rd) const;
    StatusCode decodeTrackletEIFI(State& state, const TgcRawData& rd) const;
    StatusCode decodeHiPt(State& state, const TgcRawData& rd) const;
    StatusCode decodeInner(State& state, const TgcRawData& rd) const;
    StatusCode decodeSL(State& state, const TgcRawData& rd,
                        const TgcRdo* rdoColl) const;

    static int getbitpos(int channel, TgcRawData::SlbType slbType);
    static int getchannel(int bitpos, TgcRawData::SlbType slbType);

    static bool getRfromEtaZ(const double eta, const double z, double& r);
    static bool getEtafromRZ(const double r, const double z, double& eta);

    static bool isAlreadyConverted(
        const std::vector<const TgcRdo*>& decodedRdoCollVec,
        const std::vector<const TgcRdo*>& rdoCollVec, const TgcRdo* rdoColl);

    static bool isRequested(
        const std::vector<IdentifierHash>& requestedIdHashVect,
        IdentifierHash tgcHashId);

    bool isOfflineIdOKForTgcReadoutElement(
        const MuonGM::TgcReadoutElement* descriptor,
        const Identifier channelId) const;

    bool getTrackletInfo(const TgcRawData& rd, int& tmp_slbId,
                         int& tmp_subMatrix, int& tmp_position) const;

    static int getRoiRow(const TgcRawData& rd);
    bool isIncludedInChamberBoundary(const TgcRawData& rd) const;

    static void getBitPosOutWire(const TgcRawData& rd, int& slbsubMatrix,
                                 std::array<int, 2>& bitpos_o);
    void 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;
    static void getBitPosOutStrip(const TgcRawData& rd, int& slbsubMatrix,
                                  std::array<int, 2>& bitpos_o);
    void 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;
    void getBitPosWire(const TgcRawData& rd, const int hitId_w, const int sub_w,
                       int& subMatrix_w, std::array<int, 3>& bitpos_w) const;
    static void getBitPosStrip(const int hitId_s, const int sub_s,
                               int& subMatrix_s, std::array<int, 3>& bitpos_s);

    static int getDeltaBeforeConvert(const TgcRawData& rd);

    static bool isBackwardBW(const TgcRawData& rd);

    bool getSLWireGeometry(const std::array<Identifier, 3>& channelId_wire,
                           double& width_wire, double& r_wire,
                           double& z_wire) const;
    bool getSLStripGeometry(const std::array<Identifier, 3>& channelId_strip,
                            const bool isBackWard, const bool isAside,
                            double& width_strip, double& theta_strip) const;
    bool 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;
    bool 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;

    bool 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;
    bool 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;

    bool getHiPtIds(const State& state, const TgcRawData& rd, int& sswId_o,
                    int& sbLoc_o, int& slbId_o) const;

    bool 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 = false,
                  const TgcRdo* rdoColl = 0, const int index_w = -1,
                  const int chip_w = -1, const int hitId_w = -1,
                  const int sub_w = -1) const;
    bool 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 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;
    static void getEndcapStripCandidateTrackletIds(const int roi,
                                                   int& trackletIdStripFirst,
                                                   int& trackletIdStripSecond,
                                                   int& trackletIdStripThird);

    static Amg::Vector2D getSLLocalPosition(
        const MuonGM::TgcReadoutElement* readout, const Identifier,
        const double eta, const double phi);
 
    SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> m_muDetMgrKey{
        this, "DetectorManagerKey", "MuonDetectorManager",
        "Key of input MuonDetectorManager condition data"};
 
    SG::ReadCondHandleKey<Muon::TgcCablingMap> m_cablingKey{
        this, "CablingKey", "MuonTgc_CablingMap"};
 
    ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc{
        this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

    Gaudi::Property<std::string> m_outputCollectionLocation{
        this, "OutputCollection", "TGC_Measurements"};

    Gaudi::Property<std::string> m_outputCoinCollectionLocation{
        this, "OutputCoinCollection", "TrigT1CoinDataCollection"};

    Gaudi::Property<int> m_tgcOffset{this, "TGCHashIdOffset", 26000};

    Gaudi::Property<bool> m_decodeData{this, "DecodeData", true};
    Gaudi::Property<bool> m_fillCoinData{this, "FillCoinData", true};

    Gaudi::Property<bool> m_show_warning_level_invalid_A09_SSW6_hit{
        this, "show_warning_level_invalid_A09_SSW6_hit", false};

    Gaudi::Property<bool> m_dropPrdsWithZeroWidth{this, "dropPrdsWithZeroWidth",
                                                  true};

    const static double s_cutDropPrdsWithZeroWidth;  // 0.1 mm

    mutable std::atomic<long> m_nHitRDOs{0};
    mutable std::atomic<long> m_nHitPRDs{0};
    mutable std::atomic<long> m_nTrackletRDOs{0};
    mutable std::atomic<long> m_nTrackletPRDs{0};
    mutable std::atomic<long> m_nTrackletEIFIRDOs{0};
    mutable std::atomic<long> m_nTrackletEIFIPRDs{0};
    mutable std::atomic<long> m_nHiPtRDOs{0};
    mutable std::atomic<long> m_nHiPtPRDs{0};
    mutable std::atomic<long> m_nSLRDOs{0};
    mutable std::atomic<long> m_nSLPRDs{0};
 
    SG::ReadHandleKey<TgcRdoContainer> m_rdoContainerKey{
        this, "RDOContainer", "TGCRDO", "TgcRdoContainer to retrieve"};
 
    // Write handle keys for CoinDataContainers, need 3, for current, previous
    // and next BC
    SG::WriteHandleKeyArray<Muon::TgcCoinDataContainer> m_outputCoinKeys{
        this, "outputCoinKey", {}};
    // Write handle keys for PrepDataContainers, need 4, for current, previous,
    // next and all BC
    SG::WriteHandleKeyArray<Muon::TgcPrepDataContainer> m_outputprepdataKeys{
        this, "prepDataKeys", {}};
 
    SG::WriteHandleKey<xAOD::TgcStripContainer> m_xAODKey{
        this, "xAODKey", "",
        "If empty, do not produce xAOD, otherwise this is the key of the "
        "output xAOD MDT PRD container"};

    TgcPrdUpdateHandles m_prdContainerCacheKeys{this, "UpdateKeysPrd", {}};
    TgcCoinUpdateHandles m_coinContainerCacheKeys{this, "UpdateKeysCoin", {}};
 
    // TgcPrepRawData container cache key prefix (code automatically creates
    // three keys with from this string if it is non-empty)
    Gaudi::Property<std::string> m_prdContainerCacheKeyStr{
        this, "PrdCacheString", "",
        "Prefix for names of PRD cache collections"};
    // TgcCoinData container cache key prefix (code automatically creates three
    // keys with from this string if it is non-empty)
    Gaudi::Property<std::string> m_coinContainerCacheKeyStr{
        this, "CoinCacheString", "",
        "Prefix for names of Coin cache collections"};

    StatusCode decode(const EventContext& ctx,
                      const std::vector<uint32_t>& robIds) const override;
    // Run3->Run2 conversion of rodId and sector
    void convertToRun2(const TgcRawData* rd, uint16_t& newrodId,
                       uint16_t& newsector) const {
        newrodId = rd->rodId();
        newsector = rd->sector();
        if (rd->rodId() >
            12) {  // Run3 rodID is 17..19 while Run2 rodId is 1..12
            if (rd->isForward()) {
                newrodId = rd->sector() / 2 + 1 + (rd->rodId() - 17) * 4;
                newsector = (rd->sector() + (rd->rodId() - 17) * 8) % 2;
            } else {
                newrodId = rd->sector() / 4 + 1 + (rd->rodId() - 17) * 4;
                newsector = (rd->sector() + (rd->rodId() - 17) * 16) % 4;
            }
        }
    }
    void convertToRun2(const TgcRawData& rd, uint16_t& newrodId,
                       uint16_t& newsector) const {
        convertToRun2(&rd, newrodId, newsector);
    }
};
}  // namespace Muon
 
#endif  // MUONTGC_CNVTOOLS_TGCRDOTOPREPDATATOOLMT_H