def initConfigTool(self, instanceName):
"Init configuration conditions tool"
# Set up SCT cabling
from AthenaCommon.Include import include
include('InDetRecExample/InDetRecCabling.py')
from InDetTrigRecExample.InDetTrigFlags import InDetTrigFlags
from IOVDbSvc.CondDB import conddb
if conddb.dbdata == "COMP200" or InDetTrigFlags.ForceCoraCool():
sctdaqpath = '/SCT/DAQ/Configuration'
else:
sctdaqpath = '/SCT/DAQ/Config'
if InDetTrigFlags.ForceCoolVectorPayload():
sctdaqpath = '/SCT/DAQ/Config'
from SCT_ConditionsTools.SCT_ConfigurationConditionsToolSetup import SCT_ConfigurationConditionsToolSetup
sct_ConfigurationConditionsToolSetup = SCT_ConfigurationConditionsToolSetup(
)
sct_ConfigurationConditionsToolSetup.setChannelFolder(sctdaqpath +
"/Chip")
sct_ConfigurationConditionsToolSetup.setModuleFolder(sctdaqpath +
"/Module")
sct_ConfigurationConditionsToolSetup.setMurFolder(sctdaqpath + "/MUR")
sct_ConfigurationConditionsToolSetup.setToolName(instanceName)
sct_ConfigurationConditionsToolSetup.setup()
configTool = sct_ConfigurationConditionsToolSetup.getTool()
if self._print: print(configTool)
if not (configTool.getFullName() in self.summaryTool.ConditionsTools):
self.summaryTool.ConditionsTools += [configTool.getFullName()]
if self._print: print(self.condDB)
return configTool
def configureReco(self):
from AthenaCommon.DetFlags import DetFlags
DetFlags.Muon_setOn()
DetFlags.Calo_setOff()
recAlgsFlags.doMuonIDStandAlone = False
recAlgsFlags.doMuonIDCombined = False
# add some more flags available for standalone running
import MuonRecExample.MuonRecStandaloneFlags
# configure flags so that only Muon Standalone reco is run
import MuonRecExample.MuonRecStandaloneOnlySetup
muonRecFlags.useAlignmentCorrections = mualign.useOpticalAlignment()
# cosmics setup
#if align.dataType()=='cosmic' or align.dataType()=='simCosmic':
##### no more flags after this line #####
print "align.dataType()=", align.dataType()
if align.dataType() == 'data' or align.dataType() == 'cosmic':
muonRecTopOptions = "MuonAlignGenTools/MuonDataRec_myTopOptions.py"
else:
muonRecTopOptions = "MuonRecExample/MuonRec_topOptions.py"
try:
include(muonRecTopOptions)
###### put any user finetuning before this line #####
except:
# always write config so far for debugging
from AthenaCommon.ConfigurationShelve import saveToAscii
saveToAscii("config.txt")
# but still exit with error
raise
def checkForSpecialConfigurationMetadata():
if metadata_full is not None:
if 'specialConfiguration' in metadata_full['/TagInfo']:
from G4AtlasApps.SimFlags import simFlags
simFlags.specialConfiguration = dict()
item = metadata_full['/TagInfo']['specialConfiguration']
## Parse the specialConfiguration string
## Format is 'key1=value1;key2=value2;...'. or just '
spcitems = item.split(";")
params = {}
someIncludes = []
for spcitem in spcitems:
#print spcitem
## Ignore empty or "NONE" substrings, e.g. from consecutive or trailing semicolons
if not spcitem or spcitem.upper() == "NONE":
continue
## If not in key=value format, treat as v, with k="preInclude"
if "=" not in spcitem:
spcitem = "preInclude=" + spcitem
## Handle k=v directives
k, v = spcitem.split("=")
if k == "preInclude":
someIncludes += [v]
else:
params[k] = v
simMDlog.info(params)
simFlags.specialConfiguration.get_Value().update(params)
from AthenaCommon.Include import include
for inc in someIncludes:
include(inc)
else:
simMDlog.info(
"No input Evgen MetaData object available so skipping check for specialConfiguration metadata."
)
def SetupDPDIncludes(runArgs, flagContainerList, includeType):
"""This function can be used to include all the pre-include scripts
defined for the requested DPD types.
Returns a list of output types in which a pre/post-include was used."""
# We must not produce multiple output types when pre/post-include
# scripts are involved internally. This variable keeps track of
# the output types which have used the pre/postInclude functionality
includeTypeList = []
# Make a logger for the function:
from AthenaCommon.Logging import logging
logger = logging.getLogger("SetupDPDIncludes")
# Loop over all DPD job properties:
for flagContainer in flagContainerList:
for flagName in flagContainer.__dict__.keys():
flag = getattr(flagContainer, flagName)
# Check if this DPD type has been requested in the job:
if hasattr(flag, "StreamName"):
dpdName = flag.StreamName.lstrip("Stream")
argName = 'output' + dpdName + 'File'
if hasattr(runArgs, argName):
# We found a match for an output, however if there was already a script
# included, then we may be in trouble (note that we print an error even when
# the current output type does not itself have an include, because the include
# that already exists can even mess up this new output type).
if len(includeTypeList) > 0:
logger.error(
"Multiple output DPD types requested with "
"pre/post-includes present: {0} after includes from {1}"
.format(argName, includeTypeList))
logger.error(
"This will most probably lead to bad output")
pass
# Only some DPD types define pre/post-include scripts.
# It's okay if this one doesn't define any,
if not hasattr(flag, includeType):
continue
includeTypeList.append(argName)
# Make sure that we have a list of scripts, not just one:
includes = getattr(flag, includeType)
if type(includes) != list:
includes = [includes]
pass
# Now include all the specified scripts:
for incfile in includes:
logger.warning("Including script: {0} for {1}".format(
incfile, argName))
from AthenaCommon.Include import include
include(incfile)
pass
pass
pass
pass
pass
# Tell the caller which types used pre/postIncludes:
return includeTypeList
def __enableEgamma():
" Local function to enable Egamma Reconstruction."
# Set egamma flags to True
rec.doEgamma = True
from egammaRec.egammaRecFlags import jobproperties
egammaRecFlags = jobproperties.egammaRecFlags
egammaRecFlags.Enabled = True
egammaRecFlags.doEgammaCaloSeeded = True
egammaRecFlags.doEgammaForwardSeeded = False
include("egammaRec/egammaRec_jobOptions.py")
if not egammaBuilderAvailable():
mlog.error("Couldn't add egamma reconstruction to joboptions")
raise RuntimeError("Coudln't add egamma reconstruction to joboptions.")
def uglyHackedInclude(jobOptions):
global ToolSvc, ServiceMgr
from AthenaCommon.Include import include
import __main__
if not hasattr(__main__, 'include'):
include.setShowIncludes(False)
include.setClean(False)
setattr(__main__, 'include', include)
if not hasattr(__main__, "ToolSvc"):
setattr(__main__, "ToolSvc", ToolSvc)
if not hasattr(__main__, "ServiceMgr"):
setattr(__main__, "ServiceMgr", ServiceMgr)
include(jobOptions)
def setCombMuonTrackFitter(self):
mlog = logging.getLogger(
'AlignmentTrackFitter::setCombMuonTrackFitter')
from AthenaCommon.Include import include
include('MuonCombinedRecExample/CombinedMuonFitTools.py')
from AthenaCommon.AppMgr import ToolSvc
ToolSvc.MuonCombinedTrackFitter.FillDerivativeMatrix = True
self._fitter = ToolSvc.MuonCombinedTrackFitter
self._fitter.OutputLevel = align.OutputLevel()
if align.useSLFitter():
mlog.warning("SL Fitter set to default (curved) fitter!")
self._slfitter = ToolSvc.MuonCombinedTrackFitter
def MdtPrepDataProviderTool(name="MdtPrepDataProviderTool", **kwargs):
global source, include, getService, getPrivateTool
# setup dependencies which are not yet in C++
import MuonCnvExample.MuonCablingConfig
from MuonRecExample import MuonAlignConfig
from MuonCnvExample import MuonCalibConfig
MuonCalibConfig.setupMdtCondDB()
include("AmdcAth/AmdcAth_jobOptions.py")
if source == 'data':
kwargs.setdefault("UseTwin", True)
from MuonMDT_CnvTools.MuonMDT_CnvToolsConf import Muon__MdtRdoToPrepDataToolMT
return Muon__MdtRdoToPrepDataToolMT(name, **kwargs)
def FastClusterMakerTool(name="FastClusterMakerTool", **kwargs):
from Digitization.DigitizationFlags import digitizationFlags
#FIXME: at some point we should move away from being dependent on the experimentalDigi flags.
if 'doFastSCT_Digi' in digitizationFlags.experimentalDigi(
) and not 'doFastPixelDigi' in digitizationFlags.experimentalDigi():
kwargs.setdefault("UsePixelCalibCondDB", False)
kwargs.setdefault("PixelCalibSvc", "")
kwargs.setdefault("PixelOfflineCalibSvc", "")
else:
from AthenaCommon.Include import include
include("PixelConditionsServices/PixelDCSSvc_jobOptions.py")
include.block("PixelConditionsServices/PixelDCSSvc_jobOptions.py")
from AthenaCommon.AppMgr import ToolSvc
if not hasattr(ToolSvc, "PixelRecoDbTool"):
from PixelConditionsTools.PixelConditionsToolsConf import PixelRecoDbTool
ToolSvc += PixelRecoDbTool()
ToolSvc.PixelRecoDbTool.InputSource = 1
# setup PixelCalibDbTool in ToolSvc
if not hasattr(ToolSvc, "PixelCalibDbTool"):
from PixelConditionsTools.PixelConditionsToolsConf import PixelCalibDbTool
ToolSvc += PixelCalibDbTool()
from IOVDbSvc.CondDB import conddb
if not conddb.folderRequested('/PIXEL/PixCalib'):
conddb.addFolder("PIXEL_OFL", "/PIXEL/PixCalib")
if not conddb.folderRequested('/PIXEL/ReadoutSpeed'):
conddb.addFolder("PIXEL_OFL", "/PIXEL/ReadoutSpeed")
from AthenaCommon.AppMgr import ServiceMgr
if not hasattr(ServiceMgr, "PixelCalibSvc"):
from PixelConditionsServices.PixelConditionsServicesConf import PixelCalibSvc
InDetPixelCalibSvc = PixelCalibSvc()
ServiceMgr += InDetPixelCalibSvc
if not hasattr(ServiceMgr, "PixelSiPropertiesSvc"):
from SiLorentzAngleSvc.LorentzAngleSvcSetup import lorentzAngleSvc
from SiPropertiesSvc.SiPropertiesSvcConf import SiPropertiesSvc
PixelSiPropertiesSvc = SiPropertiesSvc(
name="PixelSiPropertiesSvc",
DetectorName="Pixel",
SiConditionsServices=lorentzAngleSvc.pixelSiliconConditionsSvc)
ServiceMgr += PixelSiPropertiesSvc
if not hasattr(ServiceMgr, "PixelOfflineCalibSvc"):
from PixelConditionsServices.PixelConditionsServicesConf import PixelOfflineCalibSvc
ServiceMgr += PixelOfflineCalibSvc()
ServiceMgr.PixelOfflineCalibSvc.HDCFromCOOL = False
from AthenaCommon import CfgMgr
return CfgMgr.InDet__ClusterMakerTool(name, **kwargs)
def setupCostJob(config='OPI ROB NOPS'):
log = logging.getLogger('setupCostJob')
if config.count('OPI'):
log.info('Configure TrigSteer algorithm(s)')
from AthenaCommon.AlgSequence import AlgSequence
topSeq = AlgSequence()
from TriggerJobOpts.TriggerFlags import TriggerFlags
if TriggerFlags.doHLT():
configSteeringOPI(topSeq, 'TrigSteer_HLT', config, log)
else:
if TriggerFlags.doEF():
configSteeringOPI(topSeq, 'TrigSteer_EF', config, log)
if TriggerFlags.doLVL2():
configSteeringOPI(topSeq, 'TrigSteer_L2', config, log)
if config.count('ROB'):
log.info(
'Will try to configure online monitoring for ROBDataProviderSvc...'
)
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
try:
log.info('ROBDataProviderSvc type: ' +
svcMgr.ROBDataProviderSvc.getType())
if svcMgr.ROBDataProviderSvc.getType() == 'Lvl2ROBDataProviderSvc':
log.info('Job already uses online version ROBDataProvider')
else:
from AthenaCommon.Include import include
include('TrigDataAccessMonitoring/MonROBDataProviderSvc.py')
log.info('Setup "online" monitoring for ROBDataProvider')
except:
log.warning('Failed to setup "online" version of ROBDataProvider')
try:
from ByteStreamCnvSvcBase.ByteStreamCnvSvcBaseConf import ROBDataProviderSvc
svcMgr.ROBDataProviderSvc.doDetailedROBMonitoring = True
log.info('Set ROBDataProviderSvc.doDetailedROBMonitoring=True')
except:
log.warning(
'Failed to set ROBDataProviderSvc.doDetailedROBMonitoring')
def sync_Trigger2Reco():
from AthenaCommon.Include import include
from RecExConfig.RecAlgsFlags import recAlgs
from AthenaCommon.GlobalFlags import globalflags
from RecExConfig.RecFlags import rec
if recAlgs.doTrigger() and rec.readRDO(
) and not globalflags.InputFormat() == 'bytestream':
include("TriggerJobOpts/TransientBS_DetFlags.py")
if globalflags.InputFormat() == 'bytestream':
TriggerFlags.readBS = True
TriggerFlags.doLVL1 = False
TriggerFlags.doLVL2 = False
TriggerFlags.doEF = False
if rec.doWriteBS():
TriggerFlags.writeBS = True
def configure(self):
mlog = logging.getLogger( 'DetStatusMapGetter::configure :' )
mlog.info ('entering')
# now configure the algorithm
try:
from DetectorStatus.DetectorStatusConf import DetStatusAlg
except Exception:
mlog.error("could not import DetStatusAlg")
mlog.error (traceback.format_exc())
return False
# sets up cond db
# still use old include for time being
from AthenaCommon.Include import include
include("DetectorStatus/DetStatusSvc_CondDB.py")
# instantiate algorithm with default properties
theDetStatusAlg=DetStatusAlg(Write=True)
self._DetStatusAlgHandle = theDetStatusAlg
# register output in objKeyStore
from RecExConfig.ObjKeyStore import objKeyStore
# output both in ESD and AOD
objKeyStore.addStreamESD(self.outputType(),self.outputKey())
objKeyStore.addStreamAOD(self.outputType(),self.outputKey())
# now add algorithm to topSequence
# this should always come at the end
mlog.info(" now adding to topSequence")
from __main__ import topSequence
topSequence += theDetStatusAlg
return True
def doSpecialConfiguration(f):
#safety checks before trying to access metadata
if "tag_info" in f.infos.keys():
if "specialConfiguration" in f.infos["tag_info"]:
item = f.infos["tag_info"]["specialConfiguration"]
logDigitizationReadMetadata.info(
"specialConfiguration directive: %s" % item)
spcitems = item.split(";")
preIncludes = []
params = {}
from Digitization.DigitizationFlags import digitizationFlags
if digitizationFlags.specialConfiguration.statusOn:
logDigitizationReadMetadata.info(
"some spcialConfiguration metadata already exists: %s",
str(params))
params = digitizationFlags.specialConfiguration.get_Value()
for spcitem in spcitems:
## Ignore empty (e.g. from consecutive or trailing semicolons) or "NONE" substrings
if not spcitem or spcitem == "NONE":
continue
## If not in key=value format, treat as v, with k="preInclude"
if "=" not in spcitem:
spcitem = "preInclude=" + spcitem
## Handle k=v directives
k, v = spcitem.split("=")
logDigitizationReadMetadata.info(
"specialConfiguration metadata item: %s => %s" % (k, v))
## Store preIncludes for including later.
if k == "preInclude":
incfiles = v.split(",")
preIncludes += incfiles
else:
params[k] = v
digitizationFlags.specialConfiguration = params
## Now that we've looked at and stored all the evgen metadata keys, we should do any requested preIncludes
from AthenaCommon.Include import include
for incfile in preIncludes:
logDigitizationReadMetadata.info(
"Including %s as instructed by specialConfiguration metadata"
% incfile)
include(incfile)
del preIncludes
del params
def configure(self):
# from AthenaServices.AthenaServicesConf import AthenaOutputStream
# from AthenaCommon.AppMgr import ServiceMgr
# from AthenaCommon.AlgSequence import AlgSequence
# topSequence = AlgSequence()
# ### the following was gotten from the LVL1TriggerGetter not sure if needed when not simulation
# if not (TriggerFlags.fakeLVL1() or TriggerFlags.doLVL1()):
# DetFlags.readRIOPool.LVL1_setOn()
# # ***Temp : needed to enable required combination of thresholds
# # mu4,mu6,mu10,mu11,mu20,mu40
# # Will be replaced by config. from Lvl1ConfigSvc
# if hasattr(ServiceMgr,'RPCcablingSimSvc'):
# ServiceMgr.RPCcablingSimSvc.HackFor1031 = True
if jobproperties.Global.InputFormat() == 'bytestream':
theApp.Dlls += ["TrigT1Calo"]
include("TrigT1CaloByteStream/ReadLVL1CaloBS_jobOptions.py")
# ###
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
if recAlgs.doTrigger():
if (rec.doESD() or rec.doAOD()) and (not(rec.readAOD() or \
rec.readESD())):
if jobproperties.Global.InputFormat() == 'bytestream':
# Decode ROIB::RoIBResult from ByteStream
from TrigT1ResultByteStream.TrigT1ResultByteStreamConfig import L1ByteStreamDecodersRecExSetup
L1ByteStreamDecodersRecExSetup()
from AnalysisTriggerAlgs.AnalysisTriggerAlgsConfig import \
RoIBResultToAOD
topSequence += RoIBResultToAOD("RoIBResultToxAOD")
pass
pass
from TrigEDMConfig.TriggerEDM import getLvl1ESDList
objKeyStore.addManyTypesStreamESD(getLvl1ESDList())
from TrigEDMConfig.TriggerEDM import getLvl1AODList
objKeyStore.addManyTypesStreamAOD(getLvl1AODList())
return True
def _do_external(self):
""" Place to handle the external services: GeoModel, CondDB, etc.
"""
AtlasG4Eng.G4Eng.log.info('SimSkeleton :: _do_external '+\
'starting')
#from LArH6Detectors import Det_Layouts
from tbLArH6_calo import Det_Layouts
from AthenaCommon.AppMgr import ServiceMgr
from Geo2G4.Geo2G4Conf import Geo2G4Svc
Geo2G4Svc = Geo2G4Svc()
theApp.CreateSvc += ["Geo2G4Svc"]
ServiceMgr += Geo2G4Svc
# We do not use top transforms for the CTB geometry
Geo2G4Svc.GetTopTransform = False
#--- GeoModel stuff ----------------------------------------------------
from AtlasGeoModel import SetGeometryVersion
from AtlasGeoModel import GeoModelInit
from AthenaCommon.Configurable import Configurable
if Configurable.allConfigurables.get('GeoModelSvc'):
GeoModelSvc = Configurable.allConfigurables.get('GeoModelSvc')
else:
GeoModelSvc = theApp.service('GeoModelSvc')
GeoModelSvc.AlignCallbacks = False
if (DetFlags.Calo_on()):
# Common for the Calo
include(
"CaloDetMgrDetDescrCnv/CaloDetMgrDetDescrCnv_joboptions.py")
include("CaloIdCnv/CaloIdCnv_joboptions.py")
## Explicitly create DetectorGeometrySvc - temporary fix
from AthenaCommon.CfgGetter import getService, getPublicTool
from AthenaCommon.AppMgr import ServiceMgr
ServiceMgr += getService('DetectorGeometrySvc')
ServiceMgr.ToolSvc += getPublicTool('PhysicsListToolBase')
AtlasG4Eng.G4Eng.log.info('SimSkeleton :: _do_external '+\
'done')
def MdtPrepDataProviderTool(name="MdtPrepDataProviderTool", **kwargs):
global source, include, getService
# setup dependencies which are not yet in C++
import MuonCnvExample.MuonCablingConfig
getService("MdtCalibrationSvc")
include("AmdcAth/AmdcAth_jobOptions.py")
# If we run trigger from BS, then the RDO to PRD tools need to automatically run BS to RDO tools
kwargs.setdefault("useBStoRdoTool",
DetFlags.readRDOBS.MDT_on() and recAlgs.doTrigger())
kwargs.setdefault("RawDataProviderTool", "MdtRawDataProviderTool")
### TODO: in C++ do not retrieve tool if useBStoRdoTool==False
## if not kwargs["useBStoRdoTool"]:
## kwargs["RawDataProviderTool"] = None # empty tool
if source == 'data':
kwargs.setdefault("UseTwin", True)
from MuonMDT_CnvTools.MuonMDT_CnvToolsConf import Muon__MdtRdoToPrepDataTool
return Muon__MdtRdoToPrepDataTool(name, **kwargs)
def __init__(self, name='LocalExtrapolator'):
# get the correct TrackingGeometry setup
include('TrkDetDescrSvc/LocalTrackingGeometrySvc.py')
from __main__ import LocalTrackingGeometrySvc
from __main__ import ToolSvc
# the Navigator has to get this one
from TrkExTools.TrkExToolsConf import Trk__Navigator
LocalNavigator = Trk__Navigator(name='LocalNavigator')
LocalNavigator.TrackingGeometryName = LocalTrackingGeometrySvc.TrackingGeometryName
ToolSvc += LocalNavigator
# the standard RungeKuttaPropagator
from TrkExRungeKuttaPropagator.TrkExRungeKuttaPropagatorConf import Trk__RungeKuttaPropagator as Propagator
LocalPropagator = Propagator(name='LocalPropagator')
ToolSvc += LocalPropagator
# call the base class constructor
Trk__Extrapolator.__init__(self,
name,
Navigator=LocalNavigator,
Propagators=[LocalPropagator])
def MuonStandaloneTrackParticleCnvAlg( name="MuonStandaloneTrackParticleCnvAlg",**kwargs):
from AthenaCommon.Include import include
include("InDetBeamSpotService/BeamCondSvc.py" )
from xAODTrackingCnv.xAODTrackingCnvConf import xAODMaker__TrackParticleCnvAlg, xAODMaker__TrackCollectionCnvTool, xAODMaker__RecTrackParticleContainerCnvTool
muonParticleCreatorTool = getPublicTool("MuonParticleCreatorTool")
muonTrackCollectionCnvTool = xAODMaker__TrackCollectionCnvTool( name = "MuonTrackCollectionCnvTool", TrackParticleCreator = muonParticleCreatorTool )
muonRecTrackParticleContainerCnvTool = xAODMaker__RecTrackParticleContainerCnvTool(name = "MuonRecTrackParticleContainerCnvTool", TrackParticleCreator = muonParticleCreatorTool )
kwargs.setdefault("TrackParticleCreator", muonParticleCreatorTool)
kwargs.setdefault("RecTrackParticleContainerCnvTool", muonRecTrackParticleContainerCnvTool)
kwargs.setdefault("TrackCollectionCnvTool", muonTrackCollectionCnvTool)
kwargs.setdefault("RecTrackParticleContainerCnvTool", muonRecTrackParticleContainerCnvTool)
kwargs.setdefault("TrackContainerName", "MuonSpectrometerTracks")
kwargs.setdefault("xAODTrackParticlesFromTracksContainerName", "MuonSpectrometerTrackParticles")
kwargs.setdefault("AODContainerName", "")
kwargs.setdefault("AODTruthContainerName", "")
kwargs.setdefault("xAODTruthLinkVector", "")
kwargs.setdefault("ConvertTrackParticles", False)
kwargs.setdefault("ConvertTracks", True)
return xAODMaker__TrackParticleCnvAlg( name = "MuonStandaloneTrackParticleCnvAlg",**kwargs)
def _setupDetStoreConfig():
from AthenaCommon.AppMgr import theApp
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
# first, make sure we create a DetectorStore
import AthenaCommon.AtlasUnixStandardJob
#theApp.CreateSvc += [ svcMgr.DetectorStore.getFullName() ]
# now configure the Detector Description converter service
from DetDescrCnvSvc.DetDescrCnvSvcConf import DetDescrCnvSvc
# Create DetDescrCnvSvc and add to SvcMgr
# Specify primary Identifier dictionary to be used
svcMgr += DetDescrCnvSvc(IdDictName = "IdDictParser/ATLAS_IDS.xml")
#theApp.CreateSvc += [ svcMgr.DetDescrCnvSvc.getFullName() ]
svcMgr.EventPersistencySvc.CnvServices += [ "DetDescrCnvSvc" ]
# Always include the IdDict jobOptions
from AthenaCommon.Include import include
include( "IdDictDetDescrCnv/IdDictDetDescrCnv_joboptions.py" )
pass
#
# e.g. level=L2, type=muon, threshold=30, isIsolated=None
# level=EF, type=egamma, threshold=20, isIsolated=isolated
#
# Methods:
# instanceName() : returns name of algorithm instance
# classAndInstanceName() : returns a string to be entered in the sequence file. This string
# defines the class and instance name
#
#
from AthenaCommon.Include import include
include.block("InDetTrigRecExample/EFInDetConfig.py")
include("InDetTrigRecExample/InDetTrigRec_jobOptions.py"
) # this is needed to get InDetTrigFlags
from AthenaCommon.Logging import logging
log = logging.getLogger("EFInDetConfig.py")
from InDetTrigRecExample.InDetTrigConfigRecPreProcessing import *
from InDetTrigRecExample.InDetTrigConfigRecNewTracking import \
SiTrigTrackFinder_EF, SiTrigTrackSeededFinder_EF, SiTrigSimpleTrackFinder_EF, \
TrigAmbiguitySolver_EF,TRTTrackExtAlg_EF,\
TrigExtProcessor_EF, InDetTrigDetailedTrackTruthMaker_EF
from InDetTrigRecExample.InDetTrigConfigRecNewTracking import SimpleTrigTrackCollMerger_EF
from InDetTrigRecExample.InDetTrigConfigRecBackTracking import *
from InDetTrigRecExample.InDetTrigConfigRecPostProcessing import *
### file inclusion and tracing ----------------------------------------------- from AthenaCommon.Include import Include, IncludeError, include include.setShowIncludes( False ) ### gaudi -------------------------------------------------------------------- from GaudiPython import * from AthenaCommon.Configurable import * from AthenaCommon.OldStyleConfig import * from AthenaCommon.Constants import * preconfig = "AthenaCommon" ### Athena configuration ----------------------------------------------------- theApp = iService( "ApplicationMgr" ) # proxy theApp.Dlls += [ 'AthenaServices' ] include( "%s/Bootstrap.py" % preconfig ) ## create the application manager and start in a non-initialised state from AthenaCommon.AppMgr import theApp, ToolSvc, ServiceMgr, theAuditorSvc ## basic job configuration include( "AthenaCommon/Atlas.UnixStandardJob.py" ) include.block( "AthenaCommon/Atlas.UnixStandardJob.py" ) EventLoopMgr = iService( 'EventLoopMgr' ) AthenaEventLoopMgr = EventLoopMgr # for historic reasons ### execution ---------------------------------------------------------------- from AthenaCommon.ResourceLimits import SetMaxLimits
writePartons=True,
writeGeant=False)
JetROID3PDObject.defineBlock(0,
"myKinematics",
EventCommonD3PDMaker.FourMomFillerTool,
WriteM=False,
WritePt=True,
prefix="myKin_")
#TrackParticleD3PDObject.defineBlock( 99, "TJVAperigee",
# TauD3PDMaker.TrackParticleAtTJVAFillerTool, prefix = 'atTJVA_')
# Special muon isolation variables
#from AthenaCommon.AppMgr import ToolSvc
from AthenaCommon.Include import include
include("MuonIsolationTools/MuonIsolationTool_jobOptions.py")
myMuonD3PDObject.defineBlock(0,
"miniiso10",
BoostedTopD3PDMaker.MiniIsolationMuonFillerTool,
MuIsolationTool=ToolSvc.MuonIsolationTool,
KtDist=10.,
prefix="MI10_")
myMuonD3PDObject.defineBlock(0,
"miniiso15",
BoostedTopD3PDMaker.MiniIsolationMuonFillerTool,
MuIsolationTool=ToolSvc.MuonIsolationTool,
KtDist=15.,
prefix="MI15_")
#Add new triggers at request of HSG6
defineTriggerBits(
for s in dictchain.sequenceList:
print "Step::%i [\033[1;34m%s\033[1;m]%4s [\033[1;32m%s\033[1;m] " % (k,s['input'],"-->",s['output'])
#alg = " ::--- Algorithm(s): \n"
alg = ""
if type(s['algorithm']) == list:
for j in s['algorithm']:
alg += " |--- %s (Package: %s)\n" % (j.getFullName(),j.getDlls())
alg = alg[:-1]
else:
j = s['algorithm']
alg = " |--- %s (Package: %s) " % (j.getFullName(),j.getDlls())
print alg
k+=1
include("RecExCond/RecExCommon_flags.py")
from TriggerMenu.test.TestSliceFlags import *
#from TriggerMenu.bjet.BjetSliceFlags import *
#from TriggerJobOpts.TriggerFlags import TriggerFlags <-- already imported in the line above
# Test the current chains in the Bjet slice taking the MC_pp_v5 menu
# --> Too slow
#TriggerFlags.triggerMenuSetup='MC_pp_v5'
#TriggerFlags.readHLTconfigFromXML=False
#TriggerFlags.readLVL1configFromXML=False
#TriggerFlags.BjetSlice.setAll()
#
#
#def dvonly():
# TriggerFlags.Slices_all_setOff()
if geo:
from AthenaCommon.DetFlags import DetFlags
DetFlags.Calo_setOn()
from AtlasGeoModel import SetGeometryVersion
from AtlasGeoModel import GeoModelInit
from AtlasGeoModel import SetupRecoGeometry
ServiceMgr.IOVDbSvc.GlobalTag = tag
ServiceMgr.IOVDbSvc.DBInstance = ""
ServiceMgr.EventSelector.RunNumber = run
#ServiceMgr+=CfgMgr.PyAthenaEventLoopMgr(EventPrintoutInterval=0)
#Get identifier mapping
include("LArConditionsCommon/LArIdMap_comm_jobOptions.py")
include("LArIdCnv/LArIdCnv_joboptions.py")
include("IdDictDetDescrCnv/IdDictDetDescrCnv_joboptions.py")
include("CaloDetMgrDetDescrCnv/CaloDetMgrDetDescrCnv_joboptions.py")
#include("CaloIdCnv/CaloIdCnv_joboptions.py")
include("LArConditionsCommon/LArConditionsCommon_comm_jobOptions.py")
#if dspth:
# conddb.addFolder("LAR_ONL","/LAR/Configuration/DSPThreshold/Templates<tag>LARConfigurationDSPThresholdTemplates-Qt5sigma-samp5sigma</tag>")
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
try:
_msg.setLevel (getattr(logging, opts.msg_lvl))
except:
_help_and_exit()
### default file name for ease of use ----------------------------------------
if not opts.scripts and os.path.exists(opts.default_jobopt):
_msg.info("using default file %s", opts.default_jobopt)
opts.scripts.append(opts.default_jobopt)
if not (opts.scripts or opts.fromdb) and opts.run_batch:
_msg.error( "batch mode requires at least one script" )
from AthenaCommon.ExitCodes import INCLUDE_ERROR
_help_and_exit( INCLUDE_ERROR )
del _help_and_exit
### file inclusion and tracing -----------------------------------------------
from AthenaCommon.Include import IncludeError, include
include.setShowIncludes(opts.showincludes)
include.setClean(opts.drop_cfg)
### pre-execution step -------------------------------------------------------
include( "AthenaCommon/Preparation.py" )
### execution of user script and drop into batch or interactive mode ---------
include( "AthenaCommon/Execution.py" )
if len(listOfRuns)==0:
print 'Usage: makeSLHAFilesForSM.py run1 run2 run3,run4,run5 run6...'
sys.exit(0)
print 'Getting SLHA files for run(s)',listOfRuns
# Fake some things that we won't need later
from PyJobTransforms.trfJobOptions import RunArguments
runArgs = RunArguments()
runArgs.randomSeed = 1234
from AthenaCommon import Logging
evgenLog = Logging.logging.getLogger('SLHAGetter')
# only really need this once
from AthenaCommon.Include import IncludeError, include
include.setShowIncludes(False)
include('/cvmfs/atlas.cern.ch/repo/sw/Generators/MC12JobOptions/latest/susycontrol/MadGraphControl_SimplifiedModelPreInclude.py')
include.block('MC12JobOptions/MadGraphControl_SimplifiedModelPreInclude.py')
include.block('MC12JobOptions/MadGraphControl_SimplifiedModelPostInclude.py')
for run in listOfRuns:
loc_l = glob.glob('/cvmfs/atlas.cern.ch/repo/sw/Generators/MC12JobOptions/latest/share/DSID'+run[0:3]+'xxx/MC12.'+run+'.*')
if 0==len(loc_l):
print 'Run not found:',run,'in','/cvmfs/atlas.cern.ch/repo/sw/Generators/MC12JobOptions/latest/share/DSID'+run[0:3]+'xxx/MC12.'+run+'.*'
continue
if len(loc_l)>1:
print 'Multiple runs found:',loc_l,'for run',run,'- Using first.'
loc = loc_l[0]
jobO = open(loc,'r')
main_jobO = ''
for line in jobO:
#! /usr/bin/env python # @file: chappy.py # @purpose: wrapper script to launch ChapPy scripts # @author: Sebastien Binet <*****@*****.**> # @date: November 2006 # # @example: # lxplus> chappy McParticleAlgs/rwtest_genEvent.py # import sys from AthenaCommon.Include import include include.setShowIncludes( False ) print ":"*80 print "::: ChapPy is launching script [%s] :::" % sys.argv[1] include( sys.argv[1] ) print ":"*80
from AthenaCommon.AppMgr import theApp
from AthenaCommon.AppMgr import ToolSvc, ServiceMgr, theAuditorSvc
## These properties have alread been set on the C++ ApplicationMgr in the Psc
## but the configurable needs to have them set as well
theApp.MessageSvcType = PscConfig.optmap["MESSAGESVCTYPE"]
theApp.JobOptionsSvcType = PscConfig.optmap["JOBOPTIONSSVCTYPE"]
## add the MessageSvc and the JobOptionsSvc to the ServiceMgr
from AthenaCommon.ConfigurableDb import getConfigurable
ServiceMgr += getConfigurable(theApp.JobOptionsSvcType)("JobOptionsSvc")
ServiceMgr += getConfigurable(theApp.MessageSvcType)("MessageSvc")
## set the default values
try:
include(pscBootstrapFile)
except Exception, e:
if isinstance(e, IncludeError):
print sys.exc_type, e
theApp._exitstate = ExitCodes.INCLUDE_ERROR
sys.exit(ExitCodes.INCLUDE_ERROR)
raise
## properties of the application manager
theApp.StatusCodeCheck = False # enabled via TriggerFlags.Online.doValidation (see below)
theApp.setOutputLevel(OUTPUTLEVEL)
# Configure the CoreDumpSvc
if not hasattr(ServiceMgr, "CoreDumpSvc"):
from AthenaServices.Configurables import CoreDumpSvc
ServiceMgr += CoreDumpSvc()
# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
from AthenaCommon.Include import include
include("LArConditionsCommon/LArConditionsCommon_MC_jobOptions.py")
from AthenaCommon.Logging import logging
from LArRecUtils.LArRecUtilsConf import LArOFCCondAlg
from AthenaCommon.AlgSequence import AthSequencer
from LArCabling.LArCablingAccess import LArOnOffIdMapping
condSeq = AthSequencer("AthCondSeq")
def LArOFCCondAlgDefault():
mlog = logging.getLogger('LArOFCCondAlg')
mlog.info("entering LArOFCCondAlgDefault")
LArOnOffIdMapping()
condSeq = AthSequencer("AthCondSeq")
if hasattr (condSeq,"LArOFCCondAlg"):
return getattr(condSeq,"LArOFCCondAlg")
theOFCCondAlg=LArOFCCondAlg()
#theOFCCondAlg.MCSym = True
theOFCCondAlg.isMC = True
from LArROD.LArRODFlags import larRODFlags
from AthenaCommon.BeamFlags import jobproperties
theOFCCondAlg.firstSample = larRODFlags.firstSample()
theOFCCondAlg.useHighestGainAutoCorr = larRODFlags.useHighestGainAutoCorr()
### This is a temp include to get ROS cost from offline running of the trigger with 2012 data. When we have a map for 2015 data, we will integrate this
### into the cost infrastructure such that it becomes automatic
try:
from AthenaCommon.Logging import logging
log = logging.getLogger('offlineROSCost2012.py')
log.info('Enabling offline ROS cost monitoring for run 1 data.')
from AthenaCommon.Include import include, IncludeError
include("TrigROBDataProviderSvc/TrigROBDataProviderSvc.py")
svcMgr.ROBDataProviderSvc.PrintStackTraceGetROBData = False
# This ROB-ROS map was generated by generate-rob-ros-map-from-data.py
# Current date and time is 2014-11-10 11:23:52.444569
#
# These unique identifiers were extracted from:
# root://eosatlas//eos/atlas/atlascerngroupdisk/trig-daq/validation/test_data/data12_8TeV.00212967.physics_eb_zee_zmumu_cc._0001.data
#
svcMgr.ROBDataProviderSvc.RobRosMapping = {
#
# ROB id : ROS id = SubDetector Id
#
# 01 : Sub Detector = PIXEL_BARREL
0x111705 : 0x11 ,
0x111706 : 0x11 ,
0x111707 : 0x11 ,
0x111708 : 0x11 ,
0x111709 : 0x11 ,
0x111710 : 0x11 ,
0x111711 : 0x11 ,
0x111712 : 0x11 ,
rec.AutoConfiguration.set_Value_and_Lock(["everything"])
rec.doCBNT.set_Value_and_Lock(False)
rec.doESD.set_Value_and_Lock(False)
rec.doHist.set_Value_and_Lock(False)
rec.doPerfMon.set_Value_and_Lock(False)
rec.doWriteAOD.set_Value_and_Lock(False)
rec.doWriteESD.set_Value_and_Lock(False)
rec.doWriteTAG.set_Value_and_Lock(False)
rec.doWriteTAGCOM.set_Value_and_Lock(False)
#
from AthenaCommon.Include import include
include("RecExCommon/RecExCommon_topOptions.py")
#
for i in ServiceMgr:
i.OutputLevel = INFO
##############################
# Output file
##############################
OutputFile = 'Output_HLT_MetMon.root'
from GaudiSvc.GaudiSvcConf import THistSvc
svcMgr += THistSvc()
svcMgr.THistSvc.Output += [
"MonitorHLTmet DATAFILE='" + OutputFile + "' OPT='RECREATE'"
def configure(self):
log = logging.getLogger("Lvl1TriggerOnlineGetter.py")
from AthenaServices.AthenaServicesConf import AthenaOutputStream
from AthenaCommon.AppMgr import ServiceMgr
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
# initialize LVL1ConfigSvc
if not hasattr(ServiceMgr, 'LVL1ConfigSvc'):
from TrigConfigSvc.TrigConfigSvcConfig import LVL1ConfigSvc
LVL1ConfigSvc = LVL1ConfigSvc("LVL1ConfigSvc")
LVL1ConfigSvc.XMLMenuFile = TriggerFlags.inputLVL1configFile()
ServiceMgr += LVL1ConfigSvc
else:
log.info( "LVL1ConfigSvc already created. Will ignore configuration from xml file="+TriggerFlags.inputLVL1configFile()\
+" and use file="+ServiceMgr.LVL1ConfigSvc.XMLFile )
if (not TriggerFlags.fakeLVL1()) and TriggerFlags.doLVL1():
if TriggerFlags.useCaloTTL():
include("TrigT1CaloSim/TrigT1CaloSimJobOptions_TTL1.py")
else:
include("TrigT1CaloSim/TrigT1CaloSimJobOptions_Cell.py")
topSequence += LVL1__TrigT1MBTS()
topSequence += L1Muctpi()
if TriggerFlags.doL1Topo():
log.info("adding l1topo simulation to the topSequence")
from L1TopoSimulation.L1TopoSimulationConfig import L1TopoSimulation
topSequence += L1TopoSimulation()
topSequence.L1TopoSimulation.OutputLevel = DEBUG
try: # this is temporary until TrigT1Muctpi-00-06-29 is in the release
from TrigT1Muctpi.TrigT1MuctpiConfig import L1MuctpiTool
from AthenaCommon.AppMgr import ToolSvc
ToolSvc += L1MuctpiTool()
topSequence.L1TopoSimulation.MuonInputProvider.MuctpiSimTool = L1MuctpiTool(
)
except ImportError:
pass
# enable the reduced (coarse) granularity topo simulation
# currently only for MC
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource() != 'data':
log.info(
"Muon eta/phi encoding with reduced granularity for MC (L1 Simulation)"
)
topSequence.L1TopoSimulation.MuonInputProvider.MuonEncoding = 1
else:
log.info(
"Muon eta/phi encoding with full granularity for data (L1 Simulation) - should be faced out"
)
topSequence.L1TopoSimulation.MuonInputProvider.MuonEncoding = 1
log.info("adding ctp simulation to the topSequence")
topSequence += CTPSimulation("CTPSimulation")
log.info("adding ROIB simulation to the topSequence")
topSequence += ROIB__RoIBuilder("RoIBuilder")
return True
from AthenaCommon.Logging import *
_msg = log # from above import...
## test and set log level
try:
_msg.setLevel(getattr(logging, opts.msg_lvl))
except:
_help_and_exit()
### default file name for ease of use ----------------------------------------
if not opts.scripts and os.path.exists(opts.default_jobopt):
_msg.info("using default file %s", opts.default_jobopt)
opts.scripts.append(opts.default_jobopt)
if not (opts.scripts or opts.fromdb) and opts.run_batch:
_msg.error("batch mode requires at least one script")
from AthenaCommon.ExitCodes import INCLUDE_ERROR
_help_and_exit(INCLUDE_ERROR)
del _help_and_exit
### file inclusion and tracing -----------------------------------------------
from AthenaCommon.Include import IncludeError, include
include.setShowIncludes(opts.showincludes)
include.setClean(opts.drop_cfg)
### pre-execution step -------------------------------------------------------
include("AthenaCommon/Preparation.py")
### execution of user script and drop into batch or interactive mode ---------
include("AthenaCommon/Execution.py")
def configure(self):
if self._done:
log.info("configuration already done, who is calling it again?")
return True
self._done = True
# start with print some information what this will do
log.info(
"Basic configuration flags RecAlgsFlag.doTrigger: %d RecFlags.doTrigger: %d TriggerFlags.doTriggerConfigOnly %d"
% (recAlgs.doTrigger(), rec.doTrigger(), TF.doTriggerConfigOnly()))
log.info(
"TriggerFlags: doL1Topo: %s, doLVL1: %s, doLVL2: %s, doEF: %s, doHLT: %s"
% (TF.doL1Topo(), TF.doLVL1(), TF.doLVL2(), TF.doEF(), TF.doHLT()))
willGenerateMenu = recAlgs.doTrigger() and (
TF.doLVL1() or TF.doLVL2() or TF.doEF()
or TF.doHLT()) and not TF.doTriggerConfigOnly()
willRunTriggerConfigGetter = recAlgs.doTrigger() or rec.doTrigger(
) or TF.doTriggerConfigOnly()
willRunLVL1SimulationGetter = recAlgs.doTrigger(
) and not TF.doTriggerConfigOnly()
willRunHLTSimulationGetter = willRunLVL1SimulationGetter and (
TF.doLVL2() or TF.doEF() or TF.doHLT())
log.info("Will run: %s%s%s%s" % (
"GenerateMenu " if willGenerateMenu else "",
"TriggerConfigGetter " if willRunTriggerConfigGetter else "",
"LVL1SimulationGetter " if willRunLVL1SimulationGetter else "",
"HLTSimulationGetter " if willRunHLTSimulationGetter else "",
))
log.info("Will not run: %s%s%s%s" % (
"GenerateMenu " if not willGenerateMenu else "",
"TriggerConfigGetter " if not willRunTriggerConfigGetter else "",
"LVL1SimulationGetter " if not willRunLVL1SimulationGetter else "",
"HLTSimulationGetter " if not willRunHLTSimulationGetter else "",
))
if recAlgs.doTrigger():
# setup the trigger from the DB
if TF.readConfigFromTriggerDb():
return self.configureTriggerFromDB()
if ((TF.doLVL1() == True or TF.doLVL2() == True
or TF.doEF() == True or TF.doHLT() == True)
and TF.doTriggerConfigOnly() == False):
log.info("generating menu")
# trigger menu files generation
g = GenerateMenu()
g.generate()
# after the menu xml file has been created or the TriggerDB access is configured,
# the COOL/SQlite db can be written
# TB this needs to be optimized -- we do not need ti always but only when AOD or ESD are created
if recAlgs.doTrigger() or rec.doTrigger() or TF.doTriggerConfigOnly():
# setup configuration services
from TriggerJobOpts.TriggerConfigGetter import TriggerConfigGetter
cfg = TriggerConfigGetter()
from TrigConfigSvc.TrigConf2COOL import theConfCOOLWriter
theConfCOOLWriter.writeConf2COOL()
# preconfigure TrigDecisionTool
from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool
from AthenaCommon.AppMgr import ToolSvc
ToolSvc += Trig__TrigDecisionTool("TrigDecisionTool")
# tell tdt to use TrigConfigSvc (Since TrigDecisionTool-00-03-40, defaults to not use it)
ToolSvc.TrigDecisionTool.TrigConfigSvc = "Trig::TrigConfigSvc/TrigConfigSvc"
from TrigEDMConfig.TriggerEDM import EDMLibraries
ToolSvc.TrigDecisionTool.Navigation.Dlls = [
e for e in EDMLibraries if 'TPCnv' not in e
]
# actuall trigger simulation running
if recAlgs.doTrigger() and not TF.doTriggerConfigOnly():
# setup Lvl1
# initialize LVL1ConfigSvc
log.info("configuring lvl1")
from TriggerJobOpts.Lvl1TriggerGetter import Lvl1SimulationGetter
lvl1 = Lvl1SimulationGetter()
if jobproperties.Global.InputFormat() != 'bytestream' and (
TF.doLVL2 == True or TF.doEF == True or TF.doHLT == True):
# Transient BS construction and intialization
from ByteStreamCnvSvc import WriteByteStream
StreamBS = WriteByteStream.getStream("Transient", "StreamBS")
StreamBS.ForceRead = True
StreamBS.ItemList += [
"DataVector<LVL1::TriggerTower>#TriggerTowers"
]
StreamBS.ItemList += ["TRT_RDO_Container#TRT_RDOs"]
StreamBS.ItemList += ["SCT_RDO_Container#SCT_RDOs"]
StreamBS.ItemList += ["PixelRDO_Container#PixelRDOs"]
# StreamBS.ItemList +=["LArRawChannelContainer#*"]
StreamBS.ItemList += ["2721#*"]
# StreamBS.ItemList +=["TileRawChannelContainer#*"]
StreamBS.ItemList += ["2927#*"]
StreamBS.ItemList += [
"2934#*"
] # added on request from: Arantxa Ruiz Martinez for TileRODMu
# don't need Muons in transient BS
# StreamBS.ItemList +=["MdtCsmContainer#*"]
# StreamBS.ItemList +=["RpcPadContainer#*"]
# StreamBS.ItemList +=["TgcRdoContainer#*"]
# StreamBS.ItemList +=["CscRawDataContainer#*"]
from AthenaCommon.Include import include
# setup trans BS for the ID
include("InDetRecExample/InDetRecCabling.py")
# setup HLT
# initialize HLT config svc
log.info("TriggerFlags: doLVL2 %r" % TF.doLVL2())
log.info("TriggerFlags: doEF %r" % TF.doEF())
log.info("TriggerFlags: doHLT %r" % TF.doHLT())
if TF.doLVL2() == True or TF.doEF() == True or TF.doHLT() == True:
log.info("configuring hlt")
from TriggerJobOpts.HLTTriggerGetter import HLTSimulationGetter
hlt = HLTSimulationGetter(g)
else:
from RegionSelector.RegSelSvcDefault import RegSelSvcDefault
from AthenaCommon.AppMgr import ServiceMgr
ServiceMgr += RegSelSvcDefault()
ServiceMgr.RegSelSvc.enablePixel = False
ServiceMgr.RegSelSvc.enableSCT = False
# prepare result making of L1
from TriggerJobOpts.Lvl1ResultBuilderGetter import Lvl1ResultBuilderGetter
hltouput = Lvl1ResultBuilderGetter()
# prepare result making of HLT
if TF.doLVL2() == True or TF.doEF() == True or TF.doHLT() or (
recAlgs.doTrigger() and TF.readBS()):
from TriggerJobOpts.HLTTriggerResultGetter import HLTTriggerResultGetter
hltouput = HLTTriggerResultGetter()
return True
theApp.setEvent = setEvent
from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
#athenaCommonFlags.isOnline = True
athenaCommonFlags.BSRDOInput=BSRDOInput
from RecExConfig.RecFlags import rec
rec.readRDO = False
rec.AutoConfiguration=['everything']
#----------------------------------------------------------------------
# Set services for reading BS files
#
include("ByteStreamCnvSvc/BSEventStorageEventSelector_jobOptions.py")
svcMgr.ByteStreamCnvSvc.InitCnvs += [ "EventInfo",
"HLT::HLTResult"]
svcMgr.ByteStreamAddressProviderSvc.TypeNames += [ "HLT::HLTResult/HLTResult_L2",
"HLT::HLTResult/HLTResult_EF",
"HLT::HLTResult/HLTResult_HLT"]
#----------------------------------------------------------------------
# Set input files
#
if ('BSRDOInput' in dir()):
svcMgr.ByteStreamInputSvc.FullFileName = BSRDOInput
globalflags.InputFormat = "bytestream"
#-------------------------------------------------------------------------------
#####################################################
#
# LVL1 simulation
#
#####################################################
from TrigConfigSvc.TrigConfigSvcConfig import LVL1ConfigSvc
LVL1ConfigSvc = LVL1ConfigSvc("LVL1ConfigSvc")
LVL1ConfigSvc.XMLFile = TriggerFlags.inputLVL1configFile()
#LVL1ConfigSvc.CreateLegacyObjects=True
include("TrigT1CaloByteStream/ReadLVL1CaloBS_jobOptions.py")
include("TrigT1CaloSim/TrigT1CaloSimJobOptions.py")
print "JOERG after including T1Calo simulation"
print topSequence.getChildren()
toRemove = [
c for c in topSequence.getChildren() if c.name() == 'TriggerTowerMaker'
]
for x in toRemove:
topSequence.remove(x)
print "JOERG after removing TriggerTowerMaker"
print topSequence.getChildren()
from TrigT1MBTS.TrigT1MBTSConf import LVL1__TrigT1MBTS
