def runTest(self):
destinationCA = ComponentAccumulator()
destinationCA.addSequence(seqAND("dest"))
sourceCA = ComponentAccumulator()
sourceCA.addEventAlgo(TestAlgo("alg1"))
sourceCA.addEventAlgo(TestAlgo("alg2"))
sourceCA.addSequence(seqAND("innerSeq"))
sourceCA.addEventAlgo(TestAlgo("alg3"), sequenceName="innerSeq")
destinationCA.merge(sourceCA, sequenceName="dest")
#destinationCA.merge( sourceCA )
self.assertIsNotNone(
findAlgorithm(destinationCA.getSequence("dest"), "alg1"),
"Algorithm not placed in sub-sequence")
self.assertIsNotNone(
findSubSequence(destinationCA.getSequence(), "innerSeq"),
"The sequence is not added")
self.assertIsNotNone(
findAlgorithm(destinationCA.getSequence("dest"), "alg3"),
"Algorithm deep in thesource CA not placed in sub-sequence of destiantion CA"
)
destinationCA.wasMerged()
sourceCA.wasMerged()
def JetCopyAlgCfg(ConfigFlags, buildjetsname, copyjetsname):
copycfg = ComponentAccumulator()
# Create a sequence that holds a set of algorithms
# -- mainly for understanding how chunks of the job
# relate to each other
sequencename = "JetCopySeq"
copycfg.addSequence(CompFactory.AthSequencer(sequencename))
# Create the JetCopier, set some standard options
jcopy = CompFactory.JetCopier("copier")
jcopy.InputJets = buildjetsname
# Add a simple jet modifier to the JetRecAlg
jclsmoms = CompFactory.JetClusterMomentsTool("clsmoms",
JetContainer=copyjetsname)
# Create the JetRecAlg, configure it to use the copier
# using constructor syntax instead
# (equivalent to setting properties with "=")
jra = CompFactory.JetRecAlg(
"JRA_copy",
Provider=jcopy, # Single ToolHandle
Modifiers=[jclsmoms], # ToolHandleArray
OutputContainer=copyjetsname)
# Add the alg to the ComponentAccumulator in the named sequence
copycfg.addEventAlgo(jra, sequencename)
return copycfg
def JetGroomAlgCfg(ConfigFlags, buildjetsname, groomjetsname):
groomcfg = ComponentAccumulator()
# Create a sequence that holds a set of algorithms
# -- mainly for understanding how chunks of the job
# relate to each other
sequencename = "JetGroomSeq"
groomcfg.addSequence(CompFactory.AthSequencer(sequencename))
# Create the JetGroomer, provide it with a JetTrimmer
jtrim = CompFactory.JetTrimming("trimSmallR2Frac5", RClus=0.2, PtFrac=0.05)
jtrim.UngroomedJets = buildjetsname
jtrim.ParentPseudoJets = "PseudoJetMerged_" + buildjetsname
# Create the JetRecAlg, configure it to use the builder
# using constructor syntax instead
# (equivalent to setting properties with "=")
jra = CompFactory.JetRecAlg(
"JRA_trim",
Provider=jtrim, # Single ToolHandle
Modifiers=[], # ToolHandleArray
OutputContainer=groomjetsname)
# Add the alg to the ComponentAccumulator in the named sequence
groomcfg.addEventAlgo(jra, sequencename)
return groomcfg
def JetGroomCfg(groomdef, configFlags, jetnameprefix="",jetnamesuffix=""):
jetsfullname = jetnameprefix+groomdef.basename+jetnamesuffix+"Jets"
jetlog.info("Setting up to find {0}".format(jetsfullname))
sequencename = jetsfullname
components = ComponentAccumulator()
from AthenaCommon.AlgSequence import AthSequencer
components.addSequence( AthSequencer(sequencename) )
# Check if the ungroomed jets exist in the input file.
# If not, we need to configure their reconstruction.
filecontents = configFlags.Input.Collections
if groomdef.ungroomedname not in filecontents:
from . import JetRecCfg
components.merge(JetRecCfg(groomdef.ungroomeddef, configFlags,
jetnameoverride=groomdef.ungroomedname))
else:
# FIXME: Need to schedule rebuilding of pseudojets
pass
# FIXME: Add calls to JetModConfig.getFinalModifierListAndPrereqs
components.addEventAlgo(getJetGroomAlg(jetsfullname,groomdef,groomdef.modifiers))
return components
def RunHighLevelTaggersCfg(inputFlags, JetCollection, Associator, TrainingMaps,
TimeStamp):
result = ComponentAccumulator()
AthSequencer = CompFactory.AthSequencer
BTagCollection = inputFlags.BTagging.OutputFiles.Prefix + JetCollection
sequenceName = BTagCollection + "_HLTaggers"
if TimeStamp:
BTagCollection += '_' + TimeStamp
sequenceName += '_' + TimeStamp
HLBTagSeq = AthSequencer(sequenceName, Sequential=True)
result.addSequence(HLBTagSeq)
result.merge(
BTagHighLevelAugmenterAlgCfg(inputFlags,
JetCollection=JetCollection,
BTagCollection=BTagCollection,
Associator=Associator,
sequenceName=sequenceName))
for dl2 in TrainingMaps:
result.merge(
HighLevelBTagAlgCfg(inputFlags, BTagCollection,
'InDetTrackParticles', dl2, sequenceName))
return result
def selfSequence():
from AthenaCommon.CFElements import seqAND
accTop = ComponentAccumulator()
accTop.wasMerged()
seq1 = seqAND("seq1")
seq1_again = seqAND("seq1")
accTop.addSequence(seq1)
accTop.addSequence(seq1_again, parentName="seq1")
def setUp(self):
# trivial case without any nested sequences
log.setLevel(DEBUG)
dummyCfgFlags = AthConfigFlags()
dummyCfgFlags.lock()
def AlgsConf1(flags):
acc = ComponentAccumulator()
a1 = TestAlgo("Algo1")
a2 = TestAlgo("Algo2")
return acc, [a1, a2]
def AlgsConf2(flags):
acc = ComponentAccumulator()
result, algs = AlgsConf1(flags)
acc.merge(result)
a = TestAlgo("Algo3")
print("algo3 when created %s" % id(a))
algs.append(a)
return acc, algs
acc = ComponentAccumulator()
# top level algs
acc1, algs = AlgsConf2(dummyCfgFlags)
acc.merge(acc1)
acc.addEventAlgo(algs)
def AlgsConf3(flags):
acc = ComponentAccumulator()
na1 = TestAlgo("NestedAlgo1")
return acc, na1
def AlgsConf4(flags):
acc, na1 = AlgsConf3(flags)
NestedAlgo2 = TestAlgo("NestedAlgo2")
NestedAlgo2.OutputLevel = 7
return acc, na1, NestedAlgo2
acc.addSequence(seqAND("Nest"))
acc.addSequence(seqAND("subSequence1"), parentName="Nest")
acc.addSequence(parOR("subSequence2"), parentName="Nest")
acc.addSequence(seqAND("sub2Sequence1"), parentName="subSequence1")
acc.addSequence(seqAND("sub3Sequence1"), parentName="subSequence1")
acc.addSequence(seqAND("sub4Sequence1"), parentName="subSequence1")
accNA1 = AlgsConf4(dummyCfgFlags)
acc.merge(accNA1[0])
acc.addEventAlgo(accNA1[1:], "sub2Sequence1")
outf = open("testFile.pkl", "wb")
acc.store(outf)
outf.close()
self.acc = acc
def JetInputCfg(ConfigFlags):
inputcfg = ComponentAccumulator()
# Create a sequence that holds a set of algorithms
# -- mainly for understanding how chunks of the job
# relate to each other
sequencename = "JetInputSeq"
inputcfg.addSequence(CompFactory.AthSequencer(sequencename))
from xAODBase.xAODType import xAODType
# Apply some corrections to the topoclusters
# Example with property assignments
jetmodseq = CompFactory.JetConstituentModSequence("JetMod_LCOrigin")
jetmodseq.InputType = xAODType.CaloCluster
jetmodseq.InputContainer = "CaloCalTopoClusters"
jetmodseq.OutputContainer = "LCOriginTopoClusters"
# Build the list of modifiers to run
# Configuration with constructor keywords
modlist = [
CompFactory.CaloClusterConstituentsOrigin(
"ClusterOrigin", InputType=xAODType.CaloCluster)
]
jetmodseq.Modifiers = modlist
# We need a JetAlgorithm to run the modseq, which is a tool
jetmodalg = CompFactory.JetAlgorithm("JetModAlg_LCOrigin",
Tools=[jetmodseq])
# Add the alg to the sequence in the ComponentAccumulator
inputcfg.addEventAlgo(jetmodalg, sequencename)
# Create a PseudoJetAlgorithm
constitpjgalg = CompFactory.PseudoJetAlgorithm(
"pjgalg_LCTopo",
InputContainer="LCOriginTopoClusters",
OutputContainer="PseudoJetLCTopo",
Label="LCTopo",
SkipNegativeEnergy=True)
ghostpjgalg = CompFactory.PseudoJetAlgorithm(
"pjgalg_GhostTruth",
InputContainer="TruthParticles",
OutputContainer="PseudoJetGhostTruth",
Label="GhostTruth",
SkipNegativeEnergy=True)
pjcs = [constitpjgalg.OutputContainer, ghostpjgalg.OutputContainer]
# Add the algs to the sequence in the ComponentAccumulator
inputcfg.addEventAlgo(constitpjgalg, sequencename)
inputcfg.addEventAlgo(ghostpjgalg, sequencename)
return inputcfg, pjcs
def getAssocCA(config, sequencename='METAssociation', METName=''):
components = ComponentAccumulator()
from AthenaConfiguration.ComponentFactory import CompFactory
AthSequencer = CompFactory.AthSequencer
components.addSequence(AthSequencer(sequencename))
assocAlg = getMETAssocAlg(algName='METAssociation_' + METName,
configs={config.suffix: config})
components.addEventAlgo(assocAlg, sequencename)
if not METName == '':
makerAlg = getMETMakerAlg(METName)
components.addEventAlgo(makerAlg, sequencename)
return components
def JetBuildAlgCfg(ConfigFlags, buildjetsname):
buildcfg = ComponentAccumulator()
# Create a sequence that holds a set of algorithms
# -- mainly for understanding how chunks of the job
# relate to each other
sequencename = "JetBuildSeq"
buildcfg.addSequence(CompFactory.AthSequencer(sequencename))
# Merge in config to get jet inputs
inputcfg, pjcs = JetInputCfg(ConfigFlags)
buildcfg.merge(inputcfg)
# Create a merger to build the PseudoJetContainer for this specific jet collection
mergepjalg = CompFactory.PseudoJetMerger(
"pjmergealg_" + buildjetsname,
InputPJContainers=pjcs,
OutputContainer="PseudoJetMerged_" + buildjetsname)
buildcfg.addEventAlgo(mergepjalg)
# Create the JetClusterer, set some standard options
jclust = CompFactory.JetClusterer("builder")
jclust.JetAlgorithm = "AntiKt"
jclust.JetRadius = 1.0
jclust.PtMin = 10e3 # MeV
jclust.InputPseudoJets = "PseudoJetMerged_" + buildjetsname
jclust.JetInputType = 1 # Hardcoded "magic number" for now
# See https://gitlab.cern.ch/atlas/athena/blob/master/Event/xAOD/xAODJet/xAODJet/JetContainerInfo.h
# This should get its own dictionary.
# Add a simple jet modifier to the JetRecAlg
jclsmoms = CompFactory.JetClusterMomentsTool("clsmoms",
JetContainer=buildjetsname)
# Create the JetRecAlg, configure it to use the builder
# using constructor syntax instead
# (equivalent to setting properties with "=")
jra = CompFactory.JetRecAlg(
"JRA_build",
Provider=jclust, # Single ToolHandle
Modifiers=[jclsmoms], # ToolHandleArray
OutputContainer=buildjetsname)
# Add the alg to the ComponentAccumulator in the named sequence
buildcfg.addEventAlgo(jra, sequencename)
return buildcfg
def runTest(self):
# replicate HLT issue, it occured because the sequnces were recorded in the order of storing in the dict and thus the
# some of them (in this case hltSteps) did not have properties recorded
acc = ComponentAccumulator()
acc.addSequence(seqOR("hltTop"))
algos2 = TestAlgo("RecoAlgInTop")
acc.addEventAlgo(algos2, sequenceName="hltTop") # some algo
acc.addSequence(seqAND("hltSteps"), parentName="hltTop")
acc.addSequence(parOR("hltStep_1"), parentName="hltSteps")
acc.addSequence(seqAND("L2CaloEgammaSeq"), "hltStep_1")
acc.addSequence(parOR("hltStep_2"), parentName="hltSteps")
acc.moveSequence("L2CaloEgammaSeq", "hltStep_2")
fout = open("testFile2.pkl", "wb")
acc.store(fout)
fout.close()
def METTrack_Cfg(configFlags):
sequencename = "METReconstruction_Track"
components = ComponentAccumulator()
from AthenaConfiguration.ComponentFactory import CompFactory
AthSequencer = CompFactory.AthSequencer
components.addSequence(AthSequencer(sequencename))
cfg_trk = METConfig('Track',
configFlags, [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
recoAlg = getMETRecoAlg(algName='METRecoAlg_Track',
configs={"Track": cfg_trk})
components.addEventAlgo(recoAlg, sequencename)
return components
def skip_test_sequences_merging(self):
from AthenaConfiguration.AllConfigFlags import ConfigFlags
ConfigFlags.lock()
from AthenaCommon.Logging import logging
logging.getLogger('ComponentAccumulator').setLevel(DEBUG)
print("ca1")
ca1 = ComponentAccumulator()
ca1.addEventAlgo(TestAlgo("alg1"))
ca1.printConfig()
ca1.addSequence(seqAND("someSequence"))
print("ca2")
from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
ca2 = OutputStreamCfg(ConfigFlags,
"RDO",
ItemList=[
"SCT_RDO_Container#SCT_RDOs",
"InDetSimDataCollection#SCT_SDO_Map"
])
ca2.printConfig()
print("after merge")
ca1.merge(ca2)
ca1.printConfig()
self.assertEqual(len(ca1._allSequences), 2,
"Dangling sequences not maintained")
print("Instantiating top CA")
from AthenaConfiguration.MainServicesConfig import MainServicesCfg
topca = MainServicesCfg(ConfigFlags)
topca.printConfig()
print("Merging to the top level CA")
topca.merge(ca1)
topca.printConfig()
topca.wasMerged()
def METCalo_Cfg(configFlags):
sequencename = "METReconstruction_Calo"
components = ComponentAccumulator()
from AthenaConfiguration.ComponentFactory import CompFactory
AthSequencer = CompFactory.AthSequencer
components.addSequence(AthSequencer(sequencename))
############################################################################
# EMTopo
cfg_emt = METConfig('EMTopo',
configFlags, [BuildConfig('SoftClus', 'EMTopo')],
doRegions=True,
doOriginCorrClus=False)
############################################################################
# LocHadTopo
cfg_lht = METConfig('LocHadTopo',
configFlags, [BuildConfig('SoftClus', 'LocHadTopo')],
doRegions=True,
doOriginCorrClus=False)
############################################################################
# Calo regions
#SWITCH OFF CELLS WHEN RUNNING ON AOD
cfg_calo = METConfig('Calo',
configFlags, [BuildConfig('CaloReg')],
doCells=False)
recoAlg_calo = getMETRecoAlg(algName='METRecoAlg_Calo',
configs={
"EMTopo": cfg_emt,
"LocHadTopo": cfg_lht,
"Calo": cfg_calo
})
components.addEventAlgo(recoAlg_calo, sequencename)
return components
def selfMergedGrandParentSequence():
from AthenaCommon.CFElements import seqAND
acc1 = ComponentAccumulator()
acc1.wasMerged()
acc1.addSequence(seqAND("seq1"))
acc2 = ComponentAccumulator()
acc2.wasMerged()
acc2.addSequence(seqAND("seq2"))
acc2.addSequence(seqAND("seq1"), parentName="seq2")
acc1.merge(acc2, sequenceName="seq1")
def runTest(self):
# test if an algorithm (or sequence) can be controlled by more than one sequence
accTop = ComponentAccumulator()
recoSeq = seqAND("seqReco")
recoAlg = TestAlgo("recoAlg")
recoSeq.Members.append(recoAlg)
acc1 = ComponentAccumulator()
acc1.addSequence(seqAND("seq1"))
acc1.addSequence(recoSeq, parentName="seq1")
acc2 = ComponentAccumulator()
acc2.addSequence(seqAND("seq2"))
acc2.addSequence(recoSeq, parentName="seq2")
accTop.merge(acc1)
accTop.merge(acc2)
accTop.printConfig()
self.assertIsNotNone(
findAlgorithm(accTop.getSequence("seq1"), "recoAlg"),
"Algorithm missing in the first sequence")
self.assertIsNotNone(
findAlgorithm(accTop.getSequence("seq2"), "recoAlg"),
"Algorithm missing in the second sequence")
s = accTop.getSequence("seqReco")
self.assertEqual(
len(s.Members), 1,
"Wrong number of algorithms in reco seq: %d " % len(s.Members))
self.assertIs(findAlgorithm(accTop.getSequence("seq1"), "recoAlg"),
findAlgorithm(accTop.getSequence("seq2"), "recoAlg"),
"Algorithms are cloned")
self.assertIs(findAlgorithm(accTop.getSequence("seq1"), "recoAlg"),
recoAlg, "Clone of the original inserted in sequence")
fout = open("dummy.pkl", "wb")
accTop.store(fout)
fout.close()
def generateDecisionTree(chains):
acc = ComponentAccumulator()
mainSequenceName = 'HLTAllSteps'
acc.addSequence( seqAND(mainSequenceName) )
@memoize
def getFiltersStepSeq( stepNumber ):
"""
Returns sequence containing all filters for a step
"""
name = 'Step{}_{}'.format(stepNumber, CFNaming.FILTER_POSTFIX)
if stepNumber > 1:
getRecosStepSeq( stepNumber -1 ) # make sure steps sequencers are correctly made: Step1_filter, Step1_recos, Step2_filters, Step2_recos ...
seq = parOR( name )
acc.addSequence( seq, parentName = mainSequenceName )
return seq
@memoize
def getRecosStepSeq( stepNumber ):
"""
"""
getFiltersStepSeq( stepNumber ) # make sure there is filters step before recos
name = 'Step{}{}'.format(stepNumber, CFNaming.RECO_POSTFIX)
seq = parOR( name )
acc.addSequence( seq, parentName = mainSequenceName )
return seq
@memoize
def getSingleMenuSeq( stepNumber, stepName ):
"""
"""
name = "Menu{}{}".format(stepNumber, stepName)
seq = seqAND( name )
allRecoSeqName = getRecosStepSeq( stepNumber ).name
acc.addSequence(seq, parentName = allRecoSeqName )
return seq
@memoize
def getFilterAlg( stepNumber, stepName ):
"""
Returns, if need be created, filter for a given step
"""
filtersStep = getFiltersStepSeq( stepNumber )
singleMenuSeq = getSingleMenuSeq( stepNumber, stepName )
filterName = CFNaming.filterName( stepName )
filterAlg = CompFactory.RoRSeqFilter( filterName )
acc.addEventAlgo( filterAlg, sequenceName=filtersStep.name )
acc.addEventAlgo( filterAlg, sequenceName=singleMenuSeq.name )
log.debug('Creted filter {}'.format(filterName))
return filterAlg
@memoize
def findInputMaker( stepCounter, stepName ):
seq = getSingleMenuSeq( stepCounter, stepName )
algs = findAllAlgorithms( seq )
for alg in algs:
if isInputMakerBase(alg):
return alg
raise Exception("No input maker in seq "+seq.name)
@memoize
def findAllInputMakers( stepCounter, stepName ):
seq = getSingleMenuSeq( stepCounter, stepName )
algs = findAllAlgorithms( seq )
result = []
for alg in algs:
if isInputMakerBase(alg):
result.append(alg)
if result:
return result
else:
raise Exception("No input maker in seq "+seq.name)
@memoize
def findHypoAlg( stepCounter, stepName ):
seq = getSingleMenuSeq( stepCounter, stepName )
algs = findAllAlgorithms( seq )
for alg in algs:
if isHypoBase(alg):
return alg
raise Exception("No hypo alg in seq "+seq.name)
@memoize
def findAllHypoAlgs( stepCounter, stepName ):
seq = getSingleMenuSeq( stepCounter, stepName )
algs = findAllAlgorithms( seq )
result = []
for alg in algs:
if isHypoBase(alg):
result.append(alg)
if result:
return result
else:
raise Exception("No hypo alg in seq "+seq.name)
@memoize
def findComboHypoAlg( stepCounter, stepName ):
seq = getSingleMenuSeq( stepCounter, stepName )
algs = findAllAlgorithms( seq )
for alg in algs:
if isComboHypoAlg(alg):
return alg
raise Exception("No combo hypo alg in seq "+seq.name)
def addAndAssureUniqness( prop, toadd, context="" ):
if toadd not in prop:
log.info("{} value {} not there".format(context, toadd))
return list( prop ) + [ toadd ]
else:
log.info("{} value {} already there".format(context, toadd))
return list( prop )
def assureUnsetOrTheSame(prop, toadd, context):
"""
Central function setting strnig like proeprties (collection keys). Assures that valid names are not overwritten.
"""
if prop == "" or prop == toadd:
return toadd
if prop != toadd:
raise Exception("{}, when setting property found conflicting values, existing {} and new {}".format(context, prop, toadd))
# create all sequences and filter algs, merge CAs from signatures (decision CF)
for chain in chains:
for stepCounter, step in enumerate( chain.steps, 1 ):
getFilterAlg( stepCounter, step.name )
recoSeqName = getSingleMenuSeq( stepCounter, step.name ).name
if step.isCombo:
# add merged reco sequence
stepRecoName = step.name + CFNaming.RECO_POSTFIX
stepViewName = step.name + CFNaming.VIEW_POSTFIX
acc.addSequence( seqAND(stepViewName), parentName=recoSeqName )
acc.addSequence( parOR(stepRecoName), parentName=stepViewName )
for sequence in step.sequences:
for stepView in sequence.ca.getSequence().Members:
for viewMember in stepView.Members:
if isHypoBase(viewMember):
# add hypo alg to view sequence
acc.addEventAlgo( viewMember, sequenceName=stepViewName )
else:
# add reco sequence to merged _reco
for recoAlg in viewMember.Members:
acc.addSequence( recoAlg, parentName=stepRecoName )
# elements from ca were moved above to the appropriate sequences
# so sequence and algorithms are considered as merged
sequence.ca._algorithms = {}
sequence.ca._sequence.Members = []
acc.merge(sequence.ca, sequenceName=recoSeqName)
# create combo hypo
comboHypo = CompFactory.ComboHypo( step.combo.Alg.getName() )
acc.addEventAlgo( comboHypo, sequenceName=stepViewName )
else:
acc.merge( step.sequences[0].ca, sequenceName=recoSeqName )
# cleanup settings made by Chain & related objects (can be removed in the future)
for chain in chains:
for stepCounter, step in enumerate( chain.steps, 1 ):
filterAlg = getFilterAlg( stepCounter, step.name )
filterAlg.Input = []
filterAlg.Output = []
imAlgs = findAllInputMakers( stepCounter, step.name )
for imAlg in imAlgs:
imAlg.InputMakerInputDecisions = []
imAlg.InputMakerOutputDecisions = ""
hypoAlgs = findAllHypoAlgs( stepCounter, step.name )
for hypoAlg in hypoAlgs:
hypoAlg.HypoInputDecisions = ""
hypoAlg.HypoOutputDecisions = ""
if step.isCombo:
comboHypoAlg = findComboHypoAlg( stepCounter, step.name )
comboHypoAlg.MultiplicitiesMap = {}
comboHypoAlg.HypoInputDecisions = []
comboHypoAlg.HypoOutputDecisions = []
# connect all outputs (decision DF)
for chain in chains:
for stepCounter, step in enumerate( chain.steps, 1 ):
for seqCounter, sequence in enumerate( step.sequences ):
# Filters linking
filterAlg = getFilterAlg( stepCounter, step.name )
if step.isCombo:
chainDictLegs = ' '.join(map(str, [dic['chainName'] for dic in step.chainDicts]))
filterAlg.Chains = addAndAssureUniqness( filterAlg.Chains, chainDictLegs, "{} filter alg chains".format( filterAlg.name ) )
else:
filterAlg.Chains = addAndAssureUniqness( filterAlg.Chains, chain.name, "{} filter alg chains".format( filterAlg.name ) )
if stepCounter == 1:
filterAlg.Input = addAndAssureUniqness( filterAlg.Input, chain.L1decisions[0], "{} L1 input".format( filterAlg.name ) )
else: # look into the previous step
hypoOutput = findHypoAlg( stepCounter-1, chain.steps[chain.steps.index( step )-1].name ).HypoOutputDecisions
filterAlg.Input = addAndAssureUniqness( filterAlg.Input, hypoOutput, "{} input".format( filterAlg.name ) )
# Input Maker linking
im = findAllInputMakers( stepCounter, step.name )[seqCounter]
for i in filterAlg.Input:
filterOutputName = CFNaming.filterOutName( filterAlg.name, i )
filterAlg.Output = addAndAssureUniqness( filterAlg.Output, filterOutputName, "{} output".format( filterAlg.name ) )
im.InputMakerInputDecisions = addAndAssureUniqness( im.InputMakerInputDecisions, filterOutputName, "{} input".format( im.name ) )
imOutputName = CFNaming.inputMakerOutName( im.name )
im.InputMakerOutputDecisions = assureUnsetOrTheSame( im.InputMakerOutputDecisions, imOutputName, "{} IM output".format( im.name ) )
# Hypo linking
hypoAlg = findAllHypoAlgs( stepCounter, step.name )[seqCounter]
hypoAlg.HypoInputDecisions = assureUnsetOrTheSame( hypoAlg.HypoInputDecisions, im.InputMakerOutputDecisions,
"{} hypo input".format( hypoAlg.name ) )
hypoOutName = CFNaming.hypoAlgOutName( hypoAlg.name )
hypoAlg.HypoOutputDecisions = assureUnsetOrTheSame( hypoAlg.HypoOutputDecisions, hypoOutName,
"{} hypo output".format( hypoAlg.name ) )
# Hypo Tools
if step.isCombo:
from TriggerMenuMT.HLTMenuConfig.Menu.ChainDictTools import splitChainInDict
chainDictLeg = splitChainInDict(chain.name)[seqCounter]
hypoAlg.HypoTools.append( sequence._hypoToolConf.confAndCreate( chainDictLeg ) )
# to be deleted after ComboHypos will be properly configured and included in DF
hypoAlg.HypoTools.append( sequence._hypoToolConf.confAndCreate( TriggerConfigHLT.getChainDictFromChainName( chain.name ) ) )
else:
hypoAlg.HypoTools.append( sequence._hypoToolConf.confAndCreate( TriggerConfigHLT.getChainDictFromChainName( chain.name ) ) )
# Combo Hypo linking
if step.isCombo:
comboHypoAlg = findComboHypoAlg( stepCounter, step.name )
comboHypoAlg.MultiplicitiesMap[chain.name] = step.multiplicity
comboInputList = findAllHypoAlgs( stepCounter, step.name )
for comboInput in comboInputList:
comboHypoAlg.HypoInputDecisions = addAndAssureUniqness( comboHypoAlg.HypoInputDecisions, comboInput.name,
"{} comboHypo input".format( comboHypoAlg.name ) )
comboOutName = CFNaming.comboHypoOutputName( comboHypoAlg.name, comboInput.name )
comboHypoAlg.HypoOutputDecisions = addAndAssureUniqness( comboHypoAlg.HypoOutputDecisions, comboOutName,
"{} comboHypo output".format( comboHypoAlg.name ) )
# Combo Hypo Tools
for comboToolConf in step.comboToolConfs:
comboHypoAlg.ComboHypoTools.append( comboToolConf.confAndCreate( TriggerConfigHLT.getChainDictFromChainName( chain.name ) ) )
for chain in chains:
for stepCounter, step in enumerate( chain.steps, 1 ):
filterAlg = getFilterAlg( stepCounter, step.name )
log.info("FilterAlg {} Inputs {} Outputs {}".format( filterAlg.name, filterAlg.Input, filterAlg.Output ) )
imAlg = findInputMaker( stepCounter, step.name )
log.info("InputMaker {} Inputs {} Outputs {}".format( imAlg.name, imAlg.InputMakerInputDecisions, imAlg.InputMakerOutputDecisions ) )
hypoAlg = findHypoAlg( stepCounter, step.name )
log.info("HypoAlg {} Inputs {} Outputs {}".format( hypoAlg.name, hypoAlg.HypoInputDecisions, hypoAlg.HypoOutputDecisions ) )
return acc
def generateChains(flags, chainDict):
stepName = getChainStepName('Jet', 1)
stepReco, stepView = createStepView(stepName)
acc = ComponentAccumulator()
acc.addSequence(stepView)
# All this should be some common FS cell module?
from TrigT2CaloCommon.TrigCaloDataAccessConfig import trigCaloDataAccessSvcCfg
acc.merge(trigCaloDataAccessSvcCfg(flags))
cdaSvc = acc.getService(
"TrigCaloDataAccessSvc") # should be made primary component
acc.printConfig()
from TrigT2CaloCommon.CaloDef import clusterFSInputMaker
inEventReco = InEventReco("JetReco", inputMaker=clusterFSInputMaker())
cellsname = "CaloCellsFS"
clustersname = "HLT_CaloTopoClustersFS"
cellmakerCfg = HLTCaloCellMakerCfg(cellsname, cdaSvc)
inEventReco.mergeReco(cellmakerCfg)
from CaloRec.CaloTopoClusterConfig import CaloTopoClusterCfg
inEventReco.mergeReco(
CaloTopoClusterCfg(flags,
cellsname=cellsname,
clustersname=clustersname,
doLCCalib=False,
sequenceName=inEventReco.recoSeq.name))
#sequencing of actual jet reconstruction
from JetRecConfig import JetRecConfig
from JetRecConfig.JetDefinition import JetConstit, JetDefinition, xAODType
#hardcoded jet collection for now
clustermods = ["ECPSFrac", "ClusterMoments"]
trigMinPt = 7e3
HLT_EMTopo = JetConstit(xAODType.CaloCluster, ["EM"])
HLT_EMTopo.rawname = clustersname
HLT_EMTopo.inputname = clustersname
HLT_AntiKt4EMTopo_subjesIS = JetDefinition("AntiKt",
0.4,
HLT_EMTopo,
ptmin=trigMinPt,
ptminfilter=trigMinPt)
HLT_AntiKt4EMTopo_subjesIS.modifiers = [
"Calib:TrigRun2:data:JetArea_EtaJES_GSC_Insitu:HLT_Kt4EMTopoEventShape",
"Sort"
] + clustermods
jetprefix = "HLT_"
jetsuffix = "_subjesIS"
evsprefix = "HLT_"
# May need a switch to disable automatic modifier prerequisite generation
jetRecoComps = JetRecConfig.JetRecCfg(HLT_AntiKt4EMTopo_subjesIS, flags,
jetprefix, jetsuffix, evsprefix)
inEventReco.mergeReco(jetRecoComps)
acc.merge(inEventReco, stepReco.getName())
#hypo
from TrigHLTJetHypo.TrigJetHypoToolConfig import trigJetHypoToolFromDict
hypo = CompFactory.TrigJetHypoAlgMT("TrigJetHypoAlgMT_a4tcem_subjesIS")
jetsfullname = jetprefix + HLT_AntiKt4EMTopo_subjesIS.basename + "Jets" + jetsuffix
hypo.Jets = jetsfullname
acc.addEventAlgo(hypo)
jetSequence = CAMenuSequence(Sequence=inEventReco.sequence(),
Maker=inEventReco.inputMaker(),
Hypo=hypo,
HypoToolGen=trigJetHypoToolFromDict,
CA=acc)
jetStep = ChainStep(name=stepName,
Sequences=[jetSequence],
chainDicts=[chainDict])
l1Thresholds = []
for part in chainDict['chainParts']:
l1Thresholds.append(part['L1threshold'])
log.debug('dictionary is: %s\n', pprint.pformat(chainDict))
acc.printConfig()
chain = Chain(chainDict['chainName'],
L1Thresholds=l1Thresholds,
ChainSteps=[jetStep])
return chain
def testMenu(flags):
menuCA = ComponentAccumulator()
menuCA.addSequence( seqAND("HLTAllSteps") )
return menuCA
def METAssociatorCfg(configFlags):
sequencename = "METAssociation"
components = ComponentAccumulator()
from AthenaConfiguration.ComponentFactory import CompFactory
AthSequencer = CompFactory.AthSequencer
components.addSequence(AthSequencer(sequencename))
modConstKey = ""
modClusColls = {}
if configFlags.MET.UseTracks:
modConstKey = "OriginCorr"
modClusColls = {
'LCOriginCorrClusters': 'LCOriginTopoClusters',
'EMOriginCorrClusters': 'EMOriginTopoClusters'
}
############################################################################
# AntiKt4LCTopo
JetType = 'LCJet'
associators = [
AssocConfig(JetType),
AssocConfig('Muon'),
AssocConfig('Ele'),
AssocConfig('Gamma'),
AssocConfig('Tau'),
AssocConfig('Soft')
]
cfg_akt4lc = METAssocConfig('AntiKt4LCTopo',
configFlags,
associators,
doPFlow=False,
modConstKey=modConstKey,
modClusColls=modClusColls)
components_akt4lc = getAssocCA(cfg_akt4lc,
sequencename='METAssoc_AntiKt4LCTopo',
METName='AntiKt4LCTopo')
components.merge(components_akt4lc)
############################################################################
# AntiKt4EMTopo
JetType = 'EMJet'
associators = [
AssocConfig(JetType),
AssocConfig('Muon'),
AssocConfig('Ele'),
AssocConfig('Gamma'),
AssocConfig('Tau'),
AssocConfig('Soft')
]
cfg_akt4em = METAssocConfig('AntiKt4EMTopo',
configFlags,
associators,
doPFlow=False,
modConstKey=modConstKey,
modClusColls=modClusColls)
components_akt4em = getAssocCA(cfg_akt4em,
sequencename='METAssoc_AntiKt4EMTopo',
METName='AntiKt4EMTopo')
components.merge(components_akt4em)
############################################################################
# PFlow
if configFlags.MET.DoPFlow and configFlags.MET.UseTracks:
JetType = 'PFlowJet'
associators = [
AssocConfig(JetType),
AssocConfig('Muon'),
AssocConfig('Ele'),
AssocConfig('Gamma'),
AssocConfig('Tau'),
AssocConfig('Soft')
]
cfg_akt4pf = METAssocConfig('AntiKt4EMPFlow',
configFlags,
associators,
doPFlow=True)
components_akt4pf = getAssocCA(cfg_akt4pf,
sequencename='METAssoc_AntiKt4EMPFlow',
METName='AntiKt4EMPFlow')
components.merge(components_akt4pf)
return components
def JetRecCfg(jetdef,
configFlags,
jetnameprefix="",
jetnamesuffix="",
evsprefix="",
jetnameoverride=None):
# Ordinarily we want to have jet collection names be descriptive and derived from
# the configured reconstruction.
# Nevertheless, we allow an explicit specification when necessary
# e.g. to ensure that the correct name is used in grooming operations
if jetnameoverride:
jetsfullname = jetnameoverride
else:
jetsfullname = jetnameprefix + jetdef.basename + "Jets" + jetnamesuffix
jetlog.info("Setting up to find {0}".format(jetsfullname))
sequencename = jetsfullname
components = ComponentAccumulator()
from AthenaCommon.CFElements import parOR
components.addSequence(parOR(sequencename))
deps = resolveDependencies(jetdef)
# Schedule the various input collections.
# We don't have to worry about ordering, as the scheduler
# will handle the details. Just merge the components.
#
# To facilitate running in serial mode, we also prepare
# the constituent PseudoJetAlgorithm here (needed for rho)
inputcomps = JetInputCfg(deps["inputs"],
configFlags,
sequenceName=jetsfullname,
evsprefix=evsprefix)
constitpjalg = inputcomps.getPrimary()
constitpjkey = constitpjalg.OutputContainer
components.merge(inputcomps)
pjs = [constitpjkey]
# Schedule the ghost PseudoJetAlgs
for ghostdef in deps["ghosts"]:
ghostpjalg = getGhostPJGAlg(ghostdef)
components.addEventAlgo(ghostpjalg, sequencename)
ghostpjkey = ghostpjalg.OutputContainer
pjs.append(ghostpjkey)
# Generate a JetAlgorithm to run the jet finding and modifiers
# (via a JetRecTool instance).
mergepjalg = CompFactory.PseudoJetMerger(
"pjmergealg_" + jetsfullname,
InputPJContainers=pjs,
OutputContainer="PseudoJetMerged_" + jetsfullname)
components.addEventAlgo(mergepjalg, sequencename)
jetrecalg = getJetRecAlg(jetsfullname, jetdef,
"PseudoJetMerged_" + jetsfullname, deps["mods"])
components.addEventAlgo(jetrecalg, sequencename)
jetlog.info(
"Scheduled JetAlgorithm instance \"jetalg_{0}\"".format(jetsfullname))
return components
def CaloTopoClusterCfg(configFlags,cellsname="AllCalo",clustersname="",doLCCalib=None,sequenceName='AthAlgSeq'):
result=ComponentAccumulator()
if (sequenceName != 'AthAlgSeq'):
from AthenaCommon.CFElements import seqAND
#result.mainSeq( seqAND( sequenceName ) )
result.addSequence( seqAND(sequenceName) )
if not clustersname:
clustersname = "CaloTopoClusters"
from LArGeoAlgsNV.LArGMConfig import LArGMCfg
from TileGeoModel.TileGMConfig import TileGMCfg
from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
# Schedule total noise cond alg
result.merge(CaloNoiseCondAlgCfg(configFlags,"totalNoise"))
# Schedule electronic noise cond alg (needed for LC weights)
result.merge(CaloNoiseCondAlgCfg(configFlags,"electronicNoise"))
CaloTopoClusterMaker, CaloTopoClusterSplitter, CaloClusterMaker, CaloClusterSnapshot=CompFactory.getComps("CaloTopoClusterMaker","CaloTopoClusterSplitter","CaloClusterMaker","CaloClusterSnapshot",)
result.merge(LArGMCfg(configFlags))
from LArCalibUtils.LArHVScaleConfig import LArHVScaleCfg
result.merge(LArHVScaleCfg(configFlags))
result.merge(TileGMCfg(configFlags))
if not doLCCalib:
theCaloClusterSnapshot=CaloClusterSnapshot(OutputName=clustersname+"snapshot",SetCrossLinks=True)
else:
theCaloClusterSnapshot=CaloClusterSnapshot(OutputName=clustersname,SetCrossLinks=True)
# maker tools
TopoMaker = CaloTopoClusterMaker("TopoMaker")
TopoMaker.CellsName = cellsname
TopoMaker.CalorimeterNames=["LAREM",
"LARHEC",
"LARFCAL",
"TILE"]
# cells from the following samplings will be able to form
# seeds. By default no sampling is excluded
TopoMaker.SeedSamplingNames = ["PreSamplerB", "EMB1", "EMB2", "EMB3",
"PreSamplerE", "EME1", "EME2", "EME3",
"HEC0", "HEC1","HEC2", "HEC3",
"TileBar0", "TileBar1", "TileBar2",
"TileExt0", "TileExt1", "TileExt2",
"TileGap1", "TileGap2", "TileGap3",
"FCAL0", "FCAL1", "FCAL2"]
TopoMaker.NeighborOption = "super3D"
TopoMaker.RestrictHECIWandFCalNeighbors = False
TopoMaker.RestrictPSNeighbors = True
TopoMaker.CellThresholdOnEorAbsEinSigma = 0.0
TopoMaker.NeighborThresholdOnEorAbsEinSigma = 2.0
TopoMaker.SeedThresholdOnEorAbsEinSigma = 4.0
# note E or AbsE
#
# the following property must be set to TRUE in order to make double
# sided cuts on the seed and the cluster level
#
TopoMaker.SeedCutsInAbsE = True
TopoMaker.ClusterEtorAbsEtCut = 0.0*MeV
# use 2-gaussian or single gaussian noise for TileCal
TopoMaker.TwoGaussianNoise = configFlags.Calo.TopoCluster.doTwoGaussianNoise
TopoSplitter = CaloTopoClusterSplitter("TopoSplitter")
# cells from the following samplings will be able to form local
# maxima. The excluded samplings are PreSamplerB, EMB1,
# PreSamplerE, EME1, all Tile samplings, all HEC samplings and the
# two rear FCal samplings.
#
TopoSplitter.SamplingNames = ["EMB2", "EMB3",
"EME2", "EME3",
"FCAL0"]
# cells from the following samplings will also be able to form
# local maxima but only if they are not overlapping in eta and phi
# with local maxima in previous samplings from the primary list.
#
TopoSplitter.SecondarySamplingNames = ["EMB1","EME1",
"TileBar0","TileBar1","TileBar2",
"TileExt0","TileExt1","TileExt2",
"HEC0","HEC1","HEC2","HEC3",
"FCAL1","FCAL2"]
TopoSplitter.ShareBorderCells = True
TopoSplitter.RestrictHECIWandFCalNeighbors = False
TopoSplitter.WeightingOfNegClusters = configFlags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
#
# the following options are not set, since these are the default
# values
#
# NeighborOption = "super3D",
# NumberOfCellsCut = 4,
# EnergyCut = 500*MeV,
CaloTopoCluster=CaloClusterMaker(clustersname)
CaloTopoCluster.ClustersOutputName=clustersname
CaloTopoCluster.ClusterMakerTools = [TopoMaker, TopoSplitter]
from CaloBadChannelTool.CaloBadChanToolConfig import CaloBadChanToolCfg
caloBadChanTool = result.popToolsAndMerge( CaloBadChanToolCfg(configFlags) )
CaloClusterBadChannelList=CompFactory.CaloClusterBadChannelList
BadChannelListCorr = CaloClusterBadChannelList(badChannelTool = caloBadChanTool)
CaloTopoCluster.ClusterCorrectionTools += [BadChannelListCorr]
CaloTopoCluster.ClusterCorrectionTools += [getTopoMoments(configFlags)]
if doLCCalib is None:
doLCCalib = configFlags.Calo.TopoCluster.doTopoClusterLocalCalib
if doLCCalib:
CaloTopoCluster.ClusterCorrectionTools += [theCaloClusterSnapshot]
#if not clustersname:
CaloTopoCluster.ClustersOutputName="CaloCalTopoClusters"
CaloTopoCluster.ClusterCorrectionTools += getTopoClusterLocalCalibTools(configFlags)
from CaloRec.CaloTopoClusterConfig import caloTopoCoolFolderCfg
result.merge(caloTopoCoolFolderCfg(configFlags))
result.addEventAlgo(CaloTopoCluster,primary=True,sequenceName=sequenceName)
return result
def generateChains(flags, chainDict):
import pprint
pprint.pprint(chainDict)
firstStepName = getChainStepName('Electron', 1)
stepReco, stepView = createStepView(firstStepName)
accCalo = ComponentAccumulator()
accCalo.addSequence(stepView)
l2CaloReco = l2CaloRecoCfg(flags)
accCalo.merge(l2CaloReco, sequenceName=stepReco.getName())
# this alg needs EventInfo decorated with the pileup info
from LumiBlockComps.LumiBlockMuWriterConfig import LumiBlockMuWriterCfg
accCalo.merge(LumiBlockMuWriterCfg(flags))
l2CaloHypo = l2CaloHypoCfg(
flags,
name='L2ElectronCaloHypo',
CaloClusters=recordable('HLT_FastCaloEMClusters'))
accCalo.addEventAlgo(l2CaloHypo, sequenceName=stepView.getName())
fastCaloSequence = CAMenuSequence(
Sequence=l2CaloReco.sequence(),
Maker=l2CaloReco.inputMaker(),
Hypo=l2CaloHypo,
HypoToolGen=TrigEgammaFastCaloHypoToolFromDict,
CA=accCalo)
accCalo.printConfig()
fastCaloStep = ChainStep(name=firstStepName,
Sequences=[fastCaloSequence],
chainDicts=[chainDict])
secondStepName = getChainStepName('Electron', 2)
stepReco, stepView = createStepView(secondStepName)
accTrk = ComponentAccumulator()
accTrk.addSequence(stepView)
# # # fast ID
from TrigInDetConfig.TrigInDetConfig import indetInViewRecoCfg
fastInDetReco = indetInViewRecoCfg(flags,
viewMakerName='ElectronInDet',
signature='Electron')
accTrk.merge(fastInDetReco, sequenceName=stepReco.getName())
# TODO once tracking fully works remove fake hypos
# TODO remove once full tracking is in place
fakeHypoAlg = fakeHypoAlgCfg(flags, name='FakeHypoForElectron')
def makeFakeHypoTool(chainDict, cfg=None):
return CompFactory.getComp("HLTTest::TestHypoTool")(
chainDict['chainName'])
accTrk.addEventAlgo(fakeHypoAlg, sequenceName=stepView.getName())
fastInDetSequence = CAMenuSequence(Sequence=fastInDetReco.sequence(),
Maker=fastInDetReco.inputMaker(),
Hypo=fakeHypoAlg,
HypoToolGen=makeFakeHypoTool,
CA=accTrk)
fastInDetStep = ChainStep(name=secondStepName,
Sequences=[fastInDetSequence],
chainDicts=[chainDict])
l1Thresholds = []
for part in chainDict['chainParts']:
l1Thresholds.append(part['L1threshold'])
# # # EF calo
# # # EF ID
# # # offline egamma
chain = Chain(chainDict['chainName'],
L1Thresholds=l1Thresholds,
ChainSteps=[fastCaloStep, fastInDetStep])
return chain
def skip_test_algorithms_merging(self):
class MergeableAlgorithm(TestAlgo):
def __init__(self, name, **kwargs):
super(TestAlgo, self).__init__(name)
#self._jobOptName = name
for n, v in kwargs.items():
setattr(self, n, v)
self._set_attributes = kwargs.keys()
def getValuedProperties(self):
d = {}
for attrib in self._set_attributes:
d[attrib] = getattr(self, attrib)
return d
def __eq__(self, rhs):
if self is rhs:
return True
if not rhs or not isinstance(
rhs, Configurable
) or self.getFullName() != rhs.getFullName():
return False
for attr, value in self.getValuedProperties().items():
if getattr(rhs, attr) != value:
return False
return True
def __ne__(self, rhs):
return not self.__eq__(rhs)
ca = ComponentAccumulator()
seq1 = seqAND("seq1")
innerSeq1 = seqAND("innerSeq1")
level2Seq1 = seqAND("level2Seq1")
seq2 = seqAND("seq2")
innerSeq2 = seqAND("innerSeq2")
firstAlg = MergeableAlgorithm("alg1",
InputMakerInputDecisions=["input1"])
ca.addSequence(seq1)
ca.addSequence(innerSeq1, parentName=seq1.name())
ca.addSequence(level2Seq1, parentName=innerSeq1.name())
ca.addEventAlgo(firstAlg, sequenceName=level2Seq1.name())
ca.addSequence(seq2)
ca.addSequence(innerSeq2, parentName=seq2.name())
innerSeqCopy = seqAND("innerSeq2")
level2SeqCopy = seqAND("level2Seq2")
secondAlg = MergeableAlgorithm("alg1",
InputMakerInputDecisions=["input2"])
secondCa = ComponentAccumulator()
secondCa.addSequence(innerSeqCopy)
secondCa.addSequence(level2SeqCopy, parentName=innerSeqCopy.name())
secondCa.addEventAlgo(secondAlg, sequenceName=level2SeqCopy.name())
ca.merge(secondCa)
foundAlgs = findAllAlgorithms(ca.getSequence(), 'alg1')
self.assertEqual(len(foundAlgs), 2)
self.assertEqual(set(foundAlgs[0].InputMakerInputDecisions),
{"input1", "input2"})
self.assertEqual(set(foundAlgs[1].InputMakerInputDecisions),
{"input1", "input2"})
ca.printConfig()
ca.wasMerged()
def triggerRunCfg( flags, seqName = None, menu=None ):
"""
top of the trigger config (for real triggering online or on MC)
Returns: ca only
"""
acc = ComponentAccumulator()
# L1ConfigSvc needed for L1Decoder
from TrigConfigSvc.TrigConfigSvcCfg import L1ConfigSvcCfg
acc.merge( L1ConfigSvcCfg(flags) )
acc.addSequence( seqOR( "HLTTop") )
acc.addSequence( parOR("HLTBeginSeq"), parentName="HLTTop" )
# bit of a hack as for "legacy" type JO a seq name for cache creators has to be given,
# in newJO realm the seqName will be removed as a comp fragment shoudl be unaware of where it will be attached
acc.merge( triggerIDCCacheCreatorsCfg( flags, seqName="AthAlgSeq" ), sequenceName="HLTBeginSeq" )
from L1Decoder.L1DecoderConfig import L1DecoderCfg
l1DecoderAcc = L1DecoderCfg( flags, seqName = "HLTBeginSeq")
# TODO, once moved to newJO the algorithm can be added to l1DecoderAcc and merging will be sufficient here
acc.merge( l1DecoderAcc )
# detour to the menu here, (missing now, instead a temporary hack)
if menu:
menuAcc = menu( flags )
HLTSteps = menuAcc.getSequence( "HLTAllSteps" )
__log.info( "Configured menu with "+ str( len(HLTSteps.Members) ) +" steps" )
acc.merge( menuAcc, sequenceName="HLTTop")
# collect hypothesis algorithms from all sequence
hypos = collectHypos( HLTSteps )
filters = collectFilters( HLTSteps )
acc.addSequence( parOR("HLTEndSeq"), parentName="HLTTop" )
acc.addSequence( seqAND("HLTFinalizeSeq"), parentName="HLTEndSeq" )
summaryAcc, summaryAlg = triggerSummaryCfg( flags, hypos )
acc.merge( summaryAcc, sequenceName="HLTFinalizeSeq" )
acc.addEventAlgo( summaryAlg, sequenceName="HLTFinalizeSeq" )
#once menu is included we should configure monitoring here as below
l1DecoderAlg = l1DecoderAcc.getEventAlgo("L1Decoder")
monitoringAcc, monitoringAlg = triggerMonitoringCfg( flags, hypos, filters, l1DecoderAlg )
acc.merge( monitoringAcc, sequenceName="HLTEndSeq" )
acc.addEventAlgo( monitoringAlg, sequenceName="HLTEndSeq" )
from TrigCostMonitorMT.TrigCostMonitorMTConfig import TrigCostMonitorMTCfg
acc.merge( TrigCostMonitorMTCfg( flags ), sequenceName="HLTEndSeq" )
decObj = collectDecisionObjects( hypos, filters, l1DecoderAlg, summaryAlg )
decObjHypoOut = collectHypoDecisionObjects(hypos, inputs=False, outputs=True)
__log.info( "Number of decision objects found in HLT CF %d", len( decObj ) )
__log.info( "Of which, %d are the outputs of hypos", len( decObjHypoOut ) )
__log.info( str( decObj ) )
# configure components need to normalise output before writing out
viewMakers = collectViewMakers( HLTSteps )
outputAcc, edmSet = triggerOutputCfg( flags, decObj, decObjHypoOut, summaryAlg )
acc.merge( outputAcc )
if edmSet:
mergingAlg = triggerMergeViewsAndAddMissingEDMCfg( [edmSet] , hypos, viewMakers, decObj, decObjHypoOut )
acc.addEventAlgo( mergingAlg, sequenceName="HLTFinalizeSeq" )
return acc
def generateDecisionTreeOld(HLTNode, chains, allChainDicts):
log.debug("Run generateDecisionTreeOld on %s", HLTNode.name())
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
acc = ComponentAccumulator()
from collections import defaultdict
from TriggerMenuMT.HLTMenuConfig.Menu.MenuComponents import CFSequence
chainStepsMatrix = defaultdict(lambda: defaultdict(lambda: list()))
## Fill chain steps matrix
for chain in chains:
chain.createHypoTools() #allChainDicts)
for stepNumber, chainStep in enumerate(chain.steps):
chainName = chainStep.name.split('_')[0]
chainStepsMatrix[stepNumber][chainName].append(chain)
allSequences = []
## Matrix with steps lists generated. Creating filters for each cell
for nstep in chainStepsMatrix:
CFsequences = []
stepDecisions = []
stepAccs = []
stepHypos = []
for chainName in chainStepsMatrix[nstep]:
chainsInCell = chainStepsMatrix[nstep][chainName]
if not chainsInCell:
continue
stepCategoryAcc = ComponentAccumulator()
stepHypo = None
for chain in chainsInCell:
for seq in chain.steps[nstep].sequences:
if seq.ca:
stepCategoryAcc.merge(seq.ca)
alg = seq.hypo.Alg
if stepHypo is None:
stepHypo = alg
stepHypos.append(alg)
stepCategoryAcc.addEventAlgo(alg)
stepAccs.append(stepCategoryAcc)
stepCategoryAcc.printConfig(True, True)
firstChain = chainsInCell[0]
if nstep == 0:
filter_input = firstChain.L1decisions
else:
filter_input = []
for sequence in firstChain.steps[nstep - 1].sequences:
filter_input += sequence.outputs
# One aggregated filter per chain (one per column in matrix)
filterName = 'Filter_{}'.format(firstChain.steps[nstep].name)
filter_output = []
for i in filter_input:
filter_output.append(CFNaming.filterOutName(filterName, i))
sfilter = buildFilter(filterName, filter_input)
chainStep = firstChain.steps[nstep]
CFseq = CFSequence(ChainStep=chainStep,
FilterAlg=sfilter,
connections=filter_output)
CFsequences.append(CFseq)
for sequence in chainStep.sequences:
stepDecisions += sequence.outputs
for chain in chainsInCell:
sfilter.addChain(chain.name)
allSequences.append(CFsequences)
stepName = 'Step{}'.format(nstep)
stepFilter = createStepFilterNode(stepName, CFsequences, dump=False)
stepCF = createStepRecoNode('{}_{}'.format(HLTNode.name(), stepName),
CFsequences,
dump=False)
from AthenaCommon.CFElements import findOwningSequence
for oneAcc, cfseq, hypo in zip(stepAccs, CFsequences, stepHypos):
owning = findOwningSequence(stepCF, hypo.getName())
acc.addSequence(owning)
acc.merge(oneAcc, sequenceName=owning.getName())
summary = makeSummary('TriggerSummary{}'.format(stepName),
stepDecisions)
HLTNode += stepFilter
HLTNode += stepCF
HLTNode += summary
if create_dot():
stepCF_DataFlow_to_dot('{}_{}'.format(HLTNode.name(), stepName),
CFsequences)
stepCF_ControlFlow_to_dot(stepCF)
all_DataFlow_to_dot(HLTNode.name(), allSequences)
matrixDisplay(allSequences)
return acc
def generateMenu(flags):
"""
Using flags generate appropriate Control Flow Graph wiht all HLT algorithms
"""
# convert to chainDefs
from TriggerMenuMT.HLTMenuConfig.Menu.DictFromChainName import dictFromChainName
counter = 0
signatureToGenerator = {}
menuChains = []
allChainDicts = []
menuAcc = ComponentAccumulator()
mainSequenceName = 'HLTAllSteps'
menuAcc.addSequence(seqAND(mainSequenceName))
for name, cfgFlag in list(iteritems(flags._flagdict)):
if 'Trigger.menu.' not in name:
continue
value = flags._get(name)
if len(value) == 0:
continue
signatureName = name.split('.')[-1]
signatures = []
# fill the map[signature, generating function]
if signatureName == 'combined':
for chain in cfgFlag.get():
signatures += dictFromChainName(chain)['signatures']
else:
signatures = [signatureName]
for sig in signatures:
fillGeneratorsMap(signatureToGenerator, sig.lower())
# call generating function and pass to CF builder
for chain in cfgFlag.get():
# TODO topo threshold
mainChainDict = dictFromChainName(chain)
counter += 1
mainChainDict['chainCounter'] = counter
#set default chain prescale
mainChainDict['prescale'] = 1
allChainDicts.append(mainChainDict)
chainDicts = splitInterSignatureChainDict(mainChainDict)
listOfChainConfigs = []
for chainDict in chainDicts:
signature = chainDict['signature'].lower()
if signature not in signatureToGenerator:
log.warning(
'Generator for {} is missing. Chain dict will not be built'
.format(signature))
continue
chainConfig = signatureToGenerator[signature](flags, chainDict)
listOfChainConfigs.append(chainConfig)
if len(listOfChainConfigs) > 1:
theChainConfig = mergeChainDefs(listOfChainConfigs,
mainChainDict)
else:
theChainConfig = listOfChainConfigs[0]
TriggerConfigHLT.registerChain(mainChainDict, theChainConfig)
menuChains.append(theChainConfig)
log.info('Obtained Menu Chain objects')
# pass all menuChain to CF builder
useReworked = True
if useReworked:
menuAcc.wasMerged()
menuAcc = generateDecisionTree(menuChains)
else:
menuAcc.wasMerged()
menuAcc = ComponentAccumulator()
mainSequenceName = 'HLTAllSteps'
menuAcc.addSequence(seqAND(mainSequenceName))
chainsAcc = generateDecisionTreeOld(
menuAcc.getSequence(mainSequenceName), menuChains, allChainDicts)
menuAcc.merge(chainsAcc)
menuAcc.printConfig()
log.info('CF is built')
# # generate JOSON representation of the config
from TriggerMenuMT.HLTMenuConfig.Menu.HLTMenuJSON import generateJSON_newJO
generateJSON_newJO(allChainDicts, menuChains,
menuAcc.getSequence("HLTAllSteps"))
from TriggerMenuMT.HLTMenuConfig.Menu.HLTPrescaleJSON import generateJSON_newJO as generatePrescaleJSON_newJO
generatePrescaleJSON_newJO(allChainDicts, menuChains)
return menuAcc
def generateChains(flags, chainDict):
firstStepName = getChainStepName('Photon', 1)
stepReco, stepView = createStepView(firstStepName)
accCalo = ComponentAccumulator()
accCalo.addSequence(stepView)
l2CaloReco = l2CaloRecoCfg(flags)
accCalo.merge(l2CaloReco, sequenceName=stepReco.getName())
# this alg needs EventInfo decorated with the pileup info
from LumiBlockComps.LumiBlockMuWriterConfig import LumiBlockMuWriterCfg
accCalo.merge(LumiBlockMuWriterCfg(flags))
l2CaloHypo = l2CaloHypoCfg(
flags,
name='L2PhotonCaloHypo',
CaloClusters=recordable('HLT_FastCaloEMClusters'))
accCalo.addEventAlgo(l2CaloHypo, sequenceName=stepView.getName())
fastCaloSequence = CAMenuSequence(
Sequence=l2CaloReco.sequence(),
Maker=l2CaloReco.inputMaker(),
Hypo=l2CaloHypo,
HypoToolGen=TrigEgammaFastCaloHypoToolFromDict,
CA=accCalo)
fastCaloStep = ChainStep(firstStepName, [fastCaloSequence])
secondStepName = getChainStepName('Photon', 2)
stepReco, stepView = createStepView(secondStepName)
accPhoton = ComponentAccumulator()
accPhoton.addSequence(stepView)
l2PhotonReco = l2PhotonRecoCfg(flags)
accPhoton.merge(l2PhotonReco, sequenceName=stepReco.getName())
l2PhotonHypo = l2PhotonHypoCfg(flags,
Photons='HLT_FastPhotons',
RunInView=True)
accPhoton.addEventAlgo(l2PhotonHypo, sequenceName=stepView.getName())
l2PhotonSequence = CAMenuSequence(
Sequence=l2PhotonReco.sequence(),
Maker=l2PhotonReco.inputMaker(),
Hypo=l2PhotonHypo,
HypoToolGen=TrigEgammaFastPhotonHypoToolFromDict,
CA=accPhoton)
l2PhotonStep = ChainStep(secondStepName, [l2PhotonSequence])
l1Thresholds = []
for part in chainDict['chainParts']:
l1Thresholds.append(part['L1threshold'])
log.debug('dictionary is: %s\n', pprint.pformat(chainDict))
chain = Chain(chainDict['chainName'],
L1Thresholds=l1Thresholds,
ChainSteps=[fastCaloStep, l2PhotonStep])
return chain
class AthMonitorCfgHelper(object):
'''
This class is for the Run 3-style configuration framework. It is intended to be instantiated once
per group of related monitoring algorithms.
'''
def __init__(self, inputFlags, monName):
'''
Create the configuration helper. Needs the global flags and the name of the set of
monitoring algorithms.
Arguments:
inputFlags -- the global configuration flag object
monName -- the name you want to assign the family of algorithms
'''
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from AthenaConfiguration.ComponentFactory import CompFactory
AthSequencer = CompFactory.AthSequencer
self.inputFlags = inputFlags
self.monName = monName
self.monSeq = AthSequencer('AthMonSeq_' + monName)
self.resobj = ComponentAccumulator()
if inputFlags.DQ.useTrigger:
from .TriggerInterface import getTrigDecisionTool
self.resobj.merge(getTrigDecisionTool(inputFlags))
def addAlgorithm(self, algClassOrObj, name=None, *args, **kwargs):
'''
Instantiate/add a monitoring algorithm
Arguments:
algClassOrObj -- the Configurable class object of the algorithm to create, or an instance
of the algorithm Configurable. The former is recommended. In the former case,
the name argument is required.
name -- the name of the algorithm to create. Required when passing a Configurable class object
as algClassOrObj. No effect if a Configurable instance is passed.
*args, **kwargs -- additional arguments will be forwarded to the Configurable constructor if
a Configurable class object is passed. No effect if a Configurable instance
is passed.
Returns:
algObj -- an algorithm Configurable object
'''
from inspect import isclass
if isclass(algClassOrObj):
if name is None:
raise TypeError(
'addAlgorithm with a class argument requires a name for the algorithm'
)
algObj = algClassOrObj(name, *args, **kwargs)
else:
algObj = algClassOrObj
# configure these properties; users really should have no reason to override them
algObj.Environment = self.inputFlags.DQ.Environment
algObj.DataType = self.inputFlags.DQ.DataType
if self.inputFlags.DQ.useTrigger:
algObj.TrigDecisionTool = self.resobj.getPublicTool(
"TrigDecisionTool")
algObj.TriggerTranslatorTool = self.resobj.popToolsAndMerge(
getTriggerTranslatorToolSimple(self.inputFlags))
if not self.inputFlags.Input.isMC and self.inputFlags.DQ.enableLumiAccess:
algObj.EnableLumi = True
from LumiBlockComps.LuminosityCondAlgConfig import LuminosityCondAlgCfg
from LumiBlockComps.LBDurationCondAlgConfig import LBDurationCondAlgCfg
from LumiBlockComps.TrigLiveFractionCondAlgConfig import TrigLiveFractionCondAlgCfg
self.resobj.merge(LuminosityCondAlgCfg(self.inputFlags))
self.resobj.merge(LBDurationCondAlgCfg(self.inputFlags))
self.resobj.merge(TrigLiveFractionCondAlgCfg(self.inputFlags))
else:
algObj.EnableLumi = False
self.monSeq.Members.append(algObj)
return algObj
def addGroup(self, alg, name, topPath='', defaultDuration='run'):
'''Add a group to an algorithm
Technically, adding a GenericMonitoringTool instance. The name given here can be
used to retrieve the group from within the algorithm when calling the fill()
function. Note this is *not* the same thing as the Monitored::Group class. To
avoid replication of code, this calls the more general case, getArray with an 1D
array of length 1.
Arguments:
alg -- algorithm Configurable object (e.g. one returned from addAlgorithm)
name -- name of the group
topPath -- directory name in the output ROOT file under which histograms will be
produced
defaultDuration -- default time between histogram reset for all histograms in
group; can be overridden for each specific histogram
Returns:
tool -- a GenericMonitoringTool Configurable object. This can be used to define
histograms associated with that group (using defineHistogram).
'''
array = self.addArray([1],
alg,
name,
topPath=topPath,
defaultDuration=defaultDuration)
return array[0]
def addArray(self,
dimensions,
alg,
baseName,
topPath='',
defaultDuration='run'):
'''Add many groups to an algorithm
Arguments:
dimensions -- list holding the size in each dimension [n1,n2,n3,n4,...]
alg -- algorithm Configurable object
baseName -- base name of the group. postfixes are added by GMT Array initialize
topPath -- directory name in the output ROOT file under which histograms will be
produced
duration -- default time between histogram reset for all histograms in group
Returns:
tool -- a GenericMonitoringToolArray object. This is used to define histograms
associated with each group in the array.
'''
from AthenaMonitoringKernel.GenericMonitoringTool import GenericMonitoringArray
array = GenericMonitoringArray(baseName, dimensions)
if self.inputFlags.DQ.isReallyOldStyle:
from AthenaCommon.AppMgr import ServiceMgr
array.broadcast('THistSvc', ServiceMgr.THistSvc)
else:
acc = getDQTHistSvc(self.inputFlags)
self.resobj.merge(acc)
pathToSet = self.inputFlags.DQ.FileKey + ('/%s' %
topPath if topPath else '')
array.broadcast('HistPath', pathToSet)
# in the future, autodetect if we are online or not
array.broadcast('convention', 'OFFLINE')
array.broadcast('defaultDuration', defaultDuration)
alg.GMTools += array.toolList()
return array
def result(self):
'''
Finalize the creation of the set of monitoring algorithms.
Returns:
(resobj, monSeq) -- a tuple with a ComponentAccumulator and an AthSequencer
'''
self.resobj.addSequence(self.monSeq)
return self.resobj
def generateChains( flags, chainDict ):
chainDict = splitChainDict(chainDict)[0]
# Step 1 (L2MuonSA)
stepName = getChainStepName('Muon', 1)
stepReco, stepView = createStepView(stepName)
acc = ComponentAccumulator()
acc.addSequence(stepView)
# Set EventViews for L2MuonSA step
from TriggerMenuMT.HLTMenuConfig.Menu.MenuComponents import InViewReco
reco = InViewReco("L2MuFastReco")
#external data loading to view
reco.mergeReco( MuFastViewDataVerifier() )
# decoding
# Get RPC BS decoder
from MuonConfig.MuonBytestreamDecodeConfig import RpcBytestreamDecodeCfg
rpcAcc = RpcBytestreamDecodeCfg( flags, forTrigger=True )
rpcAcc.getEventAlgo("RpcRawDataProvider").RoIs = reco.name+"RoIs"
reco.mergeReco( rpcAcc )
# Get RPC BS->RDO convertor
from MuonConfig.MuonRdoDecodeConfig import RpcRDODecodeCfg
rpcAcc = RpcRDODecodeCfg( flags, forTrigger=True )
rpcAcc.getEventAlgo("RpcRdoToRpcPrepData").RoIs = reco.name+"RoIs"
reco.mergeReco( rpcAcc )
# Get TGC BS decoder
from MuonConfig.MuonBytestreamDecodeConfig import TgcBytestreamDecodeCfg
tgcAcc = TgcBytestreamDecodeCfg( flags, forTrigger=True )
tgcAcc.getEventAlgo("TgcRawDataProvider").RoIs = reco.name+"RoIs"
reco.mergeReco( tgcAcc )
# Get TGC BS->RDO convertor
from MuonConfig.MuonRdoDecodeConfig import TgcRDODecodeCfg
tgcAcc = TgcRDODecodeCfg( flags, forTrigger=True )
tgcAcc.getEventAlgo("TgcRdoToTgcPrepData").RoIs = reco.name+"RoIs"
reco.mergeReco( tgcAcc )
# Get MDT BS decoder
from MuonConfig.MuonBytestreamDecodeConfig import MdtBytestreamDecodeCfg
mdtAcc = MdtBytestreamDecodeCfg( flags, forTrigger=True )
mdtAcc.getEventAlgo("MdtRawDataProvider").RoIs = reco.name+"RoIs"
reco.mergeReco( mdtAcc )
# Get MDT BS->RDO convertor
from MuonConfig.MuonRdoDecodeConfig import MdtRDODecodeCfg
mdtAcc = MdtRDODecodeCfg( flags, forTrigger=True )
mdtAcc.getEventAlgo("MdtRdoToMdtPrepData").RoIs = reco.name+"RoIs"
reco.mergeReco( mdtAcc )
# Get CSC BS decoder
from MuonConfig.MuonBytestreamDecodeConfig import CscBytestreamDecodeCfg
cscAcc = CscBytestreamDecodeCfg( flags, forTrigger=True )
cscAcc.getEventAlgo("CscRawDataProvider").RoIs = reco.name+"RoIs"
reco.mergeReco( cscAcc )
# Get CSC BS->RDO convertor
from MuonConfig.MuonRdoDecodeConfig import CscRDODecodeCfg
cscAcc = CscRDODecodeCfg( flags, forTrigger=True )
cscAcc.getEventAlgo("CscRdoToCscPrepData").RoIs = reco.name+"RoIs"
reco.mergeReco( cscAcc )
# Get CSC cluster builder
from MuonConfig.MuonRdoDecodeConfig import CscClusterBuildCfg
cscAcc = CscClusterBuildCfg( flags, forTrigger=True )
reco.mergeReco( cscAcc )
# Get Reco alg of muFast Step in order to set into the view
algAcc, alg = l2MuFastAlgCfg( flags, roisKey=reco.name+"RoIs")
l2MuFastAlgAcc = ComponentAccumulator()
l2MuFastAlgAcc.addEventAlgo(alg)
reco.mergeReco( l2MuFastAlgAcc )
reco.merge( algAcc )
# l2muFastReco = l2MuFastRecoCfg(flags)
acc.merge( reco, sequenceName=stepReco.getName() )
### Set muon step1 ###
l2muFastHypo = l2MuFastHypoCfg( flags,
name = 'TrigL2MuFastHypo',
muFastInfo = 'MuonL2SAInfo' )
acc.addEventAlgo(l2muFastHypo, sequenceName=stepView.getName())
l2muFastSequence = CAMenuSequence( Sequence = reco.sequence(),
Maker = reco.inputMaker(),
Hypo = l2muFastHypo,
HypoToolGen = TrigMufastHypoToolFromDict,
CA = acc )
l2muFastStep = ChainStep( name=stepName, Sequences=[l2muFastSequence], chainDicts=[chainDict] )
### Set muon step2 ###
# Please set up L2muComb step here
#EF MS only
stepEFMSName = getChainStepName('EFMSMuon', 2)
stepEFMSReco, stepEFMSView = createStepView(stepEFMSName)
#Clone and replace offline flags so we can set muon trigger specific values
muonflags = flags.cloneAndReplace('Muon', 'Trigger.Offline.Muon')
muonflags.Muon.useTGCPriorNextBC=True
muonflags.Muon.enableErrorTuning=False
muonflags.Muon.MuonTrigger=True
muonflags.Muon.SAMuonTrigger=True
muonflags.lock()
accMS = ComponentAccumulator()
accMS.addSequence(stepEFMSView)
from TriggerMenuMT.HLTMenuConfig.Menu.MenuComponents import InViewReco
recoMS = InViewReco("EFMuMSReco")
recoMS.inputMaker().RequireParentView = True
#Probably this block will eventually need to move somewhere more central
from BeamPipeGeoModel.BeamPipeGMConfig import BeamPipeGeometryCfg
accMS.merge( BeamPipeGeometryCfg(flags) )
from PixelGeoModel.PixelGeoModelConfig import PixelGeometryCfg
accMS.merge(PixelGeometryCfg(flags))
from SCT_GeoModel.SCT_GeoModelConfig import SCT_GeometryCfg
accMS.merge(SCT_GeometryCfg(flags))
from TRT_GeoModel.TRT_GeoModelConfig import TRT_GeometryCfg
accMS.merge(TRT_GeometryCfg(flags))
from TrkConfig.AtlasTrackingGeometrySvcConfig import TrackingGeometrySvcCfg
accMS.merge(TrackingGeometrySvcCfg(flags))
###################
EFMuonViewDataVerifier = EFMuonViewDataVerifierCfg()
recoMS.mergeReco(EFMuonViewDataVerifier)
from MuonConfig.MuonSegmentFindingConfig import MooSegmentFinderAlgCfg
segCfg = MooSegmentFinderAlgCfg(muonflags,name="TrigMooSegmentFinder",UseTGCNextBC=False, UseTGCPriorBC=False)
recoMS.mergeReco(segCfg)
from MuonConfig.MuonTrackBuildingConfig import MuonTrackBuildingCfg
trkCfg = MuonTrackBuildingCfg(muonflags, name="TrigMuPatTrackBuilder")
recoMS.mergeReco(trkCfg)
cnvCfg = MuonTrackParticleCnvCfg(muonflags, name = "TrigMuonTrackParticleCnvAlg")
recoMS.mergeReco(cnvCfg)
from MuonCombinedConfig.MuonCombinedReconstructionConfig import MuonCombinedMuonCandidateAlgCfg
candCfg = MuonCombinedMuonCandidateAlgCfg(muonflags, name = "TrigMuonCandidateAlg")
recoMS.mergeReco(candCfg)
from MuonCombinedConfig.MuonCombinedReconstructionConfig import MuonCreatorAlgCfg
creatorCfg = MuonCreatorAlgCfg(muonflags, name = "TrigMuonCreatorAlg")
recoMS.mergeReco(creatorCfg)
accMS.merge(recoMS, sequenceName=stepEFMSReco.getName())
efmuMSHypo = efMuMSHypoCfg( muonflags,
name = 'TrigMuonEFMSonlyHypo',
inputMuons = "Muons" )
accMS.addEventAlgo(efmuMSHypo, sequenceName=stepEFMSView.getName())
efmuMSSequence = CAMenuSequence( Sequence = recoMS.sequence(),
Maker = recoMS.inputMaker(),
Hypo = efmuMSHypo,
HypoToolGen = TrigMuonEFMSonlyHypoToolFromDict,
CA = accMS )
efmuMSStep = ChainStep( name=stepEFMSName, Sequences=[efmuMSSequence], chainDicts=[chainDict] )
l1Thresholds=[]
for part in chainDict['chainParts']:
l1Thresholds.append(part['L1threshold'])
log.debug('dictionary is: %s\n', pprint.pformat(chainDict))
chain = Chain( name=chainDict['chainName'], L1Thresholds=l1Thresholds, ChainSteps=[ l2muFastStep, efmuMSStep ] )
return chain
