Reference Manual

def helpers._lineDiff	(	newString,
		oldString
	)

private

Definition at line 367 of file helpers.py.

References join().

 
     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 )

join

static std::string join(char **cmd)

Definition: RemoteFile.cc:19

helpers._lineDiff

def _lineDiff

Definition: helpers.py:367

def helpers.addESProducers	(	process,
		config
	)

Definition at line 32 of file helpers.py.

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

helpers.addESProducers

def addESProducers

Definition: helpers.py:32

DeadROC_duringRun.dir

string dir

Definition: DeadROC_duringRun.py:23

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.

References print().

Referenced by customizeMiniAOD_MuEGFixMoriond2017.addDiscardedPFCandidates(), customizeMiniAOD_HcalFixLegacy2016.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.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)
 

print

void print(TMatrixD &m, const char *label=nullptr, bool mathematicaFormat=false)

Definition: Utilities.cc:47

helpers.addKeepStatement

def addKeepStatement

Definition: helpers.py:354

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

helpers.addToProcessAndTask

def addToProcessAndTask

Definition: helpers.py:28

def helpers.addToTask	(	loadedProducersAndFilters,
		module
	)

Definition at line 55 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)

helpers.addToTask

def addToTask

Definition: helpers.py:55

def helpers.applyPostfix	(	process,
		label,
		postfix
	)

Definition at line 114 of file helpers.py.

Referenced by pfTools.adaptPFMuons(), pfTools.addPFCandidates(), pfTools.reconfigurePF2PATTaus(), pfTools.switchToPFJets(), pfTools.switchToPFMET(), pfTools.tauTypeInPF2PAT(), 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

helpers.applyPostfix

def applyPostfix

Definition: helpers.py:114

def helpers.associatePatAlgosToolsTask ( process )

Definition at line 24 of file helpers.py.

References getPatAlgosToolsTask().

Referenced by ConfigBuilder.ConfigBuilder.prepare().

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

helpers.getPatAlgosToolsTask

def getPatAlgosToolsTask

Definition: helpers.py:13

helpers.associatePatAlgosToolsTask

def associatePatAlgosToolsTask

Definition: helpers.py:24

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.

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

helpers.cloneProcessingSnippet

def cloneProcessingSnippet

Definition: helpers.py:257

helpers.CloneSequenceVisitor

Definition: helpers.py:155

def helpers.cloneProcessingSnippetTask	(	process,
		task,
		postfix,
		removePostfix = `""`,
		noClones = `[]`,
		verbose = `False`
	)

------------------------------------------------------------------
copy a task plus the modules therein (including modules in subtasks)
both are renamed by getting a postfix
input tags are automatically adjusted
------------------------------------------------------------------

Definition at line 484 of file helpers.py.

 
 def cloneProcessingSnippetTask(process, task, postfix, removePostfix="", noClones = [], verbose = False):
     """
     ------------------------------------------------------------------
     copy a task plus the modules therein (including modules in subtasks)
     both are renamed by getting a postfix
     input tags are automatically adjusted
     ------------------------------------------------------------------
     """
     result = task
     if not postfix == "":
         visitor = CloneTaskVisitor(process, task.label(), postfix, removePostfix, noClones, verbose)
         task.visit(visitor)
         result = visitor.clonedTask()
     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 241 of file helpers.py.

References spr.find().

Referenced by 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
 
 

spr::find

void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)

Definition: FindCaloHit.cc:19

helpers.contains

def contains

Definition: helpers.py:241

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.

References addToTask(), DeadROC_duringRun.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)

helpers.extendWithPrePostfix

def extendWithPrePostfix

Definition: helpers.py:60

DeadROC_duringRun.dir

string dir

Definition: DeadROC_duringRun.py:23

helpers.addToTask

def addToTask

Definition: helpers.py:55

MassReplace.massSearchReplaceAnyInputTag

def massSearchReplaceAnyInputTag

Definition: MassReplace.py:79

Exception

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)

helpers.get_path

def get_path

Definition: helpers.py:6

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

helpers.getPatAlgosToolsTask

def getPatAlgosToolsTask

Definition: helpers.py:13

Exception

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.

References if().

Referenced by testJetCollectionString(), heavyIonTools.ProductionDefaults.toolCode(), coreTools.RemoveMCMatching.toolCode(), and heavyIonTools.SelectionDefaults.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

helpers.jetCollectionString

def jetCollectionString

Definition: helpers.py:217

if

if(conf_.getParameter< bool >("UseStripCablingDB"))

Definition: SiStripLAProfileBooker.cc:72

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.

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

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

helpers.listDependencyChain

def listDependencyChain

Definition: helpers.py:272

bitset_utilities::append

boost::dynamic_bitset append(const boost::dynamic_bitset<> &bs1, const boost::dynamic_bitset<> &bs2)

this method takes two bitsets bs1 and bs2 and returns result of bs2 appended to the end of bs1 ...

Definition: bitset_append.cc:10

print

void print(TMatrixD &m, const char *label=nullptr, bool mathematicaFormat=false)

Definition: Utilities.cc:47

mps_monitormerge.items

list items

Definition: mps_monitormerge.py:29

def helpers.listModules ( sequence )

Definition at line 207 of file helpers.py.

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

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

helpers.GatherAllModulesVisitor

Definition: helpers.py:142

helpers.listModules

def listModules

Definition: helpers.py:207

def helpers.listSequences ( sequence )

Definition at line 212 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()

helpers.GatherAllModulesVisitor

Definition: helpers.py:142

helpers.listSequences

def listSequences

Definition: helpers.py:212

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

Definition at line 46 of file helpers.py.

References loadWithPrePostfix().

Referenced by pfTools.usePF2PAT().

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

helpers.loadWithPostfix

def loadWithPostfix

Definition: helpers.py:46

helpers.loadWithPrePostfix

def loadWithPrePostfix

Definition: helpers.py:49

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

Definition at line 43 of file helpers.py.

References loadWithPrePostfix().

Referenced by jetTools.setupBTagging().

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

helpers.loadWithPrePostfix

def loadWithPrePostfix

Definition: helpers.py:49

helpers.loadWithPrefix

def loadWithPrefix

Definition: helpers.py:43

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

Definition at line 49 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)

helpers.extendWithPrePostfix

def extendWithPrePostfix

Definition: helpers.py:60

helpers.loadWithPrePostfix

def loadWithPrePostfix

Definition: helpers.py:49

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

Definition at line 122 of file helpers.py.

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

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

MatrixUtil.remove

def remove

Definition: MatrixUtil.py:223

helpers.removeIfInSequence

def removeIfInSequence

Definition: helpers.py:122

helpers.__labelsInSequence

def __labelsInSequence

Definition: helpers.py:129

def helpers.testContains ( self )

Definition at line 415 of file helpers.py.

References contains().

415

416 def testContains(self):

417 p = cms.Process("test")

418 p.a = cms.EDProducer("a", src=cms.InputTag("gen"))

419 p.b = cms.EDProducer("ab", src=cms.InputTag("a"))

420 p.c = cms.EDProducer("ac", src=cms.InputTag("b"))

421 p.s1 = cms.Sequence(p.a*p.b*p.c)

422 p.s2 = cms.Sequence(p.b*p.c)

423 self.assertTrue( contains(p.s1, "a") )

self.assertTrue( not contains(p.s2, "a") )

helpers.testContains

def testContains

Definition: helpers.py:415

helpers.contains

def contains

Definition: helpers.py:241

def helpers.testJetCollectionString ( self )

Definition at line 424 of file helpers.py.

References jetCollectionString().

424

425 def testJetCollectionString(self):

426 self.assertEqual(jetCollectionString(algo = 'Foo', type = 'Bar'), 'patJetsFooBar')

self.assertEqual(jetCollectionString(prefix = 'prefix', algo = 'Foo', type = 'Bar'), 'prefixPatJetsFooBar')

helpers.jetCollectionString

def jetCollectionString

Definition: helpers.py:217

helpers.testJetCollectionString

def testJetCollectionString

Definition: helpers.py:424

def helpers.testListModules ( self )

Definition at line 427 of file helpers.py.

References listModules().

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

helpers.listModules

def listModules

Definition: helpers.py:207

helpers.testListModules

def testListModules

Definition: helpers.py:427

Classes
class	CloneSequenceVisitor

class	CloneTaskVisitor

struct	CompositeCandidateMaker

struct	CompositePtrCandidateMaker

class	GatherAllModulesVisitor

struct	MCTruthPairSelector

struct	NamedCompositeCandidateMaker

class	TestModuleCommand

Classes

Functions

Function Documentation

Functions
def	__labelsInSequence

def	_lineDiff

def	addESProducers

def	addKeepStatement

def	addToProcessAndTask

def	addToTask

def	applyPostfix

def	associatePatAlgosToolsTask

def	cloneProcessingSnippet

def	cloneProcessingSnippetTask

def	contains

def	extendWithPrePostfix

def	get_path

def	get_vars

def	getPatAlgosToolsTask

def	jetCollectionString

def	listDependencyChain

def	listModules

def	listSequences

def	loadWithPostfix

def	loadWithPrefix

def	loadWithPrePostfix

def	removeIfInSequence

def	testContains

def	testJetCollectionString

def	testListModules