Muon::RpcRdoToPrepDataToolMT Class Reference

#include <RpcRdoToPrepDataToolMT.h>

Inheritance diagram for Muon::RpcRdoToPrepDataToolMT:

Collaboration diagram for Muon::RpcRdoToPrepDataToolMT:

Classes
struct	State
	15 ns should be the max.diff. More...

Public Member Functions
	RpcRdoToPrepDataToolMT (const std::string &, const std::string &, const IInterface *)
virtual StatusCode	initialize () override
virtual StatusCode	decode (const EventContext &ctx, const std::vector< IdentifierHash > &idVect) const override
	This code is thread-safe as we will propagate local thread collection contents to a thread-safe one. More...
virtual StatusCode	decode (const EventContext &ctx, const std::vector< uint32_t > &robIds) const override
	This code is thread-safe as we will propagate local thread collection contents to a thread-safe one. More...
virtual StatusCode	provideEmptyContainer (const EventContext &ctx) const override

Protected Member Functions
StatusCode	transferAndRecordPrepData (const EventContext &ctx, State &state) const
	Stores the PrepData container into store gate. More...
StatusCode	transferAndRecordCoinData (const EventContext &ctx, State &state) const
	Stores the CoinData container into store gate. More...
StatusCode	loadProcessedChambers (const EventContext &ctx, State &state) const
	Load the hashes of the processed chambers. More...
void	printMTPrepData (const Muon::RpcPrepDataContainer &prepData) const
void	printMTCoinData (const Muon::RpcCoinDataContainer &prepData) const
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, bool &triggerHit, unsigned short &threshold, unsigned short &overlap, bool &toSkip) const
StatusCode	processNrpcRdo (const EventContext &ctx, State &state) const

Protected Attributes
Gaudi::Property< float >	m_etaphi_coincidenceTime
	3 ns is the resolution of the RPC readout electronics More...
Gaudi::Property< float >	m_overlap_timeTolerance
Gaudi::Property< bool >	m_producePRDfromTriggerWords
Gaudi::Property< bool >	m_solvePhiAmbiguities
Gaudi::Property< bool >	m_reduceCablingOverlap
Gaudi::Property< float >	m_timeShift
Gaudi::Property< bool >	m_decodeData
	toggle on/off the decoding of RPC RDO into RpcPerpData More...
Gaudi::Property< bool >	m_RPCInfoFromDb
	correct time prd from cool db More...
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_muDetMgrKey
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc
SG::WriteHandleKey< Muon::RpcPrepDataContainer >	m_rpcPrepDataContainerKey
	RpcPrepData containers. More...
SG::WriteHandleKey< Muon::RpcCoinDataContainer >	m_rpcCoinDataContainerKey
	RpcCoinData containers. More...
SG::ReadHandleKey< RpcPadContainer >	m_rdoContainerKey
SG::ReadHandleKey< xAOD::NRPCRDOContainer >	m_rdoNrpcContainerKey
ToolHandle< Muon::IRPC_RDO_Decoder >	m_rpcRdoDecoderTool
SG::ReadCondHandleKey< RpcCondDbData >	m_readKey
SG::ReadCondHandleKey< RpcCablingCondData >	m_rpcReadKey
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfo
SG::ReadCondHandleKey< MuonNRPC_CablingMap >	m_nRpcCablingKey
SG::UpdateHandleKey< RpcPrepDataCollection_Cache >	m_prdContainerCacheKey
	This is the key for the cache for the MDT PRD containers, can be empty. More...
SG::UpdateHandleKey< RpcCoinDataCollection_Cache >	m_coindataContainerCacheKey
SG::WriteHandleKey< xAOD::RpcStripContainer >	m_xAODKey

Detailed Description

Definition at line 35 of file RpcRdoToPrepDataToolMT.h.

Constructor & Destructor Documentation

RpcRdoToPrepDataToolMT()

Muon::RpcRdoToPrepDataToolMT::RpcRdoToPrepDataToolMT	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Definition at line 70 of file RpcRdoToPrepDataToolMT.cxx.

    : base_class(type, name, parent) {}

Member Function Documentation

decode() [1/2]

StatusCode Muon::RpcRdoToPrepDataToolMT::decode ( const EventContext &  ctx, const std::vector< IdentifierHash > &  idVect  ) const

overridevirtual

This code is thread-safe as we will propagate local thread collection contents to a thread-safe one.

Definition at line 157 of file RpcRdoToPrepDataToolMT.cxx.

                                                                                               {
  ATH_MSG_DEBUG(
      "Calling Core decode function from MT decode function (hash vector)");
  State state(m_idHelperSvc->rpcIdHelper(), m_xAODKey, ctx);
  ATH_CHECK(loadProcessedChambers(ctx, state));
 
  ATH_CHECK(decodeImpl(ctx, state, idVect, true));
  ATH_CHECK(processNrpcRdo(ctx, state));
  ATH_MSG_DEBUG("Core decode processed in MT decode (hash vector)");
 
  ATH_CHECK(transferAndRecordPrepData(ctx, state));
  ATH_CHECK(transferAndRecordCoinData(ctx, state));
 
  return StatusCode::SUCCESS;
}

decode() [2/2]

StatusCode Muon::RpcRdoToPrepDataToolMT::decode ( const EventContext &  ctx, const std::vector< uint32_t > &  robIds  ) const

overridevirtual

This code is thread-safe as we will propagate local thread collection contents to a thread-safe one.

Definition at line 176 of file RpcRdoToPrepDataToolMT.cxx.

                                                                      {
  ATH_MSG_DEBUG(
      "Calling Core decode function from MT decode function (ROB vector)");
  State state(m_idHelperSvc->rpcIdHelper(), m_xAODKey, ctx);
  ATH_CHECK(loadProcessedChambers(ctx, state));
 
  ATH_CHECK(decodeImpl(ctx, state, robIds, true));
  ATH_CHECK(processNrpcRdo(ctx, state));
  ATH_MSG_DEBUG("Core decode processed in MT decode (ROB vector)");
 
  ATH_CHECK(transferAndRecordPrepData(ctx, state));
  ATH_CHECK(transferAndRecordCoinData(ctx, state));
 
  return StatusCode::SUCCESS;
}

decodeImpl() [1/2]

StatusCode Muon::RpcRdoToPrepDataToolMT::decodeImpl ( const EventContext &  ctx, State &  state, const std::vector< IdentifierHash > &  idVect, bool  firstTimeInTheEvent  ) const

protected

RPC context

here the RDO container is retrieved and filled -whatever input type we start with- => check the size

Definition at line 272 of file RpcRdoToPrepDataToolMT.cxx.

                                                                                    {
  int sizeVectorRequested = idVect.size();
  ATH_MSG_DEBUG("Decode method called for " << sizeVectorRequested
                                            << " offline collections");
  if (sizeVectorRequested == 0)
    ATH_MSG_DEBUG("Decoding the entire event");
 
  // create an empty vector of hash ids to be decoded (will be filled if
  // RoI-based and left empty if full-scan)
  std::vector<IdentifierHash> idVectToBeDecoded;
  idVectToBeDecoded.reserve(idVect.size());
 
  if (firstTimeInTheEvent) {
    state.m_fullEventDone = sizeVectorRequested == 0;
  } else {
    if (state.m_fullEventDone) {
      ATH_MSG_DEBUG("Whole event has already been decoded; nothing to do.");
      return StatusCode::SUCCESS;
    }
    if (sizeVectorRequested == 0)
      state.m_fullEventDone = true;
  }
 
  if (sizeVectorRequested != 0) {
    // the program goes in here only if RoI-based decoding has been called and
    // the full event is not already decoded this code ensures decoding of every
    // offline hash id is called only once
    for (const IdentifierHash& itHashId : idVect) {
      if (state.m_decodedOfflineHashIds.insert(itHashId).second)
        idVectToBeDecoded.push_back(itHashId);
    }
    if (idVectToBeDecoded.empty()) {
      ATH_MSG_DEBUG(
          "All requested offline collections have already been decoded; "
          "nothing to do.");
      return StatusCode::SUCCESS;
    } else {
      ATH_MSG_DEBUG(idVectToBeDecoded.size()
                    << " offline collections have not yet been decoded and "
                       "will be decoded now.");
      if (msgLvl(MSG::VERBOSE)) {
        ATH_MSG_VERBOSE(
            "The list of offline collection hash ids to be decoded:");
        for (const IdentifierHash& itHashId : idVectToBeDecoded)
          ATH_MSG_VERBOSE(itHashId << " ");
      }
    }
  }
 
  // if RPC decoding is switched off stop here
  if (!m_decodeData) {
    ATH_MSG_DEBUG(
        "Stored empty container. Decoding RPC RDO into RPC PrepRawData is "
        "switched off");
    return StatusCode::SUCCESS;
  }
 
  ATH_MSG_DEBUG("Decoding RPC RDO into RPC PrepRawData");
 
  SG::ReadCondHandle<RpcCablingCondData> cablingCondData{m_rpcReadKey, ctx};
  const RpcCablingCondData* rpcCabling{*cablingCondData};
 
  // if the vector requested has size 0, we need to perform a scan of the entire
  // RDO container otherwise select the pads to be decoded
  std::vector<IdentifierHash> rdoHashVec;
  if (sizeVectorRequested != 0) {
    ATH_MSG_DEBUG(
        "Looking for pads IdHash to be decoded for the requested collection "
        "Ids");
    ATH_CHECK(rpcCabling->giveRDO_fromPRD(idVectToBeDecoded, rdoHashVec));
  }
 
  IdContext rpcContext = m_idHelperSvc->rpcIdHelper().module_context();
 
  // we come here if the rdo container is already in SG (for example in MC RDO!)
  ATH_MSG_DEBUG("Retrieving Rpc PAD container from the store");
  auto rdoContainerHandle = SG::makeHandle(m_rdoContainerKey, ctx);
  if (!rdoContainerHandle.isValid()) {
    ATH_MSG_ERROR("Retrieval of RPC RDO container failed !");
    return StatusCode::FAILURE;
  }
 
  if (rdoContainerHandle->numberOfCollections() == 0) {
    // empty pad container - no rpc rdo in this event
    ATH_MSG_DEBUG("Empty pad container - no rpc rdo in this event ");
    return StatusCode::SUCCESS;
  }
  ATH_MSG_DEBUG("Not empty pad container in this event ");
 
  // start here to process the RDO (for the full event of for a fraction of it)
  bool processingetaview{true}, processingphiview{false};
  if (!m_solvePhiAmbiguities)
    processingetaview = false;
  bool doingSecondLoopAmbigColls = false;
  while (processingetaview || processingphiview || (!m_solvePhiAmbiguities)) {
    int ipad{0}, nPrepRawData{0}, nPhiPrepRawData{0}, nEtaPrepRawData{0};
    if (processingphiview)
      state.m_ambiguousCollections.clear();
    if (msgLvl(MSG::DEBUG)) {
      if (processingetaview)
        ATH_MSG_DEBUG("*** Processing eta view ");
      else
        ATH_MSG_DEBUG("*** Processing phi view ");
    }
    // seeded decoding
    if (sizeVectorRequested != 0) {
      ATH_MSG_DEBUG("Start loop over pads hashes - seeded mode ");
      for (const IdentifierHash& iPadHash : rdoHashVec) {
        const RpcPad* rdoColl = rdoContainerHandle->indexFindPtr(iPadHash);
        if (!rdoColl) {
          ATH_MSG_DEBUG("Requested pad with online id "
                        << iPadHash << " not found in the rdoContainerHandle.");
          continue;
        }
        ++ipad;
 
        ATH_MSG_DEBUG("A new pad here n. " << ipad << ", online id "
                                           << (int)(rdoColl->identifyHash())
                                           << ", with " << rdoColl->size()
                                           << " CM inside ");
        ATH_CHECK(processPad(ctx, state, rdoColl, processingetaview,
                             processingphiview, nPrepRawData, idVectToBeDecoded, doingSecondLoopAmbigColls));
 
      }       // end loop over requested pads hashes
    } else {  // unseeded // whole event
      ATH_MSG_DEBUG("Start loop over pads - unseeded mode ");
      for (const RpcPad* rdoColl : *rdoContainerHandle) {
        // loop over all elements of the pad container
        if (rdoColl->empty())
          continue;
        ++ipad;
        ATH_MSG_DEBUG("A new pad here n. " << ipad << ", online id "
                                           << (int)(rdoColl->identifyHash())
                                           << ", with " << rdoColl->size()
                                           << " CM inside ");
 
        ATH_CHECK(processPad(ctx, state, rdoColl, processingetaview,
                             processingphiview, nPrepRawData, idVectToBeDecoded, doingSecondLoopAmbigColls));
      }  // end loop over pads
    }
 
    if (processingetaview) {
      processingetaview = false;
      processingphiview = true;
      nEtaPrepRawData = nPrepRawData;
      ATH_MSG_DEBUG("*** " << nEtaPrepRawData << " eta PrepRawData registered");
    } else {
      processingphiview = false;
      nPhiPrepRawData = nPrepRawData - nEtaPrepRawData;
      ATH_MSG_DEBUG("*** " << nPhiPrepRawData << " phi PrepRawData registered");
      if (!state.m_ambiguousCollections.empty()) {
        // loop again for unrequested collections stored with ambiguous phi hits
        doingSecondLoopAmbigColls = true;
        processingetaview = true;
        ATH_MSG_DEBUG(state.m_ambiguousCollections.size()
                      << " ambiguous collections were stored:");
        idVectToBeDecoded.clear();
        rdoHashVec.clear();
        for (const IdentifierHash& itAmbiColl : state.m_ambiguousCollections) {
          ATH_MSG_DEBUG((int)itAmbiColl << " ");
          idVectToBeDecoded.push_back(itAmbiColl);
          state.m_decodedOfflineHashIds.insert(itAmbiColl);
        }
        ATH_CHECK(rpcCabling->giveRDO_fromPRD(idVectToBeDecoded, rdoHashVec));
      }
    }
    if (!m_solvePhiAmbiguities) {
      ATH_MSG_DEBUG("*** " << nPrepRawData << " PrepRawData registered");
      break;
    }
  }
 
  ATH_MSG_DEBUG("*** Final Cleanup ");
  return StatusCode::SUCCESS;
}

decodeImpl() [2/2]

StatusCode Muon::RpcRdoToPrepDataToolMT::decodeImpl ( const EventContext &  ctx, State &  state, const std::vector< uint32_t > &  robIds, bool  firstTimeInTheEvent  ) const

protected

Definition at line 455 of file RpcRdoToPrepDataToolMT.cxx.

                                    {
  // ROB-based decoding is only applied in seeded mode. Full scan should use the
  // hashId-based method with empty requested collections vector.
 
  int sizeVectorRequested = robIds.size();
  ATH_MSG_DEBUG("Decode method called for " << sizeVectorRequested << " ROBs");
 
  std::vector<uint32_t> robIdsToBeDecoded;
  robIdsToBeDecoded.reserve(robIds.size());
 
  if (firstTimeInTheEvent) {
    state.m_fullEventDone = false;
  } else {
    if (state.m_fullEventDone) {
      ATH_MSG_DEBUG("Whole event has already been decoded; nothing to do.");
      return StatusCode::SUCCESS;
    }
  }
 
  // check which of the requested robs are not yet decoded
  for (uint32_t robid : robIds) {
    if (state.m_decodedRobIds.insert(robid).second)
      robIdsToBeDecoded.push_back(robid);
  }
 
  if (robIdsToBeDecoded.empty()) {
    ATH_MSG_DEBUG(
        "All requested ROBs have already been decoded; nothing to do.");
    return StatusCode::SUCCESS;
  }
  ATH_MSG_DEBUG(robIdsToBeDecoded.size()
                << " ROBs have not yet been decoded and will be decoded now.");
  if (msgLvl(MSG::VERBOSE)) {
    ATH_MSG_VERBOSE("The list of ROB Ids to be decoded:");
    for (uint32_t robid : robIdsToBeDecoded)
      ATH_MSG_VERBOSE("0x" << MSG::hex << robid << MSG::dec << " ");
  }
 
  SG::ReadCondHandle<RpcCablingCondData> cablingCondData{m_rpcReadKey, ctx};
  const RpcCablingCondData* rpcCabling{*cablingCondData};
 
  // if all robs will be decoded after the current execution of the method, set
  // the flag m_fullEventDone
  if (state.m_decodedRobIds.size() == rpcCabling->giveFullListOfRobIds().size())
    state.m_fullEventDone = true;
 
  // if RPC decoding is switched off stop here
  if (!m_decodeData) {
    ATH_MSG_DEBUG(
        "Stored empty container. Decoding RPC RDO into RPC PrepRawData is "
        "switched off");
    return StatusCode::SUCCESS;
  }
 
  ATH_MSG_DEBUG("Decoding RPC RDO into RPC PrepRawData");
 
  // we come here if the rdo container is already in SG (for example in MC RDO!)
  ATH_MSG_DEBUG("Retrieving Rpc PAD container from the store");
  auto rdoContainerHandle = SG::makeHandle(m_rdoContainerKey, ctx);
  if (!rdoContainerHandle.isValid()) {
    ATH_MSG_WARNING("Retrieval of RPC RDO container failed !");
    return StatusCode::SUCCESS;
  }
 
  // here the RDO container is retrieved and filled -whatever input type we
  // start with- => check the size
  if (rdoContainerHandle->empty()) {
    // empty pad container - no rpc rdo in this event
    ATH_MSG_DEBUG("Empty pad container - no rpc rdo in this event ");
    return StatusCode::SUCCESS;
  }
  ATH_MSG_DEBUG("Not empty pad container in this event ");
 
  // obtain a list of PADs (RDOs) to be processed
  std::vector<IdentifierHash> rdoHashVec;
  rdoHashVec.reserve(
      13 * robIdsToBeDecoded.size());  // most ROBs have 13 RDOs, some have less
  ATH_CHECK(rpcCabling->giveRDO_fromROB(robIdsToBeDecoded, rdoHashVec));
 
  // start here to process the RDOs
  bool processingetaview = true;
  bool processingphiview = false;
  if (!m_solvePhiAmbiguities)
    processingetaview = false;
  while (processingetaview || processingphiview || (!m_solvePhiAmbiguities)) {
    int ipad{0}, nPrepRawData{0}, nPhiPrepRawData{0}, nEtaPrepRawData{0};
    if (processingphiview)
      state.m_ambiguousCollections.clear();
 
    if (processingetaview)
      ATH_MSG_DEBUG("*** Processing eta view ");
    else
      ATH_MSG_DEBUG("*** Processing phi view ");
 
    // seeded decoding (for full scan, use the hashId-based method)
    ATH_MSG_DEBUG("Start loop over pads hashes - seeded mode ");
 
    for (const IdentifierHash& padHashId : rdoHashVec) {
      const RpcPad* rdoColl = rdoContainerHandle->indexFindPtr(padHashId);
      if (!rdoColl) {
        ATH_MSG_DEBUG("Requested pad with online id "
                      << (unsigned int)padHashId
                      << " not found in the rdoContainerHandle.");
        continue;
      }
      ++ipad;
      ATH_MSG_DEBUG("A new pad here n."
                    << ipad << ", online id " << (int)(rdoColl->identifyHash())
                    << ", with " << rdoColl->size() << " CM inside ");
      CHECK(processPad(ctx, state, rdoColl, processingetaview,
                       processingphiview, nPrepRawData, rdoHashVec, false));
    }
 
    if (processingetaview) {
      processingetaview = false;
      processingphiview = true;
      nEtaPrepRawData = nPrepRawData;
      ATH_MSG_DEBUG("*** " << nEtaPrepRawData << " eta PrepRawData registered");
    } else {
      processingphiview = false;
      nPhiPrepRawData = nPrepRawData - nEtaPrepRawData;
      ATH_MSG_DEBUG("*** " << nPhiPrepRawData << " phi PrepRawData registered");
    }
    if (!m_solvePhiAmbiguities) {
      ATH_MSG_DEBUG("*** " << nPrepRawData << " PrepRawData registered");
      break;
    }
  }
 
  ATH_MSG_DEBUG("*** Final Cleanup ");
  
  return StatusCode::SUCCESS;
  
}

initialize()

StatusCode Muon::RpcRdoToPrepDataToolMT::initialize ( )

overridevirtual

Definition at line 76 of file RpcRdoToPrepDataToolMT.cxx.

                                                  {
  // perform necessary one-off initialization
 
  ATH_MSG_INFO("properties are ");
  ATH_MSG_INFO("produceRpcCoinDatafromTriggerWords "
               << m_producePRDfromTriggerWords);
  ATH_MSG_INFO("reduceCablingOverlap               " << m_reduceCablingOverlap);
  ATH_MSG_INFO("solvePhiAmbiguities                " << m_solvePhiAmbiguities);
  ATH_MSG_INFO("timeShift                          " << m_timeShift);
  if (m_solvePhiAmbiguities && (!m_reduceCablingOverlap)) {
    ATH_MSG_WARNING(
        "Inconsistent setting of properties (solvePhiAmbiguities entails "
        "reduceCablingOverlap)");
    ATH_MSG_WARNING("Resetting reduceCablingOverlap to true");
    m_reduceCablingOverlap = true;
  }
  ATH_MSG_INFO("etaphi_coincidenceTime             "
               << m_etaphi_coincidenceTime);
  ATH_MSG_INFO("overlap_timeTolerance              "
               << m_overlap_timeTolerance);
  ATH_MSG_INFO("Correct prd time from cool db      " << m_RPCInfoFromDb);
  ATH_CHECK(m_rpcRdoDecoderTool.retrieve());
  ATH_CHECK(m_idHelperSvc.retrieve());
  ATH_CHECK(m_rpcReadKey.initialize());
  ATH_CHECK(m_readKey.initialize(m_RPCInfoFromDb));
  ATH_CHECK(m_rdoContainerKey.initialize());
  ATH_CHECK(m_rdoNrpcContainerKey.initialize(!m_rdoNrpcContainerKey.empty()));
  ATH_CHECK(m_nRpcCablingKey.initialize(!m_rdoNrpcContainerKey.empty()));  
  // If we don't configure the NRPC RDO
  // key, the cabling is needed either.
  ATH_CHECK(m_rpcPrepDataContainerKey.initialize());
  ATH_CHECK(m_rpcCoinDataContainerKey.initialize());
  ATH_CHECK(m_eventInfo.initialize());
  ATH_CHECK(m_muDetMgrKey.initialize());
  ATH_CHECK(m_prdContainerCacheKey.initialize(SG::AllowEmpty));
  ATH_CHECK(m_coindataContainerCacheKey.initialize(SG::AllowEmpty));
  ATH_CHECK(m_xAODKey.initialize(!m_xAODKey.empty()));
  return StatusCode::SUCCESS;
}

loadProcessedChambers()

StatusCode Muon::RpcRdoToPrepDataToolMT::loadProcessedChambers ( const EventContext &  ctx, State &  state  ) const

protected

Load the hashes of the processed chambers.

Definition at line 115 of file RpcRdoToPrepDataToolMT.cxx.

                                                 {
  if (!m_prdContainerCacheKey.key().empty()) {
    SG::UpdateHandle<RpcPrepDataCollection_Cache> update{m_prdContainerCacheKey,
                                                         ctx};
    if (!update.isValid()) {
      ATH_MSG_FATAL("Invalid UpdateHandle " << m_prdContainerCacheKey.key());
      return StatusCode::FAILURE;
    }
    state.m_prepDataCont =
        std::make_unique<Muon::RpcPrepDataContainer>(update.ptr());
    for (const RpcPrepDataCollection* coll : *state.m_prepDataCont) {
      state.m_decodedOfflineHashIds.insert(coll->identifyHash());
    }
  } else
    state.m_prepDataCont = std::make_unique<Muon::RpcPrepDataContainer>(
        m_idHelperSvc->rpcIdHelper().module_hash_max());
 
  if (m_coindataContainerCacheKey.key().empty()) {
    // without the cache we just record the container
    state.m_coinDataCont = std::make_unique<Muon::RpcCoinDataContainer>(
        m_idHelperSvc->rpcIdHelper().module_hash_max());
  } else {
    // use the cache to get the container
    SG::UpdateHandle<RpcCoinDataCollection_Cache> update{
        m_coindataContainerCacheKey, ctx};
    if (!update.isValid()) {
      ATH_MSG_FATAL("Invalid UpdateHandle "
                    << m_coindataContainerCacheKey.key());
      return StatusCode::FAILURE;
    }
    state.m_coinDataCont =
        std::make_unique<Muon::RpcCoinDataContainer>(update.ptr());
    for (const RpcCoinDataCollection* coll : *state.m_coinDataCont) {
      state.m_decodedOfflineHashIds.insert(coll->identifyHash());
    }
  }
 
  return StatusCode::SUCCESS;
}

printMTCoinData()

void Muon::RpcRdoToPrepDataToolMT::printMTCoinData ( const Muon::RpcCoinDataContainer &  prepData ) const

protected

printMTPrepData()

void Muon::RpcRdoToPrepDataToolMT::printMTPrepData ( const Muon::RpcPrepDataContainer &  prepData ) const

protected

processNrpcRdo()

StatusCode Muon::RpcRdoToPrepDataToolMT::processNrpcRdo ( const EventContext &  ctx, State &  state  ) const

protected

No need to check for its validity. It's done at other places for sure

Convert from online to offline cabling

That needs to be parsed to the constructor of the PRD somehow...

Definition at line 1112 of file RpcRdoToPrepDataToolMT.cxx.

                                                                            {
  if (m_rdoNrpcContainerKey.empty()) {
    ATH_MSG_DEBUG("The NRPC processing is disabled.");
    return StatusCode::SUCCESS;
  }
 
  ATH_MSG_DEBUG("Retrieving Nrpc RDO container from the store");
  SG::ReadHandle<xAOD::NRPCRDOContainer> rdoNrpcContainerHandle{
      m_rdoNrpcContainerKey, ctx};
  if (!rdoNrpcContainerHandle.isPresent()) {
    ATH_MSG_ERROR("Retrieval of NRPC RDO " << m_rdoNrpcContainerKey.fullKey()
                                           << " container failed !");
    return StatusCode::FAILURE;
  }
 
  if (rdoNrpcContainerHandle->empty()) {
    // empty NRPC RDO container - no nrpc rdo in this event
    ATH_MSG_DEBUG("Empty NRPC RDO container - no nrpc rdo in this event ");
    return StatusCode::SUCCESS;
  }
  ATH_MSG_DEBUG("Not empty NRPC RDO container in this event ");
 
  SG::ReadCondHandle<MuonNRPC_CablingMap> readCdo{m_nRpcCablingKey, ctx};
  if (!readCdo.isValid()) {
    ATH_MSG_ERROR("Could not retrieve " << m_nRpcCablingKey.fullKey()
                                        << " from the conditions store");
    return StatusCode::FAILURE;
  }
  SG::ReadCondHandle<MuonGM::MuonDetectorManager> muDetMgr{m_muDetMgrKey, ctx};
 
  for (const xAOD::NRPCRDO* nrpcrdo : *rdoNrpcContainerHandle) {
    NrpcCablingData cabling_data{};
    cabling_data.subDetector = nrpcrdo->subdetector();
    cabling_data.tdcSector = nrpcrdo->tdcsector();
    cabling_data.tdc = nrpcrdo->tdc();
    cabling_data.channelId = nrpcrdo->channel();
    Identifier chanId{};
    if (!readCdo->getOfflineId(cabling_data, msgStream()) ||
        !readCdo->convert(cabling_data, chanId, false)) {
      ATH_MSG_FATAL("Failed to retrieve the offline Identifier");
      return StatusCode::FAILURE;
    }
    const IdentifierHash rpcHashId = m_idHelperSvc->moduleHash(chanId);
    RpcPrepDataCollection* collection =
        state.getPrepCollection(rpcHashId, msgStream());
 
    const RpcReadoutElement* descriptor =
        muDetMgr->getRpcReadoutElement(chanId);
 
    // List of Digits in the cluster (self)
    std::vector<Identifier> identifierList{chanId};
    // Global position
    const Amg::Vector3D stripPos{descriptor->stripPos(chanId)};
    ATH_MSG_DEBUG("RPC RDO->PrepRawdata " << m_idHelperSvc->toString(chanId)
                                          << " global position "
                                          << Amg::toString(stripPos, 2));
    // Local position
    Amg::Vector2D pointLocPos{Amg::Vector2D::Zero()};
    descriptor->surface(chanId).globalToLocal(stripPos, stripPos, pointLocPos);
    // width of the cluster (self)
 
    const double stripWidth = descriptor->StripWidth(
        m_idHelperSvc->rpcIdHelper().measuresPhi(chanId));
    // Error matrix
    const double errPos = stripWidth / std::sqrt(12.0);
    Amg::MatrixX mat(1, 1);
    mat.setIdentity();
    mat *= errPos * errPos;
 
    int ambiguityFlag = 0;  // Ambiguity flag not checked for BIS RPCs
 
    const float time = nrpcrdo->time();
    const float timeoverthr = nrpcrdo->timeoverthr();
 
    RpcPrepData* newPrepData =
        new RpcPrepData(chanId, rpcHashId, pointLocPos, identifierList, mat,
                        descriptor, time, timeoverthr, 0, ambiguityFlag);
 
    newPrepData->setHashAndIndex(collection->identifyHash(),
                                 collection->size());
    collection->push_back(newPrepData);
  }
  return StatusCode::SUCCESS;
}

processPad()

StatusCode Muon::RpcRdoToPrepDataToolMT::processPad ( const EventContext &  ctx, State &  state, const RpcPad *  rdoColl, bool &  processingetaview, bool &  processingphiview, int &  nPrepRawData, const std::vector< IdentifierHash > &  idVect, bool  doingSecondLoopAmbigColls  ) const

protected

Definition at line 592 of file RpcRdoToPrepDataToolMT.cxx.

                                          {
 
  const RpcIdHelper& idHelper = m_idHelperSvc->rpcIdHelper();
 
  std::set<IdentifierHash>& ambiguousCollections{state.m_ambiguousCollections};
  ATH_MSG_DEBUG("***************** Start of processPad eta/phiview "
                << processingetaview << "/" << processingphiview);
  //{processPad
  // Get pad online id and sector id
  uint16_t padId = rdoColl->onlineId();
  uint16_t sectorId = rdoColl->sector();
  ATH_MSG_DEBUG("***************** for Pad online Id "
                << padId << " m_logic sector ID " << sectorId);
 
  // Create an RPC PrepDataCollection
  Identifier oldId{0}, oldIdTrg{0};
  ATH_MSG_VERBOSE("Init pointer to RpcPrepDataCollection ");
  RpcPrepDataCollection* collection{nullptr};
  RpcCoinDataCollection* collectionTrg{nullptr};
  IdentifierHash rpcHashId{0};
 
  SG::ReadCondHandle<RpcCablingCondData> rpcCabling{m_rpcReadKey, ctx};
 
  // For each pad, loop on the coincidence matrices
  RpcPad::const_iterator itCM = rdoColl->begin();
  RpcPad::const_iterator itCM_e = rdoColl->end();
  int icm = 0;
  SG::ReadHandle<xAOD::EventInfo> evtInfo{m_eventInfo, ctx};
  for (; itCM != itCM_e; ++itCM) {
    icm++;
    bool etaview = false;
    if (!evtInfo->eventType(xAOD::EventInfo::IS_SIMULATION))
      etaview = true;
    bool highPtCm = false;
    // Get CM online Id
    uint16_t cmaId = (*itCM)->onlineId();
    ATH_MSG_DEBUG("A new CM here n. "
                  << icm << " CM online ID " << cmaId
                  << " with n. of hits =  " << (*itCM)->size());
    if (cmaId < 4) {
      ATH_MSG_DEBUG(" low pt ");
      if (cmaId < 2) {
        etaview = true;
        if (!evtInfo->eventType(xAOD::EventInfo::IS_SIMULATION)) {
          etaview = false;
        }
        ATH_MSG_DEBUG(" eta view = " << etaview);
      }
 
      else {
        ATH_MSG_DEBUG(" eta view = " << etaview);
      }
    } else {
      ATH_MSG_DEBUG(" high pt ");
      highPtCm = true;
      if (cmaId < 6) {
        etaview = true;
        if (!evtInfo->eventType(xAOD::EventInfo::IS_SIMULATION)) {
          etaview = false;
        }
        ATH_MSG_DEBUG(" eta view = " << etaview);
      } else {
        ATH_MSG_DEBUG(" eta view = " << etaview);
      }
    }
 
    if (processingetaview && (!etaview))
      continue;
    if (processingphiview && etaview)
      continue;
 
    // For each CM, loop on the fired channels
    RpcCoinMatrix::const_iterator itD = (*itCM)->begin();
    RpcCoinMatrix::const_iterator itD_e = (*itCM)->end();
    int idata = 0;
    if (itD == itD_e) {
      ATH_MSG_DEBUG("Empty CM");
    }
    for (; itD != itD_e; ++itD) {
      idata++;
      // trigger related quantities
      unsigned short threshold = 99;
      unsigned short overlap = 99;
 
      // flags defining the processing mode of this hit
      bool solvePhiAmb_thisHit = m_solvePhiAmbiguities;
      bool reduceCablOvl_thisHit = m_reduceCablingOverlap;
 
      ATH_MSG_DEBUG("A new CM Hit " << idata);
      const RpcFiredChannel* rpcChan = (*itD);
      if (msgLvl(MSG::DEBUG)) {
        ATH_MSG_DEBUG("RpcFiredChannel: bcid " << rpcChan->bcid() << " time "
                                               << rpcChan->time() << " ijk "
                                               << rpcChan->ijk());
        if (rpcChan->ijk() < 7)
          ATH_MSG_DEBUG(" ch " << rpcChan->channel());
      }
 
      // check if trigger hit
      // select the cases: ijk = 0 and high p, ijk= 6, ijk=7
      bool triggerHit = false;
      bool toSkip = false;
      processTriggerHitHypothesis(itD, itD_e, highPtCm, triggerHit, threshold,
                                  overlap, toSkip);
      if (toSkip)
        continue;
      if (triggerHit) {
        // here ijk = 6 or ijk = 0 in high pt cm
        // keep all pivot + trigger info (even if duplicated [should never
        // happen, for pivot hits])
        solvePhiAmb_thisHit = false;
        reduceCablOvl_thisHit = false;
        ATH_MSG_DEBUG(
            "RpcFiredChannel: it's a triggerHit or a lowPt coinc. in a high pt "
            "CM \n"
            << "    ijk = " << rpcChan->ijk() << " isHighPtCM " << highPtCm
            << " thr/ovl = " << threshold << "/" << overlap);
      }
 
      // here decode (get offline ids for the online indices of this hit)
      double time = 0.;
      std::vector<Identifier> digitVec{m_rpcRdoDecoderTool->getOfflineData(
          rpcChan, sectorId, padId, cmaId, time, rpcCabling.cptr())};
      time += (double)m_timeShift;
 
      int nMatchingEtaHits = 0;
      int nDuplicatePhiHits = 0;
      bool unsolvedAmbiguity = false;
      bool notFinished = true;
      // allow for 2 iterations in case there are phi digits without matching
      // eta (eta inefficiency) all eta digits, not already recorded, will be
      // registered as PrepRawData and all phi digits, not yet recorded and with
      // a eta digit in the same module and gap, will produce a PrepRawData. Phi
      // digits without a eta match will not be recorded at the first iteration.
      // If all phi digits do not have a eta match, they will be all recorded as
      // PrepRawData in the second iteration (the ambiguity will remain
      // unsolved)
      while (notFinished) {
        // Loop on the digits corresponding to the fired channel
        ATH_MSG_DEBUG(
            "size of the corresponding list of ID = " << digitVec.size());
        if (digitVec.empty()) {
          ATH_MSG_DEBUG("going to next CM hit");
          notFinished = false;
          continue;
        }
        for (const Identifier& channelId : digitVec) {
          // Prepare the prepdata for this identifier
          // channel Id
          rpcHashId = m_idHelperSvc->moduleHash(channelId);
          const Identifier parentId = idHelper.parentID(channelId);
 
          // There is some ambiguity in the channel/sectorId's, so need to
          // explicitly filter out hashIDs outside of the RoI in seeded decoding
          // mode
          if (!idVect.empty() && 
               std::find(idVect.begin(), idVect.end(), rpcHashId) == idVect.end()) {
              continue;
          }
          ATH_MSG_DEBUG("CM Hit decoded into offline Id "
                          << m_idHelperSvc->toString(channelId) << " time "
                          << time);
          ATH_MSG_DEBUG(" oldID = " << m_idHelperSvc->toString(oldId) << 
                          " oldIDtrg = " << m_idHelperSvc->toString(oldIdTrg));
          bool hasAMatchingEtaHit = 0;
          // current collection has Id "parentId"; get it from the container !
          if (triggerHit) {
            if ((oldIdTrg != parentId) || !collectionTrg) {
              // Get collection from IDC if it exists, or create it and add it
              // if not.
              ATH_MSG_DEBUG(" Looking/Creating a collection with ID = "
                            << m_idHelperSvc->toString(parentId) << " hash = "
                            << static_cast<unsigned int>(rpcHashId));
              collectionTrg = state.getCoinCollection(rpcHashId, msgStream());
              oldIdTrg = parentId;
              ATH_MSG_DEBUG(" Resetting oldIDtrg to current parentID = "
                            << m_idHelperSvc->toString(oldIdTrg));
            }
          } else if ((oldId != parentId) || !collection) {
            // Get collection from IDC if it exists, or create it and add it if
            // not.
            ATH_MSG_DEBUG(" Looking/Creating a collection with ID = "
                          << m_idHelperSvc->toString(parentId) << " hash = "
                          << static_cast<unsigned int>(rpcHashId));
            collection = state.getPrepCollection(rpcHashId, msgStream());
            oldId = parentId;
            ATH_MSG_DEBUG(" Resetting oldID to current parentID = "
                          << m_idHelperSvc->toString(oldId));
          }
 
          // check if the data has already been recorded
          // (if you want to reduce the redundancy due to cabling overlap and if
          // the collection is not empty)
          bool duplicate = false;
          if (reduceCablOvl_thisHit) {
            if (collection->begin() != collection->end()) {
              RpcPrepDataCollection::iterator it_rpcPrepData;
              ATH_MSG_VERBOSE("Check for duplicates in coll. with size "
                              << collection->size());
              int current_dbphi{0}, current_dbz{0}, current_gg{0};
              if (processingphiview) {
                current_dbphi =
                    m_idHelperSvc->rpcIdHelper().doubletPhi(channelId);
                current_dbz = m_idHelperSvc->rpcIdHelper().doubletZ(channelId);
                current_gg = m_idHelperSvc->rpcIdHelper().gasGap(channelId);
                ATH_MSG_VERBOSE(
                    "Check also for eta hits matching dbz, dbphi, gg  "
                    << current_dbz << " " << current_dbphi << " "
                    << current_gg);
              }
 
              for (RpcPrepData* rpc : *collection) {
                if (channelId == rpc->identify() &&
                    fabs(time - rpc->time()) < m_overlap_timeTolerance) {
                  duplicate = true;
                  hasAMatchingEtaHit = false;  // we don't want to increment the
                                               // number of strips with
                  // a matching eta due to a cabling overlap
                  ATH_MSG_VERBOSE("Duplicated RpcPrepData(not recorded) = "
                                  << m_idHelperSvc->toString(channelId));
                  float previous_time = rpc->time();
                  // choose the smallest time within timeTolerance
                  if (time < previous_time) {
                    rpc->m_time = time;
                    ATH_MSG_DEBUG(
                        "time of the prd previously stored is now updated with "
                        "current hit time: "
                        << previous_time << " -> " << rpc->time());
                  }
                  break;  // this break is why we cannot have
                          //        solvePhiAmb_thisHit = true and
                          //        reduceCablOvl_thisHit= false
                }
                if (processingphiview) {
                  if (solvePhiAmb_thisHit) {
                    if (!unsolvedAmbiguity) {
                      if (m_idHelperSvc->rpcIdHelper().measuresPhi(
                              rpc->identify()) == 0) {
                        // check if there's a eta hit in the same gap
                        // of the RPC module (doubletZ, doubletPhi, gg)
                        if (current_dbz ==
                            m_idHelperSvc->rpcIdHelper().doubletZ(
                                rpc->identify())) {
                          if (current_dbphi ==
                              m_idHelperSvc->rpcIdHelper().doubletPhi(
                                  rpc->identify())) {
                            if (current_gg ==
                                m_idHelperSvc->rpcIdHelper().gasGap(
                                    rpc->identify())) {
                              if (fabs(time - rpc->time()) <
                                  m_etaphi_coincidenceTime) {
                                hasAMatchingEtaHit = true;
                                ATH_MSG_VERBOSE(
                                    "There's a matching eta hit with id "
                                    << m_idHelperSvc->toString(
                                           rpc->identify()));
                                // here there can be a break ? NO, we need to
                                // keep looping in order to check
                                //  if this preprawdata has been already
                                //  recorded (due to cabling overlaps)
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
              if (hasAMatchingEtaHit)
                nMatchingEtaHits++;  // Number of phi strips (possibly
                                     // corresponding to this CM hit)
              // with a matching eta
              if (processingphiview && duplicate)
                nDuplicatePhiHits++;  // Number of phi strips (possibly
                                      // corresponding to this CM hit)
                                      // already in the collection
            }                         // if collection is not empty
          }                           // end of if reduceCablingOverlap
 
          if (msgLvl(MSG::VERBOSE)) {
            if (solvePhiAmb_thisHit && (!etaview))
              ATH_MSG_VERBOSE("nMatchingEtaHits = " << nMatchingEtaHits
                                                    << " hasAMatchingEtaHit = "
                                                    << hasAMatchingEtaHit);
          }
 
          if (!duplicate) {
            ATH_MSG_VERBOSE(
                " solvePhiAmb_thisHit, processingetaview, processingphiview, "
                "hasAMatchingEtaHit, unsolvedAmbiguity "
                << solvePhiAmb_thisHit << " " << processingetaview << " "
                << processingphiview << " " << hasAMatchingEtaHit << " "
                << unsolvedAmbiguity);
            if ((!solvePhiAmb_thisHit) || processingetaview ||
                (processingphiview &&
                 (hasAMatchingEtaHit || unsolvedAmbiguity))) {
              if (unsolvedAmbiguity) {
                if (idVect.empty()) {  // full-scan mode
                  ATH_MSG_DEBUG("storing data even if unsolvedAmbiguity");
                } else {
                  // if in RoI mode and the collection was not requested in this
                  // event, add it to ambiguousCollections
                  ATH_MSG_DEBUG(
                      "unsolvedAmbiguity is true, adding collection with hash "
                      "= "
                      << (int)rpcHashId << " to ambiguous collections vector");
                  if (!state.m_decodedOfflineHashIds.empty() &&
                      state.m_decodedOfflineHashIds.find(rpcHashId) ==
                          state.m_decodedOfflineHashIds.end()) {
                    ambiguousCollections.insert(rpcHashId);
                    ATH_MSG_DEBUG(
                        "collection not yet processed; added to ambiguous "
                        "collection vector; going to the next offline "
                        "channel ID");
                    continue;  // go to the next possible offline channel ID
                  } else if (!doingSecondLoopAmbigColls) {
                    ambiguousCollections.insert(rpcHashId);
                    ATH_MSG_DEBUG(
                        "collection already processed and "
                        "doingSecondLoopAmbigColls=false; added to ambiguous "
                        "collection vector; going to the next offline channel "
                        "ID");
                    continue;
                  } else {
                    ATH_MSG_DEBUG(
                        "collection already processed and "
                        "doingSecondLoopAmbigColls=true; trying to store data "
                        "even if "
                        "unsolvedAmbiguity");
                  }
                }
              }
              SG::ReadCondHandle<MuonGM::MuonDetectorManager> muDetMgr{m_muDetMgrKey, ctx};
              const RpcReadoutElement* descriptor = muDetMgr->getRpcReadoutElement(channelId);
 
              // here check validity
              // if invalid, reset flags
              if (!descriptor) {
                hasAMatchingEtaHit = false;
                duplicate = false;
                ATH_MSG_WARNING(
                    "Detector Element not found for Identifier from the "
                    "cabling service <"
                    << m_idHelperSvc->toString(channelId)
                    << ">  =>>ignore this hit");
                continue;
              } else if (!descriptor->containsId(channelId)) {
                hasAMatchingEtaHit = false;
                duplicate = false;
                if (m_idHelperSvc->rpcIdHelper().stationNameString(
                        m_idHelperSvc->rpcIdHelper().stationName(channelId)) ==
                    "BOG")
                  ATH_MSG_DEBUG(
                      "Identifier from the cabling service <"
                      << m_idHelperSvc->toString(channelId)
                      << "> inconsistent with the geometry of detector element "
                         "<"
                      << m_idHelperSvc->toString(descriptor->identify())
                      << ">  =>>ignore this hit /// there are unmasked "
                         "channels in BOG");
                else
                  ATH_MSG_WARNING(
                      "Identifier from the cabling service <"
                      << m_idHelperSvc->toString(channelId)
                      << "> inconsistent with the geometry of detector element "
                         "<"
                      << m_idHelperSvc->toString(descriptor->identify())
                      << ">  =>>ignore this hit");
                continue;
              }
 
              //
              // Global position
              Amg::Vector3D tempGlobalPosition =
                  descriptor->stripPos(channelId);
              ATH_MSG_VERBOSE("RPC RDO->PrepRawdata: global position ("
                              << tempGlobalPosition.x() << ", "
                              << tempGlobalPosition.y() << ", "
                              << tempGlobalPosition.z() << ") ");
              // Local position
              Amg::Vector2D pointLocPos{Amg::Vector2D::Zero()};
              descriptor->surface(channelId).globalToLocal(
                  tempGlobalPosition, tempGlobalPosition, pointLocPos);
 
              // List of Digits in the cluster (self)
              std::vector<Identifier> identifierList{channelId};
 
              // width of the cluster (self)
              float stripWidth = descriptor->StripWidth(
                  m_idHelperSvc->rpcIdHelper().measuresPhi(channelId));
 
              // Error matrix
              double errPos = stripWidth / std::sqrt(12.0);
              Amg::MatrixX mat(1, 1);
              mat.setIdentity();
              mat *= errPos * errPos;
              // check if this is a triggerINFO rather then a real hit
              // Create a new PrepData
              int ambiguityFlag = 0;
              if (solvePhiAmb_thisHit) {
                if (processingetaview)
                  ambiguityFlag = 1;
                if (unsolvedAmbiguity)
                  ambiguityFlag = digitVec.size();
                else if (hasAMatchingEtaHit)
                  ambiguityFlag = nMatchingEtaHits;
              }
 
              // correct prd time from cool db
              if (m_RPCInfoFromDb) {
                SG::ReadCondHandle<RpcCondDbData> readHandle{m_readKey, ctx};
                std::optional<double> StripTimeFromCool = readHandle->getStripTime(channelId);
                if (StripTimeFromCool) {
                  time -= (*StripTimeFromCool);
                }                
              }
 
              if (triggerHit) {
                ATH_MSG_DEBUG("producing a new  RpcCoinData");
 
                RpcCoinData* newCoinData = new RpcCoinData(
                    channelId, rpcHashId, pointLocPos, identifierList,
                    Amg::MatrixX(mat), descriptor, (float)time, ambiguityFlag,
                    rpcChan->ijk(), threshold, overlap, cmaId, padId, sectorId,
                    !(highPtCm));
 
                // record the new data in the collection
                ATH_MSG_DEBUG(
                    " Adding RpcCoinData @ "
                    << newCoinData << " to collection "
                    << m_idHelperSvc->toString(collectionTrg->identify()));
 
                newCoinData->setHashAndIndex(collectionTrg->identifyHash(),
                                             collectionTrg->size());
                collectionTrg->push_back(newCoinData);
              }  // end of to be stored now for RpcCoinData
              else {
                ATH_MSG_DEBUG("producing a new  RpcPrepData with "
                              << "ambiguityFlag = " << ambiguityFlag);
 
                RpcPrepData* newPrepData = new RpcPrepData(
                    channelId, rpcHashId, pointLocPos, identifierList,
                    Amg::MatrixX(mat), descriptor, (float)time, ambiguityFlag);
 
                // record the new data in the collection
                ATH_MSG_DEBUG(
                    " Adding digit @ "
                    << newPrepData << " to collection "
                    << m_idHelperSvc->toString(collection->identify()));
 
                newPrepData->setHashAndIndex(collection->identifyHash(),
                                             collection->size());
                collection->push_back(newPrepData);
                // here one should reset ambiguityFlag for the prepdata
                // registered before the current one (from the same RDO hit) if
                // nMatchingEtaHits > 1
                nPrepRawData++;
              }
              if (!m_xAODKey.empty()) {
                auto xprd = state.m_xaodHandle->push_back(std::make_unique<xAOD::RpcStrip>());
                xprd->setIdentifier(channelId.get_compact());
                xAOD::MeasVector<1> locpos{pointLocPos[0]};
                xAOD::MeasMatrix<1> cov{xAOD::MeasMatrix<1>::Identity()};
                (cov)(0, 0) = mat(0, 0);
                xprd->setMeasurement(m_idHelperSvc->detElementHash(channelId), locpos, cov);
                xprd->setStripNumber(idHelper.strip(channelId));
                xprd->setGasGap(idHelper.gasGap(channelId));
                xprd->setMeasuresPhi(idHelper.measuresPhi(channelId));
                xprd->setDoubletPhi(idHelper.doubletPhi(channelId));
                xprd->setTime(static_cast<float>(time));
                xprd->setTriggerInfo(rpcChan->ijk());
                xprd->setAmbiguityFlag(ambiguityFlag);
                xprd->setTimeOverThreshold(threshold);
              }  // end of to be stored now for RpcPrepData
            }    // end of to be stored now
          }      // this hit was not yet recorded
          else {
            // this hit was already recorded
            ATH_MSG_DEBUG("digit already in the collection ");
          }
        }  // end loop over possible offline identifiers corresponding to this
           // CM hit
        ATH_MSG_VERBOSE(
            "processingphiview, nMatchingEtaHits, nDuplicatePhiHits, "
            "unsolvedAmbiguity, solvePhiAmb_thisHit : "
            << processingphiview << ", " << nMatchingEtaHits << ", "
            << nDuplicatePhiHits << ", " << unsolvedAmbiguity << ", "
            << solvePhiAmb_thisHit);
        if ((processingphiview && (nMatchingEtaHits == 0)) &&
            (nDuplicatePhiHits == 0) && (!unsolvedAmbiguity) &&
            (solvePhiAmb_thisHit)) {
          unsolvedAmbiguity = true;
          // no eta hits matching any phi digit
          // loop once again and store all phi digits potentially generating
          // this CM hit
          ATH_MSG_DEBUG(
              "No eta prepData matching any phi hit from this CM hit \n"
              << "loop once again and store all phi digits potentially "
                 "generating this CM hit");
        } else if (unsolvedAmbiguity)
          notFinished = false;
        else
          notFinished = false;
      }  // end of not finished
    }    // end loop over CM hits
  }      // end loop over CMs
 
  ATH_MSG_DEBUG("***************** Stop  of processPad eta/phiview "
                << processingetaview << "/" << processingphiview
                << "***************** for Pad online Id " << padId
                << " m_logic sector ID " << sectorId);
 
  return StatusCode::SUCCESS;
}

processTriggerHitHypothesis()

void Muon::RpcRdoToPrepDataToolMT::processTriggerHitHypothesis ( RpcCoinMatrix::const_iterator  itD, RpcCoinMatrix::const_iterator  itD_end, bool  highptpad, bool &  triggerHit, unsigned short &  threshold, unsigned short &  overlap, bool &  toSkip  ) const

protected

Definition at line 1201 of file RpcRdoToPrepDataToolMT.cxx.

                        {
  toSkip = false;
  const RpcFiredChannel* rpcChan = (*itD);
  if ((highPtCm && rpcChan->ijk() < 2) || (rpcChan->ijk() > 5)) {
    ATH_MSG_VERBOSE("RpcFiredChannel: it's a trigger hit");
    triggerHit = true;
 
    // triggerHit
    if (!m_producePRDfromTriggerWords) {
      // skip if not storing the trigger info
      toSkip = true;
      return;
    }
    if (rpcChan->ijk() == 7) {
      // the info in ijk 7 refer to the previous CM hit with ijk  6 => skip
      toSkip = true;
      return;
    }
    if (rpcChan->ijk() == 6) {
      std::string cmtype;
      // look for the subsequent ijk  7 to define threshold and overlap
      if (msgLvl(MSG::VERBOSE)) {
        cmtype = " in low  pT CM ";
        if (highPtCm)
          cmtype = " in high pT CM ";
        ATH_MSG_VERBOSE("This hit: ijk = " << rpcChan->ijk() << cmtype
                                           << " bcid is " << rpcChan->bcid()
                                           << " time is " << rpcChan->time()
                                           << " ch " << rpcChan->channel());
      }
      RpcCoinMatrix::const_iterator itDnext = itD + 1;
      while (itDnext != itD_end) {
        const RpcFiredChannel* rpcChanNext = (*itDnext);
        if (msgLvl(MSG::VERBOSE)) {
          ATH_MSG_VERBOSE("Next hit: ijk = " << rpcChanNext->ijk() << cmtype
                                             << " bcid is " << rpcChan->bcid()
                                             << " time is "
                                             << rpcChanNext->time());
          if (rpcChanNext->ijk() < 7)
            ATH_MSG_VERBOSE(" ch " << rpcChanNext->channel());
        }
        if (rpcChanNext->ijk() == 7) {
          ATH_MSG_VERBOSE("next has ijk=7 ");
          if (rpcChanNext->bcid() == rpcChan->bcid() &&
              rpcChanNext->time() == rpcChan->time()) {
            ATH_MSG_VERBOSE("bdid/tick match; assigning thr/overlap  = "
                            << rpcChanNext->thr() << "/" << rpcChanNext->ovl());
            threshold = rpcChanNext->thr();
            overlap = rpcChanNext->ovl();
          } else {
            ATH_MSG_WARNING(
                "ijk =7 after a ijk = 6 BUT bdid/tick don't match - will not "
                "assign threshold/overlap ");
          }
          break;
        } else {
          // std::cout<<"processing trigger hit with ijk = 6; next is not ijk
          // 7"<<std::endl;
          if (rpcChanNext->ijk() == 6) {
            ++itDnext;
            // std::cout<<"next has ijk 6; try next to next"<<std::endl;
          } else {
            ATH_MSG_WARNING(
                "RPC cm hit with ijk = 6 not followed by ijk = 6 or 7 - will "
                "not assign threshold / overlap");
            break;
          }
        }
      }
    }
  } else {
    triggerHit = false;
    return;
  }
  ATH_MSG_VERBOSE("RPC trigger hit; ijk = "
                  << rpcChan->ijk() << " threshold / overlap = " << threshold
                  << "/" << overlap);
}

provideEmptyContainer()

StatusCode Muon::RpcRdoToPrepDataToolMT::provideEmptyContainer ( const EventContext &  ctx ) const

overridevirtual

Definition at line 192 of file RpcRdoToPrepDataToolMT.cxx.

                                   {
  State state(m_idHelperSvc->rpcIdHelper(), m_xAODKey, ctx);
  ATH_CHECK(loadProcessedChambers(ctx, state));
  ATH_CHECK(transferAndRecordPrepData(ctx, state));
  ATH_CHECK(transferAndRecordCoinData(ctx, state));
  return StatusCode::SUCCESS;
}

transferAndRecordCoinData()

StatusCode Muon::RpcRdoToPrepDataToolMT::transferAndRecordCoinData ( const EventContext &  ctx, State &  state  ) const

protected

Stores the CoinData container into store gate.

Definition at line 233 of file RpcRdoToPrepDataToolMT.cxx.

                                                 {
  if (!m_producePRDfromTriggerWords) {
    return StatusCode::SUCCESS;
  }
 
  // Take localContainer and transfer contents to rpcCoinHandle
  for (auto& [hash, collection] : state.m_rpcCoinDataCollections) {
    if (!collection || collection->empty())
      continue;
    // If not present, get a write lock for the hash and move collection
    RpcCoinDataContainer::IDC_WriteHandle lock =
        state.m_coinDataCont->getWriteHandle(hash);
    if (lock.alreadyPresent()) {
      ATH_MSG_DEBUG("RpcCoinDataCollection already contained in IDC "
                    << m_idHelperSvc->toString(collection->identify()));
      continue;
    }
    ATH_CHECK(lock.addOrDelete(std::move(collection)));
    ATH_MSG_DEBUG("Coin hash " << hash << " has been moved to cache container");
  }
  state.m_rpcCoinDataCollections.clear();
  if (msgLvl(MSG::DEBUG)) {
    for (const auto& [hash, ptr] : state.m_coinDataCont->GetAllHashPtrPair()) {
      ATH_MSG_DEBUG("Contents of LOCAL in this view : " << hash);
    }
  }
  SG::WriteHandle<Muon::RpcCoinDataContainer> rpcCoinHandle{
      m_rpcCoinDataContainerKey, ctx};
  ATH_CHECK(rpcCoinHandle.record(std::move(state.m_coinDataCont)));
 
  ATH_MSG_DEBUG("Created container " << m_rpcCoinDataContainerKey.key());
  // For additional information on the contents of the cache-based container,
  // this function can be used printMTCoinData (*rpcCoinHandle);
 
  return StatusCode::SUCCESS;
}

transferAndRecordPrepData()

StatusCode Muon::RpcRdoToPrepDataToolMT::transferAndRecordPrepData ( const EventContext &  ctx, State &  state  ) const

protected

Stores the PrepData container into store gate.

Definition at line 201 of file RpcRdoToPrepDataToolMT.cxx.

                                                 {
 
  for (auto& [hash, collection] : state.m_rpcPrepDataCollections) {
    if (!collection || collection->empty())
      continue;
    // If not present, get a write lock for the hash and move collection
    RpcPrepDataContainer::IDC_WriteHandle lock =
        state.m_prepDataCont->getWriteHandle(hash);
    if (lock.alreadyPresent()) {
      ATH_MSG_DEBUG("RpcPrepDataCollection already contained in IDC "
                    << m_idHelperSvc->toString(collection->identify()));
      continue;
    }
    ATH_CHECK(lock.addOrDelete(std::move(collection)));
    ATH_MSG_DEBUG("PRD hash " << hash << " has been moved to cache container");
  }
  state.m_rpcPrepDataCollections.clear();
 
  if (msgLvl(MSG::DEBUG)) {
    for (const auto& [hash, ptr] : state.m_prepDataCont->GetAllHashPtrPair()) {
      ATH_MSG_DEBUG("Contents of CONTAINER in this view : " << hash);
    }
  }
  SG::WriteHandle<Muon::RpcPrepDataContainer> rpcPRDHandle{
      m_rpcPrepDataContainerKey, ctx};
  ATH_CHECK(rpcPRDHandle.record(std::move(state.m_prepDataCont)));
  ATH_MSG_DEBUG("Created container " << m_rpcPrepDataContainerKey.key());
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_coindataContainerCacheKey

SG::UpdateHandleKey<RpcCoinDataCollection_Cache> Muon::RpcRdoToPrepDataToolMT::m_coindataContainerCacheKey

protected

Initial value:

{
      this, "RpcCoinDataContainerCacheKey", "",
      "Optional external cache for the RPC coin data container"}

Definition at line 191 of file RpcRdoToPrepDataToolMT.h.

m_decodeData

Gaudi::Property<bool> Muon::RpcRdoToPrepDataToolMT::m_decodeData

protected

Initial value:

{
      this, "DecodeData",
      true}

toggle on/off the decoding of RPC RDO into RpcPerpData

Definition at line 146 of file RpcRdoToPrepDataToolMT.h.

m_etaphi_coincidenceTime

Gaudi::Property<float> Muon::RpcRdoToPrepDataToolMT::m_etaphi_coincidenceTime

protected

Initial value:

{
      this, "etaphi_coincidenceTime", 20., "time for phi*eta coincidence"}

3 ns is the resolution of the RPC readout electronics

Definition at line 130 of file RpcRdoToPrepDataToolMT.h.

m_eventInfo

SG::ReadHandleKey<xAOD::EventInfo> Muon::RpcRdoToPrepDataToolMT::m_eventInfo

protected

Initial value:

{this, "EventInfoContName",
                                                 "EventInfo", "event info key"}

Definition at line 181 of file RpcRdoToPrepDataToolMT.h.

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> Muon::RpcRdoToPrepDataToolMT::m_idHelperSvc

protected

Initial value:

{
      this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

Definition at line 157 of file RpcRdoToPrepDataToolMT.h.

m_muDetMgrKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> Muon::RpcRdoToPrepDataToolMT::m_muDetMgrKey

protected

Initial value:

{
      this, "DetectorManagerKey", "MuonDetectorManager",
      "Key of input MuonDetectorManager condition data"}

Definition at line 153 of file RpcRdoToPrepDataToolMT.h.

m_nRpcCablingKey

SG::ReadCondHandleKey<MuonNRPC_CablingMap> Muon::RpcRdoToPrepDataToolMT::m_nRpcCablingKey

protected

Initial value:

{
      this, "NrpcCablingKey", "MuonNRPC_CablingMap",
      "Key of MuonNRPC_CablingMap"}

Definition at line 183 of file RpcRdoToPrepDataToolMT.h.

m_overlap_timeTolerance

Gaudi::Property<float> Muon::RpcRdoToPrepDataToolMT::m_overlap_timeTolerance

protected

Initial value:

{
      this, "overlap_timeTolerance", 10.,
      "tolerance of the timing calibration"}

Definition at line 133 of file RpcRdoToPrepDataToolMT.h.

m_prdContainerCacheKey

SG::UpdateHandleKey<RpcPrepDataCollection_Cache> Muon::RpcRdoToPrepDataToolMT::m_prdContainerCacheKey

protected

Initial value:

{
      this, "RpcPrdContainerCacheKey", "",
      "Optional external cache for the RPC PRD container"}

This is the key for the cache for the MDT PRD containers, can be empty.

Definition at line 188 of file RpcRdoToPrepDataToolMT.h.

m_producePRDfromTriggerWords

Gaudi::Property<bool> Muon::RpcRdoToPrepDataToolMT::m_producePRDfromTriggerWords

protected

Initial value:

{
      this, "produceRpcCoinDatafromTriggerWords", true,
      "tore as prd the trigger hits"}

Definition at line 136 of file RpcRdoToPrepDataToolMT.h.

m_rdoContainerKey

SG::ReadHandleKey<RpcPadContainer> Muon::RpcRdoToPrepDataToolMT::m_rdoContainerKey

protected

Initial value:

{this, "RDOContainer",
                                                       "RPCPAD"}

Definition at line 167 of file RpcRdoToPrepDataToolMT.h.

m_rdoNrpcContainerKey

SG::ReadHandleKey<xAOD::NRPCRDOContainer> Muon::RpcRdoToPrepDataToolMT::m_rdoNrpcContainerKey

protected

Initial value:

{
      this, "NrpcInputCollection", "NRPCRDO"}

Definition at line 170 of file RpcRdoToPrepDataToolMT.h.

m_readKey

SG::ReadCondHandleKey<RpcCondDbData> Muon::RpcRdoToPrepDataToolMT::m_readKey

protected

Initial value:

{
      this, "ReadKey", "RpcCondDbData", "Key of RpcCondDbData"}

Definition at line 177 of file RpcRdoToPrepDataToolMT.h.

m_reduceCablingOverlap

Gaudi::Property<bool> Muon::RpcRdoToPrepDataToolMT::m_reduceCablingOverlap

protected

Initial value:

{
      this, "reduceCablingOverlap", true, "toggle on/off the overlap removal"}

Definition at line 142 of file RpcRdoToPrepDataToolMT.h.

m_rpcCoinDataContainerKey

SG::WriteHandleKey<Muon::RpcCoinDataContainer> Muon::RpcRdoToPrepDataToolMT::m_rpcCoinDataContainerKey

protected

Initial value:

{
      this, "TriggerOutputCollection", "RPC_triggerHits"}

RpcCoinData containers.

Definition at line 164 of file RpcRdoToPrepDataToolMT.h.

m_RPCInfoFromDb

Gaudi::Property<bool> Muon::RpcRdoToPrepDataToolMT::m_RPCInfoFromDb

protected

Initial value:

{
      this, "RPCInfoFromDb", false}

correct time prd from cool db

Definition at line 149 of file RpcRdoToPrepDataToolMT.h.

m_rpcPrepDataContainerKey

SG::WriteHandleKey<Muon::RpcPrepDataContainer> Muon::RpcRdoToPrepDataToolMT::m_rpcPrepDataContainerKey

protected

Initial value:

{
      this, "OutputCollection", "RPC_Measurements"}

RpcPrepData containers.

Definition at line 161 of file RpcRdoToPrepDataToolMT.h.

m_rpcRdoDecoderTool

ToolHandle<Muon::IRPC_RDO_Decoder> Muon::RpcRdoToPrepDataToolMT::m_rpcRdoDecoderTool

protected

Initial value:

{
      this, "RdoDecoderTool", "Muon::RpcRDO_Decoder"}

Definition at line 174 of file RpcRdoToPrepDataToolMT.h.

m_rpcReadKey

SG::ReadCondHandleKey<RpcCablingCondData> Muon::RpcRdoToPrepDataToolMT::m_rpcReadKey

protected

Initial value:

{
      this, "RpcCablingKey", "RpcCablingCondData", "Key of RpcCablingCondData"}

Definition at line 179 of file RpcRdoToPrepDataToolMT.h.

m_solvePhiAmbiguities

Gaudi::Property<bool> Muon::RpcRdoToPrepDataToolMT::m_solvePhiAmbiguities

protected

Initial value:

{
      this, "solvePhiAmbiguities", true,
      "toggle on/off the removal of phi ambiguities"}

Definition at line 139 of file RpcRdoToPrepDataToolMT.h.

m_timeShift

Gaudi::Property<float> Muon::RpcRdoToPrepDataToolMT::m_timeShift

protected

Initial value:

{this, "timeShift", -12.5,
                                     "any global time shift ?!"}

Definition at line 144 of file RpcRdoToPrepDataToolMT.h.

m_xAODKey

SG::WriteHandleKey<xAOD::RpcStripContainer> Muon::RpcRdoToPrepDataToolMT::m_xAODKey

protected

Initial value:

{
      this, "xAODKey", "",
      "If empty, do not produce xAOD, otherwise this is the key of the output "
      "xAOD MDT PRD container"}

Definition at line 195 of file RpcRdoToPrepDataToolMT.h.

---

The documentation for this class was generated from the following files:

• RpcRdoToPrepDataToolMT.h
• RpcRdoToPrepDataToolMT.cxx