4 JetRecConfig: A helper module for configuring jet reconstruction
6 The functions defined here turn JetDefinition object into ComponentAccumulator or list of algs fully configured
7 and ready to be inserted in the framework sequence.
9 Author: TJ Khoo, P-A Delsart
13 from AthenaCommon
import Logging
14 jetlog = Logging.logging.getLogger(
'JetRecConfig')
16 from ROOT
import xAODType
19 from AthenaConfiguration.ComponentAccumulator
import ComponentAccumulator
20 from AthenaConfiguration.ComponentFactory
import CompFactory
23 from JetRecConfig.JetDefinition
import JetDefinition, JetInputConstitSeq, JetInputConstit, JetInputExternal
24 from JetRecConfig.JetGrooming
import GroomingDefinition
25 from JetRecConfig.DependencyHelper
import solveDependencies, solveGroomingDependencies, aliasToModDef
28 __all__ = [
"JetRecCfg",
"JetInputCfg"]
36 def JetRecCfg( flags, jetdef, returnConfiguredDef=False):
37 """Top-level function for running jet finding or grooming.
39 This returns a ComponentAccumulator that can be merged with others
40 from elsewhere in the job and which provides everything needed to
41 reconstruct one jet collection.
44 - jetdef : jet or grooming definition
45 - flags : the configuration flags instance, mainly for input file
46 peeking such that we don't attempt to reproduce stuff that's already
47 in the input file. And also to be able to invoke building of inputs outside of Jet domain during reco from RAW/RDO.
48 - returnConfiguredDef : is for debugging. It will also returns the cloned JetDefinition which contains the calculated dependencies.
52 sequenceName = jetdef.fullname()
53 jetlog.info(
"******************")
54 jetlog.info(
"Setting up to find {0}".
format(sequenceName))
57 from AthenaCommon.CFElements
import parOR
58 components.addSequence(
parOR(sequenceName) )
61 if isinstance(jetdef, JetDefinition):
63 elif isinstance(jetdef, GroomingDefinition):
67 if flags.Concurrency.NumThreads <= 0:
68 jetlog.info(
"Reordering algorithms in sequence {0}".
format(sequenceName))
74 if isinstance(a, ComponentAccumulator):
77 components.addEventAlgo( a , sequenceName = sequenceName )
79 if returnConfiguredDef:
return components, jetdef_i
84 """Returns a ComponentAccumulator containing algs needed to build inputs to jet finding as defined by jetOrConstitdef
86 jetOrConstitdef can either be
87 * a JetDefinition : this happens when called from JetRecCfg, then the jetdef._prereqDic/Order are used.
88 * a JetInputConstit : to allow scheduling the corresponding constituents algs independently of any jet alg.
90 context is only used if jetOrConstitdef is not a JetDefinition and must refer to a context in StandardJetContext
98 if isinstance(a, ComponentAccumulator):
101 components.addEventAlgo(a)
106 """Builds a ComponentAccumulator for creating PseudoJetContainer needed by jetdef.
107 THIS updates jetdef._internalAtt['finalPJContainer']
111 for pjalg
in pjalglist:
112 components.addEventAlgo(pjalg)
123 """ Create the algorithms necessary to build the jet collection defined by jetdef.
125 This internally finds all the dependencies declared into jetdef (through input, ghosts & modifiers)
126 and returns a list of all necessary algs.
128 if returnConfiguredDef==True, also returns the fully configured clone of jetdef containing solved dependencies (debugging)
130 monTool is to allow the trigger config to pass a monitoring tool.
132 returns a list containing either algs or ComponentAccumulator
133 (ComponentAccumulator occurs only (?) in reco from RDO/RAW when we need to build externals such as clusters or tracks : in this case we call the main config functions from external packages)
147 if returnConfiguredDef:
164 jetlog.info(
"Scheduled JetAlgorithm instance \"jetalg_{0}\"".
format(jetdef_i.fullname()))
166 if returnConfiguredDef:
167 return algs, jetdef_i
171 """Instantiate and schedule all the algorithms needed to run the grooming alg 'groomdef' and
172 add them in the ComponentAccumulator 'components'
174 This function is meant to be called from the top-level JetRecConfig.JetRecCfg
175 (groomdef is expected to be non locked and will be modified).
177 monTool is to allow the trigger config to pass a monitoring tool.
186 for prereq
in groomdef_i._prereqOrder:
188 if len(prereq.split(
':')) > 2:
190 reqType, reqKey = prereq.split(
':')
192 groomdef_i.ungroomeddef.ghostdefs.append(reqKey)
193 elif reqType.endswith(
'input') :
194 groomdef_i.ungroomeddef.extrainputs.append(reqKey)
196 jetlog.info(
"Scheduling parent alg {} for {} ".
format(groomdef.ungroomeddef.fullname(), groomdef.fullname()))
201 algs, ungroomeddef_i =
getJetDefAlgs(flags, groomdef_i.ungroomeddef ,
True)
202 groomdef_i._ungroomeddef = ungroomeddef_i
210 jetlog.info(
"Scheduled JetAlgorithm instance \"jetalg_{0}\"".
format(groomdef_i.fullname()))
212 if returnConfiguredDef:
return algs, groomdef_i
216 def getJetAlgs(flags, jetdef, returnConfiguredDef=False, monTool=None):
218 if isinstance(jetdef, JetDefinition):
220 elif isinstance(jetdef, GroomingDefinition):
221 func = getJetGroomAlgs
223 return func(flags, jetdef, returnConfiguredDef, monTool)
234 """ Builds the list of configured PseudoJetAlgorithm needed for this jetdef.
235 THIS updates jetdef._internalAtt['finalPJContainer']
236 (this function is factorized out of PseudoJetCfg so it can be used standalone in the trigger config)
239 constitpjalg =
getConstitPJGAlg(jetdef.inputdef , suffix=
None , flags=jetdef._cflags, parent_jetdef = jetdef)
241 finalPJContainer =
str(constitpjalg.OutputContainer)
242 pjalglist = [constitpjalg]
245 ghostlist = [ key
for key
in jetdef._prereqOrder
if key.startswith(
'ghost:')]
248 pjContNames = [finalPJContainer]
249 for ghostkey
in sorted(ghostlist):
250 ghostdef = jetdef._prereqDic[ghostkey]
252 pjalglist.append(ghostpjalg)
253 pjContNames.append(
str(ghostpjalg.OutputContainer) )
257 finalPJContainer =
str(finalPJContainer)+
"_merged"+mergeId
258 mergerName =
"PJMerger_id"+mergeId
259 mergeAlg =CompFactory.PseudoJetMerger(
261 InputPJContainers = pjContNames,
262 OutputContainer = finalPJContainer,
264 pjalglist.append(mergeAlg)
267 jetdef._internalAtt[
'finalPJContainer'] = finalPJContainer
271 _mergedPJContainers = dict()
273 """returns a simple unique ID for the list of PseudoJet container in pjList"""
274 t = tuple(
str(n)
for n
in pjList)
275 currentSize = len(_mergedPJContainers)
276 return str(_mergedPJContainers.setdefault(t, currentSize))
279 def getInputAlgs(jetOrConstitdef, flags, context="default", monTool=None):
280 """Returns the list of configured algs needed to build inputs to jet finding as defined by jetOrConstitdef
282 jetOrConstitdef can either be
283 * a JetDefinition : this happens when called from JetRecCfg or getJetDefAlgs then the jetdef._prereqDic/Order are used.
284 * a JetInputConstit : to allow scheduling the corresponding constituents algs independently of any jet alg.
286 context is only used if jetOrConstitdef is not a JetDefinition and must refer to a context in StandardJetContext.
288 The returned list may contain several algs, including constituent modifications algs, track selection, copying of
289 input truth particles and event density calculations
290 It may also contain ComponentAccumulator, only (?) in reco from RDO/RAW when we need to build externals such as clusters or tracks : in this case we call the main config functions from external packages)
294 from .JetDefinition
import JetInputConstit, JetDefinition
295 if isinstance(jetOrConstitdef, JetInputConstit):
297 jetlog.info(
"Setting up jet inputs from JetInputConstit : "+jetOrConstitdef.name)
298 jetdef =
solveDependencies( JetDefinition(
'Kt', 0., jetOrConstitdef, context=context), flags )
303 jetdef = jetOrConstitdef
305 jetlog.info(
"Inspecting input file contents")
309 filecontents = jetdef._cflags.Input.Collections
314 cname = c.containername
if isinstance(c, JetInputConstit)
else c.containername(jetdef,c.specs)
315 return cname
in filecontents
318 inputdeps = [ inputkey
for inputkey
in jetdef._prereqOrder
if inputkey.startswith(
'input:')
or inputkey.startswith(
'extinput:') ]
320 for inputfull
in inputdeps:
321 inputInstance = jetdef._prereqDic[inputfull]
322 if isInInput( inputInstance ):
323 jetlog.info(f
"Input container for {inputInstance} already in input file.")
327 if isinstance(inputInstance, JetInputConstit):
330 alg = inputInstance.algoBuilder( jetdef, inputInstance.specs )
342 """Construct the name of the PseudoJetContainer defined by the given JetDef or JetInputConstit.
343 This name has to be constructed from various places, so we factorize the definition here.
345 cdef = jetOrConstitdef
if isinstance(jetOrConstitdef, JetInputConstit)
else jetOrConstitdef.inputdef
346 _str_containername = cdef.containername(parent_jetdef).
split(
':')[-1]
if callable(cdef.containername)
else cdef.containername
347 end =
'' if suffix
is None else f
'_{suffix}'
348 return f
'PseudoJet{_str_containername}{end}'
351 """returns a configured PseudoJetAlgorithm which converts the inputs defined by constitdef into fastjet::PseudoJet
353 IMPORTANT : constitdef must have its dependencies solved (i.e. it must result from a solveDependencies() call)
355 the flags argument is TEMPORARY and will be removed once further dev on PseudoJetAlgorithm is done (see comment below)
357 _str_containername = constitdef.containername(parent_jetdef).
split(
':')[-1]
if callable(constitdef.containername)
else constitdef.containername
358 jetlog.debug(
"Getting PseudoJetAlg for label {0} from {1}".
format(constitdef.name,constitdef.inputname))
359 end =
'' if suffix
is None else f
'_{suffix}'
360 full_label = constitdef.label + end
361 pjgalg = CompFactory.PseudoJetAlgorithm(
362 "pjgalg_"+_str_containername+end,
363 InputContainer = _str_containername,
364 OutputContainer =
getPJContName(constitdef, suffix = suffix, parent_jetdef = parent_jetdef),
366 SkipNegativeEnergy=
True,
367 DoByVertex=constitdef.byVertex
374 if flags
is not None:
375 from AthenaConfiguration.Enums
import BeamType
376 pjgalg.UseChargedPV = (flags.Beam.Type == BeamType.Collisions)
379 pjgalg.UseChargedPV=
False
380 pjgalg.UseChargedPUsideband=
True
381 elif suffix ==
'Neut':
382 pjgalg.UseCharged=
False
388 """returns a configured PseudoJetAlgorithm which converts the inputs defined by constitdef into fastjet::PseudoJet
390 The difference for the above is this is dedicated to ghosts which need variations for the Label and the muon segment cases.
392 IMPORTANT : ghostdef must have its dependencies solved (i.e. it must result from a solveDependencies() call)
394 label =
"Ghost"+ghostdef.label
395 _container_name = ghostdef.containername(parentjetdef).
split(
":")[1]
if callable(ghostdef.containername)
else ghostdef.containername
396 _output_cont_name_suffix =
"" if parentjetdef.context ==
"default" or _container_name.endswith(parentjetdef.context)
else (
"_" + parentjetdef.context)
399 InputContainer = _container_name,
400 OutputContainer=
"PseudoJetGhost"+_container_name + _output_cont_name_suffix,
402 SkipNegativeEnergy=
True,
405 pjaclass = CompFactory.PseudoJetAlgorithm
406 if ghostdef.basetype==
"MuonSegment":
408 pjaclass = CompFactory.MuonSegmentPseudoJetAlgorithm
409 kwargs.update( Pt =1e-20 )
410 kwargs.pop(
'SkipNegativeEnergy')
412 pjgalg = pjaclass(
"pjgalg_" + label +
"_" + parentjetdef.context, **kwargs )
417 """Returns the configured JetRecAlg instance corresponding to jetdef
419 IMPORTANT : jetdef must have its dependencies solved (i.e. it must result from solveDependencies() )
421 pjContNames = jetdef._internalAtt[
'finalPJContainer']
424 "JetAlgorithm": jetdef.algorithm,
425 "JetRadius": jetdef.radius,
426 "PtMin": jetdef.ptmin,
427 "InputPseudoJets": pjContNames,
428 "GhostArea": jetdef.ghostarea,
429 "JetInputType":
int(jetdef.inputdef.jetinputtype),
431 "VariableRMinRadius": jetdef.VRMinRadius,
432 "VariableRMassScale": jetdef.VRMassScale
435 jetname = jetdef.fullname()
437 jclust = CompFactory.JetClustererByVertex(
442 jclust = CompFactory.JetClusterer(
449 jra = CompFactory.JetRecAlg(
450 "jetrecalg_"+jetname+ftf_suffix,
453 OutputContainer = jetname+ftf_suffix,
457 jra.MonTool = monTool
463 """Returns a configured JetRecAlg set-up to perform the grooming defined by 'groomdef'
464 ('monTool' is a temporary placeholder, it is expected to be used in the trigger in the future)
466 jetlog.debug(
"Configuring grooming alg \"jetalg_{0}\"".
format(groomdef.fullname()))
470 groomClass = CompFactory.getComp(groomdef.tooltype)
471 groomer = groomClass(groomdef.groomalg,
472 UngroomedJets = groomdef.ungroomeddef.fullname(),
473 ParentPseudoJets = groomdef.ungroomeddef._internalAtt[
'finalPJContainer'],
474 **groomdef.properties)
480 jetname = groomdef.fullname()
481 jra = CompFactory.JetRecAlg(
482 "jetrecalg_"+jetname,
485 OutputContainer = jetname)
488 jra.MonTool = monTool
494 def getJetCopyAlg(jetsin, jetsoutdef, decorations=[], shallowcopy=True, shallowIO=True, monTool=None):
496 Get a JetRecAlg set up to copy a jet collection and apply mods
497 In this setup we do not resolve dependencies because typically
498 these may be set up already in the original jet collection
499 In future we may wish to add a toggle.
501 The decoration list can be set in order for the decorations
502 (jet moments) on the original jets to be propagated to the
503 copy collection. Beware of circular dependencies!
505 jcopy = CompFactory.JetCopier(
508 DecorDeps=decorations,
509 ShallowCopy=shallowcopy,
514 for mod
in jetsoutdef.modifiers:
516 mods.append(
getModifier(jetsoutdef,moddef,moddef.modspec))
518 jetsoutname = jetsoutdef.fullname()
519 jra = CompFactory.JetRecAlg(
520 "jetrecalg_copy_"+jetsoutname,
523 OutputContainer = jetsoutname)
525 jra.MonTool = monTool
533 """returns a configured JetConstituentModSequence or None if constit.modifiers == []
535 The JetConstituentModSequence is determined by the JetInputConstitSeq constitSeq .
536 However, details of the configuration of the JetConstituentModSequence may depends on which JetDefinition
537 this JetConstituentModSequence is intended for. Thus the function also requires a parentjetdef JetDefinition input
539 IMPORTANT : parentjetdef & constitSeq must have their dependencies solved (i.e. they must result from solveDependencies() )
541 See also getConstitModAlg_nojetdef
546 if not isinstance(constitSeq, JetInputConstitSeq):
return
549 inputtype = constitSeq.basetype
551 sequence = constitSeq.modifiers
556 if constitSeq.inputname == constitSeq.containername:
return
558 for step
in sequence:
559 modInstance = parentjetdef._prereqDic[ f
'cmod:{step}' ]
560 if not modInstance.tooltype:
continue
562 toolclass = getattr( CompFactory, modInstance.tooltype)
565 for k,v
in modInstance.properties.items():
567 modInstance.properties[k ] =
v(parentjetdef, constitSeq )
569 tool = toolclass(modInstance.name,**modInstance.properties)
571 if (inputtype == xAODType.FlowElement
or inputtype == xAODType.ParticleFlow)
and modInstance.tooltype
not in [
"CorrectPFOTool",
"ChargedHadronSubtractionTool"]:
572 tool.IgnoreChargedPFO=
True
573 tool.ApplyToChargedPFO=
False
574 tool.InputType = inputtype
577 sequenceshort =
"".
join(sequence)
578 seqname =
"ConstitMod{0}_{1}".
format(sequenceshort,constitSeq.name)
579 inputcontainer =
str(constitSeq.inputname)
580 outputcontainer =
str(constitSeq.containername)
582 if (inputtype == xAODType.FlowElement
or inputtype == xAODType.ParticleFlow):
585 def chopPFO(thestring):
586 pfostr =
"ParticleFlowObjects"
587 if thestring.endswith(pfostr):
588 return thestring[:-len(pfostr)]
590 inputcontainer = chopPFO(inputcontainer)
591 outputcontainer = chopPFO(outputcontainer)
593 doByVertex = constitSeq.byVertex
595 inChargedFEDecorKeys = []
596 inNeutralFEDecorKeys = []
610 inChargedFEDecorKeys += [
"cellCPData",
"FE_ElectronLinks",
"FE_PhotonLinks",
"FE_MuonLinks"]
611 inNeutralFEDecorKeys += [
"calpfo_NLeadingTruthParticleBarcodeEnergyPairs",
"FE_ElectronLinks",
"FE_PhotonLinks",
"FE_MuonLinks"]
613 modseq = CompFactory.JetConstituentModSequence(seqname,
615 OutputContainer = outputcontainer,
616 InputContainer= inputcontainer,
617 InChargedFEDecorKeys = inChargedFEDecorKeys,
618 InNeutralFEDecorKeys = inNeutralFEDecorKeys,
620 DoByVertex = doByVertex
623 modseq.MonTool = monTool
625 constitmodalg = CompFactory.JetAlgorithm(
"jetalg_{0}".
format(modseq.getName()))
626 constitmodalg.Tools = [modseq]
631 """Same as getConstitModAlg.
632 This is a convenient function to obtain a JetConstituentModSequence when it is certain, no JetDef is needed.
633 This function just builds a dummy JetDefinition then calls getConstitModAlg
634 Needed in the trigger config.
636 jetdef =
solveDependencies( JetDefinition(
'Kt', 0., constitSeq, context=context) , flags)
637 constitSeq = jetdef._prereqDic[
'input:'+constitSeq.name]
642 """returns the list of configured JetModifier tools needed by this jetdef.
643 This is done by instantiating the actual C++ tool as ordered in jetdef._prereqOrder
645 modlist = [ key
for key
in jetdef._prereqOrder
if key.startswith(
'mod:')]
648 for modkey
in modlist:
649 moddef = jetdef._prereqDic[modkey]
651 modspec =
'' if ':' not in modkey
else modkey.split(
':',1)[1]
659 """Translate JetModifier into a concrete tool"""
660 jetlog.verbose(
"Retrieving modifier {0}".
format(
str(moddef)))
662 if flags
is not None:
664 jetdef = jetdef.clone()
665 jetdef._cflags = flags
666 jetdef._contextDic = flags.Jet.Context[jetdef.context]
670 modtool = moddef.createfn(jetdef, modspec)
671 except Exception
as e:
672 jetlog.error( f
"Unhandled modifier specification {modspec} for mod {moddef} acting on jet def {jetdef.basename}!")
673 jetlog.error( f
"Received exception \"{e}\"" )
674 jetlog.error( f
"Helper function is \"{moddef.createfn}\"" )
675 raise ValueError( f
"JetModConfig unable to handle mod {moddef} with spec \"{modspec}\"")
680 for k,v
in moddef.properties.items():
683 v =
v(jetdef, modspec)
684 setattr(modtool, k, v)
692 """Filters the lists jetdef.modifiers and jetdef.ghosts (and jetdef._prereqOrder), so only the components
693 comptatible with flags are selected.
694 If flags==None : assume jetdef._cflags is properly set (this is done by higher-level functions)
695 The compatibility is ultimately tested using the component 'filterfn' attributes.
696 Internally calls the function isComponentPassingConditions() (see below)
698 jetlog.info(
"Standard Reco mode : filtering components in "+
str(jetdef))
700 if jetdef._cflags
is None:
701 jetdef._cflags = flags
712 raise Exception(f
"JetDefinition {jetdef} can NOT be scheduled. Failure of input {jetdef.inputdef.name} reason={reason}" )
713 jetlog.info(f
"IMPORTANT : removing {jetdef} because input incompatible with job conditions. Reason={reason} ")
716 if isinstance( jetdef.inputdef, JetInputConstitSeq):
718 jetdef.inputdef.modifiers =
filterJetDefList(jetdef, jetdef.inputdef.modifiers,
'cmod', raiseOnFailure, jetdef._cflags)
723 jetdef.ghostdefs =
filterJetDefList(jetdef, jetdef.ghostdefs,
"ghost", raiseOnFailure, jetdef._cflags)
724 jetdef.modifiers =
filterJetDefList(jetdef, jetdef.modifiers,
"mod", raiseOnFailure, jetdef._cflags)
733 groomdef.modifiers =
filterJetDefList(groomdef, groomdef.modifiers,
"mod", raiseOnFailure, flags)
743 basekey= compType+
':' if compType!=
"" else ""
745 fullname = jetdef.fullname()
749 fullkey = basekey+comp
750 cInstance = jetdef._prereqDic[fullkey]
754 raise Exception(
"JetDefinition {} can NOT be scheduled. Failure of {} {} reason={}".
format(
755 jetdef, compType, comp, reason) )
758 jetlog.info(f
"{fullname} : removing {compType} {comp} reason={reason}")
759 if fullkey
in jetdef._prereqOrder:
760 jetdef._prereqOrder.remove(fullkey)
761 if compType==
'ghost':
767 jetlog.info(
" *** Number of {} filtered components = {} final list={}".
format(compType, nOut, outList) )
775 """Test if component is compatible with flags.
776 This is done by calling component.filterfn AND testing all its prereqs.
778 for req
in component.prereqs:
779 _str_req = req(jetdef)
if callable(req)
else req
780 if _str_req
not in jetdef._prereqDic:
781 return False,
"prereq "+_str_req+
" not available"
782 reqInstance = jetdef._prereqDic[_str_req]
785 return False,
"prereq "+
str(reqInstance)+
" failed because : "+reason
787 ok, reason = component.filterfn(flags)
792 from AthenaConfiguration.Enums
import Project
793 return Project.determine() in( Project.AnalysisBase, Project.AthAnalysis)
797 """In runIII the scheduler automatically orders algs, so the JetRecConfig helpers do not try to enforce the correct ordering.
798 This is not the case in runII config for which this jobO is intended --> This function makes sure some jet-related algs are well ordered.
800 def _flatten_CA(cfg, sequence_name="AthAlgSeq"):
801 from AthenaConfiguration.ComponentAccumulator
import ConfigurationError
802 if not isinstance(cfg, ComponentAccumulator):
803 raise ConfigurationError(
'It is not allowed to flatten with multiple top sequences')
805 if len(cfg._allSequences) != 1:
806 raise ConfigurationError(
'It is not allowed to flatten with multiple top sequences')
808 sequence = cfg.getSequence(sequence_name)
809 if sequence.Sequential:
810 raise ConfigurationError(
'It is not allowed to flatten sequential sequences')
813 for member
in sequence.Members:
814 if isinstance(member, CompFactory.AthSequencer):
815 members.extend(_flatten_CA(cfg, member.getName()))
817 members.append(member)
819 sequence.Members = members
825 if not isinstance(a, ComponentAccumulator) :
829 ca_algs =
list(a._algorithms.keys())
831 algs_tmp.append(a.popEventAlgo(algo))
835 evtDensityAlgs = [(i, alg)
for (i, alg)
in enumerate(algs)
if alg
and alg.getType() ==
'EventDensityAthAlg' ]
836 pjAlgs = [(i, alg)
for (i, alg)
in enumerate(algs)
if alg
and alg.getType() ==
'PseudoJetAlgorithm' ]
838 for i, edalg
in evtDensityAlgs:
839 edInput = edalg.EventDensityTool.InputContainer
840 for j, pjalg
in pjAlgs:
843 if edInput ==
str(pjalg.OutputContainer):
844 pairsToswap.append((i, j))
845 for i, j
in pairsToswap:
846 algs[i], algs[j] = algs[j], algs[i]
853 """Make the jet collection described by jetdef available as constituents to other jet finding
855 Technically : create JetInputExternal and JetInputConstit and register them in the relevant look-up dictionnaries.
856 the JetInputConstit will have a algoBuilder to generate the JetContainer described by jetdef
858 from .StandardJetConstits
import stdConstitDic, stdInputExtDic
859 jetname = jetdef.fullname()
862 def jetBuilder(largejetdef,spec):
863 return JetRecCfg(largejetdef._cflags, jetdef)
865 stdInputExtDic[jetname] = JetInputExternal( jetname, jetname, algoBuilder=jetBuilder)
866 stdConstitDic[jetname] = JetInputConstit(jetname, xAODType.Jet, jetname )
878 from AthenaConfiguration.AllConfigFlags
import initConfigFlags
881 from AthenaConfiguration.TestDefaults
import defaultTestFiles, defaultConditionsTags
882 flags.Input.Files = defaultTestFiles.LATEST_AOD_MC
883 flags.IOVDb.GlobalTag = defaultConditionsTags.LATEST_MC
888 from AthenaConfiguration.MainServicesConfig
import MainServicesCfg
892 from AthenaPoolCnvSvc.PoolReadConfig
import PoolReadCfg
896 from JetRecConfig.StandardSmallRJets
import AntiKt4EMTopo
897 cfg.merge(
JetRecCfg(flags, AntiKt4EMTopo))
899 cfg.printConfig(withDetails=
False,summariseProps=
True)
902 if __name__==
"__main__":