Public Member Functions
def	__init__

def	correct (self, jet, rho, delta=0, addCorr=False, addShifts=False, metShift=[0, type1METCorr=[0)

def	correctAll (self, jets, rho, delta=0, addCorr=False, addShifts=False, metShift=[0., type1METCorr=[0.)

def	getCorrection (self, jet, rho, delta=0, corrector=None)

def	rawP4forType1MET_ (self, jet)

Public Attributes
	calculateType1METCorr

	doResidualJECs

	globalTag

	jecPath

	JetCorrector

	jetFlavour

	JetUncertainty

	L1JetPar

	L2JetPar

	L3JetPar

	ResJetPar

	separateJetCorrectors

	type1METParams

	upToLevel

	vPar

	vParL1

	vParL2

	vParL3

	vParL3Res

Detailed Description

Definition at line 6 of file JetReCalibrator.py.

Constructor & Destructor Documentation

def JetReCalibrator.JetReCalibrator.__init__	(	self,
		globalTag,
		jetFlavour,
		doResidualJECs,
		jecPath,
		upToLevel = `3`,
		calculateSeparateCorrections = `False`,
		calculateType1METCorrection = `False`,
		type1METParams = `{'jetPtThreshold':15.`,
		skipEMfractionThreshold
	)

Definition at line 9 of file JetReCalibrator.py.

                  calculateType1METCorrection=False, type1METParams={'jetPtThreshold':15., 'skipEMfractionThreshold':0.9, 'skipMuons':True} ):
         """Create a corrector object that reads the payloads from the text dumps of a global tag under
             CMGTools/RootTools/data/jec  (see the getJec.py there to make the dumps).
            It will apply the L1,L2,L3 and possibly the residual corrections to the jets.
            If configured to do so, it will also compute the type1 MET corrections."""
         self.globalTag = globalTag
         self.jetFlavour = jetFlavour
         self.doResidualJECs = doResidualJECs
         self.jecPath = jecPath
         self.upToLevel = upToLevel
         self.calculateType1METCorr = calculateType1METCorrection
         self.type1METParams  = type1METParams
         # Make base corrections
         path = os.path.expandvars(jecPath) #"%s/src/CMGTools/RootTools/data/jec" % os.environ['CMSSW_BASE'];
         self.L1JetPar  = ROOT.JetCorrectorParameters("%s/%s_L1FastJet_%s.txt" % (path,globalTag,jetFlavour),"");
         self.L2JetPar  = ROOT.JetCorrectorParameters("%s/%s_L2Relative_%s.txt" % (path,globalTag,jetFlavour),"");
         self.L3JetPar  = ROOT.JetCorrectorParameters("%s/%s_L3Absolute_%s.txt" % (path,globalTag,jetFlavour),"");
         self.vPar = ROOT.vector(ROOT.JetCorrectorParameters)()
         self.vPar.push_back(self.L1JetPar);
         if upToLevel >= 2: self.vPar.push_back(self.L2JetPar);
         if upToLevel >= 3: self.vPar.push_back(self.L3JetPar);
         # Add residuals if needed
         if doResidualJECs : 
             self.ResJetPar = ROOT.JetCorrectorParameters("%s/%s_L2L3Residual_%s.txt" % (path,globalTag,jetFlavour))
             self.vPar.push_back(self.ResJetPar);
         #Step3 (Construct a FactorizedJetCorrector object) 
         self.JetCorrector = ROOT.FactorizedJetCorrector(self.vPar)
         if os.path.exists("%s/%s_Uncertainty_%s.txt" % (path,globalTag,jetFlavour)):
             self.JetUncertainty = ROOT.JetCorrectionUncertainty("%s/%s_Uncertainty_%s.txt" % (path,globalTag,jetFlavour));
         elif os.path.exists("%s/Uncertainty_FAKE.txt" % path):
             self.JetUncertainty = ROOT.JetCorrectionUncertainty("%s/Uncertainty_FAKE.txt" % path);
         else:
             print 'Missing JEC uncertainty file "%s/%s_Uncertainty_%s.txt", so jet energy uncertainties will not be available' % (path,globalTag,jetFlavour)
             self.JetUncertainty = None
         self.separateJetCorrectors = {}
         if calculateSeparateCorrections or calculateType1METCorrection:
             self.vParL1 = ROOT.vector(ROOT.JetCorrectorParameters)()
             self.vParL1.push_back(self.L1JetPar)
             self.separateJetCorrectors["L1"] = ROOT.FactorizedJetCorrector(self.vParL1)
             if upToLevel >= 2 and calculateSeparateCorrections:
                 self.vParL2 = ROOT.vector(ROOT.JetCorrectorParameters)()
                 for i in [self.L1JetPar,self.L2JetPar]: self.vParL2.push_back(i)
                 self.separateJetCorrectors["L1L2"] = ROOT.FactorizedJetCorrector(self.vParL2)
             if upToLevel >= 3 and calculateSeparateCorrections:
                 self.vParL3 = ROOT.vector(ROOT.JetCorrectorParameters)()
                 for i in [self.L1JetPar,self.L2JetPar,self.L3JetPar]: self.vParL3.push_back(i)
                 self.separateJetCorrectors["L1L2L3"] = ROOT.FactorizedJetCorrector(self.vParL3)
             if doResidualJECs and calculateSeparateCorrections:
                 self.vParL3Res = ROOT.vector(ROOT.JetCorrectorParameters)()
                 for i in [self.L1JetPar,self.L2JetPar,self.L3JetPar,self.ResJetPar]: self.vParL3Res.push_back(i)
                 self.separateJetCorrectors["L1L2L3Res"] = ROOT.FactorizedJetCorrector(self.vParL3Res)
 

Member Function Documentation

def JetReCalibrator.JetReCalibrator.correct	(	self,
		jet,
		rho,
		delta = `0`,
		addCorr = `False`,
		addShifts = `False`,
		metShift = `[0`,
		type1METCorr = `[0`
	)

Corrects a jet energy (optionally shifting it also by delta times the JEC uncertainty)

   If addCorr, set jet.corr to the correction.
   If addShifts, set also the +1 and -1 jet shifts 

   The metShift vector will accumulate the x and y changes to the MET from the JEC, i.e. the 
   negative difference between the new and old jet momentum, for jets eligible for type1 MET 
   corrections, and after subtracting muons. The pt cut is applied to the new corrected pt.
   This shift can be applied on top of the *OLD TYPE1 MET*, but only if there was no change 
   in the L1 corrections nor in the definition of the type1 MET (e.g. jet pt cuts).

   The type1METCorr vector, will accumulate the x, y, sumEt type1 MET corrections, to be
   applied to the *RAW MET* (if the feature was turned on in the constructor of the class).

Definition at line 96 of file JetReCalibrator.py.

References JetReCalibrator.JetReCalibrator.calculateType1METCorr, CastorPulseContainmentCorrection.getCorrection(), HcalPulseContainmentCorrection.getCorrection(), AddCorrectionsToGenericMET.getCorrection(), FactorizedJetCorrector.getCorrection(), JetReCalibrator.JetReCalibrator.getCorrection(), FactorizedJetCorrectorCalculator.getCorrection(), JetCorrExtractorT< T >.getCorrection(), JetReCalibrator.JetReCalibrator.rawP4forType1MET_(), JetReCalibrator.JetReCalibrator.separateJetCorrectors, JetReCalibrator.JetReCalibrator.type1METParams, and objects.JetAnalyzer.JetAnalyzer.type1METParams.

Referenced by KalmanMuonCorrector.KalmanMuonCorrector.correct_all(), and JetReCalibrator.JetReCalibrator.correctAll().

     def correct(self,jet,rho,delta=0,addCorr=False,addShifts=False, metShift=[0,0],type1METCorr=[0,0,0]):
         """Corrects a jet energy (optionally shifting it also by delta times the JEC uncertainty)
 
            If addCorr, set jet.corr to the correction.
            If addShifts, set also the +1 and -1 jet shifts 
 
            The metShift vector will accumulate the x and y changes to the MET from the JEC, i.e. the 
            negative difference between the new and old jet momentum, for jets eligible for type1 MET 
            corrections, and after subtracting muons. The pt cut is applied to the new corrected pt.
            This shift can be applied on top of the *OLD TYPE1 MET*, but only if there was no change 
            in the L1 corrections nor in the definition of the type1 MET (e.g. jet pt cuts).
 
            The type1METCorr vector, will accumulate the x, y, sumEt type1 MET corrections, to be
            applied to the *RAW MET* (if the feature was turned on in the constructor of the class).
         """
         raw = jet.rawFactor()
         corr = self.getCorrection(jet,rho,delta)
         if addCorr: 
             jet.corr = corr
             for sepcorr in self.separateJetCorrectors.keys():
                 setattr(jet,"CorrFactor_"+sepcorr,self.getCorrection(jet,rho,delta=0,corrector=self.separateJetCorrectors[sepcorr]))
         if addShifts:
             for cdelta,shift in [(1.0, "JECUp"), (-1.0, "JECDown")]:
                 cshift = self.getCorrection(jet,rho,delta+cdelta)
                 setattr(jet, "corr"+shift, cshift)
         if corr <= 0:
             return False
         newpt = jet.pt()*raw*corr
         if newpt > self.type1METParams['jetPtThreshold']:
             rawP4forT1 = self.rawP4forType1MET_(jet)
             if rawP4forT1 and rawP4forT1.Pt()*corr > self.type1METParams['jetPtThreshold']:
                 metShift[0] -= rawP4forT1.Px() * (corr - 1.0/raw)
                 metShift[1] -= rawP4forT1.Py() * (corr - 1.0/raw)
                 if self.calculateType1METCorr:
                     l1corr = self.getCorrection(jet,rho,delta=0,corrector=self.separateJetCorrectors["L1"])
                     #print "\tfor jet with raw pt %.5g, eta %.5g, dpx = %.5g, dpy = %.5g" % (
                     #            jet.pt()*raw, jet.eta(), 
                     #            rawP4forT1.Px()*(corr - l1corr), 
                     #            rawP4forT1.Py()*(corr - l1corr))
                     type1METCorr[0] -= rawP4forT1.Px() * (corr - l1corr) 
                     type1METCorr[1] -= rawP4forT1.Py() * (corr - l1corr) 
                     type1METCorr[2] += rawP4forT1.Et() * (corr - l1corr) 
         jet.setCorrP4(jet.p4() * (corr * raw))
         return True
 

def JetReCalibrator.JetReCalibrator.correctAll	(	self,
		jets,
		rho,
		delta = `0`,
		addCorr = `False`,
		addShifts = `False`,
		metShift = `[0.`,
		type1METCorr = `[0.`
	)

Applies 'correct' to all the jets, discard the ones that have bad corrections (corrected pt <= 0)

Definition at line 141 of file JetReCalibrator.py.

References ElectronCalibrator.Run2ElectronCalibrator.correct(), FFTJetCorrector< Jet, Adjustable >.correct(), FFTJetCorrectorSequence< Jet, InitialConverter, FinalConverter >.correct(), MomentumScaleCorrector.correct(), and JetReCalibrator.JetReCalibrator.correct().

     def correctAll(self,jets,rho,delta=0, addCorr=False, addShifts=False, metShift=[0.,0.], type1METCorr=[0.,0.,0.]):
         """Applies 'correct' to all the jets, discard the ones that have bad corrections (corrected pt <= 0)"""
         badJets = []
         if metShift     != [0.,0.   ]: raise RuntimeError("input metShift tuple is not initialized to zeros")
         if type1METCorr != [0.,0.,0.]: raise RuntimeError("input type1METCorr tuple is not initialized to zeros")
         for j in jets:
             ok = self.correct(j,rho,delta,addCorr=addCorr,addShifts=addShifts,metShift=metShift,type1METCorr=type1METCorr)
             if not ok: badJets.append(j)
         if len(badJets) > 0:
             print "Warning: %d out of %d jets flagged bad by JEC." % (len(badJets), len(jets))
         for bj in badJets:
             jets.remove(bj)
 

def JetReCalibrator.JetReCalibrator.getCorrection	(	self,
		jet,
		rho,
		delta = `0`,
		corrector = `None`
	)

Definition at line 61 of file JetReCalibrator.py.

References JetReCalibrator.JetReCalibrator.JetCorrector, JetReCalibrator.JetReCalibrator.JetUncertainty, and hpstanc_transforms.max.

Referenced by JetReCalibrator.JetReCalibrator.correct().

     def getCorrection(self,jet,rho,delta=0,corrector=None):
         if not corrector: corrector = self.JetCorrector
         if corrector != self.JetCorrector and delta!=0: raise RuntimeError('Configuration not supported')
         corrector.setJetEta(jet.eta())
         corrector.setJetPt(jet.pt()*jet.rawFactor())
         corrector.setJetA(jet.jetArea())
         corrector.setRho(rho)
         corr = corrector.getCorrection()
         if delta != 0:
             if not self.JetUncertainty: raise RuntimeError("Jet energy scale uncertainty shifts requested, but not available")
             self.JetUncertainty.setJetEta(jet.eta())
             self.JetUncertainty.setJetPt(corr * jet.pt() * jet.rawFactor())
             try:
                 jet.jetEnergyCorrUncertainty = self.JetUncertainty.getUncertainty(True) 
             except RuntimeError as r:
                 print "Caught %s when getting uncertainty for jet of pt %.1f, eta %.2f\n" % (r,corr * jet.pt() * jet.rawFactor(),jet.eta())
                 jet.jetEnergyCorrUncertainty = 0.5
             #print "   jet with corr pt %6.2f has an uncertainty %.2f " % (jet.pt()*jet.rawFactor()*corr, jet.jetEnergyCorrUncertainty)
             corr *= max(0, 1+delta*jet.jetEnergyCorrUncertainty)
         return corr
 

def JetReCalibrator.JetReCalibrator.rawP4forType1MET_	(	self,
		jet
	)

Return the raw 4-vector, after subtracting the muons (if requested),
   or None if the jet fails the EMF cut.

Definition at line 82 of file JetReCalibrator.py.

References JetReCalibrator.JetReCalibrator.type1METParams, and objects.JetAnalyzer.JetAnalyzer.type1METParams.

Referenced by JetReCalibrator.JetReCalibrator.correct().

     def rawP4forType1MET_(self, jet):
         """Return the raw 4-vector, after subtracting the muons (if requested),
            or None if the jet fails the EMF cut."""
         p4 = jet.p4() * jet.rawFactor()
         emf = ( jet.physObj.neutralEmEnergy() + jet.physObj.chargedEmEnergy() )/p4.E()
         if emf > self.type1METParams['skipEMfractionThreshold']:
             return None
         if self.type1METParams['skipMuons']:
             for idau in xrange(jet.numberOfDaughters()):
                 pfcand = jet.daughter(idau)
                 if pfcand.isGlobalMuon() or pfcand.isStandAloneMuon(): 
                     p4 -= pfcand.p4()
         return p4
 

Member Data Documentation

JetReCalibrator.JetReCalibrator.calculateType1METCorr

Definition at line 19 of file JetReCalibrator.py.

Referenced by JetReCalibrator.JetReCalibrator.correct().

JetReCalibrator.JetReCalibrator.doResidualJECs

Definition at line 16 of file JetReCalibrator.py.

JetReCalibrator.JetReCalibrator.globalTag

Definition at line 14 of file JetReCalibrator.py.

JetReCalibrator.JetReCalibrator.jecPath

Definition at line 17 of file JetReCalibrator.py.

JetReCalibrator.JetReCalibrator.JetCorrector

Definition at line 35 of file JetReCalibrator.py.

Referenced by JetReCalibrator.JetReCalibrator.getCorrection().

JetReCalibrator.JetReCalibrator.jetFlavour

Definition at line 15 of file JetReCalibrator.py.

JetReCalibrator.JetReCalibrator.JetUncertainty

Definition at line 37 of file JetReCalibrator.py.

Referenced by JetReCalibrator.JetReCalibrator.getCorrection().

JetReCalibrator.JetReCalibrator.L1JetPar

Definition at line 23 of file JetReCalibrator.py.

JetReCalibrator.JetReCalibrator.L2JetPar

Definition at line 24 of file JetReCalibrator.py.

JetReCalibrator.JetReCalibrator.L3JetPar

Definition at line 25 of file JetReCalibrator.py.

JetReCalibrator.JetReCalibrator.ResJetPar

Definition at line 32 of file JetReCalibrator.py.

JetReCalibrator.JetReCalibrator.separateJetCorrectors

Definition at line 43 of file JetReCalibrator.py.

Referenced by JetReCalibrator.JetReCalibrator.correct().

JetReCalibrator.JetReCalibrator.type1METParams

Definition at line 20 of file JetReCalibrator.py.

Referenced by JetReCalibrator.JetReCalibrator.correct(), and JetReCalibrator.JetReCalibrator.rawP4forType1MET_().

JetReCalibrator.JetReCalibrator.upToLevel

Definition at line 18 of file JetReCalibrator.py.

JetReCalibrator.JetReCalibrator.vPar

Definition at line 26 of file JetReCalibrator.py.

JetReCalibrator.JetReCalibrator.vParL1

Definition at line 45 of file JetReCalibrator.py.

JetReCalibrator.JetReCalibrator.vParL2

Definition at line 49 of file JetReCalibrator.py.

JetReCalibrator.JetReCalibrator.vParL3

Definition at line 53 of file JetReCalibrator.py.

JetReCalibrator.JetReCalibrator.vParL3Res

Definition at line 57 of file JetReCalibrator.py.

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation