ATLAS Offline Software
Public Member Functions | Private Attributes | List of all members
LArGeo::CryostatConstructionTBEC Class Reference

#include <CryostatConstructionTBEC.h>

Collaboration diagram for LArGeo::CryostatConstructionTBEC:

Public Member Functions

 CryostatConstructionTBEC ()
 
virtual ~CryostatConstructionTBEC ()
 
virtual GeoIntrusivePtr< GeoVFullPhysVol > GetEnvelope ()
 
GeoIntrusivePtr< GeoPhysVol > GetLArPhysical ()
 

Private Attributes

GeoFullPhysVol * m_cryoEnvelopePhysical
 
GeoPhysVol * m_LArPhysical
 

Detailed Description

Definition at line 17 of file CryostatConstructionTBEC.h.

Constructor & Destructor Documentation

◆ CryostatConstructionTBEC()

LArGeo::CryostatConstructionTBEC::CryostatConstructionTBEC ( )

Definition at line 38 of file CryostatConstructionTBEC.cxx.

38  :
39 m_cryoEnvelopePhysical(nullptr),
40 m_LArPhysical(nullptr)
41 {;}

◆ ~CryostatConstructionTBEC()

LArGeo::CryostatConstructionTBEC::~CryostatConstructionTBEC ( )
virtual

Definition at line 43 of file CryostatConstructionTBEC.cxx.

43 {;}

Member Function Documentation

◆ GetEnvelope()

GeoIntrusivePtr< GeoVFullPhysVol > LArGeo::CryostatConstructionTBEC::GetEnvelope ( )
virtual

Definition at line 45 of file CryostatConstructionTBEC.cxx.

46 {
47 
48  if (m_cryoEnvelopePhysical) return m_cryoEnvelopePhysical;
49 
50  // Get access to the material manager:
51 
52  ISvcLocator *svcLocator = Gaudi::svcLocator();
53  IMessageSvc * msgSvc;
54  if (svcLocator->service("MessageSvc", msgSvc, true )==StatusCode::FAILURE) {
55  throw std::runtime_error("Error in CryostatConstructionTBEC, cannot access MessageSvc");
56  }
57 
58  MsgStream log(msgSvc, "LArGeo::CryostatConstructionTBEC");
59 
60  log << "++++++++++++++++++++++++++++++++++++++++++++++++++++" << std::endl;
61  log << "+ +" << std::endl;
62  log << "+ HELLO from LArGeo::CryostatConstructionTBEC +" << std::endl;
63  log << "+ +" << std::endl;
64  log << "++++++++++++++++++++++++++++++++++++++++++++++++++++" << std::endl;
65 
66 
67  StoreGateSvc *detStore;
68  if (svcLocator->service("DetectorStore", detStore, false )==StatusCode::FAILURE) {
69  throw std::runtime_error("Error in CryostatConstructionTBEC, cannot access DetectorStore");
70  }
71 
72  // Get the materials from the material manager:-----------------------------------------------------//
73  // //
74  StoredMaterialManager* materialManager = nullptr;
75  if (StatusCode::SUCCESS != detStore->retrieve(materialManager, std::string("MATERIALS"))) return nullptr;
76 
77  const GeoMaterial *Air = materialManager->getMaterial("std::Air");
78  if (!Air) throw std::runtime_error("Error in CryostatConstructionTBEC, std::Air is not found.");
79 
80  const GeoMaterial *Al = materialManager->getMaterial("std::Aluminium");
81  if (!Al) throw std::runtime_error("Error in CryostatConstructionTBEC, std::Aluminium is not found.");
82 
83  const GeoMaterial *LAr = materialManager->getMaterial("std::LiquidArgon");
84  if (!LAr) throw std::runtime_error("Error in CryostatConstructionTBEC, std::LiquidArgon is not found.");
85 
86  const GeoMaterial *Iron = materialManager->getMaterial("std::Iron");
87  if (!Iron) throw std::runtime_error("Error in CryostatConstructionTBEC, std::Iron is not found.");
88 
89  const GeoMaterial *Gten = materialManager->getMaterial("LAr::G10");
90  if (!Gten) throw std::runtime_error("Error in CryostatConstructionTBEC, LAr::G10 is not found.");
91 
92  const GeoMaterial *Vacuum = materialManager->getMaterial("LAr::Vacuum");
93  if (!Vacuum) throw std::runtime_error("Error in CryostatConstructionTBEC, std::Vacuum is not found.");
94 
95  // //
96  //-------------------------------------------------------------------------------------------------//
97 
98 
100  // Define geometry
102 
103  // Set up strings for volume names.
104  std::string baseName = "LAr::TBEC::Cryostat";
105 
106  // Define the mother volume for the endcap cryostat. Everything
107  // else in the endcap (cryostat walls, detectors, etc.) should be
108  // placed inside here.
109 
110  // The position of this volume may change if the thickness of the
111  // cabling in front of the endcaps changes. Therefore, we must get
112  // the z-shift from the database and adjust the volume geometry
113  // accordingly.
114 
115  std::string cryoMotherName = baseName + "::MotherVolume";
116  GeoBox* cryoMotherShape = new GeoBox( 152.*Gaudi::Units::cm, 195.*Gaudi::Units::cm, 60.09*Gaudi::Units::cm );
117  const GeoLogVol* cryoMotherLogical = new GeoLogVol( cryoMotherName, cryoMotherShape, Air );
118  //GeoIntrusivePtr<GeoFullPhysVol> m_cryoEnvelopePhysical = new GeoFullPhysVol( cryoMotherLogical );
119  m_cryoEnvelopePhysical = new GeoFullPhysVol( cryoMotherLogical );
120 
121  // Cryostat walls
122 
123  std::string ExtWallName = baseName + "::ExternalWarmWall";
124  GeoBox* ExtWallShape = new GeoBox( 152.*Gaudi::Units::cm, 195.*Gaudi::Units::cm, 60.09*Gaudi::Units::cm );
125  const GeoLogVol* ExtWallLogical = new GeoLogVol( ExtWallName, ExtWallShape, Al );
126  GeoIntrusivePtr<GeoPhysVol> ExtWallPhysical = new GeoPhysVol( ExtWallLogical );
127 
128  std::string WallName = baseName + "::WarmWallInterval";
129  GeoBox* WallShape = new GeoBox( ( 152. - 0.8 )*Gaudi::Units::cm, ( 195. - 0.8 )*Gaudi::Units::cm, ( 60.09 - 0.8 )*Gaudi::Units::cm );
130  const GeoLogVol* WallLogical = new GeoLogVol( WallName, WallShape, Vacuum );
131  GeoIntrusivePtr<GeoPhysVol> WallPhysical = new GeoPhysVol( WallLogical );
132 
133  std::string IntWallName = baseName + "::InternalWarmWall";
134  GeoBox* IntWallShape = new GeoBox( 148.4*Gaudi::Units::cm, 191.6*Gaudi::Units::cm, 46.8*Gaudi::Units::cm );
135  const GeoLogVol* IntWallLogical = new GeoLogVol( IntWallName, IntWallShape, Al );
136  GeoIntrusivePtr<GeoPhysVol> IntWallPhysical = new GeoPhysVol( IntWallLogical );
137 
138  std::string VacuumName = baseName + "::Vacuum";
139  GeoBox* VacuumShape = new GeoBox( ( 148.4 - 0.8 )*Gaudi::Units::cm, ( 191.6 - 0.8 )*Gaudi::Units::cm, ( 46.8 - 0.8 )*Gaudi::Units::cm );
140  const GeoLogVol* VacuumLogical = new GeoLogVol( VacuumName, VacuumShape, Vacuum );
141  GeoIntrusivePtr<GeoPhysVol> VacuumPhysical = new GeoPhysVol( VacuumLogical );
142 
143  std::string ColdWallName = baseName + "::ColdWall";
144  GeoBox* ColdWallShape = new GeoBox( 142.5*Gaudi::Units::cm, 184.85*Gaudi::Units::cm, 38.*Gaudi::Units::cm );
145  const GeoLogVol* ColdWallLogical = new GeoLogVol( ColdWallName, ColdWallShape, Iron );
146  GeoIntrusivePtr<GeoPhysVol> ColdWallPhysical = new GeoPhysVol( ColdWallLogical );
147 
148  std::string LArName = baseName + "::LiquidArgon";
149  GeoBox* LArShape = new GeoBox( ( 142.5 - .5 )*Gaudi::Units::cm, ( 184.85 - .5 )*Gaudi::Units::cm, ( 38. - .5 )*Gaudi::Units::cm );
150  const GeoLogVol* LArLogical = new GeoLogVol( LArName, LArShape, LAr );
151  // GeoIntrusivePtr<GeoPhysVol> m_LArPhysical = new GeoPhysVol( LArLogical );
152  m_LArPhysical = new GeoPhysVol( LArLogical );
153 
154  ColdWallPhysical->add( new GeoIdentifierTag( 1 ) );
155  ColdWallPhysical->add( new GeoTransform( GeoTrf::Translate3D( 0.*Gaudi::Units::cm, 0.*Gaudi::Units::cm, 0.*Gaudi::Units::cm ) ) );
156  ColdWallPhysical->add( m_LArPhysical );
157 
158  VacuumPhysical->add( new GeoIdentifierTag( 1 ) );
159  VacuumPhysical->add( new GeoTransform( GeoTrf::Translate3D( 0.*Gaudi::Units::cm, 0.*Gaudi::Units::cm, 0.*Gaudi::Units::cm ) ) );
160  VacuumPhysical->add( ColdWallPhysical );
161 
162  IntWallPhysical->add( new GeoIdentifierTag( 1 ) );
163  IntWallPhysical->add( new GeoTransform( GeoTrf::Translate3D( 0.*Gaudi::Units::cm, 0.*Gaudi::Units::cm, 0.*Gaudi::Units::cm ) ) );
164  IntWallPhysical->add( VacuumPhysical );
165 
166  WallPhysical->add( new GeoIdentifierTag( 1 ) );
167  WallPhysical->add( new GeoTransform( GeoTrf::Translate3D( 0.*Gaudi::Units::cm, 0.*Gaudi::Units::cm, 0.*Gaudi::Units::cm ) ) );
168  WallPhysical->add( IntWallPhysical );
169 
170  ExtWallPhysical->add( new GeoIdentifierTag( 1 ) );
171  ExtWallPhysical->add( new GeoTransform( GeoTrf::Translate3D( 0.*Gaudi::Units::cm, 0.*Gaudi::Units::cm, 0.*Gaudi::Units::cm ) ) );
172  ExtWallPhysical->add( WallPhysical );
173 
174  m_cryoEnvelopePhysical->add( new GeoIdentifierTag( 1 ) );
175  m_cryoEnvelopePhysical->add( new GeoTransform( GeoTrf::Translate3D( 0.*Gaudi::Units::cm, 0.*Gaudi::Units::cm, 0.*Gaudi::Units::cm ) ) );
176  m_cryoEnvelopePhysical->add( ExtWallPhysical );
177 
178  // Pressure cone
179 
180  std::string PConeName = baseName + "::PressureCone::Mother";
181  GeoTubs* PConeShape = new GeoTubs( 0.*Gaudi::Units::cm, 6.5*Gaudi::Units::cm, 4.*Gaudi::Units::cm, 0.*Gaudi::Units::deg, 360.*Gaudi::Units::deg );
182  const GeoLogVol* PConeLogical = new GeoLogVol( PConeName, PConeShape, Vacuum );
183  GeoIntrusivePtr<GeoPhysVol> PConePhysical = new GeoPhysVol( PConeLogical );
184 
185  std::string IntFlangeName = baseName + "::PressureCone::InternalFlange";
186  GeoTubs* IntFlangeShape = new GeoTubs( 0.*Gaudi::Units::cm, 4.9*Gaudi::Units::cm, 0.4*Gaudi::Units::cm, 0.*Gaudi::Units::deg, 360.*Gaudi::Units::deg );
187  const GeoLogVol* IntFlangeLogical = new GeoLogVol( IntFlangeName, IntFlangeShape, Gten );
188  GeoIntrusivePtr<GeoPhysVol> IntFlangePhysical = new GeoPhysVol( IntFlangeLogical );
189 
190  std::string ExtFlangeName = baseName + "::PressureCone::ExternalFlange";
191  GeoTubs* ExtFlangeShape = new GeoTubs( 5.*Gaudi::Units::cm, 6.5*Gaudi::Units::cm, 0.4*Gaudi::Units::cm, 0.*Gaudi::Units::deg, 360.*Gaudi::Units::deg );
192  const GeoLogVol* ExtFlangeLogical = new GeoLogVol( ExtFlangeName, ExtFlangeShape, Gten );
193  GeoIntrusivePtr<GeoPhysVol> ExtFlangePhysical = new GeoPhysVol( ExtFlangeLogical );
194 
195  std::string ConeName = baseName + "::PressureCone::Cone";
196  GeoCons* ConeShape = new GeoCons( 5.4*Gaudi::Units::cm, 4.5*Gaudi::Units::cm, 5.5*Gaudi::Units::cm, 4.6*Gaudi::Units::cm, 3.2*Gaudi::Units::cm, 0.*Gaudi::Units::deg, 360.*Gaudi::Units::deg );
197  const GeoLogVol* ConeLogical = new GeoLogVol( ConeName, ConeShape, Gten );
198  GeoIntrusivePtr<GeoPhysVol> ConePhysical = new GeoPhysVol( ConeLogical );
199 
200  PConePhysical->add( new GeoIdentifierTag( 1 ) );
201  PConePhysical->add( new GeoTransform( GeoTrf::Translate3D( 0.*Gaudi::Units::cm, 0.*Gaudi::Units::cm, 3.6*Gaudi::Units::cm ) ) );
202  PConePhysical->add( IntFlangePhysical );
203 
204  PConePhysical->add( new GeoIdentifierTag( 1 ) );
205  PConePhysical->add( new GeoTransform( GeoTrf::Translate3D( 0.*Gaudi::Units::cm, 0.*Gaudi::Units::cm, -3.6*Gaudi::Units::cm ) ) );
206  PConePhysical->add( ExtFlangePhysical );
207 
208  PConePhysical->add( new GeoIdentifierTag( 1 ) );
209  PConePhysical->add( new GeoTransform( GeoTrf::Translate3D( 0.*Gaudi::Units::cm, 0.*Gaudi::Units::cm, 0.*Gaudi::Units::cm ) ) );
210  PConePhysical->add( ConePhysical );
211 
212  for ( int i = 0; i < 3; i++ ) for ( int j = 0; j < 13; j++ ) {
213  double x = 135.1*Gaudi::Units::cm - 19.3*( j + 1 )*Gaudi::Units::cm;
214  double y = 19.3*( i - 1 )*Gaudi::Units::cm;
215  VacuumPhysical->add( new GeoIdentifierTag( 1 + i*13 + j ) );
216  VacuumPhysical->add( new GeoTransform( GeoTrf::Translate3D( x, y, -42.*Gaudi::Units::cm ) ) );
217  VacuumPhysical->add( PConePhysical );
218  }
219 
220  // Zig-zag structure
221 
222  std::string ZigZagMotherName = baseName + "::ZigZag::Mother";
223  GeoBox* ZigZagMotherShape = new GeoBox( 130.*Gaudi::Units::cm, 15.*Gaudi::Units::cm, 6.45*Gaudi::Units::cm );
224  const GeoLogVol* ZigZagMotherLogical = new GeoLogVol( ZigZagMotherName, ZigZagMotherShape, Vacuum );
225  GeoIntrusivePtr<GeoPhysVol> ZigZagMotherPhysical = new GeoPhysVol( ZigZagMotherLogical );
226 
227  std::string ZigZagStrAName = baseName + "::ZigZag::StrA";
228  GeoBox* ZigZagStrAShape = new GeoBox( 2.45*Gaudi::Units::cm, 5.*Gaudi::Units::cm, .4*Gaudi::Units::cm );
229  const GeoLogVol* ZigZagStrALogical = new GeoLogVol( ZigZagStrAName, ZigZagStrAShape, Al );
230  GeoIntrusivePtr<GeoPhysVol> ZigZagStrAPhysical = new GeoPhysVol( ZigZagStrALogical );
231 
232  std::string ZigZagStrBName = baseName + "::ZigZag::StrB";
233  GeoBox* ZigZagStrBShape = new GeoBox( 8.53*Gaudi::Units::cm, 5.*Gaudi::Units::cm, .4*Gaudi::Units::cm );
234  const GeoLogVol* ZigZagStrBLogical = new GeoLogVol( ZigZagStrBName, ZigZagStrBShape, Al );
235  GeoIntrusivePtr<GeoPhysVol> ZigZagStrBPhysical = new GeoPhysVol( ZigZagStrBLogical );
236 
237  std::string ZigZagStrCName = baseName + "::ZigZag::StrC";
238  GeoTrd* ZigZagStrCShape = new GeoTrd( 1.03*Gaudi::Units::cm, .453*Gaudi::Units::cm, 5.*Gaudi::Units::cm, 5.*Gaudi::Units::cm, .283*Gaudi::Units::cm );
239  const GeoLogVol* ZigZagStrCLogical = new GeoLogVol( ZigZagStrCName, ZigZagStrCShape, Al );
240  GeoIntrusivePtr<GeoPhysVol> ZigZagStrCPhysical = new GeoPhysVol( ZigZagStrCLogical );
241 
242  std::string ZigZagStrDName = baseName + "::ZigZag::StrD";
243  GeoTrd* ZigZagStrDShape = new GeoTrd( .005*Gaudi::Units::cm, .31*Gaudi::Units::cm, 5.*Gaudi::Units::cm, 5.*Gaudi::Units::cm, .365*Gaudi::Units::cm );
244  const GeoLogVol* ZigZagStrDLogical = new GeoLogVol( ZigZagStrDName, ZigZagStrDShape, Al );
245  GeoIntrusivePtr<GeoPhysVol> ZigZagStrDPhysical = new GeoPhysVol( ZigZagStrDLogical );
246 
247  int StrAIdTag = 1;
248 
249  for ( int i = 0; i < 9; i++ ) {
250  ZigZagMotherPhysical->add( new GeoIdentifierTag( StrAIdTag ) );
251  ZigZagMotherPhysical->add( new GeoTransform( GeoTrf::Translate3D( ( 124.4 - 31.1*i )*Gaudi::Units::cm, 0.*Gaudi::Units::cm, 6.05*Gaudi::Units::cm ) ) );
252  ZigZagMotherPhysical->add( ZigZagStrAPhysical );
253  StrAIdTag++;
254  }
255  for ( int j = 0; j < 2; j++ ) for ( int i = 0; i < 8; i++ ) {
256  ZigZagMotherPhysical->add( new GeoIdentifierTag( StrAIdTag ) );
257  ZigZagMotherPhysical->add( new GeoTransform( GeoTrf::Translate3D( ( 108.85 - 31.1*i )*Gaudi::Units::cm, ( 2*j - 1 )*10.*Gaudi::Units::cm, 6.05*Gaudi::Units::cm ) ) );
258  ZigZagMotherPhysical->add( ZigZagStrAPhysical );
259  StrAIdTag++;
260  }
261 
262  int StrBIdTag = 1;
263  const double xB1[ 2 ] = { ( -6.77 + 108.85 )*Gaudi::Units::cm, ( 6.77 + 108.85 )*Gaudi::Units::cm };
264  const double xB2[ 2 ] = { ( -6.77 + 124.4 )*Gaudi::Units::cm, ( 6.77 + 93.3 )*Gaudi::Units::cm };
265  const double alpha[ 2 ] = { 45.*Gaudi::Units::deg, -45.*Gaudi::Units::deg };
266 
267  for ( int k = 0; k < 2; k++ ) for ( int i = 0; i < 8; i++ ) {
268  ZigZagMotherPhysical->add( new GeoIdentifierTag( StrBIdTag ) );
269  ZigZagMotherPhysical->add( new GeoTransform( GeoTrf::Transform3D(GeoTrf::Translate3D( xB1[ k ] - 31.1*i*Gaudi::Units::cm, 0.*Gaudi::Units::cm, -.1*Gaudi::Units::cm )*GeoTrf::RotateY3D( alpha[ k ] ) ) ) );
270  ZigZagMotherPhysical->add( ZigZagStrBPhysical );
271  StrBIdTag++;
272 
273  for ( int j = 0; j < 2; j++ ) {
274  ZigZagMotherPhysical->add( new GeoIdentifierTag( StrBIdTag ) );
275  ZigZagMotherPhysical->add( new GeoTransform( GeoTrf::Transform3D( GeoTrf::Translate3D( xB2[ k ] - 31.1*i*Gaudi::Units::cm, ( -10. + 20.*j )*Gaudi::Units::cm, -.1*Gaudi::Units::cm ) *GeoTrf::RotateY3D( alpha[ k ] )) ) );
276  ZigZagMotherPhysical->add( ZigZagStrBPhysical );
277  StrBIdTag++;
278  }
279  }
280 
281  int StrCIdTag = 1;
282 
283  for ( int i = 0; i < 9; i++ ) {
284  if ( i < 8 ) {
285  ZigZagMotherPhysical->add( new GeoIdentifierTag( StrCIdTag ) );
286  ZigZagMotherPhysical->add( new GeoTransform( GeoTrf::Translate3D( ( 108.85 - 31.1*i )*Gaudi::Units::cm, 0.*Gaudi::Units::cm, -6.15*Gaudi::Units::cm ) ) );
287  ZigZagMotherPhysical->add( ZigZagStrCPhysical );
288  StrCIdTag++;
289  }
290  for ( int j = 0; j < 2; j++ ) {
291  ZigZagMotherPhysical->add( new GeoIdentifierTag( StrCIdTag ) );
292  ZigZagMotherPhysical->add( new GeoTransform( GeoTrf::Translate3D( ( 124.4 - 31.1*i )*Gaudi::Units::cm, ( -10. + 20.*j )*Gaudi::Units::cm, -6.15*Gaudi::Units::cm ) ) );
293  ZigZagMotherPhysical->add( ZigZagStrCPhysical );
294  StrCIdTag++;
295  }
296  }
297 
298  int StrDIdTag = 1;
299  const double xD1[ 2 ] = { ( -2.598 + 124.4 )*Gaudi::Units::cm, ( 2.598 + 124.4 )*Gaudi::Units::cm };
300  const double xD2[ 2 ] = { ( -2.598 + 108.85 )*Gaudi::Units::cm, ( 2.598 + 108.85 )*Gaudi::Units::cm };
301  const double beta[ 2 ] = { -22.5*Gaudi::Units::deg, 22.5*Gaudi::Units::deg };
302 
303  for ( int k = 0; k < 2; k++ ) for ( int i = 0; i < 9; i++ ) {
304  ZigZagMotherPhysical->add( new GeoIdentifierTag( StrDIdTag ) );
305  ZigZagMotherPhysical->add( new GeoTransform( GeoTrf::Transform3D( GeoTrf::Translate3D( xD1[ k ] - 31.1*i*Gaudi::Units::cm, 0.*Gaudi::Units::cm, 5.995*Gaudi::Units::cm ) *GeoTrf::RotateY3D( beta[ k ] )) ) );
306  ZigZagMotherPhysical->add( ZigZagStrDPhysical );
307  StrDIdTag++;
308 
309  if ( i < 8 ) for ( int j = 0; j < 2; j++ ) {
310  ZigZagMotherPhysical->add( new GeoIdentifierTag( StrDIdTag ) );
311  ZigZagMotherPhysical->add( new GeoTransform( GeoTrf::Transform3D( GeoTrf::Translate3D( xD2[ k ] - 31.1*i*Gaudi::Units::cm, ( -10. +20.*j )*Gaudi::Units::cm, 5.995*Gaudi::Units::cm ) *GeoTrf::RotateY3D( beta[ k ] )) ) );
312  ZigZagMotherPhysical->add( ZigZagStrDPhysical );
313  StrDIdTag++;
314  }
315  }
316 
317  WallPhysical->add( new GeoIdentifierTag( 1 ) );
318  WallPhysical->add( new GeoTransform( GeoTrf::Translate3D( 0.*Gaudi::Units::cm, 0.*Gaudi::Units::cm, -53.2*Gaudi::Units::cm ) ) );
319  WallPhysical->add( ZigZagMotherPhysical );
320 
321 return m_cryoEnvelopePhysical;
322 }

◆ GetLArPhysical()

GeoIntrusivePtr< GeoPhysVol > LArGeo::CryostatConstructionTBEC::GetLArPhysical ( )

Definition at line 324 of file CryostatConstructionTBEC.cxx.

325 {
326  return m_LArPhysical;
327 }

Member Data Documentation

◆ m_cryoEnvelopePhysical

GeoFullPhysVol* LArGeo::CryostatConstructionTBEC::m_cryoEnvelopePhysical
private

Definition at line 32 of file CryostatConstructionTBEC.h.

◆ m_LArPhysical

GeoPhysVol* LArGeo::CryostatConstructionTBEC::m_LArPhysical
private

Definition at line 33 of file CryostatConstructionTBEC.h.

The documentation for this class was generated from the following files:
LArGeo::CryostatConstructionTBEC::m_cryoEnvelopePhysical
GeoFullPhysVol * m_cryoEnvelopePhysical
Definition: CryostatConstructionTBEC.h:32
LAr
Definition: LArVolumeBuilder.h:36
deg
#define deg
Definition: SbPolyhedron.cxx:17
x
#define x
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
StdJOSetup.msgSvc
msgSvc
Provide convenience handles for various services.
Definition: StdJOSetup.py:36
lumiFormat.i
int i
Definition: lumiFormat.py:92
LArGeo::CryostatConstructionTBEC::m_LArPhysical
GeoPhysVol * m_LArPhysical
Definition: CryostatConstructionTBEC.h:33
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
y
#define y
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
MuonParameters::beta
@ beta
Definition: MuonParamDefs.h:144
fitman.k
k
Definition: fitman.py:528
Generated on Tue Jul 2 2024 22:19:01 for ATLAS Offline Software by   doxygen 1.8.18