Ejemplo n.º 1
0
def makeJetBalancing( event, sample ):
    good_jets = getJets( event, jetColl="JetGood")

    # leading jet
    event.rawPt = good_jets[0]['rawPt']
    event.eta   = good_jets[0]['eta']
    event.area  = good_jets[0]['area']

    # compute correction factors
    if sample.isData:
        corr    = jetCorrector_L1L2L3ResData.correction(event.rawPt, event.eta, event.area, event.rho, event.run) 
        corr_L1 = jetCorrector_L1Data.correction(event.rawPt, event.eta, event.area, event.rho, event.run)
    else:  
        corr    = jetCorrector_L1L2L3MC.correction(event.rawPt, event.eta, event.area, event.rho, event.run) 
        corr_L1 = jetCorrector_L1MC.correction(event.rawPt, event.eta, event.area, event.rho, event.run)

    event.deltaPU           = event.rawPt*corr*(1-1./corr_L1)
    event.deltaPUPerArea    = event.deltaPU/event.area

    if event.rho>0:
        event.deltaPUPerRho     =   event.deltaPU/event.rho 
        event.deltaPUPerAreaRho =   event.deltaPU/(event.rho*event.area)
    else:
        event.deltaPUPerRho     =  float('nan') 
        event.deltaPUPerAreaRho =  float('nan') 

    # balance raw jet
    event.r_ptbal_raw  = event.rawPt / event.dl_pt
    # balance jet corrected for everything EXCEPT L1, however, L2L3+L2L3res are evaluated at the L1 corrected pT
    event.r_ptbal_noL1 = event.rawPt*( corr / corr_L1 ) / event.dl_pt
    # balance L1 corrected jet 
    event.r_ptbal_L1   = event.rawPt*corr_L1 / event.dl_pt
    # balance fully corrected jet
    event.r_ptbal_corr = event.rawPt*corr / event.dl_pt
    return
Ejemplo n.º 2
0
def makeJetMatchingInfo( event, sample ):
    if sample.isData:
        good_jets = getJets( event, jetColl="JetGood", jetVars = jetVars)
    else:
        good_jets = getJets( event, jetColl="JetGood", jetVars = jetVars + jetMCVars)

    # leading jet
    event.rawPt = good_jets[0]['rawPt']
    event.eta   = good_jets[0]['eta']
    event.area  = good_jets[0]['area']

    if not sample.isData:
        event.isQuark = jetHasMCMatch( good_jets[0] ) and abs(good_jets[0]['partonFlavour'])>0 and abs(good_jets[0]['partonFlavour'])<6
        event.isGluon = jetHasMCMatch( good_jets[0] ) and good_jets[0]['partonFlavour'] == 21
        event.isPU    = good_jets[0]['mcPt']==0 and good_jets[0]['partonFlavour'] == 0
        event.isOther = not (event.isQuark or event.isGluon or event.isPU)
        #print sample.name, good_jets[0]['pt'], good_jets[0]['partonFlavour'], good_jets[0]['mcPt'], event.isQuark, event.isGluon, event.isPU, event.isOther
    else:
        event.isQuark = None 
        event.isGluon = None 
        event.isPU    = None 
        event.isOther = None 
    return
Ejemplo n.º 3
0
def filler( event ):
    # shortcut
    r = reader.event
    if isMC:
        event.weight = r.xsec*lumiScaleFactor*r.genWeight if lumiScaleFactor is not None else 1
    else:
        event.weight = 1
    # lumi lists and vetos
    if isData:
        #event.vetoPassed  = vetoList.passesVeto(r.run, r.lumi, r.evt)
        event.jsonPassed  = lumiList.contains(r.run, r.lumi)
        # store decision to use after filler has been executed
        event.jsonPassed_ = event.jsonPassed

    # PU weight
    if isMC:
        event.reweightPU     = puRW       ( r.nTrueInt ) 
        event.reweightPUDown = puRWDown   ( r.nTrueInt ) 
        event.reweightPUUp   = puRWUp     ( r.nTrueInt ) 

    jets = getJets( r, jetColl="Jet", jetVars = jetVarNames)

    event.nJetGood = len(jets) #FIXME
    for iJet, j in enumerate(jets):
        # 'Corr' correction level: L1L2L3 L2res
        if sample.isData:
            jet_corr_factor    =  jetCorrector_data.   correction( j['rawPt'], j['eta'], j['area'], r.rho, r.run )
            jet_corr_factor_RC =  jetCorrector_RC_data.correction( j['rawPt'], j['eta'], j['area'], r.rho, r.run )
        else:
            jet_corr_factor    =  jetCorrector_mc.     correction( j['rawPt'], j['eta'], j['area'], r.rho, r.run )  
            jet_corr_factor_RC =  jetCorrector_RC_mc.  correction( j['rawPt'], j['eta'], j['area'], r.rho, r.run )  
        
        # corrected jet
        j['pt_corr']    =  jet_corr_factor * j['rawPt'] 
        event.Jet_pt_corr[iJet] = j['pt_corr'] #FIXME
        # L1RC 
        j['pt_corr_RC'] =  jet_corr_factor_RC * j['rawPt'] 

    tag_jet, probe_jet = jets[:2]

    # randomize if both are in barrel:
    if abs(tag_jet['eta'])<1.3 and abs(probe_jet['eta'])<1.3:
        if random.random()>0.5:
            tag_jet, probe_jet = probe_jet, tag_jet
    # tag jet in barrel
    if abs(tag_jet['eta'])>1.3 and abs(probe_jet['eta'])<1.3:
        tag_jet, probe_jet = probe_jet, tag_jet

    third_jet = jets[2] if len(jets)>=3 else null_jet    

    event.tag_jet_index     = tag_jet['index']
    event.probe_jet_index   = probe_jet['index']
    event.third_jet_index   = third_jet['index']

    event.pt_avg      = 0.5*( tag_jet['pt'] + probe_jet['pt'] )
    event.alpha       = third_jet['pt']/event.pt_avg
    event.A           = (probe_jet['pt'] - tag_jet['pt']) / (probe_jet['pt'] + tag_jet['pt'])

    # MET corrections
    good_jets = filter( lambda j:j['pt_corr'] > 15, jets)

    # compute type-1 MET shifts for chs met L1L2L3 - L1RC (if 'noL1', then L1FastJets is divided out and L1RC is not applied )
    type1_met_shifts = \
                {'px' :sum( ( j['pt_corr_RC'] - j['pt_corr'] )*cos(j['phi']) for j in good_jets), 
                 'py' :sum( ( j['pt_corr_RC'] - j['pt_corr'] )*sin(j['phi']) for j in good_jets) } 

    # chs MET 
    event.chs_MEx_corr = r.met_chsPt*cos(r.met_chsPhi) + type1_met_shifts['px']
    event.chs_MEy_corr = r.met_chsPt*sin(r.met_chsPhi) + type1_met_shifts['py']

    event.chs_MEt_corr    = sqrt(  event.chs_MEx_corr**2 + event.chs_MEy_corr**2 )
    event.chs_MEphi_corr  = atan2( event.chs_MEy_corr, event.chs_MEx_corr )

    # R(MPF)
    event.B = ( event.chs_MEx_corr*tag_jet['pt']*cos(tag_jet['phi'])  + event.chs_MEy_corr*tag_jet['pt']*sin(tag_jet['phi']) ) / tag_jet['pt'] / (tag_jet['pt'] + probe_jet['pt'])
Ejemplo n.º 4
0
migration_fraction         = ROOT.TProfile("fraction", "fraction", len(eta_binning)-1, array.array('d', eta_binning)) 
migration_fraction_20_30   = ROOT.TProfile("fraction_20_30", "fraction_20_30", len(eta_binning)-1, array.array('d', eta_binning)) 
migration_fraction_30_50   = ROOT.TProfile("fraction_30_50", "fraction_30_50", len(eta_binning)-1, array.array('d', eta_binning)) 
migration_fraction_50_100  = ROOT.TProfile("fraction_50_100", "fraction_50_100", len(eta_binning)-1, array.array('d', eta_binning)) 
migration_fraction_100     = ROOT.TProfile("fraction_100", "fraction_100", len(eta_binning)-1, array.array('d', eta_binning)) 

pt_bins = jet_respons_genEta.keys()
def getPtBin( pt ):
    for ptb in pt_bins:
        if pt>=ptb[0] and (ptb[1]<0 or pt<ptb[1]):
            return ptb
    
r = QCD_flat.treeReader( variables = map( TreeVariable.fromString, ["Jet[mcPt/F,rawPt/F,mcEta/F,eta/F]", 'nJet/I'] ) )
r.start()
while r.run():
    jets = getJets( r.event, jetColl="Jet", jetVars = ['mcPt', 'rawPt', 'mcEta', 'eta'] )
    for i in range( r.event.nJet ):

        # find bins
        reco_bin = migration_response_ratio.FindBin( r.event.Jet_eta[i] )
        gen_bin  = migration_response_ratio.FindBin( r.event.Jet_mcEta[i] )
        pt_bin = getPtBin( r.event.Jet_mcPt[i] )

        if not pt_bin: continue

        # compute response ratios
        reco_response = jet_respons_genEta[pt_bin].GetBinContent( reco_bin )
        gen_response  = jet_respons_genEta[pt_bin].GetBinContent( gen_bin )
        try:
            ratio = reco_response/gen_response 
        except ZeroDivisionError:
Ejemplo n.º 5
0
def makeL3ResObservables(event, sample):
    good_jets = getJets(event, jetColl="JetGood", jetVars=jetVars)

    for j in good_jets:
        # 'Corr' correction level: L1L2L3 L2res
        if sample.isData:
            jet_corr_factor = jetCorrector_data.correction(
                j['rawPt'], j['eta'], j['area'], event.rho, event.run)
            jet_corr_factor_RC = jetCorrector_RC_data.correction(
                j['rawPt'], j['eta'], j['area'], event.rho, event.run)
        else:
            jet_corr_factor = jetCorrector_mc.correction(
                j['rawPt'], j['eta'], j['area'], event.rho, event.run)
            jet_corr_factor_RC = jetCorrector_RC_mc.correction(
                j['rawPt'], j['eta'], j['area'], event.rho, event.run)

        # corrected jet
        j['pt_corr'] = jet_corr_factor * j['rawPt']

        # noL1 -> divide out L1FastJet, remove
        if args.noL1:
            if sample.isData:
                jet_corr_factor_L1 = jetCorrector_L1_data.correction(
                    j['rawPt'], j['eta'], j['area'], event.rho, event.run)
            else:
                jet_corr_factor_L1 = jetCorrector_L1_mc.correction(
                    j['rawPt'], j['eta'], j['area'], event.rho, event.run)
            # noL1 -> divide out L1FastJet, remove
            j['pt_corr'] = j['pt_corr'] / jet_corr_factor_L1
            # no L1RC if 'noL1'
            j['pt_corr_RC'] = j['rawPt']
        else:
            # L1RC
            j['pt_corr_RC'] = jet_corr_factor_RC * j['rawPt']

    # compute type-1 MET shifts for chs met L1L2L3 - L1RC (if 'noL1', then L1FastJets is divided out and L1RC is not applied )
    type1_met_shifts = \
                {'px' :sum( ( j['pt_corr_RC'] - j['pt_corr'] )*cos(j['phi']) for j in good_jets),
                 'py' :sum( ( j['pt_corr_RC'] - j['pt_corr'] )*sin(j['phi']) for j in good_jets) }

    # leading jet
    event.leading_jet = good_jets[0]
    # subleading jet
    event.subleading_jet = good_jets[1] if len(good_jets) >= 2 else null_jet

    # alpha
    event.alpha = event.subleading_jet['pt_corr'] / event.dl_pt
    # alpha cut flag
    event.alpha_30_passed = (event.alpha < 0.3)
    event.alpha_20_passed = (event.alpha < 0.2)
    event.alpha_15_passed = (event.alpha < 0.15)
    event.alpha_10_passed = (event.alpha < 0.1)

    # chs MET
    chs_MEx_corr = event.met_chsPt * cos(
        event.met_chsPhi) + type1_met_shifts['px']
    chs_MEy_corr = event.met_chsPt * sin(
        event.met_chsPhi) + type1_met_shifts['py']

    chs_MEt_corr = sqrt(chs_MEx_corr**2 + chs_MEy_corr**2)
    chs_MEphi_corr = atan2(chs_MEy_corr, chs_MEx_corr)
    #    if sample.isData: #FIXME
    #        print "evt", event.evt
    #        for i, j in enumerate(good_jets):
    #            print "jet", i, "pt(raw)", j['rawPt'], "pt(L1L2L3)", j['pt_corr'], "pt(L1RC)", j['pt_corr_RC'], "phi", cos(j['phi'])
    #            print "cont. to type1 from jet ", i, ( j['pt_corr_RC'] - j['pt_corr'] )*cos(j['phi']), "py", ( j['pt_corr_RC'] - j['pt_corr'] )*sin(j['phi'])
    #        print "type1 shifts", type1_met_shifts['px'], type1_met_shifts['py']
    #        print "raw chs met: pt", event.met_chsPt, 'phi', event.met_chsPhi
    #        print "type1 chs met: px", chs_MEx_corr, 'py', chs_MEy_corr
    #        print "             : pt",chs_MEt_corr,"phi",chs_MEphi_corr
    #        print
    setattr(event, "met_chsPt_type1", chs_MEt_corr)
    setattr(event, "met_chsPhi_type1", chs_MEphi_corr)

    # PT-bal
    event.r_ptbal = event.leading_jet['pt_corr'] / event.dl_pt
    # PT-bal raw
    event.r_ptbalRaw = event.leading_jet['rawPt'] / event.dl_pt
    # MPF
    event.r_mpf = 1. + chs_MEt_corr * cos(chs_MEphi_corr -
                                          event.dl_phi) / event.dl_pt
    # MPF no type-1
    event.r_mpfNoType1 = 1. + event.met_chsPt * cos(event.met_chsPhi -
                                                    event.dl_phi) / event.dl_pt

    # gen
    if not sample.isData and event.leading_jet['mcPt'] > 0:
        event.r_gen = event.leading_jet['pt_corr'] / event.leading_jet['mcPt']
        #event.r_gen    = event.leading_jet['pt']/event.leading_jet['mcPt']
    else:
        event.r_gen = None
Ejemplo n.º 6
0
def filler( event ):
    # shortcut
    r = reader.event
    if isMC:
        event.weight = r.xsec*lumiScaleFactor*r.genWeight if lumiScaleFactor is not None else 1
    else:
        event.weight = 1
    # lumi lists and vetos
    if isData:
        #event.vetoPassed  = vetoList.passesVeto(r.run, r.lumi, r.evt)
        event.jsonPassed  = lumiList.contains(r.run, r.lumi)
        # store decision to use after filler has been executed
        event.jsonPassed_ = event.jsonPassed

    # PU weight
    if isMC:
        event.reweightPU     = puRW       ( r.nTrueInt ) 
        event.reweightPUDown = puRWDown   ( r.nTrueInt ) 
        event.reweightPUUp   = puRWUp     ( r.nTrueInt ) 

    jets = getJets( r, jetColl="Jet", jetVars = jetVarNames)

    event.nJetGood = len(jets) 
    for iJet, j in enumerate(jets):
        # 'Corr' correction level: L1L2L3 L2res
        if isData:
            jet_corr_factor    =  jetCorrector_data.   correction( j['rawPt'], j['eta'], j['area'], r.rho, r.run )
            jet_corr_factor_RC =  jetCorrector_RC_data.correction( j['rawPt'], j['eta'], j['area'], r.rho, r.run )
        else:
            jet_corr_factor    =  jetCorrector_mc.     correction( j['rawPt'], j['eta'], j['area'], r.rho, r.run )  
            jet_corr_factor_RC =  jetCorrector_RC_mc.  correction( j['rawPt'], j['eta'], j['area'], r.rho, r.run )  

        # corrected jet
        j['pt_corr']    =  jet_corr_factor * j['rawPt'] 


        # L1RC 
        j['pt_corr_RC'] =  jet_corr_factor_RC * j['rawPt'] 

        # JER
        if isData:
            jet_corr_factor_jer, jet_corr_factor_jer_up, jet_corr_factor_jer_down = (1., 1., 1.)
        else:
            jet_corr_factor_jer, jet_corr_factor_jer_up, jet_corr_factor_jer_down = smearer_mc.hybrid_correction( pt = j['pt_corr'], mcPt = j['mcPt'], eta = j['eta'], rho = r.rho ) 

        j['pt_corr_jer']        =  jet_corr_factor_jer      * j['pt_corr'] 
        j['pt_corr_jer_up']     =  jet_corr_factor_jer_up   * j['pt_corr'] 
        j['pt_corr_jer_down']   =  jet_corr_factor_jer_down * j['pt_corr'] 

        # write new ntuple information
        event.Jet_pt_corr[iJet]         = j['pt_corr'] 
        event.Jet_pt_corr_jer[iJet]     = j['pt_corr_jer'] 
        event.Jet_pt_corr_jer_up[iJet]  = j['pt_corr_jer'] 
        event.Jet_pt_corr_jer_down[iJet]= j['pt_corr_jer'] 
        event.Jet_isHot[iJet]   = not default_hotJetVeto.passVeto(eta = j['eta'], phi = j['phi'])

        ## keep correction factors for type-1 MET shifts below
        #j['corr_jer']        =  jet_corr_factor_jer       
        #j['corr_jer_up']     =  jet_corr_factor_jer_up    
        #j['corr_jer_down']   =  jet_corr_factor_jer_down  

    randomSwap = ( random.random()>0.5 )

    for jer in ['', 'jer', 'jer_up', 'jer_down']:

        postfix = '' if jer == '' else '_'+jer
        pt_corr = 'pt_corr' + postfix

        # sorting after JER
        jets.sort( key = lambda j: -j[pt_corr] )

        # tag probe jet selection
        tag_jet, probe_jet = jets[:2]
        # randomize if both are in barrel:
        if abs(tag_jet['eta'])<1.3 and abs(probe_jet['eta'])<1.3:
            if randomSwap:
                tag_jet, probe_jet = probe_jet, tag_jet
        # tag jet in barrel
        if abs(tag_jet['eta'])>1.3 and abs(probe_jet['eta'])<1.3:
            tag_jet, probe_jet = probe_jet, tag_jet

        third_jet = jets[2] if len(jets)>=3 else null_jet    

        setattr( event, "tag_jet_index"+postfix     , tag_jet['index'] )
        setattr( event, "probe_jet_index"+postfix   , probe_jet['index'] )
        setattr( event, "third_jet_index"+postfix   , third_jet['index'] )

        # PT avg
        pt_avg      = 0.5*( tag_jet[pt_corr] + probe_jet[pt_corr] )
        setattr( event, "pt_avg"+postfix, pt_avg )

        setattr( event, 'alpha'+postfix,  third_jet[pt_corr]/pt_avg )
        setattr( event, 'A'+postfix,     (probe_jet[pt_corr] - tag_jet[pt_corr]) / (probe_jet[pt_corr] + tag_jet[pt_corr]) )

        # MET corrections
        type1_jets = filter( lambda j:j[pt_corr] > 15 and ( j['eEF'] + j['phEF'] )<0.9, jets) 

        # compute type-1 MET shifts for chs met L1L2L3 - L1RC 
#        jer_corr = 1 if jer=='' else j['corr' + postfix]
        type1_met_shifts = \
                    {'px' : sum( ( j['pt_corr_RC'] - j['pt_corr'+postfix] )*cos(j['phi']) for j in type1_jets), 
                     'py' : sum( ( j['pt_corr_RC'] - j['pt_corr'+postfix] )*sin(j['phi']) for j in type1_jets) } 

        # chs MET 
        chs_MEx_corr = r.met_chsPt*cos(r.met_chsPhi) + type1_met_shifts['px']
        chs_MEy_corr = r.met_chsPt*sin(r.met_chsPhi) + type1_met_shifts['py']
        setattr( event, "chs_MEx_corr"+postfix, chs_MEx_corr )
        setattr( event, "chs_MEy_corr"+postfix, chs_MEy_corr )

        chs_MEt_corr    = sqrt(  chs_MEx_corr**2 + chs_MEy_corr**2 )
        chs_MEphi_corr  = atan2( chs_MEy_corr, chs_MEx_corr )
        setattr( event, "chs_MEt_corr"+postfix, chs_MEt_corr )
        setattr( event, "chs_MEphi_corr"+postfix, chs_MEphi_corr )

        # R(MPF)
        setattr( event, 
                 'B'+postfix,  
                 ( chs_MEx_corr*tag_jet[pt_corr]*cos(tag_jet['phi'])  + chs_MEy_corr*tag_jet[pt_corr]*sin(tag_jet['phi']) ) / tag_jet[pt_corr] / (tag_jet[pt_corr] + probe_jet[pt_corr])
            )
Ejemplo n.º 7
0
def makeL3ResObservables( event, sample ):
    good_jets = getJets( event, jetColl="JetGood", jetVars = jetVars)

    for j in good_jets:
        # 'Corr' correction level: L1L2L3 L2res
        if sample.isData:
            jet_corr_factor    =  jetCorrector_data.   correction( j['rawPt'], j['eta'], j['area'], event.rho, event.run )
            jet_corr_factor_RC =  jetCorrector_RC_data.correction( j['rawPt'], j['eta'], j['area'], event.rho, event.run )
        else:
            jet_corr_factor    =  jetCorrector_mc.     correction( j['rawPt'], j['eta'], j['area'], event.rho, event.run )  
            jet_corr_factor_RC =  jetCorrector_RC_mc.  correction( j['rawPt'], j['eta'], j['area'], event.rho, event.run )  
        
        # corrected jet
        j['pt_corr']    =  jet_corr_factor * j['rawPt'] 

        # noL1 -> divide out L1FastJet, remove 
        if args.noL1: 
            if sample.isData:
                jet_corr_factor_L1 =  jetCorrector_L1_data.correction( j['rawPt'], j['eta'], j['area'], event.rho, event.run ) 
            else: 
                jet_corr_factor_L1 =  jetCorrector_L1_mc.  correction( j['rawPt'], j['eta'], j['area'], event.rho, event.run ) 
            # noL1 -> divide out L1FastJet, remove 
            j['pt_corr']    =  j['pt_corr']/jet_corr_factor_L1 
            # no L1RC if 'noL1'
            j['pt_corr_RC'] =  j['rawPt'] 
        else:
            # L1RC 
            j['pt_corr_RC'] =  jet_corr_factor_RC * j['rawPt'] 


    # compute type-1 MET shifts for chs met L1L2L3 - L1RC (if 'noL1', then L1FastJets is divided out and L1RC is not applied )
    type1_met_shifts = \
                {'px' :sum( ( j['pt_corr_RC'] - j['pt_corr'] )*cos(j['phi']) for j in good_jets), 
                 'py' :sum( ( j['pt_corr_RC'] - j['pt_corr'] )*sin(j['phi']) for j in good_jets) } 

    # leading jet
    event.leading_jet    = good_jets[0]
    # subleading jet
    event.subleading_jet = good_jets[1] if len(good_jets)>=2 else null_jet

    # alpha 
    event.alpha = event.subleading_jet['pt_corr'] / event.dl_pt
    # alpha cut flag
    event.alpha_30_passed = ( event.alpha < 0.3)
    event.alpha_20_passed = ( event.alpha < 0.2)
    event.alpha_15_passed = ( event.alpha < 0.15)
    event.alpha_10_passed = ( event.alpha < 0.1)

    # chs MET 
    chs_MEx_corr = event.met_chsPt*cos(event.met_chsPhi) + type1_met_shifts['px']
    chs_MEy_corr = event.met_chsPt*sin(event.met_chsPhi) + type1_met_shifts['py']

    chs_MEt_corr    = sqrt(  chs_MEx_corr**2 + chs_MEy_corr**2 )
    chs_MEphi_corr  = atan2( chs_MEy_corr, chs_MEx_corr )
#    if sample.isData: #FIXME
#        print "evt", event.evt
#        for i, j in enumerate(good_jets):
#            print "jet", i, "pt(raw)", j['rawPt'], "pt(L1L2L3)", j['pt_corr'], "pt(L1RC)", j['pt_corr_RC'], "phi", cos(j['phi'])
#            print "cont. to type1 from jet ", i, ( j['pt_corr_RC'] - j['pt_corr'] )*cos(j['phi']), "py", ( j['pt_corr_RC'] - j['pt_corr'] )*sin(j['phi'])
#        print "type1 shifts", type1_met_shifts['px'], type1_met_shifts['py'] 
#        print "raw chs met: pt", event.met_chsPt, 'phi', event.met_chsPhi
#        print "type1 chs met: px", chs_MEx_corr, 'py', chs_MEy_corr 
#        print "             : pt",chs_MEt_corr,"phi",chs_MEphi_corr 
#        print 
    setattr( event, "met_chsPt_type1",  chs_MEt_corr )
    setattr( event, "met_chsPhi_type1", chs_MEphi_corr )

    # PT-bal
    event.r_ptbal      = event.leading_jet['pt_corr'] / event.dl_pt
    # PT-bal raw
    event.r_ptbalRaw   = event.leading_jet['rawPt'] / event.dl_pt 
    # MPF 
    event.r_mpf        = 1. + chs_MEt_corr * cos(chs_MEphi_corr - event.dl_phi) / event.dl_pt
    # MPF no type-1 
    event.r_mpfNoType1 = 1. + event.met_chsPt * cos(event.met_chsPhi - event.dl_phi) / event.dl_pt

    # gen 
    if not sample.isData and event.leading_jet['mcPt']>0:
        event.r_gen    = event.leading_jet['pt_corr']/event.leading_jet['mcPt']
        #event.r_gen    = event.leading_jet['pt']/event.leading_jet['mcPt']
    else:
        event.r_gen    = None 
Ejemplo n.º 8
0
pt_bins = jet_respons_genEta.keys()


def getPtBin(pt):
    for ptb in pt_bins:
        if pt >= ptb[0] and (ptb[1] < 0 or pt < ptb[1]):
            return ptb


r = QCD_flat.treeReader(variables=map(
    TreeVariable.fromString, ["Jet[mcPt/F,rawPt/F,mcEta/F,eta/F]", 'nJet/I']))
r.start()
while r.run():
    jets = getJets(r.event,
                   jetColl="Jet",
                   jetVars=['mcPt', 'rawPt', 'mcEta', 'eta'])
    for i in range(r.event.nJet):

        # find bins
        reco_bin = migration_response_ratio.FindBin(r.event.Jet_eta[i])
        gen_bin = migration_response_ratio.FindBin(r.event.Jet_mcEta[i])
        pt_bin = getPtBin(r.event.Jet_mcPt[i])

        if not pt_bin: continue

        # compute response ratios
        reco_response = jet_respons_genEta[pt_bin].GetBinContent(reco_bin)
        gen_response = jet_respons_genEta[pt_bin].GetBinContent(gen_bin)
        try:
            ratio = reco_response / gen_response