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	directDependencies (self)
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	setPrerequisites (self, *libs)
Public Member Functions inherited from Mixins._TypedParameterizable
def	appendToProcessDescList_ (self, lst, myname)
def	clone (self, *args, **params)
def	copy (self)
def	dumpConfig (self, options=PrintOptions())
def	dumpPythonAttributes (self, myname, options)
def	type_ (self)
Public Member Functions inherited from Mixins._Parameterizable
def	__delattr__ (self, name)
def	__init__ (self, *arg, **kargs)
def	__repr__ (self)
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	__invert__ (self)
def	__mul__ (self, rhs)
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 220 of file Modules.py.

Constructor & Destructor Documentation

__init__()

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

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

__addParameter()

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

private

Reimplemented from Mixins._Parameterizable.

Definition at line 280 of file Modules.py.

    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(self._caseFunctionDict.keys())))
        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
 

References Modules.SwitchProducer.__typeIsValid(), Modules.SwitchProducer._caseFunctionDict, Mixins._ParameterTypeBase._isModified, Mixins._SimpleParameterTypeBase._isModified, Mixins._Parameterizable._isModified, mps_setup.append, Mixins._ParameterTypeBase.dumpPython(), Mixins.UsingBlock.dumpPython(), Mixins._Parameterizable.dumpPython(), Config.Process.dumpPython(), Config.SubProcess.dumpPython(), join(), and relativeConstraints.keys.

__setattr__()

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

Reimplemented from Mixins._Parameterizable.

Definition at line 298 of file Modules.py.

    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
 

References Mixins._Parameterizable.__addParameter(), Modules.SwitchProducer.__typeIsValid(), Mixins._ParameterTypeBase._isModified, Mixins._SimpleParameterTypeBase._isModified, Mixins._Parameterizable._isModified, Mixins._ParameterTypeBase.dumpPython(), Mixins.UsingBlock.dumpPython(), Mixins._Parameterizable.dumpPython(), Config.Process.dumpPython(), Config.SubProcess.dumpPython(), Mixins._ParameterTypeBase.isFrozen(), and Mixins._Parameterizable.isFrozen().

Referenced by GenObject.GenObject.setValue().

__setParameters()

def Modules.SwitchProducer.__setParameters (   self,   parameters  )

private

Reimplemented from Mixins._Parameterizable.

Definition at line 294 of file Modules.py.

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

References Mixins._Parameterizable.__addParameter().

__typeIsValid()

def Modules.SwitchProducer.__typeIsValid (   typ )

staticprivate

Definition at line 277 of file Modules.py.

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

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

_chooseCase()

def Modules.SwitchProducer._chooseCase (   self )

private

Returns the name of the chosen case.

Definition at line 260 of file Modules.py.

    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]
 

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

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

_clonesequence()

def Modules.SwitchProducer._clonesequence (   self,   lookuptable  )

private

Reimplemented from Modules._Module.

Definition at line 408 of file Modules.py.

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

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

_errorstr()

def Modules.SwitchProducer._errorstr (   self )

private

Reimplemented from Modules._Module.

Definition at line 413 of file Modules.py.

    def _errorstr(self):
        return "SwitchProducer"
 
 

_getProducer()

def Modules.SwitchProducer._getProducer (   self )

private

Returns the EDroducer of the chosen case

Definition at line 272 of file Modules.py.

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

References Modules.SwitchProducer._chooseCase().

_placeImpl()

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

private

Reimplemented from Modules.EDProducer.

Definition at line 393 of file Modules.py.

    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)
 

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

appendToProcessDescLists_()

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

Definition at line 371 of file Modules.py.

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

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

caseLabel_()

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

Definition at line 369 of file Modules.py.

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

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

clone()

def Modules.SwitchProducer.clone	(		self,
		**	params
	)

Definition at line 323 of file Modules.py.

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

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

directDependencies()

def Modules.SwitchProducer.directDependencies

(

self

)

Reimplemented from Mixins._TypedParameterizable.

Definition at line 361 of file Modules.py.

    def directDependencies(self):
        # XXX FIXME handle SwitchProducer dependencies
        return []
 

dumpPython()

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

Reimplemented from Mixins._TypedParameterizable.

Definition at line 346 of file Modules.py.

    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
 

References __class__< T >.__class__(), and Mixins._Parameterizable.parameterNames_().

Referenced by Types._AllowedParameterTypes.__init__().

getCpu()

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

insertInto()

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

Reimplemented from Modules._Module.

Definition at line 381 of file Modules.py.

    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)
 

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

moduleLabel_()

def Modules.SwitchProducer.moduleLabel_	(		self,
			myname
	)

Reimplemented from Mixins._TypedParameterizable.

Definition at line 367 of file Modules.py.

    def moduleLabel_(self, myname):
        return myname

Referenced by ExternalGeneratorFilter.ExternalGeneratorFilter.insertInto().

nameInProcessDesc_()

def Modules.SwitchProducer.nameInProcessDesc_	(		self,
			myname
	)

Reimplemented from Mixins._TypedParameterizable.

Definition at line 365 of file Modules.py.

    def nameInProcessDesc_(self, myname):
        return myname

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

Member Data Documentation

_caseFunctionDict

Modules.SwitchProducer._caseFunctionDict

private

Definition at line 251 of file Modules.py.

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

_isModified

Modules.SwitchProducer._isModified

private

Definition at line 253 of file Modules.py.