Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Public Member Functions | Protected Attributes | Private Member Functions | Private Attributes | List of all members
DBM_Module Class Reference

#include <DBM_Module.h>

Inheritance diagram for DBM_Module:
Collaboration diagram for DBM_Module:

Public Member Functions

 DBM_Module (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)
 
virtual GeoVPhysVol * Build () override
 

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 Member Functions

std::shared_ptr< const InDetDD::PixelDiodeMatrix > makeMatrix (double phiPitch, double etaPitch, double etaPitchLong, double etaPitchLongEnd, int circuitsPhi, int circuitsEta, int diodeRowPerCirc, int diodeColPerCirc)
 

Private Attributes

const InDetDD::SiDetectorDesign * m_design
 

Detailed Description

Build the DBM Module consisting of diamond sensor, FEI4 and ceramic substrate

Definition at line 26 of file DBM_Module.h.

Constructor & Destructor Documentation

◆ DBM_Module()

DBM_Module::DBM_Module ( 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 25 of file DBM_Module.cxx.

30  : GeoVPixelFactory (ddmgr, mgr, sqliteReader, std::move(mapFPV), std::move(mapAX))
31 {
32 
33  double thickness = 0.5;
34 
35  int circuitsPhi = 1;
36  int circuitsEta = 1;
37  int cellRowPerCirc = 80;
38  int cellColPerCirc = 336;
39  int diodeRowPerCirc = 80;
40  int diodeColPerCirc = 336;
41  int readoutSide = 1;
42 
43  double etaPitchLongEnd = 0.05;
44  double etaPitchLong = 0.05;
45  double phiPitch = 0.25;
46  double etaPitch = 0.05;
47 
48  std::shared_ptr<const PixelDiodeMatrix> fullMatrix = makeMatrix(phiPitch, etaPitch, etaPitchLong, etaPitchLongEnd,
49  circuitsPhi, circuitsEta, diodeRowPerCirc, diodeColPerCirc);
50 
51  std::unique_ptr<PixelModuleDesign> p_dbmdesign = std::make_unique<PixelModuleDesign>(thickness,
52  circuitsPhi,
53  circuitsEta,
54  cellColPerCirc,
55  cellRowPerCirc,
56  diodeColPerCirc,
57  diodeRowPerCirc,
58  fullMatrix,
59  InDetDD::electrons,
60  readoutSide);
61 
62 
63  m_design = m_DDmgr->addDesign(std::move(p_dbmdesign));
64 
65 
66 }

Member Function Documentation

◆ Build()

GeoVPhysVol * DBM_Module::Build ( )
overridevirtual

Implements GeoVPixelFactory.

Definition at line 68 of file DBM_Module.cxx.

69 {
70  const PixelID * idHelper = m_gmt_mgr->getIdHelper();
71  int dbmdet = 4*m_gmt_mgr->GetSide();
72  Identifier idwafer;
73  idwafer = idHelper->wafer_id(dbmdet,m_gmt_mgr->GetLD(),m_gmt_mgr->Phi(),m_gmt_mgr->Eta());
74 
75  if(m_sqliteReader) {
76  std::string key ="DBMDiamond_" + std::to_string(dbmdet) +"_"+ std::to_string(m_gmt_mgr->GetLD()) +"_"+ std::to_string(m_gmt_mgr->Phi()) +"_"+ std::to_string(m_gmt_mgr->Eta());
77  SiDetectorElement* element = new SiDetectorElement(idwafer, m_design, (*m_mapFPV)[key], m_gmt_mgr->commonItems());
78  // add the element to the manager
79  m_DDmgr->addDetectorElement(element);
80  m_DDmgr->addAlignableTransform(0, idwafer, (*m_mapAX)[key], (*m_mapFPV)[key]);
81  return nullptr;
82  }
83  else {
84  GeoIdentifierTag* diamondTag = new GeoIdentifierTag(400);
85 
86 
87  double safety = 0.003*Gaudi::Units::mm;
88 
89  //diamond dimension
90  double diamond_X = m_gmt_mgr->DBMDiamondX();
91  double diamond_Y = m_gmt_mgr->DBMDiamondY();
92  double diamond_Z = m_gmt_mgr->DBMDiamondZ();
93  double air_gap = m_gmt_mgr->DBMAirGap();
94 
95  //chip, FEI4 dimension
96  double chip_X = m_gmt_mgr->DBMFEI4X();
97  double chip_Y = m_gmt_mgr->DBMFEI4Y();
98  double chip_thick = m_gmt_mgr->DBMFEI4Z();
99 
100  //ceramic dimension
101  double substrate_X = m_gmt_mgr->DBMCeramicX();
102  double substrate_Y = m_gmt_mgr->DBMCeramicY();
103  double substrate_Z = m_gmt_mgr->DBMCeramicZ();
104 
105  //distances from bottom of the ceramic
106  //Hardcoded!
107  double bot2Chip = 0.0*Gaudi::Units::mm;
108  double bot2Diamond = 1.685*Gaudi::Units::mm;
109 
110 
111  //---------------------------------------------
112  // Get parameters for alignable Transform
113 
114  // Position of the corner closest to IP and beamline
115  // Hardcoded, so if change then change in GeoPixelEnvelope and DBM_Det too
116  double ZToIP = 887.002*Gaudi::Units::mm;
117  double RToBeam = 46.678*Gaudi::Units::mm;
118 
119  // layer spacing
120  double Zspacing = m_gmt_mgr->DBMSpacingZ();
121  double Rspacing = m_gmt_mgr->DBMSpacingRadial();
122  // gap between V-slide and first main plate
123  double layer1Space = m_gmt_mgr->DBMSpace();
124 
125  // parameters for rotating the 3-layer unit
126  double angle = m_gmt_mgr->DBMAngle(); // telescope tilting angle in degree
127  double bracketZ = m_gmt_mgr->DBMBracketZ(); // total thickness of the bracket unit,
128  double trapBackY = m_gmt_mgr->DBMTrapezBackY();
129  double trapBackShortZ = m_gmt_mgr->DBMTrapezBackShortZ();
130  double coolingSidePlateY = m_gmt_mgr->DBMCoolingSidePlateY();
131  double brcktLockZ = m_gmt_mgr->DBMBrcktLockZ();
132 
133  //double lyRadius = sqrt(layerUnitY*layerUnitY/4 + layerUnitZ*layerUnitZ/4);
134  //double lyAngle = atan(layerUnitY/layerUnitZ);
135  // position of the 3-layer unit's corner closest to the IP and beamline, which is the rotation point
136  double layerUnitPos_Y = (trapBackY/cos(angle) - coolingSidePlateY)*cos(angle);
137  double layerUnitPos_Z = coolingSidePlateY*sin(angle) + trapBackShortZ + bracketZ - brcktLockZ;
138  //---------------------------------------------
139 
140 
141 
142  const GeoMaterial* air = m_mat_mgr->getMaterial("std::Air");
143  //first try the Diamond
144  const GeoMaterial* diamond = m_mat_mgr->getMaterial("pix::Diamond");
145  if(diamond == nullptr)
146  {
147  diamond = m_mat_mgr->getMaterial("std::Carbon");
148  }
149 
150  const GeoMaterial* chip_mat = m_mat_mgr->getMaterial("pix::ChipBase");
151 
152  double max_thick = diamond_Z + air_gap + chip_thick + substrate_Z;
153 
154  //create a outer box to contain all volumes
155  const GeoBox* dbmModuleBox = new GeoBox(substrate_X/2.0 + safety, substrate_Y/2.0 + safety, max_thick/2.0 + safety);
156  const GeoLogVol* dbmModuleLog = new GeoLogVol("dbmModuleLog", dbmModuleBox, air);
157  GeoPhysVol* dbmModulePhys = new GeoPhysVol(dbmModuleLog);
158 
159  GeoTrf::Transform3D rm = GeoTrf::RotateZ3D(90.*Gaudi::Units::deg)*GeoTrf::RotateY3D(270.*Gaudi::Units::deg);
160 
161  //diamond
162  const GeoBox* dbmDiamondBox = new GeoBox(diamond_Z/2.0, diamond_X/2.0, diamond_Y/2.0 );
163  const GeoLogVol* dbmDiamondLog = new GeoLogVol("dbmDiamondLog", dbmDiamondBox, diamond);
164  GeoFullPhysVol* dbmDiamondPhys = new GeoFullPhysVol(dbmDiamondLog);
165 
166  SiDetectorElement* element= new SiDetectorElement(idwafer, m_design, dbmDiamondPhys, m_gmt_mgr->commonItems());
167  // add the element to the manager
168  m_DDmgr->addDetectorElement(element);
169 
170  GeoTrf::Translation3D dbmDiamondPos(0, bot2Diamond+diamond_Y/2.0-substrate_Y/2.0, diamond_Z/2.0-max_thick/2.0);
171  GeoTransform* xform = new GeoTransform(GeoTrf::Transform3D(dbmDiamondPos*rm));
172 
173  dbmModulePhys->add(diamondTag);
174  dbmModulePhys->add(xform);
175  dbmModulePhys->add(dbmDiamondPhys);
176 
177  //FEI4 chip
178  const GeoBox* dbmFEI4Box = new GeoBox(chip_thick/2.0, chip_X/2.0, chip_Y/2.0 );
179  const GeoLogVol* dbmFEI4Log = new GeoLogVol("dbmWallLogF4", dbmFEI4Box, chip_mat); //should this be "dbmdiamondLog"?
180  GeoPhysVol* dbmFEI4Phys = new GeoPhysVol(dbmFEI4Log);
181 
182  GeoTrf::Translation3D dbmFEI4Pos(0, bot2Chip+chip_Y/2.0-substrate_Y/2.0, max_thick/2.0-substrate_Z-chip_thick/2.0);
183  xform = new GeoTransform(GeoTrf::Transform3D(dbmFEI4Pos*rm));
184 
185  dbmModulePhys->add(xform);
186  dbmModulePhys->add(dbmFEI4Phys);
187 
188  //ceramic support
189  const GeoBox* dbmSubstBox = new GeoBox(substrate_X/2.0, substrate_Y/2.0, substrate_Z/2.0);
190  const GeoMaterial* aluminiumNitride = m_mat_mgr->getMaterialForVolume("pix::DBMCeramic", dbmSubstBox->volume());
191  const GeoLogVol* dbmSubstLog = new GeoLogVol("dbmWallLogCe", dbmSubstBox, aluminiumNitride);
192  GeoPhysVol* dbmSubstPhys = new GeoPhysVol(dbmSubstLog);
193 
194  GeoTrf::Translate3D dbmSubstPos(0, 0, max_thick/2.0-substrate_Z/2.0);
195  xform = new GeoTransform(dbmSubstPos);
196 
197  dbmModulePhys->add(xform);
198  dbmModulePhys->add(dbmSubstPhys);
199 
200  //-----------------------------------------------------
201  //Add to alignable transform
202  // DBM has only level 0 alignable transform.
203  // So, a transform w.r.t global position is created.
204  // This mean the alignable pos below should be
205  // the global position of the sensor
206 
207  int layer = m_gmt_mgr->GetLD();
208  double sensorPosInModuleCage_Z = layer1Space + layer*Zspacing - (substrate_Z + chip_thick + air_gap + diamond_Z/2.);
209  double sensorPosInModuleCage_Y = Rspacing + bot2Diamond + diamond_Y/2.;
210  double globPosZ = ZToIP + layerUnitPos_Z + (sensorPosInModuleCage_Z * cos(angle) - sensorPosInModuleCage_Y * sin(angle));
211  double globPosY = RToBeam + layerUnitPos_Y + (sensorPosInModuleCage_Z * sin(angle) + sensorPosInModuleCage_Y * cos(angle));
212 
213  GeoTrf::RotateX3D rmX10(-10.*Gaudi::Units::deg);
214  GeoTrf::Translation3D alignTransformPos(0, globPosY, globPosZ);
215  GeoAlignableTransform *xformAlign = new GeoAlignableTransform(GeoTrf::Transform3D(alignTransformPos*rmX10));
216  m_DDmgr->addAlignableTransform(0, idwafer, xformAlign, dbmDiamondPhys);
217  //-----------------------------------------------------
218 
219  return dbmModulePhys;
220  }
221 }

◆ makeMatrix()

std::shared_ptr< const PixelDiodeMatrix > DBM_Module::makeMatrix ( double  phiPitch,
double  etaPitch,
double  etaPitchLong,
double  etaPitchLongEnd,
int  circuitsPhi,
int  circuitsEta,
int  diodeRowPerCirc,
int  diodeColPerCirc 
)
private

Definition at line 224 of file DBM_Module.cxx.

226 {
227  // There are several different cases. Not all are used at the time of wrtiting the code but I
228  // have tried to consider all possible cases for completeness.
229  //
230  // end cell : middle cells : between chip
231  // --------------------------------------
232  // long:normal:long (standard ATLAS case)
233  // normal:normal:normal
234  // normal:normal:long (> 2 chips)
235  // normal:normal:long (2 chips)
236  // end:normal:long (not likely)
237  // end:normal:normal (not likely)
238  // end:normal:end (if single chip)
239 
240  std::shared_ptr<const PixelDiodeMatrix> fullMatrix = nullptr;
241 
242  if (etaPitchLongEnd == etaPitchLong && etaPitchLong != etaPitch) {
243  // long:normal:long (standard ATLAS case)
244  if (m_gmt_mgr->msgLvl(MSG::DEBUG)) m_gmt_mgr->msg(MSG::DEBUG) << "DBMModule: Making matrix (long:normal:long, Standard ATLAS case)" << endmsg;
245 
246  std::shared_ptr<const PixelDiodeMatrix> normalCell = PixelDiodeMatrix::construct(phiPitch, etaPitch);
247  std::shared_ptr<const PixelDiodeMatrix> bigCell = PixelDiodeMatrix::construct(phiPitch, etaPitchLong);
248 
249  std::shared_ptr<const PixelDiodeMatrix> singleChipRow = PixelDiodeMatrix::construct(PixelDiodeMatrix::etaDir,
250  bigCell,
251  std::move(normalCell),
252  diodeColPerCirc-2,
253  bigCell);
254 
255  std::shared_ptr<const PixelDiodeMatrix> singleRow = PixelDiodeMatrix::construct(PixelDiodeMatrix::etaDir,
256  nullptr, std::move(singleChipRow), circuitsEta, nullptr);
257 
258  fullMatrix = PixelDiodeMatrix::construct(PixelDiodeMatrix::phiDir,
259  nullptr, std::move(singleRow), circuitsPhi*diodeRowPerCirc, nullptr);
260  } else if (etaPitchLongEnd == etaPitchLong && (etaPitchLong == etaPitch || circuitsEta == 1)) {
261  // normal:normal:normal
262  if (m_gmt_mgr->msgLvl(MSG::DEBUG)) m_gmt_mgr->msg(MSG::DEBUG) << "DBMModule: Making matrix (normal:normal:normal)" << endmsg;
263  std::shared_ptr<const PixelDiodeMatrix> normalCell = PixelDiodeMatrix::construct(phiPitch, etaPitch);
264  std::shared_ptr<const PixelDiodeMatrix> singleRow = PixelDiodeMatrix::construct(PixelDiodeMatrix::etaDir,
265  nullptr, std::move(normalCell), circuitsEta*diodeColPerCirc, nullptr);
266  fullMatrix = PixelDiodeMatrix::construct(PixelDiodeMatrix::phiDir,
267  nullptr, std::move(singleRow), circuitsPhi*diodeRowPerCirc, nullptr);
268  } else if (etaPitchLongEnd == etaPitch && etaPitchLong != etaPitch && circuitsEta > 2) {
269  if (m_gmt_mgr->msgLvl(MSG::DEBUG)) m_gmt_mgr->msg(MSG::DEBUG) << "DBMModule: Making matrix (normal:normal:long, > 2 chips)" << endmsg;
270  // normal:normal:long: > 2 chips
271  std::shared_ptr<const PixelDiodeMatrix> normalCell = PixelDiodeMatrix::construct(phiPitch, etaPitch);
272  std::shared_ptr<const PixelDiodeMatrix> bigCell = PixelDiodeMatrix::construct(phiPitch, etaPitchLong);
273 
274  std::shared_ptr<const PixelDiodeMatrix> lowerSingleChipRow = PixelDiodeMatrix::construct(PixelDiodeMatrix::etaDir,
275  nullptr,
276  normalCell,
277  diodeColPerCirc-1,
278  bigCell);
279  std::shared_ptr<const PixelDiodeMatrix> middleSingleChipRow = PixelDiodeMatrix::construct(PixelDiodeMatrix::etaDir,
280  bigCell,
281  normalCell,
282  diodeColPerCirc-2,
283  bigCell);
284  std::shared_ptr<const PixelDiodeMatrix> upperSingleChipRow = PixelDiodeMatrix::construct(PixelDiodeMatrix::etaDir,
285  std::move(bigCell),
286  std::move(normalCell),
287  diodeColPerCirc-1,
288  nullptr);
289  std::shared_ptr<const PixelDiodeMatrix> singleRow = PixelDiodeMatrix::construct(PixelDiodeMatrix::etaDir,
290  std::move(lowerSingleChipRow), std::move(middleSingleChipRow), circuitsEta-2, std::move(upperSingleChipRow));
291  fullMatrix = PixelDiodeMatrix::construct(PixelDiodeMatrix::phiDir,
292  nullptr, std::move(singleRow), circuitsPhi*diodeRowPerCirc, nullptr);
293  } else if (etaPitchLongEnd == etaPitch && etaPitchLong != etaPitch && circuitsEta == 2) {
294  // normal:normal:long: 2 chips (current SLHC case)
295  if (m_gmt_mgr->msgLvl(MSG::DEBUG)) m_gmt_mgr->msg(MSG::DEBUG) << "DBMModule: Making matrix (normal:normal:long, 2 chips)" << endmsg;
296  std::shared_ptr<const PixelDiodeMatrix> normalCell = PixelDiodeMatrix::construct(phiPitch, etaPitch);
297  std::shared_ptr<const PixelDiodeMatrix> bigCell = PixelDiodeMatrix::construct(phiPitch, etaPitchLong);
298 
299  std::shared_ptr<const PixelDiodeMatrix> lowerSingleChipRow = PixelDiodeMatrix::construct(PixelDiodeMatrix::etaDir,
300  nullptr,
301  normalCell,
302  diodeColPerCirc-1,
303  bigCell);
304  std::shared_ptr<const PixelDiodeMatrix> upperSingleChipRow = PixelDiodeMatrix::construct(PixelDiodeMatrix::etaDir,
305  std::move(bigCell),
306  std::move(normalCell),
307  diodeColPerCirc-1,
308  nullptr);
309  std::shared_ptr<const PixelDiodeMatrix> singleRow = PixelDiodeMatrix::construct(PixelDiodeMatrix::etaDir,
310  std::move(lowerSingleChipRow), std::move(upperSingleChipRow), 1, nullptr);
311  fullMatrix = PixelDiodeMatrix::construct(PixelDiodeMatrix::phiDir,
312  nullptr, std::move(singleRow), circuitsPhi*diodeRowPerCirc, nullptr);
313  } else if (circuitsEta == 1 || (etaPitchLongEnd != etaPitch && etaPitchLong == etaPitch )){ // etaPitchLongEnd != etaPitch at this stage
314  // end:normal:end (for single chip)
315  // end:normal:normal (not likely)
316  if (m_gmt_mgr->msgLvl(MSG::DEBUG)) m_gmt_mgr->msg(MSG::DEBUG) << "DBMModule: Making matrix (end:normal:end, single chips or end:normal:normal)" << endmsg;
317  std::shared_ptr<const PixelDiodeMatrix> normalCell = PixelDiodeMatrix::construct(phiPitch, etaPitch);
318  std::shared_ptr<const PixelDiodeMatrix> bigCell = PixelDiodeMatrix::construct(phiPitch, etaPitchLongEnd);
319 
320  std::shared_ptr<const PixelDiodeMatrix> singleRow = PixelDiodeMatrix::construct(PixelDiodeMatrix::etaDir,
321  bigCell,
322  std::move(normalCell),
323  circuitsEta*diodeColPerCirc-2,
324  bigCell);
325  fullMatrix = PixelDiodeMatrix::construct(PixelDiodeMatrix::phiDir,
326  nullptr, std::move(singleRow), circuitsPhi*diodeRowPerCirc, nullptr);
327  } else {
328  // end:normal:long (not likely)
329  if (m_gmt_mgr->msgLvl(MSG::DEBUG)) m_gmt_mgr->msg(MSG::DEBUG)<< "DBMModule: Making matrix (end:normal:long)" << endmsg;
330  std::shared_ptr<const PixelDiodeMatrix> normalCell = PixelDiodeMatrix::construct(phiPitch, etaPitch);
331  std::shared_ptr<const PixelDiodeMatrix> bigCell = PixelDiodeMatrix::construct(phiPitch, etaPitchLong);
332  std::shared_ptr<const PixelDiodeMatrix> endCell = PixelDiodeMatrix::construct(phiPitch, etaPitchLongEnd);
333 
334  std::shared_ptr<const PixelDiodeMatrix> lowerSingleChipRow = PixelDiodeMatrix::construct(PixelDiodeMatrix::etaDir,
335  endCell,
336  normalCell,
337  diodeColPerCirc-2,
338  bigCell);
339  std::shared_ptr<const PixelDiodeMatrix> middleSingleChipRow = PixelDiodeMatrix::construct(PixelDiodeMatrix::etaDir,
340  bigCell,
341  normalCell,
342  diodeColPerCirc-2,
343  bigCell);
344  std::shared_ptr<const PixelDiodeMatrix> upperSingleChipRow = PixelDiodeMatrix::construct(PixelDiodeMatrix::etaDir,
345  std::move(bigCell),
346  std::move(normalCell),
347  diodeColPerCirc-2,
348  std::move(endCell));
349  std::shared_ptr<const PixelDiodeMatrix> singleRow = PixelDiodeMatrix::construct(PixelDiodeMatrix::etaDir,
350  std::move(lowerSingleChipRow), std::move(middleSingleChipRow), circuitsEta-2, std::move(upperSingleChipRow));
351  fullMatrix = PixelDiodeMatrix::construct(PixelDiodeMatrix::phiDir,
352  nullptr, std::move(singleRow), circuitsPhi*diodeRowPerCirc, nullptr);
353 
354  }
355 
356  return fullMatrix;
357 }

Member Data Documentation

◆ m_DDmgr

InDetDD::PixelDetectorManager* GeoVPixelFactory::m_DDmgr
protectedinherited

Definition at line 45 of file GeoVPixelFactory.h.

◆ m_design

const InDetDD::SiDetectorDesign* DBM_Module::m_design
private

Definition at line 38 of file DBM_Module.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:
PixelGeometryManager::DBMBrcktLockZ
virtual double DBMBrcktLockZ()=0
PixelGeometryManager::DBMBracketZ
virtual double DBMBracketZ()=0
PixelGeometryManager::DBMDiamondZ
virtual double DBMDiamondZ()=0
PixelGeometryManager::DBMSpacingRadial
virtual double DBMSpacingRadial()=0
PixelGeometryManager::msg
MsgStream & msg(MSG::Level lvl) const
Definition: PixelGeometryManager.h:611
PixelGeometryManager::DBMDiamondX
virtual double DBMDiamondX()=0
PixelGeometryManager::DBMCeramicY
virtual double DBMCeramicY()=0
PixelGeometryManager::DBMTrapezBackShortZ
virtual double DBMTrapezBackShortZ()=0
deg
#define deg
Definition: SbPolyhedron.cxx:17
InDetDD::SiDetectorManager::addDesign
const SiDetectorDesign * addDesign(std::unique_ptr< const SiDetectorDesign > &&)
Access to module design; returns an observer pointer.
Definition: SiDetectorManager.cxx:134
PixelGeometryManager::msgLvl
bool msgLvl(MSG::Level lvl) const
Definition: PixelGeometryManager.h:614
PixelGeometryManager::DBMSpace
virtual double DBMSpace()=0
PixelGeometryManager::GetSide
virtual int GetSide()=0
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
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
PixelID::wafer_id
Identifier wafer_id(int barrel_ec, int layer_disk, int phi_module, int eta_module) const
For a single crystal.
Definition: PixelID.h:364
GeoVPixelFactory::m_DDmgr
InDetDD::PixelDetectorManager * m_DDmgr
Definition: GeoVPixelFactory.h:45
PixelGeometryManager::DBMAirGap
virtual double DBMAirGap()=0
GeoVPixelFactory::m_gmt_mgr
PixelGeometryManager * m_gmt_mgr
Definition: GeoVPixelFactory.h:43
GeoVPixelFactory::m_mapFPV
std::shared_ptr< std::map< std::string, GeoFullPhysVol * > > m_mapFPV
Definition: GeoVPixelFactory.h:47
BchCleanup.mgr
mgr
Definition: BchCleanup.py:294
DBM_Module::makeMatrix
std::shared_ptr< const InDetDD::PixelDiodeMatrix > makeMatrix(double phiPitch, double etaPitch, double etaPitchLong, double etaPitchLongEnd, int circuitsPhi, int circuitsEta, int diodeRowPerCirc, int diodeColPerCirc)
Definition: DBM_Module.cxx:224
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
angle
double angle(const GeoTrf::Vector2D &a, const GeoTrf::Vector2D &b)
Definition: TRTDetectorFactory_Full.cxx:73
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
PixelGeometryManager::Eta
virtual int Eta()=0
InDetMaterialManager::getMaterialForVolume
const GeoMaterial * getMaterialForVolume(const std::string &materialName, double volume, const std::string &newName="")
Create and get material with a density calculated to give weight in predefined weight table.
Definition: InDetMaterialManager.cxx:460
PixelGeometryManager::DBMAngle
virtual double DBMAngle()=0
PixelGeometryManager::DBMCoolingSidePlateY
virtual double DBMCoolingSidePlateY()=0
PixelGeometryManager::DBMSpacingZ
virtual double DBMSpacingZ()=0
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
PixelGeometryManager::DBMTrapezBackY
virtual double DBMTrapezBackY()=0
InDetDD::PixelDetectorManager::addAlignableTransform
virtual void addAlignableTransform(int level, const Identifier &id, GeoAlignableTransform *xf, const GeoVFullPhysVol *child)
Add alignable transforms.
Definition: PixelDetectorManager.cxx:262
PixelGeometryManager::DBMCeramicZ
virtual double DBMCeramicZ()=0
PixelGeometryManager::DBMCeramicX
virtual double DBMCeramicX()=0
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
InDetDD::SiDetectorElement
Definition: SiDetectorElement.h:109
GeoVPixelFactory::m_mat_mgr
InDetMaterialManager * m_mat_mgr
Definition: GeoVPixelFactory.h:44
python.SystemOfUnits.mm
int mm
Definition: SystemOfUnits.py:83
DBM_Module::m_design
const InDetDD::SiDetectorDesign * m_design
Definition: DBM_Module.h:38
PixelGeometryManager::DBMDiamondY
virtual double DBMDiamondY()=0
DEBUG
#define DEBUG
Definition: page_access.h:11
Amg::Translation3D
Eigen::Translation< double, 3 > Translation3D
Definition: GeoPrimitives.h:44
PixelGeometryManager::DBMFEI4X
virtual double DBMFEI4X()=0
PixelGeometryManager::getIdHelper
virtual const PixelID * getIdHelper()=0
PixelGeometryManager::commonItems
virtual InDetDD::SiCommonItems * commonItems()=0
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
InDetMaterialManager::getMaterial
const GeoMaterial * getMaterial(const std::string &materialName)
Get material. First looks for locally defined material and if not found looks in GeoModel material ma...
Definition: InDetMaterialManager.cxx:96
PixelID
Definition: PixelID.h:67
PixelGeometryManager::DBMFEI4Z
virtual double DBMFEI4Z()=0
InDetDD::electrons
@ electrons
Definition: InDetDD_Defs.h:17
InDetDD::PixelDetectorManager::addDetectorElement
virtual void addDetectorElement(SiDetectorElement *element) override
Add elememts.
Definition: PixelDetectorManager.cxx:121
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
PixelGeometryManager::DBMFEI4Y
virtual double DBMFEI4Y()=0
PixelGeometryManager::GetLD
virtual int GetLD()=0
PixelGeometryManager::Phi
virtual int Phi()=0
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Thu Apr 10 2025 21:29:46 for ATLAS Offline Software by   doxygen 1.8.18