CMS 3D CMS Logo

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros 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 1085 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 1092 of file jetTools.py.

References editorTools.UserCodeTool._defaultParameters, heavyIonTools.ConfigureHeavyIons._defaultParameters, coreTools.RunOnData._defaultParameters, Vispa.Plugins.ConfigEditor.ToolDataAccessor.ImportTool._defaultParameters, heavyIonTools.ProductionDefaults._defaultParameters, editorTools.ChangeSource._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(), PythonParameterSet.addParameter(), LutXml.addParameter(), ConfigToolBase.ConfigToolBase.addParameter(), and edm::ParameterSet.addParameter().

1093  def __init__(self):
1094  """
1095  Initialize elements of the class. Note that the tool needs to be derived from ConfigToolBase to be usable in the configEditor.
1096  """
1097  ## initialization of the base class
1098  ConfigToolBase.__init__(self)
1099  ## add all parameters that should be known to the class
1100  self.addParameter(self._defaultParameters,'labelName', '', "Label name of the new patJet collection.", str)
1101  self.addParameter(self._defaultParameters,'postfix','', "Postfix from usePF2PAT.", str)
1102  self.addParameter(self._defaultParameters,'btagPrefix','', "Prefix to be added to b-tag discriminator and TagInfo names", str)
1103  self.addParameter(self._defaultParameters,'jetSource','', "Label of the input collection from which the new patJet collection should be created", cms.InputTag)
1104  self.addParameter(self._defaultParameters,'pfCandidates',cms.InputTag('packedPFCandidates'), "Label of the input collection for candidatecandidatese used in b-tagging", cms.InputTag)
1105  self.addParameter(self._defaultParameters,'explicitJTA', False, "Use explicit jet-track association")
1106  self.addParameter(self._defaultParameters,'pvSource',cms.InputTag('offlineSlimmedPrimaryVertices'), "Label of the input collection for primary vertices used in b-tagging", cms.InputTag)
1107  self.addParameter(self._defaultParameters,'svSource',cms.InputTag('slimmedSecondaryVertices'), "Label of the input collection for IVF vertices used in b-tagging", cms.InputTag)
1108  self.addParameter(self._defaultParameters,'elSource',cms.InputTag('slimmedElectrons'), "Label of the input collection for electrons used in b-tagging", cms.InputTag)
1109  self.addParameter(self._defaultParameters,'muSource',cms.InputTag('slimmedMuons'), "Label of the input collection for muons used in b-tagging", cms.InputTag)
1110  self.addParameter(self._defaultParameters,'runIVF', False, "Re-run IVF secondary vertex reconstruction")
1111  self.addParameter(self._defaultParameters,'tightBTagNTkHits', False, "Enable legacy tight b-tag track selection")
1112  self.addParameter(self._defaultParameters,'loadStdRecoBTag', False, "Load the standard reconstruction b-tagging modules")
1113  self.addParameter(self._defaultParameters,'svClustering', False, "Secondary vertices ghost-associated to jets using jet clustering (mostly intended for subjets)")
1114  self.addParameter(self._defaultParameters,'fatJets', cms.InputTag(''), "Fat jet collection used for secondary vertex clustering", cms.InputTag)
1115  self.addParameter(self._defaultParameters,'groomedFatJets', cms.InputTag(''), "Groomed fat jet collection used for secondary vertex clustering", cms.InputTag)
1116  self.addParameter(self._defaultParameters,'algo', 'AK', "Jet algorithm of the input collection from which the new patJet collection should be created")
1117  self.addParameter(self._defaultParameters,'rParam', 0.4, "Jet size (distance parameter R used in jet clustering)")
1118  self.addParameter(self._defaultParameters,'jetCorrections',None, "Add all relevant information about jet energy corrections that you want to be added to your new patJet \
1119  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 \
1120  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 \
1121  new patJet collection. This should be given as a list of strings. Available values are L1Offset, L1FastJet, L1JPTOffset, L2Relative, L3Absolute, L5Falvour, L7Parton; the \
1122  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 \
1123  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 \
1124  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\' \
1125  and \'type-2\' are not case sensitive.", tuple, acceptNoneValue=True)
1126  self.addParameter(self._defaultParameters,'btagDiscriminators',['None'], "If you are interested in btagging, in most cases just the labels of the btag discriminators that \
1127  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. \
1128  If this list is empty no btag discriminator information will be added to your new patJet collection.", allowedValues=supportedBtagDiscr.keys(),Type=list)
1129  self.addParameter(self._defaultParameters,'btagInfos',['None'], "The btagInfos objects contain all relevant information from which all discriminators of a certain \
1130  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 \
1131  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 \
1132  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 \
1133  will be added to your new patJet collection.", allowedValues=supportedBtagInfos,Type=list)
1134  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 \
1135  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 \
1136  to more than one output module.")
1137  ## set defaults
1138  self._parameters=copy.deepcopy(self._defaultParameters)
1139  ## add comments
1140  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\
1141  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 \
1142  the descriptions of each parameter for more information."
_parameters
initialization of the base class
Definition: jetTools.py:1137

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

References editorTools.UserCodeTool._defaultParameters, heavyIonTools.ConfigureHeavyIons._defaultParameters, coreTools.RunOnData._defaultParameters, Vispa.Plugins.ConfigEditor.ToolDataAccessor.ImportTool._defaultParameters, heavyIonTools.ProductionDefaults._defaultParameters, editorTools.ChangeSource._defaultParameters, cmsswVersionTools.PickRelValInputFiles._defaultParameters, coreTools.RemoveMCMatching._defaultParameters, heavyIonTools.SelectionDefaults._defaultParameters, heavyIonTools.DisbaleMonteCarloDeps._defaultParameters, jetTools.AddJetCollection._defaultParameters, jetTools.SwitchJetCollection._defaultParameters, jetTools.UpdateJetCollection._defaultParameters, SignedImpactParameter3D.apply(), gen::PhotosInterfaceBase.apply(), SignedTransverseImpactParameter.apply(), HcalDeterministicFit.apply(), MatrixReader.MatrixReader.apply, SignedDecayLength3D.apply(), DummyOOTPileupCorrection.apply(), gen::PhotosppInterface.apply(), SurveyParameters.apply(), FWPSetCellEditor.apply(), gen::PhotosInterface.apply(), FWGUIEventFilter.apply(), DeviationsFromFileSensor2D.apply(), BeamSpotAlignmentParameters.apply(), RigidBodyAlignmentParameters.apply(), ConfigToolBase.ConfigToolBase.apply(), OOTPileupCorrData.apply(), BowedSurfaceAlignmentParameters.apply(), AlignmentParameters.apply(), Vispa.Plugins.ConfigEditor.ToolDataAccessor.ImportTool.apply(), Vispa.Plugins.ConfigEditor.ToolDataAccessor.ApplyTool.apply(), AbsOOTPileupCorrection.apply(), TwoBowedSurfacesAlignmentParameters.apply(), Vispa.Gui.BoxContentDialog.BoxContentDialog.apply(), reco::modules::TrackerTrackHitFilter::Rule.apply(), PulseShapeFitOOTPileupCorrection.apply(), Vispa.Plugins.ConfigEditor.ToolDialog.ToolDialog.apply(), reco::Add< T >.apply(), reco::Sub< T >.apply(), reco::Mul< T >.apply(), reco::Div< T >.apply(), cmsswVersionTools.PickRelValInputFiles.apply(), reco::And< bool >.apply(), reco::Or< bool >.apply(), reco::Less< T >.apply(), reco::LessEqual< T >.apply(), reco::More< T >.apply(), reco::MoreEqual< T >.apply(), reco::Equal< T >.apply(), npstat::ArrayND< Numeric >.apply(), npstat::ArrayND< Num1, Len1, Dim1 >.apply(), npstat::ArrayND< Numeric, StackLen, StackDim >.apply(), Config.ProcessModifier.apply(), ora::OraMainTable.setParameter(), ora::IMainTable.setParameter(), PedeReader.setParameter(), ora::PoolMainTable.setParameter(), QIE8Simulator.setParameter(), AbsElectronicODERHS.setParameter(), IntegratedCalibrationBase.setParameter(), SiStripLorentzAngleCalibration.setParameter(), SiPixelLorentzAngleCalibration.setParameter(), SiStripBackplaneCalibration.setParameter(), fit::RootMinuit< Function >.setParameter(), and ConfigToolBase.ConfigToolBase.setParameter().

1150  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,jetCorrections=None,btagDiscriminators=None,btagInfos=None):
1151  """
1152  Function call wrapper. This will check the parameters and call the actual implementation that
1153  can be found in toolCode via the base class function apply.
1154  """
1155  if labelName is None:
1156  labelName=self._defaultParameters['labelName'].value
1157  self.setParameter('labelName', labelName)
1158  if postfix is None:
1159  postfix=self._defaultParameters['postfix'].value
1160  self.setParameter('postfix', postfix)
1161  if btagPrefix is None:
1162  btagPrefix=self._defaultParameters['btagPrefix'].value
1163  self.setParameter('btagPrefix', btagPrefix)
1164  if jetSource is None:
1165  jetSource=self._defaultParameters['jetSource'].value
1166  self.setParameter('jetSource', jetSource)
1167  if pfCandidates is None:
1168  pfCandidates=self._defaultParameters['pfCandidates'].value
1169  self.setParameter('pfCandidates', pfCandidates)
1170  if explicitJTA is None:
1171  explicitJTA=self._defaultParameters['explicitJTA'].value
1172  self.setParameter('explicitJTA', explicitJTA)
1173  if pvSource is None:
1174  pvSource=self._defaultParameters['pvSource'].value
1175  self.setParameter('pvSource', pvSource)
1176  if svSource is None:
1177  svSource=self._defaultParameters['svSource'].value
1178  self.setParameter('svSource', svSource)
1179  if elSource is None:
1180  elSource=self._defaultParameters['elSource'].value
1181  self.setParameter('elSource', elSource)
1182  if muSource is None:
1183  muSource=self._defaultParameters['muSource'].value
1184  self.setParameter('muSource', muSource)
1185  if runIVF is None:
1186  runIVF=self._defaultParameters['runIVF'].value
1187  self.setParameter('runIVF', runIVF)
1188  if tightBTagNTkHits is None:
1189  tightBTagNTkHits=self._defaultParameters['tightBTagNTkHits'].value
1190  self.setParameter('tightBTagNTkHits', tightBTagNTkHits)
1191  if loadStdRecoBTag is None:
1192  loadStdRecoBTag=self._defaultParameters['loadStdRecoBTag'].value
1193  self.setParameter('loadStdRecoBTag', loadStdRecoBTag)
1194  if svClustering is None:
1195  svClustering=self._defaultParameters['svClustering'].value
1196  self.setParameter('svClustering', svClustering)
1197  if fatJets is None:
1198  fatJets=self._defaultParameters['fatJets'].value
1199  self.setParameter('fatJets', fatJets)
1200  if groomedFatJets is None:
1201  groomedFatJets=self._defaultParameters['groomedFatJets'].value
1202  self.setParameter('groomedFatJets', groomedFatJets)
1203  if algo is None:
1204  algo=self._defaultParameters['algo'].value
1205  self.setParameter('algo', algo)
1206  if rParam is None:
1207  rParam=self._defaultParameters['rParam'].value
1208  self.setParameter('rParam', rParam)
1209  if jetCorrections is None:
1210  jetCorrections=self._defaultParameters['jetCorrections'].value
1211  self.setParameter('jetCorrections', jetCorrections)
1212  if btagDiscriminators is None:
1213  btagDiscriminators=self._defaultParameters['btagDiscriminators'].value
1214  self.setParameter('btagDiscriminators', btagDiscriminators)
1215  if btagInfos is None:
1216  btagInfos=self._defaultParameters['btagInfos'].value
1217  self.setParameter('btagInfos', btagInfos)
1218  self.apply(process)
def jetTools.UpdateJetCollection.getDefaultParameters (   self)
Return default parameters of the class

Definition at line 1143 of file jetTools.py.

References editorTools.UserCodeTool._defaultParameters, heavyIonTools.ConfigureHeavyIons._defaultParameters, coreTools.RunOnData._defaultParameters, Vispa.Plugins.ConfigEditor.ToolDataAccessor.ImportTool._defaultParameters, heavyIonTools.ProductionDefaults._defaultParameters, editorTools.ChangeSource._defaultParameters, cmsswVersionTools.PickRelValInputFiles._defaultParameters, coreTools.RemoveMCMatching._defaultParameters, heavyIonTools.SelectionDefaults._defaultParameters, heavyIonTools.DisbaleMonteCarloDeps._defaultParameters, jetTools.AddJetCollection._defaultParameters, jetTools.SwitchJetCollection._defaultParameters, and jetTools.UpdateJetCollection._defaultParameters.

1144  def getDefaultParameters(self):
1145  """
1146  Return default parameters of the class
1147  """
1148  return self._defaultParameters
def jetTools.UpdateJetCollection.toolCode (   self,
  process 
)
Tool code implementation

Definition at line 1219 of file jetTools.py.

References editorTools.UserCodeTool._parameters, heavyIonTools.ConfigureHeavyIons._parameters, coreTools.RunOnData._parameters, Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigFolder._parameters, Vispa.Plugins.ConfigEditor.ToolDataAccessor.ImportTool._parameters, heavyIonTools.ProductionDefaults._parameters, ConfigToolBase.ConfigToolBase._parameters, editorTools.ChangeSource._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, jetTools.checkJetCorrectionsFormat(), list(), jetTools.setupBTagging(), jetTools.setupJetCorrections(), split, jetTools.unsupportedJetAlgorithm(), and pileupCalc.upper.

1220  def toolCode(self, process):
1221  """
1222  Tool code implementation
1223  """
1224  ## initialize parameters
1225  labelName=self._parameters['labelName'].value
1226  postfix=self._parameters['postfix'].value
1227  btagPrefix=self._parameters['btagPrefix'].value
1228  jetSource=self._parameters['jetSource'].value
1229  pfCandidates=self._parameters['pfCandidates'].value
1230  explicitJTA=self._parameters['explicitJTA'].value
1231  pvSource=self._parameters['pvSource'].value
1232  svSource=self._parameters['svSource'].value
1233  elSource=self._parameters['elSource'].value
1234  muSource=self._parameters['muSource'].value
1235  runIVF=self._parameters['runIVF'].value
1236  tightBTagNTkHits=self._parameters['tightBTagNTkHits'].value
1237  loadStdRecoBTag=self._parameters['loadStdRecoBTag'].value
1238  svClustering=self._parameters['svClustering'].value
1239  fatJets=self._parameters['fatJets'].value
1240  groomedFatJets=self._parameters['groomedFatJets'].value
1241  algo=self._parameters['algo'].value
1242  rParam=self._parameters['rParam'].value
1243  jetCorrections=self._parameters['jetCorrections'].value
1244  btagDiscriminators=list(self._parameters['btagDiscriminators'].value)
1245  btagInfos=list(self._parameters['btagInfos'].value)
1246 
1247  ## a list of all producer modules, which are already known to process
1248  knownModules = process.producerNames().split()
1249  ## determine whether btagging information is required or not
1250  if btagDiscriminators.count('None')>0:
1251  btagDiscriminators.remove('None')
1252  if btagInfos.count('None')>0:
1253  btagInfos.remove('None')
1254  bTagging=(len(btagDiscriminators)>0 or len(btagInfos)>0)
1255 
1256  ## construct postfix label for auxiliary modules; this postfix
1257  ## label will start with a capitalized first letter following
1258  ## the CMS naming conventions and for improved readablility
1259  _labelName=labelName[:1].upper()+labelName[1:]
1260 
1261  ## supported algo types are ak, ca, and kt
1262  _algo=''
1263  for x in ["ak", "ca", "kt"]:
1264  if x in algo.lower():
1265  _algo=supportedJetAlgos[x]
1266  break
1267  if _algo=='':
1269  ## add new updatedPatJets to process (keep instance for later further modifications)
1270  from PhysicsTools.PatAlgos.producersLayer1.jetUpdater_cfi import updatedPatJets
1271  if 'updatedPatJets'+_labelName+postfix in knownModules :
1272  _newPatJets=getattr(process, 'updatedPatJets'+_labelName+postfix)
1273  _newPatJets.jetSource=jetSource
1274  else :
1275  setattr(process, 'updatedPatJets'+_labelName+postfix, updatedPatJets.clone(jetSource=jetSource))
1276  _newPatJets=getattr(process, 'updatedPatJets'+_labelName+postfix)
1277  knownModules.append('updatedPatJets'+_labelName+postfix)
1278  ## add new selectedUpdatedPatJets to process
1279  from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import selectedPatJets
1280  if 'selectedUpdatedPatJets'+_labelName+postfix in knownModules :
1281  _newSelectedPatJets=getattr(process, 'selectedUpdatedPatJets'+_labelName+postfix)
1282  _newSelectedPatJets.src='updatedPatJets'+_labelName+postfix
1283  else :
1284  setattr(process, 'selectedUpdatedPatJets'+_labelName+postfix, selectedPatJets.clone(src='updatedPatJets'+_labelName+postfix))
1285  knownModules.append('selectedUpdatedPatJets'+_labelName+postfix)
1286 
1287  ## run btagging if required by user
1288  if (bTagging):
1289  print "**************************************************************"
1290  print "b tagging needs to be run on uncorrected jets. Hence, the JECs"
1291  print "will first be undone for 'updatedPatJets%s' and then applied to"%(_labelName+postfix)
1292  print "'updatedPatJetsTransientCorrected%s'."%(_labelName+postfix)
1293  print "**************************************************************"
1294  _jetSource = cms.InputTag('updatedPatJets'+_labelName+postfix)
1295  ## insert new jet collection with jet corrections applied and btag info added
1296  self(
1297  process,
1298  labelName = ('TransientCorrected'+_labelName),
1299  jetSource = _jetSource,
1300  pfCandidates=pfCandidates,
1301  explicitJTA=explicitJTA,
1302  pvSource=pvSource,
1303  svSource=svSource,
1304  elSource=elSource,
1305  muSource=muSource,
1306  runIVF=runIVF,
1307  tightBTagNTkHits=tightBTagNTkHits,
1308  loadStdRecoBTag=loadStdRecoBTag,
1309  svClustering=svClustering,
1310  fatJets=fatJets,
1311  groomedFatJets=groomedFatJets,
1312  algo=algo,
1313  rParam=rParam,
1314  jetCorrections = jetCorrections,
1315  btagPrefix = btagPrefix,
1316  postfix = postfix
1317  )
1318  ## setup btagging
1319  _patJets=getattr(process, 'updatedPatJetsTransientCorrected'+_labelName+postfix)
1320  setupBTagging(process, _jetSource, pfCandidates, explicitJTA, pvSource, svSource, elSource, muSource, runIVF, tightBTagNTkHits, loadStdRecoBTag, svClustering, fatJets, groomedFatJets,
1321  _algo, rParam, btagDiscriminators, btagInfos, _patJets, _labelName, btagPrefix, postfix)
1322  ## update final selected jets
1323  _newSelectedPatJets=getattr(process, 'selectedUpdatedPatJets'+_labelName+postfix)
1324  _newSelectedPatJets.src='updatedPatJetsTransientCorrected'+_labelName+postfix
1325  ## remove automatically added but redundant 'TransientCorrected' selected jets
1326  delattr(process, 'selectedUpdatedPatJetsTransientCorrected'+_labelName+postfix)
1327  else:
1328  _newPatJets.addBTagInfo = False
1329  _newPatJets.addTagInfos = False
1330 
1331  ## add jet correction factors if required by user
1332  if (jetCorrections != None or bTagging):
1333  ## check the jet corrections format
1334  checkJetCorrectionsFormat(jetCorrections)
1335  ## reset MET corrrection
1336  if jetCorrections[2].lower() != 'none' and jetCorrections[2] != '':
1337  print "-------------------------------------------------------------------"
1338  print " Warning: MET correction was set to " + jetCorrections[2] + " but"
1339  print " will be ignored. Please set it to \"None\" to avoid"
1340  print " getting this warning."
1341  print "-------------------------------------------------------------------"
1342  jetCorrectionsList = list(jetCorrections)
1343  jetCorrectionsList[2] = 'None'
1344  jetCorrections = tuple(jetCorrectionsList)
1345  ## if running b tagging, need to use uncorrected jets
1346  if (bTagging):
1347  jetCorrections = ('AK4PFchs', cms.vstring([]), 'None')
1348  ## setup jet energy corrections
1349  setupJetCorrections(process, knownModules, jetCorrections, jetSource, pvSource, _newPatJets, _labelName, postfix)
1350  else:
1351  ## switch jetCorrFactors off
1352  _newPatJets.addJetCorrFactors=False
1353 
1354 updateJetCollection=UpdateJetCollection()
1355 
def setupJetCorrections
Definition: jetTools.py:24
_parameters
initialization of the base class
Definition: jetTools.py:1137
def setupBTagging
Definition: jetTools.py:174
def checkJetCorrectionsFormat
Definition: jetTools.py:16
def unsupportedJetAlgorithm
Definition: jetTools.py:1465
double split
Definition: MVATrainer.cc:139
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger list("!*","!HLTx*"if it matches 2 triggers or more) will accept the event if all the matching triggers are FAIL.It will reject the event if any of the triggers are PASS or EXCEPTION(this matches the behavior of"!*"before the partial wildcard feature was incorporated).Triggers which are in the READY state are completely ignored.(READY should never be returned since the trigger paths have been run

Member Data Documentation

jetTools.UpdateJetCollection._comment
private

add comments

Definition at line 1139 of file jetTools.py.

Referenced by runJetUncertainties.RunJetUncertainties.__init__(), and runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.__init__().

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

Definition at line 1090 of file jetTools.py.

Referenced by HiCoreTools.RestrictInputToAOD.__call__(), trackTools.MakeAODTrackCandidates.__call__(), runJetUncertainties.RunJetUncertainties.__call__(), metTools.AddMETCollection.__call__(), HiCoreTools.RemoveMCMatching.__call__(), trackTools.MakePATTrackCandidates.__call__(), trigTools.SwitchOnTrigger.__call__(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.__call__(), HiCoreTools.RemoveAllPATObjectsBut.__call__(), HiCoreTools.RemoveSpecificPATObjects.__call__(), trigTools.SwitchOnTriggerStandAlone.__call__(), trackTools.MakeTrackCandidates.__call__(), tauTools.AddTauCollection.__call__(), trigTools.SwitchOnTriggerMatching.__call__(), HiCoreTools.RemoveCleaning.__call__(), HiCoreTools.AddCleaning.__call__(), trigTools.SwitchOnTriggerMatchingStandAlone.__call__(), trigTools.SwitchOnTriggerMatchEmbedding.__call__(), jetTools.UpdateJetCollection.__call__(), jetTools.AddJetID.__call__(), jetTools.SetTagInfos.__call__(), metTools.AddMETCollection.__init__(), trackTools.MakeAODTrackCandidates.__init__(), HiCoreTools.RestrictInputToAOD.__init__(), runJetUncertainties.RunJetUncertainties.__init__(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.__init__(), HiCoreTools.RemoveMCMatching.__init__(), trackTools.MakePATTrackCandidates.__init__(), trigTools.SwitchOnTrigger.__init__(), HiCoreTools.RemoveAllPATObjectsBut.__init__(), HiCoreTools.RemoveSpecificPATObjects.__init__(), trigTools.SwitchOnTriggerStandAlone.__init__(), trackTools.MakeTrackCandidates.__init__(), tauTools.AddTauCollection.__init__(), trigTools.SwitchOnTriggerMatching.__init__(), HiCoreTools.RemoveCleaning.__init__(), HiCoreTools.AddCleaning.__init__(), trigTools.SwitchOnTriggerMatchingStandAlone.__init__(), trigTools.SwitchOnTriggerMatchEmbedding.__init__(), jetTools.UpdateJetCollection.__init__(), jetTools.AddJetID.__init__(), jetTools.SetTagInfos.__init__(), ConfigToolBase.ConfigToolBase.dumpPython(), ConfigToolBase.ConfigToolBase.getAllowedValues(), HiCoreTools.RestrictInputToAOD.getDefaultParameters(), trackTools.MakeAODTrackCandidates.getDefaultParameters(), metTools.AddMETCollection.getDefaultParameters(), HiCoreTools.RemoveMCMatching.getDefaultParameters(), trackTools.MakePATTrackCandidates.getDefaultParameters(), trigTools.SwitchOnTrigger.getDefaultParameters(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.getDefaultParameters(), HiCoreTools.RemoveAllPATObjectsBut.getDefaultParameters(), HiCoreTools.RemoveSpecificPATObjects.getDefaultParameters(), trigTools.SwitchOnTriggerStandAlone.getDefaultParameters(), trackTools.MakeTrackCandidates.getDefaultParameters(), tauTools.AddTauCollection.getDefaultParameters(), trigTools.SwitchOnTriggerMatching.getDefaultParameters(), HiCoreTools.RemoveCleaning.getDefaultParameters(), HiCoreTools.AddCleaning.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 1089 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 1137 of file jetTools.py.

Referenced by runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.__call__(), runJetUncertainties.RunJetUncertainties.__init__(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.__init__(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.ak4JetReclustering(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.createMVAMETModule(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.createSmearedJetModule(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.extractMET(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.getCorrectedMET(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.getUnclusteredVariationsForMVAMET(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.jetCleaning(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.jetConfiguration(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.miniAODConfiguration(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.miniAODConfigurationPost(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.produceMET(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.recomputeRawMetFromPfcs(), HiCoreTools.RestrictInputToAOD.toolCode(), trackTools.MakeAODTrackCandidates.toolCode(), metTools.AddMETCollection.toolCode(), runJetUncertainties.RunJetUncertainties.toolCode(), HiCoreTools.RemoveMCMatching.toolCode(), trigTools.SwitchOnTrigger.toolCode(), trackTools.MakePATTrackCandidates.toolCode(), HiCoreTools.RemoveAllPATObjectsBut.toolCode(), HiCoreTools.RemoveSpecificPATObjects.toolCode(), trigTools.SwitchOnTriggerStandAlone.toolCode(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.toolCode(), trackTools.MakeTrackCandidates.toolCode(), tauTools.AddTauCollection.toolCode(), HiCoreTools.RemoveCleaning.toolCode(), trigTools.SwitchOnTriggerMatching.toolCode(), HiCoreTools.AddCleaning.toolCode(), trigTools.SwitchOnTriggerMatchingStandAlone.toolCode(), trigTools.SwitchOnTriggerMatchEmbedding.toolCode(), jetTools.UpdateJetCollection.toolCode(), jetTools.AddJetID.toolCode(), jetTools.SetTagInfos.toolCode(), and runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.updateJECs().