def getSCT_FrontEnd(name="SCT_FrontEnd", **kwargs):
from Digitization.DigitizationFlags import digitizationFlags
#Setup noise treament in SCT_FrontEnd
# To set the mean noise values for the different module types
# Default values set at 0 degrees, plus/minus ~5 enc per plus/minus degree
kwargs.setdefault("NoiseBarrel", 1500.0)
kwargs.setdefault("NoiseBarrel3", 1541.0)
kwargs.setdefault("NoiseInners", 1090.0)
kwargs.setdefault("NoiseMiddles", 1557.0)
kwargs.setdefault("NoiseShortMiddles", 940.0)
kwargs.setdefault("NoiseOuters", 1618.0)
kwargs.setdefault("NOBarrel", 1.5e-5)
kwargs.setdefault("NOBarrel3", 2.1e-5)
kwargs.setdefault("NOInners", 5.0e-9)
kwargs.setdefault("NOMiddles", 2.7e-5)
kwargs.setdefault("NOShortMiddles", 2.0e-9)
kwargs.setdefault("NOOuters", 3.5e-5)
# If noise is turned off:
if not digitizationFlags.doInDetNoise.get_Value():
###kwargs.setdefault("OnlyHitElements", True)
print('SCT_Digitization:::: Turned off Noise in SCT_FrontEnd')
kwargs.setdefault("NoiseOn", False)
kwargs.setdefault("AnalogueNoiseOn", False)
else:
kwargs.setdefault("NoiseOn", True)
kwargs.setdefault("AnalogueNoiseOn", True)
# In overlay MC, only analogue noise is on. Noise hits are not added.
from AthenaCommon.GlobalFlags import globalflags
if globalflags.isOverlay() and globalflags.DataSource == 'geant4':
kwargs["NoiseOn"] = False
kwargs["AnalogueNoiseOn"] = True
# Use Calibration data from Conditions DB, still for testing purposes only
kwargs.setdefault("UseCalibData", True)
# Setup the ReadCalibChip folders and Svc
from SCT_ConditionsTools.SCT_ReadCalibChipDataToolSetup import SCT_ReadCalibChipDataToolSetup
sct_ReadCalibChipDataToolSetup = SCT_ReadCalibChipDataToolSetup()
sct_ReadCalibChipDataToolSetup.setup()
kwargs.setdefault("SCT_ReadCalibChipDataTool",
sct_ReadCalibChipDataToolSetup.getTool())
# DataCompressionMode: 1 is level mode X1X (default), 2 is edge mode 01X, 3 is any hit mode (1XX|X1X|XX1)
from AthenaCommon.BeamFlags import jobproperties
if digitizationFlags.PileUpPremixing:
kwargs.setdefault("DataCompressionMode", 3)
elif globalflags.isOverlay() and globalflags.DataSource == 'geant4':
kwargs.setdefault("DataCompressionMode", 2)
elif (jobproperties.Beam.bunchSpacing() <= 50):
kwargs.setdefault("DataCompressionMode", 1)
else:
kwargs.setdefault("DataCompressionMode", 3)
# DataReadOutMode: 0 is condensed mode and 1 is expanded mode
if globalflags.isOverlay() and globalflags.DataSource == 'geant4':
kwargs.setdefault("DataReadOutMode", 0)
else:
kwargs.setdefault("DataReadOutMode", 1)
from SCT_Digitization.SCT_DigitizationConf import SCT_FrontEnd
return SCT_FrontEnd(name, **kwargs)
def BunchLumisToolDefault(name="BunchLumisTool"):
mlog = logging.getLogger(name)
if hasattr(svcMgr.ToolSvc, name):
# re-use previously configured tool
mlog.info("BunchLumisToolDefault returning existing tool %s", name)
return getattr(svcMgr.ToolSvc, name)
# Instantiate new tool, by default configuration will do nothing
blTool = BunchLumisTool(name)
# Now configure based on the environment
from IOVDbSvc.CondDB import conddb
# Run1
if conddb.dbdata == "COMP200":
folder = '/TDAQ/OLC/BUNCHLUMIS'
blTool.BunchLumisFolderName = folder
from IOVDbSvc.CondDB import conddb
if not conddb.folderRequested(folder):
from AthenaCommon.GlobalFlags import globalflags
if globalflags.isOverlay():
# Load reduced channel list for overlay jobs to try to reduce COOL access
# Need Lucid AND, OR, HitOR, BcmH OR, BcmV OR
conddb.addFolder(
'TDAQ',
'<channelSelection>101,102,103,201,211</channelSelection> /TDAQ/OLC/BUNCHLUMIS'
)
else:
conddb.addFolder('TDAQ', folder)
mlog.info("BunchLumisToolDefault requested %s", folder)
# Also take care of the FillParamsTool
fpToolName = "FillParamsTool"
blTool.FillParamsTool = fpToolName
# Make sure tool exists also
if not hasattr(svcMgr.ToolSvc, fpToolName):
from CoolLumiUtilities.FillParamsToolDefault import FillParamsToolDefault
svcMgr.ToolSvc += FillParamsToolDefault(fpToolName)
mlog.info("BunchLumisToolDefault added tool %s", fpToolName)
# Run2 - do nothing
elif conddb.dbdata == "CONDBR2":
pass
# Unknown, complain and do nothing
else:
mlog.warning(
"BunchLumisToolDefault can't resolve conddb.dbdata = %s, assume Run2!"
% conddb.dbdata)
pass
return blTool
def getSCT_SurfaceChargesGenerator(name="SCT_SurfaceChargesGenerator",
**kwargs):
## Set up services used by SCT_SurfaceChargesGenerator
# Set up SCT_DCSConditiosnTool
from SCT_ConditionsTools.SCT_DCSConditionsToolSetup import SCT_DCSConditionsToolSetup
sct_DCSConditionsToolSetup = SCT_DCSConditionsToolSetup()
sct_DCSConditionsToolSetup.setup()
# Set up SCT_SiliconConditionsTool
from SCT_ConditionsTools.SCT_SiliconConditionsToolSetup import SCT_SiliconConditionsToolSetup
sct_SiliconConditionsToolSetup = SCT_SiliconConditionsToolSetup()
sct_SiliconConditionsToolSetup.setDcsTool(
sct_DCSConditionsToolSetup.getTool())
sct_SiliconConditionsToolSetup.setup()
# Set up SCT_SiPropertiesTool
from SiPropertiesTool.SCT_SiPropertiesToolSetup import SCT_SiPropertiesToolSetup
sct_SiPropertiesToolSetup = SCT_SiPropertiesToolSetup()
sct_SiPropertiesToolSetup.setSiliconTool(
sct_SiliconConditionsToolSetup.getTool())
sct_SiPropertiesToolSetup.setup()
## Charge trapping tool - used by SCT_SurfaceChargesGenerator
from AthenaCommon.AppMgr import ToolSvc
## SiLorentzAngleTool for SCT_SurfaceChargesGenerator
from SiLorentzAngleTool.SCTLorentzAngleToolSetup import SCTLorentzAngleToolSetup
sctLorentzAngleToolSetup = SCTLorentzAngleToolSetup()
kwargs.setdefault("FixedTime", -999)
kwargs.setdefault("SubtractTime", -999)
kwargs.setdefault("SurfaceDriftTime", 10 * Units.ns)
kwargs.setdefault("NumberOfCharges", 1)
kwargs.setdefault("SmallStepLength", 5 * Units.micrometer)
kwargs.setdefault("DepletionVoltage", 70)
kwargs.setdefault("BiasVoltage", 150)
kwargs.setdefault("SiPropertiesTool", sct_SiPropertiesToolSetup.getTool())
kwargs.setdefault("LorentzAngleTool",
sctLorentzAngleToolSetup.SCTLorentzAngleTool)
from AthenaCommon.GlobalFlags import globalflags
kwargs.setdefault("isOverlay", globalflags.isOverlay())
# kwargs.setdefault("doTrapping", True) # ATL-INDET-INT-2016-019
from Digitization.DigitizationFlags import digitizationFlags
if 'doDetailedSurfChargesGen' in digitizationFlags.experimentalDigi():
kwargs.setdefault("ChargeDriftModel", 1)
kwargs.setdefault("EFieldModel", 2)
kwargs.setdefault("MagneticField", -2.0)
kwargs.setdefault("SensorTemperature", 273.15)
kwargs.setdefault("TransportTimeStep", 0.25)
kwargs.setdefault("TransportTimeMax", 25.0)
from SCT_Digitization.SCT_DigitizationConf import SCT_DetailedSurfaceChargesGenerator
return SCT_DetailedSurfaceChargesGenerator(name, **kwargs)
else:
from SCT_ConditionsTools.SCT_ConditionsToolsConf import SCT_RadDamageSummaryTool
kwargs.setdefault(
"RadDamageSummaryTool",
SCT_RadDamageSummaryTool(name="InDetSCT_RadDamageSummaryTool"))
from SCT_Digitization.SCT_DigitizationConf import SCT_SurfaceChargesGenerator
return SCT_SurfaceChargesGenerator(name, **kwargs)
def BCM_DigitizationTool(name="BCM_DigitizationTool", **kwargs):
from Digitization.DigitizationFlags import digitizationFlags
kwargs.setdefault("HitCollName", "BCMHits")
if not digitizationFlags.doInDetNoise.get_Value():
kwargs.setdefault("ModNoise", [0., 0., 0., 0., 0., 0., 0., 0.])
else:
kwargs.setdefault(
"ModNoise",
[90.82, 90.82, 90.82, 90.82, 90.82, 90.82, 90.82, 90.82])
kwargs.setdefault("ModSignal",
[450.0, 450.0, 450.0, 450.0, 450.0, 450.0, 450.0, 450.0])
kwargs.setdefault("NinoThr",
[330.0, 330.0, 330.0, 330.0, 330.0, 330.0, 330.0, 330.0])
kwargs.setdefault("EffDistanceParam", 4.0)
kwargs.setdefault("EffSharpnessParam", 0.11)
kwargs.setdefault("TimeDelay", 9.0)
kwargs.setdefault("MIPDeposit", 0.33) # BCM with diamond
#kwargs.setdefault("MIPDeposit", 0.25) # BCM with graphite
if digitizationFlags.doXingByXingPileUp():
kwargs.setdefault("FirstXing", BCM_FirstXing())
kwargs.setdefault("LastXing", BCM_LastXing())
from AthenaCommon.GlobalFlags import globalflags
if globalflags.isOverlay():
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("OnlyUseContainerName", False)
kwargs.setdefault("OutputRDOKey",
overlayFlags.sigPrefix() + "BCM_RDOs")
kwargs.setdefault("OutputSDOKey",
overlayFlags.sigPrefix() + "BCM_SDO_Map")
else:
kwargs.setdefault("OutputRDOKey",
overlayFlags.evtStore() + "+BCM_RDOs")
kwargs.setdefault("OutputSDOKey",
overlayFlags.evtStore() + "+BCM_SDO_Map")
else:
if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi(
):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
kwargs.setdefault("OutputRDOKey",
overlayFlags.bkgPrefix() + "BCM_RDOs")
kwargs.setdefault("OutputSDOKey",
overlayFlags.bkgPrefix() + "BCM_SDO_Map")
else:
kwargs.setdefault("OutputRDOKey", "BCM_RDOs")
kwargs.setdefault("OutputSDOKey", "BCM_SDO_Map")
from AthenaCommon import CfgMgr
return CfgMgr.BCM_DigitizationTool(name, **kwargs)
def BunchCrossingConfProvider(type=""):
# Get ourselves a logger:
from AthenaCommon.Logging import logging
__logger = logging.getLogger("BunchCrossingConfProvider")
# If the user requested some instance directly:
if type != "":
if type == "TrigConf":
__logger.info("Forcing the usage of TrigConfBunchCrossingTool")
from TrigBunchCrossingTool.BunchCrossingTool import TrigConfBunchCrossingTool
return TrigConfBunchCrossingTool()
elif type == "LHC":
__logger.info("Forcing the usage of LHCBunchCrossingTool")
from TrigBunchCrossingTool.BunchCrossingTool import LHCBunchCrossingTool
return LHCBunchCrossingTool()
elif type == "MC":
from TrigBunchCrossingTool.BunchCrossingTool import MCBunchCrossingTool
__logger.info("Forcing the usage of MCBunchCrossingTool")
return MCBunchCrossingTool()
else:
__logger.warning("Type = " + type + " not recognized")
__logger.warning("Will select tool type based on global flags")
# Decide which tool to use based on the global flags:
from AthenaCommon.GlobalFlags import globalflags
if globalflags.isOverlay():
__logger.info("Selecting LHCBunchCrossingTool for overlay job")
from TrigBunchCrossingTool.BunchCrossingTool import LHCBunchCrossingTool
return LHCBunchCrossingTool()
if globalflags.DataSource() == "data":
from RecExConfig.RecFlags import rec
from RecExConfig.RecAlgsFlags import recAlgs
from TriggerJobOpts.TriggerFlags import TriggerFlags
if rec.doTrigger() or TriggerFlags.doTriggerConfigOnly(
) or recAlgs.doTrigger():
from TrigBunchCrossingTool.BunchCrossingTool import TrigConfBunchCrossingTool
__logger.info("Selecting TrigConfBunchCrossingTool for this job")
return TrigConfBunchCrossingTool()
else:
__logger.info(
"Trigger turned off, selecting LHCBunchCrossingTool for this job"
)
from TrigBunchCrossingTool.BunchCrossingTool import LHCBunchCrossingTool
return LHCBunchCrossingTool()
else:
__logger.info("Selecting MCBunchCrossingTool for this job")
from TrigBunchCrossingTool.BunchCrossingTool import MCBunchCrossingTool
return MCBunchCrossingTool()
def __init__(self,name = Configurable.DefaultName ):
super(TgcCablingServerConfig ,self).__init__(name)
# make default Atlas
# *TODO* How do we handle the case of old CSC data? Is new DetDescrVersion CSC too? EJWM
self.Atlas = True
if ( globalflags.DetDescrVersion().startswith('DC1') or \
globalflags.DetDescrVersion().startswith('DC2') or \
globalflags.DetDescrVersion().startswith('DC3')) :
self.Atlas = False
print "DC"
if (muonByteStreamFlags.TgcDataType()=='m3' or \
muonByteStreamFlags.TgcDataType()=='oldSimulation') :
self.Atlas = False
if (muonByteStreamFlags.TgcDataType()=='m3'):
print "TgcDataType is set to m3"
else:
print "TgcDataType is set to oldSim"
# setting the default to ATLAS cabling
print self.Atlas;
# Setting of the default 12-fold (ATLAS) cabling
# New MuonTGC_CablingSvc (True) uses COOL DB and old TGCcabling12Svc (False) does not use COOL DB
self.useMuonTGC_CablingSvc = True
# do not use the call-back for digitization job
self.forcedUse = True
# if we run from RDO (overlay or other jobs) we must use the call-back,
# even if we have hits to digitize
if DetFlags.haveRDO.TGC_on() and not DetFlags.digitize.TGC_on():
self.forcedUse = False
#use the call-back in the overlay job that has no bytestream data as input
if globalflags.isOverlay():
self.forcedUse = False
# superseed the previos configuration if we run from Atlas data
if globalflags.DataSource.is_data():
self.forcedUse = True
self.Atlas = True
# avoid to use call-back if input is bytestream
if globalflags.InputFormat.is_bytestream():
self.forcedUse = True
def BunchCrossingConfProvider( type = "" ):
# Get ourselves a logger:
from AthenaCommon.Logging import logging
__logger = logging.getLogger( "BunchCrossingConfProvider" )
# If the user requested some instance directly:
if type != "":
if type == "TrigConf":
__logger.info( "Forcing the usage of TrigConfBunchCrossingTool" )
from TrigBunchCrossingTool.BunchCrossingTool import TrigConfBunchCrossingTool
return TrigConfBunchCrossingTool()
elif type == "LHC":
__logger.info( "Forcing the usage of LHCBunchCrossingTool" )
from TrigBunchCrossingTool.BunchCrossingTool import LHCBunchCrossingTool
return LHCBunchCrossingTool()
elif type == "MC":
from TrigBunchCrossingTool.BunchCrossingTool import MCBunchCrossingTool
__logger.info( "Forcing the usage of MCBunchCrossingTool" )
return MCBunchCrossingTool()
else:
__logger.warning( "Type = " + type + " not recognized" )
__logger.warning( "Will select tool type based on global flags" )
# Decide which tool to use based on the global flags:
from AthenaCommon.GlobalFlags import globalflags
if globalflags.isOverlay():
__logger.info( "Selecting LHCBunchCrossingTool for overlay job" )
from TrigBunchCrossingTool.BunchCrossingTool import LHCBunchCrossingTool
return LHCBunchCrossingTool()
if globalflags.DataSource() == "data":
from RecExConfig.RecFlags import rec
from RecExConfig.RecAlgsFlags import recAlgs
from TriggerJobOpts.TriggerFlags import TriggerFlags
if rec.doTrigger() or TriggerFlags.doTriggerConfigOnly() or recAlgs.doTrigger():
from TrigBunchCrossingTool.BunchCrossingTool import TrigConfBunchCrossingTool
__logger.info( "Selecting TrigConfBunchCrossingTool for this job" )
return TrigConfBunchCrossingTool()
else:
__logger.info( "Trigger turned off, selecting LHCBunchCrossingTool for this job" )
from TrigBunchCrossingTool.BunchCrossingTool import LHCBunchCrossingTool
return LHCBunchCrossingTool()
else:
__logger.info( "Selecting MCBunchCrossingTool for this job" )
from TrigBunchCrossingTool.BunchCrossingTool import MCBunchCrossingTool
return MCBunchCrossingTool()
def isOverlay():
from AthenaCommon.GlobalFlags import globalflags
if globalflags.isOverlay():
return True
# steer random overlay configuration
from AthenaCommon.AppMgr import ServiceMgr
if hasattr(ServiceMgr, 'PileUpMergeSvc'):
if hasattr(ServiceMgr.PileUpMergeSvc, 'ReturnTimedData'):
if (not ServiceMgr.PileUpMergeSvc.ReturnTimedData):
from AthenaCommon.DetFlags import DetFlags
checkOverlay = getattr(DetFlags, 'overlay', None)
if checkOverlay is not None:
if DetFlags.overlay.LAr_on():
return True
else: #fallback for older releases
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.doLAr():
return True
return False
def BunchLumisCondAlgDefault():
name = 'BunchLumisCondAlg'
condSeq = AthSequencer('AthCondSeq')
if hasattr(condSeq, name):
return getattr(condSeq, name)
# Should only be used for Run 1.
from IOVDbSvc.CondDB import conddb
if conddb.dbdata != 'COMP200':
return None
folder = '/TDAQ/OLC/BUNCHLUMIS'
from AthenaCommon.GlobalFlags import globalflags
if globalflags.isOverlay():
# Load reduced channel list for overlay jobs to try to reduce COOL access
# Need Lucid AND, OR, HitOR, BcmH OR, BcmV OR
conddb.addFolder(
'TDAQ',
'<channelSelection>101,102,103,201,211</channelSelection> /TDAQ/OLC/BUNCHLUMIS',
className='CondAttrListCollection')
else:
conddb.addFolder('TDAQ', folder, className='CondAttrListCollection')
from CoolLumiUtilities.CoolLumiUtilitiesConf import \
BunchLumisCondAlg
from CoolLumiUtilities.FillParamsCondAlgDefault import FillParamsCondAlgDefault
fpalg = FillParamsCondAlgDefault()
alg = BunchLumisCondAlg(name,
BunchLumisFolderInputKey=folder,
FillParamsInputKey=fpalg.FillParamsOutputKey,
BunchLumisOutputKey='BunchLumisCondData')
condSeq += alg
return alg
# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
# Always schedule beam spot conditions for digi
from AthenaCommon.AlgSequence import AthSequencer
condSeq = AthSequencer("AthCondSeq")
if not hasattr(condSeq, "BeamSpotCondAlg"):
from IOVDbSvc.CondDB import conddb
conddb.addFolderSplitOnline("INDET", "/Indet/Onl/Beampos", "/Indet/Beampos", className="AthenaAttributeList")
from BeamSpotConditions.BeamSpotConditionsConf import BeamSpotCondAlg
condSeq += BeamSpotCondAlg("BeamSpotCondAlg")
# Add beam spot fixer
from AthenaCommon import CfgGetter
from AthenaCommon.DetFlags import DetFlags
from AthenaCommon.GlobalFlags import globalflags
from Digitization.DigitizationFlags import digitizationFlags
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if (DetFlags.pileup.any_on() or digitizationFlags.doXingByXingPileUp()) or (globalflags.isOverlay() and not overlayFlags.isOverlayMT()):
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
job += CfgGetter.getAlgorithm("BeamSpotFixerAlg")
include('TrigT1CaloCalibConditions/L1CaloCalibConditionsMC_jobOptions.py')
from TrigT1CaloSim.TrigT1CaloSimRun2Config import Run2TriggerTowerMaker25ns, Run2TriggerTowerMaker50ns
from SGComps.AddressRemappingSvc import addInputRename
addInputRename('xAOD::TriggerTowerContainer', 'xAODTriggerTowers_rerun',
'xAODTriggerTowers')
# try to determine wheter running with 25ns/50ns bunchspacing
_bunchSpacing = None
_doPC = True # do pedestal correction?
_alg = {25: Run2TriggerTowerMaker25ns, 50: Run2TriggerTowerMaker50ns}
from PyUtils.MetaReaderPeeker import metadata
from AthenaCommon.GlobalFlags import globalflags
if globalflags.isOverlay() is True:
_doPC = False
from AthenaCommon import CfgMgr
from AthenaCommon.AppMgr import ToolSvc
if not hasattr(ToolSvc, "LumiBlockMuTool"):
ToolSvc += CfgMgr.LumiBlockMuTool("LumiBlockMuTool")
from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__OverlayRun2TriggerTowerMaker
job += LVL1__OverlayRun2TriggerTowerMaker('Run2TriggerTowerMaker',
CellType=3,
ZeroSuppress=True,
DoOverlay=True)
else:
try:
if not 'metadata' in dir():
raise RuntimeError('Input file summary not available.')
# try:
def configure(self):
mlog = logging.getLogger( 'TileRawChannelGetter::configure:' )
mlog.info ("entering")
self._TileRawChannelBuilderFitFilter = None
self._TileRawChannelBuilderFitFilterCool = None
self._TileRawChannelBuilderMF = None
self._TileRawChannelBuilderOF1 = None
self._TileRawChannelBuilderOpt2Filter = None
self._TileRawChannelBuilderOptATLAS = None
self._TileRawChannelBuilderWienerFilter = None
# Instantiation of the C++ algorithm
try:
from TileRecUtils.TileRecUtilsConf import TileRawChannelMaker
theTileRawChannelMaker = TileRawChannelMaker("TileRChMaker")
except Exception:
mlog.error("could not import TileRecUtils.TileRawChannelMaker")
traceback.print_exc()
return False
self._TileRChMaker = theTileRawChannelMaker
# Configure TileInfoLoader
from AthenaCommon.AppMgr import ServiceMgr
from TileConditions.TileInfoConfigurator import TileInfoConfigurator
tileInfoConfigurator = TileInfoConfigurator()
from TileRecUtils.TileRecFlags import jobproperties
# true for real data, false for MC - GlobalFlags.DataSource.is_data()
# true for nominal ATLAS configuration - GlobalFlags.DetGeo.is_atlas()
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource() == 'data' and jobproperties.TileRecFlags.noiseFilter() < 0:
# apply noise filter for real data (if this option was not set before)
jobproperties.TileRecFlags.noiseFilter = 1
if globalflags.DataSource() == 'data' and not globalflags.isOverlay():
if jobproperties.TileRecFlags.TileRunType() == 1 :
tileBeamElemContainer=""
else:
tileBeamElemContainer="TileBeamElemCnt"
if jobproperties.TileRecFlags.readDigits():
tileDigitsContainer="TileDigitsCnt"
else:
tileDigitsContainer=""
tileRawChannelContainer="TileRawChannelCnt"
else:
tileBeamElemContainer=""
tileDigitsContainer=""
tileRawChannelContainer=""
if not globalflags.isOverlay():
from TileRecUtils.TileDQstatusAlgDefault import TileDQstatusAlgDefault
TileDQstatusAlgDefault (TileRawChannelContainer = tileRawChannelContainer,
TileDigitsContainer = tileDigitsContainer,
TileBeamElemContainer = tileBeamElemContainer)
# set time window for amplitude correction if it was not set correctly before
if jobproperties.TileRecFlags.TimeMaxForAmpCorrection() <= jobproperties.TileRecFlags.TimeMinForAmpCorrection() :
from AthenaCommon.BeamFlags import jobproperties
mlog.info("adjusting min/max time of parabolic correction for %s", jobproperties.Beam.bunchSpacing)
halfBS = jobproperties.Beam.bunchSpacing.get_Value()/2.
if halfBS > 25.1:
mlog.info("Bunch spacing is too big, keeping default limits for parabolic correction")
else:
jobproperties.TileRecFlags.TimeMinForAmpCorrection = -halfBS
jobproperties.TileRecFlags.TimeMaxForAmpCorrection = halfBS
TileFrameLength = ServiceMgr.TileInfoLoader.NSamples
if TileFrameLength!=7:
mlog.info("disabling reading of OFC from COOL because Nsamples!=7")
jobproperties.TileRecFlags.OfcFromCOOL = False
jobproperties.TileRecFlags.print_JobProperties('tree&value')
# run optimal filter only if readDigits is set
if jobproperties.TileRecFlags.readDigits():
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
TilePulseTypes = {0 : 'PHY', 1 : 'PHY', 2 : 'LAS', 4 : 'PHY', 8 : 'CIS'}
TilePulse = TilePulseTypes[jobproperties.TileRecFlags.TileRunType()]
from TileConditions.TileCondToolConf import getTileCondToolOfcCool
toolOfcCool = None
toolOfcCoolOF1 = None
NoiseFilterTools = []
TileRawChannelContainerDSP = ''
if jobproperties.TileRecFlags.noiseFilter() == 1:
if globalflags.DataSource() == 'data':
# check if there are DSP thresholds in DB
if jobproperties.TileRecFlags.zeroAmplitudeWithoutDigits():
jobproperties.TileRecFlags.zeroAmplitudeWithoutDigits = False
if jobproperties.TileRecFlags.correctPedestalDifference():
# check if offline and there are OFCs in DB for OF1 method
toolOfcCoolOF1 = getTileCondToolOfcCool('COOL', TilePulse, 'OF1', 'TileCondToolOfcCoolOF1')
if athenaCommonFlags.isOnline() or not toolOfcCoolOF1:
jobproperties.TileRecFlags.correctPedestalDifference = False
#else:
# tileInfoConfigurator.setupCOOLTIME(online = True)
if jobproperties.TileRecFlags.zeroAmplitudeWithoutDigits() or jobproperties.TileRecFlags.correctPedestalDifference():
from TileRecUtils.TileRecUtilsConf import TileRawChannelOF1Corrector
theTileRawChannelOF1Corrector = TileRawChannelOF1Corrector()
theTileRawChannelOF1Corrector.CorrectPedestalDifference = jobproperties.TileRecFlags.correctPedestalDifference()
theTileRawChannelOF1Corrector.ZeroAmplitudeWithoutDigits = jobproperties.TileRecFlags.zeroAmplitudeWithoutDigits()
if jobproperties.TileRecFlags.correctPedestalDifference():
from TileConditions.TileCondToolConf import getTileCondToolTiming
toolOnlineTiming = getTileCondToolTiming('COOL', TilePulse, True, 'TileCondToolOnlineTiming')
theTileRawChannelOF1Corrector.TileCondToolTiming = toolOnlineTiming
theTileRawChannelOF1Corrector.TileCondToolOfc = toolOfcCoolOF1
NoiseFilterTools += [theTileRawChannelOF1Corrector]
from TileRecUtils.TileRecUtilsConf import TileRawChannelNoiseFilter
theTileRawChannelNoiseFilter = TileRawChannelNoiseFilter()
if not athenaCommonFlags.isOnline():
theTileRawChannelNoiseFilter.TileCondToolNoiseSample.TileOnlineSampleNoise = ''
NoiseFilterTools += [theTileRawChannelNoiseFilter]
if globalflags.DataSource() == 'data' and not globalflags.isOverlay():
from TileRecUtils.TileRecUtilsConf import TileRawChannelCorrectionAlg
theTileRawChannelCorrectionAlg = TileRawChannelCorrectionAlg()
theTileRawChannelCorrectionAlg.NoiseFilterTools= NoiseFilterTools
TileRawChannelContainerDSP = 'TileRawChannelCntCorrected'
topSequence += theTileRawChannelCorrectionAlg
if (jobproperties.TileRecFlags.doTileMF()
or (not jobproperties.TileRecFlags.OfcFromCOOL()
and (jobproperties.TileRecFlags.doTileOF1()
or jobproperties.TileRecFlags.doTileWiener()
or jobproperties.TileRecFlags.doTileOpt2()
or jobproperties.TileRecFlags.doTileOptATLAS()))):
tileInfoConfigurator.setupCOOLPULSE(type = TilePulse)
tileInfoConfigurator.setupCOOLAutoCr()
elif jobproperties.TileRecFlags.doTileFitCool():
tileInfoConfigurator.setupCOOLPULSE(type = TilePulse)
if jobproperties.TileRecFlags.OfcFromCOOL():
if (jobproperties.TileRecFlags.doTileMF()
or jobproperties.TileRecFlags.doTileWiener()
or jobproperties.TileRecFlags.doTileOpt2()
or jobproperties.TileRecFlags.doTileOptATLAS()):
tileInfoConfigurator.setupCOOLOFC(type = TilePulse)
toolOfcCool = getTileCondToolOfcCool('COOL', TilePulse)
if jobproperties.TileRecFlags.doTileOF1():
tileInfoConfigurator.setupCOOLOFC(type = TilePulse, ofcType = 'OF1')
if not toolOfcCoolOF1:
toolOfcCoolOF1 = getTileCondToolOfcCool('COOL', TilePulse, 'OF1', 'TileCondToolOfcCoolOF1')
if jobproperties.TileRecFlags.doTileQIE():
try:
from TileRecUtils.TileRecUtilsConf import TileRawChannelBuilderQIEFilter
theTileRawChannelBuilderQIEFilter= TileRawChannelBuilderQIEFilter()
except Exception:
mlog.error("could not get handle to TileRawChannelBuilderQIEFilter Quit")
traceback.print_exc()
return False
#TileRawChannelBuilderQIEFilter Options:
jobproperties.TileRecFlags.TileRawChannelContainer = "TileRawChannelQIE"
theTileRawChannelBuilderQIEFilter.TileRawChannelContainer = "TileRawChannelQIE"
theTileRawChannelBuilderQIEFilter.RunType = jobproperties.TileRecFlags.TileRunType()
theTileRawChannelBuilderQIEFilter.calibrateEnergy = jobproperties.TileRecFlags.calibrateEnergy()
theTileRawChannelBuilderQIEFilter.correctTime = jobproperties.TileRecFlags.correctTime()
theTileRawChannelBuilderQIEFilter.NoiseFilterTools= NoiseFilterTools
theTileRawChannelBuilderQIEFilter.PedestalMode = 1
theTileRawChannelBuilderQIEFilter.DSPContainer = TileRawChannelContainerDSP
mlog.info(" adding now TileRawChannelBuilderQIEFilter to the algorithm: %s", theTileRawChannelMaker.name())
theTileRawChannelMaker.TileRawChannelBuilder += [theTileRawChannelBuilderQIEFilter]
# fit with several amplitudes
if jobproperties.TileRecFlags.doTileManyAmps():
try:
from TileRecUtils.TileRecUtilsConf import TileRawChannelBuilderManyAmps
theTileRawChannelBuilderManyAmps= TileRawChannelBuilderManyAmps()
except Exception:
mlog.error("could not get handle to TileRawChannelBuilderManyAmps Quit")
traceback.print_exc()
return False
#TileRawChannelBuilderManyAmps Options:
jobproperties.TileRecFlags.TileRawChannelContainer = "TileRawChannelManyAmp"
theTileRawChannelBuilderManyAmps.TileRawChannelContainer = "TileRawChannelManyAmp"
theTileRawChannelBuilderManyAmps.RunType = jobproperties.TileRecFlags.TileRunType()
theTileRawChannelBuilderManyAmps.calibrateEnergy = jobproperties.TileRecFlags.calibrateEnergy()
theTileRawChannelBuilderManyAmps.correctTime = jobproperties.TileRecFlags.correctTime()
theTileRawChannelBuilderManyAmps.NoiseFilterTools= NoiseFilterTools
theTileRawChannelBuilderManyAmps.DSPContainer = TileRawChannelContainerDSP
mlog.info(" adding now TileRawChannelBuilderManyAmps to the algorithm: %s", theTileRawChannelMaker.name())
theTileRawChannelMaker.TileRawChannelBuilder += [theTileRawChannelBuilderManyAmps]
# flat filter - sum of 5 samples
if jobproperties.TileRecFlags.doTileFlat():
try:
from TileRecUtils.TileRecUtilsConf import TileRawChannelBuilderFlatFilter
theTileRawChannelBuilderFlatFilter= TileRawChannelBuilderFlatFilter()
except Exception:
mlog.error("could not get handle to TileRawChannelBuilderFlatFilter Quit")
traceback.print_exc()
return False
#TileRawChannelBuilderFlatFilter Options:
jobproperties.TileRecFlags.TileRawChannelContainer = "TileRawChannelFlat"
theTileRawChannelBuilderFlatFilter.TileRawChannelContainer = "TileRawChannelFlat"
theTileRawChannelBuilderFlatFilter.RunType = jobproperties.TileRecFlags.TileRunType()
theTileRawChannelBuilderFlatFilter.calibrateEnergy = jobproperties.TileRecFlags.calibrateEnergy()
theTileRawChannelBuilderFlatFilter.correctTime = jobproperties.TileRecFlags.correctTime()
theTileRawChannelBuilderFlatFilter.NoiseFilterTools= NoiseFilterTools
theTileRawChannelBuilderFlatFilter.FrameLength = TileFrameLength
theTileRawChannelBuilderFlatFilter.SignalLength = TileFrameLength - 1
theTileRawChannelBuilderFlatFilter.DSPContainer = TileRawChannelContainerDSP
mlog.info(" adding now TileRawChannelBuilderFlatFilter to the algorithm: %s", theTileRawChannelMaker.name())
theTileRawChannelMaker.TileRawChannelBuilder += [theTileRawChannelBuilderFlatFilter]
# Fit method
if jobproperties.TileRecFlags.doTileFit() or jobproperties.TileRecFlags.doTileOverflowFit():
# configure TileRawChannelMaker here
try:
from TileRecUtils.TileRecUtilsConf import TileRawChannelBuilderFitFilter
theTileRawChannelBuilderFitFilter= TileRawChannelBuilderFitFilter()
except Exception:
mlog.error("could not get handle to TileRawChannelBuilderFitFilter Quit")
traceback.print_exc()
return False
#TileRawChannelBuilderFitFilter Options:
theTileRawChannelBuilderFitFilter.RunType = jobproperties.TileRecFlags.TileRunType()
theTileRawChannelBuilderFitFilter.calibrateEnergy = jobproperties.TileRecFlags.calibrateEnergy()
theTileRawChannelBuilderFitFilter.correctTime = jobproperties.TileRecFlags.correctTime()
theTileRawChannelBuilderFitFilter.NoiseFilterTools= NoiseFilterTools
theTileRawChannelBuilderFitFilter.FrameLength = TileFrameLength
theTileRawChannelBuilderFitFilter.DSPContainer = TileRawChannelContainerDSP
if not athenaCommonFlags.isOnline():
theTileRawChannelBuilderFitFilter.TileCondToolNoiseSample.TileOnlineSampleNoise = ''
# add the tool to list of tool ( should use ToolHandle eventually)
mlog.info(" adding now TileRawChannelBuilderFitFilter to the algorithm: %s", theTileRawChannelMaker.name())
if jobproperties.TileRecFlags.doTileFit():
jobproperties.TileRecFlags.TileRawChannelContainer = "TileRawChannelFit"
theTileRawChannelBuilderFitFilter.TileRawChannelContainer = "TileRawChannelFit"
theTileRawChannelMaker.TileRawChannelBuilder += [theTileRawChannelBuilderFitFilter]
self._TileRawChannelBuilderFitFilter = theTileRawChannelBuilderFitFilter
if jobproperties.TileRecFlags.doTileOverflowFit():
theTileRawChannelMaker.FitOverflow = True
theTileRawChannelMaker.TileRawChannelBuilderFitOverflow = theTileRawChannelBuilderFitFilter
mlog.info(" set up TileRawChannelBuilderFitOverflow to TileRawChannelBuilderFitFilter")
# Fit method with reading from COOL
if jobproperties.TileRecFlags.doTileFitCool():
# configure TileRawChannelMaker here
try:
from TileRecUtils.TileRecUtilsConf import TileRawChannelBuilderFitFilterCool
theTileRawChannelBuilderFitFilterCool= TileRawChannelBuilderFitFilterCool()
except Exception:
mlog.error("could not get handle to TileRawChannelBuilderFitFilterCool Quit")
traceback.print_exc()
return False
#TileRawChannelBuilderFitFilterCool Options:
jobproperties.TileRecFlags.TileRawChannelContainer = "TileRawChannelFitCool"
theTileRawChannelBuilderFitFilterCool.TileRawChannelContainer = "TileRawChannelFitCool"
theTileRawChannelBuilderFitFilterCool.RunType = jobproperties.TileRecFlags.TileRunType()
theTileRawChannelBuilderFitFilterCool.calibrateEnergy = jobproperties.TileRecFlags.calibrateEnergy()
theTileRawChannelBuilderFitFilterCool.correctTime = jobproperties.TileRecFlags.correctTime()
theTileRawChannelBuilderFitFilterCool.NoiseFilterTools= NoiseFilterTools
theTileRawChannelBuilderFitFilterCool.FrameLength = TileFrameLength
theTileRawChannelBuilderFitFilterCool.DSPContainer = TileRawChannelContainerDSP
# add the tool to list of tool ( should use ToolHandle eventually)
mlog.info(" adding now TileRawChannelBuilderFitFilterCool to the algorithm: %s", theTileRawChannelMaker.name())
theTileRawChannelMaker.TileRawChannelBuilder += [theTileRawChannelBuilderFitFilterCool]
self._TileRawChannelBuilderFitFilterCool = theTileRawChannelBuilderFitFilterCool
# matched filter
if jobproperties.TileRecFlags.doTileMF():
try:
from TileRecUtils.TileRecUtilsConf import TileRawChannelBuilderMF
theTileRawChannelBuilderMF= TileRawChannelBuilderMF()
except Exception:
mlog.error("could not get handle to TileRawChannelBuilderMF Quit")
traceback.print_exc()
return False
# setup COOL to get OFCs, needed for COF to retrieve pulse shape and derivatives
if jobproperties.TileRecFlags.OfcFromCOOL():
theTileRawChannelBuilderMF.TileCondToolOfc = toolOfcCool
#TileRawChannelBuilderMF Options:
jobproperties.TileRecFlags.TileRawChannelContainer = "TileRawChannelMF"
theTileRawChannelBuilderMF.TileRawChannelContainer = "TileRawChannelMF"
theTileRawChannelBuilderMF.RunType = jobproperties.TileRecFlags.TileRunType()
theTileRawChannelBuilderMF.calibrateEnergy = jobproperties.TileRecFlags.calibrateEnergy()
if jobproperties.TileRecFlags.BestPhaseFromCOOL(): # can't correct time and use best phase at the same time
theTileRawChannelBuilderMF.correctTime = False
else:
theTileRawChannelBuilderMF.correctTime = jobproperties.TileRecFlags.correctTime()
theTileRawChannelBuilderMF.BestPhase = jobproperties.TileRecFlags.BestPhaseFromCOOL()
theTileRawChannelBuilderMF.NoiseFilterTools = NoiseFilterTools
theTileRawChannelBuilderMF.MaxIterations = 5 # iterative mode on
theTileRawChannelBuilderMF.AmplitudeCorrection = False
theTileRawChannelBuilderMF.TimeFromCOF = False
theTileRawChannelBuilderMF.AmpMinForAmpCorrection = jobproperties.TileRecFlags.AmpMinForAmpCorrection()
if jobproperties.TileRecFlags.TimeMaxForAmpCorrection() > jobproperties.TileRecFlags.TimeMinForAmpCorrection():
theTileRawChannelBuilderMF.TimeMinForAmpCorrection = jobproperties.TileRecFlags.TimeMinForAmpCorrection()
theTileRawChannelBuilderMF.TimeMaxForAmpCorrection = jobproperties.TileRecFlags.TimeMaxForAmpCorrection()
theTileRawChannelBuilderMF.DSPContainer = TileRawChannelContainerDSP
mlog.info(" adding now TileRawChannelBuilderMF to the algorithm: %s", theTileRawChannelMaker.name())
theTileRawChannelMaker.TileRawChannelBuilder += [theTileRawChannelBuilderMF]
self._TileRawChannelBuilderMF = theTileRawChannelBuilderMF
if jobproperties.TileRecFlags.doTileOF1():
try:
from TileRecUtils.TileRecUtilsConf import TileRawChannelBuilderOpt2Filter
theTileRawChannelBuilderOF1 = TileRawChannelBuilderOpt2Filter("TileRawChannelBuilderOF1")
except Exception:
mlog.error("could not get handle to TileRawChannelBuilderOF1 Quit")
traceback.print_exc()
return False
# setup COOL to get OFCs
if jobproperties.TileRecFlags.OfcFromCOOL():
if toolOfcCoolOF1:
theTileRawChannelBuilderOF1.TileCondToolOfc = toolOfcCoolOF1
else:
# There are no OF1 OFC in the COOL
# OFC will be calculated on the fly
tileInfoConfigurator.setupCOOLPULSE(type = TilePulse)
tileInfoConfigurator.setupCOOLAutoCr()
#TileRawChannelBuilderOF1 Options:
jobproperties.TileRecFlags.TileRawChannelContainer = "TileRawChannelOF1"
theTileRawChannelBuilderOF1.TileRawChannelContainer = "TileRawChannelOF1"
theTileRawChannelBuilderOF1.RunType = jobproperties.TileRecFlags.TileRunType()
theTileRawChannelBuilderOF1.calibrateEnergy = jobproperties.TileRecFlags.calibrateEnergy()
if jobproperties.TileRecFlags.BestPhaseFromCOOL(): # can't correct time and use best phase at the same time
theTileRawChannelBuilderOF1.correctTime = False
else:
theTileRawChannelBuilderOF1.correctTime = jobproperties.TileRecFlags.correctTime()
theTileRawChannelBuilderOF1.BestPhase = jobproperties.TileRecFlags.BestPhaseFromCOOL()
theTileRawChannelBuilderOF1.NoiseFilterTools= NoiseFilterTools
theTileRawChannelBuilderOF1.OF2 = False
theTileRawChannelBuilderOF1.PedestalMode = -1
theTileRawChannelBuilderOF1.MaxIterations = 1 # just one iteration
theTileRawChannelBuilderOF1.Minus1Iteration = False # assume that max sample is at t=0
theTileRawChannelBuilderOF1.AmplitudeCorrection = jobproperties.TileRecFlags.correctAmplitude()
theTileRawChannelBuilderOF1.TimeCorrection = False
theTileRawChannelBuilderOF1.AmpMinForAmpCorrection = jobproperties.TileRecFlags.AmpMinForAmpCorrection()
if jobproperties.TileRecFlags.TimeMaxForAmpCorrection() > jobproperties.TileRecFlags.TimeMinForAmpCorrection():
theTileRawChannelBuilderOF1.TimeMinForAmpCorrection = jobproperties.TileRecFlags.TimeMinForAmpCorrection()
theTileRawChannelBuilderOF1.TimeMaxForAmpCorrection = jobproperties.TileRecFlags.TimeMaxForAmpCorrection()
theTileRawChannelBuilderOF1.DSPContainer = TileRawChannelContainerDSP
mlog.info(" adding now TileRawChannelBuilderOF1 to the algorithm: %s", theTileRawChannelMaker.name())
theTileRawChannelMaker.TileRawChannelBuilder += [theTileRawChannelBuilderOF1]
self._TileRawChannelBuilderOF1 = theTileRawChannelBuilderOF1
if jobproperties.TileRecFlags.doTileOpt2():
try:
from TileRecUtils.TileRecUtilsConf import TileRawChannelBuilderOpt2Filter
theTileRawChannelBuilderOpt2Filter= TileRawChannelBuilderOpt2Filter()
except Exception:
mlog.error("could not get handle to TileRawChannelBuilderOpt2Filter Quit")
traceback.print_exc()
return False
# setup COOL to get OFCs
if jobproperties.TileRecFlags.OfcFromCOOL():
theTileRawChannelBuilderOpt2Filter.TileCondToolOfc = toolOfcCool
#TileRawChannelBuilderOpt2Filter Options:
jobproperties.TileRecFlags.TileRawChannelContainer = "TileRawChannelOpt2"
theTileRawChannelBuilderOpt2Filter.TileRawChannelContainer = "TileRawChannelOpt2"
theTileRawChannelBuilderOpt2Filter.RunType = jobproperties.TileRecFlags.TileRunType()
theTileRawChannelBuilderOpt2Filter.calibrateEnergy = jobproperties.TileRecFlags.calibrateEnergy()
theTileRawChannelBuilderOpt2Filter.correctTime = jobproperties.TileRecFlags.correctTime()
theTileRawChannelBuilderOpt2Filter.NoiseFilterTools= NoiseFilterTools
theTileRawChannelBuilderOpt2Filter.BestPhase = False # no point to use best phase with interations
theTileRawChannelBuilderOpt2Filter.OF2 = True
theTileRawChannelBuilderOpt2Filter.PedestalMode = 1
theTileRawChannelBuilderOpt2Filter.MaxIterations = 5
theTileRawChannelBuilderOpt2Filter.Minus1Iteration = True
theTileRawChannelBuilderOpt2Filter.AmplitudeCorrection = False # don't need correction after iterations
theTileRawChannelBuilderOpt2Filter.TimeCorrection = False # don't need correction after iterations
theTileRawChannelBuilderOpt2Filter.DSPContainer = TileRawChannelContainerDSP
mlog.info(" adding now TileRawChannelBuilderOpt2Filter to the algorithm: %s", theTileRawChannelMaker.name())
theTileRawChannelMaker.TileRawChannelBuilder += [theTileRawChannelBuilderOpt2Filter]
self._TileRawChannelBuilderOpt2Filter = theTileRawChannelBuilderOpt2Filter
if jobproperties.TileRecFlags.doTileOptATLAS():
try:
from TileRecUtils.TileRecUtilsConf import TileRawChannelBuilderOpt2Filter
theTileRawChannelBuilderOptATLAS= TileRawChannelBuilderOpt2Filter("TileRawChannelBuilderOptATLAS")
except Exception:
mlog.error("could not get handle to TileRawChannelBuilderOpt2Filter Quit")
traceback.print_exc()
return False
# setup COOL to get OFCs
if jobproperties.TileRecFlags.OfcFromCOOL():
theTileRawChannelBuilderOptATLAS.TileCondToolOfc = toolOfcCool
#TileRawChannelBuilderOptATLAS Options:
if globalflags.DataSource()=='data': # don't use the name which is used for reco data from DSP
if jobproperties.TileRecFlags.TileRawChannelContainer == "TileRawChannelCnt":
jobproperties.TileRecFlags.TileRawChannelContainer = "TileRawChannelFixed"
theTileRawChannelBuilderOptATLAS.TileRawChannelContainer = "TileRawChannelFixed"
else:
jobproperties.TileRecFlags.TileRawChannelContainer = "TileRawChannelCnt"
theTileRawChannelBuilderOptATLAS.TileRawChannelContainer = "TileRawChannelCnt"
theTileRawChannelBuilderOptATLAS.RunType = jobproperties.TileRecFlags.TileRunType()
theTileRawChannelBuilderOptATLAS.calibrateEnergy = jobproperties.TileRecFlags.calibrateEnergy()
if jobproperties.TileRecFlags.BestPhaseFromCOOL(): # can't correct time and use best phase at the same time
theTileRawChannelBuilderOptATLAS.correctTime = False
else:
theTileRawChannelBuilderOptATLAS.correctTime = jobproperties.TileRecFlags.correctTime()
theTileRawChannelBuilderOptATLAS.BestPhase = jobproperties.TileRecFlags.BestPhaseFromCOOL()
theTileRawChannelBuilderOptATLAS.NoiseFilterTools= NoiseFilterTools
theTileRawChannelBuilderOptATLAS.OF2 = True
#theTileRawChannelBuilderOptATLAS.PedestalMode = 1 # not sure if we need this option here
theTileRawChannelBuilderOptATLAS.MaxIterations = 1 # just one iteration
theTileRawChannelBuilderOptATLAS.Minus1Iteration = False # assume that max sample is at t=0
theTileRawChannelBuilderOptATLAS.AmplitudeCorrection = jobproperties.TileRecFlags.correctAmplitude()
theTileRawChannelBuilderOptATLAS.TimeCorrection = jobproperties.TileRecFlags.correctTimeNI()
theTileRawChannelBuilderOptATLAS.AmpMinForAmpCorrection = jobproperties.TileRecFlags.AmpMinForAmpCorrection()
if jobproperties.TileRecFlags.TimeMaxForAmpCorrection() > jobproperties.TileRecFlags.TimeMinForAmpCorrection():
theTileRawChannelBuilderOptATLAS.TimeMinForAmpCorrection = jobproperties.TileRecFlags.TimeMinForAmpCorrection()
theTileRawChannelBuilderOptATLAS.TimeMaxForAmpCorrection = jobproperties.TileRecFlags.TimeMaxForAmpCorrection()
theTileRawChannelBuilderOptATLAS.DSPContainer = TileRawChannelContainerDSP
mlog.info(" adding now TileRawChannelBuilderOpt2Filter with name TileRawChannelBuilderOptATLAS to the algorithm: %s",
theTileRawChannelMaker.name())
theTileRawChannelMaker.TileRawChannelBuilder += [theTileRawChannelBuilderOptATLAS]
self._TileRawChannelBuilderOptATLAS = theTileRawChannelBuilderOptATLAS
if jobproperties.TileRecFlags.doTileWiener():
try:
from TileRecUtils.TileRecUtilsConf import TileRawChannelBuilderWienerFilter
theTileRawChannelBuilderWienerFilter= TileRawChannelBuilderWienerFilter()
except Exception:
mlog.error("could not get handle to TileRawChannelBuilderWienerFilter Quit")
traceback.print_exc()
return False
#TileRawChannelBuilderWienerFilter Options:
jobproperties.TileRecFlags.TileRawChannelContainer = "TileRawChannelWiener"
theTileRawChannelBuilderWienerFilter.TileRawChannelContainer = "TileRawChannelWiener"
theTileRawChannelBuilderWienerFilter.RunType = jobproperties.TileRecFlags.TileRunType()
theTileRawChannelBuilderWienerFilter.calibrateEnergy = jobproperties.TileRecFlags.calibrateEnergy()
theTileRawChannelBuilderWienerFilter.correctTime = jobproperties.TileRecFlags.correctTime()
theTileRawChannelBuilderWienerFilter.NoiseFilterTools = NoiseFilterTools
theTileRawChannelBuilderWienerFilter.BestPhase = False # no point to use best phase with interations
theTileRawChannelBuilderWienerFilter.MC = globalflags.DataSource()!='data'
theTileRawChannelBuilderWienerFilter.PedestalMode = 1
theTileRawChannelBuilderWienerFilter.MaxIterations = 5
theTileRawChannelBuilderWienerFilter.Minus1Iteration = True
theTileRawChannelBuilderWienerFilter.AmplitudeCorrection = False # don't need correction after iterations
theTileRawChannelBuilderWienerFilter.TimeCorrection = False # don't need correction after iterations
theTileRawChannelBuilderWienerFilter.DSPContainer = TileRawChannelContainerDSP
ServiceMgr.TileInfoLoader.LoadWienerFilterWeights = True
mlog.info(" adding now TileRawChannelBuilderWienerFilter to the algorithm: %s", theTileRawChannelMaker.name())
theTileRawChannelMaker.TileRawChannelBuilder += [theTileRawChannelBuilderWienerFilter]
self._TileRawChannelBuilderWienerFilter = theTileRawChannelBuilderWienerFilter
# now add algorithm to topSequence
# this should always come at the end
mlog.info(" now adding to topSequence")
if jobproperties.TileRecFlags.noiseFilter() == 2:
# Instantiation of the C++ algorithm
try:
from TileRecUtils.TileRecUtilsConf import TileRawCorrelatedNoise
theTileRawCorrelatedNoise=TileRawCorrelatedNoise("TileRCorreNoise")
except Exception:
mlog.error("could not import TileRecUtils.TileRawCorrelatedNoise")
traceback.print_exc()
return False
#theTileRawCorrelatedNoise.UseMeanFiles = False
#theTileRawCorrelatedNoise.PMTOrder = True
jobproperties.TileRecFlags.TileDigitsContainer = "NewDigitsContainer"
topSequence += theTileRawCorrelatedNoise
jobproperties.TileRecFlags.print_JobProperties('tree&value')
theTileRawChannelMaker.TileDigitsContainer = jobproperties.TileRecFlags.TileDigitsContainer()
topSequence += theTileRawChannelMaker
else:
mlog.info(" Disable all OF methods because readDigits flag set to False ")
jobproperties.TileRecFlags.doTileFlat = False
jobproperties.TileRecFlags.doTileFit = False
jobproperties.TileRecFlags.doTileFitCool = False
jobproperties.TileRecFlags.doTileOpt2 = False
jobproperties.TileRecFlags.doTileOptATLAS = False
jobproperties.TileRecFlags.doTileManyAmps = False
jobproperties.TileRecFlags.doTileMF = False
jobproperties.TileRecFlags.doTileOF1 = False
jobproperties.TileRecFlags.doTileWiener = False
jobproperties.TileRecFlags.OfcFromCOOL = False
jobproperties.TileRecFlags.print_JobProperties('tree&value')
return True
from __main__ import ALLOWIGNORECONFIGERROR
from __main__ import ALLOWDISABLE
from __main__ import ALLOWBACKNAV
from AthenaCommon.Logging import logging
mlog = logging.getLogger('TileDigitiization')
if doTileHitToRawChannelDirect:
from TileSimAlgs.TileRawChannelFromHitsGetter import *
theTileRawChannelFromHitsGetter = TileRawChannelFromHitsGetter()
if doTileHitToDigit:
# Change default parameters for TileDQstatusAlg.
from AthenaCommon.GlobalFlags import globalflags
if globalflags.isOverlay():
from TileRecUtils.TileDQstatusAlgDefault import TileDQstatusAlgDefault
dqstatus = TileDQstatusAlgDefault()
dqstatus.TileBeamElemContainer = ""
# disable reading of trigger type from BeamElem container
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isDataOverlay():
if overlayFlags.isOverlayMT():
dqstatus.TileDigitsContainer = overlayFlags.bkgPrefix(
) + "TileDigitsCnt"
dqstatus.TileRawChannelContainer = overlayFlags.bkgPrefix(
) + "TileRawChannelCnt"
else:
dqstatus.TileDigitsContainer = overlayFlags.dataStore(
) + "+TileDigitsCnt"
###############################################################
#
# TRT Digitization
#
#==============================================================
# File updated April 2007, by Esben Klinkby <*****@*****.**>
from AthenaCommon.Resilience import protectedInclude
protectedInclude("PartPropSvc/PartPropSvc.py")
# Setup to use conditions database folder to steer digitization settings
from AthenaCommon.GlobalFlags import globalflags
if not (globalflags.isOverlay() and globalflags.DataSource == 'data'):
from IOVDbSvc.CondDB import conddb
conddb.addFolder("TRT_OFL", "/TRT/Cond/DigVers")
def configure(self):
from AthenaCommon.Logging import logging
mlog = logging.getLogger('CaloCellGetter::configure:')
mlog.info('entering')
doStandardCellReconstruction = True
from CaloRec.CaloCellFlags import jobproperties
from AthenaCommon.AppMgr import ToolSvc
if not jobproperties.CaloCellFlags.doFastCaloSim.statusOn:
doFastCaloSim = False
mlog.info("doFastCaloSim not set, so not using it")
else:
doFastCaloSim = jobproperties.CaloCellFlags.doFastCaloSim()
if doFastCaloSim:
mlog.info("doFastCaloSim requested")
doStandardCellReconstruction = False
if jobproperties.CaloCellFlags.doFastCaloSimAddCells():
doStandardCellReconstruction = True
mlog.info(
"doFastCaloSimAddCells requested: FastCaloSim is added to fullsim calorimeter"
)
else:
mlog.info(
"doFastCaloSimAddCells not requested: Stand alone FastCaloSim is running"
)
else:
mlog.info("doFastCaloSim explicitly not requested")
# get handle to upstream object
# handle tile
if doStandardCellReconstruction:
from LArROD.LArRODFlags import larRODFlags
from AthenaCommon.GlobalFlags import globalflags
if larRODFlags.readDigits() and globalflags.DataSource() == 'data':
from LArROD.LArRawChannelBuilderDefault import LArRawChannelBuilderDefault
LArRawChannelBuilderDefault()
# writing of thinned digits
if jobproperties.CaloCellFlags.doLArThinnedDigits.statusOn and jobproperties.CaloCellFlags.doLArThinnedDigits(
):
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource() == 'data':
try:
from LArROD.LArDigits import DefaultLArDigitThinner
LArDigitThinner = DefaultLArDigitThinner(
'LArDigitThinner'
) # automatically added to topSequence
LArDigitThinner.InputContainerName = "FREE"
LArDigitThinner.OutputContainerName = "LArDigitContainer_Thinned"
except Exception:
treatException("Problem with LArDigitThinner ")
# now configure the algorithm, part of this could be done in a separate class
# cannot have same name
try:
from CaloRec.CaloRecConf import CaloCellMaker
except Exception:
mlog.error("could not import CaloRec.CaloCellMaker")
print(traceback.format_exc())
return False
theCaloCellMaker = CaloCellMaker()
self._CaloCellMakerHandle = theCaloCellMaker
if doStandardCellReconstruction:
# configure CaloCellMaker here
# check LArCellMakerTool_jobOptions.py for full configurability
# FIXME
if rec.doLArg():
from LArCabling.LArCablingAccess import LArOnOffIdMapping
LArOnOffIdMapping()
try:
from LArCellRec.LArCellRecConf import LArCellBuilderFromLArRawChannelTool
theLArCellBuilder = LArCellBuilderFromLArRawChannelTool()
except Exception:
mlog.error(
"could not get handle to LArCellBuilderFromLArRawChannel Quit"
)
print(traceback.format_exc())
return False
if jobproperties.CaloCellFlags.doLArCreateMissingCells():
theLArCellBuilder.addDeadOTX = True
# add the tool to list of tool ( should use ToolHandle eventually)
theCaloCellMaker += theLArCellBuilder
theCaloCellMaker.CaloCellMakerToolNames += [theLArCellBuilder]
if rec.doTile():
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource(
) == 'data' and globalflags.InputFormat() == 'bytestream':
try:
svcMgr.ByteStreamCnvSvc.ROD2ROBmap = ["-1"]
if "TileDigitsContainer/TileDigitsCnt" not in svcMgr.ByteStreamAddressProviderSvc.TypeNames:
svcMgr.ByteStreamAddressProviderSvc.TypeNames += [
"TileBeamElemContainer/TileBeamElemCnt",
"TileDigitsContainer/TileDigitsCnt",
"TileL2Container/TileL2Cnt",
"TileLaserObject/TileLaserObj",
"TileMuonReceiverContainer/TileMuRcvCnt"
]
except Exception:
mlog.warning(
"Cannot add TileDigitsContainer/TileDigitsCnt et al. to bytestream list"
)
# set options for TileRawChannelMaker
from TileRecUtils.TileRecFlags import jobproperties
jobproperties.TileRecFlags.TileRunType = 1 # physics run type
# reading of digits can be disabled before calling CaloCellGetter
# if this is not done, but digits are not available in BS file
# reading of digits is automatically disabled at start of run
if jobproperties.TileRecFlags.readDigits() \
and not (jobproperties.TileRecFlags.doTileFlat \
or jobproperties.TileRecFlags.doTileFit \
or jobproperties.TileRecFlags.doTileFitCool \
or jobproperties.TileRecFlags.doTileOF1 \
or jobproperties.TileRecFlags.doTileOpt2 \
or jobproperties.TileRecFlags.doTileOptATLAS \
or jobproperties.TileRecFlags.doTileMF):
from AthenaCommon.BeamFlags import jobproperties
# run Opt filter with iterations by default, both for cosmics and collisions before 2011
# run Opt filter without iterations for collisions in 2011 and later
if 'doTileOpt2' not in dir():
from RecExConfig.AutoConfiguration import GetRunNumber
rn = GetRunNumber()
if not athenaCommonFlags.isOnline(
) and rn > 0 and rn < 171194:
doTileOpt2 = True
elif jobproperties.Beam.beamType() == 'collisions':
doTileOpt2 = False # use OF without iterations for collisions
else:
doTileOpt2 = True # always run OF with iterations for cosmics
# jobproperties.TileRecFlags.calibrateEnergy=True # use pCb for RawChannels
# please, note that time correction and best phase are used only for collisions
if doTileOpt2:
jobproperties.TileRecFlags.doTileOpt2 = True # run optimal filter with iterations
jobproperties.TileRecFlags.doTileOptATLAS = False # disable optimal filter without iterations
jobproperties.TileRecFlags.correctAmplitude = False # don't do parabolic correction
if jobproperties.Beam.beamType() == 'collisions':
jobproperties.TileRecFlags.correctTime = True # apply time correction in physics runs
jobproperties.TileRecFlags.BestPhaseFromCOOL = False # best phase is not needed for iterations
else:
jobproperties.TileRecFlags.doTileOpt2 = False # disable optimal filter with iterations
jobproperties.TileRecFlags.doTileOptATLAS = True # run optimal filter without iterations
jobproperties.TileRecFlags.correctAmplitude = True # apply parabolic correction
if jobproperties.Beam.beamType() == 'collisions':
jobproperties.TileRecFlags.correctTime = False # don't need time correction if best phase is used
jobproperties.TileRecFlags.BestPhaseFromCOOL = True # use best phase stored in DB
try:
from TileRecUtils.TileRawChannelGetter import TileRawChannelGetter
theTileRawChannelGetter = TileRawChannelGetter(
) # noqa: F841
except Exception:
mlog.error("could not load TileRawChannelGetter Quit")
print(traceback.format_exc())
return False
try:
from TileRecAlgs.TileRecAlgsConf import TileDigitsFilter
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
topSequence += TileDigitsFilter()
except Exception:
mlog.error("Could not configure TileDigitsFilter")
from AthenaCommon.AlgSequence import AthSequencer
condSequence = AthSequencer("AthCondSeq")
checkDCS = hasattr(condSequence, 'TileDCSCondAlg')
try:
from TileRecUtils.TileRecUtilsConf import TileCellBuilder
theTileCellBuilder = TileCellBuilder(CheckDCS=checkDCS)
from TileRecUtils.TileRecFlags import jobproperties
theTileCellBuilder.TileRawChannelContainer = jobproperties.TileRecFlags.TileRawChannelContainer(
)
if (jobproperties.TileRecFlags.noiseFilter() == 1
and jobproperties.TileRecFlags.readDigits()
and globalflags.DataSource() == 'data'
and not globalflags.isOverlay()):
theTileCellBuilder.TileDSPRawChannelContainer = 'TileRawChannelCntCorrected'
rawChannelContainer = ''
if globalflags.DataSource(
) == 'data' and globalflags.InputFormat() == 'bytestream':
if jobproperties.TileRecFlags.readDigits():
# everything is already corrected at RawChannel level
theTileCellBuilder.correctTime = False
theTileCellBuilder.correctAmplitude = False
else:
rawChannelContainer = 'TileRawChannelCnt'
# by default parameters are tuned for opt.filter without iterations
theTileCellBuilder.correctTime = jobproperties.TileRecFlags.correctTime(
)
theTileCellBuilder.correctAmplitude = jobproperties.TileRecFlags.correctAmplitude(
)
theTileCellBuilder.AmpMinForAmpCorrection = jobproperties.TileRecFlags.AmpMinForAmpCorrection(
)
if jobproperties.TileRecFlags.TimeMaxForAmpCorrection(
) <= jobproperties.TileRecFlags.TimeMinForAmpCorrection(
):
from AthenaCommon.BeamFlags import jobproperties
mlog.info(
"adjusting min/max time of parabolic correction for %s",
jobproperties.Beam.bunchSpacing)
halfBS = jobproperties.Beam.bunchSpacing.get_Value(
) / 2.
jobproperties.TileRecFlags.TimeMinForAmpCorrection = -halfBS
jobproperties.TileRecFlags.TimeMaxForAmpCorrection = halfBS
if jobproperties.TileRecFlags.TimeMaxForAmpCorrection(
) > jobproperties.TileRecFlags.TimeMinForAmpCorrection(
):
theTileCellBuilder.TimeMinForAmpCorrection = jobproperties.TileRecFlags.TimeMinForAmpCorrection(
)
theTileCellBuilder.TimeMaxForAmpCorrection = jobproperties.TileRecFlags.TimeMaxForAmpCorrection(
)
theCaloCellMaker += theTileCellBuilder
theCaloCellMaker.CaloCellMakerToolNames += [
theTileCellBuilder
]
except Exception:
mlog.error("could not get handle to TileCellBuilder Quit")
print(traceback.format_exc())
return False
if doFastCaloSim:
mlog.info('configuring FastCaloSim here')
try:
from FastCaloSim.FastCaloSimConf import EmptyCellBuilderTool
theEmptyCellBuilderTool = EmptyCellBuilderTool()
theCaloCellMaker += theEmptyCellBuilderTool
theCaloCellMaker.CaloCellMakerToolNames += [
theEmptyCellBuilderTool
]
print(theEmptyCellBuilderTool)
mlog.info("configure EmptyCellBuilderTool worked")
except Exception:
mlog.error("could not get handle to EmptyCellBuilderTool Quit")
print(traceback.format_exc())
return False
try:
from FastCaloSim.FastCaloSimFactory import FastCaloSimFactory
theFastShowerCellBuilderTool = FastCaloSimFactory()
theCaloCellMaker += theFastShowerCellBuilderTool
theCaloCellMaker.CaloCellMakerToolNames += [
theFastShowerCellBuilderTool
]
mlog.info("configure FastShowerCellBuilderTool worked")
except Exception:
mlog.error(
"could not get handle to FastShowerCellBuilderTool Quit")
print(traceback.format_exc())
return False
doFastCaloSimNoise = jobproperties.CaloCellFlags.doFastCaloSimNoise(
)
if doFastCaloSimNoise:
try:
from FastCaloSim.AddNoiseCellBuilderToolDefault import AddNoiseCellBuilderToolDefault
theAddNoiseCellBuilderTool = AddNoiseCellBuilderToolDefault(
)
print(theAddNoiseCellBuilderTool)
theCaloCellMaker += theAddNoiseCellBuilderTool
theCaloCellMaker.CaloCellMakerToolNames += [
theAddNoiseCellBuilderTool
]
mlog.info("configure AddNoiseCellBuilderTool worked")
except Exception:
mlog.error(
"could not get handle to AddNoiseCellBuilderTool Quit")
print(traceback.format_exc())
return False
#
# CaloCellContainerFinalizerTool : closing container and setting up iterators
#
from CaloRec.CaloRecConf import CaloCellContainerFinalizerTool
theCaloCellContainerFinalizerTool = CaloCellContainerFinalizerTool()
theCaloCellMaker += theCaloCellContainerFinalizerTool
theCaloCellMaker.CaloCellMakerToolNames += [
theCaloCellContainerFinalizerTool
]
#
# Mergeing of calo cellcontainer with sparse raw channel container with improved energies
#
doLArMerge = False
if globalflags.DataSource(
) == 'data' and jobproperties.CaloCellFlags.doLArRawChannelMerge.statusOn and jobproperties.CaloCellFlags.doLArRawChannelMerge(
):
from LArROD.LArRODFlags import larRODFlags
if larRODFlags.readDigits() and larRODFlags.keepDSPRaw():
doLArMerge = True
if doLArMerge:
try:
from LArCellRec.LArCellRecConf import LArCellMerger
theLArCellMerger = LArCellMerger()
except Exception:
mlog.error("could not get handle to LArCellMerge Quit")
print(traceback.format_exc())
return False
theLArCellMerger.RawChannelsName = larRODFlags.RawChannelFromDigitsContainerName(
)
theCaloCellMaker += theLArCellMerger
theCaloCellMaker.CaloCellMakerToolNames += [theLArCellMerger]
#
# masking of noisy and sporadic noisy cells in LAr
#
doNoiseMask = False
if jobproperties.CaloCellFlags.doLArNoiseMasking.statusOn and jobproperties.CaloCellFlags.doLArNoiseMasking(
):
doNoiseMask = True
doSporadicMask = False
if jobproperties.CaloCellFlags.doLArSporadicMasking.statusOn and jobproperties.CaloCellFlags.doLArSporadicMasking(
):
doSporadicMask = True
if doNoiseMask or doSporadicMask:
try:
from LArCellRec.LArCellRecConf import LArCellNoiseMaskingTool
theLArCellNoiseMaskingTool = LArCellNoiseMaskingTool()
except Exception:
mlog.error(
"could not get handle to LArCellNoiseMaskingTool Quit")
print(traceback.format_exc())
return False
if doSporadicMask:
try:
from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelMasker
theLArSporadicNoiseMasker = LArBadChannelMasker(
"LArSporadicNoiseMasker")
except Exception:
mlog.error("could not access bad channel tool Quit")
print(traceback.format_exc())
return False
theLArSporadicNoiseMasker.DoMasking = True
theLArSporadicNoiseMasker.ProblemsToMask = [
"sporadicBurstNoise"
]
#ToolSvc += theLArSporadicNoiseMasker
theLArCellNoiseMaskingTool.MaskingSporadicTool = theLArSporadicNoiseMasker
if doNoiseMask:
try:
from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelMasker
theLArNoiseMasker = LArBadChannelMasker("LArNoiseMasker")
except Exception:
mlog.error("could not access bad channel tool Quit")
print(traceback.format_exc())
return False
theLArNoiseMasker.DoMasking = True
theLArNoiseMasker.ProblemsToMask = [
"highNoiseHG", "highNoiseMG", "highNoiseLG", "deadReadout",
"deadPhys"
]
#ToolSvc+=theLArNoiseMasker
theLArCellNoiseMaskingTool.MaskingTool = theLArNoiseMasker
theLArCellNoiseMaskingTool.maskNoise = doNoiseMask
theLArCellNoiseMaskingTool.maskSporadic = doSporadicMask
# quality cut for sporadic noise masking
theLArCellNoiseMaskingTool.qualityCut = 4000
theCaloCellMaker += theLArCellNoiseMaskingTool
theCaloCellMaker.CaloCellMakerToolNames += [
theLArCellNoiseMaskingTool
]
#
# masking of Feb problems
#
doBadFebMasking = False
if jobproperties.CaloCellFlags.doLArBadFebMasking.statusOn and jobproperties.CaloCellFlags.doLArBadFebMasking(
):
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource() == 'data':
doBadFebMasking = True
if doBadFebMasking:
try:
from LArCellRec.LArCellRecConf import LArBadFebMaskingTool
theLArBadFebMaskingTool = LArBadFebMaskingTool()
if (
rec.doExpressProcessing()
or athenaCommonFlags.isOnline()
): # In online or express processing, EventInfo::LArError is triggered if >=4 FEB with data corrupted
theLArBadFebMaskingTool.minFebInError = 4
except Exception:
mlog.error("could not get handle to LArBadFebMaskingTool Quit")
print(traceback.format_exc())
return False
theCaloCellMaker += theLArBadFebMaskingTool
theCaloCellMaker.CaloCellMakerToolNames += [
theLArBadFebMaskingTool
]
#
# emulate gain pathologies on MC
#
doGainPathology = False
if jobproperties.CaloCellFlags.doLArCellGainPathology.statusOn and jobproperties.CaloCellFlags.doLArCellGainPathology(
):
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource() == 'geant4':
doGainPathology = True
if doGainPathology:
try:
from LArCellRec.LArCellRecConf import LArCellGainPathology
theLArCellGainPathology = LArCellGainPathology()
except Exception:
mlog.error("could not get handle to LArCellGainPatholog< Quit")
print(traceback.format_exc())
return False
theCaloCellMaker += theLArCellGainPathology
theCaloCellMaker.CaloCellMakerToolNames += [
theLArCellGainPathology
]
# lar miscalibration if MC only (should be done after finalisation)
if not jobproperties.CaloCellFlags.doLArCellEmMisCalib.statusOn:
# the flag has not been set, so decide a reasonable default
# this is the old global flags should use the new one as
# soon as monitoring does
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource() == 'data':
doLArCellEmMisCalib = False
mlog.info(
"jobproperties.CaloCellFlags.doLArMisCalib not set and real data: do not apply LArCellEmMisCalibTool"
)
else:
doLArCellEmMisCalib = True
mlog.info(
"jobproperties.CaloCellFlags.doLArMisCalib not set and Monte Carlo: apply LArCellEmMisCalibTool"
)
else:
doLArCellEmMisCalib = jobproperties.CaloCellFlags.doLArCellEmMisCalib(
)
if doLArCellEmMisCalib:
mlog.info("LArCellEmMisCalibTool requested")
else:
mlog.info("LArCellEmMisCalibTool explicitly not requested")
if doLArCellEmMisCalib:
try:
from LArCellRec.LArCellRecConf import LArCellEmMiscalib
theLArCellEmMiscalib = LArCellEmMiscalib("LArCellEmMiscalib")
except Exception:
mlog.error("could not get handle to LArCellEmMisCalib Quit")
print(traceback.format_exc())
return False
# examples on how to change miscalibration. Default values are 0.005 and 0.007
# theLArCellEmMiscalib.SigmaPerRegion = 0.005
# theLArCellEmMiscalib.SigmaPerCell = 0.005
try:
from CaloRec.CaloRecConf import CaloCellContainerCorrectorTool
from CaloIdentifier import SUBCALO
theMisCalibTool = CaloCellContainerCorrectorTool(
"MisCalibTool",
CaloNums=[SUBCALO.LAREM],
CellCorrectionToolNames=[theLArCellEmMiscalib])
except Exception:
mlog.error("could not get handle to MisCalibTool Quit")
print(traceback.format_exc())
return False
theCaloCellMaker += theMisCalibTool
theCaloCellMaker.CaloCellMakerToolNames += [theMisCalibTool]
#
# Pedestal shift correction
#
doPedestalCorr = False
if jobproperties.CaloCellFlags.doPedestalCorr.statusOn:
from AthenaCommon.GlobalFlags import globalflags
if jobproperties.CaloCellFlags.doPedestalCorr() and (
globalflags.DataSource() == 'data'
or jobproperties.CaloCellFlags.doPileupOffsetBCIDCorr):
doPedestalCorr = True
mlog.info("Apply cell level pedestal shift correction")
if doPedestalCorr:
try:
from CaloCellCorrection.CaloCellPedestalCorrDefault import CaloCellPedestalCorrDefault
theCaloCellPedestalCorr = CaloCellPedestalCorrDefault()
theCaloCellMaker += theCaloCellPedestalCorr
theCaloCellMaker.CaloCellMakerToolNames += [
theCaloCellPedestalCorr
]
except Exception:
mlog.error("could not get handle to CaloCellPedestalCorr")
print(traceback.format_exc())
#
# HV correction for offline reprocessing, reading HV from Cool-DCS database
#
doHVCorr = False
from AthenaCommon.DetFlags import DetFlags
if DetFlags.dcs.LAr_on():
if jobproperties.CaloCellFlags.doLArHVCorr.statusOn:
from AthenaCommon.GlobalFlags import globalflags
if jobproperties.CaloCellFlags.doLArHVCorr(
) and globalflags.DataSource() == 'data':
doHVCorr = True
mlog.info(
"Redoing HV correction at cell level from COOL/DCS database"
)
if doHVCorr:
from LArCellRec.LArCellRecConf import LArCellContHVCorrTool
theLArCellHVCorrTool = LArCellContHVCorrTool()
#theCaloCellMaker += theHVCorrTool
theCaloCellMaker.CaloCellMakerToolNames += [theLArCellHVCorrTool]
#
# correction to undo online calibration and apply new LAr electronics calibration for ADC->MeV conversion
#
doLArRecalibration = False
if jobproperties.CaloCellFlags.doLArRecalibration.statusOn:
from AthenaCommon.GlobalFlags import globalflags
from LArConditionsCommon.LArCondFlags import larCondFlags
if jobproperties.CaloCellFlags.doLArRecalibration(
) and globalflags.DataSource() == 'data' and (
not larCondFlags.SingleVersion()):
doLArRecalibration = True
mlog.info("Redoing LAr electronics calibration for ADC->MeV")
if doLArRecalibration:
# get tool for cell recalibration
try:
from LArCellRec.LArCellRecConf import LArCellRecalibration
theLArCellRecalibration = LArCellRecalibration(
"LArCellRecalibration")
except Exception:
mlog.error("could not get handle to LArCellRecalibration Quit")
print(traceback.format_exc())
return False
# get new ADC2MeVTool
try:
from LArRecUtils.LArADC2MeVToolDefault import LArADC2MeVToolDefault
theLArADC2MeVToolDefault = LArADC2MeVToolDefault()
except Exception:
mlog.error(
"Could not get handle to LArADC2MeVToolDefault Quit")
print(traceback.format_exc())
return False
ToolSvc += theLArADC2MeVToolDefault
# get old ADC2MeVTool
try:
from LArRecUtils.LArADC2MeVToolOnline import LArADC2MeVToolOnline
theLArADC2MeVToolOnline = LArADC2MeVToolOnline()
except Exception:
mlog.error("Could not get handle to LArADC2MeVToolOnline Quit")
print(traceback.format_exc())
return False
ToolSvc += theLArADC2MeVToolOnline
theLArCellRecalibration.adc2MeVTool = theLArADC2MeVToolDefault
theLArCellRecalibration.adc2MeVToolOnline = theLArADC2MeVToolOnline
try:
from CaloRec.CaloRecConf import CaloCellContainerCorrectorTool
from CaloIdentifier import SUBCALO
theLArRecalibrationTool = CaloCellContainerCorrectorTool(
"LArRecalibrationTool",
CaloNums=[SUBCALO.LAREM, SUBCALO.LARHEC, SUBCALO.LARFCAL],
CellCorrectionToolNames=[theLArCellRecalibration])
except Exception:
mlog.error("could not get handle to HVCorrTool Quit")
print(traceback.format_exc())
return False
theCaloCellMaker += theLArRecalibrationTool
theCaloCellMaker.CaloCellMakerToolNames += [
theLArRecalibrationTool
]
#
# Correction for MinBias energy shift for MC pileup reco
#
doMinBiasAverage = False
if jobproperties.CaloCellFlags.doMinBiasAverage.statusOn:
from AthenaCommon.GlobalFlags import globalflags
from AthenaCommon.BeamFlags import jobproperties
if jobproperties.CaloCellFlags.doMinBiasAverage(
) and globalflags.DataSource() == 'geant4' and (
not jobproperties.Beam.zeroLuminosity()):
doMinBiasAverage = True
if doMinBiasAverage:
try:
from CaloTools.CaloMBAverageToolDefault import CaloMBAverageToolDefault
theCaloMBAverageTool = CaloMBAverageToolDefault()
except Exception:
mlog.error("could not get handle to CaloMBAverageTool Quit")
print(traceback.format_exc())
return False
ToolSvc += theCaloMBAverageTool
try:
from CaloCellCorrection.CaloCellCorrectionConf import CaloCellMBAverageCorr
theCaloCellMBAverageCorr = CaloCellMBAverageCorr(
"CaloCellMBAverageCorr")
theCaloCellMBAverageCorr.CaloMBAverageTool = theCaloMBAverageTool
except Exception:
mlog.error(
"could not get handle to CaloCellMBAverageCorr Quit")
print(traceback.format_exc())
return False
try:
from CaloRec.CaloRecConf import CaloCellContainerCorrectorTool
from CaloIdentifier import SUBCALO
theMBAverageTool = CaloCellContainerCorrectorTool(
"MBAverageTool",
CaloNums=[SUBCALO.NSUBCALO],
CellCorrectionToolNames=[theCaloCellMBAverageCorr])
except Exception:
mlog.error(
"could not get handle to CaloCellContainerCorrectorTool/MBAverageTool Quit"
)
print(traceback.format_exc())
return False
theCaloCellMaker += theMBAverageTool
theCaloCellMaker.CaloCellMakerToolNames += [theMBAverageTool]
#
# Correction for dead cells, where we average the energy density of neighbor cells
#
doNeighborsAverage = False
if jobproperties.CaloCellFlags.doDeadCellCorr.statusOn:
if jobproperties.CaloCellFlags.doDeadCellCorr():
doNeighborsAverage = True
if doNeighborsAverage:
try:
from CaloCellCorrection.CaloCellCorrectionConf import CaloCellNeighborsAverageCorr
theCaloCellNeighborsAverageCorr = CaloCellNeighborsAverageCorr(
"CaloCellNeighborsAverageCorr")
theCaloCellNeighborsAverageCorr.testMode = False
except Exception:
mlog.error(
"could not get handle to CaloCellNeighborsAverageCorr Quit"
)
print(traceback.format_exc())
return False
theCaloCellMaker += theCaloCellNeighborsAverageCorr
theCaloCellMaker.CaloCellMakerToolNames += [
theCaloCellNeighborsAverageCorr
]
#
# correction for missing Febs based on L1 readout
doLArDeadOTXCorr = False
if jobproperties.CaloCellFlags.doLArDeadOTXCorr.statusOn and jobproperties.CaloCellFlags.doLArCreateMissingCells.statusOn:
if jobproperties.CaloCellFlags.doLArDeadOTXCorr(
) and jobproperties.CaloCellFlags.doLArCreateMissingCells(
) and doStandardCellReconstruction:
if rec.doTrigger():
doLArDeadOTXCorr = True
else:
if globalflags.DataSource.get_Value(
) != 'geant4': #warning only if not MC
mlog.warning(
"Trigger is switched off. Can't run deadOTX correction."
)
if doLArDeadOTXCorr:
try:
from LArCellRec.LArCellDeadOTXCorrToolDefault import LArCellDeadOTXCorrToolDefault
theLArCellDeadOTXCorr = LArCellDeadOTXCorrToolDefault()
except Exception:
mlog.error("could not get handle to LArCellDeadOTXCorr Quit")
print(traceback.format_exc())
theCaloCellMaker += theLArCellDeadOTXCorr
theCaloCellMaker.CaloCellMakerToolNames += [theLArCellDeadOTXCorr]
if jobproperties.CaloCellFlags.doCaloCellEnergyCorr(
) and globalflags.DataSource(
) == 'data' and not athenaCommonFlags.isOnline():
try:
from CaloCellCorrection.CaloCellCorrectionConf import CaloCellEnergyRescaler
theCCERescalerTool = CaloCellEnergyRescaler()
theCCERescalerTool.Folder = "/LAR/CellCorrOfl/EnergyCorr"
from IOVDbSvc.CondDB import conddb
# conddb.addFolder("","/LAR/CellCorrOfl/EnergyCorr<tag>EnergyScale-00</tag><db>sqlite://;schema=escale.db;dbname=COMP200</db>")
conddb.addFolder("LAR_OFL",
"/LAR/CellCorrOfl/EnergyCorr",
className="AthenaAttributeList")
theCaloCellMaker += theCCERescalerTool
theCaloCellMaker.CaloCellMakerToolNames += [theCCERescalerTool]
except Exception:
mlog.error(
"could not get handle to CaloCellEnergyRescaler Quit")
print(traceback.format_exc())
return False
pass
if jobproperties.CaloCellFlags.doCaloCellTimeCorr(
) and globalflags.DataSource(
) == 'data' and not athenaCommonFlags.isOnline():
try:
from CaloCellCorrection.CaloCellCorrectionConf import CaloCellTimeCorrTool
theLArTimeCorr = CaloCellTimeCorrTool()
theLArTimeCorr.Folder = "/LAR/TimeCorrectionOfl/CellTimeOffset"
from IOVDbSvc.CondDB import conddb
# conddb.addFolder("","/LAR/TimeCorrectionOfl/CellTimeOffset<tag>LARTimeCorrectionOflCellTimeOffset-empty</tag><db>sqlite://;schema=timecorr.db;dbname=COMP200</db>")
conddb.addFolder("LAR_OFL",
"/LAR/TimeCorrectionOfl/CellTimeOffset",
className="AthenaAttributeList")
theCaloCellMaker.CaloCellMakerToolNames += [theLArTimeCorr]
except Exception:
mlog.error("could not get handle to CaloCellTimeCorrTool Quit")
print(traceback.format_exc())
return False
pass
# make lots of checks (should not be necessary eventually)
# to print the check add:
from CaloRec.CaloRecConf import CaloCellContainerCheckerTool
theCaloCellContainerCheckerTool = CaloCellContainerCheckerTool()
# FIXME
# theCaloCellContainerCheckerTool.OutputLevel=DEBUG
theCaloCellMaker += theCaloCellContainerCheckerTool
theCaloCellMaker.CaloCellMakerToolNames += [
theCaloCellContainerCheckerTool
]
#
# sets output key
theCaloCellMaker.CaloCellsOutputName = self.outputKey()
# register output in objKeyStore
from RecExConfig.ObjKeyStore import objKeyStore
objKeyStore.addStreamESD(self.outputType(), self.outputKey())
# Also note that we produce it as a transient output.
objKeyStore.addTransient(self.outputType(), self.outputKey())
from TileRecUtils.TileDQstatusAlgDefault import TileDQstatusAlgDefault
TileDQstatusAlgDefault(TileRawChannelContainer=rawChannelContainer)
# now add algorithm to topSequence
# this should always come at the end
mlog.info(" now adding CaloCellMaker to topSequence")
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
topSequence += theCaloCellMaker
return True
def getSCT_FrontEnd(name="SCT_FrontEnd", **kwargs):
from Digitization.DigitizationFlags import digitizationFlags
#Setup noise treament in SCT_FrontEnd
# To set the mean noise values for the different module types
# Default values set at 0 degrees, plus/minus ~5 enc per plus/minus degree
kwargs.setdefault("NoiseBarrel", 1500.0)
kwargs.setdefault("NoiseBarrel3", 1541.0)
kwargs.setdefault("NoiseInners", 1090.0)
kwargs.setdefault("NoiseMiddles", 1557.0)
kwargs.setdefault("NoiseShortMiddles", 940.0)
kwargs.setdefault("NoiseOuters", 1618.0)
kwargs.setdefault("NOBarrel", 1.5e-5)
kwargs.setdefault("NOBarrel3", 2.1e-5)
kwargs.setdefault("NOInners", 5.0e-9)
kwargs.setdefault("NOMiddles", 2.7e-5)
kwargs.setdefault("NOShortMiddles", 2.0e-9)
kwargs.setdefault("NOOuters", 3.5e-5)
# If noise is turned off:
if not digitizationFlags.doInDetNoise.get_Value():
###kwargs.setdefault("OnlyHitElements", True)
print 'SCT_Digitization:::: Turned off Noise in SCT_FrontEnd'
kwargs.setdefault("NoiseOn", False)
kwargs.setdefault("AnalogueNoiseOn", False)
else:
kwargs.setdefault("NoiseOn", True)
kwargs.setdefault("AnalogueNoiseOn", True)
# In overlay MC, only analogue noise is on. Noise hits are not added.
from AthenaCommon.GlobalFlags import globalflags
if globalflags.isOverlay() and globalflags.DataSource == 'geant4':
kwargs["NoiseOn"] = False
kwargs["AnalogueNoiseOn"] = True
# Use Calibration data from Conditions DB, still for testing purposes only
kwargs.setdefault("UseCalibData", True)
# Setup the ReadCalibChip folders and Svc
from IOVDbSvc.CondDB import conddb
if not conddb.folderRequested('/SCT/DAQ/Calibration/ChipGain'):
conddb.addFolderSplitMC("SCT", "/SCT/DAQ/Calibration/ChipGain",
"/SCT/DAQ/Calibration/ChipGain")
if not conddb.folderRequested('/SCT/DAQ/Calibration/ChipNoise'):
conddb.addFolderSplitMC("SCT", "/SCT/DAQ/Calibration/ChipNoise",
"/SCT/DAQ/Calibration/ChipNoise")
from AthenaCommon.AppMgr import ServiceMgr
if not hasattr(ServiceMgr, "InDetSCT_ReadCalibChipDataSvc"):
from SCT_ConditionsServices.SCT_ConditionsServicesConf import SCT_ReadCalibChipDataSvc
InDetSCT_ReadCalibChipDataSvc = SCT_ReadCalibChipDataSvc(
name="InDetSCT_ReadCalibChipDataSvc")
ServiceMgr += InDetSCT_ReadCalibChipDataSvc
# DataCompressionMode: 1 is level mode x1x (default), 2 is edge mode 01x, 3 is expanded any hit xxx
from AthenaCommon.BeamFlags import jobproperties
if digitizationFlags.PileUpPremixing:
kwargs.setdefault("DataCompressionMode", 3)
elif globalflags.isOverlay() and globalflags.DataSource == 'geant4':
kwargs.setdefault("DataCompressionMode", 2)
elif (jobproperties.Beam.bunchSpacing() <= 50):
kwargs.setdefault("DataCompressionMode", 1)
else:
kwargs.setdefault("DataCompressionMode", 3)
# DataReadOutMode: 0 is condensed mode and 1 is expanded mode
if globalflags.isOverlay() and globalflags.DataSource == 'geant4':
kwargs.setdefault("DataReadOutMode", 0)
else:
kwargs.setdefault("DataReadOutMode", 1)
from SCT_Digitization.SCT_DigitizationConf import SCT_FrontEnd
return SCT_FrontEnd(name, **kwargs)
def getSCT_SurfaceChargesGenerator(name="SCT_SurfaceChargesGenerator",
**kwargs):
## Set up services used by SCT_SurfaceChargesGenerator
## TODO remove all this stuff and see if PixelDigitization works without it.
# Setup the DCS folders and Svc used in the sctSiliconConditionsSvc
from IOVDbSvc.CondDB import conddb
if not conddb.folderRequested('/SCT/DCS/CHANSTAT'):
conddb.addFolder("DCS_OFL", "/SCT/DCS/CHANSTAT")
if not conddb.folderRequested('/SCT/DCS/MODTEMP'):
conddb.addFolder("DCS_OFL", "/SCT/DCS/MODTEMP")
if not conddb.folderRequested('/SCT/DCS/HV'):
conddb.addFolder("DCS_OFL", "/SCT/DCS/HV")
## SCT_DCSConditionsSvc - used by SCT_SurfaceChargesGenerator
from AthenaCommon.AppMgr import ServiceMgr
if not hasattr(ServiceMgr, "InDetSCT_DCSConditionsSvc"):
from SCT_ConditionsServices.SCT_ConditionsServicesConf import SCT_DCSConditionsSvc
InDetSCT_DCSConditionsSvc = SCT_DCSConditionsSvc(
name="InDetSCT_DCSConditionsSvc")
ServiceMgr += InDetSCT_DCSConditionsSvc
## SCT_SiPropertiesSvc - used by SCT_SurfaceChargesGenerator
if not hasattr(ServiceMgr, "SCT_SiPropertiesSvc"):
# Lorentz Angle Service
from SiLorentzAngleSvc.LorentzAngleSvcSetup import lorentzAngleSvc
# Silicon conditions service (set up by LorentzAngleSvcSetup)
sctSiliconConditionsSvc = ServiceMgr.SCT_SiliconConditionsSvc
# Silicon properties service
from SiPropertiesSvc.SiPropertiesSvcConf import SiPropertiesSvc
sctSiPropertiesSvc = SiPropertiesSvc(
name="SCT_SiPropertiesSvc",
DetectorName="SCT",
SiConditionsServices=sctSiliconConditionsSvc)
ServiceMgr += sctSiPropertiesSvc
## Charge trapping service - used by SCT_SurfaceChargesGenerator
if not hasattr(ServiceMgr, "InDetSCT_RadDamageSummarySvc"):
from SCT_ConditionsServices.SCT_ConditionsServicesConf import SCT_RadDamageSummarySvc
InDetSCT_RadDamageSummarySvc = SCT_RadDamageSummarySvc(
name="InDetSCT_RadDamageSummarySvc")
ServiceMgr += InDetSCT_RadDamageSummarySvc
## END OF JUNK
kwargs.setdefault("FixedTime", -999)
kwargs.setdefault("SubtractTime", -999)
kwargs.setdefault("SurfaceDriftTime", 10)
kwargs.setdefault("NumberOfCharges", 1)
kwargs.setdefault("SmallStepLength", 5)
kwargs.setdefault("DepletionVoltage", 70)
kwargs.setdefault("BiasVoltage", 150)
from AthenaCommon.GlobalFlags import globalflags
kwargs.setdefault("isOverlay", globalflags.isOverlay())
from Digitization.DigitizationFlags import digitizationFlags
if 'doDetailedSurfChargesGen' in digitizationFlags.experimentalDigi():
kwargs.setdefault("ChargeDriftModel", 1)
kwargs.setdefault("EFieldModel", 2)
kwargs.setdefault("MagneticField", -2.0)
kwargs.setdefault("SensorTemperature", 273.15)
kwargs.setdefault("TransportTimeStep", 0.25)
kwargs.setdefault("TransportTimeMax", 25.0)
from SCT_Digitization.SCT_DigitizationConf import SCT_DetailedSurfaceChargesGenerator
return SCT_DetailedSurfaceChargesGenerator(name, **kwargs)
else:
from SCT_Digitization.SCT_DigitizationConf import SCT_SurfaceChargesGenerator
return SCT_SurfaceChargesGenerator(name, **kwargs)
def setDefaults(self):
# check on problematic global tags with no association of cabling map folders exist; in this case we use the old cabling
problematic_tags_mdtrpc = [
'COMCOND-00[0-6]', 'COMCOND-HLT[A-C]-00[0-1]',
'COMCOND-MONC-00[0-1]', 'COMCOND-ES1C-00[0-1]',
'COMCOND-REPC-00[0-4]', 'OFLCOND-CSC', 'OFLCOND-FDR'
]
problematic_tags_tgc = [
'COMCOND-00[0-5]', 'COMCOND-006-00', 'CMCCOND-CSC',
'OFLCOND-FDR-02-0[4-6]', 'OFLCOND-FDR-02-10'
]
# MDT
# if globalflags.InputFormat.is_bytestream() and globalflags.DataSource() == 'geant4':
# setDefault(self.MdtCablingMode, 'old')
# else:
# if any(re.match(tag,globalflags.ConditionsTag()) for tag in problematic_tags_mdtrpc):
# setDefault(self.MdtCablingMode, 'old')
# else:
# if globalflags.DataSource() == 'data' or DetFlags.digitize.MDT_on():
# setDefault(self.MdtCablingMode, 'new')
# else:
# setDefault(self.MdtCablingMode, 'auto')
# RPC
if globalflags.InputFormat.is_bytestream() and globalflags.DataSource(
) == 'geant4':
setDefault(self.RpcCablingMode, 'sim')
else:
if any(
re.match(tag, globalflags.ConditionsTag())
for tag in problematic_tags_mdtrpc):
setDefault(self.RpcCablingMode, 'old')
else:
if globalflags.DataSource(
) == 'data' or DetFlags.digitize.RPC_on():
setDefault(self.RpcCablingMode, 'new')
else:
setDefault(self.RpcCablingMode, 'auto')
# if globalflags.DataSource() == 'data':
# # 2010Jan7th - move to new cabling also when the trigger (i.e. LVL1 emul. or HLT algorithms) is on
# #if doTrigger==True or any(re.match(tag,globalflags.ConditionsTag()) for tag in problematic_tags_mdtrpc):
# if any(re.match(tag,globalflags.ConditionsTag()) for tag in problematic_tags_mdtrpc):
# setDefault(self.RpcCablingMode, 'old') # default is old when using trigger
## if doTrigger:
## logMuon.info("RPC cabling: Setting to OLD because of trigger settings")
## else:
# logMuon.info("RPC cabling: Setting to OLD because of condition data tags not including RPC cabling maps")
# else:
# setDefault(self.RpcCablingMode, 'new')
# logMuon.info("RPC cabling: Setting to NEW")
# else:
# setDefault(self.RpcCablingMode, 'sim')
# logMuon.info("RPC cabling: Setting to SIM")
#TGC
setDefault(self.TgcCablingMode, 'auto')
# do not use the call-back for digitization job
#use the call-back in the overlay job that has no bytestream data as input
# and avoid access to Db for problematic tags
if DetFlags.digitize.TGC_on() and not globalflags.isOverlay():
if any(
re.match(tag, globalflags.ConditionsTag())
for tag in problematic_tags_tgc):
setDefault(self.TgcCablingMode, 'old 12-fold')
else:
setDefault(self.TgcCablingMode, '12-fold')
# avoid to use call-back if input is bytestream or data and avoid access to Db for problematic tags
if globalflags.DataSource.is_data(
) or globalflags.InputFormat.is_bytestream():
if any(
re.match(tag, globalflags.ConditionsTag())
for tag in problematic_tags_tgc):
setDefault(self.TgcCablingMode, 'old 12-fold')
else:
setDefault(self.TgcCablingMode, '12-fold')
# call-back works for RDO files only and avoid access to Db for problematic tags
if self.TgcCablingMode() == 'auto' and not DetFlags.haveRDO.TGC_on():
if any(
re.match(tag, globalflags.ConditionsTag())
for tag in problematic_tags_tgc):
setDefault(self.TgcCablingMode, 'old 12-fold')
else:
setDefault(self.TgcCablingMode, '12-fold')
from AthenaCommon.GlobalFlags import globalflags
from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
from OverlayCommonAlgs.OverlayFlags import overlayFlags
from MuonRecExample.MuonRecFlags import muonRecFlags
muonRecFlags.doCSCs.set_Value_and_Lock(True)
from LArConditionsCommon.LArCondFlags import larCondFlags
larCondFlags.LArCoolChannelSelection.set_Value_and_Lock("")
larCondFlags.useShape.set_Value_and_Lock(True)
larCondFlags.OFCShapeFolder.set_Value_and_Lock("")
globalflags.isOverlay.set_Value_and_Lock(True)
isRealData = globalflags.isOverlay()
from AthenaCommon.BeamFlags import jobproperties
jobproperties.Beam.beamType.set_Value_and_Lock("collisions")
import AthenaCommon.AtlasUnixStandardJob
for cf in runArgs.jobConfig:
include(cf)
#==============================================================
# Job definition parameters:
#==============================================================
from AthenaCommon.GlobalFlags import GlobalFlags
from AthenaCommon.GlobalFlags import globalflags
def BasicPixelDigitizationTool(name="PixelDigitizationTool", **kwargs):
from AthenaCommon.AppMgr import ServiceMgr
from AthenaCommon.AppMgr import ToolSvc
from IOVDbSvc.CondDB import conddb
from AtlasGeoModel.CommonGMJobProperties import CommonGeometryFlags as commonGeoFlags
from AtlasGeoModel.InDetGMJobProperties import InDetGeometryFlags as geoFlags
from AthenaCommon.GlobalFlags import globalflags
############################################################################################
# Set up Pixel Module data (2018 condition)
############################################################################################
from AthenaCommon.AlgSequence import AthSequencer
condSeq = AthSequencer("AthCondSeq")
#################
# Module status #
#################
useNewDeadmapFormat = False
useNewChargeFormat = False
if not useNewDeadmapFormat:
if not (conddb.folderRequested("/PIXEL/PixMapOverlay")
or conddb.folderRequested("/PIXEL/Onl/PixMapOverlay")):
conddb.addFolderSplitOnline("PIXEL",
"/PIXEL/Onl/PixMapOverlay",
"/PIXEL/PixMapOverlay",
className='CondAttrListCollection')
if not hasattr(condSeq, 'PixelConfigCondAlg'):
from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelConfigCondAlg
PixelConfigCondAlg.UseCalibConditions = True
PixelConfigCondAlg.UseDeadmapConditions = True
PixelConfigCondAlg.UseDCSStateConditions = False
PixelConfigCondAlg.UseDCSStatusConditions = False
PixelConfigCondAlg.UseDCSHVConditions = True
PixelConfigCondAlg.UseDCSTemperatureConditions = True
PixelConfigCondAlg.UseTDAQConditions = False
PixelConfigCondAlg.UseCablingConditions = False
from AthenaCommon.BeamFlags import jobproperties
if jobproperties.Beam.beamType == "cosmics":
PixelConfigCondAlg.UseComTime = True
PixelConfigCondAlg.BarrelTimeJitter = [25.0, 25.0, 25.0, 25.0]
PixelConfigCondAlg.EndcapTimeJitter = [25.0, 25.0, 25.0]
PixelConfigCondAlg.DBMTimeJitter = [25.0, 25.0, 25.0]
PixelConfigCondAlg.BarrelNumberOfBCID = [8, 8, 8, 8]
PixelConfigCondAlg.EndcapNumberOfBCID = [8, 8, 8]
PixelConfigCondAlg.DBMNumberOfBCID = [8, 8, 8]
PixelConfigCondAlg.BarrelTimeOffset = [100.0, 100.0, 100.0, 100.0]
PixelConfigCondAlg.EndcapTimeOffset = [100.0, 100.0, 100.0]
PixelConfigCondAlg.DBMTimeOffset = [100.0, 100.0, 100.0]
else:
PixelConfigCondAlg.UseComTime = False
PixelConfigCondAlg.BarrelTimeJitter = [0.0, 0.0, 0.0, 0.0]
PixelConfigCondAlg.EndcapTimeJitter = [0.0, 0.0, 0.0]
PixelConfigCondAlg.DBMTimeJitter = [0.0, 0.0, 0.0]
PixelConfigCondAlg.BarrelNumberOfBCID = [1, 1, 1, 1]
PixelConfigCondAlg.EndcapNumberOfBCID = [1, 1, 1]
PixelConfigCondAlg.DBMNumberOfBCID = [1, 1, 1]
PixelConfigCondAlg.BarrelTimeOffset = [5.0, 5.0, 5.0, 5.0]
PixelConfigCondAlg.EndcapTimeOffset = [5.0, 5.0, 5.0]
PixelConfigCondAlg.DBMTimeOffset = [5.0, 5.0, 5.0]
PixelConfigCondAlg.BunchSpace = 25.0
PixelConfigCondAlg.FEI4BarrelHitDiscConfig = [2]
#====================================================================================
# Run-dependent SIMULATION(digitization) parameters:
#====================================================================================
# RUN2 2015/2016
PixelConfigCondAlg.BarrelToTThreshold2016 = [-1, 5, 5, 5]
PixelConfigCondAlg.FEI3BarrelLatency2016 = [0, 151, 256, 256]
PixelConfigCondAlg.FEI3BarrelHitDuplication2016 = [
False, False, False, False
]
PixelConfigCondAlg.FEI3BarrelSmallHitToT2016 = [-1, -1, -1, -1]
PixelConfigCondAlg.FEI3BarrelTimingSimTune2016 = [-1, 2015, 2015, 2015]
PixelConfigCondAlg.BarrelCrossTalk2016 = [0.30, 0.06, 0.06, 0.06]
PixelConfigCondAlg.BarrelNoiseOccupancy2016 = [5e-8, 5e-8, 5e-8, 5e-8]
PixelConfigCondAlg.BarrelDisableProbability2016 = [
9e-3, 9e-3, 9e-3, 9e-3
]
PixelConfigCondAlg.EndcapToTThreshold2016 = [5, 5, 5]
PixelConfigCondAlg.FEI3EndcapLatency2016 = [256, 256, 256]
PixelConfigCondAlg.FEI3EndcapHitDuplication2016 = [False, False, False]
PixelConfigCondAlg.FEI3EndcapSmallHitToT2016 = [-1, -1, -1]
PixelConfigCondAlg.FEI3EndcapTimingSimTune2016 = [2015, 2015, 2015]
PixelConfigCondAlg.EndcapCrossTalk2016 = [0.06, 0.06, 0.06]
PixelConfigCondAlg.EndcapNoiseOccupancy2016 = [5e-8, 5e-8, 5e-8]
PixelConfigCondAlg.EndcapDisableProbability2016 = [9e-3, 9e-3, 9e-3]
PixelConfigCondAlg.DBMToTThreshold2016 = [-1, -1, -1]
PixelConfigCondAlg.DBMCrossTalk2016 = [0.06, 0.06, 0.06]
PixelConfigCondAlg.DBMNoiseOccupancy2016 = [5e-8, 5e-8, 5e-8]
PixelConfigCondAlg.DBMDisableProbability2016 = [9e-3, 9e-3, 9e-3]
PixelConfigCondAlg.IBLNoiseShape2016 = [
0.0, 0.0330, 0.0, 0.3026, 0.5019, 0.6760, 0.8412, 0.9918, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0
]
PixelConfigCondAlg.BLayerNoiseShape2016 = [
0.0, 0.0, 0.0, 0.0, 0.2204, 0.5311, 0.7493, 0.8954, 0.9980, 1.0
]
PixelConfigCondAlg.PixelNoiseShape2016 = [
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.2418, 0.4397, 0.5858, 0.6949,
0.7737, 0.8414, 0.8959, 0.9414, 0.9828, 1.0
]
# Layer-2 noise shape [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.2129, 0.4016, 0.5477, 0.6599, 0.7435, 0.8160, 0.8779, 0.9340, 0.9798, 1.0]
# So far, Gaudi::Property does not support 2D vector.
#PixelConfigCondAlg.EndcapNoiseShape=[[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.1748, 0.3409, 0.4760, 0.5850, 0.6754, 0.7538, 0.8264, 0.8962, 0.9655, 1.0],
# [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.1852, 0.3528, 0.4881, 0.5961, 0.6855, 0.7640, 0.8374, 0.9068, 0.9749, 1.0],
# [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.1735, 0.3380, 0.4733, 0.5829, 0.6730, 0.7516, 0.8234, 0.8916, 0.9595, 1.0]]
#====================================================================================
# RUN2 2017
PixelConfigCondAlg.BarrelToTThreshold2017 = [-1, 5, 5, 5]
PixelConfigCondAlg.FEI3BarrelLatency2017 = [0, 151, 256, 256]
PixelConfigCondAlg.FEI3BarrelHitDuplication2017 = [
False, False, False, False
]
PixelConfigCondAlg.FEI3BarrelSmallHitToT2017 = [-1, -1, -1, -1]
PixelConfigCondAlg.FEI3BarrelTimingSimTune2017 = [-1, 2018, 2018, 2018]
PixelConfigCondAlg.BarrelCrossTalk2017 = [0.30, 0.06, 0.06, 0.06]
PixelConfigCondAlg.BarrelNoiseOccupancy2017 = [5e-8, 5e-8, 5e-8, 5e-8]
PixelConfigCondAlg.BarrelDisableProbability2017 = [
9e-3, 9e-3, 9e-3, 9e-3
]
PixelConfigCondAlg.EndcapToTThreshold2017 = [5, 5, 5]
PixelConfigCondAlg.FEI3EndcapLatency2017 = [256, 256, 256]
PixelConfigCondAlg.FEI3EndcapHitDuplication2017 = [False, False, False]
PixelConfigCondAlg.FEI3EndcapSmallHitToT2017 = [-1, -1, -1]
PixelConfigCondAlg.FEI3EndcapTimingSimTune2017 = [2018, 2018, 2018]
PixelConfigCondAlg.EndcapCrossTalk2017 = [0.06, 0.06, 0.06]
PixelConfigCondAlg.EndcapNoiseOccupancy2017 = [5e-8, 5e-8, 5e-8]
PixelConfigCondAlg.EndcapDisableProbability2017 = [9e-3, 9e-3, 9e-3]
PixelConfigCondAlg.DBMToTThreshold2017 = [-1, -1, -1]
PixelConfigCondAlg.DBMCrossTalk2017 = [0.06, 0.06, 0.06]
PixelConfigCondAlg.DBMNoiseOccupancy2017 = [5e-8, 5e-8, 5e-8]
PixelConfigCondAlg.DBMDisableProbability2017 = [9e-3, 9e-3, 9e-3]
PixelConfigCondAlg.IBLNoiseShape2017 = [
0.0, 0.0330, 0.0, 0.3026, 0.5019, 0.6760, 0.8412, 0.9918, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0
]
PixelConfigCondAlg.BLayerNoiseShape2017 = [
0.0, 0.0, 0.0, 0.0, 0.2204, 0.5311, 0.7493, 0.8954, 0.9980, 1.0
]
PixelConfigCondAlg.PixelNoiseShape2017 = [
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.2418, 0.4397, 0.5858, 0.6949,
0.7737, 0.8414, 0.8959, 0.9414, 0.9828, 1.0
]
#====================================================================================
# RUN2 2018
PixelConfigCondAlg.BarrelToTThreshold2018 = [-1, 3, 5, 5]
PixelConfigCondAlg.FEI3BarrelLatency2018 = [0, 151, 256, 256]
PixelConfigCondAlg.FEI3BarrelHitDuplication2018 = [
False, False, False, False
]
PixelConfigCondAlg.FEI3BarrelSmallHitToT2018 = [-1, -1, -1, -1]
PixelConfigCondAlg.FEI3BarrelTimingSimTune2018 = [-1, 2018, 2018, 2018]
PixelConfigCondAlg.BarrelCrossTalk2018 = [0.30, 0.06, 0.06, 0.06]
PixelConfigCondAlg.BarrelNoiseOccupancy2018 = [5e-8, 5e-8, 5e-8, 5e-8]
PixelConfigCondAlg.BarrelDisableProbability2018 = [
9e-3, 9e-3, 9e-3, 9e-3
]
PixelConfigCondAlg.EndcapToTThreshold2018 = [5, 5, 5]
PixelConfigCondAlg.FEI3EndcapLatency2018 = [256, 256, 256]
PixelConfigCondAlg.FEI3EndcapHitDuplication2018 = [False, False, False]
PixelConfigCondAlg.FEI3EndcapSmallHitToT2018 = [-1, -1, -1]
PixelConfigCondAlg.FEI3EndcapTimingSimTune2018 = [2018, 2018, 2018]
PixelConfigCondAlg.EndcapCrossTalk2018 = [0.06, 0.06, 0.06]
PixelConfigCondAlg.EndcapNoiseOccupancy2018 = [5e-8, 5e-8, 5e-8]
PixelConfigCondAlg.EndcapDisableProbability2018 = [9e-3, 9e-3, 9e-3]
PixelConfigCondAlg.DBMToTThreshold2018 = [-1, -1, -1]
PixelConfigCondAlg.DBMCrossTalk2018 = [0.06, 0.06, 0.06]
PixelConfigCondAlg.DBMNoiseOccupancy2018 = [5e-8, 5e-8, 5e-8]
PixelConfigCondAlg.DBMDisableProbability2018 = [9e-3, 9e-3, 9e-3]
PixelConfigCondAlg.IBLNoiseShape2018 = [
0.0, 0.0330, 0.0, 0.3026, 0.5019, 0.6760, 0.8412, 0.9918, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0
]
PixelConfigCondAlg.BLayerNoiseShape2018 = [
0.0, 0.0, 0.0, 0.0, 0.2204, 0.5311, 0.7493, 0.8954, 0.9980, 1.0
]
PixelConfigCondAlg.PixelNoiseShape2018 = [
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.2418, 0.4397, 0.5858, 0.6949,
0.7737, 0.8414, 0.8959, 0.9414, 0.9828, 1.0
]
#====================================================================================
# RUN1
PixelConfigCondAlg.BarrelToTThresholdRUN1 = [3, 3, 3]
PixelConfigCondAlg.FEI3BarrelLatencyRUN1 = [256, 256, 256]
PixelConfigCondAlg.FEI3BarrelHitDuplicationRUN1 = [True, True, True]
PixelConfigCondAlg.FEI3BarrelSmallHitToTRUN1 = [7, 7, 7]
PixelConfigCondAlg.FEI3BarrelTimingSimTuneRUN1 = [2009, 2009, 2009]
PixelConfigCondAlg.BarrelCrossTalkRUN1 = [0.06, 0.06, 0.06]
PixelConfigCondAlg.BarrelNoiseOccupancyRUN1 = [5e-8, 5e-8, 5e-8]
PixelConfigCondAlg.BarrelDisableProbabilityRUN1 = [9e-3, 9e-3, 9e-3]
PixelConfigCondAlg.EndcapToTThresholdRUN1 = [3, 3, 3]
PixelConfigCondAlg.FEI3EndcapLatencyRUN1 = [256, 256, 256]
PixelConfigCondAlg.FEI3EndcapHitDuplicationRUN1 = [True, True, True]
PixelConfigCondAlg.FEI3EndcapSmallHitToTRUN1 = [7, 7, 7]
PixelConfigCondAlg.FEI3EndcapTimingSimTuneRUN1 = [2009, 2009, 2009]
PixelConfigCondAlg.EndcapCrossTalkRUN1 = [0.06, 0.06, 0.06]
PixelConfigCondAlg.EndcapNoiseOccupancyRUN1 = [5e-8, 5e-8, 5e-8]
PixelConfigCondAlg.EndcapDisableProbabilityRUN1 = [9e-3, 9e-3, 9e-3]
PixelConfigCondAlg.BLayerNoiseShapeRUN1 = [
0.0, 0.0, 0.0, 0.0, 0.2204, 0.5311, 0.7493, 0.8954, 0.9980, 1.0
]
PixelConfigCondAlg.PixelNoiseShapeRUN1 = [
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.2418, 0.4397, 0.5858, 0.6949,
0.7737, 0.8414, 0.8959, 0.9414, 0.9828, 1.0
]
#====================================================================================
# ITK
PixelConfigCondAlg.BarrelToTThresholdITK = [3, 3, 3, 3, 3]
PixelConfigCondAlg.BarrelCrossTalkITK = [0.06, 0.06, 0.06, 0.06, 0.06]
PixelConfigCondAlg.BarrelNoiseOccupancyITK = [
5e-8, 5e-8, 5e-8, 5e-8, 5e-8
]
PixelConfigCondAlg.BarrelDisableProbabilityITK = [
9e-3, 9e-3, 9e-3, 9e-3, 9e-3
]
PixelConfigCondAlg.EndcapToTThresholdITK = [
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
]
PixelConfigCondAlg.EndcapCrossTalkITK = [
0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06,
0.06, 0.06, 0.06
]
PixelConfigCondAlg.EndcapNoiseOccupancyITK = [
5e-8, 5e-8, 5e-8, 5e-8, 5e-8, 5e-8, 5e-8, 5e-8, 5e-8, 5e-8, 5e-8,
5e-8, 5e-8, 5e-8
]
PixelConfigCondAlg.EndcapDisableProbabilityITK = [
9e-3, 9e-3, 9e-3, 9e-3, 9e-3, 9e-3, 9e-3, 9e-3, 9e-3, 9e-3, 9e-3,
9e-3, 9e-3, 9e-3
]
PixelConfigCondAlg.InnermostNoiseShapeITK = [0.0, 1.0]
PixelConfigCondAlg.NextInnermostNoiseShapeITK = [0.0, 1.0]
PixelConfigCondAlg.PixelNoiseShapeITK = [0.0, 1.0]
IdMappingDat = "PixelCabling/Pixels_Atlas_IdMapping_2016.dat"
# ITk:
if geoFlags.isSLHC():
IdMappingDat = "ITk_Atlas_IdMapping.dat"
if "BrlIncl4.0_ref" == commonGeoFlags.GeoType():
IdMappingDat = "ITk_Atlas_IdMapping_InclBrl4.dat"
elif "IBrlExt4.0ref" == commonGeoFlags.GeoType():
IdMappingDat = "ITk_Atlas_IdMapping_IExtBrl4.dat"
elif "BrlExt4.0_ref" == commonGeoFlags.GeoType():
IdMappingDat = "ITk_Atlas_IdMapping_ExtBrl4.dat"
elif "BrlExt3.2_ref" == commonGeoFlags.GeoType():
IdMappingDat = "ITk_Atlas_IdMapping_ExtBrl32.dat"
elif not geoFlags.isIBL():
IdMappingDat = "PixelCabling/Pixels_Atlas_IdMapping.dat"
else:
# Planar IBL
if (geoFlags.IBLLayout() == "planar"):
if geoFlags.isDBM():
IdMappingDat = "PixelCabling/Pixels_Atlas_IdMapping_inclIBL_DBM.dat"
else:
IdMappingDat = "PixelCabling/Pixels_Atlas_IdMapping_inclIBL.dat"
# Hybrid IBL plus DBM
elif (geoFlags.IBLLayout() == "3D"):
IdMappingDat = "PixelCabling/Pixels_Atlas_IdMapping_Run2.dat"
PixelConfigCondAlg.CablingMapFileName = IdMappingDat
condSeq += PixelConfigCondAlg(name="PixelConfigCondAlg")
############################################################################################
# Set up Conditions DB
############################################################################################
if useNewDeadmapFormat:
if not conddb.folderRequested("/PIXEL/PixelModuleFeMask"):
conddb.addFolder("PIXEL_OFL",
"/PIXEL/PixelModuleFeMask",
className="CondAttrListCollection")
if not hasattr(condSeq, "PixelDeadMapCondAlg"):
from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelDeadMapCondAlg
condSeq += PixelDeadMapCondAlg(name="PixelDeadMapCondAlg")
if not hasattr(condSeq, "PixelDCSCondStateAlg"):
from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelDCSCondStateAlg
condSeq += PixelDCSCondStateAlg(name="PixelDCSCondStateAlg",
ReadKeyState='')
if not hasattr(condSeq, "PixelDCSCondStatusAlg"):
from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelDCSCondStatusAlg
condSeq += PixelDCSCondStatusAlg(name="PixelDCSCondStatusAlg",
ReadKeyStatus='')
if not conddb.folderRequested("/PIXEL/DCS/HV"):
conddb.addFolder("DCS_OFL",
"/PIXEL/DCS/HV",
className="CondAttrListCollection")
if not hasattr(condSeq, "PixelDCSCondHVAlg"):
from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelDCSCondHVAlg
condSeq += PixelDCSCondHVAlg(name="PixelDCSCondHVAlg")
if not conddb.folderRequested("/PIXEL/DCS/TEMPERATURE"):
conddb.addFolder("DCS_OFL",
"/PIXEL/DCS/TEMPERATURE",
className="CondAttrListCollection")
if not hasattr(condSeq, "PixelDCSCondTempAlg"):
from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelDCSCondTempAlg
condSeq += PixelDCSCondTempAlg(name="PixelDCSCondTempAlg")
#####################
# Calibration Setup #
#####################
if not useNewChargeFormat:
if not conddb.folderRequested("/PIXEL/PixCalib"):
conddb.addFolderSplitOnline("PIXEL",
"/PIXEL/Onl/PixCalib",
"/PIXEL/PixCalib",
className="CondAttrListCollection")
if not hasattr(condSeq, 'PixelChargeCalibCondAlg'):
from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelChargeCalibCondAlg
condSeq += PixelChargeCalibCondAlg(name="PixelChargeCalibCondAlg",
ReadKey="/PIXEL/PixCalib")
else:
if not conddb.folderRequested("/PIXEL/ChargeCalibration"):
conddb.addFolder("PIXEL_OFL",
"/PIXEL/ChargeCalibration",
className="CondAttrListCollection")
if not hasattr(condSeq, 'PixelChargeLUTCalibCondAlg'):
from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelChargeLUTCalibCondAlg
condSeq += PixelChargeLUTCalibCondAlg(
name="PixelChargeLUTCalibCondAlg",
ReadKey="/PIXEL/ChargeCalibration")
#####################
# Cabling map Setup #
#####################
if geoFlags.isIBL() and not conddb.folderRequested("/PIXEL/HitDiscCnfg"):
conddb.addFolderSplitMC("PIXEL",
"/PIXEL/HitDiscCnfg",
"/PIXEL/HitDiscCnfg",
className="AthenaAttributeList")
if geoFlags.isIBL() and not hasattr(condSeq, 'PixelHitDiscCnfgAlg'):
from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelHitDiscCnfgAlg
condSeq += PixelHitDiscCnfgAlg(name="PixelHitDiscCnfgAlg")
if not conddb.folderRequested("/PIXEL/ReadoutSpeed"):
conddb.addFolderSplitMC("PIXEL",
"/PIXEL/ReadoutSpeed",
"/PIXEL/ReadoutSpeed",
className="AthenaAttributeList")
if not hasattr(condSeq, 'PixelReadoutSpeedAlg'):
from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelReadoutSpeedAlg
condSeq += PixelReadoutSpeedAlg(name="PixelReadoutSpeedAlg")
pixelReadKey = ''
if (globalflags.DataSource == 'data'
and conddb.dbdata == 'CONDBR2'): # for data overlay
if not conddb.folderRequested("/PIXEL/CablingMap"):
conddb.addFolderSplitOnline("PIXEL",
"/PIXEL/Onl/CablingMap",
"/PIXEL/CablingMap",
className="AthenaAttributeList")
if not hasattr(condSeq, 'PixelCablingCondAlg'):
from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelCablingCondAlg
condSeq += PixelCablingCondAlg(
name="PixelCablingCondAlg",
ReadKey=pixelReadKey,
MappingFile=IdMappingDat,
RodIDForSingleLink40=0,
RecordInInitialize=not globalflags.isOverlay())
if not conddb.folderRequested("/PIXEL/PixReco"):
conddb.addFolder("PIXEL_OFL",
"/PIXEL/PixReco",
className="DetCondCFloat")
if not hasattr(condSeq, 'PixelOfflineCalibCondAlg'):
from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelOfflineCalibCondAlg
condSeq += PixelOfflineCalibCondAlg(name="PixelOfflineCalibCondAlg",
ReadKey="/PIXEL/PixReco")
PixelOfflineCalibCondAlg.InputSource = 2
if not conddb.folderRequested("/Indet/PixelDist"):
conddb.addFolder("INDET",
"/Indet/PixelDist",
className="DetCondCFloat")
if not hasattr(condSeq, 'PixelDistortionAlg'):
from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelDistortionAlg
condSeq += PixelDistortionAlg(name="PixelDistortionAlg",
ReadKey="/Indet/PixelDist")
#######################
# Setup Lorentz angle #
#######################
if not hasattr(condSeq, "PixelSiPropertiesCondAlg"):
from SiPropertiesTool.SiPropertiesToolConf import PixelSiPropertiesCondAlg
condSeq += PixelSiPropertiesCondAlg(name="PixelSiPropertiesCondAlg")
if not hasattr(ToolSvc, "PixelSiPropertiesTool"):
from SiPropertiesTool.SiPropertiesToolConf import SiPropertiesTool
ToolSvc += SiPropertiesTool(name="PixelSiPropertiesTool",
DetectorName="Pixel",
ReadKey="PixelSiliconPropertiesVector")
if not hasattr(condSeq, "PixelSiLorentzAngleCondAlg"):
from SiLorentzAngleTool.SiLorentzAngleToolConf import PixelSiLorentzAngleCondAlg
condSeq += PixelSiLorentzAngleCondAlg(
name="PixelSiLorentzAngleCondAlg",
SiPropertiesTool=ToolSvc.PixelSiPropertiesTool,
UseMagFieldCache=True,
UseMagFieldDcs=True)
if not hasattr(ToolSvc, "PixelLorentzAngleTool"):
from SiLorentzAngleTool.SiLorentzAngleToolConf import SiLorentzAngleTool
ToolSvc += SiLorentzAngleTool(
name="PixelLorentzAngleTool",
DetectorName="Pixel",
UseMagFieldCache=True,
SiLorentzAngleCondData="PixelSiLorentzAngleCondData")
############################################################################################
# Set up Tool/Service
############################################################################################
#####################
# Setup Cabling Svc #
#####################
from PixelCabling.PixelCablingConf import PixelCablingSvc
PixelCablingSvc = PixelCablingSvc()
ServiceMgr += PixelCablingSvc
print(PixelCablingSvc)
kwargs.setdefault("InputObjectName", "PixelHits")
chargeTools = []
feSimTools = []
if geoFlags.isSLHC():
chargeTools += ['SensorSimPlanarTool']
feSimTools += ['BarrelRD53SimTool']
feSimTools += ['EndcapRD53SimTool']
else:
chargeTools += ['SensorSimPlanarTool']
chargeTools += ['SensorSim3DTool']
feSimTools += ['BarrelFEI4SimTool']
feSimTools += ['DBMFEI4SimTool']
feSimTools += ['BarrelFEI3SimTool']
feSimTools += ['EndcapFEI3SimTool']
kwargs.setdefault("ChargeTools", chargeTools)
kwargs.setdefault("FrontEndSimTools", feSimTools)
kwargs.setdefault("EnergyDepositionTool", "EnergyDepositionTool")
if digitizationFlags.doXingByXingPileUp(): # PileUpTool approach
kwargs.setdefault("FirstXing", Pixel_FirstXing())
kwargs.setdefault("LastXing", Pixel_LastXing())
return CfgMgr.PixelDigitizationTool(name, **kwargs)
