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

	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	_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	_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 99 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 101 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__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 440 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 410 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 310 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, 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 283 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 155 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 465 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 423 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 722 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 643 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 653 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 648 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 813 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 732 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 727 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 1135 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 869 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 879 of file Config.py.

     def _insertManyInto(self, parameterSet, label, itemDict, tracked):
         l = []
         for name,value in six.iteritems(itemDict):
           newLabel = value.nameInProcessDesc_(name)
           l.append(newLabel)
           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 872 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 901 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::test::TestProcessor.schedule_, edm::SubProcess.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 888 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._itemsInDependencyOrder	(	self,
		processDictionaryOfItems
	)

private

Definition at line 757 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 489 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 510 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 552 of file Config.py.

References Config.Process._place().

552 def _placeAlias(self,name,mod):

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

Config.Process._placeAlias

def _placeAlias(self, name, mod)

Definition: Config.py:552

Config.Process._place

def _place(self, name, mod, d)

Definition: Config.py:510

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

private

Definition at line 524 of file Config.py.

References Config.Process._place().

524 def _placeAnalyzer(self,name,mod):

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

Config.Process._placeAnalyzer

def _placeAnalyzer(self, name, mod)

Definition: Config.py:524

Config.Process._place

def _place(self, name, mod, d)

Definition: Config.py:510

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

private

Definition at line 533 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 545 of file Config.py.

References Config.Process._place().

545 def _placeESPrefer(self,name,mod):

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

Config.Process._placeESPrefer

def _placeESPrefer(self, name, mod)

Definition: Config.py:545

Config.Process._place

def _place(self, name, mod, d)

Definition: Config.py:510

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

private

Definition at line 543 of file Config.py.

References Config.Process._place().

543 def _placeESProducer(self,name,mod):

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

Config.Process._placeESProducer

def _placeESProducer(self, name, mod)

Definition: Config.py:543

Config.Process._place

def _place(self, name, mod, d)

Definition: Config.py:510

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

private

Definition at line 547 of file Config.py.

References Config.Process._place().

547 def _placeESSource(self,name,mod):

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

Config.Process._placeESSource

def _placeESSource(self, name, mod)

Definition: Config.py:547

Config.Process._place

def _place(self, name, mod, d)

Definition: Config.py:510

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

private

Definition at line 522 of file Config.py.

References Config.Process._place().

522 def _placeFilter(self,name,mod):

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

Config.Process._placeFilter

def _placeFilter(self, name, mod)

Definition: Config.py:522

Config.Process._place

def _place(self, name, mod, d)

Definition: Config.py:510

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

private

Definition at line 566 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 518 of file Config.py.

References Config.Process._place().

518 def _placeOutputModule(self,name,mod):

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

Config.Process._placeOutputModule

def _placeOutputModule(self, name, mod)

Definition: Config.py:518

Config.Process._place

def _place(self, name, mod, d)

Definition: Config.py:510

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

private

Definition at line 526 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 520 of file Config.py.

References Config.Process._place().

520 def _placeProducer(self,name,mod):

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

Config.Process._placeProducer

def _placeProducer(self, name, mod)

Definition: Config.py:520

Config.Process._place

def _place(self, name, mod, d)

Definition: Config.py:510

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

private

Definition at line 554 of file Config.py.

References Config.Process._place().

554 def _placePSet(self,name,mod):

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

Config.Process._placePSet

def _placePSet(self, name, mod)

Definition: Config.py:554

Config.Process._place

def _place(self, name, mod, d)

Definition: Config.py:510

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

private

Definition at line 540 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 576 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 558 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 571 of file Config.py.

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

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

private

Definition at line 549 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 556 of file Config.py.

References Config.Process._place().

556 def _placeVPSet(self,name,mod):

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

Config.Process._place

def _place(self, name, mod, d)

Definition: Config.py:510

Config.Process._placeVPSet

def _placeVPSet(self, name, mod)

Definition: Config.py:556

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

private

Definition at line 1016 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 858 of file Config.py.

References EcalDQMonitorTask.schedule_, edm::ModuleChanger.schedule_, edm::ScheduleInfo.schedule_, edm::PathsAndConsumesOfModules.schedule_, Config.Process.schedule_(), edm::test::TestProcessor.schedule_, edm::SubProcess.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 845 of file Config.py.

References Config.Process.endpaths, 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 854 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 741 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 749 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 474 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 574 of file Config.py.

574 def addSubProcess(self,mod):

575 self.__subProcesses.append(mod)

Config.Process.addSubProcess

def addSubProcess(self, mod)

Definition: Config.py:574

def Config.Process.aliases_ ( self )

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

Definition at line 262 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 145 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 203 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 660 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_, 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, 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_, 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.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 818 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_, FilterOR.filters_, Config.Process.filters_(), FilterSelection.filters_, FilterSelections.filters_, 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::test::TestProcessor.schedule_, edm::SubProcess.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.tasks, and Config.Process.vpsets.

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

     def dumpPython(self, options=PrintOptions()):
         """return a string containing the equivalent process defined using python"""
         result = "import FWCore.ParameterSet.Config as cms\n\n"
         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.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)
         return result

def Config.Process.endpaths_ ( self )

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

Definition at line 215 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 258 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 250 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 254 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 585 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 in seqs.iterkeys():
             seq = seqs[name]
             #newSeq = seq.copy()
             #
             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 in tasksToAttach.iterkeys():
             task = tasksToAttach[name]
             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 1023 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)
         # 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 148 of file Config.py.

References pat::eventhypothesis::AndFilter.filters_, pat::eventhypothesis::OrFilter.filters_, pat::TriggerEvent.filters_, TrigObjTnPHistColl::FilterSelector::FilterSet.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 172 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 864 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 275 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 581 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 193 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 176 of file Config.py.

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

176 def name_(self):

177 return self.__name

Config.Process.name_

def name_(self)

Definition: Config.py:176

def Config.Process.outputModules_ ( self )

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

Definition at line 207 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 151 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 211 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 1106 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 142 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 183 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 964 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_, FilterOR.filters_, Config.Process.filters_(), FilterSelection.filters_, FilterSelections.filters_, join(), list(), Config.Process.paths, 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::test::TestProcessor.schedule_, edm::SubProcess.schedule_, edm::EventProcessor.schedule_, Config.Process.sequences, 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.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 266 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 955 of file Config.py.

References Config.Process.endpaths, Config.Process.paths, EcalDQMonitorTask.schedule_, edm::ModuleChanger.schedule_, edm::ScheduleInfo.schedule_, edm::PathsAndConsumesOfModules.schedule_, Config.Process.schedule_(), edm::test::TestProcessor.schedule_, edm::SubProcess.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 227 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 219 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 246 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 196 of file Config.py.

References Config.Process._placeLooper().

196 def setLooper_(self,lpr):

197 self._placeLooper('looper',lpr)

Config.Process.setLooper_

def setLooper_(self, lpr)

Definition: Config.py:196

Config.Process._placeLooper

def _placeLooper(self, name, mod)

Definition: Config.py:566

def Config.Process.setName_	(	self,
		name
	)

Definition at line 178 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 230 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 235 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 190 of file Config.py.

References Config.Process._placeSource().

190 def setSource_(self,src):

191 self._placeSource('source',src)

Config.Process.setSource_

def setSource_(self, src)

Definition: Config.py:190

Config.Process._placeSource

def _placeSource(self, name, mod)

Definition: Config.py:558

def Config.Process.setStrict	(	self,
		value
	)

Definition at line 137 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 187 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 199 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.tasks_ ( self )

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

Definition at line 223 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 1099 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 270 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 132 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 1038 of file Config.py.

Config.Process.__process

private

Definition at line 1039 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 1028 of file Config.py.

Config.Process.__thelist

private

Definition at line 1027 of file Config.py.

Property Documentation

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

static

Definition at line 265 of file Config.py.

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

static

Definition at line 206 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 218 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 261 of file Config.py.

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

static

Definition at line 253 of file Config.py.

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

static

Definition at line 257 of file Config.py.

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

static

Definition at line 175 of file Config.py.

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

static

Definition at line 198 of file Config.py.

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

static

Definition at line 210 of file Config.py.

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

static

Definition at line 214 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 182 of file Config.py.

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

static

Definition at line 186 of file Config.py.

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

static

Definition at line 269 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 245 of file Config.py.

Referenced by Config.Process.dumpConfig(), and ConfigBuilder.ConfigBuilder.prepare().

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

static

Definition at line 222 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 249 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 192 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 202 of file Config.py.

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

static

Definition at line 226 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 273 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