jetTools.UpdateJetCollection Class Reference

Inheritance diagram for jetTools.UpdateJetCollection:

Public Member Functions
def	__call__ (self, process, labelName=None, postfix=None, btagPrefix=None, jetSource=None, pfCandidates=None, explicitJTA=None, pvSource=None, svSource=None, elSource=None, muSource=None, runIVF=None, tightBTagNTkHits=None, loadStdRecoBTag=None, svClustering=None, fatJets=None, groomedFatJets=None, algo=None, rParam=None, sortByPt=None, printWarning=None, jetCorrections=None, btagDiscriminators=None, btagInfos=None)
def	__init__ (self)
def	getDefaultParameters (self)
def	toolCode (self, process)

Private Attributes
	_comment
	add comments More...
	_parameters
	initialization of the base class More...

Static Private Attributes
	_defaultParameters
	_label

Detailed Description

Tool to update a jet collection in your PAT Tuple (primarily intended for MiniAOD for which the default input argument values have been set).

Definition at line 1894 of file jetTools.py.

Constructor & Destructor Documentation

__init__()

def jetTools.UpdateJetCollection.__init__

(

self

)

Initialize elements of the class. Note that the tool needs to be derived from ConfigToolBase to be usable in the configEditor.

Definition at line 1901 of file jetTools.py.

References heavyIonTools.ConfigureHeavyIons._defaultParameters, coreTools.RunOnData._defaultParameters, heavyIonTools.ProductionDefaults._defaultParameters, cmsswVersionTools.PickRelValInputFiles._defaultParameters, coreTools.RemoveMCMatching._defaultParameters, heavyIonTools.SelectionDefaults._defaultParameters, heavyIonTools.DisbaleMonteCarloDeps._defaultParameters, jetTools.AddJetCollection._defaultParameters, jetTools.SwitchJetCollection._defaultParameters, jetTools.UpdateJetCollection._defaultParameters, root::helper::RootFunctionAdapter< F, args >.addParameter(), root::helper::RootFunctionHelper< F, args, Tag >.addParameter(), ParameterMgr.addParameter(), fit::RootMinuit< Function >.addParameter(), DropBoxMetadata::Parameters.addParameter(), Python11ParameterSet.addParameter(), l1t::TriggerSystem.addParameter(), LutXml.addParameter(), ConfigToolBase.ConfigToolBase.addParameter(), and edm::ParameterSet.addParameter().

    def __init__(self):
        """
        Initialize elements of the class. Note that the tool needs to be derived from ConfigToolBase to be usable in the configEditor.
        """
        
        ConfigToolBase.__init__(self)
        
        self.addParameter(self._defaultParameters,'labelName', '', "Label name of the new patJet collection.", str)
        self.addParameter(self._defaultParameters,'postfix','', "Postfix from usePF2PAT.", str)
        self.addParameter(self._defaultParameters,'btagPrefix','', "Prefix to be added to b-tag discriminator and TagInfo names", str)
        self.addParameter(self._defaultParameters,'jetSource','', "Label of the input collection from which the new patJet collection should be created", cms.InputTag)
        self.addParameter(self._defaultParameters,'pfCandidates',cms.InputTag('packedPFCandidates'), "Label of the input collection for candidatecandidatese used in b-tagging", cms.InputTag)
        self.addParameter(self._defaultParameters,'explicitJTA', False, "Use explicit jet-track association")
        self.addParameter(self._defaultParameters,'pvSource',cms.InputTag('offlineSlimmedPrimaryVertices'), "Label of the input collection for primary vertices used in b-tagging", cms.InputTag)
        self.addParameter(self._defaultParameters,'svSource',cms.InputTag('slimmedSecondaryVertices'), "Label of the input collection for IVF vertices used in b-tagging", cms.InputTag)
        self.addParameter(self._defaultParameters,'elSource',cms.InputTag('slimmedElectrons'), "Label of the input collection for electrons used in b-tagging", cms.InputTag)
        self.addParameter(self._defaultParameters,'muSource',cms.InputTag('slimmedMuons'), "Label of the input collection for muons used in b-tagging", cms.InputTag)
        self.addParameter(self._defaultParameters,'runIVF', False, "Re-run IVF secondary vertex reconstruction")
        self.addParameter(self._defaultParameters,'tightBTagNTkHits', False, "Enable legacy tight b-tag track selection")
        self.addParameter(self._defaultParameters,'loadStdRecoBTag', False, "Load the standard reconstruction b-tagging modules")
        self.addParameter(self._defaultParameters,'svClustering', False, "Secondary vertices ghost-associated to jets using jet clustering (mostly intended for subjets)")
        self.addParameter(self._defaultParameters,'fatJets', cms.InputTag(''), "Fat jet collection used for secondary vertex clustering", cms.InputTag)
        self.addParameter(self._defaultParameters,'groomedFatJets', cms.InputTag(''), "Groomed fat jet collection used for secondary vertex clustering", cms.InputTag)
        self.addParameter(self._defaultParameters,'algo', 'AK', "Jet algorithm of the input collection from which the new patJet collection should be created")
        self.addParameter(self._defaultParameters,'rParam', 0.4, "Jet size (distance parameter R used in jet clustering)")
        self.addParameter(self._defaultParameters,'sortByPt', True, "Set to False to not modify incoming jet order")
        self.addParameter(self._defaultParameters,'printWarning', True, "To be use as False in production to reduce log size")
        self.addParameter(self._defaultParameters,'jetCorrections',None, "Add all relevant information about jet energy corrections that you want to be added to your new patJet \
        collection. The format has to be given in a python tuple of type: (\'AK4Calo\',[\'L2Relative\', \'L3Absolute\'], patMet). Here the first argument corresponds to the payload \
        in the CMS Conditions database for the given jet collection; the second argument corresponds to the jet energy correction levels that you want to be embedded into your \
        new patJet collection. This should be given as a list of strings. Available values are L1Offset, L1FastJet, L1JPTOffset, L2Relative, L3Absolute, L5Falvour, L7Parton; the \
        third argument indicates whether MET(Type1/2) corrections should be applied corresponding to the new patJetCollection. If so a new patMet collection will be added to your PAT \
        Tuple in addition to the raw patMet. This new patMet collection will have the MET(Type1/2) corrections applied. The argument can have the following types: \'type-1\' for \
        type-1 corrected MET; \'type-2\' for type-1 plus type-2 corrected MET; \'\' or \'none\' if no further MET corrections should be applied to your MET. The arguments \'type-1\' \
        and \'type-2\' are not case sensitive.", tuple, acceptNoneValue=True)
        self.addParameter(self._defaultParameters,'btagDiscriminators',['None'], "If you are interested in btagging, in most cases just the labels of the btag discriminators that \
        you are interested in is all relevant information that you need for a high level analysis. Add here all btag discriminators, that you are interested in as a list of strings. \
        If this list is empty no btag discriminator information will be added to your new patJet collection.", allowedValues=(list(set().union(supportedBtagDiscr.keys(),supportedMetaDiscr.keys()))),Type=list)
        self.addParameter(self._defaultParameters,'btagInfos',['None'], "The btagInfos objects contain all relevant information from which all discriminators of a certain \
        type have been calculated. You might be interested in keeping this information for low level tests or to re-calculate some discriminators from hand. Note that this information \
        on the one hand can be very space consuming and that it is not necessary to access the pre-calculated btag discriminator information that has been derived from it. Only in very \
        special cases the btagInfos might really be needed in your analysis. Add here all btagInfos, that you are interested in as a list of strings. If this list is empty no btagInfos \
        will be added to your new patJet collection.", allowedValues=supportedBtagInfos,Type=list)
        self.addParameter(self._defaultParameters,'outputModules',['out'],"Add a list of all output modules to which you would like the new jet collection to be added. Usually this is \
        just one single output module with name \'out\', which corresponds also the default configuration of the tool. There is cases though where you might want to add this collection \
        to more than one output module.")
        
        self._parameters=copy.deepcopy(self._defaultParameters)
        
        self._comment = "This is a tool to add more patJet collectinos to your PAT Tuple or to re-configure the default collection. You can add and embed additional information like jet\
        energy correction factors, btag information and generator match information to the new patJet collection depending on the parameters that you pass on to this function. Consult \
        the descriptions of each parameter for more information."

Member Function Documentation

__call__()

def jetTools.UpdateJetCollection.__call__	(		self,
			process,
			labelName = None,
			postfix = None,
			btagPrefix = None,
			jetSource = None,
			pfCandidates = None,
			explicitJTA = None,
			pvSource = None,
			svSource = None,
			elSource = None,
			muSource = None,
			runIVF = None,
			tightBTagNTkHits = None,
			loadStdRecoBTag = None,
			svClustering = None,
			fatJets = None,
			groomedFatJets = None,
			algo = None,
			rParam = None,
			sortByPt = None,
			printWarning = None,
			jetCorrections = None,
			btagDiscriminators = None,
			btagInfos = None
	)

Function call wrapper. This will check the parameters and call the actual implementation that
can be found in toolCode via the base class function apply.

Definition at line 1960 of file jetTools.py.

References heavyIonTools.ConfigureHeavyIons._defaultParameters, coreTools.RunOnData._defaultParameters, heavyIonTools.ProductionDefaults._defaultParameters, cmsswVersionTools.PickRelValInputFiles._defaultParameters, coreTools.RemoveMCMatching._defaultParameters, heavyIonTools.SelectionDefaults._defaultParameters, heavyIonTools.DisbaleMonteCarloDeps._defaultParameters, jetTools.AddJetCollection._defaultParameters, jetTools.SwitchJetCollection._defaultParameters, jetTools.UpdateJetCollection._defaultParameters, SlidingPeakFinder.apply(), SignedImpactParameter3D.apply(), SignedDecayLength3D.apply(), SignedTransverseImpactParameter.apply(), ProcessAcceleratorCUDA.ProcessAcceleratorCUDA.apply(), ProcessAcceleratorROCm.ProcessAcceleratorROCm.apply(), gen::PhotosInterfaceBase.apply(), SurveyParameters.apply(), DummyOOTPileupCorrection.apply(), MatrixReader.MatrixReader.apply, gen::PhotosppInterface.apply(), FWPSetCellEditor.apply(), BeamSpotAlignmentParameters.apply(), RigidBodyAlignmentParameters.apply(), FWGUIEventFilter.apply(), DeviationsFromFileSensor2D.apply(), AlignmentParameters.apply(), ConfigToolBase.ConfigToolBase.apply(), BowedSurfaceAlignmentParameters.apply(), OOTPileupCorrData.apply(), ProcessAcceleratorAlpaka.ProcessAcceleratorAlpaka.apply(), AbsOOTPileupCorrection.apply(), TwoBowedSurfacesAlignmentParameters.apply(), reco::modules::TrackerTrackHitFilter::Rule.apply(), cmsswVersionTools.PickRelValInputFiles.apply(), models.RegExp.apply(), npstat::ArrayND< Numeric, StackLen, StackDim >.apply(), npstat::ArrayND< Numeric >.apply(), Config.ProcessModifier.apply(), Config.ProcessAccelerator.apply(), Config.ProcessAcceleratorTest.apply(), Config.ProcessAcceleratorTest2.apply(), HGCalCassette.setParameter(), PedeReader.setParameter(), QIE8Simulator.setParameter(), AbsElectronicODERHS.setParameter(), SiStripLorentzAngleCalibration.setParameter(), SiPixelLorentzAngleCalibration.setParameter(), IntegratedCalibrationBase.setParameter(), SiStripBackplaneCalibration.setParameter(), fit::RootMinuit< Function >.setParameter(), and ConfigToolBase.ConfigToolBase.setParameter().

    def __call__(self,process,labelName=None,postfix=None,btagPrefix=None,jetSource=None,pfCandidates=None,explicitJTA=None,pvSource=None,svSource=None,elSource=None,muSource=None,runIVF=None,tightBTagNTkHits=None,loadStdRecoBTag=None,svClustering=None,fatJets=None,groomedFatJets=None,algo=None,rParam=None,sortByPt=None,printWarning=None,jetCorrections=None,btagDiscriminators=None,btagInfos=None):
        """
        Function call wrapper. This will check the parameters and call the actual implementation that
        can be found in toolCode via the base class function apply.
        """
        if labelName is None:
            labelName=self._defaultParameters['labelName'].value
        self.setParameter('labelName', labelName)
        if postfix is None:
            postfix=self._defaultParameters['postfix'].value
        self.setParameter('postfix', postfix)
        if btagPrefix is None:
            btagPrefix=self._defaultParameters['btagPrefix'].value
        self.setParameter('btagPrefix', btagPrefix)
        if jetSource is None:
            jetSource=self._defaultParameters['jetSource'].value
        self.setParameter('jetSource', jetSource)
        if pfCandidates is None:
            pfCandidates=self._defaultParameters['pfCandidates'].value
        self.setParameter('pfCandidates', pfCandidates)
        if explicitJTA is None:
            explicitJTA=self._defaultParameters['explicitJTA'].value
        self.setParameter('explicitJTA', explicitJTA)
        if pvSource is None:
            pvSource=self._defaultParameters['pvSource'].value
        self.setParameter('pvSource', pvSource)
        if svSource is None:
            svSource=self._defaultParameters['svSource'].value
        self.setParameter('svSource', svSource)
        if elSource is None:
            elSource=self._defaultParameters['elSource'].value
        self.setParameter('elSource', elSource)
        if muSource is None:
            muSource=self._defaultParameters['muSource'].value
        self.setParameter('muSource', muSource)
        if runIVF is None:
            runIVF=self._defaultParameters['runIVF'].value
        self.setParameter('runIVF', runIVF)
        if tightBTagNTkHits is None:
            tightBTagNTkHits=self._defaultParameters['tightBTagNTkHits'].value
        self.setParameter('tightBTagNTkHits', tightBTagNTkHits)
        if loadStdRecoBTag is None:
            loadStdRecoBTag=self._defaultParameters['loadStdRecoBTag'].value
        self.setParameter('loadStdRecoBTag', loadStdRecoBTag)
        if svClustering is None:
            svClustering=self._defaultParameters['svClustering'].value
        self.setParameter('svClustering', svClustering)
        if fatJets is None:
            fatJets=self._defaultParameters['fatJets'].value
        self.setParameter('fatJets', fatJets)
        if groomedFatJets is None:
            groomedFatJets=self._defaultParameters['groomedFatJets'].value
        self.setParameter('groomedFatJets', groomedFatJets)
        if algo is None:
            algo=self._defaultParameters['algo'].value
        self.setParameter('algo', algo)
        if rParam is None:
            rParam=self._defaultParameters['rParam'].value
        self.setParameter('rParam', rParam)
        if sortByPt is None:
            sortByPt=self._defaultParameters['sortByPt'].value
        self.setParameter('sortByPt', sortByPt)
        if printWarning is None:
            printWarning=self._defaultParameters['printWarning'].value
        self.setParameter('printWarning', printWarning)
        if jetCorrections is None:
            jetCorrections=self._defaultParameters['jetCorrections'].value
        self.setParameter('jetCorrections', jetCorrections)
        if btagDiscriminators is None:
            btagDiscriminators=self._defaultParameters['btagDiscriminators'].value
        self.setParameter('btagDiscriminators', btagDiscriminators)
        if btagInfos is None:
            btagInfos=self._defaultParameters['btagInfos'].value
        self.setParameter('btagInfos', btagInfos)
        self.apply(process)

getDefaultParameters()

def jetTools.UpdateJetCollection.getDefaultParameters

(

self

)

Return default parameters of the class

Definition at line 1954 of file jetTools.py.

References heavyIonTools.ConfigureHeavyIons._defaultParameters, coreTools.RunOnData._defaultParameters, heavyIonTools.ProductionDefaults._defaultParameters, cmsswVersionTools.PickRelValInputFiles._defaultParameters, coreTools.RemoveMCMatching._defaultParameters, heavyIonTools.SelectionDefaults._defaultParameters, heavyIonTools.DisbaleMonteCarloDeps._defaultParameters, jetTools.AddJetCollection._defaultParameters, jetTools.SwitchJetCollection._defaultParameters, and jetTools.UpdateJetCollection._defaultParameters.

    def getDefaultParameters(self):
        """
        Return default parameters of the class
        """
        return self._defaultParameters

toolCode()

def jetTools.UpdateJetCollection.toolCode	(		self,
			process
	)

Tool code implementation

Definition at line 2036 of file jetTools.py.

References heavyIonTools.ConfigureHeavyIons._parameters, coreTools.RunOnData._parameters, heavyIonTools.ProductionDefaults._parameters, ConfigToolBase.ConfigToolBase._parameters, TAbsFitConstraint._parameters, TAbsFitParticle._parameters, cmsswVersionTools.PickRelValInputFiles._parameters, coreTools.RemoveMCMatching._parameters, heavyIonTools.SelectionDefaults._parameters, heavyIonTools.DisbaleMonteCarloDeps._parameters, jetTools.AddJetCollection._parameters, jetTools.SwitchJetCollection._parameters, jetTools.UpdateJetCollection._parameters, helpers.addToProcessAndTask(), jetTools.checkJetCorrectionsFormat(), helpers.getPatAlgosToolsTask(), jetTools.setupBTagging(), jetTools.setupJetCorrections(), submitPVValidationJobs.split(), mkLumiAveragedPlots.tuple, and jetTools.unsupportedJetAlgorithm().

    def toolCode(self, process):
        """
        Tool code implementation
        """
        
        labelName=self._parameters['labelName'].value
        postfix=self._parameters['postfix'].value
        btagPrefix=self._parameters['btagPrefix'].value
        jetSource=self._parameters['jetSource'].value
        pfCandidates=self._parameters['pfCandidates'].value
        explicitJTA=self._parameters['explicitJTA'].value
        pvSource=self._parameters['pvSource'].value
        svSource=self._parameters['svSource'].value
        elSource=self._parameters['elSource'].value
        muSource=self._parameters['muSource'].value
        runIVF=self._parameters['runIVF'].value
        tightBTagNTkHits=self._parameters['tightBTagNTkHits'].value
        loadStdRecoBTag=self._parameters['loadStdRecoBTag'].value
        svClustering=self._parameters['svClustering'].value
        fatJets=self._parameters['fatJets'].value
        groomedFatJets=self._parameters['groomedFatJets'].value
        algo=self._parameters['algo'].value
        rParam=self._parameters['rParam'].value
        sortByPt=self._parameters['sortByPt'].value
        printWarning=self._parameters['printWarning'].value
        jetCorrections=self._parameters['jetCorrections'].value
        btagDiscriminators=list(self._parameters['btagDiscriminators'].value)
        btagInfos=list(self._parameters['btagInfos'].value)

        
        knownModules = process.producerNames().split()
        
        if btagDiscriminators.count('None')>0:
            btagDiscriminators.remove('None')
        if btagInfos.count('None')>0:
            btagInfos.remove('None')
        bTagging=(len(btagDiscriminators)>0 or len(btagInfos)>0)

        
        _labelName=labelName[:1].upper()+labelName[1:]

        
        _algo=''
        for x in ["ak", "ca", "kt"]:
            if x in algo.lower():
                _algo=supportedJetAlgos[x]
                break
        if _algo=='':
            unsupportedJetAlgorithm(self)

        task = getPatAlgosToolsTask(process)

        
        from PhysicsTools.PatAlgos.producersLayer1.jetUpdater_cfi import updatedPatJets
        if not sortByPt: # default is True
            updatedPatJets.sort = cms.bool(False)
        if 'updatedPatJets'+_labelName+postfix in knownModules :
            _newPatJets=getattr(process, 'updatedPatJets'+_labelName+postfix)
            _newPatJets.jetSource=jetSource
        else :
            addToProcessAndTask('updatedPatJets'+_labelName+postfix,
                                updatedPatJets.clone(jetSource=jetSource,
                                printWarning=printWarning), process, task)
            _newPatJets=getattr(process, 'updatedPatJets'+_labelName+postfix)
            knownModules.append('updatedPatJets'+_labelName+postfix)
        
        from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import selectedPatJets
        if 'selectedUpdatedPatJets'+_labelName+postfix in knownModules :
            _newSelectedPatJets=getattr(process, 'selectedUpdatedPatJets'+_labelName+postfix)
            _newSelectedPatJets.src='updatedPatJets'+_labelName+postfix
        else :
            addToProcessAndTask('selectedUpdatedPatJets'+_labelName+postfix,
                                selectedPatJets.clone(src='updatedPatJets'+_labelName+postfix),
                                process, task)
            knownModules.append('selectedUpdatedPatJets'+_labelName+postfix)

        
        if (bTagging):
            if printWarning:
               sys.stderr.write("**************************************************************\n")
               sys.stderr.write("b tagging needs to be run on uncorrected jets. Hence, the JECs\n")
               sys.stderr.write("will first be undone for 'updatedPatJets%s' and then applied to\n" % (_labelName+postfix) )
               sys.stderr.write("'updatedPatJetsTransientCorrected%s'.\n" % (_labelName+postfix) )
               sys.stderr.write("**************************************************************\n")
            _jetSource = cms.InputTag('updatedPatJets'+_labelName+postfix)
            
            self(
                process,
                labelName = ('TransientCorrected'+_labelName),
                jetSource = _jetSource,
                pfCandidates=pfCandidates,
                explicitJTA=explicitJTA,
                pvSource=pvSource,
                svSource=svSource,
                elSource=elSource,
                muSource=muSource,
                runIVF=runIVF,
                tightBTagNTkHits=tightBTagNTkHits,
                loadStdRecoBTag=loadStdRecoBTag,
                svClustering=svClustering,
                fatJets=fatJets,
                groomedFatJets=groomedFatJets,
                algo=algo,
                rParam=rParam,
                jetCorrections = jetCorrections,
                btagPrefix = btagPrefix,
                postfix = postfix
            )
            
            _patJets=getattr(process, 'updatedPatJetsTransientCorrected'+_labelName+postfix)
            setupBTagging(process, _jetSource, pfCandidates, explicitJTA, pvSource, svSource, elSource, muSource, runIVF, tightBTagNTkHits, loadStdRecoBTag, svClustering, fatJets, groomedFatJets,
                          _algo, rParam, btagDiscriminators, btagInfos, _patJets, _labelName, btagPrefix, postfix)
            
            _newSelectedPatJets=getattr(process, 'selectedUpdatedPatJets'+_labelName+postfix)
            _newSelectedPatJets.src='updatedPatJetsTransientCorrected'+_labelName+postfix
            
            delattr(process, 'selectedUpdatedPatJetsTransientCorrected'+_labelName+postfix)
        else:
            _newPatJets.addBTagInfo = False
            _newPatJets.addTagInfos = False

        
        if (jetCorrections is not None or bTagging):
            
            if jetCorrections is None and bTagging:
                raise ValueError("Passing jetCorrections = None while running bTagging is likely not intended.")
            else:
                checkJetCorrectionsFormat(jetCorrections)
            
            if jetCorrections[2].lower() != 'none' and jetCorrections[2] != '':
                sys.stderr.write("-------------------------------------------------------------------\n")
                sys.stderr.write(" Warning: MET correction was set to " + jetCorrections[2] + " but\n")
                sys.stderr.write("          will be ignored. Please set it to \"None\" to avoid\n")
                sys.stderr.write("          getting this warning.\n")
                sys.stderr.write("-------------------------------------------------------------------\n")
                jetCorrectionsList = list(jetCorrections)
                jetCorrectionsList[2] = 'None'
                jetCorrections = tuple(jetCorrectionsList)
            
            if (bTagging):
                jetCorrections = ('AK4PFchs', cms.vstring([]), 'None')
            
            setupJetCorrections(process, knownModules, jetCorrections, jetSource, pvSource, _newPatJets, _labelName, postfix)
        else:
            
            _newPatJets.addJetCorrFactors=False

updateJetCollection=UpdateJetCollection()

Member Data Documentation

_comment

jetTools.UpdateJetCollection._comment

private

add comments

Definition at line 1950 of file jetTools.py.

_defaultParameters

jetTools.UpdateJetCollection._defaultParameters

staticprivate

Definition at line 1899 of file jetTools.py.

Referenced by trackTools.MakeAODTrackCandidates.__call__(), runJetUncertainties.RunJetUncertainties.__call__(), metTools.AddMETCollection.__call__(), trackTools.MakePATTrackCandidates.__call__(), trigTools.SwitchOnTrigger.__call__(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.__call__(), trigTools.SwitchOnTriggerStandAlone.__call__(), tauTools.AddTauCollection.__call__(), trackTools.MakeTrackCandidates.__call__(), trigTools.SwitchOnTriggerMatching.__call__(), trigTools.SwitchOnTriggerMatchingStandAlone.__call__(), trigTools.SwitchOnTriggerMatchEmbedding.__call__(), jetTools.UpdateJetCollection.__call__(), jetTools.AddJetID.__call__(), jetTools.SetTagInfos.__call__(), trackTools.MakeAODTrackCandidates.__init__(), metTools.AddMETCollection.__init__(), runJetUncertainties.RunJetUncertainties.__init__(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.__init__(), trackTools.MakePATTrackCandidates.__init__(), trigTools.SwitchOnTrigger.__init__(), trigTools.SwitchOnTriggerStandAlone.__init__(), tauTools.AddTauCollection.__init__(), trackTools.MakeTrackCandidates.__init__(), trigTools.SwitchOnTriggerMatching.__init__(), trigTools.SwitchOnTriggerMatchingStandAlone.__init__(), trigTools.SwitchOnTriggerMatchEmbedding.__init__(), jetTools.UpdateJetCollection.__init__(), jetTools.AddJetID.__init__(), jetTools.SetTagInfos.__init__(), ConfigToolBase.ConfigToolBase.dumpPython(), ConfigToolBase.ConfigToolBase.getAllowedValues(), trackTools.MakeAODTrackCandidates.getDefaultParameters(), metTools.AddMETCollection.getDefaultParameters(), trackTools.MakePATTrackCandidates.getDefaultParameters(), trigTools.SwitchOnTrigger.getDefaultParameters(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.getDefaultParameters(), trigTools.SwitchOnTriggerStandAlone.getDefaultParameters(), tauTools.AddTauCollection.getDefaultParameters(), trackTools.MakeTrackCandidates.getDefaultParameters(), trigTools.SwitchOnTriggerMatching.getDefaultParameters(), trigTools.SwitchOnTriggerMatchingStandAlone.getDefaultParameters(), trigTools.SwitchOnTriggerMatchEmbedding.getDefaultParameters(), jetTools.UpdateJetCollection.getDefaultParameters(), jetTools.AddJetID.getDefaultParameters(), jetTools.SetTagInfos.getDefaultParameters(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.initializeInputTag(), ConfigToolBase.ConfigToolBase.reset(), and ConfigToolBase.ConfigToolBase.setParameter().

_label

jetTools.UpdateJetCollection._label

staticprivate

Definition at line 1898 of file jetTools.py.

Referenced by validation.SimpleSample.digest(), validation.SimpleSample.label(), trigTools.SwitchOnTrigger.toolCode(), trigTools.SwitchOnTriggerStandAlone.toolCode(), trigTools.SwitchOnTriggerMatching.toolCode(), trigTools.SwitchOnTriggerMatchingStandAlone.toolCode(), and trigTools.SwitchOnTriggerMatchEmbedding.toolCode().

_parameters

jetTools.UpdateJetCollection._parameters

private

initialization of the base class

add all parameters that should be known to the class set defaults

Definition at line 1948 of file jetTools.py.

Referenced by runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.ak4JetReclustering(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.createShiftedModules(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.createSmearedJetModule(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.extractMET(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.getCorrectedMET(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.getMETUncertainties(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.getVariations(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.jetCleaning(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.jetConfiguration(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.miniAODConfiguration(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.miniAODConfigurationPost(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.miniAODConfigurationPre(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.produceMET(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.recomputeRawMetFromPfcs(), trackTools.MakeAODTrackCandidates.toolCode(), metTools.AddMETCollection.toolCode(), runJetUncertainties.RunJetUncertainties.toolCode(), trigTools.SwitchOnTrigger.toolCode(), trackTools.MakePATTrackCandidates.toolCode(), trigTools.SwitchOnTriggerStandAlone.toolCode(), tauTools.AddTauCollection.toolCode(), trackTools.MakeTrackCandidates.toolCode(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.toolCode(), trigTools.SwitchOnTriggerMatching.toolCode(), trigTools.SwitchOnTriggerMatchingStandAlone.toolCode(), trigTools.SwitchOnTriggerMatchEmbedding.toolCode(), jetTools.UpdateJetCollection.toolCode(), jetTools.AddJetID.toolCode(), jetTools.SetTagInfos.toolCode(), and runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.updateJECs().