Config.Process Class Reference

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	conditionaltasks_ (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	finalpaths_ (self)
def	globalReplace (self, label, new)
def	handleProcessAccelerators (self, parameterSet)
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	processAccelerators_ (self)
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	splitPython (self, options=PrintOptions())
def	subProcesses_ (self)
def	switchProducerNames (self)
def	switchProducers_ (self)
def	tasks_ (self)
def	validate (self)
def	vpsets_ (self)

Static Public Member Functions
def	defaultMaxEvents_ ()
def	defaultMaxLuminosityBlocks_ ()
def	defaultOptions_ ()

Public Attributes
	maxLuminosityBlocks
	MessageLogger

Properties
	aliases = property(aliases_,doc="dictionary containing the aliases for the process")
	analyzers = property(analyzers_,doc="dictionary containing the analyzers for the process")
	conditionaltasks = property(conditionaltasks_,doc="dictionary containing the conditionatasks 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")
	finalpaths = property(finalpaths_,doc="dictionary containing the finalpaths 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")
	processAccelerators = property(processAccelerators_,doc="dictionary containing the ProcessAccelerators for 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	__injectValidValue (self, name, value, newValue=None)
def	__setObjectLabel (self, object, newLabel)
def	__updateMaxEvents (self, ps)
def	__updateOptions (self, opt)
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	_placeAccelerator (self, typeName, mod)
def	_placeAlias (self, name, mod)
def	_placeAnalyzer (self, name, mod)
def	_placeConditionalTask (self, name, task)
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	_placeFinalPath (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	_replaceInConditionalTasks (self, label, new)
def	_replaceInSchedule (self, label, new)
def	_replaceInScheduleDirectly (self, label, new)
def	_replaceInSequences (self, label, new)
def	_replaceInTasks (self, label, new)
def	_splitPython (self, subfolder, d, options)
def	_splitPythonList (self, subfolder, d, options)
def	_validateConditionalTask (self, task, label)
def	_validateSequence (self, sequence, label)
def	_validateTask (self, task, label)

Private Attributes
	__isStrict
	__ppset
	__process
	__processPSet
	__thelist

Static Private Attributes
	_firstProcess

Detailed Description

Root class for a CMS configuration process

Definition at line 113 of file Config.py.

Constructor & Destructor Documentation

__init__()

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 116 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__finalpaths'] = DictTypes.SortedKeysDict() # of definition
        self.__dict__['_Process__sequences'] = {}
        self.__dict__['_Process__tasks'] = {}
        self.__dict__['_Process__conditionaltasks'] = {}
        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
        self.__dict__['_Process__accelerators'] = {}
        self.__injectValidValue('options', Process.defaultOptions_())
        self.__injectValidValue('maxEvents', Process.defaultMaxEvents_())
        self.maxLuminosityBlocks = Process.defaultMaxLuminosityBlocks_()
        # intentionally not cloned to ensure that everyone taking
        # MessageLogger still via
        # FWCore.Message(Logger|Service).MessageLogger_cfi
        # use the very same MessageLogger object.
        self.MessageLogger = MessageLogger
        if Process._firstProcess:
            Process._firstProcess = False
        else:
            if len(Mods) > 0:
                for m in self.__modifiers:
                    if not m._isChosen():
                        raise RuntimeError("The Process {} tried to redefine which Modifiers to use after another Process was already started".format(name))
        for m in self.__modifiers:
            m._setChosen()

Member Function Documentation

__delattr__()

def Config.Process.__delattr__	(		self,
			name
	)

Definition at line 601 of file Config.py.

References Config.Process._delHelper(), Config.Process._replaceInConditionalTasks(), Config.Process._replaceInSchedule(), Config.Process._replaceInScheduleDirectly(), 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) and not isinstance(obj,ConditionalTask):
                # 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._replaceInConditionalTasks(name, None)
                    self._replaceInSchedule(name, None)
                if isinstance(obj, _Sequenceable) or obj._isTaskComponent():
                    self._replaceInSequences(name, None)
                if Schedule._itemIsValid(obj) or isinstance(obj, Task):
                    self._replaceInScheduleDirectly(name, None)
        # now remove it from the process itself
        try:
            del self.__dict__[name]
        except:
            pass

__findFirstUsingModule()

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 571 of file Config.py.

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 seqsOrTasks.values():
            l[:] = []
            v = ModuleNodeVisitor(l)
            seqOrTask.visit(v)
            if mod in l:
                return seqOrTask
        return None

__injectValidValue()

def Config.Process.__injectValidValue (   self,   name,   value,   newValue = None  )

private

Definition at line 561 of file Config.py.

References Config.Process.__setObjectLabel(), and l1ctLayer2EG_cff.id.

Referenced by Config.Process.__setattr__().

    def __injectValidValue(self, name, value, newValue = None):
        if newValue is None:
            newValue = value
        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)

__setattr__()

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

Definition at line 420 of file Config.py.

References Config.Process.__findFirstUsingModule(), Config.Process.__injectValidValue(), Config.Process.__isStrict, Config.Process.__updateMaxEvents(), Config.Process.__updateOptions(), Config.Process._delattrFromSetattr(), Config.Process._okToPlace(), Config.Process._replaceInConditionalTasks(), Config.Process._replaceInSchedule(), Config.Process._replaceInScheduleDirectly(), Config.Process._replaceInSequences(), Config.Process._replaceInTasks(), Config.Process.add_(), Config.Process.endpaths, Config.Process.finalpaths, 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')

        if name == 'options':
            value = self.__updateOptions(value)
        if name == 'maxEvents':
            value = self.__updateMaxEvents(value)

        # 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_():
                if hasattr(self,name) and (getattr(self,name)!=value):
                    self._replaceInTasks(name, value)
                    self._replaceInConditionalTasks(name, value)
                # 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._replaceInConditionalTasks(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() or isinstance(newValue, ConditionalTask):
                if not self.__InExtendCall:
                    if isinstance(newValue, ConditionalTask):
                        self._replaceInConditionalTasks(name, newValue)
                    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)
                    s = self.__findFirstUsingModule(self.finalpaths,oldValue)
                    if s is not None:
                        raise ValueError(msg1+"finalpath "+s.label_()+msg2)

            # In case of EDAlias, raise Exception always to avoid surprises
            if isinstance(newValue, EDAlias):
                oldValue = getattr(self, name)
                #should check to see if used in task/sequence before complaining
                newFile='top level config'
                if hasattr(value,'_filename'):
                    newFile = value._filename
                oldFile='top level config'
                if hasattr(oldValue,'_filename'):
                    oldFile = oldValue._filename
                msg1 = "Trying to override definition of "+name+" with an EDAlias while it is used by the "
                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+"task "+s.label_()+msg2)
                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)
                s = self.__findFirstUsingModule(self.finalpaths,oldValue)
                if s is not None:
                    raise ValueError(msg1+"finalpath "+s.label_()+msg2)

            if not self.__InExtendCall and (Schedule._itemIsValid(newValue) or isinstance(newValue, Task)):
                self._replaceInScheduleDirectly(name, newValue)

            self._delattrFromSetattr(name)
        self.__injectValidValue(name, value, newValue)

__setObjectLabel()

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

private

Definition at line 393 of file Config.py.

References l1ctLayer2EG_cff.id, and str.

Referenced by Config.Process.__injectValidValue(), 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)

__setstate__()

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 192 of file Config.py.

References l1ctLayer2EG_cff.id, update, and contentValuesCheck.values.

    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

__updateMaxEvents()

def Config.Process.__updateMaxEvents (   self,   ps  )

private

Definition at line 285 of file Config.py.

References Config.Process.defaultMaxEvents_().

Referenced by Config.Process.__setattr__().

    def __updateMaxEvents(self,ps):
        newMax = self.defaultMaxEvents_()
        if isinstance(ps,dict):
            for k,v in ps.items():
                setattr(newMax,k,v)
        else:
            for p in ps.parameters_():
                setattr(newMax, p, getattr(ps,p))
        return newMax

__updateOptions()

def Config.Process.__updateOptions (   self,   opt  )

private

Definition at line 272 of file Config.py.

References Config.Process.defaultOptions_().

Referenced by Config.Process.__setattr__().

    def __updateOptions(self,opt):
        newOpts = self.defaultOptions_()
        if isinstance(opt,dict):
            for k,v in opt.items():
                setattr(newOpts,k,v)
        else:
            for p in opt.parameters_():
                setattr(newOpts, p, getattr(opt,p))
        return newOpts

_delattrFromSetattr()

def Config.Process._delattrFromSetattr (   self,   name  )

private

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

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

_delHelper()

def Config.Process._delHelper (   self,   name  )

private

Definition at line 584 of file Config.py.

References contentValuesCheck.values.

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

_dumpConfigESPrefers()

def Config.Process._dumpConfigESPrefers (   self,   options  )

private

Definition at line 906 of file Config.py.

References Config.Process.es_prefers_(), and contentValuesCheck.values.

Referenced by Config.Process.dumpConfig().

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

_dumpConfigNamedList()

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

private

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

_dumpConfigOptionallyNamedList()

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

private

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

_dumpConfigUnnamedList()

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

private

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

_dumpPython()

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

private

Definition at line 1041 of file Config.py.

Referenced by Config.Process.dumpPython().

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

_dumpPythonList()

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

private

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

_dumpPythonSubProcesses()

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

private

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

_findPreferred()

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

private

Definition at line 1617 of file Config.py.

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

Referenced by Config.Process.prefer().

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

_insertInto()

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

private

Definition at line 1202 of file Config.py.

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

_insertManyInto()

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

private

Definition at line 1212 of file Config.py.

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

_insertOneInto()

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

private

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

_insertPaths()

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

private

Definition at line 1244 of file Config.py.

References Config.Process.endpaths_(), FastTimerService::PlotsPerProcess.endpaths_, Config.Process.finalpaths_(), join(), 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_, edm::SubProcess.schedule_, edm::EventProcessor.schedule_, Config.Process.schedule_(), and edm::test::TestProcessor.schedule_.

    def _insertPaths(self, processPSet, nodeVisitor):
        scheduledPaths = []
        triggerPaths = []
        endpaths = []
        finalpaths = []
        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)
            for name in self.finalpaths_():
                finalpaths.append(name)
        else:
            for path in self.schedule_():
                pathname = path.label_()
                if pathname in self.endpaths_():
                    endpaths.append(pathname)
                    scheduledPaths.append(pathname)
                elif pathname in self.finalpaths_():
                    finalpaths.append(pathname)
                else:
                    scheduledPaths.append(pathname)
                    triggerPaths.append(pathname)
            for task in self.schedule_()._tasks:
                task.resolve(self.__dict__)
                scheduleTaskValidator = ScheduleTaskValidator()
                task.visit(scheduleTaskValidator)
                task.visit(nodeVisitor)
        # consolidate all final_paths into one EndPath
        endPathWithFinalPathModulesName ="@finalPath"
        finalPathEndPath = EndPath()
        if finalpaths:
          endpaths.append(endPathWithFinalPathModulesName)
          scheduledPaths.append(endPathWithFinalPathModulesName)
          finalpathValidator = FinalPathValidator()
          modulesOnFinalPath = []
          for finalpathname in finalpaths:
              iFinalPath = self.finalpaths_()[finalpathname]
              iFinalPath.resolve(self.__dict__)
              finalpathValidator.setLabel(finalpathname)
              iFinalPath.visit(finalpathValidator)
              invalidModules = finalpathValidator.invalidModulesOnFinalpaths
              if invalidModules:
                  raise RuntimeError("FinalPath %s has non OutputModules %s" % (finalpathname, ",".join(invalidModules)))
              modulesOnFinalPath.extend(iFinalPath.moduleNames())
          for m in modulesOnFinalPath:
            mod = getattr(self, m)
            setattr(mod, "@onFinalPath", untracked.bool(True))
            finalPathEndPath += mod
            
        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)
        condTaskModules = []
        condTaskVistor = ModuleNodeOnConditionalTaskVisitor(condTaskModules)
        pathCompositeVisitor = CompositeVisitor(pathValidator, nodeVisitor, lister, condTaskVistor)
        endpathCompositeVisitor = CompositeVisitor(endpathValidator, nodeVisitor, lister)
        for triggername in triggerPaths:
            iPath = self.paths_()[triggername]
            iPath.resolve(self.__dict__)
            pathValidator.setLabel(triggername)
            lister.initialize()
            condTaskModules[:] = []
            iPath.visit(pathCompositeVisitor)
            if condTaskModules:
              decoratedList.append("#")
              l = list({x.label_() for x in condTaskModules})
              l.sort()
              decoratedList.extend(l)
              decoratedList.append("@")
            iPath.insertInto(processPSet, triggername, decoratedList[:])
        for endpathname in endpaths:
            if endpathname is not endPathWithFinalPathModulesName:
              iEndPath = self.endpaths_()[endpathname]
            else:
              iEndPath = finalPathEndPath
            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)
          

_insertSubProcessesInto()

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

private

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

_insertSwitchProducersInto()

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

private

Definition at line 1220 of file Config.py.

    def _insertSwitchProducersInto(self, parameterSet, labelModules, labelAliases, itemDict, tracked):
        modules = parameterSet.getVString(tracked, labelModules)
        aliases = parameterSet.getVString(tracked, labelAliases)
        accelerators = parameterSet.getVString(False, "@selected_accelerators")
        for name,value in itemDict.items():
            value.appendToProcessDescLists_(modules, aliases, name)
            value.insertInto(parameterSet, name, accelerators)
        modules.sort()
        aliases.sort()
        parameterSet.addVString(tracked, labelModules, modules)
        parameterSet.addVString(tracked, labelAliases, aliases)

_itemsInDependencyOrder()

def Config.Process._itemsInDependencyOrder (   self,   processDictionaryOfItems  )

private

Definition at line 975 of file Config.py.

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

    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 processDictionaryOfItems.items():
            containedItems = []
            if isinstance(item, Task):
                v = TaskVisitor(containedItems)
            elif isinstance(item, ConditionalTask):
                v = ConditionalTaskVisitor(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)
                elif isinstance(item, ConditionalTask):
                    raise RuntimeError("Failed in a ConditionalTask visitor. Probably " \
                                       "a circular dependency discovered in ConditionalTask 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_())
                        if isinstance(item, ConditionalTask):
                            raise RuntimeError("ConditionalTask 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 oldDeps.items():
                if len(deps)==0:
                    returnValue[label]=processDictionaryOfItems[label]
                    #remove this as a dependency for all other tasks
                    del dependencies[label]
                    for lb2,deps2 in dependencies.items():
                        while deps2.count(label):
                            deps2.remove(label)
        return returnValue

_okToPlace()

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

private

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

_place()

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

private

Definition at line 673 of file Config.py.

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

Referenced by Config.Process._placeAccelerator(), Config.Process._placeAlias(), Config.Process._placeAnalyzer(), Config.Process._placeConditionalTask(), Config.Process._placeEndPath(), Config.Process._placeESPrefer(), Config.Process._placeESProducer(), Config.Process._placeESSource(), Config.Process._placeFilter(), Config.Process._placeFinalPath(), Config.Process._placeOutputModule(), Config.Process._placePath(), Config.Process._placeProducer(), Config.Process._placePSet(), Config.Process._placeSequence(), Config.Process._placeService(), Config.Process._placeSwitchProducer(), Config.Process._placeTask(), Config.Process._placeVPSet(), and Config.Process.setPartialSchedule_().

    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)

_placeAccelerator()

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

private

Definition at line 756 of file Config.py.

References Config.Process._place().

    def _placeAccelerator(self,typeName,mod):
        self._place(typeName, mod, self.__accelerators)
        self.__dict__[typeName]=mod

_placeAlias()

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

private

Definition at line 727 of file Config.py.

References Config.Process._place().

    def _placeAlias(self,name,mod):
        self._place(name, mod, self.__aliases)

_placeAnalyzer()

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

private

Definition at line 689 of file Config.py.

References Config.Process._place().

    def _placeAnalyzer(self,name,mod):
        self._place(name, mod, self.__analyzers)

_placeConditionalTask()

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

private

Definition at line 724 of file Config.py.

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

    def _placeConditionalTask(self,name,task):
        self._validateConditionalTask(task, name)
        self._place(name, task, self.__conditionaltasks)

_placeEndPath()

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

private

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

_placeESPrefer()

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

private

Definition at line 717 of file Config.py.

References Config.Process._place().

    def _placeESPrefer(self,name,mod):
        self._place(name, mod, self.__esprefers)

_placeESProducer()

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

private

Definition at line 715 of file Config.py.

References Config.Process._place().

    def _placeESProducer(self,name,mod):
        self._place(name, mod, self.__esproducers)

_placeESSource()

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

private

Definition at line 719 of file Config.py.

References Config.Process._place().

    def _placeESSource(self,name,mod):
        self._place(name, mod, self.__essources)

_placeFilter()

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

private

Definition at line 687 of file Config.py.

References Config.Process._place().

    def _placeFilter(self,name,mod):
        self._place(name, mod, self.__filters)

_placeFinalPath()

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

private

Definition at line 705 of file Config.py.

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

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

_placeLooper()

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

private

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

_placeOutputModule()

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

private

Definition at line 681 of file Config.py.

References Config.Process._place().

    def _placeOutputModule(self,name,mod):
        self._place(name, mod, self.__outputmodules)

_placePath()

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

private

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

_placeProducer()

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

private

Definition at line 683 of file Config.py.

References Config.Process._place().

    def _placeProducer(self,name,mod):
        self._place(name, mod, self.__producers)

_placePSet()

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

private

Definition at line 729 of file Config.py.

References Config.Process._place().

    def _placePSet(self,name,mod):
        self._place(name, mod, self.__psets)

_placeSequence()

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

private

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

_placeService()

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

private

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

_placeSource()

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

private

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

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

_placeSubProcess()

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

private

Definition at line 746 of file Config.py.

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

_placeSwitchProducer()

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

private

Definition at line 685 of file Config.py.

References Config.Process._place().

    def _placeSwitchProducer(self,name,mod):
        self._place(name, mod, self.__switchproducers)

_placeTask()

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

private

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

_placeVPSet()

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

private

Definition at line 731 of file Config.py.

References Config.Process._place().

    def _placeVPSet(self,name,mod):
        self._place(name, mod, self.__vpsets)

_pruneModules()

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

private

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

_replaceInConditionalTasks()

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

private

Definition at line 1182 of file Config.py.

References Config.Process.conditionaltasks, and contentValuesCheck.values.

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

    def _replaceInConditionalTasks(self, label, new):
        old = getattr(self,label)
        for task in self.conditionaltasks.values():
            task.replace(old, new)

_replaceInSchedule()

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

private

Definition at line 1186 of file Config.py.

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

_replaceInScheduleDirectly()

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

private

Definition at line 1192 of file Config.py.

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

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

    def _replaceInScheduleDirectly(self, label, new):
        if self.schedule_() == None:
            return
        old = getattr(self,label)
        self.schedule_()._replaceIfHeldDirectly(old, new)

_replaceInSequences()

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

private

Definition at line 1161 of file Config.py.

References Config.Process.endpaths, Config.Process.finalpaths, Config.Process.paths, Config.Process.sequences, and contentValuesCheck.values.

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

    def _replaceInSequences(self, label, new):
        old = getattr(self,label)
        #TODO - replace by iterator concatenation
        #to ovoid dependency problems between sequences, first modify
        # process known sequences to do a non-recursive change. Then do
        # a recursive change to get cases where a sub-sequence unknown to
        # the process has the item to be replaced
        for sequenceable in self.sequences.values():
            sequenceable._replaceIfHeldDirectly(old,new)
        for sequenceable in self.sequences.values():
            sequenceable.replace(old,new)
        for sequenceable in self.paths.values():
            sequenceable.replace(old,new)
        for sequenceable in self.endpaths.values():
            sequenceable.replace(old,new)
        for sequenceable in self.finalpaths.values():
            sequenceable.replace(old,new)

_replaceInTasks()

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

private

Definition at line 1178 of file Config.py.

References Config.Process.tasks, and contentValuesCheck.values.

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

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

_splitPython()

def Config.Process._splitPython (   self,   subfolder,   d,   options  )

private

Definition at line 1047 of file Config.py.

Referenced by Config.Process.splitPython().

    def _splitPython(self, subfolder, d, options):
        result = {}
        for name, value in sorted(d.items()):
            result[name] = subfolder, value.dumpPythonAs(name, options) + '\n'
        return result

_splitPythonList()

def Config.Process._splitPythonList (   self,   subfolder,   d,   options  )

private

Definition at line 928 of file Config.py.

Referenced by Config.Process.splitPython().

    def _splitPythonList(self, subfolder, d, options):
        parts = DictTypes.SortedKeysDict()
        for name, item in d.items() if isinstance(d, DictTypes.SortedKeysDict) else sorted(d.items()):
            code = ''
            dependencies = item.directDependencies()
            for module_subfolder, module in dependencies:
                module = module + '_cfi'
                if options.useSubdirectories and module_subfolder:
                    module = module_subfolder + '.' + module
                if options.targetDirectory is not None:
                    if options.useSubdirectories and subfolder:
                      module = '..' + module
                    else:
                      module = '.' + module
                code += 'from ' + module + ' import *\n'
            if dependencies:
                code += '\n'
            code += name + ' = ' + item.dumpPython(options)
            parts[name] = subfolder, code
        return parts

_validateConditionalTask()

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

private

Definition at line 966 of file Config.py.

Referenced by Config.Process._placeConditionalTask().

    def _validateConditionalTask(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')

_validateSequence()

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

private

Definition at line 949 of file Config.py.

Referenced by Config.Process._placeEndPath(), Config.Process._placeFinalPath(), 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 Exception as e:
            raise RuntimeError("An entry in sequence {} has no label\n  Seen entries: {}\n  Error: {}".format(label, l, e))

_validateTask()

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

private

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

add_()

def Config.Process.add_	(		self,
			value
	)

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

Definition at line 638 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
        if self.__isStrict:
            newValue =value.copy()
            value.setIsFrozen()
        else:
            newValue =value
        newValue._place('',self)

addSubProcess()

def Config.Process.addSubProcess	(		self,
			mod
	)

Definition at line 749 of file Config.py.

References mps_setup.append.

    def addSubProcess(self,mod):
        self.__subProcesses.append(mod)

aliases_()

def Config.Process.aliases_

(

self

)

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

Definition at line 372 of file Config.py.

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

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

analyzerNames()

def Config.Process.analyzerNames

(

self

)

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

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

analyzers_()

def Config.Process.analyzers_

(

self

)

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

Definition at line 301 of file Config.py.

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

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

conditionaltasks_()

def Config.Process.conditionaltasks_

(

self

)

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

Definition at line 329 of file Config.py.

    def conditionaltasks_(self):
        """returns a dict of the conditionaltasks that have been added to the Process"""
        return DictTypes.FixedKeysDict(self.__conditionaltasks)

defaultMaxEvents_()

def Config.Process.defaultMaxEvents_ ( )

static

Definition at line 282 of file Config.py.

Referenced by Config.Process.__updateMaxEvents().

    def defaultMaxEvents_():
        return untracked.PSet(input=optional.untracked.int32,
                              output=optional.untracked.allowed(int32,PSet))

defaultMaxLuminosityBlocks_()

def Config.Process.defaultMaxLuminosityBlocks_ ( )

static

Definition at line 295 of file Config.py.

    def defaultMaxLuminosityBlocks_():
        return untracked.PSet(input=untracked.int32(-1))

defaultOptions_()

def Config.Process.defaultOptions_ ( )

static

Definition at line 241 of file Config.py.

Referenced by Config.Process.__updateOptions().

    def defaultOptions_():
        return untracked.PSet(numberOfThreads = untracked.uint32(1),
                              numberOfStreams = untracked.uint32(0),
                              numberOfConcurrentRuns = untracked.uint32(1),
                              numberOfConcurrentLuminosityBlocks = untracked.uint32(0),
                              eventSetup = untracked.PSet(
                                  numberOfConcurrentIOVs = untracked.uint32(0),
                                  forceNumberOfConcurrentIOVs = untracked.PSet(
                                      allowAnyLabel_ = required.untracked.uint32
                                  )
                              ),
                              accelerators = untracked.vstring('*'),
                              wantSummary = untracked.bool(False),
                              fileMode = untracked.string('FULLMERGE'),
                              forceEventSetupCacheClearOnNewRun = untracked.bool(False),
                              throwIfIllegalParameter = untracked.bool(True),
                              printDependencies = untracked.bool(False),
                              deleteNonConsumedUnscheduledModules = untracked.bool(True),
                              sizeOfStackForThreadsInKB = optional.untracked.uint32,
                              Rethrow = untracked.vstring(),
                              TryToContinue = untracked.vstring(),
                              IgnoreCompletely = untracked.vstring(),
                              modulesToCallForTryToContinue = untracked.vstring(),
                              canDeleteEarly = untracked.vstring(),
                              holdsReferencesToDeleteEarly = untracked.VPSet(),
                              modulesToIgnoreForDeleteEarly = untracked.vstring(),
                              dumpOptions = untracked.bool(False),
                              allowUnscheduled = obsolete.untracked.bool,
                              emptyRunLumiMode = obsolete.untracked.string,
                              makeTriggerResults = obsolete.untracked.bool,
                              )

dumpConfig()

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

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

Definition at line 837 of file Config.py.

References 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_, HLTGenValHistCollPath.filters_, pat::TriggerEvent.filters_, TrigObjTnPHistColl::FilterSelector::FilterSet.filters_, FilterOR.filters_, Config.Process.filters_(), cms::DDFilteredView.filters_, FilterSelection.filters_, FilterSelections.filters_, Config.Process.finalpaths_(), mps_monitormerge.items, 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_, HGCalTestPartialWaferRecHits.source_, L2MuonSeedGeneratorFromL1TkMu.source_, TestAlpakaObjectAnalyzer.source_, SiStripFedCablingBuilderFromDb.source_, TestPortableAnalyzer.source_, jsoncollector::DataPoint.source_, sistrip::SpyEventMatcher.source_, ProcessCallGraph.source_, Config.Process.source_(), edm::InputSource::EventSourceSentry.source_, edm::InputSource::LumiSourceSentry.source_, edm::InputSource::RunSourceSentry.source_, edm::InputSource::ProcessBlockSourceSentry.source_, TestAlpakaAnalyzer.source_, edm::SubProcess.subProcesses_, Config.Process.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(self.producers_().items(),
                                  'module',
                                  options)
        config+=self._dumpConfigNamedList(self.switchProducers_().items(),
                                  'module',
                                  options)
        config+=self._dumpConfigNamedList(self.filters_().items(),
                                  'module',
                                  options)
        config+=self._dumpConfigNamedList(self.analyzers_().items(),
                                  'module',
                                  options)
        config+=self._dumpConfigNamedList(self.outputModules_().items(),
                                  'module',
                                  options)
        config+=self._dumpConfigNamedList(self.sequences_().items(),
                                  'sequence',
                                  options)
        config+=self._dumpConfigNamedList(self.paths_().items(),
                                  'path',
                                  options)
        config+=self._dumpConfigNamedList(self.endpaths_().items(),
                                  'endpath',
                                  options)
        config+=self._dumpConfigNamedList(self.finalpaths_().items(),
                                  'finalpath',
                                  options)
        config+=self._dumpConfigUnnamedList(self.services_().items(),
                                  'service',
                                  options)
        config+=self._dumpConfigNamedList(self.aliases_().items(),
                                  'alias',
                                  options)
        config+=self._dumpConfigOptionallyNamedList(
            self.es_producers_().items(),
            'es_module',
            options)
        config+=self._dumpConfigOptionallyNamedList(
            self.es_sources_().items(),
            'es_source',
            options)
        config += self._dumpConfigESPrefers(options)
        for name,item in self.psets.items():
            config +=options.indentation()+item.configTypeName()+' '+name+' = '+item.configValue(options)
        for name,item in self.vpsets.items():
            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(self.vpsets.items(),
#                                  'VPSet',
#                                  options)
        config += "}\n"
        options.unindent()
        return config

dumpPython()

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

return a string containing the equivalent process defined using python

Definition at line 1053 of file Config.py.

References Config.Process._dumpPython(), Config.Process._dumpPythonList(), Config.Process._dumpPythonSubProcesses(), Config.Process._itemsInDependencyOrder(), Config.Process.aliases_(), HLTMuonValidator.analyzers_, Config.Process.analyzers_(), Config.Process.conditionaltasks, 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_, HLTGenValHistCollPath.filters_, pat::TriggerEvent.filters_, TrigObjTnPHistColl::FilterSelector::FilterSet.filters_, FilterOR.filters_, Config.Process.filters_(), cms::DDFilteredView.filters_, FilterSelection.filters_, FilterSelections.filters_, Config.Process.finalpaths_(), 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_, Config.Process.processAccelerators_(), pf2pat::EventHypothesis.producers_, Config.Process.producers_(), Config.Process.psets, ConfigBuilder.ConfigBuilder.schedule, Config.Process.schedule, EcalDQMonitorTask.schedule_, edm::ModuleChanger.schedule_, edm::ScheduleInfo.schedule_, edm::PathsAndConsumesOfModules.schedule_, edm::SubProcess.schedule_, edm::EventProcessor.schedule_, Config.Process.schedule_(), edm::test::TestProcessor.schedule_, Config.Process.sequences, edm::ProcessDesc.services_, Config.Process.services_(), ecaldqm::DBWriterWorker.source_, HGCalTestPartialWaferRecHits.source_, L2MuonSeedGeneratorFromL1TkMu.source_, TestAlpakaObjectAnalyzer.source_, SiStripFedCablingBuilderFromDb.source_, TestPortableAnalyzer.source_, jsoncollector::DataPoint.source_, sistrip::SpyEventMatcher.source_, ProcessCallGraph.source_, Config.Process.source_(), edm::InputSource::EventSourceSentry.source_, edm::InputSource::LumiSourceSentry.source_, edm::InputSource::RunSourceSentry.source_, edm::InputSource::ProcessBlockSourceSentry.source_, TestAlpakaAnalyzer.source_, edm::SubProcess.subProcesses_, Config.Process.subProcesses_(), edm::EventProcessor.subProcesses_, Config.Process.switchProducers_(), Config.Process.tasks, and Config.Process.vpsets.

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

    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.processAccelerators_(), 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.conditionaltasks), 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.finalpaths_(), 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

endpaths_()

def Config.Process.endpaths_

(

self

)

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

Definition at line 313 of file Config.py.

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

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

es_prefers_()

def Config.Process.es_prefers_

(

self

)

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

Definition at line 368 of file Config.py.

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

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

es_producers_()

def Config.Process.es_producers_

(

self

)

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

Definition at line 360 of file Config.py.

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

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

es_sources_()

def Config.Process.es_sources_

(

self

)

returns a the es_sources that have been added to the Process

Definition at line 364 of file Config.py.

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

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

extend()

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

Look in other and find types that we can use

Definition at line 763 of file Config.py.

References psClasses.BuildTreeNode.__setattr__(), Config.Process.__setattr__(), Config.FilteredStream.__setattr__, Config.Process.__setObjectLabel(), Config.Process.add_(), DeadROC_duringRun.dir, SiStripCluster.extend(), svgfig.SVG.extend(), Config.Process.extend(), and l1ctLayer2EG_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) or isinstance(item, ConditionalTask):
                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 seqs.items():
            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 tasksToAttach.items():
            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

fillProcessDesc()

def Config.Process.fillProcessDesc	(		self,
			processPSet
	)

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

Definition at line 1428 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_())
        self.handleProcessAccelerators(processPSet)
        all_modules = self.producers_().copy()
        all_modules.update(self.filters_())
        all_modules.update(self.analyzers_())
        all_modules.update(self.outputModules_())
        if hasattr(self.options,"modulesToCallForTryToContinue") :
            shouldTryToContinue = set(self.options.modulesToCallForTryToContinue)
            for m in all_modules:
                if m in shouldTryToContinue:
                    setattr(getattr(self,m),"@shouldTryToContinue",untracked.bool(True))
            missing = shouldTryToContinue.difference(all_modules)
            if missing:
                print("Warning: The following modules appear in options.modulesToCallForTryToContinue but are not in the Process: {} ".format(",".join(missing)))
        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 all_modules.items() 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 all_switches.items() 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 self.tasks.values():
            pTask.visit(processNodeVisitor)
        esProducersToEnable = {}
        for esProducerName, esProducer in self.es_producers_().items():
            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 self.es_sources_().items():
            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 self.services_().items():
            if serviceObject in nodeVisitor.services or not (serviceObject in processNodeVisitor.services):
                serviceObject.insertInto(ServiceInjectorAdaptor(adaptor,services))
        adaptor.addVPSet(False,"services",services)
        return processPSet

filterNames()

def Config.Process.filterNames

(

self

)

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

Definition at line 185 of file Config.py.

References pat::eventhypothesis::AndFilter.filters_, pat::eventhypothesis::OrFilter.filters_, HLTGenValHistCollPath.filters_, pat::TriggerEvent.filters_, TrigObjTnPHistColl::FilterSelector::FilterSet.filters_, FilterOR.filters_, Config.Process.filters_(), cms::DDFilteredView.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())

filters_()

def Config.Process.filters_

(

self

)

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

Definition at line 209 of file Config.py.

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

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

finalpaths_()

def Config.Process.finalpaths_

(

self

)

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

Definition at line 317 of file Config.py.

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

    def finalpaths_(self):
        """returns a dict of the finalpaths that have been added to the Process"""
        return DictTypes.SortedAndFixedKeysDict(self.__finalpaths)

globalReplace()

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

handleProcessAccelerators()

def Config.Process.handleProcessAccelerators	(		self,
			parameterSet
	)

Definition at line 1523 of file Config.py.

    def handleProcessAccelerators(self, parameterSet):
        # 'cpu' accelerator is always implicitly there
        allAccelerators = set(["cpu"])
        availableAccelerators = set(["cpu"])
        for acc in self.__dict__['_Process__accelerators'].values():
            allAccelerators.update(acc.labels())
            availableAccelerators.update(acc.enabledLabels())
        availableAccelerators = sorted(list(availableAccelerators))
        parameterSet.addVString(False, "@available_accelerators", availableAccelerators)

        # Resolve wildcards
        selectedAccelerators = []
        if "*" in self.options.accelerators:
            if len(self.options.accelerators) >= 2:
                raise ValueError("process.options.accelerators may contain '*' only as the only element, now it has {} elements".format(len(self.options.accelerators)))
            selectedAccelerators = availableAccelerators
        else:
            import fnmatch
            resolved = set()
            invalid = []
            for pattern in self.options.accelerators:
                acc = [a for a in availableAccelerators if fnmatch.fnmatchcase(a, pattern)]
                if len(acc) == 0:
                    if not any(fnmatch.fnmatchcase(a, pattern) for a in allAccelerators):
                        invalid.append(pattern)
                else:
                   resolved.update(acc)
            # Sanity check
            if len(invalid) != 0:
                raise ValueError("Invalid pattern{} of '{}' in process.options.accelerators, valid values are '{}' or a pattern matching some of them.".format(
                    "s" if len(invalid) > 2 else "",
                    "', '".join(invalid),
                    "', '".join(sorted(list(allAccelerators)))))
            selectedAccelerators = sorted(list(resolved))
        parameterSet.addVString(False, "@selected_accelerators", selectedAccelerators)

        # Get and apply module type resolver
        moduleTypeResolver = None
        moduleTypeResolverPlugin = ""
        for acc in self.__dict__['_Process__accelerators'].values():
            resolver = acc.moduleTypeResolver(selectedAccelerators)
            if resolver is not None:
                if moduleTypeResolver is not None:
                    raise RuntimeError("Module type resolver was already set to {} when {} tried to set it to {}. A job can have at most one ProcessAccelerator that sets module type resolver.".format(
                        moduleTypeResolver.__class__.__name__,
                        acc.__class__.__name__,
                        resolver.__class__.__name__))
                moduleTypeResolver = resolver
        if moduleTypeResolver is not None:
            # Plugin name and its configuration
            moduleTypeResolverPlugin = moduleTypeResolver.plugin()

            # Customize modules
            for modlist in [self.producers_, self.filters_, self.analyzers_,
                            self.es_producers_, self.es_sources_]:
                for module in modlist().values():
                    moduleTypeResolver.setModuleVariant(module)

        parameterSet.addString(False, "@module_type_resolver", moduleTypeResolverPlugin)

        # Customize process
        wrapped = ProcessForProcessAccelerator(self)
        for acc in self.__dict__['_Process__accelerators'].values():
            acc.apply(wrapped, selectedAccelerators)

isUsingModifier()

def Config.Process.isUsingModifier	(		self,
			mod
	)

returns True if the Modifier is in used by this Process

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

load()

def Config.Process.load	(		self,
			moduleName
	)

Definition at line 759 of file Config.py.

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

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

looper_()

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 234 of file Config.py.

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

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

name_()

def Config.Process.name_

(

self

)

Definition at line 213 of file Config.py.

    def name_(self):
        return self.__name

outputModules_()

def Config.Process.outputModules_

(

self

)

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

Definition at line 305 of file Config.py.

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

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

pathNames()

def Config.Process.pathNames

(

self

)

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

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

paths_()

def Config.Process.paths_

(

self

)

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

Definition at line 309 of file Config.py.

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

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

prefer()

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 1588 of file Config.py.

References Config.Process._findPreferred(), Config.Process.es_producers_(), and Config.Process.es_sources_().

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

processAccelerators_()

def Config.Process.processAccelerators_

(

self

)

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

Definition at line 356 of file Config.py.

Referenced by Config.Process.dumpPython().

    def processAccelerators_(self):
        """returns a dict of the ProcessAccelerators that have been added to the Process"""
        return DictTypes.FixedKeysDict(self.__accelerators)

producerNames()

def Config.Process.producerNames

(

self

)

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

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

producers_()

def Config.Process.producers_

(

self

)

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

Definition at line 220 of file Config.py.

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

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

prune()

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. The keepUnresolvedSequencePlaceholders keeps also unresolved TaskPlaceholders.

Definition at line 1350 of file Config.py.

References Config.Process._pruneModules(), HLTMuonValidator.analyzers_, Config.Process.analyzers_(), Config.Process.endpaths, pat::eventhypothesis::AndFilter.filters_, pat::eventhypothesis::OrFilter.filters_, HLTGenValHistCollPath.filters_, pat::TriggerEvent.filters_, TrigObjTnPHistColl::FilterSelector::FilterSet.filters_, FilterOR.filters_, Config.Process.filters_(), cms::DDFilteredView.filters_, FilterSelection.filters_, FilterSelections.filters_, Config.Process.finalpaths, join(), Config.Process.paths, print(), pf2pat::EventHypothesis.producers_, Config.Process.producers_(), Json::Path.resolve(), Config.Process.resolve(), EcalDQMonitorTask.schedule_, edm::ModuleChanger.schedule_, edm::ScheduleInfo.schedule_, edm::PathsAndConsumesOfModules.schedule_, edm::SubProcess.schedule_, edm::EventProcessor.schedule_, Config.Process.schedule_(), edm::test::TestProcessor.schedule_, Config.Process.sequences, Config.Process.switchProducers_(), Config.Process.tasks, contentValuesCheck.values, 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. The keepUnresolvedSequencePlaceholders keeps also unresolved TaskPlaceholders."""
# 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()
        tasks = list()
        tv = TaskVisitor(tasks)
        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))
            names.update(set(self.finalpaths))
            unneededPaths = names - schedNames
            for n in unneededPaths:
                delattr(self,n)
            for t in self.schedule_().tasks():
                tv.enter(t)
                t.visit(tv)
                tv.leave(t)
        else:
            pths = list(self.paths.values())
            pths.extend(self.endpaths.values())
            pths.extend(self.finalpaths.values())
            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 and tasks that do not appear in remaining paths and endpaths
        seqs = list()
        sv = SequenceVisitor(seqs)
        for p in self.paths.values():
            p.visit(sv)
            p.visit(tv)
        for p in self.endpaths.values():
            p.visit(sv)
            p.visit(tv)
        for p in self.finalpaths.values():
            p.visit(sv)
            p.visit(tv)
        def removeUnneeded(seqOrTasks, allSequencesOrTasks):
            _keepSet = set(( s for s in seqOrTasks if s.hasLabel_()))
            _availableSet = set(allSequencesOrTasks.values())
            _unneededSet = _availableSet-_keepSet
            _unneededLabels = []
            for s in _unneededSet:
                _unneededLabels.append(s.label_())
                delattr(self,s.label_())
            return _unneededLabels
        unneededSeqLabels = removeUnneeded(seqs, self.sequences)
        unneededTaskLabels = removeUnneeded(tasks, self.tasks)
        if verbose:
            print("prune removed the following:")
            print("  modules:"+",".join(unneededModules))
            print("  tasks:"+",".join(unneededTaskLabels))
            print("  sequences:"+",".join(unneededSeqLabels))
            print("  paths/endpaths/finalpaths:"+",".join(unneededPaths))

psets_()

def Config.Process.psets_

(

self

)

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

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

resolve()

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

Definition at line 1339 of file Config.py.

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

Referenced by Config.Process.prune().

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

schedule_()

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 333 of file Config.py.

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

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

sequences_()

def Config.Process.sequences_

(

self

)

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

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

services_()

def Config.Process.services_

(

self

)

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

Definition at line 352 of file Config.py.

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

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

setLooper_()

def Config.Process.setLooper_	(		self,
			lpr
	)

Definition at line 237 of file Config.py.

References Config.Process._placeLooper().

    def setLooper_(self,lpr):
        self._placeLooper('looper',lpr)

setName_()

def Config.Process.setName_	(		self,
			name
	)

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

setPartialSchedule_()

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

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

setSchedule_()

def Config.Process.setSchedule_	(		self,
			sch
	)

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

setSource_()

def Config.Process.setSource_	(		self,
			src
	)

Definition at line 231 of file Config.py.

References Config.Process._placeSource().

    def setSource_(self,src):
        self._placeSource('source',src)

setStrict()

def Config.Process.setStrict	(		self,
			value
	)

Definition at line 171 of file Config.py.

References Config.Process.__isStrict.

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

source_()

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 228 of file Config.py.

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

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

splitPython()

def Config.Process.splitPython	(		self,
			options = PrintOptions()
	)

return a map of file names to python configuration fragments

Definition at line 1090 of file Config.py.

References Config.Process._itemsInDependencyOrder(), Config.Process._splitPython(), Config.Process._splitPythonList(), Config.Process.aliases_(), HLTMuonValidator.analyzers_, Config.Process.analyzers_(), Config.Process.dumpPython(), 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_, HLTGenValHistCollPath.filters_, pat::TriggerEvent.filters_, TrigObjTnPHistColl::FilterSelector::FilterSet.filters_, FilterOR.filters_, Config.Process.filters_(), cms::DDFilteredView.filters_, FilterSelection.filters_, FilterSelections.filters_, Config.Process.finalpaths_(), 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, EcalDQMonitorTask.schedule_, edm::ModuleChanger.schedule_, edm::ScheduleInfo.schedule_, edm::PathsAndConsumesOfModules.schedule_, edm::SubProcess.schedule_, edm::EventProcessor.schedule_, Config.Process.schedule_(), edm::test::TestProcessor.schedule_, Config.Process.sequences, edm::ProcessDesc.services_, Config.Process.services_(), ecaldqm::DBWriterWorker.source_, HGCalTestPartialWaferRecHits.source_, L2MuonSeedGeneratorFromL1TkMu.source_, TestAlpakaObjectAnalyzer.source_, SiStripFedCablingBuilderFromDb.source_, TestPortableAnalyzer.source_, jsoncollector::DataPoint.source_, sistrip::SpyEventMatcher.source_, ProcessCallGraph.source_, Config.Process.source_(), edm::InputSource::EventSourceSentry.source_, edm::InputSource::LumiSourceSentry.source_, edm::InputSource::RunSourceSentry.source_, edm::InputSource::ProcessBlockSourceSentry.source_, TestAlpakaAnalyzer.source_, edm::SubProcess.subProcesses_, Config.Process.subProcesses_(), edm::EventProcessor.subProcesses_, Config.Process.switchProducers_(), Config.Process.tasks, and Config.Process.vpsets.

    def splitPython(self, options = PrintOptions()):
        """return a map of file names to python configuration fragments"""
        specialImportRegistry._reset()
        # extract individual fragments
        options.isCfg = False
        header = "import FWCore.ParameterSet.Config as cms"
        result = ''
        parts = {}
        files = {}

        result = 'process = cms.Process("' + self.__name + '")\n\n'

        if self.source_():
            parts['source'] = (None, 'source = ' + self.source_().dumpPython(options))

        if self.looper_():
            parts['looper'] = (None, 'looper = ' + self.looper_().dumpPython())

        parts.update(self._splitPythonList('psets', self.psets, options))
        parts.update(self._splitPythonList('psets', self.vpsets, options))
        # FIXME
        #parts.update(self._splitPythonSubProcesses(self.subProcesses_(), options))
        if len(self.subProcesses_()):
          sys.stderr.write("error: subprocesses are not supported yet\n\n")
        parts.update(self._splitPythonList('modules', self.producers_(), options))
        parts.update(self._splitPythonList('modules', self.switchProducers_(), options))
        parts.update(self._splitPythonList('modules', self.filters_() , options))
        parts.update(self._splitPythonList('modules', self.analyzers_(), options))
        parts.update(self._splitPythonList('modules', self.outputModules_(), options))
        parts.update(self._splitPythonList('services', self.services_(), options))
        parts.update(self._splitPythonList('eventsetup', self.es_producers_(), options))
        parts.update(self._splitPythonList('eventsetup', self.es_sources_(), options))
        parts.update(self._splitPython('eventsetup', self.es_prefers_(), options))
        parts.update(self._splitPythonList('tasks', self._itemsInDependencyOrder(self.tasks), options))
        parts.update(self._splitPythonList('sequences', self._itemsInDependencyOrder(self.sequences), options))
        parts.update(self._splitPythonList('paths', self.paths_(), options))
        parts.update(self._splitPythonList('paths', self.endpaths_(), options))
        parts.update(self._splitPythonList('paths', self.finalpaths_(), options))
        parts.update(self._splitPythonList('modules', self.aliases_(), options))

        if options.targetDirectory is not None:
            files[options.targetDirectory + '/__init__.py'] = ''

        if options.useSubdirectories:
          for sub in 'psets', 'modules', 'services', 'eventsetup', 'tasks', 'sequences', 'paths':
            if options.targetDirectory is not None:
                sub = options.targetDirectory + '/' + sub
            files[sub + '/__init__.py'] = ''

        # case insensitive sort by subfolder and module name
        parts = sorted(parts.items(), key = lambda nsc: (nsc[1][0].lower() if nsc[1][0] else '', nsc[0].lower()))

        for (name, (subfolder, code)) in parts:
            filename = name + '_cfi'
            if options.useSubdirectories and subfolder:
                filename = subfolder + '/' + filename
            if options.targetDirectory is not None:
                filename = options.targetDirectory + '/' + filename
            result += 'process.load("%s")\n' % filename
            files[filename + '.py'] = header + '\n\n' + code

        if self.schedule_() is not None:
            options.isCfg = True
            result += '\nprocess.schedule = ' + self.schedule.dumpPython(options)

        imports = specialImportRegistry.getSpecialImports()
        if len(imports) > 0:
            header += '\n' + '\n'.join(imports)
        files['-'] = header + '\n\n' + result
        return files

subProcesses_()

def Config.Process.subProcesses_

(

self

)

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

Definition at line 297 of file Config.py.

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

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

switchProducerNames()

def Config.Process.switchProducerNames

(

self

)

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

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

switchProducers_()

def Config.Process.switchProducers_

(

self

)

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

Definition at line 224 of file Config.py.

Referenced by Config.Process.dumpConfig(), Config.Process.dumpPython(), Config.Process.prune(), Config.Process.splitPython(), 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)

tasks_()

def Config.Process.tasks_

(

self

)

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

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

validate()

def Config.Process.validate

(

self

)

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

vpsets_()

def Config.Process.vpsets_

(

self

)

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

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

__isStrict

Config.Process.__isStrict

private

Definition at line 150 of file Config.py.

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

__ppset

Config.Process.__ppset

private

Definition at line 1443 of file Config.py.

__process

Config.Process.__process

private

Definition at line 1444 of file Config.py.

Referenced by Config.ProcessFragment.__delattr__(), Config.ProcessForProcessAccelerator.__delattr__(), Config.ProcessFragment.__dir__(), Config.ProcessForProcessAccelerator.__getattr__(), Config.ProcessFragment.__getattribute__(), Config.ProcessFragment.__setattr__(), Config.ProcessForProcessAccelerator.__setattr__(), Config.ProcessForProcessAccelerator.add_(), Config.SubProcess.dumpPython(), Config.SubProcess.getProcessName(), Config.SubProcess.getSubProcessPSet(), and Config.SubProcess.process().

__processPSet

Config.Process.__processPSet

private

Definition at line 1433 of file Config.py.

__thelist

Config.Process.__thelist

private

Definition at line 1432 of file Config.py.

_firstProcess

Config.Process._firstProcess

staticprivate

Definition at line 115 of file Config.py.

maxLuminosityBlocks

Config.Process.maxLuminosityBlocks

Definition at line 155 of file Config.py.

MessageLogger

Config.Process.MessageLogger

Definition at line 160 of file Config.py.

Property Documentation

aliases

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

static

Definition at line 375 of file Config.py.

analyzers

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

static

Definition at line 304 of file Config.py.

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

conditionaltasks

Config.Process.conditionaltasks = property(conditionaltasks_,doc="dictionary containing the conditionatasks for the process")

static

Definition at line 332 of file Config.py.

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

endpaths

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

static

Definition at line 316 of file Config.py.

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

es_prefers

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

static

Definition at line 371 of file Config.py.

es_producers

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

static

Definition at line 363 of file Config.py.

es_sources

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

static

Definition at line 367 of file Config.py.

filters

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

static

Definition at line 212 of file Config.py.

finalpaths

Config.Process.finalpaths = property(finalpaths_,doc="dictionary containing the finalpaths for the process")

static

Definition at line 320 of file Config.py.

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

looper

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

static

Definition at line 239 of file Config.py.

outputModules

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

static

Definition at line 308 of file Config.py.

paths

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

static

Definition at line 312 of file Config.py.

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

process

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

static

Definition at line 219 of file Config.py.

Referenced by adaptToRunAtMiniAOD.adaptToRunAtMiniAOD.__init__(), adaptToRunAtMiniAOD.adaptToRunAtMiniAOD.convertModuleToMiniAODInput(), runTauIdMVA.TauIDEmbedder.loadMVA_WPs_run2_2017(), runTauIdMVA.TauIDEmbedder.processDeepProducer(), runTauIdMVA.TauIDEmbedder.runTauID(), and runTauIdMVA.TauIDEmbedder.tauIDMVAinputs().

processAccelerators

Config.Process.processAccelerators = property(processAccelerators_,doc="dictionary containing the ProcessAccelerators for the process")

static

Definition at line 359 of file Config.py.

producers

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

static

Definition at line 223 of file Config.py.

psets

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

static

Definition at line 379 of file Config.py.

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

schedule

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

static

Definition at line 351 of file Config.py.

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

sequences

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

static

Definition at line 324 of file Config.py.

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

services

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

static

Definition at line 355 of file Config.py.

Referenced by config.Config.__str__(), looper.Setup.close(), and SequenceVisitors.NodeVisitor.enter().

source

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

static

Definition at line 233 of file Config.py.

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

subProcesses

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

static

Definition at line 300 of file Config.py.

switchProducers

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

static

Definition at line 227 of file Config.py.

tasks

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

static

Definition at line 328 of file Config.py.

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

vpsets

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

static

Definition at line 383 of file Config.py.

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