Modules.SwitchProducer Class Reference

Inheritance diagram for Modules.SwitchProducer:

Public Member Functions
def	__init__ (self, caseFunctionDict, kargs)
def	__setattr__ (self, name, value)
def	appendToProcessDescLists_ (self, modules, aliases, myname)
def	caseLabel_ (self, name, case)
def	clone (self, params)
def	dumpPython (self, options=PrintOptions())
def	insertInto (self, parameterSet, myname)
def	moduleLabel_ (self, myname)
def	nameInProcessDesc_ (self, myname)
Public Member Functions inherited from Modules.EDProducer
def	__init__ (self, type_, arg, kargs)
Public Member Functions inherited from Modules._Module
def	__init__ (self, type_, arg, kargs)
def	insertInto (self, parameterSet, myname)
def	setPrerequisites (self, libs)
Public Member Functions inherited from Mixins._TypedParameterizable
def	__init__ (self, type_, arg, kargs)
def	appendToProcessDescList_ (self, lst, myname)
def	clone (self, args, params)
def	copy (self)
def	dumpConfig (self, options=PrintOptions())
def	dumpPython (self, options=PrintOptions())
def	dumpPythonAttributes (self, myname, options)
def	insertInto (self, parameterSet, myname)
def	moduleLabel_ (self, myname)
def	nameInProcessDesc_ (self, myname)
def	type_ (self)
Public Member Functions inherited from Mixins._Parameterizable
def	__delattr__ (self, name)
def	__init__ (self, arg, kargs)
def	__repr__ (self)
def	__setattr__ (self, name, value)
def	dumpPython (self, options=PrintOptions())
def	getParameter (self, params)
def	hasParameter (self, params)
def	insertContentsInto (self, parameterSet)
def	isFrozen (self)
def	isModified (self)
def	parameterNames_ (self)
def	parameters_ (self)
def	setIsFrozen (self)
Public Member Functions inherited from Mixins._Labelable
def	__str__ (self)
def	dumpSequenceConfig (self)
def	dumpSequencePython (self, options=PrintOptions())
def	hasLabel_ (self)
def	label (self)
def	label_ (self)
def	setLabel (self, label)
Public Member Functions inherited from SequenceTypes._SequenceLeaf
def	__init__ (self)
def	isLeaf (self)
Public Member Functions inherited from SequenceTypes._Sequenceable
def	__add__ (self, rhs)
def	__init__ (self)
def	__invert__ (self)
def	__mul__ (self, rhs)
def	isLeaf (self)
def	isOperation (self)
def	resolve (self, processDict, keepIfCannotResolve=False)
def	visitNode (self, visitor)

Static Public Member Functions
def	getCpu ()

Private Member Functions
def	__addParameter (self, name, value)
def	__setParameters (self, parameters)
def	_chooseCase (self)
def	_clonesequence (self, lookuptable)
def	_errorstr (self)
def	_getProducer (self)
def	_placeImpl (self, name, proc)

Static Private Member Functions
def	__typeIsValid (typ)

Private Attributes
	_caseFunctionDict
	_isModified

Detailed Description

This purpose class is to provide a switch of EDProducers for a single module/product label.

The decision is done at the time when the python configuration is
translated to C++. This class is generic, and intended to be
inherited for concrete switches. Example:

class SwitchProducerFoo(SwitchProducer):
    def __init__(self, **kargs):
        super(SwitchProducerFoo,self).__init__(
            dict(case1 = case1Func, case2 = case2Func),
            **kargs
        )

foo = SwitchProducerFoo(
    case1 = EDProducer("Producer1"),
    case2 = EDProducer("Producer2")
)

Here case1Func and case2Func are functions that return a (bool,
int) tuple, where the bool tells whether that case is enabled or
not, and the int tells the priority of that case. The case with
the highest priority among those that are enabled will get chosen.

The end result is that the product(s) labeled as "foo" will be
produced with one of the producers. It would be good if their
output product types and instance names would be the same (or very
close).

Definition at line 221 of file Modules.py.

Constructor & Destructor Documentation

def Modules.SwitchProducer.__init__	(		self,
			caseFunctionDict,
			kargs
	)

Definition at line 250 of file Modules.py.

    def __init__(self, caseFunctionDict, **kargs):
        super(SwitchProducer,self).__init__(None)
        self._caseFunctionDict = copy.copy(caseFunctionDict)
        self.__setParameters(kargs)
        self._isModified = False

Member Function Documentation

def Modules.SwitchProducer.__addParameter (   self,   name,   value  )

private

Definition at line 281 of file Modules.py.

References Modules.SwitchProducer.__typeIsValid(), Modules.SwitchProducer._caseFunctionDict, Mixins._ParameterTypeBase._isModified, Mixins._SimpleParameterTypeBase._isModified, Mixins._Parameterizable._isModified, editorTools.UserCodeTool.dumpPython(), Vispa.Plugins.ConfigEditor.ToolDataAccessor.ImportTool.dumpPython(), Vispa.Plugins.ConfigEditor.ToolDataAccessor.ApplyTool.dumpPython(), Mixins._ParameterTypeBase.dumpPython(), ConfigToolBase.ConfigToolBase.dumpPython(), Mixins.UsingBlock.dumpPython(), Vispa.Plugins.ConfigEditor.ConfigEditorTabController.ConfigEditorTabController.dumpPython(), Mixins._Parameterizable.dumpPython(), Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor.dumpPython(), Config.Process.dumpPython(), Config.SubProcess.dumpPython(), and join().

    def __addParameter(self, name, value):
        if not self.__typeIsValid(value):
            raise TypeError(name+" does not already exist, so it can only be set to a cms.EDProducer or cms.EDAlias")
        if name not in self._caseFunctionDict:
            raise ValueError("Case '%s' is not allowed (allowed ones are %s)" % (name, ",".join(six.iterkeys(self._caseFunctionDict))))
        if name in self.__dict__:
            message = "Duplicate insert of member " + name
            message += "\nThe original parameters are:\n"
            message += self.dumpPython() + '\n'
            raise ValueError(message)
        self.__dict__[name]=value
        self._Parameterizable__parameterNames.append(name)
        self._isModified = True

def Modules.SwitchProducer.__setattr__	(		self,
			name,
			value
	)

Definition at line 299 of file Modules.py.

References Mixins._Parameterizable.__addParameter(), Modules.SwitchProducer.__typeIsValid(), Mixins._ParameterTypeBase._isModified, Mixins._SimpleParameterTypeBase._isModified, Mixins._Parameterizable._isModified, editorTools.UserCodeTool.dumpPython(), Vispa.Plugins.ConfigEditor.ToolDataAccessor.ImportTool.dumpPython(), Vispa.Plugins.ConfigEditor.ToolDataAccessor.ApplyTool.dumpPython(), Mixins._ParameterTypeBase.dumpPython(), ConfigToolBase.ConfigToolBase.dumpPython(), Mixins.UsingBlock.dumpPython(), Vispa.Plugins.ConfigEditor.ConfigEditorTabController.ConfigEditorTabController.dumpPython(), Mixins._Parameterizable.dumpPython(), Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor.dumpPython(), Config.Process.dumpPython(), Config.SubProcess.dumpPython(), Mixins._ParameterTypeBase.isFrozen(), and Mixins._Parameterizable.isFrozen().

Referenced by GenObject.GenObject.setValue().

    def __setattr__(self, name, value):
        # Following snippet copied and customized from
        # _Parameterizable in order to support Modifier.toModify
        #
        #since labels are not supposed to have underscores at the beginning
        # I will assume that if we have such then we are setting an internal variable
        if self.isFrozen() and not (name in ["_Labelable__label","_isFrozen"] or name.startswith('_')):
            message = "Object already added to a process. It is read only now\n"
            message +=  "    %s = %s" %(name, value)
            message += "\nThe original parameters are:\n"
            message += self.dumpPython() + '\n'
            raise ValueError(message)
        # underscored names bypass checking for _ParameterTypeBase
        if name[0]=='_':
            super(SwitchProducer, self).__setattr__(name,value)
        elif not name in self.__dict__:
            self.__addParameter(name, value)
            self._isModified = True
        else:
            if not self.__typeIsValid(value):
                raise TypeError(name+" can only be set to a cms.EDProducer or cms.EDAlias")
            # We should always receive an cms.EDProducer
            self.__dict__[name] = value
            self._isModified = True

def Modules.SwitchProducer.__setParameters (   self,   parameters  )

private

Definition at line 295 of file Modules.py.

References Mixins._Parameterizable.__addParameter().

    def __setParameters(self, parameters):
        for name, value in six.iteritems(parameters):
            self.__addParameter(name, value)

def Modules.SwitchProducer.__typeIsValid (   typ )

staticprivate

Definition at line 278 of file Modules.py.

Referenced by Modules.SwitchProducer.__addParameter(), and Modules.SwitchProducer.__setattr__().

    def __typeIsValid(typ):
        return (isinstance(typ, EDProducer) and not isinstance(typ, SwitchProducer)) or isinstance(typ, EDAlias)

def Modules.SwitchProducer._chooseCase (   self )

private

Returns the name of the chosen case.

Definition at line 261 of file Modules.py.

References Modules.SwitchProducer._caseFunctionDict, Mixins._Parameterizable.parameterNames_(), and str.

Referenced by Modules.SwitchProducer._getProducer(), and Modules.SwitchProducer.insertInto().

    def _chooseCase(self):
        """Returns the name of the chosen case."""
        cases = self.parameterNames_()
        bestCase = None
        for case in cases:
            (enabled, priority) = self._caseFunctionDict[case]()
            if enabled and (bestCase is None or bestCase[0] < priority):
                bestCase = (priority, case)
        if bestCase is None:
            raise RuntimeError("All cases '%s' were disabled" % (str(cases)))
        return bestCase[1]

def Modules.SwitchProducer._clonesequence (   self,   lookuptable  )

private

Definition at line 405 of file Modules.py.

References Modules._Module._errorstr(), and triggerObjects_cff.id.

    def _clonesequence(self, lookuptable):
        try:
            return lookuptable[id(self)]
        except:
            raise ModuleCloneError(self._errorstr())

def Modules.SwitchProducer._errorstr (   self )

private

Definition at line 410 of file Modules.py.

    def _errorstr(self):
        return "SwitchProducer"

def Modules.SwitchProducer._getProducer (   self )

private

Returns the EDroducer of the chosen case

Definition at line 273 of file Modules.py.

References Modules.SwitchProducer._chooseCase().

    def _getProducer(self):
        """Returns the EDroducer of the chosen case"""
        return self.__dict__[self._chooseCase()]

def Modules.SwitchProducer._placeImpl (   self,   name,   proc  )

private

Definition at line 390 of file Modules.py.

Referenced by SequenceTypes._ModuleSequenceType._place(), and Mixins._TypedParameterizable._place().

    def _placeImpl(self,name,proc):
        proc._placeSwitchProducer(name,self)
#        for case in self.parameterNames_():
#            caseLabel = self.caseLabel_(name, case)
#            caseObj = self.__dict__[case]
#
#            if isinstance(caseObj, EDAlias):
#                # EDAliases end up in @all_aliases automatically
#                proc._placeAlias(caseLabel, caseObj)
#            else:
#                # Note that these don't end up in @all_modules
#                # automatically because they're not part of any
#                # Task/Sequence/Path
#                proc._placeProducer(caseLabel, caseObj)

def Modules.SwitchProducer.appendToProcessDescLists_	(		self,
			modules,
			aliases,
			myname
	)

Definition at line 368 of file Modules.py.

References Modules.SwitchProducer.caseLabel_(), and Mixins._Parameterizable.parameterNames_().

    def appendToProcessDescLists_(self, modules, aliases, myname):
        # This way we can insert the chosen EDProducer to @all_modules
        # so that we get easily a worker for it
        modules.append(myname)
        for case in self.parameterNames_():
            if isinstance(self.__dict__[case], EDAlias):
                aliases.append(self.caseLabel_(myname, case))
            else:
                modules.append(self.caseLabel_(myname, case))

def Modules.SwitchProducer.caseLabel_	(		self,
			name,
			case
	)

Definition at line 366 of file Modules.py.

Referenced by Modules.SwitchProducer.appendToProcessDescLists_(), and Modules.SwitchProducer.insertInto().

    def caseLabel_(self, name, case):
        return name+"@"+case

def Modules.SwitchProducer.clone	(		self,
			params
	)

Definition at line 324 of file Modules.py.

References cmsPerfStripChart.dict, Mixins._Parameterizable.parameterNames_(), and Mixins.saveOrigin().

    def clone(self, **params):
        returnValue = SwitchProducer.__new__(type(self))

        # Need special treatment as cms.EDProducer is not a valid parameter type (except in this case)
        myparams = dict()
        for name, value in six.iteritems(params):
            if value is None:
                continue
            elif isinstance(value, dict):
                myparams[name] = self.__dict__[name].clone(**value)
            else: # value is an EDProducer
                myparams[name] = value.clone()

        # Add the ones that were not customized
        for name in self.parameterNames_():
            if name not in params:
                myparams[name] = self.__dict__[name].clone()
        returnValue.__init__(**myparams)
        returnValue._isModified = False
        returnValue._isFrozen = False
        saveOrigin(returnValue, 1)
        return returnValue

def Modules.SwitchProducer.dumpPython	(		self,
			options = PrintOptions()
	)

Definition at line 347 of file Modules.py.

References Mixins._Parameterizable.parameterNames_().

    def dumpPython(self, options=PrintOptions()):
        # Note that if anyone uses the generic SwitchProducer instead
        # of a derived-one, the information on the functions for the
        # producer decision is lost
        specialImportRegistry.registerUse(self)
        result = "%s(" % self.__class__.__name__ # not including cms. since the deriving classes are not in cms "namespace"
        options.indent()
        for resource in sorted(self.parameterNames_()):
            result += "\n" + options.indentation() + resource + " = " + getattr(self, resource).dumpPython(options).rstrip() + ","
        if result[-1] == ",":
            result = result.rstrip(",")
        options.unindent()
        result += "\n)\n"
        return result

def Modules.SwitchProducer.getCpu ( )

static

Returns a function that returns the priority for a CPU "computing device". Intended to be used by deriving classes.

Definition at line 257 of file Modules.py.

    def getCpu():
        """Returns a function that returns the priority for a CPU "computing device". Intended to be used by deriving classes."""
        return _switch_cpu

def Modules.SwitchProducer.insertInto	(		self,
			parameterSet,
			myname
	)

Definition at line 378 of file Modules.py.

References Modules.SwitchProducer._chooseCase(), Modules.SwitchProducer.caseLabel_(), FWJobMetadataManager::Data.moduleLabel_, PFMatchedCandidateRefExtractor.moduleLabel_, edm::ModuleLabelMatch.moduleLabel_, GBRForestWriter.moduleLabel_, MuonMETcorrInputProducer.moduleLabel_, edm::BranchKey.moduleLabel_, SysShiftMETcorrInputProducer.moduleLabel_, ShiftedJetProducerByMatchedObjectT< T >.moduleLabel_, Type0PFMETcorrInputProducer.moduleLabel_, PFCandMETcorrInputProducer.moduleLabel_, NoPileUpPFMEtProducer.moduleLabel_, PFchsMETcorrInputProducer.moduleLabel_, ShiftedPFCandidateProducerForPFMVAMEt.moduleLabel_, MultShiftMETcorrInputProducer.moduleLabel_, MultShiftMETcorrDBInputProducer.moduleLabel_, ShiftedParticleProducer.moduleLabel_, RecoTauDiscriminantCutMultiplexer.moduleLabel_, PATTauDiscriminantCutMultiplexer.moduleLabel_, NoPileUpPFMEtDataProducer.moduleLabel_, ShiftedPFCandidateProducerForPFNoPUMEt.moduleLabel_, BoostedTauSeedsProducer.moduleLabel_, RecoTauGenericJetRegionProducer< JetType, CandType >.moduleLabel_, PATTauDiscriminationAgainstElectronMVA6.moduleLabel_, TauDiscriminationAgainstElectronDeadECAL< TauType, TauDiscriminator >.moduleLabel_, SubjetFilterAlgorithm.moduleLabel_, pat::TauJetCorrFactorsProducer.moduleLabel_, PFRecoTauDiscriminationAgainstElectronMVA6.moduleLabel_, PFRecoTauDiscriminationAgainstElectronMVA5.moduleLabel_, ObjectViewMatcher< T1, T2 >.moduleLabel_, ObjectViewCleaner< T >.moduleLabel_, PFRecoTauDiscriminationAgainstMuonSimple.moduleLabel_, JetIdSelector< T >.moduleLabel_, PFRecoTauChargedHadronProducer.moduleLabel_, edm::ProductSelectorRules::Rule.moduleLabel_, PFRecoTauDiscriminationAgainstMuon2.moduleLabel_, TauTagValidation.moduleLabel_, MinMETProducerT< T >.moduleLabel_, edm::ModuleDescription.moduleLabel_, ShiftedParticleProducerT< T >.moduleLabel_, TauDiscriminationProducerBase< TauType, TauDiscriminator >.moduleLabel_, PFRecoTauDiscriminationAgainstMuonMVA.moduleLabel_, HLTMuonMatchAndPlot.moduleLabel_, CorrectedMETProducerT< T >.moduleLabel_, PFRecoTauDiscriminationByIsolationMVA2.moduleLabel_, edm::test::TestProcessorConfig::ProduceEntry.moduleLabel_, reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2.moduleLabel_, reco::tau::PATTauDiscriminationByMVAIsolationRun2.moduleLabel_, VirtualJetProducer.moduleLabel_, ShiftedJetProducerT< T, Textractor >.moduleLabel_, edm::PoolOutputModule.moduleLabel_, CaloJetMETcorrInputProducerT< T, Textractor >.moduleLabel_, PFRecoTauDiscriminationByIsolation.moduleLabel_, edm::BranchDescription.moduleLabel_, JetCleanerForType1METT< T, Textractor >.moduleLabel_, PFJetMETcorrInputProducerT< T, Textractor >.moduleLabel_, edm::ProductResolverIndexHelper::Item.moduleLabel_, Mixins._TypedParameterizable.moduleLabel_(), Mixins._TypedParameterizable.nameInProcessDesc_(), Config.SubProcess.nameInProcessDesc_(), and Mixins._Parameterizable.parameterNames_().

    def insertInto(self, parameterSet, myname):
        for case in self.parameterNames_():
            producer = self.__dict__[case]
            producer.insertInto(parameterSet, self.caseLabel_(myname, case))
        newpset = parameterSet.newPSet()
        newpset.addString(True, "@module_label", self.moduleLabel_(myname))
        newpset.addString(True, "@module_type", "SwitchProducer")
        newpset.addString(True, "@module_edm_type", "EDProducer")
        newpset.addVString(True, "@all_cases", [myname+"@"+p for p in self.parameterNames_()])
        newpset.addString(False, "@chosen_case", myname+"@"+self._chooseCase())
        parameterSet.addPSet(True, self.nameInProcessDesc_(myname), newpset)

def Modules.SwitchProducer.moduleLabel_	(		self,
			myname
	)

Definition at line 364 of file Modules.py.

Referenced by ExternalGeneratorFilter.ExternalGeneratorFilter.insertInto().

    def moduleLabel_(self, myname):
        return myname

def Modules.SwitchProducer.nameInProcessDesc_	(		self,
			myname
	)

Definition at line 362 of file Modules.py.

Referenced by Types.EDAlias.appendToProcessDescList_(), ExternalGeneratorFilter.ExternalGeneratorFilter.insertInto(), and Types.EDAlias.insertInto().

    def nameInProcessDesc_(self, myname):
        return myname

Member Data Documentation

Modules.SwitchProducer._caseFunctionDict

private

Definition at line 252 of file Modules.py.

Referenced by Modules.SwitchProducer.__addParameter(), and Modules.SwitchProducer._chooseCase().

Modules.SwitchProducer._isModified

private

Definition at line 254 of file Modules.py.