Loading [MathJax]/extensions/tex2jax.js
 |
ATLAS Offline Software
|
◆ CellVariablesCfg()
def TauToolHolder.CellVariablesCfg |
( |
|
flags | ) |
|
Tau cell variables calculation.
Definition at line 195 of file TauToolHolder.py.
197 _name = flags.Tau.ActiveConfig.prefix +
'CellVariables'
199 TauCellVariables = CompFactory.getComp(
"TauCellVariables")
201 VertexCorrection = flags.Tau.doVertexCorrection)
203 result.setPrivateTools(TauCellVariables)
◆ CellWeightToolCfg()
def TauToolHolder.CellWeightToolCfg |
( |
|
flags | ) |
|
cell weight tool
Definition at line 225 of file TauToolHolder.py.
229 H1WeightToolCSC12Generic = CompFactory.H1WeightToolCSC12Generic
230 isMC = flags.Input.isMC
235 onlyCellWeight =
False
236 from CaloClusterCorrection.StandardCellWeightCalib
import H1Calibration, editParm
237 (key,folder,tag) = H1Calibration.getCalibDBParams(flags, finder, mainparam, inputn, onlyCellWeight, isMC)
239 from IOVDbSvc.IOVDbSvcConfig
import addFolders
244 if (folder,tag)
not in H1Calibration.loaded_folder:
245 if H1Calibration.overrideFolder():
246 result.merge(
addFolders(flags, folder+
'<tag>'+tag+
'</tag>', detDb=dbString, className=
'CaloRec::ToolConstants') )
248 result.merge(
addFolders(flags, folder, detDb=dbString, className=
'CaloRec::ToolConstants') )
250 H1Calibration.loaded_folder.append( (folder,tag) )
253 toolName = finder +
editParm(mainparam) + inputn
255 cellcalibtool.DBHandleKey = key
256 result.setPrivateTools(cellcalibtool)
◆ ElectronVetoVarsCfg()
def TauToolHolder.ElectronVetoVarsCfg |
( |
|
flags | ) |
|
ele veto variables
Definition at line 208 of file TauToolHolder.py.
210 _name = flags.Tau.ActiveConfig.prefix +
'TauElectronVetoVars'
212 from TrackToCalo.TrackToCaloConfig
import ParticleCaloExtensionToolCfg
214 TauElectronVetoVariables = CompFactory.getComp(
"TauElectronVetoVariables")
216 VertexCorrection = flags.Tau.doVertexCorrection,
220 result.setPrivateTools(TauElectronVetoVariables)
◆ EnergyCalibrationLCCfg()
def TauToolHolder.EnergyCalibrationLCCfg |
( |
|
flags | ) |
|
Tau energy calibration.
Definition at line 181 of file TauToolHolder.py.
183 _name = flags.Tau.ActiveConfig.prefix +
'EnergyCalibrationLC'
185 TauCalibrateLC = CompFactory.getComp(
"TauCalibrateLC")
187 calibrationFile = flags.Tau.CalibrateLCConfig,
188 Key_vertexInputContainer = flags.Tau.ActiveConfig.VertexCollection)
190 result.setPrivateTools(TauCalibrateLC)
◆ getParticleCache()
def TauToolHolder.getParticleCache |
( |
|
flags | ) |
|
Definition at line 71 of file TauToolHolder.py.
73 if flags.Common.ProductionStep
is ProductionStep.Reconstruction:
74 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 707 of file TauToolHolder.py.
709 _name = flags.Tau.ActiveConfig.prefix +
'MvaTESEvaluator'
711 MvaTESEvaluator = CompFactory.getComp(
"MvaTESEvaluator")
713 WeightFileName = flags.Tau.MvaTESConfig,
714 WeightFileName0p = flags.Tau.MvaTESConfig0p )
716 result.setPrivateTools(MvaTESEvaluator)
◆ MvaTESVariableDecoratorCfg()
def TauToolHolder.MvaTESVariableDecoratorCfg |
( |
|
flags | ) |
|
MvaTESVariableDecorator.
Definition at line 687 of file TauToolHolder.py.
689 _name = flags.Tau.ActiveConfig.prefix +
'MvaTESVariableDecorator'
691 eventShapeCollection = flags.Tau.ActiveConfig.EventShapeCollection
692 if 'EMPFlow' in flags.Tau.ActiveConfig.SeedJetCollection:
693 eventShapeCollection =
"Kt4EMPFlowEventShape"
694 elif 'EMTopo' in flags.Tau.ActiveConfig.SeedJetCollection:
695 eventShapeCollection =
"Kt4EMTopoOriginEventShape"
697 MvaTESVariableDecorator = CompFactory.getComp(
"MvaTESVariableDecorator")
699 Key_vertexInputContainer = flags.Tau.ActiveConfig.VertexCollection,
700 EventShapeKey = eventShapeCollection,
701 VertexCorrection = flags.Tau.doVertexCorrection)
702 result.setPrivateTools(MvaTESVariableDecorator)
◆ Pi0ClusterCreatorCfg()
def TauToolHolder.Pi0ClusterCreatorCfg |
( |
|
flags | ) |
|
create Pi0 clusters
Definition at line 593 of file TauToolHolder.py.
595 _name = flags.Tau.ActiveConfig.prefix +
'Pi0ClusterCreator'
597 TauPi0ClusterCreator = CompFactory.getComp(
"TauPi0ClusterCreator")
600 result.setPrivateTools(TauPi0ClusterCreator)
◆ Pi0ClusterFinderCfg()
def TauToolHolder.Pi0ClusterFinderCfg |
( |
|
flags | ) |
|
Pi0 algo Cluster finder for Pi0 algo.
Definition at line 292 of file TauToolHolder.py.
294 _name = flags.Tau.ActiveConfig.prefix +
'Pi0ClusterFinder'
296 TauPi0CreateROI = CompFactory.getComp(
"TauPi0CreateROI")
300 Key_caloCellInputContainer =
"AllCalo",
301 Key_RemovedClusterInputContainer = flags.Tau.ActiveConfig.RemovedElectronClusters,
302 inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
303 RemoveElectronCells = flags.Tau.ActiveConfig.RemoveElectronCells,
306 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 605 of file TauToolHolder.py.
607 _name = flags.Tau.ActiveConfig.prefix +
'Pi0ClusterScaler'
609 TauPi0ClusterScaler = CompFactory.getComp(
"TauPi0ClusterScaler")
612 result.setPrivateTools(TauPi0ClusterScaler)
◆ Pi0ScoreCalculatorCfg()
def TauToolHolder.Pi0ScoreCalculatorCfg |
( |
|
flags | ) |
|
calculate MVA scores of pi0 clusters
Definition at line 617 of file TauToolHolder.py.
619 _name = flags.Tau.ActiveConfig.prefix +
'Pi0ScoreCalculator'
621 TauPi0ScoreCalculator = CompFactory.getComp(
"TauPi0ScoreCalculator")
623 BDTWeightFile = flags.Tau.Pi0ScoreConfig)
625 result.setPrivateTools(TauPi0ScoreCalculator)
◆ Pi0SelectorCfg()
def TauToolHolder.Pi0SelectorCfg |
( |
|
flags | ) |
|
select pi0 clusters
Definition at line 630 of file TauToolHolder.py.
632 _name = flags.Tau.ActiveConfig.prefix +
'Pi0Selector'
634 TauPi0Selector = CompFactory.getComp(
"TauPi0Selector")
636 ClusterEtCut = flags.Tau.pi0EtCuts,
637 ClusterBDTCut_1prong = flags.Tau.pi0MVACuts_1prong,
638 ClusterBDTCut_mprong = flags.Tau.pi0MVACuts_mprong)
640 result.setPrivateTools(TauPi0Selector)
◆ TauAODMuonRemovalCfg()
def TauToolHolder.TauAODMuonRemovalCfg |
( |
|
flags | ) |
|
muon removal tool
Definition at line 941 of file TauToolHolder.py.
943 _name = flags.Tau.ActiveConfig.prefix +
'MuonRemoval'
944 TauAODMuonRemovalTool = CompFactory.getComp(
"TauAODMuonRemovalTool")
946 Key_MuonInputContainer =
'Muons',
951 result.setPrivateTools(myMuonRemoval)
◆ TauAODSelectorCfg()
def TauToolHolder.TauAODSelectorCfg |
( |
|
flags | ) |
|
Definition at line 913 of file TauToolHolder.py.
915 _name = flags.Tau.ActiveConfig.prefix +
'TauAODSelector'
917 TauAODSelector = CompFactory.getComp(
"TauAODSelector")
919 Min0pTauPt = flags.Tau.MinPt0p,
920 MinTauPt = flags.Tau.MinPt,
921 doEarlyStopping = flags.Tau.doEarlyStopping
and not flags.Output.doWriteESD)
923 result.setPrivateTools(myTauAODSelector)
◆ TauAxisCfg()
def TauToolHolder.TauAxisCfg |
( |
|
flags | ) |
|
Tau energy calibration and tau axis direction.
Definition at line 57 of file TauToolHolder.py.
59 _name = flags.Tau.ActiveConfig.prefix +
'TauAxis'
61 TauAxisSetter = CompFactory.getComp(
"TauAxisSetter")
64 VertexCorrection = flags.Tau.doVertexCorrection )
66 result.setPrivateTools(TauAxisSetter)
◆ TauCaloClusterBadChannelCfg()
def TauToolHolder.TauCaloClusterBadChannelCfg |
( |
|
flags | ) |
|
Definition at line 581 of file TauToolHolder.py.
583 _name = flags.Tau.ActiveConfig.prefix +
'CaloClusterBadChannelList'
585 CaloClusterBadChannelListCorr = CompFactory.getComp(
"CaloClusterBadChannelList")
588 result.setPrivateTools(BadChannelListCorrForTaus)
◆ TauCaloClusterCellWeightCalibCfg()
def TauToolHolder.TauCaloClusterCellWeightCalibCfg |
( |
|
flags | ) |
|
Definition at line 455 of file TauToolHolder.py.
457 _name = flags.Tau.ActiveConfig.prefix +
'CellWeights'
459 CaloClusterCellWeightCalib = CompFactory.getComp(
"CaloClusterCellWeightCalib")
461 CellWeights.CellSignalWeightTool = result.popToolsAndMerge(
CellWeightToolCfg(flags))
462 CellWeights.Direction =
"AbsSignal"
463 CellWeights.BelowThresholdLikeAll =
True
464 CellWeights.BelowThresholdDirection =
"AbsSignal"
465 CellWeights.EnergyThreshold = 0.0*MeV
466 CellWeights.IgnoreGeoWeights =
False
468 result.setPrivateTools(CellWeights)
◆ TauCaloClusterLocalCalibCfg()
def TauToolHolder.TauCaloClusterLocalCalibCfg |
( |
|
flags | ) |
|
Definition at line 402 of file TauToolHolder.py.
404 _name = flags.Tau.ActiveConfig.prefix +
'CaloLocalCalib'
406 CaloClusterLocalCalib = CompFactory.getComp(
"CaloClusterLocalCalib")
409 LocalCalib.ClusterRecoStatus = [1,2]
411 LocalCalib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
413 result.setPrivateTools(LocalCalib)
◆ TauCaloClusterMomentsMakerCfg()
def TauToolHolder.TauCaloClusterMomentsMakerCfg |
( |
|
flags | ) |
|
Definition at line 541 of file TauToolHolder.py.
543 _name = flags.Tau.ActiveConfig.prefix +
'Pi0TopoMoments'
546 from CaloTools.CaloNoiseCondAlgConfig
import CaloNoiseCondAlgCfg
551 CaloClusterMomentsMaker = CompFactory.getComp(
"CaloClusterMomentsMaker")
553 TopoMomentsForTaus.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
554 TopoMomentsForTaus.MaxAxisAngle = 20*deg
555 TopoMomentsForTaus.TwoGaussianNoise = flags.Calo.TopoCluster.doTwoGaussianNoise
556 TopoMomentsForTaus.MinBadLArQuality = 4000
557 TopoMomentsForTaus.MomentsNames = [
"FIRST_PHI"
578 result.setPrivateTools(TopoMomentsForTaus)
◆ TauCaloDMCalibCfg()
def TauToolHolder.TauCaloDMCalibCfg |
( |
|
flags | ) |
|
Definition at line 429 of file TauToolHolder.py.
431 _name = flags.Tau.ActiveConfig.prefix +
'DMCalib'
433 CaloClusterLocalCalib = CompFactory.getComp(
"CaloClusterLocalCalib")
435 DMCalib.ClusterRecoStatus = [1,2]
437 DMCalib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
439 result.setPrivateTools(DMCalib)
◆ TauCaloLCClassificationCfg()
def TauToolHolder.TauCaloLCClassificationCfg |
( |
|
flags | ) |
|
Calo Tools.
Definition at line 325 of file TauToolHolder.py.
327 _name = flags.Tau.ActiveConfig.prefix +
'LCClassify'
329 CaloLCClassificationTool = CompFactory.getComp(
"CaloLCClassificationTool")
331 LCClassify.ClassificationKey =
"EMFracClassify"
332 LCClassify.UseSpread =
False
333 LCClassify.MaxProbability = 0.5
335 LCClassify.StoreClassificationProbabilityInAOD =
True
336 LCClassify.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
337 LCClassify.UseNormalizedEnergyDensity =
True
339 result.setPrivateTools(LCClassify)
◆ TauCaloLCDeadMaterialCfg()
def TauToolHolder.TauCaloLCDeadMaterialCfg |
( |
|
flags | ) |
|
Definition at line 387 of file TauToolHolder.py.
389 _name = flags.Tau.ActiveConfig.prefix +
'CaloLCDeadMaterialTool'
391 CaloLCDeadMaterialTool = CompFactory.getComp(
"CaloLCDeadMaterialTool")
393 LCDeadMaterial.HadDMCoeffKey =
"HadDMCoeff2"
394 LCDeadMaterial.ClusterRecoStatus = 0
395 LCDeadMaterial.WeightModeDM = 2
396 LCDeadMaterial.UseHadProbability =
True
397 LCDeadMaterial.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
399 result.setPrivateTools(LCDeadMaterial)
◆ TauCaloLCOutOfClusterCfg()
def TauToolHolder.TauCaloLCOutOfClusterCfg |
( |
|
flags | ) |
|
Definition at line 361 of file TauToolHolder.py.
363 _name = flags.Tau.ActiveConfig.prefix +
'CaloLCOutOfClusterTool'
365 CaloLCOutOfClusterTool = CompFactory.getComp(
"CaloLCOutOfClusterTool")
367 LCOut.CorrectionKey =
"OOCCorrection"
368 LCOut.UseEmProbability =
False
369 LCOut.UseHadProbability =
True
371 result.setPrivateTools(LCOut)
◆ TauCaloLCOutPi0Cfg()
def TauToolHolder.TauCaloLCOutPi0Cfg |
( |
|
flags | ) |
|
Definition at line 374 of file TauToolHolder.py.
376 _name = flags.Tau.ActiveConfig.prefix +
'LCOutPi0'
378 CaloLCOutOfClusterTool = CompFactory.getComp(
"CaloLCOutOfClusterTool")
380 LCOutPi0.CorrectionKey =
"OOCPi0Correction"
381 LCOutPi0.UseEmProbability =
True
382 LCOutPi0.UseHadProbability =
False
384 result.setPrivateTools(LCOutPi0)
◆ TauCaloLCWeightCfg()
def TauToolHolder.TauCaloLCWeightCfg |
( |
|
flags | ) |
|
Definition at line 342 of file TauToolHolder.py.
344 _name = flags.Tau.ActiveConfig.prefix +
'CaloLCWeightTool'
347 from CaloTools.CaloNoiseCondAlgConfig
import CaloNoiseCondAlgCfg
352 CaloLCWeightTool = CompFactory.getComp(
"CaloLCWeightTool")
354 LCWeight.CorrectionKey =
"H1ClusterCellWeights"
355 LCWeight.SignalOverNoiseCut = 2.0
356 LCWeight.UseHadProbability =
True
358 result.setPrivateTools(LCWeight)
◆ TauCaloOOCCalibCfg()
def TauToolHolder.TauCaloOOCCalibCfg |
( |
|
flags | ) |
|
Definition at line 416 of file TauToolHolder.py.
418 _name = flags.Tau.ActiveConfig.prefix +
'OOCCalibTool'
420 CaloClusterLocalCalib = CompFactory.getComp(
"CaloClusterLocalCalib")
421 OOCCalib = CaloClusterLocalCalib (_name)
422 OOCCalib.ClusterRecoStatus = [1,2]
424 OOCCalib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
426 result.setPrivateTools(OOCCalib)
◆ TauCaloOOCPi0CalibCfg()
def TauToolHolder.TauCaloOOCPi0CalibCfg |
( |
|
flags | ) |
|
Definition at line 442 of file TauToolHolder.py.
444 _name = flags.Tau.ActiveConfig.prefix +
'OOCPi0CalibTool'
446 CaloClusterLocalCalib = CompFactory.getComp(
"CaloClusterLocalCalib")
447 OOCPi0Calib = CaloClusterLocalCalib (_name)
448 OOCPi0Calib.ClusterRecoStatus = [1,2]
450 OOCPi0Calib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
452 result.setPrivateTools(OOCPi0Calib)
◆ TauCaloTopoClusterMakerCfg()
def TauToolHolder.TauCaloTopoClusterMakerCfg |
( |
|
flags | ) |
|
Definition at line 471 of file TauToolHolder.py.
473 _name = flags.Tau.ActiveConfig.prefix +
'Pi0TopoClusterMaker'
476 from CaloTools.CaloNoiseCondAlgConfig
import CaloNoiseCondAlgCfg
481 CaloTopoClusterMaker = CompFactory.getComp(
"CaloTopoClusterMaker")
484 TopoClusterForTaus.CellsName = flags.Tau.ActiveConfig.TauCommonPi0Cells
485 TopoClusterForTaus.CalorimeterNames=[
"LAREM"]
486 TopoClusterForTaus.SeedSamplingNames = [
"PreSamplerB",
"EMB1",
"EMB2",
"PreSamplerE",
"EME1",
"EME2"]
487 TopoClusterForTaus.NeighborOption =
"super3D"
488 TopoClusterForTaus.RestrictHECIWandFCalNeighbors =
False
489 TopoClusterForTaus.RestrictPSNeighbors =
True
490 TopoClusterForTaus.CellThresholdOnEorAbsEinSigma = 0.0
491 TopoClusterForTaus.NeighborThresholdOnEorAbsEinSigma = 2.0
492 TopoClusterForTaus.SeedThresholdOnEorAbsEinSigma = 4.0
493 TopoClusterForTaus.SeedCutsInAbsE =
True
494 TopoClusterForTaus.ClusterCutsInAbsEt =
True
495 TopoClusterForTaus.ClusterEtorAbsEtCut = 0.5*GeV
496 TopoClusterForTaus.TwoGaussianNoise = flags.Calo.TopoCluster.doTwoGaussianNoise
498 TopoClusterForTaus.SeedCutsInT = flags.Calo.TopoCluster.doTimeCut
499 TopoClusterForTaus.CutOOTseed = flags.Calo.TopoCluster.extendTimeCut
and flags.Calo.TopoCluster.doTimeCut
500 TopoClusterForTaus.UseTimeCutUpperLimit = flags.Calo.TopoCluster.useUpperLimitForTimeCut
501 TopoClusterForTaus.TimeCutUpperLimit = flags.Calo.TopoCluster.timeCutUpperLimit
502 TopoClusterForTaus.XTalkEM2 = flags.Calo.TopoCluster.xtalkEM2
503 TopoClusterForTaus.XTalkEM2D = flags.Calo.TopoCluster.xtalkEM2D
504 TopoClusterForTaus.XTalkEM2n = flags.Calo.TopoCluster.xtalkEM2n
505 TopoClusterForTaus.XTalkEM3 = flags.Calo.TopoCluster.xtalkEM3
506 TopoClusterForTaus.XTalkEMEta = flags.Calo.TopoCluster.xtalkEMEta
507 TopoClusterForTaus.XTalkDeltaT = flags.Calo.TopoCluster.xtalkDeltaT
508 TopoClusterForTaus.XTalk2Eratio1 = flags.Calo.TopoCluster.xtalk2Eratio1
509 TopoClusterForTaus.XTalk2Eratio2 = flags.Calo.TopoCluster.xtalk2Eratio2
510 TopoClusterForTaus.XTalk3Eratio = flags.Calo.TopoCluster.xtalk3Eratio
511 TopoClusterForTaus.XTalkEtaEratio = flags.Calo.TopoCluster.xtalkEtaEratio
512 TopoClusterForTaus.XTalk2DEratio = flags.Calo.TopoCluster.xtalk2DEratio
514 result.setPrivateTools(TopoClusterForTaus)
◆ TauCaloTopoClusterSplitterCfg()
def TauToolHolder.TauCaloTopoClusterSplitterCfg |
( |
|
flags | ) |
|
Definition at line 517 of file TauToolHolder.py.
520 _name = flags.Tau.ActiveConfig.prefix +
'Pi0TopoClusterSplitter'
522 CaloTopoClusterSplitter = CompFactory.getComp(
"CaloTopoClusterSplitter")
529 TopoSplitterForTaus.SamplingNames = [
"EMB2",
"EME2"]
533 TopoSplitterForTaus.SecondarySamplingNames = [
"EMB1",
"EME1"]
534 TopoSplitterForTaus.ShareBorderCells =
True
535 TopoSplitterForTaus.RestrictHECIWandFCalNeighbors =
False
536 TopoSplitterForTaus.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
538 result.setPrivateTools(TopoSplitterForTaus)
◆ TauCellFinalizerCfg()
def TauToolHolder.TauCellFinalizerCfg |
( |
|
flags | ) |
|
Cell finalizer tool for BuildAlg.
Definition at line 311 of file TauToolHolder.py.
313 _name = flags.Tau.ActiveConfig.prefix +
'tauPi0CellContainerFinalizer'
315 CaloCellContainerFinalizerTool = CompFactory.getComp(
"CaloCellContainerFinalizerTool")
318 result.setPrivateTools(TauCellContainerFinalizer)
◆ TauClusterFinderCfg()
def TauToolHolder.TauClusterFinderCfg |
( |
|
flags | ) |
|
Associate the cluster in jet constituents to the tau candidate.
Definition at line 117 of file TauToolHolder.py.
119 _name = flags.Tau.ActiveConfig.prefix +
'TauClusterFinder'
122 TauClusterFinder = CompFactory.getComp(
"TauClusterFinder")
125 inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
129 result.setPrivateTools(TauClusterFinder)
◆ TauCombinedTESCfg()
def TauToolHolder.TauCombinedTESCfg |
( |
|
flags | ) |
|
TauCombinedTES.
Definition at line 928 of file TauToolHolder.py.
930 _name = flags.Tau.ActiveConfig.prefix +
'TauCombinedTES'
932 TauCombinedTES = CompFactory.getComp(
"TauCombinedTES")
934 WeightFileName = flags.Tau.CombinedTESConfig)
936 result.setPrivateTools(myTauCombinedTES)
◆ TauCommonCalcVarsCfg()
def TauToolHolder.TauCommonCalcVarsCfg |
( |
|
flags | ) |
|
Tau Variables.
Definition at line 663 of file TauToolHolder.py.
665 _name = flags.Tau.ActiveConfig.prefix +
'TauCommonCalcVars'
667 TauCommonCalcVars = CompFactory.getComp(
"TauCommonCalcVars")
670 result.setPrivateTools(TauCommonCalcVars)
◆ TauDecayModeNNClassifierCfg()
def TauToolHolder.TauDecayModeNNClassifierCfg |
( |
|
flags | ) |
|
Definition at line 902 of file TauToolHolder.py.
904 _name = flags.Tau.ActiveConfig.prefix +
'TauDecayModeNNClassifier'
906 TauDecayModeNNClassifier = CompFactory.getComp(
"TauDecayModeNNClassifier")
908 WeightFile=flags.Tau.DecayModeNNClassifierConfig)
910 result.setPrivateTools(myTauDecayModeNNClassifier)
◆ TauEleOverlapChecker()
def TauToolHolder.TauEleOverlapChecker |
( |
|
flags | ) |
|
Definition at line 955 of file TauToolHolder.py.
957 _name = flags.Tau.ActiveConfig.prefix +
'TauEleOverlapChecker'
958 TauEleOverlapChecker = CompFactory.getComp(
"TauEleOverlapChecker")
961 Key_RemovedClustersContainer = flags.Tau.ActiveConfig.RemovedElectronClusters,
962 Key_RemovedTracksContainer = flags.Tau.ActiveConfig.RemovedElectronTracks,
963 CheckingCone = flags.Tau.ActiveConfig.EleRM_CheckingConeSize,
965 result.setPrivateTools(myTauEleOverlapChecker)
◆ TauEleRNNEvaluatorCfg()
def TauToolHolder.TauEleRNNEvaluatorCfg |
( |
|
flags | ) |
|
Definition at line 831 of file TauToolHolder.py.
833 _name = flags.Tau.ActiveConfig.prefix +
'TauEleRNN'
835 TauJetRNNEvaluator = CompFactory.getComp(
"TauJetRNNEvaluator")
836 RNNConf = flags.Tau.TauEleRNNConfig
838 NetworkFile1P = RNNConf[0],
839 NetworkFile3P = RNNConf[1],
840 OutputVarname =
"RNNEleScore",
844 VertexCorrection = flags.Tau.doVertexCorrection,
845 InputLayerScalar =
"scalar",
846 InputLayerTracks =
"tracks",
847 InputLayerClusters =
"clusters",
848 OutputLayer =
"rnneveto_output",
849 OutputNode =
"sig_prob")
851 result.setPrivateTools(myTauEleRNNEvaluator)
◆ TauGNNEvaluatorCfg()
def TauToolHolder.TauGNNEvaluatorCfg |
( |
|
flags, |
|
|
|
version = 0 |
|
) |
| |
Definition at line 785 of file TauToolHolder.py.
787 _name = flags.Tau.ActiveConfig.prefix +
'TauGNN_v' +
str(version)
789 TauGNNEvaluator = CompFactory.getComp(
"TauGNNEvaluator")
790 GNNConf = flags.Tau.TauGNNConfig[version]
792 NetworkFileInclusive = GNNConf,
793 OutputVarname = flags.Tau.GNTauScoreName[version],
794 OutputPTau =
"GNTauProbTau",
795 OutputPJet =
"GNTauProbJet",
796 MaxTracks = flags.Tau.GNTauMaxTracks[version],
797 MaxClusters = flags.Tau.GNTauMaxClusters[version],
799 MinTauPt = flags.Tau.MinPtDAOD,
800 VertexCorrection = flags.Tau.doVertexCorrection,
801 DecorateTracks =
False,
802 InputLayerScalar =
"tau_vars",
803 InputLayerTracks =
"track_vars",
804 InputLayerClusters =
"cluster_vars",
805 NodeNameTau=flags.Tau.GNTauNodeNameTau,
806 NodeNameJet=flags.Tau.GNTauNodeNameJet)
808 result.setPrivateTools(myTauGNNEvaluator)
◆ TauIDVarCalculatorCfg()
def TauToolHolder.TauIDVarCalculatorCfg |
( |
|
flags | ) |
|
Definition at line 719 of file TauToolHolder.py.
721 _name = flags.Tau.ActiveConfig.prefix +
'TauIDVarCalculator'
723 TauIDVarCalculator = CompFactory.getComp(
"TauIDVarCalculator")
725 VertexCorrection = flags.Tau.doVertexCorrection)
727 result.setPrivateTools(myTauIDVarCalculator)
◆ TauJetRNNEvaluatorCfg()
def TauToolHolder.TauJetRNNEvaluatorCfg |
( |
|
flags | ) |
|
Definition at line 730 of file TauToolHolder.py.
732 _name = flags.Tau.ActiveConfig.prefix +
'TauJetRNN'
734 TauJetRNNEvaluator = CompFactory.getComp(
"TauJetRNNEvaluator")
735 RNNConf = flags.Tau.TauJetRNNConfig
738 NetworkFile1P = RNNConf[0],
739 NetworkFile2P = RNNConf[1],
740 NetworkFile3P = RNNConf[2],
741 OutputVarname =
"RNNJetScore",
745 VertexCorrection = flags.Tau.doVertexCorrection,
746 InputLayerScalar =
"scalar",
747 InputLayerTracks =
"tracks",
748 InputLayerClusters =
"clusters",
749 OutputLayer =
"rnnid_output",
750 OutputNode =
"sig_prob")
752 result.setPrivateTools(myTauJetRNNEvaluator)
◆ TauShotFinderCfg()
def TauToolHolder.TauShotFinderCfg |
( |
|
flags | ) |
|
Photon Shot Finder.
Definition at line 262 of file TauToolHolder.py.
264 _name = flags.Tau.ActiveConfig.prefix +
'TauShotFinder'
266 shotPtCut_1Photon = flags.Tau.shotPtCut_1Photon
267 shotPtCut_2Photons = flags.Tau.shotPtCut_2Photons
270 from CaloClusterCorrection.StandardCellWeightCalib
import getCellWeightTool
274 TauShotFinder = CompFactory.getComp(
"TauShotFinder")
277 CaloWeightTool = result.popToolsAndMerge(CaloWeightTool),
279 MinPtCut = shotPtCut_1Photon,
280 AutoDoubleShotCut = shotPtCut_2Photons,
281 Key_RemovedClusterInputContainer = flags.Tau.ActiveConfig.RemovedElectronClusters,
282 RemoveElectronCells = flags.Tau.ActiveConfig.RemoveElectronCells,
283 inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
286 result.setPrivateTools(TauShotFinder)
◆ TauSubstructureCfg()
def TauToolHolder.TauSubstructureCfg |
( |
|
flags | ) |
|
Tau Variables.
Definition at line 675 of file TauToolHolder.py.
677 _name = flags.Tau.ActiveConfig.prefix +
'TauSubstructure'
679 TauSubstructureVariables = CompFactory.getComp(
"TauSubstructureVariables")
682 result.setPrivateTools(TauSubstructureVariables)
◆ TauTrackFinderCfg()
def TauToolHolder.TauTrackFinderCfg |
( |
|
flags | ) |
|
Tau-Track Association.
Definition at line 82 of file TauToolHolder.py.
84 _name = flags.Tau.ActiveConfig.prefix +
'TauTrackFinder'
87 from BeamSpotConditions.BeamSpotConditionsConfig
import BeamSpotCondAlgCfg
90 from TrackToVertex.TrackToVertexConfig
import TrackToVertexCfg
91 from TrackToCalo.TrackToCaloConfig
import ParticleCaloExtensionToolCfg
92 from TrkConfig.TrkVertexFitterUtilsConfig
import AtlasTrackToVertexIPEstimatorCfg
93 from InDetConfig.InDetTrackSelectorToolConfig
import TauRecInDetTrackSelectorToolCfg
95 TauTrackFinder = CompFactory.getComp(
"TauTrackFinder")
103 removeDuplicateCoreTracks = flags.Tau.RemoveDupeCoreTracks,
104 useGhostTracks = flags.Tau.useGhostTracks,
105 ghostTrackDR = flags.Tau.ghostTrackDR,
106 Key_jetContainer = (flags.Tau.ActiveConfig.SeedJetCollection
if flags.Tau.useGhostTracks
else ""),
107 Key_trackPartInputContainer = flags.Tau.ActiveConfig.TrackCollection,
108 Key_LargeD0TrackInputContainer = (flags.Tau.ActiveConfig.LargeD0TrackCollection
if flags.Tau.associateLRT
else ""),
110 inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
112 result.setPrivateTools(TauTrackFinder)
◆ TauTrackRNNCfg()
def TauToolHolder.TauTrackRNNCfg |
( |
|
flags | ) |
|
Definition at line 145 of file TauToolHolder.py.
147 _name = flags.Tau.ActiveConfig.prefix +
'TauTrackRNNClassifier'
149 TrackRNN = CompFactory.tauRecTools.TrackRNN
150 _RNN = TrackRNN(name = _name +
"_TrackRNN",
151 InputWeightsPath = flags.Tau.tauRNNTrackClassConfig,
152 calibFolder = flags.Tau.tauRecToolsCVMFSPath )
154 result.setPrivateTools(_RNN)
◆ TauTrackRNNClassifierCfg()
def TauToolHolder.TauTrackRNNClassifierCfg |
( |
|
flags | ) |
|
Definition at line 158 of file TauToolHolder.py.
160 _name = flags.Tau.ActiveConfig.prefix +
'TauTrackRNNClassifier'
163 TauTrackRNNClassifier = CompFactory.tauRecTools.TauTrackRNNClassifier
166 cppyy.load_library(
'libxAODTau_cDict')
169 if flags.Tau.associateLRT
and not flags.Tau.classifyLRT:
172 myTauTrackClassifier = TauTrackRNNClassifier( name = _name,
174 classifyLRT = _classifyLRT )
176 result.setPrivateTools(myTauTrackClassifier)
◆ TauVertexedClusterDecoratorCfg()
def TauToolHolder.TauVertexedClusterDecoratorCfg |
( |
|
flags | ) |
|
Definition at line 133 of file TauToolHolder.py.
135 _name = flags.Tau.ActiveConfig.prefix +
'TauVertexedClusterDecorator'
137 TauVertexedClusterDecorator = CompFactory.getComp(
"TauVertexedClusterDecorator")
139 SeedJet = flags.Tau.ActiveConfig.SeedJetCollection)
141 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 AssociatedTracks=
"GhostTrack",
46 Key_trackPartInputContainer= flags.Tau.ActiveConfig.TrackCollection,
47 Key_vertexInputContainer = flags.Tau.ActiveConfig.VertexCollection,
49 inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
52 result.setPrivateTools(TauVertexFinder)
◆ TauVertexVariablesCfg()
def TauToolHolder.TauVertexVariablesCfg |
( |
|
flags | ) |
|
Tau Vertex Variables.
Definition at line 645 of file TauToolHolder.py.
647 _name = flags.Tau.ActiveConfig.prefix +
'TauVertexVariables'
649 from TrkConfig.TrkVertexFittersConfig
import TauAdaptiveVertexFitterCfg
650 from TrkConfig.TrkVertexSeedFinderToolsConfig
import (
651 CrossDistancesSeedFinderCfg)
653 TauVertexVariables = CompFactory.getComp(
"TauVertexVariables")
658 result.setPrivateTools(TauVertexVariables)
◆ TauWPDecoratorEleRNNCfg()
def TauToolHolder.TauWPDecoratorEleRNNCfg |
( |
|
flags | ) |
|
Definition at line 854 of file TauToolHolder.py.
855 import PyUtils.RootUtils
as ru
856 ROOT = ru.import_root()
858 cppyy.load_library(
'libxAODTau_cDict')
861 _name = flags.Tau.ActiveConfig.prefix +
'TauWPDecoratorEleRNN'
863 TauWPDecorator = CompFactory.getComp(
"TauWPDecorator")
864 WPConf = flags.Tau.TauEleRNNWPConfig
866 flatteningFile1Prong = WPConf[0],
867 flatteningFile3Prong = WPConf[1],
869 [ ROOT.xAOD.TauJetParameters.IsTauFlag.EleRNNLoose,
870 ROOT.xAOD.TauJetParameters.IsTauFlag.EleRNNMedium,
871 ROOT.xAOD.TauJetParameters.IsTauFlag.EleRNNTight ],
872 SigEff1P = [0.95, 0.90, 0.85],
873 SigEff3P = [0.98, 0.95, 0.90],
875 ScoreName =
"RNNEleScore",
876 NewScoreName =
"RNNEleScoreSigTrans",
879 result.setPrivateTools(myTauEleWPDecorator)
◆ TauWPDecoratorEleRNNFixCfg()
def TauToolHolder.TauWPDecoratorEleRNNFixCfg |
( |
|
flags | ) |
|
Definition at line 882 of file TauToolHolder.py.
884 _name = flags.Tau.ActiveConfig.prefix +
'TauWPDecoratorEleRNNFix_v1'
886 TauWPDecorator = CompFactory.getComp(
"TauWPDecorator")
887 WPConf = flags.Tau.TauEleRNNWPfix
889 flatteningFile1Prong = WPConf[0],
890 flatteningFile3Prong = WPConf[1],
891 DecorWPNames = [
"EleRNNLoose_v1",
"EleRNNMedium_v1",
"EleRNNTight_v1" ],
892 DecorWPCutEffs1P = [0.95, 0.90, 0.85],
893 DecorWPCutEffs3P = [0.98, 0.95, 0.90],
895 ScoreName =
"RNNEleScore",
896 NewScoreName =
"RNNEleScoreSigTrans_v1",
899 result.setPrivateTools(myTauEleWPDecorator)
◆ TauWPDecoratorGNNCfg()
def TauToolHolder.TauWPDecoratorGNNCfg |
( |
|
flags, |
|
|
|
version |
|
) |
| |
Definition at line 811 of file TauToolHolder.py.
813 _name = flags.Tau.ActiveConfig.prefix +
'TauWPDecoratorGNN_v' +
str(version)
815 TauWPDecorator = CompFactory.getComp(
"TauWPDecorator")
816 WPConf = flags.Tau.TauGNNWP[version]
818 flatteningFile1Prong = WPConf[0],
819 flatteningFile2Prong = WPConf[1],
820 flatteningFile3Prong = WPConf[2],
821 DecorWPNames = flags.Tau.GNTauDecorWPNames[version],
822 DecorWPCutEffs1P = [0.95, 0.85, 0.75, 0.60],
823 DecorWPCutEffs2P = [0.95, 0.75, 0.60, 0.45],
824 DecorWPCutEffs3P = [0.95, 0.75, 0.60, 0.45],
825 ScoreName = flags.Tau.GNTauScoreName[version],
826 NewScoreName = flags.Tau.GNTauTransScoreName[version],
828 result.setPrivateTools(myTauWPDecorator)
◆ TauWPDecoratorJetRNNCfg()
def TauToolHolder.TauWPDecoratorJetRNNCfg |
( |
|
flags | ) |
|
Definition at line 755 of file TauToolHolder.py.
756 import PyUtils.RootUtils
as ru
757 ROOT = ru.import_root()
759 cppyy.load_library(
'libxAODTau_cDict')
762 _name = flags.Tau.ActiveConfig.prefix +
'TauWPDecoratorJetRNN'
764 TauWPDecorator = CompFactory.getComp(
"TauWPDecorator")
765 WPConf = flags.Tau.TauJetRNNWPConfig
767 flatteningFile1Prong = WPConf[0],
768 flatteningFile2Prong = WPConf[1],
769 flatteningFile3Prong = WPConf[2],
771 [ ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigVeryLoose,
772 ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigLoose,
773 ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigMedium,
774 ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigTight ],
775 SigEff1P = [0.95, 0.85, 0.75, 0.60],
776 SigEff2P = [0.95, 0.75, 0.60, 0.45],
777 SigEff3P = [0.95, 0.75, 0.60, 0.45],
778 ScoreName =
"RNNJetScore",
779 NewScoreName =
"RNNJetScoreSigTrans",
782 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)