Inheritance diagram for Config.Process:

Public Member Functions
def	__delattr__ (self, name)

def	__init__ (self, name, Mods)

def	__setattr__ (self, name, value)

def	__setstate__ (self, pkldict)

def	add_ (self, value)

def	addSubProcess (self, mod)

def	aliases_ (self)

def	analyzerNames (self)

def	analyzers_ (self)

def	dumpConfig (self, options=PrintOptions())

def	dumpPython (self, options=PrintOptions())

def	endpaths_ (self)

def	es_prefers_ (self)

def	es_producers_ (self)

def	es_sources_ (self)

def	extend (self, other, items=())

def	fillProcessDesc (self, processPSet)

def	filterNames (self)

def	filters_ (self)

def	globalReplace (self, label, new)

def	isUsingModifier (self, mod)

def	load (self, moduleName)

def	looper_ (self)

def	name_ (self)

def	outputModules_ (self)

def	pathNames (self)

def	paths_ (self)

def	prefer (self, esmodule, args, kargs)

def	producerNames (self)

def	producers_ (self)

def	prune (self, verbose=False, keepUnresolvedSequencePlaceholders=False)

def	psets_ (self)

def	resolve (self, keepUnresolvedSequencePlaceholders=False)

def	schedule_ (self)

def	sequences_ (self)

def	services_ (self)

def	setLooper_ (self, lpr)

def	setName_ (self, name)

def	setPartialSchedule_ (self, sch, label)

def	setSchedule_ (self, sch)

def	setSource_ (self, src)

def	setStrict (self, value)

def	source_ (self)

def	subProcesses_ (self)

def	switchProducerNames (self)

def	switchProducers_ (self)

def	tasks_ (self)

def	validate (self)

def	vpsets_ (self)

Properties
	aliases = property(aliases_,doc="dictionary containing the aliases for the process")

	analyzers = property(analyzers_,doc="dictionary containing the analyzers for the process")

	endpaths = property(endpaths_,doc="dictionary containing the endpaths for the process")

	es_prefers = property(es_prefers_,doc="dictionary containing the es_prefers for the process")

	es_producers = property(es_producers_,doc="dictionary containing the es_producers for the process")

	es_sources = property(es_sources_,doc="dictionary containing the es_sources for the process")

	filters = property(filters_, doc="dictionary containing the filters for the process")

	looper = property(looper_,setLooper_,doc='the main looper or None if not set')

	outputModules = property(outputModules_,doc="dictionary containing the output_modules for the process")

	paths = property(paths_,doc="dictionary containing the paths for the process")

	process = property(name_,setName_, doc="name of the process")

	producers = property(producers_,doc="dictionary containing the producers for the process")

	psets = property(psets_,doc="dictionary containing the PSets for the process")

	schedule = property(schedule_,setSchedule_,doc='the schedule or None if not set')

	sequences = property(sequences_,doc="dictionary containing the sequences for the process")

	services = property(services_,doc="dictionary containing the services for the process")

	source = property(source_,setSource_,doc='the main source or None if not set')

	subProcesses = property(subProcesses_,doc='the SubProcesses that have been added to the Process')

	switchProducers = property(switchProducers_,doc="dictionary containing the SwitchProducers for the process")

	tasks = property(tasks_,doc="dictionary containing the tasks for the process")

	vpsets = property(vpsets_,doc="dictionary containing the PSets for the process")

Private Member Functions
def	__findFirstUsingModule (self, seqsOrTasks, mod)

def	__setObjectLabel (self, object, newLabel)

def	_delattrFromSetattr (self, name)

def	_delHelper (self, name)

def	_dumpConfigESPrefers (self, options)

def	_dumpConfigNamedList (self, items, typeName, options)

def	_dumpConfigOptionallyNamedList (self, items, typeName, options)

def	_dumpConfigUnnamedList (self, items, typeName, options)

def	_dumpPython (self, d, options)

def	_dumpPythonList (self, d, options)

def	_dumpPythonSubProcesses (self, l, options)

def	_findPreferred (self, esname, d, args, kargs)

def	_insertInto (self, parameterSet, itemDict)

def	_insertManyInto (self, parameterSet, label, itemDict, tracked)

def	_insertOneInto (self, parameterSet, label, item, tracked)

def	_insertPaths (self, processPSet, nodeVisitor)

def	_insertSubProcessesInto (self, parameterSet, label, itemList, tracked)

def	_insertSwitchProducersInto (self, parameterSet, labelModules, labelAliases, itemDict, tracked)

def	_itemsInDependencyOrder (self, processDictionaryOfItems)

def	_okToPlace (self, name, mod, d)

def	_place (self, name, mod, d)

def	_placeAlias (self, name, mod)

def	_placeAnalyzer (self, name, mod)

def	_placeEndPath (self, name, mod)

def	_placeESPrefer (self, name, mod)

def	_placeESProducer (self, name, mod)

def	_placeESSource (self, name, mod)

def	_placeFilter (self, name, mod)

def	_placeLooper (self, name, mod)

def	_placeOutputModule (self, name, mod)

def	_placePath (self, name, mod)

def	_placeProducer (self, name, mod)

def	_placePSet (self, name, mod)

def	_placeSequence (self, name, mod)

def	_placeService (self, typeName, mod)

def	_placeSource (self, name, mod)

def	_placeSubProcess (self, name, mod)

def	_placeSwitchProducer (self, name, mod)

def	_placeTask (self, name, task)

def	_placeVPSet (self, name, mod)

def	_pruneModules (self, d, scheduledNames)

def	_replaceInSchedule (self, label, new)

def	_replaceInSequences (self, label, new)

def	_replaceInTasks (self, label, new)

def	_validateSequence (self, sequence, label)

def	_validateTask (self, task, label)

Private Attributes
	__isStrict

	__ppset

	__process

	__processPSet

	__thelist

Detailed Description

Root class for a CMS configuration process

Definition at line 101 of file Config.py.

Constructor & Destructor Documentation

def Config.Process.__init__	(	self,
		name,
		Mods
	)

The argument 'name' will be the name applied to this Process
    Can optionally pass as additional arguments cms.Modifier instances
    that will be used to modify the Process as it is built

Definition at line 103 of file Config.py.

Referenced by Config.Process.fillProcessDesc().

     def __init__(self,name,*Mods):
         """The argument 'name' will be the name applied to this Process
             Can optionally pass as additional arguments cms.Modifier instances
             that will be used to modify the Process as it is built
             """
         self.__dict__['_Process__name'] = name
         if not name.isalnum():
             raise RuntimeError("Error: The process name is an empty string or contains non-alphanumeric characters")
         self.__dict__['_Process__filters'] = {}
         self.__dict__['_Process__producers'] = {}
         self.__dict__['_Process__switchproducers'] = {}
         self.__dict__['_Process__source'] = None
         self.__dict__['_Process__looper'] = None
         self.__dict__['_Process__subProcesses'] = []
         self.__dict__['_Process__schedule'] = None
         self.__dict__['_Process__analyzers'] = {}
         self.__dict__['_Process__outputmodules'] = {}
         self.__dict__['_Process__paths'] = DictTypes.SortedKeysDict()    # have to keep the order
         self.__dict__['_Process__endpaths'] = DictTypes.SortedKeysDict() # of definition
         self.__dict__['_Process__sequences'] = {}
         self.__dict__['_Process__tasks'] = {}
         self.__dict__['_Process__services'] = {}
         self.__dict__['_Process__essources'] = {}
         self.__dict__['_Process__esproducers'] = {}
         self.__dict__['_Process__esprefers'] = {}
         self.__dict__['_Process__aliases'] = {}
         self.__dict__['_Process__psets']={}
         self.__dict__['_Process__vpsets']={}
         self.__dict__['_cloneToObjectDict'] = {}
         # policy switch to avoid object overwriting during extend/load
         self.__dict__['_Process__InExtendCall'] = False
         self.__dict__['_Process__partialschedules'] = {}
         self.__isStrict = False
         self.__dict__['_Process__modifiers'] = Mods
         for m in self.__modifiers:
             m._setChosen()
 

Member Function Documentation

def Config.Process.__delattr__	(	self,
		name
	)

Definition at line 450 of file Config.py.

References Config.Process._delHelper(), Config.Process._replaceInSchedule(), Config.Process._replaceInSequences(), and Config.Process._replaceInTasks().

     def __delattr__(self,name):
         self._delHelper(name)
         obj = getattr(self,name)
         if not obj is None:
             if not isinstance(obj, Sequence) and not isinstance(obj, Task):
                 # For modules, ES modules and services we can also remove
                 # the deleted object from Sequences, Paths, EndPaths, and
                 # Tasks. Note that for Sequences and Tasks that cannot be done
                 # reliably as the places where the Sequence or Task was used
                 # might have been expanded so we do not even try. We considered
                 # raising an exception if a Sequences or Task was explicitly
                 # deleted, but did not because when done carefully deletion
                 # is sometimes OK (for example in the prune function where it
                 # has been checked that the deleted Sequence is not used).
                 if obj._isTaskComponent():
                     self._replaceInTasks(name, None)
                     self._replaceInSchedule(name, None)
                 if isinstance(obj, _Sequenceable) or obj._isTaskComponent():
                     self._replaceInSequences(name, None)
         # now remove it from the process itself
         try:
             del self.__dict__[name]
         except:
             pass
 

def Config.Process.__findFirstUsingModule	(	self,
		seqsOrTasks,
		mod
	)

private

Given a container of sequences or tasks, find the first sequence or task
containing mod and return it. If none is found, return None

Definition at line 420 of file Config.py.

References list().

Referenced by Config.Process.__setattr__().

     def __findFirstUsingModule(self, seqsOrTasks, mod):
         """Given a container of sequences or tasks, find the first sequence or task
         containing mod and return it. If none is found, return None"""
         from FWCore.ParameterSet.SequenceTypes import ModuleNodeVisitor
         l = list()
         for seqOrTask in six.itervalues(seqsOrTasks):
             l[:] = []
             v = ModuleNodeVisitor(l)
             seqOrTask.visit(v)
             if mod in l:
                 return seqOrTask
         return None
 

def Config.Process.__setattr__	(	self,
		name,
		value
	)

Definition at line 320 of file Config.py.

References Config.Process.__findFirstUsingModule(), Config.Process.__isStrict, Config.Process.__setObjectLabel(), Config.Process._delattrFromSetattr(), Config.Process._okToPlace(), Config.Process._replaceInSchedule(), Config.Process._replaceInSequences(), Config.Process._replaceInTasks(), Config.Process.add_(), Config.Process.endpaths, triggerObjects_cff.id, cms::DDSpecPar.paths, Config.Process.paths, Config.Process.sequences, str, and Config.Process.tasks.

Referenced by Config.Process._findPreferred(), Config.Process.extend(), and GenObject.GenObject.setValue().

     def __setattr__(self,name,value):
         # check if the name is well-formed (only _ and alphanumerics are allowed)
         if not name.replace('_','').isalnum():
             raise ValueError('The label '+name+' contains forbiden characters')
 
         # private variable exempt from all this
         if name.startswith('_Process__'):
             self.__dict__[name]=value
             return
         if not isinstance(value,_ConfigureComponent):
             raise TypeError("can only assign labels to an object that inherits from '_ConfigureComponent'\n"
                             +"an instance of "+str(type(value))+" will not work - requested label is "+name)
         if not isinstance(value,_Labelable) and not isinstance(value,Source) and not isinstance(value,Looper) and not isinstance(value,Schedule):
             if name == value.type_():
                 # Only Services get handled here
                 self.add_(value)
                 return
             else:
                 raise TypeError("an instance of "+str(type(value))+" can not be assigned the label '"+name+"'.\n"+
                                 "Please either use the label '"+value.type_()+" or use the 'add_' method instead.")
         #clone the item
         if self.__isStrict:
             newValue =value.copy()
             try:
                 newValue._filename = value._filename
             except:
                 pass
             value.setIsFrozen()
         else:
             newValue =value
         if not self._okToPlace(name, value, self.__dict__):
             newFile='top level config'
             if hasattr(value,'_filename'):
                 newFile = value._filename
             oldFile='top level config'
             oldValue = getattr(self,name)
             if hasattr(oldValue,'_filename'):
                 oldFile = oldValue._filename
             msg = "Trying to override definition of process."+name
             msg += "\n new object defined in: "+newFile
             msg += "\n existing object defined in: "+oldFile
             raise ValueError(msg)
         # remove the old object of the name (if there is one)
         if hasattr(self,name) and not (getattr(self,name)==newValue):
             # Complain if items in sequences or tasks from load() statements have
             # degenerate names, but if the user overwrites a name in the
             # main config, replace it everywhere
             if newValue._isTaskComponent():
                 if not self.__InExtendCall:
                     self._replaceInTasks(name, newValue)
                     self._replaceInSchedule(name, newValue)
                 else:
                     if not isinstance(newValue, Task):
                         #should check to see if used in task before complaining
                         newFile='top level config'
                         if hasattr(value,'_filename'):
                             newFile = value._filename
                         oldFile='top level config'
                         oldValue = getattr(self,name)
                         if hasattr(oldValue,'_filename'):
                             oldFile = oldValue._filename
                         msg1 = "Trying to override definition of "+name+" while it is used by the task "
                         msg2 = "\n new object defined in: "+newFile
                         msg2 += "\n existing object defined in: "+oldFile
                         s = self.__findFirstUsingModule(self.tasks,oldValue)
                         if s is not None:
                             raise ValueError(msg1+s.label_()+msg2)
 
             if isinstance(newValue, _Sequenceable) or newValue._isTaskComponent():
                 if not self.__InExtendCall:
                     self._replaceInSequences(name, newValue)
                 else:
                     #should check to see if used in sequence before complaining
                     newFile='top level config'
                     if hasattr(value,'_filename'):
                         newFile = value._filename
                     oldFile='top level config'
                     oldValue = getattr(self,name)
                     if hasattr(oldValue,'_filename'):
                         oldFile = oldValue._filename
                     msg1 = "Trying to override definition of "+name+" while it is used by the "
                     msg2 = "\n new object defined in: "+newFile
                     msg2 += "\n existing object defined in: "+oldFile
                     s = self.__findFirstUsingModule(self.sequences,oldValue)
                     if s is not None:
                         raise ValueError(msg1+"sequence "+s.label_()+msg2)
                     s = self.__findFirstUsingModule(self.paths,oldValue)
                     if s is not None:
                         raise ValueError(msg1+"path "+s.label_()+msg2)
                     s = self.__findFirstUsingModule(self.endpaths,oldValue)
                     if s is not None:
                         raise ValueError(msg1+"endpath "+s.label_()+msg2)
             self._delattrFromSetattr(name)
         self.__dict__[name]=newValue
         if isinstance(newValue,_Labelable):
             self.__setObjectLabel(newValue, name)
             self._cloneToObjectDict[id(value)] = newValue
             self._cloneToObjectDict[id(newValue)] = newValue
         #now put in proper bucket
         newValue._place(name,self)

def Config.Process.__setObjectLabel	(	self,
		object,
		newLabel
	)

private

Definition at line 293 of file Config.py.

References triggerObjects_cff.id, and str.

Referenced by Config.Process.__setattr__(), Config.Process._place(), and Config.Process.extend().

     def __setObjectLabel(self, object, newLabel) :
         if not object.hasLabel_() :
             object.setLabel(newLabel)
             return
         if newLabel == object.label_() :
             return
         if newLabel is None :
             object.setLabel(None)
             return
         if (hasattr(self, object.label_()) and id(getattr(self, object.label_())) == id(object)) :
             msg100 = "Attempting to change the label of an attribute of the Process\n"
             msg101 = "Old label = "+object.label_()+"  New label = "+newLabel+"\n"
             msg102 = "Type = "+str(type(object))+"\n"
             msg103 = "Some possible solutions:\n"
             msg104 = "  1. Clone modules instead of using simple assignment. Cloning is\n"
             msg105 = "  also preferred for other types when possible.\n"
             msg106 = "  2. Declare new names starting with an underscore if they are\n"
             msg107 = "  for temporaries you do not want propagated into the Process. The\n"
             msg108 = "  underscore tells \"from x import *\" and process.load not to import\n"
             msg109 = "  the name.\n"
             msg110 = "  3. Reorganize so the assigment is not necessary. Giving a second\n"
             msg111 = "  name to the same object usually causes confusion and problems.\n"
             msg112 = "  4. Compose Sequences: newName = cms.Sequence(oldName)\n"
             raise ValueError(msg100+msg101+msg102+msg103+msg104+msg105+msg106+msg107+msg108+msg109+msg110+msg111+msg112)
         object.setLabel(None)
         object.setLabel(newLabel)
 

def Config.Process.__setstate__	(	self,
		pkldict
	)

Unpickling hook.

Since cloneToObjectDict stores a hash of objects by their
id() it needs to be updated when unpickling to use the
new object id values instantiated during the unpickle.

Definition at line 161 of file Config.py.

References triggerObjects_cff.id.

     def __setstate__(self, pkldict):
         """
         Unpickling hook.
 
         Since cloneToObjectDict stores a hash of objects by their
         id() it needs to be updated when unpickling to use the
         new object id values instantiated during the unpickle.
 
         """
         self.__dict__.update(pkldict)
         tmpDict = {}
         for value in self._cloneToObjectDict.values():
             tmpDict[id(value)] = value
         self.__dict__['_cloneToObjectDict'] = tmpDict
 
 
 

def Config.Process._delattrFromSetattr	(	self,
		name
	)

private

Similar to __delattr__ but we need different behavior when called from __setattr__

Definition at line 475 of file Config.py.

References Config.Process._delHelper().

Referenced by Config.Process.__setattr__().

     def _delattrFromSetattr(self,name):
         """Similar to __delattr__ but we need different behavior when called from __setattr__"""
         self._delHelper(name)
         # now remove it from the process itself
         try:
             del self.__dict__[name]
         except:
             pass
 

def Config.Process._delHelper	(	self,
		name
	)

private

Definition at line 433 of file Config.py.

Referenced by Config.Process.__delattr__(), and Config.Process._delattrFromSetattr().

     def _delHelper(self,name):
         if not hasattr(self,name):
             raise KeyError('process does not know about '+name)
         elif name.startswith('_Process__'):
             raise ValueError('this attribute cannot be deleted')
 
         # we have to remove it from all dictionaries/registries
         dicts = [item for item in self.__dict__.values() if (isinstance(item, dict) or isinstance(item, DictTypes.SortedKeysDict))]
         for reg in dicts:
             if name in reg: del reg[name]
         # if it was a labelable object, the label needs to be removed
         obj = getattr(self,name)
         if isinstance(obj,_Labelable):
             obj.setLabel(None)
         if isinstance(obj,Service):
             obj._inProcess = False
 

def Config.Process._dumpConfigESPrefers	(	self,
		options
	)

private

Definition at line 733 of file Config.py.

References Config.Process.es_prefers_().

Referenced by Config.Process.dumpConfig().

     def _dumpConfigESPrefers(self, options):
         result = ''
         for item in six.itervalues(self.es_prefers_()):
             result +=options.indentation()+'es_prefer '+item.targetLabel_()+' = '+item.dumpConfig(options)
         return result

def Config.Process._dumpConfigNamedList	(	self,
		items,
		typeName,
		options
	)

private

Definition at line 651 of file Config.py.

Referenced by Config.Process.dumpConfig().

     def _dumpConfigNamedList(self,items,typeName,options):
         returnValue = ''
         for name,item in items:
             returnValue +=options.indentation()+typeName+' '+name+' = '+item.dumpConfig(options)
         return returnValue

def Config.Process._dumpConfigOptionallyNamedList	(	self,
		items,
		typeName,
		options
	)

private

Definition at line 661 of file Config.py.

Referenced by Config.Process.dumpConfig().

     def _dumpConfigOptionallyNamedList(self,items,typeName,options):
         returnValue = ''
         for name,item in items:
             if name == item.type_():
                 name = ''
             returnValue +=options.indentation()+typeName+' '+name+' = '+item.dumpConfig(options)
         return returnValue

def Config.Process._dumpConfigUnnamedList	(	self,
		items,
		typeName,
		options
	)

private

Definition at line 656 of file Config.py.

Referenced by Config.Process.dumpConfig().

     def _dumpConfigUnnamedList(self,items,typeName,options):
         returnValue = ''
         for name,item in items:
             returnValue +=options.indentation()+typeName+' = '+item.dumpConfig(options)
         return returnValue

def Config.Process._dumpPython	(	self,
		d,
		options
	)

private

Definition at line 824 of file Config.py.

Referenced by Config.Process.dumpPython().

     def _dumpPython(self, d, options):
         result = ''
         for name, value in sorted(six.iteritems(d)):
             result += value.dumpPythonAs(name,options)+'\n'
         return result

def Config.Process._dumpPythonList	(	self,
		d,
		options
	)

private

Definition at line 743 of file Config.py.

Referenced by Config.Process.dumpPython().

     def _dumpPythonList(self, d, options):
         returnValue = ''
         if isinstance(d, DictTypes.SortedKeysDict):
             for name,item in d.items():
                 returnValue +='process.'+name+' = '+item.dumpPython(options)+'\n\n'
         else:
             for name,item in sorted(d.items()):
                 returnValue +='process.'+name+' = '+item.dumpPython(options)+'\n\n'
         return returnValue

def Config.Process._dumpPythonSubProcesses	(	self,
		l,
		options
	)

private

Definition at line 738 of file Config.py.

Referenced by Config.Process.dumpPython().

     def _dumpPythonSubProcesses(self, l, options):
         returnValue = ''
         for item in l:
             returnValue += item.dumpPython(options)+'\n\n'
         return returnValue

def Config.Process._findPreferred	(	self,
		esname,
		d,
		args,
		kargs
	)

private

Definition at line 1165 of file Config.py.

References psClasses.BuildTreeNode.__setattr__(), and Config.Process.__setattr__().

     def _findPreferred(self, esname, d,*args,**kargs):
         # is esname a name in the dictionary?
         if esname in d:
             typ = d[esname].type_()
             if typ == esname:
                 self.__setattr__( esname+"_prefer", ESPrefer(typ,*args,**kargs) )
             else:
                 self.__setattr__( esname+"_prefer", ESPrefer(typ, esname,*args,**kargs) )
             return True
         else:
             # maybe it's an unnamed ESModule?
             found = False
             for name, value in six.iteritems(d):
                 if value.type_() == esname:
                     if found:
                         raise RuntimeError("More than one ES module for "+esname)
                     found = True
                     self.__setattr__(esname+"_prefer",  ESPrefer(d[esname].type_()) )
             return found
 
 

def Config.Process._insertInto	(	self,
		parameterSet,
		itemDict
	)

private

Definition at line 886 of file Config.py.

     def _insertInto(self, parameterSet, itemDict):
         for name,value in six.iteritems(itemDict):
             value.insertInto(parameterSet, name)

def Config.Process._insertManyInto	(	self,
		parameterSet,
		label,
		itemDict,
		tracked
	)

private

Definition at line 896 of file Config.py.

     def _insertManyInto(self, parameterSet, label, itemDict, tracked):
         l = []
         for name,value in six.iteritems(itemDict):
             value.appendToProcessDescList_(l, name)
             value.insertInto(parameterSet, name)
         # alphabetical order is easier to compare with old language
         l.sort()
         parameterSet.addVString(tracked, label, l)

def Config.Process._insertOneInto	(	self,
		parameterSet,
		label,
		item,
		tracked
	)

private

Definition at line 889 of file Config.py.

     def _insertOneInto(self, parameterSet, label, item, tracked):
         vitems = []
         if not item == None:
             newlabel = item.nameInProcessDesc_(label)
             vitems = [newlabel]
             item.insertInto(parameterSet, newlabel)
         parameterSet.addVString(tracked, label, vitems)

def Config.Process._insertPaths	(	self,
		processPSet,
		nodeVisitor
	)

private

Definition at line 927 of file Config.py.

References Config.Process.endpaths_(), FastTimerService::PlotsPerProcess.endpaths_, edm::MainParameterSet.paths_, edm::HLTGlobalStatus.paths_, heppy::TriggerBitChecker.paths_, edm::PathsAndConsumesOfModules.paths_, ProcessCallGraph::ProcessType.paths_, pat::TriggerEvent.paths_, HLTPerformanceInfo.paths_, Config.Process.paths_(), FastTimerService::PlotsPerProcess.paths_, EcalDQMonitorTask.schedule_, edm::ModuleChanger.schedule_, edm::ScheduleInfo.schedule_, edm::PathsAndConsumesOfModules.schedule_, Config.Process.schedule_(), edm::SubProcess.schedule_, edm::test::TestProcessor.schedule_, and edm::EventProcessor.schedule_.

     def _insertPaths(self, processPSet, nodeVisitor):
         scheduledPaths = []
         triggerPaths = []
         endpaths = []
         if self.schedule_() == None:
             # make one from triggerpaths & endpaths
             for name in self.paths_():
                 scheduledPaths.append(name)
                 triggerPaths.append(name)
             for name in self.endpaths_():
                 scheduledPaths.append(name)
                 endpaths.append(name)
         else:
             for path in self.schedule_():
                 pathname = path.label_()
                 scheduledPaths.append(pathname)
                 if pathname in self.endpaths_():
                     endpaths.append(pathname)
                 else:
                     triggerPaths.append(pathname)
             for task in self.schedule_()._tasks:
                 task.resolve(self.__dict__)
                 scheduleTaskValidator = ScheduleTaskValidator()
                 task.visit(scheduleTaskValidator)
                 task.visit(nodeVisitor)
         processPSet.addVString(True, "@end_paths", endpaths)
         processPSet.addVString(True, "@paths", scheduledPaths)
         # trigger_paths are a little different
         p = processPSet.newPSet()
         p.addVString(True, "@trigger_paths", triggerPaths)
         processPSet.addPSet(True, "@trigger_paths", p)
         # add all these paths
         pathValidator = PathValidator()
         endpathValidator = EndPathValidator()
         decoratedList = []
         lister = DecoratedNodeNameVisitor(decoratedList)
         pathCompositeVisitor = CompositeVisitor(pathValidator, nodeVisitor, lister)
         endpathCompositeVisitor = CompositeVisitor(endpathValidator, nodeVisitor, lister)
         for triggername in triggerPaths:
             iPath = self.paths_()[triggername]
             iPath.resolve(self.__dict__)
             pathValidator.setLabel(triggername)
             lister.initialize()
             iPath.visit(pathCompositeVisitor)
             iPath.insertInto(processPSet, triggername, decoratedList)
         for endpathname in endpaths:
             iEndPath = self.endpaths_()[endpathname]
             iEndPath.resolve(self.__dict__)
             endpathValidator.setLabel(endpathname)
             lister.initialize()
             iEndPath.visit(endpathCompositeVisitor)
             iEndPath.insertInto(processPSet, endpathname, decoratedList)
         processPSet.addVString(False, "@filters_on_endpaths", endpathValidator.filtersOnEndpaths)
 

def Config.Process._insertSubProcessesInto	(	self,
		parameterSet,
		label,
		itemList,
		tracked
	)

private

Definition at line 914 of file Config.py.

     def _insertSubProcessesInto(self, parameterSet, label, itemList, tracked):
         l = []
         subprocs = []
         for value in itemList:
             name = value.getProcessName()
             newLabel = value.nameInProcessDesc_(name)
             l.append(newLabel)
             pset = value.getSubProcessPSet(parameterSet)
             subprocs.append(pset)
         # alphabetical order is easier to compare with old language
         l.sort()
         parameterSet.addVString(tracked, label, l)
         parameterSet.addVPSet(False,"subProcesses",subprocs)

def Config.Process._insertSwitchProducersInto	(	self,
		parameterSet,
		labelModules,
		labelAliases,
		itemDict,
		tracked
	)

private

Definition at line 904 of file Config.py.

     def _insertSwitchProducersInto(self, parameterSet, labelModules, labelAliases, itemDict, tracked):
         modules = parameterSet.getVString(tracked, labelModules)
         aliases = parameterSet.getVString(tracked, labelAliases)
         for name,value in six.iteritems(itemDict):
             value.appendToProcessDescLists_(modules, aliases, name)
             value.insertInto(parameterSet, name)
         modules.sort()
         aliases.sort()
         parameterSet.addVString(tracked, labelModules, modules)
         parameterSet.addVString(tracked, labelAliases, aliases)

def Config.Process._itemsInDependencyOrder	(	self,
		processDictionaryOfItems
	)

private

Definition at line 768 of file Config.py.

References cmsPerfStripChart.dict.

Referenced by Config.Process.dumpPython().

     def _itemsInDependencyOrder(self, processDictionaryOfItems):
         # The items can be Sequences or Tasks and the input
         # argument should either be the dictionary of sequences
         # or the dictionary of tasks from the process.
 
         returnValue=DictTypes.SortedKeysDict()
 
         # For each item, see what other items it depends upon
         # For our purpose here, an item depends on the items it contains.
         dependencies = {}
         for label,item in six.iteritems(processDictionaryOfItems):
             containedItems = []
             if isinstance(item, Task):
                 v = TaskVisitor(containedItems)
             else:
                 v = SequenceVisitor(containedItems)
             try:
                 item.visit(v)
             except RuntimeError:
                 if isinstance(item, Task):
                     raise RuntimeError("Failed in a Task visitor. Probably " \
                                        "a circular dependency discovered in Task with label " + label)
                 else:
                     raise RuntimeError("Failed in a Sequence visitor. Probably a " \
                                        "circular dependency discovered in Sequence with label " + label)
             for containedItem in containedItems:
                 # Check for items that both have labels and are not in the process.
                 # This should not normally occur unless someone explicitly assigns a
                 # label without putting the item in the process (which should not ever
                 # be done). We check here because this problem could cause the code
                 # in the 'while' loop below to go into an infinite loop.
                 if containedItem.hasLabel_():
                     testItem = processDictionaryOfItems.get(containedItem.label_())
                     if testItem is None or containedItem != testItem:
                         if isinstance(item, Task):
                             raise RuntimeError("Task has a label, but using its label to get an attribute" \
                                                " from the process yields a different object or None\n"+
                                                "label = " + containedItem.label_())
                         else:
                             raise RuntimeError("Sequence has a label, but using its label to get an attribute" \
                                                " from the process yields a different object or None\n"+
                                                "label = " + containedItem.label_())
             dependencies[label]=[dep.label_() for dep in containedItems if dep.hasLabel_()]
 
         # keep looping until we get rid of all dependencies
         while dependencies:
             oldDeps = dict(dependencies)
             for label,deps in six.iteritems(oldDeps):
                 if len(deps)==0:
                     returnValue[label]=processDictionaryOfItems[label]
                     #remove this as a dependency for all other tasks
                     del dependencies[label]
                     for lb2,deps2 in six.iteritems(dependencies):
                         while deps2.count(label):
                             deps2.remove(label)
         return returnValue

def Config.Process._okToPlace	(	self,
		name,
		mod,
		d
	)

private

Definition at line 499 of file Config.py.

References Config.Process.__isStrict.

Referenced by Config.Process.__setattr__(), and Config.Process._place().

     def _okToPlace(self, name, mod, d):
         if not self.__InExtendCall:
             # if going
             return True
         elif not self.__isStrict:
             return True
         elif name in d:
             # if there's an old copy, and the new one
             # hasn't been modified, we're done.  Still
             # not quite safe if something has been defined twice.
             #  Need to add checks
             if mod._isModified:
                 if d[name]._isModified:
                     return False
                 else:
                     return True
             else:
                 return True
         else:
             return True
 

def Config.Process._place	(	self,
		name,
		mod,
		d
	)

private

Definition at line 520 of file Config.py.

References Config.Process.__isStrict, Config.Process.__setObjectLabel(), and Config.Process._okToPlace().

     def _place(self, name, mod, d):
         if self._okToPlace(name, mod, d):
             if self.__isStrict and isinstance(mod, _ModuleSequenceType):
                 d[name] = mod._postProcessFixup(self._cloneToObjectDict)
             else:
                 d[name] = mod
             if isinstance(mod,_Labelable):
                 self.__setObjectLabel(mod, name)

def Config.Process._placeAlias	(	self,
		name,
		mod
	)

private

Definition at line 564 of file Config.py.

References Config.Process._place().

564 def _placeAlias(self,name,mod):

565 self._place(name, mod, self.__aliases)

Config.Process._placeAlias

def _placeAlias(self, name, mod)

Definition: Config.py:564

Config.Process._place

def _place(self, name, mod, d)

Definition: Config.py:520

def Config.Process._placeAnalyzer	(	self,
		name,
		mod
	)

private

Definition at line 536 of file Config.py.

References Config.Process._place().

536 def _placeAnalyzer(self,name,mod):

537 self._place(name, mod, self.__analyzers)

Config.Process._placeAnalyzer

def _placeAnalyzer(self, name, mod)

Definition: Config.py:536

Config.Process._place

def _place(self, name, mod, d)

Definition: Config.py:520

def Config.Process._placeEndPath	(	self,
		name,
		mod
	)

private

Definition at line 545 of file Config.py.

References Config.Process._place(), Config.Process._validateSequence(), and ExceptionHandling.format_outerframe().

     def _placeEndPath(self,name,mod):
         self._validateSequence(mod, name)
         try:
             self._place(name, mod, self.__endpaths)
         except ModuleCloneError as msg:
             context = format_outerframe(4)
             raise Exception("%sThe module %s in endpath %s is unknown to the process %s." %(context, msg, name, self._Process__name))

def Config.Process._placeESPrefer	(	self,
		name,
		mod
	)

private

Definition at line 557 of file Config.py.

References Config.Process._place().

557 def _placeESPrefer(self,name,mod):

558 self._place(name, mod, self.__esprefers)

Config.Process._placeESPrefer

def _placeESPrefer(self, name, mod)

Definition: Config.py:557

Config.Process._place

def _place(self, name, mod, d)

Definition: Config.py:520

def Config.Process._placeESProducer	(	self,
		name,
		mod
	)

private

Definition at line 555 of file Config.py.

References Config.Process._place().

555 def _placeESProducer(self,name,mod):

556 self._place(name, mod, self.__esproducers)

Config.Process._placeESProducer

def _placeESProducer(self, name, mod)

Definition: Config.py:555

Config.Process._place

def _place(self, name, mod, d)

Definition: Config.py:520

def Config.Process._placeESSource	(	self,
		name,
		mod
	)

private

Definition at line 559 of file Config.py.

References Config.Process._place().

559 def _placeESSource(self,name,mod):

560 self._place(name, mod, self.__essources)

Config.Process._placeESSource

def _placeESSource(self, name, mod)

Definition: Config.py:559

Config.Process._place

def _place(self, name, mod, d)

Definition: Config.py:520

def Config.Process._placeFilter	(	self,
		name,
		mod
	)

private

Definition at line 534 of file Config.py.

References Config.Process._place().

534 def _placeFilter(self,name,mod):

535 self._place(name, mod, self.__filters)

Config.Process._placeFilter

def _placeFilter(self, name, mod)

Definition: Config.py:534

Config.Process._place

def _place(self, name, mod, d)

Definition: Config.py:520

def Config.Process._placeLooper	(	self,
		name,
		mod
	)

private

Definition at line 578 of file Config.py.

Referenced by Config.Process.setLooper_().

     def _placeLooper(self,name,mod):
         if name != 'looper':
             raise ValueError("The label '"+name+"' can not be used for a Looper.  Only 'looper' is allowed.")
         self.__dict__['_Process__looper'] = mod
         self.__dict__[mod.type_()] = mod

def Config.Process._placeOutputModule	(	self,
		name,
		mod
	)

private

Definition at line 528 of file Config.py.

References Config.Process._place().

528 def _placeOutputModule(self,name,mod):

529 self._place(name, mod, self.__outputmodules)

Config.Process._placeOutputModule

def _placeOutputModule(self, name, mod)

Definition: Config.py:528

Config.Process._place

def _place(self, name, mod, d)

Definition: Config.py:520

def Config.Process._placePath	(	self,
		name,
		mod
	)

private

Definition at line 538 of file Config.py.

References Config.Process._place(), Config.Process._validateSequence(), and ExceptionHandling.format_outerframe().

     def _placePath(self,name,mod):
         self._validateSequence(mod, name)
         try:
             self._place(name, mod, self.__paths)
         except ModuleCloneError as msg:
             context = format_outerframe(4)
             raise Exception("%sThe module %s in path %s is unknown to the process %s." %(context, msg, name, self._Process__name))

def Config.Process._placeProducer	(	self,
		name,
		mod
	)

private

Definition at line 530 of file Config.py.

References Config.Process._place().

530 def _placeProducer(self,name,mod):

531 self._place(name, mod, self.__producers)

Config.Process._placeProducer

def _placeProducer(self, name, mod)

Definition: Config.py:530

Config.Process._place

def _place(self, name, mod, d)

Definition: Config.py:520

def Config.Process._placePSet	(	self,
		name,
		mod
	)

private

Definition at line 566 of file Config.py.

References Config.Process._place().

566 def _placePSet(self,name,mod):

567 self._place(name, mod, self.__psets)

Config.Process._placePSet

def _placePSet(self, name, mod)

Definition: Config.py:566

Config.Process._place

def _place(self, name, mod, d)

Definition: Config.py:520

def Config.Process._placeSequence	(	self,
		name,
		mod
	)

private

Definition at line 552 of file Config.py.

References Config.Process._place(), and Config.Process._validateSequence().

     def _placeSequence(self,name,mod):
         self._validateSequence(mod, name)
         self._place(name, mod, self.__sequences)

def Config.Process._placeService	(	self,
		typeName,
		mod
	)

private

Definition at line 588 of file Config.py.

References Config.Process._place().

     def _placeService(self,typeName,mod):
         self._place(typeName, mod, self.__services)
         if typeName in self.__dict__:
             self.__dict__[typeName]._inProcess = False
         self.__dict__[typeName]=mod

def Config.Process._placeSource	(	self,
		name,
		mod
	)

private

Allow the source to be referenced by 'source' or by type name

Definition at line 570 of file Config.py.

Referenced by Config.Process.setSource_().

     def _placeSource(self,name,mod):
         """Allow the source to be referenced by 'source' or by type name"""
         if name != 'source':
             raise ValueError("The label '"+name+"' can not be used for a Source.  Only 'source' is allowed.")
         if self.__dict__['_Process__source'] is not None :
             del self.__dict__[self.__dict__['_Process__source'].type_()]
         self.__dict__['_Process__source'] = mod
         self.__dict__[mod.type_()] = mod

def Config.Process._placeSubProcess	(	self,
		name,
		mod
	)

private

Definition at line 583 of file Config.py.

     def _placeSubProcess(self,name,mod):
         self.__dict__['_Process__subProcess'] = mod
         self.__dict__[mod.type_()] = mod

def Config.Process._placeSwitchProducer	(	self,
		name,
		mod
	)

private

Definition at line 532 of file Config.py.

References Config.Process._place().

532 def _placeSwitchProducer(self,name,mod):

533 self._place(name, mod, self.__switchproducers)

Config.Process._placeSwitchProducer

def _placeSwitchProducer(self, name, mod)

Definition: Config.py:532

Config.Process._place

def _place(self, name, mod, d)

Definition: Config.py:520

def Config.Process._placeTask	(	self,
		name,
		task
	)

private

Definition at line 561 of file Config.py.

References Config.Process._place(), and Config.Process._validateTask().

     def _placeTask(self,name,task):
         self._validateTask(task, name)
         self._place(name, task, self.__tasks)

def Config.Process._placeVPSet	(	self,
		name,
		mod
	)

private

Definition at line 568 of file Config.py.

References Config.Process._place().

568 def _placeVPSet(self,name,mod):

569 self._place(name, mod, self.__vpsets)

Config.Process._place

def _place(self, name, mod, d)

Definition: Config.py:520

Config.Process._placeVPSet

def _placeVPSet(self, name, mod)

Definition: Config.py:568

def Config.Process._pruneModules	(	self,
		d,
		scheduledNames
	)

private

Definition at line 1043 of file Config.py.

Referenced by Config.Process.prune().

     def _pruneModules(self, d, scheduledNames):
         moduleNames = set(d.keys())
         junk = moduleNames - scheduledNames
         for name in junk:
             delattr(self, name)
         return junk
 

def Config.Process._replaceInSchedule	(	self,
		label,
		new
	)

private

Definition at line 875 of file Config.py.

References EcalDQMonitorTask.schedule_, edm::ModuleChanger.schedule_, edm::ScheduleInfo.schedule_, edm::PathsAndConsumesOfModules.schedule_, Config.Process.schedule_(), edm::SubProcess.schedule_, edm::test::TestProcessor.schedule_, and edm::EventProcessor.schedule_.

Referenced by Config.Process.__delattr__(), and Config.Process.__setattr__().

     def _replaceInSchedule(self, label, new):
         if self.schedule_() == None:
             return
         old = getattr(self,label)
         for task in self.schedule_()._tasks:
             task.replace(old, new)

def Config.Process._replaceInSequences	(	self,
		label,
		new
	)

private

Definition at line 862 of file Config.py.

References Config.Process.endpaths, cms::DDSpecPar.paths, Config.Process.paths, and Config.Process.sequences.

Referenced by Config.Process.__delattr__(), and Config.Process.__setattr__().

     def _replaceInSequences(self, label, new):
         old = getattr(self,label)
         #TODO - replace by iterator concatenation
         for sequenceable in six.itervalues(self.sequences):
             sequenceable.replace(old,new)
         for sequenceable in six.itervalues(self.paths):
             sequenceable.replace(old,new)
         for sequenceable in six.itervalues(self.endpaths):
             sequenceable.replace(old,new)

def Config.Process._replaceInTasks	(	self,
		label,
		new
	)

private

Definition at line 871 of file Config.py.

References Config.Process.tasks.

Referenced by Config.Process.__delattr__(), and Config.Process.__setattr__().

     def _replaceInTasks(self, label, new):
         old = getattr(self,label)
         for task in six.itervalues(self.tasks):
             task.replace(old, new)

def Config.Process._validateSequence	(	self,
		sequence,
		label
	)

private

Definition at line 752 of file Config.py.

Referenced by Config.Process._placeEndPath(), Config.Process._placePath(), and Config.Process._placeSequence().

     def _validateSequence(self, sequence, label):
         # See if every module has been inserted into the process
         try:
             l = set()
             visitor = NodeNameVisitor(l)
             sequence.visit(visitor)
         except:
             raise RuntimeError("An entry in sequence "+label + ' has no label')

def Config.Process._validateTask	(	self,
		task,
		label
	)

private

Definition at line 760 of file Config.py.

Referenced by Config.Process._placeTask().

     def _validateTask(self, task, label):
         # See if every module and service has been inserted into the process
         try:
             l = set()
             visitor = NodeNameVisitor(l)
             task.visit(visitor)
         except:
             raise RuntimeError("An entry in task " + label + ' has not been attached to the process')

def Config.Process.add_	(	self,
		value
	)

Allows addition of components that do not have to have a label, e.g. Services

Definition at line 484 of file Config.py.

References Config.Process.__isStrict.

Referenced by Config.Process.__setattr__(), and Config.Process.extend().

     def add_(self,value):
         """Allows addition of components that do not have to have a label, e.g. Services"""
         if not isinstance(value,_ConfigureComponent):
             raise TypeError
         if not isinstance(value,_Unlabelable):
             raise TypeError
         #clone the item
         #clone the item
         if self.__isStrict:
             newValue =value.copy()
             value.setIsFrozen()
         else:
             newValue =value
         newValue._place('',self)
 

def Config.Process.addSubProcess	(	self,
		mod
	)

Definition at line 586 of file Config.py.

586 def addSubProcess(self,mod):

587 self.__subProcesses.append(mod)

Config.Process.addSubProcess

def addSubProcess(self, mod)

Definition: Config.py:586

def Config.Process.aliases_ ( self )

returns a dict of the aliases that have been added to the Process

Definition at line 272 of file Config.py.

Referenced by Config.Process.dumpConfig(), and Config.Process.dumpPython().

     def aliases_(self):
         """returns a dict of the aliases that have been added to the Process"""
         return DictTypes.FixedKeysDict(self.__aliases)

def Config.Process.analyzerNames ( self )

Returns a string containing all the EDAnalyzer labels separated by a blank

Definition at line 151 of file Config.py.

References HLTMuonValidator.analyzers_, Config.Process.analyzers_(), join(), and relativeConstraints.keys.

     def analyzerNames(self):
         """Returns a string containing all the EDAnalyzer labels separated by a blank"""
         return ' '.join(self.analyzers_().keys())

def Config.Process.analyzers_ ( self )

returns a dict of the analyzers that have been added to the Process

Definition at line 213 of file Config.py.

Referenced by Config.Process.analyzerNames(), Config.Process.dumpConfig(), Config.Process.dumpPython(), and Config.Process.prune().

     def analyzers_(self):
         """returns a dict of the analyzers that have been added to the Process"""
         return DictTypes.FixedKeysDict(self.__analyzers)

def Config.Process.dumpConfig	(	self,
		options = `PrintOptions()`
	)

return a string containing the equivalent process defined using the old configuration language

Definition at line 668 of file Config.py.

References dataset.Dataset.__name, genericValidation.ValidationWithPlotsSummaryBase.SummaryItem.__name, Config.Process._dumpConfigESPrefers(), Config.Process._dumpConfigNamedList(), Config.Process._dumpConfigOptionallyNamedList(), Config.Process._dumpConfigUnnamedList(), Config.Process.aliases_(), HLTMuonValidator.analyzers_, Config.Process.analyzers_(), Config.Process.endpaths_(), FastTimerService::PlotsPerProcess.endpaths_, Config.Process.es_producers_(), Config.Process.es_sources_(), pat::eventhypothesis::AndFilter.filters_, pat::eventhypothesis::OrFilter.filters_, pat::TriggerEvent.filters_, TrigObjTnPHistColl::FilterSelector::FilterSet.filters_, cms::DDFilteredView.filters_, FilterOR.filters_, Config.Process.filters_(), FilterSelection.filters_, FilterSelections.filters_, join(), Config.Process.looper_(), edm::EventProcessor.looper_, Config.Process.outputModules_(), edm::MainParameterSet.paths_, edm::HLTGlobalStatus.paths_, heppy::TriggerBitChecker.paths_, edm::PathsAndConsumesOfModules.paths_, ProcessCallGraph::ProcessType.paths_, pat::TriggerEvent.paths_, HLTPerformanceInfo.paths_, Config.Process.paths_(), FastTimerService::PlotsPerProcess.paths_, pf2pat::EventHypothesis.producers_, Config.Process.producers_(), Config.Process.psets, ConfigBuilder.ConfigBuilder.schedule, Config.Process.schedule, Config.Process.sequences_(), edm::ProcessDesc.services_, Config.Process.services_(), ecaldqm::DBWriterWorker.source_, SiStripFedCablingBuilderFromDb.source_, jsoncollector::DataPoint.source_, sistrip::SpyEventMatcher.source_, ProcessCallGraph.source_, Config.Process.source_(), edm::InputSource::EventSourceSentry.source_, edm::InputSource::LumiSourceSentry.source_, edm::InputSource::RunSourceSentry.source_, Config.Process.subProcesses_(), edm::SubProcess.subProcesses_, edm::EventProcessor.subProcesses_, Config.Process.switchProducers_(), and Config.Process.vpsets.

Referenced by Types.SecSource.configValue().

     def dumpConfig(self, options=PrintOptions()):
         """return a string containing the equivalent process defined using the old configuration language"""
         config = "process "+self.__name+" = {\n"
         options.indent()
         if self.source_():
             config += options.indentation()+"source = "+self.source_().dumpConfig(options)
         if self.looper_():
             config += options.indentation()+"looper = "+self.looper_().dumpConfig(options)
 
         config+=self._dumpConfigNamedList(self.subProcesses_(),
                                   'subProcess',
                                   options)
         config+=self._dumpConfigNamedList(six.iteritems(self.producers_()),
                                   'module',
                                   options)
         config+=self._dumpConfigNamedList(six.iteritems(self.switchProducers_()),
                                   'module',
                                   options)
         config+=self._dumpConfigNamedList(six.iteritems(self.filters_()),
                                   'module',
                                   options)
         config+=self._dumpConfigNamedList(six.iteritems(self.analyzers_()),
                                   'module',
                                   options)
         config+=self._dumpConfigNamedList(six.iteritems(self.outputModules_()),
                                   'module',
                                   options)
         config+=self._dumpConfigNamedList(six.iteritems(self.sequences_()),
                                   'sequence',
                                   options)
         config+=self._dumpConfigNamedList(six.iteritems(self.paths_()),
                                   'path',
                                   options)
         config+=self._dumpConfigNamedList(six.iteritems(self.endpaths_()),
                                   'endpath',
                                   options)
         config+=self._dumpConfigUnnamedList(six.iteritems(self.services_()),
                                   'service',
                                   options)
         config+=self._dumpConfigNamedList(six.iteritems(self.aliases_()),
                                   'alias',
                                   options)
         config+=self._dumpConfigOptionallyNamedList(
             six.iteritems(self.es_producers_()),
             'es_module',
             options)
         config+=self._dumpConfigOptionallyNamedList(
             six.iteritems(self.es_sources_()),
             'es_source',
             options)
         config += self._dumpConfigESPrefers(options)
         for name,item in six.iteritems(self.psets):
             config +=options.indentation()+item.configTypeName()+' '+name+' = '+item.configValue(options)
         for name,item in six.iteritems(self.vpsets):
             config +=options.indentation()+'VPSet '+name+' = '+item.configValue(options)
         if self.schedule:
             pathNames = [p.label_() for p in self.schedule]
             config +=options.indentation()+'schedule = {'+','.join(pathNames)+'}\n'
 
 #        config+=self._dumpConfigNamedList(six.iteritems(self.vpsets),
 #                                  'VPSet',
 #                                  options)
         config += "}\n"
         options.unindent()
         return config

def Config.Process.dumpPython	(	self,
		options = `PrintOptions()`
	)

return a string containing the equivalent process defined using python

Definition at line 829 of file Config.py.

References dataset.Dataset.__name, genericValidation.ValidationWithPlotsSummaryBase.SummaryItem.__name, Config.Process._dumpPython(), Config.Process._dumpPythonList(), Config.Process._dumpPythonSubProcesses(), Config.Process._itemsInDependencyOrder(), Config.Process.aliases_(), HLTMuonValidator.analyzers_, Config.Process.analyzers_(), Config.Process.endpaths_(), FastTimerService::PlotsPerProcess.endpaths_, Config.Process.es_prefers_(), Config.Process.es_producers_(), Config.Process.es_sources_(), pat::eventhypothesis::AndFilter.filters_, pat::eventhypothesis::OrFilter.filters_, pat::TriggerEvent.filters_, TrigObjTnPHistColl::FilterSelector::FilterSet.filters_, cms::DDFilteredView.filters_, FilterOR.filters_, Config.Process.filters_(), FilterSelection.filters_, FilterSelections.filters_, join(), Config.Process.looper_(), edm::EventProcessor.looper_, Config.Process.outputModules_(), edm::MainParameterSet.paths_, edm::HLTGlobalStatus.paths_, heppy::TriggerBitChecker.paths_, edm::PathsAndConsumesOfModules.paths_, ProcessCallGraph::ProcessType.paths_, pat::TriggerEvent.paths_, HLTPerformanceInfo.paths_, Config.Process.paths_(), FastTimerService::PlotsPerProcess.paths_, pf2pat::EventHypothesis.producers_, Config.Process.producers_(), Config.Process.psets, EcalDQMonitorTask.schedule_, edm::ModuleChanger.schedule_, edm::ScheduleInfo.schedule_, edm::PathsAndConsumesOfModules.schedule_, Config.Process.schedule_(), edm::SubProcess.schedule_, edm::test::TestProcessor.schedule_, edm::EventProcessor.schedule_, Config.Process.sequences, edm::ProcessDesc.services_, Config.Process.services_(), ecaldqm::DBWriterWorker.source_, SiStripFedCablingBuilderFromDb.source_, jsoncollector::DataPoint.source_, sistrip::SpyEventMatcher.source_, ProcessCallGraph.source_, Config.Process.source_(), edm::InputSource::EventSourceSentry.source_, edm::InputSource::LumiSourceSentry.source_, edm::InputSource::RunSourceSentry.source_, Config.Process.subProcesses_(), edm::SubProcess.subProcesses_, edm::EventProcessor.subProcesses_, Config.Process.switchProducers_(), Config.Process.tasks, and Config.Process.vpsets.

Referenced by Mixins._Parameterizable.__addParameter(), Modules.SwitchProducer.__addParameter(), Mixins._ParameterTypeBase.__repr__(), Mixins._Parameterizable.__repr__(), Mixins._ValidatingParameterListBase.__repr__(), Types.VPSet.__repr__(), Mixins._Parameterizable.__setattr__(), Modules.SwitchProducer.__setattr__(), and SequenceTypes.Schedule.__str__().

     def dumpPython(self, options=PrintOptions()):
         """return a string containing the equivalent process defined using python"""
         specialImportRegistry._reset()
         header = "import FWCore.ParameterSet.Config as cms"
         result = "process = cms.Process(\""+self.__name+"\")\n\n"
         if self.source_():
             result += "process.source = "+self.source_().dumpPython(options)
         if self.looper_():
             result += "process.looper = "+self.looper_().dumpPython()
         result+=self._dumpPythonList(self.psets, options)
         result+=self._dumpPythonList(self.vpsets, options)
         result+=self._dumpPythonSubProcesses(self.subProcesses_(), options)
         result+=self._dumpPythonList(self.producers_(), options)
         result+=self._dumpPythonList(self.switchProducers_(), options)
         result+=self._dumpPythonList(self.filters_() , options)
         result+=self._dumpPythonList(self.analyzers_(), options)
         result+=self._dumpPythonList(self.outputModules_(), options)
         result+=self._dumpPythonList(self.services_(), options)
         result+=self._dumpPythonList(self.es_producers_(), options)
         result+=self._dumpPythonList(self.es_sources_(), options)
         result+=self._dumpPython(self.es_prefers_(), options)
         result+=self._dumpPythonList(self._itemsInDependencyOrder(self.tasks), options)
         result+=self._dumpPythonList(self._itemsInDependencyOrder(self.sequences), options)
         result+=self._dumpPythonList(self.paths_(), options)
         result+=self._dumpPythonList(self.endpaths_(), options)
         result+=self._dumpPythonList(self.aliases_(), options)
         if not self.schedule_() == None:
             result += 'process.schedule = ' + self.schedule.dumpPython(options)
         imports = specialImportRegistry.getSpecialImports()
         if len(imports) > 0:
             header += "\n" + "\n".join(imports)
         header += "\n\n"
         return header+result

def Config.Process.endpaths_ ( self )

returns a dict of the endpaths that have been added to the Process

Definition at line 225 of file Config.py.

Referenced by Config.Process._insertPaths(), Config.Process.dumpConfig(), and Config.Process.dumpPython().

     def endpaths_(self):
         """returns a dict of the endpaths that have been added to the Process"""
         return DictTypes.SortedAndFixedKeysDict(self.__endpaths)

def Config.Process.es_prefers_ ( self )

returns a dict of the es_prefers that have been added to the Process

Definition at line 268 of file Config.py.

Referenced by Config.Process._dumpConfigESPrefers(), and Config.Process.dumpPython().

     def es_prefers_(self):
         """returns a dict of the es_prefers that have been added to the Process"""
         return DictTypes.FixedKeysDict(self.__esprefers)

def Config.Process.es_producers_ ( self )

returns a dict of the esproducers that have been added to the Process

Definition at line 260 of file Config.py.

Referenced by Config.Process.dumpConfig(), and Config.Process.dumpPython().

     def es_producers_(self):
         """returns a dict of the esproducers that have been added to the Process"""
         return DictTypes.FixedKeysDict(self.__esproducers)

def Config.Process.es_sources_ ( self )

returns a the es_sources that have been added to the Process

Definition at line 264 of file Config.py.

Referenced by Config.Process.dumpConfig(), and Config.Process.dumpPython().

     def es_sources_(self):
         """returns a the es_sources that have been added to the Process"""
         return DictTypes.FixedKeysDict(self.__essources)

def Config.Process.extend	(	self,
		other,
		items = `()`
	)

Look in other and find types that we can use

Definition at line 597 of file Config.py.

References psClasses.BuildTreeNode.__setattr__(), Config.Process.__setattr__(), Config.Process.__setObjectLabel(), Config.Process.add_(), cmsPerfStripChart.dict, dir, svgfig.SVG.extend(), Config.Process.extend(), and triggerObjects_cff.id.

Referenced by MatrixUtil.WF.__init__(), Config.Process.extend(), Config.Process.load(), and Mixins._ValidatingParameterListBase.setValue().

     def extend(self,other,items=()):
         """Look in other and find types that we can use"""
         # enable explicit check to avoid overwriting of existing objects
         self.__dict__['_Process__InExtendCall'] = True
 
         seqs = dict()
         tasksToAttach = dict()
         mods = []
         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":
                 # In these cases 'item' could be None if the specific object was not defined
                 if item is not None:
                     self.__setattr__(name,item)
             elif isinstance(item,_ModuleSequenceType):
                 seqs[name]=item
             elif isinstance(item,Task):
                 tasksToAttach[name] = item
             elif isinstance(item,_Labelable):
                 self.__setattr__(name,item)
                 if not item.hasLabel_() :
                     item.setLabel(name)
             elif isinstance(item,Schedule):
                 self.__setattr__(name,item)
             elif isinstance(item,_Unlabelable):
                 self.add_(item)
             elif isinstance(item,ProcessModifier):
                 mods.append(item)
             elif isinstance(item,ProcessFragment):
                 self.extend(item)
 
         #now create a sequence that uses the newly made items
         for name,seq in six.iteritems(seqs):
             if id(seq) not in self._cloneToObjectDict:
                 self.__setattr__(name,seq)
             else:
                 newSeq = self._cloneToObjectDict[id(seq)]
                 self.__dict__[name]=newSeq
                 self.__setObjectLabel(newSeq, name)
                 #now put in proper bucket
                 newSeq._place(name,self)
 
         for name, task in six.iteritems(tasksToAttach):
             self.__setattr__(name, task)
 
         #apply modifiers now that all names have been added
         for item in mods:
             item.apply(self)
 
         self.__dict__['_Process__InExtendCall'] = False
 

def Config.Process.fillProcessDesc	(	self,
		processPSet
	)

Used by the framework to convert python to C++ objects

Definition at line 1050 of file Config.py.

References Config.Process.__init__(), and resolutioncreator_cfi.object.

     def fillProcessDesc(self, processPSet):
         """Used by the framework to convert python to C++ objects"""
         class ServiceInjectorAdaptor(object):
             def __init__(self,ppset,thelist):
                 self.__thelist = thelist
                 self.__processPSet = ppset
             def addService(self,pset):
                 self.__thelist.append(pset)
             def newPSet(self):
                 return self.__processPSet.newPSet()
         #This adaptor is used to 'add' the method 'getTopPSet_'
         # to the ProcessDesc and PythonParameterSet C++ classes.
         # This method is needed for the PSet refToPSet_ functionality.
         class TopLevelPSetAcessorAdaptor(object):
             def __init__(self,ppset,process):
                 self.__ppset = ppset
                 self.__process = process
             def __getattr__(self,attr):
                 return getattr(self.__ppset,attr)
             def getTopPSet_(self,label):
                 return getattr(self.__process,label)
             def newPSet(self):
                 return TopLevelPSetAcessorAdaptor(self.__ppset.newPSet(),self.__process)
             def addPSet(self,tracked,name,ppset):
                 return self.__ppset.addPSet(tracked,name,self.__extractPSet(ppset))
             def addVPSet(self,tracked,name,vpset):
                 return self.__ppset.addVPSet(tracked,name,[self.__extractPSet(x) for x in vpset])
             def __extractPSet(self,pset):
                 if isinstance(pset,TopLevelPSetAcessorAdaptor):
                     return pset.__ppset
                 return pset
 
         self.validate()
         processPSet.addString(True, "@process_name", self.name_())
         all_modules = self.producers_().copy()
         all_modules.update(self.filters_())
         all_modules.update(self.analyzers_())
         all_modules.update(self.outputModules_())
         adaptor = TopLevelPSetAcessorAdaptor(processPSet,self)
         self._insertInto(adaptor, self.psets_())
         self._insertInto(adaptor, self.vpsets_())
         self._insertOneInto(adaptor,  "@all_sources", self.source_(), True)
         self._insertOneInto(adaptor,  "@all_loopers", self.looper_(), True)
         self._insertSubProcessesInto(adaptor, "@all_subprocesses", self.subProcesses_(), False)
         self._insertManyInto(adaptor, "@all_esprefers", self.es_prefers_(), True)
         self._insertManyInto(adaptor, "@all_aliases", self.aliases_(), True)
         # This will visit all the paths and endpaths that are scheduled to run,
         # as well as the Tasks associated to them and the schedule. It remembers
         # the modules, ESSources, ESProducers, and services it visits.
         nodeVisitor = NodeVisitor()
         self._insertPaths(adaptor, nodeVisitor)
         all_modules_onTasksOrScheduled = { key:value for key, value in six.iteritems(all_modules) if value in nodeVisitor.modules }
         self._insertManyInto(adaptor, "@all_modules", all_modules_onTasksOrScheduled, True)
         all_switches = self.switchProducers_().copy()
         all_switches_onTasksOrScheduled = {key:value for key, value in six.iteritems(all_switches) if value in nodeVisitor.modules }
         self._insertSwitchProducersInto(adaptor, "@all_modules", "@all_aliases", all_switches_onTasksOrScheduled, True)
         # Same as nodeVisitor except this one visits all the Tasks attached
         # to the process.
         processNodeVisitor = NodeVisitor()
         for pTask in six.itervalues(self.tasks):
             pTask.visit(processNodeVisitor)
         esProducersToEnable = {}
         for esProducerName, esProducer in six.iteritems(self.es_producers_()):
             if esProducer in nodeVisitor.esProducers or not (esProducer in processNodeVisitor.esProducers):
                 esProducersToEnable[esProducerName] = esProducer
         self._insertManyInto(adaptor, "@all_esmodules", esProducersToEnable, True)
         esSourcesToEnable = {}
         for esSourceName, esSource in six.iteritems(self.es_sources_()):
             if esSource in nodeVisitor.esSources or not (esSource in processNodeVisitor.esSources):
                 esSourcesToEnable[esSourceName] = esSource
         self._insertManyInto(adaptor, "@all_essources", esSourcesToEnable, True)
         #handle services differently
         services = []
         for serviceName, serviceObject in six.iteritems(self.services_()):
             if serviceObject in nodeVisitor.services or not (serviceObject in processNodeVisitor.services):
                 serviceObject.insertInto(ServiceInjectorAdaptor(adaptor,services))
         adaptor.addVPSet(False,"services",services)
         return processPSet
 

def Config.Process.filterNames ( self )

Returns a string containing all the EDFilter labels separated by a blank

Definition at line 154 of file Config.py.

References pat::eventhypothesis::AndFilter.filters_, pat::eventhypothesis::OrFilter.filters_, pat::TriggerEvent.filters_, TrigObjTnPHistColl::FilterSelector::FilterSet.filters_, cms::DDFilteredView.filters_, FilterOR.filters_, Config.Process.filters_(), FilterSelection.filters_, FilterSelections.filters_, join(), and relativeConstraints.keys.

     def filterNames(self):
         """Returns a string containing all the EDFilter labels separated by a blank"""
         return ' '.join(self.filters_().keys())

def Config.Process.filters_ ( self )

returns a dict of the filters that have been added to the Process

Definition at line 178 of file Config.py.

Referenced by Config.Process.dumpConfig(), Config.Process.dumpPython(), Config.Process.filterNames(), and Config.Process.prune().

     def filters_(self):
         """returns a dict of the filters that have been added to the Process"""
         return DictTypes.FixedKeysDict(self.__filters)

def Config.Process.globalReplace	(	self,
		label,
		new
	)

Replace the item with label 'label' by object 'new' in the process and all sequences/paths/tasks

Definition at line 881 of file Config.py.

     def globalReplace(self,label,new):
         """ Replace the item with label 'label' by object 'new' in the process and all sequences/paths/tasks"""
         if not hasattr(self,label):
             raise LookupError("process has no item of label "+label)
         setattr(self,label,new)

def Config.Process.isUsingModifier	(	self,
		mod
	)

returns True if the Modifier is in used by this Process

Definition at line 285 of file Config.py.

     def isUsingModifier(self,mod):
         """returns True if the Modifier is in used by this Process"""
         if mod._isChosen():
             for m in self.__modifiers:
                 if m._isOrContains(mod):
                     return True
         return False
 

def Config.Process.load	(	self,
		moduleName
	)

Definition at line 593 of file Config.py.

References svgfig.SVG.extend(), and Config.Process.extend().

     def load(self, moduleName):
         moduleName = moduleName.replace("/",".")
         module = __import__(moduleName)
         self.extend(sys.modules[moduleName])

def Config.Process.looper_ ( self )

returns the looper that has been added to the Process or None if none have been added

Definition at line 203 of file Config.py.

Referenced by Config.Process.dumpConfig(), and Config.Process.dumpPython().

     def looper_(self):
         """returns the looper that has been added to the Process or None if none have been added"""
         return self.__looper

def Config.Process.name_ ( self )

Definition at line 182 of file Config.py.

References dataset.Dataset.__name, and genericValidation.ValidationWithPlotsSummaryBase.SummaryItem.__name.

182 def name_(self):

183 return self.__name

Config.Process.name_

def name_(self)

Definition: Config.py:182

def Config.Process.outputModules_ ( self )

returns a dict of the output modules that have been added to the Process

Definition at line 217 of file Config.py.

Referenced by Config.Process.dumpConfig(), and Config.Process.dumpPython().

     def outputModules_(self):
         """returns a dict of the output modules that have been added to the Process"""
         return DictTypes.FixedKeysDict(self.__outputmodules)

def Config.Process.pathNames ( self )

Returns a string containing all the Path names separated by a blank

Definition at line 157 of file Config.py.

References join(), relativeConstraints.keys, edm::MainParameterSet.paths_, edm::HLTGlobalStatus.paths_, heppy::TriggerBitChecker.paths_, edm::PathsAndConsumesOfModules.paths_, ProcessCallGraph::ProcessType.paths_, pat::TriggerEvent.paths_, HLTPerformanceInfo.paths_, Config.Process.paths_(), and FastTimerService::PlotsPerProcess.paths_.

     def pathNames(self):
         """Returns a string containing all the Path names separated by a blank"""
         return ' '.join(self.paths_().keys())
 

def Config.Process.paths_ ( self )

returns a dict of the paths that have been added to the Process

Definition at line 221 of file Config.py.

Referenced by Config.Process._insertPaths(), Config.Process.dumpConfig(), Config.Process.dumpPython(), and Config.Process.pathNames().

     def paths_(self):
         """returns a dict of the paths that have been added to the Process"""
         return DictTypes.SortedAndFixedKeysDict(self.__paths)

def Config.Process.prefer	(	self,
		esmodule,
		args,
		kargs
	)

Prefer this ES source or producer.  The argument can
   either be an object label, e.g.,
     process.prefer(process.juicerProducer) (not supported yet)
   or a name of an ESSource or ESProducer
     process.prefer("juicer")
   or a type of unnamed ESSource or ESProducer
     process.prefer("JuicerProducer")
   In addition, you can pass as a labelled arguments the name of the Record you wish to
   prefer where the type passed is a cms.vstring and that vstring can contain the
   name of the C++ types in the Record that are being preferred, e.g.,
      #prefer all data in record 'OrangeRecord' from 'juicer'
      process.prefer("juicer", OrangeRecord=cms.vstring())
   or
      #prefer only "Orange" data in "OrangeRecord" from "juicer"
      process.prefer("juicer", OrangeRecord=cms.vstring("Orange"))
   or
      #prefer only "Orange" data with label "ExtraPulp" in "OrangeRecord" from "juicer"
      ESPrefer("ESJuicerProd", OrangeRecord=cms.vstring("Orange/ExtraPulp"))

Definition at line 1136 of file Config.py.

     def prefer(self, esmodule,*args,**kargs):
         """Prefer this ES source or producer.  The argument can
            either be an object label, e.g.,
              process.prefer(process.juicerProducer) (not supported yet)
            or a name of an ESSource or ESProducer
              process.prefer("juicer")
            or a type of unnamed ESSource or ESProducer
              process.prefer("JuicerProducer")
            In addition, you can pass as a labelled arguments the name of the Record you wish to
            prefer where the type passed is a cms.vstring and that vstring can contain the
            name of the C++ types in the Record that are being preferred, e.g.,
               #prefer all data in record 'OrangeRecord' from 'juicer'
               process.prefer("juicer", OrangeRecord=cms.vstring())
            or
               #prefer only "Orange" data in "OrangeRecord" from "juicer"
               process.prefer("juicer", OrangeRecord=cms.vstring("Orange"))
            or
               #prefer only "Orange" data with label "ExtraPulp" in "OrangeRecord" from "juicer"
               ESPrefer("ESJuicerProd", OrangeRecord=cms.vstring("Orange/ExtraPulp"))
         """
         # see if this refers to a named ESProducer
         if isinstance(esmodule, ESSource) or isinstance(esmodule, ESProducer):
             raise RuntimeError("Syntax of process.prefer(process.esmodule) not supported yet")
         elif self._findPreferred(esmodule, self.es_producers_(),*args,**kargs) or \
                 self._findPreferred(esmodule, self.es_sources_(),*args,**kargs):
             pass
         else:
             raise RuntimeError("Cannot resolve prefer for "+repr(esmodule))
 

def Config.Process.producerNames ( self )

Returns a string containing all the EDProducer labels separated by a blank

Definition at line 145 of file Config.py.

References join(), relativeConstraints.keys, pf2pat::EventHypothesis.producers_, and Config.Process.producers_().

     def producerNames(self):
         """Returns a string containing all the EDProducer labels separated by a blank"""
         return ' '.join(self.producers_().keys())

def Config.Process.producers_ ( self )

returns a dict of the producers that have been added to the Process

Definition at line 189 of file Config.py.

Referenced by Config.Process.dumpConfig(), Config.Process.dumpPython(), Config.Process.producerNames(), and Config.Process.prune().

     def producers_(self):
         """returns a dict of the producers that have been added to the Process"""
         return DictTypes.FixedKeysDict(self.__producers)

def Config.Process.prune	(	self,
		verbose = `False`,
		keepUnresolvedSequencePlaceholders = `False`
	)

Remove clutter from the process that we think is unnecessary:
tracked PSets, VPSets and unused modules and sequences. If a Schedule has been set, then Paths and EndPaths
not in the schedule will also be removed, along with an modules and sequences used only by
those removed Paths and EndPaths.

Definition at line 990 of file Config.py.

References Config.Process._pruneModules(), HLTMuonValidator.analyzers_, Config.Process.analyzers_(), Config.Process.endpaths, pat::eventhypothesis::AndFilter.filters_, pat::eventhypothesis::OrFilter.filters_, pat::TriggerEvent.filters_, TrigObjTnPHistColl::FilterSelector::FilterSet.filters_, cms::DDFilteredView.filters_, FilterOR.filters_, Config.Process.filters_(), FilterSelection.filters_, FilterSelections.filters_, join(), list(), cms::DDSpecPar.paths, Config.Process.paths, edm.print(), pf2pat::EventHypothesis.producers_, Config.Process.producers_(), Json::Path.resolve(), Config.Process.resolve(), EcalDQMonitorTask.schedule_, edm::ModuleChanger.schedule_, edm::ScheduleInfo.schedule_, edm::PathsAndConsumesOfModules.schedule_, Config.Process.schedule_(), edm::SubProcess.schedule_, edm::test::TestProcessor.schedule_, edm::EventProcessor.schedule_, Config.Process.sequences, Config.Process.switchProducers_(), and Config.Process.vpsets_().

Referenced by dirstructure.Directory.prune().

     def prune(self,verbose=False,keepUnresolvedSequencePlaceholders=False):
         """ Remove clutter from the process that we think is unnecessary:
         tracked PSets, VPSets and unused modules and sequences. If a Schedule has been set, then Paths and EndPaths
         not in the schedule will also be removed, along with an modules and sequences used only by
         those removed Paths and EndPaths."""
 # need to update this to only prune psets not on refToPSets
 # but for now, remove the delattr
 #        for name in self.psets_():
 #            if getattr(self,name).isTracked():
 #                delattr(self, name)
         for name in self.vpsets_():
             delattr(self, name)
         #first we need to resolve any SequencePlaceholders being used
         self.resolve(keepUnresolvedSequencePlaceholders)
         usedModules = set()
         unneededPaths = set()
         if self.schedule_():
             usedModules=set(self.schedule_().moduleNames())
             #get rid of unused paths
             schedNames = set(( x.label_() for x in self.schedule_()))
             names = set(self.paths)
             names.update(set(self.endpaths))
             unneededPaths = names - schedNames
             for n in unneededPaths:
                 delattr(self,n)
         else:
             pths = list(six.itervalues(self.paths))
             pths.extend(six.itervalues(self.endpaths))
             temp = Schedule(*pths)
             usedModules=set(temp.moduleNames())
         unneededModules = self._pruneModules(self.producers_(), usedModules)
         unneededModules.update(self._pruneModules(self.switchProducers_(), usedModules))
         unneededModules.update(self._pruneModules(self.filters_(), usedModules))
         unneededModules.update(self._pruneModules(self.analyzers_(), usedModules))
         #remove sequences that do not appear in remaining paths and endpaths
         seqs = list()
         sv = SequenceVisitor(seqs)
         for p in six.itervalues(self.paths):
             p.visit(sv)
         for p in six.itervalues(self.endpaths):
             p.visit(sv)
         keepSeqSet = set(( s for s in seqs if s.hasLabel_()))
         availableSeqs = set(six.itervalues(self.sequences))
         unneededSeqs = availableSeqs-keepSeqSet
         unneededSeqLabels = []
         for s in unneededSeqs:
             unneededSeqLabels.append(s.label_())
             delattr(self,s.label_())
         if verbose:
             print("prune removed the following:")
             print("  modules:"+",".join(unneededModules))
             print("  sequences:"+",".join(unneededSeqLabels))
             print("  paths/endpaths:"+",".join(unneededPaths))

def Config.Process.psets_ ( self )

returns a dict of the PSets that have been added to the Process

Definition at line 276 of file Config.py.

     def psets_(self):
         """returns a dict of the PSets that have been added to the Process"""
         return DictTypes.FixedKeysDict(self.__psets)

def Config.Process.resolve	(	self,
		keepUnresolvedSequencePlaceholders = `False`
	)

Definition at line 981 of file Config.py.

References Config.Process.endpaths, cms::DDSpecPar.paths, Config.Process.paths, EcalDQMonitorTask.schedule_, edm::ModuleChanger.schedule_, edm::ScheduleInfo.schedule_, edm::PathsAndConsumesOfModules.schedule_, Config.Process.schedule_(), edm::SubProcess.schedule_, edm::test::TestProcessor.schedule_, and edm::EventProcessor.schedule_.

Referenced by Config.Process.prune().

     def resolve(self,keepUnresolvedSequencePlaceholders=False):
         for x in six.itervalues(self.paths):
             x.resolve(self.__dict__,keepUnresolvedSequencePlaceholders)
         for x in six.itervalues(self.endpaths):
             x.resolve(self.__dict__,keepUnresolvedSequencePlaceholders)
         if not self.schedule_() == None:
             for task in self.schedule_()._tasks:
                 task.resolve(self.__dict__,keepUnresolvedSequencePlaceholders)
 

def Config.Process.schedule_ ( self )

returns the schedule that has been added to the Process or None if none have been added

Definition at line 237 of file Config.py.

Referenced by Config.Process._insertPaths(), Config.Process._replaceInSchedule(), Config.Process.dumpPython(), Config.Process.prune(), and Config.Process.resolve().

     def schedule_(self):
         """returns the schedule that has been added to the Process or None if none have been added"""
         return self.__schedule

def Config.Process.sequences_ ( self )

returns a dict of the sequences that have been added to the Process

Definition at line 229 of file Config.py.

Referenced by Config.Process.dumpConfig().

     def sequences_(self):
         """returns a dict of the sequences that have been added to the Process"""
         return DictTypes.FixedKeysDict(self.__sequences)

def Config.Process.services_ ( self )

returns a dict of the services that have been added to the Process

Definition at line 256 of file Config.py.

Referenced by Config.Process.dumpConfig(), and Config.Process.dumpPython().

     def services_(self):
         """returns a dict of the services that have been added to the Process"""
         return DictTypes.FixedKeysDict(self.__services)

def Config.Process.setLooper_	(	self,
		lpr
	)

Definition at line 206 of file Config.py.

References Config.Process._placeLooper().

206 def setLooper_(self,lpr):

207 self._placeLooper('looper',lpr)

Config.Process.setLooper_

def setLooper_(self, lpr)

Definition: Config.py:206

Config.Process._placeLooper

def _placeLooper(self, name, mod)

Definition: Config.py:578

def Config.Process.setName_	(	self,
		name
	)

Definition at line 184 of file Config.py.

     def setName_(self,name):
         if not name.isalnum():
             raise RuntimeError("Error: The process name is an empty string or contains non-alphanumeric characters")
         self.__dict__['_Process__name'] = name

def Config.Process.setPartialSchedule_	(	self,
		sch,
		label
	)

Definition at line 240 of file Config.py.

References Config.Process._place(), and Config.Process.setSchedule_().

     def setPartialSchedule_(self,sch,label):
         if label == "schedule":
             self.setSchedule_(sch)
         else:
             self._place(label, sch, self.__partialschedules)

def Config.Process.setSchedule_	(	self,
		sch
	)

Definition at line 245 of file Config.py.

References str.

Referenced by Config.Process.setPartialSchedule_().

     def setSchedule_(self,sch):
         # See if every path and endpath has been inserted into the process
         index = 0
         try:
             for p in sch:
                 p.label_()
                 index +=1
         except:
             raise RuntimeError("The path at index "+str(index)+" in the Schedule was not attached to the process.")
         self.__dict__['_Process__schedule'] = sch

def Config.Process.setSource_	(	self,
		src
	)

Definition at line 200 of file Config.py.

References Config.Process._placeSource().

200 def setSource_(self,src):

201 self._placeSource('source',src)

Config.Process.setSource_

def setSource_(self, src)

Definition: Config.py:200

Config.Process._placeSource

def _placeSource(self, name, mod)

Definition: Config.py:570

def Config.Process.setStrict	(	self,
		value
	)

Definition at line 140 of file Config.py.

References Config.Process.__isStrict.

     def setStrict(self, value):
         self.__isStrict = value
         _Module.__isStrict__ = True
 

def Config.Process.source_ ( self )

returns the source that has been added to the Process or None if none have been added

Definition at line 197 of file Config.py.

Referenced by Config.Process.dumpConfig(), and Config.Process.dumpPython().

     def source_(self):
         """returns the source that has been added to the Process or None if none have been added"""
         return self.__source

def Config.Process.subProcesses_ ( self )

returns a list of the subProcesses that have been added to the Process

Definition at line 209 of file Config.py.

Referenced by Config.Process.dumpConfig(), and Config.Process.dumpPython().

     def subProcesses_(self):
         """returns a list of the subProcesses that have been added to the Process"""
         return self.__subProcesses

def Config.Process.switchProducerNames ( self )

Returns a string containing all the SwitchProducer labels separated by a blank

Definition at line 148 of file Config.py.

References join(), relativeConstraints.keys, and Config.Process.switchProducers_().

     def switchProducerNames(self):
         """Returns a string containing all the SwitchProducer labels separated by a blank"""
         return ' '.join(self.switchProducers_().keys())

def Config.Process.switchProducers_ ( self )

returns a dict of the SwitchProducers that have been added to the Process

Definition at line 193 of file Config.py.

Referenced by Config.Process.dumpConfig(), Config.Process.dumpPython(), Config.Process.prune(), and Config.Process.switchProducerNames().

     def switchProducers_(self):
         """returns a dict of the SwitchProducers that have been added to the Process"""
         return DictTypes.FixedKeysDict(self.__switchproducers)

def Config.Process.tasks_ ( self )

returns a dict of the tasks that have been added to the Process

Definition at line 233 of file Config.py.

     def tasks_(self):
         """returns a dict of the tasks that have been added to the Process"""
         return DictTypes.FixedKeysDict(self.__tasks)

def Config.Process.validate ( self )

Definition at line 1129 of file Config.py.

     def validate(self):
         # check if there's some input
         # Breaks too many unit tests for now
         #if self.source_() == None and self.looper_() == None:
         #    raise RuntimeError("No input source was found for this process")
         pass
 

def Config.Process.vpsets_ ( self )

returns a dict of the VPSets that have been added to the Process

Definition at line 280 of file Config.py.

Referenced by Config.Process.prune().

     def vpsets_(self):
         """returns a dict of the VPSets that have been added to the Process"""
         return DictTypes.FixedKeysDict(self.__vpsets)

Member Data Documentation

Config.Process.__isStrict

private

Definition at line 135 of file Config.py.

Referenced by Config.Process.__setattr__(), Config.Process._okToPlace(), Config.Process._place(), Config.Process.add_(), and Config.Process.setStrict().

Config.Process.__ppset

private

Definition at line 1065 of file Config.py.

Config.Process.__process

private

Definition at line 1066 of file Config.py.

Referenced by Config.ProcessFragment.__delattr__(), Config.ProcessFragment.__dir__(), Config.ProcessFragment.__getattribute__(), Config.ProcessFragment.__setattr__(), and Config.SubProcess.process().

Config.Process.__processPSet

private

Definition at line 1055 of file Config.py.

Config.Process.__thelist

private

Definition at line 1054 of file Config.py.

Property Documentation

Config.Process.aliases = property(aliases_,doc="dictionary containing the aliases for the process")

static

Definition at line 275 of file Config.py.

Config.Process.analyzers = property(analyzers_,doc="dictionary containing the analyzers for the process")

static

Definition at line 216 of file Config.py.

Referenced by looper.Looper.loop(), and looper.Looper.write().

Config.Process.endpaths = property(endpaths_,doc="dictionary containing the endpaths for the process")

static

Definition at line 228 of file Config.py.

Referenced by Config.Process.__setattr__(), Config.Process._replaceInSequences(), Config.Process.prune(), and Config.Process.resolve().

Config.Process.es_prefers = property(es_prefers_,doc="dictionary containing the es_prefers for the process")

static

Definition at line 271 of file Config.py.

Config.Process.es_producers = property(es_producers_,doc="dictionary containing the es_producers for the process")

static

Definition at line 263 of file Config.py.

Config.Process.es_sources = property(es_sources_,doc="dictionary containing the es_sources for the process")

static

Definition at line 267 of file Config.py.

Config.Process.filters = property(filters_, doc="dictionary containing the filters for the process")

static

Definition at line 181 of file Config.py.

Config.Process.looper = property(looper_,setLooper_,doc='the main looper or None if not set')

static

Definition at line 208 of file Config.py.

Config.Process.outputModules = property(outputModules_,doc="dictionary containing the output_modules for the process")

static

Definition at line 220 of file Config.py.

Config.Process.paths = property(paths_,doc="dictionary containing the paths for the process")

static

Definition at line 224 of file Config.py.

Referenced by Config.Process.__setattr__(), Config.Process._replaceInSequences(), Config.Process.prune(), and Config.Process.resolve().

Config.Process.process = property(name_,setName_, doc="name of the process")

static

Definition at line 188 of file Config.py.

Referenced by Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor.dumpPython(), Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor.open(), Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor.outputEventContent(), runTauIdMVA.TauIDEmbedder.processDeepProducer(), runTauIdMVA.TauIDEmbedder.runTauID(), Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor.setProcess(), and Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor.setProperty().

Config.Process.producers = property(producers_,doc="dictionary containing the producers for the process")

static

Definition at line 192 of file Config.py.

Config.Process.psets = property(psets_,doc="dictionary containing the PSets for the process")

static

Definition at line 279 of file Config.py.

Referenced by Config.Process.dumpConfig(), and Config.Process.dumpPython().

Config.Process.schedule = property(schedule_,setSchedule_,doc='the schedule or None if not set')

static

Definition at line 255 of file Config.py.

Referenced by Config.Process.dumpConfig().

Config.Process.sequences = property(sequences_,doc="dictionary containing the sequences for the process")

static

Definition at line 232 of file Config.py.

Referenced by Config.Process.__setattr__(), Config.Process._replaceInSequences(), Config.Process.dumpPython(), and Config.Process.prune().

Config.Process.services = property(services_,doc="dictionary containing the services for the process")

static

Definition at line 259 of file Config.py.

Referenced by config.Config.__str__().

Config.Process.source = property(source_,setSource_,doc='the main source or None if not set')

static

Definition at line 202 of file Config.py.

Referenced by confdb.HLTProcess.build_source(), and confdb.HLTProcess.specificCustomize().

Config.Process.subProcesses = property(subProcesses_,doc='the SubProcesses that have been added to the Process')

static

Definition at line 212 of file Config.py.

Config.Process.switchProducers = property(switchProducers_,doc="dictionary containing the SwitchProducers for the process")

static

Definition at line 196 of file Config.py.

Config.Process.tasks = property(tasks_,doc="dictionary containing the tasks for the process")

static

Definition at line 236 of file Config.py.

Referenced by Config.Process.__setattr__(), Config.Process._replaceInTasks(), and Config.Process.dumpPython().

Config.Process.vpsets = property(vpsets_,doc="dictionary containing the PSets for the process")

static

Definition at line 283 of file Config.py.

Referenced by Config.Process.dumpConfig(), and Config.Process.dumpPython().

Public Member Functions

Properties

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

Property Documentation