test
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 1032 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 1039 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().

1040  def __init__(self):
1041  """
1042  Initialize elements of the class. Note that the tool needs to be derived from ConfigToolBase to be usable in the configEditor.
1043  """
1044  ## initialization of the base class
1045  ConfigToolBase.__init__(self)
1046  ## add all parameters that should be known to the class
1047  self.addParameter(self._defaultParameters,'labelName', '', "Label name of the new patJet collection.", str)
1048  self.addParameter(self._defaultParameters,'postfix','', "Postfix from usePF2PAT.", str)
1049  self.addParameter(self._defaultParameters,'btagPrefix','', "Prefix to be added to b-tag discriminator and TagInfo names", str)
1050  self.addParameter(self._defaultParameters,'jetSource','', "Label of the input collection from which the new patJet collection should be created", cms.InputTag)
1051  self.addParameter(self._defaultParameters,'pfCandidates',cms.InputTag('packedPFCandidates'), "Label of the input collection for candidatecandidatese used in b-tagging", cms.InputTag)
1052  self.addParameter(self._defaultParameters,'explicitJTA', False, "Use explicit jet-track association")
1053  self.addParameter(self._defaultParameters,'pvSource',cms.InputTag('offlineSlimmedPrimaryVertices'), "Label of the input collection for primary vertices used in b-tagging", cms.InputTag)
1054  self.addParameter(self._defaultParameters,'svSource',cms.InputTag('slimmedSecondaryVertices'), "Label of the input collection for IVF vertices used in b-tagging", cms.InputTag)
1055  self.addParameter(self._defaultParameters,'elSource',cms.InputTag('slimmedElectrons'), "Label of the input collection for electrons used in b-tagging", cms.InputTag)
1056  self.addParameter(self._defaultParameters,'muSource',cms.InputTag('slimmedMuons'), "Label of the input collection for muons used in b-tagging", cms.InputTag)
1057  self.addParameter(self._defaultParameters,'runIVF', False, "Re-run IVF secondary vertex reconstruction")
1058  self.addParameter(self._defaultParameters,'tightBTagNTkHits', False, "Enable legacy tight b-tag track selection")
1059  self.addParameter(self._defaultParameters,'loadStdRecoBTag', False, "Load the standard reconstruction b-tagging modules")
1060  self.addParameter(self._defaultParameters,'svClustering', False, "Secondary vertices ghost-associated to jets using jet clustering (mostly intended for subjets)")
1061  self.addParameter(self._defaultParameters,'fatJets', cms.InputTag(''), "Fat jet collection used for secondary vertex clustering", cms.InputTag)
1062  self.addParameter(self._defaultParameters,'groomedFatJets', cms.InputTag(''), "Groomed fat jet collection used for secondary vertex clustering", cms.InputTag)
1063  self.addParameter(self._defaultParameters,'algo', 'AK', "Jet algorithm of the input collection from which the new patJet collection should be created")
1064  self.addParameter(self._defaultParameters,'rParam', 0.4, "Jet size (distance parameter R used in jet clustering)")
1065  self.addParameter(self._defaultParameters,'jetCorrections',None, "Add all relevant information about jet energy corrections that you want to be added to your new patJet \
1066  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 \
1067  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 \
1068  new patJet collection. This should be given as a list of strings. Available values are L1Offset, L1FastJet, L1JPTOffset, L2Relative, L3Absolute, L5Falvour, L7Parton; the \
1069  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 \
1070  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 \
1071  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\' \
1072  and \'type-2\' are not case sensitive.", tuple, acceptNoneValue=True)
1073  self.addParameter(self._defaultParameters,'btagDiscriminators',['None'], "If you are interested in btagging, in most cases just the labels of the btag discriminators that \
1074  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. \
1075  If this list is empty no btag discriminator information will be added to your new patJet collection.", allowedValues=supportedBtagDiscr.keys(),Type=list)
1076  self.addParameter(self._defaultParameters,'btagInfos',['None'], "The btagInfos objects contain all relevant information from which all discriminators of a certain \
1077  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 \
1078  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 \
1079  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 \
1080  will be added to your new patJet collection.", allowedValues=supportedBtagInfos,Type=list)
1081  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 \
1082  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 \
1083  to more than one output module.")
1084  ## set defaults
1085  self._parameters=copy.deepcopy(self._defaultParameters)
1086  ## add comments
1087  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\
1088  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 \
1089  the descriptions of each parameter for more information."
_parameters
initialization of the base class
Definition: jetTools.py:1084

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

1097  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):
1098  """
1099  Function call wrapper. This will check the parameters and call the actual implementation that
1100  can be found in toolCode via the base class function apply.
1101  """
1102  if labelName is None:
1103  labelName=self._defaultParameters['labelName'].value
1104  self.setParameter('labelName', labelName)
1105  if postfix is None:
1106  postfix=self._defaultParameters['postfix'].value
1107  self.setParameter('postfix', postfix)
1108  if btagPrefix is None:
1109  btagPrefix=self._defaultParameters['btagPrefix'].value
1110  self.setParameter('btagPrefix', btagPrefix)
1111  if jetSource is None:
1112  jetSource=self._defaultParameters['jetSource'].value
1113  self.setParameter('jetSource', jetSource)
1114  if pfCandidates is None:
1115  pfCandidates=self._defaultParameters['pfCandidates'].value
1116  self.setParameter('pfCandidates', pfCandidates)
1117  if explicitJTA is None:
1118  explicitJTA=self._defaultParameters['explicitJTA'].value
1119  self.setParameter('explicitJTA', explicitJTA)
1120  if pvSource is None:
1121  pvSource=self._defaultParameters['pvSource'].value
1122  self.setParameter('pvSource', pvSource)
1123  if svSource is None:
1124  svSource=self._defaultParameters['svSource'].value
1125  self.setParameter('svSource', svSource)
1126  if elSource is None:
1127  elSource=self._defaultParameters['elSource'].value
1128  self.setParameter('elSource', elSource)
1129  if muSource is None:
1130  muSource=self._defaultParameters['muSource'].value
1131  self.setParameter('muSource', muSource)
1132  if runIVF is None:
1133  runIVF=self._defaultParameters['runIVF'].value
1134  self.setParameter('runIVF', runIVF)
1135  if tightBTagNTkHits is None:
1136  tightBTagNTkHits=self._defaultParameters['tightBTagNTkHits'].value
1137  self.setParameter('tightBTagNTkHits', tightBTagNTkHits)
1138  if loadStdRecoBTag is None:
1139  loadStdRecoBTag=self._defaultParameters['loadStdRecoBTag'].value
1140  self.setParameter('loadStdRecoBTag', loadStdRecoBTag)
1141  if svClustering is None:
1142  svClustering=self._defaultParameters['svClustering'].value
1143  self.setParameter('svClustering', svClustering)
1144  if fatJets is None:
1145  fatJets=self._defaultParameters['fatJets'].value
1146  self.setParameter('fatJets', fatJets)
1147  if groomedFatJets is None:
1148  groomedFatJets=self._defaultParameters['groomedFatJets'].value
1149  self.setParameter('groomedFatJets', groomedFatJets)
1150  if algo is None:
1151  algo=self._defaultParameters['algo'].value
1152  self.setParameter('algo', algo)
1153  if rParam is None:
1154  rParam=self._defaultParameters['rParam'].value
1155  self.setParameter('rParam', rParam)
1156  if jetCorrections is None:
1157  jetCorrections=self._defaultParameters['jetCorrections'].value
1158  self.setParameter('jetCorrections', jetCorrections)
1159  if btagDiscriminators is None:
1160  btagDiscriminators=self._defaultParameters['btagDiscriminators'].value
1161  self.setParameter('btagDiscriminators', btagDiscriminators)
1162  if btagInfos is None:
1163  btagInfos=self._defaultParameters['btagInfos'].value
1164  self.setParameter('btagInfos', btagInfos)
1165  self.apply(process)
def jetTools.UpdateJetCollection.getDefaultParameters (   self)
Return default parameters of the class

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

1091  def getDefaultParameters(self):
1092  """
1093  Return default parameters of the class
1094  """
1095  return self._defaultParameters
def jetTools.UpdateJetCollection.toolCode (   self,
  process 
)
Tool code implementation

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

1167  def toolCode(self, process):
1168  """
1169  Tool code implementation
1170  """
1171  ## initialize parameters
1172  labelName=self._parameters['labelName'].value
1173  postfix=self._parameters['postfix'].value
1174  btagPrefix=self._parameters['btagPrefix'].value
1175  jetSource=self._parameters['jetSource'].value
1176  pfCandidates=self._parameters['pfCandidates'].value
1177  explicitJTA=self._parameters['explicitJTA'].value
1178  pvSource=self._parameters['pvSource'].value
1179  svSource=self._parameters['svSource'].value
1180  elSource=self._parameters['elSource'].value
1181  muSource=self._parameters['muSource'].value
1182  runIVF=self._parameters['runIVF'].value
1183  tightBTagNTkHits=self._parameters['tightBTagNTkHits'].value
1184  loadStdRecoBTag=self._parameters['loadStdRecoBTag'].value
1185  svClustering=self._parameters['svClustering'].value
1186  fatJets=self._parameters['fatJets'].value
1187  groomedFatJets=self._parameters['groomedFatJets'].value
1188  algo=self._parameters['algo'].value
1189  rParam=self._parameters['rParam'].value
1190  jetCorrections=self._parameters['jetCorrections'].value
1191  btagDiscriminators=list(self._parameters['btagDiscriminators'].value)
1192  btagInfos=list(self._parameters['btagInfos'].value)
1193 
1194  ## a list of all producer modules, which are already known to process
1195  knownModules = process.producerNames().split()
1196  ## determine whether btagging information is required or not
1197  if btagDiscriminators.count('None')>0:
1198  btagDiscriminators.remove('None')
1199  if btagInfos.count('None')>0:
1200  btagInfos.remove('None')
1201  bTagging=(len(btagDiscriminators)>0 or len(btagInfos)>0)
1202 
1203  ## construct postfix label for auxiliary modules; this postfix
1204  ## label will start with a capitalized first letter following
1205  ## the CMS naming conventions and for improved readablility
1206  _labelName=labelName[:1].upper()+labelName[1:]
1207 
1208  ## supported algo types are ak, ca, and kt
1209  _algo=''
1210  for x in ["ak", "ca", "kt"]:
1211  if x in algo.lower():
1212  _algo=supportedJetAlgos[x]
1213  break
1214  if _algo=='':
1216  ## add new updatedPatJets to process (keep instance for later further modifications)
1217  from PhysicsTools.PatAlgos.producersLayer1.jetUpdater_cfi import updatedPatJets
1218  if 'updatedPatJets'+_labelName+postfix in knownModules :
1219  _newPatJets=getattr(process, 'updatedPatJets'+_labelName+postfix)
1220  _newPatJets.jetSource=jetSource
1221  else :
1222  setattr(process, 'updatedPatJets'+_labelName+postfix, updatedPatJets.clone(jetSource=jetSource))
1223  _newPatJets=getattr(process, 'updatedPatJets'+_labelName+postfix)
1224  knownModules.append('updatedPatJets'+_labelName+postfix)
1225  ## add new selectedUpdatedPatJets to process
1226  from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import selectedPatJets
1227  if 'selectedUpdatedPatJets'+_labelName+postfix in knownModules :
1228  _newSelectedPatJets=getattr(process, 'selectedUpdatedPatJets'+_labelName+postfix)
1229  _newSelectedPatJets.src='updatedPatJets'+_labelName+postfix
1230  else :
1231  setattr(process, 'selectedUpdatedPatJets'+_labelName+postfix, selectedPatJets.clone(src='updatedPatJets'+_labelName+postfix))
1232  knownModules.append('selectedUpdatedPatJets'+_labelName+postfix)
1233 
1234  ## run btagging if required by user
1235  if (bTagging):
1236  print "**************************************************************"
1237  print "b tagging needs to be run on uncorrected jets. Hence, the JECs"
1238  print "will first be undone for 'updatedPatJets%s' and then applied to"%(_labelName+postfix)
1239  print "'updatedPatJetsTransientCorrected%s'."%(_labelName+postfix)
1240  print "**************************************************************"
1241  _jetSource = cms.InputTag('updatedPatJets'+_labelName+postfix)
1242  ## insert new jet collection with jet corrections applied and btag info added
1243  self(
1244  process,
1245  labelName = ('TransientCorrected'+_labelName),
1246  jetSource = _jetSource,
1247  pfCandidates=pfCandidates,
1248  explicitJTA=explicitJTA,
1249  pvSource=pvSource,
1250  svSource=svSource,
1251  elSource=elSource,
1252  muSource=muSource,
1253  runIVF=runIVF,
1254  tightBTagNTkHits=tightBTagNTkHits,
1255  loadStdRecoBTag=loadStdRecoBTag,
1256  svClustering=svClustering,
1257  fatJets=fatJets,
1258  groomedFatJets=groomedFatJets,
1259  algo=algo,
1260  rParam=rParam,
1261  jetCorrections = jetCorrections,
1262  btagPrefix = btagPrefix,
1263  postfix = postfix
1264  )
1265  ## setup btagging
1266  _patJets=getattr(process, 'updatedPatJetsTransientCorrected'+_labelName+postfix)
1267  setupBTagging(process, _jetSource, pfCandidates, explicitJTA, pvSource, svSource, elSource, muSource, runIVF, tightBTagNTkHits, loadStdRecoBTag, svClustering, fatJets, groomedFatJets,
1268  _algo, rParam, btagDiscriminators, btagInfos, _patJets, _labelName, btagPrefix, postfix)
1269  ## update final selected jets
1270  _newSelectedPatJets=getattr(process, 'selectedUpdatedPatJets'+_labelName+postfix)
1271  _newSelectedPatJets.src='updatedPatJetsTransientCorrected'+_labelName+postfix
1272  ## remove automatically added but redundant 'TransientCorrected' selected jets
1273  delattr(process, 'selectedUpdatedPatJetsTransientCorrected'+_labelName+postfix)
1274  else:
1275  _newPatJets.addBTagInfo = False
1276  _newPatJets.addTagInfos = False
1277 
1278  ## add jet correction factors if required by user
1279  if (jetCorrections != None or bTagging):
1280  ## check the jet corrections format
1281  checkJetCorrectionsFormat(jetCorrections)
1282  ## reset MET corrrection
1283  if jetCorrections[2].lower() != 'none' and jetCorrections[2] != '':
1284  print "-------------------------------------------------------------------"
1285  print " Warning: MET correction was set to " + jetCorrections[2] + " but"
1286  print " will be ignored. Please set it to \"None\" to avoid"
1287  print " getting this warning."
1288  print "-------------------------------------------------------------------"
1289  jetCorrectionsList = list(jetCorrections)
1290  jetCorrectionsList[2] = 'None'
1291  jetCorrections = tuple(jetCorrectionsList)
1292  ## if running b tagging, need to use uncorrected jets
1293  if (bTagging):
1294  jetCorrections = ('AK4PFchs', cms.vstring([]), 'None')
1295  ## setup jet energy corrections
1296  setupJetCorrections(process, knownModules, jetCorrections, jetSource, pvSource, _newPatJets, _labelName, postfix)
1297  else:
1298  ## switch jetCorrFactors off
1299  _newPatJets.addJetCorrFactors=False
1300 
1301 updateJetCollection=UpdateJetCollection()
1302 
def setupJetCorrections
Definition: jetTools.py:24
_parameters
initialization of the base class
Definition: jetTools.py:1084
def setupBTagging
Definition: jetTools.py:174
def checkJetCorrectionsFormat
Definition: jetTools.py:16
def unsupportedJetAlgorithm
Definition: jetTools.py:1412
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 1086 of file jetTools.py.

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

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

Definition at line 1037 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 1036 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 1084 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().