TauToolHolder.py

Go to the documentation of this file.

# Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
 

 
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from AthenaConfiguration.ComponentFactory import CompFactory
from AthenaConfiguration.AccumulatorCache import AccumulatorCache
from AthenaConfiguration.Enums import ProductionStep, LHCPeriod
from AthenaCommon.SystemOfUnits import GeV, deg
 

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

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
 

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
 

 
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
 

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
 

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
 

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
 

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
 

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
 

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
 

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
 

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
 

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
 

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
 

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

 
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
 
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
 
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
 
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
 
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
 
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
 
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
 
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
 
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
 
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
 
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
 
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
 
def TauCaloClusterBadChannelCfg(flags):
    result = ComponentAccumulator()
    _name = flags.Tau.ActiveConfig.prefix + 'CaloClusterBadChannelList'
 
    CaloClusterBadChannelListCorr = CompFactory.getComp("CaloClusterBadChannelList")
    BadChannelListCorrForTaus = CaloClusterBadChannelListCorr(_name)
 
    result.setPrivateTools(BadChannelListCorrForTaus)
    return result
 

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
 

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
 

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
 

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
 

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
 

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
 

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
 

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
 

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

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
 

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