Functions
	AtlasExtrapolatorCfg (flags, name='AtlasExtrapolator')
	TrigPFlowExtrapolatorCfg (flags, name='HLT_PFlowExtrapolator')
	egammaCaloExtrapolatorCfg (flags, name='egammaCaloExtrapolator')
	MCTruthClassifierExtrapolatorCfg (flags, name='MCTruthClassifierExtrapolator')
	InDetExtrapolatorCfg (flags, name='InDetExtrapolator', **kwargs)
	MuonExtrapolatorCfg (flags, name="MuonExtrapolator", **kwargs)
	MuonStraightLineExtrapolatorCfg (flags, name="MuonStraightLineExtrapolator", **kwargs)
	MCTBExtrapolatorCfg (flags, name='MCTBExtrapolator', **kwargs)

Variables
bool	use_old_names = False
	flags = initConfigFlags()
	Files
	cfg = ComponentAccumulator()
	mlog = logging.getLogger("AtlasExtrapolatorConfigTest")
	nestLevel
	printDefaults
	f = open("atlasextrapolator.pkl", "wb")

Function Documentation

◆ AtlasExtrapolatorCfg()

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()

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.
    # The 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))
 
    egammaPropagators = []
    egammaUpdators = []
 
    from TrkConfig.TrkExRungeKuttaPropagatorConfig import (
        RungeKuttaPropagatorCfg)
    RungeKuttaPropagator = result.popToolsAndMerge(
        RungeKuttaPropagatorCfg(flags))
    MaterialEffectsUpdator = result.popToolsAndMerge(
        TC.AtlasMaterialEffectsUpdatorCfg(flags))
 
    egammaPropagators += [RungeKuttaPropagator]
    egammaUpdators += [MaterialEffectsUpdator]
 
    from TrkConfig.TrkExSTEP_PropagatorConfig import (
        AtlasNoMatSTEP_PropagatorCfg)
    NoMatSTEP_Propagator = result.popToolsAndMerge(
        AtlasNoMatSTEP_PropagatorCfg(flags))
    NoElossMaterialEffectsUpdator = result.popToolsAndMerge(
        TC.AtlasNoElossMaterialEffectsUpdatorCfg(flags))
 
    egammaPropagators += [NoMatSTEP_Propagator]
    egammaUpdators += [NoElossMaterialEffectsUpdator]
 
    if flags.Detector.GeometryITk:
        from TrkConfig.TrkExRungeKuttaPropagatorConfig import ITkPropagatorCfg
        ITkPropagator = result.popToolsAndMerge(
            ITkPropagatorCfg(flags))
        ITkMaterialEffectsUpdator = result.popToolsAndMerge(
            TC.ITkMaterialEffectsUpdatorCfg(flags))
 
        egammaPropagators += [ITkPropagator]
        egammaUpdators += [ITkMaterialEffectsUpdator]
 
    # configure propagators/updators according to geometry signature
    egammaSubPropagators = []
    egammaSubUpdators = []
    # Global
    egammaSubPropagators += [RungeKuttaPropagator.name]
    egammaSubUpdators += [MaterialEffectsUpdator.name]
    # ID/ITK
    if flags.Detector.GeometryITk:
        egammaSubPropagators += [ITkPropagator.name]
        egammaSubUpdators += [ITkMaterialEffectsUpdator.name]
    else:
        egammaSubPropagators += [RungeKuttaPropagator.name]
        egammaSubUpdators += [MaterialEffectsUpdator.name]
    # BeamPipe
    egammaSubPropagators += [RungeKuttaPropagator.name]
    egammaSubUpdators += [MaterialEffectsUpdator.name]
    # Calo
    egammaSubPropagators += [RungeKuttaPropagator.name]
    egammaSubUpdators += [NoElossMaterialEffectsUpdator.name]
    # MS
    egammaSubPropagators += [NoMatSTEP_Propagator.name]
    egammaSubUpdators += [NoElossMaterialEffectsUpdator.name]
    # Cavern
    egammaSubPropagators += [RungeKuttaPropagator.name]
    egammaSubUpdators += [MaterialEffectsUpdator.name]
 
    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
    # No material effects at large
    egammaExtrapolator.ApplyMaterialEffects = False
 
    result.setPrivateTools(egammaExtrapolator)
    return result
 
 
@AccumulatorCache

◆ InDetExtrapolatorCfg()

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

Definition at line 318 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()

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

Definition at line 450 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()

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

Definition at line 278 of file AtlasExtrapolatorConfig.py.

                                     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
    # No material effects at large
    MCTruthExtrapolator.ApplyMaterialEffects = False
 
    result.setPrivateTools(MCTruthExtrapolator)
    return result
 
 
@AccumulatorCache

◆ MuonExtrapolatorCfg()

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

Definition at line 379 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()

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

Definition at line 425 of file AtlasExtrapolatorConfig.py.

                                    **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()

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