ATLAS Offline Software
RpcClusterBuilderPRD.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 
6 /*
7  August 2003. Andrea Di Simone.
8  Based on CscClusterBuilder by Ketevi A. Assamagan
9 */
10 
11 #include "MuonReadoutGeometry/RpcReadoutElement.h"
12 #include "MuonIdHelpers/RpcIdHelper.h"
13 
14 #include "RpcClusterBuilderPRD.h"
15 
16 #include <cmath>
17 #include <cassert>
18 #include <fstream>
19 #include <strstream>
20 
21 //#include "TrkEventPrimitives/ErrorMatrix.h"
22 //#include "TrkEventPrimitives/CovarianceMatrix.h"
23 
26 
27 RpcClusterBuilderPRD::RpcClusterBuilderPRD(const std::string& name, ISvcLocator* pSvcLocator) :
28  AthAlgorithm(name, pSvcLocator), m_temp_coll(nullptr), m_rpcClusterContainer(nullptr)
29 {
30 
31  // Declare the properties
32  declareProperty("ClusterTimeSpread", m_timeSpread = 15.);
33 }
34 
35 
36 StatusCode RpcClusterBuilderPRD::initialize(){
37 
38  ATH_CHECK(m_DetectorManagerKey.initialize());
39 
40  ATH_CHECK(m_idHelperSvc.retrieve());
41 
42  ATH_CHECK(m_colKeyIn.initialize());
43  ATH_CHECK(m_colKey.initialize());
44 
45  // Create an empty cluster container
46  // m_rpcClusterContainer = new Muon::RpcPrepDataContainer(m_idHelperSvc->rpcIdHelper().module_hash_max());
47  // m_rpcClusterContainer->addRef();
48 
49  return StatusCode::SUCCESS;
50 
51 }
52 
53 StatusCode RpcClusterBuilderPRD::execute() {
54 
55  SG::WriteHandle<Muon::RpcPrepDataContainer> clusterContainer(m_colKey);
56  ATH_CHECK(clusterContainer.record(std::make_unique<Muon::RpcPrepDataContainer>(m_idHelperSvc->rpcIdHelper().module_hash_max())));
57  m_rpcClusterContainer = clusterContainer.ptr();
58 
59  // m_rpcClusterContainer->cleanup();
60 
61  StatusCode sc=fill_rpcClusterContainer();
62 
63  if(sc.isFailure()) ATH_MSG_WARNING("couldn't build clusters for this event");
64 
65  // try to retrieve the collection just created and print it out
66  // if (!sc.isFailure())
67  // sc = retrieve_rpcClusterContainer();
68 
69  return sc;
70 
71 }
72 
73 StatusCode RpcClusterBuilderPRD::finalize() {
74 
75  //delete m_digit_position;
76 
77  return StatusCode::SUCCESS;
78 
79 }
80 
81 StatusCode RpcClusterBuilderPRD::fill_rpcClusterContainer() {
82 
83  SG::ReadCondHandle<MuonGM::MuonDetectorManager> DetectorManagerHandle{m_DetectorManagerKey};
84  const MuonGM::MuonDetectorManager* MuonDetMgr = DetectorManagerHandle.cptr();
85  if(MuonDetMgr==nullptr){
86  ATH_MSG_ERROR("Null pointer to the read MuonDetectorManager conditions object");
87  return StatusCode::FAILURE;
88  }
89 
90  SG::ReadHandle<Muon::RpcPrepDataContainer> container(m_colKeyIn);
91  if (!container.isValid()) {
92  ATH_MSG_WARNING(" Cannot retrieve RPC Digit Container with key " << m_colKeyIn );
93  return StatusCode::SUCCESS;
94  }
95 
96  Muon::RpcPrepDataContainer::const_iterator rpcCollection=container->begin();
97  Muon::RpcPrepDataContainer::const_iterator lastCollection=container->end();
98 
99  // sc = evtStore()->retrieve(rpcCollection, lastCollection);
100  // if (sc.isFailure()) {
101  // ATH_MSG_ERROR(" Cannot retrieve RPC Digit collections ");
102  // return StatusCode::SUCCESS;
103  // }
104 
105  // const MuonDetElemHash& hashF = container->hashFunc();
106  // int n = hashF.max();
107 
108  for ( ; rpcCollection!=lastCollection; ++rpcCollection ){
109 
110  const Muon::RpcPrepDataCollection * theCollection= *rpcCollection;
111 
112  if(!theCollection->empty()){
113 
114 
115  // create temp collection for clusters
116  Identifier elementId = m_idHelperSvc->rpcIdHelper().elementID(theCollection->identify());
117  IdContext rpcContext = m_idHelperSvc->rpcIdHelper().module_context();
118  IdentifierHash rpcHashId;
119 
120  if (m_idHelperSvc->rpcIdHelper().get_hash(elementId, rpcHashId, &rpcContext)) {
121  ATH_MSG_ERROR("Unable to get RPC hash id from CSC PreDataCollection collection id"
122  << "context begin_index = " << rpcContext.begin_index()
123  << " context end_index = " << rpcContext.end_index()
124  << " the identifier is ");
125  elementId.show();
126  }
127 
128  m_temp_coll = new Muon::RpcPrepDataCollection(rpcHashId);
129  m_temp_coll->setIdentifier(elementId);
130  m_coll_vect.push_back(m_temp_coll);
131 
132  // build the patterns
133 
134  if(buildPatterns(theCollection)) buildClusters(elementId, MuonDetMgr);
135 
136  }
137  //clear map at each collection
138  m_digits.clear();
139  }
140 
141  //before returning, store collections into container:
142 
143  for(unsigned int k=0;k<m_coll_vect.size();k++){
144 
145  StatusCode sc = m_rpcClusterContainer->addCollection(m_coll_vect[k], m_coll_vect[k]->identifyHash());
146  if (sc.isFailure())
147  ATH_MSG_ERROR("Couldn't record RpcPrepDataCollection with key=" << m_colKey
148  << " in StoreGate!");
149 
150  }
151 
152 // for(;coll_begin!=coll_end;++coll_begin){
153 
154 // sc = m_rpcClusterContainer->addCollection(*coll_begin, (*coll_begin)->identifyHash());
155 // if (sc.isFailure())
156 // ATH_MSG_ERROR("Couldn't record RpcPrepDataCollection with key=" << m_colKey
157 // << " in StoreGate!");
158 
159 // }
160 
161  m_coll_vect.clear();
162 
163  return StatusCode::SUCCESS;
164 }
165 
166 int RpcClusterBuilderPRD::buildPatterns(const Muon::RpcPrepDataCollection* rpcCollection) {
167 
168  // here we loop over the digits in the collection and fill the patterns
169 
170  //const Muon::RpcPrepDataCollection rpcCollection = *iter;
171 
172  std::vector<Muon::RpcPrepData*> theDigits= rpcCollection->stdcont();
173 
174  Identifier eleId=rpcCollection->identify();
175 
176  // loop over digits in collection
177 
178  for(unsigned int j=0;j< theDigits.size();j++){
179 
180  Muon::RpcPrepData* rpcDigit = theDigits[j];
181 
182  if(!(rpcDigit->triggerInfo())){ // remove trigger patterns. temporary
183 
184  Identifier id=rpcDigit->identify();
185  int nstrip=m_idHelperSvc->rpcIdHelper().strip(id);
186  int doubletZ=m_idHelperSvc->rpcIdHelper().doubletZ(id);
187  int doubletPhi=m_idHelperSvc->rpcIdHelper().doubletPhi(id);
188  int gasGap=m_idHelperSvc->rpcIdHelper().gasGap(id);
189  int measPhi=m_idHelperSvc->rpcIdHelper().measuresPhi(id);
190 
191  // use Id of first strip to identify a panel.
192 
193  Identifier panelId=m_idHelperSvc->rpcIdHelper().channelID(eleId,doubletZ,doubletPhi,gasGap,measPhi,1);
194 
195  if(m_digits.find(panelId)==m_digits.end()){ // first hit on this panel
196 
197  pattern newPatt;
198  newPatt[nstrip]=rpcDigit;
199  m_digits[panelId]=newPatt;
200 
201  } else { // use existing pattern
202 
203  if(m_digits[panelId].find(nstrip)==m_digits[panelId].end()){ // no hits on this strip before
204 
205  m_digits[panelId][nstrip]=rpcDigit;
206 
207  } else if(m_digits[panelId][nstrip]->time()> rpcDigit->time()){
208 
209  m_digits[panelId][nstrip]=rpcDigit; // if more than one digit, keep only the one with lowest time
210 
211  }
212 
213 
214  }
215  }
216  }
217 
218  return m_digits.size();
219 
220 }
221 
222 void RpcClusterBuilderPRD::buildClusters(Identifier elementId, const MuonGM::MuonDetectorManager* MuonDetMgr) {
223 
224  // loop over existing patterns
225 
226  std::map<Identifier, pattern >::iterator patt_it=m_digits.begin();
227 
228  for(;patt_it!=m_digits.end();++patt_it){
229 
230  Identifier panelId=(*patt_it).first; // this is the panel id
231 
232  int measphi=m_idHelperSvc->rpcIdHelper().measuresPhi(panelId);
233 
234  //int clusteropen=0;
235 
236  std::map<int, Muon::RpcPrepData*, std::less<int> >::iterator dig_it=m_digits[panelId].begin();
237 
238  std::vector<Identifier> theIDs;
239  std::vector<int> theAmbFlags;
240  int lastStrip=-999;
241  float lastTime=-999;
242  float mintime=0;
243  Amg::Vector3D localPosition(0,0,0);
244  Amg::Vector3D globalPosition(0,0,0);
245  unsigned int count=0;
246  // std::vector<Trk::PrepRawData*> digitsInCluster;
247 
248  // get the ID from the first digit in collection
249 
250  for(;dig_it!=m_digits[panelId].end();++dig_it){ // loop over patterns
251 
252  const MuonGM::RpcReadoutElement* descriptor=MuonDetMgr->getRpcReadoutElement((*dig_it).second->identify());
253 
254  if(lastStrip==-999){ // first hit of a cluster..
255 
256  //std::cout<<" opening a cluster at strip "<< (*dig_it).first<<std::endl;
257  //clusteropen=1;
258  lastStrip=(*dig_it).first;
259  theIDs.push_back((*dig_it).second->identify());
260  theAmbFlags.push_back((*dig_it).second->ambiguityFlag());
261  // digitsInCluster.push_back((*dig_it).second);
262  globalPosition+=descriptor->stripPos((*dig_it).second->identify());
263  localPosition+=descriptor->localStripPos((*dig_it).second->identify());
264  mintime=(*dig_it).second->time();
265  lastTime=(*dig_it).second->time();
266 
267  } else if(abs(lastStrip-(*dig_it).first)==1 &&
268  abs(lastTime-(*dig_it).second->time())<m_timeSpread){ // still on the same cluster, with acceptable time spread
269 
270  //std::cout<<" adding to a cluster the strip "<< (*dig_it).first<<std::endl;
271  lastStrip=(*dig_it).first;
272  theIDs.push_back((*dig_it).second->identify());
273  theAmbFlags.push_back((*dig_it).second->ambiguityFlag());
274  // digitsInCluster.push_back((*dig_it).second);
275  globalPosition+=descriptor->stripPos((*dig_it).second->identify());
276  localPosition+=descriptor->localStripPos((*dig_it).second->identify());
277  if(mintime>(*dig_it).second->time()) mintime=(*dig_it).second->time(); //keep the lowest time in the cluster
278  lastTime=(*dig_it).second->time();
279 
280  } else { // close the cluster
281  //std::cout<<" closing the cluster "<<std::endl;
282 
283  // determine ambiguity flag:
284  // if one of the strips has abiguity=1, then all the cluster inherits it
285  // otherwise we assign to the cluster the max of the abiguities of the strips
286 
287  int clusAmbFlag=-1;
288  bool hasGoldenStrip=false;
289 
290  // std::cout<<"deciding amb flag"<<std::endl;
291  for(unsigned int k=0;k<theAmbFlags.size();++k){
292  clusAmbFlag=std::max(clusAmbFlag,theAmbFlags[k]);
293  // std::cout<<theAmbFlags[k]<< " "<<clusAmbFlag<<std::endl;
294  if(theAmbFlags[k]==1) hasGoldenStrip=true;
295  }
296  if(hasGoldenStrip) clusAmbFlag=1;
297 
298  // std::cout<<"decision is "<<clusAmbFlag<<std::endl;
299 
300  localPosition=localPosition*(1/(float)theIDs.size());
301  globalPosition=globalPosition*(1/(float)theIDs.size());
302  float width=descriptor->StripWidth(measphi);
303  AmgSymMatrix(1) mat ;
304  mat(0,0) = 1.;
305  double err = theIDs.size()*width/sqrt((double)12);
306  mat *= err*err;
307  auto errClusterPos = Amg::MatrixX(mat);
308 
309  IdContext rpcContext = m_idHelperSvc->rpcIdHelper().module_context();
310  IdentifierHash rpcHashId;
311  m_idHelperSvc->rpcIdHelper().get_hash(elementId, rpcHashId, &rpcContext);
312 
313  Amg::Vector2D pointLocPos ;
314  descriptor->surface(panelId).globalToLocal(globalPosition,globalPosition,pointLocPos);
315  Muon::RpcPrepData* newCluster = new Muon::RpcPrepData(theIDs[0],
316  rpcHashId,
317  pointLocPos,
318  theIDs,
319  // DV,
320  errClusterPos,
321  //width,
322  // new Trk::GlobalPosition(globalPosition),
323  descriptor,
324  mintime,
325  false,
326  clusAmbFlag);
327  push_back(newCluster);
328 
329  // clear all the numbers and restart a new cluster
330 
331  lastStrip=(*dig_it).first;
332  theIDs.clear();
333  theAmbFlags.clear();
334  //digitsInCluster.clear();
335  theIDs.push_back((*dig_it).second->identify());
336  theAmbFlags.push_back((*dig_it).second->ambiguityFlag());
337  //std::cout<<" opening2 a cluster at strip "<< (*dig_it).first<<std::endl;
338  // digitsInCluster.push_back((*dig_it).second);
339  globalPosition=descriptor->stripPos((*dig_it).second->identify());
340  localPosition=descriptor->localStripPos((*dig_it).second->identify());
341  mintime=(*dig_it).second->time();
342  lastTime=(*dig_it).second->time();
343 
344  }
345 
346 
347  // if we are at the end, close the custer anyway and fill it with what we have found
348 
349  if(count==m_digits[panelId].size()-1&&!theIDs.empty()){
350 
351 
352 
353  // determine ambiguity flag:
354  // if one of the strips has abiguity=1, then all the cluster inherits it
355  // otherwise we assign to the cluster the max of the abiguities of the strips
356 
357  int clusAmbFlag=-1;
358  bool hasGoldenStrip=false;
359 
360  // std::cout<<"deciding amb flag"<<std::endl;
361  for(unsigned int k=0;k<theAmbFlags.size();++k){
362  clusAmbFlag=std::max(clusAmbFlag,theAmbFlags[k]);
363  // std::cout<<theAmbFlags[k]<< " "<<clusAmbFlag<<std::endl;
364  if(theAmbFlags[k]==1) hasGoldenStrip=true;
365  }
366  if(hasGoldenStrip) clusAmbFlag=1;
367 
368  // std::cout<<"decision is "<<clusAmbFlag<<std::endl;
369 
370  IdContext rpcContext = m_idHelperSvc->rpcIdHelper().module_context();
371  IdentifierHash rpcHashId;
372  m_idHelperSvc->rpcIdHelper().get_hash(elementId, rpcHashId, &rpcContext);
373 
374  //std::cout<<" closing2 the cluster "<<std::endl;
375  localPosition=localPosition*(1/(float)theIDs.size());
376  globalPosition=globalPosition*(1/(float)theIDs.size());
377  double width=descriptor->StripWidth(measphi);
378  AmgSymMatrix(1) mat;
379  mat(0,0) = 1.;
380  double err = theIDs.size()*width/sqrt((double)12);
381  mat *= err*err;
382  auto errClusterPos = Amg::MatrixX(mat);
383 
384  Amg::Vector2D pointLocPos ;
385  descriptor->surface(panelId).globalToLocal(globalPosition,globalPosition,pointLocPos);
386  Muon::RpcPrepData* newCluster = new Muon::RpcPrepData(theIDs[0],
387  rpcHashId,
388  pointLocPos,
389  theIDs,
390  // DV,
391  errClusterPos,
392  // width,
393  // new Trk::GlobalPosition(globalPosition),
394  descriptor,
395  mintime,
396  false,
397  clusAmbFlag);
398  push_back(newCluster);
399 
400  }
401 
402 
403  count++;
404 
405  }
406  // outfile.close();
407 
408  }
409 
410 }
411 
412 void RpcClusterBuilderPRD::push_back(Muon::RpcPrepData *& newCluster){
413 
414  // StatusCode status = StatusCode::SUCCESS;
415 
416  m_temp_coll->push_back(newCluster);
417 
418 
419  // Identifier elementId = m_idHelperSvc->rpcIdHelper().elementID(newCluster->identify());
420  // IdContext rpcContext = m_idHelperSvc->rpcIdHelper().module_context();
421  // Muon::RpcPrepDataContainer::KEY key = m_rpcClusterContainer->key(elementId);
422 
423 // if (!evtStore()->contains<Muon::RpcPrepDataCollection>(key)) {
424 // IdentifierHash rpcHashId;
425 // if (m_idHelperSvc->rpcIdHelper().get_hash(elementId, rpcHashId, &rpcContext)) {
426 // ATH_MSG_ERROR("Unable to get RPC hash id from RPC PreDataCollection collection id"
427 // << "context begin_index = " << rpcContext.begin_index()
428 // << " context end_index = " << rpcContext.end_index()
429 // << " the identifier is ");
430 // elementId.show();
431 // }
432 // Muon::RpcPrepDataCollection * newCollection = new Muon::RpcPrepDataCollection(rpcHashId);
433 // newCollection->setIdentifier(elementId);
434 // newCollection->push_back(newCluster);
435 // status = m_rpcClusterContainer->addCollection(newCollection, newCollection->identify());
436 // if (status.isFailure())
437 // ATH_MSG_ERROR("Couldn't record RpcPrepdataCollection with key=" << key
438 // << " in StoreGate!");
439 // } else {
440 // Muon::RpcPrepDataCollection * oldCollection;
441 // status = evtStore()->retrieve(oldCollection, key);
442 // if (status.isFailure())
443 // ATH_MSG_ERROR("Couldn't retrieve RpcDigitCollection with key="
444 // << key << " from StoreGate!");
445 // oldCollection->push_back(newCluster);
446 // }
447 }
448 
449 // StatusCode RpcClusterBuilderPRD::retrieve_rpcClusterContainer() const {
450 
451 // typedef Muon::RpcPrepDataCollection::const_iterator cluster_iterator;
452 
453 // const Muon::RpcPrepDataContainer* PRDcontainer;
454 // ATH_CHECK( evtStore()->retrieve(PRDcontainer,m_colKey) );
455 
456 // for (Muon::RpcPrepDataContainer::const_iterator container_iterator=PRDcontainer->begin();
457 // container_iterator != PRDcontainer->end();
458 // ++container_iterator) {
459 
460 // const Muon::RpcPrepDataCollection* collection = *container_iterator;
461 // ATH_MSG_INFO("Size of the collection is " << collection->size() );
462 // if (collection->size() > 0) {
463 // ATH_MSG_INFO("**************************************************************");
464 // cluster_iterator beginCluster = collection->begin();
465 // cluster_iterator endCluster = collection->end();
466 // for ( ; beginCluster!=endCluster; ++beginCluster) {
467 // const Muon::RpcPrepData* cluster = *beginCluster;
468 // Amg::Vector3D position = cluster->globalPosition();
469 // ATH_MSG_INFO("RPC Cluster ID, Position (mm), size = "
470 // << m_idHelperSvc->rpcIdHelper().show_to_string(cluster->identify()) << " ["
471 // << std::setiosflags(std::ios::fixed) << std::setprecision(3) << std::setw(12) << position.x()
472 // << std::setiosflags(std::ios::fixed) << std::setprecision(3) << std::setw(12) << position.y()
473 // << std::setiosflags(std::ios::fixed) << std::setprecision(3) << std::setw(12) << position.z()
474 // // << std::setiosflags(std::ios::fixed) << std::setprecision(3) << std::setw(12) << cluster->width()
475 // << std::setiosflags(std::ios::fixed) << std::setprecision(3) << std::setw(12) << cluster->rdoList().size()
476 // << " ]");
477 // }
478 // ATH_MSG_INFO("Number of Clusters in the collection is " << collection->size() );
479 // ATH_MSG_INFO("**************************************************************");
480 // }
481 // }
482 
483 // return StatusCode::SUCCESS;
484 // }
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
MuonGM::MuonDetectorManager::getRpcReadoutElement
const RpcReadoutElement * getRpcReadoutElement(const Identifier &id) const
access via extended identifier (requires unpacking)
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonDetectorManager.cxx:168
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:213
dumpTgcDigiDeadChambers.gasGap
list gasGap
Definition: dumpTgcDigiDeadChambers.py:33
Amg::MatrixX
Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > MatrixX
Dynamic Matrix - dynamic allocation.
Definition: EventPrimitives.h:29
RpcClusterBuilderPRD::m_DetectorManagerKey
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > m_DetectorManagerKey
Definition: RpcClusterBuilderPRD.h:60
max
#define max(a, b)
Definition: cfImp.cxx:41
RpcClusterBuilderPRD::finalize
StatusCode finalize()
Definition: RpcClusterBuilderPRD.cxx:73
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
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:300
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition: GeoPrimitives.h:48
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
Muon::RpcPrepDataCollection
MuonPrepDataCollection< RpcPrepData > RpcPrepDataCollection
Definition: MuonPrepDataCollection.h:107
RpcClusterBuilderPRD::RpcClusterBuilderPRD
RpcClusterBuilderPRD(const std::string &name, ISvcLocator *pSvcLocator)
Definition: RpcClusterBuilderPRD.cxx:27
mat
GeoMaterial * mat
Definition: LArDetectorConstructionTBEC.cxx:53
MuonGM::RpcReadoutElement
An RpcReadoutElement corresponds to a single RPC module; therefore typicaly a barrel muon station con...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/RpcReadoutElement.h:54
IdContext::end_index
size_type end_index(void) const
Definition: IdContext.h:106
Muon::MuonPrepDataCollection::setIdentifier
virtual void setIdentifier(Identifier id)
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
AmgSymMatrix
#define AmgSymMatrix(dim)
Definition: EventPrimitives.h:52
RpcClusterBuilderPRD::pattern
std::map< int, Muon::RpcPrepData * > pattern
Definition: RpcClusterBuilderPRD.h:51
XMLtoHeader.count
count
Definition: XMLtoHeader.py:85
RpcIdHelper.h
SCT_CalibAlgs::lastStrip
@ lastStrip
Definition: SCT_CalibNumbers.h:10
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
Muon::RpcPrepData::time
float time() const
Returns the time.
Definition: RpcPrepData.h:197
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
RpcClusterBuilderPRD::initialize
StatusCode initialize()
Definition: RpcClusterBuilderPRD.cxx:36
RpcClusterBuilderPRD.h
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
dqt_zlumi_pandas.err
err
Definition: dqt_zlumi_pandas.py:193
Muon::RpcPrepData
Class to represent RPC measurements.
Definition: RpcPrepData.h:35
RpcClusterBuilderPRD::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: RpcClusterBuilderPRD.h:64
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
SG::WriteHandle::ptr
pointer_type ptr()
Dereference the pointer.
Muon::MuonPrepDataCollection::identify
virtual Identifier identify() const override final
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:242
IdentifiableContainerMT::const_iterator
Definition: IdentifiableContainerMT.h:82
IdentifiableContainerMT::begin
const_iterator begin() const
return const_iterator for first entry
Definition: IdentifiableContainerMT.h:236
RpcClusterBuilderPRD::m_colKey
SG::WriteHandleKey< Muon::RpcPrepDataContainer > m_colKey
Definition: RpcClusterBuilderPRD.h:66
Muon::MuonPrepDataCollection
Template to hold collections of MuonPrepRawData objects.
Definition: MuonPrepDataCollection.h:46
Muon::RpcPrepData::triggerInfo
int triggerInfo() const
Returns the trigger coincidence - usually false, unless ijk>5 or highpt&&ijk==0.
Definition: RpcPrepData.h:207
Identifier::show
void show() const
Print out in hex form.
Definition: Identifier.cxx:36
AthAlgorithm
Definition: AthAlgorithm.h:47
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
RpcClusterBuilderPRD::m_colKeyIn
SG::ReadHandleKey< Muon::RpcPrepDataContainer > m_colKeyIn
Definition: RpcClusterBuilderPRD.h:65
RpcClusterBuilderPRD::buildClusters
void buildClusters(Identifier elementId, const MuonGM::MuonDetectorManager *MuonDetMgr)
Definition: RpcClusterBuilderPRD.cxx:222
RpcClusterBuilderPRD::m_coll_vect
std::vector< Muon::RpcPrepDataCollection * > m_coll_vect
Definition: RpcClusterBuilderPRD.h:48
MuonGM::RpcReadoutElement::localStripPos
Amg::Vector3D localStripPos(int doubletPhi, int gasGap, bool measphi, int strip) const
Returns the local strip position in the AMDB frame.
Definition: MuonDetDescr/MuonReadoutGeometry/src/RpcReadoutElement.cxx:117
Trk::PrepRawData::identify
Identifier identify() const
return the identifier
IdContext::begin_index
size_type begin_index(void) const
Definition: IdContext.h:100
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
MuonGM::RpcReadoutElement::stripPos
Amg::Vector3D stripPos(const Identifier &id) const
Definition: MuonDetDescr/MuonReadoutGeometry/src/RpcReadoutElement.cxx:177
RpcClusterBuilderPRD::buildPatterns
int buildPatterns(const Muon::RpcPrepDataCollection *rpcCollection)
Definition: RpcClusterBuilderPRD.cxx:166
RpcClusterBuilderPRD::m_temp_coll
Muon::RpcPrepDataCollection * m_temp_coll
Definition: RpcClusterBuilderPRD.h:49
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
RpcClusterBuilderPRD::fill_rpcClusterContainer
StatusCode fill_rpcClusterContainer()
Definition: RpcClusterBuilderPRD.cxx:81
RpcClusterBuilderPRD::m_rpcClusterContainer
Muon::RpcPrepDataContainer * m_rpcClusterContainer
Definition: RpcClusterBuilderPRD.h:58
DataVector::stdcont
const PtrVector & stdcont() const
Return the underlying std::vector of the container.
MuonGM::RpcReadoutElement::StripWidth
double StripWidth(bool measphi) const
returns the strip width for the phi or eta plane
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:76
SG::WriteHandle::record
StatusCode record(std::unique_ptr< T > data)
Record a const object to the store.
Base_Fragment.width
width
Definition: Sherpa_i/share/common/Base_Fragment.py:59
CaloSwCorrections.time
def time(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:242
MuonGM::MuonDetectorManager
The MuonDetectorManager stores the transient representation of the Muon Spectrometer geometry and pro...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonDetectorManager.h:49
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
RpcClusterBuilderPRD::push_back
void push_back(Muon::RpcPrepData *&newCluster)
Definition: RpcClusterBuilderPRD.cxx:412
RpcClusterBuilderPRD::execute
StatusCode execute()
Definition: RpcClusterBuilderPRD.cxx:53
createCablingJSON.doubletPhi
int doubletPhi
Definition: createCablingJSON.py:11
RpcClusterBuilderPRD::m_timeSpread
float m_timeSpread
Definition: RpcClusterBuilderPRD.h:54
IdentifierHash
Definition: IdentifierHash.h:38
IdContext
class IdContext
Definition: IdContext.h:34
readCCLHist.float
float
Definition: readCCLHist.py:83
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
fitman.k
k
Definition: fitman.py:528
RpcClusterBuilderPRD::m_digits
std::map< Identifier, pattern > m_digits
Definition: RpcClusterBuilderPRD.h:52
RpcReadoutElement.h
Generated on Thu Jul 4 2024 21:25:45 for ATLAS Offline Software by   doxygen 1.8.18