JetReCalibrator.JetReCalibrator Class Reference

Public Member Functions
def	__init__ (self, globalTag, jetFlavour, doResidualJECs, jecPath, upToLevel=3, calculateSeparateCorrections=False, calculateType1METCorrection=False, type1METParams={ 'jetPtThreshold':15., 'skipEMfractionThreshold':0.9, 'skipMuons':True})
def	correct (self, jet, rho, delta=0, addCorr=False, addShifts=False, metShift=[0, 0], type1METCorr=[0, 0, 0])
def	correctAll (self, jets, rho, delta=0, addCorr=False, addShifts=False, metShift=[0., 0.], type1METCorr=[0., 0., 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 8 of file JetReCalibrator.py.

Constructor & Destructor Documentation

__init__()

def JetReCalibrator.JetReCalibrator.__init__	(		self,
			globalTag,
			jetFlavour,
			doResidualJECs,
			jecPath,
			upToLevel = 3,
			calculateSeparateCorrections = False,
			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.

Definition at line 9 of file JetReCalibrator.py.

    def __init__(self,globalTag,jetFlavour,doResidualJECs,jecPath,upToLevel=3,
                 calculateSeparateCorrections=False,
                 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

correct()

def JetReCalibrator.JetReCalibrator.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).

Definition at line 98 of file JetReCalibrator.py.

    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
 

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

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

correctAll()

def JetReCalibrator.JetReCalibrator.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)

Definition at line 143 of file JetReCalibrator.py.

    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)
 

References ElectronCalibrator.Run2ElectronCalibrator.correct(), FFTJetCorrector< Jet, Adjustable >.correct(), FFTJetCorrectorSequence< Jet, InitialConverter, FinalConverter >.correct(), MomentumScaleCorrector.correct(), JetReCalibrator.JetReCalibrator.correct(), l1tpf_calo::SingleCaloClusterer.correct(), l1tpf_calo::SimpleCaloLinkerBase.correct(), and edm.print().

getCorrection()

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

Definition at line 63 of file JetReCalibrator.py.

    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
 

References JetReCalibrator.JetReCalibrator.JetCorrector, JetReCalibrator.JetReCalibrator.JetUncertainty, SiStripPI.max, and edm.print().

Referenced by JetReCalibrator.JetReCalibrator.correct().

rawP4forType1MET_()

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 84 of file JetReCalibrator.py.

    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 range(jet.numberOfDaughters()):
                pfcand = jet.daughter(idau)
                if pfcand.isGlobalMuon() or pfcand.isStandAloneMuon(): 
                    p4 -= pfcand.p4()
        return p4
 

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

Referenced by JetReCalibrator.JetReCalibrator.correct().

Member Data Documentation

calculateType1METCorr

JetReCalibrator.JetReCalibrator.calculateType1METCorr

Definition at line 19 of file JetReCalibrator.py.

Referenced by JetReCalibrator.JetReCalibrator.correct().

doResidualJECs

JetReCalibrator.JetReCalibrator.doResidualJECs

Definition at line 16 of file JetReCalibrator.py.

globalTag

JetReCalibrator.JetReCalibrator.globalTag

Definition at line 14 of file JetReCalibrator.py.

jecPath

JetReCalibrator.JetReCalibrator.jecPath

Definition at line 17 of file JetReCalibrator.py.

JetCorrector

JetReCalibrator.JetReCalibrator.JetCorrector

Definition at line 35 of file JetReCalibrator.py.

Referenced by JetReCalibrator.JetReCalibrator.getCorrection().

jetFlavour

JetReCalibrator.JetReCalibrator.jetFlavour

Definition at line 15 of file JetReCalibrator.py.

JetUncertainty

JetReCalibrator.JetReCalibrator.JetUncertainty

Definition at line 37 of file JetReCalibrator.py.

Referenced by JetReCalibrator.JetReCalibrator.getCorrection().

L1JetPar

JetReCalibrator.JetReCalibrator.L1JetPar

Definition at line 23 of file JetReCalibrator.py.

L2JetPar

JetReCalibrator.JetReCalibrator.L2JetPar

Definition at line 24 of file JetReCalibrator.py.

L3JetPar

JetReCalibrator.JetReCalibrator.L3JetPar

Definition at line 25 of file JetReCalibrator.py.

ResJetPar

JetReCalibrator.JetReCalibrator.ResJetPar

Definition at line 32 of file JetReCalibrator.py.

separateJetCorrectors

JetReCalibrator.JetReCalibrator.separateJetCorrectors

Definition at line 43 of file JetReCalibrator.py.

Referenced by JetReCalibrator.JetReCalibrator.correct().

type1METParams

JetReCalibrator.JetReCalibrator.type1METParams

Definition at line 20 of file JetReCalibrator.py.

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

upToLevel

JetReCalibrator.JetReCalibrator.upToLevel

Definition at line 18 of file JetReCalibrator.py.

vPar

JetReCalibrator.JetReCalibrator.vPar

Definition at line 26 of file JetReCalibrator.py.

vParL1

JetReCalibrator.JetReCalibrator.vParL1

Definition at line 45 of file JetReCalibrator.py.

vParL2

JetReCalibrator.JetReCalibrator.vParL2

Definition at line 49 of file JetReCalibrator.py.

vParL3

JetReCalibrator.JetReCalibrator.vParL3

Definition at line 53 of file JetReCalibrator.py.

vParL3Res

JetReCalibrator.JetReCalibrator.vParL3Res

Definition at line 57 of file JetReCalibrator.py.