dupObjEff Namespace Reference

Functions
def	dupOfpT3 (event, dict_, debug=False)
def	dupOfpT5 (event, dict_, debug=False)
def	dupOfT5 (event, dict_, debug=False)
def	dupOfTC (event, dict_, debug=False)
def	dupOfTCObj (tc, objType, event, dict_, debug=False)
def	printObjComp (objType, dict_)
def	printSimComp (dict_)
def	printTCComp (objType, dict_)
def	simTrkInfo (event, dict_)

Variables
	action
	args
	choices
	debug
	default
	dict_pT3
	dict_pT5
	dict_sim
	dict_T5
	dict_TC
	dict_TCTot
	event
	False
	help
	infile
	int
	intree
	parser
	str
	type

Function Documentation

dupOfpT3()

def dupObjEff.dupOfpT3	(		event,
			dict_,
			debug = False
	)

Definition at line 165 of file dupObjEff.py.

References isotrackApplyRegressor.range.

def dupOfpT3(event,dict_,debug=False):
  if debug: print "Number of pT3: ",len(event.pT3_pt)
  dict_["N"] = dict_["N"] + len(event.pT3_pt)
  for pT3 in range(len(event.pT3_pt)):
    isDuplicateWpT5 = False
    isDuplicateWpT3 = False
    isDuplicateWT5 = False

    if event.pT3_isFake[pT3] == 1: dict_["Nfakes"] = dict_["Nfakes"] + 1
    if event.pT3_isDuplicate[pT3] == 1: isDuplicateWpT3 = True

    for j in range(len(event.pT3_matched_simIdx[pT3])):
      if debug:
        if event.pT3_isDuplicate[pT3]:
          print "pT3[",pT3,"]"
          print "simTrk_pt = ",event.sim_pt[event.pT3_matched_simIdx[pT3][j]]

      if event.sim_pT5_matched[event.pT3_matched_simIdx[pT3][j]] > 0:
        isDuplicateWpT5 = True
        if debug:
          print ""
          print "pT3_pt = ",event.pT3_pt[pT3]
          print "simTrk_pt = ",event.sim_pt[event.pT3_matched_simIdx[pT3][j]]
          for pT5 in range(len(event.pT5_pt)):
            for k in range(len(event.pT5_matched_simIdx[pT5])):
              if event.pT3_matched_simIdx[pT3][j] == event.pT5_matched_simIdx[pT5][k]:
                print ""
                print "pT5_pt = ",event.pT5_pt[pT5]
                print "simTrk_pt = ",event.sim_pt[event.pT5_matched_simIdx[pT5][k]]
                
      if event.sim_T5_matched[event.pT3_matched_simIdx[pT3][j]] > 0:
        isDuplicateWT5 = True
        if debug:
          print ""
          print "pT3_pt = ",event.pT3_pt[pT3]
          print "simTrk_pt = ",event.sim_pt[event.pT3_matched_simIdx[pT3][j]]
          for T5 in range(len(event.t5_pt)):
            for k in range(len(event.t5_matched_simIdx[T5])):
              if event.pT3_matched_simIdx[pT3][j] == event.t5_matched_simIdx[T5][k]:
                print ""
                print "T5_pt = ",event.t5_pt[T5]
                print "simTrk_pt = ",event.sim_pt[event.t5_matched_simIdx[T5][k]]

    if isDuplicateWpT5:
      if isDuplicateWpT3:
        if isDuplicateWT5:
          dict_["Ndup_Wall"] = dict_["Ndup_Wall"] + 1
        else:
          dict_["Ndup_WpT5ApT3"] = dict_["Ndup_WpT5ApT3"] + 1
      else:
        if isDuplicateWT5:
          dict_["Ndup_WpT5AT5"] = dict_["Ndup_WpT5AT5"] + 1
        else:
          dict_["Ndup_WpT5"] = dict_["Ndup_WpT5"] + 1
    else:
      if isDuplicateWpT3:
        if isDuplicateWT5:
          dict_["Ndup_WpT3AT5"] = dict_["Ndup_WpT3AT5"] + 1
        else:
          dict_["Ndup_WpT3"] = dict_["Ndup_WpT3"] + 1
      else:
        if isDuplicateWT5:
          dict_["Ndup_WT5"] = dict_["Ndup_WT5"] + 1

  return dict_

dupOfpT5()

def dupObjEff.dupOfpT5	(		event,
			dict_,
			debug = False
	)

Definition at line 98 of file dupObjEff.py.

References isotrackApplyRegressor.range.

def dupOfpT5(event,dict_,debug=False):
  if debug: print "Number of pT5: ",len(event.pT5_pt)
  dict_["N"] = dict_["N"] + len(event.pT5_pt)
  for pT5 in range(len(event.pT5_pt)):
    isDuplicateWpT5 = False
    isDuplicateWpT3 = False
    isDuplicateWT5 = False

    if event.pT5_isFake[pT5] == 1: dict_["Nfakes"] = dict_["Nfakes"] + 1
    if event.pT5_isDuplicate[pT5] == 1: isDuplicateWpT5 = True

    for j in range(len(event.pT5_matched_simIdx[pT5])):
      if debug:
        if event.pT5_isDuplicate[pT5]:
          print "pT5[",pT5,"]"
          print "simTrk_pt = ",event.sim_pt[event.pT5_matched_simIdx[pT5][j]]

      if event.sim_pT3_matched[event.pT5_matched_simIdx[pT5][j]] > 0:
        isDuplicateWpT3 = True
        if debug:
          print ""
          print "pT5_pt = ",event.pT5_pt[pT5]
          print "simTrk_pt = ",event.sim_pt[event.pT5_matched_simIdx[pT5][j]]
          for pT3 in range(len(event.pT3_pt)):
            for k in range(len(event.pT3_matched_simIdx[pT3])):
              if event.pT5_matched_simIdx[pT5][j] == event.pT3_matched_simIdx[pT3][k]:
                print ""
                print "pT3_pt = ",event.pT3_pt[pT3]
                print "simTrk_pt = ",event.sim_pt[event.pT3_matched_simIdx[pT3][k]]
                
      if event.sim_T5_matched[event.pT5_matched_simIdx[pT5][j]] > 0:
        isDuplicateWT5 = True
        if debug:
          print ""
          print "pT5_pt = ",event.pT5_pt[pT5]
          print "simTrk_pt = ",event.sim_pt[event.pT5_matched_simIdx[pT5][j]]
          for T5 in range(len(event.t5_pt)):
            for k in range(len(event.t5_matched_simIdx[T5])):
              if event.pT5_matched_simIdx[pT5][j] == event.t5_matched_simIdx[T5][k]:
                print ""
                print "T5_pt = ",event.t5_pt[T5]
                print "simTrk_pt = ",event.sim_pt[event.t5_matched_simIdx[T5][k]]

    if isDuplicateWpT5:
      if isDuplicateWpT3:
        if isDuplicateWT5:
          dict_["Ndup_Wall"] = dict_["Ndup_Wall"] + 1
        else:
          dict_["Ndup_WpT5ApT3"] = dict_["Ndup_WpT5ApT3"] + 1
      else:
        if isDuplicateWT5:
          dict_["Ndup_WpT5AT5"] = dict_["Ndup_WpT5AT5"] + 1
        else:
          dict_["Ndup_WpT5"] = dict_["Ndup_WpT5"] + 1
    else:
      if isDuplicateWpT3:
        if isDuplicateWT5:
          dict_["Ndup_WpT3AT5"] = dict_["Ndup_WpT3AT5"] + 1
        else:
          dict_["Ndup_WpT3"] = dict_["Ndup_WpT3"] + 1
      else:
        if isDuplicateWT5:
          dict_["Ndup_WT5"] = dict_["Ndup_WT5"] + 1

  return dict_

dupOfT5()

def dupObjEff.dupOfT5	(		event,
			dict_,
			debug = False
	)

Definition at line 232 of file dupObjEff.py.

References isotrackApplyRegressor.range.

def dupOfT5(event,dict_,debug=False):
  if debug: print "Number of T5: ",len(event.t5_pt)
  dict_["N"] = dict_["N"] + len(event.t5_pt)
  for t5 in range(len(event.t5_pt)):
    isDuplicateWpT5 = False
    isDuplicateWpT3 = False
    isDuplicateWT5 = False

    if event.t5_isFake[t5] == 1: dict_["Nfakes"] = dict_["Nfakes"] + 1
    if event.t5_isDuplicate[t5] == 1: isDuplicateWT5 = True

    for j in range(len(event.t5_matched_simIdx[t5])):
      if debug:
        if event.t5_isDuplicate[t5]:
          print "T5[",t5,"]"
          print "simTrk_pt = ",event.sim_pt[event.t5_matched_simIdx[t5][j]]

      if event.sim_pT5_matched[event.t5_matched_simIdx[t5][j]] > 0:
        isDuplicateWpT5 = True
        if debug:
          print ""
          print "T5_pt = ",event.t5_pt[t5]
          print "simTrk_pt = ",event.sim_pt[event.t5_matched_simIdx[t5][j]]
          for pT5 in range(len(event.pT5_pt)):
            for k in range(len(event.pT5_matched_simIdx[pT5])):
              if event.t5_matched_simIdx[t5][j] == event.pT5_matched_simIdx[pT5][k]:
                print ""
                print "pT5_pt = ",event.pT5_pt[pT5]
                print "simTrk_pt = ",event.sim_pt[event.pT5_matched_simIdx[pT5][k]]
                
      if event.sim_pT3_matched[event.t5_matched_simIdx[t5][j]] > 0:
        isDuplicateWpT3 = True
        if debug:
          print ""
          print "T5_pt = ",event.t5_pt[t5]
          print "simTrk_pt = ",event.sim_pt[event.t5_matched_simIdx[t5][j]]
          for pT3 in range(len(event.pT3_pt)):
            for k in range(len(event.pT3_matched_simIdx[pT3])):
              if event.t5_matched_simIdx[t5][j] == event.pT3_matched_simIdx[pT3][k]:
                print ""
                print "pT3_pt = ",event.pT3_pt[pT3]
                print "simTrk_pt = ",event.sim_pt[event.pT3_matched_simIdx[pT3][k]]

    if isDuplicateWpT5:
      if isDuplicateWpT3:
        if isDuplicateWT5:
          dict_["Ndup_Wall"] = dict_["Ndup_Wall"] + 1
        else:
          dict_["Ndup_WpT5ApT3"] = dict_["Ndup_WpT5ApT3"] + 1
      else:
        if isDuplicateWT5:
          dict_["Ndup_WpT5AT5"] = dict_["Ndup_WpT5AT5"] + 1
        else:
          dict_["Ndup_WpT5"] = dict_["Ndup_WpT5"] + 1
    else:
      if isDuplicateWpT3:
        if isDuplicateWT5:
          dict_["Ndup_WpT3AT5"] = dict_["Ndup_WpT3AT5"] + 1
        else:
          dict_["Ndup_WpT3"] = dict_["Ndup_WpT3"] + 1
      else:
        if isDuplicateWT5:
          dict_["Ndup_WT5"] = dict_["Ndup_WT5"] + 1

  return dict_

dupOfTC()

def dupObjEff.dupOfTC	(		event,
			dict_,
			debug = False
	)

Definition at line 88 of file dupObjEff.py.

References dupOfTCObj(), and isotrackApplyRegressor.range.

def dupOfTC(event,dict_,debug=False):
  for tc in range(len(event.tc_pt)):
    if event.tc_type[tc] == 7: dict_ = dupOfTCObj(tc,"pT5",event,dict_,debug=debug)
    if event.tc_type[tc] == 5: dict_ = dupOfTCObj(tc,"pT3",event,dict_,debug=debug)
    if event.tc_type[tc] == 4: dict_ = dupOfTCObj(tc,"T5",event,dict_,debug=debug)
    if event.tc_type[tc] == 8: dict_ = dupOfTCObj(tc,"pLS",event,dict_,debug=debug)

  return dict_

dupOfTCObj()

def dupObjEff.dupOfTCObj	(		tc,
			objType,
			event,
			dict_,
			debug = False
	)

Definition at line 52 of file dupObjEff.py.

References isotrackApplyRegressor.range.

Referenced by dupOfTC().

def dupOfTCObj(tc,objType,event,dict_,debug=False):
  isDuplicate = False
  isDuplicateWpT5 = False
  isDuplicateWpT3 = False
  isDuplicateWT5 = False
  isDuplicateWpLS = False

  dict_["N_"+objType] = dict_["N_"+objType] + 1

  if event.tc_isFake[tc] == 1: dict_["N_"+objType+"fakes"] = dict_["N_"+objType+"fakes"] + 1
  for simIdx in range(len(event.tc_matched_simIdx[tc])):
    for tcOther in range(len(event.tc_pt)):
      if tc==tcOther: continue
      for simIdxOther in range(len(event.tc_matched_simIdx[tcOther])):
        if event.tc_matched_simIdx[tc][simIdx] == event.tc_matched_simIdx[tcOther][simIdxOther]:
          isDuplicate = True
          if debug:
            print ""
            print "TC_"+objType+"[%d] pt = %.2f, eta = %.2f, phi = %.2f" %( tc, event.tc_pt[tc], event.tc_eta[tc], event.tc_phi[tc] )
            print "Matched simTrk pt = %.2f" %event.sim_pt[event.tc_matched_simIdx[tc][simIdx]]
            print "Duplicate of type %d:" %event.tc_type[tcOther]
            print "\tTC_[%d] pt = %.2f, eta = %.2f, phi = %.2f" %( tcOther, event.tc_pt[tcOther], event.tc_eta[tcOther], event.tc_phi[tcOther] )
          if event.tc_type[tcOther] == 7: isDuplicateWpT5 = True
          if event.tc_type[tcOther] == 5: isDuplicateWpT3 = True
          if event.tc_type[tcOther] == 4: isDuplicateWT5 = True
          if event.tc_type[tcOther] == 8: isDuplicateWpLS = True

  if isDuplicate: dict_["Ndup_"+objType+"Total"] = dict_["Ndup_"+objType+"Total"] + 1
  if isDuplicateWpT5: dict_["Ndup_"+objType+"WpT5"] = dict_["Ndup_"+objType+"WpT5"] + 1
  if isDuplicateWpT3: dict_["Ndup_"+objType+"WpT3"] = dict_["Ndup_"+objType+"WpT3"] + 1
  if isDuplicateWT5: dict_["Ndup_"+objType+"WT5"] = dict_["Ndup_"+objType+"WT5"] + 1
  if isDuplicateWpLS: dict_["Ndup_"+objType+"WpLS"] = dict_["Ndup_"+objType+"WpLS"] + 1

  return dict_

printObjComp()

def dupObjEff.printObjComp	(		objType,
			dict_
	)

Definition at line 345 of file dupObjEff.py.

References ALCARECOEcalPhiSym_cff.float.

def printObjComp(objType,dict_):
  if dict_["N"] == 0:
    print "No "+objType+" object found!"
    return
  dict_["Ndup_Total"] = dict_["Ndup_WpT5"]+dict_["Ndup_WpT3"]+dict_["Ndup_WT5"]+dict_["Ndup_WpT5ApT3"]+dict_["Ndup_WpT5AT5"]+dict_["Ndup_WpT3AT5"]+dict_["Ndup_Wall"]
  dict_["NsingleMatched"] = dict_["N"]-dict_["Nfakes"]-dict_["Ndup_Total"]

  print ""
  print "Total "+objType+" multiplicity = %d" %dict_["N"]
  print objType+" Fakes = %d (%.2f%%)" %( dict_["Nfakes"], float(dict_["Nfakes"])/float(dict_["N"])*100 )
  print objType+" Duplicates with pT5 only = %d (%.2f%%)" %( dict_["Ndup_WpT5"], float(dict_["Ndup_WpT5"])/float(dict_["N"])*100 )
  print objType+" Duplicates with pT3 only = %d (%.2f%%)" %( dict_["Ndup_WpT3"], float(dict_["Ndup_WpT3"])/float(dict_["N"])*100 )
  print objType+" Duplicates with T5 only = %d (%.2f%%)" %( dict_["Ndup_WT5"], float(dict_["Ndup_WT5"])/float(dict_["N"])*100 )
  print objType+" Duplicates with pT5 and pT3 only = %d (%.2f%%)" %( dict_["Ndup_WpT5ApT3"], float(dict_["Ndup_WpT5ApT3"])/float(dict_["N"])*100 )
  print objType+" Duplicates with pT5 and T5 only = %d (%.2f%%)" %( dict_["Ndup_WpT5AT5"], float(dict_["Ndup_WpT5AT5"])/float(dict_["N"])*100 )
  print objType+" Duplicates with pT3 and T5 only = %d (%.2f%%)" %( dict_["Ndup_WpT3AT5"], float(dict_["Ndup_WpT3AT5"])/float(dict_["N"])*100 )
  print objType+" Duplicates with all = %d (%.2f%%)" %( dict_["Ndup_Wall"], float(dict_["Ndup_Wall"])/float(dict_["N"])*100 )
  print objType+" Total duplicates = %d (%.2f%%)" %( dict_["Ndup_Total"], float(dict_["Ndup_Total"])/float(dict_["N"])*100 )
  print objType+" Single matched non-fakes = %d (%.2f%%)" %( dict_["NsingleMatched"], float(dict_["NsingleMatched"])/float(dict_["N"])*100 )
  print ""
  return

printSimComp()

def dupObjEff.printSimComp

(

dict_

)

Definition at line 299 of file dupObjEff.py.

References ALCARECOEcalPhiSym_cff.float.

def printSimComp(dict_):
  if dict_["N"] == 0:
    print "No sim  object found!"
    return

  print ""
  print "Total sim multiplicity = %d" %dict_["N"]
  print "Matched sim = %d (%.2f%%)" %( dict_["N_matched"], float(dict_["N_matched"])/float(dict_["N"])*100 )
  print "Single matched sim = %d (%.2f%%)" %( dict_["N_singleMatched"], float(dict_["N_singleMatched"])/float(dict_["N"])*100 )
  print "Duplicate sim = %d (%.2f%%)" %( dict_["N_dup"], float(dict_["N_dup"])/float(dict_["N"])*100 )
  print "Matched with pT5 = %d (%.2f%%)" %( dict_["N_matchedWpT5"], float(dict_["N_matchedWpT5"])/float(dict_["N"])*100 )
  print "Matched with pT3 = %d (%.2f%%)" %( dict_["N_matchedWpT3"], float(dict_["N_matchedWpT3"])/float(dict_["N"])*100 )
  print "Matched with T5 = %d (%.2f%%)" %( dict_["N_matchedWT5"], float(dict_["N_matchedWT5"])/float(dict_["N"])*100 )
  print "Matched with pLS = %d (%.2f%%)" %( dict_["N_matchedWpLS"], float(dict_["N_matchedWpLS"])/float(dict_["N"])*100 )
  print ""
  print "Good sim = %d (%.2f%%)" %( dict_["N_good"], float(dict_["N_good"])/float(dict_["N"])*100 )
  print "Matched good sim = %d (%.2f%%)" %( dict_["N_goodMatched"], float(dict_["N_goodMatched"])/float(dict_["N_good"])*100 )
  print "Single matched good sim = %d (%.2f%%)" %( dict_["N_goodSingleMatched"], float(dict_["N_goodSingleMatched"])/float(dict_["N_good"])*100 )
  print "Duplicate good sim = %d (%.2f%%)" %( dict_["N_goodDup"], float(dict_["N_goodDup"])/float(dict_["N_good"])*100 )
  print "Good sim matched with pT5 = %d (%.2f%%)" %( dict_["N_goodMatchedWpT5"], float(dict_["N_goodMatchedWpT5"])/float(dict_["N_good"])*100 )
  print "Good sim matched with pT3 = %d (%.2f%%)" %( dict_["N_goodMatchedWpT3"], float(dict_["N_goodMatchedWpT3"])/float(dict_["N_good"])*100 )
  print "Good sim matched with T5 = %d (%.2f%%)" %( dict_["N_goodMatchedWT5"], float(dict_["N_goodMatchedWT5"])/float(dict_["N_good"])*100 )
  print "Good sim matched with pLS = %d (%.2f%%)" %( dict_["N_goodMatchedWpLS"], float(dict_["N_goodMatchedWpLS"])/float(dict_["N_good"])*100 )
  print ""
  return

printTCComp()

def dupObjEff.printTCComp	(		objType,
			dict_
	)

Definition at line 326 of file dupObjEff.py.

References ALCARECOEcalPhiSym_cff.float.

def printTCComp(objType,dict_):
  if dict_["N_"+objType] == 0:
    print "No "+objType+" object found in TC collection!"
    return
  dict_["N_"+objType+"singleMatched"] = dict_["N_"+objType]-dict_["N_"+objType+"fakes"]-dict_["Ndup_"+objType+"Total"]

  print ""
  print "Total "+objType+" multiplicity in TC collection = %d" %dict_["N_"+objType]
  print objType+" Fakes = %d (%.2f%%)" %( dict_["N_"+objType+"fakes"], float(dict_["N_"+objType+"fakes"])/float(dict_["N_"+objType])*100 )
  print objType+" Duplicates with pT5 = %d (%.2f%%)" %( dict_["Ndup_"+objType+"WpT5"], float(dict_["Ndup_"+objType+"WpT5"])/float(dict_["N_"+objType])*100 )
  print objType+" Duplicates with pT3 = %d (%.2f%%)" %( dict_["Ndup_"+objType+"WpT3"], float(dict_["Ndup_"+objType+"WpT3"])/float(dict_["N_"+objType])*100 )
  print objType+" Duplicates with T5 = %d (%.2f%%)" %( dict_["Ndup_"+objType+"WT5"], float(dict_["Ndup_"+objType+"WT5"])/float(dict_["N_"+objType])*100 )
  print objType+" Duplicates with pLS = %d (%.2f%%)" %( dict_["Ndup_"+objType+"WpLS"], float(dict_["Ndup_"+objType+"WpLS"])/float(dict_["N_"+objType])*100 )
  print objType+" Total duplicates = %d (%.2f%%)" %( dict_["Ndup_"+objType+"Total"], float(dict_["Ndup_"+objType+"Total"])/float(dict_["N_"+objType])*100 )
  print objType+" Single matched non-fakes = %d (%.2f%%)" %( dict_["N_"+objType+"singleMatched"], float(dict_["N_"+objType+"singleMatched"])/float(dict_["N_"+objType])*100 )
  print ""
  return

simTrkInfo()

def dupObjEff.simTrkInfo	(		event,
			dict_
	)

Definition at line 17 of file dupObjEff.py.

References isotrackApplyRegressor.range.

def simTrkInfo(event,dict_):
  dict_["N"] = dict_["N"] + len(event.sim_pt)
  for simTrk in range(len(event.sim_pt)):
    isGood = False
    if event.sim_isGood[simTrk]:
      isGood = True
      dict_["N_good"] = dict_["N_good"] + 1
    if event.sim_TC_matched[simTrk] > 0:
      dict_["N_matched"] = dict_["N_matched"] + 1
      if isGood: dict_["N_goodMatched"] = dict_["N_goodMatched"] + 1
      if event.sim_TC_matched[simTrk] == 1:
        dict_["N_singleMatched"] = dict_["N_singleMatched"] + 1
        if isGood: dict_["N_goodSingleMatched"] = dict_["N_goodSingleMatched"] + 1
      if event.sim_TC_matched[simTrk] > 1:
        dict_["N_dup"] = dict_["N_dup"] + 1
        if isGood: dict_["N_goodDup"] = dict_["N_goodDup"] + 1
      for tc in range(len(event.tc_matched_simIdx)):
        for simIdxOther in range(len(event.tc_matched_simIdx[tc])):
          if event.tc_matched_simIdx[tc][simIdxOther] == simTrk:
            if event.tc_type[tc] == 7:
              dict_["N_matchedWpT5"] = dict_["N_matchedWpT5"] + 1
              if isGood: dict_["N_goodMatchedWpT5"] = dict_["N_goodMatchedWpT5"] + 1
            if event.tc_type[tc] == 5:
              dict_["N_matchedWpT3"] = dict_["N_matchedWpT3"] + 1
              if isGood: dict_["N_goodMatchedWpT3"] = dict_["N_goodMatchedWpT3"] + 1
            if event.tc_type[tc] == 4:
              dict_["N_matchedWT5"] = dict_["N_matchedWT5"] + 1
              if isGood: dict_["N_goodMatchedWT5"] = dict_["N_goodMatchedWT5"] + 1
            if event.tc_type[tc] == 8:
              dict_["N_matchedWpLS"] = dict_["N_matchedWpLS"] + 1
              if isGood: dict_["N_goodMatchedWpLS"] = dict_["N_goodMatchedWpLS"] + 1

  return dict_

Variable Documentation

action

dupObjEff.action

Definition at line 7 of file dupObjEff.py.

args

dupObjEff.args

Definition at line 10 of file dupObjEff.py.

choices

dupObjEff.choices

Definition at line 9 of file dupObjEff.py.

debug

dupObjEff.debug

Definition at line 379 of file dupObjEff.py.

default

dupObjEff.default

Definition at line 5 of file dupObjEff.py.

dict_pT3

dupObjEff.dict_pT3

Definition at line 376 of file dupObjEff.py.

dict_pT5

dupObjEff.dict_pT5

Definition at line 375 of file dupObjEff.py.

dict_sim

dupObjEff.dict_sim

Definition at line 368 of file dupObjEff.py.

dict_T5

dupObjEff.dict_T5

Definition at line 377 of file dupObjEff.py.

dict_TC

dupObjEff.dict_TC

Definition at line 371 of file dupObjEff.py.

dict_TCTot

dupObjEff.dict_TCTot

Definition at line 370 of file dupObjEff.py.

event

dupObjEff.event

Definition at line 387 of file dupObjEff.py.

False

dupObjEff.False

Definition at line 7 of file dupObjEff.py.

help

dupObjEff.help

Definition at line 5 of file dupObjEff.py.

infile

dupObjEff.infile

Definition at line 13 of file dupObjEff.py.

int

dupObjEff.int

Definition at line 6 of file dupObjEff.py.

intree

dupObjEff.intree

Definition at line 14 of file dupObjEff.py.

Referenced by APVValidationPlots.endJob().

parser

dupObjEff.parser

Definition at line 4 of file dupObjEff.py.

str

dupObjEff.str

Definition at line 5 of file dupObjEff.py.

type

dupObjEff.type

Definition at line 5 of file dupObjEff.py.