ATLAS Offline Software
Loading...
Searching...
No Matches
Public Member Functions | Protected Attributes | List of all members
DBM_ModuleCage Class Reference

The module cage is the structure forming of the three aluminium plates and rods, which support the DBM module. More...

#include <DBM_ModuleCage.h>

Inheritance diagram for DBM_ModuleCage:
Collaboration diagram for DBM_ModuleCage:

Public Member Functions

virtual GeoVPhysVol * Build () override
 GeoVPixelFactory (InDetDD::PixelDetectorManager *ddmgr, PixelGeometryManager *mgr, GeoModelIO::ReadGeoModel *sqliteReader, std::shared_ptr< std::map< std::string, GeoFullPhysVol * > > mapFPV, std::shared_ptr< std::map< std::string, GeoAlignableTransform * > > mapAX)

Protected Attributes

PixelGeometryManager * m_gmt_mgr
InDetMaterialManager * m_mat_mgr
InDetDD::PixelDetectorManager * m_DDmgr
GeoModelIO::ReadGeoModel * m_sqliteReader
std::shared_ptr< std::map< std::string, GeoFullPhysVol * > > m_mapFPV
std::shared_ptr< std::map< std::string, GeoAlignableTransform * > > m_mapAX
const double m_epsilon

Detailed Description

The module cage is the structure forming of the three aluminium plates and rods, which support the DBM module.

Definition at line 17 of file DBM_ModuleCage.h.

Member Function Documentation

◆ Build()

GeoVPhysVol * DBM_ModuleCage::Build ( )
overridevirtual

Implements GeoVPixelFactory.

Definition at line 21 of file DBM_ModuleCage.cxx.

21 {
22
23 // store initial value Eta value
24 int tempLD = m_gmt_mgr->GetLD();
25 GeoPhysVol* containerPhys{nullptr};
26
27 if(m_sqliteReader) {
28 for (int i = 0; i < 3; i++) {
29 //**** Add volume to form the module cage
30 // add sensor module
31 // set telescope layer number
32 m_gmt_mgr->SetCurrentLD(i);
33 DBM_Module module(m_DDmgr, m_gmt_mgr, m_sqliteReader, m_mapFPV, m_mapAX);
34 module.Build();
35 }
36 }
37 else {
38
39 // safety, to make sure volumes don't overlap
40 double safety = 0.005*Gaudi::Units::mm;
41
42 // Telescope dimension
43 double layerUnitY = m_gmt_mgr->DBMModuleCageY();
44 double layerUnitZ = m_gmt_mgr->DBMModuleCageZ();
45
46 // layer spacing
47 double Zspacing = m_gmt_mgr->DBMSpacingZ();
48 double Rspacing = m_gmt_mgr->DBMSpacingRadial();
49 // gap between V-slide and first main plate
50 double layer1Space = m_gmt_mgr->DBMSpace();
51
52 // main plate, on which is mounted the sensor module
53 double mainPlateX = m_gmt_mgr->DBMMainPlateX(); //dimension in x-direction or width
54 double mainPlateY = m_gmt_mgr->DBMMainPlateY(); //y-direction or height
55 double mainPlateZ = m_gmt_mgr->DBMMainPlateZ(); //z-direction or thickness
56 double mPlateWindowX = m_gmt_mgr->DBMMPlateWindowWidth(); // window width in the main plate
57 double mPlateWindowY = m_gmt_mgr->DBMMPlateWindowHeight(); // window height
58 double mPlateWindowPos = m_gmt_mgr->DBMMPlateWindowPos(); // window position from bottom of the main plate
59
60 // DBM module
61 double diamondZ = m_gmt_mgr->DBMDiamondZ();
62 double FEI4Z = m_gmt_mgr->DBMFEI4Z();
63 double ceramicY = m_gmt_mgr->DBMCeramicY();
64 double ceramicZ = m_gmt_mgr->DBMCeramicZ();
65 double moduleAirGap = m_gmt_mgr->DBMAirGap(); // air gap between diamond and FE-I4 chip
66 double kaptonZ = m_gmt_mgr->DBMKaptonZ();
67
68 // flex support
69 double flexSupportX = m_gmt_mgr->DBMFlexSupportX();
70 double flexSupportY = m_gmt_mgr->DBMFlexSupportY();
71 double flexSupportZ = m_gmt_mgr->DBMFlexSupportZ();
72 double flexSupportOffset = m_gmt_mgr->DBMFlexSupportOffset();
73
74 // rods
75 double rodRadius = m_gmt_mgr->DBMRodRadius();
76 double mPlateRod2RodY = m_gmt_mgr->DBMMPlateRod2RodY(); // distance between center of top and bottom rods
77 double mPlateRod2RodX = m_gmt_mgr->DBMMPlateRod2RodX(); // distance between center of left and right rods
78
79 // materials
80 const GeoMaterial* air = m_mat_mgr->getMaterial("std::Air");
81 const GeoMaterial* aluminium = m_mat_mgr->getMaterial("std::Aluminium");
82 const GeoMaterial* DBMRod_mat = m_mat_mgr->getMaterial("pix::DBMRod");
83
84 //**** 3-layers unit volume forming the module cage
85 const GeoBox* containerBox = new GeoBox(mainPlateX/2. + safety, layerUnitY/2. + safety, layerUnitZ/2.);
86 const GeoLogVol* containerLog = new GeoLogVol("dbmTelescopeLog", containerBox, air);
87 containerPhys = new GeoPhysVol(containerLog);
88
89 //**** blocks to form the main plate
90
91 const GeoBox* mPSide = new GeoBox((mainPlateX - mPlateWindowX)/4., mainPlateY/2., mainPlateZ/2.);
92 const GeoMaterial* dbmAluminium1 = m_mat_mgr->getMaterialForVolume("pix::DBMAluminium1", mPSide->volume());
93 const GeoLogVol* mPSideLog = new GeoLogVol("dbmWallLogPlt", mPSide, dbmAluminium1);
94 GeoPhysVol* mPSidePhys = new GeoPhysVol(mPSideLog);
95
96 const GeoBox* mPCenterBot = new GeoBox(mPlateWindowX/2., mPlateWindowPos/2., mainPlateZ/2.);
97 const GeoLogVol* mPCenterBotLog = new GeoLogVol("dbmWallLogPlt", mPCenterBot, aluminium);
98 GeoPhysVol* mPCenterBotPhys = new GeoPhysVol(mPCenterBotLog);
99
100 const GeoBox* mPCenterTop = new GeoBox(mPlateWindowX/2., (mainPlateY - mPlateWindowY - mPlateWindowPos)/2., mainPlateZ/2.);
101 const GeoLogVol* mPCenterTopLog = new GeoLogVol("dbmWallLogPlt", mPCenterTop, aluminium);
102 GeoPhysVol* mPCenterTopPhys = new GeoPhysVol(mPCenterTopLog);
103
104 //**** telescope rods
105
106 // rod in front of the first layer
107 const GeoTube* rodA = new GeoTube(0., rodRadius, layer1Space/2. - safety);
108 const GeoLogVol* rodALog = new GeoLogVol("dbmWallLogPlt", rodA, DBMRod_mat);
109 GeoPhysVol* rodAPhys = new GeoPhysVol(rodALog);
110
111 // top rods
112 const GeoTube* topRod = new GeoTube(0., rodRadius, (Zspacing - mainPlateZ - flexSupportZ)/2. - safety);
113 const GeoLogVol* topRodLog = new GeoLogVol("dbmWallLogPlt", topRod, DBMRod_mat);
114 GeoPhysVol* topRodPhys = new GeoPhysVol(topRodLog);
115
116 // Bottom rods
117 const GeoTube* botRod = new GeoTube(0., rodRadius, (Zspacing - mainPlateZ)/2. - safety);
118 const GeoLogVol* botRodLog = new GeoLogVol("dbmWallLogPlt", botRod, DBMRod_mat);
119 GeoPhysVol* botRodPhys = new GeoPhysVol(botRodLog);
120
121 //**** add volumes to the telescope box
122
123 // position of the center of the main plates with respect to the front bottom telescope box
124 double mainPlatePosZ[3]; // Z coordinates
125 mainPlatePosZ[0] = -layerUnitZ/2. + layer1Space + mainPlateZ/2.;
126 mainPlatePosZ[1] = -layerUnitZ/2. + layer1Space + Zspacing + mainPlateZ/2.;
127 mainPlatePosZ[2] = -layerUnitZ/2. + layer1Space + 2.*Zspacing + mainPlateZ/2.;
128 // Y coordinate
129 double mainPlatePosY = -layerUnitY/2. + mainPlateY/2.;
130
131 // strings for volume tag
132 std::string tag_mainPlate[3] = {"mainPlate1", "mainPlate2", "mainPlate3"};
133 std::string tag_flex[3] = {"flexSupport1", "flexSupport2", "flexSupport3"};
134 std::string tag_module[3] = {"module1", "module2", "module3"};
135 std::string tag_rod[3] = {"rod1", "rod2", "rod3"};
136
137 for (int i = 0; i < 3; i++) {
138
139 //**** Add volume to form the module cage
140
141 // add sensor module
142
143 // set telescope layer number
144 m_gmt_mgr->SetCurrentLD(i);
145
146 DBM_Module module (m_DDmgr, m_gmt_mgr, m_sqliteReader, m_mapFPV, m_mapAX);
147 GeoVPhysVol* modulePhys = module.Build();
148
149 Rspacing = m_gmt_mgr->DBMSpacingRadial();
150 GeoTrf::Translate3D modulePos(0, -layerUnitY/2. + Rspacing + ceramicY/2., mainPlatePosZ[i]-mainPlateZ/2.-(ceramicZ+FEI4Z+moduleAirGap+diamondZ + kaptonZ)/2.-2*safety);
151 GeoTransform* xform = new GeoTransform(modulePos);
152 GeoNameTag* tag = new GeoNameTag(tag_module[i].c_str());
153 containerPhys->add(tag);
154 containerPhys->add(new GeoIdentifierTag(i));
155 containerPhys->add(xform);
156 containerPhys->add(modulePhys);
157
158 // add main plate
159
160 GeoTrf::Translate3D mPSideAPos((mainPlateX+mPlateWindowX)/4.+safety/2., mainPlatePosY, mainPlatePosZ[i]);
161 xform = new GeoTransform(mPSideAPos);
162 tag = new GeoNameTag(tag_mainPlate[i].c_str());
163 containerPhys->add(tag);
164 containerPhys->add(xform);
165 containerPhys->add(mPSidePhys);
166
167 GeoTrf::Translate3D mPSideBPos(-(mainPlateX+mPlateWindowX)/4.-safety/2., mainPlatePosY, mainPlatePosZ[i]);
168 xform = new GeoTransform(mPSideBPos);
169 containerPhys->add(tag);
170 containerPhys->add(xform);
171 containerPhys->add(mPSidePhys);
172
173 GeoTrf::Translate3D mPBotPos(0.0, (-layerUnitY + mPlateWindowPos)/2.-safety/2., mainPlatePosZ[i]);
174 xform = new GeoTransform(mPBotPos);
175 containerPhys->add(tag);
176 containerPhys->add(xform);
177 containerPhys->add(mPCenterBotPhys);
178
179 GeoTrf::Translate3D mPTopPos(0.0, (-layerUnitY + mainPlateY + mPlateWindowY + mPlateWindowPos)/2.+safety/2., mainPlatePosZ[i]);
180 xform = new GeoTransform(mPTopPos);
181 containerPhys->add(tag);
182 containerPhys->add(xform);
183 containerPhys->add(mPCenterTopPhys);
184
185
186 //**** component of the flex support
187 // Additional material in the 3rd fex support from screws and the 4 rods
188 const GeoBox* flexSupp = new GeoBox(flexSupportX/2., flexSupportY/2., flexSupportZ/2.);
189
190 // get mass of flex support material
191 std::string flexSupp_matName = "";
192 if (i == 0) {
193 flexSupp_matName = "pix::DBMPeek5";
194 } else if (i == 1) {
195 flexSupp_matName = "pix::DBMPeek6";
196 } else if (i == 2) {
197 flexSupp_matName = "pix::DBMPeek7";
198 }
199 const GeoMaterial* dbmFlexSupp_mat = m_mat_mgr->getMaterialForVolume(flexSupp_matName, flexSupp->volume());
200
201 const GeoLogVol* flexSuppLog = new GeoLogVol("dbmWallLog", flexSupp, dbmFlexSupp_mat);
202 GeoPhysVol* flexSuppPhys = new GeoPhysVol(flexSuppLog);
203
204 // Y position of flex support block
205 double flexSuppPosY = mainPlatePosY + mPlateRod2RodY/2. - flexSupportY/2. + flexSupportOffset;
206 // Z position of flex support blocks
207 double flexSuppPosZ = mainPlatePosZ[i] + mainPlateZ/2. + flexSupportZ/2. + safety;
208
209 //**** add flex support
210
211 GeoTrf::Translate3D flexSuppPos(0.0, flexSuppPosY, flexSuppPosZ);
212 xform = new GeoTransform(flexSuppPos);
213 tag = new GeoNameTag(tag_flex[i].c_str());
214 containerPhys->add(tag);
215 containerPhys->add(xform);
216 containerPhys->add(flexSuppPhys);
217
218 //**** add rod
219
220 // Y position of rods
221 double topRodPosY = mainPlatePosY + mPlateRod2RodY/2.;
222 double botRodPosY = mainPlatePosY - mPlateRod2RodY/2.;
223
224 if (m_gmt_mgr->GetLD() == 0) { //first layer
225
226 double rodPosZ = mainPlatePosZ[i] - mainPlateZ/2.0 - layer1Space/2.; // Z position of rod
227
228 GeoTrf::Translate3D rodAPos(mPlateRod2RodX/2., topRodPosY, rodPosZ);
229 xform = new GeoTransform(rodAPos);
230 tag = new GeoNameTag(tag_rod[i].c_str());
231 containerPhys->add(tag);
232 containerPhys->add(xform);
233 containerPhys->add(rodAPhys);
234
235 GeoTrf::Translate3D rodBPos(-mPlateRod2RodX/2., topRodPosY, rodPosZ);
236 xform = new GeoTransform(rodBPos);
237 containerPhys->add(tag);
238 containerPhys->add(xform);
239 containerPhys->add(rodAPhys);
240
241 GeoTrf::Translate3D rodCPos(mPlateRod2RodX/2., botRodPosY, rodPosZ);
242 xform = new GeoTransform(rodCPos);
243 containerPhys->add(tag);
244 containerPhys->add(xform);
245 containerPhys->add(rodAPhys);
246
247 GeoTrf::Translate3D rodDPos(-mPlateRod2RodX/2., botRodPosY, rodPosZ);
248 xform = new GeoTransform(rodDPos);
249 containerPhys->add(tag);
250 containerPhys->add(xform);
251 containerPhys->add(rodAPhys);
252
253 } else if (m_gmt_mgr->GetLD() > 0 && m_gmt_mgr->GetLD() < 3) { //second and third layer
254
255 //Z position of rods
256 double topRodPosZ = mainPlatePosZ[i] - mainPlateZ/2. - (Zspacing - mainPlateZ - flexSupportZ)/2.;
257 double botRodPosZ = mainPlatePosZ[i] - mainPlateZ/2. - (Zspacing - mainPlateZ)/2.;
258
259 GeoTrf::Translate3D rodAPos(mPlateRod2RodX/2., topRodPosY, topRodPosZ);
260 xform = new GeoTransform(rodAPos);
261 tag = new GeoNameTag(tag_rod[i].c_str());
262 containerPhys->add(tag);
263 containerPhys->add(xform);
264 containerPhys->add(topRodPhys);
265
266 GeoTrf::Translate3D rodBPos(-mPlateRod2RodX/2., topRodPosY, topRodPosZ);
267 xform = new GeoTransform(rodBPos);
268 containerPhys->add(tag);
269 containerPhys->add(xform);
270 containerPhys->add(topRodPhys);
271
272 GeoTrf::Translate3D rodCPos(mPlateRod2RodX/2., botRodPosY, botRodPosZ);
273 xform = new GeoTransform(rodCPos);
274 containerPhys->add(tag);
275 containerPhys->add(xform);
276 containerPhys->add(botRodPhys);
277
278 GeoTrf::Translate3D rodDPos(-mPlateRod2RodX/2., botRodPosY, botRodPosZ);
279 xform = new GeoTransform(rodDPos);
280 containerPhys->add(tag);
281 containerPhys->add(xform);
282 containerPhys->add(botRodPhys);
283
284 }
285 else {
286 m_gmt_mgr->msg(MSG::WARNING) << "Module cage invalid layer value: " << m_gmt_mgr->GetLD() << endmsg;
287 }
288 }
289 }
290 // restore Eta value
291 m_gmt_mgr->SetCurrentLD(tempLD);
292
293 return containerPhys;
294}
endmsg
#define endmsg
Definition AnalysisConfig_Ntuple.cxx:63
GeoVPixelFactory::m_mapFPV
std::shared_ptr< std::map< std::string, GeoFullPhysVol * > > m_mapFPV
Definition GeoVPixelFactory.h:47
GeoVPixelFactory::m_mapAX
std::shared_ptr< std::map< std::string, GeoAlignableTransform * > > m_mapAX
Definition GeoVPixelFactory.h:48
GeoVPixelFactory::m_sqliteReader
GeoModelIO::ReadGeoModel * m_sqliteReader
Definition GeoVPixelFactory.h:46
GeoVPixelFactory::m_gmt_mgr
PixelGeometryManager * m_gmt_mgr
Definition GeoVPixelFactory.h:43
GeoVPixelFactory::m_DDmgr
InDetDD::PixelDetectorManager * m_DDmgr
Definition GeoVPixelFactory.h:45
GeoVPixelFactory::m_mat_mgr
InDetMaterialManager * m_mat_mgr
Definition GeoVPixelFactory.h:44
CaloCondBlobAlgs_fillNoiseFromASCII.tag
str tag
Definition CaloCondBlobAlgs_fillNoiseFromASCII.py:23

◆ GeoVPixelFactory()

GeoVPixelFactory::GeoVPixelFactory ( InDetDD::PixelDetectorManager * ddmgr,
PixelGeometryManager * mgr,
GeoModelIO::ReadGeoModel * sqliteReader,
std::shared_ptr< std::map< std::string, GeoFullPhysVol * > > mapFPV,
std::shared_ptr< std::map< std::string, GeoAlignableTransform * > > mapAX )

Definition at line 33 of file GeoVPixelFactory.cxx.

16 : m_gmt_mgr (mgr)
17 , m_mat_mgr (m_gmt_mgr->getMaterialManager())
18 , m_DDmgr (ddmgr)
19 , m_sqliteReader(sqliteReader)
20 , m_mapFPV(std::move(mapFPV))
21 , m_mapAX(std::move(mapAX))
22 , m_epsilon(0.0001)
23{
24}
GeoVPixelFactory::m_epsilon
const double m_epsilon
Definition GeoVPixelFactory.h:49

Member Data Documentation

◆ m_DDmgr

InDetDD::PixelDetectorManager* GeoVPixelFactory::m_DDmgr
protectedinherited

Definition at line 45 of file GeoVPixelFactory.h.

◆ m_epsilon

const double GeoVPixelFactory::m_epsilon
protectedinherited

Definition at line 49 of file GeoVPixelFactory.h.

◆ m_gmt_mgr

PixelGeometryManager* GeoVPixelFactory::m_gmt_mgr
protectedinherited

Definition at line 43 of file GeoVPixelFactory.h.

◆ m_mapAX

std::shared_ptr<std::map<std::string, GeoAlignableTransform*> > GeoVPixelFactory::m_mapAX
protectedinherited

Definition at line 48 of file GeoVPixelFactory.h.

◆ m_mapFPV

std::shared_ptr<std::map<std::string, GeoFullPhysVol*> > GeoVPixelFactory::m_mapFPV
protectedinherited

Definition at line 47 of file GeoVPixelFactory.h.

◆ m_mat_mgr

InDetMaterialManager* GeoVPixelFactory::m_mat_mgr
protectedinherited

Definition at line 44 of file GeoVPixelFactory.h.

◆ m_sqliteReader

GeoModelIO::ReadGeoModel* GeoVPixelFactory::m_sqliteReader
protectedinherited

Definition at line 46 of file GeoVPixelFactory.h.

The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.14.0