Classes
class	CloneSequenceVisitor

struct	CompositeCandidateMaker

struct	CompositePtrCandidateMaker

class	GatherAllModulesVisitor

struct	MCTruthPairSelector

struct	NamedCompositeCandidateMaker

class	TestModuleCommand

Functions
def	__labelsInSequence (process, sequenceLabel, postfix="", keepPostFix=False)

def	addESProducers (process, config)

def	addKeepStatement (process, oldKeep, newKeeps, verbose=False)

def	addToProcessAndTask (label, module, process, task)

def	addToTask (loadedProducersAndFilters, module)

def	applyPostfix (process, label, postfix)

def	associatePatAlgosToolsTask (process)

def	cloneProcessingSnippet (process, sequence, postfix, removePostfix="", noClones=[], addToTask=False)

def	contains (sequence, moduleName)

def	extendWithPrePostfix (process, other, prefix, postfix, loadedProducersAndFilters=None)

def	get_path (file_in_path)

def	get_vars (xml_path, useFileInPath=True)

def	getPatAlgosToolsTask (process)

def	jetCollectionString (prefix='', algo='', type='')

def	listDependencyChain (process, module, sources, verbose=False)

def	listModules (sequence)

def	listSequences (sequence)

def	loadWithPostfix (process, moduleName, postfix='', loadedProducersAndFilters=None)

def	loadWithPrefix (process, moduleName, prefix='', loadedProducersAndFilters=None)

def	loadWithPrePostfix (process, moduleName, prefix='', postfix='', loadedProducersAndFilters=None)

def	removeIfInSequence (process, target, sequenceLabel, postfix="")

Function Documentation

def helpers.__labelsInSequence	(	process,
		sequenceLabel,
		postfix = `""`,
		keepPostFix = `False`
	)

private

Definition at line 128 of file helpers.py.

References listModules(), and listSequences().

Referenced by removeIfInSequence().

 def __labelsInSequence(process, sequenceLabel, postfix="", keepPostFix=False):
     position = -len(postfix)
     if keepPostFix: 
         position = None
 
     result = [ m.label()[:position] for m in listModules( getattr(process,sequenceLabel+postfix))]
     result.extend([ m.label()[:position] for m in listSequences( getattr(process,sequenceLabel+postfix))]  )
     if postfix == "":
         result = [ m.label() for m in listModules( getattr(process,sequenceLabel+postfix))]
         result.extend([ m.label() for m in listSequences( getattr(process,sequenceLabel+postfix))]  )
     return result
 
 #FIXME name is not generic enough now

def helpers.addESProducers	(	process,
		config
	)

Definition at line 31 of file helpers.py.

References dir.

 def addESProducers(process,config):
     config = config.replace("/",".")
     #import RecoBTag.Configuration.RecoBTag_cff as btag
     #print btag
     module = __import__(config)
     for name in dir(sys.modules[config]):
         item = getattr(sys.modules[config],name)
         if isinstance(item,cms._Labelable) and not isinstance(item,cms._ModuleSequenceType) and not name.startswith('_') and not (name == "source" or name == "looper" or name == "subProcess") and not type(item) is cms.PSet:
             if 'ESProducer' in item.type_():
                 setattr(process,name,item)
 

def helpers.addKeepStatement	(	process,
		oldKeep,
		newKeeps,
		verbose = `False`
	)

Add new keep statements to any PoolOutputModule of the process that has the old keep statements

Definition at line 352 of file helpers.py.

Referenced by customizeMiniAOD_MuEGFixMoriond2017.addDiscardedPFCandidates(), extraSlimmedMETs_MuEGFixMoriond2017.addExtraMETCollections(), extraSlimmedMETs_MuEGFixMoriond2017.addExtraPuppiMETCorrections(), extraJets_MuEGFixMoriond2017.backupJetsSecondStep(), and customizeMiniAOD_MuEGFixMoriond2017.customizeAll().

 def addKeepStatement(process, oldKeep, newKeeps, verbose=False):
     """Add new keep statements to any PoolOutputModule of the process that has the old keep statements"""
     for name,out in process.outputModules.iteritems():
         if out.type_() == 'PoolOutputModule' and hasattr(out, "outputCommands"):
             if oldKeep in out.outputCommands:
                 out.outputCommands += newKeeps
             if verbose:
                 print "Adding the following keep statements to output module %s: " % name
                 for k in newKeeps: print "\t'%s'," % k
 
 

def helpers.addToProcessAndTask	(	label,
		module,
		process,
		task
	)

Definition at line 27 of file helpers.py.

 def addToProcessAndTask(label, module, process, task):
     setattr(process, label, module)
     task.add(getattr(process, label))
 

def helpers.addToTask	(	loadedProducersAndFilters,
		module
	)

Definition at line 54 of file helpers.py.

Referenced by extendWithPrePostfix().

 def addToTask(loadedProducersAndFilters, module):
     if loadedProducersAndFilters:
         if isinstance(module, cms.EDProducer) or isinstance(module, cms.EDFilter):
             loadedProducersAndFilters.add(module)
 

def helpers.applyPostfix	(	process,
		label,
		postfix
	)

Definition at line 113 of file helpers.py.

Referenced by pfTools.adaptPFMuons(), pfTools.addPFCandidates(), pfTools.reconfigurePF2PATTaus(), pfTools.switchToPFJets(), pfTools.switchToPFMET(), pfTools.tauTypeInPF2PAT(), HiCoreTools.RemoveMCMatching.toolCode(), HiCoreTools.RemoveSpecificPATObjects.toolCode(), HiCoreTools.RemoveCleaning.toolCode(), and pfTools.usePF2PAT().

 def applyPostfix(process, label, postfix):
     result = None
     if hasattr(process, label+postfix):
         result = getattr(process, label + postfix)
     else:
         raise ValueError("Error in <applyPostfix>: No module of name = %s attached to process !!" % (label + postfix))
     return result
 

def helpers.associatePatAlgosToolsTask ( process )

Definition at line 23 of file helpers.py.

References getPatAlgosToolsTask().

Referenced by ConfigBuilder.ConfigBuilder.prepare().

 def associatePatAlgosToolsTask(process):
     task = getPatAlgosToolsTask(process)
     process.schedule.associate(task)
 

def helpers.cloneProcessingSnippet	(	process,
		sequence,
		postfix,
		removePostfix = `""`,
		noClones = `[]`,
		addToTask = `False`
	)

------------------------------------------------------------------
copy a sequence plus the modules and sequences therein
both are renamed by getting a postfix
input tags are automatically adjusted
------------------------------------------------------------------

Definition at line 255 of file helpers.py.

Referenced by boostedHPSPFTaus_cfi.addBoostedTaus(), extraSlimmedMETs_MuEGFixMoriond2017.addExtraMETCollections(), extraJets_MuEGFixMoriond2017.backupJetsFirstStep(), extraJets_MuEGFixMoriond2017.makeRecoJetCollection(), pfIsolation.setupPFIso(), and pfIsolation.setupPFIsoPhoton().

 def cloneProcessingSnippet(process, sequence, postfix, removePostfix="", noClones = [], addToTask = False):
    """
    ------------------------------------------------------------------
    copy a sequence plus the modules and sequences therein
    both are renamed by getting a postfix
    input tags are automatically adjusted
    ------------------------------------------------------------------
    """
    result = sequence
    if not postfix == "":
        visitor = CloneSequenceVisitor(process, sequence.label(), postfix, removePostfix, noClones, addToTask)
        sequence.visit(visitor)
        result = visitor.clonedSequence()
    return result
 

def helpers.contains	(	sequence,
		moduleName
	)

------------------------------------------------------------------
return True if a module with name 'module' is contained in the
sequence with name 'sequence' and False otherwise. This version
is not so nice as it also returns True for any substr of the name
of a contained module.

sequence : sequence [e.g. process.patDefaultSequence]
module   : module name as a string
------------------------------------------------------------------

Definition at line 239 of file helpers.py.

References spr.find().

Referenced by helpers.TestModuleCommand.testContains().

 def contains(sequence, moduleName):
     """
     ------------------------------------------------------------------
     return True if a module with name 'module' is contained in the
     sequence with name 'sequence' and False otherwise. This version
     is not so nice as it also returns True for any substr of the name
     of a contained module.
 
     sequence : sequence [e.g. process.patDefaultSequence]
     module   : module name as a string
     ------------------------------------------------------------------
     """
     return not sequence.__str__().find(moduleName)==-1
 
 
 

def helpers.extendWithPrePostfix	(	process,
		other,
		prefix,
		postfix,
		loadedProducersAndFilters = `None`
	)

Look in other and find types which we can use

Definition at line 59 of file helpers.py.

References addToTask(), dir, and MassReplace.massSearchReplaceAnyInputTag().

Referenced by loadWithPrePostfix().

 def extendWithPrePostfix(process,other,prefix,postfix,loadedProducersAndFilters=None):
     """Look in other and find types which we can use"""
     # enable explicit check to avoid overwriting of existing objects
     #__dict__['_Process__InExtendCall'] = True
 
     if loadedProducersAndFilters:
         task = getattr(process, loadedProducersAndFilters)
         if not isinstance(task, cms.Task):
             raise Exception("extendWithPrePostfix argument must be name of Task type object attached to the process or None")
     else:
         task = None
 
     sequence = cms.Sequence()
     sequence._moduleLabels = []
     for name in dir(other):
         #'from XX import *' ignores these, and so should we.
         if name.startswith('_'):
             continue
         item = getattr(other,name)
         if name == "source" or name == "looper" or name == "subProcess":
             continue
         elif isinstance(item,cms._ModuleSequenceType):
             continue
         elif isinstance(item,cms.Task):
             continue
         elif isinstance(item,cms.Schedule):
             continue
         elif isinstance(item,cms.VPSet) or isinstance(item,cms.PSet):
             continue
         elif isinstance(item,cms._Labelable):
             if not item.hasLabel_():
                 item.setLabel(name)
             if prefix != '' or postfix != '':
                 newModule = item.clone()
                 if isinstance(item,cms.ESProducer):
                     newName =name
                 else:
                     if 'TauDiscrimination' in name:
                         process.__setattr__(name,item)
                         addToTask(task, item)
                     newName = prefix+name+postfix
                 process.__setattr__(newName,newModule)
                 addToTask(task, newModule)
                 if isinstance(newModule, cms._Sequenceable) and not newName == name:
                     sequence +=getattr(process,newName)
                     sequence._moduleLabels.append(item.label())
             else:
                 process.__setattr__(name,item)
                 addToTask(task, item)
 
     if prefix != '' or postfix != '':
         for label in sequence._moduleLabels:
             massSearchReplaceAnyInputTag(sequence, label, prefix+label+postfix,verbose=False,moduleLabelOnly=True)
 

def helpers.get_path ( file_in_path )

Definition at line 6 of file helpers.py.

Referenced by get_vars().

 def get_path(file_in_path):
    'mimics edm.FileInPath behavior'
    search_env = os.environ.get('CMSSW_SEARCH_PATH', '')
    if not search_env:
       raise RuntimeError('The environmental variable CMSSW_SEARCH_PATH must be set')
    search_paths = search_env.split(':')
    for spath in search_paths:
       full_path = os.path.join(spath, file_in_path)
       if os.path.isfile(full_path):
          return full_path
    raise RuntimeError('No suitable path found for %s' % file_in_path)
 

def helpers.get_vars	(	xml_path,
		useFileInPath = `True`
	)

Definition at line 18 of file helpers.py.

References get_path(), and trainingvars.get_var_pset().

 def get_vars(xml_path, useFileInPath=True):
    full_path = get_path(xml_path) if useFileInPath else xml_path
    xml_tree = ET.parse(full_path)
    root = xml_tree.getroot()
    variables = None
    for i in root:
       if i.tag == 'Variables':
          variables = i
 
    if i is None:
       raise RuntimeError('Could not find Variables inside the xml weights')
    
    var_names = [i.attrib['Title'] for i in variables]
    return [get_var_pset(i) for i in var_names]
    

def helpers.getPatAlgosToolsTask ( process )

Definition at line 12 of file helpers.py.

 def getPatAlgosToolsTask(process):
     taskName = "patAlgosToolsTask"
     if hasattr(process, taskName):
         task = getattr(process, taskName)
         if not isinstance(task, cms.Task):
             raise Exception("patAlgosToolsTask does not have type Task")
     else:
         setattr(process, taskName, cms.Task())
         task = getattr(process, taskName)
     return task
 

def helpers.jetCollectionString	(	prefix = `''`,
		algo = `''`,
		type = `''`
	)

------------------------------------------------------------------
return the string of the jet collection module depending on the
input vaules. The default return value will be 'patAK5CaloJets'.

algo   : indicating the algorithm type of the jet [expected are
         'AK5', 'IC5', 'SC7', ...]
type   : indicating the type of constituents of the jet [expec-
         ted are 'Calo', 'PFlow', 'JPT', ...]
prefix : prefix indicating the type of pat collection module (ex-
         pected are '', 'selected', 'clean').
------------------------------------------------------------------

Definition at line 215 of file helpers.py.

References reco.if().

Referenced by helpers.TestModuleCommand.testJetCollectionString(), heavyIonTools.ProductionDefaults.toolCode(), HiCoreTools.RemoveMCMatching.toolCode(), coreTools.RemoveMCMatching.toolCode(), heavyIonTools.SelectionDefaults.toolCode(), and HiCoreTools.RemoveSpecificPATObjects.toolCode().

 def jetCollectionString(prefix='', algo='', type=''):
     """
     ------------------------------------------------------------------
     return the string of the jet collection module depending on the
     input vaules. The default return value will be 'patAK5CaloJets'.
 
     algo   : indicating the algorithm type of the jet [expected are
              'AK5', 'IC5', 'SC7', ...]
     type   : indicating the type of constituents of the jet [expec-
              ted are 'Calo', 'PFlow', 'JPT', ...]
     prefix : prefix indicating the type of pat collection module (ex-
              pected are '', 'selected', 'clean').
     ------------------------------------------------------------------
     """
     if(prefix==''):
         jetCollectionString ='pat'
     else:
         jetCollectionString =prefix
         jetCollectionString+='Pat'
     jetCollectionString+='Jets'
     jetCollectionString+=algo
     jetCollectionString+=type
     return jetCollectionString
 

def helpers.listDependencyChain	(	process,
		module,
		sources,
		verbose = `False`
	)

Walk up the dependencies of a module to find any that depend on any of the listed sources

Definition at line 270 of file helpers.py.

References mps_setup.append.

Referenced by extraJets_MuEGFixMoriond2017.backupJetsFirstStep().

 def listDependencyChain(process, module, sources, verbose=False):
     """
     Walk up the dependencies of a module to find any that depend on any of the listed sources
     """
     def allDirectInputModules(moduleOrPSet,moduleName,attrName):
         ret = set()
         for name,value in moduleOrPSet.parameters_().iteritems():
             type = value.pythonTypeName()
             if type == 'cms.PSet':
                 ret.update(allDirectInputModules(value,moduleName,moduleName+"."+name))
             elif type == 'cms.VPSet':
                 for (i,ps) in enumerate(value):
                     ret.update(allDirectInputModules(ps,moduleName,"%s.%s[%d]"%(moduleName,name,i)))
             elif type == 'cms.VInputTag':
                 inputs = [ MassSearchReplaceAnyInputTagVisitor.standardizeInputTagFmt(it) for it in value ]
                 inputLabels = [ tag.moduleLabel for tag in inputs if tag.processName == '' or tag.processName == process.name_() ]
                 ret.update(inputLabels)
                 if verbose and inputLabels: print "%s depends on %s via %s" % (moduleName, inputLabels, attrName+"."+name)
             elif type.endswith('.InputTag'):
                 if value.processName == '' or value.processName == process.name_():
                     ret.add(value.moduleLabel)
                     if verbose: print "%s depends on %s via %s" % (moduleName, value.moduleLabel, attrName+"."+name)
         ret.discard("")
         return ret
     def fillDirectDepGraphs(root,fwdepgraph,revdepgraph):
         if root.label_() in fwdepgraph: return
         deps = allDirectInputModules(root,root.label_(),root.label_())
         fwdepgraph[root.label_()] = []
         for d in deps:        
             fwdepgraph[root.label_()].append(d)
             if d not in revdepgraph: revdepgraph[d] = []
             revdepgraph[d].append(root.label_())
             depmodule = getattr(process,d,None)
             if depmodule:
                 fillDirectDepGraphs(depmodule,fwdepgraph,revdepgraph)
         return (fwdepgraph,revdepgraph)
     fwdepgraph, revdepgraph = fillDirectDepGraphs(module, {}, {})
     def flattenRevDeps(flatgraph, revdepgraph, tip):
         """Make a graph that for each module lists all the ones that depend on it, directly or indirectly"""
         # don't do it multiple times for the same module
         if tip in flatgraph: return 
         # if nobody depends on this module, there's nothing to do
         if tip not in revdepgraph: return
         # assemble my dependencies, in a depth-first approach
         mydeps = set()
         # start taking the direct dependencies of this module
         for d in revdepgraph[tip]:
             # process them
             flattenRevDeps(flatgraph, revdepgraph, d)
             # then add them and their processed dependencies to our deps
             mydeps.add(d)
             if d in flatgraph: 
                  mydeps.update(flatgraph[d])
         flatgraph[tip] = mydeps
     flatdeps = {}
     allmodules = set()
     for s in sources: 
         flattenRevDeps(flatdeps, revdepgraph, s)
         if s in flatdeps: allmodules.update(f for f in flatdeps[s])
     livemodules = [ a for a in allmodules if hasattr(process,a) ]
     if not livemodules: return None
     modulelist = [livemodules.pop()]
     for module in livemodules:
         for i,m in enumerate(modulelist):
             if module in flatdeps and m in flatdeps[module]:
                 modulelist.insert(i, module)
                 break
     if module not in modulelist:
             modulelist.append(module)
     # Validate
     for i,m1 in enumerate(modulelist):
         for j,m2 in enumerate(modulelist):
             if j <= i: continue
             if m2 in flatdeps and m1 in flatdeps[m2]:
                 raise RuntimeError("BAD ORDER %s BEFORE %s" % (m1,m2))
     modules = [ getattr(process,p) for p in modulelist ]
     #return cms.Sequence(sum(modules[1:],modules[0]))
     task = cms.Task()
     for mod in modules: 
         task.add(mod)
     return task,cms.Sequence(task)
 

def helpers.listModules ( sequence )

Definition at line 205 of file helpers.py.

Referenced by __labelsInSequence(), trigTools._modulesInPath(), extraJets_MuEGFixMoriond2017.backupJetsSecondStep(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.labelsInSequence(), helpers.TestModuleCommand.testListModules(), HiCoreTools.RemoveCleaning.toolCode(), and HiCoreTools.AddCleaning.toolCode().

 def listModules(sequence):
     visitor = GatherAllModulesVisitor(gatheredInstance=cms._Module)
     sequence.visit(visitor)
     return visitor.modules()
 

def helpers.listSequences ( sequence )

Definition at line 210 of file helpers.py.

Referenced by __labelsInSequence(), and runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.labelsInSequence().

 def listSequences(sequence):
     visitor = GatherAllModulesVisitor(gatheredInstance=cms.Sequence)
     sequence.visit(visitor)
     return visitor.modules()
 

def helpers.loadWithPostfix	(	process,
		moduleName,
		postfix = `''`,
		loadedProducersAndFilters = `None`
	)

Definition at line 45 of file helpers.py.

References loadWithPrePostfix().

Referenced by pfTools.usePF2PAT().

 def loadWithPostfix(process,moduleName,postfix='',loadedProducersAndFilters=None):
         loadWithPrePostfix(process,moduleName,'',postfix,loadedProducersAndFilters)
 

def helpers.loadWithPrefix	(	process,
		moduleName,
		prefix = `''`,
		loadedProducersAndFilters = `None`
	)

Definition at line 42 of file helpers.py.

References loadWithPrePostfix().

Referenced by jetTools.setupBTagging().

 def loadWithPrefix(process,moduleName,prefix='',loadedProducersAndFilters=None):
         loadWithPrePostfix(process,moduleName,prefix,'',loadedProducersAndFilters)
 

def helpers.loadWithPrePostfix	(	process,
		moduleName,
		prefix = `''`,
		postfix = `''`,
		loadedProducersAndFilters = `None`
	)

Definition at line 48 of file helpers.py.

References extendWithPrePostfix().

Referenced by loadWithPostfix(), and loadWithPrefix().

 def loadWithPrePostfix(process,moduleName,prefix='',postfix='',loadedProducersAndFilters=None):
     moduleName = moduleName.replace("/",".")
         module = __import__(moduleName)
     #print module.PatAlgos.patSequences_cff.patDefaultSequence
         extendWithPrePostfix(process,sys.modules[moduleName],prefix,postfix,loadedProducersAndFilters)
 

def helpers.removeIfInSequence	(	process,
		target,
		sequenceLabel,
		postfix = `""`
	)

Definition at line 121 of file helpers.py.

References __labelsInSequence(), and MatrixUtil.remove().

Referenced by HiCoreTools.RemoveSpecificPATObjects.toolCode().

 def removeIfInSequence(process, target,  sequenceLabel, postfix=""):
     labels = __labelsInSequence(process, sequenceLabel, postfix, True)
     if target+postfix in labels:
         getattr(process, sequenceLabel+postfix).remove(
             getattr(process, target+postfix)
             )
 

Classes

Functions

Function Documentation