def CaloCellPedestalCorrDefault(name='CaloCellPedestalCorr'): import traceback from AthenaCommon.Logging import logging mlog = logging.getLogger('CaloCellPedestalCorrDefault') from AthenaCommon.AppMgr import ToolSvc from AthenaCommon.GlobalFlags import globalflags try: from CaloCellCorrection.CaloCellCorrectionConf import CaloCellPedestalCorr theCaloCellPedestalCorr = CaloCellPedestalCorr("CaloCellPedestalCorr") except: mlog.error("could not get handle to CaloCellPedestalCorr Quit") print traceback.format_exc() ToolSvc += theCaloCellPedestalCorr try: from CaloRec.CaloRecConf import CaloCellContainerCorrectorTool from CaloIdentifier import SUBCALO thePedestalTool = CaloCellContainerCorrectorTool( "PedestalTool", CaloNums=[SUBCALO.NSUBCALO], CellCorrectionToolNames=[theCaloCellPedestalCorr]) except: mlog.error( "could not get handle to CaloCellContainerCorrectorTool Quit") print traceback.format_exc() return False if globalflags.DataSource() == 'data': from IOVDbSvc.CondDB import conddb if conddb.isOnline: folder = '/CALO/Pedestal/CellPedestal' conddb.addFolder('CALO_ONL', folder) else: folder = '/CALO/Ofl/Pedestal/CellPedestal' conddb.addFolder('CALO_OFL', folder) theCaloCellPedestalCorr.FolderName = folder theCaloCellPedestalCorr.isMC = False else: theCaloCellPedestalCorr.isMC = True from AthenaCommon.AthenaCommonFlags import athenaCommonFlags from CaloRec.CaloCellFlags import jobproperties if globalflags.DataSource() == 'data' and ( not jobproperties.CaloCellFlags.doPileupOffsetBCIDCorr()) and ( not athenaCommonFlags.isOnline()): lumiFolder = '/TRIGGER/LUMI/LBLESTONL' conddb.addFolder('TRIGGER_ONL', lumiFolder) theCaloCellPedestalCorr.Luminosity = -1 theCaloCellPedestalCorr.LumiFolderName = lumiFolder if jobproperties.CaloCellFlags.doPileupOffsetBCIDCorr() and ( not athenaCommonFlags.isOnline()): from CaloTools.CaloLumiBCIDToolDefault import CaloLumiBCIDToolDefault theCaloLumiBCIDTool = CaloLumiBCIDToolDefault() ToolSvc += theCaloLumiBCIDTool theCaloCellPedestalCorr.LumiBCIDTool = theCaloLumiBCIDTool return thePedestalTool
def __init__(self): from AthenaCommon.AppMgr import ServiceMgr as svcMgr from AthenaCommon.AppMgr import ToolSvc from SiLorentzAngleSvc.SiLorentzAngleSvcConf import SiLorentzAngleSvc # Init PixelLorentzAngleSvc if hasattr(svcMgr, 'PixelLorentzAngleSvc'): pixelLorentzAngleSvc = svcMgr.PixelLorentzAngleSvc else: pixelLorentzAngleSvc = SiLorentzAngleSvc( name="PixelLorentzAngleSvc", DetectorName="Pixel") svcMgr += pixelLorentzAngleSvc # Init PixelSiliconConditionsSvc if hasattr(svcMgr, 'PixelSiliconConditionsSvc'): pixelSiliconConditionsSvc = svcMgr.PixelSiliconConditionsSvc else: from PixelConditionsServices.PixelConditionsServicesConf import PixelSiliconConditionsSvc pixelSiliconConditionsSvc = PixelSiliconConditionsSvc() svcMgr += pixelSiliconConditionsSvc pixelSiliconConditionsSvc.DepletionVoltage = 10.0 from SiPropertiesSvc.SiPropertiesSvcConf import SiPropertiesSvc pixelSiPropertiesSvc = SiPropertiesSvc( name="PixelSiPropertiesSvc", DetectorName="Pixel", SiConditionsServices=pixelSiliconConditionsSvc) svcMgr += pixelSiPropertiesSvc # Pass the silicon conditions services to the Lorentz angle service # Also make sure UseMagFieldTool is True as AtlasGeoModel sets this to False # if loaded first. pixelLorentzAngleSvc.UseMagFieldSvc = True pixelLorentzAngleSvc.SiConditionsServices = pixelSiliconConditionsSvc pixelLorentzAngleSvc.SiPropertiesSvc = pixelSiPropertiesSvc #pixelLorentzAngleSvc.CorrectionFactor = 0.900 #Load Correction factor from database from IOVDbSvc.CondDB import conddb #conddb.addFolder("","/PIXEL/LorentzAngleScale<db>sqlite://;schema=PixelLorentzAngle_MC.db;dbname=OFLP200</db><tag>PIXELLorentzAngleScale-Simu-001</tag>") #conddb.addFolder("PIXEL_OFL","/PIXEL/LorentzAngleScale") from AthenaCommon.AthenaCommonFlags import athenaCommonFlags if athenaCommonFlags.isOnline(): conddb.addFolderSplitOnline("PIXEL", "/PIXEL/Onl/LorentzAngleScale", "/PIXEL/LorentzAngleScale") else: conddb.addFolder("PIXEL_OFL", "/PIXEL/LorentzAngleScale") pixelLorentzAngleSvc.CorrDBFolder = "/PIXEL/LorentzAngleScale" self.PixelLorentzAngleSvc = pixelLorentzAngleSvc self.pixelSiliconConditionsSvc = pixelSiliconConditionsSvc self.PixelSiliconConditionsSvc = pixelSiliconConditionsSvc self.pixelSiPropertiesSvc = pixelSiPropertiesSvc self.PixelSiPropertiesSvc = pixelSiPropertiesSvc self.PixelSiPropertiesSvc.UseConditionsDB = True
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 initLorentzAngleTool(self, instanceName): # Set up Silicon Conditions Tool from SCT_ConditionsTools.SCT_SiliconConditionsToolSetup import SCT_SiliconConditionsToolSetup sct_SiliconConditionsToolSetup = SCT_SiliconConditionsToolSetup() sct_SiliconConditionsToolSetup.setDcsTool(self.dcsTool) sct_SiliconConditionsToolSetup.setToolName( "InDetSCT_SiliconConditionsTool") sct_SiliconConditionsToolSetup.setup() sctSiliconConditionsTool = sct_SiliconConditionsToolSetup.getTool() sctSiliconConditionsTool.CheckGeoModel = False sctSiliconConditionsTool.ForceUseGeoModel = False if self._print: print(sctSiliconConditionsTool) # Set up SCTSiLorentzAngleCondAlg from AthenaCommon.AlgSequence import AthSequencer condSeq = AthSequencer("AthCondSeq") if not hasattr(condSeq, "SCTSiLorentzAngleCondAlg"): from SiLorentzAngleTool.SiLorentzAngleToolConf import SCTSiLorentzAngleCondAlg from AthenaCommon.AthenaCommonFlags import athenaCommonFlags condSeq += SCTSiLorentzAngleCondAlg( name="SCTSiLorentzAngleCondAlg", SiConditionsTool=sctSiliconConditionsTool, UseMagFieldCache=True, UseMagFieldDcs=(not athenaCommonFlags.isOnline())) sctSiLorentzAngleCondAlg = condSeq.SCTSiLorentzAngleCondAlg "Inititalize Lorentz angle Tool" from SiLorentzAngleTool.SiLorentzAngleToolConf import SiLorentzAngleTool SCTLorentzAngleTool = SiLorentzAngleTool( name=instanceName, DetectorName="SCT", SiLorentzAngleCondData="SCTSiLorentzAngleCondData") SCTLorentzAngleTool.UseMagFieldCache = True
def _setup(): from PyUtils.MetaReader import read_metadata from AthenaCommon.Logging import logging msg = logging.getLogger('MetaReader') global metadata global metadata_all_files # get input file name from RecExConfig.RecoFunctions import InputFileNames from AthenaCommon.AthenaCommonFlags import athenaCommonFlags if athenaCommonFlags.isOnline() and (not InputFileNames() or all( [f.strip() == '' for f in InputFileNames()])): # set minimal items of inputFileSummary metadata = { 'file_type': 'BS', 'eventTypes': ['IS_DATA', 'IS_ATLAS', 'IS_PHYSICS'], 'TagStreamsRef': '' } else: inFiles = InputFileNames() if len(inFiles) < 1: msg.warning("No input files specified yet! Cannot do anything.") return metadata_all_files = read_metadata(inFiles, mode='peeker', promote=True) first_filename = inFiles[0] metadata = metadata_all_files[first_filename] metadata['file_name'] = first_filename
def GetProjectName(): # special option for online running from AthenaCommon.AthenaCommonFlags import athenaCommonFlags if athenaCommonFlags.isOnline(): from RecExOnline.OnlineISConfiguration import GetRunType rec.projectName = GetRunType()[2] # continue with options for offline running if rec.projectName() == "": from PyUtils.MetaReaderPeeker import metadata whatIsIt = None try: whatIsIt = metadata['eventTypes'][0] except: pass if whatIsIt == 'IS_SIMULATION': project = 'IS_SIMULATION' else: try: project = metadata['project_name'] except: from RecExConfig.GetCool import cool project = cool.fileNameTag() pass #rec.projectName.set_Value_and_Lock(project) logAutoConfiguration.info( "Success! GetProjectName() found a project named %s" % project) else: project = rec.projectName() if not project in KnownProjects: logAutoConfiguration.warning( "Project '%s' is not part of the KnownProjects list." % project) #print(KnownProjects) return project
def AtlasFieldMapCondAlg(name="AtlasFieldMapCondAlg", **kwargs): if athenaCommonFlags.isOnline(): # For old tests, must update field from defautl jobOpt kwargs.setdefault("UseMapsFromCOOL", False) # online has the map loaded at start (for the future - uncomment if needed) # kwargs.setdefault( "LoadMapOnStart", True ) return CfgMgr.MagField__AtlasFieldMapCondAlg(name, **kwargs)
def AtlasFieldSvc(name="AtlasFieldSvc", **kwargs): if athenaCommonFlags.isOnline(): kwargs.setdefault("UseDCS", False) kwargs.setdefault("UseSoleCurrent", 7730) kwargs.setdefault("UseToroCurrent", 20400) else: kwargs.setdefault("UseDCS", True) return CfgMgr.MagField__AtlasFieldSvc(name, **kwargs)
def __init__(self, name='TrigCaloDataAccessSvc'): super(TrigCaloDataAccessSvc, self).__init__(name) from AthenaCommon.AppMgr import ServiceMgr as svcMgr from TriggerJobOpts.TriggerFlags import TriggerFlags from AthenaCommon.GlobalFlags import globalflags from AthenaCommon.AthenaCommonFlags import athenaCommonFlags from AthenaCommon.Logging import logging log = logging.getLogger(name) if ( globalflags.DatabaseInstance == "COMP200" and TriggerFlags.doCaloOffsetCorrection() ) : log.warning("Not possible to run BCID offset correction with COMP200") else: if TriggerFlags.doCaloOffsetCorrection(): if globalflags.DataSource()=='data' and athenaCommonFlags.isOnline(): log.info('Enable HLT calo offset correction for data') from IOVDbSvc.CondDB import conddb conddb.addFolder("LAR_ONL","/LAR/ElecCalibFlat/OFC") from LArRecUtils.LArRecUtilsConf import LArFlatConditionSvc svcMgr += LArFlatConditionSvc() svcMgr.LArFlatConditionSvc.OFCInput="/LAR/ElecCalibFlat/OFC" svcMgr.ProxyProviderSvc.ProviderNames += [ "LArFlatConditionSvc" ] from IOVDbSvc.CondDB import conddb conddb.addFolder("LAR_ONL","/LAR/ElecCalibFlat/OFC",className = 'CondAttrListCollection') from AthenaCommon.AlgSequence import AthSequencer condSequence = AthSequencer("AthCondSeq") from LArRecUtils.LArRecUtilsConf import LArFlatConditionsAlg_LArOFCFlat_ as LArOFCCondAlg condSequence += LArOFCCondAlg (ReadKey="/LAR/ElecCalibFlat/OFC", WriteKey='LArOFC') from LumiBlockComps.LuminosityCondAlgDefault import LuminosityCondAlgOnlineDefault LuminosityCondAlgOnlineDefault() from CaloRec.CaloBCIDAvgAlgDefault import CaloBCIDAvgAlgDefault CaloBCIDAvgAlgDefault() else: log.info('Enable HLT calo offset correction for MC') from CaloRec.CaloBCIDAvgAlgDefault import CaloBCIDAvgAlgDefault CaloBCIDAvgAlgDefault() from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() if not hasattr(topSequence,"CaloBCIDAvgAlg"): log.info('Cannot use timer for CaloBCIDAvgAlg') else: from AthenaMonitoringKernel.GenericMonitoringTool import GenericMonitoringTool monTool = GenericMonitoringTool('MonTool') monTool.defineHistogram('TIME_exec', path='EXPERT', type='TH1F', title="CaloBCIDAvgAlg execution time; time [ us ] ; Nruns", xbins=80, xmin=0.0, xmax=4000) topSequence.CaloBCIDAvgAlg.MonTool = monTool log.info('using timer for CaloBCIDAvgAlg') else: log.info('Disable HLT calo offset correction') return
def AtlasFieldCacheCondAlg(name="AtlasFieldCacheCondAlg", **kwargs): if athenaCommonFlags.isOnline(): kwargs.setdefault("UseDCS", False) # currents for scaling wrt to map currents kwargs.setdefault("UseSoleCurrent", 7730) kwargs.setdefault("UseToroCurrent", 20400) kwargs.setdefault("LockMapCurrents", True) else: kwargs.setdefault("UseDCS", True) return CfgMgr.MagField__AtlasFieldCacheCondAlg(name, **kwargs)
def _setup(): global inputFileSummary import os from RecExConfig.RecFlags import rec import AthenaCommon.Logging as L from AthenaCommon.Resilience import treatException #define a logger msg = L.logging.getLogger('inputFilePeeker' ) msg.info("Executing inputFilePeeker.py") # special setup for online reconstruction so far from AthenaCommon.AthenaCommonFlags import athenaCommonFlags if athenaCommonFlags.isOnline(): # set minimal items of inputFileSummary inputFileSummary={'file_type':'bs', 'evt_type':['IS_DATA','IS_ATLAS','IS_PHYSICS'], 'TagStreamsRef':''} return #get input file name from RecExConfig.RecoFunctions import InputFileNames inFiles=InputFileNames() if len(inFiles) < 1: msg.error("No input files specified yet! Cannot do anything.") #create and fill inputFileSummary (DC: looping through input files if necessary) import PyUtils.AthFile as athFile failed_trials = 0 for inFile in inFiles: try: fi = athFile.fopen(inFile) inputFileSummary = fi.fileinfos except Exception,err: msg.warning("Unable to open file [%s]"%inFile) msg.warning('caught:\n%s',err) import traceback traceback.print_exc() continue ## Making sure that stream_names is always defined if not inputFileSummary.has_key('stream_names'): msg.warning("AthFile didn't find key 'stream_names'. Recovering it but that's unexpected.") inputFileSummary['stream_names']=[] #First try to catch the no entries case if inputFileSummary['stream_names'] == []: try: #print fi.infos['metadata_items'][0][1] inputFileSummary['stream_names'] = [fi.infos['metadata_items'][0][1]] except Exception, err: msg.info("Unable to find stream names in file metadata.")
def __init__(self, name='TrigDataAccess'): super(TrigDataAccess, self).__init__(name) from AthenaCommon.AppMgr import ServiceMgr as svcMgr from TriggerJobOpts.TriggerFlags import TriggerFlags from AthenaCommon.GlobalFlags import globalflags from AthenaCommon.AthenaCommonFlags import athenaCommonFlags from AthenaCommon.Logging import logging log = logging.getLogger(name) self.loadFullCollections = (TriggerFlags.doEF() or TriggerFlags.doHLT()) self.loadAllSamplings = (TriggerFlags.doLVL2() or TriggerFlags.doHLT()) if (globalflags.DatabaseInstance == "COMP200" and TriggerFlags.doCaloOffsetCorrection()): self.ApplyOffsetCorrection = False log.warning( "Not possible to run BCID offset correction with COMP200") else: if TriggerFlags.doCaloOffsetCorrection(): log.info('Enable HLT calo offset correction') if globalflags.DataSource( ) == 'data' and athenaCommonFlags.isOnline(): from IOVDbSvc.CondDB import conddb conddb.addFolder("LAR_ONL", "/LAR/ElecCalibFlat/OFC") from LArRecUtils.LArRecUtilsConf import LArFlatConditionSvc svcMgr += LArFlatConditionSvc() svcMgr.LArFlatConditionSvc.OFCInput = "/LAR/ElecCalibFlat/OFC" svcMgr.ProxyProviderSvc.ProviderNames += [ "LArFlatConditionSvc" ] from CaloTools.CaloLumiBCIDToolDefault import CaloLumiBCIDToolDefault theCaloLumiBCIDTool = CaloLumiBCIDToolDefault() svcMgr.ToolSvc += theCaloLumiBCIDTool self.CaloLumiBCIDTool = theCaloLumiBCIDTool self.ApplyOffsetCorrection = True else: log.info('Disable HLT calo offset correction') self.ApplyOffsetCorrection = False from RecExConfig.RecFlags import rec transientBS = (rec.readRDO() and not globalflags.InputFormat() == 'bytestream') if (transientBS or TriggerFlags.writeBS()): if (not hasattr(svcMgr.ToolSvc, 'LArRawDataContByteStreamTool')): from LArByteStream.LArByteStreamConfig import LArRawDataContByteStreamToolConfig svcMgr.ToolSvc += LArRawDataContByteStreamToolConfig() svcMgr.ToolSvc.LArRawDataContByteStreamTool.DSPRunMode = 4 svcMgr.ToolSvc.LArRawDataContByteStreamTool.RodBlockVersion = 10 return
def GetRunNumber(): runNb = None from RecExConfig.RecFlags import rec if rec.RunNumber.isDefault(): from PyUtils.MetaReaderPeeker import metadata try: runNb = metadata['runNumbers'][0] except Exception: from AthenaCommon.AthenaCommonFlags import athenaCommonFlags if not athenaCommonFlags.isOnline(): logAutoConfiguration.error("No RunNumber stored in InputFile!") else: runNb = rec.RunNumber() logAutoConfiguration.debug("RunNumber is: %s", runNb) return runNb
def GetRunNumber(): runNb = None from RecExConfig.RecFlags import rec if rec.RunNumber.isDefault(): from RecExConfig.InputFilePeeker import inputFileSummary try: runNb = inputFileSummary['run_number'][0] except Exception: from AthenaCommon.AthenaCommonFlags import athenaCommonFlags if not athenaCommonFlags.isOnline(): logAutoConfiguration.error("No RunNumber stored in InputFile!") else: runNb = rec.RunNumber() logAutoConfiguration.debug("RunNumber is: %s", runNb) return runNb
def CscCalibTool(name, **kwargs): import MuonCondAlg.CscCondDbAlgConfig # MT-safe conditions access # make tool return CfgMgr.CscCalibTool(Slope=0.19, Noise=3.5, Pedestal=2048.0, ReadFromDatabase=True, SlopeFromDatabase=False, integrationNumber=12.0, integrationNumber2=11.66, samplingTime=50.0, signalWidth=14.40922, timeOffset=71.825, IsOnline=athenaCommonFlags.isOnline(), Latency=119)
def CscCalibTool(name, **kwargs): # setup condDB folders setupCscCondDB() # make tool return CfgMgr.CscCalibTool(Slope=0.19, Noise=3.5, Pedestal=2048.0, ReadFromDatabase=True, SlopeFromDatabase=False, integrationNumber=12.0, integrationNumber2=11.66, samplingTime=50.0, signalWidth=14.40922, timeOffset=71.825, IsOnline=athenaCommonFlags.isOnline(), Latency=119)
def CaloCellPedestalCorrDefault(name='CaloCellPedestalCorr'): import traceback from AthenaCommon.Logging import logging mlog = logging.getLogger( 'CaloCellPedestalCorrDefault' ) from AthenaCommon.AppMgr import ToolSvc from AthenaCommon.GlobalFlags import globalflags try: from CaloCellCorrection.CaloCellCorrectionConf import CaloCellPedestalCorr theCaloCellPedestalCorr = CaloCellPedestalCorr("CaloCellPedestalCorr") except: mlog.error("could not get handle to CaloCellPedestalCorr Quit") traceback.print_exc() #ToolSvc += theCaloCellPedestalCorr if globalflags.DataSource()=='data' : from IOVDbSvc.CondDB import conddb if conddb.isOnline: folder = '/CALO/Pedestal/CellPedestal' conddb.addFolder('CALO_ONL',folder,className="CondAttrListCollection") else: folder= '/CALO/Ofl/Pedestal/CellPedestal' conddb.addFolder('CALO_OFL',folder,className="CondAttrListCollection") theCaloCellPedestalCorr.PedestalShiftFolder = folder theCaloCellPedestalCorr.isMC=False else: theCaloCellPedestalCorr.isMC=True from AthenaCommon.AthenaCommonFlags import athenaCommonFlags from CaloRec.CaloCellFlags import jobproperties if globalflags.DataSource()=='data' and (not jobproperties.CaloCellFlags.doPileupOffsetBCIDCorr()) and (not athenaCommonFlags.isOnline()): lumiFolder = '/TRIGGER/LUMI/LBLESTONL' conddb.addFolder('TRIGGER_ONL',lumiFolder,className="CondAttrListCollection"); theCaloCellPedestalCorr.Luminosity = -1 theCaloCellPedestalCorr.LumiFolderName = lumiFolder if jobproperties.CaloCellFlags.doPileupOffsetBCIDCorr() and (not athenaCommonFlags.isOnline()): from CaloRec.CaloBCIDAvgAlgDefault import CaloBCIDAvgAlgDefault CaloBCIDAvgAlgDefault() theCaloCellPedestalCorr.CaloBCIDAverageKey="CaloBCIDAverage" else: theCaloCellPedestalCorr.CaloBCIDAverageKey="" return theCaloCellPedestalCorr
def setupCOOLDCS(self, defTag="", dbConnection="", useHV=True, useHVSET=False, useSTATUS=True): """ Call this function to read DCS from COOL folder. Input parameters: - defTag : Tag to be added to each folder tag (NGO change this to a hierarchical tag!) - dbConnection : The DB connection string to use [default "": auto-initialization by CondDBSetup.py] """ #=== prevent a second initialization if self._coolDCSIsConfigured: self._msg.info( "setupCOOLDCS already called previously, ignoring this repeated call!" ) return self._coolDCSIsConfigured = True ## #=== ensure the availability of TileDCSSvc from AthenaCommon.GlobalFlags import globalflags from AthenaCommon.AthenaCommonFlags import athenaCommonFlags TileUseDCS = (not athenaCommonFlags.isOnline() ) and globalflags.DataSource() == 'data' ## get a handle to the ServiceManager from AthenaCommon.AppMgr import ServiceMgr as svcMgr if TileUseDCS and not hasattr(svcMgr, "TileDCSSvc"): self._msg.info("setting up DCS TileCal conditions data") dbConnStr = 'DCS_OFL' from IOVDbSvc.CondDB import conddb if useHV: conddb.addFolder(dbConnStr, "/TILE/DCS/HV") if useHVSET: conddb.addFolder(dbConnStr, "/TILE/DCS/HVSET") if useSTATUS: conddb.addFolder(dbConnStr, "/TILE/DCS/STATES") self._msg.info("Adding TileDCSSvc to ServiceMgr") svcMgr += CfgMgr.TileDCSSvc() from IOVDbSvc.CondDB import conddb if (conddb.GetInstance() == 'CONDBR2'): self._msg.info("setting up TileDCSSvc for RUN2") svcMgr.TileDCSSvc.Version = 2 else: self._msg.info("setting up TileDCSSvc for RUN1") svcMgr.TileDCSSvc.Version = 1
def addArray(self, dimensions, alg, baseName, topPath='', defaultDuration='run'): '''Add many groups to an algorithm Arguments: dimensions -- list holding the size in each dimension [n1,n2,n3,n4,...] alg -- algorithm Configurable object baseName -- base name of the group. postfixes are added by GMT Array initialize topPath -- directory name in the output ROOT file under which histograms will be produced duration -- default time between histogram reset for all histograms in group Returns: array -- a GenericMonitoringToolArray object. This is used to define histograms associated with each group in the array. ''' # Generate the n-dimensional array from AthenaMonitoringKernel.GenericMonitoringTool import GenericMonitoringArray array = GenericMonitoringArray(baseName, dimensions) # Retrieve the THistSvc from AthenaCommon.AppMgr import ServiceMgr as svcMgr if not hasattr(svcMgr, 'THistSvc'): from GaudiSvc.GaudiSvcConf import THistSvc svcMgr += THistSvc() # Set the histogram path pathToSet = self.dqflags.monManFileKey() + ('/%s' % topPath if topPath else '') # Detect if online or offline from AthenaCommon.AthenaCommonFlags import athenaCommonFlags conventionName = 'OFFLINE' if not athenaCommonFlags.isOnline( ) else 'ONLINE' # Broadcast member values to each element of the array array.broadcast('THistSvc', svcMgr.THistSvc) array.broadcast('HistPath', pathToSet) array.broadcast('convention', conventionName) array.broadcast('defaultDuration', defaultDuration) alg.GMTools += array.toolList() return array
def setAlg(self): hvFolder = "/PIXEL/DCS/HV" tempFolder = "/PIXEL/DCS/TEMPERATURE" dbInstance = "DCS_OFL" from AthenaCommon.AthenaCommonFlags import athenaCommonFlags if athenaCommonFlags.isOnline(): hvFolder = "/PIXEL/HLT/DCS/HV" tempFolder = "/PIXEL/HLT/DCS/TEMPERATURE" dbInstance = "PIXEL_ONL" from IOVDbSvc.CondDB import conddb if not conddb.folderRequested(hvFolder): conddb.addFolder(dbInstance, hvFolder, className="CondAttrListCollection") if not conddb.folderRequested(tempFolder): conddb.addFolder(dbInstance, tempFolder, className="CondAttrListCollection") from AthenaCommon.GlobalFlags import globalflags from AthenaCommon.AlgSequence import AthSequencer condSeq = AthSequencer("AthCondSeq") if not hasattr(condSeq, "PixelDCSCondHVAlg"): from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelDCSCondHVAlg condSeq += PixelDCSCondHVAlg(name="PixelDCSCondHVAlg", ReadKey=hvFolder) if not hasattr(condSeq, "PixelDCSCondTempAlg"): from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelDCSCondTempAlg condSeq += PixelDCSCondTempAlg(name="PixelDCSCondTempAlg", ReadKey=tempFolder) from AthenaCommon.AppMgr import ToolSvc if not hasattr(condSeq, "PixelSiPropertiesCondAlg"): from SiPropertiesTool.SiPropertiesToolConf import PixelSiPropertiesCondAlg condSeq += PixelSiPropertiesCondAlg( name="PixelSiPropertiesCondAlg") self.alg = getattr(condSeq, "PixelSiPropertiesCondAlg")
#from LArCellRec.LArNoisyROFlags import larNoisyROFlags # --- for athena online running --- if 'EventBlockSize' not in dir(): EventBlockSize = 0 #Run is Online or Offline: from AthenaCommon.AthenaCommonFlags import athenaCommonFlags OnlineMode = athenaCommonFlags.isOnline() #some FEBs to be monitored (updated 04 may 2018) MiniNoiseBurstFlagging_FEBs = [ "barrelAft09slot02", "barrelAft09slot14", "barrelAft10slot10", "barrelAft10slot14", "barrelAft31slot14", "barrelCft08slot14", "barrelCft22slot07", "barrelCft27slot05", "barrelCft27slot14" ] NewlyNoisy_FEBs = [ "barrelCft02slot14", "barrelCft01slot14", "barrelCft07slot09", "barrelCft07slot11", "barrelCft06slot14" ] NoisyRegionsInOuterWheel_FEBs = [ "endcapCft21slot04", "endcapCft21slot02", "endcapCft02slot04", "endcapCft02slot02", "endcapCft09slot02", "endcapCft09slot03", "endcapAft21slot04", "endcapAft21slot02", "endcapAft21slot03" ] NotNoisyRegionForComparison_FEBs = ["endcapAft02slot04"] FEBs_from_DQ_run_350440 = [ "endcapAft19slot12", "endcapAft19slot09", "endcapAft20slot09" ] defaultFEBs = NotNoisyRegionForComparison_FEBs + NoisyRegionsInOuterWheel_FEBs + NewlyNoisy_FEBs + MiniNoiseBurstFlagging_FEBs + FEBs_from_DQ_run_350440
if TilePedRun: TileRunType = 4 TileBiGainRun = True if not 'TileCisRun' in dir(): TileCisRun = False if TileCisRun: TileRunType = 8 TileBiGainRun = True from AthenaCommon.AthenaCommonFlags import athenaCommonFlags if not 'TileSummaryUpdateFrequency' in dir(): if athenaCommonFlags.isOnline(): TileSummaryUpdateFrequency = 100 else: TileSummaryUpdateFrequency = 0 def FindFile(path, runinput): run = str(runinput) while len(run) < 7: run = '0' + run files = [] fullname = [] if path.startswith("/castor") :
if DQMonFlags.monManEnvironment() == 'tier0Raw': tileRawMon=True tileESDMon=False elif DQMonFlags.monManEnvironment() == 'tier0ESD': tileRawMon=False tileESDMon=True else: # it should be 'tier0' tileRawMon=True tileESDMon=True if tileESDMon: TileCellMon = CfgMgr.TileCellMonTool(name = 'TileCellMon' , OutputLevel = INFO , doOnline = athenaCommonFlags.isOnline() , cellsContainerName = "AllCalo" , FillHistogramsForL1Triggers = [] , FillChannelTimePerSampleHistograms = False , FillCellTimeAndEnergyDifferenceHistograms = False , FillDigitizerEnergyVsLBHistograms = False , histoPathBase = "/Tile/Cell") if (jobproperties.Beam.beamType() == 'cosmics' or jobproperties.Beam.beamType() == 'singlebeam'): TileCellMon.FillTimeHistograms = True TileCellMon.energyThresholdForTime = 150.0 ToolSvc += TileCellMon; ManagedAthenaTileMon.AthenaMonTools += [ TileCellMon ];
tileInfoConfigurator.setupCOOLINTEGRATOR() tileInfoConfigurator.setupCOOLMUID() tileInfoConfigurator.setupCOOLPHYPULSE() tileInfoConfigurator.setupCOOLAutoCr() #============================================================ #=== configure TileInfoDump #============================================================ from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() from xAODEventInfoCnv.xAODEventInfoCreator import xAODMaker__EventInfoCnvAlg topSequence += xAODMaker__EventInfoCnvAlg() from TileCalibAlgs.TileCalibAlgsConf import TileInfoDump tileInfoDump = TileInfoDump() from AthenaCommon.AthenaCommonFlags import athenaCommonFlags tileInfoDump.AthenaIsOnline = athenaCommonFlags.isOnline() #=== add private fit method noise tool from TileConditions.TileCondToolConf import getTileCondToolNoiseRawChn tileInfoDump.TileCondToolNoiseRawChn = getTileCondToolNoiseRawChn('COOL') #=== switch section printout on/off tileInfoDump.PrintEmscale = True tileInfoDump.PrintEmscaleOnl = True tileInfoDump.PrintLaser = True tileInfoDump.PrintIntegrator = True tileInfoDump.PrintPedestals = True tileInfoDump.PrintTimingCorrections = True # set also run type below tileInfoDump.PrintBadChannels = True tileInfoDump.PrintPulseShapes = True # set also run type below tileInfoDump.PrintOfcsCool = True # set also run type below
globalflags.InputFormat.set_Value_and_Lock('pool') athenaCommonFlags.PoolRDOInput.set_Value_and_Lock( runArgs.inputRDOFile ) #include("RecExCommon/RecExCommon_topOptions.py") ServiceMgr.EventSelector.InputCollections = runArgs.inputRDOFile # ConditionsTag from IOVDbSvc.CondDB import conddb if len(globalflags.ConditionsTag())!=0: conddb.setGlobalTag(globalflags.ConditionsTag()) include("RecExCond/AllDet_detDescr.py") # Particle Property protectedInclude( "PartPropSvc/PartPropSvc.py" ) include.block( "PartPropSvc/PartPropSvc.py" ) # Detector Status if rec.doDetStatus() and not athenaCommonFlags.isOnline(): try: include("DetectorStatus/DetStatusSvc_CondDB.py") except Exception: treatException("Could not load DetStatusSvc_CondDb !") rec.doFileMetaData=False else: raise RuntimeError('No FTK inputs given. A TXT_FTKIP, NTUP_FTKIP or RDO file is mandatory.') # Set output file if hasattr(runArgs,'outputNTUP_FTKTMPFile'): FTKTrackFitter.TrackFileName = runArgs.outputNTUP_FTKTMPFile else: ftkLog.warning('FTK Sim output filename was unset') #check if we want to save 1st stage tracks
DistanceToStraw = 0.4, LongToTCut = 9.375, is_TRT_only_tracks = True, # obsolete is_zero_mag_field = True, # obsolete #Histogram Switches doAside = True, # obsolete doCside = True, # obsolete doStraws = True, doChips = True, doShift = True, doDiagnostic = True, # obsolete EventBurstCut = eventBurstCut, # default = 200 DoRDOsMon = True, DoGeoMon = False, DoTracksMon = True, doExpert = athenaCommonFlags.isOnline(), IsCosmics = InDetFlags.doCosmics(), InDetTRT_DAQ_ConditionsSvc = InDetTRT_DAQ_ConditionsSvc, doEfficiency = False, # ME: turn off TRT hole search, it fails Tier-0 every_xth_track = 25, whatdatatype = DQMonFlags.monManDataType(), MinTRTHitCut = 10, max_abs_d0 = 10 * Units.mm, max_abs_z0 = 300 * Units.mm, max_abs_eta = 2.5, MinTrackP = 0.0 * Units.GeV, min_pT = minTrkPtCut, # default = 0.5 GeV min_si_hits = minSiHitCut, # default = 1 min_pixel_hits = 0, min_sct_hits = 0, min_trt_hits = 10
def __init__(self,doOldStyleConfig=False): "Setup conditions DB - IOVDbSvc and connections according to GlobalFlags" from AthenaCommon.AppMgr import ServiceMgr as svcMgr from AthenaCommon.Logging import logging self.msg = logging.getLogger( 'IOVDbSvc.CondDB' ) self.msg.debug("Loading basic services for CondDBSetup...") # AthenaPool and IOVDbSvc configuration from AthenaPoolCnvSvc import AthenaPool # noqa: F401 from IOVDbSvc import IOVDb # noqa: F401 # local access to IOVDbSvc parameters self.iovdbsvc=svcMgr.IOVDbSvc # initialise list of allowed DBs self.dblist={} # and list of blocked folders self.blocklist=[] # decide which instance to setup # default database self.dbname='' # names for MC and data database in case forceMC/forceData are used self.dbmc='' self.dbdata='' self.poolcats=[] from AthenaCommon.GlobalFlags import globalflags from AthenaCommon.AthenaCommonFlags import athenaCommonFlags self.isOnline=athenaCommonFlags.isOnline() self.isMC=not globalflags.DataSource()=='data' if (globalflags.DetGeo() in ['atlas','commis']): # ATLAS full or commissioning geometry self.dbmc='OFLP200' self.dbdata=globalflags.DatabaseInstance() #could be 'auto' if self.isMC: # Monte Carlo self.dbname=self.dbmc self.poolcats=['oflcond'] else: # real data if (self.dbdata=='auto'): from RecExConfig.RecFlags import rec self.dbdata=self._InstanceFromProjectName(rec.projectName()) self.msg.info("Configuring database instance %s based on project tag %s", self.dbdata, rec.projectName()) self.dbname=self.dbdata self.poolcats=['comcond','oflcond'] elif (globalflags.DetGeo() in ['ctbh8','ctbh6']): self.dbmc='TMCP200' self.dbdata='TBDP200' if self.isMC: # 2004 combined testbeam, Monte Carlo self.dbname=self.dbmc self.poolcats=['tbcond','oflcond'] else: # 2004 combined testbeam, real data self.dbname=self.dbdata self.poolcats=['tbcond','oflcond'] else: raise RuntimeError("Unknown globalflags.DetGeo: %s" % globalflags.DetGeo()) if (self.dbname!=''): self.msg.info('Setting up conditions DB access to instance %s', self.dbname) # set up all access options - online schemas self._SetAcc('INDET','COOLONL_INDET') self._SetAcc('INDET_ONL','COOLONL_INDET') self._SetAcc('PIXEL','COOLONL_PIXEL') self._SetAcc('PIXEL_ONL','COOLONL_PIXEL') self._SetAcc('SCT','COOLONL_SCT') self._SetAcc('SCT_ONL','COOLONL_SCT') self._SetAcc('TRT','COOLONL_TRT') self._SetAcc('TRT_ONL','COOLONL_TRT') self._SetAcc('LAR','COOLONL_LAR') self._SetAcc('LAR_ONL','COOLONL_LAR') self._SetAcc('TILE','COOLONL_TILE') self._SetAcc('TILE_ONL','COOLONL_TILE') self._SetAcc('MUON','COOLONL_MUON') self._SetAcc('MUON_ONL','COOLONL_MUON') self._SetAcc('MUONALIGN','COOLONL_MUONALIGN') self._SetAcc('MUONALIGN_ONL','COOLONL_MUONALIGN') self._SetAcc('MDT','COOLONL_MDT') self._SetAcc('MDT_ONL','COOLONL_MDT') self._SetAcc('RPC','COOLONL_RPC') self._SetAcc('RPC_ONL','COOLONL_RPC') self._SetAcc('TGC','COOLONL_TGC') self._SetAcc('TGC_ONL','COOLONL_TGC') self._SetAcc('CSC','COOLONL_CSC') self._SetAcc('CSC_ONL','COOLONL_CSC') self._SetAcc('TDAQ','COOLONL_TDAQ') self._SetAcc('TDAQ_ONL','COOLONL_TDAQ') self._SetAcc('GLOBAL','COOLONL_GLOBAL') self._SetAcc('GLOBAL_ONL','COOLONL_GLOBAL') self._SetAcc('TRIGGER','COOLONL_TRIGGER') self._SetAcc('TRIGGER_ONL','COOLONL_TRIGGER') self._SetAcc('CALO','COOLONL_CALO') self._SetAcc('CALO_ONL','COOLONL_CALO') self._SetAcc('FWD','COOLONL_FWD') self._SetAcc('FWD_ONL','COOLONL_FWD') # set up all access options - offline schemas # only do this if isOnline flag is NOT set # or MC flag is set, to allow HLT testing using MC database if (self.isMC or not self.isOnline): self._SetAcc('INDET_OFL','COOLOFL_INDET') self._SetAcc('PIXEL_OFL','COOLOFL_PIXEL') self._SetAcc('SCT_OFL','COOLOFL_SCT') self._SetAcc('TRT_OFL','COOLOFL_TRT') self._SetAcc('LAR_OFL','COOLOFL_LAR') self._SetAcc('TILE_OFL','COOLOFL_TILE') self._SetAcc('MUON_OFL','COOLOFL_MUON') self._SetAcc('MUONALIGN_OFL','COOLOFL_MUONALIGN') self._SetAcc('MDT_OFL','COOLOFL_MDT') self._SetAcc('RPC_OFL','COOLOFL_RPC') self._SetAcc('TGC_OFL','COOLOFL_TGC') self._SetAcc('CSC_OFL','COOLOFL_CSC') self._SetAcc('TDAQ_OFL','COOLOFL_TDAQ') self._SetAcc('DCS_OFL','COOLOFL_DCS') self._SetAcc('GLOBAL_OFL','COOLOFL_GLOBAL') self._SetAcc('TRIGGER_OFL','COOLOFL_TRIGGER') self._SetAcc('CALO_OFL','COOLOFL_CALO') self._SetAcc('FWD_OFL','COOLOFL_FWD') else: self.msg.info('Running in online mode - no access to COOLOFL schemas') self.iovdbsvc.OnlineMode=True # setup default connection to localfile, and put in LOCAL symbol localfile="sqlite://;schema=mycool.db;dbname=" self.dblist['LOCAL']=localfile self.iovdbsvc.dbConnection=localfile+self.dbname # setup knowledge of dbinstance in IOVDbSvc, for global tag x-check self.iovdbsvc.DBInstance=self.dbname # setup DBReplicaSvc to veto DBRelease SQLite files if real data if not self.isMC: from DBReplicaSvc.DBReplicaSvcConf import DBReplicaSvc svcMgr+=DBReplicaSvc(COOLSQLiteVetoPattern="/DBRelease/") # enable Frontier cache alignment if it looks like Frontier will # be used (via FRONTIER_SERVER variable) if 'FRONTIER_SERVER' in os.environ.keys() and os.environ['FRONTIER_SERVER']!="": self.iovdbsvc.CacheAlign=3 # setup PoolSvc catalogues from PoolSvc.PoolSvcConf import PoolSvc if not hasattr (svcMgr, 'PoolSvc'): svcMgr+=PoolSvc() # add the standard catalogues for i in self.poolcats: svcMgr.PoolSvc.ReadCatalog+=["prfile:poolcond/PoolCat_%s.xml" % i] # also add entries which will be resolved using ATLAS_POOLCOND_PATH # (if set) - the actual resolution is done inside PoolSvc C++ for i in self.poolcats: svcMgr.PoolSvc.ReadCatalog+=["apcfile:poolcond/PoolCat_%s.xml" % i] svcMgr.PoolSvc.ReadCatalog+=["apcfile:poolcond/PoolFileCatalog.xml"] else: raise RuntimeError('Not enough configuration information to setup ConditionsDB access (are GlobalFlags being used?)') self.msg.debug("Loading basic services for CondDBSetup... [DONE]")
DistanceToStraw = 0.4, LongToTCut = 9.375, is_TRT_only_tracks = True, # obsolete is_zero_mag_field = True, # obsolete #Histogram Switches doAside = True, # obsolete doCside = True, # obsolete doStraws = True, doChips = True, doShift = True, doDiagnostic = True, # obsolete EventBurstCut = eventBurstCut, # default = 200 DoRDOsMon = True, DoGeoMon = False, DoTracksMon = True, doExpert = athenaCommonFlags.isOnline(), IsCosmics = InDetFlags.doCosmics(), InDetTRT_DAQ_ConditionsSvc = InDetTRT_DAQ_ConditionsSvc, doEfficiency = False, # ME: turn off TRT hole search, it fails Tier-0 every_xth_track = 25, whatdatatype = DQMonFlags.monManDataType(), MinTRTHitCut = 10, max_abs_d0 = 10 * Units.mm, max_abs_z0 = 300 * Units.mm, max_abs_eta = 2.5, MinTrackP = 0.0 * Units.GeV, min_pT = minTrkPtCut, # default = 0.5 GeV min_si_hits = minSiHitCut, # default = 3 min_pixel_hits = minPixHitCut, # default = 1 min_sct_hits = 0, min_trt_hits = 10
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration # MagFieldServices #-------------------------------------------------------------- from AthenaCommon.Logging import logging logging.getLogger().info("Importing %s", __name__) from AthenaCommon.AthenaCommonFlags import athenaCommonFlags # initialise required conditions DB folders from IOVDbSvc.CondDB import conddb conddb.addFolderSplitMC('GLOBAL', '/GLOBAL/BField/Maps <noover/>', '/GLOBAL/BField/Maps <noover/>', className="CondAttrListCollection") if not athenaCommonFlags.isOnline(): conddb.addFolder('DCS_OFL', '/EXT/DCS/MAGNETS/SENSORDATA', className="CondAttrListCollection") # import the field service and conditions algs (service is 'to be removed') # (it is MagFieldServices.MagFieldServicesConfig which takes care of configuration) from AthenaCommon.CfgGetter import getService, getAlgorithm getService('AtlasFieldSvc') from AthenaCommon.AlgSequence import AthSequencer condSequence = AthSequencer("AthCondSeq") condSequence += getAlgorithm("AtlasFieldMapCondAlg") condSequence += getAlgorithm("AtlasFieldCacheCondAlg")
from AthenaCommon.AthenaCommonFlags import athenaCommonFlags if athenaCommonFlags.isOnline(): BTaggingFlags.CalibrationFolderRoot="/GLOBAL/Onl/BTagCalib/" connSchema="GLOBAL" print "#BTAG# running online -> btag calib root folder is /GLOBAL/Onl/BTagCalib/" else: BTaggingFlags.CalibrationFolderRoot="/GLOBAL/BTagCalib/" connSchema="GLOBAL_OFL" print "#BTAG# running offline -> btag calib root folder is /GLOBAL/BTagCalib/" theFolders = [] if BTaggingFlags.IP1D: theFolders.append(BTaggingFlags.CalibrationFolderRoot+'IP1D') if BTaggingFlags.IP2D: theFolders.append(BTaggingFlags.CalibrationFolderRoot+'IP2D') if BTaggingFlags.IP3D: theFolders.append(BTaggingFlags.CalibrationFolderRoot+'IP3D') if BTaggingFlags.SV1: theFolders.append(BTaggingFlags.CalibrationFolderRoot+'SV1') if BTaggingFlags.SV2: theFolders.append(BTaggingFlags.CalibrationFolderRoot+'SV2') if BTaggingFlags.SoftMu: theFolders.append(BTaggingFlags.CalibrationFolderRoot+'SoftMu') if BTaggingFlags.SoftEl: theFolders.append(BTaggingFlags.CalibrationFolderRoot+'SoftEl') if BTaggingFlags.JetFitterTag|BTaggingFlags.JetFitterNN: theFolders.append(BTaggingFlags.CalibrationFolderRoot+'JetFitter') if BTaggingFlags.JetProb: theFolders.append(BTaggingFlags.CalibrationFolderRoot+'JetProb') if BTaggingFlags.MV1 | BTaggingFlags.MV1Flip:
#printfunc ('\n*************************************************************************************************\n') #printfunc (" ******** Welcome to the Offline ESD MuonRawDataMonitoring/MdtRawDataMonitoring package. ******** " ) #printfunc (" ******** Documentation may be found at:******** " ) #printfunc (" **** https://twiki.cern.ch/twiki/bin/view/Atlas/MDTOfflineMonitoringPlots ***** " ) from AthenaCommon.AthenaCommonFlags import athenaCommonFlags isTier0Flag = not athenaCommonFlags.isOnline() # #if not isTier0Flag : # printfunc (" **** Running Online ****") #else : # printfunc (" **** Running at Tier0 ****") # #printfunc ('\n*************************************************************************************************\n') if not 'MuonDQAFlags' in dir(): printfunc( "MuonDQAFlags.py: MuonDQAFlags not yet imported - I import them now") from MuonDQAMonFlags.MuonDQAFlags import MuonDQAFlags as MuonDQAFlags from AthenaMonitoring.AtlasReadyFilterTool import GetAtlasReadyFilterTool mdtRawMonMan = AthenaMonManager(name="MdtRawMonManager", FileKey=DQMonFlags.monManFileKey(), Environment=DQMonFlags.monManEnvironment(), OutputLevel=muonOutputLevel) ############# MDTRawDataValAlg ############# from MdtRawDataMonitoring.MdtRawDataMonitoringConf import MdtRawDataValAlg