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 916 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 923 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().

923 
924  def __init__(self):
925  """
926  Initialize elements of the class. Note that the tool needs to be derived from ConfigToolBase to be usable in the configEditor.
927  """
928  ## initialization of the base class
929  ConfigToolBase.__init__(self)
930  ## add all parameters that should be known to the class
931  self.addParameter(self._defaultParameters,'labelName', '', "Label name of the new patJet collection.", str)
932  self.addParameter(self._defaultParameters,'postfix','', "Postfix from usePF2PAT.", str)
933  self.addParameter(self._defaultParameters,'jetSource','', "Label of the input collection from which the new patJet collection should be created", cms.InputTag)
934  self.addParameter(self._defaultParameters,'pfCandidates',cms.InputTag('packedPFCandidates'), "Label of the input collection for candidatecandidatese used in b-tagging", cms.InputTag)
935  self.addParameter(self._defaultParameters,'explicitJTA', False, "Use explicit jet-track association")
936  self.addParameter(self._defaultParameters,'pvSource',cms.InputTag('offlineSlimmedPrimaryVertices'), "Label of the input collection for primary vertices used in b-tagging", cms.InputTag)
937  self.addParameter(self._defaultParameters,'svSource',cms.InputTag('slimmedSecondaryVertices'), "Label of the input collection for IVF vertices used in b-tagging", cms.InputTag)
938  self.addParameter(self._defaultParameters,'elSource',cms.InputTag('slimmedElectrons'), "Label of the input collection for electrons used in b-tagging", cms.InputTag)
939  self.addParameter(self._defaultParameters,'muSource',cms.InputTag('slimmedMuons'), "Label of the input collection for muons used in b-tagging", cms.InputTag)
940  self.addParameter(self._defaultParameters,'runIVF', False, "Re-run IVF secondary vertex reconstruction")
941  self.addParameter(self._defaultParameters,'loadStdRecoBTag', False, "Load the standard reconstruction b-tagging modules")
942  self.addParameter(self._defaultParameters,'svClustering', False, "Secondary vertices ghost-associated to jets using jet clustering (mostly intended for subjets)")
943  self.addParameter(self._defaultParameters,'fatJets', cms.InputTag(''), "Fat jet collection used for secondary vertex clustering", cms.InputTag)
944  self.addParameter(self._defaultParameters,'groomedFatJets', cms.InputTag(''), "Groomed fat jet collection used for secondary vertex clustering", cms.InputTag)
945  self.addParameter(self._defaultParameters,'algo', 'AK', "Jet algorithm of the input collection from which the new patJet collection should be created")
946  self.addParameter(self._defaultParameters,'rParam', 0.4, "Jet size (distance parameter R used in jet clustering)")
947  self.addParameter(self._defaultParameters,'jetCorrections',None, "Add all relevant information about jet energy corrections that you want to be added to your new patJet \
948  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 \
949  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 \
950  new patJet collection. This should be given as a list of strings. Available values are L1Offset, L1FastJet, L1JPTOffset, L2Relative, L3Absolute, L5Falvour, L7Parton; the \
951  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 \
952  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 \
953  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\' \
954  and \'type-2\' are not case sensitive.", tuple, acceptNoneValue=True)
955  self.addParameter(self._defaultParameters,'btagDiscriminators',['None'], "If you are interested in btagging, in most cases just the labels of the btag discriminators that \
956  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. \
957  If this list is empty no btag discriminator information will be added to your new patJet collection.", allowedValues=supportedBtagDiscr.keys(),Type=list)
958  self.addParameter(self._defaultParameters,'btagInfos',['None'], "The btagInfos objects contain all relevant information from which all discriminators of a certain \
959  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 \
960  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 \
961  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 \
962  will be added to your new patJet collection.", allowedValues=supportedBtagInfos,Type=list)
963  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 \
964  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 \
965  to more than one output module.")
966  ## set defaults
967  self._parameters=copy.deepcopy(self._defaultParameters)
968  ## add comments
969  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\
970  energy correction factors, btag infomration and generator match information to the new patJet collection depending on the parameters that you pass on to this function. Consult \
971  the descriptions of each parameter for more information."
jetTools.UpdateJetCollection._parameters
_parameters
initialization of the base class
Definition: jetTools.py:966

Member Function Documentation

def jetTools.UpdateJetCollection.__call__ (   self,
  process,
  labelName = None,
  postfix = None,
  jetSource = None,
  pfCandidates = None,
  explicitJTA = None,
  pvSource = None,
  svSource = None,
  elSource = None,
  muSource = None,
  runIVF = 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 978 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().

978 
979  def __call__(self,process,labelName=None,postfix=None,jetSource=None,pfCandidates=None,explicitJTA=None,pvSource=None,svSource=None,elSource=None,muSource=None,runIVF=None,loadStdRecoBTag=None,svClustering=None,fatJets=None,groomedFatJets=None,algo=None,rParam=None,jetCorrections=None,btagDiscriminators=None,btagInfos=None):
980  """
981  Function call wrapper. This will check the parameters and call the actual implementation that
982  can be found in toolCode via the base class function apply.
983  """
984  if labelName is None:
985  labelName=self._defaultParameters['labelName'].value
986  self.setParameter('labelName', labelName)
987  if postfix is None:
988  postfix=self._defaultParameters['postfix'].value
989  self.setParameter('postfix', postfix)
990  if jetSource is None:
991  jetSource=self._defaultParameters['jetSource'].value
992  self.setParameter('jetSource', jetSource)
993  if pfCandidates is None:
994  pfCandidates=self._defaultParameters['pfCandidates'].value
995  self.setParameter('pfCandidates', pfCandidates)
996  if explicitJTA is None:
997  explicitJTA=self._defaultParameters['explicitJTA'].value
998  self.setParameter('explicitJTA', explicitJTA)
999  if pvSource is None:
1000  pvSource=self._defaultParameters['pvSource'].value
1001  self.setParameter('pvSource', pvSource)
1002  if svSource is None:
1003  svSource=self._defaultParameters['svSource'].value
1004  self.setParameter('svSource', svSource)
1005  if elSource is None:
1006  elSource=self._defaultParameters['elSource'].value
1007  self.setParameter('elSource', elSource)
1008  if muSource is None:
1009  muSource=self._defaultParameters['muSource'].value
1010  self.setParameter('muSource', muSource)
1011  if runIVF is None:
1012  runIVF=self._defaultParameters['runIVF'].value
1013  self.setParameter('runIVF', runIVF)
1014  if loadStdRecoBTag is None:
1015  loadStdRecoBTag=self._defaultParameters['loadStdRecoBTag'].value
1016  self.setParameter('loadStdRecoBTag', loadStdRecoBTag)
1017  if svClustering is None:
1018  svClustering=self._defaultParameters['svClustering'].value
1019  self.setParameter('svClustering', svClustering)
1020  if fatJets is None:
1021  fatJets=self._defaultParameters['fatJets'].value
1022  self.setParameter('fatJets', fatJets)
1023  if groomedFatJets is None:
1024  groomedFatJets=self._defaultParameters['groomedFatJets'].value
1025  self.setParameter('groomedFatJets', groomedFatJets)
1026  if algo is None:
1027  algo=self._defaultParameters['algo'].value
1028  self.setParameter('algo', algo)
1029  if rParam is None:
1030  rParam=self._defaultParameters['rParam'].value
1031  self.setParameter('rParam', rParam)
1032  if jetCorrections is None:
1033  jetCorrections=self._defaultParameters['jetCorrections'].value
1034  self.setParameter('jetCorrections', jetCorrections)
1035  if btagDiscriminators is None:
1036  btagDiscriminators=self._defaultParameters['btagDiscriminators'].value
1037  self.setParameter('btagDiscriminators', btagDiscriminators)
1038  if btagInfos is None:
1039  btagInfos=self._defaultParameters['btagInfos'].value
1040  self.setParameter('btagInfos', btagInfos)
1041  self.apply(process)
def jetTools.UpdateJetCollection.getDefaultParameters (   self) 
Return default parameters of the class

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

972 
973  def getDefaultParameters(self):
974  """
975  Return default parameters of the class
976  """
977  return self._defaultParameters
def jetTools.UpdateJetCollection.toolCode (   self,
  process 
) 
Tool code implementation

Definition at line 1042 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, coreTools.RemoveMCMatching._parameters, cmsswVersionTools.PickRelValInputFiles._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.

1042 
1043  def toolCode(self, process):
1044  """
1045  Tool code implementation
1046  """
1047  ## initialize parameters
1048  labelName=self._parameters['labelName'].value
1049  postfix=self._parameters['postfix'].value
1050  jetSource=self._parameters['jetSource'].value
1051  pfCandidates=self._parameters['pfCandidates'].value
1052  explicitJTA=self._parameters['explicitJTA'].value
1053  pvSource=self._parameters['pvSource'].value
1054  svSource=self._parameters['svSource'].value
1055  elSource=self._parameters['elSource'].value
1056  muSource=self._parameters['muSource'].value
1057  runIVF=self._parameters['runIVF'].value
1058  loadStdRecoBTag=self._parameters['loadStdRecoBTag'].value
1059  svClustering=self._parameters['svClustering'].value
1060  fatJets=self._parameters['fatJets'].value
1061  groomedFatJets=self._parameters['groomedFatJets'].value
1062  algo=self._parameters['algo'].value
1063  rParam=self._parameters['rParam'].value
1064  jetCorrections=self._parameters['jetCorrections'].value
1065  btagDiscriminators=list(self._parameters['btagDiscriminators'].value)
1066  btagInfos=list(self._parameters['btagInfos'].value)
1067 
1068  ## a list of all producer modules, which are already known to process
1069  knownModules = process.producerNames().split()
1070  ## determine whether btagging information is required or not
1071  if btagDiscriminators.count('None')>0:
1072  btagDiscriminators.remove('None')
1073  if btagInfos.count('None')>0:
1074  btagInfos.remove('None')
1075  bTagging=(len(btagDiscriminators)>0 or len(btagInfos)>0)
1076 
1077  ## construct postfix label for auxiliary modules; this postfix
1078  ## label will start with a capitalized first letter following
1079  ## the CMS naming conventions and for improved readablility
1080  _labelName=labelName[:1].upper()+labelName[1:]
1081 
1082  ## supported algo types are ak, ca, and kt
1083  _algo=''
1084  for x in ["ak", "ca", "kt"]:
1085  if x in algo.lower():
1086  _algo=supportedJetAlgos[x]
1087  break
1088  if _algo=='':
1089  unsupportedJetAlgorithm(self)
1090  ## add new updatedPatJets to process (keep instance for later further modifications)
1091  from PhysicsTools.PatAlgos.producersLayer1.jetUpdater_cfi import updatedPatJets
1092  if 'updatedPatJets'+_labelName+postfix in knownModules :
1093  _newPatJets=getattr(process, 'updatedPatJets'+_labelName+postfix)
1094  _newPatJets.jetSource=jetSource
1095  else :
1096  setattr(process, 'updatedPatJets'+_labelName+postfix, updatedPatJets.clone(jetSource=jetSource))
1097  _newPatJets=getattr(process, 'updatedPatJets'+_labelName+postfix)
1098  knownModules.append('updatedPatJets'+_labelName+postfix)
1099  ## add new selectedUpdatedPatJets to process
1100  from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import selectedPatJets
1101  if 'selectedUpdatedPatJets'+_labelName+postfix in knownModules :
1102  _newSelectedPatJets=getattr(process, 'selectedUpdatedPatJets'+_labelName+postfix)
1103  _newSelectedPatJets.src='updatedPatJets'+_labelName+postfix
1104  else :
1105  setattr(process, 'selectedUpdatedPatJets'+_labelName+postfix, selectedPatJets.clone(src='updatedPatJets'+_labelName+postfix))
1106  knownModules.append('selectedUpdatedPatJets'+_labelName+postfix)
1107 
1108  ## run btagging if required by user
1109  if (bTagging):
1110  print "**************************************************************"
1111  print "b tagging needs to be run on uncorrected jets. Hence, the JECs"
1112  print "will first be undone for 'updatedPatJets%s' and then applied to"%(_labelName+postfix)
1113  print "'updatedPatJetsTransientCorrected%s'."%(_labelName+postfix)
1114  print "**************************************************************"
1115  _jetSource = cms.InputTag('updatedPatJets'+_labelName+postfix)
1116  ## insert new jet collection with jet corrections applied and btag info added
1117  self(
1118  process,
1119  labelName = ('TransientCorrected'+_labelName),
1120  jetSource = _jetSource,
1121  pfCandidates=pfCandidates,
1122  explicitJTA=explicitJTA,
1123  pvSource=pvSource,
1124  svSource=svSource,
1125  elSource=elSource,
1126  muSource=muSource,
1127  runIVF=runIVF,
1128  loadStdRecoBTag=loadStdRecoBTag,
1129  svClustering=svClustering,
1130  fatJets=fatJets,
1131  groomedFatJets=groomedFatJets,
1132  algo=algo,
1133  rParam=rParam,
1134  jetCorrections = jetCorrections,
1135  postfix = postfix
1136  )
1137  ## setup btagging
1138  _patJets=getattr(process, 'updatedPatJetsTransientCorrected'+_labelName+postfix)
1139  setupBTagging(process, _jetSource, pfCandidates, explicitJTA, pvSource, svSource, elSource, muSource, runIVF, loadStdRecoBTag, svClustering, fatJets, groomedFatJets,
1140  _algo, rParam, btagDiscriminators, btagInfos, _patJets, _labelName, postfix)
1141  ## update final selected jets
1142  _newSelectedPatJets=getattr(process, 'selectedUpdatedPatJets'+_labelName+postfix)
1143  _newSelectedPatJets.src='updatedPatJetsTransientCorrected'+_labelName+postfix
1144  ## remove automatically added but redundant 'TransientCorrected' selected jets
1145  delattr(process, 'selectedUpdatedPatJetsTransientCorrected'+_labelName+postfix)
1146  else:
1147  _newPatJets.addBTagInfo = False
1148  _newPatJets.addTagInfos = False
1149 
1150  ## add jet correction factors if required by user
1151  if (jetCorrections != None or bTagging):
1152  ## check the jet corrections format
1153  checkJetCorrectionsFormat(jetCorrections)
1154  ## reset MET corrrection
1155  if jetCorrections[2].lower() != 'none' and jetCorrections[2] != '':
1156  print "-------------------------------------------------------------------"
1157  print " Warning: MET correction was set to " + jetCorrections[2] + " but"
1158  print " will be ignored. Please set it to \"None\" to avoid"
1159  print " getting this warning."
1160  print "-------------------------------------------------------------------"
1161  jetCorrectionsList = list(jetCorrections)
1162  jetCorrectionsList[2] = 'None'
1163  jetCorrections = tuple(jetCorrectionsList)
1164  ## if running b tagging, need to use uncorrected jets
1165  if (bTagging):
1166  jetCorrections = ('AK4PFchs', cms.vstring([]), 'None')
1167  ## setup jet energy corrections
1168  setupJetCorrections(process, knownModules, jetCorrections, jetSource, pvSource, _newPatJets, _labelName, postfix)
1169  else:
1170  ## switch jetCorrFactors off
1171  _newPatJets.addJetCorrFactors=False
1172 
1173 updateJetCollection=UpdateJetCollection()
1174 
jetTools.setupJetCorrections
def setupJetCorrections
Definition: jetTools.py:24
jetUpdater_cfi
jetTools.UpdateJetCollection._parameters
_parameters
initialization of the base class
Definition: jetTools.py:966
jetTools.setupBTagging
def setupBTagging
Definition: jetTools.py:173
jetTools.checkJetCorrectionsFormat
def checkJetCorrectionsFormat
Definition: jetTools.py:16
jetSelector_cfi
jetTools.unsupportedJetAlgorithm
def unsupportedJetAlgorithm
Definition: jetTools.py:1284
split
double split
Definition: MVATrainer.cc:139
list
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 968 of file jetTools.py.

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

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

Definition at line 921 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 920 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 966 of file jetTools.py.

Referenced by runJetUncertainties.RunJetUncertainties.__init__(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.__init__(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.ak4JetReclustering(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.createMVAMETModule(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.createSmearedJetModule(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.getCorrectedMET(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.getUnclusteredVariationsForMVAMET(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.jetCleaning(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.jetConfiguration(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties.miniAODConfiguration(), 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().

Generated for CMSSW Reference Manual by doxygen 1.8.5