def LArPileUpToolDefault(useLArFloat=True,
isOverlay=False,
outputKey='LArDigitContainer_MC',
outputKey_DigiHSTruth='LArDigitContainer_DigiHSTruth',
name='LArPileUpToolDefault'):
if isOverlay:
#For all other cases, this is already done by LArConditionsCommon_MC_jobOptions.py
from LArRecUtils.LArRecUtilsConf import LArSymConditionsAlg_LArfSamplMC_LArfSamplSym_ as LArfSamplSymAlg
condSeq = AthSequencer("AthCondSeq")
condSeq += LArfSamplSymAlg(ReadKey="LArfSampl",
WriteKey="LArfSamplSym")
try:
from AthenaCommon import CfgGetter
theTool = CfgGetter.getPublicTool("LArPileUpTool")
theTool.DigitContainer = outputKey
theTool.DigitContainer_DigiHSTruth = outputKey_DigiHSTruth
from Digitization.DigitizationFlags import digitizationFlags
theTool.DoDigiTruthReconstruction = digitizationFlags.doDigiTruth()
except Exception as configException:
import traceback
traceback.print_exc()
return theTool
def TileHitVecToCntTool(name="TileHitVecToCntTool", **kwargs):
## FIXME includes to be replaced by confGetter configuration.
from AthenaCommon.Resilience import protectedInclude
protectedInclude(
"CaloDetMgrDetDescrCnv/CaloDetMgrDetDescrCnv_joboptions.py")
protectedInclude("TileConditions/TileConditions_jobOptions.py")
kwargs.setdefault("TileHitVectors", ["TileHitVec", "MBTSHits"])
kwargs.setdefault("TileInfoName", "TileInfo")
kwargs.setdefault("TileHitContainer", "TileHitCnt")
kwargs.setdefault("TileHitContainer_DigiHSTruth", "TileHitCnt_DigiHSTruth")
kwargs.setdefault("DoHSTruthReconstruction",
digitizationFlags.doDigiTruth())
from AthenaCommon.DetFlags import DetFlags
kwargs.setdefault("PileUp", DetFlags.pileup.Tile_on())
from AthenaCommon.BeamFlags import jobproperties
if jobproperties.Beam.beamType == 'cosmics':
kwargs.setdefault("TriggerTimeTool", "CosmicTriggerTimeTool")
kwargs.setdefault("HitTimeFlag", 2)
kwargs.setdefault("UseTriggerTime", True)
if digitizationFlags.doXingByXingPileUp(): # PileUpTool approach
kwargs.setdefault("FirstXing", Tile_FirstXing())
kwargs.setdefault("LastXing", Tile_LastXing())
return CfgMgr.TileHitVecToCntTool(name, **kwargs)
def LArPileUpToolDefault(useLArFloat=True,isOverlay=False,outputKey='LArDigitContainer_MC',outputKey_DigiHSTruth='LArDigitContainer_DigiHSTruth',name='LArPileUpToolDefault'):
try:
from AthenaCommon import CfgGetter
theTool = CfgGetter.getPublicTool("LArPileUpTool")
theTool.DigitContainer = outputKey
theTool.DigitContainer_DigiHSTruth = outputKey_DigiHSTruth
from Digitization.DigitizationFlags import digitizationFlags
theTool.DoDigiTruthReconstruction = digitizationFlags.doDigiTruth()
except Exception as configException:
print configException
print "ERROR Problem with configuration"
return theTool
def configure(self):
mlog = logging.getLogger( 'LArDigitGetter.py::configure :' )
mlog.info ('entering')
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
try:
from AthenaCommon import CfgGetter
# if using new scheme for pileup
from Digitization.DigitizationFlags import digitizationFlags
if digitizationFlags.doXingByXingPileUp():
# Defined in LArDigitizationConfig.py
job.PileUpToolsAlg.PileUpTools += [ CfgGetter.getPrivateTool("LArPileUpTool", checkType=True) ]
job.PileUpToolsAlg.PileUpTools["LArPileUpTool"].DigitContainer = self.outputKey()
job.PileUpToolsAlg.PileUpTools["LArPileUpTool"].DigitContainer_DigiHSTruth = self.outputKey_DigiHSTruth()
job.PileUpToolsAlg.PileUpTools["LArPileUpTool"].DoDigiTruthReconstruction = digitizationFlags.doDigiTruth()
else:
# Defined in LArDigitizationConfig.py
print "call CfgGetter for digitmaker1 "
job += CfgGetter.getAlgorithm("digitmaker1", tryDefaultConfigurable=True)
job.digitmaker1.LArPileUpTool.DigitContainer = self.outputKey()
job.digitmaker1.LArPileUpTool.DigitContainer_DigiHSTruth = self.outputKey_DigiHSTruth()
#job.digitmaker1.LArPileUpTool.DigitContainer_DigiHSTruth = "LArDigitContainer_DigiHSTruth"
job.digitmaker1.LArPileUpTool.DoDigiTruthReconstruction = digitizationFlags.doDigiTruth()
# if pileup or overlay
from AthenaCommon.DetFlags import DetFlags
from LArDigitization.LArDigitizationConfig import isOverlay
if DetFlags.pileup.LAr_on() or isOverlay():
from AthenaCommon.AppMgr import ServiceMgr
# Defined in LArDigitizationConfig.py
ServiceMgr.PileUpMergeSvc.Intervals += [ CfgGetter.getPrivateTool("LArRangeEM", checkType=True) ]
ServiceMgr.PileUpMergeSvc.Intervals += [ CfgGetter.getPrivateTool("LArRangeHEC", checkType=True) ]
ServiceMgr.PileUpMergeSvc.Intervals += [ CfgGetter.getPrivateTool("LArRangeFCAL", checkType=True) ]
except Exception as configException:
print configException
print "ERROR Problem with configuration"
return True
from TileSimAlgs.TileRawChannelFromHitsGetter import *
theTileRawChannelFromHitsGetter=TileRawChannelFromHitsGetter()
if doTileHitToDigit:
from TileSimAlgs.TileDigitsGetter import *
theTileDigitsGetter=TileDigitsGetter()
from TileSimAlgs.TileSimAlgsConf import *
theTileDigitsMaker=TileDigitsMaker()
theTileDigitsMaker.UseCoolPulseShapes=True
theTileDigitsMaker.MaskBadChannels=False
theTileDigitsMaker.RndmEvtOverlay=False
from Digitization.DigitizationFlags import digitizationFlags
theTileDigitsMaker.DoHSTruthReconstruction = digitizationFlags.doDigiTruth()
if doTileDigitsFromPulse:
import traceback
try:
from TileSimAlgs.TileSimAlgsConf import TileDigitsFromPulse
theTileDigitsFromPulse=TileDigitsFromPulse()
mlog.info("Adding TileDigitsFromPulse to topSequence")
## get a handle on the top sequence of algorithms
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
topSequence += theTileDigitsFromPulse;
except:
def configure(self):
mlog = logging.getLogger( 'TileDigitsGetter::configure:' )
mlog.info ('entering')
# get handle to upstream object
try:
from TileSimAlgs.TileDigitsGetter import TileDigitsGetter
theTileDigitsGetter=TileDigitsGetter()
except:
mlog.error("could not get handle to TileDigitsGetter Quit")
print traceback.format_exc()
return False
if not theTileDigitsGetter.usable():
if not self.ignoreConfigError():
mlog.error("TileDigitsGetter unusable. Quit.")
return False
else:
mlog.error("TileDigitsGetter unusable. Continue nevertheless")
from TileConditions.TileInfoConfigurator import TileInfoConfigurator
tileInfoConfigurator = TileInfoConfigurator()
tileInfoConfigurator.setupCOOLPHYPULSE()
# Instantiation of the C++ algorithm
try:
from TileSimAlgs.TileSimAlgsConf import TileDigitsMaker
except:
mlog.error("could not import TileSimAlgs.TileDigitsMaker")
print traceback.format_exc()
return False
theTileDigitsMaker=TileDigitsMaker()
self._TileDigitsMakerHandle = theTileDigitsMaker ;
theTileDigitsMaker.TileHitContainer_DigiHSTruth="TileHitCnt_DigiHSTruth"
from Digitization.DigitizationFlags import digitizationFlags
theTileDigitsMaker.DoHSTruthReconstruction = digitizationFlags.doDigiTruth()
# Configure TileDigitsMaker here
# Check TileDigitization_jobOptions.py for full configurability
theTileDigitsMaker.TileHitContainer="TileHitCnt"
theTileDigitsMaker.TileInfoName="TileInfo"
theTileDigitsMaker.CalibrationRun=False
# Random number engine
theTileDigitsMaker.RndmSvc=digitizationFlags.rndmSvc()
digitizationFlags.rndmSeedList.addSeed("Tile_DigitsMaker", 4789899, 989240512)
# Save integer numbers in digits vector if not pile-up premixing
theTileDigitsMaker.IntegerDigits = not digitizationFlags.PileUpPremixing()
# sets output key
theTileDigitsMaker.TileDigitsContainer=self.outputKey()
# register output in objKeyStore
from RecExConfig.ObjKeyStore import objKeyStore
objKeyStore.addStreamESD(self.outputType(),self.outputKey())
# now add algorithm to topSequence
# this should always come at the end
mlog.info(" now adding to topSequence")
# get a handle on topalg
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
topSequence += theTileDigitsMaker;
return True
# for data09_calophys project, force to use the same quality cut as in BS converter
if globalflags.DataSource() == 'data':
if rec.projectName() == "data09_calophys":
if rec.doTile():
from AthenaCommon.AppMgr import ToolSvc
ToolSvc.TileCellBuilder.QualityCut = 15
except Exception:
treatException("Problem with CaloCellGetter. Switched off.")
DetFlags.makeRIO.Calo_setOff()
# CaloCellGetter_DigiHSTruth
doDigiTruthFlag = False
try:
from Digitization.DigitizationFlags import digitizationFlags
doDigiTruthFlag = digitizationFlags.doDigiTruth()
except:
log = logging.getLogger('CaloRec')
log.info(
'Unable to import DigitizationFlags in CaloRec_jobOptions. Expected in AthenaP1'
)
if doDigiTruthFlag:
try:
from CaloRec.CaloCellGetter_DigiHSTruth import CaloCellGetter_DigiHSTruth
CaloCellGetter_DigiHSTruth()
except Exception:
treatException(
"Problem with CaloCellGetter_DigiHSTruth. Switched off.")
,
"ENG_POS"
#,"SIGNIFICANCE"
#,"CELL_SIGNIFICANCE"
#,"CELL_SIG_SAMPLING"
,
"AVG_LAR_Q",
"AVG_TILE_Q",
"EM_PROBABILITY"
#,"PTD"
,
"BadChannelList", #"LATERAL"
]
try:
from Digitization.DigitizationFlags import digitizationFlags
if digitizationFlags.doDigiTruth():
AODMoments += [
"SECOND_R_DigiHSTruth",
"SECOND_LAMBDA_DigiHSTruth",
"CENTER_MAG_DigiHSTruth",
"CENTER_LAMBDA_DigiHSTruth",
"FIRST_ENG_DENS_DigiHSTruth",
"ENG_FRAC_MAX_DigiHSTruth",
"ISOLATION_DigiHSTruth",
"ENG_BAD_CELLS_DigiHSTruth",
"N_BAD_CELLS_DigiHSTruth",
"BADLARQ_FRAC_DigiHSTruth"
#,"ENG_BAD_HV_CELLS_Truth"
#,"N_BAD_HV_CELLS_Truth"
,
def configure(self):
mlog = logging.getLogger('TileDigitsGetter::configure:')
mlog.info('entering')
# get handle to upstream object
try:
from TileSimAlgs.TileDigitsGetter import TileDigitsGetter
theTileDigitsGetter = TileDigitsGetter()
except Exception:
mlog.error("could not get handle to TileDigitsGetter Quit")
traceback.print_exc()
return False
if not theTileDigitsGetter.usable():
if not self.ignoreConfigError():
mlog.error("TileDigitsGetter unusable. Quit.")
return False
else:
mlog.error("TileDigitsGetter unusable. Continue nevertheless")
from TileConditions.TileInfoConfigurator import TileInfoConfigurator
tileInfoConfigurator = TileInfoConfigurator()
tileInfoConfigurator.setupCOOLPHYPULSE()
# Instantiation of the C++ algorithm
try:
from TileSimAlgs.TileSimAlgsConf import TileDigitsMaker
except Exception:
mlog.error("could not import TileSimAlgs.TileDigitsMaker")
traceback.print_exc()
return False
theTileDigitsMaker = TileDigitsMaker()
self._TileDigitsMakerHandle = theTileDigitsMaker
from Digitization.DigitizationFlags import digitizationFlags
theTileDigitsMaker.DoHSTruthReconstruction = digitizationFlags.doDigiTruth(
)
# Configure TileDigitsMaker here
# Check TileDigitization_jobOptions.py for full configurability
theTileDigitsMaker.TileHitContainer = "TileHitCnt"
theTileDigitsMaker.TileHitContainer_DigiHSTruth = "TileHitCnt_DigiHSTruth"
theTileDigitsMaker.TileInfoName = "TileInfo"
theTileDigitsMaker.CalibrationRun = False
# Save integer numbers in digits vector if not pile-up premixing
theTileDigitsMaker.IntegerDigits = not digitizationFlags.PileUpPremixing(
)
from TileConditions.TileConditionsConf import TileCondToolNoiseSample
theTileDigitsMaker.TileCondToolNoiseSample = TileCondToolNoiseSample(
TileOnlineSampleNoise='')
# sets output key
if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi(
):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
theTileDigitsMaker.TileDigitsContainer = overlayFlags.bkgPrefix(
) + self.outputKey()
else:
theTileDigitsMaker.TileDigitsContainer = self.outputKey()
# register output in objKeyStore
from RecExConfig.ObjKeyStore import objKeyStore
objKeyStore.addStreamESD(self.outputType(), self.outputKey())
# now add algorithm to topSequence
# this should always come at the end
mlog.info(" now adding to topSequence")
# get a handle on topalg
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
topSequence += theTileDigitsMaker
return True
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
def getLArPileUpTool(name='LArPileUpTool', **kwargs): ## useLArFloat()=True,isOverlay()=False,outputKey='LArDigitContainer_MC'):
from AthenaCommon.Logging import logging
mlog = logging.getLogger( 'LArPileUpToolDefault:' )
mlog.info(" ---- in getLArPileUpTool " )
# the LAr and Calo detector description package
## FIXME includes to be replaced by confGetter configuration.
if not isOverlay():
from AthenaCommon.Resilience import protectedInclude
protectedInclude( "CaloDetMgrDetDescrCnv/CaloDetMgrDetDescrCnv_joboptions.py" )
protectedInclude( "LArDetDescr/LArDetDescr_joboptions.py" )
protectedInclude("LArConditionsCommon/LArConditionsCommon_MC_jobOptions.py")
from Digitization.DigitizationFlags import digitizationFlags
kwargs.setdefault('NoiseOnOff', digitizationFlags.doCaloNoise.get_Value() )
kwargs.setdefault('RndmSvc', digitizationFlags.rndmSvc.get_Value() )
digitizationFlags.rndmSeedList.addSeed("LArDigitization", 1234, 5678 )
kwargs.setdefault('DoDigiTruthReconstruction',digitizationFlags.doDigiTruth())
if digitizationFlags.doXingByXingPileUp():
kwargs.setdefault('FirstXing', -751 )
kwargs.setdefault('LastXing', 101 )
from LArDigitization.LArDigitizationFlags import jobproperties
# check if using high gain for Fcal or not
if (not jobproperties.LArDigitizationFlags.useFcalHighGain()) and (not isOverlay()):
mlog.info("do not use high gain in Fcal digitization ")
kwargs.setdefault('HighGainThreshFCAL', 0 )
else:
mlog.info("use high gain in Fcal digitization or overlay job")
# check if using high gain for EMEC IW or not
if (not jobproperties.LArDigitizationFlags.useEmecIwHighGain()) and (not isOverlay()):
mlog.info("do not use high gain in EMEC IW digitization ")
kwargs.setdefault('HighGainThreshEMECIW',0)
kwargs.setdefault('RndmEvtOverlay', isOverlay() )
kwargs.setdefault('DigitContainer', 'LArDigitContainer_MC' ) ##FIXME - should not be hard-coded
# if doing MC+MC overlay
from AthenaCommon.GlobalFlags import globalflags
if isOverlay() and globalflags.DataSource() == 'geant4':
kwargs.setdefault('isMcOverlay',True)
from LArROD.LArRODFlags import larRODFlags
kwargs.setdefault('Nsamples', larRODFlags.nSamples() )
kwargs.setdefault('firstSample', larRODFlags.firstSample() )
if isOverlay() :
kwargs.setdefault('RandomDigitContainer', 'LArDigitContainer_MC' )
# ADC2MeVTool
mlog.info(" ---- set LArADC2MeVToolDefault")
kwargs.setdefault('ADC2MeVTool', 'LArADC2MeVToolDefault')
# Tool for noise autocorrelation generation
kwargs.setdefault('AutoCorrNoiseTool', 'LArAutoCorrNoiseToolDefault')
# bad channel masking
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
theLArBadChannelTool=LArBadChanTool()
from AthenaCommon.AppMgr import ToolSvc
ToolSvc+=theLArBadChannelTool
from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelMasker
theLArRCBMasker=LArBadChannelMasker("LArRCBMasker")
theLArRCBMasker.TheLArBadChanTool = theLArBadChannelTool
theLArRCBMasker.DoMasking=True
theLArRCBMasker.ProblemsToMask=[
"deadReadout","deadPhys"]
ToolSvc+=theLArRCBMasker
kwargs.setdefault('MaskingTool', theLArRCBMasker )
kwargs.setdefault('BadChannelTool', theLArBadChannelTool )
# CosmicTriggerTimeTool for cosmics digitization
from AthenaCommon.BeamFlags import jobproperties
if jobproperties.Beam.beamType == "cosmics" :
from CommissionUtils.CommissionUtilsConf import CosmicTriggerTimeTool
theTriggerTimeTool = CosmicTriggerTimeTool()
ToolSvc += theTriggerTimeTool
kwargs.setdefault('UseTriggerTime', True )
kwargs.setdefault('TriggerTimeToolName', theTriggerTimeTool )
# pileup configuration "algorithm" way
if not digitizationFlags.doXingByXingPileUp():
from AthenaCommon.DetFlags import DetFlags
if DetFlags.pileup.LAr_on() or isOverlay():
kwargs.setdefault('PileUp', True )
kwargs.setdefault('useLArFloat', useLArFloat() )
if useLArFloat():
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from SGComps.SGCompsConf import AddressRemappingSvc
AddressRemappingSvc = AddressRemappingSvc()
svcMgr += AddressRemappingSvc
from AthenaCommon.ConfigurableDb import getConfigurable
svcMgr += getConfigurable( "ProxyProviderSvc" )()
svcMgr.ProxyProviderSvc.ProviderNames += [ "AddressRemappingSvc" ]
svcMgr.AddressRemappingSvc.TypeKeyOverwriteMaps = [ "LArHitContainer#LArHitEMB->LArHitFloatContainer#LArHitEMB" ,
"LArHitContainer#LArHitEMEC->LArHitFloatContainer#LArHitEMEC",
"LArHitContainer#LArHitHEC->LArHitFloatContainer#LArHitHEC",
"LArHitContainer#LArHitFCAL->LArHitFloatContainer#LArHitFCAL"]
svcMgr.AddressRemappingSvc.ProxyDict="ActiveStoreSvc"
return CfgMgr.LArPileUpTool(name, **kwargs)