def main(): # usage description usage = "Example: ./scripts/plotLimits.py -M Asymptotic -l logs -f qq --massrange 1200 7000 100" # input parameters parser = ArgumentParser(description='Script that plots limits for specified mass points',epilog=usage) parser.add_argument('analysis', type=str, help='Analysis name') parser.add_argument('model', type=str, help='Model name') parser.add_argument("-M", "--method", dest="method", required=True, choices=['ProfileLikelihood', 'HybridNew', 'Asymptotic', 'MarkovChainMC', 'theta', 'HybridNewGrid'], help="Method to calculate upper limits", metavar="METHOD") parser.add_argument('--fit_function', type=str, default="f4", help="Name of fit function used for background estimate") parser.add_argument('--timesAE', action='store_true', help="Set y-axis to sigma*BR*A*e, instead of sigma*BR") parser.add_argument('--fitTrigger', action='store_true', help="Use trigger fit") parser.add_argument('--correctTrigger', action='store_true', help="Use trigger correction") parser.add_argument('--useMCTrigger', action='store_true', help="Use MC trigger emulation") #results_group = parser.add_mutually_exclusive_group(required=True) #results_group.add_argument("-l", "--logs_path", dest="logs_path", # help="Path to log files", # metavar="LOGS_PATH") #results_group.add_argument("-r", "--results_file", dest="results_file", # help="Path to a file containing results", # metavar="RESULTS_FILE") #parser.add_argument("-f", "--final_state", dest="final_state", required=True, # help="Final state (e.g. qq, qg, gg)", # metavar="FINAL_STATE") #parser.add_argument("-f2", "--finalstate2", dest="final_state2", required=True, help="hG,lG,hR, or lR", metavar="FINAL_STATE2") parser.add_argument("--noSyst", action="store_true", help="Make plots for limits without systematics") parser.add_argument("--freezeNuisances", type=str, help="Make plots for limits with frozen nuisance parameters") parser.add_argument("--postfix", dest="postfix", default='', help="Postfix for the output plot name (default: %(default)s)") parser.add_argument("--fileFormat", dest="fileFormat", default='pdf', help="Format of the output plot (default: %(default)s)") parser.add_argument("--saveObjects", type=str, help="Save plot objects") parser.add_argument("--extraText", dest="extraText", default='', help="Extra text on the plot (default: %(default)s)") parser.add_argument("--lumi_sqrtS", dest="lumi_sqrtS", default='19.7 fb^{-1} (8 TeV)', help="Integrated luminosity and center-of-mass energy (default: %(default)s)") parser.add_argument("--printResults", dest="printResults", default=False, action="store_true", help="Print results to the screen") mass_group = parser.add_mutually_exclusive_group(required=True) mass_group.add_argument("--mass", type=int, nargs = '*', default = 1000, help="Mass can be specified as a single value or a whitespace separated list (default: %(default)i)" ) mass_group.add_argument("--massrange", type=int, nargs = 3, help="Define a range of masses to be produced. Format: min max step", metavar = ('MIN', 'MAX', 'STEP') ) mass_group.add_argument("--masslist", help = "List containing mass information" ) args = parser.parse_args() if args.method == 'HybridNew': searchmethod = 'Hybrid New' # mass points for which resonance shapes will be produced input_masses = [] if args.massrange != None: MIN, MAX, STEP = args.massrange input_masses = range(MIN, MAX+STEP, STEP) elif args.masslist != None: # A mass list was provided print "Will create mass list according to", args.masslist masslist = __import__(args.masslist.replace(".py","")) input_masses = masslist.masses else: input_masses = args.mass # sort masses input_masses.sort() from ROOT import kTRUE, kFALSE, gROOT, gStyle, gPad, TGraph, TCanvas, TLegend, TF1, TFile from ROOT import kGreen, kYellow, kWhite # Make acc*eff TGraph ae_x = array('d',[325, 350, 400, 500, 600, 750, 900, 1200]) if args.timesAE: ae_y = np.ones(len(ae_x)) else: ae_y = array('d', []) for mass in ae_x: ae_y.append(analysis_config.simulation.get_signal_AE(args.analysis, args.model, int(mass))) acceptance_times_efficiency = TGraph(len(ae_x), ae_x, ae_y) #xs = array('d',[250,300,400,500,600,750,900,1200]) #trigger_correctionl = TF1("trigbbl_efficiency", "(1. / (1. + TMath::Exp(-1. * (x - [0]) / [1])))**[2]", 175, 400) #trigger_correctionl.SetParameter(0, 1.82469e+02) #trigger_correctionl.SetParameter(1, 2.87768e+01) #trigger_correctionl.SetParameter(2, 9.11659e-01) #trigger_correctionh = TF1("trigbbh_efficiency", "(1. / (1. + TMath::Exp(-1. * (x - [0]) / [1])))**[2]", 300, 600) #trigger_correctionh.SetParameter(0, 3.61785e+02) #trigger_correctionh.SetParameter(1, 3.16523e+01) #trigger_correctionh.SetParameter(2, 4.84357e-01) #if args.timesAE: # ys = np.ones(len(xs)) #else: # if args.analysis == "trigbbh_CSVTM" and args.model == "Hbb": # #ys = array('d',[188./19751.,1304./19993.,2697./49494.,881./19999.,534./19598.]) # ys = array('d',[24./19737.,188./19751.,1171./19984.,1419./19992.,1304./19993.,2697./49494.,881./19999.,534./19598.]) # #graphMod = trigger_correctionh # elif args.analysis == "trigbbl_CSVTM" and args.model == "Hbb": # #ys = array('d',[30./2797.,1583./19995.,1295./19996.,999./19996.,528./19999.]) # ys = array('d',[574./19737.,763./39502.,651./19984.,583./19992.,984./39986.,1905./98988.,656./39998.,369./39196.]) # #graphMod = trigger_correctionh # elif args.analysis == "trigbbh_CSVTM" and args.model == "RSG": # #ys = array('d',[109./19751.,488./19993.,954./49494.,328./19999.,182./19598.]) # ys = array('d',[40./19977.,30./2797.,1522./19991.,1640./19396.,1583./19995.,1295./19996.,999./19996.,528./19999.]) # #graphMod = trigger_correctionl # elif args.analysis == "trigbbl_CSVTM" and args.model == "RSG": # #ys = array('d',[23./2797.,599./19995.,448./19996.,338./19996.,190./19999.]) # ys = array('d',[696./19977.,137./5594.,797./19991.,652./19396.,1206./39990.,891./39992.,675./39992.,379./39998.]) # #graphMod = trigger_correctionl ##ys = array('d',[1,1,1,1,1,1,1,1,]) #acceptance_times_efficiency = TGraph(len(xs),xs,ys) # arrays holding results masses = array('d') xs_obs_limits = array('d') xs_exp_limits = array('d') masses_exp = array('d') xs_exp_limits_1sigma = array('d') xs_exp_limits_1sigma_up = array('d') xs_exp_limits_2sigma = array('d') xs_exp_limits_2sigma_up = array('d') for mass in input_masses: print ">> Reading results for %s %s resonance with m = %i GeV..."%(args.analysis, args.model, int(mass)) masses.append(mass) masses_exp.append(mass) # For masses above 1100, you scaled down the signal by 10 by hand, to help the limit setting. #if args.analysis == "trigbbh_CSVTM" and mass >= 1100: input_xs = 1./100. #else: # input_xs = 1. if args.method == "HybridNewGrid": found_limit = {"obs":False, "exp0":False, "exp1":False, "exp2":False, "exp-1":False, "exp-2":False} for what in found_limit.keys(): log_file_path = limit_config.get_combine_log_path_grid(args.analysis, args.model, mass, args.fit_function, what, systematics=(not args.noSyst), frozen_nps=args.freezeNuisances, fitTrigger=args.fitTrigger, correctTrigger=args.correctTrigger, useMCTrigger=args.useMCTrigger) print "Reading log file from " + log_file_path log_file = open(log_file_path, 'r') for line in log_file: if re.search("^Limit: r <", line) and re.search("95%", line): found_limit[what] = True this_limit = float(line.split()[3])/acceptance_times_efficiency.Eval(mass) print "Found limit for " + what + " = " + str(this_limit) if what == "obs": xs_obs_limits.append(this_limit * input_xs) elif what == "exp0": xs_exp_limits.append(this_limit * input_xs) elif what == "exp1": xs_exp_limits_1sigma_up.append(this_limit * input_xs) elif what == "exp2": xs_exp_limits_2sigma_up.append(this_limit * input_xs) elif what == "exp-1": xs_exp_limits_1sigma.append(this_limit * input_xs) elif what == "exp-2": xs_exp_limits_2sigma.append(this_limit * input_xs) if not found_limit["obs"]: xs_obs_limits.append(0) if not found_limit["exp0"]: xs_exp_limits.append(0) if not found_limit["exp1"]: xs_exp_limits_1sigma.append(0) if not found_limit["exp2"]: xs_exp_limits_1sigma_up.append(0) if not found_limit["exp-1"]: xs_exp_limits_2sigma.append(0) if not found_limit["exp-2"]: xs_exp_limits_2sigma_up.append(0) if len(masses) != len(xs_obs_limits): print "** ERROR: ** Could not find observed limit for m =", int(mass), "GeV. Aborting." sys.exit(1) else: print "Reading log file from " + limit_config.get_combine_log_path(args.analysis, args.model, mass, args.fit_function, args.method, systematics=(not args.noSyst), frozen_nps=args.freezeNuisances, fitTrigger=args.fitTrigger, correctTrigger=args.correctTrigger, useMCTrigger=args.useMCTrigger) if not os.path.exists((limit_config.get_combine_log_path(args.analysis, args.model, mass, args.fit_function, args.method, systematics=(not args.noSyst), frozen_nps=args.freezeNuisances, fitTrigger=args.fitTrigger, correctTrigger=args.correctTrigger, useMCTrigger=args.useMCTrigger))): print "[plot_limits] WARNING : Log file not found! Setting limits to zero and skipping this point." print "[plot_limits] WARNING : \t{}".format(limit_config.get_combine_log_path(args.analysis, args.model, mass, args.fit_function, args.method, systematics=(not args.noSyst), frozen_nps=args.freezeNuisances, fitTrigger=args.fitTrigger, correctTrigger=args.correctTrigger, useMCTrigger=args.useMCTrigger)) xs_obs_limits.append(0) xs_exp_limits.append(0) xs_exp_limits_1sigma.append(0) xs_exp_limits_1sigma_up.append(0) xs_exp_limits_2sigma.append(0) xs_exp_limits_2sigma_up.append(0) continue log_file = open(limit_config.get_combine_log_path(args.analysis, args.model, mass, args.fit_function, args.method, systematics=(not args.noSyst), frozen_nps=args.freezeNuisances, fitTrigger=args.fitTrigger, correctTrigger=args.correctTrigger, useMCTrigger=args.useMCTrigger)) foundMethod = False middle = 0 # read the log file found_limit = {"obs":False, "exp":False, "exp+1":False, "exp+2":False, "exp-1":False, "exp-2":False} for line in log_file: if args.method == 'Asymptotic': if re.search("^Observed Limit: r", line): xs_obs_limits.append(float(line.split()[-1])/acceptance_times_efficiency.Eval(mass) * input_xs) found_limit["obs"] = True if mass == 325 and args.model == "ZPrime": print "[debug] ZPrime 325 GeV limit = {}".format(xs_obs_limits[-1]) print "[debug] \tA*e={}, input_xs={}".format(acceptance_times_efficiency.Eval(mass), input_xs) if re.search("^Expected 50.0%: r", line): middle = float(line.split()[-1]) found_limit["exp"] = True xs_exp_limits.append(middle/acceptance_times_efficiency.Eval(mass) * input_xs) if re.search("^Expected 16.0%: r", line): xs_exp_limits_1sigma.append((float(line.split()[-1]))/acceptance_times_efficiency.Eval(mass) * input_xs) found_limit["exp-1"] = True if re.search("^Expected 84.0%: r", line): xs_exp_limits_1sigma_up.append(float(line.split()[-1])/acceptance_times_efficiency.Eval(mass) * input_xs) found_limit["exp+1"] = True if re.search("^Expected 2.5%: r", line): xs_exp_limits_2sigma.append(float(line.split()[-1])/acceptance_times_efficiency.Eval(mass) * input_xs) found_limit["exp-2"] = True if re.search("^Expected 97.5%: r", line): xs_exp_limits_2sigma_up.append(float(line.split()[-1])/acceptance_times_efficiency.Eval(mass) * input_xs) found_limit["exp+2"] = True elif args.method == 'theta': if re.search('^# x; y; yerror', line): foundMethod = True if line.split()[0] == '0' and foundMethod: xs_obs_limits.append(float(line.split()[1])/acceptance_times_efficiency.Eval(mass) * input_xs) else: searchmethod = "Hybrid New" if re.search(' -- ' + searchmethod, line): foundMethod = True if re.search("^Limit: r", line) and foundMethod: xs_obs_limits.append(float(line.split()[3])/acceptance_times_efficiency.Eval(mass) * input_xs) found_limit["obs"] = True print "[debug] Found limit " + str(xs_obs_limits[-1]) if not found_limit["obs"]: xs_obs_limits.append(0) if not found_limit["exp"]: xs_exp_limits.append(0) if not found_limit["exp+1"]: xs_exp_limits_1sigma.append(0) if not found_limit["exp+2"]: xs_exp_limits_1sigma_up.append(0) if not found_limit["exp-1"]: xs_exp_limits_2sigma.append(0) if not found_limit["exp-2"]: xs_exp_limits_2sigma_up.append(0) if len(masses) != len(xs_obs_limits): print "** ERROR: ** Could not find observed limit for m =", int(mass), "GeV. Aborting." sys.exit(1) if args.method == 'Asymptotic' or args.method == 'HybridNewGrid': if len(masses) != len(xs_exp_limits): print "** ERROR: ** Could not find expected limit for m =", int(mass), "GeV. Aborting." print "masses = ", print masses print "xs_exp_limits = ", print xs_exp_limits sys.exit(1) if len(masses) != len(xs_exp_limits_1sigma): print "** ERROR: ** Could not find expected 1 sigma down limit for m =", int(mass), "GeV. Aborting." print "masses = ", print masses print "xs_exp_limits_1sigma = ", print xs_exp_limits_1sigma sys.exit(1) if len(masses) != len(xs_exp_limits_1sigma_up): print "** ERROR: ** Could not find expected 1 sigma up limit for m =", int(mass), "GeV. Aborting." print "masses = ", print masses print "xs_exp_limits_1sigma_up = ", print xs_exp_limits_1sigma_up sys.exit(1) if len(masses) != len(xs_exp_limits_2sigma): print "** ERROR: ** Could not find expected 2 sigma down limit for m =", int(mass), "GeV. Aborting." sys.exit(1) if len(masses) != len(xs_exp_limits_2sigma_up): print "** ERROR: ** Could not find expected 2 sigma up limit for m =", int(mass), "GeV. Aborting." sys.exit(1) if args.method == 'Asymptotic' or args.method == 'HybridNewGrid': # complete the expected limit arrays for i in range(0,len(masses)): masses_exp.append( masses[len(masses)-i-1] ) xs_exp_limits_1sigma.append( xs_exp_limits_1sigma_up[len(masses)-i-1] ) xs_exp_limits_2sigma.append( xs_exp_limits_2sigma_up[len(masses)-i-1] ) if args.printResults: print "masses =", masses.tolist() print "xs_obs_limits =", xs_obs_limits.tolist() print "xs_exp_limits =", xs_exp_limits.tolist() print "" print "masses_exp =", masses_exp.tolist() print "xs_exp_limits_1sigma =", xs_exp_limits_1sigma.tolist() print "xs_exp_limits_2sigma =", xs_exp_limits_2sigma.tolist() gROOT.SetBatch(kTRUE); gStyle.SetOptStat(0) gStyle.SetOptTitle(0) gStyle.SetTitleFont(42, "XYZ") gStyle.SetTitleSize(0.05, "XYZ") gStyle.SetLabelFont(42, "XYZ") gStyle.SetLabelSize(0.05, "XYZ") gStyle.SetCanvasBorderMode(0) gStyle.SetFrameBorderMode(0) gStyle.SetCanvasColor(kWhite) gStyle.SetPadTickX(1) gStyle.SetPadTickY(1) gStyle.SetPadLeftMargin(0.15) gStyle.SetPadRightMargin(0.05) gStyle.SetPadTopMargin(0.05) gStyle.SetPadBottomMargin(0.15) gROOT.ForceStyle() # theory curves: gg massesS8 = array('d', [1000.0,1100.0,1200.0,1300.0,1400.0,1500.0,1600.0,1700.0,1800.0,1900.0,2000.0,2100.0,2200.0,2300.0,2400.0,2500.0,2600.0,2700.0,2800.0,2900.0,3000.0,3100.0,3200.0,3300.0,3400.0,3500.0,3600.0,3700.0,3800.0,3900.0,4000.0,4100.0,4200.0,4300.0,4400.0,4500.0,4600.0,4700.0,4800.0,4900.0,5000.0,5100.0,5200.0,5300.0,5400.0,5500.0,5600.0,5700.0,5800.0,5900.0,6000.0]) xsS8 = array('d', [5.46E+02,3.12E+02,1.85E+02,1.12E+02,7.19E+01,4.59E+01,3.02E+01,2.01E+01,1.37E+01,9.46E+00,6.55E+00,4.64E+00,3.27E+00,2.36E+00,1.70E+00,1.24E+00,9.11E-01,6.69E-01,4.97E-01,3.71E-01,2.78E-01,2.07E-01,1.55E-01,1.19E-01,9.26E-02,7.08E-02,5.43E-02,4.15E-02,3.22E-02,2.50E-02,1.92E-02,1.51E-02,1.19E-02,9.25E-03,7.35E-03,5.86E-03,4.53E-03,3.66E-03,2.91E-03,2.33E-03,1.86E-03,1.45E-03,1.12E-03,8.75E-04,6.90E-04,5.55E-04,4.47E-04,3.63E-04,2.92E-04,2.37E-04,1.97E-04]) graph_xsS8 = TGraph(len(massesS8),massesS8,xsS8) graph_xsS8.SetLineWidth(3) graph_xsS8.SetLineStyle(8) graph_xsS8.SetLineColor(6) # theory curves: qg massesString = array('d', [1000.0,1100.0,1200.0,1300.0,1400.0,1500.0,1600.0,1700.0,1800.0,1900.0,2000.0,2100.0,2200.0,2300.0,2400.0,2500.0,2600.0,2700.0,2800.0,2900.0,3000.0,3100.0,3200.0,3300.0,3400.0,3500.0,3600.0,3700.0,3800.0,3900.0,4000.0,4100.0,4200.0,4300.0,4400.0,4500.0,4600.0,4700.0,4800.0,4900.0,5000.0,5100.0,5200.0,5300.0,5400.0,5500.0,5600.0,5700.0,5800.0,5900.0,6000.0,6100.0,6200.0,6300.0,6400.0,6500.0,6600.0,6700.0,6800.0,6900.0,7000.0,7100.0,7200.0,7300.0,7400.0,7500.0,7600.0,7700.0,7800.0,7900.0,8000.0,8100.0,8200.0,8300.0,8400.0,8500.0,8600.0,8700.0,8800.0,8900.0,9000.0,9100.,9200.,9300.,9400.,9500.,9600.,9700.,9800.,9900.,10000.]) xsString = array('d', [8316.184311558545,5312.93137758767,3435.0309937336524,2304.4139502741305,1569.8115447896687,1090.9516635659693,770.901859690924,551.9206062572061,399.69535383507633,293.77957451762086,218.15126842827823,162.87634729465125,123.17685479653694,93.63530805932386,71.53697229809124,55.37491301647483,42.75271508357369,33.36378355470234,26.06619302090876,20.311817606835643,16.1180931789545,12.768644973921226,10.142660425967444,8.057990848043234,6.400465846290908,5.115134438331436,4.132099789492928,3.3193854239538734,2.6581204529344302,2.157554604919995,1.7505176068913348,1.4049155245498584,1.140055677916783,0.9253251132104159,0.7522038169131606,0.6119747371392215,0.49612321727328523,0.40492020959456737,0.33091999402250655,0.27017917021492555,0.2201693919322846,0.17830700070267996,0.14564253802358157,0.11940534430331146,0.09694948234356839,0.0793065371847468,0.06446186373361917,0.05282660618352478, 0.0428516302310620888,0.0348997638039910363,0.0283334766442618227,0.0231416918363592127,0.0187417921340763783,0.0153501307395115115,0.0124396534127133717,0.0100542205744949455,0.0081744954858627415,0.0066338099362915941,0.0053365711503318145,0.00430912459914657443,0.00346381039244064343,0.00278602671711227174,0.00225154342228859257,0.0018082930150063248,0.00143929440338502119,0.0011581373956044489,0.00091869589873893118,0.00073410823691329855,0.00058669382997948734,0.0004661568745858897,0.000368716655469570365,0.000293168485206959169,0.000230224535021638668,0.000182317101888465142,0.000143263359883433282,0.000112630538527214965,0.000088189175598406759,0.000068708474367442343,0.000053931726669273556,0.0000416417855733682702,0.0000326529676755488658,0.0000254365480426201587,0.0000198410151166864761,0.0000154034425617473576,0.0000119095554601641413,9.2537574320108232e-6,7.2155417437856749e-6,5.6130924422251982e-6,4.36634755605624901e-6,3.39717456406994868e-6,2.6766018046173896e-6]) massesQstar = array('d', [1000.0,1100.0,1200.0,1300.0,1400.0,1500.0,1600.0,1700.0,1800.0,1900.0,2000.0,2100.0,2200.0,2300.0,2400.0,2500.0,2600.0,2700.0,2800.0,2900.0,3000.0,3100.0,3200.0,3300.0,3400.0,3500.0,3600.0,3700.0,3800.0,3900.0,4000.0,4100.0,4200.0,4300.0,4400.0,4500.0,4600.0,4700.0,4800.0,4900.0,5000.0,5100.0,5200.0,5300.0,5400.0,5500.0,5600.0,5700.0,5800.0,5900.0,6000.0,6100.0,6200.0,6300.0,6400.0,6500.0,6600.0,6700.0,6800.0,6900.0,7000.0,7100.0,7200.0,7300.0,7400.0,7500.0,7600.0,7700.0,7800.0,7900.0,8000.0,8100.0,8200.0,8300.0,8400.0,8500.0,8600.0,8700.0,8800.0,8900.0,9000.0]) xsQstar = array('d', [0.4101E+03,0.2620E+03,0.1721E+03,0.1157E+03,0.7934E+02,0.5540E+02,0.3928E+02,0.2823E+02,0.2054E+02,0.1510E+02,0.1121E+02,0.8390E+01,0.6328E+01,0.4807E+01,0.3674E+01,0.2824E+01,0.2182E+01,0.1694E+01,0.1320E+01,0.1033E+01,0.8116E+00,0.6395E+00,0.5054E+00,0.4006E+00,0.3182E+00,0.2534E+00,0.2022E+00,0.1616E+00,0.1294E+00,0.1038E+00,0.8333E-01,0.6700E-01,0.5392E-01,0.4344E-01,0.3503E-01,0.2827E-01,0.2283E-01,0.1844E-01,0.1490E-01,0.1205E-01,0.9743E-02,0.7880E-02,0.6373E-02,0.5155E-02,0.4169E-02,0.3371E-02,0.2725E-02,0.2202E-02,0.1779E-02,0.1437E-02,0.1159E-02,0.9353E-03,0.7541E-03,0.6076E-03,0.4891E-03,0.3935E-03,0.3164E-03,0.2541E-03,0.2039E-03,0.1635E-03,0.1310E-03,0.1049E-03,0.8385E-04,0.6699E-04,0.5347E-04,0.4264E-04,0.3397E-04,0.2704E-04,0.2151E-04,0.1709E-04,0.1357E-04,0.1077E-04,0.8544E-05,0.6773E-05,0.5367E-05,0.4251E-05,0.3367E-05,0.2666E-05,0.2112E-05,0.1673E-05,0.1326E-05]) graph_xsString = TGraph(len(massesString),massesString,xsString) graph_xsString.SetLineWidth(3) graph_xsString.SetLineStyle(8) graph_xsString.SetLineColor(9) graph_xsQstar = TGraph(len(massesQstar),massesQstar,xsQstar) graph_xsQstar.SetLineWidth(3) graph_xsQstar.SetLineStyle(2) graph_xsQstar.SetLineColor(1) # theory curves: qq massesTh = array('d', [1000.0,1100.0,1200.0,1300.0,1400.0,1500.0,1600.0,1700.0,1800.0,1900.0,2000.0,2100.0,2200.0,2300.0,2400.0,2500.0,2600.0,2700.0,2800.0,2900.0,3000.0,3100.0,3200.0,3300.0,3400.0,3500.0,3600.0,3700.0,3800.0,3900.0,4000.0,4100.0,4200.0,4300.0,4400.0,4500.0,4600.0,4700.0,4800.0,4900.0,5000.0,5100.0,5200.0,5300.0,5400.0,5500.0,5600.0,5700.0,5800.0,5900.0,6000.0,6100.0,6200.0,6300.0,6400.0,6500.0,6600.0,6700.0,6800.0,6900.0,7000.0,7100.0,7200.0,7300.0,7400.0,7500.0,7600.0,7700.0,7800.0,7900.0,8000.0,8100.0,8200.0,8300.0,8400.0,8500.0,8600.0,8700.0,8800.0,8900.0,9000.0]) xsAxi = array('d', [0.1849E+03,0.1236E+03,0.8473E+02,0.5937E+02,0.4235E+02,0.3069E+02,0.2257E+02,0.1680E+02,0.1263E+02,0.9577E+01,0.7317E+01,0.5641E+01,0.4374E+01,0.3411E+01,0.2672E+01,0.2103E+01,0.1658E+01,0.1312E+01,0.1041E+01,0.8284E+00,0.6610E+00,0.5294E+00,0.4250E+00,0.3417E+00,0.2752E+00,0.2220E+00,0.1792E+00,0.1449E+00,0.1172E+00,0.9487E-01,0.7686E-01,0.6219E-01,0.5033E-01,0.4074E-01,0.3298E-01,0.2671E-01,0.2165E-01,0.1755E-01,0.1422E-01,0.1152E-01,0.9322E-02,0.7539E-02,0.6092E-02,0.4917E-02,0.3965E-02,0.3193E-02,0.2568E-02,0.2062E-02,0.1653E-02,0.1323E-02,0.1057E-02,0.8442E-03,0.6728E-03,0.5349E-03,0.4242E-03,0.3357E-03,0.2644E-03,0.2077E-03,0.1627E-03,0.1271E-03,0.9891E-04,0.7686E-04,0.5951E-04,0.4592E-04,0.3530E-04,0.2704E-04,0.2059E-04,0.1562E-04,0.1180E-04,0.8882E-05,0.6657E-05,0.4968E-05,0.3693E-05,0.2734E-05,0.2016E-05,0.1481E-05,0.1084E-05,0.7903E-06,0.5744E-06,0.4160E-06,0.3007E-06]) xsDiquark = array('d', [0.5824E+02,0.4250E+02,0.3172E+02,0.2411E+02,0.1862E+02,0.1457E+02,0.1153E+02,0.9211E+01,0.7419E+01,0.6019E+01,0.4912E+01,0.4031E+01,0.3323E+01,0.2750E+01,0.2284E+01,0.1903E+01,0.1590E+01,0.1331E+01,0.1117E+01,0.9386E+00,0.7900E+00,0.6658E+00,0.5618E+00,0.4745E+00,0.4010E+00,0.3391E+00,0.2869E+00,0.2428E+00,0.2055E+00,0.1740E+00,0.1473E+00,0.1246E+00,0.1055E+00,0.8922E-01,0.7544E-01,0.6376E-01,0.5385E-01,0.4546E-01,0.3834E-01,0.3231E-01,0.2720E-01,0.2288E-01,0.1922E-01,0.1613E-01,0.1352E-01,0.1132E-01,0.9463E-02,0.7900E-02,0.6584E-02,0.5479E-02,0.4551E-02,0.3774E-02,0.3124E-02,0.2581E-02,0.2128E-02,0.1750E-02,0.1437E-02,0.1177E-02,0.9612E-03,0.7833E-03,0.6366E-03,0.5160E-03,0.4170E-03,0.3360E-03,0.2700E-03,0.2162E-03,0.1725E-03,0.1372E-03,0.1087E-03,0.8577E-04,0.6742E-04,0.5278E-04,0.4114E-04,0.3192E-04,0.2465E-04,0.1894E-04,0.1448E-04,0.1101E-04,0.8322E-05,0.6253E-05,0.4670E-05]) xsWprime = array('d', [0.8811E+01,0.6024E+01,0.4216E+01,0.3010E+01,0.2185E+01,0.1610E+01,0.1200E+01,0.9043E+00,0.6875E+00,0.5271E+00,0.4067E+00,0.3158E+00,0.2464E+00,0.1932E+00,0.1521E+00,0.1201E+00,0.9512E-01,0.7554E-01,0.6012E-01,0.4792E-01,0.3827E-01,0.3059E-01,0.2448E-01,0.1960E-01,0.1571E-01,0.1259E-01,0.1009E-01,0.8090E-02,0.6483E-02,0.5193E-02,0.4158E-02,0.3327E-02,0.2660E-02,0.2125E-02,0.1695E-02,0.1351E-02,0.1075E-02,0.8546E-03,0.6781E-03,0.5372E-03,0.4248E-03,0.3353E-03,0.2642E-03,0.2077E-03,0.1629E-03,0.1275E-03,0.9957E-04,0.7757E-04,0.6027E-04,0.4670E-04,0.3610E-04,0.2783E-04,0.2140E-04,0.1641E-04,0.1254E-04,0.9561E-05,0.7269E-05,0.5510E-05,0.4167E-05,0.3143E-05,0.2364E-05,0.1774E-05,0.1329E-05,0.9931E-06,0.7411E-06,0.5523E-06,0.4108E-06,0.3055E-06,0.2271E-06,0.1687E-06,0.1254E-06,0.9327E-07,0.6945E-07,0.5177E-07,0.3863E-07,0.2888E-07,0.2162E-07,0.1622E-07,0.1218E-07,0.9156E-08,0.6893E-08]) xsZprime = array('d', [0.5027E+01,0.3398E+01,0.2353E+01,0.1663E+01,0.1196E+01,0.8729E+00,0.6450E+00,0.4822E+00,0.3638E+00,0.2769E+00,0.2123E+00,0.1639E+00,0.1272E+00,0.9933E-01,0.7789E-01,0.6134E-01,0.4848E-01,0.3845E-01,0.3059E-01,0.2440E-01,0.1952E-01,0.1564E-01,0.1256E-01,0.1010E-01,0.8142E-02,0.6570E-02,0.5307E-02,0.4292E-02,0.3473E-02,0.2813E-02,0.2280E-02,0.1848E-02,0.1499E-02,0.1216E-02,0.9864E-03,0.8002E-03,0.6490E-03,0.5262E-03,0.4264E-03,0.3453E-03,0.2795E-03,0.2260E-03,0.1826E-03,0.1474E-03,0.1188E-03,0.9566E-04,0.7690E-04,0.6173E-04,0.4947E-04,0.3957E-04,0.3159E-04,0.2516E-04,0.2001E-04,0.1587E-04,0.1255E-04,0.9906E-05,0.7795E-05,0.6116E-05,0.4785E-05,0.3731E-05,0.2900E-05,0.2247E-05,0.1734E-05,0.1334E-05,0.1022E-05,0.7804E-06,0.5932E-06,0.4492E-06,0.3388E-06,0.2544E-06,0.1903E-06,0.1417E-06,0.1051E-06,0.7764E-07,0.5711E-07,0.4186E-07,0.3055E-07,0.2223E-07,0.1612E-07,0.1164E-07,0.8394E-08]) graph_xsAxi = TGraph(len(massesTh),massesTh,xsAxi) graph_xsAxi.SetLineWidth(3) graph_xsAxi.SetLineStyle(3) graph_xsAxi.SetLineColor(63) graph_xsDiquark = TGraph(len(massesTh),massesTh,xsDiquark) graph_xsDiquark.SetLineWidth(3) graph_xsDiquark.SetLineStyle(9) graph_xsDiquark.SetLineColor(8) graph_xsWprime = TGraph(len(massesTh),massesTh,xsWprime) graph_xsWprime.SetLineWidth(3) graph_xsWprime.SetLineStyle(7) graph_xsWprime.SetLineColor(46) graph_xsZprime = TGraph(len(massesTh),massesTh,xsZprime) graph_xsZprime.SetLineWidth(3) graph_xsZprime.SetLineStyle(5) graph_xsZprime.SetLineColor(38) # limits if args.method == "Asymptotic" or args.method == "HybridNewGrid": graph_exp_2sigma = ( TGraph(len(masses_exp),masses_exp,xs_exp_limits_2sigma) if len(xs_exp_limits_2sigma) > 0 else TGraph(0) ) graph_exp_2sigma.SetFillColor(kYellow) graph_exp_1sigma = ( TGraph(len(masses_exp),masses_exp,xs_exp_limits_1sigma) if len(xs_exp_limits_2sigma) > 0 else TGraph(0) ) graph_exp_1sigma.SetFillColor(kGreen+1) graph_exp = ( TGraph(len(masses),masses,xs_exp_limits) if len(xs_exp_limits_2sigma) > 0 else TGraph(0) ) #graph_exp.SetMarkerStyle(24) graph_exp.SetLineWidth(3) graph_exp.SetLineStyle(2) graph_exp.SetLineColor(4) graph_obs = TGraph(len(masses),masses,xs_obs_limits) graph_obs.SetMarkerStyle(20) graph_obs.SetLineWidth(3) #graph_obs.SetLineStyle(1) graph_obs.SetLineColor(1) c = TCanvas("c", "",800,800) c.cd() legend = TLegend(.58,.72,.90,.90) legend.SetBorderSize(0) legend.SetFillColor(0) legend.SetFillStyle(0) legend.SetTextFont(42) legend.SetTextSize(0.03) legend.SetHeader('95% CL upper limits') if len(xs_exp_limits_2sigma) > 0 and (args.method == "Asymptotic" or args.method == "HybridNewGrid"): frame = graph_exp_2sigma.GetHistogram().Clone() else: frame = graph_obs.GetHistogram().Clone() frame.Reset() frame.GetXaxis().SetTitle("Resonance mass [GeV]") frame.GetXaxis().SetTitleOffset(1.05) if args.timesAE: #if args.model == "ZPrime": # frame.GetYaxis().SetTitle("#sigma #times BR(c#bar{c},b#bar{b}) #times #it{A} #times #epsilon [pb]") #else: frame.GetYaxis().SetTitle("#sigma #times BR(b#bar{b}) #times #it{A} #times #epsilon [pb]") else: #if args.model == "ZPrime": # frame.GetYaxis().SetTitle("#sigma #times BR(c#bar{c},b#bar{b}) [pb]") #else: frame.GetYaxis().SetTitle("#sigma #times BR(b#bar{b}) [pb]") frame.GetYaxis().SetTitleOffset(1.2) if args.timesAE: frame.GetYaxis().SetRangeUser(1e-03,1e+01) else: frame.GetYaxis().SetRangeUser(1e-01,5e+02) frame.Draw("axis") if len(xs_exp_limits_2sigma) > 0 and (args.method == "Asymptotic" or args.method == "HybridNewGrid"): graph_exp_2sigma.GetXaxis().SetTitle("Resonance mass [GeV]") graph_exp_2sigma.GetXaxis().SetTitleOffset(1.1) graph_exp_2sigma.GetYaxis().SetTitle("#sigma #times #it{B} [pb]") graph_exp_2sigma.GetYaxis().SetTitleOffset(1.1) #graph_exp_2sigma.GetYaxis().SetRangeUser(1e-03,1e+02) #graph_exp_2sigma.GetXaxis().SetNdivisions(1005) graph_exp_2sigma.Draw("F") graph_exp_1sigma.Draw("F") graph_exp.Draw("L") graph_obs.Draw("LP") legend.AddEntry(graph_obs,"Observed","lp") legend.AddEntry(graph_exp,"Expected","lp") legend.AddEntry(graph_exp_1sigma,"#pm 1#sigma","F") legend.AddEntry(graph_exp_2sigma,"#pm 2#sigma","F") else: graph_obs.GetXaxis().SetTitle("Resonance mass [GeV]") graph_obs.GetYaxis().SetTitle("#sigma #times #it{B} [pb]") graph_obs.GetYaxis().SetTitleOffset(1.1) graph_obs.GetYaxis().SetRangeUser(1e-02,1e+03) #graph_obs.GetXaxis().SetNdivisions(1005) graph_obs.Draw("LP") legend.AddEntry(graph_obs,"Observed","lp") #if args.final_state == 'gg' : # graph_xsS8.Draw("L") #elif args.final_state == 'qg' : # graph_xsQstar.Draw("L") # graph_xsString.Draw("L") #elif args.final_state == 'qq' : # graph_xsAxi.Draw("L") # graph_xsDiquark.Draw("L") # graph_xsWprime.Draw("L") # graph_xsZprime.Draw("L") legend.Draw() #legendTh = TLegend(.60,.72,.90,.88) #legendTh.SetBorderSize(0) #legendTh.SetFillColor(0) #legendTh.SetFillStyle(0) #legendTh.SetTextFont(42) #legendTh.SetTextSize(0.03) #legendTh.AddEntry(graph_xsAxi,"Axigluon/coloron","l") #legendTh.AddEntry(graph_xsDiquark,"Scalar diquark","l") #legendTh.AddEntry(graph_xsWprime,"W' SSM","l") #legendTh.AddEntry(graph_xsZprime,"Z' SSM","l") #legendTh.Draw() # draw the lumi text on the canvas CMS_lumi.extraText = args.extraText CMS_lumi.lumi_sqrtS = args.lumi_sqrtS # used with iPeriod = 0 (free form) iPos = 11 iPeriod = 0 CMS_lumi.CMS_lumi(c, iPeriod, iPos) gPad.RedrawAxis() c.SetLogy() postfix = ( ('_' + args.postfix) if args.postfix != '' else '' ) if args.noSyst: postfix += "_noSyst" if args.freezeNuisances: postfix += "_" + args.freezeNuisances.replace(",", "_") if args.fitTrigger: postfix += "_fitTrigger" elif args.correctTrigger: postfix += "_correctTrigger" if args.useMCTrigger: postfix += "_useMCTrigger" fileName = limit_config.paths["limit_plots"] + '/xs_limit_%s_%s_%s_%s.%s'%(args.method,args.analysis, args.model + postfix, args.fit_function, args.fileFormat.lower()) if args.timesAE: fileName = fileName.replace("xs_limit", "xsAE_limit") c.SaveAs(fileName) print "Plot saved to '%s'"%(fileName) graph_obs.Print("all") if args.saveObjects: output_file = args.saveObjects if args.timesAE: output_file = output_file.replace(".root", "_timesAE.root") f = TFile(output_file, "RECREATE") if args.method == "Asymptotic" or args.method == "HybridNewGrid": graph_exp_2sigma.SetName("graph_exp_2sigma") graph_exp_2sigma.Write() graph_exp_1sigma.SetName("graph_exp_1sigma") graph_exp_1sigma.Write() graph_exp.SetName("graph_exp") graph_exp.Write() graph_obs.SetName("graph_obs") graph_obs.Write() f.Close()
def plotPart(events, inHisto, nBinsX, minX, maxX, nBinsY, minY, maxY, outfile, canvas, XaxisTitle="", plotTitle="", cut="", stats=0, logY=0): events.Draw( "{0}>>histoEleBad({1},{2},{3})".format("eleBad" + inHisto, nBinsX, minX, maxX), cut) histoEleBad = ROOT.gROOT.FindObject("histoEleBad") events.Draw( "{0}>>histoEleTruth({1},{2},{3})".format("eleTruth" + inHisto, nBinsX, minX, maxX), cut) histoEleTruth = ROOT.gROOT.FindObject("histoEleTruth") events.Draw( "{0}>>histoPosBad({1},{2},{3})".format("posBad" + inHisto, nBinsX, minX, maxX), cut) histoPosBad = ROOT.gROOT.FindObject("histoPosBad") events.Draw( "{0}>>histoPosTruth({1},{2},{3})".format("posTruth" + inHisto, nBinsX, minX, maxX), cut) histoPosTruth = ROOT.gROOT.FindObject("histoPosTruth") #histoEleBad = getHisto(events,"eleBad"+inHisto,nBinsX,minX,maxX,cut) #histoEleTruth = getHisto(events,"eleTruth"+inHisto,nBinsX,minX,maxX,cut) #histoPosBad = getHisto(events,"posBad"+inHisto,nBinsX,minX,maxX,cut) #histoPosTruth = getHisto(events,"posTruth"+inHisto,nBinsX,minX,maxX,cut) maximumEle = histoEleBad.GetMaximum() if (histoEleTruth.GetMaximum() > maximumEle): maximumEle = histoEleTruth.GetMaximum() maximumPos = histoPosBad.GetMaximum() if (histoPosTruth.GetMaximum() > maximumPos): maximumPos = histoPosTruth.GetMaximum() histoEleBad.SetTitle("Ele " + plotTitle) histoEleBad.GetXaxis().SetTitle(XaxisTitle) histoEleBad.SetStats(stats) histoEleBad.GetYaxis().SetRangeUser(0, 1.2 * maximumEle) histoEleBad.Draw() canvas.SetLogy(logY) histoEleTruth.SetLineColor(2) histoEleTruth.Draw("same") legend = TLegend(.68, .66, .92, .87) legend.SetBorderSize(0) legend.SetFillColor(0) legend.SetFillStyle(0) legend.SetTextFont(42) legend.SetTextSize(0.035) legend.AddEntry(histoEleBad, "Bad Fit", "LP") legend.AddEntry(histoEleTruth, "Truth Fit", "LP") legend.Draw() canvas.Print(outfile + ".pdf") histoPosBad.SetTitle("Pos " + plotTitle) histoPosBad.GetXaxis().SetTitle(XaxisTitle) histoPosBad.SetStats(stats) histoPosBad.GetYaxis().SetRangeUser(0, 1.2 * maximumPos) histoPosBad.Draw() canvas.SetLogy(logY) histoPosTruth.SetLineColor(2) histoPosTruth.Draw("same") legend.Draw() canvas.Print(outfile + ".pdf") saveTuplePlot2D(events, "eleBad" + inHisto, "BaduncVZ", nBinsX, minX, maxX, nBinsY, minY, maxY, outfile, canvas, "Bad Ele " + XaxisTitle, "Bad uncVZ [mm]", plotTitle, cut) saveTuplePlot2D(events, "eleBad" + inHisto, "TruthuncVZ", nBinsX, minX, maxX, nBinsY, minY, maxY, outfile, canvas, "Bad Ele " + XaxisTitle, "Truth uncVZ [mm]", plotTitle, cut) saveTuplePlot2D(events, "eleTruth" + inHisto, "BaduncVZ", nBinsX, minX, maxX, nBinsY, minY, maxY, outfile, canvas, "Truth Ele " + XaxisTitle, "Bad uncVZ [mm]", plotTitle, cut) saveTuplePlot2D(events, "eleTruth" + inHisto, "TruthuncVZ", nBinsX, minX, maxX, nBinsY, minY, maxY, outfile, canvas, "Truth Ele " + XaxisTitle, "Truth uncVZ [mm]", plotTitle, cut) saveTuplePlot2D(events, "posBad" + inHisto, "BaduncVZ", nBinsX, minX, maxX, nBinsY, minY, maxY, outfile, canvas, "Bad Pos " + XaxisTitle, "Bad uncVZ [mm]", plotTitle, cut) saveTuplePlot2D(events, "posBad" + inHisto, "TruthuncVZ", nBinsX, minX, maxX, nBinsY, minY, maxY, outfile, canvas, "Bad Pos " + XaxisTitle, "Truth uncVZ [mm]", plotTitle, cut) saveTuplePlot2D(events, "posTruth" + inHisto, "BaduncVZ", nBinsX, minX, maxX, nBinsY, minY, maxY, outfile, canvas, "Truth Pos " + XaxisTitle, "Bad uncVZ [mm]", plotTitle, cut) saveTuplePlot2D(events, "posTruth" + inHisto, "TruthuncVZ", nBinsX, minX, maxX, nBinsY, minY, maxY, outfile, canvas, "Truth Pos " + XaxisTitle, "Truth uncVZ [mm]", plotTitle, cut) del histoEleBad del histoEleTruth del histoPosBad del histoPosTruth del legend
h_GGH.SetMarkerColor(kRed) h_GGH.SetMarkerSize(1.2) #h_GGH.Scale(1./(h_GGH.Integral())) h_GGH.Draw("hist p") h_GGH_w.SetMarkerStyle(47) h_GGH_w.SetMarkerColor(kBlue) h_GGH_w.SetMarkerSize(1.2) #h_GGH_w.Scale(1./(h_GGH_w.Integral())) h_GGH_w.Draw("hist p SAME") leg1 = TLegend(.65, .75, .87, .85) leg1.SetBorderSize(0) leg1.SetFillColor(0) leg1.SetFillStyle(0) leg1.SetTextFont(42) leg1.SetTextSize(0.04) leg1.AddEntry(h_GGH, "ggH125", "p") leg1.AddEntry(h_GGH_w, "ggH125_pref", "p") leg1.Draw() c_GGH.Update() #lower plot pad c_GGH.cd() pad2_GGH = TPad("pad2_GGH", "pad2_GGH", 0, 0.05, 1, 0.3) pad2_GGH.SetGridy() pad2_GGH.Draw() pad2_GGH.cd() #pad2 becomes the current pad #define ratio plot
# BDT h1 = norm_hists(h_train[2]) h1.GetXaxis().SetTitle("BDT Regression m_{t#bar{t}} [GeV]") h1.GetYaxis().SetTitle("A.U.") h1.Draw() h2 = norm_hists(h_test[2]) h2.SetLineColor(2) h2.SetMarkerColor(2) h2.Draw("same") # Draw legends lIy = 0.92 lg = TLegend(0.60, lIy - 0.25, 0.85, lIy) lg.SetBorderSize(0) lg.SetFillStyle(0) lg.SetTextFont(42) lg.SetTextSize(0.04) lg.AddEntry(h1, "Training", "l") lg.AddEntry(h2, "Testing", "l") lg.Draw() myc.Draw() myc.SaveAs("TMVA_tutorial_reg_test_1.png") # BDTG h1 = norm_hists(h_train[3]) h1.GetXaxis().SetTitle("BDTG Regression m_{t#bar{t}} [GeV]") h1.GetYaxis().SetTitle("A.U.") h1.Draw() h2 = norm_hists(h_test[3]) h2.SetLineColor(2)
def plot(): myfile = TFile(args.inputFile) mytree = gDirectory.Get("physics") mytree_weight = mytree.GetWeight()/1e3 trig_dec = "( passHLT == 1 )" lep_tag_trigmatch = "( lep_tag_isTrigMatched[0] == 1 && ( ( lep_tag_flavour[0] == 11 && lep_tag_pt[0] > 25e3 ) || ( lep_tag_flavour[0] == 13 && lep_tag_pt[0] > 22e3 ) ) )" lep_probe_trigmatch = "( lep_probe_isTrigMatched[0] == 1 && ( ( lep_probe_flavour[0] == 11 && lep_probe_pt[0] > 25e3 ) || ( lep_probe_flavour[0] == 13 && lep_probe_pt[0] > 22e3 ) ) )" el_tag_eta = "( TMath::Abs(el_tag_eta[0]) < 1.37 )" nbjets = "( njets_mv2c20_Fix77 > 0 )" njets = "( njets > 0 && njets < 4 )" nleptons = "( nlep == 2 && ( lep_pt[0] > 20e3 && lep_pt[1] > 20e3 ) )" same_sign = "( isSS01 == 1 )" # veto charge flips # ch_flip_veto = "( 1 )" if args.doChFlipVeto: ch_flip_veto = "( lep_isChFlip[0] == 0 && lep_isChFlip[1] == 0 )" # require at least 1 !prompt lepton # non_prompt = "( ( lep_truthType[0] != 6 && lep_truthType[0] != 2 ) || ( lep_truthType[1] != 6 && lep_truthType[1] != 2 ) )" # require at least one T lepton in the event # is_tight_event = "1" #"( isNonTightEvent == 0 )" # require tag lepton to be T # tight_tag = "( lep_tag_isTightSelected[0] == 1 )" hist_list_probe_MUPROBEEVT = {} hist_list_tag_MUPROBEEVT = {} hist_list_probe_ELPROBEEVT = {} hist_list_tag_ELPROBEEVT = {} # ----------------------------------------------------- dirname = "OutputPlots_TRUTH" if args.outdirname: dirname += ( "_" + args.outdirname ) try: os.makedirs(dirname) except: pass # ----------------------------------------------------- # ---------------- # Muon probe # ---------------- sel_FAKE_MUPROBEEVT_T = None sel_FAKE_MUPROBEEVT_L = None # look only at OF region if args.channel == "OF": sel_FAKE_MUPROBEEVT_T = "(" + trig_dec + " && " + lep_tag_trigmatch + " && " + lep_probe_trigmatch + " && " + nleptons + " && " + same_sign + " && " + is_tight_event + " && " + tight_tag + " && " + "( (nmuon == 1 && nel == 1) && ( isProbeMuEvent == 1 ) && ( muon_probe_isTightSelected[0] == 1 ) )" + " && " + el_tag_eta + " && " + nbjets + " && " + njets + " && " + ch_flip_veto + " && " + non_prompt + ")" sel_FAKE_MUPROBEEVT_L = "(" + trig_dec + " && " + lep_tag_trigmatch + " && " + lep_probe_trigmatch + " && " + nleptons + " && " + same_sign + " && " + is_tight_event + " && " + tight_tag + " && " + "( (nmuon == 1 && nel == 1) && ( isProbeMuEvent == 1 ) && ( muon_probe_isTightSelected[0] == 0 ) )" + " && " + el_tag_eta + " && " + nbjets + " && " + njets + " && " + ch_flip_veto + " && " + non_prompt + ")" # look only at SF region elif args.channel == "SF": sel_FAKE_MUPROBEEVT_T = "(" + trig_dec + " && " + lep_tag_trigmatch + " && " + lep_probe_trigmatch + " && " + nleptons + " && " + same_sign + " && " + is_tight_event + " && " + tight_tag + " && " + "( ( nmuon == 2 ) && ( isProbeMuEvent == 1 ) && ( muon_probe_isTightSelected[0] == 1 ) )" + " && " + nbjets + " && " + njets + " && " + ch_flip_veto + " && " + non_prompt + ")" sel_FAKE_MUPROBEEVT_L = "(" + trig_dec + " && " + lep_tag_trigmatch + " && " + lep_probe_trigmatch + " && " + nleptons + " && " + same_sign + " && " + is_tight_event + " && " + tight_tag + " && " + "( ( nmuon == 2 ) && ( isProbeMuEvent == 1 ) && ( muon_probe_isTightSelected[0] == 0 ) )" + " && " + nbjets + " && " + njets + " && " + ch_flip_veto + " && " + non_prompt + ")" print "sel_FAKE_MUPROBEEVT_T: \n", sel_FAKE_MUPROBEEVT_T print "sel_FAKE_MUPROBEEVT_L: \n", sel_FAKE_MUPROBEEVT_L # histograms for probe passing T # h_probelep_FAKE_MUPROBEEVT_T_pt = TH1D("probelep_FAKE_MUPROBEEVT_T_pt", "probelep_FAKE_MUPROBEEVT_T_pt", 30, 20.0, 200.0) hist_list_probe_MUPROBEEVT[h_probelep_FAKE_MUPROBEEVT_T_pt] = ["T","pt"] h_probelep_FAKE_MUPROBEEVT_T_ptvarcone30_over_pt = TH1D("probelep_FAKE_MUPROBEEVT_T_ptvarcone30_over_pt", "probelep_FAKE_MUPROBEEVT_T_ptvarcone30_over_pt", 20, 0.0, 0.1) hist_list_probe_MUPROBEEVT[h_probelep_FAKE_MUPROBEEVT_T_ptvarcone30_over_pt] = ["T","ptvarcone30_over_pt"] # h_probelep_FAKE_MUPROBEEVT_T_ptvarcone20_over_pt = TH1D("probelep_FAKE_MUPROBEEVT_T_ptvarcone20_over_pt", "probelep_FAKE_MUPROBEEVT_T_ptvarcone20_over_pt", 20, 0.0, 0.1) # hist_list_probe_MUPROBEEVT[h_probelep_FAKE_MUPROBEEVT_T_ptvarcone20_over_pt] = ["T","ptvarcone20_over_pt"] h_probelep_FAKE_MUPROBEEVT_T_topoetcone20_over_pt = TH1D("probelep_FAKE_MUPROBEEVT_T_topoetcone20_over_pt", "probelep_FAKE_MUPROBEEVT_T_topoetcone20_over_pt", 70, -0.2, 0.5) hist_list_probe_MUPROBEEVT[h_probelep_FAKE_MUPROBEEVT_T_topoetcone20_over_pt] = ["T","topoetcone20_over_pt"] h_probelep_FAKE_MUPROBEEVT_T_pt.GetXaxis().SetTitle("pT [GeV]") h_probelep_FAKE_MUPROBEEVT_T_ptvarcone30_over_pt.GetXaxis().SetTitle("ptvarcone30/pT") # h_probelep_FAKE_MUPROBEEVT_T_ptvarcone20_over_pt.GetXaxis().SetTitle("ptvarcone20/pT") h_probelep_FAKE_MUPROBEEVT_T_topoetcone20_over_pt.GetXaxis().SetTitle("topoetcone20/pT") # histograms for probe passing L!T # h_probelep_FAKE_MUPROBEEVT_L_pt = TH1D("probelep_FAKE_MUPROBEEVT_L_pt", "probelep_FAKE_MUPROBEEVT_L_pt", 30, 20.0, 200.0) hist_list_probe_MUPROBEEVT[h_probelep_FAKE_MUPROBEEVT_L_pt] = ["L","pt"] h_probelep_FAKE_MUPROBEEVT_L_ptvarcone30_over_pt = TH1D("probelep_FAKE_MUPROBEEVT_L_ptvarcone30_over_pt", "probelep_FAKE_MUPROBEEVT_L_ptvarcone30_over_pt", 20, 0.0, 0.1) hist_list_probe_MUPROBEEVT[h_probelep_FAKE_MUPROBEEVT_L_ptvarcone30_over_pt] = ["L","ptvarcone30_over_pt"] # h_probelep_FAKE_MUPROBEEVT_L_ptvarcone20_over_pt = TH1D("probelep_FAKE_MUPROBEEVT_L_ptvarcone20_over_pt", "probelep_FAKE_MUPROBEEVT_L_ptvarcone20_over_pt", 20, 0.0, 0.1) # hist_list_probe_MUPROBEEVT[h_probelep_FAKE_MUPROBEEVT_L_ptvarcone20_over_pt] = ["L","ptvarcone20_over_pt"] h_probelep_FAKE_MUPROBEEVT_L_topoetcone20_over_pt = TH1D("probelep_FAKE_MUPROBEEVT_L_topoetcone20_over_pt", "probelep_FAKE_MUPROBEEVT_L_topoetcone20_over_pt", 70, -0.2, 0.5) hist_list_probe_MUPROBEEVT[h_probelep_FAKE_MUPROBEEVT_L_topoetcone20_over_pt] = ["L","topoetcone20_over_pt"] h_probelep_FAKE_MUPROBEEVT_L_pt.GetXaxis().SetTitle("pT [GeV]") h_probelep_FAKE_MUPROBEEVT_L_ptvarcone30_over_pt.GetXaxis().SetTitle("ptvarcone30/pT") # h_probelep_FAKE_MUPROBEEVT_L_ptvarcone20_over_pt.GetXaxis().SetTitle("ptvarcone20/pT") h_probelep_FAKE_MUPROBEEVT_L_topoetcone20_over_pt.GetXaxis().SetTitle("topoetcone20/pT") # histograms for tag (passing T: default) # h_taglep_FAKE_MUPROBEEVT_T_pt = TH1D("taglep_FAKE_MUPROBEEVT_T_pt", "taglep_FAKE_MUPROBEEVT_T_pt", 30, 20.0, 200.0) hist_list_tag_MUPROBEEVT[h_taglep_FAKE_MUPROBEEVT_T_pt] = ["T","pt"] h_taglep_FAKE_MUPROBEEVT_T_ptvarcone30_over_pt = TH1D("taglep_FAKE_MUPROBEEVT_T_ptvarcone30_over_pt", "taglep_FAKE_MUPROBEEVT_T_ptvarcone30_over_pt", 20, 0.0, 0.1) hist_list_tag_MUPROBEEVT[h_taglep_FAKE_MUPROBEEVT_T_ptvarcone30_over_pt] = ["T","ptvarcone30_over_pt"] h_taglep_FAKE_MUPROBEEVT_T_ptvarcone20_over_pt = TH1D("taglep_FAKE_MUPROBEEVT_T_ptvarcone20_over_pt", "taglep_FAKE_MUPROBEEVT_T_ptvarcone20_over_pt", 20, 0.0, 0.1) hist_list_tag_MUPROBEEVT[h_taglep_FAKE_MUPROBEEVT_T_ptvarcone20_over_pt] = ["T","ptvarcone20_over_pt"] h_taglep_FAKE_MUPROBEEVT_T_topoetcone20_over_pt = TH1D("taglep_FAKE_MUPROBEEVT_T_topoetcone20_over_pt", "taglep_FAKE_MUPROBEEVT_T_topoetcone20_over_pt", 70, -0.2, 0.5) hist_list_tag_MUPROBEEVT[h_taglep_FAKE_MUPROBEEVT_T_topoetcone20_over_pt] = ["T","topoetcone20_over_pt"] h_taglep_FAKE_MUPROBEEVT_T_pt.GetXaxis().SetTitle("pT [GeV]") h_taglep_FAKE_MUPROBEEVT_T_ptvarcone30_over_pt.GetXaxis().SetTitle("ptvarcone30/pT") h_taglep_FAKE_MUPROBEEVT_T_topoetcone20_over_pt.GetXaxis().SetTitle("topoetcone20/pT") mytree.Project("probelep_FAKE_MUPROBEEVT_T_pt", "muon_probe_pt[0]/1e3", "%s * (%s)" %(mytree_weight, sel_FAKE_MUPROBEEVT_T), "" ) mytree.Project("probelep_FAKE_MUPROBEEVT_L_pt", "muon_probe_pt[0]/1e3", "%s * (%s)" %(mytree_weight, sel_FAKE_MUPROBEEVT_L), "" ) mytree.Project("probelep_FAKE_MUPROBEEVT_T_ptvarcone30_over_pt", "muon_probe_ptvarcone30[0]/muon_probe_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_MUPROBEEVT_T), "" ) mytree.Project("probelep_FAKE_MUPROBEEVT_L_ptvarcone30_over_pt", "muon_probe_ptvarcone30[0]/muon_probe_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_MUPROBEEVT_L), "" ) # mytree.Project("probelep_FAKE_MUPROBEEVT_T_ptvarcone20_over_pt", "muon_probe_ptvarcone20[0]/muon_probe_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_MUPROBEEVT_T), "" ) # mytree.Project("probelep_FAKE_MUPROBEEVT_L_ptvarcone20_over_pt", "muon_probe_ptvarcone20[0]/muon_probe_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_MUPROBEEVT_L), "" ) mytree.Project("probelep_FAKE_MUPROBEEVT_T_topoetcone20_over_pt", "muon_probe_topoetcone20[0]/muon_probe_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_MUPROBEEVT_T), "" ) mytree.Project("probelep_FAKE_MUPROBEEVT_L_topoetcone20_over_pt", "muon_probe_topoetcone20[0]/muon_probe_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_MUPROBEEVT_L), "" ) if args.channel == "OF": # probe is muon, tag is electron # mytree.Project("taglep_FAKE_MUPROBEEVT_T_pt", "el_tag_pt[0]/1e3", "%s * (%s)" %(mytree_weight, sel_FAKE_MUPROBEEVT_T), "" ) mytree.Project("taglep_FAKE_MUPROBEEVT_T_ptvarcone30_over_pt", "el_tag_ptvarcone30[0]/el_tag_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_MUPROBEEVT_T), "" ) mytree.Project("taglep_FAKE_MUPROBEEVT_T_ptvarcone20_over_pt", "el_tag_ptvarcone20[0]/el_tag_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_MUPROBEEVT_T), "" ) mytree.Project("taglep_FAKE_MUPROBEEVT_T_topoetcone20_over_pt", "el_tag_topoetcone20[0]/el_tag_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_MUPROBEEVT_T), "" ) elif args.channel == "SF": # probe is muon, tag is muon # mytree.Project("taglep_FAKE_MUPROBEEVT_T_pt", "muon_tag_pt[0]/1e3", "%s * (%s)" %(mytree_weight, sel_FAKE_MUPROBEEVT_T), "" ) mytree.Project("taglep_FAKE_MUPROBEEVT_T_ptvarcone30_over_pt", "muon_tag_ptvarcone30[0]/muon_tag_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_MUPROBEEVT_T), "" ) # mytree.Project("taglep_FAKE_MUPROBEEVT_T_ptvarcone20_over_pt", "muon_tag_ptvarcone20[0]/muon_tag_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_MUPROBEEVT_T), "" ) mytree.Project("taglep_FAKE_MUPROBEEVT_T_topoetcone20_over_pt", "muon_tag_topoetcone20[0]/muon_tag_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_MUPROBEEVT_T), "" ) # Normalise to unity if args.doNorm: for hist in hist_list_probe_MUPROBEEVT.keys(): if hist.Integral() == 0: continue hist.Scale(1/hist.Integral()) hist.GetYaxis().SetTitle("Norm. events") #hist.GetYaxis().SetRangeUser(0,1) for hist in hist_list_tag_MUPROBEEVT.keys(): if hist.Integral() == 0: continue hist.Scale(1/hist.Integral()) hist.GetYaxis().SetTitle("Norm. events") #hist.GetYaxis().SetRangeUser(0,1) # now plot # print "\tLooking at events where the PROBE is: {0} and the channel is {1}\n".format("MUON", args.channel) for hist_tag in hist_list_tag_MUPROBEEVT.keys(): c = TCanvas("c","Temp",50,50,700,900) c.Divide(1,2) c.cd(1) legend_T = TLegend(0.6,0.8,0.8,0.85); # (x1,y1 (--> bottom left corner), x2, y2 (--> top right corner) ) legend_T.SetHeader("2 Lep SS Fake CR - T probe") legend_T.SetBorderSize(0) # no border legend_T.SetFillColor(0) # Legend background should be white legend_T.SetTextSize(0.04) # Increase entry font size! legend_T.SetTextFont(42) # Helvetica c.cd(2) legend_L = TLegend(0.6,0.8,0.8,0.85); # (x1,y1 (--> bottom left corner), x2, y2 (--> top right corner) ) legend_L.SetHeader("2 Lep SS Fake CR - L!T probe") legend_L.SetBorderSize(0) # no border legend_L.SetFillColor(0) # legend_L background should be white legend_L.SetTextSize(0.04) # Increase entry font size! legend_L.SetTextFont(42) # Helvetica var_tag = hist_list_tag_MUPROBEEVT[hist_tag][1] type_tag = hist_list_tag_MUPROBEEVT[hist_tag][0] hist_tag.SetLineColor(1) hist_tag.SetLineWidth(2) print "\tPlotting variable: {0}\n".format(var_tag) print "\ttag histogram name: {0}\n".format(hist_tag.GetName()) draw_pad1 = False draw_pad2 = False for hist_probe in hist_list_probe_MUPROBEEVT.keys(): print "\t\tprobe histogram name: {0}".format(hist_probe.GetName()) hist_probe.SetLineColor(2) hist_probe.SetLineWidth(2) var_probe = hist_list_probe_MUPROBEEVT[hist_probe][1] type_probe = hist_list_probe_MUPROBEEVT[hist_probe][0] # must be looking at the same variable! # if var_probe != var_tag: continue print "\t\tfound a match in variable! {0} = {1}\n".format(var_tag,var_probe) if type_probe == "T": print "\t\t probe is of type: {0}".format(type_probe) print "\n\t\t --> drawing: \t {0} \t {1} \t on pad(1) of the same canvas\n".format(hist_tag.GetName(),hist_probe.GetName()) c.cd(1) legend_T.AddEntry(None, "", "") legend_T.AddEntry(hist_tag, "REAL lepton", "L") legend_T.AddEntry(None, "", "") legend_T.AddEntry(hist_probe, "FAKE lepton", "L") hist_tag.Draw("HIST") hist_probe.Draw("HIST SAME") draw_pad1 = True elif type_probe == "L": print "\t\t probe is of type: {0}".format(type_probe) print "\n\t\t --> drawing: \t {0} \t {1} \t on pad(2) of the same canvas\n".format(hist_tag.GetName(),hist_probe.GetName()) c.cd(2) legend_L.AddEntry(None, "", "") legend_L.AddEntry(hist_tag, "REAL lepton", "L") legend_L.AddEntry(None, "", "") legend_L.AddEntry(hist_probe, "FAKE lepton", "L") hist_tag.Draw("HIST") hist_probe.Draw("HIST SAME") draw_pad2 = True if ( draw_pad1 and draw_pad2 ): c.cd(1) legend_T.Draw() c.cd(2) legend_L.Draw() plotname = dirname + "/FAKE_MUPROBEEVT_" + var_probe c.SaveAs(plotname+".png") del c # ----------------------------------------------------- # --------------------- # Electron probe # --------------------- sel_FAKE_ELPROBEEVT_T = None sel_FAKE_ELPROBEEVT_L = None # look only at OF region if args.channel == "OF": sel_FAKE_ELPROBEEVT_T = "(" + trig_dec + " && " + lep_tag_trigmatch + " && " + lep_probe_trigmatch + " && " + nleptons + " && " + same_sign + " && " + is_tight_event + " && " + tight_tag + " && " + "( (nmuon == 1 && nel == 1) && ( isProbeElEvent == 1 ) && ( el_probe_isTightSelected[0] == 1 ) )" + " && " + nbjets + " && " + njets + " && " + ch_flip_veto + " && " + non_prompt + ")" sel_FAKE_ELPROBEEVT_L = "(" + trig_dec + " && " + lep_tag_trigmatch + " && " + lep_probe_trigmatch + " && " + nleptons + " && " + same_sign + " && " + is_tight_event + " && " + tight_tag + " && " + "( (nmuon == 1 && nel == 1) && ( isProbeElEvent == 1 ) && ( el_probe_isTightSelected[0] == 0 ) )" + " && " + nbjets + " && " + njets + " && " + ch_flip_veto + " && " + non_prompt + ")" # look only at SF region elif args.channel == "SF": sel_FAKE_ELPROBEEVT_T = "(" + trig_dec + " && " + lep_tag_trigmatch + " && " + lep_probe_trigmatch + " && " + nleptons + " && " + same_sign + " && " + is_tight_event + " && " + tight_tag + " && " + "( ( nel == 2 ) && ( isProbeElEvent == 1 ) && ( el_probe_isTightSelected[0] == 1 ) )" + " && " + el_tag_eta + " && " + nbjets + " && " + njets + " && " + ch_flip_veto + " && " + non_prompt + ")" sel_FAKE_ELPROBEEVT_L = "(" + trig_dec + " && " + lep_tag_trigmatch + " && " + lep_probe_trigmatch + " && " + nleptons + " && " + same_sign + " && " + is_tight_event + " && " + tight_tag + " && " + "( ( nel == 2 ) && ( isProbeElEvent == 1 ) && ( el_probe_isTightSelected[0] == 0 ) )" + " && " + el_tag_eta + " && " + nbjets + " && " + njets + " && " + ch_flip_veto + " && " + non_prompt + ")" print "sel_FAKE_ELPROBEEVT_T: \n", sel_FAKE_ELPROBEEVT_T print "sel_FAKE_ELPROBEEVT_L: \n", sel_FAKE_ELPROBEEVT_L # histograms for probe passing T # h_probelep_FAKE_ELPROBEEVT_T_pt = TH1D("probelep_FAKE_ELPROBEEVT_T_pt", "probelep_FAKE_ELPROBEEVT_T_pt", 30, 20.0, 200.0) hist_list_probe_ELPROBEEVT[h_probelep_FAKE_ELPROBEEVT_T_pt] = ["T","pt"] # h_probelep_FAKE_ELPROBEEVT_T_ptvarcone30_over_pt = TH1D("probelep_FAKE_ELPROBEEVT_T_ptvarcone30_over_pt", "probelep_FAKE_ELPROBEEVT_T_ptvarcone30_over_pt", 20, 0.0, 0.1) # hist_list_probe_ELPROBEEVT[h_probelep_FAKE_ELPROBEEVT_T_ptvarcone30_over_pt] = ["T","ptvarcone30_over_pt"] h_probelep_FAKE_ELPROBEEVT_T_ptvarcone20_over_pt = TH1D("probelep_FAKE_ELPROBEEVT_T_ptvarcone20_over_pt", "probelep_FAKE_ELPROBEEVT_T_ptvarcone20_over_pt", 20, 0.0, 0.1) hist_list_probe_ELPROBEEVT[h_probelep_FAKE_ELPROBEEVT_T_ptvarcone20_over_pt] = ["T","ptvarcone20_over_pt"] h_probelep_FAKE_ELPROBEEVT_T_topoetcone20_over_pt = TH1D("probelep_FAKE_ELPROBEEVT_T_topoetcone20_over_pt", "probelep_FAKE_ELPROBEEVT_T_topoetcone20_over_pt", 70, -0.2, 0.5) hist_list_probe_ELPROBEEVT[h_probelep_FAKE_ELPROBEEVT_T_topoetcone20_over_pt] = ["T","topoetcone20_over_pt"] h_probelep_FAKE_ELPROBEEVT_T_pt.GetXaxis().SetTitle("pT [GeV]") # h_probelep_FAKE_ELPROBEEVT_T_ptvarcone30_over_pt.GetXaxis().SetTitle("ptvarcone30/pT") h_probelep_FAKE_ELPROBEEVT_T_ptvarcone20_over_pt.GetXaxis().SetTitle("ptvarcone20/pT") h_probelep_FAKE_ELPROBEEVT_T_topoetcone20_over_pt.GetXaxis().SetTitle("topoetcone20/pT") # histograms for probe passing L!T # h_probelep_FAKE_ELPROBEEVT_L_pt = TH1D("probelep_FAKE_ELPROBEEVT_L_pt", "probelep_FAKE_ELPROBEEVT_L_pt", 30, 20.0, 200.0) hist_list_probe_ELPROBEEVT[h_probelep_FAKE_ELPROBEEVT_L_pt] = ["L","pt"] # h_probelep_FAKE_ELPROBEEVT_L_ptvarcone30_over_pt = TH1D("probelep_FAKE_ELPROBEEVT_L_ptvarcone30_over_pt", "probelep_FAKE_ELPROBEEVT_L_ptvarcone30_over_pt", 20, 0.0, 0.1) # hist_list_probe_ELPROBEEVT[h_probelep_FAKE_ELPROBEEVT_L_ptvarcone30_over_pt] = ["L","ptvarcone30_over_pt"] h_probelep_FAKE_ELPROBEEVT_L_ptvarcone20_over_pt = TH1D("probelep_FAKE_ELPROBEEVT_L_ptvarcone20_over_pt", "probelep_FAKE_ELPROBEEVT_L_ptvarcone20_over_pt", 20, 0.0, 0.1) hist_list_probe_ELPROBEEVT[h_probelep_FAKE_ELPROBEEVT_L_ptvarcone20_over_pt] = ["L","ptvarcone20_over_pt"] h_probelep_FAKE_ELPROBEEVT_L_topoetcone20_over_pt = TH1D("probelep_FAKE_ELPROBEEVT_L_topoetcone20_over_pt", "probelep_FAKE_ELPROBEEVT_L_topoetcone20_over_pt", 70, -0.2, 0.5) hist_list_probe_ELPROBEEVT[h_probelep_FAKE_ELPROBEEVT_L_topoetcone20_over_pt] = ["L","topoetcone20_over_pt"] h_probelep_FAKE_ELPROBEEVT_L_pt.GetXaxis().SetTitle("pT [GeV]") # h_probelep_FAKE_ELPROBEEVT_L_ptvarcone30_over_pt.GetXaxis().SetTitle("ptvarcone30/pT") h_probelep_FAKE_ELPROBEEVT_L_ptvarcone20_over_pt.GetXaxis().SetTitle("ptvarcone20/pT") h_probelep_FAKE_ELPROBEEVT_L_topoetcone20_over_pt.GetXaxis().SetTitle("topoetcone20/pT") # histograms for tag (passing T: default) # h_taglep_FAKE_ELPROBEEVT_T_pt = TH1D("taglep_FAKE_ELPROBEEVT_T_pt", "taglep_FAKE_ELPROBEEVT_T_pt", 30, 20.0, 200.0) hist_list_tag_ELPROBEEVT[h_taglep_FAKE_ELPROBEEVT_T_pt] = ["T","pt"] h_taglep_FAKE_ELPROBEEVT_T_ptvarcone30_over_pt = TH1D("taglep_FAKE_ELPROBEEVT_T_ptvarcone30_over_pt", "taglep_FAKE_ELPROBEEVT_T_ptvarcone30_over_pt", 20, 0.0, 0.1) hist_list_tag_ELPROBEEVT[h_taglep_FAKE_ELPROBEEVT_T_ptvarcone30_over_pt] = ["T","ptvarcone30_over_pt"] h_taglep_FAKE_ELPROBEEVT_T_ptvarcone20_over_pt = TH1D("taglep_FAKE_ELPROBEEVT_T_ptvarcone20_over_pt", "taglep_FAKE_ELPROBEEVT_T_ptvarcone20_over_pt", 20, 0.0, 0.1) hist_list_tag_ELPROBEEVT[h_taglep_FAKE_ELPROBEEVT_T_ptvarcone20_over_pt] = ["T","ptvarcone20_over_pt"] h_taglep_FAKE_ELPROBEEVT_T_topoetcone20_over_pt = TH1D("taglep_FAKE_ELPROBEEVT_T_topoetcone20_over_pt", "taglep_FAKE_ELPROBEEVT_T_topoetcone20_over_pt", 70, -0.2, 0.5) hist_list_tag_ELPROBEEVT[h_taglep_FAKE_ELPROBEEVT_T_topoetcone20_over_pt] = ["T","topoetcone20_over_pt"] h_taglep_FAKE_ELPROBEEVT_T_pt.GetXaxis().SetTitle("pT [GeV]") h_taglep_FAKE_ELPROBEEVT_T_ptvarcone30_over_pt.GetXaxis().SetTitle("ptvarcone30/pT") h_taglep_FAKE_ELPROBEEVT_T_ptvarcone20_over_pt.GetXaxis().SetTitle("ptvarcone20/pT") h_taglep_FAKE_ELPROBEEVT_T_topoetcone20_over_pt.GetXaxis().SetTitle("topoetcone20/pT") mytree.Project("probelep_FAKE_ELPROBEEVT_T_pt", "el_probe_pt[0]/1e3", "%s * (%s)" %(mytree_weight, sel_FAKE_ELPROBEEVT_T), "" ) mytree.Project("probelep_FAKE_ELPROBEEVT_L_pt", "el_probe_pt[0]/1e3", "%s * (%s)" %(mytree_weight, sel_FAKE_ELPROBEEVT_L), "" ) # mytree.Project("probelep_FAKE_ELPROBEEVT_T_ptvarcone30_over_pt", "el_probe_ptvarcone30[0]/el_probe_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_ELPROBEEVT_T), "" ) # mytree.Project("probelep_FAKE_ELPROBEEVT_L_ptvarcone30_over_pt", "el_probe_ptvarcone30[0]/el_probe_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_ELPROBEEVT_L), "" ) mytree.Project("probelep_FAKE_ELPROBEEVT_T_ptvarcone20_over_pt", "el_probe_ptvarcone20[0]/el_probe_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_ELPROBEEVT_T), "" ) mytree.Project("probelep_FAKE_ELPROBEEVT_L_ptvarcone20_over_pt", "el_probe_ptvarcone20[0]/el_probe_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_ELPROBEEVT_L), "" ) mytree.Project("probelep_FAKE_ELPROBEEVT_T_topoetcone20_over_pt", "el_probe_topoetcone20[0]/el_probe_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_ELPROBEEVT_T), "" ) mytree.Project("probelep_FAKE_ELPROBEEVT_L_topoetcone20_over_pt", "el_probe_topoetcone20[0]/el_probe_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_ELPROBEEVT_L), "" ) if args.channel == "OF": # probe is electron, tag is muon # mytree.Project("taglep_FAKE_ELPROBEEVT_T_pt", "muon_tag_pt[0]/1e3", "%s * (%s)" %(mytree_weight, sel_FAKE_ELPROBEEVT_T), "" ) mytree.Project("taglep_FAKE_ELPROBEEVT_T_ptvarcone30_over_pt", "muon_tag_ptvarcone30[0]/muon_tag_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_ELPROBEEVT_T), "" ) mytree.Project("taglep_FAKE_ELPROBEEVT_T_ptvarcone20_over_pt", "muon_tag_ptvarcone20[0]/muon_tag_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_ELPROBEEVT_T), "" ) mytree.Project("taglep_FAKE_ELPROBEEVT_T_topoetcone20_over_pt", "muon_tag_topoetcone20[0]/muon_tag_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_ELPROBEEVT_T), "" ) elif args.channel == "SF": # probe is electron, tag is electron # mytree.Project("taglep_FAKE_ELPROBEEVT_T_pt", "el_tag_pt[0]/1e3", "%s * (%s)" %(mytree_weight, sel_FAKE_ELPROBEEVT_T), "" ) # mytree.Project("taglep_FAKE_ELPROBEEVT_T_ptvarcone30_over_pt", "el_tag_ptvarcone30[0]/el_tag_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_ELPROBEEVT_T), "" ) mytree.Project("taglep_FAKE_ELPROBEEVT_T_ptvarcone20_over_pt", "el_tag_ptvarcone20[0]/el_tag_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_ELPROBEEVT_T), "" ) mytree.Project("taglep_FAKE_ELPROBEEVT_T_topoetcone20_over_pt", "el_tag_topoetcone20[0]/el_tag_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_ELPROBEEVT_T), "" ) # Normalise to unity if args.doNorm: for hist in hist_list_probe_ELPROBEEVT.keys(): if hist.Integral() == 0: continue hist.Scale(1/hist.Integral()) hist.GetYaxis().SetTitle("Norm. events") #hist.GetYaxis().SetRangeUser(0,1) for hist in hist_list_tag_ELPROBEEVT.keys(): if hist.Integral() == 0: continue hist.Scale(1/hist.Integral()) hist.GetYaxis().SetTitle("Norm. events") #hist.GetYaxis().SetRangeUser(0,1) # now plot # print "\tLooking at events where the PROBE is: {0} and the channel is {1}\n".format("ELECTRON", args.channel) for hist_tag in hist_list_tag_ELPROBEEVT.keys(): c = TCanvas("c","Temp",50,50,700,900) c.Divide(1,2) c.cd(1) legend_T = TLegend(0.6,0.8,0.8,0.85); # (x1,y1 (--> bottom left corner), x2, y2 (--> top right corner) ) legend_T.SetHeader("2 Lep SS Fake CR - T probe") legend_T.SetBorderSize(0) # no border legend_T.SetFillColor(0) # Legend background should be white legend_T.SetTextSize(0.04) # Increase entry font size! legend_T.SetTextFont(42) # Helvetica c.cd(2) legend_L = TLegend(0.6,0.8,0.8,0.85); # (x1,y1 (--> bottom left corner), x2, y2 (--> top right corner) ) legend_L.SetHeader("2 Lep SS Fake CR - L!T probe") legend_L.SetBorderSize(0) # no border legend_L.SetFillColor(0) # legend_L background should be white legend_L.SetTextSize(0.04) # Increase entry font size! legend_L.SetTextFont(42) # Helvetica var_tag = hist_list_tag_ELPROBEEVT[hist_tag][1] type_tag = hist_list_tag_ELPROBEEVT[hist_tag][0] hist_tag.SetLineColor(1) hist_tag.SetLineWidth(2) print "\tPlotting variable: {0}\n".format(var_tag) print "\ttag histogram name: {0}\n".format(hist_tag.GetName()) draw_pad1 = False draw_pad2 = False for hist_probe in hist_list_probe_ELPROBEEVT.keys(): print "\t\tprobe histogram name: {0}".format(hist_probe.GetName()) hist_probe.SetLineColor(2) hist_probe.SetLineWidth(2) var_probe = hist_list_probe_ELPROBEEVT[hist_probe][1] type_probe = hist_list_probe_ELPROBEEVT[hist_probe][0] # must be looking at the same variable! # if var_probe != var_tag: continue print "\t\tfound a match in variable! {0} = {1}\n".format(var_tag,var_probe) if type_probe == "T": print "\t\t probe is of type: {0}".format(type_probe) print "\n\t\t --> drawing: \t {0} \t {1} \t on pad(1) of the same canvas\n".format(hist_tag.GetName(),hist_probe.GetName()) c.cd(1) legend_T.AddEntry(None, "", "") legend_T.AddEntry(hist_tag, "REAL lepton", "L") legend_T.AddEntry(None, "", "") legend_T.AddEntry(hist_probe, "FAKE lepton", "L") hist_tag.Draw("HIST") hist_probe.Draw("HIST SAME") draw_pad1 = True elif type_probe == "L": print "\t\t probe is of type: {0}".format(type_probe) print "\n\t\t --> drawing: \t {0} \t {1} \t on pad(2) of the same canvas\n".format(hist_tag.GetName(),hist_probe.GetName()) c.cd(2) legend_L.AddEntry(None, "", "") legend_L.AddEntry(hist_tag, "REAL lepton", "L") legend_L.AddEntry(None, "", "") legend_L.AddEntry(hist_probe, "FAKE lepton", "L") hist_tag.Draw("HIST") hist_probe.Draw("HIST SAME") draw_pad2 = True if ( draw_pad1 and draw_pad2 ): c.cd(1) legend_T.Draw() c.cd(2) legend_L.Draw() plotname = dirname + "/FAKE_ELPROBEEVT_" + var_probe c.SaveAs(plotname+".png") del c
def main(): import configurations as config import csv from ModelParser import ModelKey, GroupXsecLimit from ROOT import gStyle from Styles import marker gStyle.SetPadTopMargin(0.05) gStyle.SetPadRightMargin(0.05) from optparse import OptionParser parser = OptionParser() parser.add_option("-i", "--inputfile", dest="inputfile") (options, args) = parser.parse_args() models = [] with open(config.bh_list, 'rb') as f: reader = csv.reader(f) for r in reader: models.append(ModelKey(r[0])) from ROOT import TFile, TMultiGraph, TGraph, TLegend, TCanvas infile_xsec = TFile(config.bh_xsec, "READ") infile_CL = TFile(options.inputfile, "READ") from OptimizationTools import Bisection from Styles import formatXsecCL, formatExcludedMass store = [] mg = TMultiGraph() legend1 = TLegend(0.3241611,0.49,0.746644,0.69) legend1.SetHeader("Observed Cross Section Limits") legend1.SetTextSize(0.037) legend1.SetTextFont(42) legend1.SetFillColor(0) legend1.SetLineColor(0) legend2 = TLegend(0.3241611,0.68,0.746644,0.88) legend2.SetHeader("Theoretical Cross Section") legend2.SetTextSize(0.037) legend2.SetTextFont(42) legend2.SetFillColor(0) legend2.SetLineColor(0) legend3 = TLegend(0.3241611,0.8806993,0.886644,0.9273427) legend3.SetHeader("String Ball (BlackMax)") legend3.SetTextSize(0.037) legend3.SetTextFont(42) legend3.SetFillColor(0) legend3.SetLineColor(0) iColor = 0 iStyle = 2 #for key, group in ModelLimitGroup(models).items(): for key, group in GroupXsecLimit(models).items(): if not "SB" in key: continue name = ModelKey(key).name gXsec = infile_xsec.Get(key) formatXsecCL(gXsec, iColor, iStyle) mg.Add(gXsec, "c") legend2.AddEntry(gXsec, config.model_description[name], "l") gCL95 = infile_CL.Get("%s-CL95" % key) formatXsecCL(gCL95, iColor, 1) mg.Add(gCL95, "pl") legend1.AddEntry(gCL95, config.model_description[name], "pl") iColor += 1 iStyle += 2 c = TCanvas("SB_BM", "SB_BM", 500, 500) c.SetLogy() mg.Draw("A") mg.GetXaxis().SetTitle("M^{ min} (TeV)") mg.GetXaxis().SetRangeUser(3.9,7.1) mg.GetYaxis().SetRangeUser(1e-4,50) mg.GetYaxis().SetTitle("#sigma (pb)") mg.GetYaxis().SetTitleOffset(1.05) mg.GetYaxis().SetTitleSize(0.045) mg.GetYaxis().SetLabelSize(0.045) mg.GetXaxis().SetTitleSize(0.045) mg.GetXaxis().SetLabelSize(0.045) legend1.Draw("plain") legend2.Draw("plain") legend3.Draw("plain") c.Update() from ROOT import TPaveText cmslabel = TPaveText(0.45,0.96,0.60,0.99,"brNDC") cmslabel.AddText(config.cmsTitle) cmslabel.SetTextSize(0.041) #cmslabel.AddText(config.cmsSubtitle) cmslabel.SetFillColor(0) cmslabel.Draw("plain") raw_input("Press Enter to continue...")
#================================ yarray_4K_1_gr.GetYaxis().SetTitleSize(0.04) yarray_4K_1_gr.GetXaxis().SetTitleSize(0.04) yarray_4K_1_gr.GetXaxis().SetLabelSize(0.04) yarray_4K_1_gr.GetYaxis().SetLabelSize(0.04) yarray_4K_1_gr.GetXaxis().SetLabelFont(22) yarray_4K_1_gr.GetYaxis().SetLabelFont(22) yarray_4K_1_gr.GetXaxis().SetTitleColor(1) yarray_4K_1_gr.GetYaxis().SetTitleColor(1) leg1 = TLegend(0.5, 0.6, 0.7, 0.9) leg1.SetFillColor(0) leg1.SetFillStyle(0) leg1.SetTextSize(0.05) leg1.SetBorderSize(0) leg1.SetTextFont(22) leg1.AddEntry("", "GeIA group", "") leg1.AddEntry(yarray_4K_1_gr, "4K-1V/cm", "lp") leg1.AddEntry(yarray_4K_2_gr, "4K-10V/cm", "lp") leg1.AddEntry(yarray_4K_3_gr, "4K-80V/cm(Min)", "lp") leg1.AddEntry(yarray_77K_1_gr, "77K-20V/cm", "lp") leg1.AddEntry(yarray_77K_2_gr, "77K-200V/cm", "lp") leg1.AddEntry(yarray_77K_3_gr, "77K-500V/cm(Min)", "lp") c.Draw() yarray_4K_1_gr.Draw("ALP") yarray_4K_2_gr.Draw("LPsame") yarray_4K_3_gr.Draw("LPsame") yarray_77K_1_gr.Draw("LPsame") yarray_77K_2_gr.Draw("LPsame") yarray_77K_3_gr.Draw("LPsame")
def compareUpperLimits(labels, masses, filelabels, **kwargs): print color("compareUpperLimits()", color="magenta", prepend=">>>\n>>> ") # SIGNAL strength & mass extralabel = kwargs.get('extralabel', "") plotlabel = kwargs.get('plotlabel', "") # LOOP over LABELS for label in labels: print color("plotUpperLimits - %s" % (label), color="grey", prepend="\n>>> ") ymax = -99999 ymin = 99999 medians = [] for filelabel, title in filelabels: N = len(masses) median = TGraph(N) # median line median.SetTitle(title) medians.append(median) for i, mass in enumerate(masses): filename = getOutputFilename(label, mass, extralabel=filelabel) limits = getLimits(filename) median.SetPoint(i, mass, limits[2]) # median if limits[2] > ymax: ymax = limits[2] if limits[2] < ymin: ymin = limits[2] median0 = medians[0] doLog = ymin and ymax / ymin > 6 ymax = ymax * 1.40 xtitle = "m_{X} [GeV]" ytitle = "95% upper limit on #sigma#timesBR(X #rightarrow #tau#tau) [pb]" if "bbA" in filelabels[0][0]: xtitle = "m_{A} [GeV]" ytitle = "95% upper limit on #sigma#timesBR(A #rightarrow #tau#tau) [pb]" W, H = 800, 800 T, B = 0.10 * H, 0.16 * H L, R = 0.12 * W, 0.04 * W # MAIN plot canvas = TCanvas("canvas", "canvas", 100, 100, W, H) canvas.Divide(2) canvas.cd(1) gPad.SetPad("pad1", "pad1", 0, 0.37, 1, 1, 0, -1, 0) gPad.SetTopMargin(T / H) gPad.SetBottomMargin(0.01) gPad.SetLeftMargin(L / W) gPad.SetRightMargin(R / W) gPad.SetTickx(0) gPad.SetTicky(0) gPad.SetGrid() if doLog: ymin = 10**(floor(log(ymin, 10))) ymax = 10**(ceil(log(ymax, 10))) gPad.SetLogy() else: ymin *= 0 if ymin > 0 else 1.20 width = 0.25 height = 0.05 + len(medians) * 0.05 #x1 = 0.16; x2 = x1 + width # Left x2 = 0.70 x1 = x2 - width # Right x2 = x1 + width y1 = 0.86 y2 = y1 - height legend = TLegend(x1, y1, x2, y2) frame = gPad.DrawFrame(min(masses), ymin, max(masses), ymax) frame.GetYaxis().CenterTitle() frame.GetYaxis().SetTitleSize(0.055) frame.GetXaxis().SetTitleSize(0.058) frame.GetXaxis().SetLabelSize(0.050 * 0) frame.GetYaxis().SetLabelSize(0.053) frame.GetXaxis().SetLabelOffset(0.012) frame.GetXaxis().SetTitleOffset(1.02) frame.GetYaxis().SetTitleOffset(1.08) frame.GetXaxis().SetNdivisions(508) frame.GetYaxis().CenterTitle(True) frame.GetYaxis().SetTitle(ytitle) frame.GetXaxis().SetTitle(xtitle) option = 'L' for i, median in enumerate(medians): median.SetLineColor(colors[i % len(colors)]) median.SetLineStyle(styles[i % len(styles)]) median.SetLineWidth(2 if styles[i % len(styles)] != kDotted else 3) median.Draw('L') legend.AddEntry(median, median.GetTitle(), 'L') if i == 0: option += ' SAME' CMS_lumi.CMS_lumi(gPad, 13, 0) gPad.SetTicks(1, 1) gPad.Modified() frame.Draw('sameaxis') legend.SetFillStyle(0) legend.SetBorderSize(0) legend.SetTextSize(0.041) legend.SetTextFont(62) legend.SetHeader("%s" % (label_dict[label + extralabel])) legend.SetTextFont(42) legend.Draw() # RATIO plot canvas.cd(2) gPad.SetPad("pad2", "pad2", 0, 0, 1, 0.36, 0, -1, 0) gPad.SetTopMargin(0.05) gPad.SetBottomMargin(0.24) gPad.SetLeftMargin(L / W) gPad.SetRightMargin(R / W) frame_ratio = gPad.DrawFrame(min(masses), 0.36, max(masses), 1.20) frame_ratio.GetYaxis().CenterTitle() frame_ratio.GetYaxis().SetTitleSize(0.055 * 1.79) frame_ratio.GetXaxis().SetTitleSize(0.058 * 1.79) frame_ratio.GetXaxis().SetLabelSize(0.052 * 1.79) frame_ratio.GetYaxis().SetLabelSize(0.050 * 1.79) frame_ratio.GetXaxis().SetLabelOffset(0.012) frame_ratio.GetXaxis().SetTitleOffset(1.00) frame_ratio.GetYaxis().SetTitleOffset(0.63) frame_ratio.GetXaxis().SetNdivisions(508) frame_ratio.GetYaxis().CenterTitle(True) frame_ratio.GetYaxis().SetTitle("ratio") frame_ratio.GetXaxis().SetTitle(xtitle) frame_ratio.GetYaxis().SetNdivisions(5) option = 'L' ratios = [] for i, median in enumerate(medians): ratio = makeRatioTGraphs(median, median0) ratio.SetLineColor(median.GetLineColor()) ratio.SetLineStyle(median.GetLineStyle()) ratio.SetLineWidth(median.GetLineWidth()) ratio.Draw('L') ratios.append(ratio) if i == 1: option += ' SAME' gPad.SetTicks(1, 1) gPad.Modified() frame_ratio.Draw('sameaxis') print " " canvas.SaveAs("%s/upperLimit-%s%s_compare.png" % (PLOTS_DIR, label, plotlabel)) canvas.SaveAs("%s/upperLimit-%s%s_compare.pdf" % (PLOTS_DIR, label, plotlabel)) canvas.Close()
ratio_nominal_eleP = ratio(nominal_truth_h, nominal_eleP) ratio_nominal_iso = ratio(nominal_truth_h, nominal_Iso) ratio_nominal_matchChi2 = ratio(nominal_truth_h, nominal_MatchChi2) ratio_nominal_oppo = ratio(nominal_truth_h, nominal_Oppo) ratio_nominal_posD0 = ratio(nominal_truth_h, nominal_PosD0) ratio_nominal_trkChi2 = ratio(nominal_truth_h, nominal_TrkChi2) ratio_nominal_uncP = ratio(nominal_truth_h, nominal_uncP) ratio_nominal_L1L1 = ratio(nominal_truth_h, nominal_L1L1) ratio_nominal_L1L2 = ratio(nominal_truth_h, nominal_L1L2) ratio_nominal_L2L2 = ratio(nominal_truth_h, nominal_L2L2) legend = TLegend(.68, .66, .92, .87) legend.SetBorderSize(0) legend.SetFillColor(0) legend.SetFillStyle(0) legend.SetTextFont(42) legend.SetTextSize(0.035) legend.AddEntry(ratio_L0_assym, "L0", "LP") legend.AddEntry(ratio_nominal_assym, "nominal", "LP") c.Print(outfile + ".pdf[") def plot(histo1, histo2, outfile, legend): histo1.Draw("") histo1.SetTitle(str(histo1)) histo2.Draw("same") histo2.SetLineColor(1) legend.Draw("same") c.Print(outfile + ".pdf", "Title:plot")
def plotUpperLimits(labels, values): # see CMS plot guidelines: https://ghm.web.cern.ch/ghm/plots/ N = len(labels) yellow = TGraph(2 * N) # yellow band green = TGraph(2 * N) # green band median = TGraph(N) # median line up2s = [] for i in range(N): # file_name = "higgsCombine"+labels[i]+"AsymptoticLimits.mH125.root" file_name = "higgsCombine.AsymptoticLimits.mH125." + labels[i] + ".root" limit = getLimits(file_name) # print'limit = ',limit # print'values[i] = ',values[i] up2s.append(limit[4]) yellow.SetPoint(i, values[i], limit[4]) # + 2 sigma green.SetPoint(i, values[i], limit[3]) # + 1 sigma median.SetPoint(i, values[i], limit[2]) # median green.SetPoint(2 * N - 1 - i, values[i], limit[1]) # - 1 sigma yellow.SetPoint(2 * N - 1 - i, values[i], limit[0]) # - 2 sigma W = 800 H = 600 T = 0.08 * H B = 0.12 * H L = 0.12 * W R = 0.04 * W c = TCanvas("c", "c", 100, 100, W, H) c.SetFillColor(0) c.SetBorderMode(0) c.SetFrameFillStyle(0) c.SetFrameBorderMode(0) c.SetLeftMargin(L / W) c.SetRightMargin(R / W) c.SetTopMargin(T / H) c.SetBottomMargin(B / H) c.SetTickx(0) c.SetTicky(0) c.SetGrid() # c.SetLogy() # gPad.SetLogy() c.cd() # ROOT.gPad.SetLogy() # c.SetLogy() frame = c.DrawFrame(1.4, 0.001, 4.1, 10) frame.GetYaxis().CenterTitle() frame.GetYaxis().SetTitleSize(0.05) frame.GetXaxis().SetTitleSize(0.05) frame.GetXaxis().SetLabelSize(0.04) frame.GetYaxis().SetLabelSize(0.04) frame.GetYaxis().SetTitleOffset(0.9) frame.GetXaxis().SetNdivisions(508) frame.GetYaxis().CenterTitle(True) # frame.GetYaxis().SetTitle("95% upper limit on #sigma / #sigma_{SM}") if (args.atlas_compare): frame.GetYaxis().SetTitle( "95% CL limits on #sigma(gg#rightarrow X)#times B(X#rightarrow HH) [pb]" ) elif (args.CMS_compare): frame.GetYaxis().SetTitle( "95% CL limit on #sigma(gg#rightarrow X#rightarrow HH) (fb)") # frame.GetYaxis().SetTitle("95% upper limit on #sigma #times BR / (#sigma #times BR)_{SM}") # frame.GetXaxis().SetTitle("background systematic uncertainty [%]") #if(args.SM_Radion): frame.GetXaxis.SetTitle("Standard Model") #else: frame.GetXaxis().SetTitle("Radion Mass (GeV)") # frame.SetMinimum(0) # frame.SetMinimum(1) # need Minimum > 0 for log scale frame.SetMinimum(1.000001) # need Minimum > 0 for log scale # frame.SetMaximum(max(up2s)*1.05) # frame.SetMaximum(max(up2s)*2) # frame.SetMaximum(1000.) if (args.atlas_compare): frame.SetMaximum(7 * 1e2) # ATLAS elif (args.CMS_compare): frame.SetMaximum(8 * 1e4) # CMS HH #frame.GetXaxis().SetLimits(min(values),max(values)) # frame.SetLogy() frame.GetXaxis().SetLimits(min(values) - 10, max(values) + 10) yellow.SetFillColor(ROOT.kOrange) yellow.SetLineColor(ROOT.kOrange) yellow.SetFillStyle(1001) yellow.Draw('F') green.SetFillColor(ROOT.kGreen + 1) green.SetLineColor(ROOT.kGreen + 1) green.SetFillStyle(1001) green.Draw('Fsame') median.SetLineColor(1) median.SetLineWidth(2) median.SetLineStyle(2) median.Draw('Lsame') CMS_lumi.CMS_lumi(c, 4, 11) ROOT.gPad.SetTicks(1, 1) frame.Draw('sameaxis') # yboost = 0.075 yboost = -0.2 x1 = 0.15 x2 = x1 + 0.24 y2 = 0.76 + yboost y1 = 0.60 + yboost legend = TLegend(x1, y1, x2, y2) legend.SetFillStyle(0) legend.SetBorderSize(0) legend.SetTextSize(0.041) legend.SetTextFont(42) legend.AddEntry(median, "AsymptoticLimits CL_{s} expected", 'L') legend.AddEntry(green, "#pm 1 std. deviation", 'f') # legend.AddEntry(green, "AsymptoticLimits CL_{s} #pm 1 std. deviation",'f') legend.AddEntry(yellow, "#pm 2 std. deviation", 'f') # legend.AddEntry("","STAT Only","") # legend.AddEntry(green, "AsymptoticLimits CL_{s} #pm 2 std. deviation",'f') legend.Draw() label = TLatex() label.SetNDC() label.SetTextAngle(0) label.SetTextColor(kBlack) label.SetTextFont(42) label.SetTextSize(0.045) label.SetLineWidth(2) label.DrawLatex(0.7, 0.7 + yboost, "STAT only") print " " # c.SaveAs("UpperLimit.png") outFile = '' if (args.CMS_compare): outFile += "CMS_Compare_" if (args.atlas_compare): outFile += "atlas_Compare_" if args.SM_Radion: outFile += "SM_" c.SaveAs(outFile + "UpperLimit.pdf") c.SaveAs(outFile + "UpperLimit.C") c.Close()
def plotDataMC(args, plot_mu, plot_el): hCanvas = TCanvas("hCanvas", "Distribution", 800, 800) if args.ratio: plotPad = ROOT.TPad("plotPad", "plotPad", 0, 0.5, 1, 1) ratioPad = ROOT.TPad("ratioPad", "ratioPad", 0, 0., 1, 0.5) setTDRStyle() plotPad.UseCurrentStyle() ratioPad.UseCurrentStyle() plotPad.Draw() ratioPad.Draw() plotPad.cd() else: plotPad = ROOT.TPad("plotPad", "plotPad", 0, 0, 1, 1) setTDRStyle() plotPad.UseCurrentStyle() plotPad.Draw() plotPad.cd() # Data load processes colors = createMyColors() if args.use2016: data_mu = Process(Data2016, normalized=True) data_el = Process(Data2016, normalized=True) elif args.use2018: data_mu = Process(Data2018, normalized=True) data_el = Process(Data2018, normalized=True) elif args.useall: data_all = [ Process(Data2016, normalized=True), Process(Data, normalized=True), Process(Data2018, normalized=True) ] else: data_mu = Process(Data, normalized=True) data_el = Process(Data, normalized=True) eventCounts_mu = totalNumberOfGeneratedEvents(path, plot_mu["default"].muon) eventCounts_el = totalNumberOfGeneratedEvents(path, plot_el["default"].muon) negWeights_mu = negWeightFractions(path, plot_mu["default"].muon) negWeights_el = negWeightFractions(path, plot_el["default"].muon) # Background load processes backgrounds = copy(args.backgrounds) if plot_mu["default"].useJets: if "Wjets" in backgrounds: backgrounds.remove("Wjets") backgrounds.insert(0, "Jets") processes_mu = [] processes_el = [] processes_mu2016 = [] processes_mu2017 = [] processes_mu2018 = [] processes_el2016 = [] processes_el2017 = [] processes_el2018 = [] for background in backgrounds: if args.use2016: if background == "Jets": processes_mu.append( Process(getattr(Backgrounds2016, background), eventCounts_mu, negWeights_mu, normalized=True)) processes_el.append( Process(getattr(Backgrounds2016, background), eventCounts_el, negWeights_el, normalized=True)) else: processes_mu.append( Process(getattr(Backgrounds2016, background), eventCounts_mu, negWeights_mu)) if background == "Other": processes_el.append( Process(getattr(Backgrounds2016, "OtherEle"), eventCounts_el, negWeights_el)) else: processes_el.append( Process(getattr(Backgrounds2016, background), eventCounts_el, negWeights_el)) elif args.use2018: if background == "Jets": processes_mu.append( Process(getattr(Backgrounds2018, background), eventCounts_mu, negWeights_mu, normalized=True)) processes_el.append( Process(getattr(Backgrounds2018, background), eventCounts_el, negWeights_el, normalized=True)) else: processes_mu.append( Process(getattr(Backgrounds2018, background), eventCounts_mu, negWeights_mu)) processes_el.append( Process(getattr(Backgrounds2018, background), eventCounts_el, negWeights_el)) elif args.useall: if background == "Jets": processes_mu2016.append( Process(getattr(Backgrounds2016, background), eventCounts_mu, negWeights_mu, normalized=True)) processes_el2016.append( Process(getattr(Backgrounds2016, background), eventCounts_el, negWeights_el, normalized=True)) processes_mu2017.append( Process(getattr(Backgrounds, background), eventCounts_mu, negWeights_mu, normalized=True)) processes_el2017.append( Process(getattr(Backgrounds, background), eventCounts_el, negWeights_el, normalized=True)) processes_mu2018.append( Process(getattr(Backgrounds2018, background), eventCounts_mu, negWeights_mu, normalized=True)) processes_el2018.append( Process(getattr(Backgrounds2018, background), eventCounts_el, negWeights_el, normalized=True)) processes_mu = [ processes_mu2016, processes_mu2017, processes_mu2018 ] processes_el = [ processes_mu2016, processes_mu2017, processes_mu2018 ] else: processes_mu2016.append( Process(getattr(Backgrounds2016, background), eventCounts_mu, negWeights_mu)) processes_el2016.append( Process(getattr(Backgrounds2016, background), eventCounts_el, negWeights_el)) processes_mu2017.append( Process(getattr(Backgrounds, background), eventCounts_mu, negWeights_mu)) processes_el2017.append( Process(getattr(Backgrounds, background), eventCounts_el, negWeights_el)) processes_mu2018.append( Process(getattr(Backgrounds2018, background), eventCounts_mu, negWeights_mu)) processes_el2018.append( Process(getattr(Backgrounds2018, background), eventCounts_el, negWeights_el)) processes_mu = [ processes_mu2016, processes_mu2017, processes_mu2018 ] processes_el = [ processes_mu2016, processes_mu2017, processes_mu2018 ] else: if background == "Jets": processes_mu.append( Process(getattr(Backgrounds, background), eventCounts_mu, negWeights_mu, normalized=True)) processes_el.append( Process(getattr(Backgrounds, background), eventCounts_el, negWeights_el, normalized=True)) else: processes_mu.append( Process(getattr(Backgrounds, background), eventCounts_mu, negWeights_mu)) processes_el.append( Process(getattr(Backgrounds, background), eventCounts_el, negWeights_el)) legend = TLegend(0.55, 0.75, 0.925, 0.925) legend.SetFillStyle(0) legend.SetBorderSize(0) legend.SetTextFont(42) latex = ROOT.TLatex() latex.SetTextFont(42) latex.SetTextAlign(31) latex.SetTextSize(0.04) latex.SetNDC(True) latexCMS = ROOT.TLatex() latexCMS.SetTextFont(61) latexCMS.SetTextSize(0.06) latexCMS.SetNDC(True) latexCMSExtra = ROOT.TLatex() latexCMSExtra.SetTextFont(52) latexCMSExtra.SetTextSize(0.045) latexCMSExtra.SetNDC(True) legendHists = [] # Modify legend information legendHistData_mu = ROOT.TH1F() legendHistData_el = ROOT.TH1F() dy_mu = ROOT.TH1F() dy_el = ROOT.TH1F() if args.data: legendHistData_mu.SetMarkerColor(ROOT.kViolet) legendHistData_el.SetMarkerColor(ROOT.kOrange) dy_mu.SetLineColor(ROOT.kBlue - 3) dy_el.SetLineColor(ROOT.kRed - 3) legend.AddEntry(legendHistData_mu, "Data #rightarrow #mu^{+}#mu^{-}", "pe") legend.AddEntry(legendHistData_el, "Data #rightarrow e^{+}e^{-}", "pe") legend.AddEntry(dy_mu, "MC Inclusive #rightarrow #mu^{+}#mu^{-}", "l") legend.AddEntry(dy_el, "MC Inclusive #rightarrow e^{+}e^{-}", "l") if args.useall: for i in range(3): for process in reversed(processes_mu[i]): if not plot_mu[ "default"].muon and "#mu^{+}#mu^{-}" in process.label: process.label = process.label.replace( "#mu^{+}#mu^{-}", "e^{+}e^{-}") process.theColor = ROOT.kBlue process.theLineColor = ROOT.kBlue temphist = ROOT.TH1F() temphist.SetFillColor(process.theColor) for process in reversed(processes_el[i]): if not plot_el[ "default"].muon and "#mu^{+}#mu^{-}" in process.label: process.label = process.label.replace( "#mu^{+}#mu^{-}", "e^{+}e^{-}") process.theColor = ROOT.kRed process.theLineColor = ROOT.kRed temphist = ROOT.TH1F() temphist.SetFillColor(process.theColor) else: for process in reversed(processes_mu): if not plot_mu[ "default"].muon and "#mu^{+}#mu^{-}" in process.label: process.label = process.label.replace("#mu^{+}#mu^{-}", "e^{+}e^{-}") process.theColor = ROOT.kBlue process.theLineColor = ROOT.kBlue temphist = ROOT.TH1F() temphist.SetFillColor(process.theColor) for process in reversed(processes_el): if not plot_el[ "default"].muon and "#mu^{+}#mu^{-}" in process.label: process.label = process.label.replace("#mu^{+}#mu^{-}", "e^{+}e^{-}") process.theColor = ROOT.kRed process.theLineColor = ROOT.kRed temphist = ROOT.TH1F() temphist.SetFillColor(process.theColor) # Modify plot pad information nEvents = -1 ROOT.gStyle.SetOptStat(0) intlumi = ROOT.TLatex() intlumi.SetTextAlign(12) intlumi.SetTextSize(0.045) intlumi.SetNDC(True) intlumi2 = ROOT.TLatex() intlumi2.SetTextAlign(12) intlumi2.SetTextSize(0.07) intlumi2.SetNDC(True) scalelabel = ROOT.TLatex() scalelabel.SetTextAlign(12) scalelabel.SetTextSize(0.03) scalelabel.SetNDC(True) metDiffLabel = ROOT.TLatex() metDiffLabel.SetTextAlign(12) metDiffLabel.SetTextSize(0.03) metDiffLabel.SetNDC(True) chi2Label = ROOT.TLatex() chi2Label.SetTextAlign(12) chi2Label.SetTextSize(0.03) chi2Label.SetNDC(True) hCanvas.SetLogy() # Luminosity information plotPad.cd() plotPad.SetLogy(0) logScale = plot_mu["default"].log if logScale == True: plotPad.SetLogy() if args.use2016: lumi_el = 35.9 * 1000 lumi_mu = 36.3 * 1000 elif args.use2018: lumi_el = 59.97 * 1000 lumi_mu = 61.608 * 1000 elif args.useall: lumi_el = [35.9 * 1000, 41.529 * 1000, 59.97 * 1000] lumi_mu = [36.3 * 1000, 42.135 * 1000, 61.608 * 1000] else: lumi_el = 41.529 * 1000 lumi_mu = 42.135 * 1000 if args.use2016: zScaleFac_mu = zScale2016["muons"] if "BBBE" in plot_el["default"].fileName: zScaleFac_el = zScale2016["electrons"][0] elif "BB" in plot_el["default"].fileName: zScaleFac_el = zScale2016["electrons"][1] elif "BE" in plot_el["default"].fileName: zScaleFac_el = zScale2016["electrons"][2] else: zScaleFac_el = zScale2016["electrons"][0] elif args.use2018: zScaleFac_mu = zScale2018["muons"] if "BBBE" in plot_el["default"].fileName: zScaleFac_el = zScale2018["electrons"][0] elif "BB" in plot_el["default"].fileName: zScaleFac_el = zScale2018["electrons"][1] elif "BE" in plot_el["default"].fileName: zScaleFac_el = zScale2018["electrons"][2] else: zScaleFac_el = zScale2018["electrons"][0] elif args.useall: zScaleFac_mu = [ zScale2016["muons"], zScale["muons"], zScale2018["muons"] ] if "BBBE" in plot_el["default"].fileName: zScaleFac_el = [ zScale2016["electrons"][0], zScale["electrons"][0], zScale2018["electrons"][0] ] elif "BB" in plot_el["default"].fileName: zScaleFac_el = [ zScale2016["electrons"][1], zScale["electrons"][1], zScale2018["electrons"][1] ] elif "BE" in plot_el["default"].fileName: zScaleFac_el = [ zScale2016["electrons"][2], zScale["electrons"][2], zScale2018["electrons"][2] ] else: zScaleFac_el = [ zScale2016["electrons"][0], zScale["electrons"][0], zScale2018["electrons"][0] ] else: zScaleFac_mu = zScale["muons"] if "BBBE" in plot_el["default"].fileName: zScaleFac_el = zScale["electrons"][0] elif "BB" in plot_el["default"].fileName: zScaleFac_el = zScale["electrons"][1] elif "BE" in plot_el["default"].fileName: zScaleFac_el = zScale["electrons"][2] else: zScaleFac_el = zScale["electrons"][0] # Data and background loading if args.useall: datamu = [] datael = [] for i in range(3): datamu.append(data_all[i].loadHistogram(plot_mu["default"], lumi_mu[i], zScaleFac_mu[i])) datael.append(data_all[i].loadHistogram(plot_el["default"], lumi_el[i], zScaleFac_el[i])) stackmu = Stacks(processes_mu, lumi_mu, plot_mu["default"], zScaleFac_mu) mu_scaleup = Stacks(processes_mu, lumi_mu, plot_mu["scale_up"], zScaleFac_mu) mu_scaledown = Stacks(processes_mu, lumi_mu, plot_mu["scale_down"], zScaleFac_mu) mu_ID = Stacks(processes_mu, lumi_mu, plot_mu["ID"], zScaleFac_mu) mu_reso = Stacks(processes_mu, lumi_mu, plot_mu["reso"], zScaleFac_mu) stackel = Stacks(processes_el, lumi_el, plot_el["default"], zScaleFac_el) el_scaleup = Stacks(processes_el, lumi_el, plot_el["scale_up"], zScaleFac_el) el_scaledown = Stacks(processes_el, lumi_el, plot_el["scale_down"], zScaleFac_el) el_PUup = Stacks(processes_el, lumi_el, plot_el["PU_up"], zScaleFac_el) el_PUdown = Stacks(processes_el, lumi_el, plot_el["PU_down"], zScaleFac_el) else: datamu = data_mu.loadHistogram(plot_mu["default"], lumi_mu, zScaleFac_mu) datael = data_el.loadHistogram(plot_el["default"], lumi_el, zScaleFac_el) stackmu = TheStack(processes_mu, lumi_mu, plot_mu["default"], zScaleFac_mu) mu_scaleup = TheStack(processes_mu, lumi_mu, plot_mu["scale_up"], zScaleFac_mu) mu_scaledown = TheStack(processes_mu, lumi_mu, plot_mu["scale_down"], zScaleFac_mu) mu_ID = TheStack(processes_mu, lumi_mu, plot_mu["ID"], zScaleFac_mu) mu_reso = TheStack(processes_mu, lumi_mu, plot_mu["reso"], zScaleFac_mu) stackel = TheStack(processes_el, lumi_el, plot_el["default"], zScaleFac_el) print(stackel.theHistogram.Integral()) el_scaleup = TheStack(processes_el, lumi_el, plot_el["scale_up"], zScaleFac_el) el_scaledown = TheStack(processes_el, lumi_el, plot_el["scale_down"], zScaleFac_el) el_PUup = TheStack(processes_el, lumi_el, plot_el["PU_up"], zScaleFac_el) el_PUdown = TheStack(processes_el, lumi_el, plot_el["PU_down"], zScaleFac_el) if args.znorm: muheight = stackmu.theHistogram.FindBin(90) print("Z height of mu: %d +- %d" % (stackmu.theHistogram.GetBinCenter(muheight), stackmu.theHistogram.GetBinWidth(muheight))) print("Z height of mu mc&data: %d, %d" % (stackmu.theHistogram.GetBinContent(muheight), datamu.GetBinContent(muheight))) elheight = stackel.theHistogram.FindBin(90) print("Z height of el: %d +- %d" % (stackel.theHistogram.GetBinCenter(elheight), stackel.theHistogram.GetBinWidth(elheight))) print("Z height of el mc&data: %d, %d" % (stackel.theHistogram.GetBinContent(elheight), datael.GetBinContent(elheight))) znum = stackmu.theHistogram.GetBinContent(muheight) for h in stackmu.theStack.GetHists(): print("Z height of each hist in mu") print(h.GetBinContent(muheight)) h.Scale(1. / znum) for h in stackel.theStack.GetHists(): print("Z height of each hist in ee") print(h.GetBinContent(elheight)) h.Scale(1. / znum) stackmu.theHistogram.Scale(1. / znum) stackel.theHistogram.Scale(1. / znum) datamu.Scale(1. / znum) datael.Scale(1. / znum) if args.ae: if args.useall: i = 0 for year in range(2016, 2019): for h in stackmu[i].theStack.GetHists(): inverseAE(h, plot_mu["default"], year) for h in stackel[i].theStack.GetHists(): inverseAE(h, plot_el["default"], year) inverseAE(stackmu[i].theHistogram, plot_mu["default"], year) inverseAE(stackel[i].theHistogram, plot_el["default"], year) inverseAE(mu_scaleup[i].theHistogram, plot_mu["scale_up"], year) inverseAE(mu_scaledown[i].theHistogram, plot_mu["scale_down"], year) inverseAE(mu_ID[i].theHistogram, plot_mu["ID"], year) inverseAE(mu_reso[i].theHistogram, plot_mu["reso"], year) inverseAE(el_scaleup[i].theHistogram, plot_el["scale_up"], year) inverseAE(el_scaledown[i].theHistogram, plot_el["scale_down"], year) inverseAE(el_PUup[i].theHistogram, plot_el["PU_up"], year) inverseAE(el_PUdown[i].theHistogram, plot_el["PU_down"], year) inverseAE(datamu[i], plot_mu["default"], year) inverseAE(datael[i], plot_el["default"], year) else: if args.use2016: year = 2016 elif args.use2018: year = 2018 else: year = 2017 for h in stackmu.theStack.GetHists(): inverseAE(h, plot_mu["default"], year) for h in stackel.theStack.GetHists(): inverseAE(h, plot_el["default"], year) inverseAE(stackmu.theHistogram, plot_mu["default"], year) inverseAE(stackel.theHistogram, plot_el["default"], year) inverseAE(mu_scaleup.theHistogram, plot_mu["scale_up"], year) inverseAE(mu_scaledown.theHistogram, plot_mu["scale_down"], year) inverseAE(mu_ID.theHistogram, plot_mu["ID"], year) inverseAE(mu_reso.theHistogram, plot_mu["reso"], year) inverseAE(el_scaleup.theHistogram, plot_el["scale_up"], year) inverseAE(el_scaledown.theHistogram, plot_el["scale_down"], year) inverseAE(el_PUup.theHistogram, plot_el["PU_up"], year) inverseAE(el_PUdown.theHistogram, plot_el["PU_down"], year) inverseAE(datamu, plot_mu["default"], year) inverseAE(datael, plot_el["default"], year) if args.useall: i = 0 Errs_mu = [] Errs_el = [] for year in range(2016, 2019): lis_mu = [[ mu_scaleup[i].theHistogram, mu_scaledown[i].theHistogram ], mu_ID[i].theHistogram, mu_reso[i].theHistogram] lis_el = [[ el_scaleup[i].theHistogram, el_scaledown[i].theHistogram ], [el_PUup[i].theHistogram, el_PUdown[i].theHistogram]] Errs_mu.append(getErrors(stackmu[i].theHistogram, lis_mu)) Errs_el.append(getErrors(stackel[i].theHistogram, lis_el)) i += 1 errmu = Errs_mu[0] + Errs_mu[1] + Errs_mu[2] errel = Errs_el[0] + Errs_el[1] + Errs_el[2] stackmu = Addstack(stackmu) stackel = Addstack(stackel) mu_scaleup = Addstack(mu_scaleup) mu_scaledown = Addstack(mu_scaledown) mu_ID = Addstack(mu_ID) mu_reso = Addstack(mu_reso) el_scaleup = Addstack(el_scaleup) el_scaledown = Addstack(el_scaledown) el_PUup = Addstack(el_PUup) el_PUdown = Addstack(el_PUdown) datamu = Addhist(datamu) datael = Addhist(datael) else: lis_mu = [[mu_scaleup.theHistogram, mu_scaledown.theHistogram], mu_ID.theHistogram, mu_reso.theHistogram] lis_el = [[el_scaleup.theHistogram, el_scaledown.theHistogram], [el_PUup.theHistogram, el_PUdown.theHistogram]] errmu = getErrors(stackmu.theHistogram, lis_mu) errel = getErrors(stackel.theHistogram, lis_el) if args.data: yMax = datamu.GetBinContent(datamu.GetMaximumBin()) if "Mass" in plot_mu["default"].fileName: yMin = 0.00001 else: yMin = 0.01 xMax = datamu.GetXaxis().GetXmax() xMin = datael.GetXaxis().GetXmin() else: yMax = stackmu.theHistogram.GetBinContent(datahist.GetMaximumBin()) yMin = 0.01 xMax = stackmu.theHistogram.GetXaxis().GetXmax() xMin = stackmu.theHistogram.GetXaxis().GetXmin() if plot_mu["default"].yMax == None: if logScale: yMax = yMax * 10000 else: yMax = yMax * 1.5 else: yMax = plot_mu["default"].yMax if "Mass" in plot_mu["default"].fileName: yMax = 20000000 if not plot_mu["default"].yMin == None: yMin = plot_mu.yMin if not plot_mu["default"].xMin == None: xMin = plot_mu["default"].xMin if not plot_mu["default"].xMax == None: xMax = plot_mu["default"].xMax xMin = 200 xMax = 2000 yMin = 1e-3 yMax = 1e4 if args.ae: yMin = 0.00001 / 40 yMax = 200000000.0 / 40 xMin = 200 xMax = 2000 yMin *= 10000 yMax /= 10 if args.ae: # ~ vh = plotPad.DrawFrame(xMin,yMin,xMax,yMax,"; %s ; %s" %("m(l^{+}l^{-}) [GeV]","3 years data")) vh = plotPad.DrawFrame( xMin, yMin, xMax, yMax, "; %s ; %s" % ("m(l^{+}l^{-}) [GeV]", "Events / GeV * 1/(acc. x eff)")) else: # ~ vh = plotPad.DrawFrame(xMin,yMin,xMax,yMax,"; %s ; %s" %("m(l^{+}l^{-}) [GeV]","Lumi #times d#sigma(pp#rightarrow ll)")) vh = plotPad.DrawFrame( xMin, yMin, xMax, yMax, "; %s ; %s" % ("m(l^{+}l^{-}) [GeV]", "Events / GeV")) vh.GetXaxis().SetMoreLogLabels() drawStack_mu = stackmu drawStack_el = stackel # Draw background from stack drawStack_mu.theHistogram.SetLineColor(ROOT.kBlue - 3) drawStack_el.theHistogram.SetLineColor(ROOT.kRed - 3) drawStack_mu.theHistogram.SetFillStyle(0) drawStack_el.theHistogram.SetFillStyle(0) drawStack_mu.theHistogram.Draw("same hist") drawStack_el.theHistogram.Draw("same hist") # Draw data datamu.SetMinimum(0.0001) if args.data: datamu.SetMarkerColor(ROOT.kViolet) datael.SetMarkerColor(ROOT.kOrange) datamu.Draw("samep") datael.Draw("samep") # Draw legend if "Eta" in plot_mu["default"].fileName or "CosTheta" in plot_mu[ "default"].fileName: legendEta.Draw() else: legend.Draw() plotPad.SetLogx(plot_mu["default"].logX) if args.useall: latex.DrawLatex(0.95, 0.96, "three years data") else: latex.DrawLatex( 0.95, 0.96, "%.1f fb^{-1} (13 TeV, #mu#mu), %.1f fb^{-1} (13 TeV, ee)" % (lumi_mu * 0.001, lumi_el * 0.001)) yLabelPos = 0.85 cmsExtra = "Private Work" if not args.data: cmsExtra = "#splitline{Private Work}{Simulation}" yLabelPos = 0.82 latexCMS.DrawLatex(0.19, 0.89, "CMS") latexCMSExtra.DrawLatex(0.19, yLabelPos, "%s" % (cmsExtra)) if args.ratio: ratioPad.cd() ratioPad.SetLogx(plot_mu["default"].logX) hhmu = drawStack_mu.theHistogram hhel = drawStack_el.theHistogram h_mu_scaleup = mu_scaleup.theHistogram h_mu_scaledown = mu_scaledown.theHistogram h_mu_ID = mu_ID.theHistogram h_mu_reso = mu_reso.theHistogram h_el_scaleup = el_scaleup.theHistogram h_el_scaledown = el_scaledown.theHistogram h_el_PUup = el_PUup.theHistogram h_el_PUdown = el_PUdown.theHistogram ratioGraphs = ROOT.TGraphAsymmErrors(hhmu.GetSize() - 2) chann = True if "BB" in plot_mu["default"].fileName else False #print(errel) #print(errmu) for i in range(1, hhmu.GetSize() - 1): xval = hhmu.GetBinCenter(i) xerr = hhmu.GetBinWidth(i) / 2 if hhel.GetBinContent(i) == 0: continue if hhmu.GetBinContent(i) == 0: continue #print(math.sqrt(errmu[i-1])/hhmu.GetBinContent(i)) yval = hhmu.GetBinContent(i) * 1.0 / hhel.GetBinContent(i) yerr = yval * math.sqrt( (errel[i - 1]**0.5 / hhel.GetBinContent(i))**2 + (errmu[i - 1]**0.5 / hhmu.GetBinContent(i))**2 + (hhmu.GetBinError(i) / hhmu.GetBinContent(i))**2 + (hhel.GetBinError(i) / hhel.GetBinContent(i))**2) ratioGraphs.SetPoint(i, xval, yval) ratioGraphs.SetPointError(i, xerr, xerr, yerr, yerr) print("M = %f, r+-e = %f +- %f" % (xval, yval, yerr / yval)) ratioData = ROOT.TGraphAsymmErrors(datamu.GetSize() - 2) for i in range(1, datamu.GetSize() - 1): xval = datamu.GetBinCenter(i) xerr = datamu.GetBinWidth(i) / 2 if datael.GetBinContent(i) == 0: continue if datamu.GetBinContent(i) == 0: continue #print(datael.GetBinContent(i)) #print(datael.GetBinError(i)) yval = datamu.GetBinContent(i) * 1.0 / datael.GetBinContent(i) yerr = yval * math.sqrt( (datamu.GetBinError(i) / datamu.GetBinContent(i))**2 + (datael.GetBinError(i) / datael.GetBinContent(i))**2) ratioData.SetPoint(i, xval, yval) ratioData.SetPointError(i, xerr, xerr, yerr, yerr) print("M = %f, r+-e = %f +- %f" % (xval, yval, yerr / yval)) nBinsX = 20 nBinsY = 10 if args.ae: hAxis = ROOT.TH2F("hAxis", "", nBinsX, xMin, xMax, nBinsY, 0.5, 2.5) else: hAxis = ROOT.TH2F("hAxis", "", nBinsX, xMin, xMax, nBinsY, 0.5, 5) hAxis.Draw("AXIS") hAxis.GetYaxis().SetNdivisions(408) hAxis.SetTitleOffset(0.4, "Y") hAxis.SetTitleSize(0.09, "Y") hAxis.SetTitleSize(0.06, "X") hAxis.SetYTitle("R_{#mu#mu/ee}") hAxis.SetXTitle("m(l^{+}l^{-}) [GeV]") hAxis.GetXaxis().SetLabelSize(0.048) hAxis.GetYaxis().SetLabelSize(0.048) #hAxis.GetXaxis().SetTicks("+") #hAxis.SetTitleSize(0.15, "Y") hAxis.GetXaxis().SetMoreLogLabels() oneLine = ROOT.TLine(xMin, 1.0, xMax, 1.0) oneLine.SetLineStyle(2) oneLine.Draw() ratioGraphs.SetFillColor(ROOT.kBlue - 3) ratioGraphs.SetMarkerColor(ROOT.kBlue - 3) ratioGraphs.GetXaxis().SetLabelSize(0.0) ratioGraphs.SetFillStyle(3002) ratioGraphs.Draw("SAME p") ratioData.SetMarkerColor(ROOT.kViolet) ratioData.Draw("same p") rlegend = TLegend(0.2, 0.65, 0.5, 0.925) rlegend.SetFillStyle(0) rlegend.SetBorderSize(1) rlegend.SetTextFont(42) rlegend.AddEntry(ratioGraphs, "e/mu in MC inclusive", "pe") rlegend.AddEntry(ratioData, "e/mu in data", "pe") rlegend.Draw("same") ratioPad.Update() ROOT.gPad.RedrawAxis() plotPad.RedrawAxis() if args.ratio: ratioPad.RedrawAxis() if not os.path.exists("lepFlavor"): os.makedirs("lepFlavor") if args.use2016: year = "2016" elif args.useall: year = "2016_to_2018" elif args.use2018: year = "2018" else: year = "2017" if args.ae: year += "_inverseAE" if args.znorm: year += "_znorm" hCanvas.Print("lepFlavor/%s_%s_datamc.pdf" % (plot_mu["default"].fileName, year))
def plotDataMC(mainConfig, dilepton): import gc gc.enable() from ROOT import TCanvas, TPad, TH1F, TH1I, THStack, TLegend, TMath, gROOT, TFile, TH2F import ratios from defs import Backgrounds from defs import Backgrounds2011 from defs import Signals from defs import defineMyColors from defs import myColors from defs import Region from defs import Regions from defs import Plot from corrections import triggerEffs, rSFOFTrig from setTDRStyle import setTDRStyle gROOT.SetBatch(True) from helpers import * import math ### file to normalize signal MC signalDenominatorFile = TFile( "../SignalScan/T6bbllsleptonDenominatorHisto4.root") signalDenominatorHisto = TH2F(signalDenominatorFile.Get("massScan")) if mainConfig.forPAS: hCanvas = TCanvas("hCanvas", "Distribution", 600, 800) else: hCanvas = TCanvas("hCanvas", "Distribution", 800, 800) if mainConfig.plotRatio: plotPad = ROOT.TPad("plotPad", "plotPad", 0, 0.3, 1, 1) ratioPad = ROOT.TPad("ratioPad", "ratioPad", 0, 0., 1, 0.3) setTDRStyle() plotPad.UseCurrentStyle() ratioPad.UseCurrentStyle() plotPad.Draw() ratioPad.Draw() plotPad.cd() else: plotPad = ROOT.TPad("plotPad", "plotPad", 0, 0, 1, 1) setTDRStyle() plotPad.UseCurrentStyle() plotPad.Draw() plotPad.cd() colors = createMyColors() eventCounts = totalNumberOfGeneratedEvents(mainConfig.dataSetPath) processes = [] for background in mainConfig.backgrounds: processes.append(Process(getattr(Backgrounds, background), eventCounts)) ### get the signal if any is to be plotted signalEventCounts = {} signals = [] signalNameLabel = "" for signal in mainConfig.signals: m_b = int(signal.split("_")[2]) m_n_2 = int(signal.split("_")[4]) signalEventCounts[signal] = signalDenominatorHisto.GetBinContent( signalDenominatorHisto.GetXaxis().FindBin(m_b), signalDenominatorHisto.GetYaxis().FindBin(m_n_2)) signals.append(Process(getattr(Signals, signal), signalEventCounts)) if signalNameLabel == "": signalNameLabel = "Signal" signalNameLabel += "_m_b_%s_m_n_%s" % (signal.split("_")[2], signal.split("_")[4]) #~ legend = TLegend(0.45, 0.6, 0.925, 0.925) legend = TLegend(0.55, 0.6, 0.925, 0.925) legend.SetFillStyle(0) legend.SetBorderSize(0) legend.SetTextFont(42) #~ legend.SetNColumns(2) legendEta = TLegend(0.15, 0.75, 0.7, 0.9) legendEta.SetFillStyle(0) legendEta.SetBorderSize(0) legendEta.SetTextFont(42) latex = ROOT.TLatex() latex.SetTextFont(42) latex.SetTextAlign(31) latex.SetTextSize(0.04) latex.SetNDC(True) latexCMS = ROOT.TLatex() latexCMS.SetTextFont(61) latexCMS.SetTextSize(0.06) latexCMS.SetNDC(True) latexCMSExtra = ROOT.TLatex() latexCMSExtra.SetTextFont(52) latexCMSExtra.SetTextSize(0.045) latexCMSExtra.SetNDC(True) legendHists = [] legendHistData = ROOT.TH1F() if mainConfig.plotData: legend.AddEntry(legendHistData, "Data", "pe") legendEta.AddEntry(legendHistData, "Data", "pe") ### loop over the background processes, add them in iverse order to the legend if mainConfig.plotMC: for process in reversed(processes): temphist = ROOT.TH1F() temphist.SetFillColor(process.theColor) ### Do not add a seperate legend entry for DY to tautau if new legend scheme is used if not process.label == "DY+jets non resonant": legendHists.append(temphist.Clone) legend.AddEntry(temphist, process.label, "f") legendEta.AddEntry(temphist, process.label, "f") if mainConfig.plotRatio: temphist = ROOT.TH1F() temphist.SetFillColor(myColors["MyGreen"]) legendHists.append(temphist.Clone) #~ legend.AddEntry(temphist,"Syst. uncert.","f") temphist2 = ROOT.TH1F() temphist2.SetFillColor(myColors["DarkRed"], ) temphist2.SetFillStyle(3002) legendHists.append(temphist2.Clone) if mainConfig.plotSignal: for Signal in signals: temphist = ROOT.TH1F() temphist.SetFillColor(Signal.theColor) temphist.SetLineColor(Signal.theLineColor) legendHists.append(temphist.Clone) legend.AddEntry(temphist, Signal.label, "l") legendEta.AddEntry(temphist, Signal.label, "l") nEvents = -1 ROOT.gStyle.SetOptStat(0) intlumi = ROOT.TLatex() intlumi.SetTextAlign(12) intlumi.SetTextSize(0.03) intlumi.SetNDC(True) intlumi2 = ROOT.TLatex() intlumi2.SetTextAlign(12) intlumi2.SetTextSize(0.07) intlumi2.SetNDC(True) scalelabel = ROOT.TLatex() scalelabel.SetTextAlign(12) scalelabel.SetTextSize(0.03) scalelabel.SetNDC(True) metDiffLabel = ROOT.TLatex() metDiffLabel.SetTextAlign(12) metDiffLabel.SetTextSize(0.03) metDiffLabel.SetNDC(True) chi2Label = ROOT.TLatex() chi2Label.SetTextAlign(12) chi2Label.SetTextSize(0.03) chi2Label.SetNDC(True) hCanvas.SetLogy() treeEE = readTrees(mainConfig.dataSetPath, "EE") treeMuMu = readTrees(mainConfig.dataSetPath, "MuMu") treeEMu = readTrees(mainConfig.dataSetPath, "EMu") mainConfig.plot.addDilepton(dilepton) plotPad.cd() plotPad.SetLogy(0) logScale = mainConfig.plot.log #~ logScale = True if mainConfig.plot.variable == "met" or mainConfig.plot.variable == "type1Met" or mainConfig.plot.variable == "tcMet" or mainConfig.plot.variable == "caloMet" or mainConfig.plot.variable == "mht": logScale = True if logScale == True: plotPad.SetLogy() scaleTree1 = 1.0 scaleTree2 = 1.0 if mainConfig.plot.tree1 == "EE": tree1 = treeEE if mainConfig.useDataTrigEff: scaleTree1 = getattr(triggerEffs, mainConfig.etaRegion).effEE.val #~ scaleTree1 = getattr(triggerEffs,mainConfig.etaRegion).effEE.val**2 print "ee trigger Eff:" print scaleTree1 #~ elif mainConfig.useTriggerEmulation: #~ scaleTree1 = getattr(triggerEffs,mainConfig.etaRegion).effEE.val/getattr(triggerEffs,mainConfig.etaRegion).effEE.valMC elif mainConfig.plot.tree1 == "MuMu": tree1 = treeMuMu if mainConfig.useDataTrigEff: scaleTree1 = getattr(triggerEffs, mainConfig.etaRegion).effMM.val #~ scaleTree1 = getattr(triggerEffs,mainConfig.etaRegion).effMM.val**2 print "mumu trigger Eff:" print scaleTree1 #~ elif mainConfig.useTriggerEmulation: #~ scaleTree1 = getattr(triggerEffs,mainConfig.etaRegion).effMM.val/getattr(triggerEffs,mainConfig.etaRegion).effMM.valMC elif mainConfig.plot.tree1 == "EMu": tree1 = treeEMu if mainConfig.useDataTrigEff: scaleTree1 = getattr(triggerEffs, mainConfig.etaRegion).effEM.val print "emu trigger Eff:" print scaleTree1 #~ elif mainConfig.useTriggerEmulation: #~ scaleTree1 = getattr(triggerEffs,mainConfig.etaRegion).effEM.val/getattr(triggerEffs,mainConfig.etaRegion).effEM.valMC else: print "Unknown Dilepton combination! %s not created!" % ( mainConfig.plot.filename, ) return if mainConfig.plot.tree2 != "None": if mainConfig.plot.tree2 == "EE": tree2 = treeEE if mainConfig.useDataTrigEff: #~ scaleTree2 = mainConfig.selection.trigEffs.effEE.val scaleTree2 = mainConfig.selection.trigEffs.effEE.val**2 print "ee trigger Eff:" print scaleTree2 #~ elif mainConfig.useTriggerEmulation: #~ scaleTree2 = getattr(triggerEffs,mainConfig.etaRegion).effEE.val/getattr(triggerEffs,mainConfig.etaRegion).effEE.valMC elif mainConfig.plot.tree2 == "MuMu": tree2 = treeMuMu if mainConfig.useDataTrigEff: #~ scaleTree2 = mainConfig.selection.trigEffs.effMM.val scaleTree2 = mainConfig.selection.trigEffs.effMM.val**2 print "mumu trigger Eff:" print scaleTree2 #~ elif mainConfig.useTriggerEmulation: #~ scaleTree2 = getattr(triggerEffs,mainConfig.etaRegion).effMM.val/getattr(triggerEffs,mainConfig.etaRegion).effMM.valMC elif mainConfig.plot.tree2 == "EMu": tree2 = treeEMu if mainConfig.useDataTrigEff: scaleTree2 = mainConfig.selection.trigEffs.effEM.val print "emu trigger Eff:" print scaleTree2 #~ elif mainConfig.useTriggerEmulation: #~ scaleTree2 = getattr(triggerEffs,mainConfig.etaRegion).effEM.val/getattr(triggerEffs,mainConfig.etaRegion).effEM.valMC else: print "Unknown Dilepton combination! %s not created!" % ( mainConfig.plot.filename, ) return else: tree2 = "None" if mainConfig.normalizeToData: pickleName = mainConfig.plot.filename % ( "_normalizedToData_" + mainConfig.runRange.label + "_" + dilepton) elif mainConfig.useTriggerEmulation: pickleName = mainConfig.plot.filename % ( "_TriggerEmulation_" + mainConfig.runRange.label + "_" + dilepton) elif mainConfig.DontScaleTrig: pickleName = mainConfig.plot.filename % ( "_NoTriggerScaling_" + mainConfig.runRange.label + "_" + dilepton) elif mainConfig.useDataTrigEff: pickleName = mainConfig.plot.filename % ( "_dataTriggerEffs_" + mainConfig.runRange.label + "_" + dilepton) else: pickleName = mainConfig.plot.filename % ( "_" + mainConfig.runRange.label + "_" + dilepton) counts = {} import pickle print mainConfig.plot.cuts if mainConfig.plotData: datahist = getDataHist( mainConfig.plot, tree1, tree2, normalizeToBinWidth=mainConfig.normalizeToBinWidth) counts["Data"] = { "val": datahist.Integral(0, datahist.GetNbinsX() + 1), "err": math.sqrt(datahist.Integral(0, datahist.GetNbinsX() + 1)) } print datahist.GetEntries() if mainConfig.plotMC: #~ stack = TheStack(processes,mainConfig.runRange.lumi,mainConfig.plot,tree1,tree2,1.0,scaleTree1,scaleTree2,saveIntegrals=True,counts=counts,doTopReweighting=mainConfig.doTopReweighting,theoUncert=mainConfig.theoUncert,doPUWeights=mainConfig.doPUWeights,normalizeToBinWidth=mainConfig.normalizeToBinWidth) stack = TheStack(processes, mainConfig.runRange.lumi, mainConfig.plot, tree1, tree2, 1.0, scaleTree1, scaleTree2, saveIntegrals=True, counts=counts, doTopReweighting=mainConfig.doTopReweighting, doPUWeights=mainConfig.doPUWeights, normalizeToBinWidth=mainConfig.normalizeToBinWidth, useTriggerEmulation=mainConfig.useTriggerEmulation) ### get the number of MC events and the uncertainty errIntMC = ROOT.Double() intMC = stack.theHistogram.IntegralAndError( 0, stack.theHistogram.GetNbinsX() + 1, errIntMC) val = float(intMC) err = float(errIntMC) counts["Total Background"] = {"val": val, "err": err} ### scale the stack if MC is to be normalzed to data if mainConfig.normalizeToData: scalefac = datahist.Integral( datahist.FindBin(mainConfig.plot.firstBin), datahist.FindBin( mainConfig.plot.lastBin)) / stack.theHistogram.Integral( stack.theHistogram.FindBin(mainConfig.plot.firstBin), stack.theHistogram.FindBin(mainConfig.plot.lastBin)) drawStack = TheStack( processes, mainConfig.runRange.lumi, mainConfig.plot, tree1, tree2, 1.0, scalefac * scaleTree1, scalefac * scaleTree2, doPUWeights=mainConfig.doPUWeights, normalizeToBinWidth=mainConfig.normalizeToBinWidth, useTriggerEmulation=mainConfig.useTriggerEmulation) stackJESUp = TheStack( processes, mainConfig.runRange.lumi, mainConfig.plot, tree1, tree2, 0.955, scalefac * scaleTree1, scalefac * scaleTree2, doPUWeights=mainConfig.doPUWeights, normalizeToBinWidth=mainConfig.normalizeToBinWidth, useTriggerEmulation=mainConfig.useTriggerEmulation) stackJESDown = TheStack( processes, mainConfig.runRange.lumi, mainConfig.plot, tree1, tree2, 1.045, scalefac * scaleTree1, scalefac * scaleTree2, doPUWeights=mainConfig.doPUWeights, normalizeToBinWidth=mainConfig.normalizeToBinWidth, useTriggerEmulation=mainConfig.useTriggerEmulation) else: drawStack = stack if mainConfig.plotSyst: mainConfig.plot.cuts = mainConfig.plot.cuts.replace( "met ", "metJESUp ") mainConfig.plot.cuts = mainConfig.plot.cuts.replace( " ht", " htJESUp") mainConfig.plot.cuts = mainConfig.plot.cuts.replace( " nJets ", " nShiftedJetsJESUp ") mainConfig.plot.cuts = mainConfig.plot.cuts.replace( "(nJets ", "(nShiftedJetsJESUp ") stackJESUp = TheStack( processes, mainConfig.runRange.lumi, mainConfig.plot, tree1, tree2, 1.0, scaleTree1, scaleTree2, JESUp=True, saveIntegrals=True, counts=counts, doPUWeights=mainConfig.doPUWeights, normalizeToBinWidth=mainConfig.normalizeToBinWidth, useTriggerEmulation=mainConfig.useTriggerEmulation) mainConfig.plot.cuts = mainConfig.plot.cuts.replace( "metJESUp", "metJESDown") mainConfig.plot.cuts = mainConfig.plot.cuts.replace( "htJESUp", "htJESDown") mainConfig.plot.cuts = mainConfig.plot.cuts.replace( "nShiftedJetsJESUp", "nShiftedJetsJESDown") stackJESDown = TheStack( processes, mainConfig.runRange.lumi, mainConfig.plot, tree1, tree2, 1.0, scaleTree1, scaleTree2, JESDown=True, saveIntegrals=True, counts=counts, doPUWeights=mainConfig.doPUWeights, normalizeToBinWidth=mainConfig.normalizeToBinWidth, useTriggerEmulation=mainConfig.useTriggerEmulation) mainConfig.plot.cuts = mainConfig.plot.cuts.replace( "metJESDown", "met") mainConfig.plot.cuts = mainConfig.plot.cuts.replace( "htJESDown", "ht") mainConfig.plot.cuts = mainConfig.plot.cuts.replace( "nShiftedJetsJESDown", "nJets") mainConfig.plot.cuts = mainConfig.plot.cuts.replace( "*(", "Up*(") stackPileUpUp = TheStack( processes, mainConfig.runRange.lumi, mainConfig.plot, tree1, tree2, 1.0, scaleTree1, scaleTree2, saveIntegrals=True, PileUpUp=True, counts=counts, doPUWeights=mainConfig.doPUWeights, normalizeToBinWidth=mainConfig.normalizeToBinWidth, useTriggerEmulation=mainConfig.useTriggerEmulation) mainConfig.plot.cuts = mainConfig.plot.cuts.replace( "Up*(", "Down*(") stackPileUpDown = TheStack( processes, mainConfig.runRange.lumi, mainConfig.plot, tree1, tree2, 1.0, scaleTree1, scaleTree2, saveIntegrals=True, PileUpDown=True, counts=counts, doPUWeights=mainConfig.doPUWeights, normalizeToBinWidth=mainConfig.normalizeToBinWidth, useTriggerEmulation=mainConfig.useTriggerEmulation) mainConfig.plot.cuts = mainConfig.plot.cuts.replace( "Down*(", "*(") errIntMC = ROOT.Double() intMCPileUpUp = stackPileUpUp.theHistogram.IntegralAndError( 0, stack.theHistogram.GetNbinsX() + 1, errIntMC) errIntMC = ROOT.Double() intMCPileUpDown = stackPileUpDown.theHistogram.IntegralAndError( 0, stack.theHistogram.GetNbinsX() + 1, errIntMC) valPileUpUp = float(intMCPileUpUp) valPileUpDown = float(intMCPileUpDown) pileUpUp = abs(counts["Total Background"]["val"] - valPileUpUp) pileUpDown = abs(counts["Total Background"]["val"] - valPileUpDown) counts["Total Background"]["pileUpDown"] = pileUpDown counts["Total Background"]["pileUpUp"] = pileUpUp if mainConfig.doTopReweighting: stackReweightDown = TheStack( processes, mainConfig.runRange.lumi, mainConfig.plot, tree1, tree2, 1.0, scaleTree1, scaleTree2, TopWeightDown=True, saveIntegrals=True, counts=counts, doPUWeights=mainConfig.doPUWeights, normalizeToBinWidth=mainConfig.normalizeToBinWidth, useTriggerEmulation=mainConfig.useTriggerEmulation) stackReweightUp = TheStack( processes, mainConfig.runRange.lumi, mainConfig.plot, tree1, tree2, 1.0, scaleTree1, scaleTree2, TopWeightUp=True, saveIntegrals=True, counts=counts, doPUWeights=mainConfig.doPUWeights, normalizeToBinWidth=mainConfig.normalizeToBinWidth, useTriggerEmulation=mainConfig.useTriggerEmulation) errIntMC = ROOT.Double() intMCTopWeightUp = stackReweightUp.theHistogram.IntegralAndError( 0, stack.theHistogram.GetNbinsX() + 1, errIntMC) errIntMC = ROOT.Double() intMCTopWeightDown = stackReweightDown.theHistogram.IntegralAndError( 0, stack.theHistogram.GetNbinsX() + 1, errIntMC) valTopWeightUp = float(intMCTopWeightUp) valTopWeightDown = float(intMCTopWeightDown) topWeightUp = abs(counts["Total Background"]["val"] - valTopWeightUp) topWeightDown = abs(counts["Total Background"]["val"] - valTopWeightDown) counts["Total Background"]["topWeightDown"] = topWeightDown counts["Total Background"]["topWeightUp"] = topWeightUp errIntMC = ROOT.Double() intMCJESUp = stackJESUp.theHistogram.IntegralAndError( 0, stack.theHistogram.GetNbinsX() + 1, errIntMC) errIntMC = ROOT.Double() intMCJESDown = stackJESDown.theHistogram.IntegralAndError( 0, stack.theHistogram.GetNbinsX() + 1, errIntMC) valJESUp = float(intMCJESUp) valJESDown = float(intMCJESDown) jesUp = abs(counts["Total Background"]["val"] - valJESUp) jesDown = abs(counts["Total Background"]["val"] - valJESDown) counts["Total Background"]["jesDown"] = jesDown counts["Total Background"]["jesUp"] = jesUp xSec = abs( stack.theHistogramXsecUp.Integral( 0, stack.theHistogram.GetNbinsX() + 1) - counts["Total Background"]["val"]) counts["Total Background"]["xSec"] = xSec #~ theoUncert = abs(stack.theHistogramTheoUp.Integral(0,stack.theHistogram.GetNbinsX()+1)-counts["Total Background"]["val"]) #~ counts["Total Background"]["theo"]=theoUncert outFilePkl = open("shelves/%s.pkl" % (pickleName), "w") pickle.dump(counts, outFilePkl) outFilePkl.close() if mainConfig.plotSignal: signalhists = [] signalLabels = [] ymaxSignal = 0 for Signal in signals: signalhist = Signal.createCombinedHistogram( mainConfig.runRange.lumi, mainConfig.plot, tree1, tree2) signalhist.SetLineWidth(2) if mainConfig.stackSignal: signalhist.Add(drawStack.theHistogram) signalhist.SetMinimum(0.1) signalhists.append(signalhist) signalLabels.append(Signal.label) tmpYmaxSignal = signalhist.GetBinContent( signalhist.GetMaximumBin()) if tmpYmaxSignal > ymaxSignal: ymaxSignal = tmpYmaxSignal ### set the maximum of the y-axis yMax = 0 yMin = 0 if mainConfig.plotData: yMax = datahist.GetBinContent(datahist.GetMaximumBin()) if (mainConfig.plotMC and yMax < drawStack.theHistogram.GetBinContent( drawStack.theHistogram.GetMaximumBin())): yMax = drawStack.theHistogram.GetBinContent( drawStack.theHistogram.GetMaximumBin()) if (mainConfig.plotSignal and yMax < ymaxSignal): yMax = ymaxSignal if mainConfig.plot.yMax == 0: if logScale: yMax = yMax * 200 if datahist.GetBinContent(datahist.GetMinimumBin()) > 0: yMin = datahist.GetBinContent(datahist.GetMinimumBin()) / 5. else: yMin = 0.1 #~ yMin = 0.5 #~ yMin = 5 else: yMax = yMax * 1.5 else: yMax = plot.yMax #~ yMax = 1200 #~ yMax = 130 plotPad.DrawFrame( mainConfig.plot.firstBin, yMin, mainConfig.plot.lastBin, yMax, "; %s ; %s" % (mainConfig.plot.xaxis, mainConfig.plot.yaxis)) ### draw the stack if mainConfig.plotMC: drawStack.theStack.Draw("samehist") lineHistogram = drawStack.theHistogram lineHistogram.Draw("same l") ### Draw signal if mainConfig.plotSignal: for signalhist in signalhists: signalhist.Draw("samehist") dileptonLabel = "" if dilepton == "SF": dileptonLabel = "ee + #mu#mu" if dilepton == "OF": dileptonLabel = "e#mu" if dilepton == "EE": dileptonLabel = "ee" if dilepton == "MuMu": dileptonLabel = "#mu#mu" if mainConfig.plotData: #~ datahist.SetMinimum(0.1) datahist.Draw("samep") if mainConfig.normalizeToData: scalelabel.DrawLatex(0.6, 0.4, "Background scaled by %.2f" % (scalefac)) if mainConfig.plot.variable == "eta1" or mainConfig.plot.variable == "eta2": legendEta.SetNColumns(2) legendEta.Draw() intlumi.DrawLatex( 0.2, 0.7, "#splitline{" + mainConfig.plot.label + " " + dileptonLabel + "}{#splitline{" + mainConfig.plot.label2 + "}{" + mainConfig.plot.label3 + "}}") else: legend.Draw() intlumi.DrawLatex( 0.4, 0.55, "#splitline{%s}{%s}" % (mainConfig.plot.label2, dileptonLabel)) latex.DrawLatex(0.95, 0.96, "%s fb^{-1} (13 TeV)" % (mainConfig.runRange.printval, )) yLabelPos = 0.85 #~ yLabelPos = 0.88 cmsExtra = "" if mainConfig.personalWork: cmsExtra = "Private Work" if not mainConfig.plotData: cmsExtra = "#splitline{Private Work}{Simulation}" yLabelPos = 0.82 #~ yLabelPos = 0.85 elif not mainConfig.plotData: cmsExtra = "Simulation" elif mainConfig.preliminary: cmsExtra = "Preliminary" elif mainConfig.forTWIKI: cmsExtra = "Unpublished" if mainConfig.forPAS: latexCMS.DrawLatex(0.15, 0.955, "CMS") latexCMSExtra.DrawLatex(0.26, 0.955, "%s" % (cmsExtra)) else: latexCMS.DrawLatex(0.19, 0.89, "CMS") latexCMSExtra.DrawLatex(0.19, yLabelPos, "%s" % (cmsExtra)) if mainConfig.plotRatio: ratioPad.cd() ratioGraphs = ratios.RatioGraph(datahist, drawStack.theHistogram, xMin=mainConfig.plot.firstBin, xMax=mainConfig.plot.lastBin, title="Data / MC", yMin=0.0, yMax=2, ndivisions=10, color=ROOT.kBlack, adaptiveBinning=0.25) if mainConfig.plotSyst: ratioGraphs.addErrorByHistograms("Pileup", stackPileUpUp.theHistogram, stackPileUpDown.theHistogram, color=myColors["MyGreen"]) ratioGraphs.addErrorByHistograms("JES", stackJESUp.theHistogram, stackJESDown.theHistogram, color=myColors["MyGreen"]) if mainConfig.doTopReweighting: ratioGraphs.addErrorByHistograms( "TopWeight", stackReweightUp.theHistogram, stackReweightDown.theHistogram, color=myColors["MyGreen"]) ratioGraphs.addErrorBySize("Effs", getattr(rSFOFTrig, mainConfig.etaRegion).err, color=myColors["MyGreen"], add=True) ratioGraphs.addErrorByHistograms("Xsecs", drawStack.theHistogramXsecUp, drawStack.theHistogramXsecDown, color=myColors["MyGreen"], add=True) #~ ratioGraphs.addErrorByHistograms( "Theo", drawStack.theHistogramTheoUp, drawStack.theHistogramTheoDown,color=myColors["MyGreen"],add=True) ratioGraphs.draw(ROOT.gPad, True, False, True, chi2Pos=0.8) if mainConfig.plotSignal and mainConfig.stackSignal: signalRatios = [] legendRatio = TLegend(0.175, 0.725, 0.65, 0.95) legendRatio.SetFillStyle(0) legendRatio.SetBorderSize(0) legendRatio.SetTextFont(42) backgroundHist = ROOT.TH1F() legendRatio.AddEntry(backgroundHist, "Data / background", "pe") temphist = ROOT.TH1F() temphist.SetFillColor(myColors["MyGreen"]) if mainConfig.plotSyst: legendRatio.AddEntry(temphist, "Syst. uncert.", "f") legendRatio.SetNColumns(2) for index, signalhist in enumerate(signalhists): signalRatios.append( ratios.RatioGraph(datahist, signalhist, xMin=mainConfig.plot.firstBin, xMax=mainConfig.plot.lastBin, title="Data / MC", yMin=0.0, yMax=2, ndivisions=10, color=signalhist.GetLineColor(), adaptiveBinning=0.25)) signalRatios[index].draw(ROOT.gPad, False, False, True, chi2Pos=0.7 - index * 0.1) signalhist.SetMarkerColor(signalhist.GetLineColor()) legendRatio.AddEntry( signalhist, "Data / Background + Signal (%s)" % signalLabels[index], "p") legendRatio.Draw("same") ROOT.gPad.RedrawAxis() plotPad.RedrawAxis() if mainConfig.plotRatio: ratioPad.RedrawAxis() nameModifier = mainConfig.runRange.label + "_" + dilepton if mainConfig.doTopReweighting: nameModifier += "_TopReweighted" if mainConfig.plotData == False: nameModifier += "_MCOnly" if mainConfig.plotMC == False: nameModifier += "_NoBkgMC" if mainConfig.plotSignal: nameModifier += "_" + signalNameLabel if mainConfig.stackSignal: nameModifier += "_stackedSignal" if mainConfig.normalizeToData: hCanvas.Print( "fig/DataMC/" + mainConfig.plot.filename % ("_scaled_" + nameModifier), ) elif mainConfig.useTriggerEmulation: hCanvas.Print( "fig/DataMC/" + mainConfig.plot.filename % ("_TriggerEmulation_" + nameModifier), ) elif mainConfig.DontScaleTrig: hCanvas.Print( "fig/DataMC/" + mainConfig.plot.filename % ("_NoTriggerScaling_" + nameModifier), ) else: hCanvas.Print( "fig/DataMC/" + mainConfig.plot.filename % ("_" + nameModifier), )
def makeLeptonOriginFracPlots(self, histID=None): # Fake lepton origin fraction wrt. X # Trick to make sure also the input histograms w/ variable bin size are handled correctly binsY = [] for biny in range(1, self.__hist.GetNbinsY() + 2): lowedge = self.__hist.GetYaxis().GetBinLowEdge(biny) binsY.append(lowedge) arr_binsY = array.array("d", binsY) print "hist N binsY: ", self.__hist.GetNbinsY() print "Y axis bin lims: ", binsY, " - N bins: ", len(binsY) - 1 histfakes_BF = TH1D("histfakes_BF" + "_" + histID, "histfakes_BF", self.__hist.GetNbinsY(), arr_binsY) # B-hadrons in jets (mesons/baryons) histfakes_CF = TH1D("histfakes_CF" + "_" + histID, "histfakes_CF", self.__hist.GetNbinsY(), arr_binsY) # C-hadrons in jets (mesons/baryons) histfakes_HFRes = TH1D("histfakes_HFRes" + "_" + histID, "histfakes_HFRes", self.__hist.GetNbinsY(), arr_binsY) # B,C resonances (J/psi, Upsilon...) histfakes_LF = TH1D("histfakes_LF" + "_" + histID, "histfakes_LF", self.__hist.GetNbinsY(), arr_binsY) # Light hadrons in jets histfakes_PhConv = TH1D("histfakes_PhConv" + "_" + histID, "histfakes_PhConv", self.__hist.GetNbinsY(), arr_binsY) # Photon conversions histfakes_Other = TH1D( "histfakes_Other" + "_" + histID, "histfakes_Other", self.__hist.GetNbinsY(), arr_binsY ) # Other fakes (mis-id jets, leptons from generic pi/K...) histfakes_Unknown = TH1D( "histfakes_Unknown" + "_" + histID, "histfakes_Unknown", self.__hist.GetNbinsY(), arr_binsY) # Unknown fakes (failure of MCTruthClassifier) stacklegend = TLegend(0.23, 0.25, 0.43, 0.55) stacklegend.SetBorderSize(1) stacklegend.SetFillColor(kWhite) stacklegend.SetTextSize(0.03) stacklegend.SetTextFont(42) histfakes_list = [(histfakes_BF, kRed), (histfakes_CF, kRed - 9), (histfakes_HFRes, kPink - 2), (histfakes_LF, kOrange + 1), (histfakes_PhConv, kYellow), (histfakes_Other, kPink + 1), (histfakes_Unknown, kAzure + 1)] for h in histfakes_list: h[0].SetLineWidth(2) h[0].SetLineStyle(1) h[0].SetLineColor(1) h[0].SetFillColor(h[1]) # Loop over var Y bins of the 2D hist for biny in range(1, self.__hist.GetNbinsY() + 2): offset = 1 # (to account for underflow bin, which has idx=0) # Get the tot. fakes for *this* Y fakes_TOT_biny = self.__hist.Integral(0, self.__hist.GetNbinsX() + 1, biny, biny) # Get the HF fakes for *this* Y fakes_BF_biny = self.__hist.Integral( 26 + offset, 26 + offset, biny, biny) + self.__hist.Integral( 33 + offset, 33 + offset, biny, biny) fakes_CF_biny = self.__hist.Integral( 25 + offset, 25 + offset, biny, biny) + self.__hist.Integral( 32 + offset, 32 + offset, biny, biny) fakes_HFRes_biny = self.__hist.Integral(27 + offset, 29 + offset, biny, biny) # Get the LF fakes for *this* Y fakes_LF_biny = self.__hist.Integral( 23 + offset, 24 + offset, biny, biny) + self.__hist.Integral( 30 + offset, 31 + offset, biny, biny) # Get the photon conversion fakes for *this* Y fakes_PhConv_biny = self.__hist.Integral(5 + offset, 5 + offset, biny, biny) # Get the "Unknown" fakes for *this* Y fakes_Unknown_biny = self.__hist.Integral(0 + offset, 0 + offset, biny, biny) # Get the other fakes for *this* Y fakes_Other_biny = fakes_TOT_biny - ( fakes_BF_biny + fakes_CF_biny + fakes_HFRes_biny + fakes_LF_biny + fakes_PhConv_biny + fakes_Unknown_biny) # Set the bin content for the fake lepton origin fraction hists for *this* Y bin if fakes_TOT_biny: fakes_BF_frac_biny = fakes_BF_biny / fakes_TOT_biny fakes_CF_frac_biny = fakes_CF_biny / fakes_TOT_biny fakes_HFRes_frac_biny = fakes_HFRes_biny / fakes_TOT_biny fakes_LF_frac_biny = fakes_LF_biny / fakes_TOT_biny fakes_PhConv_frac_biny = fakes_PhConv_biny / fakes_TOT_biny fakes_Unknown_frac_biny = fakes_Unknown_biny / fakes_TOT_biny fakes_Other_frac_biny = fakes_Other_biny / fakes_TOT_biny else: fakes_BF_frac_biny = fakes_CF_frac_biny = fakes_HFRes_frac_biny = fakes_LF_frac_biny = fakes_PhConv_frac_biny = fakes_Unknown_frac_biny = fakes_Other_frac_biny = 0 if False: print("varY - bin[{0}]".format(biny)) print("\ttot fakes = {0}".format(fakes_TOT_biny)) print("\t-) BF fakes = {0} ({1:.2f})".format( fakes_BF_biny, fakes_BF_frac_biny)) print("\t-) CF fakes = {0} ({1:.2f})".format( fakes_CF_biny, fakes_CF_frac_biny)) print("\t-) HFRes fakes = {0} ({1:.2f})".format( fakes_HFRes_biny, fakes_HFRes_frac_biny)) print("\t-) LF fakes = {0} ({1:.2f})".format( fakes_LF_biny, fakes_LF_frac_biny)) print("\t-) PhConv fakes = {0} ({1:.2f})".format( fakes_PhConv_biny, fakes_PhConv_frac_biny)) print("\t-) Unknown fakes = {0} ({1:.2f})".format( fakes_Unknown_biny, fakes_Unknown_frac_biny)) print("\t-) Other fakes = {0} ({1:.2f})".format( fakes_Other_biny, fakes_Other_frac_biny)) histfakes_BF.SetBinContent(biny, fakes_BF_frac_biny) histfakes_CF.SetBinContent(biny, fakes_CF_frac_biny) histfakes_HFRes.SetBinContent(biny, fakes_HFRes_frac_biny) histfakes_LF.SetBinContent(biny, fakes_LF_frac_biny) histfakes_PhConv.SetBinContent(biny, fakes_PhConv_frac_biny) histfakes_Unknown.SetBinContent(biny, fakes_Unknown_frac_biny) histfakes_Other.SetBinContent(biny, fakes_Other_frac_biny) self.conversion_frac_VS_Y.append( (biny, round(fakes_PhConv_frac_biny, 3))) # Add histograms w/ fake origin fractions into a stack plot stacklegend.AddEntry(histfakes_BF, "B-Had Fakes", "F") stacklegend.AddEntry(histfakes_CF, "C-Had Fakes", "F") stacklegend.AddEntry(histfakes_HFRes, "J/#psi,#Upsilon Fakes", "F") stacklegend.AddEntry(histfakes_LF, "L-Had Fakes", "F") stacklegend.AddEntry(histfakes_PhConv, "#gamma conversion", "F") stacklegend.AddEntry(histfakes_Other, "Other Fakes", "F") stacklegend.AddEntry(histfakes_Unknown, "Unknown", "F") stack = THStack("LepOriginFrac_VS_Y_STACK", "LepOriginFrac_VS_Y_STACK") stack.Add(histfakes_BF) stack.Add(histfakes_CF) stack.Add(histfakes_HFRes) stack.Add(histfakes_LF) stack.Add(histfakes_PhConv) stack.Add(histfakes_Other) stack.Add(histfakes_Unknown) return stack, stacklegend
def DrawOverlap(fileVec, histVec, titleVec,legendtext,pngname,logstatus=[0,0],xRange=[-99999,99999,1]): gStyle.SetOptTitle(0) gStyle.SetOptStat(0) gStyle.SetTitleOffset(1.1,"Y"); #gStyle.SetTitleOffset(1.9,"X"); gStyle.SetLineWidth(3) gStyle.SetFrameLineWidth(3); i=0 histList_=[] histList=[] histList1=[] maximum=[] ## Legend leg = TLegend(0.1, 0.70, 0.89, 0.89)#,NULL,"brNDC"); leg.SetBorderSize(0) leg.SetNColumns(3) leg.SetLineColor(1) leg.SetLineStyle(1) leg.SetLineWidth(1) leg.SetFillColor(0) leg.SetFillStyle(0) leg.SetTextFont(42) leg.SetTextSize(0.05) c = TCanvas("c1", "c1",0,0,500,500) c.SetBottomMargin(0.15) c.SetLogy(logstatus[1]) c.SetLogx(logstatus[0]) print ("you have provided "+str(len(fileVec))+" files and "+str(len(histVec))+" histograms to make a overlapping plot" ) print "opening rootfiles" c.cd() ii=0 inputfile={} print str(fileVec[(len(fileVec)-1)]) for ifile_ in range(len(fileVec)): print ("opening file "+fileVec[ifile_]) inputfile[ifile_] = TFile( fileVec[ifile_] ) print "fetching histograms" for ihisto_ in range(len(histVec)): print ("printing histo "+str(histVec[ihisto_])) histo = inputfile[ifile_].Get(histVec[ihisto_]) #status_ = type(histo) is TGraphAsymmErrors histList.append(histo) # for ratio plot as they should nt be normalize histList1.append(histo) #print histList[ii].Integral() #histList[ii].Rebin(xRange[2]) #histList[ii].Scale(1.0/histList[ii].Integral()) maximum.append(histList[ii].GetMaximum()) maximum.sort() ii=ii+1 print histList for ih in range(len(histList)): tt = type(histList[ih]) if logstatus[1] is 1 : histList[ih].SetMaximum(100) #1.4 for log histList[ih].SetMinimum(0.1) #1.4 for log if logstatus[1] is 0 : histList[ih].SetMaximum(1.4) #1.4 for log histList[ih].SetMinimum(0.001) #1.4 for log # print "graph_status =" ,(tt is TGraphAsymmErrors) # print "hist status =", (tt is TH1D) or (tt is TH1F) if ih == 0 : if tt is TGraphAsymmErrors : histList[ih].Draw("APL") if (tt is TH1D) or (tt is TH1F) or (tt is TH1) or (tt is TH1I) : histList[ih].Draw("hist") if ih > 0 : #histList[ih].SetLineWidth(2) if tt is TGraphAsymmErrors : histList[ih].Draw("PL same") if (tt is TH1D) or (tt is TH1F) or (tt is TH1) or (tt is TH1I) : histList[ih].Draw("hist same") if tt is TGraphAsymmErrors : histList[ih].SetMaximum(100) histList[ih].SetMarkerColor(colors[ih]) histList[ih].SetLineColor(colors[ih]) histList[ih].SetLineWidth(2) histList[ih].SetMarkerStyle(markerStyle[ih]) histList[ih].SetMarkerSize(1) leg.AddEntry(histList[ih],legendtext[ih],"PL") if (tt is TH1D) or (tt is TH1F) or (tt is TH1) or (tt is TH1I) : histList[ih].SetLineStyle(linestyle[ih]) histList[ih].SetLineColor(colors[ih]) histList[ih].SetLineWidth(3) leg.AddEntry(histList[ih],legendtext[ih],"L") histList[ih].GetYaxis().SetTitle(titleVec[1]) histList[ih].GetYaxis().SetTitleSize(0.052) histList[ih].GetYaxis().SetTitleOffset(0.98) histList[ih].GetYaxis().SetTitleFont(42) histList[ih].GetYaxis().SetLabelFont(42) histList[ih].GetYaxis().SetLabelSize(.052) histList[ih].GetXaxis().SetRangeUser(xRange[0],xRange[1]) # histList[ih].GetXaxis().SetLabelSize(0.0000); histList[ih].GetXaxis().SetTitle(titleVec[0]) histList[ih].GetXaxis().SetLabelSize(0.052) histList[ih].GetXaxis().SetTitleSize(0.052) #histList[ih].GetXaxis().SetTitleOffset(1.14) histList[ih].GetXaxis().SetTitleFont(42) histList[ih].GetXaxis().SetLabelFont(42) histList[ih].GetYaxis().SetLabelFont(42) histList[ih].GetXaxis().SetNdivisions(507) #histList[ih].GetXaxis().SetMoreLogLabels(); #histList[ih].GetXaxis().SetNoExponent(); #histList[ih].GetTGaxis().SetMaxDigits(3); i=i+1 pt = TPaveText(0.01,0.92,0.95,0.96,"brNDC") pt.SetBorderSize(0) pt.SetTextAlign(12) pt.SetFillStyle(0) pt.SetTextFont(42) pt.SetTextSize(0.046) text = pt.AddText(0.12,0.35,"CMS Internal 41.5 fb^{-1} (2017) ") #text = pt.AddText(0.12,0.35,"CMS Internal 59.6 fb^{-1} (2018) ") #text = pt.AddText(0.6,0.5,"41.5 fb^{-1} (2017) ") pt.Draw() leg.Draw() outputdirname = 'plots_limit/limitcomp//' histname=outputdirname+pngname c.SaveAs(histname+'.png') c.SaveAs(histname+'.pdf') outputname = 'cp -r '+ outputdirname+'/*' +' /afs/cern.ch/work/k/khurana/public/AnalysisStuff/monoH/LimitModelPlots/plots_limit/limitcomp/'
def train_and_apply(): np.random.seed(1) ROOT.gROOT.SetBatch() #Extract data from root file tree = uproot.open("out_all.root")["outA/Tevts"] branch_mc = [ "MC_B_P", "MC_B_eta", "MC_B_phi", "MC_B_pt", "MC_D0_P", "MC_D0_eta", "MC_D0_phi", "MC_D0_pt", "MC_Dst_P", "MC_Dst_eta", "MC_Dst_phi", "MC_Dst_pt", "MC_Est_mu", "MC_M2_miss", "MC_mu_P", "MC_mu_eta", "MC_mu_phi", "MC_mu_pt", "MC_pis_P", "MC_pis_eta", "MC_pis_phi", "MC_pis_pt", "MC_q2" ] branch_rec = [ "B_P", "B_eta", "B_phi", "B_pt", "D0_P", "D0_eta", "D0_phi", "D0_pt", "Dst_P", "Dst_eta", "Dst_phi", "Dst_pt", "Est_mu", "M2_miss", "mu_P", "mu_eta", "mu_phi", "mu_pt", "pis_P", "pis_eta", "pis_phi", "pis_pt", "q2" ] nvariable = len(branch_mc) x_train = tree.array(branch_mc[0], entrystop=options.maxevents) for i in range(1, nvariable): x_train = np.vstack( (x_train, tree.array(branch_mc[i], entrystop=options.maxevents))) x_test = tree.array(branch_rec[0], entrystop=options.maxevents) for i in range(1, nvariable): x_test = np.vstack( (x_test, tree.array(branch_rec[i], entrystop=options.maxevents))) x_train = x_train.T x_test = x_test.T x_test = array2D_float(x_test) #Different type of reconstruction variables #BN normalization gamma = 0 beta = 0.2 ar = np.array(x_train) a = K.constant(ar[:, 0]) mean = K.mean(a) var = K.var(a) x_train = K.eval(K.batch_normalization(a, mean, var, gamma, beta)) for i in range(1, nvariable): a = K.constant(ar[:, i]) mean = K.mean(a) var = K.var(a) a = K.eval(K.batch_normalization(a, mean, var, gamma, beta)) x_train = np.vstack((x_train, a)) x_train = x_train.T ar = np.array(x_test) a = K.constant(ar[:, 0]) mean = K.mean(a) var = K.var(a) x_test = K.eval(K.batch_normalization(a, mean, var, gamma, beta)) for i in range(1, nvariable): a = K.constant(ar[:, i]) mean = K.mean(a) var = K.var(a) a = K.eval(K.batch_normalization(a, mean, var, gamma, beta)) x_test = np.vstack((x_test, a)) x_test = x_test.T #Add noise, remain to be improved noise = np.random.normal(loc=0.0, scale=0.01, size=x_train.shape) x_train_noisy = x_train + noise noise = np.random.normal(loc=0.0, scale=0.01, size=x_test.shape) x_test_noisy = x_test + noise x_train = np.clip(x_train, -1., 1.) x_test = np.clip(x_test, -1., 1.) x_train_noisy = np.clip(x_train_noisy, -1., 1.) x_test_noisy = np.clip(x_test_noisy, -1., 1.) # Network parameters input_shape = (x_train.shape[1], ) batch_size = 128 latent_dim = 2 # Build the Autoencoder Model # First build the Encoder Model inputs = Input(shape=input_shape, name='encoder_input') x = inputs # Shape info needed to build Decoder Model shape = K.int_shape(x) # Generate the latent vector latent = Dense(latent_dim, name='latent_vector')(x) # Instantiate Encoder Model encoder = Model(inputs, latent, name='encoder') encoder.summary() # Build the Decoder Model latent_inputs = Input(shape=(latent_dim, ), name='decoder_input') x = Dense(shape[1])(latent_inputs) x = Reshape((shape[1], ))(x) outputs = Activation('tanh', name='decoder_output')(x) # Instantiate Decoder Model decoder = Model(latent_inputs, outputs, name='decoder') decoder.summary() # Autoencoder = Encoder + Decoder # Instantiate Autoencoder Model autoencoder = Model(inputs, decoder(encoder(inputs)), name='autoencoder') autoencoder.summary() autoencoder.compile(loss='mse', optimizer='adam') # Train the autoencoder autoencoder.fit(x_train_noisy, x_train, validation_data=(x_test_noisy, x_test), epochs=options.epochs, batch_size=batch_size) # Predict the Autoencoder output from corrupted test imformation x_decoded = autoencoder.predict(x_test_noisy) # Draw Comparision Plots c = TCanvas("c", "c", 700, 700) fPads1 = TPad("pad1", "Run2", 0.0, 0.29, 1.00, 1.00) fPads2 = TPad("pad2", "", 0.00, 0.00, 1.00, 0.29) fPads1.SetBottomMargin(0.007) fPads1.SetLeftMargin(0.10) fPads1.SetRightMargin(0.03) fPads2.SetLeftMargin(0.10) fPads2.SetRightMargin(0.03) fPads2.SetBottomMargin(0.25) fPads1.Draw() fPads2.Draw() fPads1.cd() nbin = 50 min = -1. max = 1. variable = "P^{B}" lbin = (max - min) / nbin lbin = str(float((max - min) / nbin)) xtitle = branch_rec[options.branch - 1] ytitle = "Events/" + lbin + "GeV" h_rec = TH1D("h_rec", "" + ";%s;%s" % (xtitle, ytitle), nbin, min, max) h_rec.Sumw2() h_pre = TH1D("h_pre", "" + ";%s;%s" % (xtitle, ytitle), nbin, min, max) h_pre.Sumw2() for i in range(x_test_noisy.shape[0]): h_rec.Fill(x_test_noisy[i][options.branch - 1]) h_pre.Fill(x_decoded[i][options.branch - 1]) h_rec = UnderOverFlow1D(h_rec) h_pre = UnderOverFlow1D(h_pre) maxY = TMath.Max(h_rec.GetMaximum(), h_pre.GetMaximum()) h_rec.SetLineColor(2) h_rec.SetFillStyle(0) h_rec.SetLineWidth(2) h_rec.SetLineStyle(1) h_pre.SetLineColor(3) h_pre.SetFillStyle(0) h_pre.SetLineWidth(2) h_pre.SetLineStyle(1) h_rec.SetStats(0) h_pre.SetStats(0) h_rec.GetYaxis().SetRangeUser(0, maxY * 1.1) h_rec.Draw("HIST") h_pre.Draw("same HIST") h_rec.GetYaxis().SetTitleSize(0.06) h_rec.GetYaxis().SetTitleOffset(0.78) theLeg = TLegend(0.5, 0.45, 0.95, 0.82, "", "NDC") theLeg.SetName("theLegend") theLeg.SetBorderSize(0) theLeg.SetLineColor(0) theLeg.SetFillColor(0) theLeg.SetFillStyle(0) theLeg.SetLineWidth(0) theLeg.SetLineStyle(0) theLeg.SetTextFont(42) theLeg.SetTextSize(.05) theLeg.AddEntry(h_rec, "Reconstruction", "L") theLeg.AddEntry(h_pre, "Prediction", "L") theLeg.SetY1NDC(0.9 - 0.05 * 6 - 0.005) theLeg.SetY1(theLeg.GetY1NDC()) fPads1.cd() theLeg.Draw() title = TLatex( 0.91, 0.93, "AE prediction compare with reconstruction, epochs=" + str(options.epochs)) title.SetNDC() title.SetTextSize(0.05) title.SetTextFont(42) title.SetTextAlign(31) title.SetLineWidth(2) title.Draw() fPads2.cd() h_Ratio = h_pre.Clone("h_Ratio") h_Ratio.Divide(h_rec) h_Ratio.SetLineColor(1) h_Ratio.SetLineWidth(2) h_Ratio.SetMarkerStyle(8) h_Ratio.SetMarkerSize(0.7) h_Ratio.GetYaxis().SetRangeUser(0, 2) h_Ratio.GetYaxis().SetNdivisions(504, 0) h_Ratio.GetYaxis().SetTitle("Pre/Rec") h_Ratio.GetYaxis().SetTitleOffset(0.35) h_Ratio.GetYaxis().SetTitleSize(0.13) h_Ratio.GetYaxis().SetTitleSize(0.13) h_Ratio.GetYaxis().SetLabelSize(0.11) h_Ratio.GetXaxis().SetLabelSize(0.1) h_Ratio.GetXaxis().SetTitleOffset(0.8) h_Ratio.GetXaxis().SetTitleSize(0.14) h_Ratio.SetStats(0) axis1 = TGaxis(min, 1, max, 1, 0, 0, 0, "L") axis1.SetLineColor(1) axis1.SetLineWidth(1) for i in range(1, h_Ratio.GetNbinsX() + 1, 1): D = h_rec.GetBinContent(i) eD = h_rec.GetBinError(i) if D == 0: eD = 0.92 B = h_pre.GetBinContent(i) eB = h_pre.GetBinError(i) if B < 0.1 and eB >= B: eB = 0.92 Err = 0. if B != 0.: Err = TMath.Sqrt((eD * eD) / (B * B) + (D * D * eB * eB) / (B * B * B * B)) h_Ratio.SetBinContent(i, D / B) h_Ratio.SetBinError(i, Err) if B == 0.: Err = TMath.Sqrt((eD * eD) / (eB * eB) + (D * D * eB * eB) / (eB * eB * eB * eB)) h_Ratio.SetBinContent(i, D / 0.92) h_Ratio.SetBinError(i, Err) if D == 0 and B == 0: h_Ratio.SetBinContent(i, -1) h_Ratio.SetBinError(i, 0) h_Ratio.Draw("e0") axis1.Draw() c.SaveAs(branch_rec[options.branch - 1] + "_comparision.png")
def plotUpperLimits(labels, masses, **kwargs): print color("plotUpperLimits()", color="magenta", prepend=">>>\n>>> ") # https://raw.githubusercontent.com/nucleosynthesis/HiggsAnalysis-CombinedLimit/combine_tutorial_SWAN/combine_tutorials_2016/combine_intro/plotPvalue.py # SIGNAL strength & mass extralabel = kwargs.get('extralabel', "") # LOOP over LABELS for label in labels: print color("plotUpperLimits - %s" % (label), color="grey", prepend="\n>>> ") N = len(masses) yellow = TGraph(2 * N) # yellow band green = TGraph(2 * N) # green band median = TGraph(N) # median line up2s = [] down2s = [] for i, mass in enumerate(masses): filename = getOutputFilename(label, mass, extralabel=extralabel) limits = getLimits(filename) yellow.SetPoint(i, mass, limits[4]) # + 2 sigma green.SetPoint(i, mass, limits[3]) # + 1 sigma median.SetPoint(i, mass, limits[2]) # median green.SetPoint(2 * N - 1 - i, mass, limits[1]) # - 1 sigma yellow.SetPoint(2 * N - 1 - i, mass, limits[0]) # - 2 sigma down2s.append(limits[0]) up2s.append(limits[4]) ymax = max(up2s) * 1.20 ymin = min(down2s) doLog = ymin and ymax / min(down2s) > 4 xtitle = "m_{X} [GeV]" ytitle = "95% upper limit on #sigma#timesBR(X #rightarrow #tau#tau) [pb]" if "bbA" in extralabel: xtitle = "m_{A} [GeV]" ytitle = "95% upper limit on #sigma#timesBR(A #rightarrow #tau#tau) [pb]" W, H = 800, 600 T, B = 0.08 * H, 0.12 * H L, R = 0.12 * W, 0.04 * W canvas = TCanvas("canvas", "canvas", 100, 100, W, H) canvas.SetFillColor(0) canvas.SetBorderMode(0) canvas.SetFrameFillStyle(0) canvas.SetFrameBorderMode(0) canvas.SetTopMargin(T / H) canvas.SetBottomMargin(B / H) canvas.SetLeftMargin(L / W) canvas.SetRightMargin(R / W) canvas.SetTickx(0) canvas.SetTicky(0) canvas.SetGrid() canvas.cd() if doLog: ymin = 0.1 #10**(floor(log(ymin,10))-1) ymax = 1000 #10**(ceil(log(ymax,10))+1) #ymin, ymax = 0.1, 1000 canvas.SetLogy() else: ymin *= 0 if ymin > 0 else 1.20 frame = canvas.DrawFrame(min(masses), ymin, max(masses), ymax) frame.GetYaxis().SetTitleSize(0.055) frame.GetXaxis().SetTitleSize(0.055) frame.GetXaxis().SetLabelSize(0.044) frame.GetYaxis().SetLabelSize(0.044) frame.GetXaxis().SetLabelOffset(0.010) frame.GetXaxis().SetTitleOffset(1.04) frame.GetYaxis().SetTitleOffset(1.08) frame.GetXaxis().SetNdivisions(508) frame.GetYaxis().CenterTitle(True) frame.GetYaxis().SetTitle(ytitle) frame.GetXaxis().SetTitle(xtitle) yellow.SetFillColor(kOrange) yellow.SetLineColor(kOrange) yellow.SetFillStyle(1001) yellow.Draw('F') green.SetFillColor(kGreen + 1) green.SetLineColor(kGreen + 1) green.SetFillStyle(1001) green.Draw('Fsame') median.SetLineColor(1) median.SetLineWidth(2) median.SetLineStyle(2) median.Draw('Lsame') CMS_lumi.CMS_lumi(canvas, 13, 0) gPad.SetTicks(1, 1) gPad.Modified() frame.Draw('sameaxis') width = 0.28 height = 0.20 #x1 = 0.16; x2 = x1 + width # Left x2 = 0.80 x1 = x2 - width # Right x2 = x1 + width y1 = 0.68 y2 = y1 + height legend = TLegend(x1, y1, x2, y2) legend.SetFillStyle(0) legend.SetBorderSize(0) legend.SetTextSize(0.040) legend.SetTextFont(62) legend.SetHeader("%s" % (label_dict[label + extralabel])) legend.SetTextFont(42) legend.AddEntry(median, "Asymptotic CL_{s} expected", 'L') legend.AddEntry(green, "#pm 1 std. deviation", 'f') #legend.AddEntry(green, "Asymptotic CL_{s} #pm 1 std. deviation",'f') legend.AddEntry(yellow, "#pm 2 std. deviation", 'f') #legend.AddEntry(green, "Asymptotic CL_{s} #pm 2 std. deviation",'f') legend.Draw() print " " canvas.SaveAs("%s/upperLimit-%s%s.png" % (PLOTS_DIR, label, extralabel)) canvas.SaveAs("%s/upperLimit-%s%s%s.pdf" % (PLOTS_DIR, label, extralabel)) canvas.Close()
def drawHistsWithRatio(hists, name, **kwargs): """Draw histograms with ratios.""" title = kwargs.get('title', "") xtitle = kwargs.get('xtitle', "") ytitle = kwargs.get('ytitle', "") rtitle = kwargs.get('rtitle', "Ratio") xmin = kwargs.get('xmin', hists[0].GetXaxis().GetXmin()) xmax = kwargs.get('xmax', hists[0].GetXaxis().GetXmax()) ymin = kwargs.get('ymin', None) ymax = kwargs.get('ymax', None) rmin = kwargs.get('rmin', 0.45) rmax = kwargs.get('rmax', 1.55) logx = kwargs.get('logx', False) logy = kwargs.get('logy', False) denom = kwargs.get('denom', 1) - 1 # denominator for ratio textsize = kwargs.get('textsize', 0.045) texts = kwargs.get('text', []) width = kwargs.get('width', 0.26) #textheight = kwargs.get('textheight', 1.09 ) #ctext = kwargs.get('ctext', [ ] ) # corner text #cposition = kwargs.get('cposition', 'topleft' ).lower() # cornertext #ctextsize = kwargs.get('ctextsize', 1.4*legendtextsize ) colors = kwargs.get('colors', linecolors) if not isinstance(texts, list) or isinstance(texts, tuple): texts = [texts] if ymax == None: ymax = 1.12 * max(h.GetMaximum() for h in hists) # MAIN plot canvas = TCanvas('canvas', 'canvas', 100, 100, 800, 800) canvas.SetFillColor(0) canvas.SetBorderMode(0) canvas.SetFrameBorderMode(0) canvas.Divide(2) canvas.SetMargin(0.0, 0.0, 0.0, 0.0) canvas.cd(1) gPad.SetPad('pad1', 'pad1', 0, 0.33, 1, 1) gPad.SetMargin(0.12, 0.04, 0.02, 0.08) gPad.SetFillColor(0) gPad.SetBorderMode(0) gPad.SetTickx(0) gPad.SetTicky(0) gPad.SetGrid() gPad.Draw() canvas.cd(2) gPad.SetPad('pad2', 'pad2', 0, 0, 1, 0.33) gPad.SetMargin(0.12, 0.04, 0.30, 0.03) gPad.SetFillColor(0) gPad.SetFillStyle(4000) gPad.SetFrameFillStyle(0) gPad.SetBorderMode(0) gPad.Draw() # MAIN plot canvas.cd(1) for i, hist in enumerate(hists): color = colors[i % len(colors)] hist.SetLineColor(color) hist.SetLineWidth(2) hist.Draw('HIST SAME') frame = hists[0] frame.GetYaxis().SetTitleSize(0.060) frame.GetXaxis().SetTitleSize(0) frame.GetXaxis().SetLabelSize(0) frame.GetYaxis().SetLabelSize(0.052) frame.GetXaxis().SetLabelOffset(0.010) frame.GetXaxis().SetTitleOffset(0.98) frame.GetYaxis().SetTitleOffset(1.05) frame.GetXaxis().SetNdivisions(508) frame.GetYaxis().SetTitle(ytitle) frame.GetXaxis().SetTitle(xtitle) if logx: gPad.Update() gPad.SetLogx() if logy: gPad.Update() gPad.SetLogy() if ymin: frame.SetMinimum(ymin) if ymax: frame.SetMaximum(ymax) height = 1.1 * textsize * len([l for l in texts + hists if l]) x1, y1 = 0.90, 0.88 x2, y2 = x1 - width, y1 - height legend = TLegend(x1, y1, x2, y2) legend.SetTextSize(textsize) legend.SetBorderSize(0) legend.SetFillStyle(0) legend.SetFillColor(0) legend.SetMargin(0.05 / width) if title: legend.SetTextFont(62) legend.SetHeader(title) legend.SetTextFont(42) for hist in hists: legend.AddEntry(hist, hist.GetTitle(), 'l') for text in texts: legend.AddEntry(0, text, '') legend.Draw() gPad.SetTicks(1, 1) gPad.Modified() frame.Draw('AXIS SAME') CMS_style.CMS_lumi(gPad, 13, 0) # RATIO plot canvas.cd(2) ratios = [] for i, hist in enumerate(hists): if i == denom: continue ratio = hist.Clone(hist.GetName() + "_ratio") ratio.Divide(hists[denom]) for ibin in xrange(1, hist.GetXaxis().GetNbins() + 1): if hists[denom].GetBinContent(ibin) == 0: if hist.GetBinContent(ibin) == 0: ratio.SetBinContent(ibin, 1) else: ratio.SetBinContent(ibin, rmax + 1e5) ratio.Draw('HIST SAME') ratios.append(ratio) frame_ratio = ratios[0] frame_ratio.GetYaxis().SetRangeUser(rmin, rmax) frame_ratio.GetYaxis().CenterTitle() frame_ratio.GetYaxis().SetTitleSize(0.13) frame_ratio.GetXaxis().SetTitleSize(0.13) frame_ratio.GetXaxis().SetLabelSize(0.12) frame_ratio.GetYaxis().SetLabelSize(0.11) frame_ratio.GetXaxis().SetLabelOffset(0.012) frame_ratio.GetXaxis().SetTitleOffset(1.02) frame_ratio.GetYaxis().SetTitleOffset(0.48) frame_ratio.GetXaxis().SetNdivisions(508) frame_ratio.GetYaxis().CenterTitle(True) frame_ratio.GetYaxis().SetTitle(rtitle) frame_ratio.GetXaxis().SetTitle(xtitle) frame_ratio.GetYaxis().SetNdivisions(505) if logx: gPad.Update() gPad.SetLogx() line = TLine(xmin, 1., xmax, 1.) line.SetLineColor(hists[denom].GetLineColor()) line.SetLineWidth(hists[denom].GetLineWidth()) line.SetLineStyle(1) line.Draw('SAME') gPad.SetTicks(1, 1) gPad.Update() gPad.SetGrid() gPad.Modified() frame_ratio.Draw('SAME AXIS') canvas.SaveAs(name + ".png") canvas.SaveAs(name + ".pdf") canvas.Close()
def plotPValues(labels, masses0, **kwargs): print color("plotPValues()", color="magenta", prepend=">>>\n>>> ") # SIGNAL strength & mass bins = kwargs.get('bins', []) ymin = 0.00005 # LOOP over LABELS for label in labels: print color("plotPValues - %s" % (label), color="grey", prepend="\n>>> ") masses = array('d', []) zeros = array('d', []) limitObs = array('d', []) limitExps = [] up2s = [] for i, mass in enumerate(masses0): bin = -1 if bins: bin = bins[i] filename = getOutputFilename(label, mass, method="ProfileLikelihood", bin=bin, extralabel=".SignifObs") limitObs.append(getLimits(filename, brazilian=False)) masses.append(mass) zeros.append(0.0) v_masses = TVectorD(len(masses), masses) v_zeros = TVectorD(len(zeros), zeros) v_limitObs = TVectorD(len(limitObs), limitObs) v_limitExps = [] for limitExp in limitExps: v_limitExps.append(TVectorD(len(limitExp), limitExp)) W = 800 H = 600 T = 0.08 * H B = 0.12 * H L = 0.12 * W R = 0.04 * W canvas = TCanvas("canvas", "canvas", 100, 100, W, H) canvas.SetFillColor(0) canvas.SetBorderMode(0) canvas.SetFrameFillStyle(0) canvas.SetFrameBorderMode(0) canvas.SetLeftMargin(L / W) canvas.SetRightMargin(R / W) canvas.SetTopMargin(T / H) canvas.SetBottomMargin(B / H) canvas.SetTickx(0) canvas.SetTicky(0) canvas.SetGrid() canvas.SetLogy() # log canvas.cd() frame = canvas.DrawFrame(1.4, 0.001, 4.1, 10) frame.GetYaxis().CenterTitle() frame.GetYaxis().SetTitleSize(0.05) frame.GetXaxis().SetTitleSize(0.05) frame.GetXaxis().SetLabelSize(0.04) frame.GetYaxis().SetLabelSize(0.04) frame.GetYaxis().SetTitleOffset(1.14) frame.GetXaxis().SetNdivisions(508) frame.GetYaxis().CenterTitle(False) frame.GetYaxis().SetTitle("local p-value") #frame.GetYaxis().SetTitle("95% upper limit on #sigma / #sigma_{SM}") frame.GetXaxis().SetTitle("X#rightarrow#tau#tau mass [GeV]") frame.SetMinimum(ymin) frame.SetMaximum(1.5) frame.GetXaxis().SetLimits(min(masses), max(masses)) latex = TLatex() latex.SetTextSize(0.4 * canvas.GetTopMargin()) latex.SetTextColor(2) f1 = TF1("f1", "0.15866", min(masses), max(masses)) f1.SetLineColor(2) f1.SetLineWidth(2) f1.Draw("lsame") latex.DrawLatex(min(masses) + 1, 0.15866 * 1.1, "1#sigma") f2 = TF1("f2", "0.02275", min(masses), max(masses)) f2.SetLineColor(2) f2.SetLineWidth(2) f2.Draw("lsame") latex.DrawLatex(min(masses) + 1, 0.02275 * 1.1, "2#sigma") f3 = TF1("f3", "0.0013499", min(masses), max(masses)) f3.SetLineColor(2) f3.SetLineWidth(2) f3.Draw("lsame") latex.DrawLatex(min(masses) + 1, 0.0013499 * 1.1, "3#sigma") graph_limitExps = [] colors = [4, 2, 3, 6, 7, 8] for i, v_limitExp in enumerate(v_limitExps): graph_limitExps.append( TGraphAsymmErrors(v_masses, v_limitExp, v_zeros, v_zeros, v_zeros, v_zeros)) graph_limitExps[-1].SetLineColor(colors[i]) graph_limitExps[-1].SetLineWidth(2) graph_limitExps[-1].SetLineStyle(2) graph_limitExps[-1].Draw("Lsame") graph_limitObs = TGraphAsymmErrors(v_masses, v_limitObs, v_zeros, v_zeros, v_zeros, v_zeros) graph_limitObs.SetLineColor(1) graph_limitObs.SetLineWidth(2) graph_limitObs.Draw("Csame") CMS_lumi.CMS_lumi(canvas, 13, 0) gPad.SetTicks(1, 1) frame.Draw('sameaxis') x1 = 0.62 x2 = x1 + 0.24 y1 = 0.15 y2 = y1 + 0.20 legend = TLegend(x1, y1, x2, y2) legend.SetFillStyle(0) legend.SetBorderSize(0) legend.SetTextSize(0.041) legend.SetTextFont(42) legend.SetHeader("%s" % (label_dict[label])) legend.AddEntry(graph_limitObs, "observed", 'L') #p-value legend.Draw("same") gPad.RedrawAxis() print " " canvas.SaveAs("%s/p-value-local-%s.png" % (PLOTS_DIR, label)) canvas.SaveAs("%s/p-value-local-%s.pdf" % (PLOTS_DIR, label)) canvas.Close()
def plot_2D(): myfile = TFile(args.inputFile) mytree = gDirectory.Get("physics") mytree_weight = mytree.GetWeight()/1e3 trig_dec = "( passHLT == 1 )" lep_tag_trigmatch = "( lep_tag_isTrigMatched[0] == 1 && ( ( lep_tag_flavour[0] == 11 && lep_tag_pt[0] > 25e3 ) || ( lep_tag_flavour[0] == 13 && lep_tag_pt[0] > 22e3 ) ) )" lep_probe_trigmatch = "( lep_probe_isTrigMatched[0] == 1 && ( ( lep_probe_flavour[0] == 11 && lep_probe_pt[0] > 25e3 ) || ( lep_probe_flavour[0] == 13 && lep_probe_pt[0] > 22e3 ) ) )" el_tag_eta = "( TMath::Abs(el_tag_eta[0]) < 1.37 )" nbjets = "( njets_mv2c20_Fix77 > 0 )" njets = "( njets > 0 && njets < 4 )" nleptons = "( nlep == 2 && ( lep_pt[0] > 20e3 && lep_pt[1] > 20e3 ) )" same_sign = "( isSS01 == 1 )" # veto charge flips # ch_flip_veto = "( 1 )" if args.doChFlipVeto: ch_flip_veto = "( lep_isChFlip[0] == 0 && lep_isChFlip[1] == 0 )" # require at least 1 !prompt lepton # non_prompt = "( ( lep_truthType[0] != 6 && lep_truthType[0] != 2 ) || ( lep_truthType[1] != 6 && lep_truthType[1] != 2 ) )" # require at least one T lepton in the event # is_tight_event = "1" #"( isNonTightEvent == 0 )" # require tag lepton to be T # tight_tag = "( lep_tag_isTightSelected[0] == 1 )" hist_list_tag_MUPROBEEVT = {} hist_list_tag_ELPROBEEVT = {} set_fancy_2D_style() gStyle.SetPaintTextFormat("2.1f") # ----------------------------------------------------- dirname = "OutputPlots_TRUTH" if args.outdirname: dirname += ( "_" + args.outdirname ) try: os.makedirs(dirname) except: pass # ----------------------------------------------------- # ---------------- # Muon probe # ---------------- sel_FAKE_MUPROBEEVT_T = None # look only at OF region if args.channel == "OF": sel_FAKE_MUPROBEEVT_T = "(" + trig_dec + " && " + lep_tag_trigmatch + " && " + lep_probe_trigmatch + " && " + nleptons + " && " + same_sign + " && " + is_tight_event + " && " + tight_tag + " && " + "( (nmuon == 1 && nel == 1) && ( isProbeMuEvent == 1 ) && ( muon_probe_isTightSelected[0] == 1 ) )" + " && " + el_tag_eta + " && " + nbjets + " && " + njets + " && " + ch_flip_veto + " && " + non_prompt + ")" # look only at SF region elif args.channel == "SF": sel_FAKE_MUPROBEEVT_T = "(" + trig_dec + " && " + lep_tag_trigmatch + " && " + lep_probe_trigmatch + " && " + nleptons + " && " + same_sign + " && " + is_tight_event + " && " + tight_tag + " && " + "( ( nmuon == 2 ) && ( isProbeMuEvent == 1 ) && ( muon_probe_isTightSelected[0] == 1 ) )" + " && " + nbjets + " && " + njets + " && " + ch_flip_veto + " && " + non_prompt + ")" print "sel_FAKE_MUPROBEEVT_T: \n", sel_FAKE_MUPROBEEVT_T # histograms for tag (passing T: default) # h_taglep_FAKE_MUPROBEEVT_T_pt = TH2D("taglep_FAKE_MUPROBEEVT_T_pt", "taglep_FAKE_MUPROBEEVT_T_pt", 30, 20.0, 200.0, 30, 20.0, 200.0) hist_list_tag_MUPROBEEVT[h_taglep_FAKE_MUPROBEEVT_T_pt] = ["T","pt"] h_taglep_FAKE_MUPROBEEVT_T_ptvarcone30_over_pt = TH2D("taglep_FAKE_MUPROBEEVT_T_ptvarcone30_over_pt", "taglep_FAKE_MUPROBEEVT_T_ptvarcone30_over_pt", 20, 0.0, 0.1, 20, 0.0, 0.1) hist_list_tag_MUPROBEEVT[h_taglep_FAKE_MUPROBEEVT_T_ptvarcone30_over_pt] = ["T","ptvarcone30_over_pt"] h_taglep_FAKE_MUPROBEEVT_T_ptvarcone20_over_pt = TH2D("taglep_FAKE_MUPROBEEVT_T_ptvarcone20_over_pt", "taglep_FAKE_MUPROBEEVT_T_ptvarcone20_over_pt", 20, 0.0, 0.1, 20, 0.0, 0.1) hist_list_tag_MUPROBEEVT[h_taglep_FAKE_MUPROBEEVT_T_ptvarcone20_over_pt] = ["T","ptvarcone20_over_pt"] h_taglep_FAKE_MUPROBEEVT_T_topoetcone20_over_pt = TH2D("taglep_FAKE_MUPROBEEVT_T_topoetcone20_over_pt", "taglep_FAKE_MUPROBEEVT_T_topoetcone20_over_pt", 20, -0.1, 0.1, 20, -0.1, 0.1) hist_list_tag_MUPROBEEVT[h_taglep_FAKE_MUPROBEEVT_T_topoetcone20_over_pt] = ["T","topoetcone20_over_pt"] h_taglep_FAKE_MUPROBEEVT_T_pt.GetXaxis().SetTitle("REAL pT [GeV]") h_taglep_FAKE_MUPROBEEVT_T_ptvarcone30_over_pt.GetXaxis().SetTitle("REAL ptvarcone30/pT") h_taglep_FAKE_MUPROBEEVT_T_topoetcone20_over_pt.GetXaxis().SetTitle("REAL topoetcone20/pT") h_taglep_FAKE_MUPROBEEVT_T_pt.GetYaxis().SetTitle("FAKE pT [GeV]") h_taglep_FAKE_MUPROBEEVT_T_ptvarcone30_over_pt.GetYaxis().SetTitle("FAKE ptvarcone30/pT") h_taglep_FAKE_MUPROBEEVT_T_topoetcone20_over_pt.GetYaxis().SetTitle("FAKE topoetcone20/pT") if args.channel == "OF": # probe is muon, tag is electron # mytree.Project("taglep_FAKE_MUPROBEEVT_T_pt", "muon_probe_pt[0]/1e3:el_tag_pt[0]/1e3", "%s * (%s)" %(mytree_weight, sel_FAKE_MUPROBEEVT_T), "" ) mytree.Project("taglep_FAKE_MUPROBEEVT_T_ptvarcone30_over_pt", "muon_probe_ptvarcone30[0]/muon_probe_pt[0]:el_tag_ptvarcone30[0]/el_tag_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_MUPROBEEVT_T), "" ) mytree.Project("taglep_FAKE_MUPROBEEVT_T_ptvarcone20_over_pt", "muon_probe_ptvarcone20[0]/muon_probe_pt[0]:el_tag_ptvarcone20[0]/el_tag_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_MUPROBEEVT_T), "" ) mytree.Project("taglep_FAKE_MUPROBEEVT_T_topoetcone20_over_pt", "muon_probe_topoetcone20[0]/muon_probe_pt[0]:el_tag_topoetcone20[0]/el_tag_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_MUPROBEEVT_T), "" ) elif args.channel == "SF": # probe is muon, tag is muon # mytree.Project("taglep_FAKE_MUPROBEEVT_T_pt", "muon_probe_pt[0]/1e3:muon_tag_pt[0]/1e3", "%s * (%s)" %(mytree_weight, sel_FAKE_MUPROBEEVT_T), "" ) mytree.Project("taglep_FAKE_MUPROBEEVT_T_ptvarcone30_over_pt", "muon_probe_ptvarcone30[0]/muon_probe_pt[0]:muon_tag_ptvarcone30[0]/muon_tag_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_MUPROBEEVT_T), "" ) # mytree.Project("taglep_FAKE_MUPROBEEVT_T_ptvarcone20_over_pt", "muon_probe_ptvarcone20[0]/muon_probe_pt[0]:muon_tag_ptvarcone20[0]/muon_tag_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_MUPROBEEVT_T), "" ) mytree.Project("taglep_FAKE_MUPROBEEVT_T_topoetcone20_over_pt", "muon_probe_topoetcone20[0]/muon_probe_pt[0]:muon_tag_topoetcone20[0]/muon_tag_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_MUPROBEEVT_T), "" ) # Normalise to unity if args.doNorm: for hist in hist_list_tag_MUPROBEEVT.keys(): if hist.Integral() == 0: continue hist.Scale(1/hist.Integral()) # now plot # print "\tLooking at events where the PROBE is: {0} and the channel is {1}\n".format("MUON", args.channel) for hist_tag in hist_list_tag_MUPROBEEVT.keys(): c = TCanvas("c","Temp",50,50,900,900) legend_T = TLegend(0.4,0.8,0.6,0.85); # (x1,y1 (--> bottom left corner), x2, y2 (--> top right corner) ) legend_T.SetHeader("2 Lep SS Fake CR - T probe") legend_T.SetBorderSize(0) # no border legend_T.SetFillColor(0) # Legend background should be white legend_T.SetTextSize(0.04) # Increase entry font size! legend_T.SetTextFont(42) # Helvetica var_tag = hist_list_tag_MUPROBEEVT[hist_tag][1] type_tag = hist_list_tag_MUPROBEEVT[hist_tag][0] print "\tPlotting variable: {0}\n".format(var_tag) print "\ttag histogram name: {0}\n".format(hist_tag.GetName()) hist_tag.Draw("colz") legend_T.Draw() plotname = dirname + "/FAKE_MUPROBEEVT_" + var_tag c.SaveAs(plotname+".png") del c # ----------------------------------------------------- # --------------------- # Electron probe # --------------------- sel_FAKE_ELPROBEEVT_T = None # look only at OF region if args.channel == "OF": sel_FAKE_ELPROBEEVT_T = "(" + trig_dec + " && " + lep_tag_trigmatch + " && " + lep_probe_trigmatch + " && " + nleptons + " && " + same_sign + " && " + is_tight_event + " && " + tight_tag + " && " + "( (nmuon == 1 && nel == 1) && ( isProbeElEvent == 1 ) && ( el_probe_isTightSelected[0] == 1 ) )" + " && " + nbjets + " && " + njets + " && " + ch_flip_veto + " && " + non_prompt + ")" # look only at SF region elif args.channel == "SF": sel_FAKE_ELPROBEEVT_T = "(" + trig_dec + " && " + lep_tag_trigmatch + " && " + lep_probe_trigmatch + " && " + nleptons + " && " + same_sign + " && " + is_tight_event + " && " + tight_tag + " && " + "( ( nel == 2 ) && ( isProbeElEvent == 1 ) && ( el_probe_isTightSelected[0] == 1 ) )" + " && " + el_tag_eta + " && " + nbjets + " && " + njets + " && " + ch_flip_veto + " && " + non_prompt + ")" print "sel_FAKE_ELPROBEEVT_T: \n", sel_FAKE_ELPROBEEVT_T # histograms for tag (passing T: default) # h_taglep_FAKE_ELPROBEEVT_T_pt = TH2D("taglep_FAKE_ELPROBEEVT_T_pt", "taglep_FAKE_ELPROBEEVT_T_pt", 30, 20.0, 200.0, 30, 20.0, 200.0) hist_list_tag_ELPROBEEVT[h_taglep_FAKE_ELPROBEEVT_T_pt] = ["T","pt"] h_taglep_FAKE_ELPROBEEVT_T_ptvarcone30_over_pt = TH2D("taglep_FAKE_ELPROBEEVT_T_ptvarcone30_over_pt", "taglep_FAKE_ELPROBEEVT_T_ptvarcone30_over_pt", 20, 0.0, 0.1, 20, 0.0, 0.1) hist_list_tag_ELPROBEEVT[h_taglep_FAKE_ELPROBEEVT_T_ptvarcone30_over_pt] = ["T","ptvarcone30_over_pt"] h_taglep_FAKE_ELPROBEEVT_T_ptvarcone20_over_pt = TH2D("taglep_FAKE_ELPROBEEVT_T_ptvarcone20_over_pt", "taglep_FAKE_ELPROBEEVT_T_ptvarcone20_over_pt", 20, 0.0, 0.1, 20, 0.0, 0.1) hist_list_tag_ELPROBEEVT[h_taglep_FAKE_ELPROBEEVT_T_ptvarcone20_over_pt] = ["T","ptvarcone20_over_pt"] h_taglep_FAKE_ELPROBEEVT_T_topoetcone20_over_pt = TH2D("taglep_FAKE_ELPROBEEVT_T_topoetcone20_over_pt", "taglep_FAKE_ELPROBEEVT_T_topoetcone20_over_pt", 20, -0.1, 0.1, 20, -0.1, 0.1) hist_list_tag_ELPROBEEVT[h_taglep_FAKE_ELPROBEEVT_T_topoetcone20_over_pt] = ["T","topoetcone20_over_pt"] h_taglep_FAKE_ELPROBEEVT_T_pt.GetXaxis().SetTitle("REAL pT [GeV]") h_taglep_FAKE_ELPROBEEVT_T_ptvarcone20_over_pt.GetXaxis().SetTitle("REAL ptvarcone20/pT") h_taglep_FAKE_ELPROBEEVT_T_topoetcone20_over_pt.GetXaxis().SetTitle("REAL topoetcone20/pT") h_taglep_FAKE_ELPROBEEVT_T_pt.GetYaxis().SetTitle("FAKE pT [GeV]") h_taglep_FAKE_ELPROBEEVT_T_ptvarcone20_over_pt.GetYaxis().SetTitle("FAKE ptvarcone20/pT") h_taglep_FAKE_ELPROBEEVT_T_topoetcone20_over_pt.GetYaxis().SetTitle("FAKE topoetcone20/pT") if args.channel == "OF": # probe is el, tag is muon # mytree.Project("taglep_FAKE_ELPROBEEVT_T_pt", "el_probe_pt[0]/1e3:muon_tag_pt[0]/1e3", "%s * (%s)" %(mytree_weight, sel_FAKE_ELPROBEEVT_T), "" ) mytree.Project("taglep_FAKE_ELPROBEEVT_T_ptvarcone30_over_pt", "el_probe_ptvarcone30[0]/el_probe_pt[0]:muon_tag_ptvarcone30[0]/muon_tag_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_ELPROBEEVT_T), "" ) mytree.Project("taglep_FAKE_ELPROBEEVT_T_ptvarcone20_over_pt", "el_probe_ptvarcone20[0]/el_probe_pt[0]:muon_tag_ptvarcone20[0]/muon_tag_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_ELPROBEEVT_T), "" ) mytree.Project("taglep_FAKE_ELPROBEEVT_T_topoetcone20_over_pt", "el_probe_topoetcone20[0]/el_probe_pt[0]:muon_tag_topoetcone20[0]/muon_tag_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_ELPROBEEVT_T), "" ) elif args.channel == "SF": # probe is el, tag is el # mytree.Project("taglep_FAKE_ELPROBEEVT_T_pt", "el_probe_pt[0]/1e3:el_tag_pt[0]/1e3", "%s * (%s)" %(mytree_weight, sel_FAKE_ELPROBEEVT_T), "" ) #mytree.Project("taglep_FAKE_ELPROBEEVT_T_ptvarcone30_over_pt", "el_probe_ptvarcone30[0]/el_probe_pt[0]:el_tag_ptvarcone30[0]/el_tag_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_ELPROBEEVT_T), "" ) mytree.Project("taglep_FAKE_ELPROBEEVT_T_ptvarcone20_over_pt", "el_probe_ptvarcone20[0]/el_probe_pt[0]:el_tag_ptvarcone20[0]/el_tag_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_ELPROBEEVT_T), "" ) mytree.Project("taglep_FAKE_ELPROBEEVT_T_topoetcone20_over_pt", "el_probe_topoetcone20[0]/el_probe_pt[0]:el_tag_topoetcone20[0]/el_tag_pt[0]", "%s * (%s)" %(mytree_weight, sel_FAKE_ELPROBEEVT_T), "" ) # Normalise to unity if args.doNorm: for hist in hist_list_tag_ELPROBEEVT.keys(): if hist.Integral() == 0: continue hist.Scale(1/hist.Integral()) # now plot # print "\tLooking at events where the PROBE is: {0} and the channel is {1}\n".format("ELECTRON", args.channel) for hist_tag in hist_list_tag_ELPROBEEVT.keys(): c = TCanvas("c","Temp",50,50,900,900) legend_T = TLegend(0.4,0.8,0.6,0.85); # (x1,y1 (--> bottom left corner), x2, y2 (--> top right corner) ) legend_T.SetHeader("2 Lep SS Fake CR - T probe") legend_T.SetBorderSize(0) # no border legend_T.SetFillColor(0) # Legend background should be white legend_T.SetTextSize(0.04) # Increase entry font size! legend_T.SetTextFont(42) # Helvetica var_tag = hist_list_tag_ELPROBEEVT[hist_tag][1] type_tag = hist_list_tag_ELPROBEEVT[hist_tag][0] print "\tPlotting variable: {0}\n".format(var_tag) print "\ttag histogram name: {0}\n".format(hist_tag.GetName()) hist_tag.Draw("colz") legend_T.Draw() plotname = dirname + "/FAKE_ELPROBEEVT_" + var_tag c.SaveAs(plotname+".png") del c