ATLAS Offline Software
Loading...
Searching...
No Matches
TRTGeometryManagerTool.cxx
Go to the documentation of this file.
1/*
2 Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
3*/
4
5#include "AthContainers/DataVector.h"
6
7#include "TRT_ReadoutGeometry/TRT_BarrelElement.h"
8#include "TRT_ReadoutGeometry/TRT_EndcapElement.h"
9#include "TRT_ReadoutGeometry/TRT_DetectorManager.h"
10#include "TRT_ReadoutGeometry/TRT_Numerology.h"
11#include "InDetIdentifier/TRT_ID.h"
12
13#include "TrkAlignInterfaces/IAlignModuleTool.h"
14
15#include "TrkAlignEvent/AlignModule.h"
16#include "TrkAlignEvent/AlignModuleList.h"
17#include "TrkAlignEvent/AlignPar.h"
18
19
20#include "InDetAlignGeomTools/TRTGeometryManagerTool.h"
21
22
23#include <iostream>
24#include <memory>
25
26using namespace InDetDD;
27
28namespace InDet {
29
30//________________________________________________________________________
31TRTGeometryManagerTool::TRTGeometryManagerTool(const std::string& type,
32 const std::string& name,
33 const IInterface * parent)
34 : AthAlgTool(type,name,parent)
35 , m_trtDetManager(nullptr)
36 , m_idHelper()
37 , m_alignModuleTool("Trk::AlignModuleTool/AlignModuleTool")
38 , m_idHashToAlignModuleMaps(Trk::AlignModule::NDetectorTypes,(Trk::AlignModuleList*)nullptr)
39 , m_alignParList(nullptr)
40 , m_fullAlignParList(nullptr)
41{
42 declareInterface<IGeometryManagerTool>(this);
43 declareProperty("AlignModuleTool", m_alignModuleTool);
44
45 declareProperty("AlignBarrel", m_alignBarrel = true);
46 declareProperty("AlignBarrelX", m_alignBarrelX = true);
47 declareProperty("AlignBarrelY", m_alignBarrelY = true);
48 declareProperty("AlignBarrelZ", m_alignBarrelZ = false);
49 declareProperty("AlignBarrelRotX", m_alignBarrelRotX = true);
50 declareProperty("AlignBarrelRotY", m_alignBarrelRotY = true);
51 declareProperty("AlignBarrelRotZ", m_alignBarrelRotZ = true);
52
53 declareProperty("AlignEndcaps", m_alignEndcaps = true);
54 declareProperty("AlignEndcapX", m_alignEndcapX = true);
55 declareProperty("AlignEndcapY", m_alignEndcapY = true);
56 declareProperty("AlignEndcapZ", m_alignEndcapZ = true);
57 declareProperty("AlignEndcapRotX", m_alignEndcapRotX = true);
58 declareProperty("AlignEndcapRotY", m_alignEndcapRotY = true);
59 declareProperty("AlignEndcapRotZ", m_alignEndcapRotZ = true);
60
61 declareProperty("SetSigmaBarrelX", m_sigmaBarrelX = 1.);
62 declareProperty("SetSigmaBarrelY", m_sigmaBarrelY = 1.);
63 declareProperty("SetSigmaBarrelZ", m_sigmaBarrelZ = 1.);
64 declareProperty("SetSigmaBarrelRotX", m_sigmaBarrelRotX = 0.001);
65 declareProperty("SetSigmaBarrelRotY", m_sigmaBarrelRotY = 0.001);
66 declareProperty("SetSigmaBarrelRotZ", m_sigmaBarrelRotZ = 0.001);
67
68 declareProperty("SetSigmaEndcapX", m_sigmaEndcapX = 1.);
69 declareProperty("SetSigmaEndcapY", m_sigmaEndcapY = 1.);
70 declareProperty("SetSigmaEndcapZ", m_sigmaEndcapZ = 1.);
71 declareProperty("SetSigmaEndcapRotX", m_sigmaEndcapRotX = 0.001);
72 declareProperty("SetSigmaEndcapRotY", m_sigmaEndcapRotY = 0.001);
73 declareProperty("SetSigmaEndcapRotZ", m_sigmaEndcapRotZ = 0.001);
74
75 declareProperty("SetSoftCutBarrelX", m_softcutBarrelX = 1.);
76 declareProperty("SetSoftCutBarrelY", m_softcutBarrelY = 1.);
77 declareProperty("SetSoftCutBarrelZ", m_softcutBarrelZ = 1.);
78 declareProperty("SetSoftCutBarrelRotX", m_softcutBarrelRotX = 1.);
79 declareProperty("SetSoftCutBarrelRotY", m_softcutBarrelRotY = 1.);
80 declareProperty("SetSoftCutBarrelRotZ", m_softcutBarrelRotZ = 1.);
81
82 declareProperty("SetSoftCutEndcapX", m_softcutEndcapX = 1.);
83 declareProperty("SetSoftCutEndcapY", m_softcutEndcapY = 1.);
84 declareProperty("SetSoftCutEndcapZ", m_softcutEndcapZ = 1.);
85 declareProperty("SetSoftCutEndcapRotX", m_softcutEndcapRotX = 1.);
86 declareProperty("SetSoftCutEndcapRotY", m_softcutEndcapRotY = 1.);
87 declareProperty("SetSoftCutEndcapRotZ", m_softcutEndcapRotZ = 1.);
88
89 declareProperty("AlignmentLevel", m_alignLevel = 1);
90 declareProperty("AlignmentLevelBarrel", m_alignLevelBarrel = -1);
91 declareProperty("AlignmentLevelEndcaps", m_alignLevelEndcaps = -1);
92
93 declareProperty("AlignBarrelPhiSectors", m_barrelPhiSectors);
94 declareProperty("AlignBarrelLayers", m_barrelLayers);
95
96 declareProperty("AlignSingleEndcap", m_endcap = 0);
97 declareProperty("AlignEndcapWheels", m_endcapWheels);
98 declareProperty("AlignEndcapPhiSectors", m_endcapPhiSectors);
99
100 declareProperty("doModuleSelection", m_doModuleSelection = false);
101 declareProperty("ModuleSelection", m_moduleSelection);
102
103 declareProperty("DumpGeometry", m_dumpGeometry = true);
104
105 m_hashCounter = 0;
106 m_logStream = nullptr;
107}
108
109//________________________________________________________________________
110TRTGeometryManagerTool::~TRTGeometryManagerTool()
111{
112 ATH_MSG_DEBUG("deleting alignModuleList");
113 for (int i=0;i<(int)m_alignModuleList.size();i++)
114 delete m_alignModuleList[i];
115 m_alignModuleList.clear();
116
117 ATH_MSG_DEBUG("deleting fullAlignParList");
118 delete m_fullAlignParList;
119 ATH_MSG_DEBUG("deleting alignParList");
120 delete m_alignParList;
121}
122
123//________________________________________________________________________
124StatusCode TRTGeometryManagerTool::initialize()
125{
126 ATH_MSG_DEBUG("initialize() of TRTGeometryManagerTool");
127
128 // retrieve AlignModuleTool
129 if ( m_alignModuleTool.retrieve().isFailure() ) {
130 msg(MSG::FATAL)<<"Could not get " << m_alignModuleTool << endmsg;
131 return StatusCode::FAILURE;
132 }
133 else
134 ATH_MSG_INFO("Retrieved " << m_alignModuleTool);
135
136 // retrieve TRT ID helper
137 if ( detStore()->retrieve(m_idHelper, "TRT_ID").isFailure() ) {
138 msg(MSG::FATAL) << " Cannot retrieve TRT ID Helper " << endmsg;
139 return StatusCode::FAILURE;
140 }
141 else
142 ATH_MSG_INFO("retrieved TRT ID Helper");
143
144 // retrieve TRT detector manager
145 if ( detStore()->retrieve(m_trtDetManager).isFailure() ) {
146 msg(MSG::FATAL) << " Cannot retrieve TRT Detector Manager " << endmsg;
147 return StatusCode::FAILURE;
148 }
149 else
150 ATH_MSG_INFO("retrieved TRT Detector Manager");
151
152 // dump module selection
153 if(m_doModuleSelection && msgLvl(MSG::INFO)) {
154 msg(MSG::INFO)<<"Creating geometry for selected "<<m_moduleSelection.size()<<" modules:"<<endmsg;
155 for(unsigned int i=0;i<m_moduleSelection.size();i++)
156 msg(MSG::INFO)<<" "<<i<<". "<<m_moduleSelection.at(i)<<endmsg;
157 }
158
159 // check the allowed geometry levels
160 if(!checkAlignLevel())
161 return StatusCode::FAILURE;
162
163 return StatusCode::SUCCESS;
164}
165
166//________________________________________________________________________
167StatusCode TRTGeometryManagerTool::finalize()
168{
169 ATH_MSG_DEBUG("finalize() of TRTGeometryManagerTool");
170
171 return StatusCode::SUCCESS;
172}
173
174//________________________________________________________________________
180
181//________________________________________________________________________
182bool TRTGeometryManagerTool::checkAlignLevel()
183{
184 if(m_alignLevel == 0) {
185 ATH_MSG_INFO("Alignment level for TRT is "<<m_alignLevel);
186 return true;
187 }
188
189 if(m_alignLevelBarrel == -1) {
190 if(m_alignLevel == 200)
191 m_alignLevelBarrel = 2;
192 else
193 m_alignLevelBarrel = m_alignLevel;
194 }
195
196 if(m_alignLevelEndcaps == -1)
197 m_alignLevelEndcaps = m_alignLevel;
198
199 bool ok = checkAlignLevelBarrel() && checkAlignLevelEndcaps();
200
201 // if the alignment level for barrel and EC is set correctly
202 // reset the global alignment level
203 if(ok)
204 m_alignLevel = -1;
205
206 return ok;
207}
208
209//________________________________________________________________________
210bool TRTGeometryManagerTool::checkAlignLevelBarrel()
211{
212 if(!m_alignBarrel)
213 return true;
214
215 // check whether geometry level is allowed
216 switch(m_alignLevelBarrel) {
217 case 1: case 2: case 3:
218 ATH_MSG_INFO("Alignment level for TRT Barrel is "<<m_alignLevelBarrel);
219 return true;
220 default:
221 msg(MSG::FATAL)<<"Alignment level "<<m_alignLevelBarrel<<" does not exist for TRT Barrel"<<endmsg;
222 return false;
223 }
224}
225
226//________________________________________________________________________
227bool TRTGeometryManagerTool::checkAlignLevelEndcaps()
228{
229 if(!m_alignEndcaps)
230 return true;
231
232 // check whether geometry level is allowed
233 switch(m_alignLevelEndcaps) {
234 case 1: case 2: case 200: case 3:
235 ATH_MSG_INFO("Alignment level for TRT Endcaps is "<<m_alignLevelEndcaps);
236 return true;
237 default:
238 msg(MSG::FATAL)<<"Alignment level "<<m_alignLevelEndcaps<<" does not exist for TRT Endcaps"<<endmsg;
239 return false;
240 }
241}
242
243//________________________________________________________________________
244int TRTGeometryManagerTool::ReadGeometry(int solveLevel)
245{
246 ATH_MSG_DEBUG("in ReadGeometry() solveLevel="<<solveLevel);
247
248 // set pointers
249 m_idHashToAlignModuleMapsPtr = &m_idHashToAlignModuleMaps;
250 m_alignModuleListPtr = &m_alignModuleList;
251
252 // build alignment geometry
253 buildGeometry();
254
255 // now set the alignment parameters
256 // first prepare the parameter lists
257 m_alignParList = new DataVector< DataVector<Trk::AlignPar> >(SG::OWN_ELEMENTS);
258 m_fullAlignParList = new DataVector< DataVector<Trk::AlignPar> >(SG::OWN_ELEMENTS);
259 // loop over modules
260 std::vector<Trk::AlignModule *>::const_iterator imod = m_alignModuleList.begin();
261 std::vector<Trk::AlignModule *>::const_iterator imod_end = m_alignModuleList.end();
262 for( ; imod!=imod_end; ++imod)
263 addModuleParameters(*imod,m_fullAlignParList,m_alignParList);
264
265 // set alignModuleList and hash table in the alignModuleTool
266 m_alignModuleTool->setAlignModules(&m_alignModuleList, &m_idHashToAlignModuleMaps);
267 ATH_MSG_DEBUG(" geometry set in m_alignModuleTool");
268
269 // set alignPar lists in the alignModuleTool
270 ATH_MSG_DEBUG(" alignParList = "<<m_alignParList);
271 ATH_MSG_DEBUG(" fullAlignParList = "<<m_fullAlignParList);
272 m_alignModuleTool->setAlignParLists(m_fullAlignParList, m_alignParList);
273 ATH_MSG_DEBUG(" AlignParLists set in m_alignModuleTool");
274
275 // dump summary about the geometry setup
276 if (m_dumpGeometry)
277 dumpGeometry();
278
279 int nDoF= m_alignModuleTool->nAlignParameters();
280 ATH_MSG_INFO("Total number of degrees of freedom: "<<nDoF);
281
282 return nDoF;
283}
284
285//_______________________________________________________________________
286void TRTGeometryManagerTool::buildGeometry()
287{
288 ATH_MSG_INFO("Preparing the TRT geometry");
289
290 if(m_alignLevel == 0)
291 buildL0();
292 else {
293
294 if(m_alignBarrel)
295 switch(m_alignLevelBarrel) {
296 case 1:
297 buildL1Barrel();
298 break;
299 case 2:
300 buildL2Barrel();
301 break;
302 case 3:
303 buildL3Barrel();
304 m_alignModuleTool->setSubDetElement(Trk::AlignModule::TRT,true);
305 break;
306 default:
307 break;
308 }
309
310 if(m_alignEndcaps)
311 switch(m_alignLevelEndcaps) {
312 case 1:
313 buildL1Endcaps();
314 break;
315 case 2:
316 buildL2Endcaps();
317 break;
318 case 200:
319 buildL2EndcapsOLD();
320 break;
321 case 3:
322 buildL3Endcap();
323 m_alignModuleTool->setSubDetElement(Trk::AlignModule::TRT,true);
324 break;
325 default:
326 break;
327 }
328 }
329}
330
331//_______________________________________________________________________
332void TRTGeometryManagerTool::buildL0()
333{
334 ATH_MSG_INFO("Preparing the TRT geometry for L0: whole TRT");
335
336 // ========================================
337 // get all modules for Level 0 alignment
338 // Level 0 is the whole TRT, i.e., 1 AlignModule in total
339
340 // define modules
341 // we'll stick with the base AlignModule here since we don't want to
342 // do shifting for the moment but we might need to extend AlignModule
343 // in the future
344
345 // for L1 alignment the alignment frame is equal to the global frame
346 // and since the TRT detector element positions are also stored in
347 // the global frame in DB, transform is identity
348 Amg::Transform3D transform = Amg::Transform3D::Identity();
349
350 // use the 'real' identifier of the TRT barrel for TRT L0 module
351 Trk::AlignModule * trt = new Trk::AlignModule(this);
352 trt->setIdHash(getNextIDHash());
353 trt->setName("TRT");
354 trt->setIdentifier(m_idHelper->barrel_ec_id(-1));
355
356 if(!moduleSelected(trt)) {
357 ATH_MSG_DEBUG("Module "<<trt->name()<<" NOT selected");
358 delete trt;
359 return;
360 }
361
362 // get maximum number of elements from the helper
363 unsigned int trtmaxHash = m_idHelper->straw_layer_hash_max();
364 ATH_MSG_DEBUG("maxHash for the TRT "<<trtmaxHash);
365
366 if(!m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT))
367 m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT) = new Trk::AlignModuleList((size_t)(trtmaxHash),nullptr);
368 Trk::AlignModuleList * trtIdHashMap = m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT);
369
370 // ================================================================
371 // loop over TRT elements and add them to respective alignModules
372 // ================================================================
373 for (unsigned int index = 0; index < trtmaxHash; index++) {
374 IdentifierHash idHash = index;
375 Identifier id = m_idHelper->layer_id(idHash);
376
377 // get the element via hash
378 const TRT_BaseElement * element = m_trtDetManager->getElement(idHash);
379 if (element) {
380 // get element location for debugging
381// HepGeom::Point3D<double> center = element->transform() * HepGeom::Point3D<double>();
382// ATH_MSG_DEBUG(" TRTDetectorElement id: " << id << " with center = " << center);
383
384 // add element to respective AlignModule
385
386 // add to the Inner Detector structure
387 if(msgLvl(MSG::DEBUG)) {
388 if (m_idHelper->is_barrel(id))
389 msg(MSG::DEBUG)<<"... TRT barrel element"<<endmsg;
390 else
391 msg(MSG::DEBUG)<<"... TRT endcap element"<<endmsg;
392 }
393 trt->addDetElement(Trk::AlignModule::TRT,element,transform);
394
395 // and fill the corresponding map
396 (*trtIdHashMap)[idHash] = trt;
397 }
398 else
399 ATH_MSG_DEBUG("No TRTDetectorElement with id: "<<id);
400 }
401
402 // add created module to the geometry
403 m_alignModuleListPtr->push_back(trt);
404
405 ATH_MSG_DEBUG("TRT L0 module successfully added to the list");
406}
407
408//_______________________________________________________________________
409void TRTGeometryManagerTool::buildL1Barrel()
410{
411 // ===========================
412 // BARREL
413 // ===========================
414 ATH_MSG_INFO("Preparing the TRT Barrelgeometry for L1: whole barrel");
415
416 // ========================================
417 // get all modules for barrel Level 1 alignment
418 // Level 1 is barrel as a single AlignModule
419
420 // define modules
421 // we'll stick with the base AlignModule here since we don't want to
422 // do shifting for the moment but we might need to extend AlignModule
423 // in the future
424
425 // get maximum number of elements from the helper
426 unsigned int maxHash = 0;
427 if(m_alignLevelEndcaps==3)
428 maxHash = m_idHelper->straw_hash_max();
429 else
430 maxHash = m_idHelper->straw_layer_hash_max();
431 ATH_MSG_DEBUG("maxHash for the TRT "<<maxHash);
432
433 if(!m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT))
434 m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT) = new Trk::AlignModuleList((size_t)maxHash,nullptr);
435 Trk::AlignModuleList * trtIdHashMap = m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT);
436
437 // for L1 alignment the alignment frame is equal to the global frame
438 // and since the TRT detector element positions are also stored in
439 // the global frame in DB, transform is identity
440 Amg::Transform3D transform = Amg::Transform3D::Identity();
441
442 // BARREL
443 // use the 'real' identifier of the TRT barrel that can be
444 // used by idHelper->barrel_ec()
445 // TRT barrel has two sides so both -1 and +1 are ok
446 // but -1 is used in the DB so we use it here as well
447 Trk::AlignModule * trtBarrel = new Trk::AlignModule(this);
448 trtBarrel->setIdHash(getNextIDHash());
449 trtBarrel->setName("TRT Barrel");
450 trtBarrel->setIdentifier(m_idHelper->barrel_ec_id(-1));
451
452 if(!moduleSelected(trtBarrel)) {
453 ATH_MSG_DEBUG("Module "<<trtBarrel->name()<<" NOT selected");
454 delete trtBarrel;
455 }
456 else {
457 // loop over detector elements in the barrel and add them to respective alignModules
458 for (unsigned int iLayer = 0; iLayer < m_trtDetManager->getNumerology()->getNBarrelRings(); iLayer++) // barrel layers
459 for (unsigned int iPhiModule = 0; iPhiModule < m_trtDetManager->getNumerology()->getNBarrelPhi(); iPhiModule++) // modules in phi
460 for (unsigned int iStrawLayer = 0; iStrawLayer < m_trtDetManager->getNumerology()->getNBarrelLayers(iLayer); iStrawLayer++) // straw layers inside one phi module
461 for (int iSide = 0; iSide < 2; iSide++) { // side of the straw
462 const TRT_BarrelElement * element = m_trtDetManager->getBarrelElement(iSide, iLayer, iPhiModule, iStrawLayer);
463 if (element) {
464 // get element location for debugging
465// HepGeom::Point3D<double> center = element->transform() * HepGeom::Point3D<double>();
466// ATH_MSG_DEBUG(" TRTDetectorElement id: " << element->identify() << " with center = " << center);
467
468 // add to the barrel
469 trtBarrel->addDetElement(Trk::AlignModule::TRT,element,transform);
470 // and fill the corresponding map
471 (*trtIdHashMap)[element->identifyHash()] = trtBarrel;
472 }
473 else
474 ATH_MSG_DEBUG("No TRT_BarrelElement with side-layer-phi-strawLayer:" <<iSide<<"-"<<iLayer<<"-"<<iPhiModule<<"-"<<iStrawLayer);
475 }
476
477 // add
478 m_alignModuleListPtr->push_back(trtBarrel);
479 }
480}
481
482
483//_______________________________________________________________________
484void TRTGeometryManagerTool::buildL1Endcaps()
485{
486 // ===========================
487 // ENDCAPs
488 // ===========================
489 ATH_MSG_INFO("Preparing the TRT Endcap geometry for L1: 2 endcaps");
490
491 // ========================================
492 // get all modules for Endcap Level 1 alignment
493 // Level 1 is endcap AlignModules
494
495 // define modules
496 // we'll stick with the base AlignModule here since we don't want to
497 // do shifting for the moment but we might need to extend AlignModule
498 // in the future
499
500 // get maximum number of elements from the helper
501 unsigned int maxHash = 0;
502 if(m_alignLevelBarrel==3)
503 maxHash = m_idHelper->straw_hash_max();
504 else
505 maxHash = m_idHelper->straw_layer_hash_max();
506 ATH_MSG_DEBUG("maxHash for the TRT "<<maxHash);
507
508 if(!m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT))
509 m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT) = new Trk::AlignModuleList((size_t)maxHash,nullptr);
510 Trk::AlignModuleList * trtIdHashMap = m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT);
511
512 // for L1 alignment the alignment frame is equal to the global frame
513 // and since the TRT detector element positions are also stored in
514 // the global frame in DB, transform is identity
515 Amg::Transform3D transform = Amg::Transform3D::Identity();
516
517 // ENDCAPs
518 // identifiers for endcaps are set in analogy to barrel
519 // above to -2 and +2 so they can be used by
520 // idHelper->barrel_ec()
521 Trk::AlignModule * trtEndCap[2];
522 for (int iSide=0;iSide<2;iSide++) {
523 trtEndCap[iSide] = new Trk::AlignModule(this);
524 trtEndCap[iSide] -> setIdHash(getNextIDHash());
525
526 if(iSide)
527 trtEndCap[iSide]->setName("TRT EndCap C");
528 else
529 trtEndCap[iSide]->setName("TRT EndCap A");
530
531 int idSide = iSide ? 2 : -2;
532 trtEndCap[iSide]->setIdentifier(m_idHelper->barrel_ec_id(idSide));
533
534 if( !moduleSelected(trtEndCap[iSide]) || (m_endcap!=idSide && m_endcap!=0 ) ) {
535 ATH_MSG_DEBUG("Module "<<trtEndCap[iSide]->name()<<" NOT selected");
536 delete trtEndCap[iSide];
537 }
538 else {
539 for (unsigned int iWheel = 0; iWheel < m_trtDetManager->getNumerology()->getNEndcapWheels(); iWheel++)
540 for (unsigned int iStrawLayer = 0; iStrawLayer < m_trtDetManager->getNumerology()->getNEndcapLayers(iWheel); iStrawLayer++)
541 for(unsigned int iPhi = 0; iPhi < m_trtDetManager->getNumerology()->getNEndcapPhi(); iPhi++) {
542 const TRT_EndcapElement * element = m_trtDetManager->getEndcapElement(iSide, iWheel, iStrawLayer, iPhi);
543 if (element) {
544 // get element location for debugging
545// HepGeom::Point3D<double> center = element->transform() * HepGeom::Point3D<double>();
546// ATH_MSG_DEBUG(" TRTDetectorElement id: " << id << " with center = " << center);
547
548 // add element to respective AlignModule
549 trtEndCap[iSide]->addDetElement(Trk::AlignModule::TRT,element,transform);
550 // and fill the corresponding map
551 (*trtIdHashMap)[element->identifyHash()] = trtEndCap[iSide];
552 }
553 else
554 ATH_MSG_DEBUG("No TRT_EndcapElement with side-wheel-strawLayer-phi:" <<iSide<<"-"<<iWheel<<"-"<<iStrawLayer<<"-"<<iPhi);
555 }
556
557 // for endcap we move the CoG
558 Amg::Translation3D translation(trtEndCap[iSide]->centerOfGravity());
559 Amg::Transform3D localtoglobal = translation * Amg::RotationMatrix3D::Identity();
560 trtEndCap[iSide]->setGlobalFrameToAlignFrameTransform(localtoglobal.inverse());
561
562 // add
563 m_alignModuleListPtr->push_back(trtEndCap[iSide]);
564 }
565 }
566}
567
568
569//_______________________________________________________________________
570void TRTGeometryManagerTool::buildL2Barrel()
571{
572 // ===========================
573 // BARREL
574 // ===========================
575 ATH_MSG_INFO("Preparing the TRT Barrel geometry for L2: 3 layers with 32 modules each (96 modules)");
576
577 // ========================================
578 // get all modules for TRT Barrel Level 2 alignment
579 // Level 2 in the barrel is 3 layers with 32 phi modules each
580 // i.e. 96 AlignModules in total
581
582 // define modules
583 // we'll stick with the base AlignModule here since we don't want to
584 // do shifting for the moment but we might need to extend AlignModule
585 // in the future
586
587 // TRT detector element positions are stored in the DB in global frame
588 // so the DB frame to global frame transform is identity
589 Amg::Transform3D transform = Amg::Transform3D::Identity();
590
591 // get maximum number of elements from the helper
592 unsigned int maxHash = 0;
593 if(m_alignLevelEndcaps==3)
594 maxHash = m_idHelper->straw_hash_max();
595 else
596 maxHash = m_idHelper->straw_layer_hash_max();
597 ATH_MSG_DEBUG("maxHash for the TRT "<<maxHash);
598
599 if(!m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT))
600 m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT) = new Trk::AlignModuleList((size_t)maxHash,nullptr);
601 Trk::AlignModuleList * trtIdHashMap = m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT);
602
603 // for the alignment frame we would like to use something like
604 // the 'center-of-gravity' (cog) of the module and the rotation
605 // of the strawlayer planes. the main problem here is that the
606 // planes are not entirely parallel. for the definition of the
607 // alignment of the module this is all irrelevant, but we would
608 // like to give the twist some meaning, like 'the rotation
609 // around the most central straw': since strawlayer planes are
610 // even and straws as well, there is no such thing as a really
611 // central straw. we'll do something that brings us as close as
612 // possible: for the central plane take strawlayer that is at
613 // (N+1)/2, where N is the maximum strawlayer. (strawlayers
614 // start counting at 0). The reason to pick the outer of the two
615 // central strawlayers is that there are more straws per layer
616 // in the outer layers and that the outer layers are also
617 // further apart, so this is closer to the 'real' cog.
618
619 for (unsigned int iPhiModule = 0; iPhiModule < m_trtDetManager->getNumerology()->getNBarrelPhi(); iPhiModule++) { // modules in phi
620 for (unsigned int iLayer = 0; iLayer < m_trtDetManager->getNumerology()->getNBarrelRings(); iLayer++) {// barrel layers
621 // create the AlignModule
622 Trk::AlignModule * mod = new Trk::AlignModule(this);
623 mod->setIdHash(getNextIDHash());
624 mod->setIdentifier(m_idHelper->module_id(-1, iPhiModule, iLayer));
625
626 std::stringstream name;
627 name<<"TRT/Barrel/Module_-1_"<<iPhiModule<<"_"<<iLayer;
628 mod->setName(name.str());
629
630 if(!moduleSelected(mod) || !moduleSelectedBarrel(iLayer,iPhiModule)) {
631 ATH_MSG_DEBUG("Module "<<mod->name()<<" NOT selected");
632 delete mod;
633 continue;
634 }
635
636 ATH_MSG_DEBUG("Building module "<<mod->name());
637
638 // create the collection of central layers for cog and transform calculation
639 std::vector<const Trk::TrkDetElementBase *> centralLayers;
640
641 int maxstrawlayer = m_trtDetManager->getNumerology()->getNBarrelLayers(iLayer);
642 ATH_MSG_DEBUG("maxstrawlayer "<<maxstrawlayer);
643 for (int iStrawLayer = 0; iStrawLayer < maxstrawlayer; iStrawLayer++) { // straw layers inside one phi module
644 ATH_MSG_DEBUG("iStrawLayer "<<iStrawLayer);
645 for (int iSide = 0; iSide < 2; iSide++) { // side of the straw
646 ATH_MSG_DEBUG("iSide "<<iSide);
647 const TRT_BarrelElement * element = m_trtDetManager->getBarrelElement(iSide, iLayer, iPhiModule, iStrawLayer);
648 if (element) {
649 // get element location for debugging
650// HepGeom::Point3D<double> center = element->transform() * HepGeom::Point3D<double>();
651// ATH_MSG_DEBUG(" TRTDetectorElement id: " << element->identify() << " with center = " << center);
652
653 // update maximum straw layer
654 maxstrawlayer = std::max(maxstrawlayer,m_idHelper->straw_layer(element->identify()));
655
656 // add element to respective AlignModule
657 mod->addDetElement(Trk::AlignModule::TRT,element,transform);
658
659 // and fill the corresponding map
660 (*trtIdHashMap)[element->identifyHash()] = mod;
661
662 // add central layers to centralLayers collection
663 // maxstrawlayer is probably odd (if there is an even number
664 // of strawlayers), but I could be wrong, so let's make this always work:
665 // if maxstrawlayer==23, we want to pick strawlayer 12
666 // if maxstrawlayer==24, we still want to pick strawlayer 12
667 if( iStrawLayer == maxstrawlayer/2 ) {
668 //Amg::Vector3D center = element->transform() * Amg::Vector3D(0,0,0);
669 centralLayers.push_back(element);
670 }
671 }
672 else
673 ATH_MSG_DEBUG("No TRT_BarrelElement with side-layer-phi-strawLayer:" <<iSide<<"-"<<iLayer<<"-"<<iPhiModule<<"-"<<iStrawLayer);
674 }
675 }
676
677 // This is how the frames line up for a bec=-1 module at global
678 // position (0,R,-360):
679 //
680 // global straw det-element
681 // x +x -x
682 // y +y +z
683 // z +z +y
684 //
685 // For other bec=-1 modules you just need to rotate around
686 // global y. For bec=+1 modules it looks like this:
687 //
688 // global straw det-element
689 // x -x -x
690 // y +y +z
691 // z -z +y
692 // So that just involves one rotation around local-y for the strawreference frame.
693 //
694 std::vector<std::vector<const Trk::TrkDetElementBase *> *> centralLayersVec;
695 centralLayersVec.push_back(&centralLayers);
696
697 Amg::Translation3D translation(Trk::AlignModule::centerOfGravity(centralLayersVec));
698 // for the rotation, we choose the element on the '-1' side.
699 Amg::RotationMatrix3D rotation = ( m_idHelper->barrel_ec(centralLayers.front()->identify()) == -1 ) ?
700 centralLayers.front()->transform().rotation() : centralLayers.back()->transform().rotation();
701 Amg::Transform3D localToGlobal = translation * rotation;
702
703
704
705 ATH_MSG_DEBUG("centerOfGravity "<< mod->centerOfGravity(centralLayersVec));
706 ATH_MSG_DEBUG("Prepared local to global transform : "<<std::setprecision(12)<<localToGlobal.translation()<<" "<<localToGlobal.rotation());
707
708 mod->setGlobalFrameToAlignFrameTransform(localToGlobal.inverse());
709
710 // add AlignModule to the geometry
711 m_alignModuleListPtr->push_back(mod);
712 }
713 }
714
715 }
716
717
718//_______________________________________________________________________
719void TRTGeometryManagerTool::buildL2Endcaps()
720{
721 // ===========================
722 // ENDCAPs
723 // ===========================
724 ATH_MSG_INFO("Preparing the TRT Endcap geometry for L2: 2 x 40 rings");
725
726 // ========================================
727 // get all modules for TRT Endcap Level 2 alignment
728 // Level 2 in the endcaps is 40 rings per endcap
729 // i.e. 40 AlignModules in total
730
731 // define modules
732 // we'll stick with the base AlignModule here since we don't want to
733 // do shifting for the moment but we might need to extend AlignModule
734 // in the future
735
736 // TRT detector element positions are stored in the DB in global frame
737 // so the DB frame to global frame transform is identity
738 Amg::Transform3D transform = Amg::Transform3D::Identity();
739
740 // get maximum number of elements from the helper
741 unsigned int maxHash = 0;
742 if(m_alignLevelBarrel==3)
743 maxHash = m_idHelper->straw_hash_max();
744 else
745 maxHash = m_idHelper->straw_layer_hash_max();
746 ATH_MSG_DEBUG("maxHash for the TRT "<<maxHash);
747
748 if(!m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT))
749 m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT) = new Trk::AlignModuleList((size_t)maxHash,nullptr);
750 Trk::AlignModuleList * trtIdHashMap = m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT);
751
752 for (int iSide = 0; iSide < 2; iSide++) {
753 int idSide = iSide ? 2 : -2;
754 ATH_MSG_DEBUG("Side : "<<iSide<<" , idSide : "<<idSide);
755 if( m_endcap!=idSide && m_endcap!=0 ) {
756 ATH_MSG_DEBUG("Endcap "<<idSide<<" NOT aligned");
757 continue;
758 }
759
760 int iRing(-1);
761 std::unique_ptr<Trk::AlignModule> mod;
762 for (unsigned int iWheel = 0; iWheel < m_trtDetManager->getNumerology()->getNEndcapWheels(); iWheel++) {
763 ATH_MSG_DEBUG("Wheel : "<<iWheel);
764 for (unsigned int iStrawLayer = 0; iStrawLayer < m_trtDetManager->getNumerology()->getNEndcapLayers(iWheel); iStrawLayer++) {
765 ATH_MSG_DEBUG("StrawLayer : "<<iStrawLayer);
766
767 if(iStrawLayer%4==0) {
768 if(iRing >= 0 && mod) {
769 // before creating module for new ring we set the alignment
770 // frame for the previous one and add it to the list of modules
771 ATH_MSG_DEBUG("Setting frame for ring : "<<iRing);
772
773 // for endcap we move the CoG with no additional rotation
774 Amg::Translation3D translation(mod->centerOfGravity());
775
776 Amg::Transform3D localToGlobal = translation * Amg::RotationMatrix3D::Identity();
777
778 mod->setGlobalFrameToAlignFrameTransform(localToGlobal.inverse());
779
780 // add AlignModule to the geometry
781 m_alignModuleListPtr->push_back(mod.release());
782 }
783
784 // new ring
785 iRing++;
786
787 ATH_MSG_DEBUG("Ring : "<<iRing);
788 // create the AlignModule
789 mod= std::make_unique<Trk::AlignModule>(this);
790 mod->setIdHash(getNextIDHash());
791 // Identifier for a ring is the Identifier for the first Straw layer in that ring
792 // one ring has 4 straw layers
793 int strawLayerForRing = (iStrawLayer/4) * 4;
794 mod->setIdentifier(m_idHelper->layer_id((iSide ? 2:-2),0,iWheel,strawLayerForRing));
795
796 std::stringstream name;
797 name<<"TRT/Endcap/Module_"<<(iSide ? 2:-2)<<"_"<<iRing;
798 mod->setName(name.str());
799
800 if(!moduleSelected(mod.get())) {
801 ATH_MSG_DEBUG("Module "<<mod->name()<<" NOT selected");
802 mod.reset();
803 continue;
804 }
805
806 ATH_MSG_DEBUG("Building module "<<mod->name());
807 }
808 if (!mod) continue;
809 for(unsigned int iPhi = 0; iPhi < m_trtDetManager->getNumerology()->getNEndcapPhi(); iPhi++) {
810 const TRT_EndcapElement * element = m_trtDetManager->getEndcapElement(iSide, iWheel, iStrawLayer, iPhi);
811 if (element) {
812 // get element location for debugging
813// HepGeom::Point3D<double> center = element->transform() * HepGeom::Point3D<double>();
814// ATH_MSG_DEBUG(" TRTDetectorElement id: " << id << " with center = " << center);
815
816 // add element to respective AlignModule
817 mod->addDetElement(Trk::AlignModule::TRT,element,transform);
818
819 // and fill the corresponding map
820 //coverity[WRAPPER_ESCAPE]
821 (*trtIdHashMap)[element->identifyHash()] = mod.get();
822 }
823 else
824 ATH_MSG_DEBUG("No TRT_EndcapElement with side-wheel-strawLayer-phi:" <<iSide<<"-"<<iWheel<<"-"<<iStrawLayer<<"-"<<iPhi);
825 }
826 }
827 }
828
829 if (mod) {
830 // for the last ring we have to explicitly set the alignment
831 // frame add it to the list of modules here, at the end of
832 // loop over wheels
833 ATH_MSG_DEBUG("Setting frame for ring : "<<iRing);
834
835 // for endcap we move the CoG with no additional rotation
836 Amg::Translation3D translation(mod->centerOfGravity());
837 Amg::Transform3D localToGlobal = translation * Amg::RotationMatrix3D::Identity();
838
839 mod->setGlobalFrameToAlignFrameTransform(localToGlobal.inverse());
840
841 // add AlignModule to the geometry
842 m_alignModuleListPtr->push_back(mod.release());
843 }
844 }
845}
846
847
848//_______________________________________________________________________
849void TRTGeometryManagerTool::buildL2EndcapsOLD()
850{
851 // !!!! WARNING !!!!
852 // !!!! This method sets up the TRT Endcap level 2 geometry which
853 // !!!! is now obsolete. The method buildL2Endcap() should be used
854 // !!!! instead !!!
855
856 // ===========================
857 // ENDCAPs
858 // ===========================
859 ATH_MSG_INFO("Preparing the _OLD_ TRT Endcap geometry for L2: 2 x 14 wheels");
860
861 // ========================================
862 // get all modules for TRT Endcap Level 2 alignment
863 // Level 2 in the endcaps is 14 wheels per endcap
864 // i.e. 28 AlignModules in total
865
866 // define modules
867 // we'll stick with the base AlignModule here since we don't want to
868 // do shifting for the moment but we might need to extend AlignModule
869 // in the future
870
871 // TRT detector element positions are stored in the DB in global frame
872 // so the DB frame to global frame transform is identity
873 Amg::Transform3D transform = Amg::Transform3D::Identity();
874
875 // get maximum number of elements from the helper
876 unsigned int maxHash = 0;
877 if(m_alignLevelBarrel==3)
878 maxHash = m_idHelper->straw_hash_max();
879 else
880 maxHash = m_idHelper->straw_layer_hash_max();
881 ATH_MSG_DEBUG("maxHash for the TRT "<<maxHash);
882
883 if(!m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT))
884 m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT) = new Trk::AlignModuleList((size_t)maxHash,nullptr);
885 Trk::AlignModuleList * trtIdHashMap = m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT);
886
887 for (int iSide = 0; iSide < 2; iSide++) {
888 int idSide = iSide ? 2 : -2;
889 ATH_MSG_DEBUG("Side : "<<iSide<<" , idSide : "<<idSide);
890 if( m_endcap!=idSide && m_endcap!=0 ) {
891 ATH_MSG_DEBUG("Endcap "<<idSide<<" NOT aligned");
892 continue;
893 }
894
895 for (unsigned int iWheel = 0; iWheel < m_trtDetManager->getNumerology()->getNEndcapWheels(); iWheel++) {
896 // create the AlignModule
897 Trk::AlignModule * mod = new Trk::AlignModule(this);
898 mod->setIdHash(getNextIDHash());
899 mod->setIdentifier(m_idHelper->module_id(idSide,0,iWheel));
900
901 std::stringstream name;
902 name<<"TRT/Endcap/Module_"<<idSide<<"_"<<iWheel;
903 mod->setName(name.str());
904
905 if(!moduleSelected(mod)) {
906 ATH_MSG_DEBUG("Module "<<mod->name()<<" NOT selected");
907 delete mod;
908 continue;
909 }
910
911 ATH_MSG_DEBUG("Building module "<<mod->name());
912
913 for (unsigned int iStrawLayer = 0; iStrawLayer < m_trtDetManager->getNumerology()->getNEndcapLayers(iWheel); iStrawLayer++) {
914 for(unsigned int iPhi = 0; iPhi < m_trtDetManager->getNumerology()->getNEndcapPhi(); iPhi++) {
915 const TRT_EndcapElement * element = m_trtDetManager->getEndcapElement(iSide, iWheel, iStrawLayer, iPhi);
916 if (element) {
917 // get element location for debugging
918// HepGeom::Point3D<double> center = element->transform() * HepGeom::Point3D<double>();
919// ATH_MSG_DEBUG(" TRTDetectorElement id: " << id << " with center = " << center);
920
921 // add element to respective AlignModule
922 mod->addDetElement(Trk::AlignModule::TRT,element,transform);
923
924 // and fill the corresponding map
925 (*trtIdHashMap)[element->identifyHash()] = mod;
926 }
927 else
928 ATH_MSG_DEBUG("No TRT_EndcapElement with side-wheel-strawLayer-phi:" <<iSide<<"-"<<iWheel<<"-"<<iStrawLayer<<"-"<<iPhi);
929 }
930 }
931
932 // for endcap we move the CoG with no additional rotation
933 Amg::Translation3D translation(mod->centerOfGravity());
934 Amg::Transform3D localtoglobal = translation * Amg::RotationMatrix3D::Identity();
935
936 mod->setGlobalFrameToAlignFrameTransform(localtoglobal.inverse());
937
938 // add AlignModule to the geometry
939 m_alignModuleListPtr->push_back(mod);
940 }
941 }
942
943 }
944
945
946//_______________________________________________________________________
947void TRTGeometryManagerTool::buildL3Barrel()
948{
949 // ===========================
950 // BARREL Level 3
951 // ===========================
952 ATH_MSG_INFO("Preparing the TRT Barrel geometry for L3");
953
954 // ========================================
955 // get all modules for TRT Barrel Level 3 alignment
956 // Level 3 is one AlignModule per straw
957
958 // define modules
959 // we'll stick with the base AlignModule here since we don't want to
960 // do shifting for the moment but we might need to extend AlignModule
961 // in the future
962
963 // TRT detector element positions are stored in the DB in global frame
964 // so the DB frame to global frame transform is identity
965 Amg::Transform3D transform = Amg::Transform3D::Identity();
966
967 // get maximum number of elements from the helper
968 unsigned int maxHash = m_idHelper->straw_hash_max();
969 ATH_MSG_DEBUG("maxHash for the TRT "<<maxHash);
970
971 if(!m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT))
972 m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT) = new Trk::AlignModuleList((size_t)maxHash,nullptr);
973 Trk::AlignModuleList * trtIdHashMap = m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT);
974
975 for (unsigned int iPhiModule = 0; iPhiModule < m_trtDetManager->getNumerology()->getNBarrelPhi(); iPhiModule++) { // modules in phi
976 ATH_MSG_DEBUG("iPhiModule "<<iPhiModule);
977 for (unsigned int iLayer = 0; iLayer < m_trtDetManager->getNumerology()->getNBarrelRings(); iLayer++) {// barrel layers
978 ATH_MSG_DEBUG("iLayer "<<iLayer);
979
980 if(!moduleSelectedBarrel(iLayer,iPhiModule)) {
981 ATH_MSG_INFO("Skipping barrel layer "<<iLayer<<" phi sector "<<iPhiModule);
982 continue;
983 }
984
985 for (unsigned int iStrawLayer = 0; iStrawLayer < m_trtDetManager->getNumerology()->getNBarrelLayers(iLayer); iStrawLayer++) { // straw layers inside one phi module
986 ATH_MSG_DEBUG("iStrawLayer "<<iStrawLayer);
987 for (int iSide = 0; iSide < 2; iSide++) { // side of the straw
988 ATH_MSG_DEBUG("iSide "<<iSide);
989 int idSide = iSide ? 1 : -1;
990
991 const TRT_BarrelElement * element = m_trtDetManager->getBarrelElement(iSide, iLayer, iPhiModule, iStrawLayer);
992 if(element) {
993 for (unsigned int iStraw = 0; iStraw< element->nStraws(); iStraw++)
994 {
995 ATH_MSG_DEBUG("iStraw "<<iStraw);
996
997 // create the AlignModule
998 Trk::AlignModule * mod = new Trk::AlignModule(this);
999 mod->setIdHash(getNextIDHash());
1000 Identifier moduleId = m_idHelper->straw_id(idSide,iPhiModule,iLayer,iStrawLayer,iStraw);
1001 mod->setIdentifier(moduleId);
1002
1003 std::stringstream name;
1004 name<<"TRT/Barrel/Straw_"<<idSide<<"_"<<iPhiModule<<"_"<<iLayer<<"_"<<iStrawLayer<<"_"<<iStraw;
1005 mod->setName(name.str());
1006
1007 if(!moduleSelected(mod)) {
1008 ATH_MSG_DEBUG("Module "<<mod->name()<<" NOT selected");
1009 delete mod;
1010 mod=nullptr;
1011 continue;
1012 }
1013
1014 ATH_MSG_DEBUG("Building module "<<mod->name());
1015
1016 // add element to respective AlignModule
1017 mod->addDetElement(Trk::AlignModule::TRT, element, transform, moduleId);
1018
1019 // and fill the corresponding map
1020 (*trtIdHashMap)[m_idHelper->straw_hash(moduleId)] = mod;
1021
1022 // set the align frame transform
1023 Amg::Transform3D localToGlobal = element->strawTransform(iStraw);
1024 Amg::RotationMatrix3D lgrot = localToGlobal.rotation();
1025 ATH_MSG_DEBUG("Prepared local to global transform : "<<std::setprecision(12)
1026 <<localToGlobal.translation()<<" "<<localToGlobal.rotation());
1027 ATH_MSG_DEBUG(" rotation = (" << lgrot(2,1) << "," << lgrot(0,2) << "," << lgrot(1,0) << ")");
1028
1029 mod->setGlobalFrameToAlignFrameTransform(localToGlobal.inverse());
1030
1031 Amg::Transform3D aatr = element->transform();
1032 Amg::RotationMatrix3D aarot = aatr.rotation();
1033
1034 ATH_MSG_DEBUG("Straw layer transform : "<<std::setprecision(12)
1035 <<aatr.translation()<<" "<<aatr.rotation());
1036 ATH_MSG_DEBUG(" rotation = (" << aarot(2,1) << "," << aarot(0,2) << "," << aarot(1,0) << ")");
1037
1038 // add AlignModule to the geometry
1039 m_alignModuleListPtr->push_back(mod);
1040 }
1041 }
1042 else
1043 ATH_MSG_DEBUG("No TRT_BarrelElement with side-layer-phi-strawLayer:" <<iSide<<"-"<<iLayer<<"-"<<iPhiModule<<"-"<<iStrawLayer);
1044 }
1045 }
1046 }
1047 }
1048
1049 }
1050
1051//_______________________________________________________________________
1052void TRTGeometryManagerTool::buildL3Endcap()
1053{
1054 // ===========================
1055 // ENDCAP Level 3
1056 // ===========================
1057 ATH_MSG_INFO("Preparing the TRT Endcap geometry for L3");
1058
1059 // ========================================
1060 // get all modules for TRT Endcap Level 3 alignment
1061 // Level 3 is one AlignModule per straw
1062
1063 // define modules
1064 // we'll stick with the base AlignModule here since we don't want to
1065 // do shifting for the moment but we might need to extend AlignModule
1066 // in the future
1067
1068 // TRT detector element positions are stored in the DB in the local frame
1069 // so the DB frame to local frame transform is identity
1070 Amg::Transform3D transform = Amg::Transform3D::Identity();
1071
1072 // get maximum number of elements from the helper
1073 unsigned int maxHash = m_idHelper->straw_hash_max();
1074 ATH_MSG_DEBUG("maxHash for the TRT "<<maxHash);
1075
1076 if(!m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT))
1077 m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT) = new Trk::AlignModuleList((size_t)maxHash,nullptr);
1078 Trk::AlignModuleList * trtIdHashMap = m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT);
1079
1080
1081 for (int iSide = 0; iSide < 2; iSide++) { // endcap
1082 int idSide = iSide ? 2 : -2;
1083 ATH_MSG_DEBUG("Side : "<<iSide<<" , idSide : "<<idSide);
1084 if( m_endcap!=idSide && m_endcap!=0 ) {
1085 ATH_MSG_DEBUG("Endcap "<<idSide<<" NOT aligned");
1086 continue;
1087 }
1088
1089 // wheels in Z
1090 for (unsigned int iWheel = 0; iWheel < m_trtDetManager->getNumerology()->getNEndcapWheels(); iWheel++) {
1091 ATH_MSG_DEBUG("iWheel "<<iWheel);
1092
1093 // sectors in Phi
1094 for (unsigned int iPhiModule = 0; iPhiModule < m_trtDetManager->getNumerology()->getNEndcapPhi(); iPhiModule++) {
1095
1096 ATH_MSG_DEBUG("iPhiModule "<<iPhiModule);
1097
1098 if(!moduleSelectedEndcap(iWheel,iPhiModule)) {
1099 ATH_MSG_INFO("Skipping endcap wheel "<<iWheel<<" phi sector "<<iPhiModule);
1100 continue;
1101 }
1102
1103 // endcap straw layers in z (with in a wheel)
1104 for (unsigned int iStrawLayer = 0; iStrawLayer < m_trtDetManager->getNumerology()->getNEndcapLayers(iWheel); iStrawLayer++) {
1105
1106 const TRT_EndcapElement * element = m_trtDetManager->getEndcapElement(iSide, iWheel, iStrawLayer, iPhiModule);
1107
1108 if(element) {
1109 for (unsigned int iStraw = 0; iStraw< element->nStraws(); iStraw++) {
1110 ATH_MSG_DEBUG("iStraw "<<iStraw);
1111
1112 // create the AlignModule
1113 Trk::AlignModule * mod = new Trk::AlignModule(this);
1114 mod->setIdHash(getNextIDHash());
1115 Identifier moduleId = m_idHelper->straw_id(idSide,iPhiModule,iWheel,iStrawLayer,iStraw);
1116 mod->setIdentifier(moduleId);
1117
1118 std::stringstream name;
1119 name<<"TRT/Endcap/Straw_"<<idSide<<"_"<<iPhiModule<<"_"<<iWheel<<"_"<<iStrawLayer<<"_"<<iStraw;
1120 mod->setName(name.str());
1121
1122 if(!moduleSelected(mod)) {
1123 ATH_MSG_DEBUG("Module "<<mod->name()<<" NOT selected");
1124 delete mod;
1125 mod=nullptr;
1126 continue;
1127 }
1128
1129 ATH_MSG_DEBUG("Building module "<<mod->name());
1130
1131 // add element to respective AlignModule
1132 mod->addDetElement(Trk::AlignModule::TRT, element, transform, moduleId);
1133
1134 // and fill the corresponding map
1135 (*trtIdHashMap)[m_idHelper->straw_hash(moduleId)] = mod;
1136
1137 // set the align frame transform
1138 Amg::Transform3D localToGlobal = element->strawTransform(iStraw);
1139 Amg::RotationMatrix3D lgrot = localToGlobal.rotation();
1140
1141 ATH_MSG_DEBUG("Prepared local to global transform : "<<std::setprecision(12)
1142 <<localToGlobal.translation()<<" "<<localToGlobal.rotation());
1143
1144 ATH_MSG_DEBUG(" rotation = (" << lgrot(2,1) << "," << lgrot(0,2) << "," << lgrot(1,0) << ")");
1145
1146 mod->setGlobalFrameToAlignFrameTransform(localToGlobal.inverse());
1147
1148 Amg::Transform3D aatr = element->transform();
1149 Amg::RotationMatrix3D aarot = aatr.rotation();
1150
1151 ATH_MSG_DEBUG("Straw layer transform : "<<std::setprecision(12)
1152 <<aatr.translation()<<" "<<aatr.rotation());
1153 ATH_MSG_DEBUG(" rotation = (" << aarot(2,1) << "," << aarot(0,2) << "," << aarot(1,0) << ")");
1154
1155 // add AlignModule to the geometry
1156 m_alignModuleListPtr->push_back(mod);
1157 }// Straws
1158 }// if the EndcapElement Exists
1159 else
1160 ATH_MSG_DEBUG("No TRT_EndcapElement with endcap-wheel-strawLayer-phi:" <<iSide<<"-"<<iWheel<<"-"<<iStrawLayer<<"-"<<iPhiModule);
1161 }// StrawLayer
1162 }// PhiModule
1163 }// Wheel
1164 }// Endcap
1165
1166 }
1167
1168//________________________________________________________________________
1169void TRTGeometryManagerTool::addModuleParameters(Trk::AlignModule * module, DataVector< DataVector<Trk::AlignPar> > * allFullModPars, DataVector< DataVector<Trk::AlignPar> > * allActiveModPars)
1170{
1171 // prepare all parameters
1172 DataVector<Trk::AlignPar> * fullModPars = new DataVector<Trk::AlignPar>(SG::OWN_ELEMENTS);
1173 fullModPars->push_back(new Trk::AlignPar(module,Trk::AlignModule::TransX));
1174 fullModPars->push_back(new Trk::AlignPar(module,Trk::AlignModule::TransY));
1175 fullModPars->push_back(new Trk::AlignPar(module,Trk::AlignModule::TransZ));
1176 fullModPars->push_back(new Trk::AlignPar(module,Trk::AlignModule::RotX));
1177 fullModPars->push_back(new Trk::AlignPar(module,Trk::AlignModule::RotY));
1178 fullModPars->push_back(new Trk::AlignPar(module,Trk::AlignModule::RotZ));
1179
1180 // set sigmas
1181 setSigmas(module,fullModPars);
1182
1183 // select active parameters based on jobOption properties
1184 DataVector<Trk::AlignPar> * activeModPars = new DataVector<Trk::AlignPar>(SG::VIEW_ELEMENTS);
1185 for(unsigned int ipar=0;ipar<fullModPars->size();++ipar) {
1186
1187 Identifier modID = module->identify();
1188
1189 if(m_idHelper->is_barrel(modID)) {
1190 ATH_MSG_DEBUG("Barrel module with id "<<modID);
1191 if( (fullModPars->at(ipar)->paramType() == Trk::AlignModule::TransX && m_alignBarrelX)
1192 || (fullModPars->at(ipar)->paramType() == Trk::AlignModule::TransY && m_alignBarrelY)
1193 || (fullModPars->at(ipar)->paramType() == Trk::AlignModule::TransZ && m_alignBarrelZ)
1194 || (fullModPars->at(ipar)->paramType() == Trk::AlignModule::RotX && m_alignBarrelRotX)
1195 || (fullModPars->at(ipar)->paramType() == Trk::AlignModule::RotY && m_alignBarrelRotY)
1196 || (fullModPars->at(ipar)->paramType() == Trk::AlignModule::RotZ && m_alignBarrelRotZ) ) {
1197 ATH_MSG_DEBUG("parameter type "<<fullModPars->at(ipar)->paramType()<<" is now active");
1198 activeModPars->push_back(fullModPars->at(ipar));
1199 }
1200 else
1201 ATH_MSG_DEBUG("parameter type "<<fullModPars->at(ipar)->paramType()<<" is NOT active");
1202 }
1203 else {
1204 ATH_MSG_DEBUG("Endcap module with id "<<modID);
1205 if( (fullModPars->at(ipar)->paramType() == Trk::AlignModule::TransX && m_alignEndcapX)
1206 || (fullModPars->at(ipar)->paramType() == Trk::AlignModule::TransY && m_alignEndcapY)
1207 || (fullModPars->at(ipar)->paramType() == Trk::AlignModule::TransZ && m_alignEndcapZ)
1208 || (fullModPars->at(ipar)->paramType() == Trk::AlignModule::RotX && m_alignEndcapRotX)
1209 || (fullModPars->at(ipar)->paramType() == Trk::AlignModule::RotY && m_alignEndcapRotY)
1210 || (fullModPars->at(ipar)->paramType() == Trk::AlignModule::RotZ && m_alignEndcapRotZ) ) {
1211 ATH_MSG_DEBUG("parameter type "<<fullModPars->at(ipar)->paramType()<<" is now active");
1212 activeModPars->push_back(fullModPars->at(ipar));
1213 }
1214 else
1215 ATH_MSG_DEBUG("parameter type "<<fullModPars->at(ipar)->paramType()<<" is NOT active");
1216 }
1217 }
1218
1219 // add to parameter lists
1220 allFullModPars->push_back(fullModPars);
1221 allActiveModPars->push_back(activeModPars);
1222}
1223
1224
1225//________________________________________________________________________
1226void TRTGeometryManagerTool::setSigmas(Trk::AlignModule * module, DataVector<Trk::AlignPar> * modPars)
1227{
1228 for(unsigned int ipar=0;ipar<modPars->size();++ipar) {
1229 // barrel
1230 if(m_idHelper->is_barrel(module->identify()))
1231 switch(modPars->at(ipar)->paramType()) {
1232 case Trk::AlignModule::TransX:
1233 modPars->at(ipar)->setSigma(m_sigmaBarrelX);
1234 modPars->at(ipar)->setSoftCut(m_softcutBarrelX);
1235 break;
1236 case Trk::AlignModule::TransY:
1237 modPars->at(ipar)->setSigma(m_sigmaBarrelY);
1238 modPars->at(ipar)->setSoftCut(m_softcutBarrelY);
1239 break;
1240 case Trk::AlignModule::TransZ:
1241 modPars->at(ipar)->setSigma(m_sigmaBarrelZ);
1242 modPars->at(ipar)->setSoftCut(m_softcutBarrelZ);
1243 break;
1244 case Trk::AlignModule::RotX:
1245 modPars->at(ipar)->setSigma(m_sigmaBarrelRotX);
1246 modPars->at(ipar)->setSoftCut(m_softcutBarrelRotX);
1247 break;
1248 case Trk::AlignModule::RotY:
1249 modPars->at(ipar)->setSigma(m_sigmaBarrelRotY);
1250 modPars->at(ipar)->setSoftCut(m_softcutBarrelRotY);
1251 break;
1252 case Trk::AlignModule::RotZ:
1253 modPars->at(ipar)->setSigma(m_sigmaBarrelRotZ);
1254 modPars->at(ipar)->setSoftCut(m_softcutBarrelRotZ);
1255 break;
1256 default:
1257 break;
1258 }
1259 // end-caps
1260 else
1261 switch(modPars->at(ipar)->paramType()) {
1262 case Trk::AlignModule::TransX:
1263 modPars->at(ipar)->setSigma(m_sigmaEndcapX);
1264 modPars->at(ipar)->setSoftCut(m_softcutEndcapX);
1265 break;
1266 case Trk::AlignModule::TransY:
1267 modPars->at(ipar)->setSigma(m_sigmaEndcapY);
1268 modPars->at(ipar)->setSoftCut(m_softcutEndcapY);
1269 break;
1270 case Trk::AlignModule::TransZ:
1271 modPars->at(ipar)->setSigma(m_sigmaEndcapZ);
1272 modPars->at(ipar)->setSoftCut(m_softcutEndcapZ);
1273 break;
1274 case Trk::AlignModule::RotX:
1275 modPars->at(ipar)->setSigma(m_sigmaEndcapRotX);
1276 modPars->at(ipar)->setSoftCut(m_softcutEndcapRotX);
1277 break;
1278 case Trk::AlignModule::RotY:
1279 modPars->at(ipar)->setSigma(m_sigmaEndcapRotY);
1280 modPars->at(ipar)->setSoftCut(m_softcutEndcapRotY);
1281 break;
1282 case Trk::AlignModule::RotZ:
1283 modPars->at(ipar)->setSigma(m_sigmaEndcapRotZ);
1284 modPars->at(ipar)->setSoftCut(m_softcutEndcapRotZ);
1285 break;
1286 default:
1287 break;
1288 }
1289 }
1290}
1291
1292
1293//________________________________________________________________________
1294bool TRTGeometryManagerTool::moduleSelected(unsigned long long id)
1295{
1296 if(!m_doModuleSelection)
1297 return true;
1298
1299 int nsel = m_moduleSelection.size();
1300 for(int i=0;i<nsel;++i)
1301 if(m_moduleSelection.at(i) == id)
1302 return true;
1303
1304 return false;
1305}
1306
1307
1308//________________________________________________________________________
1309bool TRTGeometryManagerTool::moduleSelected(Trk::AlignModule * mod)
1310{
1311 return moduleSelected(mod->identify().get_compact());
1312}
1313
1314
1315//________________________________________________________________________
1316bool TRTGeometryManagerTool::moduleSelectedBarrel(unsigned int ilayer, unsigned int iphi)
1317{
1318 bool select = true;
1319 if(!m_barrelLayers.empty()) {
1320 select = false;
1321 for(unsigned int i=0;i<m_barrelLayers.size();i++) {
1322 if(m_barrelLayers[i] == (int)ilayer) {
1323 select = true;
1324 break;
1325 }
1326 }
1327 }
1328
1329 if(!select)
1330 return false;
1331
1332 if(!m_barrelPhiSectors.empty()) {
1333 select = false;
1334 for(unsigned int i=0;i<m_barrelPhiSectors.size();i++) {
1335 if(m_barrelPhiSectors[i] == (int)iphi) {
1336 select = true;
1337 break;
1338 }
1339 }
1340 }
1341
1342 return select;
1343}
1344
1345//________________________________________________________________________
1346bool TRTGeometryManagerTool::moduleSelectedEndcap(unsigned int iwheel, unsigned int iphi)
1347{
1348 bool select = true;
1349 if(!m_endcapWheels.empty()) {
1350 select = false;
1351 for(unsigned int i=0;i<m_endcapWheels.size();++i) {
1352 if(m_endcapWheels[i] == (int)iwheel) {
1353 select = true;
1354 break;
1355 }
1356 }
1357 }
1358
1359 if(!select)
1360 return false;
1361
1362 if(!m_endcapPhiSectors.empty()) {
1363 select = false;
1364 for(unsigned int i=0;i<m_endcapPhiSectors.size();i++) {
1365 if(m_endcapPhiSectors[i] == (int)iphi) {
1366 select = true;
1367 break;
1368 }
1369 }
1370 }
1371
1372 return select;
1373}
1374
1375
1376//________________________________________________________________________
1377void TRTGeometryManagerTool::dumpGeometry()
1378{
1379 ATH_MSG_INFO("---------------------------------------------------");
1380 ATH_MSG_INFO("Summary of the alignment geometry");
1381 ATH_MSG_INFO("Number of alignable objects: "<<m_alignModuleList.size());
1382 ATH_MSG_INFO("Total number of aligment DoFs: "<<m_alignModuleTool->nAlignParameters());
1383
1384 for(unsigned int i=0;i<m_alignModuleList.size();i++) {
1385 const Trk::AlignModule * module = m_alignModuleList.at(i);
1386 //ATH_MSG_DEBUG(i<<". "<< module->name());
1387 //ATH_MSG_DEBUG(" - identifier: "<<module->identify());
1388 //ATH_MSG_DEBUG(" - has "<<module->detElementCollection(Trk::AlignModule::TRT)->size()<<" TRT modules");
1389
1390 Amg::Transform3D localtoglobal = (module->globalFrameToAlignFrame()).inverse();
1391 ATH_MSG_DEBUG(" - local to global : "<<std::setprecision(12)<<localtoglobal.translation()<<" "<<localtoglobal.rotation());
1392
1393 DataVector<Trk::AlignPar> * pars = m_alignModuleTool->getAlignPars(module);
1394 int npars = pars->size();
1395 ATH_MSG_DEBUG(" - number of active transform parameters: "<<npars);
1396 for(int j=0;j<npars;j++)
1397 ATH_MSG_DEBUG(" * par "<<j<<" \'"<<(*pars)[j]->dumpType()<<"\' : sigma = "<<(*pars)[j]->sigma()<<" , softCut = "<<(*pars)[j]->softCut());
1398 }
1399 ATH_MSG_INFO("---------------------------------------------------");
1400}
1401
1402} // end namespace
1403
endmsg
#define endmsg
Definition AnalysisConfig_Ntuple.cxx:54
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x,...)
Definition AthMsgStreamMacros.h:43
ATH_MSG_INFO
#define ATH_MSG_INFO(x,...)
Definition AthMsgStreamMacros.h:45
DataVector.h
An STL vector of pointers that by default owns its pointed-to elements.
TRT_BarrelElement.h
TRT_DetectorManager.h
TRT_EndcapElement.h
TRT_ID.h
This is an Identifier helper class for the TRT subdetector.
TRT_Numerology.h
AlignModule
AlignModule is a grouping of TrkDetElementBase objects, grouped according to the type of alignment,...
AthAlgTool::AthAlgTool
AthAlgTool(const std::string &type, const std::string &name, const IInterface *parent)
Constructor with parameters:
Definition AthAlgTool.cxx:16
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition AthCommonDataStore.h:145
AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
Definition AthCommonDataStore.h:95
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition AthCommonMsg.h:30
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition AthCommonMsg.h:24
DataVector
Derived DataVector<T>.
Definition DataVector.h:795
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
IdentifierHash
This is a "hash" representation of an Identifier.
Definition IdentifierHash.h:25
InDetDD::TRT_BarrelElement
Extended TRT_BaseElement to describe a TRT readout element, this is a planar layer with n ( order of ...
Definition TRT_BarrelElement.h:43
InDetDD::TRT_BaseElement
Virtual base class of TRT readout elements.
Definition TRT_BaseElement.h:56
InDetDD::TRT_BaseElement::identifyHash
virtual IdentifierHash identifyHash() const override final
identifier hash
InDetDD::TRT_BaseElement::nStraws
unsigned int nStraws() const
Number of straws in the element.
InDetDD::TRT_BaseElement::identify
virtual Identifier identify() const override final
identifier of this detector element:
InDetDD::TRT_BaseElement::transform
virtual const Amg::Transform3D & transform() const override final
Element Surface: Get Transform of element in Tracking frame: Amg.
InDetDD::TRT_BaseElement::strawTransform
const Amg::Transform3D & strawTransform(unsigned int straw) const
Straw transform - fast access in array, in Tracking frame: Amg.
Definition TRT_BaseElement.cxx:89
InDetDD::TRT_EndcapElement
Extended class of a TRT_BaseElement to describe a readout elment in the endcap.
Definition TRT_EndcapElement.h:43
InDet::TRTGeometryManagerTool::buildL2Endcaps
void buildL2Endcaps()
builds geometry for L2 TRT Endcapalignment Creates 80 modules - 40 rings per endcap
Definition TRTGeometryManagerTool.cxx:719
InDet::TRTGeometryManagerTool::moduleSelected
bool moduleSelected(Trk::AlignModule *mod)
check wheather module is selected for module pointer
Definition TRTGeometryManagerTool.cxx:1309
InDet::TRTGeometryManagerTool::setSigmas
void setSigmas(Trk::AlignModule *mod, DataVector< Trk::AlignPar > *modPars)
sets sigmas for modules
Definition TRTGeometryManagerTool.cxx:1226
InDet::TRTGeometryManagerTool::buildL2EndcapsOLD
void buildL2EndcapsOLD()
builds geometry for L2 TRT Endcapalignment Creates 28 modules - 14 wheels per endcap
Definition TRTGeometryManagerTool.cxx:849
InDet::TRTGeometryManagerTool::checkAlignLevelEndcaps
bool checkAlignLevelEndcaps()
check whether the Endcap alignment level is correct
Definition TRTGeometryManagerTool.cxx:227
InDet::TRTGeometryManagerTool::m_idHashToAlignModuleMaps
std::vector< Trk::AlignModuleList * > m_idHashToAlignModuleMaps
Definition TRTGeometryManagerTool.h:140
InDet::TRTGeometryManagerTool::dumpGeometry
void dumpGeometry()
print basic geometry info to screen
Definition TRTGeometryManagerTool.cxx:1377
InDet::TRTGeometryManagerTool::buildL0
void buildL0()
builds geometry for L1 TRT alignment Creates 1 module - the whole TRT
Definition TRTGeometryManagerTool.cxx:332
InDet::TRTGeometryManagerTool::setAlignLevel
void setAlignLevel(int level)
set alignment level
Definition TRTGeometryManagerTool.cxx:175
InDet::TRTGeometryManagerTool::m_endcap
int m_endcap
endcap_id of the endcap to align (-2 or 2 for endcap A or C, 0 for both)
Definition TRTGeometryManagerTool.h:193
InDet::TRTGeometryManagerTool::m_trtDetManager
const InDetDD::TRT_DetectorManager * m_trtDetManager
pointer to TRT detector manager
Definition TRTGeometryManagerTool.h:131
InDet::TRTGeometryManagerTool::moduleSelectedEndcap
bool moduleSelectedEndcap(unsigned int iwheel, unsigned int iphi)
check wheather we are aligning the different endcaps and sectors
Definition TRTGeometryManagerTool.cxx:1346
InDet::TRTGeometryManagerTool::buildGeometry
void buildGeometry()
builds geometry for TRT alignment
Definition TRTGeometryManagerTool.cxx:286
InDet::TRTGeometryManagerTool::m_fullAlignParList
DataVector< DataVector< Trk::AlignPar > > * m_fullAlignParList
Definition TRTGeometryManagerTool.h:143
InDet::TRTGeometryManagerTool::buildL3Barrel
void buildL3Barrel()
builds geometry for L3 TRT Barrel alignment Creates many modules - one module per straw
Definition TRTGeometryManagerTool.cxx:947
InDet::TRTGeometryManagerTool::moduleSelectedBarrel
bool moduleSelectedBarrel(unsigned int iLayer, unsigned int iPhi)
check wheather barrel module is selected by layer and phi
Definition TRTGeometryManagerTool.cxx:1316
InDet::TRTGeometryManagerTool::m_barrelPhiSectors
std::vector< int > m_barrelPhiSectors
list of barrel phi sectors to align (if empty, align everything)
Definition TRTGeometryManagerTool.h:190
InDet::TRTGeometryManagerTool::buildL1Endcaps
void buildL1Endcaps()
builds geometry for L1 TRT Endcap alignment Creates 2 modules, one for each endcap
Definition TRTGeometryManagerTool.cxx:484
InDet::TRTGeometryManagerTool::m_barrelLayers
std::vector< int > m_barrelLayers
list of barrel layers to align (if empty, align everything)
Definition TRTGeometryManagerTool.h:191
InDet::TRTGeometryManagerTool::m_moduleSelection
std::vector< unsigned long long > m_moduleSelection
Definition TRTGeometryManagerTool.h:198
InDet::TRTGeometryManagerTool::buildL1Barrel
void buildL1Barrel()
builds geometry for L1 TRT Barrel alignment Creates single module for barrel
Definition TRTGeometryManagerTool.cxx:409
InDet::TRTGeometryManagerTool::m_alignModuleTool
ToolHandle< Trk::IAlignModuleTool > m_alignModuleTool
pointer to AlignModuleTool
Definition TRTGeometryManagerTool.h:135
InDet::TRTGeometryManagerTool::m_endcapPhiSectors
std::vector< int > m_endcapPhiSectors
list of endcap phi sectors to align (if empty, align everything)
Definition TRTGeometryManagerTool.h:194
InDet::TRTGeometryManagerTool::buildL3Endcap
void buildL3Endcap()
builds geometry for L3 TRT Endcap alignment Creates many modules - one module per straw
Definition TRTGeometryManagerTool.cxx:1052
InDet::TRTGeometryManagerTool::buildL2Barrel
void buildL2Barrel()
builds geometry for L2 TRT Barrel alignment Creates 96 modules - 3 layers with 32 modules per layer
Definition TRTGeometryManagerTool.cxx:570
InDet::TRTGeometryManagerTool::TRTGeometryManagerTool
TRTGeometryManagerTool(const std::string &type, const std::string &name, const IInterface *parent)
Definition TRTGeometryManagerTool.cxx:31
InDet::TRTGeometryManagerTool::ReadGeometry
int ReadGeometry(int solveLevel)
read the geometry Method is called from the main AlignAlg to build the geometry based on the requeste...
Definition TRTGeometryManagerTool.cxx:244
InDet::TRTGeometryManagerTool::m_endcapWheels
std::vector< int > m_endcapWheels
list of endcap wheels to align (if empty, align everything)
Definition TRTGeometryManagerTool.h:195
InDet::TRTGeometryManagerTool::m_alignParList
DataVector< DataVector< Trk::AlignPar > > * m_alignParList
Definition TRTGeometryManagerTool.h:142
InDet::TRTGeometryManagerTool::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 TRTGeometryManagerTool.cxx:1169
InDet::TRTGeometryManagerTool::checkAlignLevel
bool checkAlignLevel()
check whether the alignment level is correct
Definition TRTGeometryManagerTool.cxx:182
InDet::TRTGeometryManagerTool::checkAlignLevelBarrel
bool checkAlignLevelBarrel()
check whether the Barrel alignment level is correct
Definition TRTGeometryManagerTool.cxx:210
Trk::AlignModule::centerOfGravity
static Amg::Vector3D centerOfGravity(const std::vector< DetElementCollection * > &)
Calculates center of gravity (average center of associated det-elements).
Definition AlignModule.cxx:95
Trk::AlignModule::setIdHash
void setIdHash(IdentifierHash id)
Definition AlignModule.h:94
Trk::AlignModule::setIdentifier
void setIdentifier(Identifier identifier)
Set and return identifier of module.
Definition AlignModule.h:97
Trk::AlignModule::name
const std::string & name() const
Definition AlignModule.h:90
Trk::AlignModule::setName
void setName(const std::string &name)
Set and return name of align module (i.e.
Definition AlignModule.h:89
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::IGeometryManagerTool::m_logStream
std::ostream * m_logStream
logfile output stream
Definition IGeometryManagerTool.h:113
Trk::IGeometryManagerTool::m_alignLevelBarrel
int m_alignLevelBarrel
alignment level
Definition IGeometryManagerTool.h:116
Trk::IGeometryManagerTool::m_hashCounter
int m_hashCounter
variable for setting the idHash of the AlignModules
Definition IGeometryManagerTool.h:111
Trk::IGeometryManagerTool::getNextIDHash
virtual int getNextIDHash()
get next free IDHash usable for new AlignModule
Definition IGeometryManagerTool.h:65
Trk::IGeometryManagerTool::m_alignModuleListPtr
Trk::AlignModuleList * m_alignModuleListPtr
pointer to module list to which the modules are added
Definition IGeometryManagerTool.h:106
Trk::IGeometryManagerTool::m_alignLevelEndcaps
int m_alignLevelEndcaps
alignment level
Definition IGeometryManagerTool.h:117
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
Amg::RotationMatrix3D
Eigen::Matrix< double, 3, 3 > RotationMatrix3D
Definition GeoPrimitives.h:49
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition GeoPrimitives.h:46
Amg::Translation3D
Eigen::Translation< double, 3 > Translation3D
Definition GeoPrimitives.h:44
InDetDD
Message Stream Member.
Definition FakeTrackBuilder.h:8
InDet
Primary Vertex Finder.
Definition VP1ErrorUtils.h:36
SG::OWN_ELEMENTS
@ OWN_ELEMENTS
this data object owns its elements
Definition OwnershipPolicy.h:17
SG::VIEW_ELEMENTS
@ VIEW_ELEMENTS
this data object is a view, it does not own its elmts
Definition OwnershipPolicy.h:18
Trk
Ensure that the ATLAS eigen extensions are properly loaded.
Definition FakeTrackBuilder.h:9
Trk::AlignModuleList
std::vector< AlignModule * > AlignModuleList
Definition AlignModuleList.h:37
index
Definition index.py:1
Generated on for ATLAS Offline Software by doxygen 1.17.0