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

#include <CreateMisalignAlg.h>

Inheritance diagram for InDetAlignment::CreateMisalignAlg:
Collaboration diagram for InDetAlignment::CreateMisalignAlg:

Public Member Functions

 CreateMisalignAlg (const std::string &name, ISvcLocator *pSvcLocator)
 Standard Athena-Algorithm Constructor. More...
 
 ~CreateMisalignAlg ()
 Default Destructor. More...
 
StatusCode initialize ()
 standard Athena-Algorithm method More...
 
StatusCode execute ()
 standard Athena-Algorithm method More...
 
StatusCode finalize ()
 standard Athena-Algorithm method More...
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

void setupSCT_AlignModule (int &)
 
void setupPixel_AlignModule (int &)
 
void setupTRT_AlignModule (int &)
 
const HepGeom::Transform3D BuildAlignTransform (const CLHEP::HepVector &)
 builds a HepGeom::Transform3D from the 6 Alignment Parameters More...
 
const Identifier reduceTRTID (Identifier id)
 
const Identifier reduceTRTID (IdentifierHash &hash)
 
double getBowingMagParam (double temp_shift)
 
double getBowingTx (double p1, double z)
 
StatusCode GenerateMisaligment ()
 the main function which calculates and applies a transformation to each detector element More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

const AtlasDetectorID * m_idHelper
 
const PixelID * m_pixelIdHelper
 
const SCT_ID * m_sctIdHelper
 
const TRT_ID * m_trtIdHelper
 
ToolHandle< IInDetAlignDBTool > m_IDAlignDBTool
 
ServiceHandle< ITRT_AlignDbSvc > m_trtaligndbservice
 
std::string m_asciiFileNameBase
 filename basis for ASCII files with alignment constants More...
 
std::string m_SQLiteTag
 tag name for the ConditionsDB More...
 
bool m_firstEvent
 Flag for Setup of AlignModuleList (1st event) More...
 
bool m_createFreshDB
 Flag to call the createDB method of DBTool (to be switched off when adding misalignments to a given geometry) More...
 
int m_MisalignmentMode
 Flag which Misalignment mode is to be generated. More...
 
long int m_nEvents
 
bool m_translation
 Flag which turns on misalignment with translation. More...
 
bool m_rotation
 Flag which turns on misalignment with rotation
More...
 
Gaudi::Property< double > m_Misalign_x {this,"MisalignmentX",0.0,"Fixed X shift (mode 1 and 2)"}
 
Gaudi::Property< double > m_Misalign_y {this,"MisalignmentY",0.0,"Fixed Y shif (model 1 and 2)"}
 
Gaudi::Property< double > m_Misalign_z {this,"MisalignmentZ",0.0,"Fixed Z shift (mode 1 and 2)"}
 
Gaudi::Property< double > m_Misalign_alpha {this,"MisalignmentAlpha",0.0,"Fixed Alpha shift (model 1 and 2)"}
 
Gaudi::Property< double > m_Misalign_beta {this,"MisalignmentBeta",0.0,"Fixed Beta shift (mode 1 and 2)"}
 
Gaudi::Property< double > m_Misalign_gamma {this,"MisalignmentGamma",0.0,"Fixed Gamma shift (model 1 and 2)"}
 
Gaudi::Property< double > m_RndmMisalignWidth_x {this,"RandomMisalignmentWidthX",0.1,"Gaussian width of X random misalignments (mode 2)"}
 
Gaudi::Property< double > m_RndmMisalignWidth_y {this,"RandomMisalignmentWidthY",0.1,"Gaussian width of Y random misalignments (mode 2)"}
 
Gaudi::Property< double > m_RndmMisalignWidth_z {this,"RandomMisalignmentWidthZ",0.1,"Gaussian width of Z random misalignments (mode 2)"}
 
Gaudi::Property< double > m_RndmMisalignWidth_alpha {this,"RandomMisalignmentWidthAplha",0.1,"Gaussian width of Alpha random misalignments (mode 2)"}
 
Gaudi::Property< double > m_RndmMisalignWidth_beta {this,"RandomMisalignmentWidthBeta",0.1,"Gaussian width of Beta random misalignments (mode 2)"}
 
Gaudi::Property< double > m_RndmMisalignWidth_gamma {this,"RandomMisalignmentWidthGamma",0.1,"Gaussian width of Gamma random misalignments (mode 2)"}
 
double m_Misalign_maxShift
 Maximum shift for global modes. More...
 
double m_Misalign_maxShift_Inner
 Maximum shift of the Pixel B-layer in curl (d0 bias!) More...
 
double m_ScalePixelIBL
 
double m_ScalePixelDBM
 
double m_IBLBowingTshift
 The relative temp shift of set point that intriduces bowing (sign is important) More...
 
double m_ScalePixelBarrel
 
double m_ScalePixelEndcap
 
double m_ScaleSCTBarrel
 
double m_ScaleSCTEndcap
 
double m_ScaleTRTBarrel
 
double m_ScaleTRTEndcap
 
std::map< Identifier, HepGeom::Point3D< double > > m_ModuleList
 map of all SiIdentifiers to be misaligned and their centerpoints in global coordinates More...
 
TTree * m_VisualizationLookupTree
 
int m_AthenaHashedID
 
int m_HumanReadableID
 
NTuple::Item< double > m_AlignResults_x
 Alignment parameter sensitive coordinate. More...
 
NTuple::Item< double > m_AlignResults_y
 AP not-so-sensitive coordinate. More...
 
NTuple::Item< double > m_AlignResults_z
 AP normal to module plane. More...
 
NTuple::Item< double > m_AlignResults_alpha
 AP rotation around x-axis. More...
 
NTuple::Item< double > m_AlignResults_beta
 AP rotation aorund y-axis. More...
 
NTuple::Item< double > m_AlignResults_gamma
 AP rotation around z-axis. More...
 
NTuple::Item< long > m_AlignResults_Identifier_ID
 ID information for this module. More...
 
NTuple::Item< long > m_AlignResults_Identifier_PixelSCT
 ID information for this module. More...
 
NTuple::Item< long > m_AlignResults_Identifier_BarrelEC
 ID information for this module. More...
 
NTuple::Item< long > m_AlignResults_Identifier_LayerDisc
 ID information for this module. More...
 
NTuple::Item< long > m_AlignResults_Identifier_Phi
 ID information for this module. More...
 
NTuple::Item< long > m_AlignResults_Identifier_Eta
 ID information for this module. More...
 
NTuple::Item< double > m_Initial_center_x
 Initial global center of module. More...
 
NTuple::Item< double > m_Initial_center_y
 Initial global center of module. More...
 
NTuple::Item< double > m_Initial_center_z
 Initial global center of module. More...
 
NTuple::Item< double > m_Global_center_x
 Misaligned global center of module. More...
 
NTuple::Item< double > m_Global_center_y
 Misaligned global center of module. More...
 
NTuple::Item< double > m_Global_center_z
 Misaligned global center of module. More...
 
bool m_doPix
 
bool m_doStrip
 
bool m_doTRT
 
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection > m_pixelDetEleCollKey {this, "PixelDetEleCollKey", "PixelDetectorElementCollection", "Key of SiDetectorElementCollection for Pixel"}
 
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection > m_SCTDetEleCollKey {this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"}
 
SG::ReadCondHandleKey< InDetDD::TRT_DetElementContainer > m_trtDetEleCollKey {this, "TRTDetEleCollKey", "TRT_DetElementContainer", "Key of TRT_DetElementContainer for TRT"}
 
DataObjIDColl m_extendedExtraObjects
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 46 of file CreateMisalignAlg.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ CreateMisalignAlg()

InDetAlignment::CreateMisalignAlg::CreateMisalignAlg ( const std::string &  name,
ISvcLocator *  pSvcLocator 
)

Standard Athena-Algorithm Constructor.

Definition at line 71 of file CreateMisalignAlg.cxx.

71  :
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  }

◆ ~CreateMisalignAlg()

InDetAlignment::CreateMisalignAlg::~CreateMisalignAlg ( )

Default Destructor.

Definition at line 128 of file CreateMisalignAlg.cxx.

129  {
130  ATH_MSG_DEBUG( "CreateMisalignAlg destructor called" );
131  }

Member Function Documentation

◆ BuildAlignTransform()

const HepGeom::Transform3D InDetAlignment::CreateMisalignAlg::BuildAlignTransform ( const CLHEP::HepVector &  AlignParams)
private

builds a HepGeom::Transform3D from the 6 Alignment Parameters

Definition at line 1037 of file CreateMisalignAlg.cxx.

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  }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode InDetAlignment::CreateMisalignAlg::execute ( )

standard Athena-Algorithm method

Definition at line 222 of file CreateMisalignAlg.cxx.

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  }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

51 {
52  // If we didn't find any symlinks to add, just return the collection
53  // from the base class. Otherwise, return the extended collection.
54  if (!m_extendedExtraObjects.empty()) {
55  return m_extendedExtraObjects;
56  }
57  return Algorithm::extraOutputDeps();
58 }

◆ finalize()

StatusCode InDetAlignment::CreateMisalignAlg::finalize ( )

standard Athena-Algorithm method

Definition at line 260 of file CreateMisalignAlg.cxx.

261  {
262  ATH_MSG_DEBUG("CreateMisalignAlg finalize()" );
263 
264  m_ModuleList.clear();
265 
266  return StatusCode::SUCCESS;
267  }

◆ GenerateMisaligment()

StatusCode InDetAlignment::CreateMisalignAlg::GenerateMisaligment ( )
private

the main function which calculates and applies a transformation to each detector element

Definition at line 441 of file CreateMisalignAlg.cxx.

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  }

◆ getBowingMagParam()

double InDetAlignment::CreateMisalignAlg::getBowingMagParam ( double  temp_shift)
private

Definition at line 1087 of file CreateMisalignAlg.cxx.

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  }

◆ getBowingTx()

double InDetAlignment::CreateMisalignAlg::getBowingTx ( double  p1,
double  z 
)
private

Definition at line 1096 of file CreateMisalignAlg.cxx.

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  }

◆ initialize()

StatusCode InDetAlignment::CreateMisalignAlg::initialize ( )

standard Athena-Algorithm method

Definition at line 134 of file CreateMisalignAlg.cxx.

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  }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ msg() [1/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ reduceTRTID() [1/2]

const Identifier InDetAlignment::CreateMisalignAlg::reduceTRTID ( Identifier  id)
private

Definition at line 1049 of file CreateMisalignAlg.cxx.

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  }

◆ reduceTRTID() [2/2]

const Identifier InDetAlignment::CreateMisalignAlg::reduceTRTID ( IdentifierHash &  hash)
private

Definition at line 1080 of file CreateMisalignAlg.cxx.

1081  {
1082  Identifier id= m_trtIdHelper->module_id(hash);
1083  return reduceTRTID(id);
1084  }

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ setupPixel_AlignModule()

void InDetAlignment::CreateMisalignAlg::setupPixel_AlignModule ( int &  nPixel)
private

Definition at line 320 of file CreateMisalignAlg.cxx.

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  }

◆ setupSCT_AlignModule()

void InDetAlignment::CreateMisalignAlg::setupSCT_AlignModule ( int &  nSCT)
private

Definition at line 270 of file CreateMisalignAlg.cxx.

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  }

◆ setupTRT_AlignModule()

void InDetAlignment::CreateMisalignAlg::setupTRT_AlignModule ( int &  nTRT)
private

Definition at line 372 of file CreateMisalignAlg.cxx.

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  }

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, PyAthena::Alg, and AthHistogramAlgorithm.

Definition at line 66 of file AthAlgorithm.cxx.

66  {
67  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
68 
69  if (sc.isFailure()) {
70  return sc;
71  }
72  ServiceHandle<ICondSvc> cs("CondSvc",name());
73  for (auto h : outputHandles()) {
74  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
75  // do this inside the loop so we don't create the CondSvc until needed
76  if ( cs.retrieve().isFailure() ) {
77  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
78  return StatusCode::SUCCESS;
79  }
80  if (cs->regHandle(this,*h).isFailure()) {
81  sc = StatusCode::FAILURE;
82  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
83  << " with CondSvc");
84  }
85  }
86  }
87  return sc;
88 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_AlignResults_alpha

NTuple::Item<double> InDetAlignment::CreateMisalignAlg::m_AlignResults_alpha
private

AP rotation around x-axis.

Definition at line 120 of file CreateMisalignAlg.h.

◆ m_AlignResults_beta

NTuple::Item<double> InDetAlignment::CreateMisalignAlg::m_AlignResults_beta
private

AP rotation aorund y-axis.

Definition at line 121 of file CreateMisalignAlg.h.

◆ m_AlignResults_gamma

NTuple::Item<double> InDetAlignment::CreateMisalignAlg::m_AlignResults_gamma
private

AP rotation around z-axis.

Definition at line 122 of file CreateMisalignAlg.h.

◆ m_AlignResults_Identifier_BarrelEC

NTuple::Item<long> InDetAlignment::CreateMisalignAlg::m_AlignResults_Identifier_BarrelEC
private

ID information for this module.

Definition at line 125 of file CreateMisalignAlg.h.

◆ m_AlignResults_Identifier_Eta

NTuple::Item<long> InDetAlignment::CreateMisalignAlg::m_AlignResults_Identifier_Eta
private

ID information for this module.

Definition at line 128 of file CreateMisalignAlg.h.

◆ m_AlignResults_Identifier_ID

NTuple::Item<long> InDetAlignment::CreateMisalignAlg::m_AlignResults_Identifier_ID
private

ID information for this module.

Definition at line 123 of file CreateMisalignAlg.h.

◆ m_AlignResults_Identifier_LayerDisc

NTuple::Item<long> InDetAlignment::CreateMisalignAlg::m_AlignResults_Identifier_LayerDisc
private

ID information for this module.

Definition at line 126 of file CreateMisalignAlg.h.

◆ m_AlignResults_Identifier_Phi

NTuple::Item<long> InDetAlignment::CreateMisalignAlg::m_AlignResults_Identifier_Phi
private

ID information for this module.

Definition at line 127 of file CreateMisalignAlg.h.

◆ m_AlignResults_Identifier_PixelSCT

NTuple::Item<long> InDetAlignment::CreateMisalignAlg::m_AlignResults_Identifier_PixelSCT
private

ID information for this module.

Definition at line 124 of file CreateMisalignAlg.h.

◆ m_AlignResults_x

NTuple::Item<double> InDetAlignment::CreateMisalignAlg::m_AlignResults_x
private

Alignment parameter sensitive coordinate.

Definition at line 117 of file CreateMisalignAlg.h.

◆ m_AlignResults_y

NTuple::Item<double> InDetAlignment::CreateMisalignAlg::m_AlignResults_y
private

AP not-so-sensitive coordinate.

Definition at line 118 of file CreateMisalignAlg.h.

◆ m_AlignResults_z

NTuple::Item<double> InDetAlignment::CreateMisalignAlg::m_AlignResults_z
private

AP normal to module plane.

Definition at line 119 of file CreateMisalignAlg.h.

◆ m_asciiFileNameBase

std::string InDetAlignment::CreateMisalignAlg::m_asciiFileNameBase
private

filename basis for ASCII files with alignment constants

Definition at line 74 of file CreateMisalignAlg.h.

◆ m_AthenaHashedID

int InDetAlignment::CreateMisalignAlg::m_AthenaHashedID
private

Definition at line 114 of file CreateMisalignAlg.h.

◆ m_createFreshDB

bool InDetAlignment::CreateMisalignAlg::m_createFreshDB
private

Flag to call the createDB method of DBTool (to be switched off when adding misalignments to a given geometry)

Definition at line 78 of file CreateMisalignAlg.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_doPix

bool InDetAlignment::CreateMisalignAlg::m_doPix
private

Definition at line 158 of file CreateMisalignAlg.h.

◆ m_doStrip

bool InDetAlignment::CreateMisalignAlg::m_doStrip
private

Definition at line 159 of file CreateMisalignAlg.h.

◆ m_doTRT

bool InDetAlignment::CreateMisalignAlg::m_doTRT
private

Definition at line 160 of file CreateMisalignAlg.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_firstEvent

bool InDetAlignment::CreateMisalignAlg::m_firstEvent
private

Flag for Setup of AlignModuleList (1st event)

Definition at line 77 of file CreateMisalignAlg.h.

◆ m_Global_center_x

NTuple::Item<double> InDetAlignment::CreateMisalignAlg::m_Global_center_x
private

Misaligned global center of module.

Definition at line 135 of file CreateMisalignAlg.h.

◆ m_Global_center_y

NTuple::Item<double> InDetAlignment::CreateMisalignAlg::m_Global_center_y
private

Misaligned global center of module.

Definition at line 136 of file CreateMisalignAlg.h.

◆ m_Global_center_z

NTuple::Item<double> InDetAlignment::CreateMisalignAlg::m_Global_center_z
private

Misaligned global center of module.

Definition at line 137 of file CreateMisalignAlg.h.

◆ m_HumanReadableID

int InDetAlignment::CreateMisalignAlg::m_HumanReadableID
private

Definition at line 115 of file CreateMisalignAlg.h.

◆ m_IBLBowingTshift

double InDetAlignment::CreateMisalignAlg::m_IBLBowingTshift
private

The relative temp shift of set point that intriduces bowing (sign is important)

Definition at line 100 of file CreateMisalignAlg.h.

◆ m_IDAlignDBTool

ToolHandle< IInDetAlignDBTool > InDetAlignment::CreateMisalignAlg::m_IDAlignDBTool
private

Definition at line 70 of file CreateMisalignAlg.h.

◆ m_idHelper

const AtlasDetectorID* InDetAlignment::CreateMisalignAlg::m_idHelper
private

Definition at line 65 of file CreateMisalignAlg.h.

◆ m_Initial_center_x

NTuple::Item<double> InDetAlignment::CreateMisalignAlg::m_Initial_center_x
private

Initial global center of module.

Definition at line 130 of file CreateMisalignAlg.h.

◆ m_Initial_center_y

NTuple::Item<double> InDetAlignment::CreateMisalignAlg::m_Initial_center_y
private

Initial global center of module.

Definition at line 131 of file CreateMisalignAlg.h.

◆ m_Initial_center_z

NTuple::Item<double> InDetAlignment::CreateMisalignAlg::m_Initial_center_z
private

Initial global center of module.

Definition at line 132 of file CreateMisalignAlg.h.

◆ m_Misalign_alpha

Gaudi::Property<double> InDetAlignment::CreateMisalignAlg::m_Misalign_alpha {this,"MisalignmentAlpha",0.0,"Fixed Alpha shift (model 1 and 2)"}
private

Definition at line 87 of file CreateMisalignAlg.h.

◆ m_Misalign_beta

Gaudi::Property<double> InDetAlignment::CreateMisalignAlg::m_Misalign_beta {this,"MisalignmentBeta",0.0,"Fixed Beta shift (mode 1 and 2)"}
private

Definition at line 88 of file CreateMisalignAlg.h.

◆ m_Misalign_gamma

Gaudi::Property<double> InDetAlignment::CreateMisalignAlg::m_Misalign_gamma {this,"MisalignmentGamma",0.0,"Fixed Gamma shift (model 1 and 2)"}
private

Definition at line 89 of file CreateMisalignAlg.h.

◆ m_Misalign_maxShift

double InDetAlignment::CreateMisalignAlg::m_Misalign_maxShift
private

Maximum shift for global modes.

Definition at line 96 of file CreateMisalignAlg.h.

◆ m_Misalign_maxShift_Inner

double InDetAlignment::CreateMisalignAlg::m_Misalign_maxShift_Inner
private

Maximum shift of the Pixel B-layer in curl (d0 bias!)

Definition at line 97 of file CreateMisalignAlg.h.

◆ m_Misalign_x

Gaudi::Property<double> InDetAlignment::CreateMisalignAlg::m_Misalign_x {this,"MisalignmentX",0.0,"Fixed X shift (mode 1 and 2)"}
private

Definition at line 84 of file CreateMisalignAlg.h.

◆ m_Misalign_y

Gaudi::Property<double> InDetAlignment::CreateMisalignAlg::m_Misalign_y {this,"MisalignmentY",0.0,"Fixed Y shif (model 1 and 2)"}
private

Definition at line 85 of file CreateMisalignAlg.h.

◆ m_Misalign_z

Gaudi::Property<double> InDetAlignment::CreateMisalignAlg::m_Misalign_z {this,"MisalignmentZ",0.0,"Fixed Z shift (mode 1 and 2)"}
private

Definition at line 86 of file CreateMisalignAlg.h.

◆ m_MisalignmentMode

int InDetAlignment::CreateMisalignAlg::m_MisalignmentMode
private

Flag which Misalignment mode is to be generated.

Definition at line 80 of file CreateMisalignAlg.h.

◆ m_ModuleList

std::map<Identifier, HepGeom::Point3D<double> > InDetAlignment::CreateMisalignAlg::m_ModuleList
private

map of all SiIdentifiers to be misaligned and their centerpoints in global coordinates

Definition at line 109 of file CreateMisalignAlg.h.

◆ m_nEvents

long int InDetAlignment::CreateMisalignAlg::m_nEvents
private

Definition at line 81 of file CreateMisalignAlg.h.

◆ m_pixelDetEleCollKey

SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> InDetAlignment::CreateMisalignAlg::m_pixelDetEleCollKey {this, "PixelDetEleCollKey", "PixelDetectorElementCollection", "Key of SiDetectorElementCollection for Pixel"}
private

Definition at line 162 of file CreateMisalignAlg.h.

◆ m_pixelIdHelper

const PixelID* InDetAlignment::CreateMisalignAlg::m_pixelIdHelper
private

Definition at line 66 of file CreateMisalignAlg.h.

◆ m_RndmMisalignWidth_alpha

Gaudi::Property<double> InDetAlignment::CreateMisalignAlg::m_RndmMisalignWidth_alpha {this,"RandomMisalignmentWidthAplha",0.1,"Gaussian width of Alpha random misalignments (mode 2)"}
private

Definition at line 93 of file CreateMisalignAlg.h.

◆ m_RndmMisalignWidth_beta

Gaudi::Property<double> InDetAlignment::CreateMisalignAlg::m_RndmMisalignWidth_beta {this,"RandomMisalignmentWidthBeta",0.1,"Gaussian width of Beta random misalignments (mode 2)"}
private

Definition at line 94 of file CreateMisalignAlg.h.

◆ m_RndmMisalignWidth_gamma

Gaudi::Property<double> InDetAlignment::CreateMisalignAlg::m_RndmMisalignWidth_gamma {this,"RandomMisalignmentWidthGamma",0.1,"Gaussian width of Gamma random misalignments (mode 2)"}
private

Definition at line 95 of file CreateMisalignAlg.h.

◆ m_RndmMisalignWidth_x

Gaudi::Property<double> InDetAlignment::CreateMisalignAlg::m_RndmMisalignWidth_x {this,"RandomMisalignmentWidthX",0.1,"Gaussian width of X random misalignments (mode 2)"}
private

Definition at line 90 of file CreateMisalignAlg.h.

◆ m_RndmMisalignWidth_y

Gaudi::Property<double> InDetAlignment::CreateMisalignAlg::m_RndmMisalignWidth_y {this,"RandomMisalignmentWidthY",0.1,"Gaussian width of Y random misalignments (mode 2)"}
private

Definition at line 91 of file CreateMisalignAlg.h.

◆ m_RndmMisalignWidth_z

Gaudi::Property<double> InDetAlignment::CreateMisalignAlg::m_RndmMisalignWidth_z {this,"RandomMisalignmentWidthZ",0.1,"Gaussian width of Z random misalignments (mode 2)"}
private

Definition at line 92 of file CreateMisalignAlg.h.

◆ m_rotation

bool InDetAlignment::CreateMisalignAlg::m_rotation
private

Flag which turns on misalignment with rotation

Definition at line 83 of file CreateMisalignAlg.h.

◆ m_ScalePixelBarrel

double InDetAlignment::CreateMisalignAlg::m_ScalePixelBarrel
private

Definition at line 101 of file CreateMisalignAlg.h.

◆ m_ScalePixelDBM

double InDetAlignment::CreateMisalignAlg::m_ScalePixelDBM
private

Definition at line 99 of file CreateMisalignAlg.h.

◆ m_ScalePixelEndcap

double InDetAlignment::CreateMisalignAlg::m_ScalePixelEndcap
private

Definition at line 102 of file CreateMisalignAlg.h.

◆ m_ScalePixelIBL

double InDetAlignment::CreateMisalignAlg::m_ScalePixelIBL
private

Definition at line 98 of file CreateMisalignAlg.h.

◆ m_ScaleSCTBarrel

double InDetAlignment::CreateMisalignAlg::m_ScaleSCTBarrel
private

Definition at line 103 of file CreateMisalignAlg.h.

◆ m_ScaleSCTEndcap

double InDetAlignment::CreateMisalignAlg::m_ScaleSCTEndcap
private

Definition at line 104 of file CreateMisalignAlg.h.

◆ m_ScaleTRTBarrel

double InDetAlignment::CreateMisalignAlg::m_ScaleTRTBarrel
private

Definition at line 105 of file CreateMisalignAlg.h.

◆ m_ScaleTRTEndcap

double InDetAlignment::CreateMisalignAlg::m_ScaleTRTEndcap
private

Definition at line 106 of file CreateMisalignAlg.h.

◆ m_SCTDetEleCollKey

SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> InDetAlignment::CreateMisalignAlg::m_SCTDetEleCollKey {this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"}
private

Definition at line 163 of file CreateMisalignAlg.h.

◆ m_sctIdHelper

const SCT_ID* InDetAlignment::CreateMisalignAlg::m_sctIdHelper
private

Definition at line 67 of file CreateMisalignAlg.h.

◆ m_SQLiteTag

std::string InDetAlignment::CreateMisalignAlg::m_SQLiteTag
private

tag name for the ConditionsDB

Definition at line 75 of file CreateMisalignAlg.h.

◆ m_translation

bool InDetAlignment::CreateMisalignAlg::m_translation
private

Flag which turns on misalignment with translation.

Definition at line 82 of file CreateMisalignAlg.h.

◆ m_trtaligndbservice

ServiceHandle<ITRT_AlignDbSvc> InDetAlignment::CreateMisalignAlg::m_trtaligndbservice
private

Definition at line 71 of file CreateMisalignAlg.h.

◆ m_trtDetEleCollKey

SG::ReadCondHandleKey<InDetDD::TRT_DetElementContainer> InDetAlignment::CreateMisalignAlg::m_trtDetEleCollKey {this, "TRTDetEleCollKey", "TRT_DetElementContainer", "Key of TRT_DetElementContainer for TRT"}
private

Definition at line 164 of file CreateMisalignAlg.h.

◆ m_trtIdHelper

const TRT_ID* InDetAlignment::CreateMisalignAlg::m_trtIdHelper
private

Definition at line 68 of file CreateMisalignAlg.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_VisualizationLookupTree

TTree* InDetAlignment::CreateMisalignAlg::m_VisualizationLookupTree
private

Definition at line 112 of file CreateMisalignAlg.h.

The documentation for this class was generated from the following files:
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
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
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
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
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
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::CreateMisalignAlg::m_Misalign_beta
Gaudi::Property< double > m_Misalign_beta
Definition: CreateMisalignAlg.h:88
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
Identifier::get_identifier32
Identifier32 get_identifier32() const
Get the 32-bit version Identifier, will be invalid if >32 bits needed.
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
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
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
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
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
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
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IOVTime::MINRUN
static constexpr uint32_t MINRUN
Definition: IOVTime.h:44
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
xAOD::phi
setEt phi
Definition: TrigEMCluster_v1.cxx:29
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
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
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
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
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
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
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::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
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
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
InDetAlignment::CreateMisalignAlg::m_doPix
bool m_doPix
Definition: CreateMisalignAlg.h:158
InDetAlignment::CreateMisalignAlg::m_pixelIdHelper
const PixelID * m_pixelIdHelper
Definition: CreateMisalignAlg.h:66
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
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
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
InDetAlignment::CreateMisalignAlg::m_ScalePixelBarrel
double m_ScalePixelBarrel
Definition: CreateMisalignAlg.h:101
PixelID::layer_disk
int layer_disk(const Identifier &id) const
Definition: PixelID.h:626
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
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
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
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
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
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
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
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
a
TList * a
Definition: liststreamerinfos.cxx:10
h
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
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
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
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
InDetAlignment::CreateMisalignAlg::setupSCT_AlignModule
void setupSCT_AlignModule(int &)
Definition: CreateMisalignAlg.cxx:270
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:13
InDetDD::TRT_DetElementCollection
Class to hold collection of TRT detector elements.
Definition: TRT_DetElementCollection.h:28
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
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
makeComparison.deltaR
float deltaR
Definition: makeComparison.py:36
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
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
TSU::T
unsigned long long T
Definition: L1TopoDataTypes.h:35
InDetAlignment::CreateMisalignAlg::m_AthenaHashedID
int m_AthenaHashedID
Definition: CreateMisalignAlg.h:114
TRTCalib_cfilter.p0
p0
Definition: TRTCalib_cfilter.py:129
fitman.k
k
Definition: fitman.py:528
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
ServiceHandle< ICondSvc >
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 Sun Apr 13 2025 21:58:25 for ATLAS Offline Software by   doxygen 1.8.18