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.reset(new 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 (*trtIdHashMap)[element->identifyHash()] = mod.get();
821 }
822 else
823 ATH_MSG_DEBUG("No TRT_EndcapElement with side-wheel-strawLayer-phi:" <<iSide<<"-"<<iWheel<<"-"<<iStrawLayer<<"-"<<iPhi);
824 }
825 }
826 }
827
828 if (mod) {
829 // for the last ring we have to explicitly set the alignment
830 // frame add it to the list of modules here, at the end of
831 // loop over wheels
832 ATH_MSG_DEBUG("Setting frame for ring : "<<iRing);
833
834 // for endcap we move the CoG with no additional rotation
835 Amg::Translation3D translation(mod->centerOfGravity());
836 Amg::Transform3D localToGlobal = translation * Amg::RotationMatrix3D::Identity();
837
838 mod->setGlobalFrameToAlignFrameTransform(localToGlobal.inverse());
839
840 // add AlignModule to the geometry
841 m_alignModuleListPtr->push_back(mod.release());
842 }
843 }
844}
845
846
847//_______________________________________________________________________
848void TRTGeometryManagerTool::buildL2EndcapsOLD()
849{
850 // !!!! WARNING !!!!
851 // !!!! This method sets up the TRT Endcap level 2 geometry which
852 // !!!! is now obsolete. The method buildL2Endcap() should be used
853 // !!!! instead !!!
854
855 // ===========================
856 // ENDCAPs
857 // ===========================
858 ATH_MSG_INFO("Preparing the _OLD_ TRT Endcap geometry for L2: 2 x 14 wheels");
859
860 // ========================================
861 // get all modules for TRT Endcap Level 2 alignment
862 // Level 2 in the endcaps is 14 wheels per endcap
863 // i.e. 28 AlignModules in total
864
865 // define modules
866 // we'll stick with the base AlignModule here since we don't want to
867 // do shifting for the moment but we might need to extend AlignModule
868 // in the future
869
870 // TRT detector element positions are stored in the DB in global frame
871 // so the DB frame to global frame transform is identity
872 Amg::Transform3D transform = Amg::Transform3D::Identity();
873
874 // get maximum number of elements from the helper
875 unsigned int maxHash = 0;
876 if(m_alignLevelBarrel==3)
877 maxHash = m_idHelper->straw_hash_max();
878 else
879 maxHash = m_idHelper->straw_layer_hash_max();
880 ATH_MSG_DEBUG("maxHash for the TRT "<<maxHash);
881
882 if(!m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT))
883 m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT) = new Trk::AlignModuleList((size_t)maxHash,nullptr);
884 Trk::AlignModuleList * trtIdHashMap = m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT);
885
886 for (int iSide = 0; iSide < 2; iSide++) {
887 int idSide = iSide ? 2 : -2;
888 ATH_MSG_DEBUG("Side : "<<iSide<<" , idSide : "<<idSide);
889 if( m_endcap!=idSide && m_endcap!=0 ) {
890 ATH_MSG_DEBUG("Endcap "<<idSide<<" NOT aligned");
891 continue;
892 }
893
894 for (unsigned int iWheel = 0; iWheel < m_trtDetManager->getNumerology()->getNEndcapWheels(); iWheel++) {
895 // create the AlignModule
896 Trk::AlignModule * mod = new Trk::AlignModule(this);
897 mod->setIdHash(getNextIDHash());
898 mod->setIdentifier(m_idHelper->module_id(idSide,0,iWheel));
899
900 std::stringstream name;
901 name<<"TRT/Endcap/Module_"<<idSide<<"_"<<iWheel;
902 mod->setName(name.str());
903
904 if(!moduleSelected(mod)) {
905 ATH_MSG_DEBUG("Module "<<mod->name()<<" NOT selected");
906 delete mod;
907 continue;
908 }
909
910 ATH_MSG_DEBUG("Building module "<<mod->name());
911
912 for (unsigned int iStrawLayer = 0; iStrawLayer < m_trtDetManager->getNumerology()->getNEndcapLayers(iWheel); iStrawLayer++) {
913 for(unsigned int iPhi = 0; iPhi < m_trtDetManager->getNumerology()->getNEndcapPhi(); iPhi++) {
914 const TRT_EndcapElement * element = m_trtDetManager->getEndcapElement(iSide, iWheel, iStrawLayer, iPhi);
915 if (element) {
916 // get element location for debugging
917// HepGeom::Point3D<double> center = element->transform() * HepGeom::Point3D<double>();
918// ATH_MSG_DEBUG(" TRTDetectorElement id: " << id << " with center = " << center);
919
920 // add element to respective AlignModule
921 mod->addDetElement(Trk::AlignModule::TRT,element,transform);
922
923 // and fill the corresponding map
924 (*trtIdHashMap)[element->identifyHash()] = mod;
925 }
926 else
927 ATH_MSG_DEBUG("No TRT_EndcapElement with side-wheel-strawLayer-phi:" <<iSide<<"-"<<iWheel<<"-"<<iStrawLayer<<"-"<<iPhi);
928 }
929 }
930
931 // for endcap we move the CoG with no additional rotation
932 Amg::Translation3D translation(mod->centerOfGravity());
933 Amg::Transform3D localtoglobal = translation * Amg::RotationMatrix3D::Identity();
934
935 mod->setGlobalFrameToAlignFrameTransform(localtoglobal.inverse());
936
937 // add AlignModule to the geometry
938 m_alignModuleListPtr->push_back(mod);
939 }
940 }
941
942 }
943
944
945//_______________________________________________________________________
946void TRTGeometryManagerTool::buildL3Barrel()
947{
948 // ===========================
949 // BARREL Level 3
950 // ===========================
951 ATH_MSG_INFO("Preparing the TRT Barrel geometry for L3");
952
953 // ========================================
954 // get all modules for TRT Barrel Level 3 alignment
955 // Level 3 is one AlignModule per straw
956
957 // define modules
958 // we'll stick with the base AlignModule here since we don't want to
959 // do shifting for the moment but we might need to extend AlignModule
960 // in the future
961
962 // TRT detector element positions are stored in the DB in global frame
963 // so the DB frame to global frame transform is identity
964 Amg::Transform3D transform = Amg::Transform3D::Identity();
965
966 // get maximum number of elements from the helper
967 unsigned int maxHash = m_idHelper->straw_hash_max();
968 ATH_MSG_DEBUG("maxHash for the TRT "<<maxHash);
969
970 if(!m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT))
971 m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT) = new Trk::AlignModuleList((size_t)maxHash,nullptr);
972 Trk::AlignModuleList * trtIdHashMap = m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT);
973
974 for (unsigned int iPhiModule = 0; iPhiModule < m_trtDetManager->getNumerology()->getNBarrelPhi(); iPhiModule++) { // modules in phi
975 ATH_MSG_DEBUG("iPhiModule "<<iPhiModule);
976 for (unsigned int iLayer = 0; iLayer < m_trtDetManager->getNumerology()->getNBarrelRings(); iLayer++) {// barrel layers
977 ATH_MSG_DEBUG("iLayer "<<iLayer);
978
979 if(!moduleSelectedBarrel(iLayer,iPhiModule)) {
980 ATH_MSG_INFO("Skipping barrel layer "<<iLayer<<" phi sector "<<iPhiModule);
981 continue;
982 }
983
984 for (unsigned int iStrawLayer = 0; iStrawLayer < m_trtDetManager->getNumerology()->getNBarrelLayers(iLayer); iStrawLayer++) { // straw layers inside one phi module
985 ATH_MSG_DEBUG("iStrawLayer "<<iStrawLayer);
986 for (int iSide = 0; iSide < 2; iSide++) { // side of the straw
987 ATH_MSG_DEBUG("iSide "<<iSide);
988 int idSide = iSide ? 1 : -1;
989
990 const TRT_BarrelElement * element = m_trtDetManager->getBarrelElement(iSide, iLayer, iPhiModule, iStrawLayer);
991 if(element) {
992 for (unsigned int iStraw = 0; iStraw< element->nStraws(); iStraw++)
993 {
994 ATH_MSG_DEBUG("iStraw "<<iStraw);
995
996 // create the AlignModule
997 Trk::AlignModule * mod = new Trk::AlignModule(this);
998 mod->setIdHash(getNextIDHash());
999 Identifier moduleId = m_idHelper->straw_id(idSide,iPhiModule,iLayer,iStrawLayer,iStraw);
1000 mod->setIdentifier(moduleId);
1001
1002 std::stringstream name;
1003 name<<"TRT/Barrel/Straw_"<<idSide<<"_"<<iPhiModule<<"_"<<iLayer<<"_"<<iStrawLayer<<"_"<<iStraw;
1004 mod->setName(name.str());
1005
1006 if(!moduleSelected(mod)) {
1007 ATH_MSG_DEBUG("Module "<<mod->name()<<" NOT selected");
1008 delete mod;
1009 mod=nullptr;
1010 continue;
1011 }
1012
1013 ATH_MSG_DEBUG("Building module "<<mod->name());
1014
1015 // add element to respective AlignModule
1016 mod->addDetElement(Trk::AlignModule::TRT, element, transform, moduleId);
1017
1018 // and fill the corresponding map
1019 (*trtIdHashMap)[m_idHelper->straw_hash(moduleId)] = mod;
1020
1021 // set the align frame transform
1022 Amg::Transform3D localToGlobal = element->strawTransform(iStraw);
1023 Amg::RotationMatrix3D lgrot = localToGlobal.rotation();
1024 ATH_MSG_DEBUG("Prepared local to global transform : "<<std::setprecision(12)
1025 <<localToGlobal.translation()<<" "<<localToGlobal.rotation());
1026 ATH_MSG_DEBUG(" rotation = (" << lgrot(2,1) << "," << lgrot(0,2) << "," << lgrot(1,0) << ")");
1027
1028 mod->setGlobalFrameToAlignFrameTransform(localToGlobal.inverse());
1029
1030 Amg::Transform3D aatr = element->transform();
1031 Amg::RotationMatrix3D aarot = aatr.rotation();
1032
1033 ATH_MSG_DEBUG("Straw layer transform : "<<std::setprecision(12)
1034 <<aatr.translation()<<" "<<aatr.rotation());
1035 ATH_MSG_DEBUG(" rotation = (" << aarot(2,1) << "," << aarot(0,2) << "," << aarot(1,0) << ")");
1036
1037 // add AlignModule to the geometry
1038 m_alignModuleListPtr->push_back(mod);
1039 }
1040 }
1041 else
1042 ATH_MSG_DEBUG("No TRT_BarrelElement with side-layer-phi-strawLayer:" <<iSide<<"-"<<iLayer<<"-"<<iPhiModule<<"-"<<iStrawLayer);
1043 }
1044 }
1045 }
1046 }
1047
1048 }
1049
1050//_______________________________________________________________________
1051void TRTGeometryManagerTool::buildL3Endcap()
1052{
1053 // ===========================
1054 // ENDCAP Level 3
1055 // ===========================
1056 ATH_MSG_INFO("Preparing the TRT Endcap geometry for L3");
1057
1058 // ========================================
1059 // get all modules for TRT Endcap Level 3 alignment
1060 // Level 3 is one AlignModule per straw
1061
1062 // define modules
1063 // we'll stick with the base AlignModule here since we don't want to
1064 // do shifting for the moment but we might need to extend AlignModule
1065 // in the future
1066
1067 // TRT detector element positions are stored in the DB in the local frame
1068 // so the DB frame to local frame transform is identity
1069 Amg::Transform3D transform = Amg::Transform3D::Identity();
1070
1071 // get maximum number of elements from the helper
1072 unsigned int maxHash = m_idHelper->straw_hash_max();
1073 ATH_MSG_DEBUG("maxHash for the TRT "<<maxHash);
1074
1075 if(!m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT))
1076 m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT) = new Trk::AlignModuleList((size_t)maxHash,nullptr);
1077 Trk::AlignModuleList * trtIdHashMap = m_idHashToAlignModuleMapsPtr->at(Trk::AlignModule::TRT);
1078
1079
1080 for (int iSide = 0; iSide < 2; iSide++) { // endcap
1081 int idSide = iSide ? 2 : -2;
1082 ATH_MSG_DEBUG("Side : "<<iSide<<" , idSide : "<<idSide);
1083 if( m_endcap!=idSide && m_endcap!=0 ) {
1084 ATH_MSG_DEBUG("Endcap "<<idSide<<" NOT aligned");
1085 continue;
1086 }
1087
1088 // wheels in Z
1089 for (unsigned int iWheel = 0; iWheel < m_trtDetManager->getNumerology()->getNEndcapWheels(); iWheel++) {
1090 ATH_MSG_DEBUG("iWheel "<<iWheel);
1091
1092 // sectors in Phi
1093 for (unsigned int iPhiModule = 0; iPhiModule < m_trtDetManager->getNumerology()->getNEndcapPhi(); iPhiModule++) {
1094
1095 ATH_MSG_DEBUG("iPhiModule "<<iPhiModule);
1096
1097 if(!moduleSelectedEndcap(iWheel,iPhiModule)) {
1098 ATH_MSG_INFO("Skipping endcap wheel "<<iWheel<<" phi sector "<<iPhiModule);
1099 continue;
1100 }
1101
1102 // endcap straw layers in z (with in a wheel)
1103 for (unsigned int iStrawLayer = 0; iStrawLayer < m_trtDetManager->getNumerology()->getNEndcapLayers(iWheel); iStrawLayer++) {
1104
1105 const TRT_EndcapElement * element = m_trtDetManager->getEndcapElement(iSide, iWheel, iStrawLayer, iPhiModule);
1106
1107 if(element) {
1108 for (unsigned int iStraw = 0; iStraw< element->nStraws(); iStraw++) {
1109 ATH_MSG_DEBUG("iStraw "<<iStraw);
1110
1111 // create the AlignModule
1112 Trk::AlignModule * mod = new Trk::AlignModule(this);
1113 mod->setIdHash(getNextIDHash());
1114 Identifier moduleId = m_idHelper->straw_id(idSide,iPhiModule,iWheel,iStrawLayer,iStraw);
1115 mod->setIdentifier(moduleId);
1116
1117 std::stringstream name;
1118 name<<"TRT/Endcap/Straw_"<<idSide<<"_"<<iPhiModule<<"_"<<iWheel<<"_"<<iStrawLayer<<"_"<<iStraw;
1119 mod->setName(name.str());
1120
1121 if(!moduleSelected(mod)) {
1122 ATH_MSG_DEBUG("Module "<<mod->name()<<" NOT selected");
1123 delete mod;
1124 mod=nullptr;
1125 continue;
1126 }
1127
1128 ATH_MSG_DEBUG("Building module "<<mod->name());
1129
1130 // add element to respective AlignModule
1131 mod->addDetElement(Trk::AlignModule::TRT, element, transform, moduleId);
1132
1133 // and fill the corresponding map
1134 (*trtIdHashMap)[m_idHelper->straw_hash(moduleId)] = mod;
1135
1136 // set the align frame transform
1137 Amg::Transform3D localToGlobal = element->strawTransform(iStraw);
1138 Amg::RotationMatrix3D lgrot = localToGlobal.rotation();
1139
1140 ATH_MSG_DEBUG("Prepared local to global transform : "<<std::setprecision(12)
1141 <<localToGlobal.translation()<<" "<<localToGlobal.rotation());
1142
1143 ATH_MSG_DEBUG(" rotation = (" << lgrot(2,1) << "," << lgrot(0,2) << "," << lgrot(1,0) << ")");
1144
1145 mod->setGlobalFrameToAlignFrameTransform(localToGlobal.inverse());
1146
1147 Amg::Transform3D aatr = element->transform();
1148 Amg::RotationMatrix3D aarot = aatr.rotation();
1149
1150 ATH_MSG_DEBUG("Straw layer transform : "<<std::setprecision(12)
1151 <<aatr.translation()<<" "<<aatr.rotation());
1152 ATH_MSG_DEBUG(" rotation = (" << aarot(2,1) << "," << aarot(0,2) << "," << aarot(1,0) << ")");
1153
1154 // add AlignModule to the geometry
1155 m_alignModuleListPtr->push_back(mod);
1156 }// Straws
1157 }// if the EndcapElement Exists
1158 else
1159 ATH_MSG_DEBUG("No TRT_EndcapElement with endcap-wheel-strawLayer-phi:" <<iSide<<"-"<<iWheel<<"-"<<iStrawLayer<<"-"<<iPhiModule);
1160 }// StrawLayer
1161 }// PhiModule
1162 }// Wheel
1163 }// Endcap
1164
1165 }
1166
1167//________________________________________________________________________
1168void TRTGeometryManagerTool::addModuleParameters(Trk::AlignModule * module, DataVector< DataVector<Trk::AlignPar> > * allFullModPars, DataVector< DataVector<Trk::AlignPar> > * allActiveModPars)
1169{
1170 // prepare all parameters
1171 DataVector<Trk::AlignPar> * fullModPars = new DataVector<Trk::AlignPar>(SG::OWN_ELEMENTS);
1172 fullModPars->push_back(new Trk::AlignPar(module,Trk::AlignModule::TransX));
1173 fullModPars->push_back(new Trk::AlignPar(module,Trk::AlignModule::TransY));
1174 fullModPars->push_back(new Trk::AlignPar(module,Trk::AlignModule::TransZ));
1175 fullModPars->push_back(new Trk::AlignPar(module,Trk::AlignModule::RotX));
1176 fullModPars->push_back(new Trk::AlignPar(module,Trk::AlignModule::RotY));
1177 fullModPars->push_back(new Trk::AlignPar(module,Trk::AlignModule::RotZ));
1178
1179 // set sigmas
1180 setSigmas(module,fullModPars);
1181
1182 // select active parameters based on jobOption properties
1183 DataVector<Trk::AlignPar> * activeModPars = new DataVector<Trk::AlignPar>(SG::VIEW_ELEMENTS);
1184 for(unsigned int ipar=0;ipar<fullModPars->size();++ipar) {
1185
1186 Identifier modID = module->identify();
1187
1188 if(m_idHelper->is_barrel(modID)) {
1189 ATH_MSG_DEBUG("Barrel module with id "<<modID);
1190 if( (fullModPars->at(ipar)->paramType() == Trk::AlignModule::TransX && m_alignBarrelX)
1191 || (fullModPars->at(ipar)->paramType() == Trk::AlignModule::TransY && m_alignBarrelY)
1192 || (fullModPars->at(ipar)->paramType() == Trk::AlignModule::TransZ && m_alignBarrelZ)
1193 || (fullModPars->at(ipar)->paramType() == Trk::AlignModule::RotX && m_alignBarrelRotX)
1194 || (fullModPars->at(ipar)->paramType() == Trk::AlignModule::RotY && m_alignBarrelRotY)
1195 || (fullModPars->at(ipar)->paramType() == Trk::AlignModule::RotZ && m_alignBarrelRotZ) ) {
1196 ATH_MSG_DEBUG("parameter type "<<fullModPars->at(ipar)->paramType()<<" is now active");
1197 activeModPars->push_back(fullModPars->at(ipar));
1198 }
1199 else
1200 ATH_MSG_DEBUG("parameter type "<<fullModPars->at(ipar)->paramType()<<" is NOT active");
1201 }
1202 else {
1203 ATH_MSG_DEBUG("Endcap module with id "<<modID);
1204 if( (fullModPars->at(ipar)->paramType() == Trk::AlignModule::TransX && m_alignEndcapX)
1205 || (fullModPars->at(ipar)->paramType() == Trk::AlignModule::TransY && m_alignEndcapY)
1206 || (fullModPars->at(ipar)->paramType() == Trk::AlignModule::TransZ && m_alignEndcapZ)
1207 || (fullModPars->at(ipar)->paramType() == Trk::AlignModule::RotX && m_alignEndcapRotX)
1208 || (fullModPars->at(ipar)->paramType() == Trk::AlignModule::RotY && m_alignEndcapRotY)
1209 || (fullModPars->at(ipar)->paramType() == Trk::AlignModule::RotZ && m_alignEndcapRotZ) ) {
1210 ATH_MSG_DEBUG("parameter type "<<fullModPars->at(ipar)->paramType()<<" is now active");
1211 activeModPars->push_back(fullModPars->at(ipar));
1212 }
1213 else
1214 ATH_MSG_DEBUG("parameter type "<<fullModPars->at(ipar)->paramType()<<" is NOT active");
1215 }
1216 }
1217
1218 // add to parameter lists
1219 allFullModPars->push_back(fullModPars);
1220 allActiveModPars->push_back(activeModPars);
1221}
1222
1223
1224//________________________________________________________________________
1225void TRTGeometryManagerTool::setSigmas(Trk::AlignModule * module, DataVector<Trk::AlignPar> * modPars)
1226{
1227 for(unsigned int ipar=0;ipar<modPars->size();++ipar) {
1228 // barrel
1229 if(m_idHelper->is_barrel(module->identify()))
1230 switch(modPars->at(ipar)->paramType()) {
1231 case Trk::AlignModule::TransX:
1232 modPars->at(ipar)->setSigma(m_sigmaBarrelX);
1233 modPars->at(ipar)->setSoftCut(m_softcutBarrelX);
1234 break;
1235 case Trk::AlignModule::TransY:
1236 modPars->at(ipar)->setSigma(m_sigmaBarrelY);
1237 modPars->at(ipar)->setSoftCut(m_softcutBarrelY);
1238 break;
1239 case Trk::AlignModule::TransZ:
1240 modPars->at(ipar)->setSigma(m_sigmaBarrelZ);
1241 modPars->at(ipar)->setSoftCut(m_softcutBarrelZ);
1242 break;
1243 case Trk::AlignModule::RotX:
1244 modPars->at(ipar)->setSigma(m_sigmaBarrelRotX);
1245 modPars->at(ipar)->setSoftCut(m_softcutBarrelRotX);
1246 break;
1247 case Trk::AlignModule::RotY:
1248 modPars->at(ipar)->setSigma(m_sigmaBarrelRotY);
1249 modPars->at(ipar)->setSoftCut(m_softcutBarrelRotY);
1250 break;
1251 case Trk::AlignModule::RotZ:
1252 modPars->at(ipar)->setSigma(m_sigmaBarrelRotZ);
1253 modPars->at(ipar)->setSoftCut(m_softcutBarrelRotZ);
1254 break;
1255 default:
1256 break;
1257 }
1258 // end-caps
1259 else
1260 switch(modPars->at(ipar)->paramType()) {
1261 case Trk::AlignModule::TransX:
1262 modPars->at(ipar)->setSigma(m_sigmaEndcapX);
1263 modPars->at(ipar)->setSoftCut(m_softcutEndcapX);
1264 break;
1265 case Trk::AlignModule::TransY:
1266 modPars->at(ipar)->setSigma(m_sigmaEndcapY);
1267 modPars->at(ipar)->setSoftCut(m_softcutEndcapY);
1268 break;
1269 case Trk::AlignModule::TransZ:
1270 modPars->at(ipar)->setSigma(m_sigmaEndcapZ);
1271 modPars->at(ipar)->setSoftCut(m_softcutEndcapZ);
1272 break;
1273 case Trk::AlignModule::RotX:
1274 modPars->at(ipar)->setSigma(m_sigmaEndcapRotX);
1275 modPars->at(ipar)->setSoftCut(m_softcutEndcapRotX);
1276 break;
1277 case Trk::AlignModule::RotY:
1278 modPars->at(ipar)->setSigma(m_sigmaEndcapRotY);
1279 modPars->at(ipar)->setSoftCut(m_softcutEndcapRotY);
1280 break;
1281 case Trk::AlignModule::RotZ:
1282 modPars->at(ipar)->setSigma(m_sigmaEndcapRotZ);
1283 modPars->at(ipar)->setSoftCut(m_softcutEndcapRotZ);
1284 break;
1285 default:
1286 break;
1287 }
1288 }
1289}
1290
1291
1292//________________________________________________________________________
1293bool TRTGeometryManagerTool::moduleSelected(unsigned long long id)
1294{
1295 if(!m_doModuleSelection)
1296 return true;
1297
1298 int nsel = m_moduleSelection.size();
1299 for(int i=0;i<nsel;++i)
1300 if(m_moduleSelection.at(i) == id)
1301 return true;
1302
1303 return false;
1304}
1305
1306
1307//________________________________________________________________________
1308bool TRTGeometryManagerTool::moduleSelected(Trk::AlignModule * mod)
1309{
1310 return moduleSelected(mod->identify().get_compact());
1311}
1312
1313
1314//________________________________________________________________________
1315bool TRTGeometryManagerTool::moduleSelectedBarrel(unsigned int ilayer, unsigned int iphi)
1316{
1317 bool select = true;
1318 if(!m_barrelLayers.empty()) {
1319 select = false;
1320 for(unsigned int i=0;i<m_barrelLayers.size();i++) {
1321 if(m_barrelLayers[i] == (int)ilayer) {
1322 select = true;
1323 break;
1324 }
1325 }
1326 }
1327
1328 if(!select)
1329 return false;
1330
1331 if(!m_barrelPhiSectors.empty()) {
1332 select = false;
1333 for(unsigned int i=0;i<m_barrelPhiSectors.size();i++) {
1334 if(m_barrelPhiSectors[i] == (int)iphi) {
1335 select = true;
1336 break;
1337 }
1338 }
1339 }
1340
1341 return select;
1342}
1343
1344//________________________________________________________________________
1345bool TRTGeometryManagerTool::moduleSelectedEndcap(unsigned int iwheel, unsigned int iphi)
1346{
1347 bool select = true;
1348 if(!m_endcapWheels.empty()) {
1349 select = false;
1350 for(unsigned int i=0;i<m_endcapWheels.size();++i) {
1351 if(m_endcapWheels[i] == (int)iwheel) {
1352 select = true;
1353 break;
1354 }
1355 }
1356 }
1357
1358 if(!select)
1359 return false;
1360
1361 if(!m_endcapPhiSectors.empty()) {
1362 select = false;
1363 for(unsigned int i=0;i<m_endcapPhiSectors.size();i++) {
1364 if(m_endcapPhiSectors[i] == (int)iphi) {
1365 select = true;
1366 break;
1367 }
1368 }
1369 }
1370
1371 return select;
1372}
1373
1374
1375//________________________________________________________________________
1376void TRTGeometryManagerTool::dumpGeometry()
1377{
1378 ATH_MSG_INFO("---------------------------------------------------");
1379 ATH_MSG_INFO("Summary of the alignment geometry");
1380 ATH_MSG_INFO("Number of alignable objects: "<<m_alignModuleList.size());
1381 ATH_MSG_INFO("Total number of aligment DoFs: "<<m_alignModuleTool->nAlignParameters());
1382
1383 for(unsigned int i=0;i<m_alignModuleList.size();i++) {
1384 const Trk::AlignModule * module = m_alignModuleList.at(i);
1385 //ATH_MSG_DEBUG(i<<". "<< module->name());
1386 //ATH_MSG_DEBUG(" - identifier: "<<module->identify());
1387 //ATH_MSG_DEBUG(" - has "<<module->detElementCollection(Trk::AlignModule::TRT)->size()<<" TRT modules");
1388
1389 Amg::Transform3D localtoglobal = (module->globalFrameToAlignFrame()).inverse();
1390 ATH_MSG_DEBUG(" - local to global : "<<std::setprecision(12)<<localtoglobal.translation()<<" "<<localtoglobal.rotation());
1391
1392 DataVector<Trk::AlignPar> * pars = m_alignModuleTool->getAlignPars(module);
1393 int npars = pars->size();
1394 ATH_MSG_DEBUG(" - number of active transform parameters: "<<npars);
1395 for(int j=0;j<npars;j++)
1396 ATH_MSG_DEBUG(" * par "<<j<<" \'"<<(*pars)[j]->dumpType()<<"\' : sigma = "<<(*pars)[j]->sigma()<<" , softCut = "<<(*pars)[j]->softCut());
1397 }
1398 ATH_MSG_INFO("---------------------------------------------------");
1399}
1400
1401} // end namespace
1402
endmsg
#define endmsg
Definition AnalysisConfig_Ntuple.cxx:63
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition AthMsgStreamMacros.h:31
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
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:1308
InDet::TRTGeometryManagerTool::setSigmas
void setSigmas(Trk::AlignModule *mod, DataVector< Trk::AlignPar > *modPars)
sets sigmas for modules
Definition TRTGeometryManagerTool.cxx:1225
InDet::TRTGeometryManagerTool::buildL2EndcapsOLD
void buildL2EndcapsOLD()
builds geometry for L2 TRT Endcapalignment Creates 28 modules - 14 wheels per endcap
Definition TRTGeometryManagerTool.cxx:848
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:1376
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:1345
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:946
InDet::TRTGeometryManagerTool::moduleSelectedBarrel
bool moduleSelectedBarrel(unsigned int iLayer, unsigned int iPhi)
check wheather barrel module is selected by layer and phi
Definition TRTGeometryManagerTool.cxx:1315
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:1051
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:1168
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:93
Trk::AlignModule::setIdentifier
void setIdentifier(Identifier identifier)
Set and return identifier of module.
Definition AlignModule.h:96
Trk::AlignModule::name
const std::string & name() const
Definition AlignModule.h:89
Trk::AlignModule::setName
void setName(const std::string &name)
Set and return name of align module (i.e.
Definition AlignModule.h:88
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.16.1