Functions
def	AtlasExtrapolatorCfg (flags, name='AtlasExtrapolator')

def	TrigPFlowExtrapolatorCfg (flags, name='HLT_PFlowExtrapolator')

def	egammaCaloExtrapolatorCfg (flags, name='egammaCaloExtrapolator')

def	MCTruthClassifierExtrapolatorCfg (flags, name='MCTruthClassifierExtrapolator')

def	InDetExtrapolatorCfg (flags, name='InDetExtrapolator', **kwargs)

def	MuonExtrapolatorCfg (flags, name="MuonExtrapolator", **kwargs)

def	MuonStraightLineExtrapolatorCfg (flags, name="MuonStraightLineExtrapolator", **kwargs)

def	MCTBExtrapolatorCfg (flags, name='MCTBExtrapolator', **kwargs)

Variables
	use_old_names

	flags

	Files

	cfg

	mlog

	nestLevel

	printDefaults

	f

Function Documentation

◆ AtlasExtrapolatorCfg()

def python.AtlasExtrapolatorConfig.AtlasExtrapolatorCfg	(	flags,
		name = `'AtlasExtrapolator'`
	)

Definition at line 63 of file AtlasExtrapolatorConfig.py.

 def AtlasExtrapolatorCfg(flags, name='AtlasExtrapolator'):
     # Default "ATLAS" with some reasonable defaults
     # Rk for Global/ID STEP to be used for dense volumes.
     from TrkConfig.AtlasExtrapolatorToolsConfig import (
         AtlasMultipleScatteringUpdatorCfg)
  
     result = ComponentAccumulator()
  
     # propagator defaults
     from TrkConfig.TrkExRungeKuttaPropagatorConfig import (
         RungeKuttaPropagatorCfg)
     AtlasRungeKuttaPropagator = result.popToolsAndMerge(
         RungeKuttaPropagatorCfg(flags))
     AtlasSTEP_Propagator = result.popToolsAndMerge(
         AtlasSTEP_PropagatorCfg(flags))
     ITkPropagator = None
     if flags.Detector.GeometryITk:
         from TrkConfig.TrkExRungeKuttaPropagatorConfig import ITkPropagatorCfg
         ITkPropagator = result.popToolsAndMerge(
             ITkPropagatorCfg(flags))
  
     AtlasPropagators = []
     AtlasPropagators += [AtlasRungeKuttaPropagator]
     AtlasPropagators += [AtlasSTEP_Propagator]
     if flags.Detector.GeometryITk:
         AtlasPropagators += [ITkPropagator]
  
     # updator defaults
     AtlasMaterialEffectsUpdator = result.popToolsAndMerge(
         TC.AtlasMaterialEffectsUpdatorCfg(flags))
     AtlasMaterialEffectsUpdatorLandau = result.popToolsAndMerge(
         TC.AtlasMaterialEffectsUpdatorLandauCfg(flags))
     ITkMaterialEffectsUpdator = None
     if flags.Detector.GeometryITk:
         ITkMaterialEffectsUpdator = result.popToolsAndMerge(
             TC.ITkMaterialEffectsUpdatorCfg(flags))
  
     AtlasUpdators = []
     AtlasUpdators += [AtlasMaterialEffectsUpdator]
     AtlasUpdators += [AtlasMaterialEffectsUpdatorLandau]
     if flags.Detector.GeometryITk:
         AtlasUpdators += [ITkMaterialEffectsUpdator]
  
     AtlasNavigator = result.popToolsAndMerge(TC.AtlasNavigatorCfg(flags))
  
     # configure propagators/updators according to geometry signature
     AtlasSubPropagators = []
     AtlasSubPropagators += [AtlasRungeKuttaPropagator.name]  # Global
     if flags.Detector.GeometryITk:
         AtlasSubPropagators += [ITkPropagator.name]  # ITk
     else:
         AtlasSubPropagators += [AtlasRungeKuttaPropagator.name]  # ID
     AtlasSubPropagators += [AtlasSTEP_Propagator.name]  # BeamPipe
     AtlasSubPropagators += [AtlasSTEP_Propagator.name]  # Calo
     AtlasSubPropagators += [AtlasSTEP_Propagator.name]  # MS
     AtlasSubPropagators += [AtlasRungeKuttaPropagator.name]  # Cavern
  
     AtlasSubUpdators = []
     AtlasSubUpdators += [AtlasMaterialEffectsUpdator.name]  # Global
     if flags.Detector.GeometryITk:
         AtlasSubUpdators += [ITkMaterialEffectsUpdator.name]  # ITk
     else:
         AtlasSubUpdators += [AtlasMaterialEffectsUpdator.name]  # ID
     AtlasSubUpdators += [AtlasMaterialEffectsUpdator.name]  # BeamPipe
     AtlasSubUpdators += [AtlasMaterialEffectsUpdator.name]  # Calo
     AtlasSubUpdators += [AtlasMaterialEffectsUpdator.name]  # MS
     AtlasSubUpdators += [AtlasMaterialEffectsUpdator.name]  # Cavern
  
     AtlasELossUpdater = result.popToolsAndMerge(
         TC.AtlasEnergyLossUpdatorCfg(flags))
     AtlasEnergyLossUpdater = AtlasELossUpdater
  
     # call the base class constructor
     Extrapolator = CompFactory.Trk.Extrapolator(
         name,
         Navigator=AtlasNavigator,
         MaterialEffectsUpdators=AtlasUpdators,
         MultipleScatteringUpdater=result.popToolsAndMerge(
             AtlasMultipleScatteringUpdatorCfg(flags, UseTrkUtils=True)),
         STEP_Propagator=AtlasSTEP_Propagator,
         Propagators=AtlasPropagators,
         SubPropagators=AtlasSubPropagators,
         SubMEUpdators=AtlasSubUpdators,
         EnergyLossUpdater=AtlasEnergyLossUpdater
     )
  
     result.setPrivateTools(Extrapolator)
     return result
  
  
 @AccumulatorCache

◆ egammaCaloExtrapolatorCfg()

def python.AtlasExtrapolatorConfig.egammaCaloExtrapolatorCfg	(	flags,
		name = `'egammaCaloExtrapolator'`
	)

Definition at line 194 of file AtlasExtrapolatorConfig.py.

 def egammaCaloExtrapolatorCfg(flags, name='egammaCaloExtrapolator'):
     # e/gamma mainly uses Extrapolate Directly to a particular
     # surface to the calo. We do not do "tracking"
     # as electrons/photon have showered.
     # This means that in practice only the 'Global'
     # propagator is used with not material effects.
     # Configure everything in any case for clarity/consistency.
     result = ComponentAccumulator()
  
     egammaExtrapolator = result.popToolsAndMerge(
         AtlasExtrapolatorCfg(flags, name))
  
     from TrkConfig.TrkExRungeKuttaPropagatorConfig import (
         RungeKuttaPropagatorCfg)
     RungeKuttaPropagator = result.popToolsAndMerge(
         RungeKuttaPropagatorCfg(flags))
     from TrkConfig.TrkExSTEP_PropagatorConfig import (
         AtlasNoMatSTEP_PropagatorCfg)
     NoMatSTEP_Propagator = result.popToolsAndMerge(
         AtlasNoMatSTEP_PropagatorCfg(flags))
     ITkPropagator = None
     if flags.Detector.GeometryITk:
         from TrkConfig.TrkExRungeKuttaPropagatorConfig import ITkPropagatorCfg
         ITkPropagator = result.popToolsAndMerge(
             ITkPropagatorCfg(flags))
  
     egammaPropagators = []
     egammaPropagators += [RungeKuttaPropagator]
     egammaPropagators += [NoMatSTEP_Propagator]
     if flags.Detector.GeometryITk:
         egammaPropagators += [ITkPropagator]
  
     MaterialEffectsUpdator = result.popToolsAndMerge(
         TC.AtlasMaterialEffectsUpdatorCfg(flags))
     NoElossMaterialEffectsUpdator = result.popToolsAndMerge(
         TC.AtlasNoElossMaterialEffectsUpdatorCfg(flags))
     ITkMaterialEffectsUpdator = None
     if flags.Detector.GeometryITk:
         ITkMaterialEffectsUpdator = result.popToolsAndMerge(
             TC.ITkMaterialEffectsUpdatorCfg(flags))
  
     egammaUpdators = []
     egammaUpdators += [MaterialEffectsUpdator]
     egammaUpdators += [NoElossMaterialEffectsUpdator]
     if flags.Detector.GeometryITk:
         egammaUpdators += [ITkMaterialEffectsUpdator]
  
     # configure propagators/updators according to geometry signature
     egammaSubPropagators = []
     egammaSubPropagators += [RungeKuttaPropagator.name]  # Global
     if flags.Detector.GeometryITk:
         egammaSubPropagators += [ITkPropagator.name]  # ITk
     else:
         egammaSubPropagators += [RungeKuttaPropagator.name]  # ID
  
     egammaSubPropagators += [RungeKuttaPropagator.name]  # BeamPipe
     egammaSubPropagators += [RungeKuttaPropagator.name]  # Calo
     egammaSubPropagators += [NoMatSTEP_Propagator.name]  # MS
     egammaSubPropagators += [RungeKuttaPropagator.name]  # Cavern
  
     egammaSubUpdators = []
     egammaSubUpdators += [MaterialEffectsUpdator.name]  # Global
     if flags.Detector.GeometryITk:
         egammaSubUpdators += [ITkMaterialEffectsUpdator.name]  # ID
     else:
         egammaSubUpdators += [MaterialEffectsUpdator.name]  # ID
     egammaSubUpdators += [MaterialEffectsUpdator.name]  # BeamPipe
     egammaSubUpdators += [NoElossMaterialEffectsUpdator.name]  # Calo
     egammaSubUpdators += [NoElossMaterialEffectsUpdator.name]  # MS
     egammaSubUpdators += [MaterialEffectsUpdator.name]  # Cavern
  
     egammaExtrapolator.MaterialEffectsUpdators = egammaUpdators
     egammaExtrapolator.SubMEUpdators = egammaSubUpdators
     egammaExtrapolator.Propagators = egammaPropagators
     egammaExtrapolator.SubPropagators = egammaSubPropagators
     # egamma STEP with no eloss for calo intersections
     egammaExtrapolator.STEP_Propagator = NoMatSTEP_Propagator
  
     result.setPrivateTools(egammaExtrapolator)
     return result
  
  
 @AccumulatorCache

◆ InDetExtrapolatorCfg()

def python.AtlasExtrapolatorConfig.InDetExtrapolatorCfg	(		flags,
			name = `'InDetExtrapolator'`,
		**	kwargs
	)

Definition at line 315 of file AtlasExtrapolatorConfig.py.

 def InDetExtrapolatorCfg(flags, name='InDetExtrapolator', **kwargs):
     # Inner detector config cares mainly for the "Global".
     # This is usually the RungeKutta Propagator and a material
     # effects updator without energy loss.
     # As extrapolations are to happen inside the InDet volume.
     result = ComponentAccumulator()
  
     # FIXME copied from the old config, also needs fixing on the c++ side.
     if 'Propagators' not in kwargs:
         from TrkConfig.TrkExRungeKuttaPropagatorConfig import (
             InDetPropagatorCfg)
         InDetPropagator = result.popToolsAndMerge(
             InDetPropagatorCfg(flags))
         Propagators = [InDetPropagator]
         kwargs.setdefault("Propagators", Propagators)
  
     propagator = kwargs.get('Propagators')[0].name if (
         kwargs.get('Propagators', None) is not None
         and len(kwargs.get('Propagators', None)) > 0) else None
  
     if 'MaterialEffectsUpdators' not in kwargs:
         InDetMaterialEffectsUpdator = result.getPrimaryAndMerge(
             TC.InDetMaterialEffectsUpdatorCfg(flags))
         MaterialEffectsUpdators = [InDetMaterialEffectsUpdator]
         kwargs.setdefault("MaterialEffectsUpdators", MaterialEffectsUpdators)
     material_updator = kwargs.get('MaterialEffectsUpdators')[0].name if (
         kwargs.get('MaterialEffectsUpdators', None) is not None
         and len(kwargs.get('MaterialEffectsUpdators', None)) > 0) else None
  
     if 'Navigator' not in kwargs:
         AtlasNavigator = result.popToolsAndMerge(
             TC.AtlasNavigatorCfg(flags, name="InDetNavigator"))
         kwargs.setdefault("Navigator", AtlasNavigator)
  
     sub_propagators = []
     sub_updators = []
  
     # configure propagators/updators according to geometry signature
     # Global entry
     sub_propagators += [propagator]
     sub_updators += [material_updator]
  
     # ID entry
     sub_propagators += [propagator]
     sub_updators += [material_updator]
  
     # beampipe entry
     sub_updators += [material_updator]
  
     kwargs.setdefault("SubPropagators", sub_propagators)
     kwargs.setdefault("SubMEUpdators", sub_updators)
  
     AtlasELossUpdater = result.popToolsAndMerge(
         TC.AtlasEnergyLossUpdatorCfg(flags))
     kwargs.setdefault("EnergyLossUpdater", AtlasELossUpdater)
  
     extrapolator = CompFactory.Trk.Extrapolator(name, **kwargs)
     result.setPrivateTools(extrapolator)
     return result
  
  

◆ MCTBExtrapolatorCfg()

def python.AtlasExtrapolatorConfig.MCTBExtrapolatorCfg	(		flags,
			name = `'MCTBExtrapolator'`,
		**	kwargs
	)

Definition at line 447 of file AtlasExtrapolatorConfig.py.

 def MCTBExtrapolatorCfg(flags, name='MCTBExtrapolator', **kwargs):
     # Muon set the STEP also as the single "Global" propagator
     result = ComponentAccumulator()
     if use_old_names:
         kwargs.setdefault("Propagators", [result.popToolsAndMerge(
             AtlasSTEP_PropagatorCfg(flags, name='MCTBPropagator'))])
         kwargs.setdefault("STEP_Propagator",
                           result.popToolsAndMerge(AtlasSTEP_PropagatorCfg(flags)))
     else:
         prop = result.popToolsAndMerge(
             AtlasSTEP_PropagatorCfg(flags))
         kwargs.setdefault("Propagators", [prop])
         kwargs.setdefault("STEP_Propagator", prop)
     kwargs.setdefault("ResolveMuonStation", False)
     kwargs.setdefault("Navigator", result.popToolsAndMerge(
         TC.AtlasNavigatorCfg(flags, name="InDetNavigator")))
     kwargs.setdefault("EnergyLossUpdater", result.popToolsAndMerge(
         TC.AtlasEnergyLossUpdatorCfg(flags)))
  
     result.setPrivateTools(result.popToolsAndMerge(
         MuonExtrapolatorCfg(flags, name, **kwargs)))
     return result
  
  

◆ MCTruthClassifierExtrapolatorCfg()

def python.AtlasExtrapolatorConfig.MCTruthClassifierExtrapolatorCfg	(	flags,
		name = `'MCTruthClassifierExtrapolator'`
	)

Definition at line 277 of file AtlasExtrapolatorConfig.py.

 def MCTruthClassifierExtrapolatorCfg(flags,
                                      name='MCTruthClassifierExtrapolator'):
     # MCTruthClassifier. Used to Extrapolate Directly
     # photons (fwd Electrons) to a specific surface to the calo
     # for truth matching.
     # We do not do "tracking" as electrons/photon have showered.
     # This means that in practice only the 'Global'
     # propagator and no material effects.
     # Configure everything in any case for clarity/consistency.
     result = ComponentAccumulator()
  
     MCTruthExtrapolator = result.popToolsAndMerge(
         AtlasExtrapolatorCfg(flags, name))
  
     MCTruthUpdators = []
  
     NoElossMaterialEffectsUpdator = result.popToolsAndMerge(
         TC.AtlasNoElossMaterialEffectsUpdatorCfg(flags))
     MCTruthUpdators += [NoElossMaterialEffectsUpdator]
  
     MCTruthSubUpdators = []
  
     # configure propagators/updators according to geometry signature
     MCTruthSubUpdators += [NoElossMaterialEffectsUpdator.name]  # Global
     MCTruthSubUpdators += [NoElossMaterialEffectsUpdator.name]  # ID
     MCTruthSubUpdators += [NoElossMaterialEffectsUpdator.name]  # beampipe
     MCTruthSubUpdators += [NoElossMaterialEffectsUpdator.name]  # calo
     MCTruthSubUpdators += [NoElossMaterialEffectsUpdator.name]  # MS
     MCTruthSubUpdators += [NoElossMaterialEffectsUpdator.name]  # cavern
  
     MCTruthExtrapolator.MaterialEffectsUpdators = MCTruthUpdators
     MCTruthExtrapolator.SubMEUpdators = MCTruthSubUpdators
  
     result.setPrivateTools(MCTruthExtrapolator)
     return result
  
  
 @AccumulatorCache

◆ MuonExtrapolatorCfg()

def python.AtlasExtrapolatorConfig.MuonExtrapolatorCfg	(		flags,
			name = `"MuonExtrapolator"`,
		**	kwargs
	)

Definition at line 376 of file AtlasExtrapolatorConfig.py.

 def MuonExtrapolatorCfg(flags, name="MuonExtrapolator", **kwargs):
     from TrkConfig.AtlasExtrapolatorToolsConfig import (
         AtlasMultipleScatteringUpdatorCfg)
  
     # Muons set the STEP also as the single "Global" propagator
     result = ComponentAccumulator()
  
     AtlasMaterialEffectsUpdator = result.popToolsAndMerge(
         TC.AtlasMaterialEffectsUpdatorCfg(flags,
                                           name="MuonMaterialEffectsUpdator"))
     kwargs.setdefault("MaterialEffectsUpdators", [AtlasMaterialEffectsUpdator])
  
     kwargs.setdefault("MultipleScatteringUpdater",
                       result.popToolsAndMerge(
                           AtlasMultipleScatteringUpdatorCfg(flags,
                                                             UseTrkUtils=True)))
  
     AtlasNavigator = result.popToolsAndMerge(TC.AtlasNavigatorCfg(
         flags, name='InDetNavigator' if use_old_names else None))
     kwargs.setdefault("Navigator", AtlasNavigator)
  
     AtlasELossUpdater = result.popToolsAndMerge(
         TC.AtlasEnergyLossUpdatorCfg(flags))
     kwargs.setdefault("EnergyLossUpdater", AtlasELossUpdater)
  
     if 'STEP_Propagator' not in kwargs:
         AtlasSTEP_Propagator = result.popToolsAndMerge(
             AtlasSTEP_PropagatorCfg(flags))
         kwargs.setdefault("STEP_Propagator", AtlasSTEP_Propagator)
  
     if 'Propagators' not in kwargs:
         if use_old_names:
             kwargs.setdefault("Propagators", [result.popToolsAndMerge(
                 AtlasSTEP_PropagatorCfg(flags, name="MuonPropagator"))])
         else:
             kwargs.setdefault("Propagators", [kwargs["STEP_Propagator"]])
  
     kwargs.setdefault("ResolveMuonStation", True)
     # must be > 1um to avoid missing MTG intersections
     kwargs.setdefault("Tolerance", 0.0011)
  
     extrap = CompFactory.Trk.Extrapolator(name, **kwargs)
     result.setPrivateTools(extrap)
     return result
  
  

◆ MuonStraightLineExtrapolatorCfg()

def python.AtlasExtrapolatorConfig.MuonStraightLineExtrapolatorCfg	(		flags,
			name = `"MuonStraightLineExtrapolator"`,
		**	kwargs
	)

Definition at line 422 of file AtlasExtrapolatorConfig.py.

 def MuonStraightLineExtrapolatorCfg(flags,
                                     name="MuonStraightLineExtrapolator",
                                     **kwargs):
     # Muon set the STEP also as the single "Global" propagator
     result = ComponentAccumulator()
  
     muon_prop = None
     if use_old_names:
         muon_prop = result.popToolsAndMerge(
             AtlasSTEP_PropagatorCfg(flags, name='MuonStraightLinePropagator'))
     else:
         muon_prop = result.popToolsAndMerge(AtlasSTEP_PropagatorCfg(flags))
     kwargs.setdefault("Propagators", [muon_prop])
     kwargs.setdefault("STEP_Propagator", muon_prop)
     extrap = result.popToolsAndMerge(
         MuonExtrapolatorCfg(flags, name, **kwargs))
     result.setPrivateTools(extrap)
     result.addPublicTool(extrap)
     # This should be done by the client with the public tool,
     # but since it's hard to track down
     # (and since Extrapolators are a specicial case),
     # just be pragmatic for now.
     return result
  
  

◆ TrigPFlowExtrapolatorCfg()

def python.AtlasExtrapolatorConfig.TrigPFlowExtrapolatorCfg	(	flags,
		name = `'HLT_PFlowExtrapolator'`
	)

Definition at line 154 of file AtlasExtrapolatorConfig.py.

 def TrigPFlowExtrapolatorCfg(flags, name='HLT_PFlowExtrapolator'):
     # This is the extrapolator which is used in PFlow 
     # reconstruction at the level of HLT. It allows to
     # setup the tolerance which influences speed (but also 
     # precision) of the extrapolation. 
     result = ComponentAccumulator()
  
     PFlowExtrapolator = result.popToolsAndMerge(
         AtlasExtrapolatorCfg(flags, name))
  
     from TrkConfig.TrkExRungeKuttaPropagatorConfig import (
         RungeKuttaPropagatorCfg)
     RungeKuttaPropagator = result.popToolsAndMerge(
         RungeKuttaPropagatorCfg(flags))
     from TrkConfig.TrkExSTEP_PropagatorConfig import (
         AtlasSTEP_PropagatorCfg)
     pflowSTEP_Propagator = result.popToolsAndMerge(
         AtlasSTEP_PropagatorCfg(flags,Tolerance=flags.Trigger.Jet.PFlowTolerance))
  
     pflowPropagators = []
     pflowPropagators += [RungeKuttaPropagator]
     pflowPropagators += [pflowSTEP_Propagator]
  
     pflowSubPropagators = []
     pflowSubPropagators += [RungeKuttaPropagator.name]  # for Global
     pflowSubPropagators += [RungeKuttaPropagator.name]  # for ID
     pflowSubPropagators += [pflowSTEP_Propagator.name]  # for BeamPipe
     pflowSubPropagators += [pflowSTEP_Propagator.name]  # for Calo
     pflowSubPropagators += [pflowSTEP_Propagator.name]  # for MS
     pflowSubPropagators += [RungeKuttaPropagator.name]  # for cavern
  
     PFlowExtrapolator.Propagators = pflowPropagators
     PFlowExtrapolator.SubPropagators = pflowSubPropagators
     PFlowExtrapolator.STEP_Propagator = pflowSTEP_Propagator
  
     result.setPrivateTools(PFlowExtrapolator)
     return result
  
  
 @AccumulatorCache