def LArHVDBCfg(configFlags):
result=ComponentAccumulator()
result.merge(IOVDbSvcCfg(configFlags))
isMC=configFlags.Input.isMC
isOnline=configFlags.Common.isOnline
if not isMC and not isOnline:
result.merge(addFolders(configFlags,["/LAR/DCS/HV/BARREl/I16","/LAR/DCS/HV/BARREL/I8"],detDb="DCS_OFL",className="CondAttrListCollection"))
result.merge(addFolders(configFlags,["/LAR/IdentifierOfl/HVLineToElectrodeMap","/LAR/HVPathologiesOfl/Pathologies"],detDb="LAR_OFL",className="AthenaAttributeList"))
from LArRecUtils.LArRecUtilsConf import LArHVIdMappingAlg
result.addCondAlgo(LArHVIdMappingAlg(ReadKey="/LAR/IdentifierOfl/HVLineToElectrodeMap",WriteKey="LArHVIdMap"))
from LArRecUtils.LArRecUtilsConf import LArHVPathologyDbCondAlg
result.addCondAlgo(LArHVPathologyDbCondAlg(PathologyFolder="/LAR/HVPathologiesOfl/Pathologies",HVMappingKey="LArHVIdMap", HVPAthologyKey="LArHVPathology"))
from LArRecUtils.LArRecUtilsConf import LArHVCondAlg
result.addCondAlgo(LArHVCondAlg(HVPathologies="LArHVPathology",OutputHVData="LArHVData"))
from LArRecUtils.LArRecUtilsConf import LArHVScaleCorrCondAlg
hvscale = LArHVScaleCorrCondAlg(keyHVdata="LArHVData",keyOutputCorr="LArHVScaleCorrRecomputed")
hvscale.UndoOnlineHVCorr=True
result.addCondAlgo(hvscale)
if isMC:
result.merge(addFolders(configFlags,detDb="LAR_OFL",folders=["/LAR/Identifier/HVLineToElectrodeMap<tag>LARHVLineToElectrodeMap-001</tag>"],className="AthenaAttributeList"))
return result
def RpcCondDbAlgCfg(flags, **kwargs):
result = ComponentAccumulator()
folders = []
if flags.Common.isOnline:
return result ## avoid adding algo to the component accumulator
kwargs["isOnline"] = True
else:
kwargs["isOnline"] = False
if flags.Input.isMC:
kwargs['isData'] = False
kwargs['ReadKey_DA_DP'] = ''
kwargs['ReadKey_DA_OP'] = ''
else:
kwargs['isData'] = True
kwargs['isRun1'] = flags.IOVDb.DatabaseInstance == 'COMP200'
folders = ["/RPC/DCS/DeadRopanels", "/RPC/DCS/OffRopanels"]
alg = RpcCondDbAlg(**kwargs)
result.merge(
addFolders(flags,
folders,
detDb="DCS_OFL",
className='CondAttrListCollection'))
result.merge(
addFolders(flags, ["/RPC/DQMF/ELEMENT_STATUS"],
detDb="RPC_OFL",
className='CondAttrListCollection'))
result.addCondAlgo(alg)
return result
def createLArRoI_Map(flags):
acc = ComponentAccumulator()
LArRoI_Map = CompFactory.LArRoI_Map
from IOVDbSvc.IOVDbSvcConfig import addFolders
from LArCabling.LArCablingConfig import LArFebRodMappingCfg, LArCalibIdMappingCfg
LArCablingLegacyService = CompFactory.LArCablingLegacyService
cablingTool = LArCablingLegacyService() # this is realy a tool
# needed by above
acc.merge(LArFebRodMappingCfg(flags))
acc.merge(LArCalibIdMappingCfg(flags))
CaloTriggerTowerService = CompFactory.CaloTriggerTowerService
triggerTowerTool = CaloTriggerTowerService()
acc.merge(addFolders(flags, ['/LAR/Identifier/LArTTCellMapAtlas'], 'LAR'))
acc.merge(addFolders(flags, ['/LAR/Identifier/OnOffIdMap'], 'LAR'))
acc.merge(
addFolders(flags, [
'/CALO/Identifier/CaloTTOnOffIdMapAtlas',
'/CALO/Identifier/CaloTTOnAttrIdMapAtlas',
'/CALO/Identifier/CaloTTPpmRxIdMapAtlas'
], 'CALO'))
LArRoI_Map = LArRoI_Map()
LArRoI_Map.CablingSvc = cablingTool
LArRoI_Map.TriggerTowerSvc = triggerTowerTool
acc.addPublicTool(LArRoI_Map) # should become private tool
return acc
def luminosityCondAlgRun1Cfg(configFlags, name, result):
log = logging.getLogger(name)
kwargs = {}
# Check if this is express stream or bulk
if configFlags.Common.doExpressProcessing:
lumiFolder = "/TRIGGER/LUMI/LBLESTONL"
result.merge(
addFolders(configFlags,
lumiFolder,
'TRIGGER_ONL',
className='CondAttrListCollection'))
else:
lumiFolder = "/TRIGGER/OFLLUMI/LBLESTOFL"
result.merge(
addFolders(configFlags,
lumiFolder,
'TRIGGER_OFL',
className='CondAttrListCollection'))
log.info("configureLuminosityCondAlgRun1 requested %s", lumiFolder)
kwargs['LuminosityFolderInputKey'] = lumiFolder
# Configure input conditions data.
from CoolLumiUtilities.FillParamsCondAlgConfig \
import FillParamsCondAlgCfg
result.merge(FillParamsCondAlgCfg(configFlags))
fpalg = result.getCondAlgo('FillParamsCondAlg')
kwargs['FillParamsInputKey'] = fpalg.FillParamsOutputKey
from CoolLumiUtilities.BunchLumisCondAlgConfig \
import BunchLumisCondAlgCfg
result.merge(BunchLumisCondAlgCfg(configFlags))
blalg = result.getCondAlgo('BunchLumisCondAlg')
kwargs['BunchLumisInputKey'] = blalg.BunchLumisOutputKey
from CoolLumiUtilities.BunchGroupCondAlgConfig \
import BunchGroupCondAlgCfg
result.merge(BunchGroupCondAlgCfg(configFlags))
bgalg = result.getCondAlgo('BunchGroupCondAlg')
kwargs['BunchGroupInputKey'] = bgalg.BunchGroupOutputKey
from CoolLumiUtilities.OnlineLumiCalibrationCondAlgConfig \
import OnlineLumiCalibrationCondAlgCfg
result.merge(OnlineLumiCalibrationCondAlgCfg(configFlags))
olalg = result.getCondAlgo('OnlineLumiCalibrationCondAlg')
kwargs['OnlineLumiCalibrationInputKey'] = olalg.LumiCalibOutputKey
return kwargs
def CaloCellPedestalCorrCfg(configFlags):
CaloCellPedestalCorr = CompFactory.CaloCellPedestalCorr
result = DetDescrCnvSvcCfg(configFlags)
isMC = configFlags.Input.isMC
theCaloCellPedestalCorr = CaloCellPedestalCorr()
if not isMC:
theCaloCellPedestalCorr.isMC = False
if configFlags.Common.isOnline:
folder = '/CALO/Pedestal/CellPedestal'
result.merge(
addFolders(configFlags,
folder,
'CALO_ONL',
className="CondAttrListCollection"))
else:
#regular offline case
folder = '/CALO/Ofl/Pedestal/CellPedestal'
result.merge(
addFolders(configFlags,
folder,
'CALO_OFL',
className="CondAttrListCollection"))
theCaloCellPedestalCorr.PedestalShiftFolder = folder
else:
theCaloCellPedestalCorr.isMC = True
if not configFlags.Common.isOnline:
if configFlags.Calo.Cell.doPileupOffsetBCIDCorr:
from CaloRec.CaloBCIDAvgAlgConfig import CaloBCIDAvgAlgCfg
result.merge(CaloBCIDAvgAlgCfg(configFlags))
theCaloCellPedestalCorr.CaloBCIDAverageKey = "CaloBCIDAverage"
else:
theCaloCellPedestalCorr.CaloBCIDAverageKey = ""
if not isMC:
lumiFolder = '/TRIGGER/LUMI/LBLESTONL'
result.merge(
addFolders(configFlags,
lumiFolder,
'TRIGGER_ONL',
className="CondAttrListCollection"))
theCaloCellPedestalCorr.Luminosity = -1
theCaloCellPedestalCorr.LumiFolderName = lumiFolder
result.setPrivateTools(theCaloCellPedestalCorr)
return result
def MDTCablingConfigCfg(flags):
acc = ComponentAccumulator()
acc.merge(MuonGeoModelCfg(flags))
MuonMDT_CablingAlg = CompFactory.MuonMDT_CablingAlg
MDTCablingAlg = MuonMDT_CablingAlg("MuonMDT_CablingAlg")
MuonMDT_CablingSvc = CompFactory.MuonMDT_CablingSvc
mdtCablingSvc = MuonMDT_CablingSvc()
mdtCablingSvc.UseOldCabling = False
mdtCablingSvc.ForcedUse = True
MDTCablingDbTool = CompFactory.MDTCablingDbTool
MDTCablingDbTool = MDTCablingDbTool()
from IOVDbSvc.IOVDbSvcConfig import addFolders
if flags.Input.isMC is True:
MDTCablingDbTool.MapFolders = "/MDT/Ofl/CABLING/MAP_SCHEMA"
MDTCablingDbTool.MezzanineFolders = "/MDT/Ofl/CABLING/MEZZANINE_SCHEMA"
MDTCablingAlg.MapFolders = "/MDT/Ofl/CABLING/MAP_SCHEMA"
MDTCablingAlg.MezzanineFolders = "/MDT/Ofl/CABLING/MEZZANINE_SCHEMA"
acc.merge(
addFolders(flags, [
"/MDT/Ofl/CABLING/MAP_SCHEMA",
"/MDT/Ofl/CABLING/MEZZANINE_SCHEMA"
],
'MDT_OFL',
className="CondAttrListCollection"))
else:
MDTCablingDbTool.MapFolders = "/MDT/CABLING/MAP_SCHEMA"
MDTCablingDbTool.MezzanineFolders = "/MDT/CABLING/MEZZANINE_SCHEMA"
MDTCablingAlg.MapFolders = "/MDT/CABLING/MAP_SCHEMA"
MDTCablingAlg.MezzanineFolders = "/MDT/CABLING/MEZZANINE_SCHEMA"
acc.merge(
addFolders(
flags,
["/MDT/CABLING/MAP_SCHEMA", "/MDT/CABLING/MEZZANINE_SCHEMA"],
'MDT',
className="CondAttrListCollection"))
acc.addCondAlgo(MDTCablingAlg)
acc.addPublicTool(MDTCablingDbTool)
mdtCablingSvc.DBTool = MDTCablingDbTool
acc.addService(mdtCablingSvc, primary=True)
return acc
def LArKnownBadFebCfg(configFlags, tag=""):
result = ComponentAccumulator()
if configFlags.GeoModel.Run == "RUN1":
foldername = ""
else:
if configFlags.Common.isOnline or configFlags.Input.isMC:
foldername = "/LAR/BadChannels/KnownBADFEBs"
else:
foldername = "/LAR/BadChannelsOfl/KnownBADFEBs"
pass
if configFlags.Common.isOnline:
dbname = "LAR"
else:
dbname = "LAR_OFL"
pass
pass
result.merge(
addFolders(configFlags,
foldername + tag,
detDb=dbname,
className="AthenaAttributeList"))
result.addCondAlgo(
LArBadFebCondAlg("LArKonwnBadFebCondAlg",
ReadKey=foldername,
WriteKey="LArKnownBadFEBs"))
return result
def TrigLiveFractionCondAlgCfg(configFlags):
name = 'TrigLiveFractionCondAlg'
result = ComponentAccumulator()
kwargs = {}
if configFlags.IOVDb.DatabaseInstance == 'COMP200':
folder = '/TRIGGER/LUMI/PerBcidDeadtime'
# Mistakenly created as multi-version folder, must specify HEAD
result.merge(
addFolders(configFlags,
folder,
'TRIGGER',
tag='HEAD',
className='AthenaAttributeList'))
kwargs['DeadtimeFolderInputKey'] = folder
kwargs['LuminosityInputKey'] = 'LuminosityCondData'
from LumiBlockComps.LuminosityCondAlgConfig import LuminosityCondAlgCfg
result.merge(LuminosityCondAlgCfg(configFlags))
else:
kwargs['DeadtimeFolderInputKey'] = ''
kwargs['LuminosityInputKey'] = ''
TrigLiveFractionCondAlg = CompFactory.TrigLiveFractionCondAlg
alg = TrigLiveFractionCondAlg(
name, TrigLiveFractionOutputKey='TrigLiveFractionCondData', **kwargs)
result.addCondAlgo(alg)
return result
def FastShowerCellBuilderToolBaseCfg(flags, name, **kwargs):
acc = RNG(flags.Random.Engine)
acc.merge(
addFolders(flags,
"/GLOBAL/AtlfastII/FastCaloSimParam",
"GLOBAL_OFL",
tag="FastCaloSim_v2"))
localFileNameList = AdditionalParticleParametrizationFileNames()
localFileNameList.insert(0, "L1_L2_egamma_corr.config20.root")
kwargs.setdefault("AdditionalParticleParametrizationFileNames",
localFileNameList)
kwargs.setdefault("RandomService", acc.getService("AthRNGSvc"))
kwargs.setdefault("RandomStreamName", "AthRNGSvc")
kwargs.setdefault("DoSimulWithInnerDetectorTruthOnly", True)
kwargs.setdefault("ID_cut_off_r", [1150])
kwargs.setdefault("ID_cut_off_z", [3490])
kwargs.setdefault("DoSimulWithInnerDetectorV14TruthCuts", True)
kwargs.setdefault("DoNewEnergyEtaSelection", True)
kwargs.setdefault("DoEnergyInterpolation", True)
kwargs.setdefault("use_Ekin_for_depositions", True)
kwargs.setdefault("McLocation", flags.Sim.FastShower.InputCollection)
kwargs.setdefault("ParticleParametrizationFileName", "")
kwargs.setdefault("Extrapolator", NITimedExtrapolatorCfg(flags))
# New kwarg from old FastCaloSimFactory
kwargs.setdefault("CaloEntrance", TrkDetFlags.InDetContainerName())
#######################################################################################################
#theFastShowerCellBuilderTool.Invisibles=[12, 14, 16, 1000022]
#########################################################################################################
acc.setPrivateTools(CompFactory.FastShowerCellBuilderTool(name, **kwargs))
return acc
def _larCablingCfg(configFlags, algo, folder):
result = ComponentAccumulator()
result.merge(IOVDbSvcCfg(configFlags))
#MC folder-tag hack (See also ATCONDDB-49)
tagsperFolder = {
"/LAR/Identifier/OnOffIdMap": "LARIdentifierOnOffIdMap-012",
"/LAR/Identifier/FebRodMap": "LARIdentifierFebRodMap-005",
"/LAR/Identifier/CalibIdMap": "LARIdentifierCalibIdMap-012",
"/LAR/IdentifierOfl/OnOffIdMap_SC": "LARIdentifierOflOnOffIdMap_SC-000"
}
if configFlags.Input.isMC:
db = 'LAR_OFL'
if folder in tagsperFolder:
ft = tagsperFolder[folder]
folderwithtag = folder + "<tag>" + ft + "</tag>"
else:
db = 'LAR_ONL'
folderwithtag = folder
result.addCondAlgo(algo(ReadKey=folder), primary=True)
result.merge(
addFolders(configFlags,
folderwithtag,
className="AthenaAttributeList",
detDb=db))
#print (result)
return result
def LArFebConfigCondAlgCfg(flags, name="LArFEBConfigCondAlg", **kwargs):
"""Return ComponentAccumulator with configured LArFEBConfigCondAlg"""
defaultFolders = [
"/LAR/Configuration/FEBConfig/Physics/EMBA1",
"/LAR/Configuration/FEBConfig/Physics/EMBA2",
"/LAR/Configuration/FEBConfig/Physics/EMBA3",
"/LAR/Configuration/FEBConfig/Physics/EMBA4",
"/LAR/Configuration/FEBConfig/Physics/EMBC1",
"/LAR/Configuration/FEBConfig/Physics/EMBC2",
"/LAR/Configuration/FEBConfig/Physics/EMBC3",
"/LAR/Configuration/FEBConfig/Physics/EMBC4",
"/LAR/Configuration/FEBConfig/Physics/EMECA1",
"/LAR/Configuration/FEBConfig/Physics/EMECA2",
"/LAR/Configuration/FEBConfig/Physics/EMECA3",
"/LAR/Configuration/FEBConfig/Physics/EMECC1",
"/LAR/Configuration/FEBConfig/Physics/EMECC2",
"/LAR/Configuration/FEBConfig/Physics/EMECC3",
"/LAR/Configuration/FEBConfig/Physics/FCALA",
"/LAR/Configuration/FEBConfig/Physics/FCALC",
"/LAR/Configuration/FEBConfig/Physics/HECA",
"/LAR/Configuration/FEBConfig/Physics/HECC",
]
LArFebConfigFolders = kwargs.setdefault("ListOfFolders", defaultFolders)
kwargs.setdefault("keyOutput", "LArFebConfig")
acc = addFolders(flags, LArFebConfigFolders, "LAR_ONL",
"CondAttrListCollection")
acc.addCondAlgo(LArFEBConfigCondAlg(name, **kwargs))
return acc
def testCfg(configFlags):
result = ComponentAccumulator()
from IOVDbSvc.IOVDbSvcConfig import addFolders
result.merge(
addFolders(configFlags,
'/LAR/CellCorrOfl/deadOTX',
detDb='LAR_OFL',
className='CondAttrListCollection'))
from CaloRec.ToolConstantsCondAlgConfig import ToolConstantsCondAlgCfg
result.merge(
ToolConstantsCondAlgCfg(configFlags,
'deadOTXCorrCtes',
COOLFolder='/LAR/CellCorrOfl/deadOTX'))
from EventSelectorAthenaPool.CondProxyProviderConfig import CondProxyProviderCfg
from CaloClusterCorrection.poolfiles import poolfiles
result.merge(
CondProxyProviderCfg(configFlags,
poolFiles=[poolfiles['caloswcorr_pool_v22']]))
result.merge(
ToolConstantsCondAlgCfg(
configFlags,
'CaloSwClusterCorrections.rfac-v5',
DetStoreKey='CaloSwClusterCorrections.rfac-v5'))
CaloClusterCorrDumper = CompFactory.CaloClusterCorrDumper # CaloRec
alg = CaloClusterCorrDumper(
'dumper1',
Constants=['deadOTXCorrCtes', 'CaloSwClusterCorrections.rfac-v5'])
result.addEventAlgo(alg)
return result
def SCT_MonitorConditionsToolCfg(flags,
name="InDetSCT_MonitorConditionsTool",
cond_kwargs={},
**kwargs):
cond_kwargs.setdefault("Folder", "/SCT/Derived/Monitoring")
cond_kwargs.setdefault("dbInstance", "SCT_OFL")
cond_kwargs.setdefault("MonitorCondAlgName", "SCT_MonitorCondAlg")
result = ComponentAccumulator()
if "FolderDb" not in cond_kwargs:
cond_kwargs["FolderDb"] = cond_kwargs["Folder"]
result.merge(
addFolders(flags,
cond_kwargs["FolderDb"],
cond_kwargs["dbInstance"],
className="CondAttrListCollection"))
result.addCondAlgo(
CompFactory.SCT_MonitorCondAlg(name=cond_kwargs["MonitorCondAlgName"],
ReadKey=cond_kwargs["Folder"]))
tool = CompFactory.SCT_MonitorConditionsTool(name, **kwargs)
result.setPrivateTools(tool)
return result
def HLTPrescaleCondAlgCfg(flags):
log = logging.getLogger('TrigConfigSvcCfg')
log.info("Setting up HLTPrescaleCondAlg")
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
acc = ComponentAccumulator()
TrigConf__HLTPrescaleCondAlg = CompFactory.getComp(
"TrigConf::HLTPrescaleCondAlg")
hltPrescaleCondAlg = TrigConf__HLTPrescaleCondAlg("HLTPrescaleCondAlg")
tc = getTrigConfigFromFlag(flags)
hltPrescaleCondAlg.Source = tc["source"]
from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
if athenaCommonFlags.isOnline():
from IOVDbSvc.IOVDbSvcConfig import addFolders
acc.merge(
addFolders(flags,
getHLTPrescaleFolderName(),
"TRIGGER_ONL",
className="AthenaAttributeList"))
log.info("Adding folder %s to CompAcc", getHLTPrescaleFolderName())
if tc["source"] == "COOL":
hltPrescaleCondAlg.TriggerDB = tc["dbconn"]
elif tc["source"] == "DB":
hltPrescaleCondAlg.TriggerDB = tc["dbconn"]
hltPrescaleCondAlg.HLTPsk = tc["hltpsk"]
elif tc["source"] == "FILE":
hltPrescaleCondAlg.Filename = getHLTPrescalesSetFileName(flags)
else:
raise RuntimeError(
"trigger configuration flag 'trigConfig' starts with %s, which is not understood"
% tc["source"])
acc.addCondAlgo(hltPrescaleCondAlg)
return acc
def BunchLumisCondAlgCfg(configFlags):
name = 'BunchLumisCondAlg'
result = ComponentAccumulator()
# Should only be used for Run 1.
if configFlags.IOVDb.DatabaseInstance != 'COMP200':
return result
folder = '/TDAQ/OLC/BUNCHLUMIS'
if configFlags.Detector.Overlay:
# Load reduced channel list for overlay jobs to try to reduce COOL access
# Need Lucid AND, OR, HitOR, BcmH OR, BcmV OR
folder = '<channelSelection>101,102,103,201,211</channelSelection> ' + folder
result.merge(
addFolders(configFlags,
folder,
'TDAQ',
className='CondAttrListCollection'))
from CoolLumiUtilities.FillParamsCondAlgConfig import FillParamsCondAlgCfg
result.merge(FillParamsCondAlgCfg(configFlags))
fpalg = result.getCondAlgo('FillParamsCondAlg')
BunchLumisCondAlg = CompFactory.BunchLumisCondAlg
alg = BunchLumisCondAlg(name,
BunchLumisFolderInputKey=folder,
FillParamsInputKey=fpalg.FillParamsOutputKey,
BunchLumisOutputKey='BunchLumisCondData')
result.addCondAlgo(alg)
return result
def BadLBFilterAlgCfg(inputFlags,name, defects, writekey, ignoreRecoverable=False, origDbTag=None):
log = logging.getLogger('BadLBFilterAlgCfg')
result=ComponentAccumulator()
from DQDefects import DefectsDB
ddb = DefectsDB('COOLOFL_GLOBAL/' + inputFlags.IOVDb.DatabaseInstance,
tag=origDbTag or inputFlags.IOVDb.GlobalTag)
primary_defects = set()
for defect in defects:
if defect in ddb.defect_names:
primary_defects.add(defect)
elif defect in ddb.virtual_defect_names:
primary_defects |= ddb.virtual_defect_logics(defect).primary_defects
else:
raise ValueError('%s is not a known defect' % defect)
log.info ("Algorithm %s configured with intolerable defects %s" % (name, list(primary_defects)))
primary_defect_ids = [ddb.defect_id_map[id] for id in primary_defects]
monFilterAlg =CompFactory.DQBadLBFilterAlg(name)
monFilterAlg.defectList = primary_defect_ids
monFilterAlg.ignoreRecoverable = ignoreRecoverable
monFilterAlg.WriteKey = writekey
from IOVDbSvc.IOVDbSvcConfig import addFolders
if not inputFlags.Input.isMC:
result.merge(addFolders(inputFlags,'/GLOBAL/DETSTATUS/DEFECTS',detDb='GLOBAL_OFL',className='CondAttrListCollection'))
result.addCondAlgo(monFilterAlg)
return result
def luminosityCondAlgOnlineCfg(configFlags, name, result):
log = logging.getLogger(name)
kwargs = {}
# Keep values for invalid data
kwargs['SkipInvalid'] = False
if configFlags.IOVDb.DatabaseInstance == 'COMP200': # Run1
folder = "/TRIGGER/LUMI/LBLESTONL"
result.merge(
addFolders(configFlags,
folder,
'TRIGGER_ONL',
className='CondAttrListCollection'))
else: # Run 2
if configFlags.IOVDb.DatabaseInstance != 'CONDBR2':
log.warning(
"LuminosityCondAlgOnlineCfg can't resolve DatabaseInstance = %s, assume Run2!",
configFlags.IOVDb.DatabaseInstance)
log.info("Using Run 2 configuration")
folder = "/TRIGGER/LUMI/HLTPrefLumi"
result.merge(
addFolders(configFlags,
folder,
'TRIGGER_ONL',
className='CondAttrListCollection'))
kwargs['LuminosityFolderInputKey'] = folder
log.info("Created online %s using folder %s" % (name, folder))
# Need the calibration just to get the proper MuToLumi value
from CoolLumiUtilities.OnlineLumiCalibrationCondAlgConfig \
import OnlineLumiCalibrationCondAlgCfg
result.merge(OnlineLumiCalibrationCondAlgCfg(configFlags))
olalg = result.getCondAlgo('OnlineLumiCalibrationCondAlg')
kwargs['OnlineLumiCalibrationInputKey'] = olalg.LumiCalibOutputKey
# Other folder names should be blank.
kwargs['BunchLumisInputKey'] = ''
kwargs['BunchGroupInputKey'] = ''
kwargs['FillParamsInputKey'] = ''
return kwargs
def TRT_OnlineFoldersCfg(flags):
"""Setup online conditions folders for TRT data overlay"""
from IOVDbSvc.IOVDbSvcConfig import addFolders
acc = ComponentAccumulator()
acc.merge(
addFolders(flags,
"/TRT/Onl/ROD/Compress",
"TRT_ONL",
className='CondAttrListCollection'))
return acc
def SCT_CablingFoldersCfg(configFlags):
cfg=ComponentAccumulator()
path="/SCT/DAQ/Config/"
if configFlags.IOVDb.DatabaseInstance == "COMP200":
path="/SCT/DAQ/Configuration/"
instance="SCT"
if configFlags.Input.isMC:
instance="SCT_OFL"
from IOVDbSvc.IOVDbSvcConfig import addFolders
cfg.merge(addFolders(configFlags, [path+"ROD", path+"RODMUR", path+"MUR", path+"Geog"], instance, className="CondAttrListVec"))
return cfg, path
def CaloCellTimeCorrCfg(configFlags):
CaloCellTimeCorrTool = CompFactory.CaloCellTimeCorrTool
result = ComponentAccumulator()
folder = "/LAR/TimeCorrectionOfl/CellTimeOffset"
result.merge(
addFolders(configFlags, [
folder,
],
"LAR_OFL",
className="AthenaAttributeList"))
result.setPrivateTools(CaloCellTimeCorrTool(Folder=folder))
return result
def CaloEnergyRescalerCfg(configFlags):
CaloCellEnergyRescaler = CompFactory.CaloCellEnergyRescaler
result = ComponentAccumulator()
folder = "/LAR/CellCorrOfl/EnergyCorr"
result.merge(
addFolders(configFlags, [
folder,
],
"LAR_OFL",
className="AthenaAttributeList"))
result.setPrivateTools(CaloCellEnergyRescaler(Folder=folder))
return result
def AtlasReadyFilterCfg(flags):
result=ComponentAccumulator()
if flags.Common.isOnline or flags.Input.isMC or flags.Beam.Type != 'collisions' or flags.DQ.disableAtlasReadyFilter:
result.setPrivateTools(CompFactory.DQDummyFilterTool())
else:
from IOVDbSvc.IOVDbSvcConfig import addFolders
result.merge(addFolders(flags,'/TDAQ/RunCtrl/DataTakingMode','TDAQ',className='AthenaAttributeList'))
result.setPrivateTools(CompFactory.DQAtlasReadyFilterTool())
return result
def SCT_DCSConditionsCfg(flags, name="InDetSCT_DCSConditions", **kwargs):
"""Return configured ComponentAccumulator and tool for SCT_DCSConditions
DCSConditionsTool may be provided in kwargs
"""
acc = ComponentAccumulator()
tool = kwargs.get("DCSConditionsTool", SCT_DCSConditionsToolCfg(flags))
# folder arguments
dbInstance = kwargs.get("dbInstance", "DCS_OFL")
hvFolder = kwargs.get("hvFolder", "/SCT/DCS/HV")
tempFolder = kwargs.get("tempFolder", "/SCT/DCS/MODTEMP")
stateFolder = kwargs.get("stateFolder", "/SCT/DCS/CHANSTAT")
if tool.ReadAllDBFolders == tool.ReturnHVTemp:
acc.merge(
addFolders(flags,
stateFolder,
dbInstance,
className="CondAttrListCollection"))
# algo
statArgs = {
"name": name + "StatCondAlg",
"ReturnHVTemp": tool.ReturnHVTemp,
"ReadKeyHV": hvFolder,
"ReadKeyState": stateFolder,
}
statAlg = SCT_DCSConditionsStatCondAlg(**statArgs)
acc.addCondAlgo(statAlg)
if tool.ReturnHVTemp:
acc.merge(
addFolders(flags, [hvFolder, tempFolder],
dbInstance,
className="CondAttrListCollection"))
hvAlg = SCT_DCSConditionsHVCondAlg(name=name + "HVCondAlg",
ReadKey=hvFolder)
acc.addCondAlgo(hvAlg)
tempAlg = SCT_DCSConditionsTempCondAlg(name=name + "TempCondAlg",
ReadKey=tempFolder)
acc.addCondAlgo(tempAlg)
acc.setPrivateTools(tool)
return acc
def luminosityCondAlgRun2Cfg(configFlags, name, result):
log = logging.getLogger(name)
kwargs = {}
# Check if this is express stream or bulk
if configFlags.Common.doExpressProcessing:
lumiFolder = "/TRIGGER/LUMI/OnlPrefLumi"
result.merge(
addFolders(configFlags,
lumiFolder,
'TRIGGER_ONL',
className='CondAttrListCollection'))
else:
lumiFolder = "/TRIGGER/OFLLUMI/OflPrefLumi"
result.merge(
addFolders(configFlags,
lumiFolder,
'TRIGGER_OFL',
className='CondAttrListCollection'))
log.info("luminosityCondAlgRun2Config requested %s", lumiFolder)
kwargs['LuminosityFolderInputKey'] = lumiFolder
log.info("Created Run2 %s using folder %s" % (name, lumiFolder))
# Need the calibration just to get the proper MuToLumi value
from CoolLumiUtilities.OnlineLumiCalibrationCondAlgConfig \
import OnlineLumiCalibrationCondAlgCfg
result.merge(OnlineLumiCalibrationCondAlgCfg(configFlags))
olalg = result.getCondAlgo('OnlineLumiCalibrationCondAlg')
kwargs['OnlineLumiCalibrationInputKey'] = olalg.LumiCalibOutputKey
# Other folder names should be blank.
kwargs['BunchLumisInputKey'] = ''
kwargs['BunchGroupInputKey'] = ''
kwargs['FillParamsInputKey'] = ''
return kwargs
def LArGMCfg(configFlags):
result = GeoModelCfg(configFlags)
doAlignment = configFlags.LAr.doAlign
LArDetectorToolNV = CompFactory.LArDetectorToolNV
result.getPrimary().DetectorTools += [
LArDetectorToolNV(ApplyAlignments=doAlignment)
]
if not configFlags.Detector.SimulateCalo:
result.getPrimary(
).DetectorTools["LArDetectorToolNV"].GeometryConfig = "RECO"
if doAlignment:
if configFlags.Input.isMC:
#Monte Carlo case:
result.merge(
addFolders(configFlags,
["/LAR/Align", "/LAR/LArCellPositionShift"],
"LAR_OFL"))
else:
if configFlags.Overlay.DataOverlay:
#Data overlay
result.merge(addFolders(configFlags, ["/LAR/Align"],
"LAR_ONL"))
result.merge(
addFolders(configFlags, ["/LAR/LArCellPositionShift"],
"LAR_OFL",
tag="LArCellPositionShift-ideal",
db="OFLP200"))
else:
#Regular offline data processing
result.merge(
addFolders(configFlags,
["/LAR/Align", "/LAR/LArCellPositionShift"],
"LAR_ONL"))
return result
def PrepareStandAloneBTagCfg(inputFlags):
result = ComponentAccumulator()
from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
result.merge(PoolReadCfg(inputFlags))
from TrkConfig.AtlasTrackingGeometrySvcConfig import TrackingGeometrySvcCfg
acc = TrackingGeometrySvcCfg(inputFlags)
result.merge(acc)
from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
result.merge(MuonGeoModelCfg(inputFlags))
GeometryDBSvc = CompFactory.GeometryDBSvc
result.addService(GeometryDBSvc("InDetGeometryDBSvc"))
from PixelGeoModel.PixelGeoModelConfig import PixelGeometryCfg
result.merge(PixelGeometryCfg(inputFlags))
# get standard config for magnetic field - map and cache
from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg
result.merge(MagneticFieldSvcCfg(inputFlags))
from IOVDbSvc.IOVDbSvcConfig import addFolders, addFoldersSplitOnline
#load folders needed for Run2 ID alignment
result.merge(
addFoldersSplitOnline(inputFlags,
"INDET",
"/Indet/Onl/Align",
"/Indet/Align",
className="AlignableTransformContainer"))
result.merge(addFolders(inputFlags, ['/TRT/Align'], 'TRT_OFL'))
#load folders needed for IBL
result.merge(addFolders(inputFlags, ['/Indet/IBLDist'], 'INDET_OFL'))
return result
def LBDurationCondAlgCfg (configFlags):
name = 'LBDurationCondAlg'
result = ComponentAccumulator()
from IOVDbSvc.CondDB import conddb # noqa: F401
folder = "/TRIGGER/LUMI/LBLB"
result.merge (addFolders (configFlags, folder, 'TRIGGER',
className = 'AthenaAttributeList'))
LBDurationCondAlg=CompFactory.LBDurationCondAlg
alg = LBDurationCondAlg (name,
LBLBFolderInputKey = folder,
LBDurationOutputKey = 'LBDurationCondData')
result.addCondAlgo (alg)
return result
def RPCCablingConfigCfg(flags):
acc = ComponentAccumulator()
# TODO check if we actually need this here?
acc.merge(MuonGeoModelCfg(flags))
RpcCablingCondAlg = CompFactory.RpcCablingCondAlg
RpcCablingAlg = RpcCablingCondAlg("RpcCablingCondAlg")
acc.addCondAlgo(RpcCablingAlg)
RPCcablingServerSvc = CompFactory.RPCcablingServerSvc
RPCCablingSvc = RPCcablingServerSvc()
RPCCablingSvc.Atlas = True
RPCCablingSvc.forcedUse = True
RPCCablingSvc.useMuonRPC_CablingSvc = True #Needed to switch to new cabling
acc.addService(RPCCablingSvc)
MuonRPC_CablingSvc = CompFactory.MuonRPC_CablingSvc
rpcCablingSvc = MuonRPC_CablingSvc()
rpcCablingSvc.ConfFileName = 'LVL1confAtlas.data' # this should come from config flag maybe ???
rpcCablingSvc.CorrFileName = 'LVL1confAtlas.corr'
rpcCablingSvc.ConfFilePath = 'MuonRPC_Cabling/'
rpcCablingSvc.RPCTriggerRoadsfromCool = True
rpcCablingSvc.CosmicConfiguration = 'HLT' in flags.IOVDb.GlobalTag # this was set to true by the modifier openThresholdRPCCabling in runHLT_standalone.py
from IOVDbSvc.IOVDbSvcConfig import addFolders
dbName = 'RPC_OFL' if flags.Input.isMC else 'RPC'
acc.merge(
addFolders(flags, [
'/RPC/TRIGGER/CM_THR_ETA', '/RPC/TRIGGER/CM_THR_PHI',
'/RPC/CABLING/MAP_SCHEMA', '/RPC/CABLING/MAP_SCHEMA_CORR'
],
dbName,
className='CondAttrListCollection'))
RPCCablingDbTool = CompFactory.RPCCablingDbTool
RPCCablingDbTool = RPCCablingDbTool()
RPCCablingDbTool.MapConfigurationFolder = '/RPC/CABLING/MAP_SCHEMA'
RPCCablingDbTool.MapCorrectionFolder = '/RPC/CABLING/MAP_SCHEMA_CORR'
acc.addPublicTool(RPCCablingDbTool)
rpcCablingSvc.TheRpcCablingDbTool = RPCCablingDbTool
acc.addService(rpcCablingSvc, primary=True)
return acc
def MDTCondSummarySvcCfg(flags, **kwargs):
result = ComponentAccumulator()
if flags.Common.isOnline:
kwargs['ConditionsServices'] = [] # COOL folders not available online
else:
if flags.Input.isMC: # OFLP200
mdt_dcs_cond_tool = MDT_DCSConditionsTool(
Simulation_Setup=flags.Input.isMC)
result.addPublicTool(mdt_dcs_cond_tool)
cond_svc = MDT_DCSConditionsSvc(
MDT_DCSConditionsTool=mdt_dcs_cond_tool)
folders = [
"/MDT/DCS/DROPPEDCH", "/MDT/DCS/PSLVCHSTATE"
] # FIXME got this by observing other job ... not really sure if it's correct
else:
# if conddb.dbdata=="CONDBR2":
# kwargs['ConditionsServices'] = ['MDT_DCSConditionsRun2Svc']
# else:
# kwargs['ConditionsServices'] = ['MDT_DCSConditionsSvc']
if flags.IOVDb.DatabaseInstance == 'CONDBR2': # CONDBR2 - run 2 data
map_conversion_tool = MDT_MapConversion()
result.addPublicTool(map_conversion_tool)
mdt_dcs_cond_tool = MDT_DCSConditionsRun2Tool(
MDT_MapConversion=map_conversion_tool)
result.addPublicTool(mdt_dcs_cond_tool)
cond_svc = MDT_DCSConditionsRun2Svc(
MDT_DCSConditionsRun2Tool=mdt_dcs_cond_tool)
# folders = ['/MDT/DCS/DROPPEDCH','/MDT/DCS/PSHVMLSTATE','/MDT/DCS/PSLVCHSTATE','/MDT/DCS/JTAGCHSTATE','/MDT/DCS/PSV0SETPOINTS', '/MDT/DCS/PSV1SETPOINTS']
folders = ["LVFolder", "HVFolder"]
else:
# Not yet implemented. Need to try to understand what on earth is going on first.
mdt_dcs_cond_tool = MDT_DCSConditionsTool(
Simulation_Setup=flags.Input.isMC)
result.addPublicTool(mdt_dcs_cond_tool)
cond_svc = MDT_DCSConditionsSvc(
MDT_DCSConditionsTool=mdt_dcs_cond_tool)
folders = ["LVFolder", "HVFolder"]
result.merge(addFolders(
flags, folders, detDb="DCS_OFL")) # TODO FIXME! Get correct list
result.addService(cond_svc)
kwargs['ConditionsServices'] = [cond_svc
] # COOL folders not available online
cond_summary = MDTCondSummarySvc(**kwargs)
result.addService(cond_summary, primary=True)
return result
def CscCondDbAlgCfg(flags, **kwargs):
result = ComponentAccumulator()
folders = [
"/CSC/FTHOLD", "/CSC/NOISE", "/CSC/PED", "/CSC/PSLOPE", "/CSC/RMS",
"/CSC/STAT", "/CSC/T0BASE", "/CSC/T0PHASE"
]
scheme = "CSC_OFL"
kwargs['ReadKey_HV'] = '' # Never used at present
if flags.Common.isOnline:
kwargs["isOnline"] = True
kwargs['isData'] = True
kwargs[
'ReadKey_FT'] = '/CSC/FTHOLD' # 'ConditionsStore+' prefix not necessarily needed in ReadKey
kwargs['ReadKey_NO'] = '/CSC/NOISE'
kwargs['ReadKey_PD'] = '/CSC/PED'
kwargs['ReadKey_PS'] = '/CSC/PSLOPE'
kwargs['ReadKey_RM'] = '/CSC/RMS'
kwargs['ReadKey_ST'] = '/CSC/STAT'
kwargs['ReadKey_TB'] = ''
kwargs['ReadKey_TP'] = ''
folders = [
"/CSC/ONL/FTHOLD", "/CSC/ONL/NOISE", "/CSC/ONL/PED",
"/CSC/ONL/PSLOPE", "/CSC/ONL/RMS", "/CSC/ONL/STAT"
]
scheme = "CSC_ONL"
else:
kwargs["isOnline"] = False
if flags.Input.isMC:
kwargs['isData'] = False
kwargs['ReadKey_HV'] = ''
else:
kwargs['isData'] = True
kwargs['isRun1'] = flags.IOVDb.DatabaseInstance == 'COMP200'
kwargs[
'ReadKey_HV'] = '' # TODO: probably this should be removed once this folder is available
alg = CscCondDbAlg(**kwargs)
result.merge(
addFolders(flags,
folders,
detDb=scheme,
className='CondAttrListCollection'))
result.addCondAlgo(alg)
return result
