ATLAS Offline Software
LArRecoSimpleGeomTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 // ***************************************************************************
6 // LArCalorimeter/LArDetDescr/LArRecoSimpleGeomTool.cxx
7 // -------------------------------------------------------------
8 //****************************************************************************
9 
10 #include "LArRecoSimpleGeomTool.h"
11 
12 #include "Gaudi/Property.h"
13 #include "GaudiKernel/IService.h"
14 #include "GaudiKernel/IToolSvc.h"
15 #include <vector>
16 
17 #include "CaloDetDescr/CaloDetDescriptor.h"
18 #include "CaloGeoHelpers/CaloPhiRange.h"
19 
20 #include "RDBAccessSvc/IRDBAccessSvc.h"
21 #include "RDBAccessSvc/IRDBRecordset.h"
22 #include "RDBAccessSvc/IRDBRecord.h"
23 #include "GeoModelInterfaces/IGeoModelSvc.h"
24 #include "GeoModelInterfaces/IGeoDbTagSvc.h"
25 #include "GeoModelUtilities/DecodeVersionKey.h"
26 #include "GeoModelUtilities/StoredPhysVol.h"
27 #include "GeoModelKernel/GeoFullPhysVol.h"
28 #include "GeoModelKernel/GeoDefinitions.h"
29 #include "GaudiKernel/SystemOfUnits.h"
30 
31 #include "GeoPrimitives/CLHEPtoEigenConverter.h"
32 
33 #include <iostream>
34 #include <iomanip>
35 
36 LArRecoSimpleGeomTool::LArRecoSimpleGeomTool(const std::string& type,
37  const std::string& name,
38  const IInterface* parent)
39  : base_class(type, name, parent)
40 {
41 }
42 
43 StatusCode
44 LArRecoSimpleGeomTool::initialize()
45 {
46  // Retrieve the Id helpers needed
47  ATH_CHECK( detStore()->retrieve (m_calo_id, "CaloCell_ID") );
48 
49  // Decode tag ( via GeoModel ) and fix it for TestBeam :
50  std::string strTag = "ATLAS-00";
51  std::string strNode = "ATLAS";
52 
53  SmartIF<IGeoModelSvc> geoModelSvc{service("GeoModelSvc")};
54  ATH_CHECK(geoModelSvc.isValid());
55 
56  DecodeVersionKey detectorKey = DecodeVersionKey(geoModelSvc, "LAr");
57  ATH_MSG_INFO ("DecodeVersionKey found : " << detectorKey.tag()
58  << " " << detectorKey.tag());
59  if ( detectorKey.tag() != "LAr-H8-00" && detectorKey.tag() != "LAr-H6-00"
60  && detectorKey.tag() != "LAr-G3-00")
61  {
62  strTag = detectorKey.tag();
63  strNode = detectorKey.node();
64  }
65  ATH_MSG_INFO ("LAr simplified geometry will use : " << strTag << " " << strNode);
66 
67  // Acess the DB service :
68  SmartIF<IGeoDbTagSvc> geoDbTag{service("GeoDbTagSvc")};
69  ATH_CHECK(geoDbTag.isValid());
70  SmartIF<IRDBAccessSvc> rdbSvc{service(geoDbTag->getParamSvcName())};
71  ATH_CHECK(rdbSvc.isValid());
72 
73  ATH_MSG_INFO (" did access RDBAccessSvc ");
74 
75  m_recCryoCyl = rdbSvc->getRecordsetPtr("CryoCylinders",strTag,strNode);
76  if (m_recCryoCyl->size()==0)
77  m_recCryoCyl = rdbSvc->getRecordsetPtr("CryoCylinders","CryoCylinders-00");
78 
79  m_recPresGeo = rdbSvc->getRecordsetPtr("PresamplerGeometry",strTag,strNode);
80  if (m_recPresGeo->size()==0)
81  m_recPresGeo = rdbSvc->getRecordsetPtr("PresamplerGeometry","PresamplerGeometry-00");
82 
83  m_recBarrGeo = rdbSvc->getRecordsetPtr("BarrelGeometry",strTag,strNode);
84  if (m_recBarrGeo->size()==0)
85  m_recBarrGeo = rdbSvc->getRecordsetPtr("BarrelGeometry","BarrelGeometry-00");
86 
87  if ( m_geometry == "ATLAS" ) {
88  DecodeVersionKey detectorKeyAtl = DecodeVersionKey(geoModelSvc, "ATLAS");
89  m_recPresPos = rdbSvc->getRecordsetPtr("PresamplerPosition",detectorKeyAtl.tag(),detectorKeyAtl.node());
90  }
91  else {
92  m_recPresPos = rdbSvc->getRecordsetPtr("PresamplerPosition",strTag,strNode);
93  }
94 
95  m_EmecGeo = rdbSvc->getRecordsetPtr("EmecGeometry",strTag,strNode);
96 
97  m_HEC = rdbSvc->getRecordsetPtr("HadronicEndcap",strTag,strNode);
98  if (m_HEC->size()==0)
99  m_HEC = rdbSvc->getRecordsetPtr("HadronicEndcap","HadronicEndcap-00");
100 
101  ATH_MSG_INFO (" LArRecoSimpleGeomTool successfully initialized ");
102  return StatusCode::SUCCESS;
103 }
104 
105 bool
106 LArRecoSimpleGeomTool::get_cylinder_surface (CaloSubdetNames::ALIGNVOL alvol,
107  Amg::Transform3D& htrans,double& hphi,
108  std::vector<double>& radius,
109  std::vector<double>& depth,
110  std::vector<double>& hlength ) const
111 {
112 
113  double rad,dep,len;
114  //double nb;
115 
116  StoredPhysVol* storedPV = nullptr;
117  std::string key = map_av(alvol);
118  if(detStore()->contains<StoredPhysVol>(key))
119  {
120  if(detStore()->retrieve(storedPV,key)==StatusCode::FAILURE)
121  {
122  return false;
123  }
124  }
125 
126  if (!storedPV) {
127  return false;
128  }
129 
130  GeoFullPhysVol* fullPV = storedPV->getPhysVol();
131  htrans = fullPV->getAbsoluteTransform()*fullPV->getDefAbsoluteTransform().inverse();
132 
133  hphi = m_phi_range.twopi();
134 
135  radius.clear();
136  depth.clear();
137  hlength.clear();
138 
139  if ( alvol == CaloSubdetNames::SOLENOID ) {
140 
141  // DDDb : LAr / CryoCylinders / CryoMother nb 11 & 12 & 13
142  IRDBRecordset_ptr lar = m_recCryoCyl;
143  if (lar->size()<14) return false;
144 
145  const IRDBRecord* rec = (*lar)[11];
146  rad = rec->getDouble("RMIN")*Gaudi::Units::cm;
147  len = rec->getDouble("DZ")*Gaudi::Units::cm /2.;
148  dep = rec->getDouble("DR")*Gaudi::Units::cm;
149  rec = (*lar)[12];
150  dep = dep +rec->getDouble("DR")*Gaudi::Units::cm;
151  rec = (*lar)[13];
152  dep = dep +rec->getDouble("DR")*Gaudi::Units::cm;
153 
154  //rad = 124.18*Gaudi::Units::cm;
155  //dep = (.305 + 1.38 + .47 )*Gaudi::Units::cm;
156  //len = 270.*Gaudi::Units::cm;
157 
158  radius.push_back( rad + dep/2.);
159  depth.push_back( dep/2. );
160  hlength.push_back( len );
161 
162  return true;
163  }
164  else if ( alvol == CaloSubdetNames::LARCRYO_B ) {
165 
166  // DDDb : LAr / CryoCylinders
167 
168  IRDBRecordset_ptr lar = m_recCryoCyl;
169  if (lar->size()<15) return false;
170 
171  // CryoMother nb 10
172  const IRDBRecord* rec = (*lar)[10];
173  rad = rec->getDouble("RMIN")*Gaudi::Units::cm;
174  len = rec->getDouble("DZ")*Gaudi::Units::cm /2.;
175  dep = rec->getDouble("DR")*Gaudi::Units::cm;
176 
177  //rad = 122.9*Gaudi::Units::cm;
178  //dep = 1.28*Gaudi::Units::cm;
179  //len = 270.*Gaudi::Units::cm;
180 
181  radius.push_back( rad + dep/2. );
182  depth.push_back( dep /2.);
183  hlength.push_back( len );
184 
185  // CryoMother nb 14
186  rec = (*lar)[14];
187  rad = rec->getDouble("RMIN")*Gaudi::Units::cm;
188  len = rec->getDouble("DZ")*Gaudi::Units::cm /2.;
189  dep = rec->getDouble("DR")*Gaudi::Units::cm;
190 
191  //rad = 126.335*Gaudi::Units::cm;
192  //dep = 1.2*Gaudi::Units::cm;
193  //len = 284.*Gaudi::Units::cm;
194 
195  radius.push_back( rad + dep/2.);
196  depth.push_back( dep /2.);
197  hlength.push_back( len );
198 
199  // CryoMother nb 0
200  rec = (*lar)[0];
201  rad = rec->getDouble("RMIN")*Gaudi::Units::cm;
202  len = rec->getDouble("DZ")*Gaudi::Units::cm /2.;
203  dep = rec->getDouble("DR")*Gaudi::Units::cm;
204 
205  //rad = 2140*mm;
206  //dep = 30*mm;
207  //len = 299.6*Gaudi::Units::cm;
208 
209  radius.push_back( rad + dep/2. );
210  depth.push_back( dep /2.);
211  hlength.push_back( len );
212 
213  // CryoMother nb 5
214  rec = (*lar)[5];
215  rad = rec->getDouble("RMIN")*Gaudi::Units::cm;
216  len = rec->getDouble("DZ")*Gaudi::Units::cm /2.;
217  dep = rec->getDouble("DR")*Gaudi::Units::cm;
218 
219  //rad = 2220*mm;
220  //dep = 30*mm;
221  //len = 285*Gaudi::Units::cm;
222 
223  radius.push_back( rad + dep/2. );
224  depth.push_back( dep /2.);
225  hlength.push_back( len );
226 
227  return true;
228  }
229  else if ( alvol == CaloSubdetNames::PRESAMPLER_B_POS ||
230  alvol == CaloSubdetNames::PRESAMPLER_B_NEG ) {
231 
232  // DDDb : LAr / PresamplerGeometry / rmin, rmax
233  // LAr / BarrelGeometry / zmax
234  IRDBRecordset_ptr lar = m_recPresGeo;
235  if (lar->size()==0) return false;
236 
237  const IRDBRecord* rec = (*lar)[0];
238  rad = rec->getDouble("RMIN")*Gaudi::Units::cm;
239  dep = rec->getDouble("RMAX")*Gaudi::Units::cm - rad;
240 
241  lar = m_recBarrGeo;
242  if ( !lar || lar->size()==0) return false;
243 
244  rec = (*lar)[0];
245  len = rec->getDouble("ZMAX")*Gaudi::Units::cm;
246 
247  //rad = 138.5*Gaudi::Units::cm;
248  //dep = (144.7 - 138.5)*Gaudi::Units::cm;
249  //len = 316.5*Gaudi::Units::cm;
250 
251  radius.push_back( rad + dep/2.);
252  depth.push_back( dep /2.);
253  hlength.push_back( len );
254 
255  return true;
256 
257  }
258  else if ( alvol == CaloSubdetNames::EMB_POS || alvol == CaloSubdetNames::EMB_NEG ) {
259 
260  // DDDb : LAr / BarrelGeometry / rmin, rmax, zmax
261 
262  IRDBRecordset_ptr lar = m_recBarrGeo;
263  if (lar->size()==0) return false;
264 
265  const IRDBRecord* rec = (*lar)[0];
266  rad = rec->getDouble("RMIN")*Gaudi::Units::cm;
267  dep = rec->getDouble("RMAX")*Gaudi::Units::cm - rad;
268  len = rec->getDouble("ZMAX")*Gaudi::Units::cm;
269 
270  //rad = 1447.3*Gaudi::Units::cm;
271  //dep = (2003.35 - 1447.3)*Gaudi::Units::cm;
272  //len = 316.5*Gaudi::Units::cm;
273 
274  radius.push_back( rad + dep/2.);
275  depth.push_back( dep /2.);
276  hlength.push_back( len );
277 
278  return true;
279  }
280 
281  return false;
282 }
283 
284 bool
285 LArRecoSimpleGeomTool::get_disk_surface (CaloSubdetNames::ALIGNVOL alvol,
286  Amg::Transform3D& htrans,double& hphi,
287  std::vector<double>& z,
288  std::vector<double>& depth,
289  std::vector<double>& rmin, std::vector<double>& rmax ) const
290 {
291 
292  // Tracking geometry convention : z is the center of the layer, it is signed
293  // and "depth" is actually the half depth
294  StoredPhysVol* storedPV = nullptr;
295  std::string key = map_av(alvol);
296  if(detStore()->contains<StoredPhysVol>(key))
297  {
298  if(detStore()->retrieve(storedPV,key)==StatusCode::FAILURE)
299  {
300  return false;
301  }
302  }
303 
304  if (!storedPV) {
305  return false;
306  }
307 
308  GeoFullPhysVol* fullPV = storedPV->getPhysVol();
309  htrans = fullPV->getAbsoluteTransform()*fullPV->getDefAbsoluteTransform().inverse();
310 
311  hphi = m_phi_range.twopi();
312  z.clear();
313  depth.clear();
314  rmin.clear();
315  rmax.clear();
316  double nb;
317  double ri,ra,dep,zcent;
318 
319  if ( alvol == CaloSubdetNames::LARCRYO_EC_POS ||
320  alvol == CaloSubdetNames::LARCRYO_EC_NEG ) {
321 
322  // DDDb : LAr / CryoCylinders / Endcap nb 11
323 
324  IRDBRecordset_ptr lar = m_recCryoCyl;
325  if (lar->size()<60) return false;
326 
327  const IRDBRecord* rec = (*lar)[49];
328 
329  ri = rec->getDouble("RMIN")*Gaudi::Units::cm;
330  ra = ri + rec->getDouble("DR")*Gaudi::Units::cm;
331  dep = rec->getDouble("DZ")*Gaudi::Units::cm;
332  zcent = rec->getDouble("ZMIN")*Gaudi::Units::cm + dep/2.;
333  if (alvol == CaloSubdetNames::LARCRYO_EC_NEG) zcent = -1. * zcent;
334 
335  //ri = 22.1*Gaudi::Units::cm;
336  //ra = (22.1 + 194.4)*Gaudi::Units::cm;
337  //dep = 6.5*Gaudi::Units::cm;
338  //zcent = (356.1 + dep/2.)*Gaudi::Units::cm;
339 
340  rmin.push_back( ri );
341  rmax.push_back( ra );
342  depth.push_back( dep/2. );
343  z.push_back( zcent );
344 
345  // DDDb : LAr / CryoCylinders / Endcap nb 6
346  rec = (*lar)[44];
347 
348  ri = rec->getDouble("RMIN")*Gaudi::Units::cm;
349  ra = ri + rec->getDouble("DR")*Gaudi::Units::cm;
350  dep = rec->getDouble("DZ")*Gaudi::Units::cm;
351  zcent = rec->getDouble("ZMIN")*Gaudi::Units::cm + dep/2.;
352  if (alvol == CaloSubdetNames::LARCRYO_EC_NEG) zcent = -1. * zcent;
353 
354  //ri = 79.*Gaudi::Units::cm;
355  //ra = (ri + 173.)*Gaudi::Units::cm;
356  //dep = 6.*Gaudi::Units::cm;
357  //zcent = (660.5 + dep/2.)*Gaudi::Units::cm;
358 
359  rmin.push_back( ri );
360  rmax.push_back( ra );
361  depth.push_back( dep/2. );
362  z.push_back( zcent );
363 
364  return true;
365  }
366 
367  if ( alvol == CaloSubdetNames::PRESAMPLER_EC_POS ||
368  alvol == CaloSubdetNames::PRESAMPLER_EC_NEG ) {
369 
370  // DDDb Cryostat / PresamplerPosition
371  IRDBRecordset_ptr lar = m_recPresPos;
372 
373  const IRDBRecord* rec = (*lar)[0];
374 
375  ri = rec->getDouble("RMIN")*Gaudi::Units::cm;
376  ra = rec->getDouble("RMAX")*Gaudi::Units::cm;
377  dep = rec->getDouble("TCK")*Gaudi::Units::cm;
378  zcent = rec->getDouble("ZPOS")*Gaudi::Units::cm + dep/2.;
379  if (alvol == CaloSubdetNames::PRESAMPLER_EC_NEG) zcent = -1. * zcent;
380 
381  //ri = 123.174*Gaudi::Units::cm;
382  //ra = 170.2*Gaudi::Units::cm;
383  //dep = 0.4*Gaudi::Units::cm;
384  //zcent = (362.4 + dep/2.)*Gaudi::Units::cm;
385 
386  rmin.push_back( ri );
387  rmax.push_back( ra );
388  depth.push_back( dep/2. );
389  z.push_back( zcent );
390 
391  return true;
392  }
393 
394  if ( alvol == CaloSubdetNames::EMEC_POS ||
395  alvol == CaloSubdetNames::EMEC_NEG ) {
396 
397  // handcoded copy of dddb : LAr / EmecGeometry / z1, etot, rmin, rmax
398  IRDBRecordset_ptr lar = m_EmecGeo;
399 
400  const IRDBRecord* rec = (*lar)[0];
401 
402  ri = rec->getDouble("RMIN")*Gaudi::Units::cm;
403  ra = rec->getDouble("RMAX")*Gaudi::Units::cm;
404  dep = rec->getDouble("ETOT")*Gaudi::Units::cm;
405  zcent = rec->getDouble("Z1")*Gaudi::Units::cm + dep/2.;
406  if (alvol == CaloSubdetNames::EMEC_NEG) zcent = -1. * zcent;
407 
408  //ri = 29.*Gaudi::Units::cm;
409  //ra = 210.*Gaudi::Units::cm;
410  //dep = 53.6*Gaudi::Units::cm;
411  //zcent = (369.1 + dep/2.)*Gaudi::Units::cm;
412 
413  rmin.push_back( ri );
414  rmax.push_back( ra );
415  depth.push_back( dep/2. );
416  z.push_back( zcent );
417 
418  return true;
419  }
420 
421  if ( alvol == CaloSubdetNames::HEC1_POS || alvol == CaloSubdetNames::HEC1_NEG ) {
422 
423  // DDDb numbers : LAr / HadronicEndcap / zstart, roorig, rend
424  // + for depth, see LArNumberHelper
425  IRDBRecordset_ptr lar = m_HEC;
426  if (lar->size()==0) return false;
427 
428  const IRDBRecord* rec = (*lar)[0];
429 
430  ri = rec->getDouble("ROORIG")*Gaudi::Units::cm;
431  ra = rec->getDouble("REND")*Gaudi::Units::cm;
432  // Block0+Block1+Block2
433  dep = rec->getDouble("PLATE_0")/2.
434  + 3*8*(rec->getDouble("LARG") + rec->getDouble("PLATE_0"));
435  dep = dep*Gaudi::Units::cm;
436  zcent = rec->getDouble("ZSTART")*Gaudi::Units::cm + dep/2.;
437  if (alvol == CaloSubdetNames::HEC1_NEG) zcent = -1. * zcent;
438 
439  //ri = 37.2*Gaudi::Units::cm;
440  //ra = 213.0*Gaudi::Units::cm;
441  //dep = (513.4 - 4.05 - 427.7)*Gaudi::Units::cm;
442  //zcent = 427.7*Gaudi::Units::cm;
443 
444  rmin.push_back( ri );
445  rmax.push_back( ra );
446  depth.push_back( dep/2. );
447  z.push_back( zcent );
448 
449  return true;
450  }
451 
452  if ( alvol == CaloSubdetNames::HEC2_POS || alvol == CaloSubdetNames::HEC2_NEG ) {
453 
454  // DDDb numbers : LAr / HadronicEndcap / zstart, roorig, rend
455  // + for depth, see LArNumberHelper
456 
457  IRDBRecordset_ptr lar = m_HEC;
458  if (lar->size()==0) return false;
459 
460  const IRDBRecord* rec = (*lar)[0];
461 
462  ri = rec->getDouble("ROORIG")*Gaudi::Units::cm;
463  ra = rec->getDouble("REND")*Gaudi::Units::cm;
464  // Block 3 + Block 4 + Block 5 + Block 6
465  dep = rec->getDouble("PLATE_1")/2.
466  + 4*4*(rec->getDouble("LARG") + rec->getDouble("PLATE_1"));
467  dep = dep*Gaudi::Units::cm;
468  // start+depth of HEC1 + gap
469  zcent = rec->getDouble("ZSTART")
470  + rec->getDouble("PLATE_0")/2.
471  + 3*8*(rec->getDouble("LARG") + rec->getDouble("PLATE_0"))
472  + rec->getDouble("GAPWHL") ;
473  zcent = zcent*Gaudi::Units::cm + dep/2.;
474  if (alvol == CaloSubdetNames::HEC2_NEG) zcent = -1. * zcent;
475 
476  //ri = 37.2*Gaudi::Units::cm;
477  //ra = 213.0*Gaudi::Units::cm;
478  //dep = (609.5 - 513.4)*Gaudi::Units::cm;
479  //zcent = (513.4 + dep/2.)*Gaudi::Units::cm;
480 
481  rmin.push_back( ri );
482  rmax.push_back( ra );
483  depth.push_back( dep/2. );
484  z.push_back( zcent );
485 
486  return true;
487  }
488 
489  if ( alvol == CaloSubdetNames::FCAL1_POS || alvol == CaloSubdetNames::FCAL1_NEG ) {
490 
491  // see LArNumberHelper
492 
493  nb = 8.6*Gaudi::Units::cm;
494  rmin.push_back( nb );
495  nb = 47.5*Gaudi::Units::cm;
496  rmax.push_back( nb );
497 
498  nb = 45.*Gaudi::Units::cm;
499  depth.push_back( nb/2. );
500 
501  nb = (466.85 + nb/2. )*Gaudi::Units::cm;
502  if (alvol == CaloSubdetNames::FCAL1_NEG) nb = -1. * nb;
503  z.push_back( nb );
504 
505  return true;
506  }
507 
508  if ( alvol == CaloSubdetNames::FCAL2_POS || alvol == CaloSubdetNames::FCAL2_NEG ) {
509 
510  // see LArNumberHelper
511 
512  nb = 8.6*Gaudi::Units::cm;
513  rmin.push_back( nb );
514  nb = 47.5*Gaudi::Units::cm;
515  rmax.push_back( nb );
516 
517  nb = 45.*Gaudi::Units::cm;
518  depth.push_back( nb/2. );
519 
520  nb = (512.3 + nb/2. )*Gaudi::Units::cm;
521  if (alvol == CaloSubdetNames::FCAL2_NEG) nb = -1. * nb;
522  z.push_back( nb );
523 
524  return true;
525  }
526 
527  if ( alvol == CaloSubdetNames::FCAL3_POS || alvol == CaloSubdetNames::FCAL3_NEG ) {
528 
529  // see LArNumberHelper
530 
531  nb = 8.6*Gaudi::Units::cm;
532  rmin.push_back( nb );
533  nb = 47.5*Gaudi::Units::cm;
534  rmax.push_back( nb );
535 
536  nb = 45.*Gaudi::Units::cm;
537  depth.push_back( nb/2. );
538 
539  nb = (559.75 + nb/2. )*Gaudi::Units::cm;
540  if (alvol == CaloSubdetNames::FCAL3_NEG) nb = -1. * nb;
541  z.push_back( nb );
542 
543  return true;
544  }
545 
546 
547  return false;
548 }
549 
550 void
551 LArRecoSimpleGeomTool::print() const
552 {}
553 
554 bool
555 LArRecoSimpleGeomTool::ScanBarrelCryo(CaloSubdetNames::ALIGNVOL alvol,
556  Amg::Transform3D& htrans,double& hphi,
557  std::vector<double>& radius,
558  std::vector<double>& depth,
559  std::vector<double>& hlength )
560 {
561  StoredPhysVol* storedPV = nullptr;
562  std::string key = map_av(alvol);
563  if(detStore()->contains<StoredPhysVol>(key))
564  {
565  if(detStore()->retrieve(storedPV,key)==StatusCode::FAILURE)
566  {
567  return false;
568  }
569  }
570 
571  if (!storedPV) {
572  return false;
573  }
574 
575  GeoFullPhysVol* fullPV = storedPV->getPhysVol();
576  htrans = fullPV->getAbsoluteTransform()*fullPV->getDefAbsoluteTransform().inverse();
577 
578  hphi = m_phi_range.twopi();
579  radius.clear();
580  depth.clear();
581  hlength.clear();
582 
583  return true;
584 }
585 
586 bool
587 LArRecoSimpleGeomTool::ScanEMB(CaloSubdetNames::ALIGNVOL alvol,
588  Amg::Transform3D& htrans,double& hphi,
589  std::vector<double>& radius,
590  std::vector<double>& depth,
591  std::vector<double>& hlength )
592 {
593  StoredPhysVol* storedPV = nullptr;
594  std::string key = map_av(alvol);
595  if(detStore()->contains<StoredPhysVol>(key))
596  {
597  if(detStore()->retrieve(storedPV,key)==StatusCode::FAILURE)
598  {
599  return false;
600  }
601  }
602 
603  if (!storedPV) {
604  return false;
605  }
606 
607  GeoFullPhysVol* fullPV = storedPV->getPhysVol();
608  htrans = fullPV->getAbsoluteTransform()*fullPV->getDefAbsoluteTransform().inverse();
609 
610  hphi = m_phi_range.twopi();
611  radius.clear();
612  depth.clear();
613  hlength.clear();
614 
615  return true;
616 }
617 
618 std::string
619 LArRecoSimpleGeomTool::map_av(CaloSubdetNames::ALIGNVOL alvol) const
620 {
621  switch(alvol)
622  {
623  case CaloSubdetNames::LARCRYO_B:
624  return std::string("LARCRYO_B");
625  case CaloSubdetNames::LARCRYO_EC_POS:
626  return std::string("LARCRYO_EC_POS");
627  case CaloSubdetNames::LARCRYO_EC_NEG:
628  return std::string("LARCRYO_EC_NEG");
629  case CaloSubdetNames::SOLENOID:
630  return std::string("SOLENOID");
631  case CaloSubdetNames::PRESAMPLER_B_POS:
632  return std::string("PRESAMPLER_B_POS");
633  case CaloSubdetNames::PRESAMPLER_B_NEG:
634  return std::string("PRESAMPLER_B_NEG");
635  case CaloSubdetNames::EMB_POS:
636  return std::string("EMB_POS");
637  case CaloSubdetNames::EMB_NEG:
638  return std::string("EMB_NEG");
639  case CaloSubdetNames::PRESAMPLER_EC_POS:
640  return std::string("PRESAMPLER_EC_POS");
641  case CaloSubdetNames::PRESAMPLER_EC_NEG:
642  return std::string("PRESAMPLER_EC_NEG");
643  case CaloSubdetNames::EMEC_POS:
644  return std::string("EMEC_POS");
645  case CaloSubdetNames::EMEC_NEG:
646  return std::string("EMEC_NEG");
647  case CaloSubdetNames::HEC1_POS:
648  return std::string("HEC1_POS");
649  case CaloSubdetNames::HEC1_NEG:
650  return std::string("HEC1_NEG");
651  case CaloSubdetNames::HEC2_POS:
652  return std::string("HEC2_POS");
653  case CaloSubdetNames::HEC2_NEG:
654  return std::string("HEC2_NEG");
655  case CaloSubdetNames::FCAL1_POS:
656  return std::string("FCAL1_POS");
657  case CaloSubdetNames::FCAL1_NEG:
658  return std::string("FCAL1_NEG");
659  case CaloSubdetNames::FCAL2_POS:
660  return std::string("FCAL2_POS");
661  case CaloSubdetNames::FCAL2_NEG:
662  return std::string("FCAL2_NEG");
663  case CaloSubdetNames::FCAL3_POS:
664  return std::string("FCAL3_POS");
665  case CaloSubdetNames::FCAL3_NEG:
666  return std::string("FCAL3_NEG");
667  default:
668  return std::string("");
669  }
670 }
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
LArRecoSimpleGeomTool::get_disk_surface
virtual bool get_disk_surface(CaloSubdetNames::ALIGNVOL alvol, Amg::Transform3D &htrans, double &hphi, std::vector< double > &z, std::vector< double > &depth, std::vector< double > &rmin, std::vector< double > &rmax) const override
Definition: LArRecoSimpleGeomTool.cxx:285
CaloSubdetNames::HEC2_POS
@ HEC2_POS
Definition: CaloSubdetNames.h:42
egammaParameters::depth
@ depth
pointing depth of the shower as calculated in egammaqgcld
Definition: egammaParamDefs.h:276
LArRecoSimpleGeomTool::ScanBarrelCryo
bool ScanBarrelCryo(CaloSubdetNames::ALIGNVOL alvol, Amg::Transform3D &htrans, double &hphi, std::vector< double > &radius, std::vector< double > &depth, std::vector< double > &hlength)
Definition: LArRecoSimpleGeomTool.cxx:555
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
LArRecoSimpleGeomTool::get_cylinder_surface
virtual bool get_cylinder_surface(CaloSubdetNames::ALIGNVOL alvol, Amg::Transform3D &htrans, double &hphi, std::vector< double > &radius, std::vector< double > &depth, std::vector< double > &hlength) const override
the enum ALIGNVOL covers all LAr pieces, including cryostats and coil
Definition: LArRecoSimpleGeomTool.cxx:106
LArRecoSimpleGeomTool::m_recPresPos
IRDBRecordset_ptr m_recPresPos
Definition: LArRecoSimpleGeomTool.h:82
LArRecoSimpleGeomTool::m_recPresGeo
IRDBRecordset_ptr m_recPresGeo
Definition: LArRecoSimpleGeomTool.h:80
CaloSubdetNames::EMB_POS
@ EMB_POS
Definition: CaloSubdetNames.h:38
LArRecoSimpleGeomTool::m_recBarrGeo
IRDBRecordset_ptr m_recBarrGeo
Definition: LArRecoSimpleGeomTool.h:81
CaloSubdetNames::PRESAMPLER_B_NEG
@ PRESAMPLER_B_NEG
Definition: CaloSubdetNames.h:37
CaloSubdetNames::FCAL2_POS
@ FCAL2_POS
Definition: CaloSubdetNames.h:44
DecodeVersionKey::node
const std::string & node() const
Return the version node.
Definition: DecodeVersionKey.cxx:97
CaloSubdetNames::HEC1_NEG
@ HEC1_NEG
Definition: CaloSubdetNames.h:41
LArRecoSimpleGeomTool::m_calo_id
const CaloCell_ID * m_calo_id
Definition: LArRecoSimpleGeomTool.h:73
LArRecoSimpleGeomTool::m_geometry
std::string m_geometry
Definition: LArRecoSimpleGeomTool.h:77
CaloSubdetNames::FCAL1_POS
@ FCAL1_POS
Definition: CaloSubdetNames.h:43
CaloSubdetNames::EMEC_POS
@ EMEC_POS
Definition: CaloSubdetNames.h:40
CaloSubdetNames::HEC2_NEG
@ HEC2_NEG
Definition: CaloSubdetNames.h:42
CaloSubdetNames::FCAL3_POS
@ FCAL3_POS
Definition: CaloSubdetNames.h:45
StoredPhysVol
Definition: StoredPhysVol.h:27
CaloSubdetNames::PRESAMPLER_EC_POS
@ PRESAMPLER_EC_POS
Definition: CaloSubdetNames.h:39
cm
const double cm
Definition: Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/tools/FCAL_ChannelMap.cxx:25
CaloDetDescriptor.h
Definition of CaloDetDescriptor.
CaloSubdetNames::PRESAMPLER_B_POS
@ PRESAMPLER_B_POS
Definition: CaloSubdetNames.h:37
CaloSubdetNames::EMEC_NEG
@ EMEC_NEG
Definition: CaloSubdetNames.h:40
StoredPhysVol::getPhysVol
GeoFullPhysVol * getPhysVol()
Destructor.
Definition: StoredPhysVol.cxx:20
LArRecoSimpleGeomTool::initialize
virtual StatusCode initialize() override
Definition: LArRecoSimpleGeomTool.cxx:44
IRDBAccessSvc.h
Definition of the abstract IRDBAccessSvc interface.
LArRecoSimpleGeomTool::print
virtual void print() const override
Definition: LArRecoSimpleGeomTool.cxx:551
CaloSubdetNames::LARCRYO_B
@ LARCRYO_B
Definition: CaloSubdetNames.h:36
z
#define z
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
CaloSubdetNames::LARCRYO_EC_POS
@ LARCRYO_EC_POS
Definition: CaloSubdetNames.h:36
CaloSubdetNames::FCAL3_NEG
@ FCAL3_NEG
Definition: CaloSubdetNames.h:45
DecodeVersionKey
This is a helper class to query the version tags from GeoModelSvc and determine the appropriate tag a...
Definition: DecodeVersionKey.h:18
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
test_pyathena.parent
parent
Definition: test_pyathena.py:15
DecodeVersionKey::tag
const std::string & tag() const
Return version tag.
Definition: DecodeVersionKey.cxx:91
CaloPhiRange.h
CaloPhiRange class declaration.
LArRecoSimpleGeomTool::ScanEMB
bool ScanEMB(CaloSubdetNames::ALIGNVOL alvol, Amg::Transform3D &htrans, double &hphi, std::vector< double > &radius, std::vector< double > &depth, std::vector< double > &hlength)
Definition: LArRecoSimpleGeomTool.cxx:587
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
LArRecoSimpleGeomTool::m_HEC
IRDBRecordset_ptr m_HEC
Definition: LArRecoSimpleGeomTool.h:84
CaloPhiRange::twopi
static double twopi()
Definition: CaloPhiRange.h:46
LArRecoSimpleGeomTool.h
IRDBRecordset_ptr
std::shared_ptr< IRDBRecordset > IRDBRecordset_ptr
Definition: IRDBAccessSvc.h:25
CLHEPtoEigenConverter.h
CaloSubdetNames::HEC1_POS
@ HEC1_POS
Definition: CaloSubdetNames.h:41
LArRecoSimpleGeomTool::m_EmecGeo
IRDBRecordset_ptr m_EmecGeo
Definition: LArRecoSimpleGeomTool.h:83
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
CaloSubdetNames::PRESAMPLER_EC_NEG
@ PRESAMPLER_EC_NEG
Definition: CaloSubdetNames.h:39
LArRecoSimpleGeomTool::LArRecoSimpleGeomTool
LArRecoSimpleGeomTool(const std::string &type, const std::string &name, const IInterface *parent)
Definition: LArRecoSimpleGeomTool.cxx:36
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
CaloSubdetNames::EMB_NEG
@ EMB_NEG
Definition: CaloSubdetNames.h:38
CaloSubdetNames::FCAL2_NEG
@ FCAL2_NEG
Definition: CaloSubdetNames.h:44
CaloSubdetNames::SOLENOID
@ SOLENOID
Definition: CaloSubdetNames.h:46
LArRecoSimpleGeomTool::m_phi_range
CaloPhiRange m_phi_range
Definition: LArRecoSimpleGeomTool.h:74
DecodeVersionKey.h
ParticleGun_SamplingFraction.radius
radius
Definition: ParticleGun_SamplingFraction.py:96
IRDBRecord.h
Definition of the abstract IRDBRecord interface.
CaloSubdetNames::FCAL1_NEG
@ FCAL1_NEG
Definition: CaloSubdetNames.h:43
IRDBRecord
IRDBRecord is one record in the IRDBRecordset object.
Definition: IRDBRecord.h:27
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
IRDBRecord::getDouble
virtual double getDouble(const std::string &fieldName) const =0
Get double field value.
IRDBRecordset.h
Definition of the abstract IRDBRecordset interface.
hotSpotInTAG.nb
nb
Definition: hotSpotInTAG.py:164
IGeoModelSvc.h
LArRecoSimpleGeomTool::m_recCryoCyl
IRDBRecordset_ptr m_recCryoCyl
Definition: LArRecoSimpleGeomTool.h:79
CaloSubdetNames::LARCRYO_EC_NEG
@ LARCRYO_EC_NEG
Definition: CaloSubdetNames.h:36
LArRecoSimpleGeomTool::map_av
std::string map_av(CaloSubdetNames::ALIGNVOL alvol) const
Definition: LArRecoSimpleGeomTool.cxx:619
IGeoDbTagSvc.h
python.SystemOfUnits.rad
int rad
Definition: SystemOfUnits.py:111
StoredPhysVol.h
CaloSubdetNames::ALIGNVOL
ALIGNVOL
LAr Alignable volumes.
Definition: CaloSubdetNames.h:36
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
Generated on Sun Dec 22 2024 21:13:42 for ATLAS Offline Software by   doxygen 1.8.18