ATLAS Offline Software
LArDetectorConstructionTBEC.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 // LArDetectorConstructionTBEC
6 
7 #include "LArDetectorConstructionTBEC.h"
8 #include "CryostatConstructionTBEC.h"
9 #include "LArGeoEndcap/EMECConstruction.h"
10 #include "LArGeoEndcap/EndcapPresamplerConstruction.h"
11 
12 #include "GeoModelKernel/GeoElement.h"
13 #include "GeoModelKernel/GeoMaterial.h"
14 #include "GeoModelKernel/GeoFullPhysVol.h"
15 #include "GeoModelKernel/GeoPhysVol.h"
16 #include "GeoModelKernel/GeoVPhysVol.h"
17 #include "GeoModelKernel/GeoLogVol.h"
18 #include "GeoModelKernel/GeoBox.h"
19 #include "GeoModelKernel/GeoTube.h"
20 #include "GeoModelKernel/GeoNameTag.h"
21 #include "GeoModelKernel/GeoTransform.h"
22 #include "GeoModelKernel/GeoAlignableTransform.h"
23 #include "GeoModelKernel/GeoIdentifierTag.h"
24 #include "GeoModelKernel/GeoDefinitions.h"
25 #include "GeoModelInterfaces/StoredMaterialManager.h"
26 #include "GeoModelUtilities/StoredPhysVol.h"
27 #include "GeoModelUtilities/DecodeVersionKey.h"
28 #include "GeoModelKernel/GeoShapeUnion.h"
29 #include "GeoModelKernel/GeoShapeShift.h"
30 
31 // For the database:
32 #include "RDBAccessSvc/IRDBAccessSvc.h"
33 #include "RDBAccessSvc/IRDBRecord.h"
34 #include "RDBAccessSvc/IRDBRecordset.h"
35 
36 #include "StoreGate/StoreGateSvc.h"
37 #include "GaudiKernel/MsgStream.h"
38 #include "GaudiKernel/Bootstrap.h"
39 #include "GaudiKernel/SystemOfUnits.h"
40 
41 // For run options :
42 #include "LArG4RunControl/LArGeoTBGeometricOptions.h"
43 
44 #include <string>
45 #include <cmath>
46 
47 // Handle Axis, for debug
48 #define AXIS_ON 0
49 
50 // The "database record" types.
51 using cryoEndcapCylDBRecord_t = struct {
52  int cylNumber;
53  GeoMaterial* mat;
54  double Rmin;
55  double Dr;
56  double Zmin;
57  double Dz;
58 };
59 
60 
61 LArGeo::LArDetectorConstructionTBEC::LArDetectorConstructionTBEC():
62 m_eta_pos(0),
63 m_eta_cell(0),
64 m_phi_pos(0),
65 m_phi_cell(0),
66 m_hasLeadCompensator(false),
67 m_hasPresampler(false),
68 m_ModuleRotation(0),
69 m_YShift(0),
70 m_tbecEnvelopePhysical(nullptr),
71 m_pAccessSvc(nullptr)
72 {;}
73 
74 void LArGeo::LArDetectorConstructionTBEC::getSimulationParameters()
75 {
76  m_eta_cell = 12;
77  m_phi_cell = 16;
78 
79  StoreGateSvc* detStore = nullptr;
80  const LArGeoTBGeometricOptions *largeotbgeometricoptions = nullptr;
81 
82  StatusCode status;
83  ISvcLocator* svcLocator = Gaudi::svcLocator();
84  IMessageSvc * msgSvc;
85  if(svcLocator->service("MessageSvc", msgSvc, true) == StatusCode::FAILURE){
86  throw std::runtime_error("Error in LArDetectorConstructionTBEC, cannot access MessageSvc");
87  }
88  MsgStream log(msgSvc, "LArGeo::LArDetectorConstructionTBEC");
89 
90  status = svcLocator->service("DetectorStore", detStore);
91 
92  if(status.isSuccess()){
93  status = detStore->retrieve(largeotbgeometricoptions, "LArGeoTBGeometricOptions");
94  if(!status.isFailure()){
95  m_eta_cell = largeotbgeometricoptions->CryoEtaPosition();
96  m_phi_cell = largeotbgeometricoptions->CryoPhiPosition();
97  } else {
98  log << MSG::WARNING
99  << "Can't access LArGeoTBGeometricOptions, using default values"
100  << endmsg;
101  }
102  } else {
103  throw std::runtime_error("LArDetectorConstructionTBEC: cannot initialize \
104 StoreGate interface");
105  }
106 
107  if ( m_eta_cell < 0.5 ) m_eta_pos = 0.05*( m_eta_cell + 0.5 ) + 1.375; // Cell 0 has double eta width
108  else if ( m_eta_cell > 43.5 ) m_eta_pos = 0.1*( m_eta_cell - 43.5 ) + 2.5; // Inner Wheel
109  else m_eta_pos = 0.025*( m_eta_cell - 0.5 ) + 1.425; // Outer Wheel
110 
111  if ( m_eta_cell <= 43.5 ) m_phi_pos = -( ( m_phi_cell - 16. )*1.40625 + 0.46875 )*Gaudi::Units::deg; // Outer Wheel
112  else m_phi_pos = -( 4*( m_phi_cell - 4. )*1.40625 + 0.46875 )*Gaudi::Units::deg; // Inner Wheel
113 
114 }
115 
116 LArGeo::LArDetectorConstructionTBEC::~LArDetectorConstructionTBEC() = default;
117 
118 PVLink LArGeo::LArDetectorConstructionTBEC::GetEnvelope()
119 {
120 
121  if (m_tbecEnvelopePhysical) return m_tbecEnvelopePhysical;
122 
123  ISvcLocator *svcLocator = Gaudi::svcLocator();
124  IMessageSvc * msgSvc;
125  if(svcLocator->service("MessageSvc", msgSvc, true) == StatusCode::FAILURE){
126  throw std::runtime_error("Error in LArDetectorConstructionTBEC, cannot access MessageSvc");
127  }
128 
129  MsgStream log(msgSvc, "LArGeo::LArDetectorConstructionTBEC");
130  StoreGateSvc *detStore;
131  if (svcLocator->service("DetectorStore", detStore, false )==StatusCode::FAILURE) {
132  throw std::runtime_error("Error in LArDetectorConstructionTBEC, cannot access DetectorStore");
133  }
134  StoredMaterialManager* materialManager = nullptr;
135  if (StatusCode::SUCCESS != detStore->retrieve(materialManager, std::string("MATERIALS"))) return nullptr;
136 
137  const GeoMaterial *Air = materialManager->getMaterial("std::Air");
138  if (!Air) {
139  throw std::runtime_error("Error in LArDetectorConstructionTBEC, std::Air is not found.");
140  }
141 
142  StatusCode sc;
143  sc=svcLocator->service("RDBAccessSvc",m_pAccessSvc);
144  if (sc != StatusCode::SUCCESS) {
145  throw std::runtime_error ("Cannot locate RDBAccessSvc!!");
146  }
147 
148  DecodeVersionKey larVersion("LAr");
149  const std::string& detectorKey = larVersion.tag();
150  const std::string& detectorNode = larVersion.node();
151 
152  // Default values....
153  m_hasLeadCompensator = false;
154  m_hasPresampler = false;
155  m_ModuleRotation = 0.*Gaudi::Units::deg;
156  m_YShift = 0.*Gaudi::Units::mm;
157 
158  IRDBRecordset_ptr tbecGeometry = m_pAccessSvc->getRecordsetPtr("TBECGeometry",detectorKey, detectorNode);
159  if ((*tbecGeometry).size()!=0) {
160  m_hasLeadCompensator = (*tbecGeometry)[0]->getInt("LEADCOMPENSATOR");
161  m_hasPresampler = (*tbecGeometry)[0]->getInt("PRESAMPLER");
162  m_ModuleRotation = (*tbecGeometry)[0]->getDouble("MODULEROTATION");
163  m_YShift = (*tbecGeometry)[0]->getDouble("YSHIFT");
164  }
165 
166  log << MSG::INFO << "LeadCompensator = ";
167  if(m_hasLeadCompensator) log << "true";
168  else log << "false";
169  log << endmsg;
170 
171  log << MSG::INFO << "Presampler = ";
172  if(m_hasPresampler) log << "true";
173  else log << "false";
174  log << endmsg;
175 
176  // Retrieve simulation parameters from Storegate
177  getSimulationParameters();
178 
179  std::string baseName = "LAr::TBEC::MotherVolume";
180 
181  GeoBox* tbecMotherShape = new GeoBox( 5.*Gaudi::Units::m, 5.*Gaudi::Units::m, 15.*Gaudi::Units::m );
182 
183  const GeoLogVol* tbecMotherLogical =
184  new GeoLogVol(baseName, tbecMotherShape, Air);
185 
186  m_tbecEnvelopePhysical = new GeoPhysVol(tbecMotherLogical);
187 
188  m_tbecEnvelopePhysical->add( new GeoNameTag("LArEndcapPos") );
189  m_tbecEnvelopePhysical->add( createEnvelope() );
190  return m_tbecEnvelopePhysical;
191 }
192 
193 GeoIntrusivePtr<GeoFullPhysVol> LArGeo::LArDetectorConstructionTBEC::createEnvelope()
194 {
195  // Get access to the material manager:
196 
197  ISvcLocator *svcLocator = Gaudi::svcLocator();
198  IMessageSvc * msgSvc;
199  if (svcLocator->service("MessageSvc", msgSvc, true )==StatusCode::FAILURE) {
200  throw std::runtime_error("Error in LArDetectorConstructionTBEC, cannot access MessageSvc");
201  }
202 
203  MsgStream log(msgSvc, "LArGeo::LArDetectorConstructionTBEC");
204  log << MSG::DEBUG << "createEnvelope() started" << endmsg;
205 
206 
207  StoreGateSvc *detStore;
208  if (svcLocator->service("DetectorStore", detStore, false )==StatusCode::FAILURE) {
209  throw std::runtime_error("Error in LArDetectorConstructionTBEC, cannot access DetectorStore");
210  }
211 
212  // Get the materials from the material manager:-----------------------------------------------------//
213  // //
214  StoredMaterialManager* materialManager = nullptr;
215  if (StatusCode::SUCCESS != detStore->retrieve(materialManager, std::string("MATERIALS"))) return nullptr;
216 
217  const GeoMaterial *Air = materialManager->getMaterial("std::Air");
218  if (!Air) throw std::runtime_error("Error in LArDetectorConstructionTBEC, std::Air is not found.");
219 
220  const GeoMaterial *Lead = materialManager->getMaterial("std::Lead");
221  if (!Lead) throw std::runtime_error("Error in LArDetectorConstructionTBEC, std::Lead is not found.");
222 
223 
224  // //
225  //-------------------------------------------------------------------------------------------------//
226  DecodeVersionKey larVersion("LAr");
227 
228 
230  // Define geometry
232 
233  // Set up strings for volume names.
234  std::string baseName = "LAr::TBEC";
235 
236  // Define the mother volume for the endcap cryostat. Everything
237  // else in the endcap (cryostat walls, detectors, etc.) should be
238  // placed inside here.
239 
240  // The position of this volume may change if the thickness of the
241  // cabling in front of the endcaps changes. Therefore, we must get
242  // the z-shift from the database and adjust the volume geometry
243  // accordingly.
244 
245  std::string tbecMotherName = baseName + "::MotherVolume";
246  GeoBox* tbecMotherShape = new GeoBox( 5.*Gaudi::Units::m, 5.*Gaudi::Units::m, 15.*Gaudi::Units::m );
247  const GeoLogVol* tbecMotherLogical = new GeoLogVol( tbecMotherName, tbecMotherShape, Air );
248  GeoIntrusivePtr<GeoFullPhysVol> tbecMotherPhysical = new GeoFullPhysVol( tbecMotherLogical );
249 
250  double xcent = -120.*Gaudi::Units::cm, zcent = 395.7*Gaudi::Units::cm;
251  double zfface = zcent - 60.09*Gaudi::Units::cm;
252  log << MSG::DEBUG << "eta = " << m_eta_pos;
253  if ( m_eta_pos > 5. ) m_eta_pos = 0.;
254  else m_eta_pos = 2*atan( exp( -m_eta_pos ) );
255  log << ", positioning cryostat with angle " << m_eta_pos*(1./Gaudi::Units::deg) << " Gaudi::Units::deg";
256  log << endmsg;
257 
258  // Tubular axis, dummy
259 
260  if ( AXIS_ON ) {
261 
262  double axisZHalfLength = 5*Gaudi::Units::m;
263 
264  GeoTube* axisShape = new GeoTube( 0.*Gaudi::Units::cm, 1.*Gaudi::Units::cm, axisZHalfLength );
265 
266  // x-axis
267  std::string XAxisName = baseName + "::XAxis";
268  const GeoLogVol* XAxisLogical = new GeoLogVol( XAxisName, axisShape, Air );
269  GeoIntrusivePtr<GeoPhysVol> XAxisPhysVol = new GeoPhysVol( XAxisLogical );
270 
271  tbecMotherPhysical->add( new GeoIdentifierTag( 1 ) );
272  tbecMotherPhysical->add( new GeoTransform( GeoTrf::Transform3D( GeoTrf::Translation3D( axisZHalfLength, 0.*Gaudi::Units::m, 0.*Gaudi::Units::m ) *GeoTrf::RotateY3D( 90.*Gaudi::Units::deg )) ) );
273  tbecMotherPhysical->add( XAxisPhysVol );
274 
275  // y-axis
276  std::string YAxisName = baseName + "::YAxis";
277  const GeoLogVol* YAxisLogical = new GeoLogVol( YAxisName, axisShape, Air );
278  GeoIntrusivePtr<GeoPhysVol> YAxisPhysVol = new GeoPhysVol( YAxisLogical );
279 
280  tbecMotherPhysical->add( new GeoIdentifierTag( 1 ) );
281  tbecMotherPhysical->add( new GeoTransform( GeoTrf::Transform3D( GeoTrf::Translation3D( 0.*Gaudi::Units::m, axisZHalfLength, 0.*Gaudi::Units::m )*GeoTrf::RotateX3D( -90.*Gaudi::Units::deg ) ) ) );
282  tbecMotherPhysical->add( YAxisPhysVol );
283 
284  //z-axis
285  std::string ZAxisName = baseName + "::ZAxis";
286  const GeoLogVol* ZAxisLogical = new GeoLogVol( ZAxisName, axisShape, Air );
287  GeoIntrusivePtr<GeoPhysVol> ZAxisPhysVol = new GeoPhysVol( ZAxisLogical );
288 
289  tbecMotherPhysical->add( new GeoIdentifierTag( 1 ) );
290  tbecMotherPhysical->add( new GeoTransform( GeoTrf::TranslateZ3D( axisZHalfLength ) ) );
291  tbecMotherPhysical->add( ZAxisPhysVol );
292  }
293 
294  // Lead compensator, Optionnal
295 
296  if ( m_hasLeadCompensator ) {
297  std::string CompensatorName = baseName + "::LeadCompensator";
298  GeoBox* CompensatorShape = new GeoBox( 152.*Gaudi::Units::cm, 195.*Gaudi::Units::cm, 0.56*Gaudi::Units::cm );
299  const GeoLogVol* CompensatorLogical = new GeoLogVol( CompensatorName, CompensatorShape, Lead );
300  GeoIntrusivePtr<GeoPhysVol> CompensatorPhysical = new GeoPhysVol( CompensatorLogical );
301 
302  tbecMotherPhysical->add( new GeoIdentifierTag( 1 ) );
303 
304  GeoTrf::Vector3D tmpvec1(xcent, 0., 300.*Gaudi::Units::cm);
305  GeoTrf::Vector3D tmpvec1Rotated = GeoTrf::RotateY3D(m_eta_pos)*tmpvec1;
306  GeoTrf::Translate3D tmpxf1(tmpvec1Rotated.x(),tmpvec1Rotated.y(),tmpvec1Rotated.z());
307  tbecMotherPhysical->add(new GeoTransform( tmpxf1 * GeoTrf::RotateY3D(m_eta_pos)));
308  tbecMotherPhysical->add( CompensatorPhysical );
309  }
310 
311  // Cryostat
312 
313  CryostatConstructionTBEC cryoConstruction;
314  GeoIntrusivePtr<GeoVFullPhysVol> cryoPhys = cryoConstruction.GetEnvelope();
315  GeoIntrusivePtr<GeoPhysVol> LArPhysical = cryoConstruction.GetLArPhysical();
316 
317  tbecMotherPhysical->add( new GeoIdentifierTag( 1 ) );
318  GeoTrf::Vector3D tmpvec2(xcent, 0., zcent);
319  GeoTrf::Vector3D tmpvec2Rotated = GeoTrf::RotateY3D(m_eta_pos)*tmpvec2;
320  GeoTrf::Translate3D tmpxf2(tmpvec2Rotated.x(),tmpvec2Rotated.y(),tmpvec2Rotated.z());
321  tbecMotherPhysical->add(new GeoTransform( tmpxf2 * GeoTrf::RotateY3D(m_eta_pos)));
322  tbecMotherPhysical->add( cryoPhys );
323 
324  // Beam chambers
325 
326  log << MSG::VERBOSE << "Creating beam chambers ..." << std::endl;
327 
328  const double beamCZ[ 4 ] = { 17.9*Gaudi::Units::m, 7.673*Gaudi::Units::m, 1.352*Gaudi::Units::m, .256*Gaudi::Units::m };
329  const double beamCSize = 11.*Gaudi::Units::cm, beamCTh = 28*Gaudi::Units::mm; // divided by 2, for half-length
330 
331  GeoBox* BeamCShape = new GeoBox( beamCSize, beamCSize, beamCTh );
332  for ( int i = 0; i < 4; i++ ) {
333  std::string BeamCName = baseName + "::BeamChamber";
334  BeamCName+= char( i ) + '0';
335  GeoLogVol* BeamCLogical = new GeoLogVol( BeamCName, BeamCShape, Air );
336  GeoIntrusivePtr<GeoPhysVol> BeamCPhysical = new GeoPhysVol( BeamCLogical );
337 
338  tbecMotherPhysical->add( new GeoIdentifierTag( 1 ) );
339  tbecMotherPhysical->add( new GeoTransform( GeoTrf::Translate3D( 0.*Gaudi::Units::cm, 0.*Gaudi::Units::cm, zfface - beamCZ[ i ] ) ) );
340  tbecMotherPhysical->add( BeamCPhysical );
341  }
342 
343  // End cap module
344  log << MSG::DEBUG << std::endl
345  << "Module deviation: " << m_ModuleRotation * (1./Gaudi::Units::deg) << " Gaudi::Units::deg" << std::endl
346  << "Phi position: " << m_phi_pos * (1./Gaudi::Units::deg) << " Gaudi::Units::deg" << std::endl
347  << "Y shift: " << m_YShift * (1./Gaudi::Units::mm) << " Gaudi::Units::mm"
348  << endmsg;
349 
350  // z = 0 in emecMother is at active region's front face
351 
352  EMECConstruction emecModuleConstruction( true, true, true );
353  GeoIntrusivePtr<GeoFullPhysVol>emecEnvelope= (GeoIntrusivePtr<GeoFullPhysVol>) emecModuleConstruction.GetEnvelope();
354  StoredPhysVol *sPhysVol = new StoredPhysVol(emecEnvelope);
355  StatusCode status=detStore->record(sPhysVol,"EMEC_POS");
356  if(!status.isSuccess()) throw std::runtime_error ("Cannot store EMEC_POS");
357 
358  GeoTrf::Transform3D Mrot(GeoTrf::RotateZ3D( m_phi_pos + 90*Gaudi::Units::deg)*GeoTrf::RotateY3D(m_ModuleRotation));
359  GeoTrf::Vector3D pos( -xcent, m_YShift, -51.4/2*Gaudi::Units::cm );
360 
361  if ( LArPhysical ) {
362 
363  LArPhysical->add( new GeoIdentifierTag( 1 ) );
364  LArPhysical->add( new GeoTransform( GeoTrf::Transform3D( GeoTrf::Translation3D(pos(0),pos(1),pos(2)))*Mrot ) );
365  LArPhysical->add( emecEnvelope );
366  }
367 
368  pos-= GeoTrf::Vector3D( 0.*Gaudi::Units::mm, 0.*Gaudi::Units::mm, 61.*Gaudi::Units::mm +2.*Gaudi::Units::mm +13.5*Gaudi::Units::mm );
369 
370  if ( m_hasPresampler ) {
371 
372  EndcapPresamplerConstruction PresamplerConstruction( true );
373  GeoIntrusivePtr<GeoFullPhysVol> PresamplerEnvelope = PresamplerConstruction.Envelope();
374 
375  StoredPhysVol *sPhysVol = new StoredPhysVol(PresamplerEnvelope);
376  StatusCode status=detStore->record(sPhysVol,"PRESAMPLER_EC_POS");
377  if(!status.isSuccess()) throw std::runtime_error ("Cannot store PRESAMPLER_EC_POS");
378 
379  if ( LArPhysical ) {
380 
381  LArPhysical->add( new GeoIdentifierTag( 1 ) );
382  LArPhysical->add( new GeoTransform( GeoTrf::Transform3D( GeoTrf::Translation3D(pos(0),pos(1),pos(2)))*Mrot ) );
383  LArPhysical->add( PresamplerEnvelope );
384  }
385  }
386 
387 return tbecMotherPhysical;
388 }
LArGeo::CryostatConstructionTBEC::GetEnvelope
virtual GeoIntrusivePtr< GeoVFullPhysVol > GetEnvelope()
Definition: CryostatConstructionTBEC.cxx:45
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
LArGeoTBGeometricOptions::CryoEtaPosition
void CryoEtaPosition(double value)
Definition: LArGeoTBGeometricOptions.h:34
LArGeo::LArDetectorConstructionTBEC::createEnvelope
GeoIntrusivePtr< GeoFullPhysVol > createEnvelope()
Definition: LArDetectorConstructionTBEC.cxx:193
mat
GeoMaterial * mat
Definition: LArDetectorConstructionTBEC.cxx:53
xAOD::char
char
Definition: TrigDecision_v1.cxx:38
LArGeo::LArDetectorConstructionTBEC::LArDetectorConstructionTBEC
LArDetectorConstructionTBEC()
Definition: LArDetectorConstructionTBEC.cxx:61
Zmin
double Zmin
Definition: LArDetectorConstructionTBEC.cxx:56
LArGeo::CryostatConstructionTBEC
Definition: CryostatConstructionTBEC.h:18
AXIS_ON
#define AXIS_ON
Definition: LArDetectorConstructionTBEC.cxx:48
LArGeo::LArDetectorConstructionTBEC::GetEnvelope
virtual PVLink GetEnvelope()
Definition: LArDetectorConstructionTBEC.cxx:118
deg
#define deg
Definition: SbPolyhedron.cxx:17
LArGeo::CryostatConstructionTBEC::GetLArPhysical
GeoIntrusivePtr< GeoPhysVol > GetLArPhysical()
Definition: CryostatConstructionTBEC.cxx:324
DecodeVersionKey::node
const std::string & node() const
Return the version node.
Definition: DecodeVersionKey.cxx:99
drawFromPickle.exp
exp
Definition: drawFromPickle.py:36
drawFromPickle.atan
atan
Definition: drawFromPickle.py:36
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
StoredPhysVol
Definition: StoredPhysVol.h:27
LArGeoTBGeometricOptions::CryoPhiPosition
void CryoPhiPosition(double value)
Definition: LArGeoTBGeometricOptions.h:35
LArGeo::LArDetectorConstructionTBEC::getSimulationParameters
void getSimulationParameters()
Definition: LArDetectorConstructionTBEC.cxx:74
cm
const double cm
Definition: Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/tools/FCAL_ChannelMap.cxx:25
StoreGateSvc
The Athena Transient Store API.
Definition: StoreGateSvc.h:128
IRDBAccessSvc.h
Definition of the abstract IRDBAccessSvc interface.
StdJOSetup.msgSvc
msgSvc
Provide convenience handles for various services.
Definition: StdJOSetup.py:35
lumiFormat.i
int i
Definition: lumiFormat.py:92
LArDetectorConstructionTBEC.h
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
Dz
double Dz
Definition: LArDetectorConstructionTBEC.cxx:57
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
DecodeVersionKey::tag
const std::string & tag() const
Return version tag.
Definition: DecodeVersionKey.cxx:93
IRDBRecordset_ptr
std::shared_ptr< IRDBRecordset > IRDBRecordset_ptr
Definition: IRDBAccessSvc.h:25
Dr
double Dr
Definition: LArDetectorConstructionTBEC.cxx:55
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
StoredMaterialManager.h
LArGeo::EMECConstruction
GeoModel description of the LAr EMEC envelope and the active part (custom shapes)
Definition: EMECConstruction.h:29
EndcapPresamplerConstruction
GeoModel description of the LAr Endcap Presampler geometry.
Definition: EndcapPresamplerConstruction.h:25
LArGeoTBGeometricOptions.h
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
DecodeVersionKey.h
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
cryoEndcapCylDBRecord_t
struct { int cylNumber cryoEndcapCylDBRecord_t
Definition: LArDetectorConstructionTBEC.cxx:52
python.SystemOfUnits.mm
int mm
Definition: SystemOfUnits.py:83
EndcapPresamplerConstruction.h
Declaration of EndcapPresamplerConstruction class.
IRDBRecord.h
Definition of the abstract IRDBRecord interface.
EndcapPresamplerConstruction::Envelope
GeoIntrusivePtr< GeoFullPhysVol > Envelope()
Definition: EndcapPresamplerConstruction.cxx:53
CryostatConstructionTBEC.h
DEBUG
#define DEBUG
Definition: page_access.h:11
Amg::Translation3D
Eigen::Translation< double, 3 > Translation3D
Definition: GeoPrimitives.h:44
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
StoredMaterialManager::getMaterial
virtual const GeoMaterial * getMaterial(const std::string &name)=0
StoredMaterialManager
This class holds one or more material managers and makes them storeable, under StoreGate.
Definition: StoredMaterialManager.h:28
Rmin
double Rmin
Definition: LArDetectorConstructionTBEC.cxx:54
LArGeo::LArDetectorConstructionTBEC::~LArDetectorConstructionTBEC
virtual ~LArDetectorConstructionTBEC()
merge.status
status
Definition: merge.py:17
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
IRDBRecordset.h
Definition of the abstract IRDBRecordset interface.
StoreGateSvc.h
EMECConstruction.h
Declaration of EMECConstruction class.
LArGeoTBGeometricOptions
Definition: LArGeoTBGeometricOptions.h:19
StoredPhysVol.h
Generated on Sun May 19 2024 21:19:59 for ATLAS Offline Software by   doxygen 1.8.18