Beispiel #1
0
def makeMinDeltaRLepJets( data ):
    jets = filter(lambda j: j['pt']>30 and abs(j['eta'])<2.4 and j['id'], getJets(data, jetColl="JetGood"))
    if len(jets)>0:
        dr =  [deltaR(j, {'eta':data.l1_eta, 'phi':data.l1_phi}) for j in jets] 
        dr += [deltaR(j, {'eta':data.l2_eta, 'phi':data.l2_phi}) for j in jets] 
        setattr( data, "minDeltaRLepJets", min(dr) )
    else:
        setattr( data, "minDeltaRLepJets", float('nan') )

    loose_bjets = filter(lambda j: j['btagCSV']>0.605, jets)
    if len(loose_bjets)>0:
        dr =  [deltaR(j, {'eta':data.l1_eta, 'phi':data.l1_phi}) for j in loose_bjets] 
        dr += [deltaR(j, {'eta':data.l2_eta, 'phi':data.l2_phi}) for j in loose_bjets] 
        setattr( data, "minDeltaRLepBJets", min(dr) )
    else:
        setattr( data, "minDeltaRLepBJets", float('nan') )
Beispiel #2
0
def cutflow(sig):
  #######################################################
  #        SELECT WHAT YOU WANT TO DO HERE              #
  #######################################################
  reduceStat = 100 #recude the statistics, i.e. 10 is ten times less samples to look at


  #######################################################
  #         Define cutflow you want to make             #
  #######################################################
  mt2llcut = 80.
  metcut = 40.
  lumi = 10000.

  baselineamount = { 'samples':{}, 'SoverB': None,}

  cutflow = {\
    'metsig':{'baseline': 0., 
              'cuts': {\
                3:{'samples':{}, 'SoverB': None}, 
                4:{'samples':{}, 'SoverB': None}, 
                5:{'samples':{}, 'SoverB': None}, 
                6:{'samples':{}, 'SoverB': None},
                7:{'samples':{}, 'SoverB': None},
                8:{'samples':{}, 'SoverB': None},
                9:{'samples':{}, 'SoverB': None},
                10:{'samples':{}, 'SoverB': None},
                10:{'samples':{}, 'SoverB': None},
                },
              'event': None,
              },
    'nbjets':{'baseline': 1., 
              'cuts': {\
                0:{'samples':{}, 'SoverB': None}, 
                1:{'samples':{}, 'SoverB': None}, 
                2:{'samples':{}, 'SoverB': None}, 
                3:{'samples':{}, 'SoverB': None},
                4:{'samples':{}, 'SoverB': None},
                5:{'samples':{}, 'SoverB': None},
                },
              'event': None,
              },
    'njets': {'baseline': 2., 
              'cuts': {\
                1:{'samples':{}, 'SoverB': None}, 
                2:{'samples':{}, 'SoverB': None}, 
                3:{'samples':{}, 'SoverB': None},
                4:{'samples':{}, 'SoverB': None},
                5:{'samples':{}, 'SoverB': None},
                6:{'samples':{}, 'SoverB': None},
                7:{'samples':{}, 'SoverB': None},
                },
              'event': None,
              },
    'ht':    {'baseline': 0., 
              'cuts': {\
                50: {'samples':{}, 'SoverB': None}, 
                100:{'samples':{}, 'SoverB': None}, 
                200:{'samples':{}, 'SoverB': None},
                300:{'samples':{}, 'SoverB': None},
                400:{'samples':{}, 'SoverB': None},
                500:{'samples':{}, 'SoverB': None},
                },
              'event': None,
              },
  }

  #preselection: MET>40, njets>=2, n_bjets>=1, n_lep>=2
  #For now see here for the Sum$ syntax: https://root.cern.ch/root/html/TTree.html#TTree:Draw@2
  preselection = 'met_pt>'+str(metcut)+'&&Sum$(LepGood_pt>20)==2'

  #######################################################
  #                 load all the samples                #
  #######################################################
  backgrounds = [singleTop_50ns,DY_50ns,TTJets_50ns]
  #signals = [SMS_T2tt_2J_mStop425_mLSP325, SMS_T2tt_2J_mStop500_mLSP325, SMS_T2tt_2J_mStop650_mLSP325, SMS_T2tt_2J_mStop850_mLSP100]
  signal = [sig]

  #######################################################
  #            get the TChains for each sample          #
  #######################################################
  for s in backgrounds+signal:
    s['chain'] = getChain(s,histname="")


  #######################################################
  #            Start filling in the histograms          #
  #######################################################
  for s in backgrounds+signal:
    for cuttype in cutflow.keys():
      for cut in cutflow[cuttype]['cuts'].keys():
        cutflow[cuttype]['cuts'][cut]['samples'][s["name"]] = 0

    baselineamount['samples'][s['name']] = 0

    chain = s["chain"]
    #Using Event loop
    #get EList after preselection
    print "Looping over %s" % s["name"]
    eList = getEList(chain, preselection) 
    nEvents = eList.GetN()/reduceStat
    print "Found %i events in %s after preselection %s, looping over %i" % (eList.GetN(),s["name"],preselection,nEvents)

    for ev in range(nEvents):
      increment = 50
      if nEvents>increment and ev%(nEvents/increment)==0: 
        sys.stdout.write('\r' + "=" * (ev / (nEvents/increment)) +  " " * ((nEvents - ev)/ (nEvents/increment)) + "]" +  str(round((ev+1) / (float(nEvents)/100),2)) + "%")
        sys.stdout.flush()
        sys.stdout.write('\r')
      chain.GetEntry(eList.GetEntry(ev))
      mt2Calc.reset()
      #event weight (L= 4fb^-1)
      weight = reduceStat*getVarValue(chain, "weight")

      weight = weight*(lumi/4000.)

      #MET
      met = getVarValue(chain, "met_pt")
      metPhi = getVarValue(chain, "met_phi")
      #jetpt
      leadingjetpt = getVarValue(chain, "Jet_pt",0)
      subleadingjetpt = getVarValue(chain, "Jet_pt",1)
      #Leptons 
      allLeptons = getLeptons(chain) 
      muons = filter(looseMuID, allLeptons)    
      electrons = filter(looseEleID, allLeptons)
      nlep = len(allLeptons)

      #SF and OF channels
      leptons = {\
        'mu':   {'name': 'mumu', 'file': muons},
        'e':   {'name': 'ee', 'file': electrons},
        'emu': {'name': 'emu', 'file': [electrons,muons]},
        }
      for lep in leptons.keys():
        twoleptons = False
        #Same Flavor
        if lep != 'emu':
          if len(leptons[lep]['file'])==2 and leptons[lep]['file'][0]['pdgId']*leptons[lep]['file'][1]['pdgId']<0:

            twoleptons = True
            l0pt, l0eta, l0phi = leptons[lep]['file'][0]['pt'],  leptons[lep]['file'][0]['eta'],  leptons[lep]['file'][0]['phi']
            l1pt, l1eta, l1phi = leptons[lep]['file'][1]['pt'],  leptons[lep]['file'][1]['eta'],  leptons[lep]['file'][1]['phi']
            leadingleptonpt = l0pt
            subleadingleptonpt = l1pt
            mll = sqrt(2.*l0pt*l1pt*(cosh(l0eta-l1eta)-cos(l0phi-l1phi)))
            zveto = True
        #Opposite Flavor
        if lep == 'emu':
          if len(leptons[lep]['file'][0])==1 and len(leptons[lep]['file'][1])==1 and leptons[lep]['file'][0][0]['pdgId']*leptons[lep]['file'][1][0]['pdgId']<0:

            twoleptons = True
            l0pt, l0eta, l0phi = leptons[lep]['file'][0][0]['pt'],  leptons[lep]['file'][0][0]['eta'],  leptons[lep]['file'][0][0]['phi']
            l1pt, l1eta, l1phi = leptons[lep]['file'][1][0]['pt'],  leptons[lep]['file'][1][0]['eta'],  leptons[lep]['file'][1][0]['phi']
            if l1pt > l0pt :
              leadingleptonpt = l1pt
              subleadingleptonpt = l0pt
            else:
              leadingleptonpt = l0pt
              subleadingleptonpt = l1pt
            mll = sqrt(2.*l0pt*l1pt*(cosh(l0eta-l1eta)-cos(l0phi-l1phi)))
            zveto = False
        if (twoleptons and mll>20 and not zveto) or (twoleptons and mll > 20 and zveto and abs(mll-90.2)>15):
          mt2Calc.setMet(met,metPhi)
          mt2Calc.setLeptons(l0pt, l0eta, l0phi, l1pt, l1eta, l1phi)        
          mt2ll = mt2Calc.mt2ll()
          jets = filter(lambda j:j['pt']>30 and abs(j['eta'])<2.4 and j['id'], getJets(chain))
          bjetspt = filter(lambda j:j['btagCSV']>0.89, jets)
          nobjets = filter(lambda j:j['btagCSV']<=0.89, jets)
          nmuons = len(muons)
          nelectrons = len(electrons)
          ht = sum([j['pt'] for j in jets])


          if len(jets)<1: continue
          if mt2ll<mt2llcut: continue 

          cutflow['metsig']['event'] = met/sqrt(ht)
          cutflow['nbjets']['event'] = len(bjetspt)
          cutflow['njets']['event'] = len(jets)
          cutflow['ht']['event'] = ht

          for cuttype in cutflow.keys():
            eventisgood = True
            for cuttype2 in cutflow.keys():
              if cuttype2 != cuttype:
                if cutflow[cuttype2]['event'] < cutflow[cuttype2]['baseline']:
                  eventisgood = False
            if eventisgood:
              for cut in cutflow[cuttype]['cuts']:
                if cutflow[cuttype]['event'] >= cut:
                  cutflow[cuttype]['cuts'][cut]['samples'][s['name']] += weight

          baselineisgood = True
          for cuttype in cutflow.keys():
            if cutflow[cuttype]['event'] < cutflow[cuttype]['baseline']:
              baselineisgood = False
          if baselineisgood:
            baselineamount['samples'][s['name']] += weight

    del eList

  sigtot = baselineamount['samples'][signal[0]['name']]
  bkgtot = sum(baselineamount['samples'].values()) - sigtot

  if bkgtot > 0: baselineamount['SoverB'] = 100 * (sigtot/sqrt(bkgtot))
  else:          baselineamount['SoverB'] = 0.

  for cuttype in cutflow.keys(): 
    for cut in cutflow[cuttype]['cuts']:
      sigtot = cutflow[cuttype]['cuts'][cut]['samples'][signal[0]['name']]
      bkgtot = sum(cutflow[cuttype]["cuts"][cut]['samples'].values()) - sigtot
      if bkgtot > 0: cutflow[cuttype]['cuts'][cut]['SoverB'] = 100 * (sigtot/sqrt(bkgtot))
      else:          cutflow[cuttype]['cuts'][cut]['SoverB'] = 0.

  maketable(baselineamount, cutflow, mt2llcut, metcut,signal,lumi)
Beispiel #3
0
      #Opposite Flavor
      if lep == 'emu':
        if len(leptons[lep]['file'][0])==1 and len(leptons[lep]['file'][1])==1 and leptons[lep]['file'][0][0]['pdgId']*leptons[lep]['file'][1][0]['pdgId']<0:
          twoleptons = True
          l0pt, l0eta, l0phi = leptons[lep]['file'][0][0]['pt'],  leptons[lep]['file'][0][0]['eta'],  leptons[lep]['file'][0][0]['phi']
          l1pt, l1eta, l1phi = leptons[lep]['file'][1][0]['pt'],  leptons[lep]['file'][1][0]['eta'],  leptons[lep]['file'][1][0]['phi']
          if l1pt > l0pt :
            leadingleptonpt = l1pt
            subleadingleptonpt = l0pt
          else:
            leadingleptonpt = l0pt
            subleadingleptonpt = l1pt
          mll = sqrt(2.*l0pt*l1pt*(cosh(l0eta-l1eta)-cos(l0phi-l1phi)))
          zveto = False
      if (twoleptons and mll>20 and not zveto) or (twoleptons and mll > 20 and zveto and abs(mll-91.2)>15):
        jets = filter(lambda j:j['pt']>30 and abs(j['eta'])<2.4 and j['id'], getJets(chain))
        ht = sum([j['pt'] for j in jets])
        PhiMetJet1 = deltaPhi(metPhi,getVarValue(chain, "Jet_phi",0))
        PhiMetJet2 = deltaPhi(metPhi,getVarValue(chain, "Jet_phi",1))

        bjetspt = filter(lambda j:j['btagCSV']>0.814, jets)
        nobjets = filter(lambda j:j['btagCSV']<=0.814, jets)
        plots[leptons[lep]['name']]['nbjets']['histo'][s["name"]].Fill(len(bjetspt),weight)
        plots[leptons[lep]['name']]['njets']['histo'][s["name"]].Fill(len(jets),weight)
  del eList


#######################################################
#             Drawing done here                       #
#######################################################
#Some coloring
Beispiel #4
0
                        subleadingleptonpt = l0pt
                    else:
                        leadingleptonpt = l0pt
                        subleadingleptonpt = l1pt
                    mll = sqrt(2. * l0pt * l1pt *
                               (cosh(l0eta - l1eta) - cos(l0phi - l1phi)))
                    zveto = False
            if (twoleptons and mll > 20
                    and not zveto) or (twoleptons and mll > 20 and zveto
                                       and abs(mll - 91.2) > 15):
                mt2Calc.setMet(met, metPhi)
                mt2Calc.setLeptons(l0pt, l0eta, l0phi, l1pt, l1eta, l1phi)
                mt2ll = mt2Calc.mt2ll()
                jets = filter(
                    lambda j: j['pt'] > 30 and abs(j['eta']) < 2.4 and j['id'],
                    getJets(chain))
                ht = sum([j['pt'] for j in jets])
                bjetspt = filter(lambda j: j['btagCSV'] > 0.814, jets)
                nobjets = filter(lambda j: j['btagCSV'] < 0.814, jets)
                njets = len(jets)
                nbjets = len(bjetspt)
                nmuons = len(muons)
                nelectrons = len(electrons)

                for cut in mt2llcuts:

                    if mt2ll >= cut:
                        if (nmuons == 1 and nelectrons == 1):

                            if njets == 0:
                                if nbjets == 0:
Beispiel #5
0
        ntot += 1
        if ev % 10000 == 0: print "At %i/%i" % (ev, nEvents)
        chain.GetEntry(eList.GetEntry(ev))
        mt2Calc.reset()
        weight = reduceStat * getVarValue(
            chain, "weight") * lumiScale if not s['isData'] else 1
        mt2ll = getVarValue(chain, "dl_mt2ll")
        met = getVarValue(chain, "met_pt")
        metPhi = getVarValue(chain, "met_phi")
        genMet = getVarValue(chain, "met_genPt")
        genMetPhi = getVarValue(chain, "met_genPhi")
        deltaMet = sqrt((met * cos(metPhi) - genMet * cos(genMetPhi))**2 +
                        (met * sin(metPhi) - genMet * sin(genMetPhi))**2)
        jets = filter(
            lambda j: j['pt'] > 30 and abs(j['eta']) < 2.4 and j['id'],
            getJets(chain))

        allLeptons = getLeptons(
            chain,
            collVars=leptonVars + [
                'mcMatchId', 'mcMatchAny', 'mcMatchTau', 'mcPt', 'ip3d',
                'relIso03', 'relIso04', 'jetPtRatiov1', 'jetPtRelv1',
                'jetPtRelv2', 'jetPtRatiov2', 'jetBTagCSV', 'jetDR'
            ])
        leptons = filter(lambda l: looseMuID(l) or looseEleID(l), allLeptons)

        #LepGood_mcMatchId Match to source from hard scatter (pdgId of heaviest particle in chain, 25 for H, 6 for t, 23/24 for W/Z), zero if non-prompt or fake for Leptons after the preselection
        #LepGood_mcMatchAny  Match to any final state leptons: 0 if unmatched, 1 if light flavour (including prompt), 4 if charm, 5 if bottom for Leptons after the preselection
        #LepGood_mcMatchTau True if the leptons comes from a tau for Leptons after the preselection

        #    for l in leptons:
Beispiel #6
0
        puppiMetPhi = getVarValue(chain, "puppiMet_phi")
        genMet = getVarValue(chain, "met_genPt")
        genMetPhi = getVarValue(chain, "met_genPhi")
        leptons = getGoodLeptons(
            chain, leptonVars + ['mcMatchId', 'mcMatchAny', 'mcPt'])
        l0GenPt, l0HasMatch, l0pt, l0eta, l0phi = leptons[0]['mcPt'], abs(
            leptons[0]['mcMatchId']
        ) == 6, leptons[0]['pt'], leptons[0]['eta'], leptons[0]['phi']
        l1GenPt, l1HasMatch, l1pt, l1eta, l1phi = leptons[1]['mcPt'], abs(
            leptons[1]['mcMatchId']
        ) == 6, leptons[1]['pt'], leptons[1]['eta'], leptons[1]['phi']
        mll = sqrt(2. * l0pt * l1pt *
                   (cosh(l0eta - l1eta) - cos(l0phi - l1phi)))
        jets = filter(
            lambda j: j['pt'] > 30 and abs(j['eta']) < 2.4 and j['id'],
            getJets(chain, jetVars + ['mcPt', 'mcMatchId', 'mcFlavour']))
        #  bjets = filter(lambda j:j['btagCSV']>0.890, jets)
        #  print len(leptons), len(bjets), mll
        mt2Calc.setMet(met, metPhi)
        mt2Calc.setLeptons(l0pt, l0eta, l0phi, l1pt, l1eta, l1phi)
        mt2ll = mt2Calc.mt2ll()
        plots['mt2ll_reco']['histo'][sample["name"]].Fill(mt2ll, weight)

        mt2Calc.setMet(puppiMet, puppiMetPhi)
        mt2ll = mt2Calc.mt2ll()
        plots['mt2ll_puppi']['histo'][sample["name"]].Fill(mt2ll, weight)

        mt2Calc.setMet(genMet, metPhi)
        mt2ll_genMetPt = mt2Calc.mt2ll()
        plots['mt2ll_genMetPt']['histo'][sample["name"]].Fill(
            mt2ll_genMetPt, weight)
Beispiel #7
0
    for ev in range(nEvents):
        if ev%10000==0:print "At %i/%i"%(ev,nEvents)
        chain.GetEntry(eList.GetEntry(ev))
        mt2Calc.reset()
        weight = reduceStat*getVarValue(chain, "weight")*lumiScale
        met = getVarValue(chain, "met_pt")
        metPhi = getVarValue(chain, "met_phi")
        puppiMet = getVarValue(chain, "puppiMet_pt")
        puppiMetPhi = getVarValue(chain, "puppiMet_phi")
        genMet = getVarValue(chain, "met_genPt")
        genMetPhi = getVarValue(chain, "met_genPhi")
        leptons = getGoodLeptons(chain, leptonVars+['mcMatchId', 'mcMatchAny', 'mcPt'])
        l0GenPt, l0HasMatch, l0pt, l0eta, l0phi = leptons[0]['mcPt'],  abs(leptons[0]['mcMatchId'])==6, leptons[0]['pt'],  leptons[0]['eta'],  leptons[0]['phi']
        l1GenPt, l1HasMatch, l1pt, l1eta, l1phi = leptons[1]['mcPt'],  abs(leptons[1]['mcMatchId'])==6, leptons[1]['pt'],  leptons[1]['eta'],  leptons[1]['phi']
        mll = sqrt(2.*l0pt*l1pt*(cosh(l0eta-l1eta)-cos(l0phi-l1phi)))
        jets = filter(lambda j:j['pt']>30 and abs(j['eta'])<2.4 and j['id'], getJets(chain, jetVars+['mcPt', 'mcMatchId', 'mcFlavour']))
    #  bjets = filter(lambda j:j['btagCSV']>0.890, jets)
    #  print len(leptons), len(bjets), mll
        mt2Calc.setMet(met,metPhi)
        mt2Calc.setLeptons(l0pt, l0eta, l0phi, l1pt, l1eta, l1phi)
        mt2ll = mt2Calc.mt2ll()
        plots['mt2ll_reco']['histo'][sample["name"]].Fill(mt2ll, weight)

        mt2Calc.setMet(puppiMet,puppiMetPhi)
        mt2ll = mt2Calc.mt2ll()
        plots['mt2ll_puppi']['histo'][sample["name"]].Fill(mt2ll, weight)

        mt2Calc.setMet(genMet,metPhi)
        mt2ll_genMetPt = mt2Calc.mt2ll()
        plots['mt2ll_genMetPt']['histo'][sample["name"]].Fill(mt2ll_genMetPt, weight)
Beispiel #8
0
def cutflow(sig):
    #######################################################
    #        SELECT WHAT YOU WANT TO DO HERE              #
    #######################################################
    reduceStat = 100  #recude the statistics, i.e. 10 is ten times less samples to look at

    #######################################################
    #         Define cutflow you want to make             #
    #######################################################
    mt2llcut = 80.
    metcut = 40.
    lumi = 10000.

    baselineamount = {
        'samples': {},
        'SoverB': None,
    }

    cutflow = {\
      'metsig':{'baseline': 0.,
                'cuts': {\
                  3:{'samples':{}, 'SoverB': None},
                  4:{'samples':{}, 'SoverB': None},
                  5:{'samples':{}, 'SoverB': None},
                  6:{'samples':{}, 'SoverB': None},
                  7:{'samples':{}, 'SoverB': None},
                  8:{'samples':{}, 'SoverB': None},
                  9:{'samples':{}, 'SoverB': None},
                  10:{'samples':{}, 'SoverB': None},
                  10:{'samples':{}, 'SoverB': None},
                  },
                'event': None,
                },
      'nbjets':{'baseline': 1.,
                'cuts': {\
                  0:{'samples':{}, 'SoverB': None},
                  1:{'samples':{}, 'SoverB': None},
                  2:{'samples':{}, 'SoverB': None},
                  3:{'samples':{}, 'SoverB': None},
                  4:{'samples':{}, 'SoverB': None},
                  5:{'samples':{}, 'SoverB': None},
                  },
                'event': None,
                },
      'njets': {'baseline': 2.,
                'cuts': {\
                  1:{'samples':{}, 'SoverB': None},
                  2:{'samples':{}, 'SoverB': None},
                  3:{'samples':{}, 'SoverB': None},
                  4:{'samples':{}, 'SoverB': None},
                  5:{'samples':{}, 'SoverB': None},
                  6:{'samples':{}, 'SoverB': None},
                  7:{'samples':{}, 'SoverB': None},
                  },
                'event': None,
                },
      'ht':    {'baseline': 0.,
                'cuts': {\
                  50: {'samples':{}, 'SoverB': None},
                  100:{'samples':{}, 'SoverB': None},
                  200:{'samples':{}, 'SoverB': None},
                  300:{'samples':{}, 'SoverB': None},
                  400:{'samples':{}, 'SoverB': None},
                  500:{'samples':{}, 'SoverB': None},
                  },
                'event': None,
                },
    }

    #preselection: MET>40, njets>=2, n_bjets>=1, n_lep>=2
    #For now see here for the Sum$ syntax: https://root.cern.ch/root/html/TTree.html#TTree:Draw@2
    preselection = 'met_pt>' + str(metcut) + '&&Sum$(LepGood_pt>20)==2'

    #######################################################
    #                 load all the samples                #
    #######################################################
    backgrounds = [singleTop_50ns, DY_50ns, TTJets_50ns]
    #signals = [SMS_T2tt_2J_mStop425_mLSP325, SMS_T2tt_2J_mStop500_mLSP325, SMS_T2tt_2J_mStop650_mLSP325, SMS_T2tt_2J_mStop850_mLSP100]
    signal = [sig]

    #######################################################
    #            get the TChains for each sample          #
    #######################################################
    for s in backgrounds + signal:
        s['chain'] = getChain(s, histname="")

    #######################################################
    #            Start filling in the histograms          #
    #######################################################
    for s in backgrounds + signal:
        for cuttype in cutflow.keys():
            for cut in cutflow[cuttype]['cuts'].keys():
                cutflow[cuttype]['cuts'][cut]['samples'][s["name"]] = 0

        baselineamount['samples'][s['name']] = 0

        chain = s["chain"]
        #Using Event loop
        #get EList after preselection
        print "Looping over %s" % s["name"]
        eList = getEList(chain, preselection)
        nEvents = eList.GetN() / reduceStat
        print "Found %i events in %s after preselection %s, looping over %i" % (
            eList.GetN(), s["name"], preselection, nEvents)

        for ev in range(nEvents):
            increment = 50
            if nEvents > increment and ev % (nEvents / increment) == 0:
                sys.stdout.write(
                    '\r' + "=" * (ev / (nEvents / increment)) + " " *
                    ((nEvents - ev) / (nEvents / increment)) + "]" +
                    str(round((ev + 1) / (float(nEvents) / 100), 2)) + "%")
                sys.stdout.flush()
                sys.stdout.write('\r')
            chain.GetEntry(eList.GetEntry(ev))
            mt2Calc.reset()
            #event weight (L= 4fb^-1)
            weight = reduceStat * getVarValue(chain, "weight")

            weight = weight * (lumi / 4000.)

            #MET
            met = getVarValue(chain, "met_pt")
            metPhi = getVarValue(chain, "met_phi")
            #jetpt
            leadingjetpt = getVarValue(chain, "Jet_pt", 0)
            subleadingjetpt = getVarValue(chain, "Jet_pt", 1)
            #Leptons
            allLeptons = getLeptons(chain)
            muons = filter(looseMuID, allLeptons)
            electrons = filter(looseEleID, allLeptons)
            nlep = len(allLeptons)

            #SF and OF channels
            leptons = {\
              'mu':   {'name': 'mumu', 'file': muons},
              'e':   {'name': 'ee', 'file': electrons},
              'emu': {'name': 'emu', 'file': [electrons,muons]},
              }
            for lep in leptons.keys():
                twoleptons = False
                #Same Flavor
                if lep != 'emu':
                    if len(leptons[lep]['file']) == 2 and leptons[lep]['file'][
                            0]['pdgId'] * leptons[lep]['file'][1]['pdgId'] < 0:

                        twoleptons = True
                        l0pt, l0eta, l0phi = leptons[lep]['file'][0][
                            'pt'], leptons[lep]['file'][0]['eta'], leptons[
                                lep]['file'][0]['phi']
                        l1pt, l1eta, l1phi = leptons[lep]['file'][1][
                            'pt'], leptons[lep]['file'][1]['eta'], leptons[
                                lep]['file'][1]['phi']
                        leadingleptonpt = l0pt
                        subleadingleptonpt = l1pt
                        mll = sqrt(2. * l0pt * l1pt *
                                   (cosh(l0eta - l1eta) - cos(l0phi - l1phi)))
                        zveto = True
                #Opposite Flavor
                if lep == 'emu':
                    if len(leptons[lep]['file'][0]) == 1 and len(
                            leptons[lep]['file']
                        [1]) == 1 and leptons[lep]['file'][0][0][
                            'pdgId'] * leptons[lep]['file'][1][0]['pdgId'] < 0:

                        twoleptons = True
                        l0pt, l0eta, l0phi = leptons[lep]['file'][0][0][
                            'pt'], leptons[lep]['file'][0][0]['eta'], leptons[
                                lep]['file'][0][0]['phi']
                        l1pt, l1eta, l1phi = leptons[lep]['file'][1][0][
                            'pt'], leptons[lep]['file'][1][0]['eta'], leptons[
                                lep]['file'][1][0]['phi']
                        if l1pt > l0pt:
                            leadingleptonpt = l1pt
                            subleadingleptonpt = l0pt
                        else:
                            leadingleptonpt = l0pt
                            subleadingleptonpt = l1pt
                        mll = sqrt(2. * l0pt * l1pt *
                                   (cosh(l0eta - l1eta) - cos(l0phi - l1phi)))
                        zveto = False
                if (twoleptons and mll > 20
                        and not zveto) or (twoleptons and mll > 20 and zveto
                                           and abs(mll - 91.2) > 15):
                    mt2Calc.setMet(met, metPhi)
                    mt2Calc.setLeptons(l0pt, l0eta, l0phi, l1pt, l1eta, l1phi)
                    mt2ll = mt2Calc.mt2ll()
                    jets = filter(
                        lambda j: j['pt'] > 30 and abs(j['eta']) < 2.4 and j[
                            'id'], getJets(chain))
                    bjetspt = filter(lambda j: j['btagCSV'] > 0.89, jets)
                    nobjets = filter(lambda j: j['btagCSV'] <= 0.89, jets)
                    nmuons = len(muons)
                    nelectrons = len(electrons)
                    ht = sum([j['pt'] for j in jets])

                    if len(jets) < 1: continue
                    if mt2ll < mt2llcut: continue

                    cutflow['metsig']['event'] = met / sqrt(ht)
                    cutflow['nbjets']['event'] = len(bjetspt)
                    cutflow['njets']['event'] = len(jets)
                    cutflow['ht']['event'] = ht

                    for cuttype in cutflow.keys():
                        eventisgood = True
                        for cuttype2 in cutflow.keys():
                            if cuttype2 != cuttype:
                                if cutflow[cuttype2]['event'] < cutflow[
                                        cuttype2]['baseline']:
                                    eventisgood = False
                        if eventisgood:
                            for cut in cutflow[cuttype]['cuts']:
                                if cutflow[cuttype]['event'] >= cut:
                                    cutflow[cuttype]['cuts'][cut]['samples'][
                                        s['name']] += weight

                    baselineisgood = True
                    for cuttype in cutflow.keys():
                        if cutflow[cuttype]['event'] < cutflow[cuttype][
                                'baseline']:
                            baselineisgood = False
                    if baselineisgood:
                        baselineamount['samples'][s['name']] += weight

        del eList

    sigtot = baselineamount['samples'][signal[0]['name']]
    bkgtot = sum(baselineamount['samples'].values()) - sigtot

    if bkgtot > 0: baselineamount['SoverB'] = 100 * (sigtot / sqrt(bkgtot))
    else: baselineamount['SoverB'] = 0.

    for cuttype in cutflow.keys():
        for cut in cutflow[cuttype]['cuts']:
            sigtot = cutflow[cuttype]['cuts'][cut]['samples'][signal[0]
                                                              ['name']]
            bkgtot = sum(
                cutflow[cuttype]["cuts"][cut]['samples'].values()) - sigtot
            if bkgtot > 0:
                cutflow[cuttype]['cuts'][cut]['SoverB'] = 100 * (sigtot /
                                                                 sqrt(bkgtot))
            else:
                cutflow[cuttype]['cuts'][cut]['SoverB'] = 0.

    maketable(baselineamount, cutflow, mt2llcut, metcut, signal, lumi)
reader.start()
cmg_reader.start()

for i_event, event in enumerate( intersec ):

    reader.goToPosition( positions[event] )
    cmg_reader.goToPosition( cmg_positions[event] )

    # Make sure alignement of trees is OK
    assert reader.data.met_pt == cmg_reader.data.met_pt, "Events inconsistent!"

    logger.info( "###################### Event %2i #############################" % i_event )
    logger.info( "Run %i lumi %i event %i", reader.data.run, reader.data.lumi, reader.data.evt )

    nonId_jets = filter(lambda j:j['pt']>30 and not j['id'], getJets(cmg_reader.data))
    for j in nonId_jets:
        logger.info( "Non-ID Jet found pt %3.2f eta %3.2f phi %3.2f", j['pt'], j['eta'], j['phi'] )

    # reco leptons
    all_reco_leps = getGoodAndOtherLeptons(cmg_reader.data, ptCut=10, miniRelIso = 999. , dz = 0.1, dxy = 1.)

    loose_mu = filter(lambda l:abs(l['pdgId'])==13 and looseMuID(l), all_reco_leps )
    loose_e  = filter(lambda l:abs(l['pdgId'])==11 and looseEleID(l), all_reco_leps )

    extra_mu = filter(lambda l:abs(l['pdgId'])==13 and not looseMuID(l), all_reco_leps )
    extra_e  = filter(lambda l:abs(l['pdgId'])==11 and not looseEleID(l), all_reco_leps )

    reco_mode = "unknown"
    if reader.data.isMuMu:
        reco_mode = "MuMu"
for i_event, event in enumerate(intersec):

    reader.goToPosition(positions[event])
    cmg_reader.goToPosition(cmg_positions[event])

    # Make sure alignement of trees is OK
    assert reader.data.met_pt == cmg_reader.data.met_pt, "Events inconsistent!"

    logger.info(
        "###################### Event %2i #############################" %
        i_event)
    logger.info("Run %i lumi %i event %i", reader.data.run, reader.data.lumi,
                reader.data.evt)

    nonId_jets = filter(lambda j: j['pt'] > 30 and not j['id'],
                        getJets(cmg_reader.data))
    for j in nonId_jets:
        logger.info("Non-ID Jet found pt %3.2f eta %3.2f phi %3.2f", j['pt'],
                    j['eta'], j['phi'])

    # reco leptons
    all_reco_leps = getGoodAndOtherLeptons(cmg_reader.data,
                                           ptCut=10,
                                           miniRelIso=999.,
                                           dz=0.1,
                                           dxy=1.)

    loose_mu = filter(lambda l: abs(l['pdgId']) == 13 and looseMuID(l),
                      all_reco_leps)
    loose_e = filter(lambda l: abs(l['pdgId']) == 11 and looseEleID(l),
                     all_reco_leps)
Beispiel #11
0
    counterRecoGen_failRelIso03[mode]={}
    badMuonCandidates[mode]=[]
    badElectronCandidates[mode]=[]
  for ev in range(nEvents):
    ntot+=1
    if ev%10000==0:print "At %i/%i"%(ev,nEvents)
    chain.GetEntry(eList.GetEntry(ev))
    mt2Calc.reset()
    weight = reduceStat*getVarValue(chain, "weight")*lumiScale if not s['isData'] else 1
    mt2ll = getVarValue(chain, "dl_mt2ll")
    met = getVarValue(chain, "met_pt")
    metPhi = getVarValue(chain, "met_phi")
    genMet = getVarValue(chain, "met_genPt")
    genMetPhi = getVarValue(chain, "met_genPhi")
    deltaMet = sqrt((met*cos(metPhi)-genMet*cos(genMetPhi))**2+(met*sin(metPhi)-genMet*sin(genMetPhi))**2)
    jets = filter(lambda j:j['pt']>30 and abs(j['eta'])<2.4 and j['id'], getJets(chain))

    allLeptons = getLeptons(chain, collVars=leptonVars+['mcMatchId','mcMatchAny','mcMatchTau','mcPt','ip3d', 'relIso03', 'relIso04', 'jetPtRatiov1', 'jetPtRelv1', 'jetPtRelv2', 'jetPtRatiov2', 'jetBTagCSV', 'jetDR'])
    leptons = filter(lambda l: looseMuID(l) or looseEleID(l), allLeptons)

#LepGood_mcMatchId Match to source from hard scatter (pdgId of heaviest particle in chain, 25 for H, 6 for t, 23/24 for W/Z), zero if non-prompt or fake for Leptons after the preselection 
#LepGood_mcMatchAny  Match to any final state leptons: 0 if unmatched, 1 if light flavour (including prompt), 4 if charm, 5 if bottom for Leptons after the preselection
#LepGood_mcMatchTau True if the leptons comes from a tau for Leptons after the preselection

#    for l in leptons:
#      if (l['mcMatchAny']==0 and (not (l['mcMatchId']==0))) or ( (not l['mcMatchAny']==0) and (l['mcMatchId']==0)):
#        print "Match?",l

#RECO
    looseMu = filter(lambda l: abs(l['pdgId'])==13 and l['miniRelIso']<0.4 and l['pt']>15, allLeptons)
    looseEle= filter(lambda l: abs(l['pdgId'])==11 and l['miniRelIso']<0.4 and l['pt']>15, allLeptons)
Beispiel #12
0
        counterRecoGen_genLepOutOfAcceptance[mode]={}
        badMuonCandidates[mode]=[]
        badElectronCandidates[mode]=[]
    for ev in range(nEvents):
        ntot+=1
        if ev%10000==0:print "At %i/%i"%(ev,nEvents)
        s.chain.GetEntry(eList.GetEntry(ev))
        mt2Calc.reset()
        weight = getVarValue(s.chain, "weight")*lumiScale
        mt2ll = getVarValue(s.chain, "dl_mt2ll")
        met = getVarValue(s.chain, "met_pt")
        metPhi = getVarValue(s.chain, "met_phi")
        genMet = getVarValue(s.chain, "met_genPt")
        genMetPhi = getVarValue(s.chain, "met_genPhi")
        deltaMet = sqrt((met*cos(metPhi)-genMet*cos(genMetPhi))**2+(met*sin(metPhi)-genMet*sin(genMetPhi))**2)
        jets = filter(lambda j:j['pt']>30 and abs(j['eta'])<2.4 and j['id'], getJets(s.chain, jetColl="JetGood"))

        allLeptons = getLeptons(s.chain, collVars=leptonVars+['mcMatchId','mcMatchAny','mcMatchTau','mcPt','ip3d', 'relIso03', 'relIso04', 'jetPtRatiov1', 'jetPtRelv1', 'jetPtRelv2', 'jetPtRatiov2', 'jetBTagCSV', 'jetDR'])
        leptons = filter(lambda l: looseMuID(l) or looseEleID(l), allLeptons)

#LepGood_mcMatchId Match to source from hard scatter (pdgId of heaviest particle in s.chain, 25 for H, 6 for t, 23/24 for W/Z), zero if non-prompt or fake for Leptons after the preselection
#LepGood_mcMatchAny  Match to any final state leptons: 0 if unmatched, 1 if light flavour (including prompt), 4 if charm, 5 if bottom for Leptons after the preselection
#LepGood_mcMatchTau True if the leptons comes from a tau for Leptons after the preselection

#RECO
        looseMu = filter(lambda l: abs(l['pdgId'])==13 and l['miniRelIso']<0.4 and l['pt']>15, allLeptons)
        looseEle= filter(lambda l: abs(l['pdgId'])==11 and l['miniRelIso']<0.4 and l['pt']>15, allLeptons)
        mu      = filter(lambda l: abs(l['pdgId'])==13, leptons)
        ele     = filter(lambda l: abs(l['pdgId'])==11, leptons)
        tau     = getGoodTaus(s.chain)
Beispiel #13
0
        electrons = getGoodElectrons(chain)

        #SF and OF channels
        leptons = {\
            'mu':   {'name': 'mumu', 'file': muons},
            'e':   {'name': 'ee', 'file': electrons},
            'emu': {'name': 'emu', 'file': [electrons,muons]},
            }

        for lep in leptons.keys():
            if (lep == "emu" and isEMu) or (((lep == "e" and isEE) or
                                             (lep == "mu" and isMuMu))
                                            and abs(mll - 91.2) > 15):
                jets = filter(
                    lambda j: j['pt'] > 30 and abs(j['eta']) < 2.4 and j['id'],
                    getJets(chain))
                ht = sum([j['pt'] for j in jets])
                bjetspt = filter(lambda j: j['btagCSV'] > btagcoeff, jets)
                nobjets = filter(lambda j: j['btagCSV'] < btagcoeff, jets)
                njets = len(jets)
                nbjets = len(bjetspt)
                nmuons = len(muons)
                nelectrons = len(electrons)

                mt2ll = getVarValue(chain, "dl_mt2ll")

                PhiMetJet1 = deltaPhi(metPhi, getVarValue(chain, "Jet_phi", 0))
                PhiMetJet2 = deltaPhi(metPhi, getVarValue(chain, "Jet_phi", 1))

                PhiMetJet_small = min(PhiMetJet1, PhiMetJet2)