JetReCalibrator.JetReCalibrator Class Reference

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 8 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 11 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 98 of file JetReCalibrator.py.

References JetReCalibrator.JetReCalibrator.calculateType1METCorr, CastorPulseContainmentCorrection.getCorrection(), HcalPulseContainmentCorrection.getCorrection(), AddCorrectionsToGenericMET.getCorrection(), FactorizedJetCorrector.getCorrection(), JetReCalibrator.JetReCalibrator.getCorrection(), JetCorrExtractorT< T >.getCorrection(), FactorizedJetCorrectorCalculator.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 143 of file JetReCalibrator.py.

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

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

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

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

References FastTimerService_cff.range, 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 range(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 21 of file JetReCalibrator.py.

Referenced by JetReCalibrator.JetReCalibrator.correct().

JetReCalibrator.JetReCalibrator.doResidualJECs

Definition at line 18 of file JetReCalibrator.py.

JetReCalibrator.JetReCalibrator.globalTag

Definition at line 16 of file JetReCalibrator.py.

JetReCalibrator.JetReCalibrator.jecPath

Definition at line 19 of file JetReCalibrator.py.

JetReCalibrator.JetReCalibrator.JetCorrector

Definition at line 37 of file JetReCalibrator.py.

Referenced by JetReCalibrator.JetReCalibrator.getCorrection().

JetReCalibrator.JetReCalibrator.jetFlavour

Definition at line 17 of file JetReCalibrator.py.

JetReCalibrator.JetReCalibrator.JetUncertainty

Definition at line 39 of file JetReCalibrator.py.

Referenced by JetReCalibrator.JetReCalibrator.getCorrection().

JetReCalibrator.JetReCalibrator.L1JetPar

Definition at line 25 of file JetReCalibrator.py.

JetReCalibrator.JetReCalibrator.L2JetPar

Definition at line 26 of file JetReCalibrator.py.

JetReCalibrator.JetReCalibrator.L3JetPar

Definition at line 27 of file JetReCalibrator.py.

JetReCalibrator.JetReCalibrator.ResJetPar

Definition at line 34 of file JetReCalibrator.py.

JetReCalibrator.JetReCalibrator.separateJetCorrectors

Definition at line 45 of file JetReCalibrator.py.

Referenced by JetReCalibrator.JetReCalibrator.correct().

JetReCalibrator.JetReCalibrator.type1METParams

Definition at line 22 of file JetReCalibrator.py.

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

JetReCalibrator.JetReCalibrator.upToLevel

Definition at line 20 of file JetReCalibrator.py.

JetReCalibrator.JetReCalibrator.vPar

Definition at line 28 of file JetReCalibrator.py.

JetReCalibrator.JetReCalibrator.vParL1

Definition at line 47 of file JetReCalibrator.py.

JetReCalibrator.JetReCalibrator.vParL2

Definition at line 51 of file JetReCalibrator.py.

JetReCalibrator.JetReCalibrator.vParL3

Definition at line 55 of file JetReCalibrator.py.

JetReCalibrator.JetReCalibrator.vParL3Res

Definition at line 59 of file JetReCalibrator.py.