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 > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

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

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

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

Private Attributes

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

Detailed Description

Definition at line 46 of file CreateMisalignAlg.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ CreateMisalignAlg()

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

Standard Athena-Algorithm Constructor.

Definition at line 71 of file CreateMisalignAlg.cxx.

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

◆ ~CreateMisalignAlg()

InDetAlignment::CreateMisalignAlg::~CreateMisalignAlg ( )

Default Destructor.

Definition at line 124 of file CreateMisalignAlg.cxx.

125  {
126  ATH_MSG_DEBUG( "CreateMisalignAlg destructor called" );
127  }

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

1021  {
1022  HepGeom::Vector3D<double> AlignShift(AlignParams[0],AlignParams[1],AlignParams[2]);
1023  CLHEP::HepRotation AlignRot;
1024 
1025  AlignRot = CLHEP::HepRotationX(AlignParams[3]) * CLHEP::HepRotationY(AlignParams[4]) * CLHEP::HepRotationZ(AlignParams[5]);
1026 
1027  HepGeom::Transform3D AlignTransform = HepGeom::Transform3D(AlignRot,AlignShift);
1028  return AlignTransform;
1029  }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

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

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

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

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

Definition at line 245 of file AthCommonDataStore.h.

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

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

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

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

Definition at line 221 of file AthCommonDataStore.h.

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

◆ declareProperty() [3/6]

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

Definition at line 259 of file AthCommonDataStore.h.

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

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

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

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

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

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

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

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode InDetAlignment::CreateMisalignAlg::execute ( )

standard Athena-Algorithm method

Definition at line 218 of file CreateMisalignAlg.cxx.

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

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

257  {
258  ATH_MSG_DEBUG("CreateMisalignAlg finalize()" );
259 
260  m_ModuleList.clear();
261 
262  return StatusCode::SUCCESS;
263  }

◆ GenerateMisaligment()

StatusCode InDetAlignment::CreateMisalignAlg::GenerateMisaligment ( )
private

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

Definition at line 437 of file CreateMisalignAlg.cxx.

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

◆ getBowingMagParam()

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

Definition at line 1070 of file CreateMisalignAlg.cxx.

1071  {
1072  // IBL staves are straight at a set point of 15 degrees.
1073  // Get set point value to use for magnitude parameter from temp_shift starting at 15 degrees
1074  double T = 15 + temp_shift;
1075  return 1.53e-12 - 1.02e-13*T;
1076  }

◆ getBowingTx()

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

Definition at line 1079 of file CreateMisalignAlg.cxx.

1080  {
1081  // Bowing fit function has the following form
1082  // [0]-[1]*(x+[2]) * (4.0*[2]*(x+[2])**2 - (x+[2])**3 - (2.0*[2])**3)
1083  // param 0 : is the baseline shift (fixed at 0 for MC)
1084  // param 1 : is the magnitude fit param (temp dependent input param)
1085  // param 2 : is the stave fix pointat both ends (fixed at 366.5)
1086  double p0 = 0;
1087  double p2 = 366.5;
1088  double Tx = p0 - p1*(z+p2) * (4.*p2*pow((z+p2),2) - pow((z+p2),3) - pow((2.*p2),3));
1089  return Tx;
1090  }

◆ initialize()

StatusCode InDetAlignment::CreateMisalignAlg::initialize ( )

standard Athena-Algorithm method

Definition at line 130 of file CreateMisalignAlg.cxx.

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

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

1033  {
1034  // msg(MSG::DEBUG) << "in CreateMisalignAlg::reduceTRTID" << endmsg;
1035  ATH_MSG_DEBUG( "reduceTRTID got Id " << m_idHelper->show_to_string(id,nullptr,'/'));
1036 
1037  int barrel_ec= m_trtIdHelper->barrel_ec(id);
1038  // attention: TRT DB only has one alignment correction per barrel module (+1/-1) pair
1039  // which is stored in -1 identifier
1040  if (barrel_ec==1) barrel_ec=-1; //only regard -1 barrel modules, +1 modules will belong to them
1041 
1042  //if (abs(barrel_ec)==2) phi_module=0;
1043  // only regard phi sector 0, the only one having an alignmentTrafo
1044  //does not work, since the center-of-mass of all phi sectors is on the beamline,so
1045  // transformations would become zero -> this has to be handled later
1046  int phi_module=m_trtIdHelper->phi_module(id);
1047 
1048  int layer_or_wheel=m_trtIdHelper->layer_or_wheel(id);
1049 
1050  int strawlayer=0;
1051  if (!m_trtIdHelper->is_barrel(id)) {
1052  strawlayer = m_trtIdHelper->straw_layer(id) / 4 * 4;
1053  // only strawlayers 0,4,8,12 are fed into DB for endcap
1054  }
1055 
1056  // 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;
1057  ATH_MSG_DEBUG( " and returns Id " << m_idHelper->show_to_string(m_trtIdHelper->layer_id(barrel_ec,phi_module,layer_or_wheel,strawlayer),nullptr,'/'));
1058  // return m_trtIdHelper->module_id(barrel_ec,phi_module,layer_or_wheel);
1059  return m_trtIdHelper->layer_id(barrel_ec,phi_module,layer_or_wheel,strawlayer);
1060  }

◆ reduceTRTID() [2/2]

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

Definition at line 1063 of file CreateMisalignAlg.cxx.

1064  {
1065  Identifier id= m_trtIdHelper->module_id(hash);
1066  return reduceTRTID(id);
1067  }

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

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

◆ setupSCT_AlignModule()

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

Definition at line 266 of file CreateMisalignAlg.cxx.

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

◆ setupTRT_AlignModule()

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

Definition at line 368 of file CreateMisalignAlg.cxx.

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

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

◆ m_AlignResults_beta

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

AP rotation aorund y-axis.

Definition at line 119 of file CreateMisalignAlg.h.

◆ m_AlignResults_gamma

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

AP rotation around z-axis.

Definition at line 120 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 123 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 126 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 121 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 124 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 125 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 122 of file CreateMisalignAlg.h.

◆ m_AlignResults_x

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

Alignment parameter sensitive coordinate.

Definition at line 115 of file CreateMisalignAlg.h.

◆ m_AlignResults_y

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

AP not-so-sensitive coordinate.

Definition at line 116 of file CreateMisalignAlg.h.

◆ m_AlignResults_z

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

AP normal to module plane.

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

◆ m_doStrip

bool InDetAlignment::CreateMisalignAlg::m_doStrip
private

Definition at line 157 of file CreateMisalignAlg.h.

◆ m_doTRT

bool InDetAlignment::CreateMisalignAlg::m_doTRT
private

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

◆ m_HumanReadableID

int InDetAlignment::CreateMisalignAlg::m_HumanReadableID
private

Definition at line 113 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 98 of file CreateMisalignAlg.h.

◆ m_IDAlignDBTool

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

Definition at line 70 of file CreateMisalignAlg.h.

◆ m_idHelper

const AtlasDetectorID* InDetAlignment::CreateMisalignAlg::m_idHelper
private

Definition at line 65 of file CreateMisalignAlg.h.

◆ m_Initial_center_x

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

Initial global center of module.

Definition at line 128 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 129 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 130 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 85 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 86 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 87 of file CreateMisalignAlg.h.

◆ m_Misalign_maxShift

double InDetAlignment::CreateMisalignAlg::m_Misalign_maxShift
private

Maximum shift for global modes.

Definition at line 94 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 95 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 82 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 83 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 84 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 107 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 160 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 91 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 92 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 93 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 88 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 89 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 90 of file CreateMisalignAlg.h.

◆ m_ScalePixelBarrel

double InDetAlignment::CreateMisalignAlg::m_ScalePixelBarrel
private

Definition at line 99 of file CreateMisalignAlg.h.

◆ m_ScalePixelDBM

double InDetAlignment::CreateMisalignAlg::m_ScalePixelDBM
private

Definition at line 97 of file CreateMisalignAlg.h.

◆ m_ScalePixelEndcap

double InDetAlignment::CreateMisalignAlg::m_ScalePixelEndcap
private

Definition at line 100 of file CreateMisalignAlg.h.

◆ m_ScalePixelIBL

double InDetAlignment::CreateMisalignAlg::m_ScalePixelIBL
private

Definition at line 96 of file CreateMisalignAlg.h.

◆ m_ScaleSCTBarrel

double InDetAlignment::CreateMisalignAlg::m_ScaleSCTBarrel
private

Definition at line 101 of file CreateMisalignAlg.h.

◆ m_ScaleSCTEndcap

double InDetAlignment::CreateMisalignAlg::m_ScaleSCTEndcap
private

Definition at line 102 of file CreateMisalignAlg.h.

◆ m_ScaleTRTBarrel

double InDetAlignment::CreateMisalignAlg::m_ScaleTRTBarrel
private

Definition at line 103 of file CreateMisalignAlg.h.

◆ m_ScaleTRTEndcap

double InDetAlignment::CreateMisalignAlg::m_ScaleTRTEndcap
private

Definition at line 104 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 161 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_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 162 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 110 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:89
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
AtlasDetectorID::is_pixel
bool is_pixel(Identifier id) const
Definition: AtlasDetectorID.h:760
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
InDetAlignment::CreateMisalignAlg::m_Misalign_z
Gaudi::Property< double > m_Misalign_z
Definition: CreateMisalignAlg.h:84
beamspotman.r
def r
Definition: beamspotman.py:676
InDetAlignment::CreateMisalignAlg::m_ScalePixelDBM
double m_ScalePixelDBM
Definition: CreateMisalignAlg.h:97
InDetAlignment::CreateMisalignAlg::m_AlignResults_alpha
NTuple::Item< double > m_AlignResults_alpha
AP rotation around x-axis.
Definition: CreateMisalignAlg.h:118
TRT_ID::layer_id
Identifier layer_id(int barrel_ec, int phi_module, int layer_or_wheel, int straw_layer) const
For an individual straw layer.
Definition: TRT_ID.h:500
InDetAlignment::CreateMisalignAlg::m_HumanReadableID
int m_HumanReadableID
Definition: CreateMisalignAlg.h:113
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
InDetAlignment::CreateMisalignAlg::m_ScalePixelEndcap
double m_ScalePixelEndcap
Definition: CreateMisalignAlg.h:100
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:121
InDetDD::SiDetectorElementCollection
Definition: SiDetectorElementCollection.h:30
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
InDetAlignment::CreateMisalignAlg::m_Global_center_x
NTuple::Item< double > m_Global_center_x
Misaligned global center of module.
Definition: CreateMisalignAlg.h:133
InDetAlignment::CreateMisalignAlg::m_Initial_center_z
NTuple::Item< double > m_Initial_center_z
Initial global center of module.
Definition: CreateMisalignAlg.h:130
InDetAlignment::CreateMisalignAlg::m_Misalign_gamma
Gaudi::Property< double > m_Misalign_gamma
Definition: CreateMisalignAlg.h:87
AtlasDetectorID::is_sct
bool is_sct(Identifier id) const
Definition: AtlasDetectorID.h:770
PixelID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: PixelID.h:619
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
xAOD::deltaPhi
setSAddress setEtaMS setDirPhiMS setDirZMS setBarrelRadius setEndcapAlpha setEndcapRadius setInterceptInner setEtaMap setEtaBin setIsTgcFailure setDeltaPt deltaPhi
Definition: L2StandAloneMuon_v1.cxx:160
InDetAlignment::CreateMisalignAlg::m_pixelDetEleCollKey
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection > m_pixelDetEleCollKey
Definition: CreateMisalignAlg.h:160
conifer::pow
constexpr int pow(int x)
Definition: conifer.h:20
TRTCalib_cfilter.p1
p1
Definition: TRTCalib_cfilter.py:130
InDetAlignment::CreateMisalignAlg::m_Misalign_beta
Gaudi::Property< double > m_Misalign_beta
Definition: CreateMisalignAlg.h:86
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:103
InDetAlignment::CreateMisalignAlg::m_AlignResults_gamma
NTuple::Item< double > m_AlignResults_gamma
AP rotation around z-axis.
Definition: CreateMisalignAlg.h:120
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:158
InDetAlignment::CreateMisalignAlg::m_ScaleSCTBarrel
double m_ScaleSCTBarrel
Definition: CreateMisalignAlg.h:101
SCT_ID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: SCT_ID.h:728
InDetAlignment::CreateMisalignAlg::m_SQLiteTag
std::string m_SQLiteTag
tag name for the ConditionsDB
Definition: CreateMisalignAlg.h:75
AtlasDetectorID::is_trt
bool is_trt(Identifier id) const
Definition: AtlasDetectorID.h:782
SCT_ID::phi_module
int phi_module(const Identifier &id) const
Definition: SCT_ID.h:740
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
InDetAlignment::CreateMisalignAlg::m_AlignResults_Identifier_LayerDisc
NTuple::Item< long > m_AlignResults_Identifier_LayerDisc
ID information for this module.
Definition: CreateMisalignAlg.h:124
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
python.SystemOfUnits.mrad
int mrad
Definition: SystemOfUnits.py:112
Identifier::is_valid
bool is_valid() const
Check if id is in a valid state.
Identifier32::get_compact
value_type get_compact() const
Get the compact id.
Definition: Identifier32.h:44
SCT_ID::module_id
Identifier module_id(int barrel_ec, int layer_disk, int phi_module, int eta_module) const
For a single crystal.
Definition: SCT_ID.h:416
PixelID::is_blayer
bool is_blayer(const Identifier &id) const
Test for b-layer - WARNING: id MUST be pixel id, otherwise answer is not accurate....
Definition: PixelID.h:633
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
InDetAlignment::CreateMisalignAlg::m_AlignResults_Identifier_Eta
NTuple::Item< long > m_AlignResults_Identifier_Eta
ID information for this module.
Definition: CreateMisalignAlg.h:126
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:107
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:27
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:158
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:123
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:119
PixelID::is_barrel
bool is_barrel(const Identifier &id) const
Test for barrel - WARNING: id MUST be pixel id, otherwise answer is not accurate. Use SiliconID for g...
Definition: PixelID.h:605
InDetAlignment::CreateMisalignAlg::m_RndmMisalignWidth_beta
Gaudi::Property< double > m_RndmMisalignWidth_beta
Definition: CreateMisalignAlg.h:92
InDetAlignment::CreateMisalignAlg::m_createFreshDB
bool m_createFreshDB
Flag to call the createDB method of DBTool (to be switched off when adding misalignments to a given g...
Definition: CreateMisalignAlg.h:78
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
PixelID::wafer_hash
IdentifierHash wafer_hash(Identifier wafer_id) const
wafer hash from id
Definition: PixelID.h:387
InDetAlignment::CreateMisalignAlg::m_trtDetEleCollKey
SG::ReadCondHandleKey< InDetDD::TRT_DetElementContainer > m_trtDetEleCollKey
Definition: CreateMisalignAlg.h:162
InDetAlignment::CreateMisalignAlg::m_RndmMisalignWidth_gamma
Gaudi::Property< double > m_RndmMisalignWidth_gamma
Definition: CreateMisalignAlg.h:93
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:1079
InDetDD::SiDetectorElement::moduleTransform
const Amg::Transform3D & moduleTransform() const
Module to global frame transform.
Definition: SiDetectorElement.cxx:173
TrigVtx::gamma
@ gamma
Definition: TrigParticleTable.h:26
InDetAlignment::CreateMisalignAlg::m_asciiFileNameBase
std::string m_asciiFileNameBase
filename basis for ASCII files with alignment constants
Definition: CreateMisalignAlg.h:74
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
InDetAlignment::CreateMisalignAlg::m_VisualizationLookupTree
TTree * m_VisualizationLookupTree
Definition: CreateMisalignAlg.h:110
lumiFormat.i
int i
Definition: lumiFormat.py:85
z
#define z
InDetAlignment::CreateMisalignAlg::m_trtIdHelper
const TRT_ID * m_trtIdHelper
Definition: CreateMisalignAlg.h:68
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
InDetAlignment::CreateMisalignAlg::m_AlignResults_Identifier_Phi
NTuple::Item< long > m_AlignResults_Identifier_Phi
ID information for this module.
Definition: CreateMisalignAlg.h:125
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:316
InDetAlignment::CreateMisalignAlg::m_AlignResults_x
NTuple::Item< double > m_AlignResults_x
Alignment parameter sensitive coordinate.
Definition: CreateMisalignAlg.h:115
InDetAlignment::CreateMisalignAlg::m_Misalign_x
Gaudi::Property< double > m_Misalign_x
Definition: CreateMisalignAlg.h:82
InDetAlignment::CreateMisalignAlg::m_RndmMisalignWidth_z
Gaudi::Property< double > m_RndmMisalignWidth_z
Definition: CreateMisalignAlg.h:90
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:104
SCT_ID::wafer_hash
IdentifierHash wafer_hash(const Identifier &wafer_id) const
wafer hash from id - optimized
Definition: SCT_ID.h:492
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
python.SystemOfUnits.micrometer
int micrometer
Definition: SystemOfUnits.py:71
TRT_ID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: TRT_ID.h:866
TRT_ID::straw_layer
int straw_layer(const Identifier &id) const
Definition: TRT_ID.h:893
InDetAlignment::CreateMisalignAlg::m_ScaleSCTEndcap
double m_ScaleSCTEndcap
Definition: CreateMisalignAlg.h:102
TRT_ID::layer_or_wheel
int layer_or_wheel(const Identifier &id) const
Definition: TRT_ID.h:884
compareGeometries.deltaX
float deltaX
Definition: compareGeometries.py:32
InDetAlignment::CreateMisalignAlg::m_doPix
bool m_doPix
Definition: CreateMisalignAlg.h:156
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:157
InDetAlignment::CreateMisalignAlg::m_IBLBowingTshift
double m_IBLBowingTshift
The relative temp shift of set point that intriduces bowing (sign is important)
Definition: CreateMisalignAlg.h:98
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:99
PixelID::layer_disk
int layer_disk(const Identifier &id) const
Definition: PixelID.h:626
InDetAlignment::CreateMisalignAlg::setupTRT_AlignModule
void setupTRT_AlignModule(int &)
Definition: CreateMisalignAlg.cxx:368
PixelID::eta_module
int eta_module(const Identifier &id) const
Definition: PixelID.h:651
InDetDD::StripStereoAnnulusDesign::sensorCenter
virtual Amg::Vector3D sensorCenter() const override
Return the centre of a sensor in the local reference frame.
Definition: StripStereoAnnulusDesign.cxx:262
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
InDetAlignment::CreateMisalignAlg::m_Initial_center_x
NTuple::Item< double > m_Initial_center_x
Initial global center of module.
Definition: CreateMisalignAlg.h:128
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
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:116
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:96
InDetAlignment::CreateMisalignAlg::getBowingMagParam
double getBowingMagParam(double temp_shift)
Definition: CreateMisalignAlg.cxx:1070
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
TRT_ID::phi_module
int phi_module(const Identifier &id) const
Definition: TRT_ID.h:875
IOVTime::MINEVENT
static constexpr uint32_t MINEVENT
Definition: IOVTime.h:50
InDetAlignment::CreateMisalignAlg::m_AlignResults_z
NTuple::Item< double > m_AlignResults_z
AP normal to module plane.
Definition: CreateMisalignAlg.h:117
InDetAlignment::CreateMisalignAlg::reduceTRTID
const Identifier reduceTRTID(Identifier id)
Definition: CreateMisalignAlg.cxx:1032
python.SystemOfUnits.mm
int mm
Definition: SystemOfUnits.py:83
PixelID::is_dbm
bool is_dbm(const Identifier &id) const
Test for dbm - WARNING: id MUST be pixel id, otherwise answer is not accurate. Use SiliconID for gene...
Definition: PixelID.h:612
InDetAlignment::CreateMisalignAlg::m_Global_center_y
NTuple::Item< double > m_Global_center_y
Misaligned global center of module.
Definition: CreateMisalignAlg.h:134
InDetAlignment::CreateMisalignAlg::m_Misalign_maxShift
double m_Misalign_maxShift
Maximum shift for global modes.
Definition: CreateMisalignAlg.h:94
InDetAlignment::CreateMisalignAlg::m_Initial_center_y
NTuple::Item< double > m_Initial_center_y
Initial global center of module.
Definition: CreateMisalignAlg.h:129
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
TRT_ID::is_barrel
bool is_barrel(const Identifier &id) const
Test for barrel.
Definition: TRT_ID.h:857
InDetAlignment::CreateMisalignAlg::m_SCTDetEleCollKey
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection > m_SCTDetEleCollKey
Definition: CreateMisalignAlg.h:161
a
TList * a
Definition: liststreamerinfos.cxx:10
h
InDetAlignment::CreateMisalignAlg::m_RndmMisalignWidth_alpha
Gaudi::Property< double > m_RndmMisalignWidth_alpha
Definition: CreateMisalignAlg.h:91
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:574
CaloCondBlobAlgs_fillNoiseFromASCII.hash
dictionary hash
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:109
InDetAlignment::CreateMisalignAlg::m_nEvents
long int m_nEvents
Definition: CreateMisalignAlg.h:81
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
InDetAlignment::CreateMisalignAlg::m_Misalign_alpha
Gaudi::Property< double > m_Misalign_alpha
Definition: CreateMisalignAlg.h:85
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:83
InDetAlignment::CreateMisalignAlg::m_AlignResults_Identifier_PixelSCT
NTuple::Item< long > m_AlignResults_Identifier_PixelSCT
ID information for this module.
Definition: CreateMisalignAlg.h:122
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:623
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:135
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
InDetAlignment::CreateMisalignAlg::setupSCT_AlignModule
void setupSCT_AlignModule(int &)
Definition: CreateMisalignAlg.cxx:266
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
InDetDD::TRT_DetElementCollection
Class to hold collection of TRT detector elements.
Definition: TRT_DetElementCollection.h:28
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
beamspotnt.nt
def nt
Definition: bin/beamspotnt.py:1063
InDetAlignment::CreateMisalignAlg::m_Misalign_maxShift_Inner
double m_Misalign_maxShift_Inner
Maximum shift of the Pixel B-layer in curl (d0 bias!)
Definition: CreateMisalignAlg.h:95
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
makeComparison.deltaZ
int deltaZ
Definition: makeComparison.py:46
MuonParameters::beta
@ beta
Definition: MuonParamDefs.h:144
InDetDD::SiDetectorElement::design
virtual const SiDetectorDesign & design() const override final
access to the local description (inline):
PixelID::phi_module
int phi_module(const Identifier &id) const
Definition: PixelID.h:644
InDetAlignment::CreateMisalignAlg::GenerateMisaligment
StatusCode GenerateMisaligment()
the main function which calculates and applies a transformation to each detector element
Definition: CreateMisalignAlg.cxx:437
ntupleSvc
INTupleSvc * ntupleSvc()
Definition: ServiceAccessor.h:14
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
makeComparison.deltaR
float deltaR
Definition: makeComparison.py:36
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
InDetDD::SiDetectorElementCollection::getDetectorElement
const SiDetectorElement * getDetectorElement(const IdentifierHash &hash) const
Definition: SiDetectorElementCollection.cxx:15
InDetAlignment::CreateMisalignAlg::m_RndmMisalignWidth_x
Gaudi::Property< double > m_RndmMisalignWidth_x
Definition: CreateMisalignAlg.h:88
TSU::T
unsigned long long T
Definition: L1TopoDataTypes.h:35
InDetAlignment::CreateMisalignAlg::m_AthenaHashedID
int m_AthenaHashedID
Definition: CreateMisalignAlg.h:112
TRTCalib_cfilter.p0
p0
Definition: TRTCalib_cfilter.py:129
fitman.k
k
Definition: fitman.py:528
InDetDD::TRT_BaseElement
Definition: TRT_BaseElement.h:57
TRT_ID::module_id
Identifier module_id(int barrel_ec, int phi_module, int layer_or_wheel) const
For an individual module phi sector.
Definition: TRT_ID.h:448
SCT_ID::is_barrel
bool is_barrel(const Identifier &id) const
Test for barrel - WARNING: id MUST be sct id, otherwise answer is not accurate. Use SiliconID for gen...
Definition: SCT_ID.h:721
ServiceHandle< ICondSvc >
InDetAlignment::CreateMisalignAlg::m_MisalignmentMode
int m_MisalignmentMode
Flag which Misalignment mode is to be generated.
Definition: CreateMisalignAlg.h:80
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Thu Nov 7 2024 22:16:09 for ATLAS Offline Software by   doxygen 1.8.18