ATLAS Offline Software
MuonPrdSelectorAlg.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "MuonPrdSelector/MuonPrdSelectorAlg.h"
6 
7 #include <iomanip>
8 
9 // Constructor with parameters:
10 MuonPrdSelectorAlg::MuonPrdSelectorAlg(const std::string &name, ISvcLocator *pSvcLocator)
11  : AthAlgorithm(name,pSvcLocator),
12  m_mdtPRDs_in(nullptr), m_rpcPRDs_in(nullptr), m_tgcPRDs_in(nullptr), m_cscPRDs_in(nullptr),
13  m_mdtPRDs_out(nullptr), m_rpcPRDs_out(nullptr), m_tgcPRDs_out(nullptr), m_cscPRDs_out(nullptr)
14 {
15  declareProperty("MDT_PRDinputContainer" , m_inputContainer_mdt = "MDT_DriftCircles_unfiltered" );
16  declareProperty("MDT_PRDoutputContainer" , m_outputContainer_mdt = "MDT_DriftCircles" );
17 
18  declareProperty("RPC_PRDinputContainer" , m_inputContainer_rpc = "RPC_Measurements_unfiltered" );
19  declareProperty("RPC_PRDoutputContainer" , m_outputContainer_rpc = "RPC_Measurements" );
20 
21  declareProperty("TGC_PRDinputContainer" , m_inputContainer_tgc = "TGC_Measurements_unfiltered" );
22  declareProperty("TGC_PRDoutputContainer" , m_outputContainer_tgc = "TGC_Measurements" );
23 
24  declareProperty("CSC_PRDinputContainer" , m_inputContainer_csc = "CSC_Measurements_unfiltered" );
25  declareProperty("CSC_PRDoutputContainer" , m_outputContainer_csc = "CSC_Measurements" );
26 }
27 
28 
29 // Initialize method:
30 StatusCode MuonPrdSelectorAlg::initialize()
31 {
32  ATH_MSG_DEBUG( "initialize() called" );
33 
34  ATH_CHECK( m_idHelperSvc.retrieve() );
35 
36  // retrieve test tool
37  ATH_CHECK( m_muonIdCutTool.retrieve() );
38 
39  try {
40  m_mdtPRDs_out = new Muon::MdtPrepDataContainer(m_idHelperSvc->mdtIdHelper().module_hash_max());
41  } catch(const std::bad_alloc&) {
42  ATH_MSG_FATAL( "Could not create a new MDT PrepRawData container!" );
43  return StatusCode::FAILURE;
44  }
45  m_mdtPRDs_out->addRef();
46 
47 
48 
49  try {
50  m_rpcPRDs_out = new Muon::RpcPrepDataContainer(m_idHelperSvc->rpcIdHelper().module_hash_max());
51  } catch(const std::bad_alloc&) {
52  ATH_MSG_FATAL( "Could not create a new RPC PrepRawData container!" );
53  return StatusCode::FAILURE;
54  }
55  m_rpcPRDs_out->addRef();
56 
57  try {
58  m_tgcPRDs_out = new Muon::TgcPrepDataContainer(m_idHelperSvc->tgcIdHelper().module_hash_max());
59  } catch(const std::bad_alloc&) {
60  ATH_MSG_FATAL( "Could not create a new TGC PrepRawData container!" );
61  return StatusCode::FAILURE;
62  }
63  m_tgcPRDs_out->addRef();
64 
65 
66  try {
67  m_cscPRDs_out = new Muon::CscStripPrepDataContainer(m_idHelperSvc->cscIdHelper().module_hash_max());
68  } catch(const std::bad_alloc&) {
69  ATH_MSG_FATAL( "Could not create a new CSC PrepRawData container!" );
70  return StatusCode::FAILURE;
71  }
72  m_cscPRDs_out->addRef();
73 
74 
75  return StatusCode::SUCCESS;
76 }
77 
78 StatusCode MuonPrdSelectorAlg::execute()
79 {
80  ATH_MSG_DEBUG( "execute() called" );
81  ATH_CHECK( retrieveContainers() );
82  ATH_CHECK( recordContainers() );
83  ATH_CHECK( performSelection() );
84  return StatusCode::SUCCESS;
85 }
86 
87 StatusCode MuonPrdSelectorAlg::retrieveContainers() {
88  ATH_MSG_DEBUG( "retrieveContainers() called" );
89 
90  //resetting the inputcollections.
91  m_mdtPRDs_in = nullptr;
92  m_rpcPRDs_in = nullptr;
93  m_tgcPRDs_in = nullptr;
94  m_cscPRDs_in = nullptr;
95 
96  StatusCode sc = evtStore()->retrieve( m_mdtPRDs_in, m_inputContainer_mdt );
97  if( sc.isFailure() ) {
98  ATH_MSG_WARNING( "Could not retrieve MDT PRDs input container "
99  << m_inputContainer_mdt );
100  } else {
101  ATH_MSG_DEBUG( "Retrieved MDT PRDs input container " << m_inputContainer_mdt << " ( "
102  << m_mdtPRDs_in->size() << " ) " );
103  }
104 
105  sc = evtStore()->retrieve( m_rpcPRDs_in, m_inputContainer_rpc );
106  if( sc.isFailure() ) {
107  ATH_MSG_WARNING( "Could not retrieve RPC PRDs input container "
108  << m_inputContainer_rpc );
109  } else {
110  ATH_MSG_DEBUG( "Retrieved RPC PRDs input container " << m_inputContainer_rpc << " ( "
111  << m_rpcPRDs_in->size() << " ) " );
112  }
113 
114  sc = evtStore()->retrieve( m_tgcPRDs_in, m_inputContainer_tgc );
115  if( sc.isFailure() ) {
116  ATH_MSG_WARNING( "Could not retrieve TGC PRDs input container "
117  << m_inputContainer_tgc );
118  } else {
119  ATH_MSG_DEBUG( "Retrieved TGC PRDs input container " << m_inputContainer_tgc << " ( "
120  << m_tgcPRDs_in->size() << " ) " );
121  }
122 
123  sc = evtStore()->retrieve( m_cscPRDs_in, m_inputContainer_csc );
124  if( sc.isFailure() ) {
125  ATH_MSG_WARNING( "Could not retrieve CSC PRDs input container "
126  << m_inputContainer_csc );
127  } else {
128  ATH_MSG_DEBUG( "Retrieved CSC PRDs input container " << m_inputContainer_csc << " ( "
129  << m_cscPRDs_in->size() << " ) " );
130  }
131 
132  return StatusCode::SUCCESS;
133 }
134 
135 
136 StatusCode MuonPrdSelectorAlg::recordContainers() {
137  StatusCode sc = evtStore()->record( m_mdtPRDs_out, m_outputContainer_mdt );
138  if( sc.isFailure() ) ATH_MSG_DEBUG( "Could not record MDT PRDs to output container " << m_outputContainer_mdt );
139 
140  sc = evtStore()->record( m_rpcPRDs_out, m_outputContainer_rpc );
141  if( sc.isFailure() ) ATH_MSG_DEBUG( "Could not record RPC PRDs to output container " << m_outputContainer_rpc );
142 
143  sc = evtStore()->record( m_tgcPRDs_out, m_outputContainer_tgc );
144  if( sc.isFailure() ) ATH_MSG_DEBUG( "Could not record TGC PRDs to output container " << m_outputContainer_tgc );
145 
146  sc = evtStore()->record( m_cscPRDs_out, m_outputContainer_csc );
147  if( sc.isFailure() ) ATH_MSG_DEBUG( "Could not record CSC PRDs to output container " << m_outputContainer_csc );
148  return sc;
149 }
150 
151 StatusCode MuonPrdSelectorAlg::performSelection() {
152  if( m_mdtPRDs_in ) ATH_CHECK( selectMDTs() );
153  if( m_rpcPRDs_in ) ATH_CHECK( selectRPCs() );
154  if( m_tgcPRDs_in ) ATH_CHECK( selectTGCs() );
155  if( m_cscPRDs_in ) ATH_CHECK( selectCSCs() );
156 
157  return StatusCode::SUCCESS;
158 }
159 
160 
161 StatusCode MuonPrdSelectorAlg::selectMDTs() {
162  StatusCode sc = StatusCode::SUCCESS ;
163 
164  // Clearing the outputContainers
165  m_mdtPRDs_out->cleanup();
166 
167 
168  Muon::MdtPrepDataContainer::const_iterator mdtColl = m_mdtPRDs_in->begin();
169  Muon::MdtPrepDataContainer::const_iterator last_mdtColl = m_mdtPRDs_in->end();
170 
171  unsigned int i_mdtColl(0);
172 
173 
174  for( ; mdtColl!=last_mdtColl ; ++mdtColl, ++i_mdtColl ){ //for each collection
175 
176  Identifier ID = (*mdtColl)->identify() ;
177  IdentifierHash hashID = (*mdtColl)->identifyHash();
178  Muon::MdtPrepDataCollection * driftCircleColl = new Muon::MdtPrepDataCollection(hashID);
179  (driftCircleColl)->setIdentifier(ID);
180 
181  Muon::MdtPrepDataCollection::const_iterator mdtItr = (*mdtColl)->begin();
182  Muon::MdtPrepDataCollection::const_iterator mdtEnd = (*mdtColl)->end();
183  int i = 0;
184 
185  for(; mdtItr != mdtEnd; ++mdtItr,i++ ) { //for each hit in the collection
186  Identifier hitID =(*mdtItr)->identify();
187 
188  if (!m_muonIdCutTool->isCut(hitID)){ //write event to new collection
189 
190  driftCircleColl->push_back(new Muon::MdtPrepData(**mdtItr));
191  ATH_MSG_DEBUG( "Writing Event." );
192  }
193  else
194  ATH_MSG_DEBUG( "Rejecting Event." );
195 
196  }
197 
198 
199  Identifier newID = (driftCircleColl)->identify();
200  ATH_MSG_DEBUG( "Adding New Collection to MDT list:" << newID );
201  if (StatusCode::SUCCESS != m_mdtPRDs_out->addCollection(driftCircleColl,hashID )) {
202  ATH_MSG_ERROR( "Couldn't record MDT Drift Circle Collection with hash=" << hashID
203  << " in StoreGate!" );
204  continue;
205  }
206  else{
207  ATH_MSG_DEBUG( " Added collection with hashID " << hashID
208  << " in StoreGate!" );
209 
210  }
211  }
212  return sc ;
213 }
214 
215 
216 StatusCode MuonPrdSelectorAlg::selectRPCs() {
217  StatusCode sc = StatusCode::SUCCESS ;
218 
219  // Clearing the outputContainers
220  m_rpcPRDs_out->cleanup();
221 
222 
223  Muon::RpcPrepDataContainer::const_iterator rpcColl = m_rpcPRDs_in->begin();
224  Muon::RpcPrepDataContainer::const_iterator last_rpcColl = m_rpcPRDs_in->end();
225 
226  unsigned int i_rpcColl(0);
227 
228 
229  for( ; rpcColl!=last_rpcColl ; ++rpcColl, ++i_rpcColl ){ //for each collection
230 
231  Identifier ID = (*rpcColl)->identify() ;
232  IdentifierHash hashID = (*rpcColl)->identifyHash();
233  Muon::RpcPrepDataCollection * rpcPrdColl = new Muon::RpcPrepDataCollection(hashID);
234  (rpcPrdColl)->setIdentifier(ID);
235 
236  Muon::RpcPrepDataCollection::const_iterator rpcItr = (*rpcColl)->begin();
237  Muon::RpcPrepDataCollection::const_iterator rpcEnd = (*rpcColl)->end();
238  int i = 0;
239 
240  for(; rpcItr != rpcEnd; ++rpcItr,i++ ) { //for each hit in the collection
241  Identifier hitID =(*rpcItr)->identify();
242 
243  if (!m_muonIdCutTool->isCut(hitID)){ //write event to new collection
244 
245  rpcPrdColl->push_back(new Muon::RpcPrepData(**rpcItr));
246  ATH_MSG_DEBUG( "Writing Event." );
247  }
248  else
249  ATH_MSG_DEBUG( "Rejecting Event." );
250 
251  }
252 
253 
254  Identifier newID = (rpcPrdColl)->identify();
255  ATH_MSG_DEBUG( "Adding New Collection to RPC list:" << newID );
256  if (StatusCode::SUCCESS != m_rpcPRDs_out->addCollection(rpcPrdColl,hashID )) {
257  ATH_MSG_ERROR( "Couldn't record RPC Drift Circle Collection with hashID=" << hashID
258  << " in StoreGate!" );
259  continue;
260  }
261  else{
262  ATH_MSG_DEBUG( " Added collection with hashID " << hashID
263  << " in StoreGate!" );
264 
265  }
266  }
267  return sc ;
268 }
269 
270 
271 StatusCode MuonPrdSelectorAlg::selectTGCs() {
272  StatusCode sc = StatusCode::SUCCESS ;
273 
274  // Clearing the outputContainers
275  m_tgcPRDs_out->cleanup();
276 
277 
278  Muon::TgcPrepDataContainer::const_iterator tgcColl = m_tgcPRDs_in->begin();
279  Muon::TgcPrepDataContainer::const_iterator last_tgcColl = m_tgcPRDs_in->end();
280 
281  unsigned int i_tgcColl(0);
282 
283 
284  for( ; tgcColl!=last_tgcColl ; ++tgcColl, ++i_tgcColl ){ //for each collection
285 
286  Identifier ID = (*tgcColl)->identify() ;
287  IdentifierHash hashID = (*tgcColl)->identifyHash();
288  Muon::TgcPrepDataCollection * tgcPrdColl = new Muon::TgcPrepDataCollection(hashID);
289  (tgcPrdColl)->setIdentifier(ID);
290 
291  Muon::TgcPrepDataCollection::const_iterator tgcItr = (*tgcColl)->begin();
292  Muon::TgcPrepDataCollection::const_iterator tgcEnd = (*tgcColl)->end();
293  int i = 0;
294 
295  for(; tgcItr != tgcEnd; ++tgcItr,i++ ) { //for each hit in the collection
296  Identifier hitID =(*tgcItr)->identify();
297 
298  if (!m_muonIdCutTool->isCut(hitID)){ //write event to new collection
299 
300  tgcPrdColl->push_back(new Muon::TgcPrepData(**tgcItr));
301  ATH_MSG_DEBUG( "Writing Event." );
302  }
303  else
304  ATH_MSG_DEBUG( "Rejecting Event." );
305 
306  }
307 
308 
309  Identifier newID = (tgcPrdColl)->identify();
310  ATH_MSG_DEBUG( "Adding New Collection to TGC list:" << newID );
311  if (StatusCode::SUCCESS != m_tgcPRDs_out->addCollection(tgcPrdColl,hashID )) {
312  ATH_MSG_ERROR( "Couldn't record TGC Drift Circle Collection with hashID=" << hashID
313  << " in StoreGate!" );
314  continue;
315  }
316  else{
317  ATH_MSG_DEBUG( " Added collection with hashID " << hashID
318  << " in StoreGate!" );
319  }
320  }
321  return sc ;
322 }
323 
324 
325 StatusCode MuonPrdSelectorAlg::selectCSCs() {
326  StatusCode sc = StatusCode::SUCCESS ;
327 
328  // Clearing the outputContainers
329  m_cscPRDs_out->cleanup();
330 
331 
332  Muon::CscStripPrepDataContainer::const_iterator cscColl = m_cscPRDs_in->begin();
333  Muon::CscStripPrepDataContainer::const_iterator last_cscColl = m_cscPRDs_in->end();
334 
335  unsigned int i_cscColl(0);
336 
337 
338  for( ; cscColl!=last_cscColl ; ++cscColl, ++i_cscColl ){ //for each collection
339 
340  Identifier ID = (*cscColl)->identify() ;
341  IdentifierHash hashID = (*cscColl)->identifyHash();
342  Muon::CscStripPrepDataCollection * cscPrdColl = new Muon::CscStripPrepDataCollection(hashID);
343  (cscPrdColl)->setIdentifier(ID);
344 
345  Muon::CscStripPrepDataCollection::const_iterator cscItr = (*cscColl)->begin();
346  Muon::CscStripPrepDataCollection::const_iterator cscEnd = (*cscColl)->end();
347  int i = 0;
348 
349  for(; cscItr != cscEnd; ++cscItr,i++ ) { //for each hit in the collection
350  Identifier hitID =(*cscItr)->identify();
351 
352  if (!m_muonIdCutTool->isCut(hitID)){ //write event to new collection
353 
354  cscPrdColl->push_back(new Muon::CscStripPrepData(**cscItr));
355  ATH_MSG_DEBUG( "Writing Event." );
356  }
357  else
358  ATH_MSG_DEBUG( "Rejecting Event." );
359  }
360 
361 
362  Identifier newID = (cscPrdColl)->identify();
363  ATH_MSG_DEBUG( "Adding New Collection to CSC list:" << newID );
364  if (StatusCode::SUCCESS != m_cscPRDs_out->addCollection(cscPrdColl,hashID )) {
365  ATH_MSG_ERROR( "Couldn't record CSC Collection with hashID=" << hashID
366  << " in StoreGate!" );
367  continue;
368  }
369  else{
370  ATH_MSG_DEBUG( " Added collection with hashID " << hashID
371  << " in StoreGate!" );
372 
373  }
374  }
375  return sc ;
376 }
377 
378 
379 void MuonPrdSelectorAlg::print(){
380  Muon::MdtPrepDataContainer::const_iterator mdtColl = m_mdtPRDs_in->begin();
381  Muon::MdtPrepDataContainer::const_iterator last_mdtColl = m_mdtPRDs_in->end();
382  unsigned int i_coll(0);
383  for( ; mdtColl!=last_mdtColl ; ++mdtColl, ++i_coll ){
384  Identifier ID = (*mdtColl)->identify() ;
385  ATH_MSG_DEBUG( "MDT IN Collection(" << std::setw(2) << i_coll << ") : " << ID );
386  }
387 
388  mdtColl = m_mdtPRDs_out->begin();
389  last_mdtColl = m_mdtPRDs_out->end();
390  i_coll = 0 ;
391  for( ; mdtColl!=last_mdtColl ; ++mdtColl, ++i_coll ){
392  Identifier ID = (*mdtColl)->identify() ;
393  ATH_MSG_DEBUG( "MDT OUT Collection(" << std::setw(2) << i_coll << ") : " << ID );
394  }
395 
396  Muon::RpcPrepDataContainer::const_iterator rpcColl = m_rpcPRDs_in->begin();
397  Muon::RpcPrepDataContainer::const_iterator last_rpcColl = m_rpcPRDs_in->end();
398  i_coll = 0 ;
399  for( ; rpcColl!=last_rpcColl ; ++rpcColl, ++i_coll ){
400  Identifier ID = (*rpcColl)->identify() ;
401  ATH_MSG_DEBUG( "RPC IN Collection(" << std::setw(2) << i_coll << ") : " << ID );
402  }
403 
404  rpcColl = m_rpcPRDs_out->begin();
405  last_rpcColl = m_rpcPRDs_out->end();
406  i_coll = 0 ;
407  for( ; rpcColl!=last_rpcColl ; ++rpcColl, ++i_coll ){
408  Identifier ID = (*rpcColl)->identify() ;
409  ATH_MSG_DEBUG( "RPC OUT Collection(" << std::setw(2) << i_coll << ") : " << ID );
410  }
411 
412 
413  Muon::TgcPrepDataContainer::const_iterator tgcColl = m_tgcPRDs_in->begin();
414  Muon::TgcPrepDataContainer::const_iterator last_tgcColl = m_tgcPRDs_in->end();
415  i_coll = 0 ;
416  for( ; tgcColl!=last_tgcColl ; ++tgcColl, ++i_coll ){
417  Identifier ID = (*tgcColl)->identify() ;
418  ATH_MSG_DEBUG( "TGC IN Collection(" << std::setw(2) << i_coll << ") : " << ID );
419  }
420 
421  tgcColl = m_tgcPRDs_out->begin();
422  last_tgcColl = m_tgcPRDs_out->end();
423  i_coll = 0 ;
424  for( ; tgcColl!=last_tgcColl ; ++tgcColl, ++i_coll ){
425  Identifier ID = (*tgcColl)->identify() ;
426  ATH_MSG_DEBUG( "TGC OUT Collection(" << std::setw(2) << i_coll << ") : " << ID );
427  }
428 
429  Muon::CscStripPrepDataContainer::const_iterator cscColl = m_cscPRDs_in->begin();
430  Muon::CscStripPrepDataContainer::const_iterator last_cscColl = m_cscPRDs_in->end();
431  i_coll = 0 ;
432  for( ; cscColl!=last_cscColl ; ++cscColl, ++i_coll ){
433  Identifier ID = (*cscColl)->identify() ;
434  ATH_MSG_DEBUG( "CSC IN Collection(" << std::setw(2) << i_coll << ") : " << ID );
435  }
436 
437  cscColl = m_cscPRDs_out->begin();
438  last_cscColl = m_cscPRDs_out->end();
439  i_coll = 0 ;
440  for( ; cscColl!=last_cscColl ; ++cscColl, ++i_coll ){
441  Identifier ID = (*cscColl)->identify() ;
442  ATH_MSG_DEBUG( "CSC OUT Collection(" << std::setw(2) << i_coll << ") : " << ID );
443  }
444 
445  SG::ConstIterator<Muon::MdtPrepDataCollection> mdtCollection;
446  SG::ConstIterator<Muon::MdtPrepDataCollection> lastColl;
447  i_coll = 0;
448  if (evtStore()->retrieve(mdtCollection,lastColl) ==StatusCode::SUCCESS) {
449  for ( ; mdtCollection != lastColl ; ++mdtCollection ) {
450  ATH_MSG_DEBUG( "DIRECTLY FROM COLL (" <<std::setw(2) << i_coll << ") " << mdtCollection->identify() );
451  }
452  }
453 
454 }
455 
456 
457 
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
MuonPrdSelectorAlg::selectRPCs
StatusCode selectRPCs()
selects the hits from RPCcollections
Definition: MuonPrdSelectorAlg.cxx:216
MuonPrdSelectorAlg::MuonPrdSelectorAlg
MuonPrdSelectorAlg(const std::string &name, ISvcLocator *pSvcLocator)
Athena algorithm constructor.
Definition: MuonPrdSelectorAlg.cxx:10
xAOD::identify
const Identifier & identify(const UncalibratedMeasurement *meas)
Returns the associated identifier from the muon measurement.
Definition: MuonSpectrometer/MuonPhaseII/Event/xAOD/xAODMuonPrepData/Root/UtilFunctions.cxx:95
MuonPrdSelectorAlg::selectCSCs
StatusCode selectCSCs()
selects the hits from CSCcollections
Definition: MuonPrdSelectorAlg.cxx:325
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
MuonPrdSelectorAlg::print
void print()
method for DEBUG purposes: prints the content of input and output MuonPrepDataContainer
Definition: MuonPrdSelectorAlg.cxx:379
MuonPrdSelectorAlg::m_outputContainer_mdt
std::string m_outputContainer_mdt
Definition: MuonPrdSelectorAlg.h:64
MuonPrdSelectorAlg::execute
virtual StatusCode execute()
Retrieves and records containers, performs selection.
Definition: MuonPrdSelectorAlg.cxx:78
MuonPrdSelectorAlg::performSelection
StatusCode performSelection()
checks if each hit in each collection passes a set of cuts these hits are written to new collections
Definition: MuonPrdSelectorAlg.cxx:151
ID
std::vector< Identifier > ID
Definition: CalibHitIDCheck.h:24
IdentifiableContainerMT::addCollection
virtual StatusCode addCollection(const T *coll, IdentifierHash hashId) override final
insert collection into container with id hash if IDC should not take ownership of collection,...
Definition: IdentifiableContainerMT.h:298
Muon::CscStripPrepDataCollection
MuonPrepDataCollection< CscStripPrepData > CscStripPrepDataCollection
Definition: MuonPrepDataCollection.h:111
Muon::RpcPrepDataCollection
MuonPrepDataCollection< RpcPrepData > RpcPrepDataCollection
Definition: MuonPrepDataCollection.h:107
MuonPrdSelectorAlg::m_inputContainer_tgc
std::string m_inputContainer_tgc
Definition: MuonPrdSelectorAlg.h:61
Muon::MdtPrepDataCollection
MuonPrepDataCollection< MdtPrepData > MdtPrepDataCollection
Definition: MuonPrepDataCollection.h:106
Muon::MdtPrepDataContainer
MuonPrepDataContainerT< MdtPrepData > MdtPrepDataContainer
Definition: MuonPrepDataContainer.h:95
IdentifiableContainerMT::size
size_t size() const
Duplicate of fullSize for backwards compatability.
Definition: IdentifiableContainerMT.h:207
Muon::TgcPrepDataContainer
MuonPrepDataContainerT< TgcPrepData > TgcPrepDataContainer
Definition: MuonPrepDataContainer.h:97
MuonPrdSelectorAlg::retrieveContainers
StatusCode retrieveContainers()
retrieves input MuonPrepDataContainers from StoreGate
Definition: MuonPrdSelectorAlg.cxx:87
MuonPrdSelectorAlg::m_inputContainer_rpc
std::string m_inputContainer_rpc
Definition: MuonPrdSelectorAlg.h:60
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
Muon::CscStripPrepData
Class representing the raw data of one CSC strip (for clusters look at Muon::CscPrepData).
Definition: CscStripPrepData.h:40
MuonPrdSelectorAlg::m_outputContainer_csc
std::string m_outputContainer_csc
Definition: MuonPrdSelectorAlg.h:67
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
MuonPrdSelectorAlg::m_muonIdCutTool
ToolHandle< IMuonIdCutTool > m_muonIdCutTool
Definition: MuonPrdSelectorAlg.h:57
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
lumiFormat.i
int i
Definition: lumiFormat.py:85
MuonPrdSelectorAlg::m_inputContainer_mdt
std::string m_inputContainer_mdt
Definition: MuonPrdSelectorAlg.h:59
Muon::RpcPrepData
Class to represent RPC measurements.
Definition: RpcPrepData.h:35
MuonPrdSelectorAlg::m_cscPRDs_in
const Muon::CscStripPrepDataContainer * m_cscPRDs_in
Definition: MuonPrdSelectorAlg.h:72
MuonPrdSelectorAlg::m_mdtPRDs_in
const Muon::MdtPrepDataContainer * m_mdtPRDs_in
Definition: MuonPrdSelectorAlg.h:69
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
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
MuonPrdSelectorAlg::selectTGCs
StatusCode selectTGCs()
selects the hits from TGCcollections
Definition: MuonPrdSelectorAlg.cxx:271
MuonPrdSelectorAlg::m_outputContainer_rpc
std::string m_outputContainer_rpc
Definition: MuonPrdSelectorAlg.h:65
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
IdentifiableContainerMT::end
const_iterator end() const
return const_iterator for end of container
Definition: IdentifiableContainerMT.h:240
MuonPrdSelectorAlg::selectMDTs
StatusCode selectMDTs()
selects the hits from MDTcollections
Definition: MuonPrdSelectorAlg.cxx:161
MuonPrdSelectorAlg::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: MuonPrdSelectorAlg.h:55
MuonPrdSelectorAlg::initialize
virtual StatusCode initialize()
Algorithm initialization: retrieves StoreGate/DetectorStore/MuonIdHelpers/MuonPrepDataContainers.
Definition: MuonPrdSelectorAlg.cxx:30
IdentifiableContainerMT::const_iterator
Definition: IdentifiableContainerMT.h:80
IdentifiableContainerMT::begin
const_iterator begin() const
return const_iterator for first entry
Definition: IdentifiableContainerMT.h:234
Muon::CscStripPrepDataContainer
MuonPrepDataContainerT< CscStripPrepData > CscStripPrepDataContainer
Definition: MuonPrepDataContainer.h:99
Muon::MuonPrepDataCollection
Template to hold collections of MuonPrepRawData objects.
Definition: MuonPrepDataCollection.h:46
AthAlgorithm
Definition: AthAlgorithm.h:47
MuonPrdSelectorAlg::m_rpcPRDs_in
const Muon::RpcPrepDataContainer * m_rpcPRDs_in
Definition: MuonPrdSelectorAlg.h:70
MuonPrdSelectorAlg::m_mdtPRDs_out
Muon::MdtPrepDataContainer * m_mdtPRDs_out
Definition: MuonPrdSelectorAlg.h:74
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
MuonPrdSelectorAlg::m_cscPRDs_out
Muon::CscStripPrepDataContainer * m_cscPRDs_out
Definition: MuonPrdSelectorAlg.h:77
Muon::MdtPrepData
Class to represent measurements from the Monitored Drift Tubes.
Definition: MdtPrepData.h:33
MuonPrdSelectorAlg::m_tgcPRDs_out
Muon::TgcPrepDataContainer * m_tgcPRDs_out
Definition: MuonPrdSelectorAlg.h:76
Muon::RpcPrepDataContainer
MuonPrepDataContainerT< RpcPrepData > RpcPrepDataContainer
Definition: MuonPrepDataContainer.h:96
MuonPrdSelectorAlg::m_rpcPRDs_out
Muon::RpcPrepDataContainer * m_rpcPRDs_out
Definition: MuonPrdSelectorAlg.h:75
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
Muon::TgcPrepData
Class to represent TGC measurements.
Definition: TgcPrepData.h:32
MuonPrdSelectorAlg::m_outputContainer_tgc
std::string m_outputContainer_tgc
Definition: MuonPrdSelectorAlg.h:66
MuonPrdSelectorAlg::recordContainers
StatusCode recordContainers()
records output MuonPrepDataContainers to StoreGate
Definition: MuonPrdSelectorAlg.cxx:136
Muon::TgcPrepDataCollection
MuonPrepDataCollection< TgcPrepData > TgcPrepDataCollection
Definition: MuonPrepDataCollection.h:108
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
MuonPrdSelectorAlg.h
SG::ConstIterator
Definition: SGIterator.h:164
MuonPrdSelectorAlg::m_inputContainer_csc
std::string m_inputContainer_csc
Definition: MuonPrdSelectorAlg.h:62
IdentifiableContainerMT::cleanup
virtual void cleanup() override final
reset m_hashids and call IdentifiableCache's cleanup
Definition: IdentifiableContainerMT.h:310
MuonPrdSelectorAlg::m_tgcPRDs_in
const Muon::TgcPrepDataContainer * m_tgcPRDs_in
Definition: MuonPrdSelectorAlg.h:71
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Mon Nov 3 2025 21:15:29 for ATLAS Offline Software by   doxygen 1.8.18