ATLAS Offline Software
TRT_DetElementsRoadMaker_xk.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 */
4 
6 // Implementation file for class InDet::TRT_DetElementsRoadMaker_xk
8 // (c) ATLAS Detector software
11 // Version 1.0 21/04/2004 I.Gavrilenko
13 
14 #include <iostream>
15 #include <iomanip>
16 
17 #include <utility>
18 
19 #include "GeoModelInterfaces/IGeoModelTool.h"
20 
21 #include "TRT_ReadoutGeometry/TRT_BarrelElement.h"
22 #include "TRT_ReadoutGeometry/TRT_EndcapElement.h"
23 #include "TRT_ReadoutGeometry/TRT_Numerology.h"
24 
25 #include "TrkExInterfaces/IPropagator.h"
26 #include "TrkSurfaces/TrapezoidBounds.h"
27 #include "TrkSurfaces/RectangleBounds.h"
28 #include "TrkSurfaces/DiscBounds.h"
29 #include "TrkSurfaces/PlaneSurface.h"
30 
31 #include "TRT_DetElementsRoadUtils_xk.h"
32 
33 #include "TRT_DetElementsRoadTool_xk/TRT_DetElementsRoadMaker_xk.h"
34 #include "TRT_DetElementsRoadTool_xk/TRT_DetElementsComparison.h"
35 #include <cmath>
36 
37 
39 // Constructor
41 
42 InDet::TRT_DetElementsRoadMaker_xk::TRT_DetElementsRoadMaker_xk
43 (const std::string& t,const std::string& n,const IInterface* p)
44  : AthAlgTool(t,n,p) ,
45  m_proptool ("Trk::RungeKuttaPropagator/InDetPropagator" ),
46  m_width (10.),
47  m_step (20.),
48  m_fieldmode ("MapSolenoid")
49 {
50  declareInterface<ITRT_DetElementsRoadMaker>(this);
51  declareProperty("RoadWidth" ,m_width );
52  declareProperty("MaxStep" ,m_step );
53  declareProperty("PropagatorTool" ,m_proptool );
54  declareProperty("MagneticFieldMode" ,m_fieldmode );
55 }
56 
58 // Destructor
60 
61 InDet::TRT_DetElementsRoadMaker_xk::~TRT_DetElementsRoadMaker_xk()
62 = default;
63 
65 // Initialisation
67 
68 StatusCode InDet::TRT_DetElementsRoadMaker_xk::initialize()
69 {
70  StatusCode sc = AlgTool::initialize();
71  if(m_fieldmode == "NoField") m_fieldModeEnum = Trk::NoField;
72  else if(m_fieldmode == "MapSolenoid") m_fieldModeEnum = Trk::FastField;
73  else m_fieldModeEnum = Trk::FullField;
74  // Get propagator tool
75  ATH_CHECK (m_proptool.retrieve());
76  ATH_MSG_DEBUG("Retrieved tool " << m_proptool);
77  ATH_CHECK(m_roadDataKey.initialize());
78  ATH_CHECK( m_fieldCacheCondObjInputKey.initialize() );
79 
80  return sc;
81 }
82 
84 // Finalize
86 
87 StatusCode InDet::TRT_DetElementsRoadMaker_xk::finalize()
88 {
89  StatusCode sc = AlgTool::finalize(); return sc;
90 }
91 
93 // Dumps relevant information into the MsgStream
95 
96 MsgStream& InDet::TRT_DetElementsRoadMaker_xk::dump( MsgStream& out ) const
97 {
98  return dumpConditions(out);
99 }
100 
102 // Dumps conditions information into the MsgStream
104 
105 MsgStream& InDet::TRT_DetElementsRoadMaker_xk::dumpConditions( MsgStream& out ) const
106 {
107  int n = 62-m_proptool.type().size();
108  std::string s1; for(int i=0; i<n; ++i) s1.append(" "); s1.append("|");
109 
110  std::string fieldmode[9] ={"NoField" ,"ConstantField","SolenoidalField",
111  "ToroidalField" ,"Grid3DField" ,"RealisticField" ,
112  "UndefinedField","AthenaField" , "?????" };
113 
114  Trk::MagneticFieldMode fieldModeEnum(m_fieldModeEnum);
115  SG::ReadCondHandle<AtlasFieldCacheCondObj> fieldHandle(m_fieldCacheCondObjInputKey);
116  const AtlasFieldCacheCondObj* fieldCondObj{*fieldHandle};
117  if (fieldCondObj) {
118  MagField::AtlasFieldCache fieldCache;
119  fieldCondObj->getInitializedCache (fieldCache);
120  if(!fieldCache.solenoidOn()) fieldModeEnum = Trk::NoField;
121  }
122  Trk::MagneticFieldProperties fieldprop(fieldModeEnum);
123  int mode = fieldprop.magneticFieldMode();
124  if(mode<0 || mode>8 ) mode = 8;
125 
126  n = 62-fieldmode[mode].size();
127  std::string s3; for(int i=0; i<n; ++i) s3.append(" "); s3.append("|");
128 
129  const TRT_DetElementsLayerVectors_xk &layer = *getLayers();
130 
131  int maps = 0;
132  if(!layer[0].empty()) ++maps;
133  if(!layer[1].empty()) ++maps;
134  if(!layer[2].empty()) ++maps;
135 
136  out<<"|----------------------------------------------------------------------"
137  <<"-------------------|"
138  <<std::endl;
139  out<<"| Tool for propagation | "<<m_proptool.type()<<s1<<std::endl;
140  out<<"| Magnetic field mode | "<<fieldmode[mode]<<s3<<std::endl;
141  out<<"| Width of the road (mm) | "
142  <<std::setw(12)<<std::setprecision(5)<<m_width
143  <<" |"<<std::endl;
144  out<<"|----------------------------------------------------------------------"
145  <<"-------------------|"
146  <<std::endl;
147 
148  if(!maps || !msgLvl(MSG::VERBOSE)) return out;
149 
150  if(!layer[1].empty()) {
151  int nl = layer[1].size();
152  int nc = 0;
153  for(const auto & i : layer[1]) nc+=i.nElements();
154  out<<"|----------------------------------------------------------------|"
155  <<std::endl;
156  out<<"| Barrel map containt "
157  <<std::setw(4)<<nl<<" layers and "
158  <<std::setw(6)<<nc<<" elements |"
159  <<std::endl;
160  out<<"|------|-----------|------------|------------|------------|------|"
161  <<std::endl;
162  out<<"| n | R | Z min | Z max | max dF | nEl |"
163  <<std::endl;
164  out<<"|------|-----------|------------|------------|------------|------|"
165  <<std::endl;
166  for(unsigned int i=0; i!=layer[1].size(); ++i) {
167  float zmin = layer[1][i].z()-layer[1][i].dz();
168  float zmax = layer[1][i].z()+layer[1][i].dz();
169  out<<"| "
170  <<std::setw(4)<<i<<" |"
171  <<std::setw(10)<<std::setprecision(4)<< layer[1][i].r ()<<" | "
172  <<std::setw(10)<<std::setprecision(4)<< zmin<<" | "
173  <<std::setw(10)<<std::setprecision(4)<< zmax<<" | "
174  <<std::setw(10)<<std::setprecision(4)<< layer[1][i].dfe()<<" | "
175  <<std::setw(4)<<layer[1][i].nElements()<<" | "
176  <<std::endl;
177  }
178  out<<"|------|-----------|------------|------------|------------|------|"
179  <<std::endl;
180 
181  }
182  if(!layer[0].empty()) {
183 
184  int nl = layer[0].size();
185  int nc = 0;
186  for(const auto & i : layer[0]) nc+=i.nElements();
187  out<<"|----------------------------------------------------------------|"
188  <<std::endl;
189  out<<"| L.Endcap map containt "
190  <<std::setw(4)<<nl<<" layers and "
191  <<std::setw(6)<<nc<<" elements |"
192  <<std::endl;
193 
194  out<<"|------|-----------|------------|------------|------------|------|"
195  <<std::endl;
196  out<<"| n | Z | R min | R max | max dF | nEl |"
197  <<std::endl;
198  out<<"|------|-----------|------------|------------|------------|------|"
199  <<std::endl;
200  for(unsigned int i=0; i!=layer[0].size(); ++i) {
201  float rmin = layer[0][i].r()-layer[0][i].dr();
202  float rmax = layer[0][i].r()+layer[0][i].dr();
203  out<<"| "
204  <<std::setw(4)<<i<<" |"
205  <<std::setw(10)<<std::setprecision(4)<< layer[0][i].z()<<" | "
206  <<std::setw(10)<<std::setprecision(4)<< rmin<<" | "
207  <<std::setw(10)<<std::setprecision(4)<< rmax<<" | "
208  <<std::setw(10)<<std::setprecision(4)<<layer[0][i].dfe()<<" | "
209  <<std::setw(4)<<layer[0][i].nElements()<<" | "
210  <<std::endl;
211  }
212  out<<"|------|-----------|------------|------------|------------|------|"
213  <<std::endl;
214  }
215  if(!layer[2].empty()) {
216  int nl = layer[2].size();
217  int nc = 0;
218  for(const auto & i : layer[2]) nc+=i.nElements();
219  out<<"|----------------------------------------------------------------|"
220  <<std::endl;
221  out<<"| R.Endcap map containt "
222  <<std::setw(4)<<nl<<" layers and "
223  <<std::setw(6)<<nc<<" elements |"
224  <<std::endl;
225  out<<"|------|-----------|------------|------------|------------|------|"
226  <<std::endl;
227  out<<"| n | Z | R min | R max | max dF | nEl |"
228  <<std::endl;
229  out<<"|------|-----------|------------|------------|------------|------|"
230  <<std::endl;
231  for(unsigned int i=0; i!=layer[2].size(); ++i) {
232  float rmin = layer[2][i].r()-layer[0][i].dr();
233  float rmax = layer[2][i].r()+layer[0][i].dr();
234  out<<"| "
235  <<std::setw(4)<<i<<" |"
236  <<std::setw(10)<<std::setprecision(4)<< layer[2][i].z()<<" | "
237  <<std::setw(10)<<std::setprecision(4)<< rmin<<" | "
238  <<std::setw(10)<<std::setprecision(4)<< rmax<<" | "
239  <<std::setw(10)<<std::setprecision(4)<<layer[2][i].dfe()<<" | "
240  <<std::setw(4)<<layer[2][i].nElements()<<" | "
241  <<std::endl;
242  }
243  out<<"|------|-----------|------------|------------|------------|------|"
244  <<std::endl;
245  }
246  return out;
247 }
248 
250 // Dumps event information into the MsgStream
252 
253 MsgStream& InDet::TRT_DetElementsRoadMaker_xk::dumpEvent( MsgStream& out, int size_road)
254 {
255  out<<"|--------------------------------------------------------------------|"
256  <<std::endl;
257  out<<"| Road size | "<<std::setw(12)<<size_road
258  <<" |"<<std::endl;
259  out<<"|--------------------------------------------------------------------|"
260  <<std::endl;
261  return out;
262 }
263 
265 // Dumps relevant information into the ostream
267 
268 std::ostream& InDet::TRT_DetElementsRoadMaker_xk::dump( std::ostream& out ) const
269 {
270  return out;
271 }
272 
274 // Main methods for road builder
276 
277 std::vector<const InDetDD::TRT_BaseElement*>
278 InDet::TRT_DetElementsRoadMaker_xk::detElementsRoad
279 (const EventContext& ctx,
280  MagField::AtlasFieldCache& fieldCache,
281  const Trk::TrackParameters& Tp,Trk::PropDirection D,
282  InDet::TRT_DetElementLink_xk::TRT_DetElemUsedMap& used) const
283 {
284  double qp = std::abs(500.*Tp.parameters()[4]) ;
285  if( qp < 1.e-10 ) qp = 1.e-10;
286  double S = m_step/qp ;
287  if( S > 200. ) S = 200. ;
288  if(D<0) S=-S;
289  Trk::CylinderBounds CB = getBound(fieldCache, Tp);
290  double rminTRT = getTRTMinR();
291  std::vector<const InDetDD::TRT_BaseElement*> result;
292  if( CB.r() > rminTRT) {
293  Trk::MagneticFieldMode fieldModeEnum(m_fieldModeEnum);
294  if(!fieldCache.solenoidOn()) fieldModeEnum = Trk::NoField;
295  Trk::MagneticFieldProperties fieldprop(fieldModeEnum);
296  std::deque<Amg::Vector3D> G;
297  m_proptool->globalPositions(ctx, G,Tp,fieldprop,CB,S,Trk::pion);
298  if(G.size() > 1 ) {
299  detElementsRoadATL(G,result,used);
300  }
301  }
302  return result;
303 }
304 
305 
307 // Main methods for road builder using input list global positions
308 // for Atlas geometry
310 
311 void InDet::TRT_DetElementsRoadMaker_xk::detElementsRoadATL
312 (std::deque<Amg::Vector3D>& GP,
313  std::vector<const InDetDD::TRT_BaseElement*>& Road,
314  InDet::TRT_DetElementLink_xk::TRT_DetElemUsedMap& used) const
315 {
316  int n0 = 0;
317  int n1 = 0;
318  int n2 = 0;
319  std::deque<Amg::Vector3D>::iterator g=GP.begin(),ge=GP.end();
320 
321  const TRT_DetElementsLayerVectors_xk &layer = *getLayers();
322 
323  float Po[6] = {float((*g).x()),float((*g).y()),float((*g).z()),
324  float(std::sqrt((*g).x()*(*g).x()+(*g).y()*(*g).y())),m_width,0.};
325 
326  for(; n0!=(int)layer[0].size(); ++n0) {if(Po[2] > layer[0][n0].z()) break;}
327  for(; n1!=(int)layer[1].size(); ++n1) {if(Po[3] < layer[1][n1].r()) break;}
328  for(; n2!=(int)layer[2].size(); ++n2) {if(Po[2] < layer[2][n2].z()) break;}
329 
330  std::vector<std::pair<const InDet::TRT_DetElementLink_xk*,float> > lDE;
331  for (unsigned int module_i = 0; module_i < 3; ++module_i) {
332  size_t layersSize = layer[module_i].size();
333  //Add more vectors if we need more
334  used[module_i].resize(layersSize);
335  for (unsigned int layer_i = 0; layer_i < layersSize; ++layer_i) {
336  // Although we clear/resize , we retain capacity
337  // clear what was there before
338  used[module_i][layer_i].clear();
339  //default init to false
340  used[module_i][layer_i].resize(layer[module_i][layer_i].nElements());
341  }
342  }
343 
344  for(++g; g!=ge; ++g) {
345 
346  float Pn[4] = {float((*g).x()),float((*g).y()),float((*g).z()),
347  float(std::sqrt((*g).x()*(*g).x()+(*g).y()*(*g).y()))};
348 
349  float dx = Pn[0]-Po[0];
350  float dy = Pn[1]-Po[1];
351  float dz = Pn[2]-Po[2];
352  float st = std::sqrt(dx*dx+dy*dy+dz*dz);
353  if(st <=0.) continue;
354  float ds = 1./st;
355  float A[3]= {dx*ds,dy*ds,dz*ds};
356 
357  // Barrel
358  //
359  if (Pn[3] > Po[3]) {
360  for (; n1 < (int)layer[1].size(); ++n1) {
361 
362  if (Pn[3] < layer[1][n1].r())
363  break;
364  assert(used.at(1).size() > static_cast<unsigned int>(n1));
365  layer[1][n1].getBarrelDetElementsATL(Po, A, lDE, used[1][n1]);
366  }
367  } else {
368  for (--n1; n1 >= 0; --n1) {
369  if (Pn[3] > layer[1][n1].r())
370  break;
371  assert(used.at(1).size() > static_cast<unsigned int>(n1));
372  layer[1][n1].getBarrelDetElementsATL(Po, A, lDE, used[1][n1]);
373  }
374  ++n1;
375  }
376 
377  // Positive endcap
378  //
379  if(Pn[2]>Po[2]) {
380 
381  for (; n2 < (int)layer[2].size(); ++n2) {
382  if (Pn[2] < layer[2][n2].z())
383  break;
384  assert(used.at(2).size() > static_cast<unsigned int>(n2));
385  layer[2][n2].getEndcapDetElements(Po, A, lDE, used[2][n2]);
386  }
387  } else {
388  for (--n2; n2 >= 0; --n2) {
389  if (Pn[2] > layer[2][n2].z())
390  break;
391  assert(used.at(2).size() > static_cast<unsigned int>(n2));
392  layer[2][n2].getEndcapDetElements(Po, A, lDE, used[2][n2]);
393  }
394  ++n2;
395  }
396 
397  // Negative endcap
398  //
399  if(Pn[2]<Po[2]) {
400 
401  for (; n0 < (int)layer[0].size(); ++n0) {
402  if (Pn[2] > layer[0][n0].z())
403  break;
404  assert(used.at(0).size() > static_cast<unsigned int>(n0));
405  layer[0][n0].getEndcapDetElements(Po, A, lDE, used[0][n0]);
406  }
407  } else {
408  for (--n0; n0 >= 0; --n0) {
409  if (Pn[2] < layer[0][n0].z())
410  break;
411  assert(used.at(0).size() > static_cast<unsigned int>(n0));
412  layer[0][n0].getEndcapDetElements(Po, A, lDE, used[0][n0]);
413  }
414  ++n0;
415  }
416  Po[0] = Pn[0];
417  Po[1] = Pn[1];
418  Po[2] = Pn[2];
419  Po[3] = Pn[3];
420  Po[5]+= st;
421  }
422 
423  // Sort list in propogation order
424  //
425  std::vector<std::pair<const InDet::TRT_DetElementLink_xk*,float> >::iterator l=lDE.begin(),le=lDE.end(),n,m;
426  if(l==le) return;
427 
428  bool nc =true;
429  while(nc) {
430 
431  nc =false; m=l; n=l;
432  for(++n; n!=le; ++n) {
433 
434  if( (*m).second > (*n).second ) {
435  std::pair<const InDet::TRT_DetElementLink_xk*,float> d=(*m); (*m)=(*n); (*n)=d; nc=true;
436  }
437  ++m;
438  }
439  }
440 
441  // Fill list pointers to detector elements
442  //
443  for(l=lDE.begin(); l!=le; ++l) {
444  Road.push_back((*l).first->detElement());
445  }
446 }
447 
449 // Main methods for road builder using input list global positions
450 // for CTB geometry
452 
453 void InDet::TRT_DetElementsRoadMaker_xk::detElementsRoadCTB
454 (std::deque<Amg::Vector3D>& GP,
455  std::vector<const InDetDD::TRT_BaseElement*>& Road,
456  InDet::TRT_DetElementLink_xk::TRT_DetElemUsedMap& used) const
457 {
458  int n1 = 0;
459  std::deque<Amg::Vector3D>::iterator g=GP.begin(),ge=GP.end();
460 
461  const TRT_DetElementsLayerVectors_xk &layer = *getLayers();
462 
463  float Po[6] = {float((*g).x()),float((*g).y()),float((*g).z()),
464  float(std::sqrt((*g).x()*(*g).x()+(*g).y()*(*g).y())),m_width,0.};
465 
466  for(; n1!=(int)layer[1].size(); ++n1) {if(Po[3] < layer[1][n1].r()) break;}
467 
468  std::vector<std::pair<const InDet::TRT_DetElementLink_xk*,float> > lDE;
469  for (unsigned int module_i = 0; module_i < 3; ++module_i) {
470  size_t layersSize = layer[module_i].size();
471  //Add more vectors if we need more
472  used[module_i].resize(layersSize);
473  for (unsigned int layer_i = 0; layer_i < layersSize; ++layer_i) {
474  // Although we clear/resize , we retain capacity
475  // clear what was there before
476  used[module_i][layer_i].clear();
477  //default init to false
478  used[module_i][layer_i].resize(layer[module_i][layer_i].nElements());
479  }
480  }
481 
482  for(++g; g!=ge; ++g) {
483 
484  float Pn[4] = {float((*g).x()),float((*g).y()),float((*g).z()),
485  float(std::sqrt((*g).x()*(*g).x()+(*g).y()*(*g).y()))};
486 
487  float dx = Pn[0]-Po[0];
488  float dy = Pn[1]-Po[1];
489  float dz = Pn[2]-Po[2];
490  float st = std::sqrt(dx*dx+dy*dy+dz*dz);
491  float ds = 1./st;
492  float A[3]= {dx*ds,dy*ds,dz*ds};
493 
494  // Barrel
495  //
496  if(Pn[3]>Po[3]) {
497  for(; n1<(int)layer[1].size(); ++n1) {
498  if(Pn[3] < layer[1][n1].r()) break;
499  assert( used.at(1).size() > static_cast<unsigned int>(n1) );
500  layer[1][n1].getBarrelDetElementsCTB(Po,A,lDE,used[1][n1]);
501  }
502  }
503  else {
504  for(--n1; n1>=0; --n1) {
505  if(Pn[3] > layer[1][n1].r()) break;
506  layer[1][n1].getBarrelDetElementsCTB(Po,A,lDE,used[1][n1]);
507  }
508  ++n1;
509  }
510  }
511 
512  // Sort list in propogation order
513  //
514  std::vector<std::pair<const InDet::TRT_DetElementLink_xk*, float> >::iterator l=lDE.begin(),le=lDE.end(),n;
515  if(l==le) return;
516 
517  bool nc =true;
518  while(nc) {
519 
520  nc =false; n=l;
521  for(++n; n!=le; ++n) {
522 
523  if( (*l).second > (*n).second ) {
524  std::pair<const InDet::TRT_DetElementLink_xk*,float> d = (*l); (*l) = (*n); (*n) = d;
525  nc = true;
526  }
527  ++l;
528  }
529  }
530 
531  // Fill list pointers to detector elements
532  //
533  for(l=lDE.begin(); l!=le; ++l) {
534  Road.push_back((*l).first->detElement());
535  }
536 }
537 
539 // Distance to detector element according stright line model
541 
542 double InDet::TRT_DetElementsRoadMaker_xk::stepToDetElement
543 (const InDetDD::TRT_BaseElement*& de,Amg::Vector3D& r,Amg::Vector3D& a)
544 {
545  Amg::Vector3D R = de->center();
546  Amg::Vector3D A = de->normal();
547  double D = a.x()*A.x()+a.y()*A.y()+a.z()*A.z(); if(D==0.) return D;
548  return ((A.x()*(R.x()-r.x())+A.y()*(R.y()-r.y())+A.z()*(R.z()-r.z()))/D);
549 }
550 
552 // Cylinder bounds parameters estimation
554 
555 Trk::CylinderBounds InDet::TRT_DetElementsRoadMaker_xk::getBound
556 (MagField::AtlasFieldCache& fieldCache, const Trk::TrackParameters& Tp) const
557 {
558  const double cor = 0.8;
559 
560  double zfield = 0.;
561  if(m_fieldModeEnum!=Trk::NoField && fieldCache.solenoidOn()) {
562  const Amg::Vector3D& pos = Tp.position();
563  double f[3], p[3] ={pos[Amg::x],pos[Amg::y],pos[Amg::z]};
564  fieldCache.getFieldZR (p, f);
565  zfield = 299.7925*f[2];
566  }
567 
568  const Trk::CylinderBounds bounds = get_bounds();
569 
570  if( std::abs(zfield) < .0000001 ) return bounds;
571 
572  const AmgVector(5)& Vp = Tp.parameters();
573 
574  double cur = zfield*Vp[4]/std::sin(Vp[3]);
575 
576  if( std::abs(cur)*bounds.r() < cor ) return bounds;
577 
578  double rad = 1./cur;
579  if(cor*std::abs(rad) > bounds.r() ) return bounds;
580 
581  const Amg::Vector3D& Gp = Tp.position() ;
582  double sn,cs; sincos(Vp[2],&sn,&cs);
583  double xc = Gp.x()+sn*rad ;
584  double yc = Gp.y()-cs*rad ;
585  double rm = (std::sqrt(xc*xc+yc*yc)+std::abs(rad))*cor;
586  if( rm > bounds.r() ) return bounds;
587  Trk::CylinderBounds CB(rm,bounds.halflengthZ());
588  return CB;
589 }
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
used
TrapezoidBounds.h
InDet::TRT_DetElementsRoadMaker_xk::dumpConditions
MsgStream & dumpConditions(MsgStream &out) const
Definition: TRT_DetElementsRoadMaker_xk.cxx:105
beamspotman.r
def r
Definition: beamspotman.py:676
InDet::TRT_DetElementsRoadMaker_xk::detElementsRoadCTB
void detElementsRoadCTB(std::deque< Amg::Vector3D > &, std::vector< const InDetDD::TRT_BaseElement * > &, InDet::TRT_DetElementLink_xk::TRT_DetElemUsedMap &used) const
Definition: TRT_DetElementsRoadMaker_xk.cxx:454
python.CaloRecoConfig.f
f
Definition: CaloRecoConfig.py:127
InDet::TRT_DetElementsRoadMaker_xk::m_fieldmode
std::string m_fieldmode
Definition: TRT_DetElementsRoadMaker_xk.h:114
checkxAOD.ds
ds
Definition: Tools/PyUtils/bin/checkxAOD.py:257
python.tests.PyTestsLib.finalize
def finalize(self)
_info( "content of StoreGate..." ) self.sg.dump()
Definition: PyTestsLib.py:53
InDet::TRT_DetElementsRoadMaker_xk::get_bounds
const Trk::CylinderBounds get_bounds() const
Definition: TRT_DetElementsRoadMaker_xk.h:148
get_generator_info.result
result
Definition: get_generator_info.py:21
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
DiscBounds.h
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
Trk::MagneticFieldProperties
Definition: MagneticFieldProperties.h:31
RectangleBounds.h
AtlasFieldCacheCondObj
Definition: AtlasFieldCacheCondObj.h:19
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
MagField::AtlasFieldCache::getFieldZR
void getFieldZR(const double *ATH_RESTRICT xyz, double *ATH_RESTRICT bxyz, double *ATH_RESTRICT deriv=nullptr)
get B field valaue on the z-r plane at given position works only inside the solenoid.
Definition: AtlasFieldCache.cxx:86
beamspotman.cur
def cur
Definition: beamspotman.py:671
Trk::ParametersBase::position
const Amg::Vector3D & position() const
Access method for the position.
PixelAthClusterMonAlgCfg.zmin
zmin
Definition: PixelAthClusterMonAlgCfg.py:176
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
hist_file_dump.d
d
Definition: hist_file_dump.py:137
initialize
void initialize()
Definition: run_EoverP.cxx:894
InDet::TRT_DetElementsRoadMaker_xk::getTRTMinR
double getTRTMinR() const
Definition: TRT_DetElementsRoadMaker_xk.h:157
Amg::y
@ y
Definition: GeoPrimitives.h:35
InDet::TRT_DetElementsRoadMaker_xk::finalize
virtual StatusCode finalize() override
Definition: TRT_DetElementsRoadMaker_xk.cxx:87
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:71
TRT_DetElementsRoadMaker_xk.h
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:158
IPropagator.h
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
InDet::TRT_DetElementsRoadMaker_xk::getLayers
const TRT_DetElementsLayerVectors_xk * getLayers() const
Definition: TRT_DetElementsRoadMaker_xk.h:139
InDet::TRT_DetElementsLayerVectors_xk
std::vector< std::vector< InDet::TRT_DetElementsLayer_xk > > TRT_DetElementsLayerVectors_xk
Definition: TRT_DetElementsLayerVectors_xk.h:16
InDet::TRT_DetElementsRoadMaker_xk::m_width
float m_width
Definition: TRT_DetElementsRoadMaker_xk.h:111
JetTiledMap::S
@ S
Definition: TiledEtaPhiMap.h:44
empty
bool empty(TH1 *h)
Definition: computils.cxx:294
InDet::TRT_DetElementsRoadMaker_xk::dump
virtual MsgStream & dump(MsgStream &out) const override
Definition: TRT_DetElementsRoadMaker_xk.cxx:96
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
InDet::TRT_DetElementsRoadMaker_xk::m_fieldModeEnum
Trk::MagneticFieldMode m_fieldModeEnum
Definition: TRT_DetElementsRoadMaker_xk.h:115
InDet::TRT_DetElementsRoadMaker_xk::m_roadDataKey
SG::ReadCondHandleKey< TRT_DetElementsRoadData_xk > m_roadDataKey
Definition: TRT_DetElementsRoadMaker_xk.h:103
Trk::FastField
@ FastField
call the fast field access method of the FieldSvc
Definition: MagneticFieldMode.h:20
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
TRT_EndcapElement.h
Amg::z
@ z
Definition: GeoPrimitives.h:36
InDet::TRT_DetElementsRoadMaker_xk::m_proptool
ToolHandle< Trk::IPropagator > m_proptool
Definition: TRT_DetElementsRoadMaker_xk.h:109
Trk::PropDirection
PropDirection
Definition: PropDirection.h:19
TRT_DetElementsComparison.h
lumiFormat.i
int i
Definition: lumiFormat.py:92
z
#define z
G
#define G(x, y, z)
Definition: MD5.cxx:113
python.CaloCondTools.g
g
Definition: CaloCondTools.py:15
beamspotman.n
n
Definition: beamspotman.py:731
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
AmgVector
AmgVector(4) T2BSTrackFilterTool
Definition: T2BSTrackFilterTool.cxx:114
Amg::x
@ x
Definition: GeoPrimitives.h:34
Trk::CylinderBounds
Definition: CylinderBounds.h:46
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
Trk::pion
@ pion
Definition: ParticleHypothesis.h:29
PixelAthClusterMonAlgCfg.zmax
zmax
Definition: PixelAthClusterMonAlgCfg.py:176
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Preparation.mode
mode
Definition: Preparation.py:95
InDet::TRT_DetElementsRoadMaker_xk::m_step
double m_step
Definition: TRT_DetElementsRoadMaker_xk.h:112
Trk::ParametersBase
Definition: ParametersBase.h:55
TRT_DetElementsRoadUtils_xk.h
TRT_BarrelElement.h
MagField::AtlasFieldCache::solenoidOn
bool solenoidOn() const
status of the magnets
Trk::FullField
@ FullField
Field is set to be realistic, but within a given Volume.
Definition: MagneticFieldMode.h:21
IGeoModelTool.h
InDet::TRT_DetElementsRoadMaker_xk::getBound
Trk::CylinderBounds getBound(MagField::AtlasFieldCache &fieldCache, const Trk::TrackParameters &) const
Definition: TRT_DetElementsRoadMaker_xk.cxx:556
Trk::NoField
@ NoField
Field is set to 0., 0., 0.,.
Definition: MagneticFieldMode.h:18
InDet::TRT_DetElementsRoadMaker_xk::stepToDetElement
static double stepToDetElement(const InDetDD::TRT_BaseElement *&, Amg::Vector3D &, Amg::Vector3D &)
Definition: TRT_DetElementsRoadMaker_xk.cxx:543
ReadCellNoiseFromCoolCompare.s3
s3
Definition: ReadCellNoiseFromCoolCompare.py:380
InDet::TRT_DetElementsRoadMaker_xk::~TRT_DetElementsRoadMaker_xk
virtual ~TRT_DetElementsRoadMaker_xk()
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
Trk::MagneticFieldProperties::magneticFieldMode
MagneticFieldMode magneticFieldMode() const
Returns the MagneticFieldMode as specified.
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
InDet::TRT_DetElementsRoadMaker_xk::initialize
virtual StatusCode initialize() override
Definition: TRT_DetElementsRoadMaker_xk.cxx:68
Rtt_histogram.n1
n1
Definition: Rtt_histogram.py:21
makeTRTBarrelCans.dy
tuple dy
Definition: makeTRTBarrelCans.py:21
InDet::TRT_DetElementsRoadMaker_xk::detElementsRoadATL
void detElementsRoadATL(std::deque< Amg::Vector3D > &, std::vector< const InDetDD::TRT_BaseElement * > &, InDet::TRT_DetElementLink_xk::TRT_DetElemUsedMap &used) const
Definition: TRT_DetElementsRoadMaker_xk.cxx:312
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
a
TList * a
Definition: liststreamerinfos.cxx:10
PlaneSurface.h
InDet::TRT_DetElementsRoadMaker_xk::dumpEvent
static MsgStream & dumpEvent(MsgStream &out, int size_road)
Definition: TRT_DetElementsRoadMaker_xk.cxx:253
makeTRTBarrelCans.dx
tuple dx
Definition: makeTRTBarrelCans.py:20
InDetDD::TRT_BaseElement::center
virtual const Amg::Vector3D & center() const override final
Element Surface: center of a straw layer.
MagField::AtlasFieldCache
Local cache for magnetic field (based on MagFieldServices/AtlasFieldSvcTLS.h)
Definition: AtlasFieldCache.h:43
TRT_Numerology.h
InDet::TRT_DetElementLink_xk::TRT_DetElemUsedMap
std::array< std::vector< std::vector< Used_t > >, 3 > TRT_DetElemUsedMap
Definition: TRT_DetElementLink_xk.h:42
InDet::TRT_DetElementsRoadMaker_xk::TRT_DetElementsRoadMaker_xk
TRT_DetElementsRoadMaker_xk(const std::string &, const std::string &, const IInterface *)
Definition: TRT_DetElementsRoadMaker_xk.cxx:43
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
AthAlgTool
Definition: AthAlgTool.h:26
Trk::MagneticFieldMode
MagneticFieldMode
Definition: MagneticFieldMode.h:17
InDetDD::TRT_BaseElement::normal
virtual const Amg::Vector3D & normal() const override final
Element Surface: normal of a straw layer.
InDet::TRT_DetElementsRoadMaker_xk::m_fieldCacheCondObjInputKey
SG::ReadCondHandleKey< AtlasFieldCacheCondObj > m_fieldCacheCondObjInputKey
Definition: TRT_DetElementsRoadMaker_xk.h:106
InDet::TRT_DetElementsRoadMaker_xk::detElementsRoad
virtual std::vector< const InDetDD::TRT_BaseElement * > detElementsRoad(const EventContext &ctx, MagField::AtlasFieldCache &fieldCache, const Trk::TrackParameters &Tp, Trk::PropDirection D, InDet::TRT_DetElementLink_xk::TRT_DetElemUsedMap &used) const override
Definition: TRT_DetElementsRoadMaker_xk.cxx:279
readCCLHist.float
float
Definition: readCCLHist.py:83
plotBeamSpotMon.nc
int nc
Definition: plotBeamSpotMon.py:83
python.SystemOfUnits.rad
int rad
Definition: SystemOfUnits.py:111
Trk::CylinderBounds::halflengthZ
double halflengthZ() const
This method returns the halflengthZ.
InDetDD::TRT_BaseElement
Definition: TRT_BaseElement.h:57
Trk::CylinderBounds::r
virtual double r() const override final
This method returns the radius.
Generated on Sun Jun 30 2024 21:31:17 for ATLAS Offline Software by   doxygen 1.8.18