RpcRdoToPrepDataToolMT.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONRDOTOPREPDATA_RPCRDOTOPREPDATATOOLMT_H
#define MUONRDOTOPREPDATA_RPCRDOTOPREPDATATOOLMT_H
 
 
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "MuonCablingData/RpcCablingMap.h"
#include "MuonCnvToolInterfaces/IMuonRdoToPrepDataTool.h"
#include "MuonCondData/RpcCondDbData.h"
#include "MuonIdHelpers/IMuonIdHelperSvc.h"
#include "MuonPrepRawData/MuonPrepDataCollection_Cache.h"
#include "MuonPrepRawData/MuonPrepDataContainer.h"
#include "MuonRDO/RpcCoinMatrix.h"
#include "MuonRDO/RpcPadContainer.h"
#include "MuonRPC_CnvTools/IRPC_RDO_Decoder.h"
#include "MuonReadoutGeometry/MuonDetectorManager.h"
#include "MuonTrigCoinData/MuonTrigCoinData_Cache.h"
#include "MuonTrigCoinData/RpcCoinDataContainer.h"
#include "RPC_CondCabling/RpcCablingCondData.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "xAODMuonRDO/NRPCRDOContainer.h"
 
#include <set>
#include <unordered_set>
#include <atomic>
#include <vector>
#include <cstdint>
 
namespace Muon {

 
class RpcRdoToPrepDataToolMT
    : public extends<AthAlgTool, IMuonRdoToPrepDataTool> {
 public:
 using base_class::base_class;
  // setup/teardown functions, similar like those for Algorithm/Service
  virtual StatusCode initialize() override;
 
  virtual StatusCode finalize() override;
 
  virtual StatusCode decode(const EventContext& ctx, 
                            const std::vector<IdentifierHash>& idVect) const override;
 
  virtual StatusCode decode(const EventContext& ctx,
                            const std::vector<uint32_t>& robIds) const override;
  virtual StatusCode provideEmptyContainer(const EventContext& ctx) const override;
  
 protected:
   struct State {
        State(const IMuonIdHelperSvc* idHelperSvc);
 
        RpcPrepDataCollection* getPrepCollection(const Identifier& id);
        RpcCoinDataCollection* getCoinCollection(const Identifier& id);
        
        
        const IMuonIdHelperSvc* m_idHelperSvc{nullptr};
 
        std::vector<std::unique_ptr<RpcPrepDataCollection>> rpcPrepDataCollections{};
        std::vector<std::unique_ptr<RpcCoinDataCollection>> rpcCoinDataCollections{};

        std::unique_ptr<RpcPrepDataContainer> prepDataCont{nullptr};
        std::unique_ptr<RpcCoinDataContainer> coinDataCont{nullptr};
 
 
        // keepTrackOfFullEventDecoding
        bool m_fullEventDone{false};
 
        // the set of already requested and decoded offline (PrepRawData)
        // collections
        std::unordered_set<IdentifierHash> m_decodedOfflineHashIds{};
 
        // the set of unrequested collections with phi hits stored with
        // ambiguityFlag > 1
        std::unordered_set<IdentifierHash> m_ambiguousCollections{};
 
        // the set of already requested and decoded ROBs
        std::unordered_set<uint32_t> m_decodedRobIds{};
   };

  StatusCode transferAndRecordPrepData(const EventContext& ctx,
                                       State& state) const;
  StatusCode transferAndRecordCoinData(const EventContext& ctx,
                                       State& state) const;
  StatusCode loadProcessedChambers(const EventContext& ctx, State& state) const;
 
  void printMTPrepData(const RpcPrepDataContainer& prepData) const;
  void printMTCoinData(const RpcCoinDataContainer& prepData) const;
 
  // decoding method
  StatusCode decodeImpl(const EventContext& ctx, State& state,
                        const std::vector<IdentifierHash>& idVect,
                        bool firstTimeInTheEvent) const;
  StatusCode decodeImpl(const EventContext& ctx, State& state,
                        const std::vector<uint32_t>& robIds,
                        bool firstTimeInTheEvent) const;
 
  StatusCode processPad(const EventContext& ctx, State& state,
                        const RpcPad* rdoColl, bool& processingetaview,
                        bool& processingphiview, int& nPrepRawData,
                        const std::vector<IdentifierHash>& idVect,
                        bool doingSecondLoopAmbigColls) const;
 
  void processTriggerHitHypothesis(RpcCoinMatrix::const_iterator itD,
                                   RpcCoinMatrix::const_iterator itD_end,
                                   bool highptpad,  // these are inputs
                                   bool& triggerHit, unsigned short& threshold,
                                   unsigned short& overlap, bool& toSkip) const;
 
  StatusCode processNrpcRdo(const EventContext& ctx, State& state) const;
 
 

  Gaudi::Property<float> m_etaphi_coincidenceTime{
      this, "etaphi_coincidenceTime", 20., "time for phi*eta coincidence"};

  Gaudi::Property<float> m_overlap_timeTolerance{
      this, "overlap_timeTolerance", 10.,
      "tolerance of the timing calibration"};
  Gaudi::Property<bool> m_producePRDfromTriggerWords{
      this, "produceRpcCoinDatafromTriggerWords", true,
      "tore as prd the trigger hits"};
  Gaudi::Property<bool> m_solvePhiAmbiguities{
      this, "solvePhiAmbiguities", true,
      "toggle on/off the removal of phi ambiguities"};
  Gaudi::Property<bool> m_reduceCablingOverlap{
      this, "reduceCablingOverlap", true, "toggle on/off the overlap removal"};
  Gaudi::Property<float> m_timeShift{this, "timeShift", -12.5,
                                     "any global time shift ?!"};
  Gaudi::Property<bool> m_decodeData{
      this, "DecodeData",
      true};  
  Gaudi::Property<bool> m_RPCInfoFromDb{this, "RPCInfoFromDb", false};  
 
  Gaudi::Property<bool> m_isMC{this, "isMC", false};
 
  SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> m_muDetMgrKey{
      this, "DetectorManagerKey", "MuonDetectorManager",
      "Key of input MuonDetectorManager condition data"};
 
  ServiceHandle<IMuonIdHelperSvc> m_idHelperSvc{
      this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

  SG::WriteHandleKey<RpcPrepDataContainer> m_rpcPrepDataContainerKey{
      this, "OutputCollection", "RPC_Measurements"};

  SG::WriteHandleKey<RpcCoinDataContainer> m_rpcCoinDataContainerKey{
      this, "TriggerOutputCollection", "RPC_triggerHits"};
 
  SG::ReadHandleKey<RpcPadContainer> m_rdoContainerKey{this, "RDOContainer",
                                                       "RPCPAD"};
 
  SG::ReadHandleKey<xAOD::NRPCRDOContainer> m_rdoNrpcContainerKey{
      this, "NrpcInputCollection", "NRPCRDO"};
 
  // Rob Data Provider handle
  ToolHandle<IRPC_RDO_Decoder> m_rpcRdoDecoderTool{
      this, "RdoDecoderTool", "Muon::RpcRDO_Decoder"};
 
  SG::ReadCondHandleKey<RpcCondDbData> m_readKey{
      this, "ReadKey", "RpcCondDbData", "Key of RpcCondDbData"};
  SG::ReadCondHandleKey<RpcCablingCondData> m_rpcReadKey{
      this, "RpcCablingKey", "RpcCablingCondData", "Key of RpcCablingCondData"};
  SG::ReadCondHandleKey<RpcCablingMap> m_nRpcCablingKey{this, "NrpcCablingKey","MuonNRPC_CablingMap",
                                                         "Key of MuonNRPC_CablingMap"};

  SG::UpdateHandleKey<RpcPrepDataCollection_Cache> m_prdContainerCacheKey{
      this, "RpcPrdContainerCacheKey", "",
      "Optional external cache for the RPC PRD container"};
  SG::UpdateHandleKey<RpcCoinDataCollection_Cache> m_coindataContainerCacheKey{
      this, "RpcCoinDataContainerCacheKey", "",
      "Optional external cache for the RPC coin data container"};
   
  Gaudi::Property<double> m_stripTimeResolution{this, "timeResolution", 0.6 * Gaudi::Units::nanosecond,
    "Estimated time resolution of the strip readout"};
 
 private:
  mutable std::atomic_int m_spuriousHitCounter{};
};
}  // namespace Muon
 
#endif  // !ATHEXJOBOPTIONS_CONCRETETOOL_H