AlignmentAlgsConfig Namespace Reference

Functions
def	ActsAlignStoreProviderAlgCfg (flags, name="AlignStoreProviderAlg", **kwargs)
def	DetectorAlignCondAlgCfg (flags, name="DetectorAlignCondAlg", **kwargs)
def	PixelAlignCondAlgCfg (flags)
	Setups the Acts alignment for the Pixel detectors. More...
def	SctAlignCondAlgCfg (flags)
	Setups the Acts alignment for the Sct detectors. More...
def	ActsGeometryContextAlgCfg (flags, name="GeometryContextAlg", **kwargs)
	Setup the Geometry context algorithm. More...

Function Documentation

ActsAlignStoreProviderAlgCfg()

def AlignmentAlgsConfig.ActsAlignStoreProviderAlgCfg	(		flags,
			name = "AlignStoreProviderAlg",
		**	kwargs
	)

Definition at line 7 of file AlignmentAlgsConfig.py.

def ActsAlignStoreProviderAlgCfg(flags, name="AlignStoreProviderAlg", **kwargs):
    result = ComponentAccumulator()
    kwargs.setdefault("LoadDetectorVolumeSvc", False)
 
    from AthenaConfiguration.Enums import ProductionStep
    
    if flags.Common.ProductionStep  == ProductionStep.Simulation:       
        kwargs.setdefault("LoadTrackingGeoSvc" , False)
        kwargs.setdefault("LoadDetectorVolumeSvc" , False)
    else:
        kwargs.setdefault("LoadDetectorVolumeSvc", False)
        kwargs.setdefault("LoadTrackingGeoSvc", True)
 
    from ActsConfig.ActsGeometryConfig import ActsTrackingGeometrySvcCfg
    kwargs.setdefault("TrackingGeometrySvc", result.getPrimaryAndMerge(ActsTrackingGeometrySvcCfg(flags)) 
                                                                         if kwargs["LoadTrackingGeoSvc"] else "")
    from ActsGeometry.DetectorVolumeSvcCfg import DetectorVolumeSvcCfg
    kwargs.setdefault("DetectorVolumeSvc", result.getPrimaryAndMerge(DetectorVolumeSvcCfg(flags))
                                                                      if kwargs["LoadDetectorVolumeSvc"] else "")
 
    the_alg = CompFactory.ActsTrk.AlignStoreProviderAlg(name, **kwargs)
    result.addCondAlgo(the_alg, primary = True)
    return result
 

ActsGeometryContextAlgCfg()

def AlignmentAlgsConfig.ActsGeometryContextAlgCfg	(		flags,
			name = "GeometryContextAlg",
		**	kwargs
	)

Setup the Geometry context algorithm.

Definition at line 125 of file AlignmentAlgsConfig.py.

def ActsGeometryContextAlgCfg(flags, name="GeometryContextAlg", **kwargs):
    result = ComponentAccumulator()
    AlignmentStores = []
    
    from AthenaConfiguration.Enums import ProductionStep
    
    if flags.Common.ProductionStep  != ProductionStep.Simulation:
        result.merge(SctAlignCondAlgCfg(flags))
        result.merge(PixelAlignCondAlgCfg(flags))
        if flags.Detector.GeometryITkPixel: AlignmentStores += ["ActsITkPixelAlignmentStore"] 
        if flags.Detector.GeometryITkStrip: AlignmentStores += ["ActsITkStripAlignmentStore"]    
        if flags.Detector.GeometryPixel: AlignmentStores += ["ActsPixelAlignmentStore"]
        if flags.Detector.GeometrySCT: AlignmentStores += ["ActsSCTAlignmentStore"]
 
    
    if flags.Muon.usePhaseIIGeoSetup:
        from MuonGeoModelR4.MuonGeoModelConfig import MuonAlignStoreCfg
        result.merge(MuonAlignStoreCfg(flags))
      
        if flags.Detector.GeometryMDT:  AlignmentStores += ["MdtActsAlignContainer"]
        if flags.Detector.GeometryRPC:  AlignmentStores += ["RpcActsAlignContainer"]
        if flags.Detector.GeometryTGC:  AlignmentStores += ["TgcActsAlignContainer"]
        if flags.Detector.GeometrysTGC: AlignmentStores += ["sTgcActsAlignContainer"]
        if flags.Detector.GeometryMM:   AlignmentStores += ["MmActsAlignContainer"]
 
    kwargs.setdefault("AlignmentStores", AlignmentStores)
 
    the_alg = CompFactory.ActsTrk.GeometryContextAlg(name, **kwargs)
    result.addCondAlgo(the_alg, primary = True)
    return result

DetectorAlignCondAlgCfg()

def AlignmentAlgsConfig.DetectorAlignCondAlgCfg	(		flags,
			name = "DetectorAlignCondAlg",
		**	kwargs
	)

Definition at line 31 of file AlignmentAlgsConfig.py.

def DetectorAlignCondAlgCfg(flags, name="DetectorAlignCondAlg", **kwargs):
    result = ComponentAccumulator()
 
    from AthenaConfiguration.Enums import ProductionStep
    
    if flags.Common.ProductionStep  == ProductionStep.Simulation:       
        kwargs.setdefault("LoadTrackingGeoSvc" , False)
        kwargs.setdefault("LoadDetectorVolumeSvc" , False)
    else:
        kwargs.setdefault("LoadDetectorVolumeSvc", False)
        kwargs.setdefault("LoadTrackingGeoSvc", True)
 
    from ActsConfig.ActsGeometryConfig import ActsTrackingGeometrySvcCfg
    kwargs.setdefault("TrackingGeometrySvc", result.getPrimaryAndMerge(ActsTrackingGeometrySvcCfg(flags)) 
                                                                         if kwargs["LoadTrackingGeoSvc"] else "")
    from ActsGeometry.DetectorVolumeSvcCfg import DetectorVolumeSvcCfg
    kwargs.setdefault("DetectorVolumeSvc", result.getPrimaryAndMerge(DetectorVolumeSvcCfg(flags))
                                                                      if kwargs["LoadDetectorVolumeSvc"] else "")
 
    the_alg = CompFactory.ActsTrk.DetectorAlignCondAlg(name, **kwargs)
    result.addCondAlgo(the_alg, primary = True)
    return result
 
 

PixelAlignCondAlgCfg()

def AlignmentAlgsConfig.PixelAlignCondAlgCfg

(

flags

)

Setups the Acts alignment for the Pixel detectors.

Definition at line 56 of file AlignmentAlgsConfig.py.

def PixelAlignCondAlgCfg(flags):
    result = ComponentAccumulator()
    from ROOT.ActsTrk import DetectorType 
 
    if flags.Detector.GeometryITkPixel:
        from PixelConditionsAlgorithms.ITkPixelConditionsConfig import ITkPixelAlignCondAlgCfg
        result.merge(ITkPixelAlignCondAlgCfg(flags))
        result.merge(DetectorAlignCondAlgCfg(flags,
                                             name="ActsDetAlignmentCondAlgITkPixel",
                                             InputTransforms="ITkPixelAlignmentStore",
                                             ActsTransforms="ActsITkPixelAlignmentStore",
                                             DetectorType=DetectorType.Pixel))
        result.merge(ActsAlignStoreProviderAlgCfg(flags,
                                                  name="ActsDetAlignmentAlgITkPixel",
                                                  CondAlignStore="ActsITkPixelAlignmentStore",
                                                  EventAlignStore="ActsITkPixelAlignmentStore",
                                                  DetectorType=DetectorType.Pixel))
 
    elif flags.Detector.GeometryPixel:
        from PixelConditionsAlgorithms.PixelConditionsConfig import PixelAlignCondAlgCfg
        result.merge(PixelAlignCondAlgCfg(flags))
        result.merge(DetectorAlignCondAlgCfg(flags,
                                             name="ActsDetAlignmentCondAlgPixel",
                                             InputTransforms="PixelAlignmentStore",
                                             ActsTransforms="ActsPixelAlignmentStore",
                                             DetectorType=DetectorType.Pixel))
        result.merge(ActsAlignStoreProviderAlgCfg(flags,
                                                  name="ActsDetAlignmentAlgPixel",
                                                  CondAlignStore="ActsPixelAlignmentStore",
                                                  EventAlignStore="ActsPixelAlignmentStore",
                                                  DetectorType=DetectorType.Pixel))
    return result
 

SctAlignCondAlgCfg()

def AlignmentAlgsConfig.SctAlignCondAlgCfg

(

flags

)

Setups the Acts alignment for the Sct detectors.

Definition at line 90 of file AlignmentAlgsConfig.py.

def SctAlignCondAlgCfg(flags):
    result = ComponentAccumulator()
    from ROOT.ActsTrk import DetectorType 
 
    if flags.Detector.GeometryITkStrip:
        from SCT_ConditionsAlgorithms.ITkStripConditionsAlgorithmsConfig import ITkStripAlignCondAlgCfg
        result.merge(ITkStripAlignCondAlgCfg(flags))
        result.merge(DetectorAlignCondAlgCfg(flags,
                                             name="ActsDetAlignmentCondAlgITkSct",
                                             InputTransforms="ITkStripAlignmentStore",
                                             ActsTransforms="ActsITkStripAlignmentStore",
                                             DetectorType=DetectorType.Sct))
        result.merge(ActsAlignStoreProviderAlgCfg(flags,
                                                  name="ActsDetAlignmentAlgITkSct",
                                                  CondAlignStore="ActsITkStripAlignmentStore",
                                                  EventAlignStore="ActsITkStripAlignmentStore",
                                                  DetectorType=DetectorType.Sct))
    elif flags.Detector.GeometrySCT:
        from SCT_ConditionsAlgorithms.SCT_ConditionsAlgorithmsConfig import SCT_AlignCondAlgCfg
        result.merge(SCT_AlignCondAlgCfg(flags))
        result.merge(DetectorAlignCondAlgCfg(flags,
                                                name="ActsDetAlignmentCondAlgSct",
                                                InputTransforms="SCTAlignmentStore",
                                                ActsTransforms="ActsSCTAlignmentStore",
                                                DetectorType=DetectorType.Sct))
 
        result.merge(ActsAlignStoreProviderAlgCfg(flags,
                                                  name="ActsDetAlignmentAlgSct",
                                                  CondAlignStore="ActsSCTAlignmentStore",
                                                  EventAlignStore="ActsSCTAlignmentStore",
                                                  DetectorType=DetectorType.Sct))
    return result