Classes
class	CloneSequenceVisitor

struct	CompositeCandidateMaker

struct	CompositePtrCandidateMaker

class	GatherAllModulesVisitor

struct	MCTruthPairSelector

struct	NamedCompositeCandidateMaker

class	TestModuleCommand

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

def	_lineDiff (newString, oldString)

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, verbose=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="")

def	testContains (self)

def	testJetCollectionString (self)

def	testListModules (self)

Function Documentation

◆ __labelsInSequence()

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

private

Definition at line 129 of file helpers.py.

 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

References listModules(), and listSequences().

Referenced by removeIfInSequence().

◆ _lineDiff()

def helpers._lineDiff	(	newString,
		oldString
	)

private

Definition at line 367 of file helpers.py.

     def _lineDiff(newString, oldString):
         newString = ( x for x in newString.split('\n') if len(x) > 0)
         oldString = [ x for x in oldString.split('\n') if len(x) > 0]
         diff = []
         oldStringLine = 0
         for l in newString:
             if oldStringLine >= len(oldString):
                 diff.append(l)
                 continue
             if l == oldString[oldStringLine]:
                 oldStringLine +=1
                 continue
             diff.append(l)
         return "\n".join( diff )
  

References join().

◆ addESProducers()

def helpers.addESProducers	(	process,
		config
	)

Definition at line 32 of file helpers.py.

 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 isinstance(item, cms.PSet):
             if 'ESProducer' in item.type_():
                 setattr(process,name,item)
  

References DeadROC_duringRun.dir.

◆ addKeepStatement()

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 354 of file helpers.py.

 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.items():
         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)
  
  

References print().

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

◆ addToProcessAndTask()

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

Definition at line 28 of file helpers.py.

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

◆ addToTask()

def helpers.addToTask	(	loadedProducersAndFilters,
		module
	)

Definition at line 55 of file helpers.py.

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

Referenced by extendWithPrePostfix().

◆ applyPostfix()

def helpers.applyPostfix	(	process,
		label,
		postfix
	)

Definition at line 114 of file helpers.py.

 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
  

Referenced by pfTools.adaptPFMuons(), pfTools.addPFCandidates(), pfTools.reconfigurePF2PATTaus(), pfTools.switchToPFJets(), pfTools.switchToPFMET(), pfTools.tauTypeInPF2PAT(), and pfTools.usePF2PAT().

◆ associatePatAlgosToolsTask()

def helpers.associatePatAlgosToolsTask ( process )

Definition at line 24 of file helpers.py.

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

References getPatAlgosToolsTask().

Referenced by ConfigBuilder.ConfigBuilder.prepare().

◆ cloneProcessingSnippet()

def helpers.cloneProcessingSnippet	(	process,
		sequence,
		postfix,
		removePostfix = `""`,
		noClones = `[]`,
		addToTask = `False`,
		verbose = `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 257 of file helpers.py.

 def cloneProcessingSnippet(process, sequence, postfix, removePostfix="", noClones = [], addToTask = False, verbose = 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, verbose)
         sequence.visit(visitor)
         result = visitor.clonedSequence()
     return result
  

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

◆ contains()

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 241 of file helpers.py.

 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
  
  
  

References spr.find().

Referenced by testContains().

◆ extendWithPrePostfix()

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

Look in other and find types which we can use

Definition at line 60 of file helpers.py.

 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)
  

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

Referenced by loadWithPrePostfix().

◆ get_path()

def helpers.get_path ( file_in_path )

Definition at line 6 of file helpers.py.

 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)
  

Referenced by get_vars().

◆ get_vars()

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

Definition at line 18 of file helpers.py.

 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]
    

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

◆ getPatAlgosToolsTask()

def helpers.getPatAlgosToolsTask ( process )

Definition at line 13 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
  

◆ jetCollectionString()

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 217 of file helpers.py.

 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
  

References if().

Referenced by testJetCollectionString(), heavyIonTools.ProductionDefaults.toolCode(), coreTools.RemoveMCMatching.toolCode(), and heavyIonTools.SelectionDefaults.toolCode().

◆ listDependencyChain()

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 272 of file helpers.py.

 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_().items():
             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)
  

References mps_setup.append, mps_monitormerge.items, and print().

Referenced by extraJets_MuEGFixMoriond2017.backupJetsFirstStep().

◆ listModules()

def helpers.listModules ( sequence )

Definition at line 207 of file helpers.py.

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

Referenced by __labelsInSequence(), trigTools._modulesInPath(), extraJets_MuEGFixMoriond2017.backupJetsSecondStep(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.labelsInSequence(), and testListModules().

◆ listSequences()

def helpers.listSequences ( sequence )

Definition at line 212 of file helpers.py.

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

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

◆ loadWithPostfix()

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

Definition at line 46 of file helpers.py.

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

References loadWithPrePostfix().

Referenced by pfTools.usePF2PAT().

◆ loadWithPrefix()

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

Definition at line 43 of file helpers.py.

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

References loadWithPrePostfix().

Referenced by jetTools.setupBTagging().

◆ loadWithPrePostfix()

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

Definition at line 49 of file helpers.py.

 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)
  

References extendWithPrePostfix().

Referenced by loadWithPostfix(), and loadWithPrefix().

◆ removeIfInSequence()

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

Definition at line 122 of file helpers.py.

 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)
             )
  

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

◆ testContains()

def helpers.testContains ( self )

Definition at line 415 of file helpers.py.

         def testContains(self):
             p = cms.Process("test")
             p.a = cms.EDProducer("a", src=cms.InputTag("gen"))
             p.b = cms.EDProducer("ab", src=cms.InputTag("a"))
             p.c = cms.EDProducer("ac", src=cms.InputTag("b"))
             p.s1 = cms.Sequence(p.a*p.b*p.c)
             p.s2 = cms.Sequence(p.b*p.c)
             self.assertTrue( contains(p.s1, "a") )
             self.assertTrue( not contains(p.s2, "a") )

References contains().

◆ testJetCollectionString()

def helpers.testJetCollectionString ( self )

Definition at line 424 of file helpers.py.

         def testJetCollectionString(self):
             self.assertEqual(jetCollectionString(algo = 'Foo', type = 'Bar'), 'patJetsFooBar')
             self.assertEqual(jetCollectionString(prefix = 'prefix', algo = 'Foo', type = 'Bar'), 'prefixPatJetsFooBar')

References jetCollectionString().

◆ testListModules()

def helpers.testListModules ( self )

Definition at line 427 of file helpers.py.

         def testListModules(self):
             p = cms.Process("test")
             p.a = cms.EDProducer("a", src=cms.InputTag("gen"))
             p.b = cms.EDProducer("ab", src=cms.InputTag("a"))
             p.c = cms.EDProducer("ac", src=cms.InputTag("b"))
             p.s = cms.Sequence(p.a*p.b*p.c)
             self.assertEqual([p.a,p.b,p.c], listModules(p.s))
  

References listModules().

Classes

Functions