def checkInput(self): self.checkFileMetaData() log = logging.getLogger( "TriggerConfigGetter.py" ) if "ReadPool" in self._environment or "WritePool" in self._environment: log.info("Flags are ignored, since 'ReadPool' or 'WritePool' is specified") return True if rec.readESD() or rec.readAOD(): # and globalflags.DataSource()=='data': # need this for MC as well protectedInclude("TriggerJobOpts/TriggerConfigCheckMetadata.py") if rec.readRDO() and globalflags.InputFormat()=='bytestream' and globalflags.DataSource()=='data' and TriggerFlags.configForStartup()!='HLToffline': protectedInclude("TriggerJobOpts/TriggerConfigCheckHLTpsk.py") log.info("The following flags are set:") log.info("globalflags.InputFormat : %s", globalflags.InputFormat()) log.info("rec.read.* : RDO: %s, ESD: %s, AOD: %s, TAG: %s", rec.readRDO(), rec.readESD(), rec.readAOD(), rec.readTAG()) log.info("rec.doWrite.* : ESD: %s, AOD: %s, TAG: %s", rec.doWriteESD(), rec.doWriteAOD(), rec.doWriteTAG()) log.info("globalflags.DataSource : %s", globalflags.DataSource()) log.info("TriggerFlags.configForStartup : %s", TriggerFlags.configForStartup()) log.info("TriggerFlags.dataTakingConditions : %s", TriggerFlags.dataTakingConditions()) log.info("TriggerFlags.configurationSourceList: %s", TriggerFlags.configurationSourceList()) count = len([1 for x in [rec.readRDO(),rec.readESD(),rec.readAOD()] if x ]) #readTAG is only set with another input if count == 0: log.warning("Don't know what the input format is.") return False if count >= 2: log.warning("More than one input format specified, please set only the appropriate one.") return False return True
def addMetaData(self): '''standard function to apply metadata, can overload if necessary for complicated scenarios.''' if self.doAODFix: logAODFix.debug("in addMetaData") from RecExConfig.RecFlags import rec suffix="_RAW" if rec.readESD(): suffix="_ESD" elif rec.readAOD(): suffix="_AOD" # remove any metadata we don't want to write out (in order to rerun again) metadataList = self.newAODFix.split("-") excludeFromMetadata = self.excludeFromMetadata() for excl in excludeFromMetadata: if excl in metadataList: metadataList.remove(excl) metastr = "AODFix_" + "-".join(metadataList) + suffix logAODFix.info("executing addMetaData, will add as AODFixVersion %s" % metastr) from AthenaCommon.AppMgr import ServiceMgr as svcMgr svcMgr.TagInfoMgr.ExtraTagValuePairs["AODFixVersion"]=metastr
def inputFileNames(): from AthenaCommon.AthenaCommonFlags import athenaCommonFlags if athenaCommonFlags.FilesInput() != []: return athenaCommonFlags.FilesInput() from RecExConfig.RecFlags import rec inFiles = None # highest flag have precedence if rec.readTAG(): inFiles = athenaCommonFlags.PoolTAGInput() elif rec.readAOD(): inFiles = athenaCommonFlags.PoolAODInput() elif rec.readESD(): inFiles = athenaCommonFlags.PoolESDInput() elif rec.readRDO(): from AthenaCommon.GlobalFlags import globalflags if globalflags.InputFormat == 'bytestream': inFiles = athenaCommonFlags.BSRDOInput() else: inFiles = athenaCommonFlags.PoolRDOInput() else: raise RutimeError("Unable to determine input file") return inFiles
def addCalorimeter(streamName=""): if not streamName=="" : stream = MSMgr.GetStream(streamName) #----------------------------------------------------------------------------- # Write Calorimeter information # for more info on the calorimeter collections, see: # https://twiki.cern.ch/twiki/bin/view/Atlas/CaloEvolution1200Persist #----------------------------------------------------------------------------- stream.AddItem( ["CaloClusterContainer#egClusterCollection"] ) stream.AddItem( ["CaloCellLinkContainer#egClusterCollection*"] ) stream.AddItem( ["CaloShowerContainer#egClusterCollection*"] ) stream.AddItem( ["CaloClusterContainer#EMTopoCluster*"] ) stream.AddItem( ["CaloCellLinkContainer#EMTopoCluster*"] ) stream.AddItem( ["CaloShowerContainer#EMTopoCluster*"] ) if rec.readESD() : stream.AddItem( ["CaloClusterContainer#LArClusterEM*"] ) stream.AddItem( ["CaloShowerContainer#LArClusterEM*"] ) stream.AddItem( ["CaloCellLinkContainer#LArClusterEM*"] ) stream.AddItem( ["CaloShowerContainer#egClusterCollection*"] ) pass pass else : primaryDPD_BasicOutput_msg.warning( 'Can not add the basic output collections to the stream %s', streamName ) pass return
def _fixJetTiming(c, **kw): # Check version number of the input data. # If no version is found, assume old. rlist = release_version() if rlist: if rlist[0] >= 16: return if rlist[0] == 15 and rlist[1] >= 7: return if rlist[0] == 15 and rlist[1] == 6 and rlist[2] >= 8: return sgkey_in = c.Getter.SGKey sgkey_in = resolveSGKey('JetCollection', sgkey_in) sgkey_out = sgkey_in + '_timing' seq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()) if not hasattr(seq, sgkey_out): tools = [] caloqual_kw = { 'doCellBasedVariables': True, 'doConstituentBasedVariables': True, 'doSamplingBasedVariables': True, 'cutOnTile': 254, 'cutOnLAr': 4000, 'doTileQuality': True, 'doLArQuality': True } if hasattr(JetRecToolsConf, 'JetTimeQualityTool'): # rel 15 setup tool1 = JetRecToolsConf.JetTimeQualityTool(sgkey_out + 'TimeTool', DoTime=False, DoQuality=False, UseCells=False) if rec.readESD() or rec.readRDO(): tool1.DoTime = True tool1.DoQuality = True tool1.UseCells = True if rec.readAOD() and (sgkey_in.find('H1Topo') >= 0 or sgkey_in.find('LCTopo') >= 0): tool1.DoTime = True tools.append(tool1) else: # rel 16 caloqual_kw['doTiming'] = True tool2 = JetCaloQualityTool(sgkey_out + 'QualTool', **caloqual_kw) tools.append(tool2) alg = JetD3PDMaker.JetFixupAlg(sgkey_out, InputKey=sgkey_in, OutputKey=sgkey_out, Tools=tools) for t in tools: alg += t seq += alg c.Getter.SGKey = sgkey_out return
def egammaBuilderAvailable(): " Return true if egammaBuilder is available." flag = False if rec.readRDO() or rec.readESD() and not rec.readAOD(): from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() if hasattr(topSequence, 'egamma'): flag = True return flag
def MuonsMuonCollectionAvailable(): if rec.readESD() and checkContainerInInputFile("Analysis::MuonContainer", "Muons"): return True if muonCombinedRecFlags.doxAOD() and muonCombinedRecFlags.doCombinedFit(): return True if hasattr(topSequence, 'BuildMuonCollection'): return True return False
def configure(self): log = logging.getLogger("TrigDecisionGetterRun2") from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() #if hasOnlyLVL1: #from RecExConfig.ObjKeyStore import objKeyStore #objKeyStore.addStreamESD('TrigDec::TrigDecision','TrigDecision') #objKeyStore.addStreamAOD('TrigDec::TrigDecision','TrigDecision') from RecExConfig.RecFlags import rec if ( rec.doWriteESD() or rec.doWriteAOD() or rec.doESD() or rec.doAOD() ) and \ ( not ( rec.readAOD() or rec.readESD() or rec.doWriteBS()) ): log.info("Will write TrigDecision object to storegate") from TrigDecisionMaker.TrigDecisionMakerConfig import WriteTrigDecision trigDecWriter = WriteTrigDecision() # noqa: F841 # WritexAODTrigDecision() is called within WriteTrigDecision() # inform TD maker that some parts may be missing if TriggerFlags.dataTakingConditions() == 'Lvl1Only': topSequence.TrigDecMaker.doL2 = False topSequence.TrigDecMaker.doEF = False topSequence.TrigDecMaker.doHLT = False topSequence.TrigNavigationCnvAlg.doL2 = False topSequence.TrigNavigationCnvAlg.doEF = False topSequence.TrigNavigationCnvAlg.doHLT = False elif TriggerFlags.dataTakingConditions() == 'HltOnly': from AthenaCommon.AlgSequence import AlgSequence topSequence.TrigDecMaker.doL1 = False # Decide based on the doMergedHLTResult to assume a merged, or a # split HLT: if not TriggerFlags.doMergedHLTResult(): topSequence.TrigDecMaker.doHLT = False topSequence.TrigNavigationCnvAlg.doL2 = False topSequence.TrigNavigationCnvAlg.doHLT = False else: topSequence.TrigDecMaker.doL2 = False topSequence.TrigDecMaker.doEF = False topSequence.TrigNavigationCnvAlg.doL2 = False topSequence.TrigNavigationCnvAlg.doEF = False pass else: log.info("Will not write TrigDecision object to storegate") return True
def addMuons(streamName=""): if not streamName == "": stream = MSMgr.GetStream(streamName) ##----------------------------------------------------------------------------- ## Write Muon related containers ##----------------------------------------------------------------------------- stream.AddItem(["Analysis::MuonContainer#*"]) stream.AddItem(["TrackRecordCollection#MuonEntryRecordFilter"]) stream.AddItem(["Rec::TrackParticleContainer#MuidCombTrackParticles"]) stream.AddItem( ["Rec::TrackParticleContainer#MuidCombTrackParticlesLowPt"]) stream.AddItem(["Rec::TrackParticleContainer#MuidExtrTrackParticles"]) stream.AddItem(["Rec::TrackParticleContainer#MuTagTrackParticles"]) stream.AddItem([ "Rec::TrackParticleContainer#MuonboyMuonSpectroOnlyTrackParticles" ]) stream.AddItem(["Rec::TrackParticleContainer#MuonboyTrackParticles"]) stream.AddItem(["Rec::TrackParticleContainer#StacoTrackParticles"]) stream.AddItem(["Rec::TrackParticleContainer#MooreTrackParticles"]) stream.AddItem(["Rec::MuonSpShowerContainer#MuonSpShowers"]) stream.AddItem(["CaloCompactCellContainer#AODCellContainer" ]) ## Requires detector description stream.AddItem(["CaloCellContainer#AODCellContainer" ]) ## Requires detector description stream.AddItem(["CaloClusterContainer#CaloCalTopoCluster"]) if rec.readESD(): stream.AddItem(["TileMuContainer#TileMuObj"]) stream.AddItem(["Trk::SegmentCollection#*"]) stream.AddItem(["Muon::CscPrepDataContainer#CSC_Clusters"]) stream.AddItem(["Muon::MdtPrepDataContainer#MDT_DriftCircles"]) stream.AddItem(["Muon::RpcPrepDataContainer#RPC_Measurements"]) stream.AddItem(["Muon::TgcPrepDataContainer#TGC_Measurements"]) stream.AddItem( ["MuonCaloEnergyContainer#MuonCaloEnergyCollection"]) if primDPD.UseMCTruth(): stream.AddItem(["PRD_MultiTruthCollection#*"]) pass else: primaryDPD_BasicOutput_msg.warning( 'Can not add the basic output collections to the stream %s', streamName) pass return
def GetDefaultTagRefStream(streams): # spot the most downstream target : this will be the default # except if one readXYZ is locked from RecExConfig.RecFlags import rec if rec.readRDO.is_locked() and rec.readRDO(): if 'Stream1_ref' in streams: return 'Stream1_ref' if 'StreamRDO_ref' in streams: return 'StreamRDO_ref' elif 'StreamRAW_ref' in streams: return 'StreamRAW_ref' else: raise RuntimeError( " readRDO locked True and no Stream1 nor StreamRDO nor StreamRAW !" ) if rec.readESD.is_locked() and rec.readESD(): if 'StreamESD_ref' in streams: return 'StreamESD_ref' else: raise RuntimeError(" readESD locked True and no StreamESD !") if rec.readAOD.is_locked() and rec.readAOD(): if 'StreamAOD_ref' in streams: return 'StreamAOD_ref' else: raise RuntimeError(" readAOD locked True and no StreamAOD !") # now deal with default case if 'StreamAOD_ref' in streams: return 'StreamAOD_ref' elif 'StreamESD_ref' in streams: return 'StreamESD_ref' elif 'Stream1_ref' in streams: return 'Stream1_ref' elif 'StreamRDO_ref' in streams: return 'StreamRDO_ref' elif 'StreamRAW_ref' in streams: return 'StreamRAW_ref' else: raise RuntimeError(" no known streams !") return None
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 setMetaData(): ''' Write the input source on which the InDet decoration algorithm was running to the meta data ''' from AthenaCommon.AppMgr import ServiceMgr as svcMgr if metaDataKey() in svcMgr.TagInfoMgr.ExtraTagValuePairs: return from RecExConfig.RecFlags import rec str = '' if rec.readRDO(): str = 'fromRDO' elif rec.readESD(): str = 'fromESD' elif rec.readAOD(): str = 'fromAOD' if metaDataKey() not in svcMgr.TagInfoMgr.ExtraTagValuePairs: svcMgr.TagInfoMgr.ExtraTagValuePairs[metaDataKey()] = str
def addEGamma(streamName=""): if not streamName=="" : stream = MSMgr.GetStream(streamName) ##----------------------------------------------------------------------------- ## Write EGamma related containers ##----------------------------------------------------------------------------- stream.AddItem( ["egDetailContainer#egDetailAOD"] ) stream.AddItem( ["egDetailContainer#egDetailContainer"] ) stream.AddItem( ["egDetailContainer#SofteDetailContainer"] ) if rec.readESD() : stream.AddItem( ["ElectronContainer#softeCollection"] ) stream.AddItem( ["ElectronContainer#ElectronCollection"] ) stream.AddItem( ["PhotonContainer#PhotonCollection"] ) pass else : primaryDPD_BasicOutput_msg.warning( 'Can not add the basic output collections to the stream %s', streamName ) pass return
def checkFileMetaData(self): log = logging.getLogger("TriggerConfigGetter.py") from RecExConfig.InputFilePeeker import inputFileSummary self.hasLBwiseHLTPrescalesAndL1ItemDef = True if rec.readESD() or rec.readAOD() or "ReadPool" in self._environment: self.hasLBwiseHLTPrescalesAndL1ItemDef = inputFileSummary[ 'metadata'].has_key( '/TRIGGER/HLT/Prescales' ) # they were all added at the same time (Repro with 15.6.3.2 Prod) # protection against early runs if inputFileSummary.has_key( 'run_number' ) and self._environment == "" and globalflags.DataSource( ) == 'data' and rec.readRDO() and any( [run < 134230 for run in inputFileSummary['run_number']]): self.hasLBwiseHLTPrescalesAndL1ItemDef = False if self.hasLBwiseHLTPrescalesAndL1ItemDef: log.info("Using LB-wise HLT prescales") else: log.info("Using run-wise HLT prescales")
def OutputFileName(suffix=""): from RecExConfig.RecFlags import rec OutFileName = "" if rec.OutputFileNameForRecoStep() == "": if rec.readRDO(): if globalflags.InputFormat() == "bytestream": OutFileName = "bs" else: OutFileName = "rdo" elif rec.readESD(): OutFileName = "esd" elif rec.readAOD(): OutFileName = "aod" else: OutFileName = "in" OutFileName = OutFileName + "to" if rec.doWriteBS(): OutFileName = OutFileName + "bs" elif rec.doWriteRDO(): OutFileName = OutFileName + "rdo" if rec.doESD(): OutFileName = OutFileName + "esd" if rec.doAOD(): OutFileName = OutFileName + "aod" if rec.doDPD(): OutFileName = OutFileName + "dpd" if rec.doWriteTAG(): OutFileName = OutFileName + "tag" if suffix != "": OutFileName = OutFileName + "_" + suffix print("Generated OutFileName", OutFileName) else: OutFileName = rec.OutputFileNameForRecoStep() print("User defined OutFileName", OutFileName) return OutFileName
def InputFileNames(): from AthenaCommon.AthenaCommonFlags import athenaCommonFlags if athenaCommonFlags.FilesInput() != []: return athenaCommonFlags.FilesInput() from RecExConfig.RecFlags import rec inFiles = None ## FIXME ## if (not athenaCommonFlags.PoolTAGInput.isDefault() or rec.readTAG() ): ## inFiles=athenaCommonFlags.PoolTAGInput() ## elif (not athenaCommonFlags.PoolAODInput.isDefault() or rec.readAOD() ): ## inFiles=athenaCommonFlags.PoolAODInput() ## elif (not athenaCommonFlags.PoolESDInput.isDefault() or rec.readESD() ): ## inFiles=athenaCommonFlags.PoolESDInput() ## elif not athenaCommonFlags.BSRDOInput.isDefault(): ## inFiles=athenaCommonFlags.BSRDOInput() ## elif not athenaCommonFlags.PoolRDOInput.isDefault(): ## inFiles=athenaCommonFlags.PoolRDOInput() if rec.readTAG(): inFiles = athenaCommonFlags.PoolTAGInput() elif rec.readAOD(): inFiles = athenaCommonFlags.PoolAODInput() elif rec.readESD(): inFiles = athenaCommonFlags.PoolESDInput() elif rec.readRDO(): from AthenaCommon.GlobalFlags import globalflags if globalflags.InputFormat == 'bytestream': inFiles = athenaCommonFlags.BSRDOInput() else: inFiles = athenaCommonFlags.PoolRDOInput() else: raise RuntimeError("Unable to determine input file") return inFiles
from AthenaCommon.GlobalFlags import globalflags from RecExConfig.RecFlags import rec if globalflags.InputFormat=='bytestream' or (not TriggerFlags.doLVL1()): CBNT_AthenaAware.Members += ["LVL1::CBNTAA_LVL1CaloESD/CBNT_LVL1calo"] elif (rec.readESD() or rec.readAOD()): CBNT_AthenaAware.Members += ["LVL1::CBNTAA_LVL1CaloESD/CBNT_LVL1calo"] elif (rec.readRDO() and TriggerFlags.doLVL1()): CBNT_AthenaAware.Members += [ "LVL1::CBNTAA_LVL1calo/CBNT_LVL1calo" ] elif ( jobproperties.CaloCellFlags.doFastCaloSim() and TriggerFlags.doLVL1()): CBNT_AthenaAware.Members += [ "LVL1::CBNTAA_LVL1calo/CBNT_LVL1calo" ] CBNT_AthenaAware.Members += [ "CBNTAA_ReadRoIBResult/CBNT_ReadRoIBResult" ] #CBNTAthenaAware=True include( "CBNT_Athena/CBNT_AthenaAware_jobOptions.py" ) include( "CBNT_Athena/CBNT_EventInfo_jobOptions.py" ) if rec.Commissioning: from AthenaMonitoring.DQMonFlags import DQMonFlags if DQMonFlags.doCTPMon(): include ("TrigT1CTMonitoring/NtupleFragment.py") if DQMonFlags.doLVL1CaloMon(): include( "TrigT1CaloCalibTools/CBNT_L1Calo_jobOptions.py" ) else: doL1CaloCBNT_JEM = False doL1CaloCBNT_CPM = False doL1CaloCBNT_RODHeader = False include( "TrigT1CaloCalibTools/CBNT_L1Calo_jobOptions.py" ) include("TrigNtInDet/jobOfragment_TrigNtInDet.py")
tdt_local_logger = logging.getLogger('TrigDecTool_jobOptions') # Set up the trigger decision tool (for trigger-aware monitoring) if not 'DQMonFlags' in dir(): tdt_local_logger.debug("DQMonFlags not yet imported - I import them now") from AthenaMonitoring.DQMonFlags import DQMonFlags if DQMonFlags.useTrigger(): if not 'rec' in dir(): from RecExConfig.RecFlags import rec if rec.readESD() and (DQMonFlags.monManEnvironment=='tier0ESD'): # for ESD->AOD use trigger config stored as in-file meta-data, if not 'TriggerFlags' in dir(): from TriggerJobOpts.TriggerFlags import TriggerFlags TriggerFlags.configurationSourceList = ['ds'] # set up trigger config service if not 'TriggerConfigGetter' in dir(): from TriggerJobOpts.TriggerConfigGetter import TriggerConfigGetter cfg = TriggerConfigGetter() if not hasattr(ToolSvc, DQMonFlags.nameTrigDecTool()): from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool monTrigDecTool = Trig__TrigDecisionTool(name=DQMonFlags.nameTrigDecTool(), OutputLevel=ERROR, PublicChainGroups = {"EFTau": "EF_[0-9]?tau.*", "EFPhoton": "EF_[0-9]?g*", "EFJets":"EF_J.*", } )
from AthenaCommon.GlobalFlags import globalflags from RecExConfig.RecFlags import rec from RecExConfig.RecAlgsFlags import recAlgs if rec.Commissioning: CBNTAthenaAware = True if rec.doTruth(): protectedInclude("RecExCommon/CBNT_Truth_jobOptions.py") if not (globalflags.DetDescrVersion()[0:3] == "DC1" or globalflags.DetDescrVersion()[0:3] == "DC2"): protectedInclude("MCTruthAlgs/CBNT_TrackRecord.py") if (DetFlags.haveRIO.ID_on() or rec.readESD() or rec.readAOD()): # no CBNT for ID anymore (use track validation ntuple) if jobproperties.Beam.beamType() == "collisions": # # functionality : put tracks from any tracking algorithm in combined ntuple # protectedInclude("InDetPriVxCBNT/InDetPriVxCBNT_jobOptions.py") if rec.readAOD(): try: CBNTAA_VxPrimary.useTrkTrack = False CBNTAA_VxPrimary.McEventCollectionName = "GEN_AOD" except Exception: logCBNT_config.warning("CBNTAA_VxPrimary undefined")
def ConfigureInputType(): from PyUtils.MetaReaderPeeker import metadata from AthenaCommon.GlobalFlags import globalflags streamsName = [] if metadata['file_type'] == 'BS': #byte stream logAutoConfiguration.info("Input BS detected") globalflags.InputFormat = 'bytestream' rec.readRDO = True rec.readESD = False rec.readAOD = False rec.doAOD = False rec.doESD = True rec.doWriteAOD = False logAutoConfiguration.info( "BS format: setting globalflags.InputFormat=%s " % globalflags.InputFormat()) logAutoConfiguration.info("BS format: setting rec.readRDO=%s " % rec.readRDO()) logAutoConfiguration.info("BS format: setting rec.doAOD=%s " % rec.doAOD()) logAutoConfiguration.info("BS format: setting rec.doESD=%s " % rec.doESD()) logAutoConfiguration.info("BS format: setting rec.doWriteAOD=%s " % rec.doWriteAOD()) else: globalflags.InputFormat = 'pool' #Get streamsName streamsName = [] if 'processingTags' in metadata: streamsName = metadata['processingTags'] if streamsName == None: streamsName = [] logAutoConfiguration.info("Extracted streams %s from input file " % streamsName) if len(streamsName) == 0: logAutoConfiguration.warning( "ConfigureInputType: no stream in input file.") elif len(streamsName) > 1: logAutoConfiguration.warning( "ConfigureInputType: more than one stream: %s in input file. Default action. Consider the highest one." ) else: rec.mergingStreamName = streamsName[0] from RecExConfig.RecoFunctions import OverlapLists try: from PrimaryDPDMaker.PrimaryDPDFlags import listRAWtoDPD, listESDtoDPD, listAODtoDPD except: logAutoConfiguration.warning( "Unable to import PrimaryDPDFlags. OK for ATN tests below AtlasAnalysis, otherwise suspicious." ) listRAWtoDPD = [] listESDtoDPD = [] listAODtoDPD = [] ## these lines have been added to guarantee the backward compatibility for the old DPD naming convention cosmics try: from PrimaryDPDMaker.PrimaryDPDFlags import listBackwardCompatibleAODtoDPD, listBackwardCompatibleESDtoDPD listESDtoDPD.extend(listBackwardCompatibleESDtoDPD) listAODtoDPD.extend(listBackwardCompatibleAODtoDPD) except: logAutoConfiguration.warning( "Primary DPDMake does not support the old naming convention!!") if 'TagStreamsRef' in metadata and metadata['TagStreamsRef'] != None: logAutoConfiguration.info("Input TAG detected") rec.readTAG = True logAutoConfiguration.info("Auto configured rec.readTAG=%s " % rec.readTAG()) from RecExConfig.RecoFunctions import ItemInListStartsWith if ItemInListStartsWith("StreamAOD", streamsName) or ItemInListStartsWith( 'StreamDAOD', streamsName) or ItemInListStartsWith( 'StreamD2AOD', streamsName) or OverlapLists( streamsName, listAODtoDPD) or ItemInListStartsWith( 'DAOD', streamsName) or ItemInListStartsWith( 'D2AOD', streamsName): logAutoConfiguration.info("Input AOD detected") rec.readRDO = False rec.readESD = False rec.readAOD = True rec.doAOD = False rec.doESD = False logAutoConfiguration.info("setting rec.readAOD=%s " % rec.readAOD()) elif ItemInListStartsWith( "StreamESD", streamsName) or ItemInListStartsWith( 'StreamDESD', streamsName) or ItemInListStartsWith( 'StreamD2ESD', streamsName) or OverlapLists( streamsName, listESDtoDPD) or ItemInListStartsWith( 'DESD', streamsName) or ItemInListStartsWith( 'D2ESD', streamsName): logAutoConfiguration.info("Input ESD detected") rec.readRDO = False rec.readESD = True rec.readAOD = False rec.doAOD = True rec.doESD = False logAutoConfiguration.info("setting rec.readESD=%s " % rec.readESD()) logAutoConfiguration.info("setting rec.doAOD=%s " % rec.doAOD()) elif ItemInListStartsWith("Stream1", streamsName) or ItemInListStartsWith( "StreamRDO", streamsName) or ItemInListStartsWith( "OutputStreamRDO", streamsName) or OverlapLists( streamsName, listRAWtoDPD): logAutoConfiguration.info("Input RDO detected") rec.readRDO = True rec.readESD = False rec.readAOD = False rec.doAOD = False rec.doESD = True logAutoConfiguration.info("setting rec.readRDO=%s " % rec.readRDO()) logAutoConfiguration.info("setting rec.doESD=%s " % rec.doESD()) elif ItemInListStartsWith("StreamEVGEN", streamsName): logAutoConfiguration.info("Input EVGEN detected") rec.readRDO = False rec.readESD = False rec.readAOD = False rec.doAOD = False rec.doESD = False logAutoConfiguration.info( "setting all unlocked rec.readXXX and rec.doXXX to False") elif ItemInListStartsWith("StreamHITS", streamsName): logAutoConfiguration.info("Input StreamEVGEN detected") elif metadata['file_type'] != 'BS': raise RuntimeError("ConfigureInputType cannot handle streamsName==%s" % streamsName) return
elif jobproperties.Beam.beamType() == 'singlebeam': ## There is no singlebeam in AthenaMonitoring DQMonFlags.monManDataType = 'collisions' else: local_logger.warning("invalid jobproperties.Beam.beamType(): %s, using default (%s)", jobproperties.Beam.beamType(), DQMonFlags.monManDataType) # First, test to see if this is being run online if athenaCommonFlags.isOnline: DQMonFlags.monManEnvironment='online' # Running offline; set the monMan environment based on monType elif DQMonFlags.monType=='BSonly': DQMonFlags.monManEnvironment='tier0Raw' if rec.readESD(): DQMonFlags.doMonitoring=False elif DQMonFlags.monType=='ESDonly': DQMonFlags.monManEnvironment='tier0ESD' if rec.readRDO(): DQMonFlags.doMonitoring=False elif (DQMonFlags.monType=='BS_ESD'): if rec.readRDO(): DQMonFlags.monManEnvironment='tier0Raw' if rec.readESD(): DQMonFlags.monManEnvironment='tier0ESD' if rec.readAOD(): DQMonFlags.monManEnvironment='AOD'
def AODFix_Init(): ''' This function is called to correctly setup AODFix.''' global _aodFixInstance from RecExConfig.RecFlags import rec ################## # exit if locked to false ################## if rec.doApplyAODFix.is_locked() and rec.doApplyAODFix.get_Value( ) == False: logAODFix.info( "doApplyAODFix is locked to False; not applying anything") return ################## # deterimine in what release we are running (and fill some rec variables ################## import os curRelease = os.getenv("AtlasVersion") or '' logAODFix.debug("curRelease set to " + curRelease) ################## # determine athena with which input file was created and previous AODFix ################## # RDO doesn't have MetaData prevAODFix = '' prevRelease = '' isMC = False isHI = rec.doHeavyIon() isHIP = rec.doHIP() # is it better to do this or to look at GlobalFlags? from RecExConfig.InputFilePeeker import inputFileSummary try: isMC = (inputFileSummary['evt_type'][0] == "IS_SIMULATION") except Exception: logAODFix.warning( "Could not tell if the input file is data or MC; setting to data") isMC = False if not rec.readRDO(): try: AtlasReleaseVersionString = inputFileSummary['metadata'][ '/TagInfo']['AtlasRelease'] rv = AtlasReleaseVersionString.split('-') if len(rv) > 1: prevRelease = rv[1] except Exception: logAODFix.warning( "no AthenRelease found in input file, setting to <none> !!") prevRelease = '' ################## # determine which is the previous verion of the AODFix ################## try: prevAODFix = inputFileSummary['tag_info']['AODFixVersion'] if prevAODFix.startswith("AODFix_"): prevAODFix = prevAODFix[7:] prevAODFix = prevAODFix.split("_")[0] except Exception: logAODFix.debug( "no AODFixVersion found in input file, setting to <none>.") prevAODFix = '' logAODFix.info("Summary of MetaData for AODFix:") if isMC: logAODFix.info(" Input file is MC") else: logAODFix.info(" Input file is DATA") logAODFix.info(" Input file produced with Athena version <%s>." % prevRelease) logAODFix.info(" AODFix version <%s> was previously applied." % prevAODFix) if rec.doApplyAODFix.is_locked(): logAODFix.info(" AODFix is forced to run!") ################## # determine which AODFix to run (if actually running--to be determined later) ################## doAODFix = False if rec.readAOD(): # change in policy: no AODFix if reading ESD. doAODFix = True # check to see if it's a DAOD; do not run by default in DAODs from RecExConfig.InputFilePeeker import inputFileSummary try: streamNames = inputFileSummary['stream_names'] if any(map(lambda x: "StreamDAOD" in x, streamNames)) and not rec.doApplyAODFix.is_locked(): logAODFix.info("Running on a DAOD, so not scheduling AODFix") doAODFix = False except Exception: logAODFix.warning("Could not determine the stream name") elif rec.readESD() and rec.doApplyAODFix.is_locked(): # only run on ESDs if forcing doAODFix = True #exit if not doing AODFix if not doAODFix: return curReleaseSplit = curRelease.split('.') prevReleaseSplit = prevRelease.split('.') if len(curReleaseSplit) >= 2 and (rec.doApplyAODFix.is_locked() or len(prevReleaseSplit) >= 2): ### If adding an AODFix for a release family that does not have it, ### please add it to the if-elif... statement below # if (curReleaseSplit[0] == '21' and (curReleaseSplit[1] == '0' or curReleaseSplit[1] == '2') and # (rec.doApplyAODFix.is_locked() or # (prevReleaseSplit[0] == '21' and (prevReleaseSplit[1] == '0' or prevReleaseSplit[1] == '2')))): # _aodFixInstance = AODFix_r210(prevAODFix, isMC, rec.doApplyAODFix.is_locked(), isHI, isHIP) # else: # logAODFix.info("No AODFix scheduled for this release.") logAODFix.info("AODFix disabled.") else: logAODFix.info("Current release is of strange form: %s" % curRelease)
from InDetVertexMonitoring.InDetVertexMonitoringConf import InDetVertexMonitoring myVx = InDetVertexMonitoring() myVx.DoControlPlots = False myVx.OutputLevel = WARNING if not 'DQMonFlags' in dir(): print "DQMonFlags not yet imported - I import them now" from AthenaMonitoring.DQMonFlags import DQMonFlags #DQMonFlags.useTrigger = False if DQMonFlags.useTrigger(): if not 'rec' in dir(): from RecExConfig.RecFlags import rec if rec.readESD() and (DQMonFlags.monManEnvironment=='tier0ESD'): # for ESD->AOD use trigger config stored as in-file meta-data, if not 'TriggerFlags' in dir(): from TriggerJobOpts.TriggerFlags import TriggerFlags TriggerFlags.configurationSourceList = ['ds'] # set up trigger config service if not 'TriggerConfigGetter' in dir(): from TriggerJobOpts.TriggerConfigGetter import TriggerConfigGetter cfg = TriggerConfigGetter() if not hasattr(ToolSvc, DQMonFlags.nameTrigDecTool()): from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool monTrigDecTool = Trig__TrigDecisionTool(name=DQMonFlags.nameTrigDecTool(), OutputLevel=ERROR, PublicChainGroups = {"EF": "EF_rd0*",}
from TrkExTools.AtlasExtrapolator import AtlasExtrapolator from TrackToCalo.TrackToCaloConf import Trk__ParticleCaloExtensionTool, Rec__ParticleCaloCellAssociationTool pcExtensionTool = Trk__ParticleCaloExtensionTool( Extrapolator=AtlasExtrapolator()) caloCellAssociationTool = Rec__ParticleCaloCellAssociationTool( ParticleCaloExtensionTool=pcExtensionTool) topSequence += CfgMgr.TrackParticleCellAssociationAlg( "TrackParticleCellAssociationAlg", ParticleCaloCellAssociationTool=caloCellAssociationTool) # # functionality : energy flow # pdr.flag_domain('eflow') if recAlgs.doEFlow() and (rec.readESD() or (DetFlags.haveRIO.ID_on() and DetFlags.haveRIO.Calo_allOn() and rec.doMuonCombined())): try: include("eflowRec/eflowRec_jobOptions.py") except Exception: treatException("Could not set up EFlow. Switched off !") recAlgs.doEFlow = False else: recAlgs.doEFlow = False #AODFix_postMuonCombinedRec() # # functionality : CaloTower protojets + preclustering + KT algorithm + CombinedJetAlg # pdr.flag_domain('jet')
from RecExConfig.RecAlgsFlags import recAlgs from AthenaCommon.Resilience import treatException from AthenaCommon.DetFlags import DetFlags from egammaRec import egammaKeys from egammaRec.egammaKeys import egammaKeysDict from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() ###############Print Egamma JobProperties############# jobproperties.egammaRecFlags.print_JobProperties("full") ##################################################################### # Run calo-based (egamma) algorithm, includes topo-seeded # It requires either to read ESD # either that Emcluster have been build if jobproperties.egammaRecFlags.doEgammaCaloSeeded() and ( rec.readESD() or jobproperties.CaloRecFlags.doEmCluster()) : # try: if jobproperties.egammaRecFlags.doEgammaCaloSeeded: from egammaRec.egammaGetter import egammaGetter egammaGetter(ignoreExistingDataObject=True) except Exception: treatException("Could not set up egammaGetter. Switch it off !") jobproperties.egammaRecFlags.doEgammaCaloSeeded=False egammaGetter(disable=True) else: jobproperties.egammaRecFlags.doEgammaCaloSeeded=False try: from egammaRec.egammaGetter import egammaGetter egammaGetter(disable=True) except Exception:
# include DetFlags # by default everything is off from AthenaCommon.DetFlags import DetFlags # switch on tasks for all detectors DetFlags.detdescr.all_setOn() # switch on dcs for all detectors try: # need AthenaCommon DetFlags.dcs.all_setOn() except Exception: logRecExCommon_DetFlags.warning("could not set DetFlags.dcs") pass from RecExConfig.RecFlags import rec if not rec.readESD() and not rec.readAOD() and not rec.doWriteRDO(): DetFlags.makeRIO.all_setOn() else: DetFlags.makeRIO.all_setOff() #calo cells are there on ESD if rec.readESD(): DetFlags.readRIOPool.Calo_setOn() # savannah 73686 from RecExConfig.AutoConfiguration import IsInInputFile from InDetRecExample.InDetKeys import InDetKeys if IsInInputFile('InDet::PixelClusterContainer', InDetKeys.PixelClusters()): DetFlags.readRIOPool.pixel_setOn() if IsInInputFile('InDet::SCT_ClusterContainer', InDetKeys.SCT_Clusters()): DetFlags.readRIOPool.SCT_setOn()
if globalflags.InputFormat.is_pool(): logAnaCommon_topOptions.info("Pool file : storing in objKeyStore the list of input object directly from file") try: from PyUtils.MetaReaderPeeker import convert_itemList objKeyStore.addManyTypesInputFile(convert_itemList(layout = '#join')) pass except: logAnaCommon_topOptions.error("no input file defined in flags. If using RTT please use tag <athenaCommonFlags/>. Now continuing at own riske") pass pass # for BS file this cannot be done already, see later if not rec.readESD() and not rec.readAOD(): ##objKeyStore.readInputFile('RecExPers/OKS_streamRDO.py') pass elif rec.readESD(): ##objKeyStore.readInputFile('RecExPers/OKS_streamESD.py') ##objKeyStore.readInputBackNav('RecExPers/OKS_streamRDO.py') # still need to read in AOD content built at ESD stage objKeyStore.readStreamAOD('RecExPers/OKS_streamAOD_fromESD.py') # at this point all streamAOD there should already be in ESD for k in objKeyStore['streamAOD'].list(): if not objKeyStore['inputFile'].has_item (k): logAnaCommon_topOptions.info("Warning item %s scheduled co be copied from ESD to AOD, but missing in ESD! Dropped. " % k ) objKeyStore['streamAOD'].removeItem (k) pass pass pass
def configure(self): log = logging.getLogger("HLTTriggerResultGetter.py") from RecExConfig.ObjKeyStore import objKeyStore # set EDMDecodingVersion EDMDecodingVersion() # Set AODFULL for data unless it was set explicitly already if TriggerFlags.AODEDMSet.isDefault() and globalflags.DataSource( ) == 'data': TriggerFlags.AODEDMSet = 'AODFULL' from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() log.info("BS unpacking (TF.readBS): %d", TriggerFlags.readBS()) if TriggerFlags.readBS(): if TriggerFlags.EDMDecodingVersion() <= 2: bs = ByteStreamUnpackGetterRun2() # noqa: F841 else: bs = ByteStreamUnpackGetter() # noqa: F841 xAODContainers = {} # if not recAlgs.doTrigger(): #only convert when running on old data if TriggerFlags.EDMDecodingVersion() == 1: xaodcnvrt = xAODConversionGetter() xAODContainers = xaodcnvrt.xaodlist if recAlgs.doTrigger() or TriggerFlags.doTriggerConfigOnly(): if TriggerFlags.EDMDecodingVersion() <= 2: tdt = TrigDecisionGetterRun2() # noqa: F841 else: tdt = TrigDecisionGetter() # noqa: F841 # Temporary hack to add Run-3 navigation to ESD and AOD if (rec.doESD() or rec.doAOD()) and TriggerFlags.EDMDecodingVersion() == 3: # The hack with wildcards is needed for BS->ESD because we don't know the exact keys # of HLT navigation containers before unpacking them from the BS event. objKeyStore._store['streamESD'].allowWildCard(True) objKeyStore._store['streamAOD'].allowWildCard(True) objKeyStore.addManyTypesStreamESD([ 'xAOD::TrigCompositeContainer#HLTNav*', 'xAOD::TrigCompositeAuxContainer#HLTNav*' ]) objKeyStore.addManyTypesStreamAOD([ 'xAOD::TrigCompositeContainer#HLTNav*', 'xAOD::TrigCompositeAuxContainer#HLTNav*' ]) # TrigJetRec additions if rec.doWriteESD(): objKeyStore.addStreamESD("JetKeyDescriptor", "JetKeyMap") objKeyStore.addStreamESD("JetMomentMap", "TrigJetRecMomentMap") if rec.doWriteAOD(): objKeyStore.addStreamAOD("JetKeyDescriptor", "JetKeyMap") objKeyStore.addStreamAOD("JetMomentMap", "TrigJetRecMomentMap") # ID truth if not rec.readESD() and (not rec.readAOD()) and TriggerFlags.doID() \ and rec.doTruth(): try: from TrigInDetTruthAlgs.TrigInDetTruthAlgsConfig import \ TrigIDTruthMaker topSequence += TrigIDTruthMaker() except Exception: log.warning("Couldn't set up the trigger ID truth maker") pass if rec.doESD() or rec.doAOD(): from TrigEDMConfig.TriggerEDM import getTrigIDTruthList objKeyStore.addManyTypesStreamESD( getTrigIDTruthList(TriggerFlags.ESDEDMSet())) objKeyStore.addManyTypesStreamAOD( getTrigIDTruthList(TriggerFlags.AODEDMSet())) if (rec.doESD() or rec.doAOD()) and TriggerFlags.writeL1TopoValData(): objKeyStore.addManyTypesStreamESD([ 'xAOD::TrigCompositeContainer#HLT_xAOD__TrigCompositeContainer_L1TopoValData', 'xAOD::TrigCompositeAuxContainer#HLT_xAOD__TrigCompositeContainer_L1TopoValDataAux.' ]) objKeyStore.addManyTypesStreamAOD([ 'xAOD::TrigCompositeContainer#HLT_xAOD__TrigCompositeContainer_L1TopoValData', 'xAOD::TrigCompositeAuxContainer#HLT_xAOD__TrigCompositeContainer_L1TopoValDataAux.' ]) log.debug( "HLT_xAOD__TrigCompositeContainer_L1TopoValData(Aux.) for L1Topo validation added to the data." ) if rec.doAOD() or rec.doWriteAOD(): # schedule the RoiDescriptorStore conversion # log.warning( "HLTTriggerResultGetter - setting up RoiWriter" ) roiWriter = RoiWriter() # Add fictional input to ensure data dependency in AthenaMT roiWriter.ExtraInputs += [("TrigBSExtractionOutput", "StoreGateSvc+TrigBSExtractionOutput")] topSequence += roiWriter # write out the RoiDescriptorStores from TrigEDMConfig.TriggerEDMRun2 import TriggerRoiList objKeyStore.addManyTypesStreamAOD(TriggerRoiList) #Are we adding operational info objects in ESD? added = self._AddOPIToESD() if added: log.debug( "Operational Info object HLT_EXPRESS_OPI_HLT with extra information about express stream prescaling added to the data." ) # ESD objects definitions _TriggerESDList = {} from TrigEDMConfig.TriggerEDM import getTriggerEDMList # we have to store xAOD containers in the root file, NOT AOD, # if the xAOD container list is not empty if (xAODContainers): _TriggerESDList.update(xAODContainers) else: _TriggerESDList.update( getTriggerEDMList(TriggerFlags.ESDEDMSet(), TriggerFlags.EDMDecodingVersion())) log.info( "ESD content set according to the ESDEDMSet flag: %s and EDM version %d", TriggerFlags.ESDEDMSet(), TriggerFlags.EDMDecodingVersion()) # AOD objects choice _TriggerAODList = {} #from TrigEDMConfig.TriggerEDM import getAODList _TriggerAODList.update( getTriggerEDMList(TriggerFlags.AODEDMSet(), TriggerFlags.EDMDecodingVersion())) log.info( "AOD content set according to the AODEDMSet flag: %s and EDM version %d", TriggerFlags.AODEDMSet(), TriggerFlags.EDMDecodingVersion()) log.debug("ESD EDM list: %s", _TriggerESDList) log.debug("AOD EDM list: %s", _TriggerAODList) # Highlight what is in AOD list but not in ESD list, as this can cause # the "different number of entries in branch" problem, when it is in the # AOD list but the empty container per event is not created # Just compares keys of dicts, which are the class names, not their string keys in StoreGate not_in = [ element for element in _TriggerAODList if element not in _TriggerESDList ] if (len(not_in) > 0): log.warning("In AOD list but not in ESD list: ") log.warning(not_in) else: log.info("AOD list is subset of ESD list - good.") def _addSlimming(stream, edm): from TrigNavTools.TrigNavToolsConfig import navigationThinningSvc edmlist = list(y.split('-')[0] for x in edm.values() for y in x) #flatten names svc = navigationThinningSvc({ 'name': 'HLTNav_%s' % stream, 'mode': 'cleanup', 'result': 'HLTResult_HLT', 'features': edmlist }) from OutputStreamAthenaPool.CreateOutputStreams import registerTrigNavThinningSvc registerTrigNavThinningSvc(stream, svc) log.info("Configured slimming of HLT for %s", stream) print(svc) # noqa: ATL901 del edmlist if TriggerFlags.doNavigationSlimming() and rec.readRDO( ) and rec.doWriteAOD(): _addSlimming('StreamAOD', _TriggerESDList) #Use ESD item list also for AOD! log.info("configured navigation slimming for AOD output") if TriggerFlags.doNavigationSlimming() and rec.readRDO( ) and rec.doWriteESD(): _addSlimming('StreamESD', _TriggerESDList) log.info("configured navigation slimming for ESD output") objKeyStore.addManyTypesStreamESD(_TriggerESDList) objKeyStore.addManyTypesStreamAOD(_TriggerAODList) return True
from RecExConfig.RecAlgsFlags import recAlgs from AthenaCommon.AthenaCommonFlags import athenaCommonFlags athenaCommonFlags.FilesInput = [ '/tmp/jdevivi/ESD.186186._001566.pool.root.1' ] athenaCommonFlags.EvtMax.set_Value_and_Lock(5) athenaCommonFlags.SkipEvents.set_Value_and_Lock(0) from AthenaCommon.GlobalFlags import globalflags if OverrideConditionsTag != "": print '#BTAG# Overriding conditions tag with ', OverrideConditionsTag globalflags.ConditionsTag.set_Value_and_Lock(OverrideConditionsTag) # --- Re-reconstruction steering flags: do not change if not an expert ! #rec.readAOD.set_Value_and_Lock(True) rec.doTrigger.set_Value_and_Lock(False) rec.readESD.set_Value_and_Lock(True) rec.doESD.set_Value_and_Lock(ReDoTrkEgComMuon and rec.readESD()) rec.doAOD.set_Value_and_Lock(False) rec.doWriteAOD.set_Value_and_Lock(False) rec.doWriteTAG.set_Value_and_Lock(False) rec.doCBNT.set_Value_and_Lock(False) rec.doHist.set_Value_and_Lock(False) rec.doDumpTES.set_Value_and_Lock(False) rec.doPerfMon.set_Value_and_Lock(False) rec.doDetailedPerfMon.set_Value_and_Lock(False) if rec.doESD(): rec.Commissioning=True rec.doMonitoring=False # Since I put doESD at True to allow for ID reco, I have to swich off many things # High level objects recAlgs.doMuonIDStandAlone.set_Value_and_Lock(False)
from AthenaCommon.BFieldFlags import jobproperties jobproperties.BField.solenoidOn.set_Value_and_Lock(False) jobproperties.BField.barrelToroidOn.set_Value_and_Lock(True) jobproperties.BField.endcapToroidOn.set_Value_and_Lock(True) globalflags.InputFormat.set_Value_and_Lock('bytestream') if rec.readAOD(): if rec.readTAG(): raise "Cannot have both readAOD and readTAG true" athenaCommonFlags.PoolAODInput.set_Value_and_Lock( ["../cosm/myAOD.pool.root"]) rec.doWriteAOD = False rec.doWriteESD = False if rec.readESD(): #lxplus225 ####L1CaloEM # this is ignored if tags are read athenaCommonFlags.PoolESDInput.set_Value_and_Lock( ["../cosm/myESD.pool.root"]) rec.doWriteESD = False if rec.readESD() or rec.readAOD(): globalflags.InputFormat.set_Value_and_Lock('pool') globalflags.DetDescrVersion.set_Value_and_Lock('ATLAS-GEO-03-00-00') globalflags.ConditionsTag.set_Value_and_Lock('COMCOND-REPC-001-00') from AthenaCommon.BFieldFlags import jobproperties jobproperties.BField.solenoidOn.set_Value_and_Lock(True) jobproperties.BField.barrelToroidOn.set_Value_and_Lock(True) jobproperties.BField.endcapToroidOn.set_Value_and_Lock(True)
topSequence.VrtSecInclusive.TrkA0ErrCut = 200000 topSequence.VrtSecInclusive.TrkZErrCut = 200000 topSequence.VrtSecInclusive.a0TrkPVDstMinCut = 5.0 topSequence.VrtSecInclusive.TrkPtCut = 300 topSequence.VrtSecInclusive.SelVrtChi2Cut=4.5 topSequence.VrtSecInclusive.CutSharedHits=5 topSequence.VrtSecInclusive.TrkChi2Cut=5.0 topSequence.VrtSecInclusive.TruthTrkLen=1 topSequence.VrtSecInclusive.DoSAloneTRT=False topSequence.VrtSecInclusive.DoTruth = False # following is when there is no GEN_AOD in input file, # e.g., when I run on output of InDetRecExample or on a ESD file # when running on AOD output of InDetRecEx, explicitly uncomment the next line and comment out rec.readESD # topSequence.VrtSecInclusive.MCEventContainer = "TruthEvent" if rec.readESD(): topSequence.VrtSecInclusive.MCEventContainer = "TruthEvent" if 'IS_SIMULATION' in metadata['eventTypes']: topSequence.VrtSecInclusive.DoTruth=True from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter InclusiveVxFitterTool = Trk__TrkVKalVrtFitter(name = "InclusiveVxFitter", Extrapolator = ToolSvc.AtlasExtrapolator, IterationNumber = 30 ) ToolSvc += InclusiveVxFitterTool; InclusiveVxFitterTool.OutputLevel = INFO topSequence.VrtSecInclusive.VertexFitterTool=InclusiveVxFitterTool topSequence.VrtSecInclusive.Extrapolator = ToolSvc.AtlasExtrapolator
# this is a RDO to RDO copy, do not put detector status rec.doDetStatus = False # in case several read specified, favour the highest one if rec.readAOD(): logRecExCommon_flags.info("read AOD : all algs switched off ") # switch off all algorithms rec.doESD = False rec.doAOD = False rec.doWriteESD = False rec.doWriteAOD = False if rec.readRDO: logRecExCommon_flags.info("readAOD : switch readRDO off ") rec.readRDO = False if rec.readESD(): logRecExCommon_flags.info("readESD : switch readRDO off ") rec.readRDO = False if rec.readESD(): logRecExCommon_flags.info("read ESD : all algs switched off ") # switch off all algorithms rec.doESD = False rec.doWriteESD = False if rec.readRDO(): logRecExCommon_flags.info("readESD : switch readRDO off ") rec.readRDO = False # consistency check in case of lock _allRead = rec.readRDO() + rec.readESD() + rec.readAOD()
topSequence = AlgSequence() if muonRecFlags.doDigitization(): include("MuonRecExample/MuonDigitization_jobOptions.py") if rec.readRDO(): if globalflags.InputFormat == 'bytestream': include("MuonCnvExample/MuonReadBS_jobOptions.py") else: include("MuonCnvExample/MuonReadRDO_jobOptions.py") if DetFlags.makeRIO.Muon_on(): include("MuonRecExample/MuonRDO_to_PRD_jobOptions.py") ### add PRD -> xAOD if (rec.readRDO() or rec.readESD()) and muonRecFlags.prdToxAOD(): from AthenaCommon import CfgMgr topSequence += CfgMgr.MDT_PrepDataToxAOD() topSequence += CfgMgr.RPC_PrepDataToxAOD() topSequence += CfgMgr.TGC_PrepDataToxAOD() topSequence += CfgMgr.CSC_PrepDataToxAOD() if muonRecFlags.doCreateClusters(): topSequence += CfgMgr.RPC_PrepDataToxAOD( "RPC_ClusterToxAOD", InputContainerName="RPC_Clusters") topSequence += CfgMgr.TGC_PrepDataToxAOD( "TGC_ClusterToxAOD", InputContainerName="TGC_Clusters") ### add RPC RDO -> xAOD if (rec.readRDO() or rec.readESD()) and muonRecFlags.rpcRawToxAOD(): from AthenaCommon import CfgMgr
treatException("Could not set up combined muon reconstruction. Switched off !") rec.doMuonCombined = False # # functionality : add cells crossed by high pt ID tracks # if rec.doESD() and recAlgs.doTrackParticleCellAssociation(): from AthenaCommon.CfgGetter import getPublicTool getPublicTool("MuonCombinedInDetDetailedTrackSelectorTool") topSequence += CfgMgr.TrackParticleCellAssociationAlg("TrackParticleCellAssociationAlg") # # functionality : energy flow # pdr.flag_domain('eflow') if recAlgs.doEFlow() and ( rec.readESD() or ( DetFlags.haveRIO.ID_on() and DetFlags.haveRIO.Calo_allOn() ) ) : try: include( "eflowRec/eflowRec_jobOptions.py" ) except Exception: treatException("Could not set up EFlow. Switched off !") recAlgs.doEFlow=False else: recAlgs.doEFlow=False # Calo extrapolation try: from eflowRec.eflowRecConf import eflowTrackCaloExtensionTool TrackCaloExtensionTool=eflowTrackCaloExtensionTool() except: mlog.error("could not import eflowRec.eflowTrackCaloExtensionTool") print traceback.format_exc()