InDetAlignment::CreateMisalignAlg Class Reference

#include <CreateMisalignAlg.h>

Inheritance diagram for InDetAlignment::CreateMisalignAlg:

Public Member Functions
	CreateMisalignAlg (const std::string &name, ISvcLocator *pSvcLocator)
	Standard Athena-Algorithm Constructor.
	~CreateMisalignAlg ()
	Default Destructor.
StatusCode	initialize ()
	standard Athena-Algorithm method
StatusCode	execute (const EventContext &ctx)
	standard Athena-Algorithm method
StatusCode	finalize ()
	standard Athena-Algorithm method
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
bool	filterPassed (const EventContext &ctx) const
void	setFilterPassed (bool state, const EventContext &ctx) const
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
const EventContext &	getContext () const
	Deprecated methods (use the ones with EventContext).
bool	filterPassed () const
void	setFilterPassed (bool state) const

Protected Member Functions
virtual bool	isReEntrant () const override final
	Legacy algorithms are not thread-safe.
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
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.

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
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
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

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
std::string	m_SQLiteTag
	tag name for the ConditionsDB
bool	m_firstEvent
	Flag for Setup of AlignModuleList (1st event).
bool	m_createFreshDB
	Flag to call the createDB method of DBTool (to be switched off when adding misalignments to a given geometry).
int	m_MisalignmentMode
	Flag which Misalignment mode is to be generated.
long int	m_nEvents
std::vector< double >	m_translation
	Flag which turns on misalignment with translation.
std::vector< double >	m_rotation
	Flag which turns on misalignment with rotation.
std::vector< double >	m_local_translation
	Specify misalignment with translation.
std::vector< double >	m_local_rotation
	Specify misalignment with rotation.
std::string	m_index
	Generate misalignment according to module indices.
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.
double	m_Misalign_maxShift_Inner
	Maximum shift of the Pixel B-layer in curl (d0 bias!).
double	m_ScalePixelIBL
double	m_ScalePixelDBM
double	m_IBLBowingTshift
	The relative temp shift of set point that intriduces bowing (sign is important).
int	m_targetLayer
	ITk barrel layer selector for dedicated ITk modes (-1 means all layers).
int	m_targetLayerMax
	Upper ITk barrel layer selector for layer-range modes (-999 means unused).
std::string	m_endcapShiftConvention
	Endcap z-shift convention for mode 41.
double	m_radialShift
	Barrel radial shift for mode 43.
std::string	m_radialShiftConvention
	Barrel radial shift convention for mode 43.
std::string	m_radialSubdetector
	Subdetector selector for mode 43: Pixel, Strip, or Both.
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
TTree *	m_VisualizationLookupTree
int	m_AthenaHashedID
int	m_HumanReadableID
NTuple::Item< double >	m_AlignResults_x
	Alignment parameter sensitive coordinate.
NTuple::Item< double >	m_AlignResults_y
	AP not-so-sensitive coordinate.
NTuple::Item< double >	m_AlignResults_z
	AP normal to module plane.
NTuple::Item< double >	m_AlignResults_alpha
	AP rotation around x-axis.
NTuple::Item< double >	m_AlignResults_beta
	AP rotation aorund y-axis.
NTuple::Item< double >	m_AlignResults_gamma
	AP rotation around z-axis.
NTuple::Item< long >	m_AlignResults_Identifier_ID
	ID information for this module.
NTuple::Item< long >	m_AlignResults_Identifier_PixelSCT
	ID information for this module.
NTuple::Item< long >	m_AlignResults_Identifier_BarrelEC
	ID information for this module.
NTuple::Item< long >	m_AlignResults_Identifier_LayerDisc
	ID information for this module.
NTuple::Item< long >	m_AlignResults_Identifier_Phi
	ID information for this module.
NTuple::Item< long >	m_AlignResults_Identifier_Eta
	ID information for this module.
NTuple::Item< double >	m_Initial_center_x
	Initial global center of module.
NTuple::Item< double >	m_Initial_center_y
	Initial global center of module.
NTuple::Item< double >	m_Initial_center_z
	Initial global center of module.
NTuple::Item< double >	m_Global_center_x
	Misaligned global center of module.
NTuple::Item< double >	m_Global_center_y
	Misaligned global center of module.
NTuple::Item< double >	m_Global_center_z
	Misaligned global center of module.
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).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
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< Gaudi::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.

                                                                                       :
    AthAlgorithm(name,pSvcLocator),
    m_idHelper(nullptr),
    m_pixelIdHelper(nullptr),
    m_sctIdHelper(nullptr),
    m_trtIdHelper(nullptr),
    m_IDAlignDBTool("InDetAlignDBTool",this),
    m_trtaligndbservice("TRT_AlignDbSvc",name),
    m_asciiFileNameBase("MisalignmentSet"),
    m_SQLiteTag("test_tag"),
    m_firstEvent(true),
    m_createFreshDB(true),
    m_MisalignmentMode(0),
    m_nEvents(0),
    m_translation{0.1, 0.1, 0.1},
    m_rotation{0.1, 0.1, 0.1},
    m_local_translation{0., 0., 0.},
    m_local_rotation{0., 0., 0.},
    m_index(""),
    m_Misalign_maxShift(1*CLHEP::mm),
    m_Misalign_maxShift_Inner(50*CLHEP::micrometer),
    m_ScalePixelIBL(1.),
    m_ScalePixelDBM(1.),
    m_IBLBowingTshift(0.),
    m_targetLayer(0),
    m_targetLayerMax(-999),
    m_endcapShiftConvention("outward"),
    m_radialShift(0.),
    m_radialShiftConvention("outward"),
    m_radialSubdetector("Pixel"),
    m_ScalePixelBarrel(1.),
    m_ScalePixelEndcap(1.),
    m_ScaleSCTBarrel(1.),
    m_ScaleSCTEndcap(1.),
    m_ScaleTRTBarrel(1.),
    m_ScaleTRTEndcap(1.),
    m_VisualizationLookupTree(nullptr),
    m_AthenaHashedID(-1),
    m_HumanReadableID(-1),
    m_doPix(true),
    m_doStrip(true),
    m_doTRT(true)
    {
        declareProperty("ASCIIFilenameBase"             ,     m_asciiFileNameBase);
        declareProperty("SQLiteTag"                     ,     m_SQLiteTag);
        declareProperty("MisalignMode"                  ,     m_MisalignmentMode);
        declareProperty("Translation_Scale"                   ,     m_translation);
        declareProperty("Rotation_Scale"                      ,     m_rotation);
        declareProperty("Local_Translation"                   ,     m_local_translation);
                declareProperty("Local_Rotation"                      ,     m_local_rotation);
        declareProperty("Index"                         ,     m_index);
        declareProperty("MaxShift"                      ,     m_Misalign_maxShift);
        declareProperty("MaxShiftInner"                 ,     m_Misalign_maxShift_Inner);
        declareProperty("CreateFreshDB"                 ,     m_createFreshDB);
        declareProperty("IDAlignDBTool"                 ,     m_IDAlignDBTool);
        declareProperty("TRTAlignDBService"             ,     m_trtaligndbservice);
        declareProperty("ScalePixelIBL"                 ,     m_ScalePixelIBL);
        declareProperty("ScalePixelDBM"                 ,     m_ScalePixelDBM);
        declareProperty("IBLBowingTshift"               ,     m_IBLBowingTshift);
        declareProperty("TargetLayer"                   ,     m_targetLayer);
        declareProperty("TargetLayerMax"                ,     m_targetLayerMax);
        declareProperty("EndcapShiftConvention"         ,     m_endcapShiftConvention);
        declareProperty("RadialShift"                   ,     m_radialShift);
        declareProperty("RadialShiftConvention"         ,     m_radialShiftConvention);
        declareProperty("RadialSubdetector"             ,     m_radialSubdetector);
        declareProperty("ScalePixelBarrel"              ,     m_ScalePixelBarrel);
        declareProperty("ScalePixelEndcap"              ,     m_ScalePixelEndcap);
        declareProperty("ScaleSCTBarrel"                ,     m_ScaleSCTBarrel);
        declareProperty("ScaleSCTEndcap"                ,     m_ScaleSCTEndcap);
        declareProperty("ScaleTRTBarrel"                ,     m_ScaleTRTBarrel);
        declareProperty("ScaleTRTEndcap"                ,     m_ScaleTRTEndcap);
    }

~CreateMisalignAlg()

InDetAlignment::CreateMisalignAlg::~CreateMisalignAlg

(

void

)

Default Destructor.

Definition at line 146 of file CreateMisalignAlg.cxx.

    {
        ATH_MSG_DEBUG( "CreateMisalignAlg destructor called" );
    }

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

    {
        HepGeom::Vector3D<double> AlignShift(AlignParams[0],AlignParams[1],AlignParams[2]);
        CLHEP::HepRotation AlignRot;
        
        AlignRot = CLHEP::HepRotationX(AlignParams[3]) * CLHEP::HepRotationY(AlignParams[4]) * CLHEP::HepRotationZ(AlignParams[5]);
        
        HepGeom::Transform3D AlignTransform = HepGeom::Transform3D(AlignRot,AlignShift);
        return AlignTransform;
    }

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode InDetAlignment::CreateMisalignAlg::execute ( const EventContext & ctx )

virtual

standard Athena-Algorithm method

Implements AthAlgorithm.

Definition at line 240 of file CreateMisalignAlg.cxx.

    {
    ATH_MSG_DEBUG( "AlignAlg execute()" );
        ++m_nEvents;
        
        if (m_firstEvent) {
            int nSCT   = 0;
            int nPixel = 0;
            int nTRT   = 0;
            
            if (m_createFreshDB) {
                m_IDAlignDBTool->createDB();
                //m_trtaligndbservice->createAlignObjects(); //create DB for TRT? should be ok... //TODO
            }
            
            if(m_doPix) setupPixel_AlignModule(nPixel);
            if(m_doStrip) setupSCT_AlignModule(nSCT);
            if(m_doTRT) setupTRT_AlignModule(nTRT);
            
            ATH_MSG_INFO( "Back from AlignModuleObject Setup. " );
            ATH_MSG_INFO(  nPixel << " Pixel modules found." );
            ATH_MSG_INFO(  nSCT   << "  SCT  modules found," );
            ATH_MSG_INFO(  nTRT   << "  TRT  modules found." );
            
            ATH_MSG_INFO( m_ModuleList.size() << " entries in identifier list" );
            
            if (StatusCode::SUCCESS!=GenerateMisaligment()) {
        ATH_MSG_ERROR( "GenerateMisalignment failed!" );
              return StatusCode::FAILURE;
            };
            
            m_firstEvent = false;
        }
        
        return StatusCode::SUCCESS;
    }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::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.

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

filterPassed() [1/2]

bool AthAlgorithm::filterPassed ( ) const

inherited

Definition at line 94 of file AthAlgorithm.cxx.

                                      {
  return filterPassed( Gaudi::Hive::currentContext() );
}

filterPassed() [2/2]

bool AthAlgorithm::filterPassed ( const EventContext & ctx ) const

inherited

Definition at line 98 of file AthAlgorithm.cxx.

                                                             {
  return execState( ctx ).filterPassed();
}

finalize()

StatusCode InDetAlignment::CreateMisalignAlg::finalize

(

)

standard Athena-Algorithm method

Definition at line 278 of file CreateMisalignAlg.cxx.

    {
        ATH_MSG_DEBUG("CreateMisalignAlg finalize()" );
        
        m_ModuleList.clear();
        
        return StatusCode::SUCCESS;
    }

GenerateMisaligment()

StatusCode InDetAlignment::CreateMisalignAlg::GenerateMisaligment ( )

private

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

Definition at line 459 of file CreateMisalignAlg.cxx.

    {
 
      SmartIF<IRndmGenSvc> randsvc{Gaudi::svcLocator()->service("RndmGenSvc")};
      ATH_CHECK(randsvc.isValid());
      ATH_MSG_DEBUG( "Got RndmGenSvc" );
        
      int i = 0;
        
        /*
         ===================================
         Documentation of misalignment modes
         ===================================
         
         MisalignMode =
         0: nothing, no misalignments are generated
         1: Misalignment of whole InDet by 6 parameters
         2: random misalignment
                 3: IBL-stave temperature dependent bowing       
                 41: ITk endcap beam-pipe z shift
                 42: ITk pixel barrel layer bowing
                 43: ITk barrel radial expansion/contraction
 
         ====================================================
         Global Distortions according to David Brown (LHC Detector Alignment Workshop 2006-09-04, slides page 11)
         ====================================================
         11: R delta R:     Radial expansion linearly with r
         12: Phi delta R:   radial expansion sinuisoidally with phi
         13: Z delta R:     radial expansion linearly with z
         21: R delta Phi:   rotation linearly with r
         22: Phi delta Phi: rotation sinusoidally with phi
         23: Z delta Phi:   rotation linearly with z
         31: R delta Z:     z-shift linearly with r
         32: Phi delta Z:   z-shift sinusoidally with phi
         33: Z delta Z:     z-shift linearly with z
         */
        
        const double maxRadius=51.4*CLHEP::cm;   // maximum radius of Silicon Detector (=outermost SCT radius)
        const double minRadius=50.5*CLHEP::mm;   // minimum radius of Silicon Detector (=innermost PIX radius)
        const double maxLength=158.*CLHEP::cm;   // maximum length of Silicon Detector barrel (=length of SCT barrel)
        
        const double maxDeltaR = m_Misalign_maxShift;
        const double maxAngle = 2 * asin( m_Misalign_maxShift / (2*maxRadius));
        const double maxAngleInner = 2 * asin ( m_Misalign_maxShift_Inner / (2*minRadius));
        const double maxDeltaZ = m_Misalign_maxShift;
        ATH_MSG_DEBUG( "maximum deltaPhi              = " << maxAngle/CLHEP::mrad << " mrad" );
        ATH_MSG_DEBUG( "maximum deltaPhi for 1/r term = " << maxAngleInner/CLHEP::mrad << " mrad" );
                const InDetDD::SiDetectorElementCollection* pixelElements=nullptr;
                const InDetDD::SiDetectorElementCollection* sctElements=nullptr;
                if(m_doPix){
                    // SiDetectorElementCollection for Pixel
                    SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> pixelDetEleHandle(m_pixelDetEleCollKey);
                    pixelElements = *pixelDetEleHandle;
                    if (not pixelDetEleHandle.isValid() or pixelElements==nullptr) {
                        ATH_MSG_FATAL(m_pixelDetEleCollKey.fullKey() << " is not available.");
                        return StatusCode::FAILURE;
                    }
                }
                if(m_doStrip){
                    // SiDetectorElementCollection for SCT
                    SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> sctDetEleHandle(m_SCTDetEleCollKey);
                    sctElements = *sctDetEleHandle;
                    if (not sctDetEleHandle.isValid() or sctElements==nullptr) {
                        ATH_MSG_FATAL(m_SCTDetEleCollKey.fullKey() << " is not available.");
                        return StatusCode::FAILURE;
                    }
                }
 
                double mode42BowingAnchorAbsZ = 0.;
                if (m_MisalignmentMode == 42) {
                  for (std::map<Identifier, HepGeom::Point3D<double> >::const_iterator anchorIter = m_ModuleList.begin();
                       anchorIter != m_ModuleList.end(); ++anchorIter) {
                    const Identifier& anchorModuleID = anchorIter->first;
                    if (m_idHelper->is_pixel(anchorModuleID) &&
                        m_pixelIdHelper->is_barrel(anchorModuleID) &&
                        m_pixelIdHelper->layer_disk(anchorModuleID) == m_targetLayer) {
                      const double absZ = std::abs(anchorIter->second.z());
                      if (absZ > mode42BowingAnchorAbsZ) mode42BowingAnchorAbsZ = absZ;
                    }
                  }
                  ATH_MSG_INFO( "Mode 42 bowing endpoint anchor |z| = "
                                << mode42BowingAnchorAbsZ / CLHEP::mm << " mm" );
                }
        
        for (std::map<Identifier, HepGeom::Point3D<double> >::const_iterator iter = m_ModuleList.begin(); iter != m_ModuleList.end(); ++iter) {
            ++i;
            const Identifier& ModuleID = iter->first;
            
            const InDetDD::SiDetectorElement * SiModule = nullptr; //dummy to get moduleTransform() for silicon
            
            if (m_idHelper->is_pixel(ModuleID)) {
                                const IdentifierHash Pixel_ModuleHash = m_pixelIdHelper->wafer_hash(ModuleID);
                if(pixelElements) SiModule = pixelElements->getDetectorElement(Pixel_ModuleHash);
                else ATH_MSG_WARNING("Trying to access a Pixel module when running with no Pixel!");
                //module = SiModule;
            } else if (m_idHelper->is_sct(ModuleID)) {
                                const IdentifierHash SCT_ModuleHash = m_sctIdHelper->wafer_hash(ModuleID);
                if(sctElements) SiModule = sctElements->getDetectorElement(SCT_ModuleHash);
                else ATH_MSG_WARNING("Trying to access an SCT/Strop module when running with no SCT/Strip!");
                //module = SiModule;OB
            } else if (m_idHelper->is_trt(ModuleID)) {
                //module = m_TRT_Manager->getElement(ModuleID);
                //const InDetDD::TRT_BaseElement *p_TRT_Module = m_TRT_Manager->getElement(iter->second.moduleID());
            } else {
                ATH_MSG_WARNING( "Something fishy, identifier is neither Pixel, nor SCT or TRT!" );
            }
            
            //TRT alignment transformations are given in global frame in DB,
            // that's not fully correct, since the level2 transform can rotate the system in which level1 transforms
            // are applied ...
            
            //Si have a local coordinate system
            // Take care: For SCT we have to ensure that module's
            // system is taken, not the system of one of the wafers!
            HepGeom::Transform3D localToGlobal = HepGeom::Transform3D();
            if ((not m_idHelper->is_trt(ModuleID))){
              if (SiModule){
                localToGlobal=Amg::EigenTransformToCLHEP(SiModule->moduleTransform());
              } else {
                ATH_MSG_WARNING("Apparently in a silicon detector, but SiModule is a null pointer");
              }
            }
            const HepGeom::Point3D<double> center = iter->second;
            
            //center of module in global coordinates
            double r = center.rho(); //distance from beampipe
            double phi = center.phi();
            double z = center.z();
            
            HepGeom::Transform3D parameterizedTrafo;
            HepGeom::Transform3D alignmentTrafo;
            
 
            // prepare scale factor for different subsystems:
      double ScaleFactor = 1.;
 
      if (m_idHelper->is_pixel(ModuleID))
        {
      ATH_MSG_INFO(  "ID Module " << i << " with ID " << m_pixelIdHelper->show_to_string(ModuleID,nullptr,'/') );
          if (m_pixelIdHelper->is_barrel(ModuleID))   {
            ScaleFactor=m_ScalePixelBarrel;
          }
          else {
            ScaleFactor=m_ScalePixelEndcap;
          }
          if (m_pixelIdHelper->is_blayer(ModuleID))   {  // IBL
            ScaleFactor=m_ScalePixelIBL;
          }
          if (m_pixelIdHelper->is_dbm(ModuleID))   {    // DBM
            ScaleFactor=m_ScalePixelDBM;
          }
 
        } else if (m_idHelper->is_sct(ModuleID))
        {
      ATH_MSG_INFO(  "ID Module " << i << " with ID " << m_sctIdHelper->show_to_string(ModuleID,nullptr,'/') );
          if (m_sctIdHelper->is_barrel(ModuleID)) {
            ScaleFactor=m_ScaleSCTBarrel;
          }
          else {
            ScaleFactor=m_ScaleSCTEndcap;
          }
 
        } else if (m_idHelper->is_trt(ModuleID))
        {
      ATH_MSG_INFO(  "ID Module " << i << " with ID " << m_trtIdHelper->show_to_string(ModuleID,nullptr,'/') );
      if (m_trtIdHelper->is_barrel(ModuleID)) {
            ScaleFactor=m_ScaleTRTBarrel;
          }
          else {
            ScaleFactor=m_ScaleTRTEndcap;
          }
        } else {
        ATH_MSG_WARNING( "Something fishy, identifier is neither Pixel, nor SCT or TRT!" );
      }
 
            if (msgLvl(MSG::DEBUG)) {
                msg() << "radius "  << r / CLHEP::cm << " centimeter" << endmsg;
                msg() << "phi "  << phi << endmsg;
                msg() << "z "  << z / CLHEP::cm << " centimeter" << endmsg;
                if (msgLvl(MSG::VERBOSE)) {
                    msg() << "localToGlobal transformation:" << endmsg;
                    msg() << "translation: "  << localToGlobal.dx() / CLHEP::cm << ";" << localToGlobal.dy() / CLHEP::cm << ";" << localToGlobal.dz() / CLHEP::cm << endmsg;
                    msg() << "rotation: "  << endmsg;
                    msg() << localToGlobal.xx() << " " << localToGlobal.xy() << " " << localToGlobal.xz() << endmsg;
                    msg() << localToGlobal.yx() << " " << localToGlobal.yy() << " " << localToGlobal.yz() << endmsg;
                    msg() << localToGlobal.zx() << " " << localToGlobal.zy() << " " << localToGlobal.zz() << endmsg;
                }
            }
            
            if (!m_MisalignmentMode) {
                //no misalignment mode set
                parameterizedTrafo = HepGeom::Transform3D(); // initialized as identity transformation
            }
            
            else if (m_MisalignmentMode==1) {
                //shift whole detector
                HepGeom::Vector3D<double> shift(ScaleFactor*m_Misalign_x, ScaleFactor*m_Misalign_y, ScaleFactor*m_Misalign_z);
 
                CLHEP::HepRotation rot;
        rot = CLHEP::HepRotationX(ScaleFactor*m_Misalign_alpha) * CLHEP::HepRotationY(ScaleFactor*m_Misalign_beta) * CLHEP::HepRotationZ(ScaleFactor*m_Misalign_gamma);
 
        if (ScaleFactor == 0.0)  {
          parameterizedTrafo = HepGeom::Transform3D(); // initialized as identity transformation
        } else {
          parameterizedTrafo = HepGeom::Transform3D(rot, shift);
        }
 
            }
            
            else if (m_MisalignmentMode == 2) {
                
                                // randomly misalign modules at L3
                m_RndmMisalignWidth_x = m_translation[0];
                m_RndmMisalignWidth_y = m_translation[1];
                m_RndmMisalignWidth_z = m_translation[2];
        m_RndmMisalignWidth_alpha = m_rotation[0];
        m_RndmMisalignWidth_beta = m_rotation[1];
        m_RndmMisalignWidth_gamma = m_rotation[2];
                Rndm::Numbers RandMisX(randsvc, Rndm::Gauss(m_Misalign_x,m_RndmMisalignWidth_x*ScaleFactor));
                Rndm::Numbers RandMisY(randsvc, Rndm::Gauss(m_Misalign_y,m_RndmMisalignWidth_y*ScaleFactor));
                Rndm::Numbers RandMisZ(randsvc, Rndm::Gauss(m_Misalign_z,m_RndmMisalignWidth_z*ScaleFactor));
                Rndm::Numbers RandMisalpha(randsvc, Rndm::Gauss(m_Misalign_alpha,m_RndmMisalignWidth_alpha*ScaleFactor));
                Rndm::Numbers RandMisbeta(randsvc, Rndm::Gauss(m_Misalign_beta,m_RndmMisalignWidth_beta*ScaleFactor));
                Rndm::Numbers RandMisgamma(randsvc, Rndm::Gauss(m_Misalign_gamma,m_RndmMisalignWidth_gamma*ScaleFactor));
                
                double randMisX = RandMisX(); //assign to variables to allow the values to be queried
                double randMisY = RandMisY();
                double randMisZ = RandMisZ();
                
                double randMisaplha = RandMisalpha();
                double randMisbeta = RandMisbeta();
                double randMisgamma = RandMisgamma();
                
                CLHEP::HepRotation rot;
        HepGeom::Vector3D<double> shift;
                
 
                if (ScaleFactor == 0.0)  {
                                  parameterizedTrafo = HepGeom::Transform3D(); // initialized as identity transformation
                                } else {
                        shift = HepGeom::Vector3D<double>(randMisX, randMisY, randMisZ);
                        rot = CLHEP::HepRotationX(randMisaplha) * CLHEP::HepRotationY(randMisbeta) * CLHEP::HepRotationZ(randMisgamma);
                        parameterizedTrafo = HepGeom::Transform3D(rot, shift);}
                
            }
 
                        else if (m_MisalignmentMode==3) {
                          //shift whole detector                                                                                                        
                          double deltaX;
                          if ( m_idHelper->is_pixel(ModuleID) && m_pixelIdHelper->is_blayer(ModuleID) )   {
                            //function is parameterized in global z                                                                                     
                deltaX = getBowingTx( getBowingMagParam(m_IBLBowingTshift), z);
                                                  
                          } else {
                            //IBL-stave temperature distortion not applied to anything but IBL                             
                            deltaX = 0.;
                            ATH_MSG_DEBUG( "will not move this module for IBL temp distortion " );
                          }
 
                          ATH_MSG_DEBUG( "deltaX for this module: "  << deltaX/CLHEP::micrometer << " um" );
                          parameterizedTrafo = HepGeom::Translate3D(deltaX,0,0); // translation in x direction                                          
                        }
 
                        else if (m_MisalignmentMode == 41) {
                          // ITk endcap shift along the beam pipe. This is a global z translation;
                          // it is converted to the local module frame later with the other global modes.
                          int barrelEC = 0;
                          if (m_idHelper->is_pixel(ModuleID)) barrelEC = m_pixelIdHelper->barrel_ec(ModuleID);
                          if (m_idHelper->is_sct(ModuleID))   barrelEC = m_sctIdHelper->barrel_ec(ModuleID);
 
                          double deltaZ = 0.;
                          if ((m_idHelper->is_pixel(ModuleID) || m_idHelper->is_sct(ModuleID)) && barrelEC != 0) {
                            const double inputZ = m_local_translation.size() > 2 ? m_local_translation[2] : 0.;
                            const double sideSign = barrelEC > 0 ? 1. : -1.;
 
                            if (m_endcapShiftConvention == "outward") {
                              deltaZ = sideSign * inputZ;
                            } else if (m_endcapShiftConvention == "inward") {
                              deltaZ = -sideSign * inputZ;
                            } else if (m_endcapShiftConvention == "plusZ") {
                              deltaZ = inputZ;
                            } else if (m_endcapShiftConvention == "minusZ") {
                              deltaZ = -inputZ;
                            } else {
                              ATH_MSG_WARNING( "Unknown EndcapShiftConvention " << m_endcapShiftConvention
                                               << "; using outward" );
                              deltaZ = sideSign * inputZ;
                            }
                          } else {
                            ATH_MSG_DEBUG( "will not move this module for ITk endcap z shift " );
                          }
 
                          ATH_MSG_DEBUG( "deltaZ for this module: " << deltaZ / CLHEP::micrometer << " um" );
                          parameterizedTrafo = HepGeom::Translate3D(0, 0, deltaZ);
                        }
 
                        else if (m_MisalignmentMode == 42) {
                          // ITk pixel barrel layer bowing. The bowing function is parameterized in global z.
                          double deltaX = 0.;
 
                          if (m_idHelper->is_pixel(ModuleID) &&
                              m_pixelIdHelper->is_barrel(ModuleID) &&
                              m_pixelIdHelper->layer_disk(ModuleID) == m_targetLayer) {
                            const double bowingP1 = getBowingMagParam(m_IBLBowingTshift);
                            const double rawDeltaX = getBowingTx(bowingP1, z);
                            const double anchorZ = (z >= 0.) ? mode42BowingAnchorAbsZ : -mode42BowingAnchorAbsZ;
                            const double edgeDeltaX = getBowingTx(bowingP1, anchorZ);
                            deltaX = rawDeltaX - edgeDeltaX;
                          } else {
                            ATH_MSG_DEBUG( "will not move this module for ITk pixel barrel bowing " );
                          }
 
                          ATH_MSG_DEBUG( "deltaX for this module: " << deltaX / CLHEP::micrometer << " um" );
                          parameterizedTrafo = HepGeom::Translate3D(deltaX, 0, 0);
                        }
 
                        else if (m_MisalignmentMode == 43) {
                          // ITk barrel radial expansion/contraction. This is a global radial translation;
                          // it is converted to the local module frame later with the other global modes.
                          const bool isPixelBarrel = m_idHelper->is_pixel(ModuleID) && m_pixelIdHelper->is_barrel(ModuleID);
                          const bool isStripBarrel = m_idHelper->is_sct(ModuleID) && m_sctIdHelper->is_barrel(ModuleID);
 
                          const bool selectPixel = (m_radialSubdetector == "Pixel" || m_radialSubdetector == "pixel" ||
                                                    m_radialSubdetector == "Both"  || m_radialSubdetector == "both");
                          const bool selectStrip = (m_radialSubdetector == "Strip" || m_radialSubdetector == "strip" ||
                                                    m_radialSubdetector == "Both"  || m_radialSubdetector == "both");
 
                          int layer = -999;
                          if (isPixelBarrel) layer = m_pixelIdHelper->layer_disk(ModuleID);
                          if (isStripBarrel) layer = m_sctIdHelper->layer_disk(ModuleID);
 
                          const bool selectedSubdetector = (isPixelBarrel && selectPixel) || (isStripBarrel && selectStrip);
 
                          bool selectedLayer = false;
                          if (m_targetLayer < 0) {
                            // TargetLayer=-1 means all barrel layers.
                            selectedLayer = true;
                          } else if (m_targetLayerMax >= m_targetLayer) {
                            // Layer range, e.g. TargetLayer=0 TargetLayerMax=1.
                            selectedLayer = (layer >= m_targetLayer && layer <= m_targetLayerMax);
                          } else {
                            // Default behaviour: one layer only.
                            selectedLayer = (layer == m_targetLayer);
                          }
 
                          double deltaR = 0.;
                          double deltaX = 0.;
                          double deltaY = 0.;
 
                          if (selectedSubdetector && selectedLayer && r > 0.) {
                            if (m_radialShiftConvention == "outward") {
                              deltaR = m_radialShift;
                            } else if (m_radialShiftConvention == "inward") {
                              deltaR = -m_radialShift;
                            } else if (m_radialShiftConvention == "signed") {
                              deltaR = m_radialShift;
                            } else {
                              ATH_MSG_WARNING( "Unknown RadialShiftConvention " << m_radialShiftConvention
                                               << "; using outward" );
                              deltaR = m_radialShift;
                            }
 
                            deltaX = deltaR * center.x() / r;
                            deltaY = deltaR * center.y() / r;
                          } else {
                            ATH_MSG_DEBUG( "will not move this module for ITk barrel radial shift " );
                          }
 
                          ATH_MSG_DEBUG( "deltaR for this module: " << deltaR / CLHEP::micrometer << " um" );
                          parameterizedTrafo = HepGeom::Translate3D(deltaX, deltaY, 0);
                        }
 
        else if (m_MisalignmentMode == 7) {
                 
          std::string module_str;
          if(m_idHelper->is_pixel(ModuleID)) module_str = m_pixelIdHelper->show_to_string(ModuleID,nullptr,'/');
          if(m_idHelper->is_sct(ModuleID)) module_str = m_sctIdHelper->show_to_string(ModuleID,nullptr,'/');
 
                 if (module_str.substr(0, m_index.size()) == m_index) {
 
                   // Handle translation
                   HepGeom::Vector3D<double> shift(0, 0, 0);
                   if (!m_local_translation.empty()) {
                     shift = HepGeom::Vector3D<double>(m_local_translation[0], m_local_translation[1], m_local_translation[2]);
                   }
                   
                   // Handle rotation
                   CLHEP::HepRotation rot = CLHEP::HepRotationX(0) * CLHEP::HepRotationY(0) * CLHEP::HepRotationZ(0);
                   if (!m_local_rotation.empty()) {
                     rot = CLHEP::HepRotationX(m_local_rotation[0]) * CLHEP::HepRotationY(m_local_rotation[1]) * CLHEP::HepRotationZ(m_local_rotation[2]);
                   }
                   
                   // Assign transformation
                   parameterizedTrafo = HepGeom::Transform3D(rot, shift);
                  }
                }
    
            
            else { // systematic misalignments
                if (m_MisalignmentMode/10==1) {
                    //radial misalignments
                    double deltaR;
                    if (m_MisalignmentMode==11) {
                        //R deltaR = radial expansion
                        if (m_idHelper->is_trt(ModuleID) && abs(m_trtIdHelper->barrel_ec(ModuleID))==2) {
                            //radial mode cannot handle TRT endcap, sorry
                            deltaR = 0.;
                            ATH_MSG_DEBUG( "will not move TRT endcap for radial distortion " );
                        } else {
                            //deltaR = 0.5 * cos ( 2*phi ) * r/maxRadius * maxDeltaR;
                            deltaR = r/maxRadius * maxDeltaR; //scale linearly in r
                        }
                    } else if (m_MisalignmentMode==12) {
                        //Phi deltaR = elliptical (egg-shape)
                        if (m_idHelper->is_trt(ModuleID) && abs(m_trtIdHelper->barrel_ec(ModuleID))==2) {
                            //elliptical mode cannot handle TRT endcap, sorry
                            deltaR = 0.;
                            ATH_MSG_DEBUG( "will not move TRT endcap for elliptical distortion " );
                        } else {
                            // deltaR = 0.5 * cos ( 2*phi ) * r/maxRadius * maxDeltaR;
                            deltaR = cos ( 2*phi ) * r/maxRadius * maxDeltaR;
                        }
                    } else if (m_MisalignmentMode==13) {
                        //Z deltaR = funnel
                        if (m_idHelper->is_trt(ModuleID) && abs(m_trtIdHelper->barrel_ec(ModuleID))==2) {
                            //funnel mode cannot handle TRT endcap, sorry
                            deltaR = 0.;
                            ATH_MSG_DEBUG( "will not move TRT endcap for funnel distortion " );
                        } else {
                            //deltaR = z/maxLength * maxDeltaR; // linearly in z
                            deltaR = 2. * z/maxLength * maxDeltaR; // linearly in z
                        }
                    } else {
                        ATH_MSG_DEBUG( "Wrong misalignment mode entered, doing nothing." );
                        deltaR=0;
                    }
                    
                    ATH_MSG_DEBUG( "deltaR for this module: "  << deltaR / CLHEP::micrometer << " um" );
                    parameterizedTrafo = HepGeom::Translate3D(deltaR*cos(phi),deltaR * sin(phi),0.); // translation along R vector
                }
                
                else if (m_MisalignmentMode/10==2) {
                    //azimuthal misalignments
                    double deltaPhi;
                    if (m_MisalignmentMode==21) {
                        
                            deltaPhi = r/maxRadius * maxAngle + minRadius/r * maxAngleInner; //linearly + reciprocal term in r
                    } else if (m_MisalignmentMode==22) {
                        //Phi deltaPhi = clamshell
                        //                     deltaPhi = std::abs( sin ( phi )) * maxAngle;
                        if (m_idHelper->is_trt(ModuleID) && abs(m_trtIdHelper->barrel_ec(ModuleID))==2) {
                            //clamshell mode cannot handle TRT endcap, sorry
                            deltaPhi = 0.;
                            ATH_MSG_DEBUG( "will not move TRT endcap for clamshell distortion " );
                        } else {
                            //                        deltaPhi = 0.5 * cos ( 2*phi ) * maxAngle;
                            deltaPhi =  cos ( 2*phi ) * maxAngle;
                        }
                    } else if (m_MisalignmentMode==23) {
                        //Z deltaPhi = Twist
                        deltaPhi = 2*z/maxLength * maxAngle;
                        //deltaPhi = z/maxLength * maxAngle;
                    } else {
                        ATH_MSG_WARNING( "Wrong misalignment mode entered, doing nothing." );
                        deltaPhi=0;
                    }
                    
                    ATH_MSG_DEBUG( "deltaPhi for this module: "  << deltaPhi/CLHEP::mrad << " mrad" );
                    parameterizedTrafo = HepGeom::RotateZ3D(deltaPhi); // rotation around z axis => in phi
                }
                
                else if (m_MisalignmentMode/10==3) {
                    //z misalignments
                    double deltaZ;
                    if (m_MisalignmentMode==31) {
                        //R deltaZ = Telescope
                        deltaZ = r/maxRadius * maxDeltaZ; //scale linearly in r
                    } else if (m_MisalignmentMode==32) {
                        
                        if (m_idHelper->is_trt(ModuleID) && abs(m_trtIdHelper->barrel_ec(ModuleID))==2) {
                            //clamshell mode cannot handle TRT endcap, sorry
                            deltaZ = 0.;
                            ATH_MSG_DEBUG( "will not move TRT endcap for skew distortion " );
                        } else {
                            
                            deltaZ =  cos ( 2*phi ) * maxDeltaZ;
                        }
                    } else if (m_MisalignmentMode==33) {
                        //Z deltaZ = Z expansion
                        //                  deltaZ = z/maxLength * maxDeltaZ;
                        deltaZ = 2. * z/maxLength * maxDeltaZ;
                    } else {
                        ATH_MSG_WARNING( "Wrong misalignment mode entered, doing nothing." );
                        deltaZ=0;
                    }
                    
                    ATH_MSG_DEBUG( "deltaZ for this module: "  << deltaZ/CLHEP::micrometer << " um" );
                    parameterizedTrafo = HepGeom::Translate3D(0,0,deltaZ); // translation in z direction
                }
                
                else {
                    //no or wrong misalignment selected
                    ATH_MSG_WARNING( "Wrong misalignment mode entered, doing nothing." );
                    
                    parameterizedTrafo = HepGeom::Transform3D(); // initialized as identity transformation
                }
            } //end of misalignment
            
            if ( m_MisalignmentMode==21 && m_idHelper->is_trt(ModuleID) && m_trtIdHelper->is_barrel(ModuleID) ) {
                //curl for TRT barrel
                ATH_MSG_DEBUG( "additional rotation for TRT barrel module!" );
                HepGeom::Transform3D realLocalToGlobalTRT = HepGeom::Translate3D(center.x(),center.y(),center.z());
                //rotate a TRT barrel module by the same angle again, but around its local z axis
                //this is an approximation to accomodate the impossible curling of TRT segments
                alignmentTrafo = parameterizedTrafo * realLocalToGlobalTRT * parameterizedTrafo * realLocalToGlobalTRT.inverse();
            } else if (m_MisalignmentMode==23 && m_idHelper->is_trt(ModuleID) && m_trtIdHelper->is_barrel(ModuleID) ) {
                //do the twist! (for TRT barrel)
                HepGeom::Transform3D realLocalToGlobalTRT = HepGeom::Translate3D(center.x(),center.y(),center.z());
                double deltaAlpha = (-2.) * r * maxAngle/maxLength;
                ATH_MSG_DEBUG( "TRT barrel module alpha for twist: "  << deltaAlpha/CLHEP::mrad << " mrad" );
                
                CLHEP::HepRotation twistForTRTRotation(HepGeom::Vector3D<double>(center.x(),center.y(),center.z()), deltaAlpha );
                HepGeom::Transform3D twistForTRT= HepGeom::Transform3D(twistForTRTRotation,HepGeom::Vector3D<double>(0.,0.,0.));
                //             HepGeom::Transform3D twistForTRTRotation = HepGeom::RotateZ3D( r * maxAngle/maxLength );
                
                alignmentTrafo = realLocalToGlobalTRT * twistForTRT * realLocalToGlobalTRT.inverse();
            } else if (m_MisalignmentMode==13 && m_idHelper->is_trt(ModuleID) && m_trtIdHelper->is_barrel(ModuleID) ) {
                // funneling for TRT barrel
                HepGeom::Transform3D realLocalToGlobalTRT = HepGeom::Translate3D(center.x(),center.y(),center.z());
                double deltaAlpha = (-2.) * maxDeltaR/maxLength;
                //double deltaAlpha = maxDeltaR/maxLength;
                ATH_MSG_DEBUG( "TRT barrel module alpha for funnel: "  << deltaAlpha/CLHEP::mrad << " mrad" );
                
                HepGeom::Vector3D<double> normalVector(center.x(),center.y(),center.z());
                HepGeom::Vector3D<double> beamVector(0.,0.,1.);
                HepGeom::Vector3D<double> rotationAxis = normalVector.cross(beamVector);
                CLHEP::HepRotation twistForTRTRotation(rotationAxis, deltaAlpha );
                HepGeom::Transform3D twistForTRT= HepGeom::Transform3D(twistForTRTRotation,HepGeom::Vector3D<double>(0.,0.,0.));
                
                alignmentTrafo = realLocalToGlobalTRT * twistForTRT * realLocalToGlobalTRT.inverse();
                
                
                
            } else if (m_MisalignmentMode==2 || m_MisalignmentMode==3 || m_MisalignmentMode==7 || m_MisalignmentMode==42) //random misalignment in local frame
            {
                alignmentTrafo = parameterizedTrafo;
            }
            else {
                // final transformation executed in global coordinates, converted to local coordinates
                alignmentTrafo = localToGlobal.inverse() * parameterizedTrafo * localToGlobal; 
            }
            
            if (msgLvl(MSG::INFO)) {
                msg() << "Align Transformation x = ("  << alignmentTrafo.getTranslation().x() / CLHEP::micrometer << " um)" << endmsg;
                msg() << "Align Transformation y = ("  << alignmentTrafo.getTranslation().y() / CLHEP::micrometer << " um)" << endmsg;
                msg() << "Align Transformation z = ("  << alignmentTrafo.getTranslation().z() / CLHEP::micrometer << " um)" << endmsg;
                msg() << "Align Transformation x phi   = ("  << alignmentTrafo.getRotation().phiX() / CLHEP::deg << ")" << endmsg;
                msg() << "Align Transformation x Theta = ("  << alignmentTrafo.getRotation().thetaX() / CLHEP::deg << ")" << endmsg;
                msg() << "Align Transformation y phi   = ("  << alignmentTrafo.getRotation().phiY() / CLHEP::deg << ")" << endmsg;
                msg() << "Align Transformation y Theta = ("  << alignmentTrafo.getRotation().thetaY() / CLHEP::deg << ")" << endmsg;
                msg() << "Align Transformation z phi   = ("  << alignmentTrafo.getRotation().phiZ() / CLHEP::deg << ")" << endmsg;
                msg() << "Align Transformation z Theta = ("  << alignmentTrafo.getRotation().thetaZ() / CLHEP::deg << ")" << endmsg;
            }
            
            // suppress tiny translations that occur due to trafo.inverse*trafo numerics
            if ( std::abs(alignmentTrafo.getTranslation().x()) < 1e-10) {
                HepGeom::Vector3D<double>
                zeroSuppressedTranslation(0,alignmentTrafo.getTranslation().y(),alignmentTrafo.
                                          getTranslation().z());
                alignmentTrafo =
                HepGeom::Transform3D(alignmentTrafo.getRotation(),zeroSuppressedTranslation);
            }
            if ( std::abs(alignmentTrafo.getTranslation().y()) < 1e-10) {
                HepGeom::Vector3D<double>
                zeroSuppressedTranslation(alignmentTrafo.getTranslation().x(),0,alignmentTrafo.
                                          getTranslation().z());
                alignmentTrafo =
                HepGeom::Transform3D(alignmentTrafo.getRotation(),zeroSuppressedTranslation);
            }
            if ( std::abs(alignmentTrafo.getTranslation().z()) < 1e-10) {
                HepGeom::Vector3D<double>
                zeroSuppressedTranslation(alignmentTrafo.getTranslation().x(),alignmentTrafo.getTranslation().y(),0);
                alignmentTrafo =
                HepGeom::Transform3D(alignmentTrafo.getRotation(),zeroSuppressedTranslation);
            }
            if ( std::abs(alignmentTrafo.getRotation().getDelta()) < 1e-10) {
                CLHEP::HepRotation zeroSuppressedRotation(alignmentTrafo.getRotation());
                zeroSuppressedRotation.setDelta(0.);
                alignmentTrafo =
                HepGeom::Transform3D(zeroSuppressedRotation,alignmentTrafo.getTranslation());
            }
            
            
            Amg::Transform3D alignmentTrafoAmg = Amg::CLHEPTransformToEigen(alignmentTrafo);
            
            if (m_idHelper->is_pixel(ModuleID)) {
                if (m_IDAlignDBTool->tweakTrans(ModuleID,3, alignmentTrafoAmg)) {
                    ATH_MSG_INFO( "Update of alignment constants for module " << m_pixelIdHelper->show_to_string(ModuleID,nullptr,'/') << " successful" );
                } else {
                    ATH_MSG_ERROR( "Update of alignment constants for module " << m_pixelIdHelper->show_to_string(ModuleID,nullptr,'/') << " not successful" );
                }
            } else if (m_idHelper->is_sct(ModuleID)) {
                                if (m_IDAlignDBTool->tweakTrans(ModuleID,3, alignmentTrafoAmg)) {
                                        ATH_MSG_INFO( "Update of alignment constants for module " << m_sctIdHelper->show_to_string(ModuleID,nullptr,'/') << " successful" );
                                } else {
                                        ATH_MSG_ERROR( "Update of alignment constants for module " << m_sctIdHelper->show_to_string(ModuleID,nullptr,'/') << " not successful" );
                                }
            } else if (m_idHelper->is_trt(ModuleID)) {
                if (!m_trtIdHelper->is_barrel(ModuleID) && m_trtIdHelper->phi_module(ModuleID)!=0) {
                    //don't align - there's no trans in the DB for phi sectors other than 0
                    ATH_MSG_DEBUG( "TRT endcap phi sector " << m_trtIdHelper->phi_module(ModuleID) << " not aligned" );
                } else {
                    if (m_trtaligndbservice->tweakAlignTransform(ModuleID,alignmentTrafoAmg,2).isFailure()) { 
                        ATH_MSG_ERROR( "Update of alignment constants for module " << m_trtIdHelper->show_to_string(ModuleID,nullptr,'/') << " not successful" );
                    } else {
                        ATH_MSG_INFO( "Update of alignment constants for module " << m_trtIdHelper->show_to_string(ModuleID,nullptr,'/') << " successful" );
                    }
                }
            } else {
                ATH_MSG_WARNING( "Something fishy, identifier is neither Pixel, nor SCT or TRT!" );
            }
            
            double alpha, beta, gamma;
            m_IDAlignDBTool->extractAlphaBetaGamma(alignmentTrafoAmg, alpha, beta, gamma);
 
            m_AlignResults_x = alignmentTrafo.getTranslation().x();
            m_AlignResults_y = alignmentTrafo.getTranslation().y();
            m_AlignResults_z = alignmentTrafo.getTranslation().z();
            m_AlignResults_alpha = alpha;
            m_AlignResults_beta = beta;
            m_AlignResults_gamma = gamma;
            
 
                        HepGeom::Transform3D LocalaGlobal = HepGeom::Transform3D();
                        LocalaGlobal = Amg::EigenTransformToCLHEP(SiModule->moduleTransform());
                        HepGeom::Point3D<double> alignedPosLocal(m_AlignResults_x,m_AlignResults_y,m_AlignResults_z);
 
 
 
              
                        m_Initial_center_x = center.x() ;
                        m_Initial_center_y = center.y() ;
                        m_Initial_center_z = center.z() ;
                        
                        HepGeom::Point3D<double> alignedPosGlobal = LocalaGlobal * alignedPosLocal;
                        
                        // Global Misalignment HERE
                        if (m_idHelper->is_sct(ModuleID)) {
                              // non-zero local center position gives additional radial shift of SCT endcap
                              const InDetDD::StripStereoAnnulusDesign *p_design_check = dynamic_cast<const InDetDD::StripStereoAnnulusDesign*>(&(SiModule->design()));
                              if (p_design_check){
                                     Amg::Vector3D SCT_Center = p_design_check->sensorCenter();
                                     double radialShift_x = SCT_Center[0];     // in sensor frame, x direction
                                     double radialShift_y = SCT_Center[1];     // in sensor frame, y direction
                                     HepGeom::Transform3D radial_shift = HepGeom::Translate3D(radialShift_x,radialShift_y,0);       // the additional radial shift applied as translation
                                     HepGeom::Transform3D LocalaaGlobal = LocalaGlobal * radial_shift;                              // apply additional radial shift
                                     HepGeom::Point3D<double> SCT_endcap_alignedPosGlobal = LocalaaGlobal * alignedPosLocal;       // corrected global transformation 
                                     m_Global_center_x = SCT_endcap_alignedPosGlobal.x();
                                     m_Global_center_z = SCT_endcap_alignedPosGlobal.z();
                                     m_Global_center_y = SCT_endcap_alignedPosGlobal.y();
                              }
 
                              else { // no additional radial shift for SCT barrel 
                                     m_Global_center_x =  alignedPosGlobal.x();
                                     m_Global_center_y =  alignedPosGlobal.y();
                                     m_Global_center_z =  alignedPosGlobal.z();
                                                                                                                                                                 
                              }
                              
                        }
 
                        else { // no additional radial shift for non-SCT elements
                               m_Global_center_x =  alignedPosGlobal.x();
                               m_Global_center_y =  alignedPosGlobal.y();
                               m_Global_center_z =  alignedPosGlobal.z();
                        }
 
 
                         if (m_idHelper->is_sct(ModuleID)) {
                m_AlignResults_Identifier_ID = 2;
                m_AlignResults_Identifier_PixelSCT = 2;
                m_AlignResults_Identifier_BarrelEC = m_sctIdHelper->barrel_ec(ModuleID);
                m_AlignResults_Identifier_LayerDisc = m_sctIdHelper->layer_disk(ModuleID);
                m_AlignResults_Identifier_Phi = m_sctIdHelper->phi_module(ModuleID);
                m_AlignResults_Identifier_Eta = m_sctIdHelper->eta_module(ModuleID);
            } else if (m_idHelper->is_pixel(ModuleID)) {
                m_AlignResults_Identifier_ID = 2;
                m_AlignResults_Identifier_PixelSCT = 1;
                m_AlignResults_Identifier_BarrelEC = m_pixelIdHelper->barrel_ec(ModuleID);
                m_AlignResults_Identifier_LayerDisc = m_pixelIdHelper->layer_disk(ModuleID);
                m_AlignResults_Identifier_Phi = m_pixelIdHelper->phi_module(ModuleID);
                m_AlignResults_Identifier_Eta = m_pixelIdHelper->eta_module(ModuleID);
            } else if (m_idHelper->is_trt(ModuleID)) {
                m_AlignResults_Identifier_ID = 2;
                m_AlignResults_Identifier_PixelSCT = 3;
                m_AlignResults_Identifier_BarrelEC = m_trtIdHelper->barrel_ec(ModuleID);
                m_AlignResults_Identifier_LayerDisc = m_trtIdHelper->layer_or_wheel(ModuleID);
                m_AlignResults_Identifier_Phi = m_trtIdHelper->phi_module(ModuleID);
                m_AlignResults_Identifier_Eta = m_trtIdHelper->straw_layer(ModuleID);
                
            } else {
                ATH_MSG_WARNING( "Something fishy, identifier is neither Pixel, nor SCT or TRT!" );
            }
            
            // Write out AlignResults ntuple
            if (StatusCode::SUCCESS!=ntupleSvc()->writeRecord("NTUPLES/CREATEMISALIGN/InitialAlignment")) {
                ATH_MSG_ERROR( "Could not write InitialAlignment ntuple." );
            }
            
        } // end of module loop
        
        //  i = 0;
        
        //m_IDAlignDBTool->printDB(2);
        if(m_doPix || m_doStrip){
         if (StatusCode::SUCCESS!=m_IDAlignDBTool->outputObjs()) {
            ATH_MSG_ERROR( "Writing of AlignableTransforms failed" );
         } else {
            ATH_MSG_INFO( "AlignableTransforms were written" );
            ATH_MSG_INFO( "Writing database to textfile" );
            m_IDAlignDBTool->writeFile(false,m_asciiFileNameBase+"_Si.txt");
            ATH_MSG_INFO( "Writing IoV information to mysql file" );
            m_IDAlignDBTool->fillDB("InDetSi_"+m_SQLiteTag,IOVTime::MINRUN,IOVTime::MINEVENT,IOVTime::MAXRUN,IOVTime::MAXEVENT);
        } 
        }
        
        if(m_doTRT){
         if (StatusCode::SUCCESS!=m_trtaligndbservice->streamOutAlignObjects()) {
            ATH_MSG_ERROR( "Write of AlignableTransforms (TRT) failed" );
         } else {
            ATH_MSG_INFO( "AlignableTransforms for TRT were written" );
            ATH_MSG_INFO( "Writing TRT database to textfile" );
            if ( StatusCode::SUCCESS != m_trtaligndbservice->writeAlignTextFile(m_asciiFileNameBase+"_TRT.txt") ) {
                          ATH_MSG_ERROR( "Failed to write AlignableTransforms (TRT) to txt file " << m_asciiFileNameBase+"_TRT.txt" );
                        }
            ATH_MSG_INFO( "Writing IoV information for TRT to mysql file" );
            if ( StatusCode::SUCCESS
                             != m_trtaligndbservice->registerAlignObjects(m_SQLiteTag+"_TRT",IOVTime::MINRUN,IOVTime::MINEVENT,IOVTime::MAXRUN,IOVTime::MAXEVENT)) {
                          ATH_MSG_ERROR( "Write of AIoV information (TRT) to mysql failed (tag=" << m_SQLiteTag << "_TRT)");
                        }
         }
        }
 
        return StatusCode::SUCCESS;               
        
    }

getBowingMagParam()

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

private

Definition at line 1257 of file CreateMisalignAlg.cxx.

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

getBowingTx()

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

private

Definition at line 1266 of file CreateMisalignAlg.cxx.

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

getContext()

const EventContext & AthAlgorithm::getContext ( ) const

inherited

Deprecated methods (use the ones with EventContext).

Definition at line 90 of file AthAlgorithm.cxx.

                                                   {
  return Gaudi::Hive::currentContext();
}

initialize()

StatusCode InDetAlignment::CreateMisalignAlg::initialize

(

)

standard Athena-Algorithm method

Definition at line 152 of file CreateMisalignAlg.cxx.

    {
        ATH_MSG_DEBUG("CreateMisalignAlg initialize()");
        if(m_pixelDetEleCollKey.empty()) {m_doPix=false;ATH_MSG_INFO("Not creating misalignment for Pixel");}
        if(m_SCTDetEleCollKey.empty()) {m_doStrip=false;ATH_MSG_INFO("Not creating misalignment for Strip/SCT");}
        if(m_trtDetEleCollKey.empty()) {m_doTRT=false;ATH_MSG_INFO("Not creating misalignment for TRT");}
 
        ATH_CHECK(m_pixelDetEleCollKey.initialize(SG::AllowEmpty));
        ATH_CHECK(m_SCTDetEleCollKey.initialize(SG::AllowEmpty));
        ATH_CHECK(m_trtDetEleCollKey.initialize(SG::AllowEmpty));
 
        if (m_doPix || m_doStrip) ATH_CHECK(m_IDAlignDBTool.retrieve());
        if(m_doTRT) ATH_CHECK(m_trtaligndbservice.retrieve());
        //ID helpers
        // Pixel
        if(m_doPix){
            ATH_CHECK(detStore()->retrieve(m_pixelIdHelper, "PixelID"));
        }
        // SCT
        if(m_doStrip){
            ATH_CHECK(detStore()->retrieve(m_sctIdHelper, "SCT_ID"));
        }
        // TRT
        if(m_doTRT){
            ATH_CHECK(detStore()->retrieve(m_trtIdHelper, "TRT_ID"));
        }
        ATH_CHECK(detStore()->retrieve(m_idHelper, "AtlasID"));
 
        // Retrieve the Histo Service
        SmartIF<ITHistSvc> hist_svc{Gaudi::svcLocator()->service("THistSvc")};
        ATH_CHECK(hist_svc.isValid());
        //Registering TTree for Visualization Lookup
        m_VisualizationLookupTree = new TTree("IdentifierTree", "Visualization Identifier Lookup Tree");
        ATH_CHECK(hist_svc->regTree("/IDENTIFIERTREE/IdentifierTree", m_VisualizationLookupTree));
        m_VisualizationLookupTree->Branch ("AthenaHashedID", &m_AthenaHashedID, "AthenaID/i");
        m_VisualizationLookupTree->Branch ("HumanReadableID", &m_HumanReadableID, "HumanID/I");
        
        // initialize generated Initial Alignment NTuple
        NTupleFilePtr file1(ntupleSvc(), "/NTUPLES/CREATEMISALIGN");
        
        NTuplePtr nt(ntupleSvc(), "/NTUPLES/CREATEMISALIGN/InitialAlignment");
        if ( !nt ) {       // Check if already booked
            nt = ntupleSvc()->book("/NTUPLES/CREATEMISALIGN/InitialAlignment", CLID_ColumnWiseTuple, "InitialAlignment");
            if ( nt ) {
                ATH_MSG_INFO( "InitialAlignment ntuple booked." );
                ATH_CHECK(  nt->addItem("x"         ,m_AlignResults_x) );
                ATH_CHECK(  nt->addItem("y"         ,m_AlignResults_y) );
                ATH_CHECK(  nt->addItem("z"         ,m_AlignResults_z) );
                ATH_CHECK(  nt->addItem("alpha"     ,m_AlignResults_alpha) );
                ATH_CHECK(  nt->addItem("beta"      ,m_AlignResults_beta) );
                ATH_CHECK(  nt->addItem("gamma"     ,m_AlignResults_gamma) );
                ATH_CHECK(  nt->addItem("ID"        ,m_AlignResults_Identifier_ID) );
                ATH_CHECK(  nt->addItem("PixelSCT"  ,m_AlignResults_Identifier_PixelSCT) );
                ATH_CHECK(  nt->addItem("BarrelEC"  ,m_AlignResults_Identifier_BarrelEC) );
                ATH_CHECK(  nt->addItem("LayerDisc" ,m_AlignResults_Identifier_LayerDisc) );
                ATH_CHECK(  nt->addItem("Phi"       ,m_AlignResults_Identifier_Phi) );
                ATH_CHECK(  nt->addItem("Eta"       ,m_AlignResults_Identifier_Eta) );
                ATH_CHECK(  nt->addItem("center_x"         ,m_Initial_center_x ) );
                ATH_CHECK(  nt->addItem("center_y"         ,m_Initial_center_y ) );
                                ATH_CHECK(  nt->addItem("center_z"         ,m_Initial_center_z ) );
                                ATH_CHECK(  nt->addItem("misaligned_global_x"         ,m_Global_center_x ) );
                                ATH_CHECK(  nt->addItem("misaligned_global_y"         ,m_Global_center_y ) );
                                ATH_CHECK(  nt->addItem("misaligned_global_z"         ,m_Global_center_z ) );
            } else {  // did not manage to book the N tuple....
                msg(MSG::ERROR) << "Failed to book InitialAlignment ntuple." << endmsg;
            }
        }
        
        if (m_MisalignmentMode) {
            ATH_MSG_INFO( "Misalignment mode chosen: " << m_MisalignmentMode );
            if (m_MisalignmentMode == 1) {
                ATH_MSG_INFO( "MisalignmentX     : " << m_Misalign_x / CLHEP::micrometer << " micrometer" );
                ATH_MSG_INFO( "MisalignmentY     : " << m_Misalign_y / CLHEP::micrometer << " micrometer" );
                ATH_MSG_INFO( "MisalignmentZ     : " << m_Misalign_z / CLHEP::micrometer << " micrometer" );
                ATH_MSG_INFO( "MisalignmentAlpha : " << m_Misalign_alpha / CLHEP::mrad << " mrad" );
                ATH_MSG_INFO( "MisalignmentBeta  : " << m_Misalign_beta / CLHEP::mrad << " mrad" );
                ATH_MSG_INFO( "MisalignmentGamma : " << m_Misalign_gamma / CLHEP::mrad << " mrad" );
            } else {
                ATH_MSG_INFO( "with maximum shift of " << m_Misalign_maxShift / CLHEP::micrometer << " micrometer" );
            }
        } else {
            ATH_MSG_INFO( "Dry run, no misalignment will be generated." );
        }
        
        return StatusCode::SUCCESS;
    }

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::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.

isReEntrant()

virtual bool AthAlgorithm::isReEntrant ( ) const

inlinefinaloverrideprotectedvirtualinherited

Legacy algorithms are not thread-safe.

Definition at line 111 of file AthAlgorithm.h.

{ return false; }

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::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 1219 of file CreateMisalignAlg.cxx.

    {
        //     msg(MSG::DEBUG)  << "in CreateMisalignAlg::reduceTRTID" << endmsg;
        ATH_MSG_DEBUG( "reduceTRTID got Id " << m_idHelper->show_to_string(id,nullptr,'/'));
        
        int barrel_ec= m_trtIdHelper->barrel_ec(id);
        // attention: TRT DB only has one alignment correction per barrel module (+1/-1) pair
        // which is stored in -1 identifier
        if (barrel_ec==1) barrel_ec=-1; //only regard -1 barrel modules, +1 modules will belong to them
        
        //if (abs(barrel_ec)==2) phi_module=0; 
        //  only regard phi sector 0, the only one having an alignmentTrafo
        //does not work, since the center-of-mass of all phi sectors is on the beamline,so
        //  transformations would become zero -> this has to be handled later
        int phi_module=m_trtIdHelper->phi_module(id);
        
        int layer_or_wheel=m_trtIdHelper->layer_or_wheel(id);
        
        int strawlayer=0;
        if (!m_trtIdHelper->is_barrel(id)) {
            strawlayer = m_trtIdHelper->straw_layer(id) / 4 * 4;
            // only strawlayers 0,4,8,12 are fed into DB for endcap
        }
        
        //     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;
        ATH_MSG_DEBUG(  "    and returns Id " << m_idHelper->show_to_string(m_trtIdHelper->layer_id(barrel_ec,phi_module,layer_or_wheel,strawlayer),nullptr,'/'));
        //     return  m_trtIdHelper->module_id(barrel_ec,phi_module,layer_or_wheel);
        return  m_trtIdHelper->layer_id(barrel_ec,phi_module,layer_or_wheel,strawlayer);
    }

reduceTRTID() [2/2]

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

private

Definition at line 1250 of file CreateMisalignAlg.cxx.

    {
        Identifier id= m_trtIdHelper->module_id(hash);
        return reduceTRTID(id);
    }

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< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setFilterPassed() [1/2]

void AthAlgorithm::setFilterPassed ( bool state ) const

inherited

Definition at line 102 of file AthAlgorithm.cxx.

                                                     {
  setFilterPassed( state, Gaudi::Hive::currentContext() );
}

setFilterPassed() [2/2]

void AthAlgorithm::setFilterPassed ( bool state, const EventContext & ctx ) const

inherited

Definition at line 106 of file AthAlgorithm.cxx.

                                                                              {
  execState( ctx ).setFilterPassed(state);
}

setupPixel_AlignModule()

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

private

Definition at line 338 of file CreateMisalignAlg.cxx.

    {
                // SiDetectorElementCollection for Pixel
                SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> pixelDetEleHandle(m_pixelDetEleCollKey);
                const InDetDD::SiDetectorElementCollection* elements(*pixelDetEleHandle);
                if (not pixelDetEleHandle.isValid() or elements==nullptr) {
                  ATH_MSG_FATAL(m_pixelDetEleCollKey.fullKey() << " is not available.");
                  return;
                }
                for (const InDetDD::SiDetectorElement *element: *elements) {            
            // get the ID
                        const Identifier Pixel_ModuleID = element->identify();
                        const IdentifierHash Pixel_ModuleHash = m_pixelIdHelper->wafer_hash(Pixel_ModuleID);
            // check the validity
            if (Pixel_ModuleID.is_valid()) {
                if (m_ModuleList.find(Pixel_ModuleID) == m_ModuleList.end()) {
                        const InDetDD::SiDetectorElement *module = elements->getDetectorElement(Pixel_ModuleHash);
                    m_ModuleList[Pixel_ModuleID][0] = module->center()[0];
                    m_ModuleList[Pixel_ModuleID][1] = module->center()[1];
                    m_ModuleList[Pixel_ModuleID][2] = module->center()[2];
                    
                    ++nPixel;
                    ATH_MSG_VERBOSE( "Pixel module " << nPixel );
                    
                    // Write out Visualization Lookup Tree
                    m_AthenaHashedID = Pixel_ModuleID.get_identifier32().get_compact();
                    m_HumanReadableID = 1000000*1 /*1 = Pixel*/
                    + 100000*m_pixelIdHelper->layer_disk(Pixel_ModuleID)
                    + 1000*(10+m_pixelIdHelper->eta_module(Pixel_ModuleID))
                    + m_pixelIdHelper->phi_module(Pixel_ModuleID);
                    if ( m_pixelIdHelper->barrel_ec(Pixel_ModuleID) != 0 ) {
                        m_HumanReadableID = m_pixelIdHelper->barrel_ec(Pixel_ModuleID)*(m_HumanReadableID + 10000000);
                    }
                    
                    ATH_MSG_VERBOSE( "Human Readable ID: " << m_HumanReadableID );
                    
                    m_VisualizationLookupTree->Fill();
                    
                    if (msgLvl(MSG::VERBOSE)) {
            HepGeom::Transform3D InitialAlignment = Amg::EigenTransformToCLHEP(m_IDAlignDBTool->getTrans(Pixel_ModuleID,3));
                        msg() << "Initial Alignment of module " << m_idHelper->show_to_string(Pixel_ModuleID,nullptr,'/') << endmsg;
                        msg() << commonAlignmentOutput(InitialAlignment);
                        msg() << endmsg;
                    }
                }
            } else {
                ATH_MSG_INFO( "not a valid PIXEL Module ID (setup)" );
            }
        }
    }

setupSCT_AlignModule()

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

private

Definition at line 288 of file CreateMisalignAlg.cxx.

    {
                // SiDetectorElementCollection for SCT
                SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> sctDetEleHandle(m_SCTDetEleCollKey);
                const InDetDD::SiDetectorElementCollection* elements(*sctDetEleHandle);
                if (not sctDetEleHandle.isValid() or elements==nullptr) {
                        ATH_MSG_FATAL(m_SCTDetEleCollKey.fullKey() << " is not available.");
                        return;
                }
        for (const InDetDD::SiDetectorElement *element: *elements) {
            const Identifier SCT_ModuleID = m_sctIdHelper->module_id(element->identify()); //from wafer id to module id
                        const IdentifierHash SCT_ModuleHash = m_sctIdHelper->wafer_hash(SCT_ModuleID);
            
            if (m_ModuleList.find(SCT_ModuleID) == m_ModuleList.end())
            {
                const InDetDD::SiDetectorElement *module = elements->getDetectorElement(SCT_ModuleHash);
                m_ModuleList[SCT_ModuleID][0] = module->center()[0];
                m_ModuleList[SCT_ModuleID][1] = module->center()[1];
                m_ModuleList[SCT_ModuleID][2] = module->center()[2];
                ++nSCT;
                ATH_MSG_VERBOSE( "SCT module " << nSCT );
            }
            
            if (m_sctIdHelper->side(element->identify()) == 0) { // inner side case
                // Write out Visualization Lookup Tree
                m_AthenaHashedID = SCT_ModuleID.get_identifier32().get_compact();
                m_HumanReadableID = 1000000*2 /*2 = SCT*/
                + 100000*m_sctIdHelper->layer_disk(SCT_ModuleID)
                + 1000*(10+m_sctIdHelper->eta_module(SCT_ModuleID))
                + m_sctIdHelper->phi_module(SCT_ModuleID);
                if ( m_sctIdHelper->barrel_ec(SCT_ModuleID) != 0 ) {
                    m_HumanReadableID = m_sctIdHelper->barrel_ec(SCT_ModuleID)*(m_HumanReadableID + 10000000);
                }
                
                ATH_MSG_VERBOSE( "Human Readable ID: " << m_HumanReadableID );
                
                m_VisualizationLookupTree->Fill();
                
                // Syntax is (ID, Level) where Level is from 1 to 3 (3 is single module level)
                if (msgLvl(MSG::VERBOSE)) {
          HepGeom::Transform3D InitialAlignment = Amg::EigenTransformToCLHEP(m_IDAlignDBTool->getTrans(SCT_ModuleID,3));
                    msg() << "Initial Alignment of module " << m_idHelper->show_to_string(SCT_ModuleID,nullptr,'/') << endmsg;
                    msg() << commonAlignmentOutput(InitialAlignment);
                    msg() << endmsg;
                }
            } // end inner side case
        } //end loop over SCT elements
    }

setupTRT_AlignModule()

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

private

Definition at line 390 of file CreateMisalignAlg.cxx.

    {
        //TODO: writing into the Identifier tree is undone for TRT (AthenaHashedID and HumanReadableID)
        
        std::map< Identifier, std::vector<double> > trtModulesWithCOG;
 
                // TRT_DetElementContainer->TRT_DetElementCollection for TRT                                                                                                                            
        SG::ReadCondHandle<InDetDD::TRT_DetElementContainer> trtDetEleHandle(m_trtDetEleCollKey);
                const InDetDD::TRT_DetElementCollection* elements(trtDetEleHandle->getElements());
                if (not trtDetEleHandle.isValid() or elements==nullptr) {
          ATH_MSG_FATAL(m_trtDetEleCollKey.fullKey() << " is not available.");
          return;
                }
        
        //step through all detector elements (=strawlayers) and accumulate strawcenters per
        // element (with DB granularity, i.e. phi sectors in endcap, bi-modules in barrel)
        for (const InDetDD::TRT_BaseElement *element: *elements) {
            const Identifier TRTID_orig = element->identify();
            const Identifier TRTID      = reduceTRTID(TRTID_orig);
            bool insertSuccess{};
            std::tie(std::ignore, insertSuccess) = trtModulesWithCOG.insert({TRTID,std::vector<double>(4,0.)}); //create fresh vector for module center
            if (not insertSuccess){
              ATH_MSG_VERBOSE("No insert was performed, identifier was already in the trtModulesWithCOG map");
            }
            
            unsigned int nStraws = element->nStraws();
            for (unsigned int l = 0; l<nStraws; l++) {
                const Amg::Vector3D strawcenter = element->strawCenter(l);
                trtModulesWithCOG[TRTID].at(0) += strawcenter.x(); /*sumx*/
                trtModulesWithCOG[TRTID].at(1) += strawcenter.y(); /*sumy*/
                trtModulesWithCOG[TRTID].at(2) += strawcenter.z(); /*sumz*/
                trtModulesWithCOG[TRTID].at(3) += 1.;              /*nStraws*/
                
            }
            
                ATH_MSG_DEBUG( "this strawlayer has " << nStraws << " straws." );
                ATH_MSG_DEBUG( "strawcount of this module: " << trtModulesWithCOG[TRTID].at(3) );
            
        }
        
        //go through cog list and create one COG per TRT module (at DB granularity)
        std::map< Identifier, std::vector<double> >::const_iterator iter2;
        for (iter2 = trtModulesWithCOG.begin(); iter2!=trtModulesWithCOG.end(); ++iter2) {
            const Identifier TRTID = iter2->first;
            double nStraws = iter2->second.at(3);
            nTRT++;
            ATH_MSG_VERBOSE( "TRT module " << nTRT );
            m_ModuleList[TRTID] = HepGeom::Point3D<double>(iter2->second.at(0)/nStraws, iter2->second.at(1)/nStraws,iter2->second.at(2)/nStraws);
            
            HepGeom::Transform3D InitialAlignment ;
            
            const Amg::Transform3D* p = m_trtaligndbservice->getAlignmentTransformPtr(TRTID,2) ;
            if ( p ) {
                if (msgLvl(MSG::VERBOSE)) {
                InitialAlignment = Amg::EigenTransformToCLHEP(*p) ;
                    msg() << "Initial Alignment of module " << m_idHelper->show_to_string(TRTID,nullptr,'/') << endmsg;
                    msg() << commonAlignmentOutput(InitialAlignment);
                    msg() << endmsg;
                }
            } else {
                
                    ATH_MSG_VERBOSE("No initial alignment for TRT module " << m_idHelper->show_to_string(TRTID,nullptr,'/') );
            }
            
            
        }
    }

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< Gaudi::Algorithm > >.

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

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::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< Gaudi::Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_AlignResults_alpha

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

private

AP rotation around x-axis.

Definition at line 129 of file CreateMisalignAlg.h.

m_AlignResults_beta

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

private

AP rotation aorund y-axis.

Definition at line 130 of file CreateMisalignAlg.h.

m_AlignResults_gamma

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

private

AP rotation around z-axis.

Definition at line 131 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 134 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 137 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 132 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 135 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 136 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 133 of file CreateMisalignAlg.h.

m_AlignResults_x

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

private

Alignment parameter sensitive coordinate.

Definition at line 126 of file CreateMisalignAlg.h.

m_AlignResults_y

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

private

AP not-so-sensitive coordinate.

Definition at line 127 of file CreateMisalignAlg.h.

m_AlignResults_z

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

private

AP normal to module plane.

Definition at line 128 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 123 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< Gaudi::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 167 of file CreateMisalignAlg.h.

m_doStrip

bool InDetAlignment::CreateMisalignAlg::m_doStrip

private

Definition at line 168 of file CreateMisalignAlg.h.

m_doTRT

bool InDetAlignment::CreateMisalignAlg::m_doTRT

private

Definition at line 169 of file CreateMisalignAlg.h.

m_endcapShiftConvention

std::string InDetAlignment::CreateMisalignAlg::m_endcapShiftConvention

private

Endcap z-shift convention for mode 41.

Definition at line 106 of file CreateMisalignAlg.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::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 114 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 144 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 145 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 146 of file CreateMisalignAlg.h.

m_HumanReadableID

int InDetAlignment::CreateMisalignAlg::m_HumanReadableID

private

Definition at line 124 of file CreateMisalignAlg.h.

m_IBLBowingTshift

double InDetAlignment::CreateMisalignAlg::m_IBLBowingTshift

private

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

Definition at line 103 of file CreateMisalignAlg.h.

m_IDAlignDBTool

ToolHandle< IInDetAlignDBTool > InDetAlignment::CreateMisalignAlg::m_IDAlignDBTool

private

Definition at line 70 of file CreateMisalignAlg.h.

m_idHelper

const AtlasDetectorID* InDetAlignment::CreateMisalignAlg::m_idHelper

private

Definition at line 65 of file CreateMisalignAlg.h.

m_index

std::string InDetAlignment::CreateMisalignAlg::m_index

private

Generate misalignment according to module indices.

Definition at line 86 of file CreateMisalignAlg.h.

m_Initial_center_x

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

private

Initial global center of module.

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

m_local_rotation

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

private

Specify misalignment with rotation.

Definition at line 85 of file CreateMisalignAlg.h.

m_local_translation

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

private

Specify misalignment with translation.

Definition at line 84 of file CreateMisalignAlg.h.

m_Misalign_alpha

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

private

Definition at line 90 of file CreateMisalignAlg.h.

{this,"MisalignmentAlpha",0.0,"Fixed Alpha shift (model 1 and 2)"};

m_Misalign_beta

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

private

Definition at line 91 of file CreateMisalignAlg.h.

{this,"MisalignmentBeta",0.0,"Fixed Beta shift (mode 1 and 2)"};

m_Misalign_gamma

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

private

Definition at line 92 of file CreateMisalignAlg.h.

{this,"MisalignmentGamma",0.0,"Fixed Gamma shift (model 1 and 2)"};     

m_Misalign_maxShift

double InDetAlignment::CreateMisalignAlg::m_Misalign_maxShift

private

Maximum shift for global modes.

Definition at line 99 of file CreateMisalignAlg.h.

m_Misalign_maxShift_Inner

double InDetAlignment::CreateMisalignAlg::m_Misalign_maxShift_Inner

private

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

Definition at line 100 of file CreateMisalignAlg.h.

m_Misalign_x

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

private

Definition at line 87 of file CreateMisalignAlg.h.

{this,"MisalignmentX",0.0,"Fixed X shift (mode 1 and 2)"};

m_Misalign_y

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

private

Definition at line 88 of file CreateMisalignAlg.h.

{this,"MisalignmentY",0.0,"Fixed Y shif (model 1 and 2)"};       

m_Misalign_z

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

private

Definition at line 89 of file CreateMisalignAlg.h.

{this,"MisalignmentZ",0.0,"Fixed Z shift (mode 1 and 2)"};

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

{this, "PixelDetEleCollKey", "PixelDetectorElementCollection", "Key of SiDetectorElementCollection for Pixel"};

m_pixelIdHelper

const PixelID* InDetAlignment::CreateMisalignAlg::m_pixelIdHelper

private

Definition at line 66 of file CreateMisalignAlg.h.

m_radialShift

double InDetAlignment::CreateMisalignAlg::m_radialShift

private

Barrel radial shift for mode 43.

Definition at line 107 of file CreateMisalignAlg.h.

m_radialShiftConvention

std::string InDetAlignment::CreateMisalignAlg::m_radialShiftConvention

private

Barrel radial shift convention for mode 43.

Definition at line 108 of file CreateMisalignAlg.h.

m_radialSubdetector

std::string InDetAlignment::CreateMisalignAlg::m_radialSubdetector

private

Subdetector selector for mode 43: Pixel, Strip, or Both.

Definition at line 109 of file CreateMisalignAlg.h.

m_RndmMisalignWidth_alpha

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

private

Definition at line 96 of file CreateMisalignAlg.h.

{this,"RandomMisalignmentWidthAplha",0.1,"Gaussian width of Alpha random misalignments (mode 2)"};

m_RndmMisalignWidth_beta

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

private

Definition at line 97 of file CreateMisalignAlg.h.

{this,"RandomMisalignmentWidthBeta",0.1,"Gaussian width of Beta random misalignments (mode 2)"};

m_RndmMisalignWidth_gamma

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

private

Definition at line 98 of file CreateMisalignAlg.h.

{this,"RandomMisalignmentWidthGamma",0.1,"Gaussian width of Gamma random misalignments (mode 2)"};

m_RndmMisalignWidth_x

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

private

Definition at line 93 of file CreateMisalignAlg.h.

{this,"RandomMisalignmentWidthX",0.1,"Gaussian width of X random misalignments (mode 2)"};

m_RndmMisalignWidth_y

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

private

Definition at line 94 of file CreateMisalignAlg.h.

{this,"RandomMisalignmentWidthY",0.1,"Gaussian width of Y random misalignments (mode 2)"};

m_RndmMisalignWidth_z

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

private

Definition at line 95 of file CreateMisalignAlg.h.

{this,"RandomMisalignmentWidthZ",0.1,"Gaussian width of Z random misalignments (mode 2)"};

m_rotation

std::vector<double> InDetAlignment::CreateMisalignAlg::m_rotation

private

Flag which turns on misalignment with rotation.

Definition at line 83 of file CreateMisalignAlg.h.

m_ScalePixelBarrel

double InDetAlignment::CreateMisalignAlg::m_ScalePixelBarrel

private

Definition at line 110 of file CreateMisalignAlg.h.

m_ScalePixelDBM

double InDetAlignment::CreateMisalignAlg::m_ScalePixelDBM

private

Definition at line 102 of file CreateMisalignAlg.h.

m_ScalePixelEndcap

double InDetAlignment::CreateMisalignAlg::m_ScalePixelEndcap

private

Definition at line 111 of file CreateMisalignAlg.h.

m_ScalePixelIBL

double InDetAlignment::CreateMisalignAlg::m_ScalePixelIBL

private

Definition at line 101 of file CreateMisalignAlg.h.

m_ScaleSCTBarrel

double InDetAlignment::CreateMisalignAlg::m_ScaleSCTBarrel

private

Definition at line 112 of file CreateMisalignAlg.h.

m_ScaleSCTEndcap

double InDetAlignment::CreateMisalignAlg::m_ScaleSCTEndcap

private

Definition at line 113 of file CreateMisalignAlg.h.

m_ScaleTRTBarrel

double InDetAlignment::CreateMisalignAlg::m_ScaleTRTBarrel

private

Definition at line 114 of file CreateMisalignAlg.h.

m_ScaleTRTEndcap

double InDetAlignment::CreateMisalignAlg::m_ScaleTRTEndcap

private

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

{this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"};

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_targetLayer

int InDetAlignment::CreateMisalignAlg::m_targetLayer

private

ITk barrel layer selector for dedicated ITk modes (-1 means all layers).

Definition at line 104 of file CreateMisalignAlg.h.

m_targetLayerMax

int InDetAlignment::CreateMisalignAlg::m_targetLayerMax

private

Upper ITk barrel layer selector for layer-range modes (-999 means unused).

Definition at line 105 of file CreateMisalignAlg.h.

m_translation

std::vector<double> InDetAlignment::CreateMisalignAlg::m_translation

private

Flag which turns on misalignment with translation.

Definition at line 82 of file CreateMisalignAlg.h.

m_trtaligndbservice

ServiceHandle<ITRT_AlignDbSvc> InDetAlignment::CreateMisalignAlg::m_trtaligndbservice

private

Definition at line 71 of file CreateMisalignAlg.h.

m_trtDetEleCollKey

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

private

Definition at line 173 of file CreateMisalignAlg.h.

{this, "TRTDetEleCollKey", "TRT_DetElementContainer", "Key of TRT_DetElementContainer for TRT"};

m_trtIdHelper

const TRT_ID* InDetAlignment::CreateMisalignAlg::m_trtIdHelper

private

Definition at line 68 of file CreateMisalignAlg.h.

m_varHandleArraysDeclared

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

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_VisualizationLookupTree

TTree* InDetAlignment::CreateMisalignAlg::m_VisualizationLookupTree

private

Definition at line 121 of file CreateMisalignAlg.h.

---

The documentation for this class was generated from the following files:

• CreateMisalignAlg.h
• CreateMisalignAlg.cxx