TauToolHolder Namespace Reference

Functions
	JetSeedBuilderCfg (flags)
	JetSeedBuilder.
	TauVertexFinderCfg (flags)
	TauAxisCfg (flags)
	Tau energy calibration and tau axis direction.
	getParticleCache (flags)
	TauTrackFinderCfg (flags)
	Tau-Track Association.
	TauClusterFinderCfg (flags)
	Associate the cluster in jet constituents to the tau candidate.
	TauVertexedClusterDecoratorCfg (flags)
	TauTrackRNNCfg (flags)
	TauTrackRNNClassifierCfg (flags)
	EnergyCalibrationLCCfg (flags)
	Tau energy calibration.
	CellVariablesCfg (flags)
	Tau cell variables calculation.
	ElectronVetoVarsCfg (flags)
	ele veto variables
	TauShotFinderCfg (flags)
	Photon Shot Finder.
	Pi0ClusterFinderCfg (flags)
	Pi0 algo Cluster finder for Pi0 algo.
	TauCellFinalizerCfg (flags)
	Cell finalizer tool for BuildAlg.
	TauCaloLCClassificationCfg (flags)
	Calo Tools.
	TauCaloLCWeightCfg (flags)
	TauCaloLCOutOfClusterCfg (flags)
	TauCaloLCOutPi0Cfg (flags)
	TauCaloLCDeadMaterialCfg (flags)
	TauCaloClusterLocalCalibCfg (flags)
	TauCaloOOCCalibCfg (flags)
	TauCaloDMCalibCfg (flags)
	TauCaloOOCPi0CalibCfg (flags)
	TauCaloTopoClusterMakerCfg (flags)
	TauCaloTopoClusterSplitterCfg (flags)
	TauCaloClusterMomentsMakerCfg (flags)
	TauCaloClusterBadChannelCfg (flags)
	Pi0ClusterCreatorCfg (flags)
	create Pi0 clusters
	Pi0ClusterScalerCfg (flags)
	Set energy of cluster to take care of charged pion energy deposited in the ECAL.
	Pi0ScoreCalculatorCfg (flags)
	calculate MVA scores of pi0 clusters
	Pi0SelectorCfg (flags)
	select pi0 clusters
	TauVertexVariablesCfg (flags)
	Tau Vertex Variables.
	TauCommonCalcVarsCfg (flags)
	Tau Variables.
	TauSubstructureCfg (flags)
	Tau Variables.
	MvaTESVariableDecoratorCfg (flags)
	MvaTESVariableDecorator.
	MvaTESEvaluatorCfg (flags)
	MvaTESEvaluator.
	TauIDVarCalculatorCfg (flags)
	TauJetRNNEvaluatorCfg (flags, applyLooseTrackSel=False)
	TauWPDecoratorJetRNNCfg (flags)
	TauGNNEvaluatorCfg (flags, version=0, applyLooseTrackSel=False, applyTightTrackSel=False, tauContainerName="")
	TauWPDecoratorGNNCfg (flags, version, tauContainerName="")
	TauGNNDisplacedEvaluatorCfg (flags, tauContainerName="")
	TauEleRNNEvaluatorCfg (flags, applyLooseTrackSel=False)
	TauWPDecoratorEleRNNCfg (flags)
	TauDecayModeNNClassifierCfg (flags)
	TauAODSelectorCfg (flags)
	TauCombinedTESCfg (flags, **kwargs)
	TauCombinedTES.
	TauAODMuonRemovalCfg (flags)
	muon removal tool
	TauEleOverlapChecker (flags)

Function Documentation

CellVariablesCfg()

CellVariablesCfg

(

flags

)

Tau cell variables calculation.

Definition at line 208 of file TauToolHolder.py.

def CellVariablesCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'CellVariables'
 
    TauCellVariables = CompFactory.getComp("TauCellVariables")
    TauCellVariables = TauCellVariables(name = _name,
                                        VertexCorrection = flags.Tau.doVertexCorrection)
 
    result.setPrivateTools(TauCellVariables)
    return result
 

ElectronVetoVarsCfg()

ElectronVetoVarsCfg

(

flags

)

ele veto variables

Definition at line 221 of file TauToolHolder.py.

def ElectronVetoVarsCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'TauElectronVetoVars'
    
    from TrackToCalo.TrackToCaloConfig import ParticleCaloExtensionToolCfg
 
    TauElectronVetoVariables = CompFactory.getComp("TauElectronVetoVariables")
    TauElectronVetoVariables = TauElectronVetoVariables(name = _name,
                                                        VertexCorrection = flags.Tau.doVertexCorrection,
                                                        ParticleCaloExtensionTool = result.popToolsAndMerge(ParticleCaloExtensionToolCfg(flags)),
                                                        tauEVParticleCache = getParticleCache(flags))
 
    result.setPrivateTools(TauElectronVetoVariables)
    return result
 

EnergyCalibrationLCCfg()

EnergyCalibrationLCCfg

(

flags

)

Tau energy calibration.

Definition at line 194 of file TauToolHolder.py.

def EnergyCalibrationLCCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix +'EnergyCalibrationLC'
 
    TauCalibrateLC = CompFactory.getComp("TauCalibrateLC")
    TauCalibrateLC = TauCalibrateLC(name = _name,
                                    calibrationFile = flags.Tau.CalibrateLCConfig,
                                    Key_vertexInputContainer = flags.Tau.ActiveConfig.VertexCollection)
            
    result.setPrivateTools(TauCalibrateLC)
    return result
 

getParticleCache()

getParticleCache

(

flags

)

Definition at line 70 of file TauToolHolder.py.

def getParticleCache(flags):
    #If reading from ESD we not create a cache of extrapolations to the calorimeter, so we should signify this by setting the cache key to a null string
    if flags.Common.ProductionStep is ProductionStep.Reconstruction:
        ParticleCache = "ParticleCaloExtension"
    else:
        ParticleCache = ""
 
    return ParticleCache
 

JetSeedBuilderCfg()

JetSeedBuilderCfg

(

flags

)

JetSeedBuilder.

Definition at line 20 of file TauToolHolder.py.

def JetSeedBuilderCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'JetSeedBuilder'
 
    JetSeedBuilder = CompFactory.getComp("JetSeedBuilder")
    JetSeedBuilder = JetSeedBuilder(name = _name)
    
    result.setPrivateTools(JetSeedBuilder)
    return result
 

MvaTESEvaluatorCfg()

MvaTESEvaluatorCfg

(

flags

)

MvaTESEvaluator.

Definition at line 680 of file TauToolHolder.py.

def MvaTESEvaluatorCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'MvaTESEvaluator'
 
    MvaTESEvaluator = CompFactory.getComp("MvaTESEvaluator")
    MvaTESEvaluator = MvaTESEvaluator(name = _name,
                                      WeightFileName = flags.Tau.MvaTESConfig,
                                      WeightFileName0p = flags.Tau.MvaTESConfig0p )
 
    result.setPrivateTools(MvaTESEvaluator)
    return result
 

MvaTESVariableDecoratorCfg()

MvaTESVariableDecoratorCfg

(

flags

)

MvaTESVariableDecorator.

Definition at line 660 of file TauToolHolder.py.

def MvaTESVariableDecoratorCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'MvaTESVariableDecorator'
 
    eventShapeCollection = flags.Tau.ActiveConfig.EventShapeCollection
    if 'EMPFlow' in flags.Tau.ActiveConfig.SeedJetCollection:
        eventShapeCollection = "Kt4EMPFlowEventShape"
    elif 'EMTopo' in flags.Tau.ActiveConfig.SeedJetCollection:
        eventShapeCollection ="Kt4EMTopoOriginEventShape"
 
    MvaTESVariableDecorator = CompFactory.getComp("MvaTESVariableDecorator")
    MvaTESVariableDecorator = MvaTESVariableDecorator(name = _name,
                                                      Key_vertexInputContainer = flags.Tau.ActiveConfig.VertexCollection,
                                                      EventShapeKey = eventShapeCollection,
                                                      VertexCorrection = flags.Tau.doVertexCorrection)
    result.setPrivateTools(MvaTESVariableDecorator)
    return result
 

Pi0ClusterCreatorCfg()

Pi0ClusterCreatorCfg

(

flags

)

create Pi0 clusters

Definition at line 553 of file TauToolHolder.py.

def Pi0ClusterCreatorCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'Pi0ClusterCreator'
 
    # TauPi0ClusterCreator accesses cells via links only, which doesn't
    # make a scheduler dependency.  So make additional explicit dependencies
    # on cells in the input file.
    extraInputs = []
    for typ, nam in [i.split('#') for i in flags.Input.TypedCollections]:
        if typ == 'CaloCellContainer':
            extraInputs += [('CaloCellContainer', nam)]
 
    TauPi0ClusterCreator = CompFactory.getComp("TauPi0ClusterCreator")
    TauPi0ClusterCreator = TauPi0ClusterCreator(name = _name,
                                                ExtraInputs = extraInputs,
                                                RecoFromAOD = flags.Common.ProductionStep is ProductionStep.Derivation)
 
    result.setPrivateTools(TauPi0ClusterCreator)
    return result
 

Pi0ClusterFinderCfg()

Pi0ClusterFinderCfg

(

flags

)

Pi0 algo Cluster finder for Pi0 algo.

Definition at line 268 of file TauToolHolder.py.

def Pi0ClusterFinderCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'Pi0ClusterFinder'
 
    TauPi0CreateROI = CompFactory.getComp("TauPi0CreateROI")
 
    myTauPi0CreateROI = TauPi0CreateROI(
        name                             = _name,
        Key_caloCellInputContainer       = "AllCalo",
        Key_RemovedClusterInputContainer = flags.Tau.ActiveConfig.RemovedElectronClusters,
        inEleRM                          = flags.Tau.ActiveConfig.inTauEleRM,
        RemoveElectronCells              = flags.Tau.ActiveConfig.RemoveElectronCells,
    )
 
    result.setPrivateTools(myTauPi0CreateROI)
    return result
 

Pi0ClusterScalerCfg()

Pi0ClusterScalerCfg

(

flags

)

Set energy of cluster to take care of charged pion energy deposited in the ECAL.

Definition at line 575 of file TauToolHolder.py.

def Pi0ClusterScalerCfg(flags): 
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'Pi0ClusterScaler'
 
    TauPi0ClusterScaler = CompFactory.getComp("TauPi0ClusterScaler")
    TauPi0ClusterScaler = TauPi0ClusterScaler(name = _name,
                                              MinNeutralPFOPt = flags.Tau.MinNeutralPFOPt)
 
    result.setPrivateTools(TauPi0ClusterScaler)
    return result
 

Pi0ScoreCalculatorCfg()

Pi0ScoreCalculatorCfg

(

flags

)

calculate MVA scores of pi0 clusters

Definition at line 588 of file TauToolHolder.py.

def Pi0ScoreCalculatorCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'Pi0ScoreCalculator'
 
    TauPi0ScoreCalculator = CompFactory.getComp("TauPi0ScoreCalculator")
    TauPi0ScoreCalculator = TauPi0ScoreCalculator(name = _name,
                                                  BDTWeightFile = flags.Tau.Pi0ScoreConfig)
 
    result.setPrivateTools(TauPi0ScoreCalculator)
    return result
 

Pi0SelectorCfg()

Pi0SelectorCfg

(

flags

)

select pi0 clusters

Definition at line 601 of file TauToolHolder.py.

def Pi0SelectorCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'Pi0Selector'
 
    TauPi0Selector = CompFactory.getComp("TauPi0Selector")
    TauPi0Selector = TauPi0Selector(name = _name,
                                    Pi0EtCut         = flags.Tau.pi0EtCuts,
                                    Pi0BDTCut_1prong = flags.Tau.pi0MVACuts_1prong,
                                    Pi0BDTCut_mprong = flags.Tau.pi0MVACuts_mprong)
 
    result.setPrivateTools(TauPi0Selector)
    return result
 

TauAODMuonRemovalCfg()

TauAODMuonRemovalCfg

(

flags

)

muon removal tool

Definition at line 948 of file TauToolHolder.py.

def TauAODMuonRemovalCfg(flags):
    result = ComponentAccumulator()   
    _name = flags.Tau.ActiveConfig.prefix + 'MuonRemoval'
    TauAODMuonRemovalTool = CompFactory.getComp("TauAODMuonRemovalTool")
    myMuonRemoval = TauAODMuonRemovalTool(      name                   = _name,
                                                Key_MuonInputContainer = 'Muons',
                                                doMuonTrkRm            = True,
                                                doMuonClsRm            = True,
                                                muonIDWP               = 'Medium'
    )
    result.setPrivateTools(myMuonRemoval)
    return result
 
# electron excluder tool

TauAODSelectorCfg()

TauAODSelectorCfg

(

flags

)

Definition at line 920 of file TauToolHolder.py.

def TauAODSelectorCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'TauAODSelector'
 
    TauAODSelector = CompFactory.getComp("TauAODSelector")
    myTauAODSelector = TauAODSelector(name=_name,
                                      Min0pTauPt = flags.Tau.MinPt0p,
                                      MinTauPt = flags.Tau.MinPt,
                                      doEarlyStopping = flags.Tau.doEarlyStopping and not flags.Output.doWriteESD)
 
    result.setPrivateTools(myTauAODSelector)
    return result
 

TauAxisCfg()

TauAxisCfg

(

flags

)

Tau energy calibration and tau axis direction.

Definition at line 56 of file TauToolHolder.py.

def TauAxisCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'TauAxis'
 
    TauAxisSetter = CompFactory.getComp("TauAxisSetter")
    TauAxisSetter = TauAxisSetter(  name = _name,
                                    ClusterCone = 0.2,
                                    VertexCorrection = flags.Tau.doVertexCorrection )
 
    result.setPrivateTools(TauAxisSetter)
    return result
 

TauCaloClusterBadChannelCfg()

TauCaloClusterBadChannelCfg

(

flags

)

Definition at line 541 of file TauToolHolder.py.

def TauCaloClusterBadChannelCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'CaloClusterBadChannelList'
 
    CaloClusterBadChannelListCorr = CompFactory.getComp("CaloClusterBadChannelList")
    BadChannelListCorrForTaus = CaloClusterBadChannelListCorr(_name)
 
    result.setPrivateTools(BadChannelListCorrForTaus)
    return result
 

TauCaloClusterLocalCalibCfg()

TauCaloClusterLocalCalibCfg

(

flags

)

Definition at line 378 of file TauToolHolder.py.

def TauCaloClusterLocalCalibCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'CaloLocalCalib'
 
    CaloClusterLocalCalib = CompFactory.getComp("CaloClusterLocalCalib")
    LocalCalib =  CaloClusterLocalCalib(_name)
    LocalCalib.ClusterClassificationTool     = [result.popToolsAndMerge(TauCaloLCClassificationCfg(flags))]
    LocalCalib.ClusterRecoStatus             = [1,2]
    LocalCalib.LocalCalibTools               = [result.popToolsAndMerge(TauCaloLCWeightCfg(flags))]
    LocalCalib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
 
    result.setPrivateTools(LocalCalib)
    return result
 

TauCaloClusterMomentsMakerCfg()

TauCaloClusterMomentsMakerCfg

(

flags

)

Definition at line 501 of file TauToolHolder.py.

def TauCaloClusterMomentsMakerCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'Pi0TopoMoments'
 
    # Schedule total noise cond alg
    from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
    result.merge(CaloNoiseCondAlgCfg(flags,"totalNoise"))
    # Schedule electronic noise cond alg (needed for LC weights)
    result.merge(CaloNoiseCondAlgCfg(flags,"electronicNoise"))
 
    CaloClusterMomentsMaker = CompFactory.getComp("CaloClusterMomentsMaker")
    TopoMomentsForTaus = CaloClusterMomentsMaker(_name)
    TopoMomentsForTaus.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
    TopoMomentsForTaus.MaxAxisAngle = 20*deg
    TopoMomentsForTaus.TwoGaussianNoise = flags.Calo.TopoCluster.doTwoGaussianNoise
    TopoMomentsForTaus.MinBadLArQuality = 4000
    TopoMomentsForTaus.MomentsNames = ["FIRST_PHI"
                                       ,"FIRST_ETA"
                                       ,"SECOND_R"
                                       ,"SECOND_LAMBDA"
                                       ,"DELTA_PHI"
                                       ,"DELTA_THETA"
                                       ,"DELTA_ALPHA"
                                       ,"CENTER_X"
                                       ,"CENTER_Y"
                                       ,"CENTER_Z"
                                       ,"CENTER_MAG"
                                       ,"CENTER_LAMBDA"
                                       ,"LATERAL"
                                       ,"LONGITUDINAL"
                                       ,"ENG_FRAC_EM"
                                       ,"ENG_FRAC_MAX"
                                       ,"ENG_FRAC_CORE"
                                       ,"FIRST_ENG_DENS"
                                       ,"SECOND_ENG_DENS"
                                       ,"ISOLATION"]
 
    result.setPrivateTools(TopoMomentsForTaus)
    return result
 

TauCaloDMCalibCfg()

TauCaloDMCalibCfg

(

flags

)

Definition at line 405 of file TauToolHolder.py.

def TauCaloDMCalibCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'DMCalib'
 
    CaloClusterLocalCalib = CompFactory.getComp("CaloClusterLocalCalib")
    DMCalib =  CaloClusterLocalCalib(_name)
    DMCalib.ClusterRecoStatus             = [1,2]
    DMCalib.LocalCalibTools = [result.popToolsAndMerge(TauCaloLCDeadMaterialCfg(flags))]
    DMCalib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
 
    result.setPrivateTools(DMCalib)
    return result
 

TauCaloLCClassificationCfg()

TauCaloLCClassificationCfg

(

flags

)

Calo Tools.

Definition at line 301 of file TauToolHolder.py.

def TauCaloLCClassificationCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'LCClassify'
 
    CaloLCClassificationTool = CompFactory.getComp("CaloLCClassificationTool")
    LCClassify = CaloLCClassificationTool(_name)
    LCClassify.ClassificationKey   = "EMFracClassify"
    LCClassify.UseSpread = False
    LCClassify.MaxProbability = 0.5
    # add the moments EM_PROBABILITY, HAD_WEIGHT, OOC_WEIGHT, DM_WEIGHT to the AOD:
    LCClassify.StoreClassificationProbabilityInAOD = True
    LCClassify.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
    LCClassify.UseNormalizedEnergyDensity = True
 
    result.setPrivateTools(LCClassify)
    return result
 

TauCaloLCDeadMaterialCfg()

TauCaloLCDeadMaterialCfg

(

flags

)

Definition at line 363 of file TauToolHolder.py.

def TauCaloLCDeadMaterialCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'CaloLCDeadMaterialTool'
 
    CaloLCDeadMaterialTool = CompFactory.getComp("CaloLCDeadMaterialTool")
    LCDeadMaterial = CaloLCDeadMaterialTool(_name)
    LCDeadMaterial.HadDMCoeffKey       = "HadDMCoeff2"
    LCDeadMaterial.ClusterRecoStatus   = 0
    LCDeadMaterial.WeightModeDM        = 2
    LCDeadMaterial.UseHadProbability   = True
    LCDeadMaterial.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
 
    result.setPrivateTools(LCDeadMaterial)
    return result
 

TauCaloLCOutOfClusterCfg()

TauCaloLCOutOfClusterCfg

(

flags

)

Definition at line 337 of file TauToolHolder.py.

def TauCaloLCOutOfClusterCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'CaloLCOutOfClusterTool'
 
    CaloLCOutOfClusterTool = CompFactory.getComp("CaloLCOutOfClusterTool")
    LCOut = CaloLCOutOfClusterTool(_name)
    LCOut.CorrectionKey       = "OOCCorrection"
    LCOut.UseEmProbability    = False
    LCOut.UseHadProbability   = True
 
    result.setPrivateTools(LCOut)
    return result
 

TauCaloLCOutPi0Cfg()

TauCaloLCOutPi0Cfg

(

flags

)

Definition at line 350 of file TauToolHolder.py.

def TauCaloLCOutPi0Cfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'LCOutPi0'
 
    CaloLCOutOfClusterTool = CompFactory.getComp("CaloLCOutOfClusterTool")
    LCOutPi0 = CaloLCOutOfClusterTool(_name)
    LCOutPi0.CorrectionKey    = "OOCPi0Correction"
    LCOutPi0.UseEmProbability  = True
    LCOutPi0.UseHadProbability = False
 
    result.setPrivateTools(LCOutPi0)
    return result
 

TauCaloLCWeightCfg()

TauCaloLCWeightCfg

(

flags

)

Definition at line 318 of file TauToolHolder.py.

def TauCaloLCWeightCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'CaloLCWeightTool'
 
    # Schedule total noise cond alg
    from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
    result.merge(CaloNoiseCondAlgCfg(flags,"totalNoise"))
    # Schedule electronic noise cond alg (needed for LC weights)
    result.merge(CaloNoiseCondAlgCfg(flags,"electronicNoise"))
 
    CaloLCWeightTool = CompFactory.getComp("CaloLCWeightTool")
    LCWeight = CaloLCWeightTool(_name)
    LCWeight.CorrectionKey       = "H1ClusterCellWeights"
    LCWeight.SignalOverNoiseCut  = 2.0
    LCWeight.UseHadProbability   = True
 
    result.setPrivateTools(LCWeight)
    return result
 

TauCaloOOCCalibCfg()

TauCaloOOCCalibCfg

(

flags

)

Definition at line 392 of file TauToolHolder.py.

def TauCaloOOCCalibCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'OOCCalibTool'
 
    CaloClusterLocalCalib = CompFactory.getComp("CaloClusterLocalCalib")
    OOCCalib   = CaloClusterLocalCalib (_name)
    OOCCalib.ClusterRecoStatus   = [1,2]
    OOCCalib.LocalCalibTools     = [result.popToolsAndMerge(TauCaloLCOutOfClusterCfg(flags))]
    OOCCalib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
 
    result.setPrivateTools(OOCCalib)
    return result
 

TauCaloOOCPi0CalibCfg()

TauCaloOOCPi0CalibCfg

(

flags

)

Definition at line 418 of file TauToolHolder.py.

def TauCaloOOCPi0CalibCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'OOCPi0CalibTool'
 
    CaloClusterLocalCalib = CompFactory.getComp("CaloClusterLocalCalib")
    OOCPi0Calib   = CaloClusterLocalCalib (_name)
    OOCPi0Calib.ClusterRecoStatus   = [1,2]
    OOCPi0Calib.LocalCalibTools     = [result.popToolsAndMerge(TauCaloLCOutPi0Cfg(flags))]
    OOCPi0Calib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
 
    result.setPrivateTools(OOCPi0Calib)
    return result
 

TauCaloTopoClusterMakerCfg()

TauCaloTopoClusterMakerCfg

(

flags

)

Definition at line 431 of file TauToolHolder.py.

def TauCaloTopoClusterMakerCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'Pi0TopoClusterMaker'
 
    # Schedule total noise cond alg
    from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
    result.merge(CaloNoiseCondAlgCfg(flags,"totalNoise"))
    # Schedule electronic noise cond alg (needed for LC weights)
    result.merge(CaloNoiseCondAlgCfg(flags,"electronicNoise"))
 
    CaloTopoClusterMaker = CompFactory.getComp("CaloTopoClusterMaker")
    TopoClusterForTaus = CaloTopoClusterMaker(_name)
 
    TopoClusterForTaus.CellsName = flags.Tau.ActiveConfig.TauCommonPi0Cells
    TopoClusterForTaus.CalorimeterNames=["LAREM"]
    TopoClusterForTaus.SeedSamplingNames = ["PreSamplerB", "EMB1", "EMB2", "PreSamplerE", "EME1", "EME2"]
    TopoClusterForTaus.NeighborOption                    = "super3D"
    TopoClusterForTaus.RestrictHECIWandFCalNeighbors     = False
    TopoClusterForTaus.RestrictPSNeighbors               = True
    TopoClusterForTaus.CellThresholdOnEorAbsEinSigma     = 0.0
    TopoClusterForTaus.NeighborThresholdOnEorAbsEinSigma = 2.0
    TopoClusterForTaus.SeedThresholdOnEorAbsEinSigma     = 4.0
    TopoClusterForTaus.SeedCutsInAbsE                    = True
    TopoClusterForTaus.ClusterCutsInAbsEt                = True
    TopoClusterForTaus.ClusterEtorAbsEtCut               = 0.5*GeV # 0.0*MeV in standard CaloCalTopoCluster JobOptions!
    TopoClusterForTaus.TwoGaussianNoise                  = flags.Calo.TopoCluster.doTwoGaussianNoise
    # timing cut on seed cell to suppress out-of-time pileup
    TopoClusterForTaus.SeedCutsInT = flags.Calo.TopoCluster.doTimeCut
    TopoClusterForTaus.CutOOTseed = flags.Calo.TopoCluster.extendTimeCut and flags.Calo.TopoCluster.doTimeCut
    TopoClusterForTaus.UseTimeCutUpperLimit = flags.Calo.TopoCluster.useUpperLimitForTimeCut
    TopoClusterForTaus.TimeCutUpperLimit = flags.Calo.TopoCluster.timeCutUpperLimit
    TopoClusterForTaus.XTalkEM2 = flags.Calo.TopoCluster.xtalkEM2
    TopoClusterForTaus.XTalkEM2D = flags.Calo.TopoCluster.xtalkEM2D
    TopoClusterForTaus.XTalkEM2n = flags.Calo.TopoCluster.xtalkEM2n
    TopoClusterForTaus.XTalkEM3 = flags.Calo.TopoCluster.xtalkEM3
    TopoClusterForTaus.XTalkEMEta = flags.Calo.TopoCluster.xtalkEMEta
    TopoClusterForTaus.XTalkDeltaT = flags.Calo.TopoCluster.xtalkDeltaT
    TopoClusterForTaus.XTalk2Eratio1 = flags.Calo.TopoCluster.xtalk2Eratio1
    TopoClusterForTaus.XTalk2Eratio2 = flags.Calo.TopoCluster.xtalk2Eratio2
    TopoClusterForTaus.XTalk3Eratio = flags.Calo.TopoCluster.xtalk3Eratio
    TopoClusterForTaus.XTalkEtaEratio = flags.Calo.TopoCluster.xtalkEtaEratio
    TopoClusterForTaus.XTalk2DEratio = flags.Calo.TopoCluster.xtalk2DEratio
 
    result.setPrivateTools(TopoClusterForTaus)
    return result
 

TauCaloTopoClusterSplitterCfg()

TauCaloTopoClusterSplitterCfg

(

flags

)

Definition at line 477 of file TauToolHolder.py.

def TauCaloTopoClusterSplitterCfg(flags):
 
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'Pi0TopoClusterSplitter'
 
    CaloTopoClusterSplitter = CompFactory.getComp("CaloTopoClusterSplitter")
    TopoSplitterForTaus = CaloTopoClusterSplitter(_name)
 
    # cells from the following samplings will be able to form local
    # maxima. The excluded samplings are PreSamplerB, EMB1,
    # PreSamplerE, EME1, all Tile samplings, all HEC samplings and the
    # two rear FCal samplings.
    TopoSplitterForTaus.SamplingNames = ["EMB2","EME2"] # Do we want to use EMB3 and EME3?
    # cells from the following samplings will also be able to form
    # local maxima but only if they are not overlapping in eta and phi
    # with local maxima in previous samplings from the primary list.
    TopoSplitterForTaus.SecondarySamplingNames = ["EMB1","EME1"]
    TopoSplitterForTaus.ShareBorderCells = True
    TopoSplitterForTaus.RestrictHECIWandFCalNeighbors  = False
    TopoSplitterForTaus.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
 
    result.setPrivateTools(TopoSplitterForTaus)
    return result
 

TauCellFinalizerCfg()

TauCellFinalizerCfg

(

flags

)

Cell finalizer tool for BuildAlg.

Definition at line 287 of file TauToolHolder.py.

def TauCellFinalizerCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'tauPi0CellContainerFinalizer'
 
    CaloCellContainerFinalizerTool = CompFactory.getComp("CaloCellContainerFinalizerTool")
    TauCellContainerFinalizer = CaloCellContainerFinalizerTool(name=_name)
 
    result.setPrivateTools(TauCellContainerFinalizer)
    return result
 

TauClusterFinderCfg()

TauClusterFinderCfg

(

flags

)

Associate the cluster in jet constituents to the tau candidate.

Definition at line 122 of file TauToolHolder.py.

def TauClusterFinderCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'TauClusterFinder'
 
 
    TauClusterFinder = CompFactory.getComp("TauClusterFinder")
    TauClusterFinder = TauClusterFinder(
        name = _name, 
        inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
    )
 
 
    result.setPrivateTools(TauClusterFinder)
    return result
 

TauCombinedTESCfg()

TauCombinedTESCfg	(		flags,
		**	kwargs )

TauCombinedTES.

Definition at line 935 of file TauToolHolder.py.

def TauCombinedTESCfg(flags, **kwargs):
    result = ComponentAccumulator()  
    _name = flags.Tau.ActiveConfig.prefix + 'TauCombinedTES'
    kwargs.setdefault("WeightFileName", flags.Tau.CombinedTESConfig)
 
    TauCombinedTES = CompFactory.getComp("TauCombinedTES")
    myTauCombinedTES = TauCombinedTES(name = _name, **kwargs)
 
    result.setPrivateTools(myTauCombinedTES)
    return result
 

TauCommonCalcVarsCfg()

TauCommonCalcVarsCfg

(

flags

)

Tau Variables.

Definition at line 634 of file TauToolHolder.py.

def TauCommonCalcVarsCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'TauCommonCalcVars'
 
    TauCommonCalcVars = CompFactory.getComp("TauCommonCalcVars")
    TauCommonCalcVars = TauCommonCalcVars(name = _name,
                                          doRun4 = flags.GeoModel.Run > LHCPeriod.Run3)
    
    result.setPrivateTools(TauCommonCalcVars)
    return result
 

TauDecayModeNNClassifierCfg()

TauDecayModeNNClassifierCfg

(

flags

)

Definition at line 909 of file TauToolHolder.py.

def TauDecayModeNNClassifierCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'TauDecayModeNNClassifier'
 
    TauDecayModeNNClassifier = CompFactory.getComp("TauDecayModeNNClassifier")
    myTauDecayModeNNClassifier = TauDecayModeNNClassifier(name=_name,
                                                          WeightFile=flags.Tau.DecayModeNNClassifierConfig)
 
    result.setPrivateTools(myTauDecayModeNNClassifier)
    return result
 

TauEleOverlapChecker()

TauEleOverlapChecker

(

flags

)

Definition at line 962 of file TauToolHolder.py.

def TauEleOverlapChecker(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'TauEleOverlapChecker'
    TauEleOverlapChecker = CompFactory.getComp("TauEleOverlapChecker")
    myTauEleOverlapChecker = TauEleOverlapChecker(
        name                         = _name,
        Key_RemovedClustersContainer = flags.Tau.ActiveConfig.RemovedElectronClusters,
        Key_RemovedTracksContainer   = flags.Tau.ActiveConfig.RemovedElectronTracks,
        CheckingCone                 = flags.Tau.ActiveConfig.EleRM_CheckingConeSize,
    )
    result.setPrivateTools(myTauEleOverlapChecker)
    return result

TauEleRNNEvaluatorCfg()

TauEleRNNEvaluatorCfg	(		flags,
			applyLooseTrackSel = False )

Definition at line 831 of file TauToolHolder.py.

def TauEleRNNEvaluatorCfg(flags, applyLooseTrackSel=False):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'TauEleRNN'
 
    TauJetRNNEvaluator = CompFactory.getComp("TauJetRNNEvaluator")
    RNNConf = flags.Tau.TauEleRNNConfig    
    myTauEleRNNEvaluator = TauJetRNNEvaluator(name = _name,
                                              useTRT = flags.Detector.EnableTRT,
                                              NetworkFile1P = RNNConf[0],
                                              NetworkFile3P = RNNConf[1],
                                              OutputVarname = "RNNEleScore",
                                              MaxTracks = 10,
                                              MaxClusters = 6,
                                              MaxClusterDR = 1.0,
                                              ApplyLooseTrackSel = applyLooseTrackSel,
                                              VertexCorrection = flags.Tau.doVertexCorrection,
                                              InputLayerScalar = "scalar",
                                              InputLayerTracks = "tracks",
                                              InputLayerClusters = "clusters",
                                              OutputLayer = "rnneveto_output",
                                              OutputNode = "sig_prob")
 
    result.setPrivateTools(myTauEleRNNEvaluator)
    return result
 

TauGNNDisplacedEvaluatorCfg()

TauGNNDisplacedEvaluatorCfg	(		flags,
			tauContainerName = "" )

Definition at line 811 of file TauToolHolder.py.

def TauGNNDisplacedEvaluatorCfg(flags, tauContainerName=""):
    # Displaced TauGNNEvaluator tool setup
    result = ComponentAccumulator()
 
    TauGNNEvaluator = CompFactory.TauGNNEvaluator(
        name = flags.Tau.ActiveConfig.prefix + 'TauDisplacedGNN',
        NetworkFileInclusive = flags.Tau.TauDisplacedGNNConfig[0],
        OutputVarname = "GNdTauScore",
        OutputPTau = "GNdTauProbTau",
        OutputPJet = "GNdTauProbJet",
        MaxClusterDR = 15.0,
        MinTauPt = flags.Tau.MinPtDAOD,
        VertexCorrection = flags.Tau.doVertexCorrection,
        NodeNameTau="GNdTauv3_pb",
        NodeNameJet="GNdTauv3_pu",
        TauContainerName = tauContainerName,
    )
    result.setPrivateTools(TauGNNEvaluator)
    return result
 

TauGNNEvaluatorCfg()

TauGNNEvaluatorCfg	(		flags,
			version = 0,
			applyLooseTrackSel = False,
			applyTightTrackSel = False,
			tauContainerName = "" )

Definition at line 760 of file TauToolHolder.py.

def TauGNNEvaluatorCfg(flags, version=0, applyLooseTrackSel=False, applyTightTrackSel=False, tauContainerName=""):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'TauGNN_v' + str(version)
 
    TauGNNEvaluator = CompFactory.getComp("TauGNNEvaluator")
    GNNConf = flags.Tau.TauGNNConfig[version]
    myTauGNNEvaluator = TauGNNEvaluator(name = _name,
                                              useTRT = flags.Detector.EnableTRT,
                                              NetworkFileInclusive = GNNConf,
                                              OutputVarname = flags.Tau.GNTauScoreName[version],
                                              OutputPTau = "GNTauProbTau",
                                              OutputPJet = "GNTauProbJet",
                                              MaxTracks = flags.Tau.GNTauMaxTracks[version], 
                                              MaxClusters = flags.Tau.GNTauMaxClusters[version],
                                              MaxClusterDR = 15.0,
                                              MinTauPt = flags.Tau.MinPtDAOD,
                                              ApplyLooseTrackSel = applyLooseTrackSel,
                                              ApplyTightTrackSel = applyTightTrackSel,
                                              VertexCorrection = flags.Tau.doVertexCorrection,
                                              InputLayerScalar = 'tau_vars',
                                              InputLayerTracks = 'track_vars',
                                              InputLayerClusters = 'cluster_vars',
                                              NodeNameTau=flags.Tau.GNTauNodeNameTau,
                                              NodeNameJet=flags.Tau.GNTauNodeNameJet,
                                              TauContainerName = tauContainerName,
                                        )
 
    result.setPrivateTools(myTauGNNEvaluator)
    return result
 

TauIDVarCalculatorCfg()

TauIDVarCalculatorCfg

(

flags

)

Definition at line 692 of file TauToolHolder.py.

def TauIDVarCalculatorCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'TauIDVarCalculator'
 
    TauIDVarCalculator = CompFactory.getComp("TauIDVarCalculator")    
    myTauIDVarCalculator = TauIDVarCalculator(name=_name,
                                              VertexCorrection = flags.Tau.doVertexCorrection,
                                              doRun4 = flags.GeoModel.Run > LHCPeriod.Run3)
 
    result.setPrivateTools(myTauIDVarCalculator)
    return result
 

TauJetRNNEvaluatorCfg()

TauJetRNNEvaluatorCfg	(		flags,
			applyLooseTrackSel = False )

Definition at line 704 of file TauToolHolder.py.

def TauJetRNNEvaluatorCfg(flags, applyLooseTrackSel=False):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'TauJetRNN'
 
    TauJetRNNEvaluator = CompFactory.getComp("TauJetRNNEvaluator")
    RNNConf = flags.Tau.TauJetRNNConfig
    myTauJetRNNEvaluator = TauJetRNNEvaluator(name = _name,
                                              NetworkFile0P = "",
                                              NetworkFile1P = RNNConf[0],
                                              NetworkFile2P = RNNConf[1],
                                              NetworkFile3P = RNNConf[2],
                                              OutputVarname = "RNNJetScore",
                                              MaxTracks = 10,
                                              MaxClusters = 6,
                                              MaxClusterDR = 1.0,
                                              ApplyLooseTrackSel = applyLooseTrackSel,
                                              VertexCorrection = flags.Tau.doVertexCorrection,
                                              InputLayerScalar = "scalar",
                                              InputLayerTracks = "tracks",
                                              InputLayerClusters = "clusters",
                                              OutputLayer = "rnnid_output",
                                              OutputNode = "sig_prob")
 
    result.setPrivateTools(myTauJetRNNEvaluator)
    return result
 

TauShotFinderCfg()

TauShotFinderCfg

(

flags

)

Photon Shot Finder.

Definition at line 238 of file TauToolHolder.py.

def TauShotFinderCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'TauShotFinder'
 
    shotPtCut_1Photon = flags.Tau.shotPtCut_1Photon
    shotPtCut_2Photons = flags.Tau.shotPtCut_2Photons
 
    
    from CaloClusterCorrection.StandardCellWeightCalib import getCellWeightTool
    CaloWeightTool = getCellWeightTool(flags=flags)
 
 
    TauShotFinder = CompFactory.getComp("TauShotFinder")
    TauShotFinder = TauShotFinder(
        name                                = _name,
        CaloWeightTool                      = result.popToolsAndMerge(CaloWeightTool),
        NCellsInEta                         = 5,
        MinPtCut                            = shotPtCut_1Photon,
        AutoDoubleShotCut                   = shotPtCut_2Photons,
        Key_RemovedClusterInputContainer    = flags.Tau.ActiveConfig.RemovedElectronClusters,
        RemoveElectronCells                 = flags.Tau.ActiveConfig.RemoveElectronCells,
        inEleRM                             = flags.Tau.ActiveConfig.inTauEleRM,
    )
 
    result.setPrivateTools(TauShotFinder)
    return result
 

TauSubstructureCfg()

TauSubstructureCfg

(

flags

)

Tau Variables.

Definition at line 647 of file TauToolHolder.py.

def TauSubstructureCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'TauSubstructure'
 
    TauSubstructureVariables = CompFactory.getComp("TauSubstructureVariables")
    TauSubstructureVariables = TauSubstructureVariables(  name = _name,
                                                          doRun4 = flags.GeoModel.Run > LHCPeriod.Run3) 
 
    result.setPrivateTools(TauSubstructureVariables)
    return result
 

TauTrackFinderCfg()

TauTrackFinderCfg

(

flags

)

Tau-Track Association.

Definition at line 81 of file TauToolHolder.py.

def TauTrackFinderCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'TauTrackFinder'
 
    # BeamSpot Conditions
    from BeamSpotConditions.BeamSpotConditionsConfig import BeamSpotCondAlgCfg
    result.merge(BeamSpotCondAlgCfg(flags))
 
    from TrackToVertex.TrackToVertexConfig import TrackToVertexCfg
    from TrackToCalo.TrackToCaloConfig import ParticleCaloExtensionToolCfg
    from TrkConfig.TrkVertexFitterUtilsConfig import AtlasTrackToVertexIPEstimatorCfg
    from InDetConfig.InDetTrackSelectorToolConfig import TauRecInDetTrackSelectorToolCfg
 
    _LargeD0TrackInputContainer = (flags.Tau.ActiveConfig.LargeD0TrackCollection if flags.Tau.associateLRT else "")
 
    # Manually setting for TauLRT reco
    if flags.Tau.ActiveConfig.inTauLRT:
        _LargeD0TrackInputContainer = flags.Tau.ActiveConfig.LargeD0TrackCollection
 
    TauTrackFinder = CompFactory.getComp("TauTrackFinder")
    TauTrackFinder = TauTrackFinder(name = _name,
                                    MaxJetDrTau = 0.2,
                                    MaxJetDrWide = 0.4,
                                    TrackSelectorToolTau      = result.popToolsAndMerge(TauRecInDetTrackSelectorToolCfg(flags)),
                                    TrackToVertexTool         = result.popToolsAndMerge(TrackToVertexCfg(flags)),
                                    ParticleCaloExtensionTool = result.popToolsAndMerge(ParticleCaloExtensionToolCfg(flags)),
                                    tauParticleCache = getParticleCache(flags), # only returns a string
                                    removeDuplicateCoreTracks = flags.Tau.RemoveDupeCoreTracks,
                                    useGhostTracks = flags.Tau.useGhostTracks,
                                    ghostTrackDR = flags.Tau.ghostTrackDR,
                                    Key_jetContainer = (flags.Tau.ActiveConfig.SeedJetCollection if flags.Tau.useGhostTracks else ""),
                                    Key_trackPartInputContainer = flags.Tau.ActiveConfig.TrackCollection,
                                    Key_LargeD0TrackInputContainer = _LargeD0TrackInputContainer,
                                    TrackToVertexIPEstimator = result.popToolsAndMerge(AtlasTrackToVertexIPEstimatorCfg(flags)),
                                    inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
    )
    result.setPrivateTools(TauTrackFinder)
    return result
 

TauTrackRNNCfg()

TauTrackRNNCfg

(

flags

)

Definition at line 150 of file TauToolHolder.py.

def TauTrackRNNCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'TauTrackRNNClassifier'
 
    TrackRNN = CompFactory.tauRecTools.TrackRNN
    _RNN = TrackRNN(name = _name + "_TrackRNN",
                    InputWeightsPath = flags.Tau.tauRNNTrackClassConfig,
                    calibFolder = flags.Tau.tauRecToolsCVMFSPath )
 
    result.setPrivateTools(_RNN)
    return result
 

TauTrackRNNClassifierCfg()

TauTrackRNNClassifierCfg

(

flags

)

Definition at line 163 of file TauToolHolder.py.

def TauTrackRNNClassifierCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'TauTrackRNNClassifier'
 
    # create tool alg
    TauTrackRNNClassifier = CompFactory.tauRecTools.TauTrackRNNClassifier
 
    import cppyy
    cppyy.load_library('libxAODTau_cDict')
 
    _classifyLRT = True
    _classifyLRTWithDedicated = flags.Tau.classifyLRTWithDedicated
    if flags.Tau.associateLRT and not flags.Tau.classifyLRT:
        _classifyLRT = False
 
    # Manually setting for TauLRT reco
    if flags.Tau.ActiveConfig.inTauLRT:
        _classifyLRT = True
        _classifyLRTWithDedicated = True
 
 
    myTauTrackClassifier = TauTrackRNNClassifier( name = _name,
                                                  Classifiers = [ result.popToolsAndMerge(TauTrackRNNCfg(flags)) ],
                                                  classifyLRT = _classifyLRT,
                                                  classifyLRTWithDedicated = _classifyLRTWithDedicated)
 
    result.setPrivateTools(myTauTrackClassifier)
    return result
 

TauVertexedClusterDecoratorCfg()

TauVertexedClusterDecoratorCfg

(

flags

)

Definition at line 138 of file TauToolHolder.py.

def TauVertexedClusterDecoratorCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'TauVertexedClusterDecorator'
 
    TauVertexedClusterDecorator = CompFactory.getComp("TauVertexedClusterDecorator")
    myTauVertexedClusterDecorator = TauVertexedClusterDecorator(name = _name,
                                                                SeedJet = flags.Tau.ActiveConfig.SeedJetCollection)
 
    result.setPrivateTools(myTauVertexedClusterDecorator)
    return result
 

TauVertexFinderCfg()

TauVertexFinderCfg

(

flags

)

Definition at line 31 of file TauToolHolder.py.

def TauVertexFinderCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'TauVertexFinder'
 
    from InDetTrackSelectionTool.InDetTrackSelectionToolConfig import (
        Tau_InDetTrackSelectionToolForTJVACfg)
    from TrackVertexAssociationTool.TrackVertexAssociationToolConfig import TauTTVAToolCfg
 
    # Algorithm that overwrites numTrack() and charge() of tauJets in container
    # from tauRecTools.tauRecToolsConf import TauVertexFinder
    TauVertexFinder = CompFactory.getComp("TauVertexFinder")
    TauVertexFinder = TauVertexFinder(name = _name,
                                      UseTJVA                 = flags.Tau.doTJVA,
                                      AssociatedTracks="GhostTrack", # OK??
                                      InDetTrackSelectionToolForTJVA = result.popToolsAndMerge(Tau_InDetTrackSelectionToolForTJVACfg(flags)),
                                      Key_vertexInputContainer = flags.Tau.ActiveConfig.VertexCollection,
                                      TVATool = result.popToolsAndMerge(TauTTVAToolCfg(flags)),
                                      inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
                                      )
 
    result.setPrivateTools(TauVertexFinder)
    return result
 

TauVertexVariablesCfg()

TauVertexVariablesCfg

(

flags

)

Tau Vertex Variables.

Definition at line 616 of file TauToolHolder.py.

def TauVertexVariablesCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'TauVertexVariables'
 
    from TrkConfig.TrkVertexFittersConfig import TauAdaptiveVertexFitterCfg
    from TrkConfig.TrkVertexSeedFinderToolsConfig import (
        CrossDistancesSeedFinderCfg)
 
    TauVertexVariables = CompFactory.getComp("TauVertexVariables")
    TauVertexVariables = TauVertexVariables(  name = _name,
                                              VertexFitter = result.popToolsAndMerge(TauAdaptiveVertexFitterCfg(flags)),
                                              SeedFinder = result.popToolsAndMerge(CrossDistancesSeedFinderCfg(flags)) )
 
    result.setPrivateTools(TauVertexVariables)
    return result
 

TauWPDecoratorEleRNNCfg()

TauWPDecoratorEleRNNCfg

(

flags

)

Definition at line 856 of file TauToolHolder.py.

def TauWPDecoratorEleRNNCfg(flags):
 
    result = ComponentAccumulator()
 
    WPConf = flags.Tau.TauEleRNNWPConfig
 
    from AthenaConfiguration.Enums import ProductionStep
    # set the instance to run at derivation level
    if flags.Common.ProductionStep is ProductionStep.Derivation:
        _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorEleRNNFix_v1'
        NewScoreName = "RNNEleScoreSigTrans_v1"
        CutEnumVals = []
        SigEff1P = []
        SigEff3P = []
        DecorWPNames = [ "EleRNNLoose_v1", "EleRNNMedium_v1", "EleRNNTight_v1" ]
        DecorWPCutEffs1P = [0.95, 0.90, 0.85]
        DecorWPCutEffs3P = [0.98, 0.95, 0.90]
    else:
        #this is the instance running in reconstruction level
        import PyUtils.RootUtils as ru
        ROOT = ru.import_root()
        import cppyy
        cppyy.load_library('libxAODTau_cDict')
 
        _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorEleRNN'
        NewScoreName = "RNNEleScoreSigTrans"
        SigEff1P = [0.95, 0.90, 0.85]
        SigEff3P = [0.98, 0.95, 0.90]
        CutEnumVals = [ ROOT.xAOD.TauJetParameters.IsTauFlag.EleRNNLoose,
                        ROOT.xAOD.TauJetParameters.IsTauFlag.EleRNNMedium,
                        ROOT.xAOD.TauJetParameters.IsTauFlag.EleRNNTight ]
        DecorWPNames = []
        DecorWPCutEffs1P = []
        DecorWPCutEffs3P = []
 
    TauWPDecorator = CompFactory.getComp("TauWPDecorator")
    myTauEleWPDecorator = TauWPDecorator( name=_name,
                                       flatteningFile1Prong = WPConf[0],
                                       flatteningFile3Prong = WPConf[1],
                                       CutEnumVals = CutEnumVals,
                                       DecorWPNames = DecorWPNames,
                                       SigEff1P = SigEff1P,
                                       SigEff3P = SigEff3P,
                                       DecorWPCutEffs1P = DecorWPCutEffs1P,
                                       DecorWPCutEffs3P = DecorWPCutEffs3P,
                                       UseAbsEta = True ,
                                       ScoreName = "RNNEleScore",
                                       NewScoreName = NewScoreName,
                                       DefineWPs = True)
 
    result.setPrivateTools(myTauEleWPDecorator)
    return result
 

TauWPDecoratorGNNCfg()

TauWPDecoratorGNNCfg	(		flags,
			version,
			tauContainerName = "" )

Definition at line 790 of file TauToolHolder.py.

def TauWPDecoratorGNNCfg(flags, version, tauContainerName=""):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorGNN_v' + str(version)
 
    TauWPDecorator = CompFactory.getComp("TauWPDecorator")
    WPConf = flags.Tau.TauGNNWP[version]
    myTauWPDecorator = TauWPDecorator(name=_name,
                                      flatteningFile1Prong = WPConf[0],
                                      flatteningFile2Prong = WPConf[1],
                                      flatteningFile3Prong = WPConf[2],
                                      TauContainerName = tauContainerName,
                                      DecorWPNames = flags.Tau.GNTauDecorWPNames[version],
                                      DecorWPCutEffs1P = [0.95, 0.85, 0.75, 0.60],
                                      DecorWPCutEffs2P = [0.95, 0.75, 0.60, 0.45],
                                      DecorWPCutEffs3P = [0.95, 0.75, 0.60, 0.45],
                                      ScoreName = flags.Tau.GNTauScoreName[version],
                                      NewScoreName = flags.Tau.GNTauTransScoreName[version],
                                      DefineWPs = True)
    result.setPrivateTools(myTauWPDecorator)
    return result
 

TauWPDecoratorJetRNNCfg()

TauWPDecoratorJetRNNCfg

(

flags

)

Definition at line 730 of file TauToolHolder.py.

def TauWPDecoratorJetRNNCfg(flags):
    import PyUtils.RootUtils as ru
    ROOT = ru.import_root()
    import cppyy
    cppyy.load_library('libxAODTau_cDict')
 
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorJetRNN'
 
    TauWPDecorator = CompFactory.getComp("TauWPDecorator")
    WPConf = flags.Tau.TauJetRNNWPConfig
    myTauWPDecorator = TauWPDecorator( name=_name,
                                       flatteningFile1Prong = WPConf[0],
                                       flatteningFile2Prong = WPConf[1],
                                       flatteningFile3Prong = WPConf[2],
                                       CutEnumVals =
                                       [ ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigVeryLoose,
                                         ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigLoose,
                                         ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigMedium,
                                         ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigTight ],
                                       SigEff1P = [0.95, 0.85, 0.75, 0.60],
                                       SigEff2P = [0.95, 0.75, 0.60, 0.45],
                                       SigEff3P = [0.95, 0.75, 0.60, 0.45],
                                       ScoreName = "RNNJetScore",
                                       NewScoreName = "RNNJetScoreSigTrans",
                                       DefineWPs = True )
 
    result.setPrivateTools(myTauWPDecorator)
    return result