Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
CreateMisalignAlg.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
6 // ================================================
7 // CreateMisalignAlg
8 // ================================================
9 //
10 // CreateMisalignAlg.cxx
11 // Source file for CreateMisalignAlg
12 //
13 // Namespace LocalChi2Align
14 // Header include
15 
16 // Gaudi & StoreGate
17 #include "GaudiKernel/ITHistSvc.h"
18 #include "GaudiKernel/SmartDataPtr.h" //NTupleFilePtr
19 #include "GaudiKernel/RndmGenerators.h"
20 #include "GaudiKernel/IRndmGenSvc.h"
21 
22 // Geometry Stuff
23 #include "Identifier/Identifier.h"
24 #include "AtlasDetDescr/AtlasDetectorID.h"
25 #include "InDetIdentifier/PixelID.h"
26 #include "InDetIdentifier/SCT_ID.h"
27 #include "InDetIdentifier/TRT_ID.h"
28 #include "InDetReadoutGeometry/SiDetectorElement.h"
29 #include "TRT_ReadoutGeometry/TRT_DetElementCollection.h"
30 #include "TRT_ReadoutGeometry/TRT_BaseElement.h"
31 #include "DetDescrConditions/AlignableTransform.h"
32 #include "StoreGate/ReadCondHandleKey.h"
33 
34 // Alignment DB Stuff
35 #include "InDetAlignGenTools/IInDetAlignDBTool.h"
36 #include "TRT_ConditionsServices/ITRT_AlignDbSvc.h"
37 #include "AthenaKernel/IOVRange.h"
38 #include "CreateMisalignAlg.h"
39 #include "GeoPrimitives/CLHEPtoEigenConverter.h"
40 #include "AthenaBaseComps/AthCheckMacros.h"
41 #include <cmath>
42 #include <tuple> //for tuple decomposition and std::ignore
43 #include <sstream>
44 
45 
46 
47 
48 #include "SCT_ReadoutGeometry/StripStereoAnnulusDesign.h"
49 
50 
51 namespace{
52  std::string commonAlignmentOutput(const HepGeom::Transform3D & initialAlignment){
53  std::ostringstream os;
54  os << "\nAlignment x = (" << initialAlignment.getTranslation().x() / CLHEP::micrometer << ") micron\n";
55  os << "Alignment y = (" << initialAlignment.getTranslation().y() / CLHEP::micrometer << ") micron\n";
56  os << "Alignment z = (" << initialAlignment.getTranslation().z() / CLHEP::micrometer << ") micron\n";
57  os << "Alignment x phi = (" << initialAlignment.getRotation().phiX() / CLHEP::deg << ") degree\n";
58  os << "Alignment x Theta = (" << initialAlignment.getRotation().thetaX() / CLHEP::deg << ") degree\n";
59  os << "Alignment y phi = (" << initialAlignment.getRotation().phiY() / CLHEP::deg << ") degree\n";
60  os << "Alignment y Theta = (" << initialAlignment.getRotation().thetaY() / CLHEP::deg << ") degree\n";
61  os << "Alignment z phi = (" << initialAlignment.getRotation().phiZ() / CLHEP::deg << ") degree\n";
62  os << "Alignment z Theta = (" << initialAlignment.getRotation().thetaZ() / CLHEP::deg << ") degree\n";
63  return os.str();
64  }
65 }
66 
67 namespace InDetAlignment
68 {
69 
70  // Constructor
71  CreateMisalignAlg::CreateMisalignAlg(const std::string& name, ISvcLocator* pSvcLocator):
72  AthAlgorithm(name,pSvcLocator),
73  m_idHelper(nullptr),
74  m_pixelIdHelper(nullptr),
75  m_sctIdHelper(nullptr),
76  m_trtIdHelper(nullptr),
77  m_IDAlignDBTool("InDetAlignDBTool",this),
78  m_trtaligndbservice("TRT_AlignDbSvc",name),
79  m_asciiFileNameBase("MisalignmentSet"),
80  m_SQLiteTag("test_tag"),
81  m_firstEvent(true),
82  m_createFreshDB(true),
83  m_MisalignmentMode(0),
84  m_nEvents(0),
85  m_translation(true),
86  m_rotation(true),
87  m_Misalign_maxShift(1*CLHEP::mm),
88  m_Misalign_maxShift_Inner(50*CLHEP::micrometer),
89  m_ScalePixelIBL(1.),
90  m_ScalePixelDBM(1.),
91  m_IBLBowingTshift(0.),
92  m_ScalePixelBarrel(1.),
93  m_ScalePixelEndcap(1.),
94  m_ScaleSCTBarrel(1.),
95  m_ScaleSCTEndcap(1.),
96  m_ScaleTRTBarrel(1.),
97  m_ScaleTRTEndcap(1.),
98  m_VisualizationLookupTree(nullptr),
99  m_AthenaHashedID(-1),
100  m_HumanReadableID(-1),
101  m_doPix(true),
102  m_doStrip(true),
103  m_doTRT(true)
104  {
105  declareProperty("ASCIIFilenameBase" , m_asciiFileNameBase);
106  declareProperty("SQLiteTag" , m_SQLiteTag);
107  declareProperty("MisalignMode" , m_MisalignmentMode);
108  declareProperty("Translation" , m_translation);
109  declareProperty("Rotation" , m_rotation);
110  declareProperty("MaxShift" , m_Misalign_maxShift);
111  declareProperty("MaxShiftInner" , m_Misalign_maxShift_Inner);
112  declareProperty("CreateFreshDB" , m_createFreshDB);
113  declareProperty("IDAlignDBTool" , m_IDAlignDBTool);
114  declareProperty("TRTAlignDBService" , m_trtaligndbservice);
115  declareProperty("ScalePixelIBL" , m_ScalePixelIBL);
116  declareProperty("ScalePixelDBM" , m_ScalePixelDBM);
117  declareProperty("IBLBowingTshift" , m_IBLBowingTshift);
118  declareProperty("ScalePixelBarrel" , m_ScalePixelBarrel);
119  declareProperty("ScalePixelEndcap" , m_ScalePixelEndcap);
120  declareProperty("ScaleSCTBarrel" , m_ScaleSCTBarrel);
121  declareProperty("ScaleSCTEndcap" , m_ScaleSCTEndcap);
122  declareProperty("ScaleTRTBarrel" , m_ScaleTRTBarrel);
123  declareProperty("ScaleTRTEndcap" , m_ScaleTRTEndcap);
124  }
125 
126  //__________________________________________________________________________
127  // Destructor
128  CreateMisalignAlg::~CreateMisalignAlg(void)
129  {
130  ATH_MSG_DEBUG( "CreateMisalignAlg destructor called" );
131  }
132 
133  //__________________________________________________________________________
134  StatusCode CreateMisalignAlg::initialize()
135  {
136  ATH_MSG_DEBUG("CreateMisalignAlg initialize()");
137  if(m_pixelDetEleCollKey.empty()) {m_doPix=false;ATH_MSG_INFO("Not creating misalignment for Pixel");}
138  if(m_SCTDetEleCollKey.empty()) {m_doStrip=false;ATH_MSG_INFO("Not creating misalignment for Strip/SCT");}
139  if(m_trtDetEleCollKey.empty()) {m_doTRT=false;ATH_MSG_INFO("Not creating misalignment for TRT");}
140 
141  ATH_CHECK(m_pixelDetEleCollKey.initialize(SG::AllowEmpty));
142  ATH_CHECK(m_SCTDetEleCollKey.initialize(SG::AllowEmpty));
143  ATH_CHECK(m_trtDetEleCollKey.initialize(SG::AllowEmpty));
144 
145  if (m_doPix || m_doStrip) ATH_CHECK(m_IDAlignDBTool.retrieve());
146  if(m_doTRT) ATH_CHECK(m_trtaligndbservice.retrieve());
147  //ID helpers
148  // Pixel
149  if(m_doPix){
150  ATH_CHECK(detStore()->retrieve(m_pixelIdHelper, "PixelID"));
151  }
152  // SCT
153  if(m_doStrip){
154  ATH_CHECK(detStore()->retrieve(m_sctIdHelper, "SCT_ID"));
155  }
156  // TRT
157  if(m_doTRT){
158  ATH_CHECK(detStore()->retrieve(m_trtIdHelper, "TRT_ID"));
159  }
160  ATH_CHECK(detStore()->retrieve(m_idHelper, "AtlasID"));
161 
162  // Retrieve the Histo Service
163  SmartIF<ITHistSvc> hist_svc{Gaudi::svcLocator()->service("THistSvc")};
164  ATH_CHECK(hist_svc.isValid());
165  //Registering TTree for Visualization Lookup
166  m_VisualizationLookupTree = new TTree("IdentifierTree", "Visualization Identifier Lookup Tree");
167  ATH_CHECK(hist_svc->regTree("/IDENTIFIERTREE/IdentifierTree", m_VisualizationLookupTree));
168  m_VisualizationLookupTree->Branch ("AthenaHashedID", &m_AthenaHashedID, "AthenaID/i");
169  m_VisualizationLookupTree->Branch ("HumanReadableID", &m_HumanReadableID, "HumanID/I");
170 
171  // initialize generated Initial Alignment NTuple
172  NTupleFilePtr file1(ntupleSvc(), "/NTUPLES/CREATEMISALIGN");
173 
174  NTuplePtr nt(ntupleSvc(), "/NTUPLES/CREATEMISALIGN/InitialAlignment");
175  if ( !nt ) { // Check if already booked
176  nt = ntupleSvc()->book("/NTUPLES/CREATEMISALIGN/InitialAlignment", CLID_ColumnWiseTuple, "InitialAlignment");
177  if ( nt ) {
178  ATH_MSG_INFO( "InitialAlignment ntuple booked." );
179  ATH_CHECK( nt->addItem("x" ,m_AlignResults_x) );
180  ATH_CHECK( nt->addItem("y" ,m_AlignResults_y) );
181  ATH_CHECK( nt->addItem("z" ,m_AlignResults_z) );
182  ATH_CHECK( nt->addItem("alpha" ,m_AlignResults_alpha) );
183  ATH_CHECK( nt->addItem("beta" ,m_AlignResults_beta) );
184  ATH_CHECK( nt->addItem("gamma" ,m_AlignResults_gamma) );
185  ATH_CHECK( nt->addItem("ID" ,m_AlignResults_Identifier_ID) );
186  ATH_CHECK( nt->addItem("PixelSCT" ,m_AlignResults_Identifier_PixelSCT) );
187  ATH_CHECK( nt->addItem("BarrelEC" ,m_AlignResults_Identifier_BarrelEC) );
188  ATH_CHECK( nt->addItem("LayerDisc" ,m_AlignResults_Identifier_LayerDisc) );
189  ATH_CHECK( nt->addItem("Phi" ,m_AlignResults_Identifier_Phi) );
190  ATH_CHECK( nt->addItem("Eta" ,m_AlignResults_Identifier_Eta) );
191  ATH_CHECK( nt->addItem("center_x" ,m_Initial_center_x ) );
192  ATH_CHECK( nt->addItem("center_y" ,m_Initial_center_y ) );
193  ATH_CHECK( nt->addItem("center_z" ,m_Initial_center_z ) );
194  ATH_CHECK( nt->addItem("misaligned_global_x" ,m_Global_center_x ) );
195  ATH_CHECK( nt->addItem("misaligned_global_y" ,m_Global_center_y ) );
196  ATH_CHECK( nt->addItem("misaligned_global_z" ,m_Global_center_z ) );
197  } else { // did not manage to book the N tuple....
198  msg(MSG::ERROR) << "Failed to book InitialAlignment ntuple." << endmsg;
199  }
200  }
201 
202  if (m_MisalignmentMode) {
203  ATH_MSG_INFO( "Misalignment mode chosen: " << m_MisalignmentMode );
204  if (m_MisalignmentMode == 1) {
205  ATH_MSG_INFO( "MisalignmentX : " << m_Misalign_x / CLHEP::micrometer << " micrometer" );
206  ATH_MSG_INFO( "MisalignmentY : " << m_Misalign_y / CLHEP::micrometer << " micrometer" );
207  ATH_MSG_INFO( "MisalignmentZ : " << m_Misalign_z / CLHEP::micrometer << " micrometer" );
208  ATH_MSG_INFO( "MisalignmentAlpha : " << m_Misalign_alpha / CLHEP::mrad << " mrad" );
209  ATH_MSG_INFO( "MisalignmentBeta : " << m_Misalign_beta / CLHEP::mrad << " mrad" );
210  ATH_MSG_INFO( "MisalignmentGamma : " << m_Misalign_gamma / CLHEP::mrad << " mrad" );
211  } else {
212  ATH_MSG_INFO( "with maximum shift of " << m_Misalign_maxShift / CLHEP::micrometer << " micrometer" );
213  }
214  } else {
215  ATH_MSG_INFO( "Dry run, no misalignment will be generated." );
216  }
217 
218  return StatusCode::SUCCESS;
219  }
220 
221  //__________________________________________________________________________
222  StatusCode CreateMisalignAlg::execute()
223  {
224  ATH_MSG_DEBUG( "AlignAlg execute()" );
225  ++m_nEvents;
226 
227  if (m_firstEvent) {
228  int nSCT = 0;
229  int nPixel = 0;
230  int nTRT = 0;
231 
232  if (m_createFreshDB) {
233  m_IDAlignDBTool->createDB();
234  //m_trtaligndbservice->createAlignObjects(); //create DB for TRT? should be ok... //TODO
235  }
236 
237  if(m_doPix) setupPixel_AlignModule(nPixel);
238  if(m_doStrip) setupSCT_AlignModule(nSCT);
239  if(m_doTRT) setupTRT_AlignModule(nTRT);
240 
241  ATH_MSG_INFO( "Back from AlignModuleObject Setup. " );
242  ATH_MSG_INFO( nPixel << " Pixel modules found." );
243  ATH_MSG_INFO( nSCT << " SCT modules found," );
244  ATH_MSG_INFO( nTRT << " TRT modules found." );
245 
246  ATH_MSG_INFO( m_ModuleList.size() << " entries in identifier list" );
247 
248  if (StatusCode::SUCCESS!=GenerateMisaligment()) {
249  ATH_MSG_ERROR( "GenerateMisalignment failed!" );
250  return StatusCode::FAILURE;
251  };
252 
253  m_firstEvent = false;
254  }
255 
256  return StatusCode::SUCCESS;
257  }
258 
259  //__________________________________________________________________________
260  StatusCode CreateMisalignAlg::finalize()
261  {
262  ATH_MSG_DEBUG("CreateMisalignAlg finalize()" );
263 
264  m_ModuleList.clear();
265 
266  return StatusCode::SUCCESS;
267  }
268 
269  //__________________________________________________________________________
270  void CreateMisalignAlg::setupSCT_AlignModule(int& nSCT)
271  {
272  // SiDetectorElementCollection for SCT
273  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> sctDetEleHandle(m_SCTDetEleCollKey);
274  const InDetDD::SiDetectorElementCollection* elements(*sctDetEleHandle);
275  if (not sctDetEleHandle.isValid() or elements==nullptr) {
276  ATH_MSG_FATAL(m_SCTDetEleCollKey.fullKey() << " is not available.");
277  return;
278  }
279  for (const InDetDD::SiDetectorElement *element: *elements) {
280  const Identifier SCT_ModuleID = m_sctIdHelper->module_id(element->identify()); //from wafer id to module id
281  const IdentifierHash SCT_ModuleHash = m_sctIdHelper->wafer_hash(SCT_ModuleID);
282 
283  if (m_ModuleList.find(SCT_ModuleID) == m_ModuleList.end())
284  {
285  const InDetDD::SiDetectorElement *module = elements->getDetectorElement(SCT_ModuleHash);
286  m_ModuleList[SCT_ModuleID][0] = module->center()[0];
287  m_ModuleList[SCT_ModuleID][1] = module->center()[1];
288  m_ModuleList[SCT_ModuleID][2] = module->center()[2];
289  ++nSCT;
290  ATH_MSG_VERBOSE( "SCT module " << nSCT );
291  }
292 
293  if (m_sctIdHelper->side(element->identify()) == 0) { // inner side case
294  // Write out Visualization Lookup Tree
295  m_AthenaHashedID = SCT_ModuleID.get_identifier32().get_compact();
296  m_HumanReadableID = 1000000*2 /*2 = SCT*/
297  + 100000*m_sctIdHelper->layer_disk(SCT_ModuleID)
298  + 1000*(10+m_sctIdHelper->eta_module(SCT_ModuleID))
299  + m_sctIdHelper->phi_module(SCT_ModuleID);
300  if ( m_sctIdHelper->barrel_ec(SCT_ModuleID) != 0 ) {
301  m_HumanReadableID = m_sctIdHelper->barrel_ec(SCT_ModuleID)*(m_HumanReadableID + 10000000);
302  }
303 
304  ATH_MSG_VERBOSE( "Human Readable ID: " << m_HumanReadableID );
305 
306  m_VisualizationLookupTree->Fill();
307 
308  // Syntax is (ID, Level) where Level is from 1 to 3 (3 is single module level)
309  if (msgLvl(MSG::VERBOSE)) {
310  HepGeom::Transform3D InitialAlignment = Amg::EigenTransformToCLHEP(m_IDAlignDBTool->getTrans(SCT_ModuleID,3));
311  msg() << "Initial Alignment of module " << m_idHelper->show_to_string(SCT_ModuleID,nullptr,'/') << endmsg;
312  msg() << commonAlignmentOutput(InitialAlignment);
313  msg() << endmsg;
314  }
315  } // end inner side case
316  } //end loop over SCT elements
317  }
318 
319  //__________________________________________________________________________
320  void CreateMisalignAlg::setupPixel_AlignModule(int& nPixel)
321  {
322  // SiDetectorElementCollection for Pixel
323  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> pixelDetEleHandle(m_pixelDetEleCollKey);
324  const InDetDD::SiDetectorElementCollection* elements(*pixelDetEleHandle);
325  if (not pixelDetEleHandle.isValid() or elements==nullptr) {
326  ATH_MSG_FATAL(m_pixelDetEleCollKey.fullKey() << " is not available.");
327  return;
328  }
329  for (const InDetDD::SiDetectorElement *element: *elements) {
330  // get the ID
331  const Identifier Pixel_ModuleID = element->identify();
332  const IdentifierHash Pixel_ModuleHash = m_pixelIdHelper->wafer_hash(Pixel_ModuleID);
333  // check the validity
334  if (Pixel_ModuleID.is_valid()) {
335  if (m_ModuleList.find(Pixel_ModuleID) == m_ModuleList.end()) {
336  const InDetDD::SiDetectorElement *module = elements->getDetectorElement(Pixel_ModuleHash);
337  m_ModuleList[Pixel_ModuleID][0] = module->center()[0];
338  m_ModuleList[Pixel_ModuleID][1] = module->center()[1];
339  m_ModuleList[Pixel_ModuleID][2] = module->center()[2];
340 
341  ++nPixel;
342  ATH_MSG_VERBOSE( "Pixel module " << nPixel );
343 
344  // Write out Visualization Lookup Tree
345  m_AthenaHashedID = Pixel_ModuleID.get_identifier32().get_compact();
346  m_HumanReadableID = 1000000*1 /*1 = Pixel*/
347  + 100000*m_pixelIdHelper->layer_disk(Pixel_ModuleID)
348  + 1000*(10+m_pixelIdHelper->eta_module(Pixel_ModuleID))
349  + m_pixelIdHelper->phi_module(Pixel_ModuleID);
350  if ( m_pixelIdHelper->barrel_ec(Pixel_ModuleID) != 0 ) {
351  m_HumanReadableID = m_pixelIdHelper->barrel_ec(Pixel_ModuleID)*(m_HumanReadableID + 10000000);
352  }
353 
354  ATH_MSG_VERBOSE( "Human Readable ID: " << m_HumanReadableID );
355 
356  m_VisualizationLookupTree->Fill();
357 
358  if (msgLvl(MSG::VERBOSE)) {
359  HepGeom::Transform3D InitialAlignment = Amg::EigenTransformToCLHEP(m_IDAlignDBTool->getTrans(Pixel_ModuleID,3));
360  msg() << "Initial Alignment of module " << m_idHelper->show_to_string(Pixel_ModuleID,nullptr,'/') << endmsg;
361  msg() << commonAlignmentOutput(InitialAlignment);
362  msg() << endmsg;
363  }
364  }
365  } else {
366  ATH_MSG_INFO( "not a valid PIXEL Module ID (setup)" );
367  }
368  }
369  }
370 
371  //__________________________________________________________________________
372  void CreateMisalignAlg::setupTRT_AlignModule(int& nTRT)
373  {
374  //TODO: writing into the Identifier tree is undone for TRT (AthenaHashedID and HumanReadableID)
375 
376  std::map< Identifier, std::vector<double> > trtModulesWithCOG;
377 
378  // TRT_DetElementContainer->TRT_DetElementCollection for TRT
379  SG::ReadCondHandle<InDetDD::TRT_DetElementContainer> trtDetEleHandle(m_trtDetEleCollKey);
380  const InDetDD::TRT_DetElementCollection* elements(trtDetEleHandle->getElements());
381  if (not trtDetEleHandle.isValid() or elements==nullptr) {
382  ATH_MSG_FATAL(m_trtDetEleCollKey.fullKey() << " is not available.");
383  return;
384  }
385 
386  //step through all detector elements (=strawlayers) and accumulate strawcenters per
387  // element (with DB granularity, i.e. phi sectors in endcap, bi-modules in barrel)
388  for (const InDetDD::TRT_BaseElement *element: *elements) {
389  const Identifier TRTID_orig = element->identify();
390  const Identifier TRTID = reduceTRTID(TRTID_orig);
391  bool insertSuccess{};
392  std::tie(std::ignore, insertSuccess) = trtModulesWithCOG.insert({TRTID,std::vector<double>(4,0.)}); //create fresh vector for module center
393  if (not insertSuccess){
394  ATH_MSG_VERBOSE("No insert was performed, identifier was already in the trtModulesWithCOG map");
395  }
396 
397  unsigned int nStraws = element->nStraws();
398  for (unsigned int l = 0; l<nStraws; l++) {
399  const Amg::Vector3D strawcenter = element->strawCenter(l);
400  trtModulesWithCOG[TRTID].at(0) += strawcenter.x(); /*sumx*/
401  trtModulesWithCOG[TRTID].at(1) += strawcenter.y(); /*sumy*/
402  trtModulesWithCOG[TRTID].at(2) += strawcenter.z(); /*sumz*/
403  trtModulesWithCOG[TRTID].at(3) += 1.; /*nStraws*/
404 
405  }
406 
407  ATH_MSG_DEBUG( "this strawlayer has " << nStraws << " straws." );
408  ATH_MSG_DEBUG( "strawcount of this module: " << trtModulesWithCOG[TRTID].at(3) );
409 
410  }
411 
412  //go through cog list and create one COG per TRT module (at DB granularity)
413  std::map< Identifier, std::vector<double> >::const_iterator iter2;
414  for (iter2 = trtModulesWithCOG.begin(); iter2!=trtModulesWithCOG.end(); ++iter2) {
415  const Identifier TRTID = iter2->first;
416  double nStraws = iter2->second.at(3);
417  nTRT++;
418  ATH_MSG_VERBOSE( "TRT module " << nTRT );
419  m_ModuleList[TRTID] = HepGeom::Point3D<double>(iter2->second.at(0)/nStraws, iter2->second.at(1)/nStraws,iter2->second.at(2)/nStraws);
420 
421  HepGeom::Transform3D InitialAlignment ;
422 
423  const Amg::Transform3D* p = m_trtaligndbservice->getAlignmentTransformPtr(TRTID,2) ;
424  if ( p ) {
425  if (msgLvl(MSG::VERBOSE)) {
426  InitialAlignment = Amg::EigenTransformToCLHEP(*p) ;
427  msg() << "Initial Alignment of module " << m_idHelper->show_to_string(TRTID,nullptr,'/') << endmsg;
428  msg() << commonAlignmentOutput(InitialAlignment);
429  msg() << endmsg;
430  }
431  } else {
432 
433  ATH_MSG_VERBOSE("No initial alignment for TRT module " << m_idHelper->show_to_string(TRTID,nullptr,'/') );
434  }
435 
436 
437  }
438  }
439 
440  //__________________________________________________________________________
441  StatusCode CreateMisalignAlg::GenerateMisaligment()
442  {
443 
444  SmartIF<IRndmGenSvc> randsvc{Gaudi::svcLocator()->service("RndmGenSvc")};
445  ATH_CHECK(randsvc.isValid());
446  ATH_MSG_DEBUG( "Got RndmGenSvc" );
447 
448  int i = 0;
449 
450  /*
451  ===================================
452  Documentation of misalignment modes
453  ===================================
454 
455  MisalignMode =
456  0: nothing, no misalignments are generated
457  1: Misalignment of whole InDet by 6 parameters
458  2: random misalignment
459  3: IBL-stave temperature dependent bowing
460 
461  ====================================================
462  Global Distortions according to David Brown (LHC Detector Alignment Workshop 2006-09-04, slides page 11)
463  ====================================================
464  11: R delta R: Radial expansion linearly with r
465  12: Phi delta R: radial expansion sinuisoidally with phi
466  13: Z delta R: radial expansion linearly with z
467  21: R delta Phi: rotation linearly with r
468  22: Phi delta Phi: rotation sinusoidally with phi
469  23: Z delta Phi: rotation linearly with z
470  31: R delta Z: z-shift linearly with r
471  32: Phi delta Z: z-shift sinusoidally with phi
472  33: Z delta Z: z-shift linearly with z
473  */
474 
475  const double maxRadius=51.4*CLHEP::cm; // maximum radius of Silicon Detector (=outermost SCT radius)
476  const double minRadius=50.5*CLHEP::mm; // minimum radius of Silicon Detector (=innermost PIX radius)
477  const double maxLength=158.*CLHEP::cm; // maximum length of Silicon Detector barrel (=length of SCT barrel)
478 
479  const double maxDeltaR = m_Misalign_maxShift;
480  const double maxAngle = 2 * asin( m_Misalign_maxShift / (2*maxRadius));
481  const double maxAngleInner = 2 * asin ( m_Misalign_maxShift_Inner / (2*minRadius));
482  const double maxDeltaZ = m_Misalign_maxShift;
483  ATH_MSG_DEBUG( "maximum deltaPhi = " << maxAngle/CLHEP::mrad << " mrad" );
484  ATH_MSG_DEBUG( "maximum deltaPhi for 1/r term = " << maxAngleInner/CLHEP::mrad << " mrad" );
485  const InDetDD::SiDetectorElementCollection* pixelElements=nullptr;
486  const InDetDD::SiDetectorElementCollection* sctElements=nullptr;
487  if(m_doPix){
488  // SiDetectorElementCollection for Pixel
489  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> pixelDetEleHandle(m_pixelDetEleCollKey);
490  pixelElements = *pixelDetEleHandle;
491  if (not pixelDetEleHandle.isValid() or pixelElements==nullptr) {
492  ATH_MSG_FATAL(m_pixelDetEleCollKey.fullKey() << " is not available.");
493  return StatusCode::FAILURE;
494  }
495  }
496  if(m_doStrip){
497  // SiDetectorElementCollection for SCT
498  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> sctDetEleHandle(m_SCTDetEleCollKey);
499  sctElements = *sctDetEleHandle;
500  if (not sctDetEleHandle.isValid() or sctElements==nullptr) {
501  ATH_MSG_FATAL(m_SCTDetEleCollKey.fullKey() << " is not available.");
502  return StatusCode::FAILURE;
503  }
504  }
505 
506  for (std::map<Identifier, HepGeom::Point3D<double> >::const_iterator iter = m_ModuleList.begin(); iter != m_ModuleList.end(); ++iter) {
507  ++i;
508  const Identifier& ModuleID = iter->first;
509 
510  const InDetDD::SiDetectorElement * SiModule = nullptr; //dummy to get moduleTransform() for silicon
511 
512  if (m_idHelper->is_pixel(ModuleID)) {
513  const IdentifierHash Pixel_ModuleHash = m_pixelIdHelper->wafer_hash(ModuleID);
514  if(pixelElements) SiModule = pixelElements->getDetectorElement(Pixel_ModuleHash);
515  else ATH_MSG_WARNING("Trying to access a Pixel module when running with no Pixel!");
516  //module = SiModule;
517  } else if (m_idHelper->is_sct(ModuleID)) {
518  const IdentifierHash SCT_ModuleHash = m_sctIdHelper->wafer_hash(ModuleID);
519  if(sctElements) SiModule = sctElements->getDetectorElement(SCT_ModuleHash);
520  else ATH_MSG_WARNING("Trying to access an SCT/Strop module when running with no SCT/Strip!");
521  //module = SiModule;OB
522  } else if (m_idHelper->is_trt(ModuleID)) {
523  //module = m_TRT_Manager->getElement(ModuleID);
524  //const InDetDD::TRT_BaseElement *p_TRT_Module = m_TRT_Manager->getElement(iter->second.moduleID());
525  } else {
526  ATH_MSG_WARNING( "Something fishy, identifier is neither Pixel, nor SCT or TRT!" );
527  }
528 
529  //TRT alignment transformations are given in global frame in DB,
530  // that's not fully correct, since the level2 transform can rotate the system in which level1 transforms
531  // are applied ...
532 
533  //Si have a local coordinate system
534  // Take care: For SCT we have to ensure that module's
535  // system is taken, not the system of one of the wafers!
536  HepGeom::Transform3D localToGlobal = HepGeom::Transform3D();
537  if ((not m_idHelper->is_trt(ModuleID))){
538  if (SiModule){
539  localToGlobal=Amg::EigenTransformToCLHEP(SiModule->moduleTransform());
540  } else {
541  ATH_MSG_WARNING("Apparently in a silicon detector, but SiModule is a null pointer");
542  }
543  }
544  const HepGeom::Point3D<double> center = iter->second;
545 
546  //center of module in global coordinates
547  double r = center.rho(); //distance from beampipe
548  double phi = center.phi();
549  double z = center.z();
550 
551  HepGeom::Transform3D parameterizedTrafo;
552  HepGeom::Transform3D alignmentTrafo;
553 
554 
555  // prepare scale factor for different subsystems:
556  double ScaleFactor = 1.;
557 
558  if (m_idHelper->is_pixel(ModuleID))
559  {
560  if (m_pixelIdHelper->is_barrel(ModuleID)) {
561  ScaleFactor=m_ScalePixelBarrel;
562  }
563  else {
564  ScaleFactor=m_ScalePixelEndcap;
565  }
566  if (m_pixelIdHelper->is_blayer(ModuleID)) { // IBL
567  ScaleFactor=m_ScalePixelIBL;
568  }
569  if (m_pixelIdHelper->is_dbm(ModuleID)) { // DBM
570  ScaleFactor=m_ScalePixelDBM;
571  }
572 
573  } else if (m_idHelper->is_sct(ModuleID))
574  {
575  if (m_sctIdHelper->is_barrel(ModuleID)) {
576  ScaleFactor=m_ScaleSCTBarrel;
577  }
578  else {
579  ScaleFactor=m_ScaleSCTEndcap;
580  }
581 
582  } else if (m_idHelper->is_trt(ModuleID))
583  {
584  if (m_trtIdHelper->is_barrel(ModuleID)) {
585  ScaleFactor=m_ScaleTRTBarrel;
586  }
587  else {
588  ScaleFactor=m_ScaleTRTEndcap;
589  }
590  } else {
591  ATH_MSG_WARNING( "Something fishy, identifier is neither Pixel, nor SCT or TRT!" );
592  }
593 
594 
595 
596  ATH_MSG_INFO( "ID Module " << i << " with ID " << m_idHelper->show_to_string(ModuleID,nullptr,'/') );
597  if (msgLvl(MSG::DEBUG)) {
598  msg() << "radius " << r / CLHEP::cm << " centimeter" << endmsg;
599  msg() << "phi " << phi << endmsg;
600  msg() << "z " << z / CLHEP::cm << " centimeter" << endmsg;
601  if (msgLvl(MSG::VERBOSE)) {
602  msg() << "localToGlobal transformation:" << endmsg;
603  msg() << "translation: " << localToGlobal.dx() / CLHEP::cm << ";" << localToGlobal.dy() / CLHEP::cm << ";" << localToGlobal.dz() / CLHEP::cm << endmsg;
604  msg() << "rotation: " << endmsg;
605  msg() << localToGlobal.xx() << " " << localToGlobal.xy() << " " << localToGlobal.xz() << endmsg;
606  msg() << localToGlobal.yx() << " " << localToGlobal.yy() << " " << localToGlobal.yz() << endmsg;
607  msg() << localToGlobal.zx() << " " << localToGlobal.zy() << " " << localToGlobal.zz() << endmsg;
608  }
609  }
610 
611  if (!m_MisalignmentMode) {
612  //no misalignment mode set
613  parameterizedTrafo = HepGeom::Transform3D(); // initialized as identity transformation
614  }
615 
616  else if (m_MisalignmentMode==1) {
617  //shift whole detector
618  HepGeom::Vector3D<double> shift(ScaleFactor*m_Misalign_x, ScaleFactor*m_Misalign_y, ScaleFactor*m_Misalign_z);
619 
620  CLHEP::HepRotation rot;
621  rot = CLHEP::HepRotationX(ScaleFactor*m_Misalign_alpha) * CLHEP::HepRotationY(ScaleFactor*m_Misalign_beta) * CLHEP::HepRotationZ(ScaleFactor*m_Misalign_gamma);
622 
623  if (ScaleFactor == 0.0) {
624  parameterizedTrafo = HepGeom::Transform3D(); // initialized as identity transformation
625  } else {
626  parameterizedTrafo = HepGeom::Transform3D(rot, shift);
627  }
628 
629  }
630 
631  else if (m_MisalignmentMode == 2) {
632 
633  // randomly misalign modules at L3
634  Rndm::Numbers RandMisX(randsvc, Rndm::Gauss(m_Misalign_x,m_RndmMisalignWidth_x*ScaleFactor));
635  Rndm::Numbers RandMisY(randsvc, Rndm::Gauss(m_Misalign_y,m_RndmMisalignWidth_y*ScaleFactor));
636  Rndm::Numbers RandMisZ(randsvc, Rndm::Gauss(m_Misalign_z,m_RndmMisalignWidth_z*ScaleFactor));
637  Rndm::Numbers RandMisalpha(randsvc, Rndm::Gauss(m_Misalign_alpha,m_RndmMisalignWidth_alpha*ScaleFactor));
638  Rndm::Numbers RandMisbeta(randsvc, Rndm::Gauss(m_Misalign_beta,m_RndmMisalignWidth_beta*ScaleFactor));
639  Rndm::Numbers RandMisgamma(randsvc, Rndm::Gauss(m_Misalign_gamma,m_RndmMisalignWidth_gamma*ScaleFactor));
640 
641  double randMisX = RandMisX(); //assign to variables to allow the values to be queried
642  double randMisY = RandMisY();
643  double randMisZ = RandMisZ();
644 
645  double randMisaplha = RandMisalpha();
646  double randMisbeta = RandMisbeta();
647  double randMisgamma = RandMisgamma();
648 
649  CLHEP::HepRotation rot;
650  HepGeom::Vector3D<double> shift;
651 
652 
653  if (ScaleFactor == 0.0) {
654  parameterizedTrafo = HepGeom::Transform3D(); // initialized as identity transformation
655  } else {
656  if (m_translation && m_rotation) {
657  shift = HepGeom::Vector3D<double>(randMisX, randMisY, randMisZ);
658  rot = CLHEP::HepRotationX(randMisaplha) * CLHEP::HepRotationY(randMisbeta) * CLHEP::HepRotationZ(randMisgamma);
659  parameterizedTrafo = HepGeom::Transform3D(rot, shift);}
660  else if (!m_translation && m_rotation) {
661  shift = HepGeom::Vector3D<double>(0, 0, 0);
662  rot = CLHEP::HepRotationX(randMisaplha) * CLHEP::HepRotationY(randMisbeta) * CLHEP::HepRotationZ(randMisgamma);
663  parameterizedTrafo = HepGeom::Transform3D(rot, shift);}
664  else if (m_translation && !m_rotation) {
665  shift = HepGeom::Vector3D<double>(randMisX, randMisY, randMisZ);
666  rot = CLHEP::HepRotationX(0) * CLHEP::HepRotationY(0) * CLHEP::HepRotationZ(0);
667  parameterizedTrafo = HepGeom::Transform3D(rot, shift);}
668  else { shift = HepGeom::Vector3D<double>(0, 0, 0);
669  rot = CLHEP::HepRotationX(0) * CLHEP::HepRotationY(0) * CLHEP::HepRotationZ(0);
670  parameterizedTrafo = HepGeom::Transform3D(rot, shift);}
671  }
672 
673  }
674 
675  else if (m_MisalignmentMode==3) {
676  //shift whole detector
677  double deltaX;
678  if ( m_idHelper->is_pixel(ModuleID) && m_pixelIdHelper->is_blayer(ModuleID) ) {
679  //function is parameterized in global z
680  deltaX = getBowingTx( getBowingMagParam(m_IBLBowingTshift), z);
681 
682  } else {
683  //IBL-stave temperature distortion not applied to anything but IBL
684  deltaX = 0.;
685  ATH_MSG_DEBUG( "will not move this module for IBL temp distortion " );
686  }
687 
688  ATH_MSG_DEBUG( "deltaX for this module: " << deltaX/CLHEP::micrometer << " um" );
689  parameterizedTrafo = HepGeom::Translate3D(deltaX,0,0); // translation in x direction
690  }
691 
692  else { // systematic misalignments
693  if (m_MisalignmentMode/10==1) {
694  //radial misalignments
695  double deltaR;
696  if (m_MisalignmentMode==11) {
697  //R deltaR = radial expansion
698  if (m_idHelper->is_trt(ModuleID) && abs(m_trtIdHelper->barrel_ec(ModuleID))==2) {
699  //radial mode cannot handle TRT endcap, sorry
700  deltaR = 0.;
701  ATH_MSG_DEBUG( "will not move TRT endcap for radial distortion " );
702  } else {
703  //deltaR = 0.5 * cos ( 2*phi ) * r/maxRadius * maxDeltaR;
704  deltaR = r/maxRadius * maxDeltaR; //scale linearly in r
705  }
706  } else if (m_MisalignmentMode==12) {
707  //Phi deltaR = elliptical (egg-shape)
708  if (m_idHelper->is_trt(ModuleID) && abs(m_trtIdHelper->barrel_ec(ModuleID))==2) {
709  //elliptical mode cannot handle TRT endcap, sorry
710  deltaR = 0.;
711  ATH_MSG_DEBUG( "will not move TRT endcap for elliptical distortion " );
712  } else {
713  // deltaR = 0.5 * cos ( 2*phi ) * r/maxRadius * maxDeltaR;
714  deltaR = cos ( 2*phi ) * r/maxRadius * maxDeltaR;
715  }
716  } else if (m_MisalignmentMode==13) {
717  //Z deltaR = funnel
718  if (m_idHelper->is_trt(ModuleID) && abs(m_trtIdHelper->barrel_ec(ModuleID))==2) {
719  //funnel mode cannot handle TRT endcap, sorry
720  deltaR = 0.;
721  ATH_MSG_DEBUG( "will not move TRT endcap for funnel distortion " );
722  } else {
723  //deltaR = z/maxLength * maxDeltaR; // linearly in z
724  deltaR = 2. * z/maxLength * maxDeltaR; // linearly in z
725  }
726  } else {
727  ATH_MSG_DEBUG( "Wrong misalignment mode entered, doing nothing." );
728  deltaR=0;
729  }
730 
731  ATH_MSG_DEBUG( "deltaR for this module: " << deltaR / CLHEP::micrometer << " um" );
732  parameterizedTrafo = HepGeom::Translate3D(deltaR*cos(phi),deltaR * sin(phi),0.); // translation along R vector
733  }
734 
735  else if (m_MisalignmentMode/10==2) {
736  //azimuthal misalignments
737  double deltaPhi;
738  if (m_MisalignmentMode==21) {
739 
740  deltaPhi = r/maxRadius * maxAngle + minRadius/r * maxAngleInner; //linearly + reciprocal term in r
741  } else if (m_MisalignmentMode==22) {
742  //Phi deltaPhi = clamshell
743  // deltaPhi = std::abs( sin ( phi )) * maxAngle;
744  if (m_idHelper->is_trt(ModuleID) && abs(m_trtIdHelper->barrel_ec(ModuleID))==2) {
745  //clamshell mode cannot handle TRT endcap, sorry
746  deltaPhi = 0.;
747  ATH_MSG_DEBUG( "will not move TRT endcap for clamshell distortion " );
748  } else {
749  // deltaPhi = 0.5 * cos ( 2*phi ) * maxAngle;
750  deltaPhi = cos ( 2*phi ) * maxAngle;
751  }
752  } else if (m_MisalignmentMode==23) {
753  //Z deltaPhi = Twist
754  deltaPhi = 2*z/maxLength * maxAngle;
755  //deltaPhi = z/maxLength * maxAngle;
756  } else {
757  ATH_MSG_WARNING( "Wrong misalignment mode entered, doing nothing." );
758  deltaPhi=0;
759  }
760 
761  ATH_MSG_DEBUG( "deltaPhi for this module: " << deltaPhi/CLHEP::mrad << " mrad" );
762  parameterizedTrafo = HepGeom::RotateZ3D(deltaPhi); // rotation around z axis => in phi
763  }
764 
765  else if (m_MisalignmentMode/10==3) {
766  //z misalignments
767  double deltaZ;
768  if (m_MisalignmentMode==31) {
769  //R deltaZ = Telescope
770  deltaZ = r/maxRadius * maxDeltaZ; //scale linearly in r
771  } else if (m_MisalignmentMode==32) {
772 
773  if (m_idHelper->is_trt(ModuleID) && abs(m_trtIdHelper->barrel_ec(ModuleID))==2) {
774  //clamshell mode cannot handle TRT endcap, sorry
775  deltaZ = 0.;
776  ATH_MSG_DEBUG( "will not move TRT endcap for skew distortion " );
777  } else {
778 
779  deltaZ = cos ( 2*phi ) * maxDeltaZ;
780  }
781  } else if (m_MisalignmentMode==33) {
782  //Z deltaZ = Z expansion
783  // deltaZ = z/maxLength * maxDeltaZ;
784  deltaZ = 2. * z/maxLength * maxDeltaZ;
785  } else {
786  ATH_MSG_WARNING( "Wrong misalignment mode entered, doing nothing." );
787  deltaZ=0;
788  }
789 
790  ATH_MSG_DEBUG( "deltaZ for this module: " << deltaZ/CLHEP::micrometer << " um" );
791  parameterizedTrafo = HepGeom::Translate3D(0,0,deltaZ); // translation in z direction
792  }
793 
794  else {
795  //no or wrong misalignment selected
796  ATH_MSG_WARNING( "Wrong misalignment mode entered, doing nothing." );
797 
798  parameterizedTrafo = HepGeom::Transform3D(); // initialized as identity transformation
799  }
800  } //end of misalignment
801 
802  if ( m_MisalignmentMode==21 && m_idHelper->is_trt(ModuleID) && m_trtIdHelper->is_barrel(ModuleID) ) {
803  //curl for TRT barrel
804  ATH_MSG_DEBUG( "additional rotation for TRT barrel module!" );
805  HepGeom::Transform3D realLocalToGlobalTRT = HepGeom::Translate3D(center.x(),center.y(),center.z());
806  //rotate a TRT barrel module by the same angle again, but around its local z axis
807  //this is an approximation to accomodate the impossible curling of TRT segments
808  alignmentTrafo = parameterizedTrafo * realLocalToGlobalTRT * parameterizedTrafo * realLocalToGlobalTRT.inverse();
809  } else if (m_MisalignmentMode==23 && m_idHelper->is_trt(ModuleID) && m_trtIdHelper->is_barrel(ModuleID) ) {
810  //do the twist! (for TRT barrel)
811  HepGeom::Transform3D realLocalToGlobalTRT = HepGeom::Translate3D(center.x(),center.y(),center.z());
812  double deltaAlpha = (-2.) * r * maxAngle/maxLength;
813  ATH_MSG_DEBUG( "TRT barrel module alpha for twist: " << deltaAlpha/CLHEP::mrad << " mrad" );
814 
815  CLHEP::HepRotation twistForTRTRotation(HepGeom::Vector3D<double>(center.x(),center.y(),center.z()), deltaAlpha );
816  HepGeom::Transform3D twistForTRT= HepGeom::Transform3D(twistForTRTRotation,HepGeom::Vector3D<double>(0.,0.,0.));
817  // HepGeom::Transform3D twistForTRTRotation = HepGeom::RotateZ3D( r * maxAngle/maxLength );
818 
819  alignmentTrafo = realLocalToGlobalTRT * twistForTRT * realLocalToGlobalTRT.inverse();
820  } else if (m_MisalignmentMode==13 && m_idHelper->is_trt(ModuleID) && m_trtIdHelper->is_barrel(ModuleID) ) {
821  // funneling for TRT barrel
822  HepGeom::Transform3D realLocalToGlobalTRT = HepGeom::Translate3D(center.x(),center.y(),center.z());
823  double deltaAlpha = (-2.) * maxDeltaR/maxLength;
824  //double deltaAlpha = maxDeltaR/maxLength;
825  ATH_MSG_DEBUG( "TRT barrel module alpha for funnel: " << deltaAlpha/CLHEP::mrad << " mrad" );
826 
827  HepGeom::Vector3D<double> normalVector(center.x(),center.y(),center.z());
828  HepGeom::Vector3D<double> beamVector(0.,0.,1.);
829  HepGeom::Vector3D<double> rotationAxis = normalVector.cross(beamVector);
830  CLHEP::HepRotation twistForTRTRotation(rotationAxis, deltaAlpha );
831  HepGeom::Transform3D twistForTRT= HepGeom::Transform3D(twistForTRTRotation,HepGeom::Vector3D<double>(0.,0.,0.));
832 
833  alignmentTrafo = realLocalToGlobalTRT * twistForTRT * realLocalToGlobalTRT.inverse();
834 
835 
836 
837  } else if (m_MisalignmentMode==2 || m_MisalignmentMode==3) //random misalignment in local frame
838  {
839  alignmentTrafo = parameterizedTrafo;
840  }
841  else {
842  // final transformation executed in global coordinates, converted to local coordinates
843  alignmentTrafo = localToGlobal.inverse() * parameterizedTrafo * localToGlobal;
844  }
845 
846  if (msgLvl(MSG::INFO)) {
847  msg() << "Align Transformation x = (" << alignmentTrafo.getTranslation().x() / CLHEP::micrometer << " um)" << endmsg;
848  msg() << "Align Transformation y = (" << alignmentTrafo.getTranslation().y() / CLHEP::micrometer << " um)" << endmsg;
849  msg() << "Align Transformation z = (" << alignmentTrafo.getTranslation().z() / CLHEP::micrometer << " um)" << endmsg;
850  msg() << "Align Transformation x phi = (" << alignmentTrafo.getRotation().phiX() / CLHEP::deg << ")" << endmsg;
851  msg() << "Align Transformation x Theta = (" << alignmentTrafo.getRotation().thetaX() / CLHEP::deg << ")" << endmsg;
852  msg() << "Align Transformation y phi = (" << alignmentTrafo.getRotation().phiY() / CLHEP::deg << ")" << endmsg;
853  msg() << "Align Transformation y Theta = (" << alignmentTrafo.getRotation().thetaY() / CLHEP::deg << ")" << endmsg;
854  msg() << "Align Transformation z phi = (" << alignmentTrafo.getRotation().phiZ() / CLHEP::deg << ")" << endmsg;
855  msg() << "Align Transformation z Theta = (" << alignmentTrafo.getRotation().thetaZ() / CLHEP::deg << ")" << endmsg;
856  }
857 
858  // suppress tiny translations that occur due to trafo.inverse*trafo numerics
859  if ( std::abs(alignmentTrafo.getTranslation().x()) < 1e-10) {
860  HepGeom::Vector3D<double>
861  zeroSuppressedTranslation(0,alignmentTrafo.getTranslation().y(),alignmentTrafo.
862  getTranslation().z());
863  alignmentTrafo =
864  HepGeom::Transform3D(alignmentTrafo.getRotation(),zeroSuppressedTranslation);
865  }
866  if ( std::abs(alignmentTrafo.getTranslation().y()) < 1e-10) {
867  HepGeom::Vector3D<double>
868  zeroSuppressedTranslation(alignmentTrafo.getTranslation().x(),0,alignmentTrafo.
869  getTranslation().z());
870  alignmentTrafo =
871  HepGeom::Transform3D(alignmentTrafo.getRotation(),zeroSuppressedTranslation);
872  }
873  if ( std::abs(alignmentTrafo.getTranslation().z()) < 1e-10) {
874  HepGeom::Vector3D<double>
875  zeroSuppressedTranslation(alignmentTrafo.getTranslation().x(),alignmentTrafo.getTranslation().y(),0);
876  alignmentTrafo =
877  HepGeom::Transform3D(alignmentTrafo.getRotation(),zeroSuppressedTranslation);
878  }
879  if ( std::abs(alignmentTrafo.getRotation().getDelta()) < 1e-10) {
880  CLHEP::HepRotation zeroSuppressedRotation(alignmentTrafo.getRotation());
881  zeroSuppressedRotation.setDelta(0.);
882  alignmentTrafo =
883  HepGeom::Transform3D(zeroSuppressedRotation,alignmentTrafo.getTranslation());
884  }
885 
886 
887  Amg::Transform3D alignmentTrafoAmg = Amg::CLHEPTransformToEigen(alignmentTrafo);
888 
889  if (m_idHelper->is_sct(ModuleID) || m_idHelper->is_pixel(ModuleID)) {
890  if (m_IDAlignDBTool->tweakTrans(ModuleID,3, alignmentTrafoAmg)) {
891  ATH_MSG_INFO( "Update of alignment constants for module " << m_idHelper->show_to_string(ModuleID,nullptr,'/') << " successful" );
892  } else {
893  ATH_MSG_ERROR( "Update of alignment constants for module " << m_idHelper->show_to_string(ModuleID,nullptr,'/') << " not successful" );
894  }
895  } else if (m_idHelper->is_trt(ModuleID)) {
896  if (!m_trtIdHelper->is_barrel(ModuleID) && m_trtIdHelper->phi_module(ModuleID)!=0) {
897  //don't align - there's no trans in the DB for phi sectors other than 0
898  ATH_MSG_DEBUG( "TRT endcap phi sector " << m_trtIdHelper->phi_module(ModuleID) << " not aligned" );
899  } else {
900  //if (m_trtaligndbservice->tweakTrans(ModuleID,alignmentTrafo).isFailure()) {
901  if (m_trtaligndbservice->tweakAlignTransform(ModuleID,alignmentTrafoAmg,2).isFailure()) {
902  ATH_MSG_ERROR( "Update of alignment constants for module " << m_idHelper->show_to_string(ModuleID,nullptr,'/') << " not successful" );
903  } else {
904  ATH_MSG_INFO( "Update of alignment constants for module " << m_idHelper->show_to_string(ModuleID,nullptr,'/') << " successful" );
905  }
906  }
907  } else {
908  ATH_MSG_WARNING( "Something fishy, identifier is neither Pixel, nor SCT or TRT!" );
909  }
910 
911  double alpha, beta, gamma;
912  m_IDAlignDBTool->extractAlphaBetaGamma(alignmentTrafoAmg, alpha, beta, gamma);
913 
914  m_AlignResults_x = alignmentTrafo.getTranslation().x();
915  m_AlignResults_y = alignmentTrafo.getTranslation().y();
916  m_AlignResults_z = alignmentTrafo.getTranslation().z();
917  m_AlignResults_alpha = alpha;
918  m_AlignResults_beta = beta;
919  m_AlignResults_gamma = gamma;
920 
921 
922  HepGeom::Transform3D LocalaGlobal = HepGeom::Transform3D();
923  LocalaGlobal = Amg::EigenTransformToCLHEP(SiModule->moduleTransform());
924  HepGeom::Point3D<double> alignedPosLocal(m_AlignResults_x,m_AlignResults_y,m_AlignResults_z);
925 
926 
927 
928 
929  m_Initial_center_x = center.x() ;
930  m_Initial_center_y = center.y() ;
931  m_Initial_center_z = center.z() ;
932 
933  HepGeom::Point3D<double> alignedPosGlobal = LocalaGlobal * alignedPosLocal;
934 
935  // Global Misalignment HERE
936  if (m_idHelper->is_sct(ModuleID)) {
937  // non-zero local center position gives additional radial shift of SCT endcap
938  const InDetDD::StripStereoAnnulusDesign *p_design_check = dynamic_cast<const InDetDD::StripStereoAnnulusDesign*>(&(SiModule->design()));
939  if (p_design_check){
940  Amg::Vector3D SCT_Center = p_design_check->sensorCenter();
941  double radialShift_x = SCT_Center[0]; // in sensor frame, x direction
942  double radialShift_y = SCT_Center[1]; // in sensor frame, y direction
943  HepGeom::Transform3D radial_shift = HepGeom::Translate3D(radialShift_x,radialShift_y,0); // the additional radial shift applied as translation
944  HepGeom::Transform3D LocalaaGlobal = LocalaGlobal * radial_shift; // apply additional radial shift
945  HepGeom::Point3D<double> SCT_endcap_alignedPosGlobal = LocalaaGlobal * alignedPosLocal; // corrected global transformation
946  m_Global_center_x = SCT_endcap_alignedPosGlobal.x();
947  m_Global_center_z = SCT_endcap_alignedPosGlobal.z();
948  m_Global_center_y = SCT_endcap_alignedPosGlobal.y();
949  }
950 
951  else { // no additional radial shift for SCT barrel
952  m_Global_center_x = alignedPosGlobal.x();
953  m_Global_center_y = alignedPosGlobal.y();
954  m_Global_center_z = alignedPosGlobal.z();
955 
956  }
957 
958  }
959 
960  else { // no additional radial shift for non-SCT elements
961  m_Global_center_x = alignedPosGlobal.x();
962  m_Global_center_y = alignedPosGlobal.y();
963  m_Global_center_z = alignedPosGlobal.z();
964  }
965 
966 
967  if (m_idHelper->is_sct(ModuleID)) {
968  m_AlignResults_Identifier_ID = 2;
969  m_AlignResults_Identifier_PixelSCT = 2;
970  m_AlignResults_Identifier_BarrelEC = m_sctIdHelper->barrel_ec(ModuleID);
971  m_AlignResults_Identifier_LayerDisc = m_sctIdHelper->layer_disk(ModuleID);
972  m_AlignResults_Identifier_Phi = m_sctIdHelper->phi_module(ModuleID);
973  m_AlignResults_Identifier_Eta = m_sctIdHelper->eta_module(ModuleID);
974  } else if (m_idHelper->is_pixel(ModuleID)) {
975  m_AlignResults_Identifier_ID = 2;
976  m_AlignResults_Identifier_PixelSCT = 1;
977  m_AlignResults_Identifier_BarrelEC = m_pixelIdHelper->barrel_ec(ModuleID);
978  m_AlignResults_Identifier_LayerDisc = m_pixelIdHelper->layer_disk(ModuleID);
979  m_AlignResults_Identifier_Phi = m_pixelIdHelper->phi_module(ModuleID);
980  m_AlignResults_Identifier_Eta = m_pixelIdHelper->eta_module(ModuleID);
981  } else if (m_idHelper->is_trt(ModuleID)) {
982  m_AlignResults_Identifier_ID = 2;
983  m_AlignResults_Identifier_PixelSCT = 3;
984  m_AlignResults_Identifier_BarrelEC = m_trtIdHelper->barrel_ec(ModuleID);
985  m_AlignResults_Identifier_LayerDisc = m_trtIdHelper->layer_or_wheel(ModuleID);
986  m_AlignResults_Identifier_Phi = m_trtIdHelper->phi_module(ModuleID);
987  m_AlignResults_Identifier_Eta = m_trtIdHelper->straw_layer(ModuleID);
988 
989  } else {
990  ATH_MSG_WARNING( "Something fishy, identifier is neither Pixel, nor SCT or TRT!" );
991  }
992 
993  // Write out AlignResults ntuple
994  if (StatusCode::SUCCESS!=ntupleSvc()->writeRecord("NTUPLES/CREATEMISALIGN/InitialAlignment")) {
995  ATH_MSG_ERROR( "Could not write InitialAlignment ntuple." );
996  }
997 
998  } // end of module loop
999 
1000  // i = 0;
1001 
1002  //m_IDAlignDBTool->printDB(2);
1003  if(m_doPix || m_doStrip){
1004  if (StatusCode::SUCCESS!=m_IDAlignDBTool->outputObjs()) {
1005  ATH_MSG_ERROR( "Writing of AlignableTransforms failed" );
1006  } else {
1007  ATH_MSG_INFO( "AlignableTransforms were written" );
1008  ATH_MSG_INFO( "Writing database to textfile" );
1009  m_IDAlignDBTool->writeFile(false,m_asciiFileNameBase+"_Si.txt");
1010  ATH_MSG_INFO( "Writing IoV information to mysql file" );
1011  m_IDAlignDBTool->fillDB("InDetSi_"+m_SQLiteTag,IOVTime::MINRUN,IOVTime::MINEVENT,IOVTime::MAXRUN,IOVTime::MAXEVENT);
1012  }
1013  }
1014 
1015  if(m_doTRT){
1016  if (StatusCode::SUCCESS!=m_trtaligndbservice->streamOutAlignObjects()) {
1017  ATH_MSG_ERROR( "Write of AlignableTransforms (TRT) failed" );
1018  } else {
1019  ATH_MSG_INFO( "AlignableTransforms for TRT were written" );
1020  ATH_MSG_INFO( "Writing TRT database to textfile" );
1021  if ( StatusCode::SUCCESS != m_trtaligndbservice->writeAlignTextFile(m_asciiFileNameBase+"_TRT.txt") ) {
1022  ATH_MSG_ERROR( "Failed to write AlignableTransforms (TRT) to txt file " << m_asciiFileNameBase+"_TRT.txt" );
1023  }
1024  ATH_MSG_INFO( "Writing IoV information for TRT to mysql file" );
1025  if ( StatusCode::SUCCESS
1026  != m_trtaligndbservice->registerAlignObjects(m_SQLiteTag+"_TRT",IOVTime::MINRUN,IOVTime::MINEVENT,IOVTime::MAXRUN,IOVTime::MAXEVENT)) {
1027  ATH_MSG_ERROR( "Write of AIoV information (TRT) to mysql failed (tag=" << m_SQLiteTag << "_TRT)");
1028  }
1029  }
1030  }
1031 
1032  return StatusCode::SUCCESS;
1033 
1034  }
1035 
1036  //__________________________________________________________________________
1037  const HepGeom::Transform3D CreateMisalignAlg::BuildAlignTransform(const CLHEP::HepVector & AlignParams)
1038  {
1039  HepGeom::Vector3D<double> AlignShift(AlignParams[0],AlignParams[1],AlignParams[2]);
1040  CLHEP::HepRotation AlignRot;
1041 
1042  AlignRot = CLHEP::HepRotationX(AlignParams[3]) * CLHEP::HepRotationY(AlignParams[4]) * CLHEP::HepRotationZ(AlignParams[5]);
1043 
1044  HepGeom::Transform3D AlignTransform = HepGeom::Transform3D(AlignRot,AlignShift);
1045  return AlignTransform;
1046  }
1047 
1048  //__________________________________________________________________________
1049  const Identifier CreateMisalignAlg::reduceTRTID(Identifier id)
1050  {
1051  // msg(MSG::DEBUG) << "in CreateMisalignAlg::reduceTRTID" << endmsg;
1052  ATH_MSG_DEBUG( "reduceTRTID got Id " << m_idHelper->show_to_string(id,nullptr,'/'));
1053 
1054  int barrel_ec= m_trtIdHelper->barrel_ec(id);
1055  // attention: TRT DB only has one alignment correction per barrel module (+1/-1) pair
1056  // which is stored in -1 identifier
1057  if (barrel_ec==1) barrel_ec=-1; //only regard -1 barrel modules, +1 modules will belong to them
1058 
1059  //if (abs(barrel_ec)==2) phi_module=0;
1060  // only regard phi sector 0, the only one having an alignmentTrafo
1061  //does not work, since the center-of-mass of all phi sectors is on the beamline,so
1062  // transformations would become zero -> this has to be handled later
1063  int phi_module=m_trtIdHelper->phi_module(id);
1064 
1065  int layer_or_wheel=m_trtIdHelper->layer_or_wheel(id);
1066 
1067  int strawlayer=0;
1068  if (!m_trtIdHelper->is_barrel(id)) {
1069  strawlayer = m_trtIdHelper->straw_layer(id) / 4 * 4;
1070  // only strawlayers 0,4,8,12 are fed into DB for endcap
1071  }
1072 
1073  // if (msgLvl(MSG::DEBUG)) msg() << " and returns Id " << m_idHelper->show_to_string(m_trtIdHelper->module_id(barrel_ec,phi_module,layer_or_wheel),0,'/') << endmsg;
1074  ATH_MSG_DEBUG( " and returns Id " << m_idHelper->show_to_string(m_trtIdHelper->layer_id(barrel_ec,phi_module,layer_or_wheel,strawlayer),nullptr,'/'));
1075  // return m_trtIdHelper->module_id(barrel_ec,phi_module,layer_or_wheel);
1076  return m_trtIdHelper->layer_id(barrel_ec,phi_module,layer_or_wheel,strawlayer);
1077  }
1078 
1079  //__________________________________________________________________________
1080  const Identifier CreateMisalignAlg::reduceTRTID(IdentifierHash &hash)
1081  {
1082  Identifier id= m_trtIdHelper->module_id(hash);
1083  return reduceTRTID(id);
1084  }
1085 
1086  //__________________________________________________________________________
1087  double CreateMisalignAlg::getBowingMagParam(double temp_shift)
1088  {
1089  // IBL staves are straight at a set point of 15 degrees.
1090  // Get set point value to use for magnitude parameter from temp_shift starting at 15 degrees
1091  double T = 15 + temp_shift;
1092  return 1.53e-12 - 1.02e-13*T;
1093  }
1094 
1095  //__________________________________________________________________________
1096  double CreateMisalignAlg::getBowingTx(double p1, double z)
1097  {
1098  // Bowing fit function has the following form
1099  // [0]-[1]*(x+[2]) * (4.0*[2]*(x+[2])**2 - (x+[2])**3 - (2.0*[2])**3)
1100  // param 0 : is the baseline shift (fixed at 0 for MC)
1101  // param 1 : is the magnitude fit param (temp dependent input param)
1102  // param 2 : is the stave fix pointat both ends (fixed at 366.5)
1103  double p0 = 0;
1104  double p2 = 366.5;
1105  double Tx = p0 - p1*(z+p2) * (4.*p2*pow((z+p2),2) - pow((z+p2),3) - pow((2.*p2),3));
1106  return Tx;
1107  }
1108 
1109 } // end of namespace bracket
InDetAlignment::CreateMisalignAlg::m_RndmMisalignWidth_y
Gaudi::Property< double > m_RndmMisalignWidth_y
Definition: CreateMisalignAlg.h:91
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
PixelID.h
This is an Identifier helper class for the Pixel subdetector. This class is a factory for creating co...
AtlasDetectorID::is_pixel
bool is_pixel(Identifier id) const
Definition: AtlasDetectorID.h:760
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
InDetAlignment::CreateMisalignAlg::m_Misalign_z
Gaudi::Property< double > m_Misalign_z
Definition: CreateMisalignAlg.h:86
beamspotman.r
def r
Definition: beamspotman.py:676
InDetAlignment::CreateMisalignAlg::m_ScalePixelDBM
double m_ScalePixelDBM
Definition: CreateMisalignAlg.h:99
InDetAlignment::CreateMisalignAlg::m_AlignResults_alpha
NTuple::Item< double > m_AlignResults_alpha
AP rotation around x-axis.
Definition: CreateMisalignAlg.h:120
TRT_ID::layer_id
Identifier layer_id(int barrel_ec, int phi_module, int layer_or_wheel, int straw_layer) const
For an individual straw layer.
Definition: TRT_ID.h:500
InDetAlignment::CreateMisalignAlg::m_HumanReadableID
int m_HumanReadableID
Definition: CreateMisalignAlg.h:115
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
SCT_ID.h
This is an Identifier helper class for the SCT subdetector. This class is a factory for creating comp...
InDetAlignment::CreateMisalignAlg::m_ScalePixelEndcap
double m_ScalePixelEndcap
Definition: CreateMisalignAlg.h:102
add-xsec-uncert-quadrature-N.alpha
alpha
Definition: add-xsec-uncert-quadrature-N.py:110
IOVTime::MAXRUN
static constexpr uint32_t MAXRUN
Definition: IOVTime.h:48
InDetAlignment::CreateMisalignAlg::m_AlignResults_Identifier_ID
NTuple::Item< long > m_AlignResults_Identifier_ID
ID information for this module.
Definition: CreateMisalignAlg.h:123
InDetDD::SiDetectorElementCollection
Definition: SiDetectorElementCollection.h:30
AthCheckMacros.h
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
InDetAlignment::CreateMisalignAlg::m_Global_center_x
NTuple::Item< double > m_Global_center_x
Misaligned global center of module.
Definition: CreateMisalignAlg.h:135
TRT_DetElementCollection.h
IOVRange.h
Validity Range object. Holds two IOVTime instances (start and stop)
InDetAlignment::CreateMisalignAlg::m_Initial_center_z
NTuple::Item< double > m_Initial_center_z
Initial global center of module.
Definition: CreateMisalignAlg.h:132
InDetAlignment::CreateMisalignAlg::m_Misalign_gamma
Gaudi::Property< double > m_Misalign_gamma
Definition: CreateMisalignAlg.h:89
AtlasDetectorID::is_sct
bool is_sct(Identifier id) const
Definition: AtlasDetectorID.h:770
PixelID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: PixelID.h:619
InDetAlignment::CreateMisalignAlg::BuildAlignTransform
const HepGeom::Transform3D BuildAlignTransform(const CLHEP::HepVector &)
builds a HepGeom::Transform3D from the 6 Alignment Parameters
Definition: CreateMisalignAlg.cxx:1037
CreateMisalignAlg.h
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
xAOD::deltaPhi
setSAddress setEtaMS setDirPhiMS setDirZMS setBarrelRadius setEndcapAlpha setEndcapRadius setInterceptInner setEtaMap setEtaBin setIsTgcFailure setDeltaPt deltaPhi
Definition: L2StandAloneMuon_v1.cxx:160
InDetAlignment::CreateMisalignAlg::m_pixelDetEleCollKey
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection > m_pixelDetEleCollKey
Definition: CreateMisalignAlg.h:162
TRTCalib_cfilter.p1
p1
Definition: TRTCalib_cfilter.py:130
InDetAlignment
Definition: CreateMisalignAlg.cxx:68
TRT_ID.h
This is an Identifier helper class for the TRT subdetector. This class is a factory for creating comp...
InDetAlignment::CreateMisalignAlg::m_Misalign_beta
Gaudi::Property< double > m_Misalign_beta
Definition: CreateMisalignAlg.h:88
SG::ReadCondHandle::isValid
bool isValid()
Definition: ReadCondHandle.h:210
Identifier::get_identifier32
Identifier32 get_identifier32() const
Get the 32-bit version Identifier, will be invalid if >32 bits needed.
deg
#define deg
Definition: SbPolyhedron.cxx:17
AthCommonMsg< Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
InDetAlignment::CreateMisalignAlg::m_ScaleTRTBarrel
double m_ScaleTRTBarrel
Definition: CreateMisalignAlg.h:105
InDetAlignment::CreateMisalignAlg::m_AlignResults_gamma
NTuple::Item< double > m_AlignResults_gamma
AP rotation around z-axis.
Definition: CreateMisalignAlg.h:122
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:158
InDetAlignment::CreateMisalignAlg::m_ScaleSCTBarrel
double m_ScaleSCTBarrel
Definition: CreateMisalignAlg.h:103
SCT_ID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: SCT_ID.h:728
InDetAlignment::CreateMisalignAlg::m_SQLiteTag
std::string m_SQLiteTag
tag name for the ConditionsDB
Definition: CreateMisalignAlg.h:75
AtlasDetectorID::is_trt
bool is_trt(Identifier id) const
Definition: AtlasDetectorID.h:782
SCT_ID::phi_module
int phi_module(const Identifier &id) const
Definition: SCT_ID.h:740
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
InDetAlignment::CreateMisalignAlg::m_AlignResults_Identifier_LayerDisc
NTuple::Item< long > m_AlignResults_Identifier_LayerDisc
ID information for this module.
Definition: CreateMisalignAlg.h:126
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
python.SystemOfUnits.mrad
int mrad
Definition: SystemOfUnits.py:112
Identifier::is_valid
bool is_valid() const
Check if id is in a valid state.
Identifier32::get_compact
value_type get_compact() const
Get the compact id.
Definition: Identifier32.h:44
SCT_ID::module_id
Identifier module_id(int barrel_ec, int layer_disk, int phi_module, int eta_module) const
For a single crystal.
Definition: SCT_ID.h:416
PixelID::is_blayer
bool is_blayer(const Identifier &id) const
Test for b-layer - WARNING: id MUST be pixel id, otherwise answer is not accurate....
Definition: PixelID.h:633
InDetAlignment::CreateMisalignAlg::finalize
StatusCode finalize()
standard Athena-Algorithm method
Definition: CreateMisalignAlg.cxx:260
InDetAlignment::CreateMisalignAlg::m_AlignResults_Identifier_Eta
NTuple::Item< long > m_AlignResults_Identifier_Eta
ID information for this module.
Definition: CreateMisalignAlg.h:128
AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
InDetAlignment::CreateMisalignAlg::m_ModuleList
std::map< Identifier, HepGeom::Point3D< double > > m_ModuleList
map of all SiIdentifiers to be misaligned and their centerpoints in global coordinates
Definition: CreateMisalignAlg.h:109
IOVTime::MINRUN
static constexpr uint32_t MINRUN
Definition: IOVTime.h:44
cm
const double cm
Definition: Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/tools/FCAL_ChannelMap.cxx:25
InDetAlignment::CreateMisalignAlg::m_doTRT
bool m_doTRT
Definition: CreateMisalignAlg.h:160
python.PyAthena.module
module
Definition: PyAthena.py:131
InDetAlignment::CreateMisalignAlg::m_AlignResults_Identifier_BarrelEC
NTuple::Item< long > m_AlignResults_Identifier_BarrelEC
ID information for this module.
Definition: CreateMisalignAlg.h:125
DiTauMassTools::ignore
void ignore(T &&)
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:58
AtlasDetectorID.h
This class provides an interface to generate or decode an identifier for the upper levels of the dete...
TRTCalib_cfilter.p2
p2
Definition: TRTCalib_cfilter.py:131
InDetAlignment::CreateMisalignAlg::m_AlignResults_beta
NTuple::Item< double > m_AlignResults_beta
AP rotation aorund y-axis.
Definition: CreateMisalignAlg.h:121
PixelID::is_barrel
bool is_barrel(const Identifier &id) const
Test for barrel - WARNING: id MUST be pixel id, otherwise answer is not accurate. Use SiliconID for g...
Definition: PixelID.h:605
InDetAlignment::CreateMisalignAlg::m_RndmMisalignWidth_beta
Gaudi::Property< double > m_RndmMisalignWidth_beta
Definition: CreateMisalignAlg.h:94
InDetAlignment::CreateMisalignAlg::m_createFreshDB
bool m_createFreshDB
Flag to call the createDB method of DBTool (to be switched off when adding misalignments to a given g...
Definition: CreateMisalignAlg.h:78
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
PixelID::wafer_hash
IdentifierHash wafer_hash(Identifier wafer_id) const
wafer hash from id
Definition: PixelID.h:387
InDetAlignment::CreateMisalignAlg::m_trtDetEleCollKey
SG::ReadCondHandleKey< InDetDD::TRT_DetElementContainer > m_trtDetEleCollKey
Definition: CreateMisalignAlg.h:164
InDetAlignment::CreateMisalignAlg::m_RndmMisalignWidth_gamma
Gaudi::Property< double > m_RndmMisalignWidth_gamma
Definition: CreateMisalignAlg.h:95
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
InDetAlignment::CreateMisalignAlg::getBowingTx
double getBowingTx(double p1, double z)
Definition: CreateMisalignAlg.cxx:1096
InDetDD::SiDetectorElement::moduleTransform
const Amg::Transform3D & moduleTransform() const
Module to global frame transform.
Definition: SiDetectorElement.cxx:173
TrigVtx::gamma
@ gamma
Definition: TrigParticleTable.h:26
InDetAlignment::CreateMisalignAlg::m_asciiFileNameBase
std::string m_asciiFileNameBase
filename basis for ASCII files with alignment constants
Definition: CreateMisalignAlg.h:74
InDetAlignment::CreateMisalignAlg::m_VisualizationLookupTree
TTree * m_VisualizationLookupTree
Definition: CreateMisalignAlg.h:112
lumiFormat.i
int i
Definition: lumiFormat.py:85
z
#define z
InDetAlignment::CreateMisalignAlg::m_trtIdHelper
const TRT_ID * m_trtIdHelper
Definition: CreateMisalignAlg.h:68
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
InDetAlignment::CreateMisalignAlg::m_AlignResults_Identifier_Phi
NTuple::Item< long > m_AlignResults_Identifier_Phi
ID information for this module.
Definition: CreateMisalignAlg.h:127
CLHEP
STD'S.
Definition: IAtRndmGenSvc.h:19
InDetAlignment::CreateMisalignAlg::m_trtaligndbservice
ServiceHandle< ITRT_AlignDbSvc > m_trtaligndbservice
Definition: CreateMisalignAlg.h:71
InDetDD::StripStereoAnnulusDesign
Definition: StripStereoAnnulusDesign.h:50
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
InDetAlignment::CreateMisalignAlg::m_sctIdHelper
const SCT_ID * m_sctIdHelper
Definition: CreateMisalignAlg.h:67
InDetAlignment::CreateMisalignAlg::setupPixel_AlignModule
void setupPixel_AlignModule(int &)
Definition: CreateMisalignAlg.cxx:320
InDetAlignment::CreateMisalignAlg::m_rotation
bool m_rotation
Flag which turns on misalignment with rotation
Definition: CreateMisalignAlg.h:83
InDetAlignment::CreateMisalignAlg::m_AlignResults_x
NTuple::Item< double > m_AlignResults_x
Alignment parameter sensitive coordinate.
Definition: CreateMisalignAlg.h:117
InDetAlignment::CreateMisalignAlg::m_Misalign_x
Gaudi::Property< double > m_Misalign_x
Definition: CreateMisalignAlg.h:84
InDetAlignment::CreateMisalignAlg::m_RndmMisalignWidth_z
Gaudi::Property< double > m_RndmMisalignWidth_z
Definition: CreateMisalignAlg.h:92
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
InDetAlignment::CreateMisalignAlg::m_idHelper
const AtlasDetectorID * m_idHelper
Definition: CreateMisalignAlg.h:65
InDetAlignment::CreateMisalignAlg::initialize
StatusCode initialize()
standard Athena-Algorithm method
Definition: CreateMisalignAlg.cxx:134
InDetAlignment::CreateMisalignAlg::m_ScaleTRTEndcap
double m_ScaleTRTEndcap
Definition: CreateMisalignAlg.h:106
SCT_ID::wafer_hash
IdentifierHash wafer_hash(const Identifier &wafer_id) const
wafer hash from id - optimized
Definition: SCT_ID.h:492
python.SystemOfUnits.micrometer
int micrometer
Definition: SystemOfUnits.py:71
TRT_ID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: TRT_ID.h:866
TRT_ID::straw_layer
int straw_layer(const Identifier &id) const
Definition: TRT_ID.h:893
InDetAlignment::CreateMisalignAlg::m_ScaleSCTEndcap
double m_ScaleSCTEndcap
Definition: CreateMisalignAlg.h:104
TRT_ID::layer_or_wheel
int layer_or_wheel(const Identifier &id) const
Definition: TRT_ID.h:884
compareGeometries.deltaX
float deltaX
Definition: compareGeometries.py:32
ReadFromCoolCompare.os
os
Definition: ReadFromCoolCompare.py:231
InDetAlignment::CreateMisalignAlg::m_doPix
bool m_doPix
Definition: CreateMisalignAlg.h:158
IInDetAlignDBTool.h
AthAlgorithm
Definition: AthAlgorithm.h:47
ReadCondHandleKey.h
InDetAlignment::CreateMisalignAlg::m_pixelIdHelper
const PixelID * m_pixelIdHelper
Definition: CreateMisalignAlg.h:66
InDetAlignment::CreateMisalignAlg::m_doStrip
bool m_doStrip
Definition: CreateMisalignAlg.h:159
InDetAlignment::CreateMisalignAlg::m_translation
bool m_translation
Flag which turns on misalignment with translation.
Definition: CreateMisalignAlg.h:82
InDetAlignment::CreateMisalignAlg::m_IBLBowingTshift
double m_IBLBowingTshift
The relative temp shift of set point that intriduces bowing (sign is important)
Definition: CreateMisalignAlg.h:100
IOVTime::MAXEVENT
static constexpr uint32_t MAXEVENT
Definition: IOVTime.h:51
InDetAlignment::CreateMisalignAlg::m_ScalePixelBarrel
double m_ScalePixelBarrel
Definition: CreateMisalignAlg.h:101
CLHEPtoEigenConverter.h
PixelID::layer_disk
int layer_disk(const Identifier &id) const
Definition: PixelID.h:626
TRT_BaseElement.h
InDetAlignment::CreateMisalignAlg::setupTRT_AlignModule
void setupTRT_AlignModule(int &)
Definition: CreateMisalignAlg.cxx:372
PixelID::eta_module
int eta_module(const Identifier &id) const
Definition: PixelID.h:651
InDetDD::StripStereoAnnulusDesign::sensorCenter
virtual Amg::Vector3D sensorCenter() const override
Return the centre of a sensor in the local reference frame.
Definition: StripStereoAnnulusDesign.cxx:262
InDetAlignment::CreateMisalignAlg::m_Initial_center_x
NTuple::Item< double > m_Initial_center_x
Initial global center of module.
Definition: CreateMisalignAlg.h:130
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
InDetAlignment::CreateMisalignAlg::m_firstEvent
bool m_firstEvent
Flag for Setup of AlignModuleList (1st event)
Definition: CreateMisalignAlg.h:77
SCT_ID::layer_disk
int layer_disk(const Identifier &id) const
Definition: SCT_ID.h:734
InDetDD::SiDetectorElement
Definition: SiDetectorElement.h:109
InDetAlignment::CreateMisalignAlg::m_AlignResults_y
NTuple::Item< double > m_AlignResults_y
AP not-so-sensitive coordinate.
Definition: CreateMisalignAlg.h:118
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
InDetAlignment::CreateMisalignAlg::m_IDAlignDBTool
ToolHandle< IInDetAlignDBTool > m_IDAlignDBTool
Definition: CreateMisalignAlg.h:70
InDetAlignment::CreateMisalignAlg::m_ScalePixelIBL
double m_ScalePixelIBL
Definition: CreateMisalignAlg.h:98
InDetAlignment::CreateMisalignAlg::getBowingMagParam
double getBowingMagParam(double temp_shift)
Definition: CreateMisalignAlg.cxx:1087
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
TRT_ID::phi_module
int phi_module(const Identifier &id) const
Definition: TRT_ID.h:875
IOVTime::MINEVENT
static constexpr uint32_t MINEVENT
Definition: IOVTime.h:50
SiDetectorElement.h
InDetAlignment::CreateMisalignAlg::m_AlignResults_z
NTuple::Item< double > m_AlignResults_z
AP normal to module plane.
Definition: CreateMisalignAlg.h:119
InDetAlignment::CreateMisalignAlg::reduceTRTID
const Identifier reduceTRTID(Identifier id)
Definition: CreateMisalignAlg.cxx:1049
AlignableTransform.h
python.SystemOfUnits.mm
int mm
Definition: SystemOfUnits.py:83
PixelID::is_dbm
bool is_dbm(const Identifier &id) const
Test for dbm - WARNING: id MUST be pixel id, otherwise answer is not accurate. Use SiliconID for gene...
Definition: PixelID.h:612
StripStereoAnnulusDesign.h
InDetAlignment::CreateMisalignAlg::m_Global_center_y
NTuple::Item< double > m_Global_center_y
Misaligned global center of module.
Definition: CreateMisalignAlg.h:136
InDetAlignment::CreateMisalignAlg::m_Misalign_maxShift
double m_Misalign_maxShift
Maximum shift for global modes.
Definition: CreateMisalignAlg.h:96
InDetAlignment::CreateMisalignAlg::m_Initial_center_y
NTuple::Item< double > m_Initial_center_y
Initial global center of module.
Definition: CreateMisalignAlg.h:131
TRT_ID::is_barrel
bool is_barrel(const Identifier &id) const
Test for barrel.
Definition: TRT_ID.h:857
InDetAlignment::CreateMisalignAlg::m_SCTDetEleCollKey
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection > m_SCTDetEleCollKey
Definition: CreateMisalignAlg.h:163
InDetAlignment::CreateMisalignAlg::m_RndmMisalignWidth_alpha
Gaudi::Property< double > m_RndmMisalignWidth_alpha
Definition: CreateMisalignAlg.h:93
AtlasDetectorID::show_to_string
std::string show_to_string(Identifier id, const IdContext *context=0, char sep='.') const
or provide the printout in string form
Definition: AtlasDetectorID.cxx:350
CaloCondBlobAlgs_fillNoiseFromASCII.hash
dictionary hash
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:109
InDetAlignment::CreateMisalignAlg::m_nEvents
long int m_nEvents
Definition: CreateMisalignAlg.h:81
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
InDetAlignment::CreateMisalignAlg::m_Misalign_alpha
Gaudi::Property< double > m_Misalign_alpha
Definition: CreateMisalignAlg.h:87
Amg::CLHEPTransformToEigen
Amg::Transform3D CLHEPTransformToEigen(const HepGeom::Transform3D &CLHEPtransf)
Converts a CLHEP-based HepGeom::Transform3D into an Eigen Amg::Transform3D.
Definition: CLHEPtoEigenConverter.h:38
InDetAlignment::CreateMisalignAlg::m_Misalign_y
Gaudi::Property< double > m_Misalign_y
Definition: CreateMisalignAlg.h:85
InDetAlignment::CreateMisalignAlg::m_AlignResults_Identifier_PixelSCT
NTuple::Item< long > m_AlignResults_Identifier_PixelSCT
ID information for this module.
Definition: CreateMisalignAlg.h:124
DEBUG
#define DEBUG
Definition: page_access.h:11
SCT_ID::eta_module
int eta_module(const Identifier &id) const
Definition: SCT_ID.h:746
AthCommonMsg< Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
Amg::EigenTransformToCLHEP
HepGeom::Transform3D EigenTransformToCLHEP(const Amg::Transform3D &eigenTransf)
Converts an Eigen-based Amg::Transform3D into a CLHEP-based HepGeom::Transform3D.
Definition: CLHEPtoEigenConverter.h:120
InDetAlignment::CreateMisalignAlg::CreateMisalignAlg
CreateMisalignAlg(const std::string &name, ISvcLocator *pSvcLocator)
Standard Athena-Algorithm Constructor.
Definition: CreateMisalignAlg.cxx:71
InDetDD::TRT_DetElementContainer::getElements
const TRT_DetElementCollection * getElements() const
Definition: TRT_DetElementContainer.cxx:29
InDetAlignment::CreateMisalignAlg::execute
StatusCode execute()
standard Athena-Algorithm method
Definition: CreateMisalignAlg.cxx:222
SCT_ID::side
int side(const Identifier &id) const
Definition: SCT_ID.h:752
InDetAlignment::CreateMisalignAlg::m_Global_center_z
NTuple::Item< double > m_Global_center_z
Misaligned global center of module.
Definition: CreateMisalignAlg.h:137
InDetAlignment::CreateMisalignAlg::setupSCT_AlignModule
void setupSCT_AlignModule(int &)
Definition: CreateMisalignAlg.cxx:270
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:13
ITRT_AlignDbSvc.h
abstract interface to Service to manage TRT alignment conditions
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
InDetDD::TRT_DetElementCollection
Class to hold collection of TRT detector elements.
Definition: TRT_DetElementCollection.h:28
beamspotnt.nt
def nt
Definition: bin/beamspotnt.py:1063
InDetAlignment::CreateMisalignAlg::m_Misalign_maxShift_Inner
double m_Misalign_maxShift_Inner
Maximum shift of the Pixel B-layer in curl (d0 bias!)
Definition: CreateMisalignAlg.h:97
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
makeComparison.deltaZ
int deltaZ
Definition: makeComparison.py:46
MuonParameters::beta
@ beta
Definition: MuonParamDefs.h:144
InDetDD::SiDetectorElement::design
virtual const SiDetectorDesign & design() const override final
access to the local description (inline):
PixelID::phi_module
int phi_module(const Identifier &id) const
Definition: PixelID.h:644
InDetAlignment::CreateMisalignAlg::GenerateMisaligment
StatusCode GenerateMisaligment()
the main function which calculates and applies a transformation to each detector element
Definition: CreateMisalignAlg.cxx:441
ntupleSvc
INTupleSvc * ntupleSvc()
Definition: ServiceAccessor.h:14
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
InDetAlignment::CreateMisalignAlg::~CreateMisalignAlg
~CreateMisalignAlg()
Default Destructor.
Definition: CreateMisalignAlg.cxx:128
makeComparison.deltaR
float deltaR
Definition: makeComparison.py:36
InDetDD::SiDetectorElementCollection::getDetectorElement
const SiDetectorElement * getDetectorElement(const IdentifierHash &hash) const
Definition: SiDetectorElementCollection.cxx:15
InDetAlignment::CreateMisalignAlg::m_RndmMisalignWidth_x
Gaudi::Property< double > m_RndmMisalignWidth_x
Definition: CreateMisalignAlg.h:90
InDetAlignment::CreateMisalignAlg::m_AthenaHashedID
int m_AthenaHashedID
Definition: CreateMisalignAlg.h:114
TRTCalib_cfilter.p0
p0
Definition: TRTCalib_cfilter.py:129
InDetDD::TRT_BaseElement
Definition: TRT_BaseElement.h:52
TRT_ID::module_id
Identifier module_id(int barrel_ec, int phi_module, int layer_or_wheel) const
For an individual module phi sector.
Definition: TRT_ID.h:448
SCT_ID::is_barrel
bool is_barrel(const Identifier &id) const
Test for barrel - WARNING: id MUST be sct id, otherwise answer is not accurate. Use SiliconID for gen...
Definition: SCT_ID.h:721
InDetAlignment::CreateMisalignAlg::m_MisalignmentMode
int m_MisalignmentMode
Flag which Misalignment mode is to be generated.
Definition: CreateMisalignAlg.h:80
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Sat Apr 5 2025 21:09:04 for ATLAS Offline Software by   doxygen 1.8.18