Utilities Namespace Reference

Classes
class	TestModuleCommand
Functions
def	_build_options
def	convertToUnscheduled
def	getHltConfiguration
def	loadHltConfiguration
def	removeModulesNotOnAPathExcluding

---

Function Documentation

def Utilities::_build_options

(

args

)

[private]

Definition at line 6 of file Utilities.py.

                          :
  options = _options.HLTProcessOptions()
  for key, val in args.iteritems():
    setattr(options, key, val)
  return options

def Utilities::convertToUnscheduled

(

proc

)

Definition at line 27 of file Utilities.py.

                              :
  import FWCore.ParameterSet.Config as cms
  """Given a 'Process', convert from scheduled execution to unscheduled. This is done by
    1. Removing all modules not on Paths or EndPaths
    2. Pulling all EDProducers off of all Paths
    3. Dropping any paths which are now empty
    4. Fixing up the Schedule if needed
  """
  proc.prune()
  if not hasattr(proc,'options'):
    proc.options = cms.untracked.PSet()
  proc.options.allowUnscheduled = cms.untracked.bool(True)
  l = proc.paths
  droppedPaths =[]
  #have to get them now since switching them after the
  # paths have been changed gives null labels
  if proc.schedule:
    pathNamesInScheduled = [p.label_() for p in proc.schedule]
  else:
    pathNamesInScheduled = False
  
  for pName,p in l.iteritems():
    nodes = []
    v = cms.ModuleNodeVisitor(nodes)
    p.visit(v)
    names = [node.label_() for node in nodes]
    remaining =[]
    for n in names:
      if not isinstance(getattr(proc,n), cms.EDProducer):
        remaining.append(n)
    if remaining:
      p=getattr(proc,remaining[0])
      for m in remaining[1:]:
        p+=getattr(proc,m)
      setattr(proc,pName,cms.Path(p))
    else:
      delattr(proc,pName)
      droppedPaths.append(pName)
  if droppedPaths and proc.schedule:
    for p in droppedPaths:
      if p in pathNamesInScheduled:
        pathNamesInScheduled.remove(p)
    proc.schedule = cms.Schedule([getattr(proc,p) for p in pathNamesInScheduled])

def Utilities::getHltConfiguration	(		menu,
			args
	)

Definition at line 13 of file Utilities.py.

                                     :
  args['menu']     = menu
  args['fragment'] = False
  options = _build_options(**args)

  hlt = _imp.new_module('hlt')
  exec _confdb.HLTProcess(options).dump() in globals(), hlt.__dict__
  return hlt.process

def Utilities::loadHltConfiguration	(		process,
			menu,
			args
	)

Definition at line 23 of file Utilities.py.

                                               :
  args['menu']     = menu
  args['fragment'] = True
  options = _build_options(**args)

  hlt = _imp.new_module('hlt')
  exec _confdb.HLTProcess(options).dump() in globals(), hlt.__dict__
  process.extend( hlt )

def Utilities::removeModulesNotOnAPathExcluding	(		process,
			keepList = ()
	)

Given a 'process', find all modules (EDProducers,EDFilters,EDAnalyzers,OutputModules)
and remove them if they do not appear on a Path or EndPath.  One can optionally pass in
a list of modules which even if they are not on a Path or EndPath you wish to have stay 
in the configuration [useful for unscheduled execution].

Definition at line 1 of file Utilities.py.

                                                            :
    """Given a 'process', find all modules (EDProducers,EDFilters,EDAnalyzers,OutputModules)
    and remove them if they do not appear on a Path or EndPath.  One can optionally pass in
    a list of modules which even if they are not on a Path or EndPath you wish to have stay 
    in the configuration [useful for unscheduled execution].
    """
    allMods=set((x for x in process.producers_().iterkeys()))
    allMods.update((x for x in process.filters_().iterkeys()))
    allMods.update((x for x in process.analyzers_().iterkeys()))
    allMods.update((x for x in process.outputModules_().iterkeys()))
    
    modulesOnPaths = set()
    for p in process.paths_():
        modulesOnPaths.update( (x for x in getattr(process,p).moduleNames()))        
    for p in process.endpaths_():
        modulesOnPaths.update( (x for x in getattr(process,p).moduleNames()))

    notOnPaths = allMods.difference(modulesOnPaths)
    
    keepModuleNames = set( (x.label_() for x in keepList) )
    
    getRidOf = notOnPaths.difference(keepModuleNames)
    
    for n in getRidOf:
        delattr(process,n)