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

#include <GeoPixelLadderServices.h>

Inheritance diagram for GeoPixelLadderServices:
Collaboration diagram for GeoPixelLadderServices:

Public Member Functions

 GeoPixelLadderServices (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, int ladderType)
 GeoPixelLadderServices (const GeoPixelLadderServices &)=delete
GeoPixelLadderServices & operator= (const GeoPixelLadderServices &)=delete
virtual ~GeoPixelLadderServices ()=default
virtual GeoVPhysVol * Build () override
const GeoTrf::Vector3D & envelopeCornerA1 ()
const GeoTrf::Vector3D & envelopeCornerA2 ()
const GeoTrf::Vector3D & envelopeCornerC1 ()
const GeoTrf::Vector3D & envelopeCornerC2 ()
double referenceX ()
double referenceY ()
GeoVPhysVol * BuildAlTube ()
GeoVPhysVol * BuildOmega ()
void BuildGlue (GeoPhysVol *parent)
void BuildPigtailAndConnector (GeoPhysVol *parent)

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

Private Attributes

GeoIntrusivePtr< const GeoLogVol > m_ladderServicesLV {}
int m_ladderType
GeoTrf::Vector3D m_envelopeCornerA1
GeoTrf::Vector3D m_envelopeCornerA2
GeoTrf::Vector3D m_envelopeCornerC1
GeoTrf::Vector3D m_envelopeCornerC2
double m_xOffset
double m_yOffset

Detailed Description

Definition at line 15 of file GeoPixelLadderServices.h.

Constructor & Destructor Documentation

◆ GeoPixelLadderServices() [1/2]

GeoPixelLadderServices::GeoPixelLadderServices ( 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,
int ladderType )

Definition at line 27 of file GeoPixelLadderServices.cxx.

33 : GeoVPixelFactory(ddmgr, mgr, sqliteReader, std::move(mapFPV), std::move(mapAX)),
34 m_ladderType(ladderType)
35{
36 //std::cout << "Building GeoPixelLadderServices with ladder type : " << ladderType << std::endl;
37 //
38 // Define the log volume in the constructor, so I do it only once.
39 //
40 // Length and thickness of the Omega are in the db
41 //
42 double halflength =0.5* m_gmt_mgr->PixelLadderLength()+m_epsilon;
43 //
44 const GeoMaterial* air = m_mat_mgr->getMaterial("std::Air");
45 //
46 //const GeoBox* ladderSvcBox = new GeoBox(thickness/2.,width/2.,halflength);
47 // Quick fix - we hardwire the numbers. Need to work out a way to extract this from the database numbers.
48 double safety = 0.01*Gaudi::Units::mm;
49 double xBase = 0;
50
51 // ConnA: Part to fit Connector
52 // ConnC: Part to fit Cable
53
54 double xOffsetConnA = xBase + m_gmt_mgr->PixelLadderCableOffsetX() - m_gmt_mgr->PixelLadderServicesX();
55 double xOffsetConnC = xOffsetConnA;
56
57
58 //double xMaxConnA = 1.250 * Gaudi::Units::cm + xOffsetConnA + safety;
59 // double xMaxConnC = 1.6575 * Gaudi::Units::cm + xOffsetConnC + safety;
60 // max offset is 12.5mm + 1/2 thickness of cables
61 // double xMaxConnA = 1.5075 * Gaudi::Units::cm + 0.5* 0.15*Gaudi::Units::cm + xOffsetConnA + safety;
62 double xMaxConnA = m_gmt_mgr->PixelConnectorPosX(1) + 0.5*m_gmt_mgr->PixelConnectorWidthX(1) + xOffsetConnA + safety;
63 double xMaxConnC = 1.25 * Gaudi::Units::cm + 0.5* 0.0125*Gaudi::Units::cm + xOffsetConnC + safety;
64 double xMaxOmegaBase = 0.055 * Gaudi::Units::cm + xBase + 1*Gaudi::Units::mm; // The 1 mm is just extra safety.
65 double yWidthConnA = 1.0 * Gaudi::Units::cm;
66 double yWidthConnC = 0.2 * Gaudi::Units::cm;
67 double yPosConnA = m_gmt_mgr->PixelLadderCableOffsetY() - m_gmt_mgr->PixelLadderServicesY();
68 double yPosConnC = yPosConnA;
69 double xCenter = 0;
70 double xWidthOmegaBase = xMaxOmegaBase - xBase;
71 double xWidthConnA = xMaxConnA - xBase;
72 double xWidthConnC = xMaxConnC - xBase;
73 double yWidthOmega = 1.2*Gaudi::Units::cm + m_epsilon;
74
75 const GeoBox* omegaBaseEnv = new GeoBox(0.5*xWidthOmegaBase, 0.5*yWidthOmega, halflength);
76 const GeoBox* connAEnv = new GeoBox(0.5*xWidthConnA, 0.5*yWidthConnA + safety, halflength);
77 const GeoBox* connCEnv = new GeoBox(0.5*xWidthConnC, 0.5*yWidthConnC + safety, halflength);
78 GeoTrf::Transform3D omegaBaseShift = GeoTrf::Translate3D(xBase + 0.5*xWidthOmegaBase - xCenter, 0., 0.);
79 GeoTrf::Transform3D connAShift = GeoTrf::Translate3D(xBase + 0.5*xWidthConnA - xCenter, yPosConnA, 0.);
80 GeoTrf::Transform3D connCShift = GeoTrf::Translate3D(xBase + 0.5*xWidthConnC - xCenter, yPosConnC, 0.);
81
82 const GeoShape & ladderSvcShape = ((*omegaBaseEnv) << omegaBaseShift)
83 .add(*connAEnv << connAShift)
84 .add(*connCEnv << connCShift);
85
86 m_ladderServicesLV = new GeoLogVol("LadderSvc",&ladderSvcShape,air);
87 // store coordinates of corners of envelope.
88 m_envelopeCornerA1 = GeoTrf::Vector3D(xMaxConnA - xCenter, yPosConnA + 0.5* yWidthConnA + safety, 0.);
89 m_envelopeCornerA2 = GeoTrf::Vector3D(xMaxConnA - xCenter, yPosConnA - 0.5* yWidthConnA + safety, 0.);
90 m_envelopeCornerC1 = GeoTrf::Vector3D(xMaxConnC - xCenter, yPosConnC + 0.5* yWidthConnC + safety, 0.);
91 m_envelopeCornerC2 = GeoTrf::Vector3D(xMaxConnC - xCenter, yPosConnC - 0.5* yWidthConnC + safety, 0.);
92
93
94 m_xOffset = xBase;
95 m_yOffset = 0;
96
97}
GeoPixelLadderServices::m_envelopeCornerC2
GeoTrf::Vector3D m_envelopeCornerC2
Definition GeoPixelLadderServices.h:45
GeoPixelLadderServices::m_envelopeCornerC1
GeoTrf::Vector3D m_envelopeCornerC1
Definition GeoPixelLadderServices.h:44
GeoPixelLadderServices::m_envelopeCornerA2
GeoTrf::Vector3D m_envelopeCornerA2
Definition GeoPixelLadderServices.h:43
GeoPixelLadderServices::m_ladderServicesLV
GeoIntrusivePtr< const GeoLogVol > m_ladderServicesLV
Definition GeoPixelLadderServices.h:39
GeoPixelLadderServices::m_envelopeCornerA1
GeoTrf::Vector3D m_envelopeCornerA1
Definition GeoPixelLadderServices.h:42
GeoVPixelFactory::m_epsilon
const double m_epsilon
Definition GeoVPixelFactory.h:49
GeoVPixelFactory::m_gmt_mgr
PixelGeometryManager * m_gmt_mgr
Definition GeoVPixelFactory.h:43
GeoVPixelFactory::m_mat_mgr
InDetMaterialManager * m_mat_mgr
Definition GeoVPixelFactory.h:44
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 GeoVPixelFactory.cxx:11
add
bool add(const std::string &hname, TKey *tobj)
Definition fastadd.cxx:55

◆ GeoPixelLadderServices() [2/2]

GeoPixelLadderServices::GeoPixelLadderServices ( const GeoPixelLadderServices & )
delete

◆ ~GeoPixelLadderServices()

virtual GeoPixelLadderServices::~GeoPixelLadderServices ( )
virtualdefault

Member Function Documentation

◆ Build()

GeoVPhysVol * GeoPixelLadderServices::Build ( )
overridevirtual

Implements GeoVPixelFactory.

Definition at line 102 of file GeoPixelLadderServices.cxx.

102 {
103 GeoPhysVol* ladderSvcPhys = new GeoPhysVol(m_ladderServicesLV);
104 //double thickness = m_gmt_mgr->PixelLadderThickness()+m_gmt_mgr->PixelCableThickness();
105 //double thickness = m_gmt_mgr->PixelLadderThickness() + m_gmt_mgr->PixelCableThickness() + 0.25*Gaudi::Units::cm; // plus 0.25 cm New DC3 ???
106 //double thickness = m_gmt_mgr->PixelLadderThickness()+ 6.5; // m_gmt_mgr->PixelCableThickness() was 0.4 cm, plus 0.25 cm New DC3
107 //
108 // The Glue
109 BuildGlue(ladderSvcPhys);
110
111 // The aluminium tube
112 // Positioned at 0,0,0 relative to parent.
113 ladderSvcPhys->add(this->BuildAlTube());
114
115 // The carbon-carbon Omega
116 // Positioned at 0,0,0 relative to parent.
117 ladderSvcPhys->add(this->BuildOmega());
118
119 //
120 // Put the fluid/gaz mixture
121 //
122 GeoPixelFluid fluid(m_DDmgr, m_gmt_mgr, m_sqliteReader, m_mapFPV, m_mapAX, m_ladderType);
123 double xpos = fluid.posX() + m_xOffset;
124 double ypos = fluid.posY() + m_yOffset;
125 double zpos = fluid.posZ();
126
127 GeoVPhysVol* fluidPhys = fluid.Build();
128 GeoTransform* xform = new GeoTransform(GeoTrf::Translate3D(xpos,ypos,zpos));
129 ladderSvcPhys->add(xform);
130 ladderSvcPhys->add(fluidPhys);
131
132 //
133 // Place Pigtail + connector
134 //
135 BuildPigtailAndConnector(ladderSvcPhys);
136
137
138 //
139 // Cables
140 //
141 GeoPixelCable cable (m_DDmgr, m_gmt_mgr, m_sqliteReader, m_mapFPV, m_mapAX);
142 for (int ii = 0; ii < cable.numElements(); ii++) {
143 cable.setElement(ii);
144 GeoVPhysVol* phys = cable.Build();
145 double xpos = m_xOffset + cable.getStackOffset() + m_gmt_mgr->PixelLadderCableOffsetX() - m_gmt_mgr->PixelLadderServicesX();
146 double ypos = m_yOffset + m_gmt_mgr->PixelLadderCableOffsetY() - m_gmt_mgr->PixelLadderServicesY();
147 double zpos = cable.zpos();
148 GeoTransform* xform = new GeoTransform(GeoTrf::Translate3D(xpos,ypos,zpos));
149 ladderSvcPhys->add(xform);
150 ladderSvcPhys->add(phys);
151 }
152
153 return ladderSvcPhys;
154}
GeoPixelLadderServices::BuildPigtailAndConnector
void BuildPigtailAndConnector(GeoPhysVol *parent)
Definition GeoPixelLadderServices.cxx:348
GeoPixelLadderServices::BuildGlue
void BuildGlue(GeoPhysVol *parent)
Definition GeoPixelLadderServices.cxx:321
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_DDmgr
InDetDD::PixelDetectorManager * m_DDmgr
Definition GeoVPixelFactory.h:45

◆ BuildAlTube()

GeoVPhysVol * GeoPixelLadderServices::BuildAlTube ( )

Definition at line 241 of file GeoPixelLadderServices.cxx.

241 {
242
243 double xOffset = m_xOffset;
244 double yOffset = m_yOffset;
245
246 /*
247 double xUpperBend = xOffset + 2.7*Gaudi::Units::mm;
248 double yUpperBend = yOffset;
249 double radUpperBend = 2.0*Gaudi::Units::mm;
250 double xLowerBend = xOffset + 0.55;
251 double yLowerBend = yOffset+1.925*Gaudi::Units::mm;
252 double radLowerBend = 0.5*Gaudi::Units::mm;
253 double thick = 0.2*Gaudi::Units::mm;
254 double length = 838*Gaudi::Units::mm;
255 double zOffset = 0;
256 */
257
258 double xUpperBend = xOffset + m_gmt_mgr->PixelAlTubeUpperBendX();
259 double yUpperBend = yOffset + m_gmt_mgr->PixelAlTubeUpperBendY();
260 double radUpperBend = m_gmt_mgr->PixelAlTubeUpperBendRadius();
261 double xLowerBend = xOffset + m_gmt_mgr->PixelAlTubeLowerBendX();
262 double yLowerBend = yOffset + m_gmt_mgr->PixelAlTubeLowerBendY();
263 double radLowerBend = m_gmt_mgr->PixelAlTubeLowerBendRadius();
264 double thick = m_gmt_mgr->PixelAlTubeWallThickness();
265 double length = m_gmt_mgr->PixelAlTubeLength();
266 double zOffset = 0;
267
268 double sepX = (xUpperBend - xLowerBend);
269 double sepY = (yUpperBend - yLowerBend);
270 double sep2 = sepX*sepX+sepY*sepY;
271 double sep = sqrt(sep2);
272 double radDist = radUpperBend-radLowerBend;
273 double alpha = atan(-sepY/sepX) - asin(radDist/sep);
274 double upperStraightLength = sqrt(sep2 - radDist*radDist);
275 double xLowerStraight = xLowerBend + (radLowerBend-0.5*thick)*sin(alpha);
276 double yLowerStraight = yLowerBend + (radLowerBend-0.5*thick)*cos(alpha);
277 double xUpperStraight = xUpperBend + (radUpperBend-0.5*thick)*sin(alpha);
278 double yUpperStraight = yUpperBend + (radUpperBend-0.5*thick)*cos(alpha);
279
280
281 // Tube sector for upper bend
282 GeoTubs * upperBendShape = new GeoTubs(radUpperBend - thick, radUpperBend, 0.5* length, alpha-0.5*Gaudi::Units::pi, Gaudi::Units::pi - 2*alpha);
283
284 // Tube sector for lower bend (+y)
285 GeoTubs * lowerBendShapeP = new GeoTubs(radLowerBend - thick, radLowerBend, 0.5* length, 0.5*Gaudi::Units::pi-alpha, 0.5*Gaudi::Units::pi+alpha);
286
287 // Tube sector for lower bend (-y)
288 GeoTubs * lowerBendShapeM = new GeoTubs(radLowerBend - thick, radLowerBend, 0.5* length, Gaudi::Units::pi, 0.5*Gaudi::Units::pi+alpha);
289
290 // Lower Straight section
291 GeoBox * lowerStraightBox = new GeoBox(0.5*thick, yLowerBend, 0.5*length);
292
293 // Upper Straight section (+-y)
294 GeoBox * upperStraightBox = new GeoBox(0.5*thick, 0.5*upperStraightLength, 0.5*length);
295
296 // Put it all together
297 const GeoShape & alTubeShape =
298 (*lowerStraightBox << GeoTrf::Translate3D(xLowerBend-radLowerBend+0.5*thick,0,zOffset) )
299 .add(*lowerBendShapeP << GeoTrf::Translate3D(xLowerBend,yLowerBend,zOffset) )
300 .add(*upperStraightBox << GeoTrf::Translate3D(0.5*(xLowerStraight+xUpperStraight),0.5*(yLowerStraight+yUpperStraight),zOffset)*GeoTrf::RotateZ3D(0.5*Gaudi::Units::pi-alpha) )
301 .add(*upperBendShape << GeoTrf::Translate3D(xUpperBend,yUpperBend,zOffset) )
302 .add(*upperStraightBox << GeoTrf::Translate3D(0.5*(xLowerStraight+xUpperStraight),-0.5*(yLowerStraight+yUpperStraight),zOffset)*GeoTrf::RotateZ3D(0.5*Gaudi::Units::pi+alpha) )
303 .add(*lowerBendShapeM << GeoTrf::Translate3D(xLowerBend,-yLowerBend,zOffset) );
304
305 double totVolume =
306 lowerStraightBox->volume()
307 + lowerBendShapeP->volume()
308 + 2*upperStraightBox->volume()
309 + upperBendShape->volume()
310 + lowerBendShapeM->volume();
311
312
313 std::string matName = m_gmt_mgr->getMaterialName("AlTube", m_gmt_mgr->GetLD());
314 const GeoMaterial* alMat = m_mat_mgr->getMaterialForVolume(matName,totVolume);
315 GeoLogVol* tubeLV = new GeoLogVol("AlTube",&alTubeShape,alMat);
316 return new GeoPhysVol(tubeLV);
317
318
319}
length
double length(const pvec &v)
Definition FPGATrackSimLLPDoubletHoughTransformTool.cxx:26

◆ BuildGlue()

void GeoPixelLadderServices::BuildGlue ( GeoPhysVol * parent)

Definition at line 321 of file GeoPixelLadderServices.cxx.

321 {
322
323
324 int nGlueElements = m_gmt_mgr->PixelNumOmegaGlueElements();
325 for (int i = 0; i < nGlueElements; ++i) {
326 double x1 = m_gmt_mgr->PixelOmegaGlueStartX(i);
327 double thickness = m_gmt_mgr->PixelOmegaGlueThickness(i);
328 double y1 = m_gmt_mgr->PixelOmegaGlueStartY(i);
329 double y2 = m_gmt_mgr->PixelOmegaGlueEndY(i);
330 double length = m_gmt_mgr->PixelOmegaGlueLength(i);
331 double zOffset = m_gmt_mgr->PixelOmegaGluePosZ(i);
332 int typeNum = m_gmt_mgr->PixelOmegaGlueTypeNum(i);
333
334 GeoBox * glueShape = new GeoBox(0.5*thickness, 0.5*std::abs(y1-y2), 0.5*length);
335 std::string matName = m_gmt_mgr->getMaterialName("GlueOmegaStave", m_gmt_mgr->GetLD(), typeNum);
336 const GeoMaterial* glueMat = m_mat_mgr->getMaterialForVolume(matName, glueShape->volume());
337 GeoLogVol* glueLV = new GeoLogVol("Glue",glueShape,glueMat);
338 GeoPhysVol* gluePV = new GeoPhysVol(glueLV);
339
340 GeoTransform * xform = new GeoTransform(GeoTrf::Translate3D(m_xOffset+x1+0.5*thickness, m_yOffset-0.5*(y1+y2), zOffset));
341
342 parent->add(xform);
343 parent->add(gluePV);
344 }
345}
RCU::Check::typeNum
const int typeNum
Definition Assert.h:75
test_pyathena.parent
parent
Definition test_pyathena.py:15

◆ BuildOmega()

GeoVPhysVol * GeoPixelLadderServices::BuildOmega ( )

Definition at line 156 of file GeoPixelLadderServices.cxx.

156 {
157
158 double xOffset = m_xOffset;
159 double yOffset = m_yOffset;
160 /*
161 double xUpperBend = xOffset + 2.9*Gaudi::Units::mm;
162 double yUpperBend = yOffset + 0;
163 double radUpperBend = 2.3*Gaudi::Units::mm;
164 double xLowerBend = xOffset + 0.9;
165 double yLowerBend = yOffset + 3.35*Gaudi::Units::mm;
166 double radLowerBend = 0.8*Gaudi::Units::mm;
167 double yStart= yOffset + (4.675+0.5*2.65)*Gaudi::Units::mm;
168 double yEnd = yOffset -yStart;
169 double thick = 0.3*Gaudi::Units::mm;
170 double length = 816*Gaudi::Units::mm;
171 double zOffset = 0;
172 */
173 double xUpperBend = xOffset + m_gmt_mgr->PixelOmegaUpperBendX();
174 double yUpperBend = yOffset + m_gmt_mgr->PixelOmegaUpperBendY();
175 double radUpperBend = m_gmt_mgr->PixelOmegaUpperBendRadius();
176 double xLowerBend = xOffset + m_gmt_mgr->PixelOmegaLowerBendX();
177 double yLowerBend = yOffset + m_gmt_mgr->PixelOmegaLowerBendY();
178 double radLowerBend = m_gmt_mgr->PixelOmegaLowerBendRadius();
179 double yStart= yOffset + m_gmt_mgr->PixelOmegaStartY();
180 double yEnd = yOffset + m_gmt_mgr->PixelOmegaEndY();
181 double thick = m_gmt_mgr->PixelOmegaWallThickness();
182 double length = m_gmt_mgr->PixelOmegaLength();
183 double zOffset = 0;
184
185 double sepX = (xUpperBend - xLowerBend);
186 double sepY = (yUpperBend - yLowerBend);
187 double sep2 = sepX*sepX+sepY*sepY;
188 double sep = sqrt(sep2);
189 double radDist = radUpperBend+radLowerBend-thick;
190 double alpha = atan(-sepY/sepX) - asin(radDist/sep);
191 double upperStraightLength = sqrt(sep2 - radDist*radDist);
192 double xLowerStraight = xLowerBend - (radLowerBend-0.5*thick)*sin(alpha);
193 double yLowerStraight = yLowerBend - (radLowerBend-0.5*thick)*cos(alpha);
194 double xUpperStraight = xUpperBend + (radUpperBend-0.5*thick)*sin(alpha);
195 double yUpperStraight = yUpperBend + (radUpperBend-0.5*thick)*cos(alpha);
196
197
198 // Tube sector for upper bend
199 GeoTubs * upperBendShape = new GeoTubs(radUpperBend - thick, radUpperBend, 0.5* length, alpha-0.5*Gaudi::Units::pi, Gaudi::Units::pi - 2*alpha);
200
201 // Tube sector for lower bend (+y)
202 GeoTubs * lowerBendShapeP = new GeoTubs(radLowerBend - thick, radLowerBend, 0.5* length, Gaudi::Units::pi, 0.5*Gaudi::Units::pi-alpha);
203
204 // Tube sector for lower bend (-y)
205 GeoTubs * lowerBendShapeM = new GeoTubs(radLowerBend - thick, radLowerBend, 0.5* length, 0.5*Gaudi::Units::pi + alpha, 0.5*Gaudi::Units::pi-alpha);
206
207 // Lower Straight section (+y)
208 GeoBox * lowerStraightBoxP = new GeoBox(0.5*thick, 0.5*(yStart - yLowerBend), 0.5*length);
209
210 // Lower Straight section (-y)
211 GeoBox * lowerStraightBoxM = new GeoBox(0.5*thick, 0.5*(-yLowerBend - yEnd), 0.5*length);
212
213 // Upper Straight section (+-y)
214 GeoBox * upperStraightBox = new GeoBox(0.5*thick, 0.5*upperStraightLength, 0.5*length);
215
216 // Put it all together
217 const GeoShape & omegaShape =
218 (*lowerStraightBoxP << GeoTrf::Translate3D(xLowerBend-radLowerBend+0.5*thick,0.5*(yLowerBend+yStart),zOffset) )
219 .add(*lowerBendShapeP << GeoTrf::Translate3D(xLowerBend,yLowerBend,zOffset) )
220 .add(*upperStraightBox << GeoTrf::Translate3D(0.5*(xLowerStraight+xUpperStraight),0.5*(yLowerStraight+yUpperStraight),zOffset)*GeoTrf::RotateZ3D(0.5*Gaudi::Units::pi-alpha) )
221 .add(*upperBendShape << GeoTrf::Translate3D(xUpperBend,yUpperBend,zOffset) )
222 .add(*upperStraightBox << GeoTrf::Translate3D(0.5*(xLowerStraight+xUpperStraight),-0.5*(yLowerStraight+yUpperStraight),zOffset)*GeoTrf::RotateZ3D(0.5*Gaudi::Units::pi+alpha) )
223 .add(*lowerBendShapeM << GeoTrf::Translate3D(xLowerBend,-yLowerBend,zOffset) )
224 .add(*lowerStraightBoxM << GeoTrf::Translate3D(xLowerBend-radLowerBend+0.5*thick,0.5*(-yLowerBend+yEnd),zOffset) );
225
226 double totVolume =
227 lowerStraightBoxP->volume()
228 + lowerBendShapeP->volume()
229 + 2*upperStraightBox->volume()
230 + upperBendShape->volume()
231 + lowerBendShapeM->volume()
232 + lowerStraightBoxM->volume();
233
234 std::string matName = m_gmt_mgr->getMaterialName("Omega", m_gmt_mgr->GetLD());
235 const GeoMaterial* omegaMat = m_mat_mgr->getMaterialForVolume(matName,totVolume);
236 GeoLogVol* omegaLV = new GeoLogVol("Omega",&omegaShape,omegaMat);
237 return new GeoPhysVol(omegaLV);
238
239}

◆ BuildPigtailAndConnector()

void GeoPixelLadderServices::BuildPigtailAndConnector ( GeoPhysVol * parent)

Definition at line 348 of file GeoPixelLadderServices.cxx.

348 {
349
350 double xOffset = m_xOffset + m_gmt_mgr->PixelLadderCableOffsetX() - m_gmt_mgr->PixelLadderServicesX();
351 double yOffset = m_yOffset + m_gmt_mgr->PixelLadderCableOffsetY() - m_gmt_mgr->PixelLadderServicesY();
352
353 // Pigtail flat section
354 double xPosPigtail = xOffset + m_gmt_mgr->PixelPigtailPosX();
355 double yPosPigtail = yOffset + 0.5*(m_gmt_mgr->PixelPigtailStartY() + m_gmt_mgr->PixelPigtailEndY());
356 double zPosPigtail = m_gmt_mgr->PixelPigtailPosZ();
357 double xWidthPigtail = m_gmt_mgr->PixelPigtailThickness();
358 double yWidthPigtail = std::abs(m_gmt_mgr->PixelPigtailStartY() - m_gmt_mgr->PixelPigtailEndY());
359 double zWidthPigtail = m_gmt_mgr->PixelPigtailFlatWidthZ();
360 std::string matNamePigtail = m_gmt_mgr->getMaterialName("PigtailFlat", m_gmt_mgr->GetLD());
361 GeoBox * pigtailShape = new GeoBox(0.5*xWidthPigtail, 0.5*yWidthPigtail, 0.5*zWidthPigtail);
362 const GeoMaterial* pigtailMat = m_mat_mgr->getMaterialForVolume(matNamePigtail,pigtailShape->volume());
363 GeoLogVol * pigtailLV = new GeoLogVol("PigtailFlat",pigtailShape,pigtailMat);
364 GeoPhysVol * pigtailPhys = new GeoPhysVol(pigtailLV);
365
366 // Connector
367 int numConn = m_gmt_mgr->PixelNumConnectorElements();
368 std::vector<GeoPhysVol *> connectorPhysVols(numConn);
369 std::vector<GeoTrf::Transform3D> connectorTransforms(numConn);
370 for (int iConn = 0; iConn < numConn; iConn++) {
371 double xPosConnector = xOffset + m_gmt_mgr->PixelConnectorPosX(iConn);
372 double yPosConnector = yOffset + m_gmt_mgr->PixelConnectorPosY(iConn);
373 double zPosConnector = m_gmt_mgr->PixelConnectorPosZ(iConn);
374 double xWidthConnector = m_gmt_mgr->PixelConnectorWidthX(iConn);
375 double yWidthConnector = m_gmt_mgr->PixelConnectorWidthY(iConn);
376 double zWidthConnector = m_gmt_mgr->PixelConnectorWidthZ(iConn);
377 std::string matNameConnector = m_gmt_mgr->getMaterialName("Connector", m_gmt_mgr->GetLD(), iConn);
378 GeoBox * connectorShape = new GeoBox(0.5*xWidthConnector, 0.5*yWidthConnector, 0.5*zWidthConnector);
379 const GeoMaterial* connectorMat = m_mat_mgr->getMaterialForVolume(matNameConnector,connectorShape->volume());
380 GeoLogVol * connectorLV = new GeoLogVol("Connector",connectorShape,connectorMat);
381 connectorPhysVols[iConn] = new GeoPhysVol(connectorLV);
382 connectorTransforms[iConn] = GeoTrf::Translate3D(xPosConnector, yPosConnector, zPosConnector);
383 }
384
385 for (int iModule = 0; iModule<m_gmt_mgr->PixelNModule(); iModule++) {
386 int moduleEta = m_gmt_mgr->PixelModuleEtaFromIndex(iModule);
387 double zShift = m_gmt_mgr->PixelModuleZPosition(moduleEta);
388
389 // Place pigtail
390 GeoTransform * xformPigtail = new GeoTransform(GeoTrf::Translate3D(xPosPigtail, yPosPigtail, zShift+zPosPigtail));
391 parent->add(xformPigtail);
392 parent->add(pigtailPhys);
393
394 // Place connector
395 for (int iConn = 0; iConn < numConn; iConn++) {
396 GeoTransform * xformConnector = new GeoTransform(GeoTrf::TranslateZ3D(zShift)*connectorTransforms[iConn]);
397 parent->add(xformConnector);
398 parent->add(connectorPhysVols[iConn]);
399 }
400 }
401}

◆ envelopeCornerA1()

const GeoTrf::Vector3D & GeoPixelLadderServices::envelopeCornerA1 ( )
inline

Definition at line 26 of file GeoPixelLadderServices.h.

26{return m_envelopeCornerA1;}

◆ envelopeCornerA2()

const GeoTrf::Vector3D & GeoPixelLadderServices::envelopeCornerA2 ( )
inline

Definition at line 27 of file GeoPixelLadderServices.h.

27{return m_envelopeCornerA2;}

◆ envelopeCornerC1()

const GeoTrf::Vector3D & GeoPixelLadderServices::envelopeCornerC1 ( )
inline

Definition at line 28 of file GeoPixelLadderServices.h.

28{return m_envelopeCornerC1;}

◆ envelopeCornerC2()

const GeoTrf::Vector3D & GeoPixelLadderServices::envelopeCornerC2 ( )
inline

Definition at line 29 of file GeoPixelLadderServices.h.

29{return m_envelopeCornerC2;}

◆ operator=()

GeoPixelLadderServices & GeoPixelLadderServices::operator= ( const GeoPixelLadderServices & )
delete

◆ referenceX()

double GeoPixelLadderServices::referenceX ( )
inline

Definition at line 30 of file GeoPixelLadderServices.h.

30{return m_xOffset;}

◆ referenceY()

double GeoPixelLadderServices::referenceY ( )
inline

Definition at line 31 of file GeoPixelLadderServices.h.

31{return m_yOffset;}

Member Data Documentation

◆ m_DDmgr

InDetDD::PixelDetectorManager* GeoVPixelFactory::m_DDmgr
protectedinherited

Definition at line 45 of file GeoVPixelFactory.h.

◆ m_envelopeCornerA1

GeoTrf::Vector3D GeoPixelLadderServices::m_envelopeCornerA1
private

Definition at line 42 of file GeoPixelLadderServices.h.

◆ m_envelopeCornerA2

GeoTrf::Vector3D GeoPixelLadderServices::m_envelopeCornerA2
private

Definition at line 43 of file GeoPixelLadderServices.h.

◆ m_envelopeCornerC1

GeoTrf::Vector3D GeoPixelLadderServices::m_envelopeCornerC1
private

Definition at line 44 of file GeoPixelLadderServices.h.

◆ m_envelopeCornerC2

GeoTrf::Vector3D GeoPixelLadderServices::m_envelopeCornerC2
private

Definition at line 45 of file GeoPixelLadderServices.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_ladderServicesLV

GeoIntrusivePtr<const GeoLogVol> GeoPixelLadderServices::m_ladderServicesLV {}
private

Definition at line 39 of file GeoPixelLadderServices.h.

39{};

◆ m_ladderType

int GeoPixelLadderServices::m_ladderType
private

Definition at line 40 of file GeoPixelLadderServices.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.

◆ m_xOffset

double GeoPixelLadderServices::m_xOffset
private

Definition at line 47 of file GeoPixelLadderServices.h.

◆ m_yOffset

double GeoPixelLadderServices::m_yOffset
private

Definition at line 48 of file GeoPixelLadderServices.h.

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