|
ATLAS Offline Software
|
◆ CellVariablesCfg()
def TauToolHolder.CellVariablesCfg |
( |
|
flags | ) |
|
Tau cell variables calculation.
Definition at line 198 of file TauToolHolder.py.
200 _name = flags.Tau.ActiveConfig.prefix +
'CellVariables'
202 TauCellVariables = CompFactory.getComp(
"TauCellVariables")
204 VertexCorrection =
True)
206 result.setPrivateTools(TauCellVariables)
◆ CellWeightToolCfg()
def TauToolHolder.CellWeightToolCfg |
( |
|
flags | ) |
|
cell weight tool
Definition at line 228 of file TauToolHolder.py.
232 H1WeightToolCSC12Generic = CompFactory.H1WeightToolCSC12Generic
233 isMC = flags.Input.isMC
238 onlyCellWeight =
False
239 from CaloClusterCorrection.StandardCellWeightCalib
import H1Calibration, editParm
240 (key,folder,tag) = H1Calibration.getCalibDBParams(flags, finder, mainparam, inputn, onlyCellWeight, isMC)
242 from IOVDbSvc.IOVDbSvcConfig
import addFolders
247 if (folder,tag)
not in H1Calibration.loaded_folder:
248 if H1Calibration.overrideFolder():
249 result.merge(
addFolders(flags, folder+
'<tag>'+tag+
'</tag>', detDb=dbString, className=
'CaloRec::ToolConstants') )
251 result.merge(
addFolders(flags, folder, detDb=dbString, className=
'CaloRec::ToolConstants') )
253 H1Calibration.loaded_folder.append( (folder,tag) )
256 toolName = finder +
editParm(mainparam) + inputn
258 cellcalibtool.DBHandleKey = key
259 result.setPrivateTools(cellcalibtool)
◆ ElectronVetoVarsCfg()
def TauToolHolder.ElectronVetoVarsCfg |
( |
|
flags | ) |
|
ele veto variables
Definition at line 211 of file TauToolHolder.py.
213 _name = flags.Tau.ActiveConfig.prefix +
'TauElectronVetoVars'
215 from TrackToCalo.TrackToCaloConfig
import ParticleCaloExtensionToolCfg
217 TauElectronVetoVariables = CompFactory.getComp(
"TauElectronVetoVariables")
219 VertexCorrection =
True,
223 result.setPrivateTools(TauElectronVetoVariables)
◆ EnergyCalibrationLCCfg()
def TauToolHolder.EnergyCalibrationLCCfg |
( |
|
flags | ) |
|
Tau energy calibration.
Definition at line 184 of file TauToolHolder.py.
186 _name = flags.Tau.ActiveConfig.prefix +
'EnergyCalibrationLC'
188 TauCalibrateLC = CompFactory.getComp(
"TauCalibrateLC")
190 calibrationFile = flags.Tau.CalibrateLCConfig,
191 Key_vertexInputContainer = flags.Tau.ActiveConfig.VertexCollection)
193 result.setPrivateTools(TauCalibrateLC)
◆ getParticleCache()
def TauToolHolder.getParticleCache |
( |
|
flags | ) |
|
Definition at line 72 of file TauToolHolder.py.
74 if flags.Common.ProductionStep
is ProductionStep.Reconstruction:
75 ParticleCache =
"ParticleCaloExtension"
◆ JetSeedBuilderCfg()
def TauToolHolder.JetSeedBuilderCfg |
( |
|
flags | ) |
|
JetSeedBuilder.
Definition at line 21 of file TauToolHolder.py.
23 _name = flags.Tau.ActiveConfig.prefix +
'JetSeedBuilder'
25 JetSeedBuilder = CompFactory.getComp(
"JetSeedBuilder")
28 result.setPrivateTools(JetSeedBuilder)
◆ MvaTESEvaluatorCfg()
def TauToolHolder.MvaTESEvaluatorCfg |
( |
|
flags | ) |
|
MvaTESEvaluator.
Definition at line 704 of file TauToolHolder.py.
706 _name = flags.Tau.ActiveConfig.prefix +
'MvaTESEvaluator'
708 MvaTESEvaluator = CompFactory.getComp(
"MvaTESEvaluator")
710 WeightFileName = flags.Tau.MvaTESConfig,
711 WeightFileName0p = flags.Tau.MvaTESConfig0p )
713 result.setPrivateTools(MvaTESEvaluator)
◆ MvaTESVariableDecoratorCfg()
def TauToolHolder.MvaTESVariableDecoratorCfg |
( |
|
flags | ) |
|
MvaTESVariableDecorator.
Definition at line 690 of file TauToolHolder.py.
692 _name = flags.Tau.ActiveConfig.prefix +
'MvaTESVariableDecorator'
694 MvaTESVariableDecorator = CompFactory.getComp(
"MvaTESVariableDecorator")
696 Key_vertexInputContainer = flags.Tau.ActiveConfig.VertexCollection,
697 EventShapeKey = flags.Tau.ActiveConfig.EventShapeCollection,
698 VertexCorrection =
True)
699 result.setPrivateTools(MvaTESVariableDecorator)
◆ Pi0ClusterCreatorCfg()
def TauToolHolder.Pi0ClusterCreatorCfg |
( |
|
flags | ) |
|
create Pi0 clusters
Definition at line 596 of file TauToolHolder.py.
598 _name = flags.Tau.ActiveConfig.prefix +
'Pi0ClusterCreator'
600 TauPi0ClusterCreator = CompFactory.getComp(
"TauPi0ClusterCreator")
603 result.setPrivateTools(TauPi0ClusterCreator)
◆ Pi0ClusterFinderCfg()
def TauToolHolder.Pi0ClusterFinderCfg |
( |
|
flags | ) |
|
Pi0 algo Cluster finder for Pi0 algo.
Definition at line 295 of file TauToolHolder.py.
297 _name = flags.Tau.ActiveConfig.prefix +
'Pi0ClusterFinder'
299 TauPi0CreateROI = CompFactory.getComp(
"TauPi0CreateROI")
303 Key_caloCellInputContainer =
"AllCalo",
304 Key_RemovedClusterInputContainer = flags.Tau.ActiveConfig.RemovedElectronClusters,
305 inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
306 RemoveElectronCells = flags.Tau.ActiveConfig.RemoveElectronCells,
309 result.setPrivateTools(myTauPi0CreateROI)
◆ Pi0ClusterScalerCfg()
def TauToolHolder.Pi0ClusterScalerCfg |
( |
|
flags | ) |
|
Set energy of cluster to take care of charged pion energy deposited in the ECAL.
Definition at line 608 of file TauToolHolder.py.
610 _name = flags.Tau.ActiveConfig.prefix +
'Pi0ClusterScaler'
612 TauPi0ClusterScaler = CompFactory.getComp(
"TauPi0ClusterScaler")
615 result.setPrivateTools(TauPi0ClusterScaler)
◆ Pi0ScoreCalculatorCfg()
def TauToolHolder.Pi0ScoreCalculatorCfg |
( |
|
flags | ) |
|
calculate MVA scores of pi0 clusters
Definition at line 620 of file TauToolHolder.py.
622 _name = flags.Tau.ActiveConfig.prefix +
'Pi0ScoreCalculator'
624 TauPi0ScoreCalculator = CompFactory.getComp(
"TauPi0ScoreCalculator")
626 BDTWeightFile = flags.Tau.Pi0ScoreConfig)
628 result.setPrivateTools(TauPi0ScoreCalculator)
◆ Pi0SelectorCfg()
def TauToolHolder.Pi0SelectorCfg |
( |
|
flags | ) |
|
select pi0 clusters
Definition at line 633 of file TauToolHolder.py.
635 _name = flags.Tau.ActiveConfig.prefix +
'Pi0Selector'
637 TauPi0Selector = CompFactory.getComp(
"TauPi0Selector")
639 ClusterEtCut = flags.Tau.pi0EtCuts,
640 ClusterBDTCut_1prong = flags.Tau.pi0MVACuts_1prong,
641 ClusterBDTCut_mprong = flags.Tau.pi0MVACuts_mprong)
643 result.setPrivateTools(TauPi0Selector)
◆ TauAODMuonRemovalCfg()
def TauToolHolder.TauAODMuonRemovalCfg |
( |
|
flags | ) |
|
muon removal tool
Definition at line 938 of file TauToolHolder.py.
940 _name = flags.Tau.ActiveConfig.prefix +
'MuonRemoval'
941 TauAODLeptonRemovalTool = CompFactory.getComp(
"TauAODLeptonRemovalTool")
943 Key_MuonInputContainer =
'Muons',
948 result.setPrivateTools(myMuonRemoval)
◆ TauAODSelectorCfg()
def TauToolHolder.TauAODSelectorCfg |
( |
|
flags | ) |
|
Definition at line 910 of file TauToolHolder.py.
912 _name = flags.Tau.ActiveConfig.prefix +
'TauAODSelector'
914 TauAODSelector = CompFactory.getComp(
"TauAODSelector")
916 Min0pTauPt = flags.Tau.MinPt0p,
917 MinTauPt = flags.Tau.MinPt,
918 doEarlyStopping = flags.Tau.doEarlyStopping
and not flags.Output.doWriteESD)
920 result.setPrivateTools(myTauAODSelector)
◆ TauAxisCfg()
def TauToolHolder.TauAxisCfg |
( |
|
flags | ) |
|
Tau energy calibration and tau axis direction.
Definition at line 58 of file TauToolHolder.py.
60 _name = flags.Tau.ActiveConfig.prefix +
'TauAxis'
62 TauAxisSetter = CompFactory.getComp(
"TauAxisSetter")
65 VertexCorrection =
True )
67 result.setPrivateTools(TauAxisSetter)
◆ TauCaloClusterBadChannelCfg()
def TauToolHolder.TauCaloClusterBadChannelCfg |
( |
|
flags | ) |
|
Definition at line 584 of file TauToolHolder.py.
586 _name = flags.Tau.ActiveConfig.prefix +
'CaloClusterBadChannelList'
588 CaloClusterBadChannelListCorr = CompFactory.getComp(
"CaloClusterBadChannelList")
591 result.setPrivateTools(BadChannelListCorrForTaus)
◆ TauCaloClusterCellWeightCalibCfg()
def TauToolHolder.TauCaloClusterCellWeightCalibCfg |
( |
|
flags | ) |
|
Definition at line 458 of file TauToolHolder.py.
460 _name = flags.Tau.ActiveConfig.prefix +
'CellWeights'
462 CaloClusterCellWeightCalib = CompFactory.getComp(
"CaloClusterCellWeightCalib")
464 CellWeights.CellSignalWeightTool = result.popToolsAndMerge(
CellWeightToolCfg(flags))
465 CellWeights.Direction =
"AbsSignal"
466 CellWeights.BelowThresholdLikeAll =
True
467 CellWeights.BelowThresholdDirection =
"AbsSignal"
468 CellWeights.EnergyThreshold = 0.0*MeV
469 CellWeights.IgnoreGeoWeights =
False
471 result.setPrivateTools(CellWeights)
◆ TauCaloClusterLocalCalibCfg()
def TauToolHolder.TauCaloClusterLocalCalibCfg |
( |
|
flags | ) |
|
Definition at line 405 of file TauToolHolder.py.
407 _name = flags.Tau.ActiveConfig.prefix +
'CaloLocalCalib'
409 CaloClusterLocalCalib = CompFactory.getComp(
"CaloClusterLocalCalib")
412 LocalCalib.ClusterRecoStatus = [1,2]
414 LocalCalib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
416 result.setPrivateTools(LocalCalib)
◆ TauCaloClusterMomentsMakerCfg()
def TauToolHolder.TauCaloClusterMomentsMakerCfg |
( |
|
flags | ) |
|
Definition at line 544 of file TauToolHolder.py.
546 _name = flags.Tau.ActiveConfig.prefix +
'Pi0TopoMoments'
549 from CaloTools.CaloNoiseCondAlgConfig
import CaloNoiseCondAlgCfg
554 CaloClusterMomentsMaker = CompFactory.getComp(
"CaloClusterMomentsMaker")
556 TopoMomentsForTaus.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
557 TopoMomentsForTaus.MaxAxisAngle = 20*deg
558 TopoMomentsForTaus.TwoGaussianNoise = flags.Calo.TopoCluster.doTwoGaussianNoise
559 TopoMomentsForTaus.MinBadLArQuality = 4000
560 TopoMomentsForTaus.MomentsNames = [
"FIRST_PHI"
581 result.setPrivateTools(TopoMomentsForTaus)
◆ TauCaloDMCalibCfg()
def TauToolHolder.TauCaloDMCalibCfg |
( |
|
flags | ) |
|
Definition at line 432 of file TauToolHolder.py.
434 _name = flags.Tau.ActiveConfig.prefix +
'DMCalib'
436 CaloClusterLocalCalib = CompFactory.getComp(
"CaloClusterLocalCalib")
438 DMCalib.ClusterRecoStatus = [1,2]
440 DMCalib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
442 result.setPrivateTools(DMCalib)
◆ TauCaloLCClassificationCfg()
def TauToolHolder.TauCaloLCClassificationCfg |
( |
|
flags | ) |
|
Calo Tools.
Definition at line 328 of file TauToolHolder.py.
330 _name = flags.Tau.ActiveConfig.prefix +
'LCClassify'
332 CaloLCClassificationTool = CompFactory.getComp(
"CaloLCClassificationTool")
334 LCClassify.ClassificationKey =
"EMFracClassify"
335 LCClassify.UseSpread =
False
336 LCClassify.MaxProbability = 0.5
338 LCClassify.StoreClassificationProbabilityInAOD =
True
339 LCClassify.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
340 LCClassify.UseNormalizedEnergyDensity =
True
342 result.setPrivateTools(LCClassify)
◆ TauCaloLCDeadMaterialCfg()
def TauToolHolder.TauCaloLCDeadMaterialCfg |
( |
|
flags | ) |
|
Definition at line 390 of file TauToolHolder.py.
392 _name = flags.Tau.ActiveConfig.prefix +
'CaloLCDeadMaterialTool'
394 CaloLCDeadMaterialTool = CompFactory.getComp(
"CaloLCDeadMaterialTool")
396 LCDeadMaterial.HadDMCoeffKey =
"HadDMCoeff2"
397 LCDeadMaterial.ClusterRecoStatus = 0
398 LCDeadMaterial.WeightModeDM = 2
399 LCDeadMaterial.UseHadProbability =
True
400 LCDeadMaterial.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
402 result.setPrivateTools(LCDeadMaterial)
◆ TauCaloLCOutOfClusterCfg()
def TauToolHolder.TauCaloLCOutOfClusterCfg |
( |
|
flags | ) |
|
Definition at line 364 of file TauToolHolder.py.
366 _name = flags.Tau.ActiveConfig.prefix +
'CaloLCOutOfClusterTool'
368 CaloLCOutOfClusterTool = CompFactory.getComp(
"CaloLCOutOfClusterTool")
370 LCOut.CorrectionKey =
"OOCCorrection"
371 LCOut.UseEmProbability =
False
372 LCOut.UseHadProbability =
True
374 result.setPrivateTools(LCOut)
◆ TauCaloLCOutPi0Cfg()
def TauToolHolder.TauCaloLCOutPi0Cfg |
( |
|
flags | ) |
|
Definition at line 377 of file TauToolHolder.py.
379 _name = flags.Tau.ActiveConfig.prefix +
'LCOutPi0'
381 CaloLCOutOfClusterTool = CompFactory.getComp(
"CaloLCOutOfClusterTool")
383 LCOutPi0.CorrectionKey =
"OOCPi0Correction"
384 LCOutPi0.UseEmProbability =
True
385 LCOutPi0.UseHadProbability =
False
387 result.setPrivateTools(LCOutPi0)
◆ TauCaloLCWeightCfg()
def TauToolHolder.TauCaloLCWeightCfg |
( |
|
flags | ) |
|
Definition at line 345 of file TauToolHolder.py.
347 _name = flags.Tau.ActiveConfig.prefix +
'CaloLCWeightTool'
350 from CaloTools.CaloNoiseCondAlgConfig
import CaloNoiseCondAlgCfg
355 CaloLCWeightTool = CompFactory.getComp(
"CaloLCWeightTool")
357 LCWeight.CorrectionKey =
"H1ClusterCellWeights"
358 LCWeight.SignalOverNoiseCut = 2.0
359 LCWeight.UseHadProbability =
True
361 result.setPrivateTools(LCWeight)
◆ TauCaloOOCCalibCfg()
def TauToolHolder.TauCaloOOCCalibCfg |
( |
|
flags | ) |
|
Definition at line 419 of file TauToolHolder.py.
421 _name = flags.Tau.ActiveConfig.prefix +
'OOCCalibTool'
423 CaloClusterLocalCalib = CompFactory.getComp(
"CaloClusterLocalCalib")
424 OOCCalib = CaloClusterLocalCalib (_name)
425 OOCCalib.ClusterRecoStatus = [1,2]
427 OOCCalib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
429 result.setPrivateTools(OOCCalib)
◆ TauCaloOOCPi0CalibCfg()
def TauToolHolder.TauCaloOOCPi0CalibCfg |
( |
|
flags | ) |
|
Definition at line 445 of file TauToolHolder.py.
447 _name = flags.Tau.ActiveConfig.prefix +
'OOCPi0CalibTool'
449 CaloClusterLocalCalib = CompFactory.getComp(
"CaloClusterLocalCalib")
450 OOCPi0Calib = CaloClusterLocalCalib (_name)
451 OOCPi0Calib.ClusterRecoStatus = [1,2]
453 OOCPi0Calib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
455 result.setPrivateTools(OOCPi0Calib)
◆ TauCaloTopoClusterMakerCfg()
def TauToolHolder.TauCaloTopoClusterMakerCfg |
( |
|
flags | ) |
|
Definition at line 474 of file TauToolHolder.py.
476 _name = flags.Tau.ActiveConfig.prefix +
'Pi0TopoClusterMaker'
479 from CaloTools.CaloNoiseCondAlgConfig
import CaloNoiseCondAlgCfg
484 CaloTopoClusterMaker = CompFactory.getComp(
"CaloTopoClusterMaker")
487 TopoClusterForTaus.CellsName = flags.Tau.ActiveConfig.TauCommonPi0Cells
488 TopoClusterForTaus.CalorimeterNames=[
"LAREM"]
489 TopoClusterForTaus.SeedSamplingNames = [
"PreSamplerB",
"EMB1",
"EMB2",
"PreSamplerE",
"EME1",
"EME2"]
490 TopoClusterForTaus.NeighborOption =
"super3D"
491 TopoClusterForTaus.RestrictHECIWandFCalNeighbors =
False
492 TopoClusterForTaus.RestrictPSNeighbors =
True
493 TopoClusterForTaus.CellThresholdOnEorAbsEinSigma = 0.0
494 TopoClusterForTaus.NeighborThresholdOnEorAbsEinSigma = 2.0
495 TopoClusterForTaus.SeedThresholdOnEorAbsEinSigma = 4.0
496 TopoClusterForTaus.SeedCutsInAbsE =
True
497 TopoClusterForTaus.ClusterCutsInAbsEt =
True
498 TopoClusterForTaus.ClusterEtorAbsEtCut = 0.5*GeV
499 TopoClusterForTaus.TwoGaussianNoise = flags.Calo.TopoCluster.doTwoGaussianNoise
501 TopoClusterForTaus.SeedCutsInT = flags.Calo.TopoCluster.doTimeCut
502 TopoClusterForTaus.CutOOTseed = flags.Calo.TopoCluster.extendTimeCut
and flags.Calo.TopoCluster.doTimeCut
503 TopoClusterForTaus.UseTimeCutUpperLimit = flags.Calo.TopoCluster.useUpperLimitForTimeCut
504 TopoClusterForTaus.TimeCutUpperLimit = flags.Calo.TopoCluster.timeCutUpperLimit
505 TopoClusterForTaus.XTalkEM2 = flags.Calo.TopoCluster.xtalkEM2
506 TopoClusterForTaus.XTalkEM2D = flags.Calo.TopoCluster.xtalkEM2D
507 TopoClusterForTaus.XTalkEM2n = flags.Calo.TopoCluster.xtalkEM2n
508 TopoClusterForTaus.XTalkEM3 = flags.Calo.TopoCluster.xtalkEM3
509 TopoClusterForTaus.XTalkEMEta = flags.Calo.TopoCluster.xtalkEMEta
510 TopoClusterForTaus.XTalkDeltaT = flags.Calo.TopoCluster.xtalkDeltaT
511 TopoClusterForTaus.XTalk2Eratio1 = flags.Calo.TopoCluster.xtalk2Eratio1
512 TopoClusterForTaus.XTalk2Eratio2 = flags.Calo.TopoCluster.xtalk2Eratio2
513 TopoClusterForTaus.XTalk3Eratio = flags.Calo.TopoCluster.xtalk3Eratio
514 TopoClusterForTaus.XTalkEtaEratio = flags.Calo.TopoCluster.xtalkEtaEratio
515 TopoClusterForTaus.XTalk2DEratio = flags.Calo.TopoCluster.xtalk2DEratio
517 result.setPrivateTools(TopoClusterForTaus)
◆ TauCaloTopoClusterSplitterCfg()
def TauToolHolder.TauCaloTopoClusterSplitterCfg |
( |
|
flags | ) |
|
Definition at line 520 of file TauToolHolder.py.
523 _name = flags.Tau.ActiveConfig.prefix +
'Pi0TopoClusterSplitter'
525 CaloTopoClusterSplitter = CompFactory.getComp(
"CaloTopoClusterSplitter")
532 TopoSplitterForTaus.SamplingNames = [
"EMB2",
"EME2"]
536 TopoSplitterForTaus.SecondarySamplingNames = [
"EMB1",
"EME1"]
537 TopoSplitterForTaus.ShareBorderCells =
True
538 TopoSplitterForTaus.RestrictHECIWandFCalNeighbors =
False
539 TopoSplitterForTaus.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
541 result.setPrivateTools(TopoSplitterForTaus)
◆ TauCellFinalizerCfg()
def TauToolHolder.TauCellFinalizerCfg |
( |
|
flags | ) |
|
Cell finalizer tool for BuildAlg.
Definition at line 314 of file TauToolHolder.py.
316 _name = flags.Tau.ActiveConfig.prefix +
'tauPi0CellContainerFinalizer'
318 CaloCellContainerFinalizerTool = CompFactory.getComp(
"CaloCellContainerFinalizerTool")
321 result.setPrivateTools(TauCellContainerFinalizer)
◆ TauClusterFinderCfg()
def TauToolHolder.TauClusterFinderCfg |
( |
|
flags | ) |
|
Associate the cluster in jet constituents to the tau candidate.
Definition at line 120 of file TauToolHolder.py.
122 _name = flags.Tau.ActiveConfig.prefix +
'TauClusterFinder'
125 TauClusterFinder = CompFactory.getComp(
"TauClusterFinder")
128 inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
132 result.setPrivateTools(TauClusterFinder)
◆ TauCombinedTESCfg()
def TauToolHolder.TauCombinedTESCfg |
( |
|
flags | ) |
|
TauCombinedTES.
Definition at line 925 of file TauToolHolder.py.
927 _name = flags.Tau.ActiveConfig.prefix +
'TauCombinedTES'
929 TauCombinedTES = CompFactory.getComp(
"TauCombinedTES")
931 WeightFileName = flags.Tau.CombinedTESConfig)
933 result.setPrivateTools(myTauCombinedTES)
◆ TauCommonCalcVarsCfg()
def TauToolHolder.TauCommonCalcVarsCfg |
( |
|
flags | ) |
|
Tau Variables.
Definition at line 666 of file TauToolHolder.py.
668 _name = flags.Tau.ActiveConfig.prefix +
'TauCommonCalcVars'
670 TauCommonCalcVars = CompFactory.getComp(
"TauCommonCalcVars")
673 result.setPrivateTools(TauCommonCalcVars)
◆ TauDecayModeNNClassifierCfg()
def TauToolHolder.TauDecayModeNNClassifierCfg |
( |
|
flags | ) |
|
Definition at line 899 of file TauToolHolder.py.
901 _name = flags.Tau.ActiveConfig.prefix +
'TauDecayModeNNClassifier'
903 TauDecayModeNNClassifier = CompFactory.getComp(
"TauDecayModeNNClassifier")
905 WeightFile=flags.Tau.DecayModeNNClassifierConfig)
907 result.setPrivateTools(myTauDecayModeNNClassifier)
◆ TauEleOverlapChecker()
def TauToolHolder.TauEleOverlapChecker |
( |
|
flags | ) |
|
Definition at line 952 of file TauToolHolder.py.
954 _name = flags.Tau.ActiveConfig.prefix +
'TauEleOverlapChecker'
955 TauEleOverlapChecker = CompFactory.getComp(
"TauEleOverlapChecker")
958 Key_RemovedClustersContainer = flags.Tau.ActiveConfig.RemovedElectronClusters,
959 Key_RemovedTracksContainer = flags.Tau.ActiveConfig.RemovedElectronTracks,
960 CheckingCone = flags.Tau.ActiveConfig.EleRM_CheckingConeSize,
962 result.setPrivateTools(myTauEleOverlapChecker)
◆ TauEleRNNEvaluatorCfg()
def TauToolHolder.TauEleRNNEvaluatorCfg |
( |
|
flags | ) |
|
Definition at line 828 of file TauToolHolder.py.
830 _name = flags.Tau.ActiveConfig.prefix +
'TauEleRNN'
832 TauJetRNNEvaluator = CompFactory.getComp(
"TauJetRNNEvaluator")
833 RNNConf = flags.Tau.TauEleRNNConfig
835 NetworkFile1P = RNNConf[0],
836 NetworkFile3P = RNNConf[1],
837 OutputVarname =
"RNNEleScore",
841 VertexCorrection =
True,
842 InputLayerScalar =
"scalar",
843 InputLayerTracks =
"tracks",
844 InputLayerClusters =
"clusters",
845 OutputLayer =
"rnneveto_output",
846 OutputNode =
"sig_prob")
848 result.setPrivateTools(myTauEleRNNEvaluator)
◆ TauGNNEvaluatorCfg()
def TauToolHolder.TauGNNEvaluatorCfg |
( |
|
flags, |
|
|
|
version = 0 |
|
) |
| |
Definition at line 782 of file TauToolHolder.py.
784 _name = flags.Tau.ActiveConfig.prefix +
'TauGNN_v' +
str(version)
786 TauGNNEvaluator = CompFactory.getComp(
"TauGNNEvaluator")
787 GNNConf = flags.Tau.TauGNNConfig[version]
789 NetworkFile = GNNConf,
790 OutputVarname = flags.Tau.GNTauScoreName[version],
791 OutputPTau =
"GNTauProbTau",
792 OutputPJet =
"GNTauProbJet",
793 MaxTracks = flags.Tau.GNTauMaxTracks[version],
794 MaxClusters = flags.Tau.GNTauMaxClusters[version],
796 MinTauPt = flags.Tau.MinPtDAOD,
797 VertexCorrection =
True,
798 DecorateTracks =
False,
799 InputLayerScalar =
"tau_vars",
800 InputLayerTracks =
"track_vars",
801 InputLayerClusters =
"cluster_vars",
802 NodeNameTau=flags.Tau.GNTauNodeNameTau,
803 NodeNameJet=flags.Tau.GNTauNodeNameJet)
805 result.setPrivateTools(myTauGNNEvaluator)
◆ TauIDVarCalculatorCfg()
def TauToolHolder.TauIDVarCalculatorCfg |
( |
|
flags | ) |
|
Definition at line 716 of file TauToolHolder.py.
718 _name = flags.Tau.ActiveConfig.prefix +
'TauIDVarCalculator'
720 TauIDVarCalculator = CompFactory.getComp(
"TauIDVarCalculator")
722 VertexCorrection =
True)
724 result.setPrivateTools(myTauIDVarCalculator)
◆ TauJetRNNEvaluatorCfg()
def TauToolHolder.TauJetRNNEvaluatorCfg |
( |
|
flags | ) |
|
Definition at line 727 of file TauToolHolder.py.
729 _name = flags.Tau.ActiveConfig.prefix +
'TauJetRNN'
731 TauJetRNNEvaluator = CompFactory.getComp(
"TauJetRNNEvaluator")
732 RNNConf = flags.Tau.TauJetRNNConfig
735 NetworkFile1P = RNNConf[0],
736 NetworkFile2P = RNNConf[1],
737 NetworkFile3P = RNNConf[2],
738 OutputVarname =
"RNNJetScore",
742 VertexCorrection =
True,
743 InputLayerScalar =
"scalar",
744 InputLayerTracks =
"tracks",
745 InputLayerClusters =
"clusters",
746 OutputLayer =
"rnnid_output",
747 OutputNode =
"sig_prob")
749 result.setPrivateTools(myTauJetRNNEvaluator)
◆ TauShotFinderCfg()
def TauToolHolder.TauShotFinderCfg |
( |
|
flags | ) |
|
Photon Shot Finder.
Definition at line 265 of file TauToolHolder.py.
267 _name = flags.Tau.ActiveConfig.prefix +
'TauShotFinder'
269 shotPtCut_1Photon = flags.Tau.shotPtCut_1Photon
270 shotPtCut_2Photons = flags.Tau.shotPtCut_2Photons
273 from CaloClusterCorrection.StandardCellWeightCalib
import getCellWeightTool
277 TauShotFinder = CompFactory.getComp(
"TauShotFinder")
280 CaloWeightTool = result.popToolsAndMerge(CaloWeightTool),
282 MinPtCut = shotPtCut_1Photon,
283 AutoDoubleShotCut = shotPtCut_2Photons,
284 Key_RemovedClusterInputContainer = flags.Tau.ActiveConfig.RemovedElectronClusters,
285 RemoveElectronCells = flags.Tau.ActiveConfig.RemoveElectronCells,
286 inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
289 result.setPrivateTools(TauShotFinder)
◆ TauSubstructureCfg()
def TauToolHolder.TauSubstructureCfg |
( |
|
flags | ) |
|
Tau Variables.
Definition at line 678 of file TauToolHolder.py.
680 _name = flags.Tau.ActiveConfig.prefix +
'TauSubstructure'
682 TauSubstructureVariables = CompFactory.getComp(
"TauSubstructureVariables")
685 result.setPrivateTools(TauSubstructureVariables)
◆ TauTrackFinderCfg()
def TauToolHolder.TauTrackFinderCfg |
( |
|
flags | ) |
|
Tau-Track Association.
Definition at line 83 of file TauToolHolder.py.
85 _name = flags.Tau.ActiveConfig.prefix +
'TauTrackFinder'
88 from BeamSpotConditions.BeamSpotConditionsConfig
import BeamSpotCondAlgCfg
91 from TrackToVertex.TrackToVertexConfig
import TrackToVertexCfg
92 from TrackToCalo.TrackToCaloConfig
import ParticleCaloExtensionToolCfg
93 from TrkConfig.TrkVertexFitterUtilsConfig
import AtlasTrackToVertexIPEstimatorCfg
94 from InDetConfig.InDetTrackSelectorToolConfig
import TauRecInDetTrackSelectorToolCfg
96 TauTrackFinder = CompFactory.getComp(
"TauTrackFinder")
104 removeDuplicateCoreTracks = flags.Tau.RemoveDupeCoreTracks,
105 useGhostTracks = flags.Tau.useGhostTracks,
106 ghostTrackDR = flags.Tau.ghostTrackDR,
107 Key_jetContainer = (flags.Tau.ActiveConfig.SeedJetCollection
if flags.Tau.useGhostTracks
else ""),
108 Key_trackPartInputContainer = flags.Tau.ActiveConfig.TrackCollection,
109 Key_LargeD0TrackInputContainer = (flags.Tau.ActiveConfig.LargeD0TrackCollection
if flags.Tau.associateLRT
else ""),
111 inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
115 result.setPrivateTools(TauTrackFinder)
◆ TauTrackRNNCfg()
def TauToolHolder.TauTrackRNNCfg |
( |
|
flags | ) |
|
Definition at line 148 of file TauToolHolder.py.
150 _name = flags.Tau.ActiveConfig.prefix +
'TauTrackRNNClassifier'
152 TrackRNN = CompFactory.tauRecTools.TrackRNN
153 _RNN = TrackRNN(name = _name +
"_TrackRNN",
154 InputWeightsPath = flags.Tau.tauRNNTrackClassConfig,
155 calibFolder = flags.Tau.tauRecToolsCVMFSPath )
157 result.setPrivateTools(_RNN)
◆ TauTrackRNNClassifierCfg()
def TauToolHolder.TauTrackRNNClassifierCfg |
( |
|
flags | ) |
|
Definition at line 161 of file TauToolHolder.py.
163 _name = flags.Tau.ActiveConfig.prefix +
'TauTrackRNNClassifier'
166 TauTrackRNNClassifier = CompFactory.tauRecTools.TauTrackRNNClassifier
169 cppyy.load_library(
'libxAODTau_cDict')
172 if flags.Tau.associateLRT
and not flags.Tau.classifyLRT:
175 myTauTrackClassifier = TauTrackRNNClassifier( name = _name,
177 classifyLRT = _classifyLRT )
179 result.setPrivateTools(myTauTrackClassifier)
◆ TauVertexedClusterDecoratorCfg()
def TauToolHolder.TauVertexedClusterDecoratorCfg |
( |
|
flags | ) |
|
Definition at line 136 of file TauToolHolder.py.
138 _name = flags.Tau.ActiveConfig.prefix +
'TauVertexedClusterDecorator'
140 TauVertexedClusterDecorator = CompFactory.getComp(
"TauVertexedClusterDecorator")
142 SeedJet = flags.Tau.ActiveConfig.SeedJetCollection)
144 result.setPrivateTools(myTauVertexedClusterDecorator)
◆ TauVertexFinderCfg()
def TauToolHolder.TauVertexFinderCfg |
( |
|
flags | ) |
|
Definition at line 32 of file TauToolHolder.py.
34 _name = flags.Tau.ActiveConfig.prefix +
'TauVertexFinder'
36 from InDetConfig.InDetTrackSelectionToolConfig
import Tau_InDetTrackSelectionToolForTJVACfg
37 from TrackVertexAssociationTool.TrackVertexAssociationToolConfig
import TauTTVAToolCfg
41 TauVertexFinder = CompFactory.getComp(
"TauVertexFinder")
43 UseTJVA = flags.Tau.doTJVA,
44 UseTJVA_Tiebreak = flags.Tau.doTJVATiebreak,
45 AssociatedTracks=
"GhostTrack",
47 Key_trackPartInputContainer= flags.Tau.ActiveConfig.TrackCollection,
48 Key_vertexInputContainer = flags.Tau.ActiveConfig.VertexCollection,
50 inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
53 result.setPrivateTools(TauVertexFinder)
◆ TauVertexVariablesCfg()
def TauToolHolder.TauVertexVariablesCfg |
( |
|
flags | ) |
|
Tau Vertex Variables.
Definition at line 648 of file TauToolHolder.py.
650 _name = flags.Tau.ActiveConfig.prefix +
'TauVertexVariables'
652 from TrkConfig.TrkVertexFittersConfig
import TauAdaptiveVertexFitterCfg
653 from TrkConfig.TrkVertexSeedFinderToolsConfig
import (
654 CrossDistancesSeedFinderCfg)
656 TauVertexVariables = CompFactory.getComp(
"TauVertexVariables")
661 result.setPrivateTools(TauVertexVariables)
◆ TauWPDecoratorEleRNNCfg()
def TauToolHolder.TauWPDecoratorEleRNNCfg |
( |
|
flags | ) |
|
Definition at line 851 of file TauToolHolder.py.
852 import PyUtils.RootUtils
as ru
853 ROOT = ru.import_root()
855 cppyy.load_library(
'libxAODTau_cDict')
858 _name = flags.Tau.ActiveConfig.prefix +
'TauWPDecoratorEleRNN'
860 TauWPDecorator = CompFactory.getComp(
"TauWPDecorator")
861 WPConf = flags.Tau.TauEleRNNWPConfig
863 flatteningFile1Prong = WPConf[0],
864 flatteningFile3Prong = WPConf[1],
866 [ ROOT.xAOD.TauJetParameters.IsTauFlag.EleRNNLoose,
867 ROOT.xAOD.TauJetParameters.IsTauFlag.EleRNNMedium,
868 ROOT.xAOD.TauJetParameters.IsTauFlag.EleRNNTight ],
869 SigEff1P = [0.95, 0.90, 0.85],
870 SigEff3P = [0.98, 0.95, 0.90],
872 ScoreName =
"RNNEleScore",
873 NewScoreName =
"RNNEleScoreSigTrans",
876 result.setPrivateTools(myTauEleWPDecorator)
◆ TauWPDecoratorEleRNNFixCfg()
def TauToolHolder.TauWPDecoratorEleRNNFixCfg |
( |
|
flags | ) |
|
Definition at line 879 of file TauToolHolder.py.
881 _name = flags.Tau.ActiveConfig.prefix +
'TauWPDecoratorEleRNNFix_v1'
883 TauWPDecorator = CompFactory.getComp(
"TauWPDecorator")
884 WPConf = flags.Tau.TauEleRNNWPfix
886 flatteningFile1Prong = WPConf[0],
887 flatteningFile3Prong = WPConf[1],
888 DecorWPNames = [
"EleRNNLoose_v1",
"EleRNNMedium_v1",
"EleRNNTight_v1" ],
889 DecorWPCutEffs1P = [0.95, 0.90, 0.85],
890 DecorWPCutEffs3P = [0.98, 0.95, 0.90],
892 ScoreName =
"RNNEleScore",
893 NewScoreName =
"RNNEleScoreSigTrans_v1",
896 result.setPrivateTools(myTauEleWPDecorator)
◆ TauWPDecoratorGNNCfg()
def TauToolHolder.TauWPDecoratorGNNCfg |
( |
|
flags, |
|
|
|
version |
|
) |
| |
Definition at line 808 of file TauToolHolder.py.
810 _name = flags.Tau.ActiveConfig.prefix +
'TauWPDecoratorGNN_v' +
str(version)
812 TauWPDecorator = CompFactory.getComp(
"TauWPDecorator")
813 WPConf = flags.Tau.TauGNNWP[version]
815 flatteningFile1Prong = WPConf[0],
816 flatteningFile2Prong = WPConf[1],
817 flatteningFile3Prong = WPConf[2],
818 DecorWPNames = flags.Tau.GNTauDecorWPNames[version],
819 DecorWPCutEffs1P = [0.95, 0.85, 0.75, 0.60],
820 DecorWPCutEffs2P = [0.95, 0.75, 0.60, 0.45],
821 DecorWPCutEffs3P = [0.95, 0.75, 0.60, 0.45],
822 ScoreName = flags.Tau.GNTauScoreName[version],
823 NewScoreName = flags.Tau.GNTauTransScoreName[version],
825 result.setPrivateTools(myTauWPDecorator)
◆ TauWPDecoratorJetRNNCfg()
def TauToolHolder.TauWPDecoratorJetRNNCfg |
( |
|
flags | ) |
|
Definition at line 752 of file TauToolHolder.py.
753 import PyUtils.RootUtils
as ru
754 ROOT = ru.import_root()
756 cppyy.load_library(
'libxAODTau_cDict')
759 _name = flags.Tau.ActiveConfig.prefix +
'TauWPDecoratorJetRNN'
761 TauWPDecorator = CompFactory.getComp(
"TauWPDecorator")
762 WPConf = flags.Tau.TauJetRNNWPConfig
764 flatteningFile1Prong = WPConf[0],
765 flatteningFile2Prong = WPConf[1],
766 flatteningFile3Prong = WPConf[2],
768 [ ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigVeryLoose,
769 ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigLoose,
770 ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigMedium,
771 ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigTight ],
772 SigEff1P = [0.95, 0.85, 0.75, 0.60],
773 SigEff2P = [0.95, 0.75, 0.60, 0.45],
774 SigEff3P = [0.95, 0.75, 0.60, 0.45],
775 ScoreName =
"RNNJetScore",
776 NewScoreName =
"RNNJetScoreSigTrans",
779 result.setPrivateTools(myTauWPDecorator)
Implementation of tool to decorate flattened BDT score and working points.
Calculate variables which rely on tracks and precalculated cell/cluster information.
Calculate variables from the tau substructure.
def TauAdaptiveVertexFitterCfg(flags, name="TauAdaptiveVertexFitter", **kwargs)
Find the cells used to create pi0 cluster.
Select only the tau within the removal direction.
Class for calculating vertex variables.
def AtlasTrackToVertexIPEstimatorCfg(flags, name='AtlasTrackToVertexIPEstimator', **kwargs)
def BeamSpotCondAlgCfg(flags, name="BeamSpotCondAlg", **kwargs)
Cluster correction tool which applies local hadronic calibration w eights to the cells....
topological cluster splitter.
Creates Pi0 clusters (Pi0 Finder).
Implementation of tau energy scale (TES) with eta and pile-up correction.
def getCellWeightTool(flags, finder="Cone", mainparam=0.4, input="Topo", onlyCellWeight=False)
Selectes pi0Candidates (Pi0 Finder).
Decorate CaloVertexedTopoCluster to the tau candidate.
Set Tau "Detector Axis" and "Intermediate Axis".
def CaloNoiseCondAlgCfg(flags, noisetype="totalNoise")
scale cluster energy to take care of charged pion energy
Tau decay mode classifier using a neural network.
def addFolders(flags, folderStrings, detDb=None, className=None, extensible=False, tag=None, db=None, modifiers='')
Apply Et and BDT score cut to pi0s.
This class implements a tool to calculate ID input variables and add them to the tau aux store.
Calculate variables sensitive on electrons.
Calculate tau calorimeter variables from cell information.
Associate a vertex (origin) to the tau candidate.
Class to build tau jet seed.
Associate tracks to the tau candidate.
Calculate moments for CaloCluster objects.
Associate the clusters used in the seed jet to the tau candidate.
Tool to calculate tau identification score from .onnx inputs.
def TrackToVertexCfg(flags, name="AtlasTrackToVertexTool", **kwargs)
Tool to calculate a tau identification score based on neural networks.
topological cluster maker.
def ParticleCaloExtensionToolCfg(flags, name='ParticleCaloExtensionTool', **kwargs)