TgcRdoToPrepDataToolMT.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONTGC_CNVTOOLS_TGCRDOTOPREPDATATOOLMT_H
#define MUONTGC_CNVTOOLS_TGCRDOTOPREPDATATOOLMT_H
 
#include "MuonCnvToolInterfaces/IMuonRdoToPrepDataTool.h"
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ServiceHandle.h"
 
#include "MuonPrepRawData/MuonPrepDataContainer.h"
#include "MuonRDO/TgcRdo.h"
#include "MuonTrigCoinData/TgcCoinDataContainer.h"
#include "MuonPrepRawData/MuonPrepDataCollection_Cache.h"
#include "MuonTrigCoinData/MuonTrigCoinData_Cache.h"
#include "MuonRDO/TgcRdoContainer.h"
#include "MuonIdHelpers/IMuonIdHelperSvc.h"
#include "TGCcablingInterface/ITGCcablingSvc.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "StoreGate/HandleKeyArray.h"
#include "StoreGate/UpdateHandleKey.h"
#include "StoreGate/UpdateHandle.h"
#include "MuonReadoutGeometry/MuonDetectorManager.h"
#include "CxxUtils/CachedValue.h"
#include "xAODMuonPrepData/TgcStripContainer.h"
 
#include <string>
#include <vector>
#include <atomic>
 
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:
      TgcRdoToPrepDataToolMT(const std::string& t, const std::string& n, const IInterface* p);
      
      virtual ~TgcRdoToPrepDataToolMT()=default;
      
      virtual StatusCode initialize() override;
      virtual StatusCode finalize() override;
      
      virtual StatusCode decode(const EventContext& ctx,
                                const std::vector<IdentifierHash>& idVect) const override;
 
      
    protected:
      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 {
        TgcPrepDataContainer* m_tgcPrepDataContainer[NBC_HIT+1] = {};   // +1 for AllBCs
        std::unordered_map<Identifier, TgcPrepDataCollection*> m_tgcPrepDataCollections[NBC_HIT+1];
        TgcCoinDataContainer* m_tgcCoinDataContainer[NBC_TRIG] = {};
        std::unordered_map<Identifier, TgcCoinDataCollection*> m_tgcCoinDataCollections[NBC_TRIG];
 
        SG::WriteHandle<xAOD::TgcStripContainer>    m_xaodHandle;
      };
      StatusCode setupState(const EventContext& ctx, State& state) const;
 
      struct CablingInfo {
        const ITGCcablingSvc* m_tgcCabling = nullptr;
        std::vector<uint16_t> m_hashToOnlineId;
        int m_MAX_N_ROD = 0;
      };
      CxxUtils::CachedValue<CablingInfo> m_cablingInfo;
 
      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 printPrepDataImpl(const TgcPrepDataContainer* const* tgcPrepDataContainer,
                             const TgcCoinDataContainer* const* tgcCoinDataContainer) const;
      
      void selectDecoder(State& state,
                         const TgcRawData& rd,
                         const TgcRdo* rdoColl,
                         std::vector< std::unordered_map<IdentifierHash, std::unique_ptr<TgcPrepDataCollection> > >& collectionMap,
                         std::vector< std::unordered_map<IdentifierHash, std::unique_ptr<TgcCoinDataCollection> > >& coinMap) const;
 
      StatusCode decodeHits(State& state,
                            const TgcRawData& rd,
                            std::vector<std::unordered_map<IdentifierHash, std::unique_ptr<TgcPrepDataCollection> > >& collectionMap) const;
      StatusCode decodeTracklet(State& state,
                                const TgcRawData& rd,
                                std::vector< std::unordered_map<IdentifierHash, std::unique_ptr<TgcCoinDataCollection> > >& coinMap) const;
      StatusCode decodeTrackletEIFI(State& state,
                                    const TgcRawData& rd,
                                    std::vector< std::unordered_map<IdentifierHash, std::unique_ptr<TgcCoinDataCollection> > >& coinMap) const;
      StatusCode decodeHiPt(State& state,
                            const TgcRawData& rd,
                            std::vector< std::unordered_map<IdentifierHash, std::unique_ptr<TgcCoinDataCollection> > >& coinMap) const;
      StatusCode decodeInner(State& state,
                             const TgcRawData& rd,
                             std::vector< std::unordered_map<IdentifierHash, std::unique_ptr<TgcCoinDataCollection> > >& coinMap) const;
      StatusCode decodeSL(State& state,
                          const TgcRawData& rd,
                          const TgcRdo* rdoColl,
                          std::vector< std::unordered_map<IdentifierHash, std::unique_ptr<TgcCoinDataCollection> > >& coinMap) const;
      
      static int getbitpos(int channel, TgcRawData::SlbType slbType) ;
      static int getchannel(int bitpos, TgcRawData::SlbType slbType) ;
 
      static bool getRPhiEtafromXYZ(const double x, const double y, const double z, double& r,  double& phi, double& eta) ;
      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;
 
 
      void showIdentifierHash(const State& state) const;
      
      static bool isIdentifierHashFoundInAnyTgcPrepDataContainer(const State& state,
                                                          const IdentifierHash Hash) ;
      static bool isIdentifierHashFoundInAnyTgcCoinDataContainer(const State& state,
                                                          const IdentifierHash Hash) ;
      
      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 TgcRawData& rd, int& sswId_o, int& sbLoc_o, int& slbId_o) const;
 
      bool getSLIds(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 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 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) ;
 
      const CablingInfo*  getCabling() const;
 
      static const Amg::Vector2D* getSLLocalPosition(const MuonGM::TgcReadoutElement* readout, const Identifier, const double eta, const double phi) ; 
 
      TgcCoinDataCollection* getTgcCoinDataColFromMap(const IdentifierHash& tgcHashId, State& state, std::vector< std::unordered_map<IdentifierHash, std::unique_ptr<TgcCoinDataCollection> > >& coinMap, int locId, const Identifier& elementId) const;
 
      SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> m_muDetMgrKey {this, "DetectorManagerKey", "MuonDetectorManager", "Key of input MuonDetectorManager condition data"}; 
 
      ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
      
      /* TGC Cabling service */
      const ITGCcablingSvc* m_tgcCabling = nullptr;
 
      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"};
 
      virtual StatusCode decode(const EventContext& ctx, const std::vector<uint32_t>& robIds) const override; 
      virtual StatusCode provideEmptyContainer(const EventContext& ctx) 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);
      }
 
   }; 
} // end of namespace
 
#endif // MUONTGC_CNVTOOLS_TGCRDOTOPREPDATATOOLMT_H