ATLAS Offline Software
SiGeometryManagerTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
6 
10 
11 #include "InDetIdentifier/SCT_ID.h"
14 
16 
19 #include "TrkAlignEvent/AlignPar.h"
20 
22 #include <ostream>
23 
24 
25 using namespace InDetDD;
26 
27 namespace InDet {
28 
29  //________________________________________________________________________
30  SiGeometryManagerTool::SiGeometryManagerTool(const std::string& type,
31  const std::string& name,
32  const IInterface * parent)
34  , m_pixelDetManager(nullptr)
35  , m_sctDetManager(nullptr)
36  , m_pixHelper()
37  , m_sctHelper()
38  , m_idHelper()
39  , m_pixelGeoManager("")
40  , m_sctGeoManager("")
41  , m_alignModuleTool("Trk::AlignModuleTool/AlignModuleTool")
42  , m_idHashToAlignModuleMaps(Trk::AlignModule::NDetectorTypes,(Trk::AlignModuleList*)nullptr)
43  , m_alignParList(nullptr)
44  , m_fullAlignParList(nullptr)
45  {
46  declareInterface<IGeometryManagerTool>(this);
47  declareProperty("AlignModuleTool", m_alignModuleTool);
48 
49  declareProperty("PixelGeometryManager", m_pixelGeoManager);
50  declareProperty("SCTGeometryManager", m_sctGeoManager);
51 
52  // Silicon joboptions
53  declareProperty("AlignPixel", m_alignPixel = true);
54  declareProperty("AlignSCT", m_alignSCT = true);
55 
56  declareProperty("AlignX", m_alignX = true);
57  declareProperty("AlignY", m_alignY = true);
58  declareProperty("AlignZ", m_alignZ = true);
59  declareProperty("AlignRotX", m_alignRotX = true);
60  declareProperty("AlignRotY", m_alignRotY = true);
61  declareProperty("AlignRotZ", m_alignRotZ = true);
62 
63  declareProperty("SetSigmaX", m_sigmaX = 1.);
64  declareProperty("SetSigmaY", m_sigmaY = 1.);
65  declareProperty("SetSigmaZ", m_sigmaZ = 1.);
66  declareProperty("SetSigmaRotX", m_sigmaRotX = 0.001);
67  declareProperty("SetSigmaRotY", m_sigmaRotY = 0.001);
68  declareProperty("SetSigmaRotZ", m_sigmaRotZ = 0.001);
69 
70  // defines alignment level
71  declareProperty("AlignmentLevel", m_alignLevel = -1);
72 
73  declareProperty("doModuleSelection", m_doModuleSelection = false);
74  declareProperty("ModuleSelection", m_moduleSelection);
75 
76  declareProperty("DumpGeometry", m_dumpGeometry = true);
77  declareProperty("ActualGeometry", m_actualGeom = false);
78 
79  m_hashCounter = 0;
80  m_logStream = nullptr;
81  }
82 
83  //________________________________________________________________________
85  {
86  ATH_MSG_DEBUG("deleting alignModuleList");
87  for (const auto & i:m_alignModuleList) delete i;
88  m_alignModuleList.clear();
89 
90  ATH_MSG_DEBUG("deleting fullAlignParList");
91  delete m_fullAlignParList;
92  ATH_MSG_DEBUG("deleting alignParList");
93  delete m_alignParList;
94  }
95 
96  //________________________________________________________________________
98  {
99  ATH_MSG_DEBUG("initialize() of SiGeometryManagerTool");
100 
101  // retrieve AlignModuleTool
102  ATH_CHECK( m_alignModuleTool.retrieve() );
103 
104  // retrieve Pixel helper
106 
107  // retrieve SCT helper
109 
110  // retrieve silicon helper
112 
113  // retrieve SCT detector manager
115 
116  // retrieve PIX detector manager
118 
119  // dump module selection
121  int idx{};
122  ATH_MSG_INFO("Creating geometry for selected "<<m_moduleSelection.size()<<" modules:");
123  for(const auto & mod:m_moduleSelection)
124  ATH_MSG_INFO(" "<<idx++<<". "<<mod);
125  }
126 
127  // retrieve PixelGeometryManagerTool
128  if ( !m_pixelGeoManager.empty() ) {
129  ATH_CHECK( m_pixelGeoManager.retrieve() );
130  }
131 
132  // retrieve SCTGeometryManagerTool
133  if ( !m_sctGeoManager.empty() ) {
134  ATH_CHECK( m_sctGeoManager.retrieve() );
135  }
136 
137  if(!m_alignPixel && !m_alignSCT) {
138  ATH_MSG_FATAL("Alignment of both Pixel and SCT turned off. Aborting.");
139  return StatusCode::FAILURE;
140  }
141 
142  // check allowed alignment level
143  if(!checkAlignLevel()) {
144  ATH_MSG_FATAL("Wrong alignment level.");
145  return StatusCode::FAILURE;
146  }
147 
148  return StatusCode::SUCCESS;
149  }
150 
151  //________________________________________________________________________
153  {
154  ATH_MSG_DEBUG("finalize() of SiGeometryManagerTool");
155 
156  return StatusCode::SUCCESS;
157  }
158 
159  //________________________________________________________________________
161  {
162  switch(m_alignLevel) {
163 
164  case 0:
165  // for L0 we don't need the other two managers so everything is ok
166  ATH_MSG_INFO("Setting up level 0 alignment of the Silicon");
167  break;
168 
169  case 1: case 2: case 3:
170  // for levels 1,2,3 we need the managers and we have to
171  // set the levels in them
172  if( (m_pixelGeoManager.empty() && m_alignPixel) || (m_sctGeoManager.empty() && m_alignSCT) ) {
173  ATH_MSG_ERROR("PixelGeometryManagerTool and/or SCTGeometryManagerTool not available");
174  ATH_MSG_ERROR("Can't set alignment geometry.");
175  return false;
176  }
177 
178  ATH_MSG_INFO("Setting up level "<<m_alignLevel<<" alignment of the Silicon");
179  m_pixelGeoManager->setAlignLevel(m_alignLevel);
180  m_sctGeoManager->setAlignLevel(m_alignLevel);
181 
182  // we also check that the managers support the levels
183  if( (m_alignPixel && !m_pixelGeoManager->checkAlignLevel()) || (m_alignSCT && !m_sctGeoManager->checkAlignLevel()) )
184  return false;
185  break;
186 
187  case -1:
188  // if level is not set here (i.e. it is equal to -1) we need the Pixel and SCT
189  // managers but we trust their setup, we don't need to check it
190  if( (m_pixelGeoManager.empty() && m_alignPixel) || (m_sctGeoManager.empty() && m_alignSCT) ) {
191  ATH_MSG_ERROR("PixelGeometryManagerTool and/or SCTGeometryManagerTool not available");
192  ATH_MSG_ERROR("Can't set alignment geometry.");
193  return false;
194  }
195  break;
196 
197  default:
198  ATH_MSG_ERROR("Unknown alignment level "<<m_alignLevel<<". Can't set alignment geometry.");
199  return false;
200 
201  }
202 
203  return true;
204  }
205 
206  //________________________________________________________________________
208  {
209  m_logStream = os;
210  if (!m_pixelGeoManager.empty())
211  m_pixelGeoManager->setLogStream(m_logStream);
212  if (!m_sctGeoManager.empty())
213  m_sctGeoManager->setLogStream(m_logStream);
214  }
215 
216  //________________________________________________________________________
218  {
219  ATH_MSG_DEBUG("in ReadGeometry() solveLevel="<<solveLevel);
220 
221  // set pointers
224 
225  // build alignment geometry
226  buildGeometry();
227 
228  // now set the alignment parameters
229  // first prepare the parameter lists
232  // loop over modules
233  ATH_MSG_DEBUG("Adding module parameters to modules");
234  std::vector<Trk::AlignModule *>::const_iterator imod = m_alignModuleList.begin();
235  std::vector<Trk::AlignModule *>::const_iterator imod_end = m_alignModuleList.end();
236  for( ; imod!=imod_end ; ++imod) {
237  ATH_MSG_DEBUG("Module "<<(*imod)->name());
239  }
240 
241  // set alignModuleList and hash table in the alignModuleTool
243  ATH_MSG_DEBUG(" geometry set in m_alignModuleTool");
244 
245  // set alignPar lists in the alignModuleTool
246  ATH_MSG_DEBUG(" alignParList = "<<m_alignParList);
247  ATH_MSG_DEBUG(" fullAlignParList = "<<m_fullAlignParList);
249  ATH_MSG_DEBUG(" AlignParLists set in m_alignModuleTool");
250 
251  // dump summary about the geometry setup
252  if (m_dumpGeometry)
253  dumpGeometry();
254 
255  int nDoF= m_alignModuleTool->nAlignParameters();
256  ATH_MSG_INFO("Total number of degrees of freedom: "<<nDoF);
257 
258  return nDoF;
259  }
260 
261  //_______________________________________________________________________
263  {
264  ATH_MSG_INFO("Preparing the Silicon geometry");
265 
266  int idHash = 0;
267 
268  if(m_alignLevel==0)
269  buildL0();
270 
271  else {
272 
273  // PIXEL
274  if(m_alignPixel) {
275  m_pixelGeoManager->setFirstIDHash(idHash);
276  m_pixelGeoManager->setModuleList(m_alignModuleListPtr);
278 
279  m_pixelGeoManager->buildGeometry();
280 
281  idHash=m_pixelGeoManager->getNextIDHash();
282  }
283 
284  // SCT
285  if(m_alignSCT) {
286  m_sctGeoManager->setFirstIDHash(idHash);
287  m_sctGeoManager->setModuleList(m_alignModuleListPtr);
289 
290  m_sctGeoManager->buildGeometry();
291  }
292  }
293 
294  }
295 
296  //_______________________________________________________________________
298  {
299  ATH_MSG_INFO("Preparing the Silicon geometry for L0");
300  // ========================================
301  // Level 0 is just one module containing
302  // the whole Silicon detector (Pixel+SCT)
303 
304  Trk::AlignModule * silicon = new Trk::AlignModule(this);
305  silicon->setIdHash(getNextIDHash());
306  silicon->setName("Silicon");
307 
308  // use the identifier of the Pixel for the whole Silicon at L0
309  silicon->setIdentifier(m_pixHelper->wafer_id(0,0,0,0));
310 
311  // check if we're aligning Silicon
312  if(!moduleSelected(silicon)) {
313  ATH_MSG_DEBUG("Module "<<silicon->name()<<" NOT selected");
314  delete silicon;
315  return;
316  }
317 
318  ATH_MSG_DEBUG("Created module "<<silicon->name()<<" idHash: "<<silicon->identifyHash()<<" identifier: "<<silicon->identify());
319 
320  // for L0 alignment the alignment frame is equal to the global frame
321  // and since the PIXEL and SCT detector element positions are also stored
322  // in the global frame in DB, transform is identity
323  const Amg::Transform3D transform = Amg::Transform3D::Identity();
324 
325  // PIXEL
326  // get maximum number of elements from the helper
327  unsigned int pixelmaxHash = m_pixHelper->wafer_hash_max();
328  ATH_MSG_DEBUG("maxHash for the Pixel: "<<pixelmaxHash);
329 
331  m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::Pixel) = new Trk::AlignModuleList((size_t)(pixelmaxHash),nullptr);
333 
334  // ==================================================================
335  // loop over Pixel elements and add them to respective alignModules
336  // ==================================================================
337  for (unsigned int index = 0; index < pixelmaxHash; index++) {
338  IdentifierHash idHash = index;
339  Identifier id = m_pixHelper->wafer_id(idHash);
340 
341  ATH_MSG_DEBUG(" Pixel DetectorElement idhash: "<<index);
342  ATH_MSG_DEBUG(" DetectorElement id: "<<id);
343 
344  // get the element via hash
346  if (element2) {
347  const Trk::TrkDetElementBase * element = static_cast<const Trk::TrkDetElementBase*> (element2);
348 
349  // get element location for debugging
350  // HepGeom::Point3D<double> center = element->transform() * HepGeom::Point3D<double>();
351  // ATH_MSG_DEBUG(" DetectorElement idhash: " << index);
352  // ATH_MSG_DEBUG(" DetectorElement id: " << id << " with center = " << center);
353  // ATH_MSG_DEBUG(" Is Barrel: "<< m_pixHelper->is_barrel(id));
354 
355  // add element to respective AlignModule
356 
357  // add to the pixel structure
358  if(msgLvl(MSG::DEBUG)) {
359  if (m_pixHelper->is_barrel(id))
360  msg(MSG::DEBUG)<<"... Pixel barrel element"<<endmsg;
361  else
362  msg(MSG::DEBUG)<<"... Pixel endcap element"<<endmsg;
363  }
365 
366  // and fill the corresponding map
367  (*pixelIdHashMap)[idHash] = silicon;
368  }
369  else
370  ATH_MSG_DEBUG("No Pixel detector with id: "<<id);
371  }
372 
373  // SCT
374  // get maximum number of elements from the helper
375  unsigned int sctmaxHash = m_sctHelper->wafer_hash_max();
376  ATH_MSG_DEBUG("maxHash for the SCT: "<<sctmaxHash);
377 
379  m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::SCT) = new Trk::AlignModuleList((size_t)(sctmaxHash),nullptr);
381 
382  // ================================================================
383  // loop over SCT elements and add them to respective alignModules
384  // ================================================================
385  for (unsigned int index = 0; index < sctmaxHash; index++) {
386  IdentifierHash idHash = index;
387  Identifier id = m_sctHelper->wafer_id(idHash);
388 
389  ATH_MSG_DEBUG(" SCT DetectorElement idhash: "<<index);
390  ATH_MSG_DEBUG(" DetectorElement id: "<<id);
391 
392  // get the element via hash
393  const SiDetectorElement * element2 = m_sctDetManager->getDetectorElement(id);
394  if (element2) {
395  const Trk::TrkDetElementBase * element = static_cast<const Trk::TrkDetElementBase*> (element2);
396 
397  // add element to respective AlignModule
398 
399  // add to the sct barrel structure
400  if(msgLvl(MSG::DEBUG)) {
401  if (m_sctHelper->is_barrel(id))
402  msg(MSG::DEBUG)<<"... SCT barrel element"<<endmsg;
403  else
404  msg(MSG::DEBUG)<<"... SCT endcap element"<<endmsg;
405  }
407 
408  // and fill the corresponding map
409  (*sctIdHashMap)[idHash] = silicon;
410  }
411  else
412  ATH_MSG_DEBUG("No SCT detector with id: "<<id);
413  }
414 
415  // add created module to the geometry
416  m_alignModuleListPtr->push_back(silicon);
417 
418  ATH_MSG_DEBUG("Silicon L0 module successfully added to the list");
419  }
420 
421  //________________________________________________________________________
423  {
424  // for standalone Pixel and SCT modules call the respective methods
426  m_pixelGeoManager->addModuleParameters(module,allFullModPars,allActiveModPars);
427  return;
428  }
430  m_sctGeoManager->addModuleParameters(module,allFullModPars,allActiveModPars);
431  return;
432  }
433 
434  // for combined modules do the work here
435 
436  // prepare all parameters
444 
445  // set sigmas
446  setSigmas(module,fullModPars);
447 
448  // select active parameters based on jobOption properties
450  for(unsigned int ipar=0;ipar<fullModPars->size();++ipar) {
451 
452  Identifier AlimodID = module->identify();
453 
454  ATH_MSG_DEBUG("Silicon module with id "<<AlimodID);
455  if( (fullModPars->at(ipar)->paramType() == Trk::AlignModule::TransX && m_alignX)
456  || (fullModPars->at(ipar)->paramType() == Trk::AlignModule::TransY && m_alignY)
457  || (fullModPars->at(ipar)->paramType() == Trk::AlignModule::TransZ && m_alignZ)
458  || (fullModPars->at(ipar)->paramType() == Trk::AlignModule::RotX && m_alignRotX)
459  || (fullModPars->at(ipar)->paramType() == Trk::AlignModule::RotY && m_alignRotY)
460  || (fullModPars->at(ipar)->paramType() == Trk::AlignModule::RotZ && m_alignRotZ) ) {
461  ATH_MSG_DEBUG("parameter type "<<fullModPars->at(ipar)->paramType()<<" is now active");
462  activeModPars->push_back(fullModPars->at(ipar));
463  }
464  else
465  ATH_MSG_DEBUG("parameter type "<<fullModPars->at(ipar)->paramType()<<" is NOT active");
466  }
467 
468  // now add parameters to the list
469  allFullModPars->push_back(fullModPars);
470  allActiveModPars->push_back(activeModPars);
471  }
472 
473  //________________________________________________________________________
474  bool SiGeometryManagerTool::moduleSelected(unsigned long long id)
475  {
477  return true;
478 
479  int nsel = m_moduleSelection.size();
480  for(int i=0;i<nsel;++i)
481  if(m_moduleSelection.at(i) == id)
482  return true;
483 
484  return false;
485  }
486 
487  //________________________________________________________________________
489  {
490  ATH_MSG_DEBUG("Setting sigmas for module: "<<module->name());
491  for(unsigned int ipar=0;ipar<modPars->size();++ipar)
492  switch(modPars->at(ipar)->paramType()) {
494  modPars->at(ipar)->setSigma(m_sigmaX);
495  break;
497  modPars->at(ipar)->setSigma(m_sigmaY);
498  break;
500  modPars->at(ipar)->setSigma(m_sigmaZ);
501  break;
503  modPars->at(ipar)->setSigma(m_sigmaRotX);
504  break;
506  modPars->at(ipar)->setSigma(m_sigmaRotY);
507  break;
509  modPars->at(ipar)->setSigma(m_sigmaRotZ);
510  break;
511  default:
512  break;
513  }
514  }
515 
516  //________________________________________________________________________
518  {
519  return moduleSelected(mod->identify().get_compact());
520  }
521 
522  //________________________________________________________________________
524  {
525 
526  ATH_MSG_INFO("---------------------------------------------------");
527  ATH_MSG_INFO("Try to write an Si geom root file:");
528  TGeoManager* gm=new TGeoManager("Silicon","Silicon");
529  TGeoMaterial* mat=new TGeoMaterial("Vacuum",0,0,0);
530  TGeoMedium* med=new TGeoMedium("Vacuum",1,mat);
531  TGeoVolume* top = gm->MakeBox("Silicon",med,2000.,2000.,10000.);
532  gm->SetTopVolume(top);
533  TGeoVolume* Si_cog[60000]; //where does 22000 come from? For ITk this is too small it seems. Make configurable?
534  TGeoVolume* Si[60000];
535  int Si_count=0;
536  TGeoTranslation* tr[60000];
537  TGeoRotation* ro[60000];
538  TGeoCombiTrans* mx[60000];
539 
540  TGeoTranslation* nulltrans=new TGeoTranslation(0.0,0.0,0.0);
541  TGeoRotation* nullrota=new TGeoRotation();
542  nullrota->SetAngles(0.0,0.0,0.0); // Euler angles
543  TGeoRotation* fliprota=new TGeoRotation();
544  fliprota->SetAngles(0.0,-90.0,0.0); // Euler angles (rotation around X)
545  TGeoCombiTrans* donothing=new TGeoCombiTrans(*nulltrans,*nullrota);
546  TGeoCombiTrans* swapaxes=new TGeoCombiTrans(*nulltrans,*fliprota);
547 
548  Amg::Vector3D ea;
550 
551  // First prepare the higher level (L1, L2) structures:
552  TGeoVolume* L0_A = gm->MakeTube("L0_A",med,0.0,1100.0,5000.0);
553  L0_A->SetVisibility(kFALSE);
554  top->AddNodeOverlap(L0_A,Si_count,donothing);
555  Si_count++;
556  TGeoVolume* L1_IBL_A = gm->MakeTube("L1_IBL_A",med,20.0,40.0,700.0);
557  L1_IBL_A->SetVisibility(kFALSE);
558  L0_A->AddNodeOverlap(L1_IBL_A,Si_count,donothing);
559  Si_count++;
560  TGeoVolume* L1_DBM_A = gm->MakeTube("L1_DBM_A",med,20.0,40.0,1000.0);
561  L1_DBM_A->SetVisibility(kFALSE);
562  L0_A->AddNodeOverlap(L1_DBM_A,Si_count,donothing);
563  Si_count++;
564  TGeoVolume* L1_PIX_A = gm->MakeTube("L1_PIX_A",med,40.0,150.0,700.0);
565  L1_PIX_A->SetVisibility(kFALSE);
566  L0_A->AddNodeOverlap(L1_PIX_A,Si_count,donothing);
567  Si_count++;
568  TGeoVolume* L1_SCTA_A = gm->MakeTube("L1_SCTA_A",med,250.0,550.0,3000.0);
569  L1_SCTA_A->SetVisibility(kFALSE);
570  L0_A->AddNodeOverlap(L1_SCTA_A,Si_count,donothing);
571  Si_count++;
572  TGeoVolume* L1_SCTB_A = gm->MakeTube("L1_SCTB_A",med,250.0,550.0,3000.0);
573  L1_SCTB_A->SetVisibility(kFALSE);
574  L0_A->AddNodeOverlap(L1_SCTB_A,Si_count,donothing);
575  Si_count++;
576  TGeoVolume* L1_SCTC_A = gm->MakeTube("L1_SCTC_A",med,250.0,550.0,3000.0);
577  L1_SCTC_A->SetVisibility(kFALSE);
578  L0_A->AddNodeOverlap(L1_SCTC_A,Si_count,donothing);
579  Si_count++;
580 
581 
582 
583  ATH_MSG_INFO("---------------------------------------------------");
584  ATH_MSG_INFO("Summary of the alignment geometry");
585  ATH_MSG_INFO("Number of alignable objects: "<< m_alignModuleList.size());
586  for(unsigned int i=0;i<m_alignModuleList.size();i++) {
588  ATH_MSG_INFO(i<<". "<< module->name());
589  ATH_MSG_INFO(" - identifier: "<<module->identify());
590  ATH_MSG_INFO(" - identifierHash: "<<module->identifyHash());
591 
592  unsigned int npix(0);
593  unsigned int nsct(0);
594  unsigned int nSi(0);
595  bool isPix(false);
596  bool isSCT(false);
597  if(module->detElementCollection(Trk::AlignModule::Pixel)) {
598  npix = module->detElementCollection(Trk::AlignModule::Pixel)->size();
599  nSi = npix; isPix = true;
600  ATH_MSG_INFO(" - has "<<npix<<" Pixel modules");
601  }
602  if(module->detElementCollection(Trk::AlignModule::SCT)) {
603  nsct = module->detElementCollection(Trk::AlignModule::SCT)->size();
604  nSi = nsct; isSCT = true;
605  ATH_MSG_INFO(" - has "<<nsct<<" SCT modules");
606  }
607  if(!isPix && !isSCT) ATH_MSG_INFO(" UNKNOWN module found: "<<module->identify());
608 
609  // Loop over all detector elements of this align module:
610  for(unsigned int j=0;j<nSi;j++) {
611  const SiDetectorElement * element=nullptr;
612  if(isPix) element = dynamic_cast<const SiDetectorElement*>(module->detElementCollection(Trk::AlignModule::Pixel)->at(j));
613  if(isSCT) element = dynamic_cast<const SiDetectorElement*>(module->detElementCollection(Trk::AlignModule::SCT)->at(j));
614  if (not element){
615  ATH_MSG_WARNING("Dynamic cast to SiDetectorElement from pixel or SCT module failed");
616  return;
617  }
618  const Identifier element_id = element->identify();
619  int det;
620  int bec;
621  int layer;
622  int ring;
623  int sector;
624  int side;
625  // in the future, the InDetAlignDBTool::idToDetSet should be directly used !
626  bool resok=false;
627  if (m_pixHelper->is_pixel(element_id)) {
628  det=1;
629  bec=m_pixHelper->barrel_ec(element_id);
630  layer=m_pixHelper->layer_disk(element_id);
631  ring=m_pixHelper->eta_module(element_id);
632  sector=m_pixHelper->phi_module(element_id);
633  side=0;
634  resok=true;
635  } else if (m_sctHelper->is_sct(element_id)) {
636  det=2;
637  bec=m_sctHelper->barrel_ec(element_id);
638  layer=m_sctHelper->layer_disk(element_id);
639  ring=m_sctHelper->eta_module(element_id);
640  sector=m_sctHelper->phi_module(element_id);
641  side=m_sctHelper->side(element_id);
642  resok=true;
643  }
644  if(!resok) ATH_MSG_INFO(" UNRESOLVED module found: "<<element_id);
645 
646  if(resok && !(element->isStereo())) { // take only phi SCT modules and Pixels
647  // extract the transformation parameters from Eigen:
648  if( m_actualGeom ) {
649  xyz = element->transform().translation(); // translation (actual)
650  ea = element->transform().rotation().eulerAngles(2, 0, 2); // Euler angles (actual)
651  } else {
652  xyz = element->defTransform().translation(); // translation (nominal)
653  ea = element->defTransform().rotation().eulerAngles(2, 0, 2); // Euler angles (nominal)
654  }
655 
656  ATH_MSG_INFO(">>> Element ident,det,bec,layer,ring,sector,side: "<<element_id<<", "<<det<<", "<<bec<<", "<<layer<<", "<<ring<<", "<<sector<<", "<<side);
657  ATH_MSG_INFO(">>> Element length/width/thickness: "<<element->length()<<", "<<element->width()<<", "<<element->thickness());
658  if(element->isSCT() && element->isEndcap())
659  ATH_MSG_INFO(">>> SCT Endcap wedge, min/max "<<element->minWidth()<<" / "<<element->maxWidth());
660  ATH_MSG_INFO(">>> Center position: "<<element->center());
661  ATH_MSG_INFO(">>> Default transformation: ");
662  ATH_MSG_INFO(">>> translation: "<<xyz);
663  ATH_MSG_INFO(">>> Euler angles: Phi="<<57.2957*ea[0]<<" Theta="<<57.2957*ea[1]<<" Psi="<<57.2957*ea[2]);
664 
665 
666  ATH_MSG_INFO("Adding a volume to the Silicon geometry:");
667  TString nname = "Si_COG_";
668  TString mname = "Si_MOD_";
669  TString undsc = "_";
670 
671  std::string det_str = std::to_string(det);
672  std::string bec_str = std::to_string( bec);
673  std::string layer_str = std::to_string( layer);
674  std::string ring_str = std::to_string( ring);
675  std::string sector_str = std::to_string( sector);
676  const auto suffix = TString(det_str)+undsc+TString(bec_str)+undsc+TString(layer_str)+undsc+TString(ring_str)+undsc+TString(sector_str);
677  nname += suffix;
678  mname += suffix;
679 
680  Si_cog[Si_count] = gm->MakeSphere(nname,med,0.0,element->length(),0.0,180.0,0.0,360.0); // invisible container
681  Si_cog[Si_count]->SetVisibility(kFALSE);
682  // create a wedge for SCT Endcap, otherwise a box:
683  if(element->isSCT() && element->isEndcap()) {
684  Si[Si_count] = gm->MakeTrd1(mname,med,0.5*element->minWidth(),0.5*element->maxWidth(),0.5*element->thickness(),0.5*element->length()); // this is a wedge!
685  } else {
686  Si[Si_count] = gm->MakeBox(mname,med,0.5*element->width(),0.5*element->thickness(),0.5*element->length()); // creator takes the half-lengths!
687  }
688  tr[Si_count] = new TGeoTranslation();
689  tr[Si_count]->SetTranslation(xyz[0],xyz[1],xyz[2]);
690  ro[Si_count] = new TGeoRotation();
691  ro[Si_count]->SetAngles(57.2957*ea[0],57.2957*ea[1],57.2957*ea[2]);
692  mx[Si_count] = new TGeoCombiTrans(*tr[Si_count],*ro[Si_count]);
693 
694  TGeoVolume* parrent_elem = nullptr;
695  switch(det)
696  {
697  case 1:
698  if(bec==0 && layer==0) parrent_elem = L1_IBL_A;
699  else if(abs(bec)==4) parrent_elem = L1_DBM_A;
700  else parrent_elem = L1_PIX_A;
701  break;
702  case 2:
703  switch(bec)
704  {
705  case -2:
706  parrent_elem = L1_SCTC_A;
707  break;
708  case 0:
709  parrent_elem = L1_SCTB_A;
710  break;
711  case 2:
712  parrent_elem = L1_SCTA_A;
713  break;
714  default:
715  break;
716  }
717  break;
718  default:
719  break;
720  }
721  if(parrent_elem) {
722  // parrent_elem->AddNode(Si_cog[Si_count],Si_count,mx[Si_count]);
723  // top->AddNode(Si_cog[Si_count],Si_count,mx[Si_count]);
724  top->AddNode(Si_cog[Si_count],0,mx[Si_count]);
725  // Si_cog[Si_count]->AddNode(Si[Si_count],Si_count,gGeoIdentity);
726  // Si_cog[Si_count]->AddNode(Si[Si_count],side,swapaxes);
727  Si_cog[Si_count]->AddNode(Si[Si_count],0,swapaxes);
728  Si_count++;
729  }
730  }
731  }
732 
733 
734  if(npix && nsct)
735  ATH_MSG_INFO(" - has "<<npix+nsct<<" Silicon modules in total");
736 
737  Amg::Transform3D localtoglobal = (module->globalFrameToAlignFrame()).inverse();
738  ATH_MSG_DEBUG(" - local to global : "<<std::setprecision(12)<<localtoglobal.translation()<<" "<<localtoglobal.rotation());
739 
741  int npars = pars->size();
742  ATH_MSG_DEBUG(" - number of active transform parameters: "<<npars);
743  for(int j=0;j<npars;j++)
744  ATH_MSG_DEBUG(" * par "<<j<<": sigma = "<<(*pars)[j]->sigma());
745 
746  }
747 
748 
749  // close geometry end write the geometry root file:
750  gm->CloseGeometry();
751  gm->Export("Silicon.root","Silicon","v");
752 
753  }
754 
755  //________________________________________________________________________
757  {
758  ATH_MSG_DEBUG("in isOneDetOnly for detector type "<<dettype);
759  const Trk::AlignModule::DetElementCollection * coll = mod->detElementCollection(dettype);
760  if(!coll || coll->empty())
761  return false;
762 
763  int nelem(0);
764  for(int i=1;i<Trk::AlignModule::NDetectorTypes;i++) {
765  if(i==dettype)
766  continue;
767  coll = mod->detElementCollection((Trk::AlignModule::DetectorType)i);
768  if(coll)
769  nelem += coll->size();
770  }
771 
772  if(nelem)
773  return false;
774 
775  ATH_MSG_DEBUG("module IS of type "<<dettype);
776  return true;
777  }
778 
779 
780 } // end namespace
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
PixelID.h
This is an Identifier helper class for the Pixel subdetector. This class is a factory for creating co...
AtlasDetectorID::is_pixel
bool is_pixel(Identifier id) const
Definition: AtlasDetectorID.h:767
make_hlt_rep.pars
pars
Definition: make_hlt_rep.py:90
InDet::SiGeometryManagerTool::setLogStream
void setLogStream(std::ostream *os)
sets the output stream for the logfile
Definition: SiGeometryManagerTool.cxx:207
InDet::SiGeometryManagerTool::isOneDetOnly
bool isOneDetOnly(const Trk::AlignModule *mod, Trk::AlignModule::DetectorType dettype) const
check whether the module is of a single detector type
Definition: SiGeometryManagerTool.cxx:756
InDet::SiGeometryManagerTool::m_alignModuleTool
ToolHandle< Trk::IAlignModuleTool > m_alignModuleTool
pointer to AlignModuleTool
Definition: SiGeometryManagerTool.h:111
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
SCT_ID.h
This is an Identifier helper class for the SCT subdetector. This class is a factory for creating comp...
pdg_comparison.sigma
sigma
Definition: pdg_comparison.py:324
hotSpotInTAG.suffix
string suffix
Definition: hotSpotInTAG.py:185
InDet::SiGeometryManagerTool::buildGeometry
void buildGeometry()
builds geometry for Silicon alignment
Definition: SiGeometryManagerTool.cxx:262
Trk::AlignModule::TransZ
@ TransZ
Definition: AlignModule.h:54
InDet::SiGeometryManagerTool::m_actualGeom
bool m_actualGeom
Definition: SiGeometryManagerTool.h:144
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
InDet::SiGeometryManagerTool::initialize
StatusCode initialize()
Definition: SiGeometryManagerTool.cxx:97
Trk::AlignModuleList
std::vector< AlignModule * > AlignModuleList
Definition: AlignModuleList.h:37
InDet::SiGeometryManagerTool::m_sctGeoManager
ToolHandle< Trk::IGeometryManagerTool > m_sctGeoManager
pointer to SCT geometry manager
Definition: SiGeometryManagerTool.h:109
ParticleGun_SamplingFraction.bec
int bec
Definition: ParticleGun_SamplingFraction.py:89
InDet::SiGeometryManagerTool::m_sigmaRotZ
double m_sigmaRotZ
Definition: SiGeometryManagerTool.h:134
SG::VIEW_ELEMENTS
@ VIEW_ELEMENTS
this data object is a view, it does not own its elmts
Definition: OwnershipPolicy.h:18
TRTCalib_Extractor.det
det
Definition: TRTCalib_Extractor.py:36
AtlasDetectorID::is_sct
bool is_sct(Identifier id) const
Definition: AtlasDetectorID.h:777
PixelID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: PixelID.h:615
Trk::IGeometryManagerTool::m_hashCounter
int m_hashCounter
variable for setting the idHash of the AlignModules
Definition: IGeometryManagerTool.h:111
index
Definition: index.py:1
InDet::SiGeometryManagerTool::m_dumpGeometry
bool m_dumpGeometry
Definition: SiGeometryManagerTool.h:143
InDet
Primary Vertex Finder.
Definition: VP1ErrorUtils.h:36
mat
GeoMaterial * mat
Definition: LArDetectorConstructionTBEC.cxx:55
SiGeometryManagerTool.h
InDet::SiGeometryManagerTool::m_pixelDetManager
const InDetDD::PixelDetectorManager * m_pixelDetManager
pointer to PIX detector manager
Definition: SiGeometryManagerTool.h:101
Trk::AlignModule::addDetElement
void addDetElement(AlignModule::DetectorType detType, const TrkDetElementBase *det, const Amg::Transform3D &transform, Identifier id=Identifier())
used to add a detector element to the align module with a align frame to detector element local frame...
Definition: AlignModule.cxx:126
Trk::AlignModule
Definition: AlignModule.h:45
InDet::SiGeometryManagerTool::m_sigmaRotX
double m_sigmaRotX
Definition: SiGeometryManagerTool.h:132
xyz
#define xyz
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
fitman.mx
mx
Definition: fitman.py:520
Trk::TrkDetElementBase
Definition: TrkDetElementBase.h:52
Trk::AlignModule::Pixel
@ Pixel
Definition: AlignModule.h:57
SCT_ID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: SCT_ID.h:728
InDet::SiGeometryManagerTool::m_sigmaZ
double m_sigmaZ
Definition: SiGeometryManagerTool.h:131
InDet::SiGeometryManagerTool::checkAlignLevel
bool checkAlignLevel()
check whether the alignment level is correct
Definition: SiGeometryManagerTool.cxx:160
SCT_ID::phi_module
int phi_module(const Identifier &id) const
Definition: SCT_ID.h:740
Trk::AlignModule::NDetectorTypes
@ NDetectorTypes
Definition: AlignModule.h:57
Trk::AlignPar::paramType
AlignModule::TransformParameters paramType() const
returns the type of parameter (i.e.
Definition: AlignPar.h:47
InDetDD::SCT_DetectorManager::getDetectorElement
virtual const SiDetectorElement * getDetectorElement(const Identifier &id) const override
access to individual elements via Identifier
Definition: SCT_DetectorManager.cxx:66
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
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:360
AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
InDet::SiGeometryManagerTool::finalize
StatusCode finalize()
Definition: SiGeometryManagerTool.cxx:152
InDet::SiGeometryManagerTool::m_sctDetManager
const InDetDD::SCT_DetectorManager * m_sctDetManager
pointer to SCT detector manager
Definition: SiGeometryManagerTool.h:102
InDet::SiGeometryManagerTool::m_alignPixel
bool m_alignPixel
Definition: SiGeometryManagerTool.h:137
Trk::IGeometryManagerTool::m_alignLevel
int m_alignLevel
alignment level
Definition: IGeometryManagerTool.h:115
TRT::Hit::side
@ side
Definition: HitInfo.h:83
InDet::SiGeometryManagerTool::m_sigmaRotY
double m_sigmaRotY
Definition: SiGeometryManagerTool.h:133
InDet::SiGeometryManagerTool::ReadGeometry
int ReadGeometry(int solveLevel)
read the geometry Method is called from the main AlignAlg to build the geometry based on the requeste...
Definition: SiGeometryManagerTool.cxx:217
AlignModule
AlignModule is a grouping of TrkDetElementBase objects, grouped according to the type of alignment,...
python.PyAthena.module
module
Definition: PyAthena.py:131
PixelID::is_barrel
bool is_barrel(const Identifier &id) const
Test for barrel - WARNING: id MUST be pixel id, otherwise answer is not accurate. Use SiliconID for g...
Definition: PixelID.h:601
Trk::AlignPar::setSigma
void setSigma(double sigma)
sets sigma
Definition: AlignPar.h:87
PixelDetectorManager.h
Trk::AlignModule::setName
void setName(const std::string &name)
Set and return name of align module (i.e.
Definition: AlignModule.h:88
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
Trk::IGeometryManagerTool::m_alignModuleListPtr
Trk::AlignModuleList * m_alignModuleListPtr
pointer to module list to which the modules are added
Definition: IGeometryManagerTool.h:106
maskDeadModules.mod
mod
Definition: maskDeadModules.py:36
Trk::AlignModule::setIdentifier
void setIdentifier(Identifier identifier)
Set and return identifier of module.
Definition: AlignModule.h:96
SCT_ID::wafer_hash_max
size_type wafer_hash_max() const
Definition: SCT_ID.cxx:646
lumiFormat.i
int i
Definition: lumiFormat.py:85
SG::OWN_ELEMENTS
@ OWN_ELEMENTS
this data object owns its elements
Definition: OwnershipPolicy.h:17
Trk::IGeometryManagerTool::getNextIDHash
virtual int getNextIDHash()
get next free IDHash usable for new AlignModule
Definition: IGeometryManagerTool.h:65
Trk::AlignModule::identifyHash
IdentifierHash identifyHash() const
Set and return index of module, used by alignment classes to keep track of order of align module.
Definition: AlignModule.h:92
InDet::SiGeometryManagerTool::m_fullAlignParList
DataVector< DataVector< Trk::AlignPar > > * m_fullAlignParList
Definition: SiGeometryManagerTool.h:119
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
MuonR4::inverse
CalibratedSpacePoint::Covariance_t inverse(const CalibratedSpacePoint::Covariance_t &mat)
Inverts the parsed matrix.
Definition: MuonSpectrometer/MuonPhaseII/Event/MuonSpacePoint/src/UtilFunctions.cxx:65
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
InDet::SiGeometryManagerTool::m_alignSCT
bool m_alignSCT
Definition: SiGeometryManagerTool.h:138
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
Trk::AlignPar
Definition: AlignPar.h:25
SiliconID.h
This is an Identifier helper class for both the Pixel and SCT subdetectors. This class defines identi...
test_pyathena.parent
parent
Definition: test_pyathena.py:15
InDet::SiGeometryManagerTool::m_alignX
bool m_alignX
Definition: SiGeometryManagerTool.h:122
Trk::AlignModule::RotX
@ RotX
Definition: AlignModule.h:54
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Trk::AlignModule::SCT
@ SCT
Definition: AlignModule.h:57
InDet::SiGeometryManagerTool::m_alignY
bool m_alignY
Definition: SiGeometryManagerTool.h:123
InDet::SiGeometryManagerTool::m_alignParList
DataVector< DataVector< Trk::AlignPar > > * m_alignParList
Definition: SiGeometryManagerTool.h:118
InDet::SiGeometryManagerTool::m_pixelGeoManager
ToolHandle< Trk::IGeometryManagerTool > m_pixelGeoManager
pointer to Pixel geometry manager
Definition: SiGeometryManagerTool.h:108
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
AlignModuleList.h
ReadFromCoolCompare.os
os
Definition: ReadFromCoolCompare.py:231
Trk::AlignModule::DetElementCollection
std::vector< const TrkDetElementBase * > DetElementCollection
typedefs to contain detector element pointers and transforms
Definition: AlignModule.h:60
Trk::AlignModule::name
const std::string & name() const
Definition: AlignModule.h:89
InDet::SiGeometryManagerTool::setSigmas
void setSigmas(Trk::AlignModule *mod, DataVector< Trk::AlignPar > *modPars)
sets sigmas for modules
Definition: SiGeometryManagerTool.cxx:488
PixelID::wafer_hash_max
size_type wafer_hash_max() const
Definition: PixelID.cxx:833
keylayer_zslicemap.isPix
isPix
Definition: keylayer_zslicemap.py:127
PixelID::layer_disk
int layer_disk(const Identifier &id) const
Definition: PixelID.h:622
InDet::SiGeometryManagerTool::m_idHelper
const SiliconID * m_idHelper
pointer to Silicon detector manager
Definition: SiGeometryManagerTool.h:106
Trk
Ensure that the ATLAS eigen extensions are properly loaded.
Definition: FakeTrackBuilder.h:9
PixelID::eta_module
int eta_module(const Identifier &id) const
Definition: PixelID.h:647
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
Trk::AlignModule::DetectorType
DetectorType
Definition: AlignModule.h:57
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
AlignModule.h
InDet::SiGeometryManagerTool::m_doModuleSelection
bool m_doModuleSelection
Definition: SiGeometryManagerTool.h:140
SCT_ID::layer_disk
int layer_disk(const Identifier &id) const
Definition: SCT_ID.h:734
InDetDD::SiDetectorElement
Definition: SiDetectorElement.h:109
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
InDet::SiGeometryManagerTool::m_alignZ
bool m_alignZ
Definition: SiGeometryManagerTool.h:124
Trk::IGeometryManagerTool::m_logStream
std::ostream * m_logStream
logfile output stream
Definition: IGeometryManagerTool.h:113
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
SiDetectorElement.h
InDet::SiGeometryManagerTool::moduleSelected
bool moduleSelected(Trk::AlignModule *mod)
check wheather module is selected for module pointer
Definition: SiGeometryManagerTool.cxx:517
InDet::SiGeometryManagerTool::buildL0
void buildL0()
creates L0 AlignModules for Silicon
Definition: SiGeometryManagerTool.cxx:297
Trk::AlignModule::setIdHash
void setIdHash(IdentifierHash id)
Definition: AlignModule.h:93
Trk::AlignModule::TransX
@ TransX
Definition: AlignModule.h:54
DataVector.h
An STL vector of pointers that by default owns its pointed-to elements.
DeMoScan.index
string index
Definition: DeMoScan.py:362
InDet::SiGeometryManagerTool::m_sigmaX
double m_sigmaX
Definition: SiGeometryManagerTool.h:129
InDet::SiGeometryManagerTool::dumpGeometry
void dumpGeometry()
print basic geometry info to screen
Definition: SiGeometryManagerTool.cxx:523
InDet::SiGeometryManagerTool::m_sigmaY
double m_sigmaY
Definition: SiGeometryManagerTool.h:130
Trk::IGeometryManagerTool::m_idHashToAlignModuleMapsPtr
std::vector< Trk::AlignModuleList * > * m_idHashToAlignModuleMapsPtr
pointer to vector of hashMaps to which the elements are added
Definition: IGeometryManagerTool.h:109
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.Constants.INFO
int INFO
Definition: Control/AthenaCommon/python/Constants.py:15
InDetDD
Message Stream Member.
Definition: FakeTrackBuilder.h:8
InDet::SiGeometryManagerTool::m_moduleSelection
std::vector< unsigned long long > m_moduleSelection
Definition: SiGeometryManagerTool.h:141
Trk::AlignModule::RotY
@ RotY
Definition: AlignModule.h:54
InDet::SiGeometryManagerTool::m_stripDetManagerName
Gaudi::Property< std::string > m_stripDetManagerName
Definition: SiGeometryManagerTool.h:147
DEBUG
#define DEBUG
Definition: page_access.h:11
SCT_ID::eta_module
int eta_module(const Identifier &id) const
Definition: SCT_ID.h:746
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
InDet::SiGeometryManagerTool::m_alignRotY
bool m_alignRotY
Definition: SiGeometryManagerTool.h:126
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
IAlignModuleTool.h
InDet::SiGeometryManagerTool::~SiGeometryManagerTool
virtual ~SiGeometryManagerTool()
Definition: SiGeometryManagerTool.cxx:84
InDet::SiGeometryManagerTool::m_idHashToAlignModuleMaps
std::vector< Trk::AlignModuleList * > m_idHashToAlignModuleMaps
Definition: SiGeometryManagerTool.h:116
AlignPar.h
SCT_ID::side
int side(const Identifier &id) const
Definition: SCT_ID.h:752
InDet::SiGeometryManagerTool::m_pixelDetManagerName
Gaudi::Property< std::string > m_pixelDetManagerName
Definition: SiGeometryManagerTool.h:146
InDetDD::PixelDetectorManager::getDetectorElement
virtual const SiDetectorElement * getDetectorElement(const Identifier &id) const override
access to individual elements : via Identifier
Definition: PixelDetectorManager.cxx:80
top
@ top
Definition: TruthClasses.h:64
InDet::SiGeometryManagerTool::m_sctHelper
const SCT_ID * m_sctHelper
pointer to SCT detector manager
Definition: SiGeometryManagerTool.h:105
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
InDet::SiGeometryManagerTool::m_alignModuleList
Trk::AlignModuleList m_alignModuleList
Definition: SiGeometryManagerTool.h:113
InDet::SiGeometryManagerTool::addModuleParameters
void addModuleParameters(Trk::AlignModule *module, DataVector< DataVector< Trk::AlignPar > > *allFullModPars, DataVector< DataVector< Trk::AlignPar > > *allActiveModPars)
adds alignment parameters for the module checks for active parameters and calls setSigmas()
Definition: SiGeometryManagerTool.cxx:422
AthAlgTool
Definition: AthAlgTool.h:26
SCT_ID::wafer_id
Identifier wafer_id(int barrel_ec, int layer_disk, int phi_module, int eta_module, int side) const
For a single side of module.
Definition: SCT_ID.h:464
SCT_DetectorManager.h
Trk::AlignModule::RotZ
@ RotZ
Definition: AlignModule.h:54
PixelID::phi_module
int phi_module(const Identifier &id) const
Definition: PixelID.h:640
InDet::SiGeometryManagerTool::m_alignRotZ
bool m_alignRotZ
Definition: SiGeometryManagerTool.h:127
Trk::AlignModule::TransY
@ TransY
Definition: AlignModule.h:54
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
Trk::AlignModule::identify
Identifier identify() const
Definition: AlignModule.h:97
InDet::SiGeometryManagerTool::m_alignRotX
bool m_alignRotX
Definition: SiGeometryManagerTool.h:125
InDet::SiGeometryManagerTool::m_pixHelper
const PixelID * m_pixHelper
pointer to PIX detector manager
Definition: SiGeometryManagerTool.h:104
SCT_ID::is_barrel
bool is_barrel(const Identifier &id) const
Test for barrel - WARNING: id MUST be sct id, otherwise answer is not accurate. Use SiliconID for gen...
Definition: SCT_ID.h:721
Identifier
Definition: IdentifierFieldParser.cxx:14