def getTauShotFinder():
_name = sPrefix + 'TauShotFinder'
if _name in cached_instances:
return cached_instances[_name]
#from CaloRec.CaloRecConf import CaloCellContainerFinalizerTool
#TauCellContainerFinalizer = CaloCellContainerFinalizerTool(name=sPrefix+'tauShotCellContainerFinalizer')
#from AthenaCommon.AppMgr import ToolSvc
#ToolSvc += TauCellContainerFinalizer
from tauRecTools.tauRecToolsConf import TauShotFinder
TauShotFinder = TauShotFinder(name = _name,
CaloWeightTool = getCellWeightTool(),
ReaderOption = "Silent:!Color",
BDTWeightFile_barrel = "TauShotsBDTWeights.xml",
BDTWeightFile_endcap1 = "TauShotsBDTWeights.xml",
BDTWeightFile_endcap2 = "TauShotsBDTWeights.xml",
NCellsInEta = 5,
MinPtCut = (400.*MeV,320.*MeV,9999999.*MeV,350.*MeV,320.*MeV),
AutoDoubleShotCut = (10000.*MeV,10000.*MeV,9999999.*MeV,10000.*MeV,10000.*MeV),
MergedBDTScoreCut = (-9999999.,-9999999.,-9999999.,-9999999.,-9999999.),
)
cached_instances[_name] = TauShotFinder
return TauShotFinder
def getBonnPi0ClusterFinder():
_name = sPrefix + 'BonnPi0ClusterFinder'
if _name in cached_instances:
return cached_instances[_name]
from CaloRec.CaloRecConf import CaloCellContainerFinalizerTool
TauCellContainerFinalizer = CaloCellContainerFinalizerTool(name=sPrefix+'tauPi0CellContainerFinalizer')
from AthenaCommon.AppMgr import ToolSvc
ToolSvc += TauCellContainerFinalizer
from tauRecTools.tauRecToolsConf import TauPi0BonnCreateROI
TauPi0BonnCreateROI = TauPi0BonnCreateROI(name = _name,
CaloWeightTool = getCellWeightTool(),
CellMakerTool = TauCellContainerFinalizer,
#LonParFile = "longitudinal_para.dat",
#LatParFile = "lateral_para.dat",
LatParFile = "lateral_para.root",
#OriginCorrectionTool = getTauCellCorrection(),
ChargedPFOContainerName = 'TauPi0BonnChargedPFOContainer',
)
cached_instances[_name] = TauPi0BonnCreateROI
return TauPi0BonnCreateROI
def getStandardCalibTool(doAtlfastII=False):
# define here name of H1 calib tool
#finder = "Cone"
finder = "AntiKt"
mainparam = 0.4
input = "Topo"
#def getCellWeightTool(finder="Cone",mainparam=0.4,input="Topo")
cellcalibtool = getCellWeightTool(finder, mainparam, input, True)
return cellcalibtool
def getJetBadChanCorrTool(finder, mainParam, input, **options):
options = checkAndUpdateOptions(finder=finder,
mainParam=mainParam,
input=input,
**options)
from JetMomentTools.JetMomentToolsConf import JetBadChanCorrTool
from CaloClusterCorrection.StandardCellWeightCalib import getCellWeightTool
cellcalibtool = getCellWeightTool(options['finder'],
options['mainParam'],
input,
onlyCellWeight=True)
coneSize = options['mainParam']
BadChanCorrT = JetBadChanCorrTool("JetBadChanCorrTool")
# Explicitly list flags
BadChanCorrT.ConeDr = coneSize
BadChanCorrT.CellCalibrator = cellcalibtool
BadChanCorrT.UseCalibScale = False
BadChanCorrT.AttachCorrCell = True
BadChanCorrT.AttachCorrDOTX = True
BadChanCorrT.AttachCorrJet = True
BadChanCorrT.MissingCellTool = getDefaultMissingCellTool(coneSize)
# Optional
BadChanCorrT.AttachCorrJetForCell = False
if options['addJetQualityMoments'] == True:
BadChanCorrT.AttachCorrJetForCell = True
# new setup for THistService
import os
dataPathList = os.environ['DATAPATH'].split(os.pathsep)
dataPathList.insert(0, os.curdir)
from AthenaCommon.Utils.unixtools import FindFile
RefFileName = FindFile("JetBadChanCorrTool.root", dataPathList, os.R_OK)
from AthenaCommon.AppMgr import ServiceMgr
if not hasattr(ServiceMgr, 'THistSvc'):
from GaudiSvc.GaudiSvcConf import THistSvc
ServiceMgr += THistSvc()
ServiceMgr.THistSvc.Input += [
"JetBadChanCorrTool DATAFILE=\'%s\' OPT=\'READ\'" % RefFileName
]
return BadChanCorrT
def getTauShotFinder():
_name = sPrefix + 'TauShotFinder'
if _name in cached_instances:
return cached_instances[_name]
from tauRecTools.tauRecToolsConf import TauShotFinder
TauShotFinder = TauShotFinder(
name=_name,
CaloWeightTool=getCellWeightTool(),
NCellsInEta=5,
MinPtCut=(400. * MeV, 320. * MeV, 9999999. * MeV, 350. * MeV,
320. * MeV),
AutoDoubleShotCut=(10000. * MeV, 10000. * MeV, 9999999. * MeV,
10000. * MeV, 10000. * MeV),
)
cached_instances[_name] = TauShotFinder
return TauShotFinder
def getTauShotFinder():
_name = sPrefix + 'TauShotFinder'
if _name in cached_instances:
return cached_instances[_name]
from tauRec.tauRecFlags import jobproperties
shotPtCut_1Photon = jobproperties.tauRecFlags.shotPtCut_1Photon()
shotPtCut_2Photons = jobproperties.tauRecFlags.shotPtCut_2Photons()
from tauRecTools.tauRecToolsConf import TauShotFinder
TauShotFinder = TauShotFinder(name=_name,
CaloWeightTool=getCellWeightTool(),
NCellsInEta=5,
MinPtCut=shotPtCut_1Photon,
AutoDoubleShotCut=shotPtCut_2Photons,
Key_caloCellInputContainer="AllCalo")
cached_instances[_name] = TauShotFinder
return TauShotFinder
def getCellWeightTool():
_name = sPrefix + 'CellWeightTool'
if _name in cached_instances:
return cached_instances[_name]
#from CaloClusterCorrection.CaloClusterCorrectionConf import H1WeightToolCSC12Generic
from CaloRec.CaloTopoClusterFlags import jobproperties
# -- auto configure weight tool
finder = jobproperties.CaloTopoClusterFlags.cellWeightRefFinder.get_Value()
size = jobproperties.CaloTopoClusterFlags.cellWeightRefSize.get_Value()
signal = jobproperties.CaloTopoClusterFlags.cellWeightRefSignal.get_Value()
from CaloClusterCorrection.StandardCellWeightCalib import getCellWeightTool
CaloWeightTool = getCellWeightTool(finder,size,signal)
from AthenaCommon.AppMgr import ToolSvc
ToolSvc += CaloWeightTool
cached_instances[_name] = CaloWeightTool
return CaloWeightTool
def getJetBadChanCorrTool(finder, mainParam, input, **options):
options=checkAndUpdateOptions(finder=finder, mainParam=mainParam, input=input, **options)
from JetMomentTools.JetMomentToolsConf import JetBadChanCorrTool
from CaloClusterCorrection.StandardCellWeightCalib import getCellWeightTool
cellcalibtool = getCellWeightTool(options['finder'], options['mainParam'], input, onlyCellWeight=True)
coneSize = options['mainParam']
BadChanCorrT = JetBadChanCorrTool("JetBadChanCorrTool")
# Explicitly list flags
BadChanCorrT.ConeDr = coneSize
BadChanCorrT.CellCalibrator = cellcalibtool
BadChanCorrT.UseCalibScale = False
BadChanCorrT.AttachCorrCell = True
BadChanCorrT.AttachCorrDOTX = True
BadChanCorrT.AttachCorrJet = True
BadChanCorrT.MissingCellTool = getDefaultMissingCellTool(coneSize)
# Optional
BadChanCorrT.AttachCorrJetForCell = False
if options['addJetQualityMoments'] == True:
BadChanCorrT.AttachCorrJetForCell = True
# new setup for THistService
import os
dataPathList = os.environ[ 'DATAPATH' ].split(os.pathsep)
dataPathList.insert(0, os.curdir)
from AthenaCommon.Utils.unixtools import FindFile
RefFileName = FindFile( "JetBadChanCorrTool.root" ,dataPathList, os.R_OK )
from AthenaCommon.AppMgr import ServiceMgr
if not hasattr(ServiceMgr, 'THistSvc'):
from GaudiSvc.GaudiSvcConf import THistSvc
ServiceMgr += THistSvc()
ServiceMgr.THistSvc.Input += ["JetBadChanCorrTool DATAFILE=\'%s\' OPT=\'READ\'" % RefFileName]
return BadChanCorrT
theCaloNoiseTool = CaloNoiseToolDefault()
from AthenaCommon.AppMgr import ToolSvc
ToolSvc += theCaloNoiseTool
# configure cell weight calibration
if jobproperties.CaloTopoClusterFlags.doCellWeightCalib():
from CaloClusterCorrection.CaloClusterCorrectionConf import H1WeightToolCSC12Generic
from CaloClusterCorrection.StandardCellWeightCalib import H1Calibration, getCellWeightTool
CellWeights = CaloClusterCellWeightCalib("CellWeights")
# -- configure weight tool
finder = jobproperties.CaloTopoClusterFlags.cellWeightRefFinder.get_Value()
size = jobproperties.CaloTopoClusterFlags.cellWeightRefSize.get_Value()
signal = jobproperties.CaloTopoClusterFlags.cellWeightRefSignal.get_Value()
WeightTool = getCellWeightTool(finder, size, signal)
# -- connect weight tool
CellWeights.CellSignalWeightTool = WeightTool
CellWeights += WeightTool
#-- default properties
CellWeights.Direction = "AbsSignal" #-- use absolute cell energies for eta/phi calculation
CellWeights.BelowThresholdLikeAll = True #-- treat clusters below thresholds the same as all others
CellWeights.BelowThresholdDirection = "AbsSignal" #-- alternative direction calculation for below threshold clusters,
# ignored if BelowThresholdLikeAll = True
CellWeights.EnergyThreshold = 0.0 * MeV #-- threshold for possible change of direction calculation
CellWeights.IgnoreGeoWeights = False #-- ignore geometrical cell signal weights if True
# now configure local hadronic calibration
if jobproperties.CaloTopoClusterFlags.doTopoClusterLocalCalib():
# tools used by tools
# EMFrac = EMFracClusterClassificationTool("EMFrac")
include.block( "MissingETGoodness/JetVarTool_jobOptions.py" )
###############################################
from RecExConfig.ObjKeyStore import cfgKeyStore
if cfgKeyStore.isInInput ('CaloCellContainer', 'AllCalo'):
from JetRecTools.JetRecToolsConf import *
from JetRec.JetMomentGetter import make_JetMomentGetter
from JetRec.JetGetters import *
from JetRec.JetRecFlags import jetFlags
from CaloClusterCorrection.StandardCellWeightCalib import getCellWeightTool
cellcalibtool = getCellWeightTool('Kt', 0.4, 'Topo', onlyCellWeight=True)
jetFlags.doJVF = False ##the following jet getter seems to fail if we don't deactivate the jet vertex finder.
make_StandardJetGetter('AntiKt',0.4,'Topo',disable=False, doCalib=True, calibName='H1NumInv', outputCollectionName='AntiKt4TopoJets')
make_StandardJetGetter('AntiKt',0.6,'Topo',disable=False, doCalib=True, calibName='H1NumInv', outputCollectionName='AntiKt6TopoJets')
atool4 = JetBadChanCorrTool("JetBadChanCorrTool_anti04",UpdateEvery=False,ConeDr=0.4,UseCalibScale=False)
atool4.CellCalibrator = cellcalibtool
atool6 = JetBadChanCorrTool("JetBadChanCorrTool_anti06",UpdateEvery=False,ConeDr=0.6,UseCalibScale=False)
atool6.CellCalibrator = cellcalibtool
cqual_tool = JetCaloQualityTool("CaloQualTool")
cqual_tool.doSamplingBasedVariables=True
cqual_tool.doCellBasedVariables=True
BadCellCorrT = JetBadCellCorrTool("JetBadCellCorrTool")
def JetVarToolConfig(seq=AlgSequence):
from RecExConfig.ObjKeyStore import cfgKeyStore
if (cfgKeyStore.isInInput('CaloCellContainer', 'AllCalo')
and cfgKeyStore.isInInput('CaloCellLinkContainer',
'CaloCalTopoCluster_Link')):
from JetRec.JetMomentGetter import make_JetMomentGetter
from JetRec.JetRecFlags import jetFlags
from CaloClusterCorrection.StandardCellWeightCalib import getCellWeightTool
cellcalibtool = getCellWeightTool('Kt',
0.4,
'Topo',
onlyCellWeight=True)
jetFlags.doJVF = False ##the following jet getter seems to fail if we don't deactivate the jet vertex finder.
#make_StandardJetGetter('AntiKt',0.4,'Topo',disable=False, doCalib=True, calibName='H1NumInv', outputCollectionName='AntiKt4TopoJets',seq=seq)
#make_StandardJetGetter('AntiKt',0.6,'Topo',disable=False, doCalib=True, calibName='H1NumInv', outputCollectionName='AntiKt6TopoJets',seq=seq)
# MB: April 19, 2011, Suggested fix from SS
make_StandardJetGetter('AntiKt',
0.4,
'Topo',
disable=False,
doCalib=True,
calibName='EM:H1NumInv',
outputCollectionName='AntiKt4TopoJets',
seq=seq)
make_StandardJetGetter('AntiKt',
0.6,
'Topo',
disable=False,
doCalib=True,
calibName='EM:H1NumInv',
outputCollectionName='AntiKt6TopoJets',
seq=seq)
# MB: April 7, 2011 : Suggested fix from SS
from JetMomentTools.JetMomentToolsConf import \
JetBadChanCorrTool, JetBadCellCorrTool, JetCaloQualityTool
atool4 = JetBadChanCorrTool("JetBadChanCorrTool_anti04",
ConeDr=0.4,
UseCalibScale=False)
atool4.CellCalibrator = cellcalibtool
atool6 = JetBadChanCorrTool("JetBadChanCorrTool_anti06",
ConeDr=0.6,
UseCalibScale=False)
atool6.CellCalibrator = cellcalibtool
#atool4 = JetBadChanCorrTool("JetBadChanCorrTool_anti04",UpdateEvery=False,ConeDr=0.4,UseCalibScale=False)
#atool4.CellCalibrator = cellcalibtool
#atool6 = JetBadChanCorrTool("JetBadChanCorrTool_anti06",UpdateEvery=False,ConeDr=0.6,UseCalibScale=False)
#atool6.CellCalibrator = cellcalibtool
cqual_tool = JetCaloQualityTool("CaloQualTool")
cqual_tool.doSamplingBasedVariables = True
cqual_tool.doCellBasedVariables = True
BadCellCorrT = JetBadCellCorrTool("JetBadCellCorrTool")
BadCellCorrT.CellCalibrator = cellcalibtool
##print BadCellCorrT
##toolist += [BadCellCorrT]
make_JetMomentGetter("AntiKt4TopoJets",
[atool4, cqual_tool, BadCellCorrT],
seq=seq)
make_JetMomentGetter("AntiKt6TopoJets",
[atool6, cqual_tool, BadCellCorrT],
seq=seq)
else:
from AthenaCommon.Logging import logging
log = logging.getLogger('MissingETGoodness')
log.warning('No cells; not rebuilding jets.')
###############################################
jet_collection_key = 'AntiKt4TopoJets'
if cfgKeyStore.isInInput('JetCollection', 'AntiKt4TopoEMJets'):
jet_collection_key = 'AntiKt4TopoEMJets'
truth_jet_collection_key = 'Cone4TruthJets'
if cfgKeyStore.isInInput('JetCollection', 'AntiKt4TruthJets'):
truth_jet_collection_key = 'AntiKt4TruthJets'
from MissingETGoodness.MissingETGoodnessConf import JetVarTool as ConfiguredJetVarTool
JetVarTool = ConfiguredJetVarTool(
JetCollectionKey=jet_collection_key,
JetTruthCollectionKey=truth_jet_collection_key,
TrackParticleContainerKey='TrackParticleCandidate',
)
from AthenaCommon.AppMgr import ToolSvc
ToolSvc += JetVarTool
print JetVarTool
def configure(self):
mlog = logging.getLogger('CaloClusterTopoGetter::configure :')
mlog.info('scheduled to output %s', self.output())
# get handle to upstream object
theCaloCellGetter = self.getInputGetter\
(jp.CaloRecFlags.clusterCellGetterName())
# configure cell weight calibration
if jobproperties.CaloTopoClusterFlags.doCellWeightCalib():
from CaloClusterCorrection.CaloClusterCorrectionConf import H1WeightToolCSC12Generic
from CaloClusterCorrection.StandardCellWeightCalib import H1Calibration, getCellWeightTool
CellWeights = CaloClusterCellWeightCalib("CellWeights")
# -- configure weight tool
finder = jobproperties.CaloTopoClusterFlags.cellWeightRefFinder.get_Value(
)
size = jobproperties.CaloTopoClusterFlags.cellWeightRefSize.get_Value(
)
signal = jobproperties.CaloTopoClusterFlags.cellWeightRefSignal.get_Value(
)
WeightTool = getCellWeightTool(finder, size, signal)
# -- connect weight tool
CellWeights.CellSignalWeightTool = WeightTool
CellWeights += WeightTool
#-- default properties
CellWeights.Direction = "AbsSignal" #-- use absolute cell energies for eta/phi calculation
CellWeights.BelowThresholdLikeAll = True #-- treat clusters below thresholds the same as all others
CellWeights.BelowThresholdDirection = "AbsSignal" #-- alternative direction calculation for below threshold clusters,
# ignored if BelowThresholdLikeAll = True
CellWeights.EnergyThreshold = 0.0 * MeV #-- threshold for possible change of direction calculation
CellWeights.IgnoreGeoWeights = False #-- ignore geometrical cell signal weights if True
# now configure local hadronic calibration
if jobproperties.CaloTopoClusterFlags.doTopoClusterLocalCalib():
# tools used by tools
# EMFrac = EMFracClusterClassificationTool("EMFrac")
# EMFrac.ClassificationKey = "EMFracClassify"
# EMFrac.UseEMFractionSpread = False
# EMFrac.MaxEMFraction = 0.5
#
# H1Weight = H1ClusterCellWeightTool("H1Weight")
# H1Weight.CorrectionKey = "H1ClusterCellWeights"
# H1Weight.SignalOverNoiseCut = 2.0
# H1Weight.CaloNoiseTool = theCaloNoiseTool
#
# OOCC = OutOfClusterCorrectionTool("OOCC")
# OOCC.CorrectionKey = "OOCCorrection"
#
# OOCCPi0 = OutOfClusterCorrectionTool("OOCCPi0")
# OOCCPi0.CorrectionKey = "OOCPi0Correction"
# tools used by tools
LCClassify = CaloLCClassificationTool("LCClassify")
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 = jobproperties.CaloTopoClusterFlags.doTreatEnergyCutAsAbsolute(
)
LCWeight = CaloLCWeightTool("LCWeight")
LCWeight.CorrectionKey = "H1ClusterCellWeights"
LCWeight.SignalOverNoiseCut = 2.0
LCWeight.CaloNoiseTool = theCaloNoiseTool
LCWeight.UseHadProbability = True
LCOut = CaloLCOutOfClusterTool("LCOut")
LCOut.CorrectionKey = "OOCCorrection"
LCOut.UseEmProbability = False
LCOut.UseHadProbability = True
LCOutPi0 = CaloLCOutOfClusterTool("LCOutPi0")
LCOutPi0.CorrectionKey = "OOCPi0Correction"
LCOutPi0.UseEmProbability = True
LCOutPi0.UseHadProbability = False
#DMTool = DeadMaterialCorrectionTool2("DMTool")
#DMTool.HadDMCoeffKey = "HadDMCoeff2"
#DMTool.SignalOverNoiseCut = 1.0
#DMTool.ClusterRecoStatus = 0
#DMTool.WeightModeDM = 2
#DMTool.CaloNoiseTool = theCaloNoiseTool
LCDeadMaterial = CaloLCDeadMaterialTool("LCDeadMaterial")
LCDeadMaterial.HadDMCoeffKey = "HadDMCoeff2"
LCDeadMaterial.ClusterRecoStatus = 0
LCDeadMaterial.WeightModeDM = 2
LCDeadMaterial.UseHadProbability = True
LCDeadMaterial.WeightingOfNegClusters = jobproperties.CaloTopoClusterFlags.doTreatEnergyCutAsAbsolute(
)
# correction tools using tools
LocalCalib = CaloClusterLocalCalib("LocalCalib")
LocalCalib.ClusterClassificationTool = [LCClassify]
#LocalCalib.ClusterRecoStatus = [2]
LocalCalib.ClusterRecoStatus = [1, 2]
LocalCalib.LocalCalibTools = [LCWeight]
LocalCalib.WeightingOfNegClusters = jobproperties.CaloTopoClusterFlags.doTreatEnergyCutAsAbsolute(
)
LocalCalib += LCClassify
LocalCalib += LCWeight
OOCCalib = CaloClusterLocalCalib("OOCCalib")
#OOCCalib.ClusterRecoStatus = [2]
OOCCalib.ClusterRecoStatus = [1, 2]
OOCCalib.LocalCalibTools = [LCOut]
OOCCalib.WeightingOfNegClusters = jobproperties.CaloTopoClusterFlags.doTreatEnergyCutAsAbsolute(
)
OOCCalib += LCOut
OOCPi0Calib = CaloClusterLocalCalib("OOCPi0Calib")
#OOCPi0Calib.ClusterRecoStatus = [1]
OOCPi0Calib.ClusterRecoStatus = [1, 2]
OOCPi0Calib.LocalCalibTools = [LCOutPi0]
OOCPi0Calib.WeightingOfNegClusters = jobproperties.CaloTopoClusterFlags.doTreatEnergyCutAsAbsolute(
)
OOCPi0Calib += LCOutPi0
DMCalib = CaloClusterLocalCalib("DMCalib")
DMCalib.ClusterRecoStatus = [1, 2]
#DMCalib.LocalCalibToolNames = [DMTool.getFullName()]
#DMCalib += DMTool
DMCalib.LocalCalibTools = [LCDeadMaterial]
DMCalib.WeightingOfNegClusters = jobproperties.CaloTopoClusterFlags.doTreatEnergyCutAsAbsolute(
)
DMCalib += LCDeadMaterial
# correction tools not using tools
TopoMoments = CaloClusterMomentsMaker("TopoMoments")
TopoMoments.WeightingOfNegClusters = jobproperties.CaloTopoClusterFlags.doTreatEnergyCutAsAbsolute(
)
TopoMoments.MaxAxisAngle = 20 * deg
TopoMoments.CaloNoiseTool = theCaloNoiseTool
TopoMoments.UsePileUpNoise = True
TopoMoments.TwoGaussianNoise = jobproperties.CaloTopoClusterFlags.doTwoGaussianNoise(
)
TopoMoments.MinBadLArQuality = 4000
TopoMoments.MomentsNames = [
"AVG_LAR_Q", "AVG_TILE_Q", "BAD_CELLS_CORR_E", "BADLARQ_FRAC",
"CELL_SIGNIFICANCE", "CELL_SIG_SAMPLING", "CENTER_LAMBDA",
"CENTER_MAG", "CENTER_X", "CENTER_Y", "CENTER_Z", "DELTA_ALPHA",
"DELTA_PHI", "DELTA_THETA", "ENG_BAD_CELLS", "ENG_FRAC_CORE",
"ENG_FRAC_EM", "ENG_FRAC_MAX", "ENG_POS", "FIRST_ENG_DENS",
"FIRST_ETA", "FIRST_PHI", "ISOLATION", "LATERAL", "LONGITUDINAL",
"MASS", "N_BAD_CELLS", "N_BAD_CELLS_CORR", "PTD",
"SECOND_ENG_DENS", "SECOND_LAMBDA", "SECOND_R", "SIGNIFICANCE"
]
doDigiTruthFlag = False
try:
from Digitization.DigitizationFlags import digitizationFlags
doDigiTruthFlag = digitizationFlags.doDigiTruth()
except:
log = logging.getLogger('CaloClusterTopoGetter')
log.info(
'Unable to import DigitizationFlags in CaloClusterTopoGetter. Expected in AthenaP1'
)
if doDigiTruthFlag:
TopoMoments_Truth = CaloClusterMomentsMaker_DigiHSTruth(
"TopoMoments_Truth")
TopoMoments_Truth.WeightingOfNegClusters = jobproperties.CaloTopoClusterFlags.doTreatEnergyCutAsAbsolute(
)
TopoMoments_Truth.MaxAxisAngle = 20 * deg
TopoMoments_Truth.CaloNoiseTool = theCaloNoiseTool
TopoMoments_Truth.UsePileUpNoise = True
TopoMoments_Truth.TwoGaussianNoise = jobproperties.CaloTopoClusterFlags.doTwoGaussianNoise(
)
TopoMoments_Truth.MinBadLArQuality = 4000
TopoMoments_Truth.MomentsNames = [
"FIRST_PHI_DigiHSTruth", "FIRST_ETA_DigiHSTruth",
"SECOND_R_DigiHSTruth", "SECOND_LAMBDA_DigiHSTruth",
"DELTA_PHI_DigiHSTruth", "DELTA_THETA_DigiHSTruth",
"DELTA_ALPHA_DigiHSTruth", "CENTER_X_DigiHSTruth",
"CENTER_Y_DigiHSTruth", "CENTER_Z_DigiHSTruth",
"CENTER_MAG_DigiHSTruth", "CENTER_LAMBDA_DigiHSTruth",
"LATERAL_DigiHSTruth", "LONGITUDINAL_DigiHSTruth",
"ENG_FRAC_CORE_DigiHSTruth", "FIRST_ENG_DENS_DigiHSTruth",
"SECOND_ENG_DENS_DigiHSTruth", "ISOLATION_DigiHSTruth",
"BAD_CELLS_CORR_E_DigiHSTruth", "ENG_POS_DigiHSTruth",
"SIGNIFICANCE_DigiHSTruth", "CELL_SIGNIFICANCE_DigiHSTruth",
"CELL_SIG_SAMPLING_DigiHSTruth", "AVG_LAR_Q_DigiHSTruth",
"AVG_TILE_Q_DigiHSTruth", "ENERGY_DigiHSTruth",
"PHI_DigiHSTruth", "ETA_DigiHSTruth"
]
# only add HV related moments if it is offline.
from IOVDbSvc.CondDB import conddb
if not conddb.isOnline:
from LArRecUtils.LArHVScaleRetrieverDefault import LArHVScaleRetrieverDefault
TopoMoments.LArHVScaleRetriever = LArHVScaleRetrieverDefault()
TopoMoments.MomentsNames += ["ENG_BAD_HV_CELLS", "N_BAD_HV_CELLS"]
# TopoMoments.AODMomentsNames = ["LATERAL"
# ,"LONGITUDINAL"
# ,"SECOND_R"
# ,"SECOND_LAMBDA"
# ,"CENTER_MAG"
# ,"CENTER_LAMBDA"
# ,"FIRST_ENG_DENS"
# ,"ENG_FRAC_MAX"
# ,"ISOLATION"
# ,"ENG_BAD_CELLS"
# ,"N_BAD_CELLS"
# ,"BADLARQ_FRAC"
# ,"ENG_POS"
# ,"SIGNIFICANCE"
# ,"CELL_SIGNIFICANCE"
# ,"CELL_SIG_SAMPLING"
# ,"AVG_LAR_Q"
# ,"AVG_TILE_Q"
# ]
#if jobproperties.CaloTopoClusterFlags.lockTopoClusterSamplingEnergies() or jobproperties.CaloTopoClusterFlags.lockTopoClusterSamplingVariables():
# LockVariables = CaloClusterLockVars("LockVariables")
# LockVariables.FixBasicEnergy = True
# LockVariables.LockedSamplingVariables = []
# if jobproperties.CaloTopoClusterFlags.lockTopoClusterSamplingEnergies():
# LockVariables.LockedSamplingVariables += [
# "Energy", "Max_Energy"]
# if jobproperties.CaloTopoClusterFlags.lockTopoClusterSamplingVariables():
# LockVariables.LockedSamplingVariables += [
# "Eta", "Phi", "Delta_Eta",
# "Delta_Phi", "Max_Eta", "Max_Phi"
# ]
#if jobproperties.CaloTopoClusterFlags.printTopoClusters():
# PrintCaloCluster = CaloClusterPrinter("PrintCaloCluster")
# PrintCaloCluster.PrintFirstOnly = True
# PrintCaloCluster.PrintFrequency = 1
# PrintCaloCluster.EnergyUnit = 1.0*GeV
theCaloClusterSnapshot = CaloClusterSnapshot(
OutputName="CaloTopoCluster", SetCrossLinks=True)
# maker tools
TopoMaker = CaloTopoClusterMaker("TopoMaker")
TopoMaker.CellsName = theCaloCellGetter.outputKey()
TopoMaker.CalorimeterNames = ["LAREM", "LARHEC", "LARFCAL", "TILE"]
# cells from the following samplings will be able to form
# seeds. By default no sampling is excluded
TopoMaker.SeedSamplingNames = [
"PreSamplerB", "EMB1", "EMB2", "EMB3", "PreSamplerE", "EME1",
"EME2", "EME3", "HEC0", "HEC1", "HEC2", "HEC3", "TileBar0",
"TileBar1", "TileBar2", "TileExt0", "TileExt1", "TileExt2",
"TileGap1", "TileGap2", "TileGap3", "FCAL0", "FCAL1", "FCAL2"
]
TopoMaker.CaloNoiseTool = theCaloNoiseTool
TopoMaker.UseCaloNoiseTool = True
TopoMaker.UsePileUpNoise = True
TopoMaker.NeighborOption = "super3D"
TopoMaker.RestrictHECIWandFCalNeighbors = False
TopoMaker.RestrictPSNeighbors = True
TopoMaker.CellThresholdOnEorAbsEinSigma = 0.0
TopoMaker.NeighborThresholdOnEorAbsEinSigma = 2.0
TopoMaker.SeedThresholdOnEorAbsEinSigma = 4.0
#timing
TopoMaker.SeedCutsInT = jobproperties.CaloTopoClusterFlags.doTimeCut()
# note E or AbsE
#
# the following property must be set to TRUE in order to make double
# sided cuts on the seed and the cluster level
#
TopoMaker.SeedCutsInAbsE = True
TopoMaker.ClusterEtorAbsEtCut = 0.0 * MeV
#
# note E or AbsE
#
# by default neighbor and cell thresholds are on AbsE. Set the following
# properties to FALSE in order to switch to cuts on E
#
#TopoMaker.NeighborCutsInAbsE = False
#TopoMaker.CellCutsInAbsE = False
# the following Et thresholds are ignored in case UsePileUpNoise
# is TRUE
#
#
# CellThresholdOnAbsEt = 0.0*MeV
# NeighborThresholdOnAbsEt = 100.0*MeV
# SeedThresholdOnEtorAbsEt = 200.0*MeV
# note Et or AbsEt
# use 2-gaussian or single gaussian noise for TileCal
TopoMaker.TwoGaussianNoise = jobproperties.CaloTopoClusterFlags.doTwoGaussianNoise(
)
TopoSplitter = CaloTopoClusterSplitter("TopoSplitter")
# 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.
#
TopoSplitter.SamplingNames = ["EMB2", "EMB3", "EME2", "EME3", "FCAL0"]
# 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.
#
TopoSplitter.SecondarySamplingNames = [
"EMB1", "EME1", "TileBar0", "TileBar1", "TileBar2", "TileExt0",
"TileExt1", "TileExt2", "HEC0", "HEC1", "HEC2", "HEC3", "FCAL1",
"FCAL2"
]
TopoSplitter.ShareBorderCells = True
TopoSplitter.RestrictHECIWandFCalNeighbors = False
TopoSplitter.WeightingOfNegClusters = jobproperties.CaloTopoClusterFlags.doTreatEnergyCutAsAbsolute(
)
#
# the following options are not set, since these are the default
# values
#
# NeighborOption = "super3D",
# NumberOfCellsCut = 4,
# EnergyCut = 500*MeV,
# cluster maker
CaloTopoCluster = CaloClusterMaker("CaloTopoCluster")
if jobproperties.CaloTopoClusterFlags.doTopoClusterLocalCalib():
CaloTopoCluster.ClustersOutputName = "CaloCalTopoClusters"
else:
CaloTopoCluster.ClustersOutputName = "CaloTopoCluster"
CaloTopoCluster.ClusterMakerTools = [TopoMaker, TopoSplitter]
from CaloClusterCorrection.CaloClusterBadChannelListCorr import CaloClusterBadChannelListCorr
BadChannelListCorr = CaloClusterBadChannelListCorr()
CaloTopoCluster.ClusterCorrectionTools += [BadChannelListCorr]
CaloTopoCluster.ClusterCorrectionTools += [TopoMoments]
if doDigiTruthFlag:
CaloTopoCluster.ClusterCorrectionTools += [TopoMoments_Truth]
CaloTopoCluster += TopoMaker
CaloTopoCluster += TopoSplitter
CaloTopoCluster += BadChannelListCorr
CaloTopoCluster += TopoMoments
if doDigiTruthFlag:
CaloTopoCluster += TopoMoments_Truth
if jobproperties.CaloTopoClusterFlags.doClusterVertexFraction():
from CaloTrackUtils.CaloTrackUtilsConf import CaloClusterVertexFractionMaker
MyCaloClusterVertexFractionMaker = CaloClusterVertexFractionMaker(
name="CaloClusterVertexFractionMaker",
VxContainerName="VxPrimaryCandidate",
dRMatchMax=0.17)
CaloTopoCluster.ClusterCorrectionTools += [
MyCaloClusterVertexFractionMaker
]
CaloTopoCluster += MyCaloClusterVertexFractionMaker
if jobproperties.CaloTopoClusterFlags.doCalibHitMoments(
) and rec.doTruth():
from CaloCalibHitRec.CaloCalibHitRecConf import CaloCalibClusterMomentsMaker2
TopoCalibMoments = CaloCalibClusterMomentsMaker2(
"TopoCalibMoments")
TopoCalibMoments.MomentsNames = [
"ENG_CALIB_TOT",
"ENG_CALIB_OUT_L"
#,"ENG_CALIB_OUT_M"
# ,"ENG_CALIB_OUT_T"
# ,"ENG_CALIB_DEAD_L"
# ,"ENG_CALIB_DEAD_M"
# ,"ENG_CALIB_DEAD_T"
,
"ENG_CALIB_EMB0",
"ENG_CALIB_EME0",
"ENG_CALIB_TILEG3",
"ENG_CALIB_DEAD_TOT",
"ENG_CALIB_DEAD_EMB0",
"ENG_CALIB_DEAD_TILE0",
"ENG_CALIB_DEAD_TILEG3",
"ENG_CALIB_DEAD_EME0",
"ENG_CALIB_DEAD_HEC0",
"ENG_CALIB_DEAD_FCAL",
"ENG_CALIB_DEAD_LEAKAGE",
"ENG_CALIB_DEAD_UNCLASS",
"ENG_CALIB_FRAC_EM",
"ENG_CALIB_FRAC_HAD",
"ENG_CALIB_FRAC_REST"
]
# TopoCalibMoments.AODMomentsNames = ["ENG_CALIB_TOT"
# ,"ENG_CALIB_OUT_L"
# #,"ENG_CALIB_OUT_M"
# # ,"ENG_CALIB_OUT_T"
# # ,"ENG_CALIB_DEAD_L"
# # ,"ENG_CALIB_DEAD_M"
# # ,"ENG_CALIB_DEAD_T"
# ,"ENG_CALIB_EMB0"
# ,"ENG_CALIB_EME0"
# ,"ENG_CALIB_TILEG3"
# ,"ENG_CALIB_DEAD_TOT"
# ,"ENG_CALIB_DEAD_EMB0"
# ,"ENG_CALIB_DEAD_TILE0"
# ,"ENG_CALIB_DEAD_TILEG3"
# ,"ENG_CALIB_DEAD_EME0"
# ,"ENG_CALIB_DEAD_HEC0"
# ,"ENG_CALIB_DEAD_FCAL"
# ,"ENG_CALIB_DEAD_LEAKAGE"
# ,"ENG_CALIB_DEAD_UNCLASS"
# ,"ENG_CALIB_FRAC_EM"
# ,"ENG_CALIB_FRAC_HAD"
# ,"ENG_CALIB_FRAC_REST"]
TopoCalibMoments.CalibrationHitContainerNames = [
"LArCalibrationHitInactive", "LArCalibrationHitActive",
"TileCalibHitActiveCell", "TileCalibHitInactiveCell"
]
TopoCalibMoments.DMCalibrationHitContainerNames = [
"LArCalibrationHitDeadMaterial", "TileCalibHitDeadMaterial"
]
CaloTopoCluster.ClusterCorrectionTools += [TopoCalibMoments]
CaloTopoCluster += TopoCalibMoments
#if jobproperties.CaloTopoClusterFlags.lockTopoClusterSamplingEnergies() or jobproperties.CaloTopoClusterFlags.lockTopoClusterSamplingVariables():
# CaloTopoCluster.ClusterCorrectionTools += [
# LockVariables.getFullName()]
# CaloTopoCluster += LockVariables
CaloTopoCluster.ClusterCorrectionTools += [theCaloClusterSnapshot]
CaloTopoCluster += theCaloClusterSnapshot
if jobproperties.CaloTopoClusterFlags.doCellWeightCalib():
CaloTopoCluster.ClusterCorrectionTools += [
CellWeights.getFullName()
]
CaloTopoCluster += CellWeights
if jobproperties.CaloTopoClusterFlags.doTopoClusterLocalCalib():
CaloTopoCluster.ClusterCorrectionTools += [
LocalCalib, OOCCalib, OOCPi0Calib, DMCalib
]
CaloTopoCluster += LocalCalib
CaloTopoCluster += OOCCalib
CaloTopoCluster += OOCPi0Calib
CaloTopoCluster += DMCalib
#
# pool/cool part
#
if jobproperties.CaloTopoClusterFlags.doTopoClusterLocalCalib():
from CaloRec import CaloClusterTopoCoolFolder
if globalflags.DetDescrVersion().startswith("Rome"):
CaloTopoCluster.LocalCalib.LCClassify.MaxProbability = 0.85
CaloTopoCluster.LocalCalib.LCClassify.UseNormalizedEnergyDensity = False
else:
CaloTopoCluster.LocalCalib.LCClassify.MaxProbability = 0.50
CaloTopoCluster.LocalCalib.LCClassify.UseNormalizedEnergyDensity = True
self._handle = CaloTopoCluster
objKeyStore.addManyTypesTransient(self.output())
# only write main object in AOD
# 2014-01-15 W.L. Remove objs from output streams b/c of xAOD migration
#objKeyStore.addStreamESD(self.outputType(),self.outputKey())
#objKeyStore.addStreamESD("CaloShowerContainer",self.outputKey()+"_Data")
#objKeyStore.addStreamESD("CaloCellLinkContainer",self.outputKey()+"_Link")
#objKeyStore.addStreamAOD(self.outputType(),self.outputKey())
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
topSequence += CaloTopoCluster
return True