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