Classes
class	CloneSequenceVisitor

class	CloneTaskVisitor

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	cloneProcessingSnippetTask (process, task, postfix, removePostfix="", noClones=[], 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.

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

◆ _lineDiff()

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 )
 

◆ addESProducers()

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)
 

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

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)
 
 

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

Referenced by extendWithPrePostfix().

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

◆ applyPostfix()

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
 

◆ associatePatAlgosToolsTask()

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)
 

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

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
 

◆ cloneProcessingSnippetTask()

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

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

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
 
 
 

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

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)
 

◆ get_path()

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)
 

◆ get_vars()

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]
    

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

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
 

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

References mps_setup.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)
 

◆ listModules()

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

◆ listSequences()

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

◆ loadWithPostfix()

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)
 

◆ loadWithPrefix()

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)
 

◆ loadWithPrePostfix()

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)
 

◆ removeIfInSequence()

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

◆ testContains()

def helpers.testContains ( self )

Definition at line 415 of file helpers.py.

References contains().

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

◆ testJetCollectionString()

def helpers.testJetCollectionString ( self )

Definition at line 424 of file helpers.py.

References jetCollectionString().

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

◆ testListModules()

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

Classes

Functions