ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/UserCode/jbabb/ScriptsAndMacros/DataPlotter.C
Revision: 1.1
Committed: Sat Sep 3 21:22:22 2011 UTC (13 years, 8 months ago) by jbabb
Content type: text/plain
Branch: MAIN
CVS Tags: HEAD
Error occurred while calculating annotation data.
Log Message: 
*** empty log message ***

File Contents

# Content
1 //
2 // A root macro to plot MC and data on the
3 // same histogram for a variety of different
4 // variables.
5 //
6 // John Babb 11/11/10
7 //
8
9 //ROOT includes
10 #include "TTree.h"
11 #include "TFile.h"
12 #include "TBranch.h"
13 #include "TLeafF.h"
14 #include "TLeafI.h"
15 #include "TH1F.h"
16 #include "TH2F.h"
17 #include "THStack.h"
18
19
20 //System includes
21 #include <TObject.h>
22 #include <TMinuit.h>
23 #include <TLorentzVector.h>
24 #include <TMath.h>
25 #include <TString.h>
26 #include <TStyle.h>
27 #include <TLegend.h>
28 #include <TCanvas.h>
29 #include <TPad.h>
30 #include <TGraphErrors.h>
31 #include <TSystem.h>
32 #include <vector>
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <iostream>
36 #include <string>
37
38
39
40
41 void DataPlotter() {
42
43 //Output file
44 TFile *f = new TFile("nTuplePlots.root", "recreate");
45
46 double ttbar_lumi = 3701947./(165.*0.85);//0.85 is from minuit scaling
47
48 double singletop_s_t_lumi = 259971./3.19;
49 double singletop_t_t_lumi = 3900171./41.92;
50 double singletop_tw_t_lumi = 814390./7.87;
51 double singletop_s_tbar_lumi = 137980./1.44;
52 double singletop_t_tbar_lumi = 1944826./22.63;
53 double singletop_tw_tbar_lumi = 809984./7.87;
54
55 //double ww_lumi = 2061760. / (27.79 * 1.);
56 //double wz_lumi = 2194752. / (10.4* 1.);
57 //double zz_lumi = 2113368. / (4.297 * 1.);
58 double qcd_lumi = 25064715. / (296600000. * 0.0002855);
59 //double wjets_lumi = 81352581. /(28000.);
60 //double zjets_lumi = 36277961. / 2800.;
61 double wjets_lumi = 81352581. /(31314.*0.78);//0.78 is from minuit scaling
62 double zjets_lumi = 36277961. / 3048.;
63 //double lumi_2011 = 835.;
64 double data_lumi = 835.;
65 //double data_lumi = 1564.;
66
67 /*
68 //minuit scales
69 double scale30 = 1.20176;
70 double scale31 = 0.99251;
71 double scale32 = 0.79793;
72 double scale40 = 1.21034;
73 double scale41 = 1.03571;
74 double scale42 = 0.87861;
75 */
76
77 //Minuit scales + qcd templating
78
79 //Preselection
80 /*
81 double scale30 = 1.20176*0.075;
82 double scale31 = 0.99251*0.038;
83 double scale32 = 0.79793*0.010;
84 double scale40 = 1.21034*0.056;
85 double scale41 = 1.03571*0.031;
86 double scale42 = 0.87861*0.009;
87
88
89 //ttbar tree
90 double scale30 = 1.20176*1.;
91 double scale31 = 0.99251*0.;
92 double scale32 = 0.79793*0.011;
93 double scale40 = 1.21034*0.022;
94 double scale41 = 1.03571*0.021;
95 double scale42 = 0.87861*0.008;
96
97
98 //zprime tree
99 double scale30 = 1.20176*0.;
100 double scale31 = 0.99251*0.009;
101 double scale32 = 0.79793*0.003;
102 double scale40 = 1.21034*0.016;
103 double scale41 = 1.03571*0.022;
104 double scale42 = 0.87861*0.012;
105 */
106
107
108 double scale30 = 0.;
109 double scale31 = 0.;
110 double scale32 = 0.;
111 double scale40 = 0.;
112 double scale41 = 0.;
113 double scale42 = 0.87861*0.012;
114
115
116
117 bool splitQCD = true;
118 bool splitTT = false;
119 bool splitWJ = false;
120 bool logScale = false;
121
122
123 bool reweight2010 = false;
124 bool reweight2011 = true;
125
126
127 TString weightBranch;
128
129 if (reweight2010) weightBranch = "mcWeight2010";
130 else if (reweight2011) weightBranch = "mcWeight2011";
131
132
133 TString path = "/uscms_data/d2/jbabb/CMSSW_4_2_5/src/TopQuarkAnalysis/Skynet/test/ZprimeTree/Skynet_ZPtree-n0p1_4j2b_";
134 TString qcdpath = "/uscms_data/d2/jbabb/CMSSW_4_2_5/src/TopQuarkAnalysis/Skynet/test/ZprimeTree/Skynet_ZPtree-n0p1_InvertedIsolation_";
135
136 //Get files
137 TFile *ttbar_file = new TFile(path+"TTbar.root", "open");
138 //TFile *ttbar_file1 = new TFile(path+"3jets0bjets_TTbar.root", "open");
139 //TFile *ttbar_file2 = new TFile(path+"3jets1bjets_TTbar.root", "open");
140 //TFile *ttbar_file3 = new TFile(path+"3jets2bjets_TTbar.root", "open");
141 //TFile *ttbar_file4 = new TFile(path+"4jets0bjets_TTbar.root", "open");
142 //TFile *ttbar_file5 = new TFile(path+"4jets1bjets_TTbar.root", "open");
143 //TFile *ttbar_file6 = new TFile(path+"4jets2bjets_TTbar.root", "open");
144 TFile *singletop_s_t_file = new TFile(path+"ST-s-T.root", "open");
145 TFile *singletop_t_t_file = new TFile(path+"ST-t-T.root", "open");
146 TFile *singletop_tw_t_file = new TFile(path+"ST-tW-T.root", "open");
147 TFile *singletop_s_tbar_file = new TFile(path+"ST-s-Tbar.root", "open");
148 TFile *singletop_t_tbar_file = new TFile(path+"ST-t-Tbar.root", "open");
149 TFile *singletop_tw_tbar_file = new TFile(path+"ST-tW-Tbar.root", "open");
150 //TFile *ww_file = new TFile(path+"WW.root", "open");
151 //TFile *wz_file = new TFile(path+"WZ.root", "open");
152 //TFile *zz_file = new TFile(path+"ZZ.root", "open");
153 TFile *qcd_file = new TFile(path+"QCD.root", "open");
154 TFile *qcd_file1 = new TFile(qcdpath+"3j0b_QCD.root", "open");
155 TFile *qcd_file2 = new TFile(qcdpath+"3j1b_QCD.root", "open");
156 TFile *qcd_file3 = new TFile(qcdpath+"3j2b_QCD.root", "open");
157 TFile *qcd_file4 = new TFile(qcdpath+"4j0b_QCD.root", "open");
158 TFile *qcd_file5 = new TFile(qcdpath+"4j1b_QCD.root", "open");
159 TFile *qcd_file6 = new TFile(qcdpath+"4j2b_QCD.root", "open");
160 TFile *wjets_file = new TFile(path+"WJets.root", "open");
161 //TFile *wjets_file1 = new TFile(path+"3jets0bjets_WJets.root", "open");
162 //TFile *wjets_file2 = new TFile(path+"3jets1bjets_WJets.root", "open");
163 //TFile *wjets_file3 = new TFile(path+"3jets2bjets_WJets.root", "open");
164 //TFile *wjets_file4 = new TFile(path+"4jets0bjets_WJets.root", "open");
165 //TFile *wjets_file5 = new TFile(path+"4jets1bjets_WJets.root", "open");
166 //TFile *wjets_file6 = new TFile(path+"4jets2bjets_WJets.root", "open");
167 TFile *zjets_file = new TFile(path+"ZJets.root", "open");
168 TFile *data_file = new TFile(path+"2011-835pb.root", "open");
169 //TFile *zprime750_file = new TFile(path+"Zprime750.root", "open");
170 //TFile *zprime1000_file = new TFile(path+"Zprime1000.root", "open");
171 //TFile *zprime1250_file = new TFile(path+"Zprime1250.root", "open");
172 //TFile *zprime1500_file = new TFile(path+"Zprime1500.root", "open");
173 //TFile *zprime2000_file = new TFile(path+"Zprime2000.root", "open");
174
175
176 //Get trees
177 TTree *ttbar_tree = (TTree*)ttbar_file ->Get("PATuple");
178 //TTree *ttbar_tree1 = (TTree*)ttbar_file1 ->Get("PATuple");
179 //TTree *ttbar_tree2 = (TTree*)ttbar_file2 ->Get("PATuple");
180 //TTree *ttbar_tree3 = (TTree*)ttbar_file3 ->Get("PATuple");
181 //TTree *ttbar_tree4 = (TTree*)ttbar_file4 ->Get("PATuple");
182 //TTree *ttbar_tree5 = (TTree*)ttbar_file5 ->Get("PATuple");
183 //TTree *ttbar_tree6 = (TTree*)ttbar_file6 ->Get("PATuple");
184 TTree *singletop_s_t_tree = (TTree*)singletop_s_t_file ->Get("PATuple");
185 TTree *singletop_t_t_tree = (TTree*)singletop_t_t_file ->Get("PATuple");
186 TTree *singletop_tw_t_tree = (TTree*)singletop_tw_t_file->Get("PATuple");
187 TTree *singletop_s_tbar_tree = (TTree*)singletop_s_tbar_file ->Get("PATuple");
188 TTree *singletop_t_tbar_tree = (TTree*)singletop_t_tbar_file ->Get("PATuple");
189 TTree *singletop_tw_tbar_tree = (TTree*)singletop_tw_tbar_file->Get("PATuple");
190 //TTree *ww_tree = (TTree*)ww_file ->Get("PATuple");
191 //TTree *wz_tree = (TTree*)wz_file ->Get("PATuple");
192 //TTree *zz_tree = (TTree*)zz_file ->Get("PATuple");
193 TTree *qcd_tree = (TTree*)qcd_file ->Get("PATuple");
194 TTree *qcd_tree1 = (TTree*)qcd_file1 ->Get("PATuple");
195 TTree *qcd_tree2 = (TTree*)qcd_file2 ->Get("PATuple");
196 TTree *qcd_tree3 = (TTree*)qcd_file3 ->Get("PATuple");
197 TTree *qcd_tree4 = (TTree*)qcd_file4 ->Get("PATuple");
198 TTree *qcd_tree5 = (TTree*)qcd_file5 ->Get("PATuple");
199 TTree *qcd_tree6 = (TTree*)qcd_file6 ->Get("PATuple");
200 TTree *wjets_tree = (TTree*)wjets_file ->Get("PATuple");
201 //TTree *wjets_tree1 = (TTree*)wjets_file1 ->Get("PATuple");
202 //TTree *wjets_tree2 = (TTree*)wjets_file2 ->Get("PATuple");
203 //TTree *wjets_tree3 = (TTree*)wjets_file3 ->Get("PATuple");
204 //TTree *wjets_tree4 = (TTree*)wjets_file4 ->Get("PATuple");
205 //TTree *wjets_tree5 = (TTree*)wjets_file5 ->Get("PATuple");
206 //TTree *wjets_tree6 = (TTree*)wjets_file6 ->Get("PATuple");
207 TTree *zjets_tree = (TTree*)zjets_file ->Get("PATuple");
208 TTree *data_tree = (TTree*)data_file ->Get("PATuple");
209 //TTree *zprime750_tree = (TTree*)zprime750_file ->Get("PATuple");
210 //TTree *zprime1000_tree = (TTree*)zprime1000_file ->Get("PATuple");
211 //TTree *zprime1250_tree = (TTree*)zprime1250_file ->Get("PATuple");
212 //TTree *zprime1500_tree = (TTree*)zprime1500_file ->Get("PATuple");
213 //TTree *zprime2000_tree = (TTree*)zprime2000_file ->Get("PATuple");
214
215
216 //List the variables that we want plots of
217 int nVariables = 47;
218 int nBins;
219
220 TString VariableList[] = {
221 "unfittedEvent_ttInvariantMass", "unfittedHadTopMass", "unfittedLepTopMass", "HtJets",
222 "HtJetsLepMET", "drMinMuJ_smuon", "drMaxMuJ_smuon", "dPhiMuMET_smuon", "aplanarity",
223 "centrality", "drJ1J2", "drJ1J3", "drJ2J3", "drMinJ1", "drMinJ2", "drMinJ3", "met",
224 "pt_jet1", "pt_jet2", "pt_jet3", "pt_smuon", "sphericity", "tt_dR", "tt_dPhi", "tt_dTheta",
225 "unfittedHadWMass", "unfittedHadWE", "unfittedHadWPt", "unfittedLepWMass", "unfittedLepWE",
226 "unfittedLepWPt", "unfittedHadTopE", "unfittedHadTopPt", "unfittedLepTopE", "unfittedLepTopPt",
227 "ptRel_muon", "relIso_muon", "pfIso_muon", "MMuJet1_smuon", "MJ1J2J3", "MJ1J2", "MJ1J3", "MJ2J3",
228 "topPtDiff", "topMassDiff", "nHardJets", "bJets"
229 };
230
231 double VariableMax[] = { 2200., 750., 500., 2000., 2000., 3., 5., 3.2, 0.3,
232 1.0, 5., 5., 5., 5., 5., 5., 500., 750., 500., 300., 500., 1., 5., 3., 3.,
233 300., 1000., 500., 200., 1000., 500., 1000., 750., 1000., 750., 350., 1.,
234 2., 1000., 1500., 1000., 1000., 1000., 400., 400., 8., 5.
235 };
236
237 double VariableMin[] = { 200., 100., 100., 100., 150., 0., 1.5, 0.0, 0.0,
238 0.0, 0., 0., 0., 0., 0., 0., 20., 40., 30., 20., 20., 0., 0., 0., 0.,
239 50., 0., 0., 70., 50., 0., 50., 0., 100., 0., 0., 0.,
240 0., 0., 0., 0., 0., 0., 0., 0., 3., 0.
241 };
242
243 TString TitleList[] = {
244 "M_{t#bar{t}} (GeV)", "M_{HadTop} (GeV)", "M_{LepTop} (GeV)", "H_{T} Jets (GeV)",
245 "H_{T} Jets+Leps (GeV)", "#Delta R_{Min}(#mu, Jet)", "#Delta R_{Max}(#mu, Jet)", "#Delta #phi (#mu, MET)", "Aplanarity",
246 "Centrality", "#Delta R(Jet1,Jet2)", "#Delta R(Jet1,Jet3)", "#Delta R(Jet2,Jet3)", "#Delta R_{Min} (Jet1, nearest Jet)",
247 "#Delta R_{Min} (Jet2, nearest Jet)", "#Delta R_{Min} (Jet3, nearest Jet)", "MET (GeV)",
248 "p_{T}^{Jet1} (GeV)", "p_{T}^{Jet2} (GeV)", "p_{T}^{Jet3} (GeV)", "p_{T}^{#mu} (GeV)", "Sphericity", "#Delta R t#bar{t}",
249 "#Delta #phi t#bar{t}", "#Delta #theta t#bar{t}",
250 "M_{HadW} (GeV)", "E_{HadW} (GeV)", "p_{T}^{HadW} (GeV)", "M_{LepW} (GeV)", "E_{LepW} (GeV)",
251 "p_{T}^{LepW} (GeV)", "E_{HadTop} (GeV)", "p_{T}^{HadTop} (GeV)", "E_{LepTop} (GeV)", "p_{T}^{LepTop} (GeV)",
252 "p_{T}^{Rel} (#mu, jet) (GeV)", "relIso", "pfIso", "M_{(#mu,Jet1)} (GeV)", "M_{(Jet1, Jet2, Jet3)} (GeV) ",
253 "M_{(Jet1, Jet2)} (GeV) ", "M_{(Jet1, Jet3)} (GeV) ", "M_{(Jet2, Jet3)} (GeV) ",
254 "ttPtDifference (GeV)", "topMassDifference (GeV)", "nJets", "bJets"
255 };
256
257
258 TString PlotType = ".png";
259
260 //Loop over all of the variables we want to plot
261 for ( int i = 0; i < nVariables; i++ ) {
262
263
264
265 //gStyle->SetOptStat(0);
266
267
268
269 if (i == (nVariables-1) || i == (nVariables - 2)) nBins = 5;
270 else if (i == 0) nBins = 20;
271 else nBins = 15;
272
273
274 //Here take a variable and loop over it and fill histogram
275 //Must do this for each TTree, MC and data.
276
277 //Stack for the MC
278 THStack *hStk = new THStack( VariableList[i], VariableList[i] );
279
280
281 // TTbar
282 double ttscale = data_lumi / ttbar_lumi;
283
284 float tt;
285 float tt_w;
286
287 int entries_ttbar = ttbar_tree->GetEntries();
288 TH1F *ttPlot = new TH1F( "ttbar_"+VariableList[i], "ttbar_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
289 TBranch *TopBranch = ttbar_tree->GetBranch( VariableList[i] );
290 if (reweight2010 || reweight2011) TBranch *TopWeights = ttbar_tree->GetBranch( weightBranch );
291
292 TopBranch ->SetAddress(&tt);
293 if (reweight2010 || reweight2011) TopWeights->SetAddress(&tt_w);
294
295
296 TCanvas* c1 = new TCanvas();
297 c1->cd();
298
299 for ( int j = 0; j < entries_ttbar; j++ ) {
300
301
302 TopBranch->GetEntry(j);
303 if (reweight2010 || reweight2011) TopWeights->GetEntry(j);
304
305 if (reweight2010 || reweight2011) ttPlot->Fill(tt, tt_w);
306 else ttPlot->Fill(tt);
307
308 }
309
310 ttPlot->SetFillColor(kRed+1);
311
312 ttPlot->Scale( ttscale, "" );
313 if (logScale) c1->SetLogy();
314
315 ttPlot->Draw();
316
317 f->cd();
318
319 ttPlot->Write();
320
321 c1->Update();
322 //c1->Print( "TTbar_"+VariableList[i]+PlotType );
323 delete c1;
324
325
326 /*
327 float tt1;
328 float tt_w1;
329
330 int entries_ttbar1 = ttbar_tree1->GetEntries();
331 TH1F *TTPlot1 = new TH1F( "TTbar1_"+VariableList[i], "TTbar1_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
332 TBranch *TopBranch1 = ttbar_tree1->GetBranch( VariableList[i] );
333 if (reweight2010 || reweight2011) TBranch *TopWeights1 = ttbar_tree1->GetBranch( weightBranch );
334
335 TopBranch1->SetAddress(&tt1);
336 if (reweight2010 || reweight2011) TopWeights1->SetAddress(&tt_w1);
337
338
339 TCanvas* c1 = new TCanvas();
340 c1->cd();
341
342 for ( int j = 0; j < entries_ttbar1; j++ ) {
343
344
345 TopBranch1->GetEntry(j);
346 if (reweight2010 || reweight2011) TopWeights1->GetEntry(j);
347
348 if (reweight2010 || reweight2011) TTPlot1->Fill(tt1, tt_w1);
349 else TTPlot1->Fill(tt1);
350
351 }
352
353 TTPlot1->SetFillColor(kRed+1);
354
355 TTPlot1->Scale( ttscale*ttscale30, "" );
356 if (logScale) c1->SetLogy();
357
358 TTPlot1->Draw();
359
360 f->cd();
361
362 TTPlot1->Write();
363
364 c1->Update();
365 //c1->Print( "TTbar_"+VariableList[i]+PlotType );
366 delete c1;
367
368
369
370 float tt2;
371 float tt_w2;
372
373 int entries_ttbar2 = ttbar_tree2->GetEntries();
374 TH1F *TTPlot2 = new TH1F( "TTbar2_"+VariableList[i], "TTbar2_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
375 TBranch *TopBranch2 = ttbar_tree2->GetBranch( VariableList[i] );
376 if (reweight2010 || reweight2011) TBranch *TopWeights2 = ttbar_tree2->GetBranch( weightBranch );
377
378 TopBranch2->SetAddress(&tt2);
379 if (reweight2010 || reweight2011) TopWeights2->SetAddress(&tt_w2);
380
381
382 TCanvas* c1 = new TCanvas();
383 c1->cd();
384
385 for ( int j = 0; j < entries_ttbar2; j++ ) {
386
387
388 TopBranch2->GetEntry(j);
389 if (reweight2010 || reweight2011) TopWeights2->GetEntry(j);
390
391 if (reweight2010 || reweight2011) TTPlot2->Fill(tt2, tt_w2);
392 else TTPlot2->Fill(tt2);
393
394 }
395
396 TTPlot2->SetFillColor(kRed+1);
397
398 TTPlot2->Scale( ttscale*ttscale31, "" );
399 if (logScale) c1->SetLogy();
400
401 TTPlot2->Draw();
402
403 f->cd();
404
405 TTPlot2->Write();
406
407 c1->Update();
408 //c1->Print( "TTbar_"+VariableList[i]+PlotType );
409 delete c1;
410
411
412
413 float tt3;
414 float tt_w3;
415
416 int entries_ttbar3 = ttbar_tree3->GetEntries();
417 TH1F *TTPlot3 = new TH1F( "TTbar3_"+VariableList[i], "TTbar3_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
418 TBranch *TopBranch3 = ttbar_tree3->GetBranch( VariableList[i] );
419 if (reweight2010 || reweight2011) TBranch *TopWeights3 = ttbar_tree3->GetBranch( weightBranch );
420
421 TopBranch3->SetAddress(&tt3);
422 if (reweight2010 || reweight2011) TopWeights3->SetAddress(&tt_w3);
423
424
425 TCanvas* c1 = new TCanvas();
426 c1->cd();
427
428 for ( int j = 0; j < entries_ttbar3; j++ ) {
429
430
431 TopBranch3->GetEntry(j);
432 if (reweight2010 || reweight2011) TopWeights3->GetEntry(j);
433
434 if (reweight2010 || reweight2011) TTPlot3->Fill(tt3, tt_w3);
435 else TTPlot3->Fill(tt3);
436
437 }
438
439 TTPlot3->SetFillColor(kRed+1);
440
441 TTPlot3->Scale( ttscale*ttscale32, "" );
442 if (logScale) c1->SetLogy();
443
444 TTPlot3->Draw();
445
446 f->cd();
447
448 TTPlot3->Write();
449
450 c1->Update();
451 //c1->Print( "TTbar_"+VariableList[i]+PlotType );
452 delete c1;
453
454
455
456 float tt4;
457 float tt_w4;
458
459 int entries_ttbar4 = ttbar_tree4->GetEntries();
460 TH1F *TTPlot4 = new TH1F( "TTbar4_"+VariableList[i], "TTbar4_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
461 TBranch *TopBranch4 = ttbar_tree4->GetBranch( VariableList[i] );
462 if (reweight2010 || reweight2011) TBranch *TopWeights4 = ttbar_tree4->GetBranch( weightBranch );
463
464 TopBranch4->SetAddress(&tt4);
465 if (reweight2010 || reweight2011) TopWeights4->SetAddress(&tt_w4);
466
467
468 TCanvas* c1 = new TCanvas();
469 c1->cd();
470
471 for ( int j = 0; j < entries_ttbar4; j++ ) {
472
473
474 TopBranch4->GetEntry(j);
475 if (reweight2010 || reweight2011) TopWeights4->GetEntry(j);
476
477 if (reweight2010 || reweight2011) TTPlot4->Fill(tt4, tt_w4);
478 else TTPlot4->Fill(tt4);
479
480 }
481
482 TTPlot4->SetFillColor(kRed+1);
483
484 TTPlot4->Scale( ttscale*ttscale40, "" );
485 if (logScale) c1->SetLogy();
486
487 TTPlot4->Draw();
488
489 f->cd();
490
491 TTPlot4->Write();
492
493 c1->Update();
494 //c1->Print( "TTbar_"+VariableList[i]+PlotType );
495 delete c1;
496
497
498
499 float tt5;
500 float tt_w5;
501
502 int entries_ttbar5 = ttbar_tree5->GetEntries();
503 TH1F *TTPlot5 = new TH1F( "TTbar5_"+VariableList[i], "TTbar5_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
504 TBranch *TopBranch5 = ttbar_tree5->GetBranch( VariableList[i] );
505 if (reweight2010 || reweight2011) TBranch *TopWeights5 = ttbar_tree5->GetBranch( weightBranch );
506
507 TopBranch5->SetAddress(&tt5);
508 if (reweight2010 || reweight2011) TopWeights5->SetAddress(&tt_w5);
509
510
511 TCanvas* c1 = new TCanvas();
512 c1->cd();
513
514 for ( int j = 0; j < entries_ttbar5; j++ ) {
515
516 TopBranch5->GetEntry(j);
517 if (reweight2010 || reweight2011) TopWeights5->GetEntry(j);
518
519 if (reweight2010 || reweight2011) TTPlot5->Fill(tt5, tt_w5);
520 else TTPlot5->Fill(tt5);
521
522 }
523
524 TTPlot5->SetFillColor(kRed+1);
525
526 TTPlot5->Scale( ttscale*ttscale41, "" );
527 if (logScale) c1->SetLogy();
528
529 TTPlot5->Draw();
530
531 f->cd();
532
533 TTPlot5->Write();
534
535 c1->Update();
536 //c1->Print( "TTbar_"+VariableList[i]+PlotType );
537 delete c1;
538
539
540
541 float tt6;
542 float tt_w6;
543
544 int entries_ttbar6 = ttbar_tree6->GetEntries();
545 TH1F *TTPlot6 = new TH1F( "TTbar6_"+VariableList[i], "TTbar6_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
546 TBranch *TopBranch6 = ttbar_tree6->GetBranch( VariableList[i] );
547 if (reweight2010 || reweight2011) TBranch *TopWeights6 = ttbar_tree6->GetBranch( weightBranch );
548
549 TopBranch6->SetAddress(&tt6);
550 if (reweight2010 || reweight2011) TopWeights6->SetAddress(&tt_w6);
551
552
553 TCanvas* c1 = new TCanvas();
554 c1->cd();
555
556 for ( int j = 0; j < entries_ttbar6; j++ ) {
557
558
559 TopBranch6->GetEntry(j);
560 if (reweight2010 || reweight2011) TopWeights6->GetEntry(j);
561
562 if (reweight2010 || reweight2011) TTPlot6->Fill(tt6, tt_w6);
563 else TTPlot6->Fill(tt6);
564
565 }
566
567 TTPlot6->SetFillColor(kRed+1);
568
569 TTPlot6->Scale( ttscale*ttscale42, "" );
570 if (logScale) c1->SetLogy();
571
572 TTPlot6->Draw();
573
574 f->cd();
575
576 TTPlot6->Write();
577
578 c1->Update();
579 //c1->Print( "TTbar_"+VariableList[i]+PlotType );
580 delete c1;
581
582 */
583
584
585 //SingleTop_sChannel
586 float st_s_t;
587 float st_s_t_w;
588
589 int entries_st_s_t = singletop_s_t_tree->GetEntries();
590 TH1F *ST_s_t_Plot = new TH1F( "SingleTop_s_t_"+VariableList[i], "SingleTop_s_t_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
591 TBranch *ST_s_t_Branch = singletop_s_t_tree->GetBranch( VariableList[i] );
592 if (reweight2010 || reweight2011) TBranch *ST_s_t_Weights = singletop_s_t_tree->GetBranch( weightBranch );
593
594 ST_s_t_Branch->SetAddress(&st_s_t);
595 if (reweight2010 || reweight2011) ST_s_t_Weights->SetAddress(&st_s_t_w);
596
597 TCanvas* c2_s_t = new TCanvas();
598 c2_s_t->cd();
599
600 for ( int k = 0; k < entries_st_s_t; k++ ) {
601
602
603 ST_s_t_Branch->GetEntry(k);
604 if (reweight2010 || reweight2011) ST_s_t_Weights->GetEntry(k);
605
606 if (reweight2010 || reweight2011) ST_s_t_Plot->Fill(st_s_t, st_s_t_w);
607 else ST_s_t_Plot->Fill(st_s_t);
608
609 }
610
611 ST_s_t_Plot->SetFillColor(kMagenta);
612
613 double st_s_t_scale = data_lumi / singletop_s_t_lumi;
614 ST_s_t_Plot->Scale( st_s_t_scale, "" );
615
616 if (logScale) c2_s_t->SetLogy();
617
618 ST_s_t_Plot->Draw();
619
620 //f->cd();
621
622 //ST_s_Plot->Write();
623
624 c2_s_t->Update();
625 //c2_s->Print( "SingleTop_s_"+VariableList[i]+PlotType );
626 delete c2_s_t;
627
628
629
630 //SingleTop_tChannel
631 float st_t_t;
632 float st_t_t_w;
633
634 int entries_st_t_t = singletop_t_t_tree->GetEntries();
635 TH1F *ST_t_t_Plot = new TH1F( "SingleTop_t_t_"+VariableList[i], "SingleTop_t_t_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
636 TBranch *ST_t_t_Branch = singletop_t_t_tree->GetBranch( VariableList[i] );
637 if (reweight2010 || reweight2011) TBranch *ST_t_t_Weights = singletop_t_t_tree->GetBranch( weightBranch );
638
639 ST_t_t_Branch->SetAddress(&st_t_t);
640 if (reweight2010 || reweight2011) ST_t_t_Weights->SetAddress(&st_t_t_w);
641
642 TCanvas* c2_t_t = new TCanvas();
643 c2_t_t->cd();
644
645 for ( int k = 0; k < entries_st_t_t; k++ ) {
646
647 ST_t_t_Branch->GetEntry(k);
648 if (reweight2010 || reweight2011) ST_t_t_Weights->GetEntry(k);
649
650 if (reweight2010 || reweight2011) ST_t_t_Plot->Fill(st_t_t, st_t_t_w);
651 else ST_t_t_Plot->Fill(st_t_t);
652
653 }
654
655 ST_t_t_Plot->SetFillColor(kMagenta);
656
657 double st_t_t_scale = data_lumi / singletop_t_t_lumi;
658 ST_t_t_Plot->Scale( st_t_t_scale, "" );
659
660 if (logScale) c2_t_t->SetLogy();
661
662 ST_t_t_Plot->Draw();
663
664 //f->cd();
665
666 //ST_t_Plot->Write();
667
668 c2_t_t->Update();
669 //c2_t->Print( "SingleTop_t_"+VariableList[i]+PlotType );
670 delete c2_t_t;
671
672
673
674 //SingleTop_tChannel
675 float st_tw_t;
676 float st_tw_t_w;
677
678 int entries_st_tw_t = singletop_tw_t_tree->GetEntries();
679 TH1F *ST_tw_t_Plot = new TH1F( "SingleTop_tw_t_"+VariableList[i], "SingleTop_tw_t_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
680 TBranch *ST_tw_t_Branch = singletop_tw_t_tree->GetBranch( VariableList[i] );
681 if (reweight2010 || reweight2011) TBranch *ST_tw_t_Weights = singletop_tw_t_tree->GetBranch( weightBranch );
682
683 ST_tw_t_Branch->SetAddress(&st_tw_t);
684 if (reweight2010 || reweight2011) ST_tw_t_Weights->SetAddress(&st_tw_t_w);
685
686 TCanvas* c2_tw_t = new TCanvas();
687 c2_tw_t->cd();
688
689 for ( int k = 0; k < entries_st_tw_t; k++ ) {
690
691
692 ST_tw_t_Branch->GetEntry(k);
693 if (reweight2010 || reweight2011) ST_tw_t_Weights->GetEntry(k);
694
695 if (reweight2010 || reweight2011) ST_tw_t_Plot->Fill(st_tw_t, st_tw_t_w);
696 else ST_tw_t_Plot->Fill(st_tw_t);
697 }
698
699 ST_tw_t_Plot->SetFillColor(kMagenta);
700
701 double st_tw_t_scale = data_lumi / singletop_tw_t_lumi;
702 ST_tw_t_Plot->Scale( st_tw_t_scale, "" );
703
704 if (logScale) c2_tw_t->SetLogy();
705
706 ST_tw_t_Plot->Draw();
707
708 //f->cd();
709
710 //ST_tw_Plot->Write();
711
712 c2_tw_t->Update();
713 //c2_tw->Print( "SingleTop_tw_"+VariableList[i]+PlotType );
714 delete c2_tw_t;
715
716
717
718
719
720 //SingleTop_sChannel
721 float st_s_tbar;
722 float st_s_tbar_w;
723
724 int entries_st_s_tbar = singletop_s_tbar_tree->GetEntries();
725 TH1F *ST_s_tbar_Plot = new TH1F( "SingleTop_s_tbar_"+VariableList[i], "SingleTop_s_tbar_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
726 TBranch *ST_s_tbar_Branch = singletop_s_tbar_tree->GetBranch( VariableList[i] );
727 if (reweight2010 || reweight2011) TBranch *ST_s_tbar_Weights = singletop_s_tbar_tree->GetBranch( weightBranch );
728
729 ST_s_tbar_Branch->SetAddress(&st_s_tbar);
730 if (reweight2010 || reweight2011) ST_s_tbar_Weights->SetAddress(&st_s_tbar_w);
731
732 TCanvas* c2_s_tbar = new TCanvas();
733 c2_s_tbar->cd();
734
735 for ( int k = 0; k < entries_st_s_tbar; k++ ) {
736
737
738 ST_s_tbar_Branch->GetEntry(k);
739 if (reweight2010 || reweight2011) ST_s_tbar_Weights->GetEntry(k);
740
741 if (reweight2010 || reweight2011) ST_s_tbar_Plot->Fill(st_s_tbar, st_s_tbar_w);
742 else ST_s_tbar_Plot->Fill(st_s_tbar);
743
744 }
745
746 ST_s_tbar_Plot->SetFillColor(kMagenta);
747
748 double st_s_tbar_scale = data_lumi / singletop_s_tbar_lumi;
749 ST_s_tbar_Plot->Scale( st_s_tbar_scale, "" );
750
751 if (logScale) c2_s_tbar->SetLogy();
752
753 ST_s_tbar_Plot->Draw();
754
755 //f->cd();
756
757 //ST_s_Plot->Write();
758
759 c2_s_tbar->Update();
760 //c2_s->Print( "SingleTop_s_"+VariableList[i]+PlotType );
761 delete c2_s_tbar;
762
763
764
765
766 //SingleTop_tChannel
767 float st_t_tbar;
768 float st_t_tbar_w;
769
770 int entries_st_t_tbar = singletop_t_tbar_tree->GetEntries();
771 TH1F *ST_t_tbar_Plot = new TH1F( "SingleTop_t_tbar_"+VariableList[i], "SingleTop_t_tbar_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
772 TBranch *ST_t_tbar_Branch = singletop_t_tbar_tree->GetBranch( VariableList[i] );
773 if (reweight2010 || reweight2011) TBranch *ST_t_tbar_Weights = singletop_t_tbar_tree->GetBranch( weightBranch );
774
775 ST_t_tbar_Branch->SetAddress(&st_t_tbar);
776 if (reweight2010 || reweight2011) ST_t_tbar_Weights->SetAddress(&st_t_tbar_w);
777
778 TCanvas* c2_t_tbar = new TCanvas();
779 c2_t_tbar->cd();
780
781 for ( int k = 0; k < entries_st_t_tbar; k++ ) {
782
783 ST_t_tbar_Branch->GetEntry(k);
784 if (reweight2010 || reweight2011) ST_t_tbar_Weights->GetEntry(k);
785
786 if (reweight2010 || reweight2011) ST_t_tbar_Plot->Fill(st_t_tbar, st_t_tbar_w);
787 else ST_t_tbar_Plot->Fill(st_t_tbar);
788
789 }
790
791 ST_t_tbar_Plot->SetFillColor(kMagenta);
792
793 double st_t_tbar_scale = data_lumi / singletop_t_tbar_lumi;
794 ST_t_tbar_Plot->Scale( st_t_tbar_scale, "" );
795
796 if (logScale) c2_t_tbar->SetLogy();
797
798 ST_t_tbar_Plot->Draw();
799
800 //f->cd();
801
802 //ST_t_Plot->Write();
803
804 c2_t_tbar->Update();
805 //c2_t->Print( "SingleTop_t_"+VariableList[i]+PlotType );
806 delete c2_t_tbar;
807
808
809
810
811 //SingleTop_tChannel
812 float st_tw_tbar;
813 float st_tw_tbar_w;
814
815 int entries_st_tw_tbar = singletop_tw_tbar_tree->GetEntries();
816 TH1F *ST_tw_tbar_Plot = new TH1F( "SingleTop_tw_tbar_"+VariableList[i], "SingleTop_tw_tbar_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
817 TBranch *ST_tw_tbar_Branch = singletop_tw_tbar_tree->GetBranch( VariableList[i] );
818 if (reweight2010 || reweight2011) TBranch *ST_tw_tbar_Weights = singletop_tw_tbar_tree->GetBranch( weightBranch );
819
820 ST_tw_tbar_Branch->SetAddress(&st_tw_tbar);
821 if (reweight2010 || reweight2011) ST_tw_tbar_Weights->SetAddress(&st_tw_tbar_w);
822
823 TCanvas* c2_tw_tbar = new TCanvas();
824 c2_tw_tbar->cd();
825
826 for ( int k = 0; k < entries_st_tw_tbar; k++ ) {
827
828
829 ST_tw_tbar_Branch->GetEntry(k);
830 if (reweight2010 || reweight2011) ST_tw_tbar_Weights->GetEntry(k);
831
832 if (reweight2010 || reweight2011) ST_tw_tbar_Plot->Fill(st_tw_tbar, st_tw_tbar_w);
833 else ST_tw_tbar_Plot->Fill(st_tw_tbar);
834 }
835
836 ST_tw_tbar_Plot->SetFillColor(kMagenta);
837
838 double st_tw_tbar_scale = data_lumi / singletop_tw_tbar_lumi;
839 ST_tw_tbar_Plot->Scale( st_tw_tbar_scale, "" );
840
841 if (logScale) c2_tw_tbar->SetLogy();
842
843 ST_tw_tbar_Plot->Draw();
844
845 //f->cd();
846
847 //ST_tw_Plot->Write();
848
849 c2_tw_tbar->Update();
850 //c2_tw->Print( "SingleTop_tw_"+VariableList[i]+PlotType );
851 delete c2_tw_tbar;
852
853
854
855
856
857
858 //WJets
859 double wjscale = data_lumi / wjets_lumi;
860
861 float wj;
862 float wj_w;
863
864 int entries_wj = wjets_tree->GetEntries();
865 TH1F *wjPlot = new TH1F( "wjets_"+VariableList[i], "wjets_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
866 TBranch *WJBranch = wjets_tree->GetBranch( VariableList[i] );
867 if (reweight2010 || reweight2011) TBranch *WJWeights = wjets_tree->GetBranch(weightBranch);
868
869 WJBranch->SetAddress(&wj);
870 if (reweight2010 || reweight2011) WJWeights->SetAddress(&wj_w);
871
872 TCanvas* c3 = new TCanvas();
873 c3->cd();
874
875 for ( int l = 0; l < entries_wj; l++ ) {
876
877 WJBranch->GetEntry(l);
878 if (reweight2010 || reweight2011) WJWeights->GetEntry(l);
879 if (reweight2010 || reweight2011) wjPlot->Fill(wj, wj_w);
880 else wjPlot->Fill(wj);
881
882 }
883
884 wjPlot->SetFillColor(kGreen);
885
886 wjPlot->Scale( wjscale, "" );
887
888 if (logScale) c3->SetLogy();
889
890 wjPlot->Draw();
891
892 f->cd();
893
894 wjPlot->Write();
895
896 c3->Update();
897 //c3->Print( "WJets_"+VariableList[i]+PlotType );
898 delete c3;
899
900
901 /*
902
903 float wj1;
904 float wj_w1;
905
906 int entries_wj1 = wjets_tree1->GetEntries();
907 TH1F *WJPlot1 = new TH1F( "WJets1_"+VariableList[i], "WJets1_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
908 TBranch *WJBranch1 = wjets_tree1->GetBranch( VariableList[i] );
909 if (reweight2010 || reweight2011) TBranch *WJWeights1 = wjets_tree1->GetBranch(weightBranch);
910
911 WJBranch1->SetAddress(&wj1);
912 if (reweight2010 || reweight2011) WJWeights1->SetAddress(&wj_w1);
913
914 TCanvas* c3 = new TCanvas();
915 c3->cd();
916
917 for ( int l = 0; l < entries_wj1; l++ ) {
918
919 WJBranch1->GetEntry(l);
920 if (reweight2010 || reweight2011) WJWeights1->GetEntry(l);
921 if (reweight2010 || reweight2011) WJPlot1->Fill(wj1, wj_w1);
922 else WJPlot1->Fill(wj1);
923
924 }
925
926 WJPlot1->SetFillColor(kGreen);
927
928 WJPlot1->Scale( wjscale*wjscale30, "" );
929
930 if (logScale) c3->SetLogy();
931
932 WJPlot1->Draw();
933
934 f->cd();
935
936 WJPlot1->Write();
937
938 c3->Update();
939 //c3->Print( "WJets_"+VariableList[i]+PlotType );
940 delete c3;
941
942
943
944
945 float wj2;
946 float wj_w2;
947
948 int entries_wj2 = wjets_tree2->GetEntries();
949 TH1F *WJPlot2 = new TH1F( "WJets2_"+VariableList[i], "WJets2_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
950 TBranch *WJBranch2 = wjets_tree2->GetBranch( VariableList[i] );
951 if (reweight2010 || reweight2011) TBranch *WJWeights2 = wjets_tree2->GetBranch(weightBranch);
952
953 WJBranch2->SetAddress(&wj2);
954 if (reweight2010 || reweight2011) WJWeights2->SetAddress(&wj_w2);
955
956 TCanvas* c3 = new TCanvas();
957 c3->cd();
958
959 for ( int l = 0; l < entries_wj2; l++ ) {
960
961 WJBranch2->GetEntry(l);
962 if (reweight2010 || reweight2011) WJWeights2->GetEntry(l);
963 if (reweight2010 || reweight2011) WJPlot2->Fill(wj2, wj_w2);
964 else WJPlot2->Fill(wj2);
965
966 }
967
968 WJPlot2->SetFillColor(kGreen);
969
970 WJPlot2->Scale( wjscale*wjscale31, "" );
971
972 if (logScale) c3->SetLogy();
973
974 WJPlot2->Draw();
975
976 f->cd();
977
978 WJPlot2->Write();
979
980 c3->Update();
981 //c3->Print( "WJets_"+VariableList[i]+PlotType );
982 delete c3;
983
984
985
986
987
988 float wj3;
989 float wj_w3;
990
991 int entries_wj3 = wjets_tree3->GetEntries();
992 TH1F *WJPlot3 = new TH1F( "WJets3_"+VariableList[i], "WJets3_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
993 TBranch *WJBranch3 = wjets_tree3->GetBranch( VariableList[i] );
994 if (reweight2010 || reweight2011) TBranch *WJWeights3 = wjets_tree3->GetBranch(weightBranch);
995
996 WJBranch3->SetAddress(&wj3);
997 if (reweight2010 || reweight2011) WJWeights3->SetAddress(&wj_w3);
998
999 TCanvas* c3 = new TCanvas();
1000 c3->cd();
1001
1002 for ( int l = 0; l < entries_wj3; l++ ) {
1003
1004 WJBranch3->GetEntry(l);
1005 if (reweight2010 || reweight2011) WJWeights3->GetEntry(l);
1006 if (reweight2010 || reweight2011) WJPlot3->Fill(wj3, wj_w3);
1007 else WJPlot3->Fill(wj3);
1008
1009 }
1010
1011 WJPlot3->SetFillColor(kGreen);
1012
1013 WJPlot3->Scale( wjscale*wjscale32, "" );
1014
1015 if (logScale) c3->SetLogy();
1016
1017 WJPlot3->Draw();
1018
1019 f->cd();
1020
1021 WJPlot3->Write();
1022
1023 c3->Update();
1024 //c3->Print( "WJets_"+VariableList[i]+PlotType );
1025 delete c3;
1026
1027
1028
1029
1030 float wj4;
1031 float wj_w4;
1032
1033 int entries_wj4 = wjets_tree4->GetEntries();
1034 TH1F *WJPlot4 = new TH1F( "WJets4_"+VariableList[i], "WJets4_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
1035 TBranch *WJBranch4 = wjets_tree4->GetBranch( VariableList[i] );
1036 if (reweight2010 || reweight2011) TBranch *WJWeights4 = wjets_tree4->GetBranch(weightBranch);
1037
1038 WJBranch4->SetAddress(&wj4);
1039 if (reweight2010 || reweight2011) WJWeights4->SetAddress(&wj_w4);
1040
1041 TCanvas* c3 = new TCanvas();
1042 c3->cd();
1043
1044 for ( int l = 0; l < entries_wj4; l++ ) {
1045
1046 WJBranch4->GetEntry(l);
1047 if (reweight2010 || reweight2011) WJWeights4->GetEntry(l);
1048 if (reweight2010 || reweight2011) WJPlot4->Fill(wj4, wj_w4);
1049 else WJPlot4->Fill(wj4);
1050
1051 }
1052
1053 WJPlot4->SetFillColor(kGreen);
1054
1055 WJPlot4->Scale( wjscale*wjscale40, "" );
1056
1057 if (logScale) c3->SetLogy();
1058
1059 WJPlot4->Draw();
1060
1061 f->cd();
1062
1063 WJPlot4->Write();
1064
1065 c3->Update();
1066 //c3->Print( "WJets_"+VariableList[i]+PlotType );
1067 delete c3;
1068
1069
1070
1071
1072 float wj5;
1073 float wj_w5;
1074
1075 int entries_wj5 = wjets_tree5->GetEntries();
1076 TH1F *WJPlot5 = new TH1F( "WJets5_"+VariableList[i], "WJets5_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
1077 TBranch *WJBranch5 = wjets_tree5->GetBranch( VariableList[i] );
1078 if (reweight2010 || reweight2011) TBranch *WJWeights5 = wjets_tree5->GetBranch(weightBranch);
1079
1080 WJBranch5->SetAddress(&wj5);
1081 if (reweight2010 || reweight2011) WJWeights5->SetAddress(&wj_w5);
1082
1083 TCanvas* c3 = new TCanvas();
1084 c3->cd();
1085
1086 for ( int l = 0; l < entries_wj5; l++ ) {
1087
1088 WJBranch5->GetEntry(l);
1089 if (reweight2010 || reweight2011) WJWeights5->GetEntry(l);
1090 if (reweight2010 || reweight2011) WJPlot5->Fill(wj5, wj_w5);
1091 else WJPlot5->Fill(wj5);
1092
1093 }
1094
1095 WJPlot5->SetFillColor(kGreen);
1096
1097 WJPlot5->Scale( wjscale*wjscale41, "" );
1098
1099 if (logScale) c3->SetLogy();
1100
1101 WJPlot5->Draw();
1102
1103 f->cd();
1104
1105 WJPlot5->Write();
1106
1107 c3->Update();
1108 //c3->Print( "WJets_"+VariableList[i]+PlotType );
1109 delete c3;
1110
1111
1112
1113
1114 float wj6;
1115 float wj_w6;
1116
1117 int entries_wj6 = wjets_tree6->GetEntries();
1118 TH1F *WJPlot6 = new TH1F( "WJets6_"+VariableList[i], "WJets6_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
1119 TBranch *WJBranch6 = wjets_tree6->GetBranch( VariableList[i] );
1120 if (reweight2010 || reweight2011) TBranch *WJWeights6 = wjets_tree6->GetBranch(weightBranch);
1121
1122 WJBranch6->SetAddress(&wj6);
1123 if (reweight2010 || reweight2011) WJWeights6->SetAddress(&wj_w6);
1124
1125 TCanvas* c3 = new TCanvas();
1126 c3->cd();
1127
1128 for ( int l = 0; l < entries_wj6; l++ ) {
1129
1130 WJBranch6->GetEntry(l);
1131 if (reweight2010 || reweight2011) WJWeights6->GetEntry(l);
1132 if (reweight2010 || reweight2011) WJPlot6->Fill(wj6, wj_w6);
1133 else WJPlot6->Fill(wj6);
1134
1135 }
1136
1137 WJPlot6->SetFillColor(kGreen);
1138
1139 WJPlot6->Scale( wjscale*wjscale42, "" );
1140
1141 if (logScale) c3->SetLogy();
1142
1143 WJPlot6->Draw();
1144
1145 f->cd();
1146
1147 WJPlot6->Write();
1148
1149 c3->Update();
1150 //c3->Print( "WJets_"+VariableList[i]+PlotType );
1151 delete c3;
1152
1153
1154 */
1155
1156
1157
1158 //ZJets
1159
1160 float zj;
1161 float zj_w;
1162
1163 int entries_zj = zjets_tree->GetEntries();
1164 TH1F *ZJPlot = new TH1F( "ZJets_"+VariableList[i], "ZJets_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
1165 TBranch *ZJBranch = zjets_tree->GetBranch( VariableList[i] );
1166 if (reweight2010 || reweight2011) TBranch *ZJWeights = zjets_tree->GetBranch( weightBranch );
1167
1168 ZJBranch->SetAddress(&zj);
1169 if (reweight2010 || reweight2011) ZJWeights->SetAddress(&zj_w);
1170
1171 TCanvas* c4 = new TCanvas();
1172 c4->cd();
1173
1174 for ( int m = 0; m < entries_zj; m++ ) {
1175
1176
1177 ZJBranch->GetEntry(m);
1178 if (reweight2010 || reweight2011) ZJWeights->GetEntry(m);
1179 if (reweight2010 || reweight2011) ZJPlot->Fill(zj, zj_w);
1180 else ZJPlot->Fill(zj);
1181
1182 }
1183
1184 ZJPlot->SetFillColor(kAzure-2);
1185
1186 double zjscale = data_lumi / zjets_lumi;
1187 ZJPlot->Scale( zjscale, "" );
1188
1189 if (logScale) c4->SetLogy();
1190
1191 ZJPlot->Draw();
1192
1193 f->cd();
1194
1195 ZJPlot->Write();
1196
1197 c4->Update();
1198 //c4->Print( "ZJets_"+VariableList[i]+PlotType );
1199 delete c4;
1200
1201
1202 /*
1203 //WW
1204
1205 float ww;
1206 float ww_w;
1207
1208 int entries_ww = ww_tree->GetEntries();
1209 TH1F *WWPlot = new TH1F( "WW_"+VariableList[i], "WW_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
1210 TBranch *WWBranch = ww_tree->GetBranch( VariableList[i] );
1211 if (reweight2010 || reweight2011) TBranch *WWWeights = ww_tree->GetBranch( weightBranch );
1212
1213 WWBranch->SetAddress(&ww);
1214 if (reweight2010 || reweight2011) WWWeights->SetAddress(&ww_w);
1215
1216 TCanvas* c5_ww = new TCanvas();
1217 c5_ww->cd();
1218
1219 for ( int n = 0; n < entries_ww; n++ ) {
1220
1221
1222 WWBranch->GetEntry(n);
1223 if (reweight2010 || reweight2011) WWWeights->GetEntry(n);
1224 if (reweight2010 || reweight2011) WWPlot->Fill(ww, ww_w);
1225 else WWPlot->Fill(ww);
1226
1227 }
1228
1229 WWPlot->SetFillColor(kBlue);
1230
1231 double wwscale = data_lumi / ww_lumi;
1232 WWPlot->Scale( wwscale, "" );
1233
1234 if (logScale) c5_ww->SetLogy();
1235
1236 WWPlot->Draw();
1237
1238 //f->cd();
1239
1240 //WWPlot->Write();
1241
1242 c5_ww->Update();
1243 //c5_ww->Print( "WW_"+VariableList[i]+PlotType );
1244 delete c5_ww;
1245
1246
1247
1248 //WZ
1249
1250 float wz;
1251 float wz_w;
1252
1253 int entries_wz = wz_tree->GetEntries();
1254 TH1F *WZPlot = new TH1F( "WZ_"+VariableList[i], "WZ_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
1255 TBranch *WZBranch = wz_tree->GetBranch( VariableList[i] );
1256 if (reweight2010 || reweight2011) TBranch *WZWeights = wz_tree->GetBranch( weightBranch );
1257
1258 WZBranch->SetAddress(&wz);
1259 if (reweight2010 || reweight2011) WZWeights->SetAddress(&wz_w);
1260
1261 TCanvas* c5_wz = new TCanvas();
1262 c5_wz->cd();
1263
1264 for ( int n = 0; n < entries_wz; n++ ) {
1265
1266
1267 WZBranch->GetEntry(n);
1268 if (reweight2010 || reweight2011) WZWeights->GetEntry(n);
1269 if (reweight2010 || reweight2011) WZPlot->Fill(wz, wz_w);
1270 else WZPlot->Fill(wz);
1271
1272 }
1273
1274 WZPlot->SetFillColor(kBlue);
1275
1276 double wzscale = data_lumi / wz_lumi;
1277 WZPlot->Scale( wzscale, "" );
1278
1279 if (logScale) c5_wz->SetLogy();
1280
1281 WZPlot->Draw();
1282
1283 //f->cd();
1284
1285 //WZPlot->Write();
1286
1287 c5_wz->Update();
1288 //c5_wz->Print( "WZ_"+VariableList[i]+PlotType );
1289
1290 delete c5_wz;
1291
1292
1293
1294 //ZZ
1295
1296 float zz;
1297 float zz_w;
1298
1299 int entries_zz = zz_tree->GetEntries();
1300 TH1F *ZZPlot = new TH1F( "ZZ_"+VariableList[i], "ZZ_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
1301 TBranch *ZZBranch = zz_tree->GetBranch( VariableList[i] );
1302 if (reweight2010 || reweight2011) TBranch *ZZWeights = zz_tree->GetBranch( weightBranch );
1303
1304 ZZBranch->SetAddress(&zz);
1305 if (reweight2010 || reweight2011) ZZWeights->SetAddress(&zz_w);
1306
1307 TCanvas* c5_zz = new TCanvas();
1308 c5_zz->cd();
1309
1310 for ( int n = 0; n < entries_zz; n++ ) {
1311
1312
1313 ZZBranch->GetEntry(n);
1314 if (reweight2010 || reweight2011) ZZWeights->GetEntry(n);
1315 if (reweight2010 || reweight2011) ZZPlot->Fill(zz, zz_w);
1316 else ZZPlot->Fill(zz);
1317
1318 }
1319
1320 ZZPlot->SetFillColor(kBlue);
1321
1322 double zzscale = data_lumi / zz_lumi;
1323 ZZPlot->Scale( zzscale, "" );
1324
1325 if (logScale) c5_zz->SetLogy();
1326
1327 ZZPlot->Draw();
1328
1329 //f->cd();
1330
1331 //ZZPlot->Write();
1332
1333 c5_zz->Update();
1334 //c5_zz->Print( "ZZ_"+VariableList[i]+PlotType );
1335 delete c5_zz;
1336
1337
1338 */
1339
1340
1341
1342
1343 //QCD
1344 double qcdscale = data_lumi / qcd_lumi;
1345
1346 float qcd1;
1347 float qcd_w1;
1348
1349 int entries_qcd1 = qcd_tree1->GetEntries();
1350 TH1F *QCDPlot1 = new TH1F( "QCD1_"+VariableList[i], "QCD1_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
1351 TBranch *QCDBranch1 = qcd_tree1->GetBranch( VariableList[i] );
1352 if (reweight2010 || reweight2011) TBranch *QCDWeights1 = qcd_tree1->GetBranch( weightBranch );
1353
1354 QCDBranch1->SetAddress(&qcd1);
1355 if (reweight2010 || reweight2011) QCDWeights1->SetAddress(&qcd_w1);
1356
1357 TCanvas* c6 = new TCanvas();
1358 c6->cd();
1359
1360 for ( int o = 0; o < entries_qcd1; o++ ) {
1361
1362
1363 QCDBranch1->GetEntry(o);
1364 if (reweight2010 || reweight2011) QCDWeights1->GetEntry(o);
1365 if (reweight2010 || reweight2011) QCDPlot1->Fill(qcd1, qcd_w1);
1366 else QCDPlot1->Fill(qcd1);
1367
1368 }
1369
1370 QCDPlot1->SetFillColor(kYellow);
1371
1372 QCDPlot1->Scale( qcdscale*scale30, "" );
1373
1374 if (logScale) c6->SetLogy();
1375
1376 QCDPlot1->Draw();
1377
1378 f->cd();
1379
1380 QCDPlot1->Write();
1381
1382 c6->Update();
1383 //c6->Print( "QCD_"+VariableList[i]+PlotType );
1384 delete c6;
1385
1386
1387
1388
1389
1390 float qcd2;
1391 float qcd_w2;
1392
1393 int entries_qcd2 = qcd_tree2->GetEntries();
1394 TH1F *QCDPlot2 = new TH1F( "QCD2_"+VariableList[i], "QCD2_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
1395 TBranch *QCDBranch2 = qcd_tree2->GetBranch( VariableList[i] );
1396 if (reweight2010 || reweight2011) TBranch *QCDWeights2 = qcd_tree2->GetBranch( weightBranch );
1397
1398 QCDBranch2->SetAddress(&qcd2);
1399 if (reweight2010 || reweight2011) QCDWeights2->SetAddress(&qcd_w2);
1400
1401 TCanvas* c6 = new TCanvas();
1402 c6->cd();
1403
1404 for ( int o = 0; o < entries_qcd2; o++ ) {
1405
1406
1407 QCDBranch2->GetEntry(o);
1408 if (reweight2010 || reweight2011) QCDWeights2->GetEntry(o);
1409 if (reweight2010 || reweight2011) QCDPlot2->Fill(qcd2, qcd_w2);
1410 else QCDPlot2->Fill(qcd2);
1411
1412 }
1413
1414 QCDPlot2->SetFillColor(kYellow);
1415
1416 QCDPlot2->Scale( qcdscale*scale31, "" );
1417
1418 if (logScale) c6->SetLogy();
1419
1420 QCDPlot2->Draw();
1421
1422 f->cd();
1423
1424 QCDPlot2->Write();
1425
1426 c6->Update();
1427 //c6->Print( "QCD_"+VariableList[i]+PlotType );
1428 delete c6;
1429
1430
1431
1432 float qcd3;
1433 float qcd_w3;
1434
1435 int entries_qcd3 = qcd_tree3->GetEntries();
1436 TH1F *QCDPlot3 = new TH1F( "QCD3_"+VariableList[i], "QCD3_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
1437 TBranch *QCDBranch3 = qcd_tree3->GetBranch( VariableList[i] );
1438 if (reweight2010 || reweight2011) TBranch *QCDWeights3 = qcd_tree3->GetBranch( weightBranch );
1439
1440 QCDBranch3->SetAddress(&qcd3);
1441 if (reweight2010 || reweight2011) QCDWeights3->SetAddress(&qcd_w3);
1442
1443 TCanvas* c6 = new TCanvas();
1444 c6->cd();
1445
1446 for ( int o = 0; o < entries_qcd3; o++ ) {
1447
1448
1449 QCDBranch3->GetEntry(o);
1450 if (reweight2010 || reweight2011) QCDWeights3->GetEntry(o);
1451 if (reweight2010 || reweight2011) QCDPlot3->Fill(qcd3, qcd_w3);
1452 else QCDPlot3->Fill(qcd3);
1453
1454 }
1455
1456 QCDPlot3->SetFillColor(kYellow);
1457
1458 QCDPlot3->Scale( qcdscale*scale32, "" );
1459
1460 if (logScale) c6->SetLogy();
1461
1462 QCDPlot3->Draw();
1463
1464 f->cd();
1465
1466 QCDPlot3->Write();
1467
1468 c6->Update();
1469 //c6->Print( "QCD_"+VariableList[i]+PlotType );
1470 delete c6;
1471
1472
1473
1474 float qcd4;
1475 float qcd_w4;
1476
1477 int entries_qcd4 = qcd_tree4->GetEntries();
1478 TH1F *QCDPlot4 = new TH1F( "QCD4_"+VariableList[i], "QCD4_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
1479 TBranch *QCDBranch4 = qcd_tree4->GetBranch( VariableList[i] );
1480 if (reweight2010 || reweight2011) TBranch *QCDWeights4 = qcd_tree4->GetBranch( weightBranch );
1481
1482 QCDBranch4->SetAddress(&qcd4);
1483 if (reweight2010 || reweight2011) QCDWeights4->SetAddress(&qcd_w4);
1484
1485 TCanvas* c6 = new TCanvas();
1486 c6->cd();
1487
1488 for ( int o = 0; o < entries_qcd4; o++ ) {
1489
1490
1491 QCDBranch4->GetEntry(o);
1492 if (reweight2010 || reweight2011) QCDWeights4->GetEntry(o);
1493 if (reweight2010 || reweight2011) QCDPlot4->Fill(qcd4, qcd_w4);
1494 else QCDPlot4->Fill(qcd4);
1495
1496 }
1497
1498 QCDPlot4->SetFillColor(kYellow);
1499
1500 double qcdscale = data_lumi / qcd_lumi;
1501 QCDPlot4->Scale( qcdscale*scale40, "" );
1502
1503 if (logScale) c6->SetLogy();
1504
1505 QCDPlot4->Draw();
1506
1507 f->cd();
1508
1509 QCDPlot4->Write();
1510
1511 c6->Update();
1512 //c6->Print( "QCD_"+VariableList[i]+PlotType );
1513 delete c6;
1514
1515
1516 float qcd5;
1517 float qcd_w5;
1518
1519 int entries_qcd5 = qcd_tree5->GetEntries();
1520 TH1F *QCDPlot5 = new TH1F( "QCD5_"+VariableList[i], "QCD5_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
1521 TBranch *QCDBranch5 = qcd_tree5->GetBranch( VariableList[i] );
1522 if (reweight2010 || reweight2011) TBranch *QCDWeights5 = qcd_tree5->GetBranch( weightBranch );
1523
1524 QCDBranch5->SetAddress(&qcd5);
1525 if (reweight2010 || reweight2011) QCDWeights5->SetAddress(&qcd_w5);
1526
1527 TCanvas* c6 = new TCanvas();
1528 c6->cd();
1529
1530 for ( int o = 0; o < entries_qcd5; o++ ) {
1531
1532
1533 QCDBranch5->GetEntry(o);
1534 if (reweight2010 || reweight2011) QCDWeights5->GetEntry(o);
1535 if (reweight2010 || reweight2011) QCDPlot5->Fill(qcd5, qcd_w5);
1536 else QCDPlot5->Fill(qcd5);
1537
1538 }
1539
1540 QCDPlot5->SetFillColor(kYellow);
1541
1542 QCDPlot5->Scale( qcdscale*scale41, "" );
1543
1544 if (logScale) c6->SetLogy();
1545
1546 QCDPlot5->Draw();
1547
1548 f->cd();
1549
1550 QCDPlot5->Write();
1551
1552 c6->Update();
1553 //c6->Print( "QCD_"+VariableList[i]+PlotType );
1554 delete c6;
1555
1556
1557 float qcd6;
1558 float qcd_w6;
1559
1560 int entries_qcd6 = qcd_tree6->GetEntries();
1561 TH1F *QCDPlot6 = new TH1F( "QCD6_"+VariableList[i], "QCD6_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
1562 TBranch *QCDBranch6 = qcd_tree6->GetBranch( VariableList[i] );
1563 if (reweight2010 || reweight2011) TBranch *QCDWeights6 = qcd_tree6->GetBranch( weightBranch );
1564
1565 QCDBranch6->SetAddress(&qcd6);
1566 if (reweight2010 || reweight2011) QCDWeights6->SetAddress(&qcd_w6);
1567
1568 TCanvas* c6 = new TCanvas();
1569 c6->cd();
1570
1571 for ( int o = 0; o < entries_qcd6; o++ ) {
1572
1573
1574 QCDBranch6->GetEntry(o);
1575 if (reweight2010 || reweight2011) QCDWeights6->GetEntry(o);
1576 if (reweight2010 || reweight2011) QCDPlot6->Fill(qcd6, qcd_w6);
1577 else QCDPlot6->Fill(qcd6);
1578
1579 }
1580
1581 QCDPlot6->SetFillColor(kYellow);
1582
1583 QCDPlot6->Scale( qcdscale*scale42, "" );
1584
1585 if (logScale) c6->SetLogy();
1586
1587 QCDPlot6->Draw();
1588
1589 f->cd();
1590
1591 QCDPlot6->Write();
1592
1593 c6->Update();
1594 //c6->Print( "QCD_"+VariableList[i]+PlotType );
1595 delete c6;
1596
1597
1598
1599 float qcd;
1600 float qcd_w;
1601
1602 int entries_qcd = qcd_tree->GetEntries();
1603 TH1F *qcdPlot = new TH1F( "qcd_"+VariableList[i], "qcd_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
1604 TBranch *QCDBranch = qcd_tree->GetBranch( VariableList[i] );
1605 if (reweight2010 || reweight2011) TBranch *QCDWeights = qcd_tree->GetBranch( weightBranch );
1606
1607 QCDBranch->SetAddress(&qcd);
1608 if (reweight2010 || reweight2011) QCDWeights->SetAddress(&qcd_w);
1609
1610 TCanvas* c6 = new TCanvas();
1611 c6->cd();
1612
1613 for ( int o = 0; o < entries_qcd; o++ ) {
1614
1615
1616 QCDBranch->GetEntry(o);
1617 if (reweight2010 || reweight2011) QCDWeights->GetEntry(o);
1618 if (reweight2010 || reweight2011) qcdPlot->Fill(qcd, qcd_w);
1619 else qcdPlot->Fill(qcd);
1620
1621 }
1622
1623 qcdPlot->SetFillColor(kYellow);
1624
1625
1626 double qcdscale = data_lumi / qcd_lumi;
1627 qcdPlot->Scale( qcdscale, "" );
1628
1629 if (logScale) c6->SetLogy();
1630
1631 qcdPlot->Draw();
1632
1633 f->cd();
1634
1635 qcdPlot->Write();
1636
1637 c6->Update();
1638 //c6->Print( "QCD_"+VariableList[i]+PlotType );
1639 delete c6;
1640
1641
1642
1643
1644
1645 TCanvas* c6 = new TCanvas();
1646 c6->cd();
1647
1648 TH1F *QCDPlot = new TH1F( "QCD_"+VariableList[i], "QCD_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
1649
1650
1651 if (splitQCD){
1652 QCDPlot->Add(QCDPlot1);
1653 QCDPlot->Add(QCDPlot2);
1654 QCDPlot->Add(QCDPlot3);
1655 QCDPlot->Add(QCDPlot4);
1656 QCDPlot->Add(QCDPlot5);
1657 QCDPlot->Add(QCDPlot6);
1658 }
1659 else QCDPlot->Add(qcdPlot);
1660
1661 if (logScale) c6->SetLogy();
1662
1663 QCDPlot->SetFillColor(kYellow);
1664
1665 QCDPlot->Draw();
1666
1667 f->cd();
1668
1669 QCDPlot->Write();
1670
1671 c6->Update();
1672 //c6->Print( "QCD_"+VariableList[i]+PlotType );
1673 delete c6;
1674
1675
1676
1677
1678 TCanvas* c6 = new TCanvas();
1679 c6->cd();
1680
1681 TH1F *TTPlot = new TH1F( "TT_"+VariableList[i], "TT_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
1682
1683
1684 if (splitTT){
1685 TTPlot->Add(TTPlot1);
1686 TTPlot->Add(TTPlot2);
1687 TTPlot->Add(TTPlot3);
1688 TTPlot->Add(TTPlot4);
1689 TTPlot->Add(TTPlot5);
1690 TTPlot->Add(TTPlot6);
1691 }
1692 else TTPlot->Add(ttPlot);
1693
1694 if (logScale) c6->SetLogy();
1695
1696 TTPlot->SetFillColor(kRed+1);
1697
1698 TTPlot->Draw();
1699
1700 f->cd();
1701
1702 TTPlot->Write();
1703
1704 c6->Update();
1705 //c6->Print( "QCD_"+VariableList[i]+PlotType );
1706 delete c6;
1707
1708
1709
1710
1711 TCanvas* c6 = new TCanvas();
1712 c6->cd();
1713
1714 TH1F *WJPlot = new TH1F( "WJ_"+VariableList[i], "WJ_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
1715
1716
1717 if (splitWJ){
1718 WJPlot->Add(WJPlot1);
1719 WJPlot->Add(WJPlot2);
1720 WJPlot->Add(WJPlot3);
1721 WJPlot->Add(WJPlot4);
1722 WJPlot->Add(WJPlot5);
1723 WJPlot->Add(WJPlot6);
1724 }
1725 else WJPlot->Add(wjPlot);
1726
1727 if (logScale) c6->SetLogy();
1728
1729 WJPlot->SetFillColor(kGreen);
1730
1731 WJPlot->Draw();
1732
1733 f->cd();
1734
1735 WJPlot->Write();
1736
1737 c6->Update();
1738 //c6->Print( "QCD_"+VariableList[i]+PlotType );
1739 delete c6;
1740
1741
1742
1743
1744
1745 TCanvas* c6 = new TCanvas();
1746 c6->cd();
1747
1748 TH1F *STPlot = new TH1F( "ST_"+VariableList[i], "ST_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
1749
1750 if (logScale) c6->SetLogy();
1751
1752 STPlot->Add(ST_s_t_Plot);
1753 STPlot->Add(ST_t_t_Plot);
1754 STPlot->Add(ST_tw_t_Plot);
1755 STPlot->Add(ST_s_tbar_Plot);
1756 STPlot->Add(ST_t_tbar_Plot);
1757 STPlot->Add(ST_tw_tbar_Plot);
1758
1759 STPlot->SetFillColor(kMagenta);
1760
1761 STPlot->Draw();
1762
1763 f->cd();
1764
1765 STPlot->Write();
1766
1767 c6->Update();
1768 //c6->Print( "QCD_"+VariableList[i]+PlotType );
1769 delete c6;
1770
1771
1772
1773 /*
1774 TCanvas* c6 = new TCanvas();
1775 c6->cd();
1776
1777 TH1F *VVPlot = new TH1F( "VV_"+VariableList[i], "VV_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
1778
1779 if (logScale) c6->SetLogy();
1780
1781 VVPlot->Add(WWPlot);
1782 VVPlot->Add(WZPlot);
1783 VVPlot->Add(ZZPlot);
1784
1785 VVPlot->SetFillColor(kBlue);
1786
1787 VVPlot->Draw();
1788
1789 f->cd();
1790
1791 VVPlot->Write();
1792
1793 c6->Update();
1794 //c6->Print( "QCD_"+VariableList[i]+PlotType );
1795 delete c6;
1796 */
1797
1798
1799
1800
1801 //ZPrime
1802
1803 /*
1804 float zp750;
1805
1806 int entries_zp750 = zprime750_tree->GetEntries();
1807 TH1F *ZPrime750Plot = new TH1F( "ZPrime750_"+VariableList[i], "ZPrime750_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
1808 TBranch *ZPrime750Branch = zprime750_tree->GetBranch( VariableList[i] );
1809
1810 ZPrime750Branch->SetAddress(&zp750);
1811
1812 TCanvas* cz1 = new TCanvas("c1","", 800, 600);
1813 cz1->cd();
1814
1815 for ( int z1 = 0; z1 < entries_zp750; z1++ ) {
1816
1817 ZPrime750Branch->GetEntry(z1);
1818 ZPrime750Plot->Fill(zp750);
1819
1820 }
1821
1822 ZPrime750Plot->SetFillColor(kOrange);
1823
1824 //double zprimescale = data_lumi / zprime_lumi;
1825 //ZPrime750Plot->Scale( zprimescale, "" );
1826
1827
1828 ZPrime750Plot->Draw();
1829
1830 f->cd();
1831
1832 ZPrime750Plot->Write();
1833
1834 cz1->Update();
1835 //cz1->Print( "ZPrime750_"+VariableList[i]+PlotType );
1836 delete cz1;
1837
1838
1839
1840 float zp1000;
1841
1842 int entries_zp1000 = zprime1000_tree->GetEntries();
1843 TH1F *ZPrime1000Plot = new TH1F( "ZPrime1000_"+VariableList[i], "ZPrime1000_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
1844 TBranch *ZPrime1000Branch = zprime1000_tree->GetBranch( VariableList[i] );
1845
1846 ZPrime1000Branch->SetAddress(&zp1000);
1847
1848 TCanvas* cz2 = new TCanvas("c1","", 800, 600);
1849 cz2->cd();
1850
1851 for ( int z2 = 0; z2 < entries_zp1000; z2++ ) {
1852
1853 ZPrime1000Branch->GetEntry(z2);
1854 ZPrime1000Plot->Fill(zp1000);
1855
1856 }
1857
1858 ZPrime1000Plot->SetFillColor(kOrange);
1859
1860 //double zprimescale = data_lumi / zprime_lumi;
1861 //ZPrime1000Plot->Scale( zprimescale, "" );
1862
1863
1864 ZPrime1000Plot->Draw();
1865
1866 f->cd();
1867
1868 ZPrime1000Plot->Write();
1869
1870 cz2->Update();
1871 //cz2->Print( "ZPrime1000_"+VariableList[i]+PlotType );
1872 delete cz2;
1873
1874
1875
1876
1877
1878 float zp1250;
1879
1880 int entries_zp1250 = zprime1250_tree->GetEntries();
1881 TH1F *ZPrime1250Plot = new TH1F( "ZPrime1250_"+VariableList[i], "ZPrime1250_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
1882 TBranch *ZPrime1250Branch = zprime1250_tree->GetBranch( VariableList[i] );
1883
1884 ZPrime1250Branch->SetAddress(&zp1250);
1885
1886 TCanvas* cz3 = new TCanvas("c1","", 800, 600);
1887 cz3->cd();
1888
1889 for ( int z3 = 0; z3 < entries_zp1250; z3++ ) {
1890
1891 ZPrime1250Branch->GetEntry(z3);
1892 ZPrime1250Plot->Fill(zp1250);
1893
1894 }
1895
1896 ZPrime1250Plot->SetFillColor(kOrange);
1897
1898 //double zprimescale = data_lumi / zprime_lumi;
1899 //ZPrime1250Plot->Scale( zprimescale, "" );
1900
1901
1902 ZPrime1250Plot->Draw();
1903
1904 f->cd();
1905
1906 ZPrime1250Plot->Write();
1907
1908 cz3->Update();
1909 //cz3->Print( "ZPrime1250_"+VariableList[i]+PlotType );
1910 delete cz3;
1911
1912
1913
1914
1915 float zp1500;
1916
1917 int entries_zp1500 = zprime1500_tree->GetEntries();
1918 TH1F *ZPrime1500Plot = new TH1F( "ZPrime1500_"+VariableList[i], "ZPrime1500_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
1919 TBranch *ZPrime1500Branch = zprime1500_tree->GetBranch( VariableList[i] );
1920
1921 ZPrime1500Branch->SetAddress(&zp1500);
1922
1923 TCanvas* cz4 = new TCanvas("c1","", 800, 600);
1924 cz4->cd();
1925
1926 for ( int z4 = 0; z4 < entries_zp1500; z4++ ) {
1927
1928 ZPrime1500Branch->GetEntry(z4);
1929 ZPrime1500Plot->Fill(zp1500);
1930
1931 }
1932
1933 ZPrime1500Plot->SetFillColor(kOrange);
1934
1935 //double zprimescale = data_lumi / zprime_lumi;
1936 //ZPrime1500Plot->Scale( zprimescale, "" );
1937
1938
1939 ZPrime1500Plot->Draw();
1940
1941 f->cd();
1942
1943 ZPrime1500Plot->Write();
1944
1945 cz4->Update();
1946 //cz4->Print( "ZPrime1500_"+VariableList[i]+PlotType );
1947 delete cz4;
1948
1949
1950
1951
1952 float zp2000;
1953
1954 int entries_zp2000 = zprime2000_tree->GetEntries();
1955 TH1F *ZPrime2000Plot = new TH1F( "ZPrime2000_"+VariableList[i], "ZPrime2000_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
1956 TBranch *ZPrime2000Branch = zprime2000_tree->GetBranch( VariableList[i] );
1957
1958 ZPrime2000Branch->SetAddress(&zp2000);
1959
1960 TCanvas* cz5 = new TCanvas("c1","", 800, 600);
1961 cz5->cd();
1962
1963 for ( int z5 = 0; z5 < entries_zp2000; z5++ ) {
1964
1965 ZPrime2000Branch->GetEntry(z5);
1966 ZPrime2000Plot->Fill(zp2000);
1967
1968 }
1969
1970 ZPrime2000Plot->SetFillColor(kOrange);
1971
1972 //double zprimescale = data_lumi / zprime_lumi;
1973 //ZPrime2000Plot->Scale( zprimescale, "" );
1974
1975
1976 ZPrime2000Plot->Draw();
1977
1978 f->cd();
1979
1980 ZPrime2000Plot->Write();
1981
1982 cz5->Update();
1983 //cz5->Print( "ZPrime2000_"+VariableList[i]+PlotType );
1984 delete cz5;
1985
1986 */
1987
1988
1989
1990 //Data
1991 float data;
1992
1993 int entries_data = data_tree->GetEntries();
1994 TH1F *DataPlot = new TH1F( "Data_"+VariableList[i], "Data_"+VariableList[i], nBins, VariableMin[i], VariableMax[i]);
1995 TBranch *DataBranch = data_tree->GetBranch( VariableList[i] );
1996
1997 DataBranch->SetAddress(&data);
1998
1999 TCanvas* c8 = new TCanvas();
2000 c8->cd();
2001
2002 for ( int q = 0; q < entries_data; q++ ) {
2003
2004 DataBranch->GetEntry(q);
2005 DataPlot->Fill(data);
2006
2007 }
2008
2009 if (logScale) c8->SetLogy();
2010
2011 //hStk->Add( DataPlot );
2012
2013 DataPlot->Draw("PE");
2014
2015 f->cd();
2016
2017 DataPlot->Write();
2018
2019 c8->Update();
2020 //c8->Print( "Data_"+VariableList[i]+PlotType );
2021 delete c8;
2022
2023
2024
2025 //Here scale all of the MC histograms to the Data Lumi and form a
2026 //TStack out of all of the MC and plot data on the same histo
2027
2028 hStk->Add( QCDPlot );
2029 //hStk->Add( VVPlot );
2030 hStk->Add( ZJPlot );
2031 hStk->Add( WJPlot );
2032 hStk->Add( STPlot );
2033 hStk->Add( TTPlot );
2034 //hStk->Add( ZPrime750Plot );
2035 //hStk->Add( ZPrime1000Plot );
2036 //hStk->Add( ZPrime1250Plot );
2037 //hStk->Add( ZPrime1500Plot );
2038 //hStk->Add( ZPrime2000Plot );
2039
2040
2041 TCanvas* c9 = new TCanvas();
2042 c9->cd();
2043
2044
2045
2046
2047 double yscale = 1.;
2048 double max1 = 1.;
2049 double max2 = 1.;
2050
2051
2052 max1 = hStk->GetMaximum();
2053 max2 = DataPlot->GetBinContent(DataPlot->GetMaximumBin());
2054
2055
2056 if (max1 > max2) yscale = max1*1.25;
2057 else yscale = max2*1.25;
2058
2059
2060 c9->Update();
2061
2062 DataPlot->Draw("PE");
2063 c9->Update();
2064 hStk->Draw("SAME");
2065 c9->Update();
2066 DataPlot->Draw("PE SAME");
2067
2068 c9->Update();
2069
2070 DataPlot->GetYaxis()->SetRangeUser(0., yscale);
2071 hStk->GetYaxis()->SetRangeUser(0., yscale);
2072
2073 DataPlot->GetXaxis()->SetTitle(TitleList[i]);
2074 hStk->GetXaxis()->SetTitle(TitleList[i]);
2075
2076 if (i ==0 ) {
2077
2078 DataPlot->GetYaxis()->SetTitle("Events / 100 GeV");
2079 hStk->GetYaxis()->SetTitle("Events / 100 GeV");
2080
2081 }
2082
2083 c9->Update();
2084
2085
2086 TLegend *leg = new TLegend(.75, .75, .95, .95);
2087 leg->AddEntry(QCDPlot, "QCD", "f");
2088 leg->AddEntry(STPlot, "Single Top", "f");
2089 leg->AddEntry(ZJPlot, "Z+jets", "f");
2090 leg->AddEntry(WJPlot, "W+jets", "f");
2091 //leg->AddEntry(VVPlot, "Diboson", "f");
2092 leg->AddEntry(TTPlot, "t #bar{t}", "f");
2093 leg->AddEntry(DataPlot, "2011 Data", "p");
2094 leg->Draw();
2095
2096
2097
2098 TPaveText *pt = new TPaveText(0.3,0.85,0.7,0.95,"brNDC");
2099 //pt->SetFillColor(18);
2100 pt->SetTextAlign(12);
2101 pt->AddText("CMS preliminary");
2102 pt->AddText("1564 pb^{-1} at #sqrt{s} = 7 TeV");
2103 pt->Draw();
2104
2105
2106 c9->Update();
2107
2108 //c9->SetLogy(1);
2109
2110 c9->Update();
2111 f->cd();
2112
2113 hStk->Write();
2114
2115 TString plotname = "Stack_"+VariableList[i]+PlotType;
2116 c9->Print( plotname );
2117
2118
2119 delete c9;
2120 delete hStk;
2121
2122 delete TTPlot;
2123 //delete TTPlot1;
2124 //delete TTPlot2;
2125 //delete TTPlot3;
2126 //delete TTPlot4;
2127 //delete TTPlot5;
2128 //delete TTPlot6;
2129 delete STPlot;
2130 delete ST_s_t_Plot;
2131 delete ST_t_t_Plot;
2132 delete ST_tw_t_Plot;
2133 delete ST_s_tbar_Plot;
2134 delete ST_t_tbar_Plot;
2135 delete ST_tw_tbar_Plot;
2136 delete WJPlot;
2137 //delete WJPlot1;
2138 //delete WJPlot2;
2139 //delete WJPlot3;
2140 //delete WJPlot4;
2141 //delete WJPlot5;
2142 //delete WJPlot6;
2143 delete ZJPlot;
2144 delete QCDPlot1;
2145 delete QCDPlot2;
2146 delete QCDPlot3;
2147 delete QCDPlot4;
2148 delete QCDPlot5;
2149 delete QCDPlot6;
2150 delete QCDPlot;
2151 //delete WWPlot;
2152 //delete WZPlot;
2153 //delete ZZPlot;
2154 //delete VVPlot;
2155 delete DataPlot;
2156 //delete ZPrimePlot;
2157
2158
2159
2160
2161
2162
2163 } //for i
2164
2165
2166 f->cd();
2167 f->Write();
2168 f->Close();
2169
2170
2171 }//DataPlotter