CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
List of all members | Public Member Functions | Private Attributes | Static Private Attributes
jetTools.UpdateJetCollection Class Reference
Inheritance diagram for jetTools.UpdateJetCollection:

Public Member Functions

def __call__
 
def __init__
 
def getDefaultParameters
 
def toolCode
 

Private Attributes

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

Static Private Attributes

tuple _defaultParameters = dicttypes.SortedKeysDict()
 
string _label = 'updateJetCollection'
 

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 1530 of file jetTools.py.

Constructor & Destructor Documentation

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 1537 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().

1537 
1538  def __init__(self):
1539  """
1540  Initialize elements of the class. Note that the tool needs to be derived from ConfigToolBase to be usable in the configEditor.
1541  """
1542  ## initialization of the base class
1543  ConfigToolBase.__init__(self)
1544  ## add all parameters that should be known to the class
1545  self.addParameter(self._defaultParameters,'labelName', '', "Label name of the new patJet collection.", str)
1546  self.addParameter(self._defaultParameters,'postfix','', "Postfix from usePF2PAT.", str)
1547  self.addParameter(self._defaultParameters,'btagPrefix','', "Prefix to be added to b-tag discriminator and TagInfo names", str)
1548  self.addParameter(self._defaultParameters,'jetSource','', "Label of the input collection from which the new patJet collection should be created", cms.InputTag)
1549  self.addParameter(self._defaultParameters,'pfCandidates',cms.InputTag('packedPFCandidates'), "Label of the input collection for candidatecandidatese used in b-tagging", cms.InputTag)
1550  self.addParameter(self._defaultParameters,'explicitJTA', False, "Use explicit jet-track association")
1551  self.addParameter(self._defaultParameters,'pvSource',cms.InputTag('offlineSlimmedPrimaryVertices'), "Label of the input collection for primary vertices used in b-tagging", cms.InputTag)
1552  self.addParameter(self._defaultParameters,'svSource',cms.InputTag('slimmedSecondaryVertices'), "Label of the input collection for IVF vertices used in b-tagging", cms.InputTag)
1553  self.addParameter(self._defaultParameters,'elSource',cms.InputTag('slimmedElectrons'), "Label of the input collection for electrons used in b-tagging", cms.InputTag)
1554  self.addParameter(self._defaultParameters,'muSource',cms.InputTag('slimmedMuons'), "Label of the input collection for muons used in b-tagging", cms.InputTag)
1555  self.addParameter(self._defaultParameters,'runIVF', False, "Re-run IVF secondary vertex reconstruction")
1556  self.addParameter(self._defaultParameters,'tightBTagNTkHits', False, "Enable legacy tight b-tag track selection")
1557  self.addParameter(self._defaultParameters,'loadStdRecoBTag', False, "Load the standard reconstruction b-tagging modules")
1558  self.addParameter(self._defaultParameters,'svClustering', False, "Secondary vertices ghost-associated to jets using jet clustering (mostly intended for subjets)")
1559  self.addParameter(self._defaultParameters,'fatJets', cms.InputTag(''), "Fat jet collection used for secondary vertex clustering", cms.InputTag)
1560  self.addParameter(self._defaultParameters,'groomedFatJets', cms.InputTag(''), "Groomed fat jet collection used for secondary vertex clustering", cms.InputTag)
1561  self.addParameter(self._defaultParameters,'algo', 'AK', "Jet algorithm of the input collection from which the new patJet collection should be created")
1562  self.addParameter(self._defaultParameters,'rParam', 0.4, "Jet size (distance parameter R used in jet clustering)")
1563  self.addParameter(self._defaultParameters,'sortByPt', True, "Set to False to not modify incoming jet order")
1564  self.addParameter(self._defaultParameters,'printWarning', True, "To be use as False in production to reduce log size")
1565  self.addParameter(self._defaultParameters,'jetCorrections',None, "Add all relevant information about jet energy corrections that you want to be added to your new patJet \
1566  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 \
1567  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 \
1568  new patJet collection. This should be given as a list of strings. Available values are L1Offset, L1FastJet, L1JPTOffset, L2Relative, L3Absolute, L5Falvour, L7Parton; the \
1569  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 \
1570  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 \
1571  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\' \
1572  and \'type-2\' are not case sensitive.", tuple, acceptNoneValue=True)
1573  self.addParameter(self._defaultParameters,'btagDiscriminators',['None'], "If you are interested in btagging, in most cases just the labels of the btag discriminators that \
1574  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. \
1575  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)
1576  self.addParameter(self._defaultParameters,'btagInfos',['None'], "The btagInfos objects contain all relevant information from which all discriminators of a certain \
1577  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 \
1578  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 \
1579  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 \
1580  will be added to your new patJet collection.", allowedValues=supportedBtagInfos,Type=list)
1581  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 \
1582  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 \
1583  to more than one output module.")
1584  ## set defaults
1585  self._parameters=copy.deepcopy(self._defaultParameters)
1586  ## add comments
1587  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\
1588  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 \
1589  the descriptions of each parameter for more information."
jetTools.UpdateJetCollection._parameters
_parameters
initialization of the base class
Definition: jetTools.py:1584

Member Function Documentation

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 1596 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, ProcessAcceleratorCUDA.ProcessAcceleratorCUDA.apply(), SignedImpactParameter3D.apply(), SignedTransverseImpactParameter.apply(), SignedDecayLength3D.apply(), gen::PhotosInterfaceBase.apply(), SurveyParameters.apply(), DummyOOTPileupCorrection.apply(), MatrixReader.MatrixReader.apply, gen::PhotosppInterface.apply(), gen::PhotosInterface.apply(), FWPSetCellEditor.apply(), BeamSpotAlignmentParameters.apply(), RigidBodyAlignmentParameters.apply(), FWGUIEventFilter.apply(), DeviationsFromFileSensor2D.apply(), AlignmentParameters.apply(), ConfigToolBase.ConfigToolBase.apply(), BowedSurfaceAlignmentParameters.apply(), OOTPileupCorrData.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(), PedeReader.setParameter(), QIE8Simulator.setParameter(), AbsElectronicODERHS.setParameter(), SiStripLorentzAngleCalibration.setParameter(), IntegratedCalibrationBase.setParameter(), SiPixelLorentzAngleCalibration.setParameter(), SiStripBackplaneCalibration.setParameter(), fit::RootMinuit< Function >.setParameter(), and ConfigToolBase.ConfigToolBase.setParameter().

1596 
1597  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):
1598  """
1599  Function call wrapper. This will check the parameters and call the actual implementation that
1600  can be found in toolCode via the base class function apply.
1601  """
1602  if labelName is None:
1603  labelName=self._defaultParameters['labelName'].value
1604  self.setParameter('labelName', labelName)
1605  if postfix is None:
1606  postfix=self._defaultParameters['postfix'].value
1607  self.setParameter('postfix', postfix)
1608  if btagPrefix is None:
1609  btagPrefix=self._defaultParameters['btagPrefix'].value
1610  self.setParameter('btagPrefix', btagPrefix)
1611  if jetSource is None:
1612  jetSource=self._defaultParameters['jetSource'].value
1613  self.setParameter('jetSource', jetSource)
1614  if pfCandidates is None:
1615  pfCandidates=self._defaultParameters['pfCandidates'].value
1616  self.setParameter('pfCandidates', pfCandidates)
1617  if explicitJTA is None:
1618  explicitJTA=self._defaultParameters['explicitJTA'].value
1619  self.setParameter('explicitJTA', explicitJTA)
1620  if pvSource is None:
1621  pvSource=self._defaultParameters['pvSource'].value
1622  self.setParameter('pvSource', pvSource)
1623  if svSource is None:
1624  svSource=self._defaultParameters['svSource'].value
1625  self.setParameter('svSource', svSource)
1626  if elSource is None:
1627  elSource=self._defaultParameters['elSource'].value
1628  self.setParameter('elSource', elSource)
1629  if muSource is None:
1630  muSource=self._defaultParameters['muSource'].value
1631  self.setParameter('muSource', muSource)
1632  if runIVF is None:
1633  runIVF=self._defaultParameters['runIVF'].value
1634  self.setParameter('runIVF', runIVF)
1635  if tightBTagNTkHits is None:
1636  tightBTagNTkHits=self._defaultParameters['tightBTagNTkHits'].value
1637  self.setParameter('tightBTagNTkHits', tightBTagNTkHits)
1638  if loadStdRecoBTag is None:
1639  loadStdRecoBTag=self._defaultParameters['loadStdRecoBTag'].value
1640  self.setParameter('loadStdRecoBTag', loadStdRecoBTag)
1641  if svClustering is None:
1642  svClustering=self._defaultParameters['svClustering'].value
1643  self.setParameter('svClustering', svClustering)
1644  if fatJets is None:
1645  fatJets=self._defaultParameters['fatJets'].value
1646  self.setParameter('fatJets', fatJets)
1647  if groomedFatJets is None:
1648  groomedFatJets=self._defaultParameters['groomedFatJets'].value
1649  self.setParameter('groomedFatJets', groomedFatJets)
1650  if algo is None:
1651  algo=self._defaultParameters['algo'].value
1652  self.setParameter('algo', algo)
1653  if rParam is None:
1654  rParam=self._defaultParameters['rParam'].value
1655  self.setParameter('rParam', rParam)
1656  if sortByPt is None:
1657  sortByPt=self._defaultParameters['sortByPt'].value
1658  self.setParameter('sortByPt', sortByPt)
1659  if printWarning is None:
1660  printWarning=self._defaultParameters['printWarning'].value
1661  self.setParameter('printWarning', printWarning)
1662  if jetCorrections is None:
1663  jetCorrections=self._defaultParameters['jetCorrections'].value
1664  self.setParameter('jetCorrections', jetCorrections)
1665  if btagDiscriminators is None:
1666  btagDiscriminators=self._defaultParameters['btagDiscriminators'].value
1667  self.setParameter('btagDiscriminators', btagDiscriminators)
1668  if btagInfos is None:
1669  btagInfos=self._defaultParameters['btagInfos'].value
1670  self.setParameter('btagInfos', btagInfos)
1671  self.apply(process)
def jetTools.UpdateJetCollection.getDefaultParameters (   self) 
Return default parameters of the class

Definition at line 1590 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.

1590 
1591  def getDefaultParameters(self):
1592  """
1593  Return default parameters of the class
1594  """
1595  return self._defaultParameters
def jetTools.UpdateJetCollection.toolCode (   self,
  process 
) 
Tool code implementation

Definition at line 1672 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(), and jetTools.unsupportedJetAlgorithm().

1672 
1673  def toolCode(self, process):
1674  """
1675  Tool code implementation
1676  """
1677  ## initialize parameters
1678  labelName=self._parameters['labelName'].value
1679  postfix=self._parameters['postfix'].value
1680  btagPrefix=self._parameters['btagPrefix'].value
1681  jetSource=self._parameters['jetSource'].value
1682  pfCandidates=self._parameters['pfCandidates'].value
1683  explicitJTA=self._parameters['explicitJTA'].value
1684  pvSource=self._parameters['pvSource'].value
1685  svSource=self._parameters['svSource'].value
1686  elSource=self._parameters['elSource'].value
1687  muSource=self._parameters['muSource'].value
1688  runIVF=self._parameters['runIVF'].value
1689  tightBTagNTkHits=self._parameters['tightBTagNTkHits'].value
1690  loadStdRecoBTag=self._parameters['loadStdRecoBTag'].value
1691  svClustering=self._parameters['svClustering'].value
1692  fatJets=self._parameters['fatJets'].value
1693  groomedFatJets=self._parameters['groomedFatJets'].value
1694  algo=self._parameters['algo'].value
1695  rParam=self._parameters['rParam'].value
1696  sortByPt=self._parameters['sortByPt'].value
1697  printWarning=self._parameters['printWarning'].value
1698  jetCorrections=self._parameters['jetCorrections'].value
1699  btagDiscriminators=list(self._parameters['btagDiscriminators'].value)
1700  btagInfos=list(self._parameters['btagInfos'].value)
1701 
1702  ## a list of all producer modules, which are already known to process
1703  knownModules = process.producerNames().split()
1704  ## determine whether btagging information is required or not
1705  if btagDiscriminators.count('None')>0:
1706  btagDiscriminators.remove('None')
1707  if btagInfos.count('None')>0:
1708  btagInfos.remove('None')
1709  bTagging=(len(btagDiscriminators)>0 or len(btagInfos)>0)
1710 
1711  ## construct postfix label for auxiliary modules; this postfix
1712  ## label will start with a capitalized first letter following
1713  ## the CMS naming conventions and for improved readablility
1714  _labelName=labelName[:1].upper()+labelName[1:]
1715 
1716  ## supported algo types are ak, ca, and kt
1717  _algo=''
1718  for x in ["ak", "ca", "kt"]:
1719  if x in algo.lower():
1720  _algo=supportedJetAlgos[x]
1721  break
1722  if _algo=='':
1723  unsupportedJetAlgorithm(self)
1724 
1725  task = getPatAlgosToolsTask(process)
1726 
1727  ## add new updatedPatJets to process (keep instance for later further modifications)
1728  from PhysicsTools.PatAlgos.producersLayer1.jetUpdater_cfi import updatedPatJets
1729  if not sortByPt: # default is True
1730  updatedPatJets.sort = cms.bool(False)
1731  if 'updatedPatJets'+_labelName+postfix in knownModules :
1732  _newPatJets=getattr(process, 'updatedPatJets'+_labelName+postfix)
1733  _newPatJets.jetSource=jetSource
1734  else :
1735  addToProcessAndTask('updatedPatJets'+_labelName+postfix,
1736  updatedPatJets.clone(jetSource=jetSource,
1737  printWarning=printWarning), process, task)
1738  _newPatJets=getattr(process, 'updatedPatJets'+_labelName+postfix)
1739  knownModules.append('updatedPatJets'+_labelName+postfix)
1740  ## add new selectedUpdatedPatJets to process
1741  from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import selectedPatJets
1742  if 'selectedUpdatedPatJets'+_labelName+postfix in knownModules :
1743  _newSelectedPatJets=getattr(process, 'selectedUpdatedPatJets'+_labelName+postfix)
1744  _newSelectedPatJets.src='updatedPatJets'+_labelName+postfix
1745  else :
1746  addToProcessAndTask('selectedUpdatedPatJets'+_labelName+postfix,
1747  selectedPatJets.clone(src='updatedPatJets'+_labelName+postfix),
1748  process, task)
1749  knownModules.append('selectedUpdatedPatJets'+_labelName+postfix)
1750 
1751  ## run btagging if required by user
1752  if (bTagging):
1753  if printWarning:
1754  sys.stderr.write("**************************************************************\n")
1755  sys.stderr.write("b tagging needs to be run on uncorrected jets. Hence, the JECs\n")
1756  sys.stderr.write("will first be undone for 'updatedPatJets%s' and then applied to\n" % (_labelName+postfix) )
1757  sys.stderr.write("'updatedPatJetsTransientCorrected%s'.\n" % (_labelName+postfix) )
1758  sys.stderr.write("**************************************************************\n")
1759  _jetSource = cms.InputTag('updatedPatJets'+_labelName+postfix)
1760  ## insert new jet collection with jet corrections applied and btag info added
1761  self(
1762  process,
1763  labelName = ('TransientCorrected'+_labelName),
1764  jetSource = _jetSource,
1765  pfCandidates=pfCandidates,
1766  explicitJTA=explicitJTA,
1767  pvSource=pvSource,
1768  svSource=svSource,
1769  elSource=elSource,
1770  muSource=muSource,
1771  runIVF=runIVF,
1772  tightBTagNTkHits=tightBTagNTkHits,
1773  loadStdRecoBTag=loadStdRecoBTag,
1774  svClustering=svClustering,
1775  fatJets=fatJets,
1776  groomedFatJets=groomedFatJets,
1777  algo=algo,
1778  rParam=rParam,
1779  jetCorrections = jetCorrections,
1780  btagPrefix = btagPrefix,
1781  postfix = postfix
1782  )
1783  ## setup btagging
1784  _patJets=getattr(process, 'updatedPatJetsTransientCorrected'+_labelName+postfix)
1785  setupBTagging(process, _jetSource, pfCandidates, explicitJTA, pvSource, svSource, elSource, muSource, runIVF, tightBTagNTkHits, loadStdRecoBTag, svClustering, fatJets, groomedFatJets,
1786  _algo, rParam, btagDiscriminators, btagInfos, _patJets, _labelName, btagPrefix, postfix)
1787  ## update final selected jets
1788  _newSelectedPatJets=getattr(process, 'selectedUpdatedPatJets'+_labelName+postfix)
1789  _newSelectedPatJets.src='updatedPatJetsTransientCorrected'+_labelName+postfix
1790  ## remove automatically added but redundant 'TransientCorrected' selected jets
1791  delattr(process, 'selectedUpdatedPatJetsTransientCorrected'+_labelName+postfix)
1792  else:
1793  _newPatJets.addBTagInfo = False
1794  _newPatJets.addTagInfos = False
1795 
1796  ## add jet correction factors if required by user
1797  if (jetCorrections is not None or bTagging):
1798  ## check the jet corrections format
1799  if jetCorrections is None and bTagging:
1800  raise ValueError("Passing jetCorrections = None while running bTagging is likely not intended.")
1801  else:
1802  checkJetCorrectionsFormat(jetCorrections)
1803  ## reset MET corrrection
1804  if jetCorrections[2].lower() != 'none' and jetCorrections[2] != '':
1805  sys.stderr.write("-------------------------------------------------------------------\n")
1806  sys.stderr.write(" Warning: MET correction was set to " + jetCorrections[2] + " but\n")
1807  sys.stderr.write(" will be ignored. Please set it to \"None\" to avoid\n")
1808  sys.stderr.write(" getting this warning.\n")
1809  sys.stderr.write("-------------------------------------------------------------------\n")
1810  jetCorrectionsList = list(jetCorrections)
1811  jetCorrectionsList[2] = 'None'
1812  jetCorrections = tuple(jetCorrectionsList)
1813  ## if running b tagging, need to use uncorrected jets
1814  if (bTagging):
1815  jetCorrections = ('AK4PFchs', cms.vstring([]), 'None')
1816  ## setup jet energy corrections
1817  setupJetCorrections(process, knownModules, jetCorrections, jetSource, pvSource, _newPatJets, _labelName, postfix)
1818  else:
1819  ## switch jetCorrFactors off
1820  _newPatJets.addJetCorrFactors=False
1821 
1822 updateJetCollection=UpdateJetCollection()
1823 
jetTools.setupJetCorrections
def setupJetCorrections
Definition: jetTools.py:26
helpers.getPatAlgosToolsTask
def getPatAlgosToolsTask
Definition: helpers.py:13
jetUpdater_cfi
jetTools.UpdateJetCollection._parameters
_parameters
initialization of the base class
Definition: jetTools.py:1584
jetTools.setupBTagging
def setupBTagging
Definition: jetTools.py:239
jetTools.checkJetCorrectionsFormat
def checkJetCorrectionsFormat
Definition: jetTools.py:18
jetSelector_cfi
jetTools.unsupportedJetAlgorithm
def unsupportedJetAlgorithm
Definition: jetTools.py:1936
helpers.addToProcessAndTask
def addToProcessAndTask
Definition: helpers.py:28

Member Data Documentation

jetTools.UpdateJetCollection._comment
private

add comments

Definition at line 1586 of file jetTools.py.

tuple jetTools.UpdateJetCollection._defaultParameters = dicttypes.SortedKeysDict()
staticprivate

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

string jetTools.UpdateJetCollection._label = 'updateJetCollection'
staticprivate

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

jetTools.UpdateJetCollection._parameters
private

initialization of the base class

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

Definition at line 1584 of file jetTools.py.

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

Generated for CMSSW Reference Manual by doxygen 1.8.5