ATLAS Offline Software
Public Member Functions | Private Attributes | List of all members
MuonR4::RpcRdoToRpcPrepDataTool Class Reference

#include <RpcRdoToRpcPrepDataTool.h>

Inheritance diagram for MuonR4::RpcRdoToRpcPrepDataTool:
Collaboration diagram for MuonR4::RpcRdoToRpcPrepDataTool:

Public Member Functions

 ~RpcRdoToRpcPrepDataTool ()=default
 
StatusCode initialize () override final
 
StatusCode decode (const EventContext &ctx, const std::vector< IdentifierHash > &idVect) const override final
 
StatusCode decode (const EventContext &ctx, const std::vector< uint32_t > &robIds) const override final
 
StatusCode provideEmptyContainer (const EventContext &ctx) const override final
 Method to create the empty containers.. Only used for seeded decoding. More...
 

Private Attributes

ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
 
SG::ReadHandleKey< xAOD::NRPCRDOContainer > m_rdoKey {this, "RpcRdoContainer", "NRPCRDO"}
 
SG::ReadCondHandleKey< Muon::RpcCablingMap > m_cablingKey
 
SG::WriteHandleKey< xAOD::RpcStripContainer > m_writeKey
 
SG::WriteHandleKey< xAOD::RpcStrip2DContainer > m_writeKeyBI
 
const MuonGMR4::MuonDetectorManager * m_detMgr {nullptr}
 
Gaudi::Property< bool > m_decode2DStrips {this, "decode2DStrips", true}
 
Gaudi::Property< double > m_propagationVelocity
 
Gaudi::Property< double > m_stripTimeResolution
 

Detailed Description

Definition at line 24 of file RpcRdoToRpcPrepDataTool.h.

Constructor & Destructor Documentation

◆ ~RpcRdoToRpcPrepDataTool()

MuonR4::RpcRdoToRpcPrepDataTool::~RpcRdoToRpcPrepDataTool ( )
default

Member Function Documentation

◆ decode() [1/2]

StatusCode MuonR4::RpcRdoToRpcPrepDataTool::decode ( const EventContext &  ctx,
const std::vector< IdentifierHash > &  idVect 
) const
finaloverride

TODO: Do we need to apply a time of flight correction here?

Next step convert the RDOs into prepdata objects

Hash is overwritten by the setMeasValues method

Hash is overwritten by the setMeasValues method

Definition at line 26 of file RpcRdoToRpcPrepDataTool.cxx.

27  {
28 
29 
30  const xAOD::NRPCRDOContainer* rdoContainer{nullptr};
31  ATH_CHECK(SG::get(rdoContainer, m_rdoKey, ctx));
32 
33  const Muon::RpcCablingMap* cablingMap{nullptr};
34  ATH_CHECK(SG::get(cablingMap, m_cablingKey, ctx));
35 
36  const std::unordered_set<IdentifierHash> hashToSelect(idVect.begin(), idVect.end());
37  using RdoPairs = std::array<const xAOD::NRPCRDO*, 2>;
38  std::map<Identifier, RdoPairs, Muon::IdentifierByDetElSorter> sortedRdos{Muon::IdentifierByDetElSorter{m_idHelperSvc.get()}};
39  for (const xAOD::NRPCRDO* rdo : *rdoContainer){
40  /* cabling data conversion */
41  Muon::RpcCablingData cabling{};
42  cabling.subDetector = rdo->subdetector();
43  cabling.boardSector = rdo->boardsector();
44  cabling.board = rdo->board();
45  cabling.channelId = rdo->channel();
46 
47 
48  if (!cablingMap->getOfflineId(cabling, msgStream())){
49  return StatusCode::FAILURE;
50  }
51  Identifier offId{};
52  if (!cablingMap->convert(cabling, offId)){
53  ATH_MSG_FATAL("Cabling conversion failed "<<cabling);
54  return StatusCode::FAILURE;
55  }
56  if (hashToSelect.size() && !hashToSelect.count(m_idHelperSvc->moduleHash(offId))) {
57  ATH_MSG_VERBOSE("Skip "<<m_idHelperSvc->toString(offId)<<" due to ROI selection ");
58  continue;
59  }
61  const bool stripSide = cabling.stripSide();
62  sortedRdos[offId][stripSide] = rdo;
63  }
64 
65  SG::WriteHandle stripHandle{m_writeKey, ctx};
66  ATH_CHECK(stripHandle.record(std::make_unique<xAOD::RpcStripContainer>(),
67  std::make_unique<xAOD::RpcStripAuxContainer>()));
68 
69  SG::WriteHandle<xAOD::RpcStrip2DContainer> strip2DHandle{};
70  if (!m_writeKeyBI.empty()) {
71  strip2DHandle = SG::WriteHandle{m_writeKeyBI, ctx};
72  ATH_CHECK(strip2DHandle.record(std::make_unique<xAOD::RpcStrip2DContainer>(),
73  std::make_unique<xAOD::RpcStrip2DAuxContainer>()));
74 
75  }
76 
77  const RpcIdHelper& idHelper{m_idHelperSvc->rpcIdHelper()};
78 
79  auto setMeasValues = [&idHelper,this](xAOD::RpcMeasurement* outputMeas,
80  const xAOD::NRPCRDO* rdo,
81  const Identifier& offId){
82 
83  const MuonGMR4::RpcReadoutElement* reElement = m_detMgr->getRpcReadoutElement(offId);
84  outputMeas->setIdentifierHash(m_idHelperSvc->detElementHash(offId));
85  outputMeas->setReadoutElement(reElement);
86  outputMeas->setIdentifier(offId.get_compact());
87  outputMeas->setDoubletPhi(idHelper.doubletPhi(offId));
88  outputMeas->setGasGap(idHelper.gasGap(offId));
89  outputMeas->setStripNumber(idHelper.channel(offId));
90  outputMeas->setTimeOverThreshold(rdo->timeoverthr());
92  outputMeas->setTime(rdo->time());
93  outputMeas->setTimeCovariance(std::pow(m_stripTimeResolution,2));
94  };
95 
97  using CheckVector2D = MuonGMR4::StripDesign::CheckVector2D;
98  for (const auto& [offId, rdoPairs] : sortedRdos) {
99  const MuonGMR4::RpcReadoutElement* reElement = m_detMgr->getRpcReadoutElement(offId);
100  const IdentifierHash measHash = reElement->measurementHash(offId);
101 
102  const MuonGMR4::StripDesign& design{reElement->sensorLayout(measHash)->design(idHelper.measuresPhi(offId))};
103 
104  CheckVector2D stripPos = design.center(idHelper.channel(offId));
105  if (!stripPos) {
106  ATH_MSG_WARNING("Failed to fetch a valid stripPosition for "<<m_idHelperSvc->toString(offId));
107  continue;
108  }
109  const double stripLocX = (*stripPos).x();
110  const double stripCovX = std::pow(design.stripPitch(), 2) / std::sqrt(12.);
111 
112  if (m_decode2DStrips && rdoPairs[0] && rdoPairs[1]) {
113  xAOD::RpcStrip2D* measurement = strip2DHandle->push_back(std::make_unique<xAOD::RpcStrip2D>());
114 
115  xAOD::MeasVector<2> lPos{xAOD::MeasVector<2>::Zero()};
116  xAOD::MeasMatrix<2> lCov{xAOD::MeasMatrix<2>::Identity()};
117 
118  lPos[0] = stripLocX;
119  lPos[1] = 0.5*m_propagationVelocity *(rdoPairs[0]->time() - rdoPairs[1]->time());
120  lCov(0,0) = stripCovX;
121  lCov(1,1) = M_SQRT1_2 * m_propagationVelocity* m_stripTimeResolution;
123  measurement->setMeasurement<2>(0, lPos, lCov);
124  // CheckVector2D stripPos
125  setMeasValues(measurement, rdoPairs[0], offId);
126  ATH_MSG_VERBOSE("Measurement "<<m_idHelperSvc->toString(offId)<<" "<<lPos.x()<<", "<<lPos.y());
127  continue;
128  }
129 
130  xAOD::RpcStrip* strip = stripHandle->push_back(std::make_unique<xAOD::RpcStrip>());
131  xAOD::MeasVector<1> lPos{xAOD::MeasVector<1>::Zero()};
132  xAOD::MeasMatrix<1> lCov{xAOD::MeasMatrix<1>::Identity()};
133  lPos[0] = stripLocX;
134  lCov(0,0) = stripCovX;
135 
136  strip->setMeasuresPhi(idHelper.measuresPhi(offId));
138  strip->setMeasurement<1>(0, lPos, lCov);
139  setMeasValues(strip, rdoPairs[0] ? rdoPairs[0] : rdoPairs[1], offId);
140  }
141  return StatusCode::SUCCESS;
142 
143  }

◆ decode() [2/2]

StatusCode MuonR4::RpcRdoToRpcPrepDataTool::decode ( const EventContext &  ctx,
const std::vector< uint32_t > &  robIds 
) const
finaloverride

Definition at line 144 of file RpcRdoToRpcPrepDataTool.cxx.

145  {
146  const Muon::RpcCablingMap* cablingMap{nullptr};
147  ATH_CHECK(SG::get(cablingMap, m_cablingKey, ctx));
148  return decode(ctx, cablingMap->getChamberHashVec(robIds, msgStream()));
149  }

◆ initialize()

StatusCode MuonR4::RpcRdoToRpcPrepDataTool::initialize ( )
finaloverride

Definition at line 16 of file RpcRdoToRpcPrepDataTool.cxx.

16  {
17  ATH_CHECK(m_idHelperSvc.retrieve());
18  ATH_CHECK(m_rdoKey.initialize());
19  ATH_CHECK(m_cablingKey.initialize());
20  ATH_CHECK(detStore()->retrieve(m_detMgr));
21  ATH_CHECK(m_writeKey.initialize());
22  ATH_CHECK(m_writeKeyBI.initialize(m_decode2DStrips));
23  return StatusCode::SUCCESS;
24  }

◆ provideEmptyContainer()

StatusCode MuonR4::RpcRdoToRpcPrepDataTool::provideEmptyContainer ( const EventContext &  ctx) const
finaloverride

Method to create the empty containers.. Only used for seeded decoding.

Definition at line 150 of file RpcRdoToRpcPrepDataTool.cxx.

150  {
151  SG::WriteHandle stripHandle{m_writeKey, ctx};
152  ATH_CHECK(stripHandle.record(std::make_unique<xAOD::RpcStripContainer>(),
153  std::make_unique<xAOD::RpcStripAuxContainer>()));
154 
155  if (!m_writeKeyBI.empty()) {
156  SG::WriteHandle strip2DHandle{m_writeKeyBI, ctx};
157  ATH_CHECK(strip2DHandle.record(std::make_unique<xAOD::RpcStrip2DContainer>(),
158  std::make_unique<xAOD::RpcStrip2DAuxContainer>()));
159 
160  }
161  return StatusCode::SUCCESS;
162  }

Member Data Documentation

◆ m_cablingKey

SG::ReadCondHandleKey<Muon::RpcCablingMap> MuonR4::RpcRdoToRpcPrepDataTool::m_cablingKey
private
Initial value:
{this, "CablingKey", "MuonNRPC_CablingMap",
"Key of MuonNRPC_CablingMap"}

Definition at line 47 of file RpcRdoToRpcPrepDataTool.h.

◆ m_decode2DStrips

Gaudi::Property<bool> MuonR4::RpcRdoToRpcPrepDataTool::m_decode2DStrips {this, "decode2DStrips", true}
private

Definition at line 60 of file RpcRdoToRpcPrepDataTool.h.

◆ m_detMgr

const MuonGMR4::MuonDetectorManager* MuonR4::RpcRdoToRpcPrepDataTool::m_detMgr {nullptr}
private

Definition at line 57 of file RpcRdoToRpcPrepDataTool.h.

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> MuonR4::RpcRdoToRpcPrepDataTool::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
private

Definition at line 43 of file RpcRdoToRpcPrepDataTool.h.

◆ m_propagationVelocity

Gaudi::Property<double> MuonR4::RpcRdoToRpcPrepDataTool::m_propagationVelocity
private
Initial value:
{this, "propSpeed", 0.5 * Gaudi::Units::c_light,
"Propagation speed of the signal inside the strip"}

Definition at line 62 of file RpcRdoToRpcPrepDataTool.h.

◆ m_rdoKey

SG::ReadHandleKey<xAOD::NRPCRDOContainer> MuonR4::RpcRdoToRpcPrepDataTool::m_rdoKey {this, "RpcRdoContainer", "NRPCRDO"}
private

Definition at line 45 of file RpcRdoToRpcPrepDataTool.h.

◆ m_stripTimeResolution

Gaudi::Property<double> MuonR4::RpcRdoToRpcPrepDataTool::m_stripTimeResolution
private
Initial value:
{this, "timeResolution", 0.6 * Gaudi::Units::nanosecond,
"Estimated time resolution of the strip readout"}

Definition at line 65 of file RpcRdoToRpcPrepDataTool.h.

◆ m_writeKey

SG::WriteHandleKey<xAOD::RpcStripContainer> MuonR4::RpcRdoToRpcPrepDataTool::m_writeKey
private
Initial value:
{this, "OutputContainer", "xRpcStrips",
"Output container"}

Definition at line 51 of file RpcRdoToRpcPrepDataTool.h.

◆ m_writeKeyBI

SG::WriteHandleKey<xAOD::RpcStrip2DContainer> MuonR4::RpcRdoToRpcPrepDataTool::m_writeKeyBI
private
Initial value:
{this, "OutputContainerBI", "xRpcBILStrips",
"Output container of the 2D BIL rpc strips"}

Definition at line 54 of file RpcRdoToRpcPrepDataTool.h.

The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::RpcMeasurement_v1
RpcMeasurement_v1: Class storing the geneic.
Definition: RpcMeasurement_v1.h:21
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
MuonGMR4::StripDesign
Definition: StripDesign.h:30
MuonR4::RpcRdoToRpcPrepDataTool::decode
StatusCode decode(const EventContext &ctx, const std::vector< IdentifierHash > &idVect) const override final
Definition: RpcRdoToRpcPrepDataTool.cxx:26
MuonR4::RpcRdoToRpcPrepDataTool::m_cablingKey
SG::ReadCondHandleKey< Muon::RpcCablingMap > m_cablingKey
Definition: RpcRdoToRpcPrepDataTool.h:47
ReadCellNoiseFromCool.cabling
cabling
Definition: ReadCellNoiseFromCool.py:154
xAOD::NRPCRDO_v1
Definition: NRPCRDO_v1.h:14
python.SystemOfUnits.nanosecond
float nanosecond
Definition: SystemOfUnits.py:134
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
xAOD::RpcStrip_v1
Definition: RpcStrip_v1.h:11
MuonGMR4::RpcReadoutElement
Definition: MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/RpcReadoutElement.h:17
RpcIdHelper
Definition: RpcIdHelper.h:51
keylayer_zslicemap.strip
strip
Definition: keylayer_zslicemap.py:151
MuonR4::RpcRdoToRpcPrepDataTool::m_decode2DStrips
Gaudi::Property< bool > m_decode2DStrips
Definition: RpcRdoToRpcPrepDataTool.h:60
MuonR4::RpcRdoToRpcPrepDataTool::m_rdoKey
SG::ReadHandleKey< xAOD::NRPCRDOContainer > m_rdoKey
Definition: RpcRdoToRpcPrepDataTool.h:45
MuonR4::RpcRdoToRpcPrepDataTool::m_propagationVelocity
Gaudi::Property< double > m_propagationVelocity
Definition: RpcRdoToRpcPrepDataTool.h:62
SG::get
const T * get(const ReadCondHandleKey< T > &key, const EventContext &ctx)
Convenience function to retrieve an object given a ReadCondHandleKey.
Definition: ReadCondHandle.h:287
xAOD::RpcStrip2D_v1
Definition: RpcStrip2D_v1.h:11
MuonR4::RpcRdoToRpcPrepDataTool::m_writeKey
SG::WriteHandleKey< xAOD::RpcStripContainer > m_writeKey
Definition: RpcRdoToRpcPrepDataTool.h:51
MdtMezzExtraction.cablingMap
cablingMap
Definition: MdtMezzExtraction.py:22
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
MuonGMR4::RpcReadoutElement::measurementHash
IdentifierHash measurementHash(const Identifier &measId) const override final
Constructs the identifier hash from the full measurement Identifier.
DataVector
Derived DataVector<T>.
Definition: DataVector.h:795
Muon::RpcCablingMap
Definition: RpcCablingMap.h:27
xAOD::MeasVector
Eigen::Matrix< float, N, 1 > MeasVector
Abrivation of the Matrix & Covariance definitions.
Definition: MeasurementDefs.h:53
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
Muon::RpcCablingData
Helper struct that is parsed to the cabling map to translate between the offline & online Identifiers...
Definition: RpcCablingData.h:96
MuonR4::RpcRdoToRpcPrepDataTool::m_writeKeyBI
SG::WriteHandleKey< xAOD::RpcStrip2DContainer > m_writeKeyBI
Definition: RpcRdoToRpcPrepDataTool.h:54
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
python.PhysicalConstants.c_light
float c_light
Definition: PhysicalConstants.py:73
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:73
xAOD::UncalibratedMeasurement_v1::setMeasurement
void setMeasurement(const DetectorIDHashType idHash, MeasVector< N > locPos, MeasMatrix< N > locCov)
Sets IdentifierHash, local position and local covariance of the measurement.
MuonR4::RpcRdoToRpcPrepDataTool::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: RpcRdoToRpcPrepDataTool.h:43
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
MuonGMR4::RpcReadoutElement::sensorLayout
const StripLayerPtr & sensorLayout(const IdentifierHash &measHash) const
Access to the StripLayer associated to a given measurement Hash.
xAOD::MeasMatrix
Eigen::Matrix< float, N, N > MeasMatrix
Definition: MeasurementDefs.h:55
Muon::IdentifierByDetElSorter
Definition: IdentifierByDetElSorter.h:17
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
MuonR4::RpcRdoToRpcPrepDataTool::m_stripTimeResolution
Gaudi::Property< double > m_stripTimeResolution
Definition: RpcRdoToRpcPrepDataTool.h:65
MuonR4::RpcRdoToRpcPrepDataTool::m_detMgr
const MuonGMR4::MuonDetectorManager * m_detMgr
Definition: RpcRdoToRpcPrepDataTool.h:57
generate::Zero
void Zero(TH1D *hin)
Definition: generate.cxx:32
MuonGMR4::StripDesign::CheckVector2D
std::optional< Amg::Vector2D > CheckVector2D
Definition: StripDesign.h:82
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Thu Oct 30 2025 22:01:26 for ATLAS Offline Software by   doxygen 1.8.18