ATLAS Offline Software
ZDC_ZDCModule.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "ZDC_ZDCModule.h"
6 
7 #include "GeoModelKernel/GeoElement.h"
8 #include "GeoModelKernel/GeoBox.h"
9 #include "GeoModelKernel/GeoTube.h"
10 #include "GeoModelKernel/GeoLogVol.h"
11 #include "GeoModelKernel/GeoNameTag.h"
12 #include "GeoModelKernel/GeoPhysVol.h"
13 #include "GeoModelKernel/GeoFullPhysVol.h"
14 #include "GeoModelKernel/GeoIdentifierTag.h"
15 #include "GeoModelKernel/GeoAlignableTransform.h"
16 #include "GeoModelKernel/GeoDefinitions.h"
17 #include "GeoModelKernel/Units.h"
18 #include "GaudiKernel/SystemOfUnits.h"
19 #include "StoreGate/StoreGateSvc.h"
20 #include "GeoModelInterfaces/StoredMaterialManager.h"
21 #include "GeoModelKernel/GeoMaterial.h"
22 
23 
24 #include "AthenaKernel/getMessageSvc.h"
25 #include "CLHEP/Geometry/Transform3D.h"
26 
27 ZDC_ZDCModule::ZDC_ZDCModule()
28  : ZDC_ModuleBase(),
29  m_modType(1)
30 {
31 }
32 
33 ZDC_ZDCModule::ZDC_ZDCModule(StoreGateSvc *detStore, int side, int module, const ZdcID *zdcID, int modType)
34  : ZDC_ModuleBase(detStore, side, module, zdcID),
35  m_modType(modType)
36 {
37 }
38 
39 ZDC_ZDCModule::ZDC_ZDCModule(ZDC_ZDCModule *right, int side, int module)
40  : ZDC_ModuleBase((ZDC_ModuleBase*)right, side, module)
41 {
42  m_modType = right->m_modType;
43 }
44 
45 
46 void ZDC_ZDCModule::create(GeoFullPhysVol* mother, GeoAlignableTransform* trf){
47 
48  MsgStream LogStream(Athena::getMessageSvc(), "ZDC_ZDCModule::create");
49 
50  StoredMaterialManager *materialManager = nullptr;
51  if (StatusCode::SUCCESS != m_detectorStore->retrieve(materialManager, "MATERIALS")) {
52  MsgStream LogStream(Athena::getMessageSvc(), "ZDC_ZDCModule::create");
53  LogStream << MSG::ERROR << "execute: Could not retrieve StoredMaterialManager object from the detector store" << endmsg;
54  return;
55  }
56 
57  const GeoMaterial *OpAir = materialManager->getMaterial("ZDC::opticalAir" );
58  const GeoMaterial *OpSilica = materialManager->getMaterial("ZDC::opticalSilica");
59  const GeoMaterial *Silica = materialManager->getMaterial("std::Quartz" );
60  const GeoMaterial *Tungsten = materialManager->getMaterial("ZDC::Tungsten" );
61  const GeoMaterial *Steel = materialManager->getMaterial("ZDC::Steel" );
62 
63  // geometric constants. All units are in millimeters unless otherwise specified.
64  // All dimensions are gathered from technical drawings available at TODO: insert link to tech drawings
65 
66  // Dimensions determined by the pixel modules
67  // Both modules with pixels equipped and without have features determined by the pixel geometry, namely the gap number and spacing between
68  // groups of vertical radiator rods
69  const float pixelPitch = 10.3; // pixel rod pitch in both x and y
70  const float pixelGap = 1.2; // distance between the main fiber channels for the pixel fibers to be routed
71  const float pixelRodDia = 1.0; // diameter of the quartz rods used for the pixel
72  const float pixelHoleDia = 1.35; // diameter of the holes drilled in the tungsten plates which the pixel rods pass through
73  const int nPixelHolesX = 8; // number of positions for pixel rods in x (May or may not contain a quartz rod)
74  const int nPixelHolesY = 16; // number of positions for pixel rods in y (May or may not contain a quartz rod)
75  const float firstPixelX = -pixelPitch * (nPixelHolesX - 1) * 0.5; // Position of the outter most pixel placement in x
76  const float firstPixelY = -pixelPitch * (nPixelHolesY - 1) * 0.5; // Position of the lowest pixel placement in y
77 
78 
79  // These dimensions exist independent of the pixels (Though some still involve pixel dimensions for inter compatibility)
80  const float radiator_gap_depth = 2.0; // Depth of the radiator gap
81  const int nRadGaps = 12; // number of radiator gaps
82  const float strip_diameter = 1.5; // Diameter of the vertical quartz rods
83  const float absorber_width = 89.57; // Width (x) of the tungsten absorber
84  const float absorber_depth = 10.0; // Depth (z) of the tungsten absorber
85  const float absorber_height = 180.0; // Height (y) of the tungsten absorber
86  const float wallThicknessFront = 10.0; // Depth (z) of the steel case wall closest to the IP
87  const float wallThicknessSide = 1.21; // Thickness of the side walls (x) of the module
88  const float floorThickness = 1.21; // Thickness of the bottom of the module
89  const float zPitch = radiator_gap_depth + absorber_depth; // tungsten plate/quartz rod pitch in z
90  const float strip_gap_center = pixelPitch - pixelGap; // Width of the center channels for quartz rods
91  const float strip_gap_edge = (absorber_width - pixelPitch * (nPixelHolesX - 1) - pixelGap) * 0.5; // Width of the edge channels for quartz rods
92  const int nRods_center_gap = 6; // Number of rods in the center gaps
93  const int nRods_edge_gap = 5; // Number of rods in the edge gaps
94  const float housing_width = absorber_width + 2 * wallThicknessSide; // Width (x) of the steel module case
95  const float housing_height = absorber_height + floorThickness; // Height (y) of the steel module case
96 
97 
98  // These dimensions are for the default module type 1, but are modified by the presence of pixels
99  float zBackCavity = 0.0; // extra air cavity for pixel rods routing to the readout
100  float wallThicknessBack = 10.0; // Depth (z) of the steel case wall furthest from the IP
101  float rearCoverThickness = 0.0; // Thickness of additional rear cover for pixel modules
102  int pixelStart = 0, pixelStop = 0; // Start and stop rows for pixel rods
103 
104  //Set the dimensions for module type 2 or 3
105  switch (m_modType){
106  case 1: //type 1 (no pixel)
107  break;
108  case 2: //type 2 (pixel)
109  pixelStop = 9;
110  wallThicknessBack = 8.0;
111  rearCoverThickness = 1.21;
112  zBackCavity = 28;
113  break;
114  case 3: //type 3 (Bigger back cavity)
115  pixelStart = 1;
116  pixelStop = 8;
117  wallThicknessBack = 8.0;
118  rearCoverThickness = 1.21;
119  zBackCavity = 102;
120  break;
121  default:
122  LogStream << MSG::ERROR << "Invalid module type: " << m_modType << endmsg;
123  return;
124  }
125 
126 
127  // Finally calculate the total module z depth
128  const float housing_depth = (nRadGaps - 1) * zPitch + radiator_gap_depth + wallThicknessFront + wallThicknessBack + zBackCavity + rearCoverThickness;
129 
130  /*************************************************
131  * Create the volumes that are used independent of
132  * module type
133  **************************************************/
134  GeoTube *Strip_Tube = new GeoTube (0.0 * Gaudi::Units::mm , strip_diameter * Gaudi::Units::mm * 0.5, absorber_height * Gaudi::Units::mm * 0.5);
135  GeoBox *Steel_Box = new GeoBox (housing_width * Gaudi::Units::mm * 0.5, housing_height * Gaudi::Units::mm * 0.5, housing_depth * Gaudi::Units::mm * 0.5);
136  GeoBox *RadGap_Box = new GeoBox (absorber_width * Gaudi::Units::mm * 0.5, absorber_height * Gaudi::Units::mm * 0.5, radiator_gap_depth * Gaudi::Units::mm * 0.5);
137  GeoBox *Abs_Box = new GeoBox (absorber_width * Gaudi::Units::mm * 0.5, absorber_height * Gaudi::Units::mm * 0.5, absorber_depth * Gaudi::Units::mm * 0.5);
138 
139  GeoLogVol *Strip_Logical = new GeoLogVol("Strip_Logical" , Strip_Tube , OpSilica );
140  GeoLogVol *Steel_Logical = new GeoLogVol("Steel_Logical" , Steel_Box , Steel );
141  GeoLogVol *RadGap_Logical = new GeoLogVol("RadGap_Logical" , RadGap_Box , OpAir );
142  GeoLogVol *Abs_Plate_Logical = new GeoLogVol("Abs_Plate_Logical" , Abs_Box , Tungsten );
143 
144  GeoFullPhysVol *Housing_Physical = new GeoFullPhysVol(Steel_Logical );
145  GeoFullPhysVol *Abs_Plate = new GeoFullPhysVol(Abs_Plate_Logical);
146  GeoFullPhysVol *RadiatorGap = new GeoFullPhysVol(RadGap_Logical );
147 
148  // Surrogate ID and string to give the volumes dynamic references
149  Identifier id;
150  char volName[256];
151 
152  /*************************************************
153  * Pre-assemble tungsten plates, radiator gaps, and
154  * steel housing with pixel holes and rods if applicable
155  **************************************************/
156  if(m_modType > 1){
157 
158  // Z position of the inner wall that the pixel rods pass through
159  const float inner_wall_z = -0.5 * housing_depth + wallThicknessFront + (nRadGaps - 1) * zPitch + radiator_gap_depth + 0.5 * wallThicknessBack ;
160 
161  GeoTube *Pixel_Rod_Abs = new GeoTube ( 0.0 * Gaudi::Units::mm , pixelRodDia * Gaudi::Units::mm * 0.5 , absorber_depth * Gaudi::Units::mm * 0.5 );
162  GeoTube *Pixel_Rod_Rad = new GeoTube ( 0.0 * Gaudi::Units::mm , pixelRodDia * Gaudi::Units::mm * 0.5 , radiator_gap_depth * Gaudi::Units::mm * 0.5 );
163  GeoTube *Pixel_Rod_Housing = new GeoTube ( 0.0 * Gaudi::Units::mm , pixelRodDia * Gaudi::Units::mm * 0.5 , wallThicknessBack * Gaudi::Units::mm * 0.5 );
164  GeoTube *Pixel_Hole_Abs = new GeoTube ( 0.0 * Gaudi::Units::mm , pixelHoleDia * Gaudi::Units::mm * 0.5 , absorber_depth * Gaudi::Units::mm * 0.5 );
165  GeoTube *Pixel_Hole_Housing = new GeoTube ( 0.0 * Gaudi::Units::mm , pixelHoleDia * Gaudi::Units::mm * 0.5 , wallThicknessBack * Gaudi::Units::mm * 0.5 );
166  GeoBox *Pixel_Routing_Box = new GeoBox (absorber_width * Gaudi::Units::mm* 0.5, absorber_height * Gaudi::Units::mm * 0.5 , zBackCavity * Gaudi::Units::mm * 0.5 );
167 
168  GeoLogVol *Pixel_Abs_Logical = new GeoLogVol("Pixel_Abs_Logical" , Pixel_Rod_Abs , Silica );
169  GeoLogVol *Pixel_Rad_Logical = new GeoLogVol("Pixel_Rad_Logical" , Pixel_Rod_Rad , Silica );
170  GeoLogVol *Pixel_House_Logical = new GeoLogVol("Pixel_House_Logical" , Pixel_Rod_Housing , Silica );
171  GeoLogVol *Pixel_Hole_Abs_Logical = new GeoLogVol("Pixel_Hole_Logical" , Pixel_Hole_Abs , OpAir );
172  GeoLogVol *Pixel_Hole_House_Logical = new GeoLogVol("Pixel_Hole_House_Logical" , Pixel_Hole_Housing , OpAir );
173  GeoLogVol *Pixel_Routing_Logical = new GeoLogVol("Pixel_Routing_Logical" , Pixel_Routing_Box , OpAir );
174 
175 
176  /*************************************************
177  * Place the cavity the pixel rods are routed in
178  **************************************************/
179  id = m_zdcID->channel_id(m_side,m_module,ZdcIDType::INACTIVE,ZdcIDVolChannel::AIR);
180  sprintf(volName, "ZDC::Pixel_Routing %s", id.getString().c_str());
181  Housing_Physical->add(new GeoNameTag(volName));
182  Housing_Physical->add(new GeoIdentifierTag(id.get_identifier32().get_compact()));
183  Housing_Physical->add(new GeoAlignableTransform(GeoTrf::Translate3D(0.0, 0.5 * floorThickness * Gaudi::Units::mm, (housing_depth * 0.5 - rearCoverThickness - zBackCavity * 0.5) * Gaudi::Units::mm)));
184  Housing_Physical->add(new GeoFullPhysVol(Pixel_Routing_Logical));
185 
186  /*************************************************
187  * Make unpopulated and populated holes for the
188  * tungsten plates
189  **************************************************/
190  GeoFullPhysVol *Pixel_Hole_Abs_Empty = new GeoFullPhysVol(Pixel_Hole_Abs_Logical);
191 
192  GeoFullPhysVol *Pixel_Hole_Abs_Filled = new GeoFullPhysVol(Pixel_Hole_Abs_Logical);
193  id = m_zdcID->channel_id(m_side,m_module,ZdcIDType::INACTIVE,ZdcIDVolChannel::PIXEL);
194  sprintf(volName, "ZDC::Pixel %s", id.getString().c_str());
195  Pixel_Hole_Abs_Filled->add(new GeoNameTag(volName));
196  Pixel_Hole_Abs_Filled->add(new GeoIdentifierTag(id.get_identifier32().get_compact()));
197  Pixel_Hole_Abs_Filled->add(new GeoFullPhysVol(Pixel_Abs_Logical));
198 
199  /*************************************************
200  * Make unpopulated and populated holes for the
201  * inner wall
202  **************************************************/
203  GeoFullPhysVol *Pixel_Hole_House_Empty = new GeoFullPhysVol(Pixel_Hole_House_Logical);
204 
205  GeoFullPhysVol *Pixel_Hole_House_Filled = new GeoFullPhysVol(Pixel_Hole_House_Logical);
206  id = m_zdcID->channel_id(m_side,m_module,ZdcIDType::INACTIVE,ZdcIDVolChannel::PIXEL);
207  sprintf(volName, "ZDC::Pixel %s", id.getString().c_str());
208  Pixel_Hole_House_Filled->add(new GeoNameTag(volName));
209  Pixel_Hole_House_Filled->add(new GeoIdentifierTag(id.get_identifier32().get_compact()));
210  Pixel_Hole_House_Filled->add(new GeoFullPhysVol(Pixel_House_Logical));
211 
212  /*************************************************
213  * Make a pixel rod for the radiator gaps
214  **************************************************/
215  GeoFullPhysVol *Pixel_Rad = new GeoFullPhysVol(Pixel_Rad_Logical);
216 
217  // Populate the absorber, air gaps, and inner housing with the pixel rods and holes
218  for (int rodChannel = 0; rodChannel < nPixelHolesX; ++rodChannel){
219  float pixelX = firstPixelX + pixelPitch * rodChannel;
220 
221  for (int pixelLayer = 0; pixelLayer <= nPixelHolesY; ++pixelLayer){
222  float pixelY = firstPixelY + pixelPitch * pixelLayer;
223 
224  if (pixelLayer >= pixelStart && pixelLayer <= pixelStop){//Populated holes
225  // Place pixel rods in the radiator gaps
226  id = m_zdcID->channel_id(m_side,m_module,ZdcIDType::INACTIVE,ZdcIDVolChannel::PIXEL);
227  sprintf(volName, "ZDC::Pixel_Rad %s", id.getString().c_str());
228  RadiatorGap->add(new GeoNameTag(volName));
229  RadiatorGap->add(new GeoIdentifierTag(id.get_identifier32().get_compact()));
230  RadiatorGap->add(new GeoAlignableTransform(GeoTrf::Translate3D(pixelX * Gaudi::Units::mm, pixelY * Gaudi::Units::mm, 0.0 * Gaudi::Units::mm)));
231  RadiatorGap->add(Pixel_Rad);
232 
233  // Place a pixel rod in the tungsten plate
234  sprintf(volName, "ZDC::Pixel_Abs %s", id.getString().c_str());
235  Abs_Plate->add(new GeoNameTag(volName));
236  Abs_Plate->add(new GeoIdentifierTag(id.get_identifier32().get_compact()));
237  Abs_Plate->add(new GeoAlignableTransform(GeoTrf::Translate3D(pixelX * Gaudi::Units::mm, pixelY * Gaudi::Units::mm, 0.0 * Gaudi::Units::mm)));
238  Abs_Plate->add(Pixel_Hole_Abs_Filled);
239 
240  // Place a pixel rod in the inner housing
241  id = m_zdcID->channel_id(m_side,m_module,ZdcIDType::INACTIVE,ZdcIDVolChannel::AIR);
242  sprintf(volName, "ZDC::Pixel_Housing %s", id.getString().c_str());
243  Housing_Physical->add(new GeoNameTag(volName));
244  Housing_Physical->add(new GeoIdentifierTag(id.get_identifier32().get_compact()));
245  Housing_Physical->add(new GeoAlignableTransform(GeoTrf::Translate3D(pixelX * Gaudi::Units::mm, 0.5 * floorThickness + pixelY * Gaudi::Units::mm, inner_wall_z * Gaudi::Units::mm)));
246  Housing_Physical->add(Pixel_Hole_House_Filled);
247 
248  }else{// Unpopulated holes
249  id = m_zdcID->channel_id(m_side,m_module,ZdcIDType::INACTIVE,ZdcIDVolChannel::AIR);
250  sprintf(volName, "ZDC::Pixel_Hole %s", id.getString().c_str());
251 
252  // Place an unpopulated hole in the tungsten plate
253  Abs_Plate->add(new GeoNameTag(volName));
254  Abs_Plate->add(new GeoIdentifierTag(id.get_identifier32().get_compact()));
255  Abs_Plate->add(new GeoAlignableTransform(GeoTrf::Translate3D(pixelX * Gaudi::Units::mm, pixelY * Gaudi::Units::mm, 0.0 * Gaudi::Units::mm)));
256  Abs_Plate->add(Pixel_Hole_Abs_Empty);
257 
258  // Place an unpopulated hole in the housing
259  Housing_Physical->add(new GeoNameTag(volName));
260  Housing_Physical->add(new GeoIdentifierTag(id.get_identifier32().get_compact()));
261  Housing_Physical->add(new GeoAlignableTransform(GeoTrf::Translate3D(pixelX * Gaudi::Units::mm, 0.5 * floorThickness + pixelY * Gaudi::Units::mm, inner_wall_z * Gaudi::Units::mm)));
262  Housing_Physical->add(Pixel_Hole_House_Empty);
263  }
264  } // end loop over pixel y placement
265  }// end loop over pixel x placement
266  }// end if pixel module
267 
268 
269 
270  /*************************************************
271  * Place the pre-assembled tungsten plates and
272  * radiator gaps in the steel housing. Also,
273  * add the vertical quartz rods to the radiator gaps
274  **************************************************/
275  for (int radGap = 0; radGap < nRadGaps; ++radGap){
276  float zRadGap = -housing_depth * 0.5 + wallThicknessFront + radiator_gap_depth * 0.5 + zPitch * radGap;
277  float zAbsorber = zRadGap + radiator_gap_depth * 0.5 + absorber_depth * 0.5;
278 
279  /*************************************************
280  * Place tungsten plates
281  **************************************************/
282  if (radGap != nRadGaps - 1){ // Don't place a tungsten plate after the last radiator gap
283  id = m_zdcID->channel_id(m_side,m_module,ZdcIDType::INACTIVE,ZdcIDVolChannel::TUNGSTEN);
284  sprintf(volName, "ZDC::W_Mod %s", id.getString().c_str());
285  Housing_Physical->add(new GeoNameTag(volName));
286  Housing_Physical->add(new GeoIdentifierTag(id.get_identifier32().get_compact()));
287  Housing_Physical->add(new GeoAlignableTransform(GeoTrf::Translate3D(0.0, 0.5 * floorThickness * Gaudi::Units::mm, zAbsorber * Gaudi::Units::mm)));
288  Housing_Physical->add(Abs_Plate);
289  }
290 
291  /*************************************************
292  * Place vertical quartz rods
293  **************************************************/
294 
295  // Clone the air gap so we can place rods in the clone
296  // Unless it's the last volume, then we can just use the original
297  // so GeoModel can take ownership of it
298  GeoFullPhysVol *thisRadGap = (radGap == nRadGaps - 1) ? RadiatorGap : RadiatorGap->clone(false);
299 
300  for (int rodChannel = 0; rodChannel < nPixelHolesX + 1; ++rodChannel){
301  //Default values are for central gaps
302  int nRods = nRods_center_gap;
303  float rodPitch = strip_gap_center / nRods;
304  float startX = pixelPitch * (-(nPixelHolesX - 1) * 0.5 + rodChannel - 1) + (pixelGap + rodPitch) * 0.5; // Location of the first rod in this set
305 
306  // The first and last channels are smaller and contain one fewer rods
307  if (rodChannel == 0 || rodChannel == nPixelHolesX){
308  // Making this a bit flexible in case I find the dimensions are different from the drawings
309  nRods = nRods_edge_gap;
310  rodPitch = strip_gap_edge / nRods;
311  // The first edge has unique placement, but the last one can use the normal method
312  if (rodChannel == 0){
313  startX = (-absorber_width + rodPitch) * 0.5;
314  }
315  }
316 
317  id = m_zdcID->channel_id(m_side,m_module,ZdcIDType::ACTIVE, radGap*(nPixelHolesX+1) + rodChannel);
318  sprintf(volName, "ZDC::Strip %s", id.getString().c_str());
319  for (int rod = 0; rod < nRods; ++rod){
320  thisRadGap->add(new GeoNameTag(volName));
321  thisRadGap->add(new GeoIdentifierTag(id.get_identifier32().get_compact()));
322  thisRadGap->add(new GeoAlignableTransform(GeoTrf::TranslateX3D((startX + rod * rodPitch) * Gaudi::Units::mm)));
323  thisRadGap->add(new GeoAlignableTransform(GeoTrf::RotateX3D(90 * Gaudi::Units::deg)));
324  thisRadGap->add(new GeoFullPhysVol(Strip_Logical));
325  } // end vertical rod placement
326  } // end loop over rod channels
327 
328  /*************************************************
329  * Place the radiator gap
330  **************************************************/
331  id = m_zdcID->channel_id(m_side,m_module,ZdcIDType::INACTIVE,ZdcIDVolChannel::AIR);
332  sprintf(volName, "ZDC::Rad_Gap %s", id.getString().c_str());
333  Housing_Physical->add(new GeoNameTag(volName));
334  Housing_Physical->add(new GeoIdentifierTag(id.get_identifier32().get_compact()));
335  Housing_Physical->add(new GeoAlignableTransform(GeoTrf::Translate3D(0.0, 0.5 * floorThickness * Gaudi::Units::mm, zRadGap * Gaudi::Units::mm)));
336  Housing_Physical->add(thisRadGap);
337  }// end loop over radiator gaps
338 
339  // Place the steel case in the mother volume
340  id = m_zdcID->channel_id(m_side, m_module, ZdcIDType::INACTIVE,ZdcIDVolChannel::HOUSING);
341  sprintf(volName, "Zdc::ZDC_Mod %s", id.getString().c_str());
342  mother->add(new GeoNameTag(volName));
343  mother->add(new GeoIdentifierTag(id.get_identifier32().get_compact()));
344  mother->add(trf);
345  mother->add(Housing_Physical);
346 
347 }
ZDC_ZDCModule::m_modType
int m_modType
Definition: ZDC_ZDCModule.h:21
HOUSING
@ HOUSING
Definition: ZdcID.h:22
getMessageSvc.h
singleton-like access to IMessageSvc via open function and helper
ZDC_ModuleBase::m_module
int m_module
Definition: ZDC_ModuleBase.h:41
ZDC_ModuleBase
Definition: ZDC_ModuleBase.h:16
deg
#define deg
Definition: SbPolyhedron.cxx:17
AIR
@ AIR
Definition: ZdcID.h:22
ZDC_ZDCModule::create
virtual void create(GeoFullPhysVol *mother, GeoAlignableTransform *trf) override
Definition: ZDC_ZDCModule.cxx:46
ZDC_ZDCModule.h
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition: getMessageSvc.cxx:20
StoreGateSvc::retrieve
StatusCode retrieve(const T *&ptr) const
Retrieve the default object into a const T*.
ZdcID::channel_id
Identifier channel_id(int side, int module, int type, int channel) const
Definition: ZdcID.h:205
TRT::Hit::side
@ side
Definition: HitInfo.h:83
python.PyAthena.module
module
Definition: PyAthena.py:131
StoreGateSvc
The Athena Transient Store API.
Definition: StoreGateSvc.h:125
ZDC_ZDCModule::ZDC_ZDCModule
ZDC_ZDCModule()
Definition: ZDC_ZDCModule.cxx:27
ZDC_ModuleBase::m_detectorStore
StoreGateSvc * m_detectorStore
Definition: ZDC_ModuleBase.h:39
ZDC_ModuleBase::m_zdcID
const ZdcID * m_zdcID
Definition: ZDC_ModuleBase.h:42
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
RunTileMonitoring.rod
rod
Definition: RunTileMonitoring.py:134
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:227
StoredMaterialManager.h
TUNGSTEN
@ TUNGSTEN
Definition: ZdcID.h:22
ZDC_ModuleBase::m_side
int m_side
Definition: ZDC_ModuleBase.h:40
ZDC_ZDCModule
Definition: ZDC_ZDCModule.h:10
python.SystemOfUnits.mm
int mm
Definition: SystemOfUnits.py:83
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
ACTIVE
@ ACTIVE
Definition: ZdcID.h:21
CaloLCW_tf.trf
trf
Definition: CaloLCW_tf.py:20
INACTIVE
@ INACTIVE
Definition: ZdcID.h:21
StoreGateSvc.h
ZdcID
Definition: ZdcID.h:25
PIXEL
@ PIXEL
Definition: RegSelEnums.h:24
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Mon Dec 23 2024 21:23:20 for ATLAS Offline Software by   doxygen 1.8.18