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 927 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 934 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().

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

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

989 
990  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):
991  """
992  Function call wrapper. This will check the parameters and call the actual implementation that
993  can be found in toolCode via the base class function apply.
994  """
995  if labelName is None:
996  labelName=self._defaultParameters['labelName'].value
997  self.setParameter('labelName', labelName)
998  if postfix is None:
999  postfix=self._defaultParameters['postfix'].value
1000  self.setParameter('postfix', postfix)
1001  if jetSource is None:
1002  jetSource=self._defaultParameters['jetSource'].value
1003  self.setParameter('jetSource', jetSource)
1004  if pfCandidates is None:
1005  pfCandidates=self._defaultParameters['pfCandidates'].value
1006  self.setParameter('pfCandidates', pfCandidates)
1007  if explicitJTA is None:
1008  explicitJTA=self._defaultParameters['explicitJTA'].value
1009  self.setParameter('explicitJTA', explicitJTA)
1010  if pvSource is None:
1011  pvSource=self._defaultParameters['pvSource'].value
1012  self.setParameter('pvSource', pvSource)
1013  if svSource is None:
1014  svSource=self._defaultParameters['svSource'].value
1015  self.setParameter('svSource', svSource)
1016  if elSource is None:
1017  elSource=self._defaultParameters['elSource'].value
1018  self.setParameter('elSource', elSource)
1019  if muSource is None:
1020  muSource=self._defaultParameters['muSource'].value
1021  self.setParameter('muSource', muSource)
1022  if runIVF is None:
1023  runIVF=self._defaultParameters['runIVF'].value
1024  self.setParameter('runIVF', runIVF)
1025  if loadStdRecoBTag is None:
1026  loadStdRecoBTag=self._defaultParameters['loadStdRecoBTag'].value
1027  self.setParameter('loadStdRecoBTag', loadStdRecoBTag)
1028  if svClustering is None:
1029  svClustering=self._defaultParameters['svClustering'].value
1030  self.setParameter('svClustering', svClustering)
1031  if fatJets is None:
1032  fatJets=self._defaultParameters['fatJets'].value
1033  self.setParameter('fatJets', fatJets)
1034  if groomedFatJets is None:
1035  groomedFatJets=self._defaultParameters['groomedFatJets'].value
1036  self.setParameter('groomedFatJets', groomedFatJets)
1037  if algo is None:
1038  algo=self._defaultParameters['algo'].value
1039  self.setParameter('algo', algo)
1040  if rParam is None:
1041  rParam=self._defaultParameters['rParam'].value
1042  self.setParameter('rParam', rParam)
1043  if jetCorrections is None:
1044  jetCorrections=self._defaultParameters['jetCorrections'].value
1045  self.setParameter('jetCorrections', jetCorrections)
1046  if btagDiscriminators is None:
1047  btagDiscriminators=self._defaultParameters['btagDiscriminators'].value
1048  self.setParameter('btagDiscriminators', btagDiscriminators)
1049  if btagInfos is None:
1050  btagInfos=self._defaultParameters['btagInfos'].value
1051  self.setParameter('btagInfos', btagInfos)
1052  self.apply(process)
def jetTools.UpdateJetCollection.getDefaultParameters (   self) 
Return default parameters of the class

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

983 
984  def getDefaultParameters(self):
985  """
986  Return default parameters of the class
987  """
988  return self._defaultParameters
def jetTools.UpdateJetCollection.toolCode (   self,
  process 
) 
Tool code implementation

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

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

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

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

Definition at line 932 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 931 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 977 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