Loading [MathJax]/jax/output/SVG/config.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
Muon::MmRdoToPrepDataToolMT Class Reference

#include <MmRdoToPrepDataToolMT.h>

Inheritance diagram for Muon::MmRdoToPrepDataToolMT:
Collaboration diagram for Muon::MmRdoToPrepDataToolMT:

Public Member Functions

 MmRdoToPrepDataToolMT (const std::string &, const std::string &, const IInterface *)
 
virtual ~MmRdoToPrepDataToolMT ()=default
 default destructor More...
 
virtual StatusCode initialize () override
 standard Athena-Algorithm method More...
 
virtual StatusCode decode (const EventContext &ctx, const std::vector< IdentifierHash > &idVect) const override
 Decode method - declared in Muon::IMuonRdoToPrepDataTool. More...
 
virtual StatusCode decode (const EventContext &ctx, const std::vector< uint32_t > &robIds) const override
 
virtual StatusCode provideEmptyContainer (const EventContext &ctx) const override
 
StatusCode processCollection (const EventContext &ctx, Muon::MMPrepDataContainer *mmPrepDataContainer, xAOD::MMClusterContainer *xAODContainer, const std::vector< IdentifierHash > &idsToDecode, const MM_RawDataCollection *rdoColl) const
 

Protected Member Functions

Muon::MMPrepDataContainer * setupMM_PrepDataContainer (const EventContext &ctx) const
 
xAOD::MMClusterContainer * setupxAODPrepDataContainer (SG::WriteHandle< xAOD::MMClusterContainer > &outputContainer) const
 
const MM_RawDataContainer * getRdoContainer (const EventContext &ctx) const
 
void processRDOContainer (const EventContext &ctx, Muon::MMPrepDataContainer *mmPrepDataContainer, xAOD::MMClusterContainer *xAODContainer, const std::vector< IdentifierHash > &idsToDecode) const
 

Protected Attributes

SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > m_muDetMgrKey
 
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
 
SG::WriteHandleKey< Muon::MMPrepDataContainer > m_writeKey
 MdtPrepRawData containers. More...
 
SG::ReadHandleKey< MM_RawDataContainer > m_readKey
 
SG::UpdateHandleKey< MMPrepDataCollection_Cache > m_updateKey
 This is the key for the cache for the MM PRD containers, can be empty. More...
 
Gaudi::Property< bool > m_merge {this, "MergePrds", true}
 
ToolHandle< IMMClusterBuilderTool > m_clusterBuilderTool
 
ToolHandle< INSWCalibTool > m_calibTool {this, "NSWCalibTool", ""}
 
Gaudi::Property< float > m_singleStripChargeCut
 
SG::WriteHandleKey< xAOD::MMClusterContainer > m_xAODKey
 

Detailed Description

Definition at line 22 of file MmRdoToPrepDataToolMT.h.

Constructor & Destructor Documentation

◆ MmRdoToPrepDataToolMT()

Muon::MmRdoToPrepDataToolMT::MmRdoToPrepDataToolMT ( const std::string &  t,
const std::string &  n,
const IInterface *  p 
)

Definition at line 25 of file MmRdoToPrepDataToolMT.cxx.

28  : base_class(t, n, p) {}

◆ ~MmRdoToPrepDataToolMT()

virtual Muon::MmRdoToPrepDataToolMT::~MmRdoToPrepDataToolMT ( )
virtualdefault

default destructor

Member Function Documentation

◆ decode() [1/2]

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

Decode method - declared in Muon::IMuonRdoToPrepDataTool.

Definition at line 267 of file MmRdoToPrepDataToolMT.cxx.

268  {
269 
270  // is idVect a right thing to use here? to be reviewed maybe
271  ATH_MSG_DEBUG("Size of the RDO container to be decoded: " << idVect.size());
272 
273  MMPrepDataContainer* mmPrepDataContainer = setupMM_PrepDataContainer(ctx);
274 
275  if (!mmPrepDataContainer) {
276  return StatusCode::FAILURE;
277  }
278 
279  SG::WriteHandle<xAOD::MMClusterContainer> outputContainer{};
280  xAOD::MMClusterContainer* xAODContainer{nullptr};
281  if (!m_xAODKey.empty()) {
282  outputContainer = SG::WriteHandle{m_xAODKey, ctx};
283  ATH_CHECK(outputContainer.record(std::make_unique<xAOD::MMClusterContainer>(),
284  std::make_unique<xAOD::MMClusterAuxContainer>()));
285  xAODContainer = outputContainer.ptr();
286  }
287 
288  processRDOContainer(ctx, mmPrepDataContainer, xAODContainer, idVect);
289 
290  return StatusCode::SUCCESS;
291 }

◆ decode() [2/2]

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

Definition at line 293 of file MmRdoToPrepDataToolMT.cxx.

294  {
295  ATH_MSG_FATAL("ROB based decoding is not supported....");
296  return StatusCode::FAILURE;
297 }

◆ getRdoContainer()

const MM_RawDataContainer * Muon::MmRdoToPrepDataToolMT::getRdoContainer ( const EventContext &  ctx) const
protected

Definition at line 230 of file MmRdoToPrepDataToolMT.cxx.

230  {
231  auto rdoContainerHandle = SG::makeHandle(m_readKey, ctx);
232  if (rdoContainerHandle.isValid()) {
233  ATH_MSG_DEBUG("MM_getRdoContainer success");
234  return rdoContainerHandle.cptr();
235  }
236  ATH_MSG_WARNING("Retrieval of MM_RawDataContainer failed !");
237 
238  return nullptr;
239 }

◆ initialize()

StatusCode Muon::MmRdoToPrepDataToolMT::initialize ( )
overridevirtual

standard Athena-Algorithm method

Definition at line 30 of file MmRdoToPrepDataToolMT.cxx.

30  {
31  ATH_MSG_DEBUG(" in initialize()");
32  ATH_CHECK(m_idHelperSvc.retrieve());
33  // check if the initialization of the data container is success
34  ATH_CHECK(m_writeKey.initialize());
35  ATH_CHECK(m_readKey.initialize());
36  ATH_CHECK(m_muDetMgrKey.initialize());
37  ATH_CHECK(m_calibTool.retrieve());
38  ATH_CHECK(m_updateKey.initialize(!m_updateKey.key().empty()));
39  ATH_CHECK(m_xAODKey.initialize(!m_xAODKey.empty()));
40  return StatusCode::SUCCESS;
41 }

◆ processCollection()

StatusCode Muon::MmRdoToPrepDataToolMT::processCollection ( const EventContext &  ctx,
Muon::MMPrepDataContainer *  mmPrepDataContainer,
xAOD::MMClusterContainer *  xAODContainer,
const std::vector< IdentifierHash > &  idsToDecode,
const MM_RawDataCollection *  rdoColl 
) const

reconstruct the clusters

Definition at line 43 of file MmRdoToPrepDataToolMT.cxx.

47  {
48  ATH_MSG_DEBUG(" ***************** Start of process MM Collection");
49  const MmIdHelper& id_helper = m_idHelperSvc->mmIdHelper();
50  // protect for large splashes
51  bool merge = m_merge || rdoColl->size() > 100;
52 
53  const IdentifierHash hash = rdoColl->identifierHash();
54 
55  // check if we actually want to decode this RDO collection
56  if (!idsToDecode.empty() and std::find(idsToDecode.begin(), idsToDecode.end(),
57  hash) == idsToDecode.end()) {
58  ATH_MSG_DEBUG("Hash ID " << hash << " not in input list, ignore");
59  return StatusCode::SUCCESS;
60  } else
61  ATH_MSG_DEBUG("Going to decode " << hash);
62 
63  // check if the collection already exists, otherwise add it
64  if (mmPrepDataContainer->indexFindPtr(hash) != nullptr) {
65 
66  ATH_MSG_DEBUG("In processCollection: collection already contained in the MM PrepData container");
67  return StatusCode::SUCCESS;
68  }
69 
70  // Get write handle for this collection
71  MMPrepDataContainer::IDC_WriteHandle lock = mmPrepDataContainer->getWriteHandle(hash);
72  // Check if collection already exists (via the cache, i.e. in online trigger
73  // mode)
74  if (lock.OnlineAndPresentInAnotherView()) {
75  ATH_MSG_DEBUG("In processCollection: collection already available in the MM PrepData container (via cache)");
76  return StatusCode::SUCCESS;
77  }
78  auto prdColl = std::make_unique<MMPrepDataCollection>(hash);
79 
80  // set the offline identifier of the collection Id
81  IdContext context = id_helper.module_context();
82  Identifier moduleId{};
83  if (id_helper.get_id(hash, moduleId, &context) != 0) {
84  ATH_MSG_ERROR("Could not convert the hash Id: " << hash << " to identifier");
85  } else {
86  ATH_MSG_DEBUG(" dump moduleId " << moduleId);
87  prdColl->setIdentifier(moduleId);
88  }
89 
90  // MuonDetectorManager from the conditions store
91  SG::ReadCondHandle<MuonGM::MuonDetectorManager> MuonDetMgr{m_muDetMgrKey, ctx};
92  if (!MuonDetMgr.isValid()) {
93  ATH_MSG_ERROR("Null pointer to the read MuonDetectorManager conditions object");
94  return StatusCode::FAILURE;
95  }
96 
97  std::vector<MMPrepData> MMprds;
98  // convert the RDO collection to a PRD collection
99  for (const MM_RawData* rdo : *rdoColl) {
100  ATH_MSG_DEBUG("Adding a new MM PrepRawData");
101 
102  const Identifier rdoId = rdo->identify();
103  ATH_MSG_DEBUG(" dump rdo " << m_idHelperSvc->toString(rdoId));
104 
105  int channel = rdo->channel();
106  std::vector<Identifier> rdoList;
107  Identifier prdId = id_helper.channelID(rdoId, id_helper.multilayer(rdoId), id_helper.gasGap(rdoId), channel);
108  ATH_MSG_DEBUG(" channel RDO " << channel << " channel from rdoID " << id_helper.channel(rdoId));
109  rdoList.push_back(prdId);
110 
111  // get the local and global positions
112  const MuonGM::MMReadoutElement* detEl = MuonDetMgr->getMMReadoutElement(prdId);
113  Amg::Vector2D localPos{Amg::Vector2D::Zero()};
114 
115  bool getLocalPos = detEl->stripPosition(prdId, localPos);
116  if (!getLocalPos) {
117  if (msgLvl(MSG::DEBUG)) { // We should still keep this a warning and fix it properly but silence it for now (ATLASRECTS-7520)
118  ATH_MSG_WARNING("Could not get the local strip position for "<< m_idHelperSvc->toString(prdId));
119  }
120  continue;
121  }
122 
123  Amg::Vector3D globalPos{Amg::Vector3D::Zero()};
124  bool getGlobalPos = detEl->stripGlobalPosition(prdId, globalPos);
125  if (!getGlobalPos) {
126  ATH_MSG_WARNING("Could not get the global strip position for MM");
127  continue;
128  }
129  NSWCalib::CalibratedStrip calibStrip;
130  ATH_CHECK(m_calibTool->calibrateStrip(ctx, rdo, calibStrip));
131  if (calibStrip.charge < 0) {
132  if (!hitNegativeCharge || msgLvl(MSG::DEBUG)) {
133  ATH_MSG_WARNING("One MM RDO or more, such as one with pdo = "<< rdo->charge()
134  << " counts, corresponds to a negative charge ("<< calibStrip.charge << "). Skipping these RDOs");
135  hitNegativeCharge = true;
136  }
137  continue;
138  }
139 
140  Trk::LocalDirection localDir;
141  const Trk::PlaneSurface& psurf = detEl->surface(prdId);
142  Amg::Vector2D lpos{Amg::Vector2D::Zero()};
143  psurf.globalToLocal(globalPos, globalPos, lpos);
144  psurf.globalToLocalDirection(globalPos, localDir);
145 
146  ATH_MSG_DEBUG(" Surface centre x " << Amg::toString(psurf.center()));
147  ATH_MSG_DEBUG(" localPos x " <<Amg::toString(localPos)<< " localPos y " << Amg::toString(lpos));
148 
149  Amg::Vector3D gdir = psurf.transform().linear() * Amg::Vector3D::UnitY();
150  ATH_MSG_DEBUG(" MM detector surface direction phi "<< gdir.phi() << " global radius hit " << globalPos.perp()
151  << " phi pos " << globalPos.phi() << " global z "<< globalPos.z());
152 
153  auto cov = Amg::MatrixX(2, 2);
154  cov.setIdentity();
155  (cov)(0, 0) = calibStrip.resTransDistDrift;
156  (cov)(1, 1) = calibStrip.resLongDistDrift;
157  localPos.x() += calibStrip.dx;
158 
159  if (!merge) {
160  // storage will be handeled by Store Gate
161  auto mpd = std::make_unique<MMPrepData>(prdId, hash,
162  std::move(localPos), std::move(rdoList), std::move(cov),
163  detEl,
164  calibStrip.time, calibStrip.charge, calibStrip.distDrift);
165  mpd->setAuthor(MMPrepData::Author::RDOTOPRDConverter);
166 
167  prdColl->push_back(std::move(mpd));
168 
169  } else {
170  if (calibStrip.charge < m_singleStripChargeCut) {
171  continue;
172  }
173  MMPrepData mpd(prdId, hash, std::move(localPos), std::move(rdoList),
174  std::move(cov), detEl, calibStrip.time, calibStrip.charge,
175  calibStrip.distDrift);
176  // set the hash of the MMPrepData such that it contains the correct value
177  // in case it gets used in SimpleMMClusterBuilderTool::getClusters
178  mpd.setHashAndIndex(hash, 0);
179  mpd.setAuthor(MMPrepData::Author::RDOTOPRDConverter);
180  MMprds.push_back(std::move(mpd));
181  }
182  }
183 
184  if (merge) {
185  std::vector<std::unique_ptr<MMPrepData>> clusters;
186 
188  ATH_CHECK(m_clusterBuilderTool->getClusters(ctx, std::move(MMprds), clusters));
189 
190  for (std::unique_ptr<MMPrepData>& prdN : clusters) {
191  prdN->setHashAndIndex(prdColl->identifyHash(), prdColl->size());
192  prdColl->push_back(std::move(prdN));
193  }
194  } // merge
195 
196  if (xAODContainer) {
197  // Lambda to fill xprd from prd
198  std::vector<const MMPrepData*> sortMe{prdColl->begin(), prdColl->end()};
199  std::ranges::sort(sortMe, IdentifierByDetElSorter{m_idHelperSvc.get()});
200  for (const MMPrepData* prd : sortMe) {
201  xAOD::MMCluster* cluster{xAODContainer->push_back(std::make_unique<xAOD::MMCluster>())};
202  cluster->setIdentifier(prd->identify().get_compact());
203  cluster->setMeasurement(m_idHelperSvc->detElementHash(prd->identify()),
204  xAOD::MeasVector<1>{prd->localPosition().x()},
205  xAOD::MeasMatrix<1>{prd->localCovariance()(0, 0)});
206  cluster->setGasGap(id_helper.gasGap(prd->identify()));
207  cluster->setChannelNumber(id_helper.channel(prd->identify()));
208  cluster->setTime(prd->time());
209  cluster->setCharge(prd->charge());
210  cluster->setDriftDist(prd->driftDist());
211  cluster->setAngle(prd->angle());
212  cluster->setChiSqProb(prd->chisqProb());
213  cluster->setAuthor(prd->author());
214  cluster->setQuality(prd->quality());
215  cluster->setStripNumbers(prd->stripNumbers());
216  cluster->setStripTimes(prd->stripTimes());
217  cluster->setStripCharges(prd->stripCharges());
218  cluster->setStripDriftDist(prd->stripDriftDist());
219  cluster->setStripDriftErrors(prd->stripDriftErrors());
220  }
221  }
222  // now write the collection
223  ATH_CHECK(lock.addOrDelete(std::move(prdColl)));
224  ATH_MSG_DEBUG("PRD hash " << hash << " has been moved to container");
225 
226  return StatusCode::SUCCESS;
227 }

◆ processRDOContainer()

void Muon::MmRdoToPrepDataToolMT::processRDOContainer ( const EventContext &  ctx,
Muon::MMPrepDataContainer *  mmPrepDataContainer,
xAOD::MMClusterContainer *  xAODContainer,
const std::vector< IdentifierHash > &  idsToDecode 
) const
protected

Definition at line 241 of file MmRdoToPrepDataToolMT.cxx.

244  {
245  ATH_MSG_DEBUG("In processRDOContainer");
246  const MM_RawDataContainer* rdoContainer = getRdoContainer(ctx);
247  if (!rdoContainer) {
248  return;
249  }
250 
251  for (const MM_RawDataCollection* rdoColl : *rdoContainer) {
252 
253  if (rdoColl->empty()){
254  continue;
255  }
256  ATH_MSG_DEBUG("New RDO collection with " << rdoColl->size() << "MM Hits");
257 
258  if (processCollection(ctx, mmPrepDataContainer, xAODContainer, idsToDecode, rdoColl).isFailure()) {
259  ATH_MSG_DEBUG(
260  "processCsm returns a bad StatusCode - keep going for new data "
261  "collections in this event");
262  }
263  }
264 }

◆ provideEmptyContainer()

StatusCode Muon::MmRdoToPrepDataToolMT::provideEmptyContainer ( const EventContext &  ctx) const
overridevirtual

Definition at line 298 of file MmRdoToPrepDataToolMT.cxx.

298  {
299  if (!m_xAODKey.empty()) {
300  SG::WriteHandle writeHandle{m_xAODKey, ctx};
301  ATH_CHECK(writeHandle.record(std::make_unique<xAOD::MMClusterContainer>(),
302  std::make_unique<xAOD::MMClusterAuxContainer>()));
303  }
304 
305  return setupMM_PrepDataContainer(ctx) ? StatusCode::SUCCESS
306  : StatusCode::FAILURE;
307 }

◆ setupMM_PrepDataContainer()

MMPrepDataContainer * Muon::MmRdoToPrepDataToolMT::setupMM_PrepDataContainer ( const EventContext &  ctx) const
protected

Definition at line 310 of file MmRdoToPrepDataToolMT.cxx.

310  {
311 
312  SG::WriteHandle handle{m_writeKey, ctx};
313  if (m_updateKey.key().empty()) {
314  // No external cache, just record the container
315  StatusCode status =
316  handle.record(std::make_unique<MMPrepDataContainer>(
317  m_idHelperSvc->mmIdHelper().module_hash_max()));
318 
319  if (status.isFailure() || !handle.isValid()) {
320  ATH_MSG_FATAL(
321  "Could not record container of MicroMega PrepData Container at "
322  << m_writeKey.key());
323  return nullptr;
324  }
325  } else {
326  // use the cache to get the container
327  SG::UpdateHandle update(m_updateKey, ctx);
328  if (!update.isValid()) {
329  ATH_MSG_FATAL("Invalid UpdateHandle " << m_updateKey.key());
330  return nullptr;
331  }
332  StatusCode status = handle.record(std::make_unique<MMPrepDataContainer>(update.ptr()));
333  if (status.isFailure() || !handle.isValid()) {
334  ATH_MSG_FATAL(
335  "Could not record container of MM PrepData Container using cache "
336  << m_updateKey.key() << " - "
337  << m_writeKey.key());
338  return nullptr;
339  }
340  ATH_MSG_DEBUG("Created container using cache for "
341  << m_updateKey.key());
342  }
343  return handle.ptr();
344 }

◆ setupxAODPrepDataContainer()

xAOD::MMClusterContainer* Muon::MmRdoToPrepDataToolMT::setupxAODPrepDataContainer ( SG::WriteHandle< xAOD::MMClusterContainer > &  outputContainer) const
protected

Member Data Documentation

◆ m_calibTool

ToolHandle<INSWCalibTool> Muon::MmRdoToPrepDataToolMT::m_calibTool {this, "NSWCalibTool", ""}
protected

Definition at line 82 of file MmRdoToPrepDataToolMT.h.

◆ m_clusterBuilderTool

ToolHandle<IMMClusterBuilderTool> Muon::MmRdoToPrepDataToolMT::m_clusterBuilderTool
protected
Initial value:
{
this, "ClusterBuilderTool",
"Muon::SimpleMMClusterBuilderTool/SimpleMMClusterBuilderTool"}

Definition at line 79 of file MmRdoToPrepDataToolMT.h.

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> Muon::MmRdoToPrepDataToolMT::m_idHelperSvc
protected
Initial value:
{
this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

Definition at line 64 of file MmRdoToPrepDataToolMT.h.

◆ m_merge

Gaudi::Property<bool> Muon::MmRdoToPrepDataToolMT::m_merge {this, "MergePrds", true}
protected

Definition at line 77 of file MmRdoToPrepDataToolMT.h.

◆ m_muDetMgrKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> Muon::MmRdoToPrepDataToolMT::m_muDetMgrKey
protected
Initial value:
{
this, "DetectorManagerKey", "MuonDetectorManager",
"Key of input MuonDetectorManager condition data"}

Definition at line 60 of file MmRdoToPrepDataToolMT.h.

◆ m_readKey

SG::ReadHandleKey<MM_RawDataContainer> Muon::MmRdoToPrepDataToolMT::m_readKey
protected
Initial value:
{
this, "InputCollection", "MMRDO"}

Definition at line 70 of file MmRdoToPrepDataToolMT.h.

◆ m_singleStripChargeCut

Gaudi::Property<float> Muon::MmRdoToPrepDataToolMT::m_singleStripChargeCut
protected
Initial value:
{
this, "singleStripChargeCut",
FLT_MIN }

Definition at line 86 of file MmRdoToPrepDataToolMT.h.

◆ m_updateKey

SG::UpdateHandleKey<MMPrepDataCollection_Cache> Muon::MmRdoToPrepDataToolMT::m_updateKey
protected
Initial value:
{
this, "PrdCacheKey", "",
"Optional external cache for the MM PRD container"}

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

Definition at line 74 of file MmRdoToPrepDataToolMT.h.

◆ m_writeKey

SG::WriteHandleKey<Muon::MMPrepDataContainer> Muon::MmRdoToPrepDataToolMT::m_writeKey
protected
Initial value:
{
this, "OutputCollection", "MM_Measurements"}

MdtPrepRawData containers.

Definition at line 68 of file MmRdoToPrepDataToolMT.h.

◆ m_xAODKey

SG::WriteHandleKey<xAOD::MMClusterContainer> Muon::MmRdoToPrepDataToolMT::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 89 of file MmRdoToPrepDataToolMT.h.

The documentation for this class was generated from the following files:
MuonGM::MMReadoutElement::stripPosition
virtual bool stripPosition(const Identifier &id, Amg::Vector2D &pos) const override final
strip position – local or global If the strip number is outside the range of valid strips,...
Definition: MMReadoutElement.h:207
Muon::MmRdoToPrepDataToolMT::m_muDetMgrKey
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > m_muDetMgrKey
Definition: MmRdoToPrepDataToolMT.h:60
Trk::PlaneSurface::globalToLocal
virtual bool globalToLocal(const Amg::Vector3D &glob, const Amg::Vector3D &mom, Amg::Vector2D &loc) const override final
Specified for PlaneSurface: GlobalToLocal method without dynamic memory allocation - boolean checks i...
Definition: PlaneSurface.cxx:215
Muon::MmRdoToPrepDataToolMT::processCollection
StatusCode processCollection(const EventContext &ctx, Muon::MMPrepDataContainer *mmPrepDataContainer, xAOD::MMClusterContainer *xAODContainer, const std::vector< IdentifierHash > &idsToDecode, const MM_RawDataCollection *rdoColl) const
Definition: MmRdoToPrepDataToolMT.cxx:43
NSWCalib::CalibratedStrip::time
double time
Definition: INSWCalibTool.h:22
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
Amg::MatrixX
Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > MatrixX
Dynamic Matrix - dynamic allocation.
Definition: EventPrimitives.h:27
NSWCalib::CalibratedStrip::charge
double charge
Definition: INSWCalibTool.h:21
IdentifiableContainerMT::IDC_WriteHandle
friend class IDC_WriteHandle
Definition: IdentifiableContainerMT.h:140
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:24
MuonIdHelper::get_id
virtual int get_id(const IdentifierHash &hash_id, Identifier &id, const IdContext *context=0) const override
Create compact id from hash id (return == 0 for OK)
Definition: MuonIdHelper.cxx:68
Trk::PrepRawDataType::MMPrepData
@ MMPrepData
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
xAOD::MMCluster_v1
Definition: MMCluster_v1.h:20
NSWCalib::CalibratedStrip::distDrift
double distDrift
Definition: INSWCalibTool.h:24
IdentifiableContainerMT::getWriteHandle
IDC_WriteHandle getWriteHandle(IdentifierHash hash)
Definition: IdentifiableContainerMT.h:248
Muon::MmRdoToPrepDataToolMT::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: MmRdoToPrepDataToolMT.h:64
NSWCalib::CalibratedStrip::dx
double dx
Definition: INSWCalibTool.h:27
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition: GeoPrimitives.h:48
Muon::MmRdoToPrepDataToolMT::m_clusterBuilderTool
ToolHandle< IMMClusterBuilderTool > m_clusterBuilderTool
Definition: MmRdoToPrepDataToolMT.h:79
Muon::MMPrepDataContainer
MuonPrepDataContainerT< MMPrepData > MMPrepDataContainer
Definition: MuonPrepDataContainer.h:100
plotBeamSpotVxVal.cov
cov
Definition: plotBeamSpotVxVal.py:201
NSWCalib::CalibratedStrip::resTransDistDrift
double resTransDistDrift
Definition: INSWCalibTool.h:25
Muon::MmRdoToPrepDataToolMT::processRDOContainer
void processRDOContainer(const EventContext &ctx, Muon::MMPrepDataContainer *mmPrepDataContainer, xAOD::MMClusterContainer *xAODContainer, const std::vector< IdentifierHash > &idsToDecode) const
Definition: MmRdoToPrepDataToolMT.cxx:241
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
Trk::Surface::center
const Amg::Vector3D & center() const
Returns the center position of the Surface.
NSWCalib::CalibratedStrip::resLongDistDrift
double resLongDistDrift
Definition: INSWCalibTool.h:26
MuonGM::MuonClusterReadoutElement::surface
virtual const Trk::PlaneSurface & surface() const override
access to chamber surface (phi orientation), uses the first gas gap
Definition: MuonClusterReadoutElement.h:123
Muon::MmRdoToPrepDataToolMT::m_updateKey
SG::UpdateHandleKey< MMPrepDataCollection_Cache > m_updateKey
This is the key for the cache for the MM PRD containers, can be empty.
Definition: MmRdoToPrepDataToolMT.h:74
MmIdHelper::multilayer
int multilayer(const Identifier &id) const
Definition: MmIdHelper.cxx:796
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:274
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
Amg::toString
std::string toString(const Translation3D &translation, int precision=4)
GeoPrimitvesToStringConverter.
Definition: GeoPrimitivesToStringConverter.h:40
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
columnar::ContainerId::cluster
@ cluster
beamspotman.n
n
Definition: beamspotman.py:731
Muon::MmRdoToPrepDataToolMT::m_xAODKey
SG::WriteHandleKey< xAOD::MMClusterContainer > m_xAODKey
Definition: MmRdoToPrepDataToolMT.h:89
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
MuonGM::MMReadoutElement::stripGlobalPosition
bool stripGlobalPosition(const Identifier &id, Amg::Vector3D &gpos) const
Definition: MMReadoutElement.h:280
Muon::MMPrepData::Author::RDOTOPRDConverter
@ RDOTOPRDConverter
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Trk::PlaneSurface::globalToLocalDirection
void globalToLocalDirection(const Amg::Vector3D &glodir, Trk::LocalDirection &locdir) const
This method transforms the global direction to a local direction wrt the plane.
Definition: PlaneSurface.cxx:262
NSWCalib::CalibratedStrip
Definition: INSWCalibTool.h:20
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
Trk::LocalDirection
represents the three-dimensional global direction with respect to a planar surface frame.
Definition: LocalDirection.h:81
columnar::xAODContainer
typename ContainerIdTraits< CI >::xAODObjectRangeType xAODContainer
Definition: ObjectRange.h:114
xAOD::MeasVector
Eigen::Matrix< float, N, 1 > MeasVector
Abrivation of the Matrix & Covariance definitions.
Definition: MeasurementDefs.h:53
Muon::MmRdoToPrepDataToolMT::getRdoContainer
const MM_RawDataContainer * getRdoContainer(const EventContext &ctx) const
Definition: MmRdoToPrepDataToolMT.cxx:230
Muon::MmRdoToPrepDataToolMT::m_singleStripChargeCut
Gaudi::Property< float > m_singleStripChargeCut
Definition: MmRdoToPrepDataToolMT.h:86
SG::UpdateHandle
Definition: UpdateHandle.h:91
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
Muon::MmRdoToPrepDataToolMT::m_merge
Gaudi::Property< bool > m_merge
Definition: MmRdoToPrepDataToolMT.h:77
IdentifiableContainerMT::indexFindPtr
virtual const T * indexFindPtr(IdentifierHash hashId) const override final
return pointer on the found entry or null if out of range using hashed index - fast version,...
Definition: IdentifiableContainerMT.h:289
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:73
MmIdHelper::channel
int channel(const Identifier &id) const override
Definition: MmIdHelper.cxx:800
MmIdHelper
Definition: MmIdHelper.h:54
MmIdHelper::gasGap
int gasGap(const Identifier &id) const override
get the hashes
Definition: MmIdHelper.cxx:798
CaloCondBlobAlgs_fillNoiseFromASCII.hash
dictionary hash
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:109
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
Trk::PlaneSurface
Definition: PlaneSurface.h:64
DEBUG
#define DEBUG
Definition: page_access.h:11
RunTileMonitoring.clusters
clusters
Definition: RunTileMonitoring.py:133
MuonIdHelper::module_context
IdContext module_context() const
id for module
Definition: MuonIdHelper.cxx:731
MuonGM::MMReadoutElement
An MMReadoutElement corresponds to a single STGC module; therefore typicaly a barrel muon station con...
Definition: MMReadoutElement.h:25
merge.status
status
Definition: merge.py:17
xAOD::MeasMatrix
Eigen::Matrix< float, N, N > MeasMatrix
Definition: MeasurementDefs.h:55
Muon::MmRdoToPrepDataToolMT::setupMM_PrepDataContainer
Muon::MMPrepDataContainer * setupMM_PrepDataContainer(const EventContext &ctx) const
Definition: MmRdoToPrepDataToolMT.cxx:310
MmIdHelper::channelID
Identifier channelID(int stationName, int stationEta, int stationPhi, int multilayer, int gasGap, int channel) const
Definition: MmIdHelper.cxx:736
Muon::MmRdoToPrepDataToolMT::m_writeKey
SG::WriteHandleKey< Muon::MMPrepDataContainer > m_writeKey
MdtPrepRawData containers.
Definition: MmRdoToPrepDataToolMT.h:68
Trk::Surface::transform
const Amg::Transform3D & transform() const
Returns HepGeom::Transform3D by reference.
IdContext
This class saves the "context" of an expanded identifier (ExpandedIdentifier) for compact or hash ver...
Definition: IdContext.h:26
WriteBchToCool.update
update
Definition: WriteBchToCool.py:67
Muon::MmRdoToPrepDataToolMT::m_calibTool
ToolHandle< INSWCalibTool > m_calibTool
Definition: MmRdoToPrepDataToolMT.h:82
merge
Definition: merge.py:1
generate::Zero
void Zero(TH1D *hin)
Definition: generate.cxx:32
Muon::MmRdoToPrepDataToolMT::m_readKey
SG::ReadHandleKey< MM_RawDataContainer > m_readKey
Definition: MmRdoToPrepDataToolMT.h:70
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Sat Apr 12 2025 22:02:22 for ATLAS Offline Software by   doxygen 1.8.18