diff --git a/Control/AthenaConfiguration/python/AllConfigFlags.py b/Control/AthenaConfiguration/python/AllConfigFlags.py
index d32177d7f16cd7f24ccc23fbee3382b137e98342..e95b330c3b2c496958056845454a91b83ae111e1 100644
--- a/Control/AthenaConfiguration/python/AllConfigFlags.py
+++ b/Control/AthenaConfiguration/python/AllConfigFlags.py
@@ -167,6 +167,11 @@ def _createCfgFlags():
return createPFConfigFlags()
_addFlagsCategory(acf,"PF",__pflow, 'eflowRec')
+ def __met():
+ from METReconstruction.METConfigFlags import createMETConfigFlags
+ return createMETConfigFlags()
+ _addFlagsCategory(acf,"MET",__met, 'METReconstruction')
+
def __btagging():
from BTagging.BTaggingConfigFlags import createBTaggingConfigFlags
return createBTaggingConfigFlags()
diff --git a/Reconstruction/MET/METReconstruction/python/METCfg_Track.py b/Reconstruction/MET/METReconstruction/python/METCfg_Track.py
new file mode 100644
index 0000000000000000000000000000000000000000..c4632924b4ae64466efcdb157f679f7c531756ff
--- /dev/null
+++ b/Reconstruction/MET/METReconstruction/python/METCfg_Track.py
@@ -0,0 +1,28 @@
+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+from METReconstruction.METRecoCfg import BuildConfig, RefConfig, METConfig,clusterSigStates,getMETRecoAlg
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+
+
+def METTrack_Cfg(configFlags):
+ sequencename = "METReconstruction_Track"
+
+ components = ComponentAccumulator()
+ from AthenaCommon.AlgSequence import AthSequencer
+ components.addSequence( AthSequencer(sequencename) )
+
+ cfg_trk = METConfig('Track',[BuildConfig('SoftTrk','Track')],
+ [RefConfig('TrackFilter','PVTrack')],
+ doTracks=configFlags.MET.UseTracks)
+
+ cfg_trk.refiners['TrackFilter'].DoLepRecovery=True
+ cfg_trk.refiners['TrackFilter'].DoVxSep=configFlags.MET.UseTracks
+ cfg_trk.refiners['TrackFilter'].DoEoverPSel=True
+ print "MET track helper object defined!!!"
+ print cfg_trk
+ recoAlg=getMETRecoAlg(sequencename,{'Track':cfg_trk})
+ print "ALG defined"
+ print recoAlg
+ components.addEventAlgo(recoAlg, sequencename)
+ return components
+
diff --git a/Reconstruction/MET/METReconstruction/python/METConfigFlags.py b/Reconstruction/MET/METReconstruction/python/METConfigFlags.py
new file mode 100644
index 0000000000000000000000000000000000000000..7d49987262b6b199d4fb8a0baad7abd42179f4e7
--- /dev/null
+++ b/Reconstruction/MET/METReconstruction/python/METConfigFlags.py
@@ -0,0 +1 @@
+# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
from AthenaConfiguration.AthConfigFlags import AthConfigFlags
def createMETConfigFlags():
metConfigFlags=AthConfigFlags()
metConfigFlags.addFlag("MET.UseTracks",True)
metConfigFlags.addFlag("MET.DoPFlow",True)
return metConfigFlags
diff --git a/Reconstruction/MET/METReconstruction/python/METRecoCfg.py b/Reconstruction/MET/METReconstruction/python/METRecoCfg.py
new file mode 100644
index 0000000000000000000000000000000000000000..5c02e426ef342d78946279ef5f32c945e743e03a
--- /dev/null
+++ b/Reconstruction/MET/METReconstruction/python/METRecoCfg.py
@@ -0,0 +1,327 @@
+# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+
+from AthenaCommon import CfgMgr
+
+#################################################################################
+# Define some default values
+
+clusterSigStates = {
+ 'EMScale':0,
+ 'LocHad':1,
+ 'Mod':1
+}
+
+defaultSelection = {
+ 'Ele':'Medium',
+ 'Gamma':'Tight',
+}
+
+defaultAuthor = {
+ 'Ele':17,
+ 'Gamma':20,
+}
+
+defaultInputKey = {
+ 'Ele' :'Electrons',
+ 'Gamma' :'Photons',
+ 'Tau' :'TauJets',
+ 'Jet' :'AntiKt4EMTopoJets',
+ 'Muon' :'Muons',
+ 'SoftTrk' :'InDetTrackParticles',
+ 'SoftClus' :'CaloCalTopoClusters',
+ 'SoftPFlow':'JetETMissNeutralParticleFlowObjects',
+ 'PrimaryVx':'PrimaryVertices',
+ 'Truth' :'TruthEvents',
+ 'Calo' :'AllCalo',
+ 'LCOCSoftClus':'LCOriginTopoClusters',
+ 'EMOCSoftClus':'EMOriginTopoClusters',
+ }
+
+defaultOutputKey = {
+ 'Ele' :'RefEle',
+ 'Gamma' :'RefGamma',
+ 'Tau' :'RefTau',
+ 'Jet' :'RefJet',
+ 'Muon' :'Muons',
+ 'SoftTrk' :'SoftTrk',
+ 'SoftClus' :'SoftClus',
+ 'SoftPFlow':'SoftPFlow',
+ 'Total' :'Final',
+ 'Truth' :'Truth',
+ 'Calo' :'Calo'
+ }
+
+prefix = 'METRecoConfig: '
+
+#################################################################################
+# Configuration of builders
+
+class BuildConfig:
+ def __init__(self,objType='',outputKey='',inputKey=''):
+ self.objType = objType
+ self.outputKey = outputKey
+ self.inputKey = inputKey
+
+def getBuilder(config,suffix,doTracks,doCells,doTriggerMET,doOriginCorrClus):
+ tool = None
+ # Construct tool and set defaults for case-specific configuration
+ if config.objType == 'Ele':
+ tool = CfgMgr.met__METElectronTool('MET_ElectronTool_'+suffix)
+ tool.PIDSel = defaultSelection['Ele']
+ tool.AuthorSel = defaultAuthor['Ele']
+ tool.DoTracks = doTracks
+ if config.objType == 'Gamma':
+ tool = CfgMgr.met__METPhotonTool('MET_PhotonTool_'+suffix)
+ tool.PIDSel = defaultSelection['Gamma']
+ tool.AuthorSel = defaultAuthor['Gamma']
+ tool.DoTracks = doTracks
+ if config.objType == 'Tau':
+ tool = CfgMgr.met__METTauTool('MET_TauTool_'+suffix)
+ tool.DoTracks = doTracks
+ if config.objType == 'Jet':
+ tool = CfgMgr.met__METJetTool('MET_JetTool_'+suffix)
+ tool.DoTracks = doTracks
+ if "EMTopo" in suffix:
+ tool.SignalState = clusterSigStates['EMScale']
+ else:
+ tool.SignalState = clusterSigStates['LocHad']
+ if config.objType == 'Muon':
+ tool = CfgMgr.met__METMuonTool('MET_MuonTool_'+suffix)
+ if config.objType == 'SoftTrk':
+ tool = CfgMgr.met__METSoftTermsTool('MET_SoftTrkTool_'+suffix)
+ tool.InputComposition = 'Tracks'
+ if config.objType.endswith('SoftClus'):
+ tool = CfgMgr.met__METSoftTermsTool('MET_SoftClusTool_'+suffix)
+ tool.InputComposition = 'Clusters'
+ if doOriginCorrClus:
+ tool.SignalState = clusterSigStates['Mod']
+ else:
+ tool.SignalState = clusterSigStates['LocHad']
+ if config.objType == 'SoftPFlow':
+ tool = CfgMgr.met__METSoftTermsTool('MET_SoftPFlowTool_'+suffix)
+ tool.InputComposition = 'PFlow'
+ pfotool = CfgMgr.CP__RetrievePFOTool('MET_PFOTool_'+suffix)
+ tool.PFOTool = pfotool
+ if suffix == 'Truth':
+ tool = CfgMgr.met__METTruthTool('MET_TruthTool_'+config.objType)
+ tool.InputComposition = config.objType
+ config.inputKey = defaultInputKey['Truth']
+ config.outputKey = config.objType
+ if suffix == 'Calo':
+ from CaloTools.CaloNoiseCondAlg import CaloNoiseCondAlg
+ CaloNoiseCondAlg ('totalNoise')
+ tool = CfgMgr.met__METCaloRegionsTool('MET_CaloRegionsTool')
+ if doCells:
+ tool.UseCells = True
+ tool.DoTriggerMET = doTriggerMET
+ config.inputKey = defaultInputKey['Calo']
+ else:
+ tool.UseCells = False
+ tool.DoTriggerMET = False
+ config.inputKey = defaultInputKey['SoftClus']
+ config.outputKey = config.objType
+
+ # set input/output key names
+ if config.inputKey == '':
+ tool.InputCollection = defaultInputKey[config.objType]
+ config.inputKey = tool.InputCollection
+ else:
+ tool.InputCollection = config.inputKey
+ if not suffix=='Calo':
+ if config.outputKey == '':
+ tool.MissingETKey = defaultOutputKey[config.objType]
+ config.outputKey = tool.MissingETKey
+ else:
+ tool.MissingETKey = config.outputKey
+ return tool
+
+#################################################################################
+# Configuration of refiners
+
+class RefConfig:
+ def __init__(self,myType='',outputKey=''):
+ self.type = myType
+ self.outputKey = outputKey
+
+def getRefiner(config,suffix,trkseltool=None,trkvxtool=None,trkisotool=None,caloisotool=None):
+ tool = None
+
+ if config.type == 'TrackFilter':
+ tool = CfgMgr.met__METTrackFilterTool('MET_TrackFilterTool_'+suffix)
+ tool.InputPVKey = defaultInputKey['PrimaryVx']
+ tool.TrackSelectorTool=trkseltool
+ tool.TrackVxAssocTool=trkvxtool
+ #
+ tool.UseIsolationTools = False #True
+ tool.TrackIsolationTool = trkisotool
+ tool.CaloIsolationTool = caloisotool
+ from METReconstruction.METRecoFlags import metFlags
+ tool.DoPVSel = metFlags.UseTracks()
+ tool.DoVxSep = metFlags.UseTracks()
+
+ if config.type == 'JetFilter':
+ tool = CfgMgr.met__METJetFilterTool('MET_JetFilterTool_'+suffix)
+ if config.type == 'MuonEloss':
+ tool = CfgMgr.met__METMuonElossTool('MET_MuonElossTool_'+suffix)
+ tool.MissingETKey = config.outputKey
+ return tool
+
+#################################################################################
+# Region tools are a special case of refiners
+
+def getRegions(config,suffix):
+ if suffix == 'Truth':
+ config.outputKey = config.objType
+ tool = CfgMgr.met__METRegionsTool('MET_'+config.outputKey+'Regions_'+suffix)
+ tool.InputMETContainer = 'MET_'+suffix
+ tool.InputMETMap = 'METMap_'+suffix
+ tool.InputMETKey = config.outputKey
+ tool.RegionValues = [ 1.5, 3.2, 10 ]
+ return tool
+
+#################################################################################
+# Top level MET configuration
+
+class METConfig:
+ def outputCollection(self):
+ return 'MET_'+self.suffix
+ #
+ def outputMap(self):
+ return 'METMap_'+self.suffix
+ #
+ def setupBuilders(self,buildconfigs):
+ print prefix, 'Setting up builders for MET config '+self.suffix
+ for config in buildconfigs:
+ if config.objType in self.builders:
+ print prefix, 'Config '+self.suffix+' already contains a builder of type '+config.objType
+ raise LookupError
+ else:
+ builder = getBuilder(config,self.suffix,self.doTracks,self.doCells,
+ self.doTriggerMET,self.doOriginCorrClus)
+ self.builders[config.objType] = builder
+ self.buildlist.append(builder)
+ print prefix, ' Added '+config.objType+' tool named '+builder.name()
+ #
+ def setupRefiners(self,refconfigs):
+ print prefix, 'Setting up refiners for MET config '+self.suffix
+ for config in refconfigs:
+ # need to enforce this?
+ if config.type in self.refiners:
+ print 'Config '+self.suffix+' already contains a refiner of type '+config.type
+ raise LookupError
+ else:
+ refiner = getRefiner(config=config,suffix=self.suffix,
+ trkseltool=self.trkseltool,trkvxtool=self.trkvxtool,
+ trkisotool=self.trkisotool,caloisotool=self.caloisotool)
+ self.refiners[config.type] = refiner
+ self.reflist.append(refiner)
+ print prefix, ' Added '+config.type+' tool named '+refiner.name()
+ #
+ def setupRegions(self,buildconfigs):
+ print prefix, 'Setting up regions for MET config '+self.suffix
+ for config in buildconfigs:
+ if config.objType in self.regions:
+ print prefix, 'Config '+self.suffix+' already contains a region tool of type '+config.objType
+ raise LookupError
+ else:
+ regions = getRegions(config,self.suffix)
+ self.regions[config.objType] = regions
+ self.reglist.append(regions)
+ print prefix, ' Added '+config.objType+' region tool named '+regions.name()
+ #
+ def __init__(self,suffix,buildconfigs=[],refconfigs=[],
+ doTracks=False,doSum=False,doRegions=False,
+ doCells=False,doTriggerMET=True,duplicateWarning=True,
+ doOriginCorrClus=False):
+ print prefix, 'Creating MET config \''+suffix+'\''
+ self.suffix = suffix
+ self.doSum = doSum
+ self.doTracks = doTracks
+ self.doRegions = doRegions
+ self.doCells = doCells,
+ self.doOriginCorrClus = doOriginCorrClus
+ self.doTriggerMET = doTriggerMET
+ self.duplicateWarning = duplicateWarning
+ #
+ self.builders = {}
+ self.buildlist = [] # need an ordered list
+ #
+ self.refiners = {}
+ self.reflist = [] # need an ordered list
+ #
+ self.regions = {}
+ self.reglist = [] # need an ordered list
+ if doRegions:
+ self.setupRegions(buildconfigs)
+ #
+ self.trkseltool=CfgMgr.InDet__InDetTrackSelectionTool("IDTrkSel_MET",
+ CutLevel="TightPrimary",
+ maxZ0SinTheta=3,
+ maxD0=2,
+ minPt=500)
+ #
+ self.trkvxtool=CfgMgr.CP__LooseTrackVertexAssociationTool("LooseTrackVertexAssociationTool_MET")
+ #self.trkvxtool=CfgMgr.CP__TightTrackVertexAssociationTool("TightTrackVertexAssociationTool_MET", dzSinTheta_cut=3, doPV=False)
+ #
+ self.trkisotool = CfgMgr.xAOD__TrackIsolationTool("TrackIsolationTool_MET")
+ self.trkisotool.TrackSelectionTool = self.trkseltool # As configured above
+ #
+ from TrackToCalo.TrackToCaloConf import Trk__ParticleCaloExtensionTool, Rec__ParticleCaloCellAssociationTool
+ from TrkExTools.AtlasExtrapolator import AtlasExtrapolator
+ CaloExtensionTool= Trk__ParticleCaloExtensionTool(Extrapolator = AtlasExtrapolator())
+ CaloCellAssocTool = Rec__ParticleCaloCellAssociationTool(ParticleCaloExtensionTool = CaloExtensionTool)
+ self.caloisotool = CfgMgr.xAOD__CaloIsolationTool("CaloIsolationTool_MET",
+ saveOnlyRequestedCorrections=True,
+ addCaloExtensionDecoration=False,
+ ParticleCaloExtensionTool = CaloExtensionTool,
+ ParticleCaloCellAssociationTool = CaloCellAssocTool)
+
+ self.setupBuilders(buildconfigs)
+ self.setupRefiners(refconfigs)
+
+# Set up a top-level tool with mostly defaults
+def getMETRecoTool(topconfig):
+ recoTool = CfgMgr.met__METRecoTool('MET_RecoTool_'+topconfig.suffix,
+ METBuilders = topconfig.buildlist,
+ METRefiners = topconfig.reflist,
+ METContainer = topconfig.outputCollection(),
+ METComponentMap = topconfig.outputMap(),
+ WarnIfDuplicate = topconfig.duplicateWarning,
+ TimingDetail=0)
+ if topconfig.doSum:
+ recoTool.METFinalName = defaultOutputKey['Total']
+
+ return recoTool
+
+# Set up a METRecoTool that builds MET regions
+def getRegionRecoTool(topconfig):
+ regTool = CfgMgr.met__METRecoTool('MET_RegionTool_'+topconfig.suffix,
+ METBuilders = [],
+ METRefiners = topconfig.reglist,
+ METContainer = topconfig.outputCollection()+'Regions',
+ METComponentMap = topconfig.outputMap()+'Regions',
+ WarnIfDuplicate = topconfig.duplicateWarning)
+ return regTool
+
+# Allow user to configure reco tools directly or get more default configurations
+def getMETRecoAlg(algName='METReconstruction',configs={},tools=[]):
+
+ recoTools = []
+ recoTools += tools
+ print 'Setting up MET Reconstruction'
+ for key,conf in configs.iteritems():
+ print prefix, 'Generate METRecoTool for MET_'+key
+ recotool = getMETRecoTool(conf)
+ print recotool
+ recoTools.append(recotool)
+ #metFlags.METRecoTools()[key] = recotool
+ if conf.doRegions:
+ regiontool = getRegionRecoTool(conf)
+ recoTools.append(regiontool)
+ print "Added region tool"
+ for tool in recoTools:
+ print prefix, 'Added METRecoTool \''+tool.name()+'\' to alg '+algName
+
+ recoAlg = CfgMgr.met__METRecoAlg(name=algName,
+ RecoTools=recoTools)
+ return recoAlg
diff --git a/Reconstruction/MET/METReconstruction/share/METRecConfig.py b/Reconstruction/MET/METReconstruction/share/METRecConfig.py
index 8514a2ee01199165a170e0ad8cf8c32fd9a74a2d..c4da387f84e215d637bd75dabd6e0ca15b6c63af 100644
--- a/Reconstruction/MET/METReconstruction/share/METRecConfig.py
+++ b/Reconstruction/MET/METReconstruction/share/METRecConfig.py
@@ -1 +1 @@
-from AthenaCommon import Logging
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
if __name__=="__main__":
# Setting needed for the ComponentAccumulator to do its thing
from AthenaCommon.Configurable import Configurable
Configurable.configurableRun3Behavior=True
# Set message levels
from AthenaCommon import Constants
msgLvl = "INFO"
from AthenaCommon.Logging import log
log.setLevel(msgLvl)
# Config flags steer the job at various levels
from AthenaConfiguration.AllConfigFlags import ConfigFlags
ConfigFlags.Input.isMC = True
ConfigFlags.Input.Files = ["/cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/ASG/mc16_13TeV.410501.PowhegPythia8EvtGen_A14_ttbar_hdamp258p75_nonallhad.merge.AOD.e5458_s3126_r9364_r9315/AOD.11182705._000001.pool.root.1"]
# Flags relating to multithreaded execution
nthreads=0
ConfigFlags.Concurrency.NumThreads =nthreads
if nthreads>0:
ConfigFlags.Concurrency.NumThreads = 1
ConfigFlags.Concurrency.NumConcurrentEvents = 1
ConfigFlags.lock()
# Get a ComponentAccumulator setting up the fundamental Athena job
from AthenaConfiguration.MainServicesConfig import MainServicesThreadedCfg
cfg=MainServicesThreadedCfg(ConfigFlags)
# Add the components for reading in pool files
from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
cfg.merge(PoolReadCfg(ConfigFlags))
# Get Jet Inputs
from JetRecConfig.StandardJetDefs import EMTopoOrigin, LCTopoOrigin, CHSPFlow
from JetRecConfig import JetRecConfig
cfg1 = JetRecConfig.JetInputCfg( [EMTopoOrigin], ConfigFlags)
cfg1.printConfig()
cfg.merge( cfg1 )
cfg2 = JetRecConfig.JetInputCfg( [LCTopoOrigin], ConfigFlags)
cfg2.printConfig()
cfg.merge( cfg2 )
cfg3 = JetRecConfig.JetInputCfg( [CHSPFlow], ConfigFlags)
cfg3.printConfig()
cfg.merge( cfg3 )
# Start by just trying to add in MET Reconstruction based on METReconstruction_jobOptions.py
from METReconstruction.METRecoFlags import metFlags
# from AthenaCommon.BeamFlags import jobproperties NO LONGER ALLOWED
# from RecExConfig.RecFlags import rec NO LONGER ALLOWED
#NEED TO CHANGE THIS TO DEPEND ON ConfigFlags.Beam.Type => for now ignore
"""
if jobproperties.Beam.beamType == 'cosmics' or jobproperties.Beam.beamType == 'singlebeam' or not rec.doInDet():
metFlags.UseTracks.set_Value(False)
metFlags.DoPFlow.set_Value(False)
print "METReconstruction_jobOptions: detected cosmics/single-beam configuration -- switch off track-based MET reco"
"""
# TJ: Best to start each of these from scratch as a new CA module,
# Can e.g. make files called METCaloConfig.py that just put the
# old alg into a CA.
# Rather than have N reco tools that get thrown into one alg later,
# have each CA generate its own METRecoAlg and add this to the sequence.
"""
import METReconstruction.METConfig_Calo
import METReconstruction.METConfig_Track
if rec.doTruth():
import METReconstruction.METConfig_Truth
from METReconstruction.METRecoConfig import getMETRecoAlg
print "PICKING UP CHANGES"
metAlg = getMETRecoAlg('METReconstruction')
"""
# Probably want to define one CA each for EMTopo, LCTopo and PFlow,
# then have a higher level one that merges in all three,
# then the top-level (i.e. this) can just pull in the all-associators CA
"""
components_metAlg = ComponentAccumulator()
from AthenaCommon.AlgSequence import AthSequencer
components_metAlg.addSequence( AthSequencer('METReconstruction') ) #technically don't need a new sequence name for it
components_metAlg.addEventAlgo(metAlg,'METReconstruction')
cfg.merge(components_metAlg)
# Set up default configurations
import METReconstruction.METConfig_Associator
from METReconstruction.METAssocConfig import getMETAssocAlg
# Get the configuration directly from METRecoFlags
# Can also provide a dict of configurations or list of RecoTools or both
assocAlg = getMETAssocAlg('METAssociation')
components_assocAlg = ComponentAccumulator()
components_assocAlg.addSequence(AthSequencer('METAssociation') )
components_assocAlg.addEventAlgo(assocAlg,'METAssociation')
cfg.merge(components_assocAlg)
from METUtilities.METMakerConfig import getMETMakerAlg
for key,conf in metFlags.METAssocConfigs().iteritems():
if not conf.doTruth:
makerAlg = getMETMakerAlg(conf.suffix)
components_makerAlg=ComponentAccumulator()
components_makerAlg.addSequence(AthSequencer(conf.suffix) )
components_makerAlg.addEventAlgo(makerAlg,conf.suffix)
cfg.merge(components_makerAlg)
"""
print "Running final component accumulator"
cfg.printConfig()
cfg.run(maxEvents=10)
\ No newline at end of file
+from AthenaCommon import Logging
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
if __name__=="__main__":
# Setting needed for the ComponentAccumulator to do its thing
from AthenaCommon.Configurable import Configurable
Configurable.configurableRun3Behavior=True
# Set message levels
from AthenaCommon import Constants
msgLvl = "INFO"
from AthenaCommon.Logging import log
log.setLevel(msgLvl)
# Config flags steer the job at various levels
from AthenaConfiguration.AllConfigFlags import ConfigFlags
ConfigFlags.Input.isMC = True
ConfigFlags.Input.Files = ["/cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/ASG/mc16_13TeV.410501.PowhegPythia8EvtGen_A14_ttbar_hdamp258p75_nonallhad.merge.AOD.e5458_s3126_r9364_r9315/AOD.11182705._000001.pool.root.1"]
# Flags relating to multithreaded execution
nthreads=0
ConfigFlags.Concurrency.NumThreads =nthreads
if nthreads>0:
ConfigFlags.Concurrency.NumThreads = 1
ConfigFlags.Concurrency.NumConcurrentEvents = 1
if ConfigFlags.Beam.Type == 'cosmics' or ConfigFlags.Beam.Type == 'singlebeam':# used to have " or not rec.doInDet()" on the end
ConfigFlags.MET.UseTracks=False
ConfigFlags.MET.DoPFlow=False
print "METReconstruction_jobOptions: detected cosmics/single-beam configuration -- switch off track-based MET reco"
ConfigFlags.lock()
# Get a ComponentAccumulator setting up the fundamental Athena job
from AthenaConfiguration.MainServicesConfig import MainServicesThreadedCfg
cfg=MainServicesThreadedCfg(ConfigFlags)
# Add the components for reading in pool files
from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
cfg.merge(PoolReadCfg(ConfigFlags))
print "CHECKPOINT 1"
# Get Jet Inputs
from JetRecConfig.StandardJetDefs import EMTopoOrigin, LCTopoOrigin, CHSPFlow
from JetRecConfig import JetRecConfig
cfg1 = JetRecConfig.JetInputCfg( [EMTopoOrigin], ConfigFlags)
cfg1.printConfig()
cfg.merge( cfg1 )
cfg2 = JetRecConfig.JetInputCfg( [LCTopoOrigin], ConfigFlags)
cfg2.printConfig()
cfg.merge( cfg2 )
cfg3 = JetRecConfig.JetInputCfg( [CHSPFlow], ConfigFlags)
cfg3.printConfig()
cfg.merge( cfg3 )
print "CHECKPOINT 2"
from METReconstruction.METCfg_Track import METTrack_Cfg
cfg4=METTrack_Cfg(ConfigFlags)
cfg4.printConfig()
cfg.merge(cfg4)
# Start by just trying to add in MET Reconstruction based on METReconstruction_jobOptions.py
#from METReconstruction.METRecoFlags import metFlags
# from AthenaCommon.BeamFlags import jobproperties NO LONGER ALLOWED
# from RecExConfig.RecFlags import rec NO LONGER ALLOWED
#NEED TO CHANGE THIS TO DEPEND ON ConfigFlags.Beam.Type => for now ignore
# TJ: Best to start each of these from scratch as a new CA module,
# Can e.g. make files called METCaloConfig.py that just put the
# old alg into a CA.
# Rather than have N reco tools that get thrown into one alg later,
# have each CA generate its own METRecoAlg and add this to the sequence.
"""
import METReconstruction.METConfig_Calo
import METReconstruction.METConfig_Track
if rec.doTruth():
import METReconstruction.METConfig_Truth
from METReconstruction.METRecoConfig import getMETRecoAlg
print "PICKING UP CHANGES"
metAlg = getMETRecoAlg('METReconstruction')
"""
# Probably want to define one CA each for EMTopo, LCTopo and PFlow,
# then have a higher level one that merges in all three,
# then the top-level (i.e. this) can just pull in the all-associators CA
"""
components_metAlg = ComponentAccumulator()
from AthenaCommon.AlgSequence import AthSequencer
components_metAlg.addSequence( AthSequencer('METReconstruction') ) #technically don't need a new sequence name for it
components_metAlg.addEventAlgo(metAlg,'METReconstruction')
cfg.merge(components_metAlg)
# Set up default configurations
import METReconstruction.METConfig_Associator
from METReconstruction.METAssocConfig import getMETAssocAlg
# Get the configuration directly from METRecoFlags
# Can also provide a dict of configurations or list of RecoTools or both
assocAlg = getMETAssocAlg('METAssociation')
components_assocAlg = ComponentAccumulator()
components_assocAlg.addSequence(AthSequencer('METAssociation') )
components_assocAlg.addEventAlgo(assocAlg,'METAssociation')
cfg.merge(components_assocAlg)
from METUtilities.METMakerConfig import getMETMakerAlg
for key,conf in metFlags.METAssocConfigs().iteritems():
if not conf.doTruth:
makerAlg = getMETMakerAlg(conf.suffix)
components_makerAlg=ComponentAccumulator()
components_makerAlg.addSequence(AthSequencer(conf.suffix) )
components_makerAlg.addEventAlgo(makerAlg,conf.suffix)
cfg.merge(components_makerAlg)
"""
print "Running final component accumulator"
cfg.printConfig()
cfg.run(maxEvents=10)
\ No newline at end of file