ATLAS Offline Software
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, V, H > &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, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &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
 
std::vector< double > m_translation
 Flag which turns on misalignment with translation. More...
 
std::vector< double > m_rotation
 Flag which turns on misalignment with rotation. More...
 
std::vector< double > m_local_translation
 Specify misalignment with translation. More...
 
std::vector< double > m_local_rotation
 Specify misalignment with rotation. More...
 
std::string m_index
 Generate misalignment according to module indices. 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 72 of file CreateMisalignAlg.cxx.

72  :
73  AthAlgorithm(name,pSvcLocator),
74  m_idHelper(nullptr),
75  m_pixelIdHelper(nullptr),
76  m_sctIdHelper(nullptr),
77  m_trtIdHelper(nullptr),
78  m_IDAlignDBTool("InDetAlignDBTool",this),
79  m_trtaligndbservice("TRT_AlignDbSvc",name),
80  m_asciiFileNameBase("MisalignmentSet"),
81  m_SQLiteTag("test_tag"),
82  m_firstEvent(true),
83  m_createFreshDB(true),
84  m_MisalignmentMode(0),
85  m_nEvents(0),
86  m_translation{0.1, 0.1, 0.1},
87  m_rotation{0.1, 0.1, 0.1},
88  m_local_translation{0., 0., 0.},
89  m_local_rotation{0., 0., 0.},
90  m_index(""),
91  m_Misalign_maxShift(1*CLHEP::mm),
92  m_Misalign_maxShift_Inner(50*CLHEP::micrometer),
93  m_ScalePixelIBL(1.),
94  m_ScalePixelDBM(1.),
95  m_IBLBowingTshift(0.),
96  m_ScalePixelBarrel(1.),
97  m_ScalePixelEndcap(1.),
98  m_ScaleSCTBarrel(1.),
99  m_ScaleSCTEndcap(1.),
100  m_ScaleTRTBarrel(1.),
101  m_ScaleTRTEndcap(1.),
102  m_VisualizationLookupTree(nullptr),
103  m_AthenaHashedID(-1),
104  m_HumanReadableID(-1),
105  m_doPix(true),
106  m_doStrip(true),
107  m_doTRT(true)
108  {
109  declareProperty("ASCIIFilenameBase" , m_asciiFileNameBase);
110  declareProperty("SQLiteTag" , m_SQLiteTag);
111  declareProperty("MisalignMode" , m_MisalignmentMode);
112  declareProperty("Translation_Scale" , m_translation);
113  declareProperty("Rotation_Scale" , m_rotation);
114  declareProperty("Local_Translation" , m_local_translation);
115  declareProperty("Local_Rotation" , m_local_rotation);
116  declareProperty("Index" , m_index);
117  declareProperty("MaxShift" , m_Misalign_maxShift);
118  declareProperty("MaxShiftInner" , m_Misalign_maxShift_Inner);
119  declareProperty("CreateFreshDB" , m_createFreshDB);
120  declareProperty("IDAlignDBTool" , m_IDAlignDBTool);
121  declareProperty("TRTAlignDBService" , m_trtaligndbservice);
122  declareProperty("ScalePixelIBL" , m_ScalePixelIBL);
123  declareProperty("ScalePixelDBM" , m_ScalePixelDBM);
124  declareProperty("IBLBowingTshift" , m_IBLBowingTshift);
125  declareProperty("ScalePixelBarrel" , m_ScalePixelBarrel);
126  declareProperty("ScalePixelEndcap" , m_ScalePixelEndcap);
127  declareProperty("ScaleSCTBarrel" , m_ScaleSCTBarrel);
128  declareProperty("ScaleSCTEndcap" , m_ScaleSCTEndcap);
129  declareProperty("ScaleTRTBarrel" , m_ScaleTRTBarrel);
130  declareProperty("ScaleTRTEndcap" , m_ScaleTRTEndcap);
131  }

◆ ~CreateMisalignAlg()

InDetAlignment::CreateMisalignAlg::~CreateMisalignAlg ( )

Default Destructor.

Definition at line 135 of file CreateMisalignAlg.cxx.

136  {
137  ATH_MSG_DEBUG( "CreateMisalignAlg destructor called" );
138  }

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 1062 of file CreateMisalignAlg.cxx.

1063  {
1064  HepGeom::Vector3D<double> AlignShift(AlignParams[0],AlignParams[1],AlignParams[2]);
1065  CLHEP::HepRotation AlignRot;
1066 
1067  AlignRot = CLHEP::HepRotationX(AlignParams[3]) * CLHEP::HepRotationY(AlignParams[4]) * CLHEP::HepRotationZ(AlignParams[5]);
1068 
1069  HepGeom::Transform3D AlignTransform = HepGeom::Transform3D(AlignRot,AlignShift);
1070  return AlignTransform;
1071  }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  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, V, H > &  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, V, H > &  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, V, H > &  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, V, H > &  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 229 of file CreateMisalignAlg.cxx.

230  {
231  ATH_MSG_DEBUG( "AlignAlg execute()" );
232  ++m_nEvents;
233 
234  if (m_firstEvent) {
235  int nSCT = 0;
236  int nPixel = 0;
237  int nTRT = 0;
238 
239  if (m_createFreshDB) {
240  m_IDAlignDBTool->createDB();
241  //m_trtaligndbservice->createAlignObjects(); //create DB for TRT? should be ok... //TODO
242  }
243 
244  if(m_doPix) setupPixel_AlignModule(nPixel);
245  if(m_doStrip) setupSCT_AlignModule(nSCT);
246  if(m_doTRT) setupTRT_AlignModule(nTRT);
247 
248  ATH_MSG_INFO( "Back from AlignModuleObject Setup. " );
249  ATH_MSG_INFO( nPixel << " Pixel modules found." );
250  ATH_MSG_INFO( nSCT << " SCT modules found," );
251  ATH_MSG_INFO( nTRT << " TRT modules found." );
252 
253  ATH_MSG_INFO( m_ModuleList.size() << " entries in identifier list" );
254 
255  if (StatusCode::SUCCESS!=GenerateMisaligment()) {
256  ATH_MSG_ERROR( "GenerateMisalignment failed!" );
257  return StatusCode::FAILURE;
258  };
259 
260  m_firstEvent = false;
261  }
262 
263  return StatusCode::SUCCESS;
264  }

◆ 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 267 of file CreateMisalignAlg.cxx.

268  {
269  ATH_MSG_DEBUG("CreateMisalignAlg finalize()" );
270 
271  m_ModuleList.clear();
272 
273  return StatusCode::SUCCESS;
274  }

◆ GenerateMisaligment()

StatusCode InDetAlignment::CreateMisalignAlg::GenerateMisaligment ( )
private

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

Definition at line 448 of file CreateMisalignAlg.cxx.

449  {
450 
451  SmartIF<IRndmGenSvc> randsvc{Gaudi::svcLocator()->service("RndmGenSvc")};
452  ATH_CHECK(randsvc.isValid());
453  ATH_MSG_DEBUG( "Got RndmGenSvc" );
454 
455  int i = 0;
456 
457  /*
458  ===================================
459  Documentation of misalignment modes
460  ===================================
461 
462  MisalignMode =
463  0: nothing, no misalignments are generated
464  1: Misalignment of whole InDet by 6 parameters
465  2: random misalignment
466  3: IBL-stave temperature dependent bowing
467 
468  ====================================================
469  Global Distortions according to David Brown (LHC Detector Alignment Workshop 2006-09-04, slides page 11)
470  ====================================================
471  11: R delta R: Radial expansion linearly with r
472  12: Phi delta R: radial expansion sinuisoidally with phi
473  13: Z delta R: radial expansion linearly with z
474  21: R delta Phi: rotation linearly with r
475  22: Phi delta Phi: rotation sinusoidally with phi
476  23: Z delta Phi: rotation linearly with z
477  31: R delta Z: z-shift linearly with r
478  32: Phi delta Z: z-shift sinusoidally with phi
479  33: Z delta Z: z-shift linearly with z
480  */
481 
482  const double maxRadius=51.4*CLHEP::cm; // maximum radius of Silicon Detector (=outermost SCT radius)
483  const double minRadius=50.5*CLHEP::mm; // minimum radius of Silicon Detector (=innermost PIX radius)
484  const double maxLength=158.*CLHEP::cm; // maximum length of Silicon Detector barrel (=length of SCT barrel)
485 
486  const double maxDeltaR = m_Misalign_maxShift;
487  const double maxAngle = 2 * asin( m_Misalign_maxShift / (2*maxRadius));
488  const double maxAngleInner = 2 * asin ( m_Misalign_maxShift_Inner / (2*minRadius));
489  const double maxDeltaZ = m_Misalign_maxShift;
490  ATH_MSG_DEBUG( "maximum deltaPhi = " << maxAngle/CLHEP::mrad << " mrad" );
491  ATH_MSG_DEBUG( "maximum deltaPhi for 1/r term = " << maxAngleInner/CLHEP::mrad << " mrad" );
492  const InDetDD::SiDetectorElementCollection* pixelElements=nullptr;
493  const InDetDD::SiDetectorElementCollection* sctElements=nullptr;
494  if(m_doPix){
495  // SiDetectorElementCollection for Pixel
496  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> pixelDetEleHandle(m_pixelDetEleCollKey);
497  pixelElements = *pixelDetEleHandle;
498  if (not pixelDetEleHandle.isValid() or pixelElements==nullptr) {
499  ATH_MSG_FATAL(m_pixelDetEleCollKey.fullKey() << " is not available.");
500  return StatusCode::FAILURE;
501  }
502  }
503  if(m_doStrip){
504  // SiDetectorElementCollection for SCT
505  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> sctDetEleHandle(m_SCTDetEleCollKey);
506  sctElements = *sctDetEleHandle;
507  if (not sctDetEleHandle.isValid() or sctElements==nullptr) {
508  ATH_MSG_FATAL(m_SCTDetEleCollKey.fullKey() << " is not available.");
509  return StatusCode::FAILURE;
510  }
511  }
512 
513  for (std::map<Identifier, HepGeom::Point3D<double> >::const_iterator iter = m_ModuleList.begin(); iter != m_ModuleList.end(); ++iter) {
514  ++i;
515  const Identifier& ModuleID = iter->first;
516 
517  const InDetDD::SiDetectorElement * SiModule = nullptr; //dummy to get moduleTransform() for silicon
518 
519  if (m_idHelper->is_pixel(ModuleID)) {
520  const IdentifierHash Pixel_ModuleHash = m_pixelIdHelper->wafer_hash(ModuleID);
521  if(pixelElements) SiModule = pixelElements->getDetectorElement(Pixel_ModuleHash);
522  else ATH_MSG_WARNING("Trying to access a Pixel module when running with no Pixel!");
523  //module = SiModule;
524  } else if (m_idHelper->is_sct(ModuleID)) {
525  const IdentifierHash SCT_ModuleHash = m_sctIdHelper->wafer_hash(ModuleID);
526  if(sctElements) SiModule = sctElements->getDetectorElement(SCT_ModuleHash);
527  else ATH_MSG_WARNING("Trying to access an SCT/Strop module when running with no SCT/Strip!");
528  //module = SiModule;OB
529  } else if (m_idHelper->is_trt(ModuleID)) {
530  //module = m_TRT_Manager->getElement(ModuleID);
531  //const InDetDD::TRT_BaseElement *p_TRT_Module = m_TRT_Manager->getElement(iter->second.moduleID());
532  } else {
533  ATH_MSG_WARNING( "Something fishy, identifier is neither Pixel, nor SCT or TRT!" );
534  }
535 
536  //TRT alignment transformations are given in global frame in DB,
537  // that's not fully correct, since the level2 transform can rotate the system in which level1 transforms
538  // are applied ...
539 
540  //Si have a local coordinate system
541  // Take care: For SCT we have to ensure that module's
542  // system is taken, not the system of one of the wafers!
543  HepGeom::Transform3D localToGlobal = HepGeom::Transform3D();
544  if ((not m_idHelper->is_trt(ModuleID))){
545  if (SiModule){
546  localToGlobal=Amg::EigenTransformToCLHEP(SiModule->moduleTransform());
547  } else {
548  ATH_MSG_WARNING("Apparently in a silicon detector, but SiModule is a null pointer");
549  }
550  }
551  const HepGeom::Point3D<double> center = iter->second;
552 
553  //center of module in global coordinates
554  double r = center.rho(); //distance from beampipe
555  double phi = center.phi();
556  double z = center.z();
557 
558  HepGeom::Transform3D parameterizedTrafo;
559  HepGeom::Transform3D alignmentTrafo;
560 
561 
562  // prepare scale factor for different subsystems:
563  double ScaleFactor = 1.;
564 
565  if (m_idHelper->is_pixel(ModuleID))
566  {
567  if (m_pixelIdHelper->is_barrel(ModuleID)) {
568  ScaleFactor=m_ScalePixelBarrel;
569  }
570  else {
571  ScaleFactor=m_ScalePixelEndcap;
572  }
573  if (m_pixelIdHelper->is_blayer(ModuleID)) { // IBL
574  ScaleFactor=m_ScalePixelIBL;
575  }
576  if (m_pixelIdHelper->is_dbm(ModuleID)) { // DBM
577  ScaleFactor=m_ScalePixelDBM;
578  }
579 
580  } else if (m_idHelper->is_sct(ModuleID))
581  {
582  if (m_sctIdHelper->is_barrel(ModuleID)) {
583  ScaleFactor=m_ScaleSCTBarrel;
584  }
585  else {
586  ScaleFactor=m_ScaleSCTEndcap;
587  }
588 
589  } else if (m_idHelper->is_trt(ModuleID))
590  {
591  if (m_trtIdHelper->is_barrel(ModuleID)) {
592  ScaleFactor=m_ScaleTRTBarrel;
593  }
594  else {
595  ScaleFactor=m_ScaleTRTEndcap;
596  }
597  } else {
598  ATH_MSG_WARNING( "Something fishy, identifier is neither Pixel, nor SCT or TRT!" );
599  }
600 
601 
602 
603  ATH_MSG_INFO( "ID Module " << i << " with ID " << m_idHelper->show_to_string(ModuleID,nullptr,'/') );
604  if (msgLvl(MSG::DEBUG)) {
605  msg() << "radius " << r / CLHEP::cm << " centimeter" << endmsg;
606  msg() << "phi " << phi << endmsg;
607  msg() << "z " << z / CLHEP::cm << " centimeter" << endmsg;
608  if (msgLvl(MSG::VERBOSE)) {
609  msg() << "localToGlobal transformation:" << endmsg;
610  msg() << "translation: " << localToGlobal.dx() / CLHEP::cm << ";" << localToGlobal.dy() / CLHEP::cm << ";" << localToGlobal.dz() / CLHEP::cm << endmsg;
611  msg() << "rotation: " << endmsg;
612  msg() << localToGlobal.xx() << " " << localToGlobal.xy() << " " << localToGlobal.xz() << endmsg;
613  msg() << localToGlobal.yx() << " " << localToGlobal.yy() << " " << localToGlobal.yz() << endmsg;
614  msg() << localToGlobal.zx() << " " << localToGlobal.zy() << " " << localToGlobal.zz() << endmsg;
615  }
616  }
617 
618  if (!m_MisalignmentMode) {
619  //no misalignment mode set
620  parameterizedTrafo = HepGeom::Transform3D(); // initialized as identity transformation
621  }
622 
623  else if (m_MisalignmentMode==1) {
624  //shift whole detector
625  HepGeom::Vector3D<double> shift(ScaleFactor*m_Misalign_x, ScaleFactor*m_Misalign_y, ScaleFactor*m_Misalign_z);
626 
627  CLHEP::HepRotation rot;
628  rot = CLHEP::HepRotationX(ScaleFactor*m_Misalign_alpha) * CLHEP::HepRotationY(ScaleFactor*m_Misalign_beta) * CLHEP::HepRotationZ(ScaleFactor*m_Misalign_gamma);
629 
630  if (ScaleFactor == 0.0) {
631  parameterizedTrafo = HepGeom::Transform3D(); // initialized as identity transformation
632  } else {
633  parameterizedTrafo = HepGeom::Transform3D(rot, shift);
634  }
635 
636  }
637 
638  else if (m_MisalignmentMode == 2) {
639 
640  // randomly misalign modules at L3
641  m_RndmMisalignWidth_x = m_translation[0];
642  m_RndmMisalignWidth_y = m_translation[1];
643  m_RndmMisalignWidth_z = m_translation[2];
644  m_RndmMisalignWidth_alpha = m_rotation[0];
645  m_RndmMisalignWidth_beta = m_rotation[1];
646  m_RndmMisalignWidth_gamma = m_rotation[2];
647  Rndm::Numbers RandMisX(randsvc, Rndm::Gauss(m_Misalign_x,m_RndmMisalignWidth_x*ScaleFactor));
648  Rndm::Numbers RandMisY(randsvc, Rndm::Gauss(m_Misalign_y,m_RndmMisalignWidth_y*ScaleFactor));
649  Rndm::Numbers RandMisZ(randsvc, Rndm::Gauss(m_Misalign_z,m_RndmMisalignWidth_z*ScaleFactor));
650  Rndm::Numbers RandMisalpha(randsvc, Rndm::Gauss(m_Misalign_alpha,m_RndmMisalignWidth_alpha*ScaleFactor));
651  Rndm::Numbers RandMisbeta(randsvc, Rndm::Gauss(m_Misalign_beta,m_RndmMisalignWidth_beta*ScaleFactor));
652  Rndm::Numbers RandMisgamma(randsvc, Rndm::Gauss(m_Misalign_gamma,m_RndmMisalignWidth_gamma*ScaleFactor));
653 
654  double randMisX = RandMisX(); //assign to variables to allow the values to be queried
655  double randMisY = RandMisY();
656  double randMisZ = RandMisZ();
657 
658  double randMisaplha = RandMisalpha();
659  double randMisbeta = RandMisbeta();
660  double randMisgamma = RandMisgamma();
661 
662  CLHEP::HepRotation rot;
663  HepGeom::Vector3D<double> shift;
664 
665 
666  if (ScaleFactor == 0.0) {
667  parameterizedTrafo = HepGeom::Transform3D(); // initialized as identity transformation
668  } else {
669  shift = HepGeom::Vector3D<double>(randMisX, randMisY, randMisZ);
670  rot = CLHEP::HepRotationX(randMisaplha) * CLHEP::HepRotationY(randMisbeta) * CLHEP::HepRotationZ(randMisgamma);
671  parameterizedTrafo = HepGeom::Transform3D(rot, shift);}
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 if (m_MisalignmentMode == 7) {
693 
694 
695  std::string module_str = m_idHelper->show_to_string(ModuleID, nullptr, '/');
696 
697  if (module_str.substr(0, m_index.size()) == m_index) {
698 
699  // Handle translation
700  HepGeom::Vector3D<double> shift(0, 0, 0);
701  if (!m_local_translation.empty()) {
702  shift = HepGeom::Vector3D<double>(m_local_translation[0], m_local_translation[1], m_local_translation[2]);
703  }
704 
705  // Handle rotation
706  CLHEP::HepRotation rot = CLHEP::HepRotationX(0) * CLHEP::HepRotationY(0) * CLHEP::HepRotationZ(0);
707  if (!m_local_rotation.empty()) {
708  rot = CLHEP::HepRotationX(m_local_rotation[0]) * CLHEP::HepRotationY(m_local_rotation[1]) * CLHEP::HepRotationZ(m_local_rotation[2]);
709  }
710 
711  // Assign transformation
712  parameterizedTrafo = HepGeom::Transform3D(rot, shift);
713  }
714  }
715 
716 
717  else { // systematic misalignments
718  if (m_MisalignmentMode/10==1) {
719  //radial misalignments
720  double deltaR;
721  if (m_MisalignmentMode==11) {
722  //R deltaR = radial expansion
723  if (m_idHelper->is_trt(ModuleID) && abs(m_trtIdHelper->barrel_ec(ModuleID))==2) {
724  //radial mode cannot handle TRT endcap, sorry
725  deltaR = 0.;
726  ATH_MSG_DEBUG( "will not move TRT endcap for radial distortion " );
727  } else {
728  //deltaR = 0.5 * cos ( 2*phi ) * r/maxRadius * maxDeltaR;
729  deltaR = r/maxRadius * maxDeltaR; //scale linearly in r
730  }
731  } else if (m_MisalignmentMode==12) {
732  //Phi deltaR = elliptical (egg-shape)
733  if (m_idHelper->is_trt(ModuleID) && abs(m_trtIdHelper->barrel_ec(ModuleID))==2) {
734  //elliptical mode cannot handle TRT endcap, sorry
735  deltaR = 0.;
736  ATH_MSG_DEBUG( "will not move TRT endcap for elliptical distortion " );
737  } else {
738  // deltaR = 0.5 * cos ( 2*phi ) * r/maxRadius * maxDeltaR;
739  deltaR = cos ( 2*phi ) * r/maxRadius * maxDeltaR;
740  }
741  } else if (m_MisalignmentMode==13) {
742  //Z deltaR = funnel
743  if (m_idHelper->is_trt(ModuleID) && abs(m_trtIdHelper->barrel_ec(ModuleID))==2) {
744  //funnel mode cannot handle TRT endcap, sorry
745  deltaR = 0.;
746  ATH_MSG_DEBUG( "will not move TRT endcap for funnel distortion " );
747  } else {
748  //deltaR = z/maxLength * maxDeltaR; // linearly in z
749  deltaR = 2. * z/maxLength * maxDeltaR; // linearly in z
750  }
751  } else {
752  ATH_MSG_DEBUG( "Wrong misalignment mode entered, doing nothing." );
753  deltaR=0;
754  }
755 
756  ATH_MSG_DEBUG( "deltaR for this module: " << deltaR / CLHEP::micrometer << " um" );
757  parameterizedTrafo = HepGeom::Translate3D(deltaR*cos(phi),deltaR * sin(phi),0.); // translation along R vector
758  }
759 
760  else if (m_MisalignmentMode/10==2) {
761  //azimuthal misalignments
762  double deltaPhi;
763  if (m_MisalignmentMode==21) {
764 
765  deltaPhi = r/maxRadius * maxAngle + minRadius/r * maxAngleInner; //linearly + reciprocal term in r
766  } else if (m_MisalignmentMode==22) {
767  //Phi deltaPhi = clamshell
768  // deltaPhi = std::abs( sin ( phi )) * maxAngle;
769  if (m_idHelper->is_trt(ModuleID) && abs(m_trtIdHelper->barrel_ec(ModuleID))==2) {
770  //clamshell mode cannot handle TRT endcap, sorry
771  deltaPhi = 0.;
772  ATH_MSG_DEBUG( "will not move TRT endcap for clamshell distortion " );
773  } else {
774  // deltaPhi = 0.5 * cos ( 2*phi ) * maxAngle;
775  deltaPhi = cos ( 2*phi ) * maxAngle;
776  }
777  } else if (m_MisalignmentMode==23) {
778  //Z deltaPhi = Twist
779  deltaPhi = 2*z/maxLength * maxAngle;
780  //deltaPhi = z/maxLength * maxAngle;
781  } else {
782  ATH_MSG_WARNING( "Wrong misalignment mode entered, doing nothing." );
783  deltaPhi=0;
784  }
785 
786  ATH_MSG_DEBUG( "deltaPhi for this module: " << deltaPhi/CLHEP::mrad << " mrad" );
787  parameterizedTrafo = HepGeom::RotateZ3D(deltaPhi); // rotation around z axis => in phi
788  }
789 
790  else if (m_MisalignmentMode/10==3) {
791  //z misalignments
792  double deltaZ;
793  if (m_MisalignmentMode==31) {
794  //R deltaZ = Telescope
795  deltaZ = r/maxRadius * maxDeltaZ; //scale linearly in r
796  } else if (m_MisalignmentMode==32) {
797 
798  if (m_idHelper->is_trt(ModuleID) && abs(m_trtIdHelper->barrel_ec(ModuleID))==2) {
799  //clamshell mode cannot handle TRT endcap, sorry
800  deltaZ = 0.;
801  ATH_MSG_DEBUG( "will not move TRT endcap for skew distortion " );
802  } else {
803 
804  deltaZ = cos ( 2*phi ) * maxDeltaZ;
805  }
806  } else if (m_MisalignmentMode==33) {
807  //Z deltaZ = Z expansion
808  // deltaZ = z/maxLength * maxDeltaZ;
809  deltaZ = 2. * z/maxLength * maxDeltaZ;
810  } else {
811  ATH_MSG_WARNING( "Wrong misalignment mode entered, doing nothing." );
812  deltaZ=0;
813  }
814 
815  ATH_MSG_DEBUG( "deltaZ for this module: " << deltaZ/CLHEP::micrometer << " um" );
816  parameterizedTrafo = HepGeom::Translate3D(0,0,deltaZ); // translation in z direction
817  }
818 
819  else {
820  //no or wrong misalignment selected
821  ATH_MSG_WARNING( "Wrong misalignment mode entered, doing nothing." );
822 
823  parameterizedTrafo = HepGeom::Transform3D(); // initialized as identity transformation
824  }
825  } //end of misalignment
826 
827  if ( m_MisalignmentMode==21 && m_idHelper->is_trt(ModuleID) && m_trtIdHelper->is_barrel(ModuleID) ) {
828  //curl for TRT barrel
829  ATH_MSG_DEBUG( "additional rotation for TRT barrel module!" );
830  HepGeom::Transform3D realLocalToGlobalTRT = HepGeom::Translate3D(center.x(),center.y(),center.z());
831  //rotate a TRT barrel module by the same angle again, but around its local z axis
832  //this is an approximation to accomodate the impossible curling of TRT segments
833  alignmentTrafo = parameterizedTrafo * realLocalToGlobalTRT * parameterizedTrafo * realLocalToGlobalTRT.inverse();
834  } else if (m_MisalignmentMode==23 && m_idHelper->is_trt(ModuleID) && m_trtIdHelper->is_barrel(ModuleID) ) {
835  //do the twist! (for TRT barrel)
836  HepGeom::Transform3D realLocalToGlobalTRT = HepGeom::Translate3D(center.x(),center.y(),center.z());
837  double deltaAlpha = (-2.) * r * maxAngle/maxLength;
838  ATH_MSG_DEBUG( "TRT barrel module alpha for twist: " << deltaAlpha/CLHEP::mrad << " mrad" );
839 
840  CLHEP::HepRotation twistForTRTRotation(HepGeom::Vector3D<double>(center.x(),center.y(),center.z()), deltaAlpha );
841  HepGeom::Transform3D twistForTRT= HepGeom::Transform3D(twistForTRTRotation,HepGeom::Vector3D<double>(0.,0.,0.));
842  // HepGeom::Transform3D twistForTRTRotation = HepGeom::RotateZ3D( r * maxAngle/maxLength );
843 
844  alignmentTrafo = realLocalToGlobalTRT * twistForTRT * realLocalToGlobalTRT.inverse();
845  } else if (m_MisalignmentMode==13 && m_idHelper->is_trt(ModuleID) && m_trtIdHelper->is_barrel(ModuleID) ) {
846  // funneling for TRT barrel
847  HepGeom::Transform3D realLocalToGlobalTRT = HepGeom::Translate3D(center.x(),center.y(),center.z());
848  double deltaAlpha = (-2.) * maxDeltaR/maxLength;
849  //double deltaAlpha = maxDeltaR/maxLength;
850  ATH_MSG_DEBUG( "TRT barrel module alpha for funnel: " << deltaAlpha/CLHEP::mrad << " mrad" );
851 
852  HepGeom::Vector3D<double> normalVector(center.x(),center.y(),center.z());
853  HepGeom::Vector3D<double> beamVector(0.,0.,1.);
854  HepGeom::Vector3D<double> rotationAxis = normalVector.cross(beamVector);
855  CLHEP::HepRotation twistForTRTRotation(rotationAxis, deltaAlpha );
856  HepGeom::Transform3D twistForTRT= HepGeom::Transform3D(twistForTRTRotation,HepGeom::Vector3D<double>(0.,0.,0.));
857 
858  alignmentTrafo = realLocalToGlobalTRT * twistForTRT * realLocalToGlobalTRT.inverse();
859 
860 
861 
862  } else if (m_MisalignmentMode==2 || m_MisalignmentMode==3 || m_MisalignmentMode==7) //random misalignment in local frame
863  {
864  alignmentTrafo = parameterizedTrafo;
865  }
866  else {
867  // final transformation executed in global coordinates, converted to local coordinates
868  alignmentTrafo = localToGlobal.inverse() * parameterizedTrafo * localToGlobal;
869  }
870 
871  if (msgLvl(MSG::INFO)) {
872  msg() << "Align Transformation x = (" << alignmentTrafo.getTranslation().x() / CLHEP::micrometer << " um)" << endmsg;
873  msg() << "Align Transformation y = (" << alignmentTrafo.getTranslation().y() / CLHEP::micrometer << " um)" << endmsg;
874  msg() << "Align Transformation z = (" << alignmentTrafo.getTranslation().z() / CLHEP::micrometer << " um)" << endmsg;
875  msg() << "Align Transformation x phi = (" << alignmentTrafo.getRotation().phiX() / CLHEP::deg << ")" << endmsg;
876  msg() << "Align Transformation x Theta = (" << alignmentTrafo.getRotation().thetaX() / CLHEP::deg << ")" << endmsg;
877  msg() << "Align Transformation y phi = (" << alignmentTrafo.getRotation().phiY() / CLHEP::deg << ")" << endmsg;
878  msg() << "Align Transformation y Theta = (" << alignmentTrafo.getRotation().thetaY() / CLHEP::deg << ")" << endmsg;
879  msg() << "Align Transformation z phi = (" << alignmentTrafo.getRotation().phiZ() / CLHEP::deg << ")" << endmsg;
880  msg() << "Align Transformation z Theta = (" << alignmentTrafo.getRotation().thetaZ() / CLHEP::deg << ")" << endmsg;
881  }
882 
883  // suppress tiny translations that occur due to trafo.inverse*trafo numerics
884  if ( std::abs(alignmentTrafo.getTranslation().x()) < 1e-10) {
885  HepGeom::Vector3D<double>
886  zeroSuppressedTranslation(0,alignmentTrafo.getTranslation().y(),alignmentTrafo.
887  getTranslation().z());
888  alignmentTrafo =
889  HepGeom::Transform3D(alignmentTrafo.getRotation(),zeroSuppressedTranslation);
890  }
891  if ( std::abs(alignmentTrafo.getTranslation().y()) < 1e-10) {
892  HepGeom::Vector3D<double>
893  zeroSuppressedTranslation(alignmentTrafo.getTranslation().x(),0,alignmentTrafo.
894  getTranslation().z());
895  alignmentTrafo =
896  HepGeom::Transform3D(alignmentTrafo.getRotation(),zeroSuppressedTranslation);
897  }
898  if ( std::abs(alignmentTrafo.getTranslation().z()) < 1e-10) {
899  HepGeom::Vector3D<double>
900  zeroSuppressedTranslation(alignmentTrafo.getTranslation().x(),alignmentTrafo.getTranslation().y(),0);
901  alignmentTrafo =
902  HepGeom::Transform3D(alignmentTrafo.getRotation(),zeroSuppressedTranslation);
903  }
904  if ( std::abs(alignmentTrafo.getRotation().getDelta()) < 1e-10) {
905  CLHEP::HepRotation zeroSuppressedRotation(alignmentTrafo.getRotation());
906  zeroSuppressedRotation.setDelta(0.);
907  alignmentTrafo =
908  HepGeom::Transform3D(zeroSuppressedRotation,alignmentTrafo.getTranslation());
909  }
910 
911 
912  Amg::Transform3D alignmentTrafoAmg = Amg::CLHEPTransformToEigen(alignmentTrafo);
913 
914  if (m_idHelper->is_sct(ModuleID) || m_idHelper->is_pixel(ModuleID)) {
915  if (m_IDAlignDBTool->tweakTrans(ModuleID,3, alignmentTrafoAmg)) {
916  ATH_MSG_INFO( "Update of alignment constants for module " << m_idHelper->show_to_string(ModuleID,nullptr,'/') << " successful" );
917  } else {
918  ATH_MSG_ERROR( "Update of alignment constants for module " << m_idHelper->show_to_string(ModuleID,nullptr,'/') << " not successful" );
919  }
920  } else if (m_idHelper->is_trt(ModuleID)) {
921  if (!m_trtIdHelper->is_barrel(ModuleID) && m_trtIdHelper->phi_module(ModuleID)!=0) {
922  //don't align - there's no trans in the DB for phi sectors other than 0
923  ATH_MSG_DEBUG( "TRT endcap phi sector " << m_trtIdHelper->phi_module(ModuleID) << " not aligned" );
924  } else {
925  //if (m_trtaligndbservice->tweakTrans(ModuleID,alignmentTrafo).isFailure()) {
926  if (m_trtaligndbservice->tweakAlignTransform(ModuleID,alignmentTrafoAmg,2).isFailure()) {
927  ATH_MSG_ERROR( "Update of alignment constants for module " << m_idHelper->show_to_string(ModuleID,nullptr,'/') << " not successful" );
928  } else {
929  ATH_MSG_INFO( "Update of alignment constants for module " << m_idHelper->show_to_string(ModuleID,nullptr,'/') << " successful" );
930  }
931  }
932  } else {
933  ATH_MSG_WARNING( "Something fishy, identifier is neither Pixel, nor SCT or TRT!" );
934  }
935 
936  double alpha, beta, gamma;
937  m_IDAlignDBTool->extractAlphaBetaGamma(alignmentTrafoAmg, alpha, beta, gamma);
938 
939  m_AlignResults_x = alignmentTrafo.getTranslation().x();
940  m_AlignResults_y = alignmentTrafo.getTranslation().y();
941  m_AlignResults_z = alignmentTrafo.getTranslation().z();
942  m_AlignResults_alpha = alpha;
943  m_AlignResults_beta = beta;
944  m_AlignResults_gamma = gamma;
945 
946 
947  HepGeom::Transform3D LocalaGlobal = HepGeom::Transform3D();
948  LocalaGlobal = Amg::EigenTransformToCLHEP(SiModule->moduleTransform());
949  HepGeom::Point3D<double> alignedPosLocal(m_AlignResults_x,m_AlignResults_y,m_AlignResults_z);
950 
951 
952 
953 
954  m_Initial_center_x = center.x() ;
955  m_Initial_center_y = center.y() ;
956  m_Initial_center_z = center.z() ;
957 
958  HepGeom::Point3D<double> alignedPosGlobal = LocalaGlobal * alignedPosLocal;
959 
960  // Global Misalignment HERE
961  if (m_idHelper->is_sct(ModuleID)) {
962  // non-zero local center position gives additional radial shift of SCT endcap
963  const InDetDD::StripStereoAnnulusDesign *p_design_check = dynamic_cast<const InDetDD::StripStereoAnnulusDesign*>(&(SiModule->design()));
964  if (p_design_check){
965  Amg::Vector3D SCT_Center = p_design_check->sensorCenter();
966  double radialShift_x = SCT_Center[0]; // in sensor frame, x direction
967  double radialShift_y = SCT_Center[1]; // in sensor frame, y direction
968  HepGeom::Transform3D radial_shift = HepGeom::Translate3D(radialShift_x,radialShift_y,0); // the additional radial shift applied as translation
969  HepGeom::Transform3D LocalaaGlobal = LocalaGlobal * radial_shift; // apply additional radial shift
970  HepGeom::Point3D<double> SCT_endcap_alignedPosGlobal = LocalaaGlobal * alignedPosLocal; // corrected global transformation
971  m_Global_center_x = SCT_endcap_alignedPosGlobal.x();
972  m_Global_center_z = SCT_endcap_alignedPosGlobal.z();
973  m_Global_center_y = SCT_endcap_alignedPosGlobal.y();
974  }
975 
976  else { // no additional radial shift for SCT barrel
977  m_Global_center_x = alignedPosGlobal.x();
978  m_Global_center_y = alignedPosGlobal.y();
979  m_Global_center_z = alignedPosGlobal.z();
980 
981  }
982 
983  }
984 
985  else { // no additional radial shift for non-SCT elements
986  m_Global_center_x = alignedPosGlobal.x();
987  m_Global_center_y = alignedPosGlobal.y();
988  m_Global_center_z = alignedPosGlobal.z();
989  }
990 
991 
992  if (m_idHelper->is_sct(ModuleID)) {
993  m_AlignResults_Identifier_ID = 2;
994  m_AlignResults_Identifier_PixelSCT = 2;
995  m_AlignResults_Identifier_BarrelEC = m_sctIdHelper->barrel_ec(ModuleID);
996  m_AlignResults_Identifier_LayerDisc = m_sctIdHelper->layer_disk(ModuleID);
997  m_AlignResults_Identifier_Phi = m_sctIdHelper->phi_module(ModuleID);
998  m_AlignResults_Identifier_Eta = m_sctIdHelper->eta_module(ModuleID);
999  } else if (m_idHelper->is_pixel(ModuleID)) {
1000  m_AlignResults_Identifier_ID = 2;
1001  m_AlignResults_Identifier_PixelSCT = 1;
1002  m_AlignResults_Identifier_BarrelEC = m_pixelIdHelper->barrel_ec(ModuleID);
1003  m_AlignResults_Identifier_LayerDisc = m_pixelIdHelper->layer_disk(ModuleID);
1004  m_AlignResults_Identifier_Phi = m_pixelIdHelper->phi_module(ModuleID);
1005  m_AlignResults_Identifier_Eta = m_pixelIdHelper->eta_module(ModuleID);
1006  } else if (m_idHelper->is_trt(ModuleID)) {
1007  m_AlignResults_Identifier_ID = 2;
1008  m_AlignResults_Identifier_PixelSCT = 3;
1009  m_AlignResults_Identifier_BarrelEC = m_trtIdHelper->barrel_ec(ModuleID);
1010  m_AlignResults_Identifier_LayerDisc = m_trtIdHelper->layer_or_wheel(ModuleID);
1011  m_AlignResults_Identifier_Phi = m_trtIdHelper->phi_module(ModuleID);
1012  m_AlignResults_Identifier_Eta = m_trtIdHelper->straw_layer(ModuleID);
1013 
1014  } else {
1015  ATH_MSG_WARNING( "Something fishy, identifier is neither Pixel, nor SCT or TRT!" );
1016  }
1017 
1018  // Write out AlignResults ntuple
1019  if (StatusCode::SUCCESS!=ntupleSvc()->writeRecord("NTUPLES/CREATEMISALIGN/InitialAlignment")) {
1020  ATH_MSG_ERROR( "Could not write InitialAlignment ntuple." );
1021  }
1022 
1023  } // end of module loop
1024 
1025  // i = 0;
1026 
1027  //m_IDAlignDBTool->printDB(2);
1028  if(m_doPix || m_doStrip){
1029  if (StatusCode::SUCCESS!=m_IDAlignDBTool->outputObjs()) {
1030  ATH_MSG_ERROR( "Writing of AlignableTransforms failed" );
1031  } else {
1032  ATH_MSG_INFO( "AlignableTransforms were written" );
1033  ATH_MSG_INFO( "Writing database to textfile" );
1034  m_IDAlignDBTool->writeFile(false,m_asciiFileNameBase+"_Si.txt");
1035  ATH_MSG_INFO( "Writing IoV information to mysql file" );
1036  m_IDAlignDBTool->fillDB("InDetSi_"+m_SQLiteTag,IOVTime::MINRUN,IOVTime::MINEVENT,IOVTime::MAXRUN,IOVTime::MAXEVENT);
1037  }
1038  }
1039 
1040  if(m_doTRT){
1041  if (StatusCode::SUCCESS!=m_trtaligndbservice->streamOutAlignObjects()) {
1042  ATH_MSG_ERROR( "Write of AlignableTransforms (TRT) failed" );
1043  } else {
1044  ATH_MSG_INFO( "AlignableTransforms for TRT were written" );
1045  ATH_MSG_INFO( "Writing TRT database to textfile" );
1046  if ( StatusCode::SUCCESS != m_trtaligndbservice->writeAlignTextFile(m_asciiFileNameBase+"_TRT.txt") ) {
1047  ATH_MSG_ERROR( "Failed to write AlignableTransforms (TRT) to txt file " << m_asciiFileNameBase+"_TRT.txt" );
1048  }
1049  ATH_MSG_INFO( "Writing IoV information for TRT to mysql file" );
1050  if ( StatusCode::SUCCESS
1051  != m_trtaligndbservice->registerAlignObjects(m_SQLiteTag+"_TRT",IOVTime::MINRUN,IOVTime::MINEVENT,IOVTime::MAXRUN,IOVTime::MAXEVENT)) {
1052  ATH_MSG_ERROR( "Write of AIoV information (TRT) to mysql failed (tag=" << m_SQLiteTag << "_TRT)");
1053  }
1054  }
1055  }
1056 
1057  return StatusCode::SUCCESS;
1058 
1059  }

◆ getBowingMagParam()

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

Definition at line 1112 of file CreateMisalignAlg.cxx.

1113  {
1114  // IBL staves are straight at a set point of 15 degrees.
1115  // Get set point value to use for magnitude parameter from temp_shift starting at 15 degrees
1116  double T = 15 + temp_shift;
1117  return 1.53e-12 - 1.02e-13*T;
1118  }

◆ getBowingTx()

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

Definition at line 1121 of file CreateMisalignAlg.cxx.

1122  {
1123  // Bowing fit function has the following form
1124  // [0]-[1]*(x+[2]) * (4.0*[2]*(x+[2])**2 - (x+[2])**3 - (2.0*[2])**3)
1125  // param 0 : is the baseline shift (fixed at 0 for MC)
1126  // param 1 : is the magnitude fit param (temp dependent input param)
1127  // param 2 : is the stave fix pointat both ends (fixed at 366.5)
1128  double p0 = 0;
1129  double p2 = 366.5;
1130  double Tx = p0 - p1*(z+p2) * (4.*p2*pow((z+p2),2) - pow((z+p2),3) - pow((2.*p2),3));
1131  return Tx;
1132  }

◆ initialize()

StatusCode InDetAlignment::CreateMisalignAlg::initialize ( )

standard Athena-Algorithm method

Definition at line 141 of file CreateMisalignAlg.cxx.

142  {
143  ATH_MSG_DEBUG("CreateMisalignAlg initialize()");
144  if(m_pixelDetEleCollKey.empty()) {m_doPix=false;ATH_MSG_INFO("Not creating misalignment for Pixel");}
145  if(m_SCTDetEleCollKey.empty()) {m_doStrip=false;ATH_MSG_INFO("Not creating misalignment for Strip/SCT");}
146  if(m_trtDetEleCollKey.empty()) {m_doTRT=false;ATH_MSG_INFO("Not creating misalignment for TRT");}
147 
148  ATH_CHECK(m_pixelDetEleCollKey.initialize(SG::AllowEmpty));
149  ATH_CHECK(m_SCTDetEleCollKey.initialize(SG::AllowEmpty));
150  ATH_CHECK(m_trtDetEleCollKey.initialize(SG::AllowEmpty));
151 
152  if (m_doPix || m_doStrip) ATH_CHECK(m_IDAlignDBTool.retrieve());
153  if(m_doTRT) ATH_CHECK(m_trtaligndbservice.retrieve());
154  //ID helpers
155  // Pixel
156  if(m_doPix){
157  ATH_CHECK(detStore()->retrieve(m_pixelIdHelper, "PixelID"));
158  }
159  // SCT
160  if(m_doStrip){
161  ATH_CHECK(detStore()->retrieve(m_sctIdHelper, "SCT_ID"));
162  }
163  // TRT
164  if(m_doTRT){
165  ATH_CHECK(detStore()->retrieve(m_trtIdHelper, "TRT_ID"));
166  }
167  ATH_CHECK(detStore()->retrieve(m_idHelper, "AtlasID"));
168 
169  // Retrieve the Histo Service
170  SmartIF<ITHistSvc> hist_svc{Gaudi::svcLocator()->service("THistSvc")};
171  ATH_CHECK(hist_svc.isValid());
172  //Registering TTree for Visualization Lookup
173  m_VisualizationLookupTree = new TTree("IdentifierTree", "Visualization Identifier Lookup Tree");
174  ATH_CHECK(hist_svc->regTree("/IDENTIFIERTREE/IdentifierTree", m_VisualizationLookupTree));
175  m_VisualizationLookupTree->Branch ("AthenaHashedID", &m_AthenaHashedID, "AthenaID/i");
176  m_VisualizationLookupTree->Branch ("HumanReadableID", &m_HumanReadableID, "HumanID/I");
177 
178  // initialize generated Initial Alignment NTuple
179  NTupleFilePtr file1(ntupleSvc(), "/NTUPLES/CREATEMISALIGN");
180 
181  NTuplePtr nt(ntupleSvc(), "/NTUPLES/CREATEMISALIGN/InitialAlignment");
182  if ( !nt ) { // Check if already booked
183  nt = ntupleSvc()->book("/NTUPLES/CREATEMISALIGN/InitialAlignment", CLID_ColumnWiseTuple, "InitialAlignment");
184  if ( nt ) {
185  ATH_MSG_INFO( "InitialAlignment ntuple booked." );
186  ATH_CHECK( nt->addItem("x" ,m_AlignResults_x) );
187  ATH_CHECK( nt->addItem("y" ,m_AlignResults_y) );
188  ATH_CHECK( nt->addItem("z" ,m_AlignResults_z) );
189  ATH_CHECK( nt->addItem("alpha" ,m_AlignResults_alpha) );
190  ATH_CHECK( nt->addItem("beta" ,m_AlignResults_beta) );
191  ATH_CHECK( nt->addItem("gamma" ,m_AlignResults_gamma) );
192  ATH_CHECK( nt->addItem("ID" ,m_AlignResults_Identifier_ID) );
193  ATH_CHECK( nt->addItem("PixelSCT" ,m_AlignResults_Identifier_PixelSCT) );
194  ATH_CHECK( nt->addItem("BarrelEC" ,m_AlignResults_Identifier_BarrelEC) );
195  ATH_CHECK( nt->addItem("LayerDisc" ,m_AlignResults_Identifier_LayerDisc) );
196  ATH_CHECK( nt->addItem("Phi" ,m_AlignResults_Identifier_Phi) );
197  ATH_CHECK( nt->addItem("Eta" ,m_AlignResults_Identifier_Eta) );
198  ATH_CHECK( nt->addItem("center_x" ,m_Initial_center_x ) );
199  ATH_CHECK( nt->addItem("center_y" ,m_Initial_center_y ) );
200  ATH_CHECK( nt->addItem("center_z" ,m_Initial_center_z ) );
201  ATH_CHECK( nt->addItem("misaligned_global_x" ,m_Global_center_x ) );
202  ATH_CHECK( nt->addItem("misaligned_global_y" ,m_Global_center_y ) );
203  ATH_CHECK( nt->addItem("misaligned_global_z" ,m_Global_center_z ) );
204  } else { // did not manage to book the N tuple....
205  msg(MSG::ERROR) << "Failed to book InitialAlignment ntuple." << endmsg;
206  }
207  }
208 
209  if (m_MisalignmentMode) {
210  ATH_MSG_INFO( "Misalignment mode chosen: " << m_MisalignmentMode );
211  if (m_MisalignmentMode == 1) {
212  ATH_MSG_INFO( "MisalignmentX : " << m_Misalign_x / CLHEP::micrometer << " micrometer" );
213  ATH_MSG_INFO( "MisalignmentY : " << m_Misalign_y / CLHEP::micrometer << " micrometer" );
214  ATH_MSG_INFO( "MisalignmentZ : " << m_Misalign_z / CLHEP::micrometer << " micrometer" );
215  ATH_MSG_INFO( "MisalignmentAlpha : " << m_Misalign_alpha / CLHEP::mrad << " mrad" );
216  ATH_MSG_INFO( "MisalignmentBeta : " << m_Misalign_beta / CLHEP::mrad << " mrad" );
217  ATH_MSG_INFO( "MisalignmentGamma : " << m_Misalign_gamma / CLHEP::mrad << " mrad" );
218  } else {
219  ATH_MSG_INFO( "with maximum shift of " << m_Misalign_maxShift / CLHEP::micrometer << " micrometer" );
220  }
221  } else {
222  ATH_MSG_INFO( "Dry run, no misalignment will be generated." );
223  }
224 
225  return StatusCode::SUCCESS;
226  }

◆ 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 1074 of file CreateMisalignAlg.cxx.

1075  {
1076  // msg(MSG::DEBUG) << "in CreateMisalignAlg::reduceTRTID" << endmsg;
1077  ATH_MSG_DEBUG( "reduceTRTID got Id " << m_idHelper->show_to_string(id,nullptr,'/'));
1078 
1079  int barrel_ec= m_trtIdHelper->barrel_ec(id);
1080  // attention: TRT DB only has one alignment correction per barrel module (+1/-1) pair
1081  // which is stored in -1 identifier
1082  if (barrel_ec==1) barrel_ec=-1; //only regard -1 barrel modules, +1 modules will belong to them
1083 
1084  //if (abs(barrel_ec)==2) phi_module=0;
1085  // only regard phi sector 0, the only one having an alignmentTrafo
1086  //does not work, since the center-of-mass of all phi sectors is on the beamline,so
1087  // transformations would become zero -> this has to be handled later
1088  int phi_module=m_trtIdHelper->phi_module(id);
1089 
1090  int layer_or_wheel=m_trtIdHelper->layer_or_wheel(id);
1091 
1092  int strawlayer=0;
1093  if (!m_trtIdHelper->is_barrel(id)) {
1094  strawlayer = m_trtIdHelper->straw_layer(id) / 4 * 4;
1095  // only strawlayers 0,4,8,12 are fed into DB for endcap
1096  }
1097 
1098  // 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;
1099  ATH_MSG_DEBUG( " and returns Id " << m_idHelper->show_to_string(m_trtIdHelper->layer_id(barrel_ec,phi_module,layer_or_wheel,strawlayer),nullptr,'/'));
1100  // return m_trtIdHelper->module_id(barrel_ec,phi_module,layer_or_wheel);
1101  return m_trtIdHelper->layer_id(barrel_ec,phi_module,layer_or_wheel,strawlayer);
1102  }

◆ reduceTRTID() [2/2]

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

Definition at line 1105 of file CreateMisalignAlg.cxx.

1106  {
1107  Identifier id= m_trtIdHelper->module_id(hash);
1108  return reduceTRTID(id);
1109  }

◆ 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 327 of file CreateMisalignAlg.cxx.

328  {
329  // SiDetectorElementCollection for Pixel
330  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> pixelDetEleHandle(m_pixelDetEleCollKey);
331  const InDetDD::SiDetectorElementCollection* elements(*pixelDetEleHandle);
332  if (not pixelDetEleHandle.isValid() or elements==nullptr) {
333  ATH_MSG_FATAL(m_pixelDetEleCollKey.fullKey() << " is not available.");
334  return;
335  }
336  for (const InDetDD::SiDetectorElement *element: *elements) {
337  // get the ID
338  const Identifier Pixel_ModuleID = element->identify();
339  const IdentifierHash Pixel_ModuleHash = m_pixelIdHelper->wafer_hash(Pixel_ModuleID);
340  // check the validity
341  if (Pixel_ModuleID.is_valid()) {
342  if (m_ModuleList.find(Pixel_ModuleID) == m_ModuleList.end()) {
343  const InDetDD::SiDetectorElement *module = elements->getDetectorElement(Pixel_ModuleHash);
344  m_ModuleList[Pixel_ModuleID][0] = module->center()[0];
345  m_ModuleList[Pixel_ModuleID][1] = module->center()[1];
346  m_ModuleList[Pixel_ModuleID][2] = module->center()[2];
347 
348  ++nPixel;
349  ATH_MSG_VERBOSE( "Pixel module " << nPixel );
350 
351  // Write out Visualization Lookup Tree
352  m_AthenaHashedID = Pixel_ModuleID.get_identifier32().get_compact();
353  m_HumanReadableID = 1000000*1 /*1 = Pixel*/
354  + 100000*m_pixelIdHelper->layer_disk(Pixel_ModuleID)
355  + 1000*(10+m_pixelIdHelper->eta_module(Pixel_ModuleID))
356  + m_pixelIdHelper->phi_module(Pixel_ModuleID);
357  if ( m_pixelIdHelper->barrel_ec(Pixel_ModuleID) != 0 ) {
358  m_HumanReadableID = m_pixelIdHelper->barrel_ec(Pixel_ModuleID)*(m_HumanReadableID + 10000000);
359  }
360 
361  ATH_MSG_VERBOSE( "Human Readable ID: " << m_HumanReadableID );
362 
363  m_VisualizationLookupTree->Fill();
364 
365  if (msgLvl(MSG::VERBOSE)) {
366  HepGeom::Transform3D InitialAlignment = Amg::EigenTransformToCLHEP(m_IDAlignDBTool->getTrans(Pixel_ModuleID,3));
367  msg() << "Initial Alignment of module " << m_idHelper->show_to_string(Pixel_ModuleID,nullptr,'/') << endmsg;
368  msg() << commonAlignmentOutput(InitialAlignment);
369  msg() << endmsg;
370  }
371  }
372  } else {
373  ATH_MSG_INFO( "not a valid PIXEL Module ID (setup)" );
374  }
375  }
376  }

◆ setupSCT_AlignModule()

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

Definition at line 277 of file CreateMisalignAlg.cxx.

278  {
279  // SiDetectorElementCollection for SCT
280  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> sctDetEleHandle(m_SCTDetEleCollKey);
281  const InDetDD::SiDetectorElementCollection* elements(*sctDetEleHandle);
282  if (not sctDetEleHandle.isValid() or elements==nullptr) {
283  ATH_MSG_FATAL(m_SCTDetEleCollKey.fullKey() << " is not available.");
284  return;
285  }
286  for (const InDetDD::SiDetectorElement *element: *elements) {
287  const Identifier SCT_ModuleID = m_sctIdHelper->module_id(element->identify()); //from wafer id to module id
288  const IdentifierHash SCT_ModuleHash = m_sctIdHelper->wafer_hash(SCT_ModuleID);
289 
290  if (m_ModuleList.find(SCT_ModuleID) == m_ModuleList.end())
291  {
292  const InDetDD::SiDetectorElement *module = elements->getDetectorElement(SCT_ModuleHash);
293  m_ModuleList[SCT_ModuleID][0] = module->center()[0];
294  m_ModuleList[SCT_ModuleID][1] = module->center()[1];
295  m_ModuleList[SCT_ModuleID][2] = module->center()[2];
296  ++nSCT;
297  ATH_MSG_VERBOSE( "SCT module " << nSCT );
298  }
299 
300  if (m_sctIdHelper->side(element->identify()) == 0) { // inner side case
301  // Write out Visualization Lookup Tree
302  m_AthenaHashedID = SCT_ModuleID.get_identifier32().get_compact();
303  m_HumanReadableID = 1000000*2 /*2 = SCT*/
304  + 100000*m_sctIdHelper->layer_disk(SCT_ModuleID)
305  + 1000*(10+m_sctIdHelper->eta_module(SCT_ModuleID))
306  + m_sctIdHelper->phi_module(SCT_ModuleID);
307  if ( m_sctIdHelper->barrel_ec(SCT_ModuleID) != 0 ) {
308  m_HumanReadableID = m_sctIdHelper->barrel_ec(SCT_ModuleID)*(m_HumanReadableID + 10000000);
309  }
310 
311  ATH_MSG_VERBOSE( "Human Readable ID: " << m_HumanReadableID );
312 
313  m_VisualizationLookupTree->Fill();
314 
315  // Syntax is (ID, Level) where Level is from 1 to 3 (3 is single module level)
316  if (msgLvl(MSG::VERBOSE)) {
317  HepGeom::Transform3D InitialAlignment = Amg::EigenTransformToCLHEP(m_IDAlignDBTool->getTrans(SCT_ModuleID,3));
318  msg() << "Initial Alignment of module " << m_idHelper->show_to_string(SCT_ModuleID,nullptr,'/') << endmsg;
319  msg() << commonAlignmentOutput(InitialAlignment);
320  msg() << endmsg;
321  }
322  } // end inner side case
323  } //end loop over SCT elements
324  }

◆ setupTRT_AlignModule()

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

Definition at line 379 of file CreateMisalignAlg.cxx.

380  {
381  //TODO: writing into the Identifier tree is undone for TRT (AthenaHashedID and HumanReadableID)
382 
383  std::map< Identifier, std::vector<double> > trtModulesWithCOG;
384 
385  // TRT_DetElementContainer->TRT_DetElementCollection for TRT
386  SG::ReadCondHandle<InDetDD::TRT_DetElementContainer> trtDetEleHandle(m_trtDetEleCollKey);
387  const InDetDD::TRT_DetElementCollection* elements(trtDetEleHandle->getElements());
388  if (not trtDetEleHandle.isValid() or elements==nullptr) {
389  ATH_MSG_FATAL(m_trtDetEleCollKey.fullKey() << " is not available.");
390  return;
391  }
392 
393  //step through all detector elements (=strawlayers) and accumulate strawcenters per
394  // element (with DB granularity, i.e. phi sectors in endcap, bi-modules in barrel)
395  for (const InDetDD::TRT_BaseElement *element: *elements) {
396  const Identifier TRTID_orig = element->identify();
397  const Identifier TRTID = reduceTRTID(TRTID_orig);
398  bool insertSuccess{};
399  std::tie(std::ignore, insertSuccess) = trtModulesWithCOG.insert({TRTID,std::vector<double>(4,0.)}); //create fresh vector for module center
400  if (not insertSuccess){
401  ATH_MSG_VERBOSE("No insert was performed, identifier was already in the trtModulesWithCOG map");
402  }
403 
404  unsigned int nStraws = element->nStraws();
405  for (unsigned int l = 0; l<nStraws; l++) {
406  const Amg::Vector3D strawcenter = element->strawCenter(l);
407  trtModulesWithCOG[TRTID].at(0) += strawcenter.x(); /*sumx*/
408  trtModulesWithCOG[TRTID].at(1) += strawcenter.y(); /*sumy*/
409  trtModulesWithCOG[TRTID].at(2) += strawcenter.z(); /*sumz*/
410  trtModulesWithCOG[TRTID].at(3) += 1.; /*nStraws*/
411 
412  }
413 
414  ATH_MSG_DEBUG( "this strawlayer has " << nStraws << " straws." );
415  ATH_MSG_DEBUG( "strawcount of this module: " << trtModulesWithCOG[TRTID].at(3) );
416 
417  }
418 
419  //go through cog list and create one COG per TRT module (at DB granularity)
420  std::map< Identifier, std::vector<double> >::const_iterator iter2;
421  for (iter2 = trtModulesWithCOG.begin(); iter2!=trtModulesWithCOG.end(); ++iter2) {
422  const Identifier TRTID = iter2->first;
423  double nStraws = iter2->second.at(3);
424  nTRT++;
425  ATH_MSG_VERBOSE( "TRT module " << nTRT );
426  m_ModuleList[TRTID] = HepGeom::Point3D<double>(iter2->second.at(0)/nStraws, iter2->second.at(1)/nStraws,iter2->second.at(2)/nStraws);
427 
428  HepGeom::Transform3D InitialAlignment ;
429 
430  const Amg::Transform3D* p = m_trtaligndbservice->getAlignmentTransformPtr(TRTID,2) ;
431  if ( p ) {
432  if (msgLvl(MSG::VERBOSE)) {
433  InitialAlignment = Amg::EigenTransformToCLHEP(*p) ;
434  msg() << "Initial Alignment of module " << m_idHelper->show_to_string(TRTID,nullptr,'/') << endmsg;
435  msg() << commonAlignmentOutput(InitialAlignment);
436  msg() << endmsg;
437  }
438  } else {
439 
440  ATH_MSG_VERBOSE("No initial alignment for TRT module " << m_idHelper->show_to_string(TRTID,nullptr,'/') );
441  }
442 
443 
444  }
445  }

◆ 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 123 of file CreateMisalignAlg.h.

◆ m_AlignResults_beta

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

AP rotation aorund y-axis.

Definition at line 124 of file CreateMisalignAlg.h.

◆ m_AlignResults_gamma

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

AP rotation around z-axis.

Definition at line 125 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 128 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 131 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 126 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 129 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 130 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 127 of file CreateMisalignAlg.h.

◆ m_AlignResults_x

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

Alignment parameter sensitive coordinate.

Definition at line 120 of file CreateMisalignAlg.h.

◆ m_AlignResults_y

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

AP not-so-sensitive coordinate.

Definition at line 121 of file CreateMisalignAlg.h.

◆ m_AlignResults_z

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

AP normal to module plane.

Definition at line 122 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 117 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 161 of file CreateMisalignAlg.h.

◆ m_doStrip

bool InDetAlignment::CreateMisalignAlg::m_doStrip
private

Definition at line 162 of file CreateMisalignAlg.h.

◆ m_doTRT

bool InDetAlignment::CreateMisalignAlg::m_doTRT
private

Definition at line 163 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 138 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 139 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 140 of file CreateMisalignAlg.h.

◆ m_HumanReadableID

int InDetAlignment::CreateMisalignAlg::m_HumanReadableID
private

Definition at line 118 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 103 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_index

std::string InDetAlignment::CreateMisalignAlg::m_index
private

Generate misalignment according to module indices.

Definition at line 86 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 133 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 134 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 135 of file CreateMisalignAlg.h.

◆ m_local_rotation

std::vector<double> InDetAlignment::CreateMisalignAlg::m_local_rotation
private

Specify misalignment with rotation.

Definition at line 85 of file CreateMisalignAlg.h.

◆ m_local_translation

std::vector<double> InDetAlignment::CreateMisalignAlg::m_local_translation
private

Specify misalignment with translation.

Definition at line 84 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 90 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 91 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 92 of file CreateMisalignAlg.h.

◆ m_Misalign_maxShift

double InDetAlignment::CreateMisalignAlg::m_Misalign_maxShift
private

Maximum shift for global modes.

Definition at line 99 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 100 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 87 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 88 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 89 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 112 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 165 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 96 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 97 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 98 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 93 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 94 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 95 of file CreateMisalignAlg.h.

◆ m_rotation

std::vector<double> 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 104 of file CreateMisalignAlg.h.

◆ m_ScalePixelDBM

double InDetAlignment::CreateMisalignAlg::m_ScalePixelDBM
private

Definition at line 102 of file CreateMisalignAlg.h.

◆ m_ScalePixelEndcap

double InDetAlignment::CreateMisalignAlg::m_ScalePixelEndcap
private

Definition at line 105 of file CreateMisalignAlg.h.

◆ m_ScalePixelIBL

double InDetAlignment::CreateMisalignAlg::m_ScalePixelIBL
private

Definition at line 101 of file CreateMisalignAlg.h.

◆ m_ScaleSCTBarrel

double InDetAlignment::CreateMisalignAlg::m_ScaleSCTBarrel
private

Definition at line 106 of file CreateMisalignAlg.h.

◆ m_ScaleSCTEndcap

double InDetAlignment::CreateMisalignAlg::m_ScaleSCTEndcap
private

Definition at line 107 of file CreateMisalignAlg.h.

◆ m_ScaleTRTBarrel

double InDetAlignment::CreateMisalignAlg::m_ScaleTRTBarrel
private

Definition at line 108 of file CreateMisalignAlg.h.

◆ m_ScaleTRTEndcap

double InDetAlignment::CreateMisalignAlg::m_ScaleTRTEndcap
private

Definition at line 109 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 166 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

std::vector<double> 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 167 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 115 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:94
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
AtlasDetectorID::is_pixel
bool is_pixel(Identifier id) const
Definition: AtlasDetectorID.h:755
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
InDetAlignment::CreateMisalignAlg::m_Misalign_z
Gaudi::Property< double > m_Misalign_z
Definition: CreateMisalignAlg.h:89
beamspotman.r
def r
Definition: beamspotman.py:672
InDetAlignment::CreateMisalignAlg::m_ScalePixelDBM
double m_ScalePixelDBM
Definition: CreateMisalignAlg.h:102
InDetAlignment::CreateMisalignAlg::m_AlignResults_alpha
NTuple::Item< double > m_AlignResults_alpha
AP rotation around x-axis.
Definition: CreateMisalignAlg.h:123
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:494
InDetAlignment::CreateMisalignAlg::m_HumanReadableID
int m_HumanReadableID
Definition: CreateMisalignAlg.h:118
createLinkingScheme.iter
iter
Definition: createLinkingScheme.py:62
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
InDetAlignment::CreateMisalignAlg::m_ScalePixelEndcap
double m_ScalePixelEndcap
Definition: CreateMisalignAlg.h:105
add-xsec-uncert-quadrature-N.alpha
alpha
Definition: add-xsec-uncert-quadrature-N.py:110
python.SystemOfUnits.mm
float mm
Definition: SystemOfUnits.py:98
IOVTime::MAXRUN
static constexpr uint32_t MAXRUN
Definition: IOVTime.h:48
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
InDetAlignment::CreateMisalignAlg::m_AlignResults_Identifier_ID
NTuple::Item< long > m_AlignResults_Identifier_ID
ID information for this module.
Definition: CreateMisalignAlg.h:126
InDetDD::SiDetectorElementCollection
Definition: SiDetectorElementCollection.h:27
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:138
InDetAlignment::CreateMisalignAlg::m_local_translation
std::vector< double > m_local_translation
Specify misalignment with translation.
Definition: CreateMisalignAlg.h:84
InDetAlignment::CreateMisalignAlg::m_Initial_center_z
NTuple::Item< double > m_Initial_center_z
Initial global center of module.
Definition: CreateMisalignAlg.h:135
InDetAlignment::CreateMisalignAlg::m_Misalign_gamma
Gaudi::Property< double > m_Misalign_gamma
Definition: CreateMisalignAlg.h:92
AtlasDetectorID::is_sct
bool is_sct(Identifier id) const
Definition: AtlasDetectorID.h:765
PixelID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: PixelID.h:615
xAOD::deltaPhi
setSAddress setEtaMS setDirPhiMS setDirZMS setBarrelRadius setEndcapAlpha setEndcapRadius setInterceptInner setEtaMap setEtaBin setIsTgcFailure setDeltaPt deltaPhi
Definition: L2StandAloneMuon_v1.cxx:161
InDetAlignment::CreateMisalignAlg::m_pixelDetEleCollKey
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection > m_pixelDetEleCollKey
Definition: CreateMisalignAlg.h:165
TRTCalib_cfilter.p1
p1
Definition: TRTCalib_cfilter.py:130
InDetAlignment::CreateMisalignAlg::m_Misalign_beta
Gaudi::Property< double > m_Misalign_beta
Definition: CreateMisalignAlg.h:91
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:108
InDetAlignment::CreateMisalignAlg::m_AlignResults_gamma
NTuple::Item< double > m_AlignResults_gamma
AP rotation around z-axis.
Definition: CreateMisalignAlg.h:125
InDetAlignment::CreateMisalignAlg::m_index
std::string m_index
Generate misalignment according to module indices.
Definition: CreateMisalignAlg.h:86
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:157
InDetAlignment::CreateMisalignAlg::m_ScaleSCTBarrel
double m_ScaleSCTBarrel
Definition: CreateMisalignAlg.h:106
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:777
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:129
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
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:629
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:131
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:112
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
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:163
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:128
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
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:124
PixelID::is_barrel
bool is_barrel(const Identifier &id) const
Test for barrel - WARNING: id MUST be pixel id, otherwise answer is not accurate. Use SiliconID for g...
Definition: PixelID.h:601
InDetAlignment::CreateMisalignAlg::m_RndmMisalignWidth_beta
Gaudi::Property< double > m_RndmMisalignWidth_beta
Definition: CreateMisalignAlg.h:97
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:209
PixelID::wafer_hash
IdentifierHash wafer_hash(Identifier wafer_id) const
wafer hash from id
Definition: PixelID.h:383
InDetAlignment::CreateMisalignAlg::m_trtDetEleCollKey
SG::ReadCondHandleKey< InDetDD::TRT_DetElementContainer > m_trtDetEleCollKey
Definition: CreateMisalignAlg.h:167
InDetAlignment::CreateMisalignAlg::m_RndmMisalignWidth_gamma
Gaudi::Property< double > m_RndmMisalignWidth_gamma
Definition: CreateMisalignAlg.h:98
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:1121
InDetDD::SiDetectorElement::moduleTransform
const Amg::Transform3D & moduleTransform() const
Module to global frame transform.
Definition: SiDetectorElement.cxx:173
TrigVtx::gamma
@ gamma
Definition: TrigParticleTable.h:27
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:115
lumiFormat.i
int i
Definition: lumiFormat.py:85
z
#define z
InDetAlignment::CreateMisalignAlg::m_trtIdHelper
const TRT_ID * m_trtIdHelper
Definition: CreateMisalignAlg.h:68
python.SystemOfUnits.micrometer
float micrometer
Definition: SystemOfUnits.py:80
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:130
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
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:327
InDetAlignment::CreateMisalignAlg::m_AlignResults_x
NTuple::Item< double > m_AlignResults_x
Alignment parameter sensitive coordinate.
Definition: CreateMisalignAlg.h:120
InDetAlignment::CreateMisalignAlg::m_Misalign_x
Gaudi::Property< double > m_Misalign_x
Definition: CreateMisalignAlg.h:87
InDetAlignment::CreateMisalignAlg::m_RndmMisalignWidth_z
Gaudi::Property< double > m_RndmMisalignWidth_z
Definition: CreateMisalignAlg.h:95
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:109
InDetAlignment::CreateMisalignAlg::m_translation
std::vector< double > m_translation
Flag which turns on misalignment with translation.
Definition: CreateMisalignAlg.h:82
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
TRT_ID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: TRT_ID.h:860
TRT_ID::straw_layer
int straw_layer(const Identifier &id) const
Definition: TRT_ID.h:887
InDetAlignment::CreateMisalignAlg::m_ScaleSCTEndcap
double m_ScaleSCTEndcap
Definition: CreateMisalignAlg.h:107
TRT_ID::layer_or_wheel
int layer_or_wheel(const Identifier &id) const
Definition: TRT_ID.h:878
compareGeometries.deltaX
float deltaX
Definition: compareGeometries.py:32
InDetAlignment::CreateMisalignAlg::m_doPix
bool m_doPix
Definition: CreateMisalignAlg.h:161
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:162
InDetAlignment::CreateMisalignAlg::m_IBLBowingTshift
double m_IBLBowingTshift
The relative temp shift of set point that intriduces bowing (sign is important)
Definition: CreateMisalignAlg.h:103
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:104
PixelID::layer_disk
int layer_disk(const Identifier &id) const
Definition: PixelID.h:622
InDetAlignment::CreateMisalignAlg::setupTRT_AlignModule
void setupTRT_AlignModule(int &)
Definition: CreateMisalignAlg.cxx:379
PixelID::eta_module
int eta_module(const Identifier &id) const
Definition: PixelID.h:647
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:133
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:121
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:101
python.SystemOfUnits.mrad
float mrad
Definition: SystemOfUnits.py:127
InDetAlignment::CreateMisalignAlg::getBowingMagParam
double getBowingMagParam(double temp_shift)
Definition: CreateMisalignAlg.cxx:1112
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:869
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:122
InDetAlignment::CreateMisalignAlg::reduceTRTID
const Identifier reduceTRTID(Identifier id)
Definition: CreateMisalignAlg.cxx:1074
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:608
InDetAlignment::CreateMisalignAlg::m_Global_center_y
NTuple::Item< double > m_Global_center_y
Misaligned global center of module.
Definition: CreateMisalignAlg.h:139
InDetAlignment::CreateMisalignAlg::m_Misalign_maxShift
double m_Misalign_maxShift
Maximum shift for global modes.
Definition: CreateMisalignAlg.h:99
InDetAlignment::CreateMisalignAlg::m_local_rotation
std::vector< double > m_local_rotation
Specify misalignment with rotation.
Definition: CreateMisalignAlg.h:85
InDetAlignment::CreateMisalignAlg::m_Initial_center_y
NTuple::Item< double > m_Initial_center_y
Initial global center of module.
Definition: CreateMisalignAlg.h:134
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:851
InDetAlignment::CreateMisalignAlg::m_SCTDetEleCollKey
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection > m_SCTDetEleCollKey
Definition: CreateMisalignAlg.h:166
a
TList * a
Definition: liststreamerinfos.cxx:10
h
InDetAlignment::CreateMisalignAlg::m_RndmMisalignWidth_alpha
Gaudi::Property< double > m_RndmMisalignWidth_alpha
Definition: CreateMisalignAlg.h:96
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:360
CaloCondBlobAlgs_fillNoiseFromASCII.hash
dictionary hash
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:108
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:90
python.Constants.INFO
int INFO
Definition: Control/AthenaCommon/python/Constants.py:15
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:88
InDetAlignment::CreateMisalignAlg::m_AlignResults_Identifier_PixelSCT
NTuple::Item< long > m_AlignResults_Identifier_PixelSCT
ID information for this module.
Definition: CreateMisalignAlg.h:127
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:140
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
InDetAlignment::CreateMisalignAlg::setupSCT_AlignModule
void setupSCT_AlignModule(int &)
Definition: CreateMisalignAlg.cxx:277
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:26
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
beamspotnt.nt
def nt
Definition: bin/beamspotnt.py:1062
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:100
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:640
InDetAlignment::CreateMisalignAlg::GenerateMisaligment
StatusCode GenerateMisaligment()
the main function which calculates and applies a transformation to each detector element
Definition: CreateMisalignAlg.cxx:448
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
InDetDD::SiDetectorElementCollection::getDetectorElement
const SiDetectorElement * getDetectorElement(const IdentifierHash &hash) const
Definition: SiDetectorElementCollection.cxx:9
InDetAlignment::CreateMisalignAlg::m_rotation
std::vector< double > m_rotation
Flag which turns on misalignment with rotation.
Definition: CreateMisalignAlg.h:83
InDetAlignment::CreateMisalignAlg::m_RndmMisalignWidth_x
Gaudi::Property< double > m_RndmMisalignWidth_x
Definition: CreateMisalignAlg.h:93
TSU::T
unsigned long long T
Definition: L1TopoDataTypes.h:35
InDetAlignment::CreateMisalignAlg::m_AthenaHashedID
int m_AthenaHashedID
Definition: CreateMisalignAlg.h:117
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:442
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 Fri Sep 26 2025 22:00:38 for ATLAS Offline Software by   doxygen 1.8.18