Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
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<xAOD::RpcStripContainer> 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<xAOD::RpcStrip2DContainer>{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 
101  const MuonGMR4::StripDesign& design{reElement->sensorLayout(reElement->measurementHash(offId)).design()};
102 
103  CheckVector2D stripPos = design.center(idHelper.channel(offId));
104  if (!stripPos) {
105  ATH_MSG_WARNING("Failed to fetch a valid stripPosition for "<<m_idHelperSvc->toString(offId));
106  continue;
107  }
108  const double stripLocX = (*stripPos).x();
109  const double stripCovX = std::pow(design.stripPitch(), 2) / std::sqrt(12.);
110 
111  if (m_decode2DStrips && rdoPairs[0] && rdoPairs[1]) {
112  xAOD::RpcStrip2D* measurement = strip2DHandle->push_back(std::make_unique<xAOD::RpcStrip2D>());
113 
114  xAOD::MeasVector<2> lPos{xAOD::MeasVector<2>::Zero()};
115  xAOD::MeasMatrix<2> lCov{xAOD::MeasMatrix<2>::Identity()};
116 
117  lPos[0] = stripLocX;
118  lPos[1] = -0.5*m_propagationVelocity *(rdoPairs[0]->time() - rdoPairs[1]->time());
119  lCov(0,0) = stripCovX;
120  lCov(1,1) = M_SQRT1_2 * m_propagationVelocity* m_stripTimeResolution;
122  measurement->setMeasurement<2>(0, lPos, lCov);
123  // CheckVector2D stripPos
124  setMeasValues(measurement, rdoPairs[0], offId);
125  ATH_MSG_VERBOSE("Measurement "<<m_idHelperSvc->toString(offId)<<" "<<lPos.x()<<", "<<lPos.y());
126  continue;
127  }
128 
129  xAOD::RpcStrip* strip = stripHandle->push_back(std::make_unique<xAOD::RpcStrip>());
130  xAOD::MeasVector<1> lPos{xAOD::MeasVector<1>::Zero()};
131  xAOD::MeasMatrix<1> lCov{xAOD::MeasMatrix<1>::Identity()};
132  lPos[0] = stripLocX;
133  lCov(0,0) = stripCovX;
134 
135  strip->setMeasuresPhi(idHelper.measuresPhi(offId));
137  strip->setMeasurement<1>(0, lPos, lCov);
138  setMeasValues(strip, rdoPairs[0] ? rdoPairs[0] : rdoPairs[1], offId);
139  }
140  return StatusCode::SUCCESS;
141 
142  }

◆ decode() [2/2]

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

Definition at line 143 of file RpcRdoToRpcPrepDataTool.cxx.

144  {
145  SG::ReadCondHandle cablingMap{m_cablingKey, ctx};
146  ATH_CHECK(cablingMap.isValid());
147  return decode(ctx, cablingMap->getChamberHashVec(robIds, msgStream()));
148  }

◆ 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 149 of file RpcRdoToRpcPrepDataTool.cxx.

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

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
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
python.SystemOfUnits.nanosecond
int nanosecond
Definition: SystemOfUnits.py:119
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
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:19
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:794
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:94
MuonR4::RpcRdoToRpcPrepDataTool::m_writeKeyBI
SG::WriteHandleKey< xAOD::RpcStrip2DContainer > m_writeKeyBI
Definition: RpcRdoToRpcPrepDataTool.h:54
MuonGMR4::RpcReadoutElement::sensorLayout
const StripLayer & sensorLayout(const IdentifierHash &measHash) const
Access to the StripLayer associated to a given measurement Hash.
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
python.PhysicalConstants.c_light
float c_light
Definition: PhysicalConstants.py:63
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
xAOD::MeasMatrix
Eigen::Matrix< float, N, N > MeasMatrix
Definition: MeasurementDefs.h:55
Muon::IdentifierByDetElSorter
Definition: IdentifierByDetElSorter.h:17
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 Apr 24 2025 22:02:35 for ATLAS Offline Software by   doxygen 1.8.18