ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/UserCode/cbrown/Development/Plotting/Modules/Plotting_Functions.C
(Generate patch)

Comparing UserCode/cbrown/Development/Plotting/Modules/Plotting_Functions.C (file contents):
Revision 1.12 by buchmann, Wed Apr 18 09:20:36 2012 UTC vs.
Revision 1.38 by buchmann, Mon Jul 16 04:18:05 2012 UTC

# Line 28 | Line 28 | void todo() {
28    dout << "Info : The pt requirement is currently set to " << (const char*) passtrig << endl;
29    dout << "Info : The mll requirement is currently set to " << (const char*) cutmass << endl;
30    dout << "Info : The lepton requirement is currently set to " << (const char*) leptoncut << endl;
31 +  dout << "Info : The weight applied to all MC is " << (const char*) cutWeight << endl;
32   }  
33  
34 < void find_peaks(float &MCPeak,float &MCPeakError, float &DataPeak, float &DataPeakError, float &MCSigma, float &DataSigma, stringstream &result, bool doPUreweighting = true )
34 >
35 >
36 > void find_one_peak_combination(TCut specialcut, float &MCPeak,float &MCPeakError, float &DataPeak, float &DataPeakError, float &MCSigma, float &DataSigma, stringstream &result, bool doPUreweighting = true, string saveas="")
37   {
38    // Temporarily switch off PU reweighting, if asked
39    TCut weightbackup=cutWeight;
40    if ( !doPUreweighting ) cutWeight="1.0";
41 <
41 >  
42 >  int nbins=100;
43 >  if(PlottingSetup::DoBTag) nbins=25;
44 >  
45    TCanvas *tempcan = new TCanvas("tempcan","Temporary canvas for peak finding preparations");
46 <  TH1F *rawJZBeemmMC      = allsamples.Draw("rawJZBeemmMC",jzbvariablemc,100,-50,50, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,mc, luminosity);
47 <  TH1F *rawJZBeemmData    = allsamples.Draw("rawJZBeemmData",jzbvariabledata,100, -50,50, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,data, luminosity);
48 <  TH1F *rawJZBemMC      = allsamples.Draw("rawJZBemMC",jzbvariablemc,100,-50,50, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,mc, luminosity);
49 <  TH1F *rawJZBemData    = allsamples.Draw("rawJZBemData",jzbvariabledata,100, -50,50, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,data, luminosity);
46 >  TH1F *rawJZBeemmMC      = allsamples.Draw("rawJZBeemmMC",jzbvariablemc,nbins,-50,50, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&specialcut,mc, luminosity);
47 >  TH1F *rawJZBeemmData    = allsamples.Draw("rawJZBeemmData",jzbvariabledata,nbins, -50,50, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&specialcut,data, luminosity);
48 >  TH1F *rawJZBemMC      = allsamples.Draw("rawJZBemMC",jzbvariablemc,nbins,-50,50, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&specialcut,mc, luminosity);
49 >  TH1F *rawJZBemData    = allsamples.Draw("rawJZBemData",jzbvariabledata,nbins, -50,50, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&specialcut,data, luminosity);
50    TH1F *rawttbarjzbeemmMC;
51  
52    if(method==doKM) {
53      //we only need this histo for the KM fitting...
54 <    rawttbarjzbeemmMC = allsamples.Draw("rawttbarjzbeemmMC",jzbvariablemc,100, -50,50, "JZB [GeV]", "events",cutmass&&cutOSSF&&cutnJets,mc,luminosity,allsamples.FindSample("TTJet"));
55 <    MCPeak=find_peak(rawJZBeemmMC, rawttbarjzbeemmMC, -40, 40, mc, MCPeakError,MCSigma,method);
56 <    DataPeak=find_peak(rawJZBeemmData, rawJZBeemmData, -40, 40, data, DataPeakError,DataSigma,method);
54 >    rawttbarjzbeemmMC = allsamples.Draw("rawttbarjzbeemmMC",jzbvariablemc,nbins, -50,50, "JZB [GeV]", "events",cutmass&&cutOSSF&&cutnJets&&specialcut,mc,luminosity,allsamples.FindSample("TTJet"));
55 >    MCPeak=find_peak(rawJZBeemmMC, rawttbarjzbeemmMC, -40, 40, mc, MCPeakError,MCSigma,method,saveas);
56 >    DataPeak=find_peak(rawJZBeemmData, rawJZBeemmData, -40, 40, data, DataPeakError,DataSigma,method,saveas);
57 >    delete rawttbarjzbeemmMC;
58    }
59    else {
60      TH1F *reducedMC = (TH1F*)rawJZBeemmMC->Clone();
# Line 55 | Line 62 | void find_peaks(float &MCPeak,float &MCP
62      reducedMC->Add(rawJZBemMC,-1);
63      reducedData->Add(rawJZBemData,-1);
64      //this is Kostas' way of doing it - we subtract em to get rid of some of the ttbar contribution (in reality, of flavor-symmetric contribution)
65 <    MCPeak=find_peak(reducedMC, rawttbarjzbeemmMC, -40, 40, mc, MCPeakError,MCSigma,method);
66 <    DataPeak=find_peak(reducedData, rawJZBeemmData, -40, 40, data, DataPeakError,DataSigma,method);
67 <    
65 >    MCPeak=find_peak(reducedMC, rawttbarjzbeemmMC, -40, 40, mc, MCPeakError,MCSigma,method,saveas);
66 >    DataPeak=find_peak(reducedData, rawJZBeemmData, -40, 40, data, DataPeakError,DataSigma,method,saveas);
67 >    delete reducedMC;
68 >    delete reducedData;
69    }
70  
71    // Revert to original PU reweighting
# Line 65 | Line 73 | void find_peaks(float &MCPeak,float &MCP
73      
74   //  MCPeak=find_peak(rawJZBeemmMC, rawttbarjzbeemmMC, -40, 40, mc, MCPeakError,MCSigma,method);
75   //  DataPeak=find_peak(rawJZBeemmData, rawJZBeemmData, -40, 40, data, DataPeakError,DataSigma,method);
76 <  dout << "We have found the peak in Data at " << DataPeak << " +/- " << DataPeakError << " with sigma=" << DataSigma << " +/- ?? (not impl.)" << endl;
77 <  result << "We have found the peak in Data at " << DataPeak << " +/- " << DataPeakError << " with sigma=" << DataSigma << " +/- ?? (not impl.)" << endl;
78 <  dout << "We have found the peak in MC at " << MCPeak << " +/- " << MCPeakError << " with sigma=" << MCSigma << " +/- ?? (not impl.)" << endl;
79 <  result << "We have found the peak in MC at " << MCPeak << " +/- " << MCPeakError << " with sigma=" << MCSigma << " +/- ?? (not impl.)" << endl;
76 >  dout   << "   We have found the peak in Data at " << DataPeak << " +/- " << DataPeakError << " with sigma=" << DataSigma << " +/- ?? (not impl.)" << endl;
77 >  result << "   We have found the peak in Data at " << DataPeak << " +/- " << DataPeakError << " with sigma=" << DataSigma << " +/- ?? (not impl.)" << endl;
78 >  dout   << "   We have found the peak in MC at " << MCPeak << " +/- " << MCPeakError << " with sigma=" << MCSigma << " +/- ?? (not impl.)" << endl;
79 >  result << "   We have found the peak in MC at " << MCPeak << " +/- " << MCPeakError << " with sigma=" << MCSigma << " +/- ?? (not impl.)" << endl;
80 >  delete rawJZBeemmData;
81 >  delete rawJZBeemmMC;
82 >  delete rawJZBemData;
83 >  delete rawJZBemMC;
84    delete tempcan;
85   }
86  
87 < void make_special_obs_pred_mll_plot(string mcjzb, float jzbthreshold) {
87 > void find_peaks(float &MCPeak,float &MCPeakError, float &DataPeak, float &DataPeakError, stringstream &result, bool doPUreweighting, stringstream &datajzb, stringstream &mcjzb)
88 > {
89 >  
90 >  bool DoInvidualeemmPeaks=false;
91 >  
92 >  float mcpeak, datapeak;
93 >  float mcpeakerr, datapeakerr;
94 >  
95 >  float mceepeak,mcmmpeak;
96 >  float mceepeakerr,mcmmpeakerr;
97 >  
98 >  float datammpeak,dataeepeak;
99 >  float datammpeakerr,dataeepeakerr;
100 >  
101 >  float mcSigma, dataSigma;
102 >  
103 >  dout << "Finding global peak : " << endl;
104 >  find_one_peak_combination(TCut(""),mcpeak,mcpeakerr, datapeak,datapeakerr,mcSigma, dataSigma,result,doPUreweighting,"");
105 >  
106 >  if(DoInvidualeemmPeaks) {
107 >    dout << "Finding peak for electrons : " << endl;
108 >    find_one_peak_combination(TCut("id1==0"),mceepeak,mceepeakerr, dataeepeak,dataeepeakerr,mcSigma, dataSigma,result,doPUreweighting,"_ele");
109 >    dout << "Finding peak for muons : " << endl;
110 >    find_one_peak_combination(TCut("id1==1"),mcmmpeak,mcmmpeakerr, datammpeak,datammpeakerr,mcSigma, dataSigma,result,doPUreweighting,"_mu");
111 >    
112 >    datajzb << "(" << jzbvariabledata;
113 >    mcjzb << "(" << jzbvariablemc;
114 >    
115 >    if(dataeepeak>0) datajzb << "- (id1==id2)*(id1==0)*" << TMath::Abs(dataeepeak) << " ";
116 >    else datajzb << "+ (id1==id2)*(id1==0)*" << TMath::Abs(dataeepeak) << " ";
117 >    
118 >    if(datammpeak>0) datajzb << "- (id1==id2)*(id1==1)*" << TMath::Abs(datammpeak) << " ";
119 >    else datajzb << "+ (id1==id2)*(id1==1)*" << TMath::Abs(datammpeak) << " ";
120 >    
121 >    if(datapeak>0) datajzb << "- (id1!=id2)*" << TMath::Abs(datapeak) << " ";
122 >    else datajzb << "+ (id1!=id2)*" << TMath::Abs(datapeak) << " ";
123 >    
124 >    datajzb << ")";
125 >    
126 >    if(mceepeak>0) mcjzb << "- (id1==id2)*(id1==0)*" << TMath::Abs(mceepeak) << " ";
127 >    else mcjzb << "+ (id1==id2)*(id1==0)*" << TMath::Abs(mceepeak) << " ";
128 >    
129 >    if(mcmmpeak>0) mcjzb << "- (id1==id2)*(id1==1)*" << TMath::Abs(mcmmpeak) << " ";
130 >    else mcjzb << "+ (id1==id2)*(id1==1)*" << TMath::Abs(mcmmpeak) << " ";
131 >    
132 >    if(mcpeak>0) mcjzb << "- (id1!=id2)*" << TMath::Abs(mcpeak) << " ";
133 >    else mcjzb << "+ (id1!=id2)*" << TMath::Abs(mcpeak) << " ";
134 >    
135 >    mcjzb << ")";
136 >  } else {
137 >    datajzb << "(" << jzbvariabledata;
138 >      mcjzb << "(" << jzbvariablemc;
139 >    
140 >    if(datapeak>0) datajzb << "- " << TMath::Abs(datapeak) << " ";
141 >    else datajzb << "+ " << TMath::Abs(datapeak) << " ";
142 >    
143 >    datajzb << ")";
144 >    
145 >    if(mcpeak>0) mcjzb << "- " << TMath::Abs(mcpeak) << " ";
146 >    else mcjzb << "+ " << TMath::Abs(mcpeak) << " ";
147 >    
148 >    mcjzb << ")";
149 >  }
150 >  
151 >  
152 > }
153 >
154 > void make_special_obs_pred_mll_plot(string datajzb, string mcjzb, float jzbthreshold) {
155    float min=70.0;
156    float max=115.0;
157    if(!PlottingSetup::RestrictToMassPeak) {
158 <    min=10;
159 <    max=150;
158 >    min=20;
159 >    max=200;
160    }
161    int nbins=int((max-min)/5);
162    
163    TCanvas *ckin = new TCanvas("ckin","Kinematic Plots (in the making)",600,600);
164    
165    stringstream largerzeroS;
166 <  largerzeroS << "(" << mcjzb << ">" << jzbthreshold << ")";
167 <  TCut largerzero(largerzeroS.str().c_str());
166 >  largerzeroS << "(" << datajzb << ">" << jzbthreshold << ")";
167 >  TCut largerzeroD(largerzeroS.str().c_str());
168    
169    stringstream smallerzeroS;
170 <  smallerzeroS << "(" << mcjzb << "<-" << jzbthreshold << ")";
171 <  TCut smallerzero(smallerzeroS.str().c_str());
172 <  
173 <  TH1F *RcorrJZBeemm     = allsamples.Draw("RcorrJZBeemm",       "mll",nbins,min,max, "m_{ll} [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&largerzero,data,luminosity);
174 <  THStack mcRcorrJZBeemm = allsamples.DrawStack("mcRcorrJZBeemm","mll",nbins,min,max, "m_{ll} [GeV}", "events", cutmass&&cutOSSF&&cutnJets&&largerzero,mc,luminosity);
175 <  TH1F *LcorrJZBeemm     = allsamples.Draw("LcorrJZBeemm",       "mll",nbins,min,max, "m_{ll} [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&smallerzero,data,luminosity);
176 <  TH1F *RcorrJZBem       = allsamples.Draw("RcorrJZBem",         "mll",nbins,min,max, "m_{ll} [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&largerzero,data,luminosity);
177 <  TH1F *LcorrJZBem       = allsamples.Draw("LcorrJZBem",         "mll",nbins,min,max, "m_{ll} [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&smallerzero,data,luminosity);
170 >  smallerzeroS << "(" << datajzb << "<-" << jzbthreshold << ")";
171 >  TCut smallerzeroD(smallerzeroS.str().c_str());
172 >
173 >
174 >  stringstream largerzeroMS;
175 >  largerzeroMS << "(" << mcjzb << ">" << jzbthreshold << ")";
176 >  TCut largerzeroM(largerzeroMS.str().c_str());
177 >  
178 >  TH1F *RcorrJZBeemm     = allsamples.Draw("RcorrJZBeemm",       "mll",nbins,min,max, "m_{ll} [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&largerzeroD,data,luminosity);
179 >  THStack mcRcorrJZBeemm = allsamples.DrawStack("mcRcorrJZBeemm","mll",nbins,min,max, "m_{ll} [GeV}", "events", cutmass&&cutOSSF&&cutnJets&&largerzeroM,mc,luminosity);
180 >  TH1F *LcorrJZBeemm     = allsamples.Draw("LcorrJZBeemm",       "mll",nbins,min,max, "m_{ll} [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&smallerzeroD,data,luminosity);
181 >  TH1F *RcorrJZBem       = allsamples.Draw("RcorrJZBem",         "mll",nbins,min,max, "m_{ll} [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&largerzeroD,data,luminosity);
182 >  TH1F *LcorrJZBem       = allsamples.Draw("LcorrJZBem",         "mll",nbins,min,max, "m_{ll} [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&smallerzeroD,data,luminosity);
183  
184    TH1F *RcorrJZBSBem;
185    TH1F *LcorrJZBSBem;
186    TH1F *RcorrJZBSBeemm;
187    TH1F *LcorrJZBSBeemm;
188    
189 <  TH1F *RcorrJZBeemmNoS;
189 > //  TH1F *RcorrJZBeemmNoS;
190  
191    if(PlottingSetup::RestrictToMassPeak) {
192 <    RcorrJZBSBem   = allsamples.Draw("RcorrJZBSBem",  "mll",nbins,min,max, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets&&largerzero,data, luminosity);
193 <    LcorrJZBSBem   = allsamples.Draw("LcorrJZBSBem",  "mll",nbins,min,max, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets&&smallerzero,data, luminosity);
194 <    RcorrJZBSBeemm = allsamples.Draw("RcorrJZBSBeemm","mll",nbins,min,max, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets&&largerzero,data, luminosity);
195 <    LcorrJZBSBeemm = allsamples.Draw("LcorrJZBSBeemm","mll",nbins,min,max, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets&&smallerzero,data, luminosity);
192 >    RcorrJZBSBem   = allsamples.Draw("RcorrJZBSBem",  "mll",nbins,min,max, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets&&largerzeroD,data, luminosity);
193 >    LcorrJZBSBem   = allsamples.Draw("LcorrJZBSBem",  "mll",nbins,min,max, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets&&smallerzeroD,data, luminosity);
194 >    RcorrJZBSBeemm = allsamples.Draw("RcorrJZBSBeemm","mll",nbins,min,max, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets&&largerzeroD,data, luminosity);
195 >    LcorrJZBSBeemm = allsamples.Draw("LcorrJZBSBeemm","mll",nbins,min,max, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets&&smallerzeroD,data, luminosity);
196    }
197    
198    TH1F *Bpred = (TH1F*)LcorrJZBeemm->Clone("Bpred");
# Line 140 | Line 224 | void make_special_obs_pred_mll_plot(stri
224    stringstream saveas;
225    saveas << "kin/Mll_After_Cut/Cut_At" << jzbthreshold;
226    CompleteSave(ckin,saveas.str());
227 +  
228 +  
229 +  
230 +  RcorrJZBeemm->Draw();
231 +  Bpred->Draw("histo,same");
232 +  RcorrJZBeemm->Draw("same");
233 +  
234 +  TLegend *leg2 = make_legend();
235 +  leg2->SetX1(0.58);
236 +  leg2->AddEntry(RcorrJZBeemm,"observed (data)","l");
237 +  leg2->AddEntry(Bpred,"predicted (data)","l");
238 +  leg2->Draw("same");
239 +  
240 +  saveas.str("");
241 +  saveas << "kin/Mll_After_Cut/Cut_At" << jzbthreshold << "_nomc";
242 +  CompleteSave(ckin,saveas.str());
243 +  
244 +  
245  
246    delete RcorrJZBeemm;
247    delete LcorrJZBeemm;
# Line 189 | Line 291 | void make_special_mll_plot(int nbins, fl
291    TIter next(bgleg->GetListOfPrimitives());
292    TObject* obj;
293    // Copy the nice bkgd legend skipping the "data"
294 <  while ( obj = next() )
294 >  while ( (obj = next()) )
295      if ( strcmp(((TLegendEntry*)obj)->GetObject()->GetName(),"datahistoOSSF") )
296        kinleg->GetListOfPrimitives()->Add(obj);
297  
# Line 208 | Line 310 | void draw_ratio_plot(TH1* hdata, THStack
310    TIter next(hmc.GetHists());
311    TObject* obj;
312    TH1* hratio = NULL;
313 <  while ( obj = next() ) {
313 >  while ( (obj = next()) ) {
314      if ( !hratio ) {
315        hratio = (TH1*)obj->Clone();
316        hratio->SetName("hratio");
# Line 269 | Line 371 | void make_kin_plot(string variable, stri
371    TCut cut;
372    cut=cutmass&&cutOSSF&&cutnJets&&ibasiccut;
373    if(filename=="nJets") cut=cutmass&&cutOSSF&&ibasiccut;
374 +  if(filename=="nJets_osof") cut=cutmass&&cutOSOF&&ibasiccut;
375    if(filename=="nJets_nocuts_except_mll_ossf") cut=cutmass&&cutOSSF;
376    if(filename=="mll") {
377          cut=cutOSSF&&cutnJets&&ibasiccut;
# Line 280 | Line 383 | void make_kin_plot(string variable, stri
383          draw_separation_lines=true;
384    }
385    if(filename=="mll_mm") cut=cutOSSF&&cutnJets&&ibasiccut&&"id1==1";
386 <  if(Contains(filename,"mll_aboveJZB100")) cut=cutOSSF&&cutnJets&&ibasiccut;
386 >  if(Contains(filename,"aboveJZB")) cut=cutOSSF&&cutnJets&&ibasiccut;
387 >  if(Contains(filename,"mll_ee_above")) cut=cut&&"id1==0";
388 >  if(Contains(filename,"mll_mm_above")) cut=cut&&"id1==1";
389    if(Contains(filename,"mll_osof_aboveJZB")) cut=cutOSOF&&cutnJets&&ibasiccut;
390    if(filename=="mll_inclusive"||filename=="mll_inclusive_highrange") cut=cutOSSF;
391    if(filename=="mll_inclusive_osof") cut=cutOSOF;
# Line 296 | Line 401 | void make_kin_plot(string variable, stri
401    THStack mcstack = allsamples.DrawStack("mcstack",variable,nbins,min,max, xlabel, "events",cut,mc,luminosity);
402    if(variable=="pfJetGoodPt[0]") datahisto->SetMaximum(10*datahisto->GetMaximum());
403    if(variable=="pt") datahisto->SetMaximum(10*datahisto->GetMaximum());
404 <  if(filename=="mll_inclusive") datahisto->SetMinimum(1);
404 >  if(filename=="mll_inclusive"||filename=="mll_inclusive_mm"||filename=="mll_inclusive_ee") datahisto->SetMinimum(1);
405    if(filename=="mll_osof") datahisto->SetMaximum(10*datahisto->GetMaximum());
406    if(filename=="mll_osof") datahisto->SetMinimum(9);
302 –
407    datahisto->SetMaximum(5.3*datahisto->GetMaximum());
408    datahisto->Draw("e1");
409    ckin->Update();
# Line 393 | Line 497 | void make_JES_plot() {
497    TH1F *datahisto = allsamples.Draw("datahisto","pfJetGoodNum",nbins,min,max, xlabel, "events",cut,data,luminosity);
498    datahisto->SetMarkerSize(DataMarkerSize);
499    THStack mcstack = allsamples.DrawStack("mcstack","pfJetGoodNum",nbins,min,max, xlabel, "events",cut,mc,luminosity);
500 <  TH1F *JESup = allsamples.Draw("JESup","pfJetGoodNum315",nbins,min,max, xlabel, "events",cut,mc,luminosity);
501 <  TH1F *JESdn = allsamples.Draw("JESdn","pfJetGoodNum285",nbins,min,max, xlabel, "events",cut,mc,luminosity);
500 >  TH1F *JESup = allsamples.Draw("JESup","pfJetGoodNump1sigma",nbins,min,max, xlabel, "events",cut,mc,luminosity);
501 >  TH1F *JESdn = allsamples.Draw("JESdn","pfJetGoodNumn1sigma",nbins,min,max, xlabel, "events",cut,mc,luminosity);
502  
503    datahisto->SetMinimum(1);
504    datahisto->SetMaximum(5.3*datahisto->GetMaximum()); // in line with kinematic plots style
# Line 430 | Line 534 | void do_kinematic_plots(string mcjzb, st
534    bool dolog=true;
535    bool nolog=false;
536    if(doPF) write_warning(__FUNCTION__,"Please use caution when trying to produce PF plots; not all versions of the JZB trees have these variables!");
537 <  float mll_low=40;
537 >  float mll_low=50;
538    float mll_hi=160;
539    if(!PlottingSetup::RestrictToMassPeak) {
540 <        mll_low=10;
540 >        mll_low=20;
541          mll_hi=210;
542    }
543 <  /*
543 >  
544 >  make_kin_plot("met[4]","",40,0,200,dolog,"MET [GeV]","met",doPF,true);
545    make_kin_plot("mll","",(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll",doPF,true);
546    make_kin_plot("mll","",(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_osof",doPF,true,true);
547    make_kin_plot("mll","",(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_ee",doPF,true);
# Line 444 | Line 549 | void do_kinematic_plots(string mcjzb, st
549    make_kin_plot("mll","",(int)((mll_hi-mll_low)),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_inclusive",doPF,true);
550    make_kin_plot("mll","",(int)((mll_hi-mll_low)),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_inclusive_ee",doPF,true);
551    make_kin_plot("mll","",(int)((mll_hi-mll_low)),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_inclusive_mm",doPF,true);
552 <  make_kin_plot("mll","",(int)((mll_hi-mll_low)),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_inclusive_osof",doPF,true);
553 <  make_kin_plot("mll","",(int)((350-mll_low)),mll_low,350,dolog,"m_{ll} [GeV]","mll_inclusive_highrange",doPF);/*
552 >  make_kin_plot("mll","",(int)((mll_hi-mll_low))/2,mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_inclusive_osof",doPF,true);
553 >  make_kin_plot("mll","",(int)((350-mll_low)),mll_low,350,dolog,"m_{ll} [GeV]","mll_inclusive_highrange",doPF);
554    make_kin_plot("numVtx","",(int)(30.5-(-0.5)),-0.5,30.5,nolog,"N(Vtx)","numVtx",doPF);
555 <  make_kin_plot("jetpt[0]","",40,0,200,dolog,"leading jet p_{T} [GeV]","pfJetGoodPt_0",doPF);
556 <  make_kin_plot("jeteta[0]","",40,-5,5,nolog,"leading jet #eta","pfJetGoodEta_0",doPF);
555 > //  make_kin_plot("jetpt[0]","",40,0,200,dolog,"leading jet p_{T} [GeV]","pfJetGoodPt_0",doPF);
556 > //  make_kin_plot("jeteta[0]","",40,-5,5,nolog,"leading jet #eta","pfJetGoodEta_0",doPF);
557    make_kin_plot("pt","",50,0,400,dolog,"Z p_{T} [GeV]","Zpt",doPF);
558    make_kin_plot("pt1","",50,0,100,nolog,"p_{T} [GeV]","pt1",doPF);
559    make_kin_plot("pt2","",50,0,100,nolog,"p_{T} [GeV]","pt2",doPF);
560    make_kin_plot("eta1","",40,-5,5,nolog,"#eta_{l}","eta",doPF);
561    make_kin_plot("jzb[1]","",100,-150,150,dolog,"JZB [GeV]","jzb_ossf",doPF);
562 <  make_kin_plot("pfJetGoodNum","",8,0.5,8.5,dolog,"nJets","nJets",doPF);
563 <  make_kin_plot("pfJetGoodNum","",8,0.5,8.5,dolog,"nJets","nJets_nocuts_except_mll_ossf",doPF);*//*
562 >  make_kin_plot("pfJetGoodNum40","",9,-0.5,8.5,dolog,"nJets","nJets",doPF);
563 >  make_kin_plot("pfJetGoodNum40","",9,-0.5,8.5,dolog,"nJets","nJets_osof",doPF);
564 >  make_kin_plot("pfJetGoodNum40","",9,-0.5,8.5,dolog,"nJets","nJets_nocuts_except_mll_ossf",doPF);
565    if(!doPF) make_special_mll_plot((int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]");
566    stringstream jzbcut;
567    jzbcut << "((is_data&&("<<datajzb<<")>100)||(!is_data&&("<<mcjzb<<")>100))";
568 <  make_kin_plot("mll",jzbcut.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_aboveJZB100",doPF,true);
569 <  make_kin_plot("mll",jzbcut.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_osof_aboveJZB100",doPF,true);
570 <  make_kin_plot("mll",jzbcut.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_aboveJZB100",doPF,true);
571 <  make_kin_plot("mll",jzbcut.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_osof_aboveJZB100",doPF,true);
568 >  make_kin_plot("mll",jzbcut.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,nolog,"m_{ll} [GeV]","mll_aboveJZB100",doPF,true);
569 >  make_kin_plot("mll",jzbcut.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,nolog,"m_{ll} [GeV]","mll_osof_aboveJZB100",doPF,true);
570 >  make_kin_plot("mll",jzbcut.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,nolog,"m_{ll} [GeV]","mll_ee_aboveJZB100",doPF,true);
571 >  make_kin_plot("mll",jzbcut.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,nolog,"m_{ll} [GeV]","mll_mm_aboveJZB100",doPF,true);
572    stringstream jzbcut2;
573    jzbcut2 << "((is_data&&("<<datajzb<<")>150)||(!is_data&&("<<mcjzb<<")>150))";
574 <  make_kin_plot("mll",jzbcut2.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_aboveJZB150",doPF,true);
575 <  make_kin_plot("mll",jzbcut2.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_osof_aboveJZB150",doPF,true);
574 >  make_kin_plot("mll",jzbcut2.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,nolog,"m_{ll} [GeV]","mll_aboveJZB150",doPF,true);
575 >  make_kin_plot("mll",jzbcut2.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,nolog,"m_{ll} [GeV]","mll_osof_aboveJZB150",doPF,true);
576 >  make_kin_plot("mll",jzbcut2.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,nolog,"m_{ll} [GeV]","mll_ee_aboveJZB150",doPF,true);
577 >  make_kin_plot("mll",jzbcut2.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,nolog,"m_{ll} [GeV]","mll_mm_aboveJZB150",doPF,true);
578    stringstream jzbcut3;
579    jzbcut3 << "((is_data&&("<<datajzb<<")>50)||(!is_data&&("<<mcjzb<<")>50))";
580 <  make_kin_plot("mll",jzbcut3.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_aboveJZB50",doPF,true);   make_kin_plot("mll",jzbcut3.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_osof_aboveJZB50",doPF,true,true);
581 <  */
582 <  make_special_obs_pred_mll_plot(mcjzb,50);
583 <  make_special_obs_pred_mll_plot(mcjzb,100);
584 <  make_special_obs_pred_mll_plot(mcjzb,150);
585 <  make_special_obs_pred_mll_plot(mcjzb,200);
586 <  make_special_obs_pred_mll_plot(mcjzb,250);
580 >  make_kin_plot("mll",jzbcut3.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,nolog,"m_{ll} [GeV]","mll_aboveJZB50",doPF,true);  
581 >  make_kin_plot("mll",jzbcut3.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,nolog,"m_{ll} [GeV]","mll_osof_aboveJZB50",doPF,true,true);
582 >  make_kin_plot("mll",jzbcut3.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,nolog,"m_{ll} [GeV]","mll_ee_aboveJZB50",doPF,true);  
583 >  make_kin_plot("mll",jzbcut3.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,nolog,"m_{ll} [GeV]","mll_mm_aboveJZB50",doPF,true);  
584 >  
585 >  
586 >  make_special_obs_pred_mll_plot(datajzb,mcjzb,0);
587 >  make_special_obs_pred_mll_plot(datajzb,mcjzb,50);
588 >  make_special_obs_pred_mll_plot(datajzb,mcjzb,100);
589 >  make_special_obs_pred_mll_plot(datajzb,mcjzb,150);
590 >  make_special_obs_pred_mll_plot(datajzb,mcjzb,200);
591 >  make_special_obs_pred_mll_plot(datajzb,mcjzb,250);
592 >  
593 >  make_JES_plot();
594   }
595  
596   void make_comp_plot( string var, string xlabel, string filename, float jzbcut, string mcjzb, string datajzb,
# Line 509 | Line 624 | void make_comp_plot( string var, string
624        TCanvas *ccomp = new TCanvas("ccomp","Comparison plot",600,400);
625        ccomp->SetLogy(log);
626        TH1F *datahisto = allsamples.Draw("datahisto",   var,nbins,xmin,xmax,xlabel,"events",kRegions[iregion]&&jzbData[ijzb],data,luminosity);
627 <      TH1F *lm4histo = signalsamples.Draw("lm4histo",   var,nbins,xmin,xmax,xlabel,"events",kRegions[iregion]&&jzbData[ijzb],data,luminosity,signalsamples.FindSample("LM4"));
627 >      TH1F *lm4histo = signalsamples.Draw("lm4histo",   var,nbins,xmin,xmax,xlabel,"events",kRegions[iregion]&&jzbData[ijzb],data,luminosity,signalsamples.FindSample("LM"));
628        THStack mcstack = allsamples.DrawStack("mcstack",var,nbins,xmin,xmax,xlabel,"events",kRegions[iregion]&&jzbMC[ijzb],  mc,  luminosity);
629        datahisto->SetMarkerSize(DataMarkerSize);
630        if (ymax>ymin) datahisto->SetMaximum(ymax);
# Line 543 | Line 658 | void region_comparison_plots(string mcjz
658    dout << "Creating comparison plots for signal and control regions" << endl;
659    // Compare a few quantities in the signal region and all 7 control regions
660  
661 <  switch_overunderflow(true);  // switching overflow/underflow bins on
661 > //  switch_overunderflow(true);  // switching overflow/underflow bins on
662      
663    
664      flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak ---- the arguments changed
665 <  for(int ijzb=0;ijzb<jzb_cuts.size();ijzb++) {
665 >  for(int ijzb=0;ijzb<(int)jzb_cuts.size();ijzb++) {
666      float jzbcut=jzb_cuts[ijzb]; // Comparison plots are done for this JZB cut
667      float mll_low=50;float mll_high=170;
668      if(!PlottingSetup::RestrictToMassPeak) {
# Line 854 | Line 969 | if you want to start from scratch (witho
969    return return_functions;
970   }
971  
972 < void do_prediction_plot(string jzb, TCanvas *globalcanvas, float sigma, float high, int use_data, bool overlay_signal = false,string subdir="" )
972 > void do_prediction_plot(string jzb, TCanvas *globalcanvas, float high, int use_data, bool overlay_signal = false,string subdir="" )
973   {
974 <  // note: sigma is not used ATM
860 <  switch_overunderflow(true);
974 > //  switch_overunderflow(true);
975    bool is_data=false;
976    bool use_signal=false;
977    if(use_data==1) is_data=true;
# Line 867 | Line 981 | void do_prediction_plot(string jzb, TCan
981    float low=0;
982    float hi=500;
983    
870 –  stringstream largerzeroS;
871 –  largerzeroS << "("<<jzb<<">0)";
872 –  TCut largerzero(largerzeroS.str().c_str());
873 –  stringstream smallerzeroS;
874 –  smallerzeroS << "("<<jzb<<"<0)";
875 –  TCut smallerzero(smallerzeroS.str().c_str());
876 –  
984    TH1F *blankback = new TH1F("blankback","blankback",int(high/10),0,high);
985 <  TH1F *RcorrJZBeemm   = allsamples.Draw("RcorrJZBeemm",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&largerzero,is_data, luminosity,use_signal);
986 <  TH1F *LcorrJZBeemm   = allsamples.Draw("LcorrJZBeemm",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&smallerzero,is_data, luminosity,use_signal);
987 <  TH1F *RcorrJZBem     = allsamples.Draw("RcorrJZBem",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&largerzero,is_data, luminosity,use_signal);
988 <  TH1F *LcorrJZBem     = allsamples.Draw("LcorrJZBem",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&smallerzero,is_data, luminosity,use_signal);
985 >  TH1F *RcorrJZBeemm   = allsamples.Draw("RcorrJZBeemm",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
986 >  TH1F *LcorrJZBeemm   = allsamples.Draw("LcorrJZBeemm",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
987 >  TH1F *RcorrJZBem     = allsamples.Draw("RcorrJZBem",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
988 >  TH1F *LcorrJZBem     = allsamples.Draw("LcorrJZBem",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
989  
990    blankback->GetXaxis()->SetTitle(RcorrJZBeemm->GetXaxis()->GetTitle());
991    blankback->GetYaxis()->SetTitle(RcorrJZBeemm->GetYaxis()->GetTitle());
# Line 895 | Line 1002 | void do_prediction_plot(string jzb, TCan
1002  
1003      //these are for the ratio
1004    
1005 <  TH1F *JRcorrJZBeemm   = allsamples.Draw("JRcorrJZBeemm",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&largerzero,is_data, luminosity,use_signal);
1006 <  TH1F *JLcorrJZBeemm   = allsamples.Draw("JLcorrJZBeemm",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&smallerzero,is_data, luminosity,use_signal);
1007 <  TH1F *JRcorrJZBem     = allsamples.Draw("JRcorrJZBem",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&largerzero,is_data, luminosity,use_signal);
1008 <  TH1F *JLcorrJZBem     = allsamples.Draw("JLcorrJZBem",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&smallerzero,is_data, luminosity,use_signal);
1005 >  TH1F *JRcorrJZBeemm   = allsamples.Draw("JRcorrJZBeemm",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1006 >  TH1F *JLcorrJZBeemm   = allsamples.Draw("JLcorrJZBeemm",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1007 >  TH1F *JRcorrJZBem     = allsamples.Draw("JRcorrJZBem",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1008 >  TH1F *JLcorrJZBem     = allsamples.Draw("JLcorrJZBem",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1009    
1010    TH1F *JRcorrJZBSBem;
1011    TH1F *JLcorrJZBSBem;
1012    TH1F *JRcorrJZBSBeemm;
1013    TH1F *JLcorrJZBSBeemm;
1014    
1015 <  if(use_data==2 || overlay_signal) RcorrJZBeemmNoS = allsamples.Draw("RcorrJZBeemmNoS",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&largerzero,is_data, luminosity,false);
1015 >  if(use_data==2 || overlay_signal) RcorrJZBeemmNoS = allsamples.Draw("RcorrJZBeemmNoS",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,is_data, luminosity,false);
1016  
1017    
1018    if(PlottingSetup::RestrictToMassPeak) {
1019 <    RcorrJZBSBem   = allsamples.Draw("RcorrJZBSBem",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets&&largerzero,is_data, luminosity,use_signal);
1020 <    LcorrJZBSBem   = allsamples.Draw("LcorrJZBSBem",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets&&smallerzero,is_data, luminosity,use_signal);
1021 <    RcorrJZBSBeemm = allsamples.Draw("RcorrJZBSBeemm",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets&&largerzero,is_data, luminosity,use_signal);
1022 <    LcorrJZBSBeemm = allsamples.Draw("LcorrJZBSBeemm",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets&&smallerzero,is_data, luminosity,use_signal);
1019 >    RcorrJZBSBem   = allsamples.Draw("RcorrJZBSBem",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1020 >    LcorrJZBSBem   = allsamples.Draw("LcorrJZBSBem",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1021 >    RcorrJZBSBeemm = allsamples.Draw("RcorrJZBSBeemm",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1022 >    LcorrJZBSBeemm = allsamples.Draw("LcorrJZBSBeemm",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1023      
1024      //these are for the ratio
1025 <    JRcorrJZBSBem   = allsamples.Draw("JRcorrJZBSBem",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets&&largerzero,is_data, luminosity,use_signal);
1026 <    JLcorrJZBSBem   = allsamples.Draw("JLcorrJZBSBem",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets&&smallerzero,is_data, luminosity,use_signal);
1027 <    JRcorrJZBSBeemm = allsamples.Draw("JRcorrJZBSBeemm",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets&&largerzero,is_data, luminosity,use_signal);
1028 <    JLcorrJZBSBeemm = allsamples.Draw("JLcorrJZBSBeemm",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets&&smallerzero,is_data, luminosity,use_signal);
1025 >    JRcorrJZBSBem   = allsamples.Draw("JRcorrJZBSBem",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1026 >    JLcorrJZBSBem   = allsamples.Draw("JLcorrJZBSBem",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1027 >    JRcorrJZBSBeemm = allsamples.Draw("JRcorrJZBSBeemm",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1028 >    JLcorrJZBSBeemm = allsamples.Draw("JLcorrJZBSBeemm",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1029    }
1030    
1031    TH1F *lm4RcorrJZBeemm;
1032 <  if(overlay_signal || use_data == 2 || use_data == 1) lm4RcorrJZBeemm = allsamples.Draw("lm4RcorrJZBSBeemm",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&largerzero,is_data, luminosity,allsamples.FindSample("LM"));
1032 >  if(overlay_signal || use_data == 2 || use_data == 1) lm4RcorrJZBeemm = allsamples.Draw("lm4RcorrJZBSBeemm",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,is_data, luminosity,allsamples.FindSample("LM"));
1033    
1034    flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak ---- prediction changed.
1035    
# Line 931 | Line 1038 | void do_prediction_plot(string jzb, TCan
1038      
1039    TH1F *Bpred = (TH1F*)LcorrJZBeemm->Clone("Bpred");
1040    TH1F *JBpred = (TH1F*)JLcorrJZBeemm->Clone("Bpred");
1041 +    
1042 +  TH1F *BpredSys = new TH1F("Bpredsys","Bpredsys",PlottingSetup::global_ratio_binning.size()-1,&PlottingSetup::global_ratio_binning[0]);
1043 +  ClearHisto(BpredSys);
1044 +    
1045    if(PlottingSetup::RestrictToMassPeak) {
1046      Bpred->Add(RcorrJZBem,1.0/3.);
1047      Bpred->Add(LcorrJZBem,-1.0/3.);
# Line 953 | Line 1064 | void do_prediction_plot(string jzb, TCan
1064      JBpred->Add(JLcorrJZBSBem,-1.0/3.);
1065      JBpred->Add(JRcorrJZBSBeemm,1.0/3.);
1066      JBpred->Add(JLcorrJZBSBeemm,-1.0/3.);
1067 +      
1068 +    //Systematics:
1069 +    AddSquared(BpredSys,JLcorrJZBeemm,zjetsestimateuncertONPEAK*zjetsestimateuncertONPEAK);
1070 +    AddSquared(BpredSys,JRcorrJZBem,emuncertONPEAK*emuncertONPEAK*(1.0/9));
1071 +    AddSquared(BpredSys,JLcorrJZBem,emuncertONPEAK*emuncertONPEAK*(1.0/9));
1072 +    AddSquared(BpredSys,JRcorrJZBSBem,emsidebanduncertONPEAK*emsidebanduncertONPEAK*(1.0/9));
1073 +    AddSquared(BpredSys,JLcorrJZBSBem,emsidebanduncertONPEAK*emsidebanduncertONPEAK*(1.0/9));
1074 +    AddSquared(BpredSys,JRcorrJZBSBeemm,eemmsidebanduncertONPEAK*eemmsidebanduncertONPEAK*(1.0/9));
1075 +    AddSquared(BpredSys,JLcorrJZBSBeemm,eemmsidebanduncertONPEAK*eemmsidebanduncertONPEAK*(1.0/9));
1076    } else {
1077      Bpred->Add(RcorrJZBem,1.0);
1078      Bpred->Add(LcorrJZBem,-1.0);
# Line 962 | Line 1082 | void do_prediction_plot(string jzb, TCan
1082      //these are for the ratio
1083      JBpred->Add(JRcorrJZBem,1.0);
1084      JBpred->Add(JLcorrJZBem,-1.0);
1085 +      
1086 +    //Systematics
1087 +    AddSquared(BpredSys,JLcorrJZBeemm,zjetsestimateuncertOFFPEAK*zjetsestimateuncertOFFPEAK);
1088 +    AddSquared(BpredSys,JRcorrJZBem,emuncertOFFPEAK*emuncertOFFPEAK);
1089 +    AddSquared(BpredSys,JLcorrJZBem,emuncertOFFPEAK*emuncertOFFPEAK);
1090 +
1091    }
1092      
1093 <  
1093 >  SQRT(BpredSys);
1094 >  BpredSys->Divide(JBpred);
1095 >
1096    
1097    flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak ---- prediction changed
1098    TH1F *Tpred = (TH1F*)RcorrJZBem->Clone("Bpred");
# Line 1009 | Line 1137 | void do_prediction_plot(string jzb, TCan
1137    blankback->Draw();
1138    if(use_data==1)
1139    {
1140 +    //Bpred->SetLineWidth(3); //paper style.overruled.
1141 +    //lm4RcorrJZBeemm->SetLineWidth(3); //paper style.overruled.
1142      analytical_function = do_extended_fit_to_plot(Bpred,Tpred,LcorrJZBeemm,LcorrJZBem,is_data);
1143      kinpad->cd();//necessary because the extended fit function creates its own canvas
1144      RcorrJZBeemm->Draw("e1x0,same");
1145  
1146      Bpred->Draw("hist,same");
1147 <    analytical_function[0]->Draw("same"); analytical_function[1]->Draw("same");analytical_function[2]->Draw("same");
1147 >    //analytical_function[0]->Draw("same"); analytical_function[1]->Draw("same");analytical_function[2]->Draw("same");
1148      RcorrJZBeemm->Draw("e1x0,same");//HAVE IT ON TOP!
1149      lm4RcorrJZBeemm->Draw("hist,same");
1150      legBpred->AddEntry(RcorrJZBeemm,"observed","p");
1151      legBpred->AddEntry(Bpred,"predicted","l");
1152 <    legBpred->AddEntry(analytical_function[1],"predicted fit","l");
1153 <    legBpred->AddEntry(analytical_function[2],"stat. uncert.","l");
1154 <    if ( overlay_signal ) legBpred->AddEntry(lm4RcorrJZBeemm,"LM4","l");
1152 > //    legBpred->AddEntry(analytical_function[1],"predicted fit","l");
1153 > //    legBpred->AddEntry(analytical_function[2],"stat. uncert.","l");
1154 >    legBpred->AddEntry(lm4RcorrJZBeemm,(allsamples.collection[allsamples.FindSample("LM")[0]].samplename).c_str(),"l");
1155      legBpred->Draw();
1156      DrawPrelim();
1157  
# Line 1050 | Line 1180 | void do_prediction_plot(string jzb, TCan
1180      Bpred->Draw("hist,same");
1181   //    analytical_function[0]->Draw("same"); analytical_function[1]->Draw("same");analytical_function[2]->Draw("same");
1182      RcorrJZBeemm->Draw("e1x0,same");//HAVE IT ON TOP!
1183 < //    TH1F *lm4RcorrJZBeemmC = (TH1F*)lm4RcorrJZBeemm->Clone("lm4RcorrJZBeemmC");
1054 < //    lm4RcorrJZBeemmC->SetLineColor(kOrange+1);
1055 <    lm4RcorrJZBeemm->SetLineColor(kOrange+1);
1056 < //    lm4RcorrJZBeemmC->Draw("histo,same");
1183 > //    lm4RcorrJZBeemm->SetLineColor(kOrange+1);
1184      lm4RcorrJZBeemm->SetLineWidth(2);
1185 +    //lm4RcorrJZBeemm->SetLineWidth(2); // paper style. overruled.
1186      lm4RcorrJZBeemm->Draw("histo,same");
1187      DrawPrelim();
1188      TLegend *speciallegBpred = make_legend("",0.45,0.55);
1189 +    //TLegend *speciallegBpred = make_legend("",0.35,0.55); // paper style. overruled.
1190      speciallegBpred->AddEntry(RcorrJZBeemm,"Data","pl");
1191      speciallegBpred->AddEntry(Bpred,"Total background","l");
1192      speciallegBpred->AddEntry(jzbnegative,"JZB<0 (data)","f");
1193 <    speciallegBpred->AddEntry(sidebandsemu,"Sidebands/e#mu (data)","f");
1193 >    if(PlottingSetup::RestrictToMassPeak) speciallegBpred->AddEntry(sidebandsemu,"Sidebands/e#mu (data)","f");
1194 >    else speciallegBpred->AddEntry(sidebandsemu,"e#mu (data)","f");
1195   //    speciallegBpred->AddEntry(lm4RcorrJZBeemmC,"LM4","l");
1196      speciallegBpred->AddEntry(lm4RcorrJZBeemm,"LM4","l");
1197      speciallegBpred->Draw();
1198 <    save_with_ratio(JRcorrJZBeemm,JBpred,predcomppad,subdir+"Bpred_Data_____PredictionComposition",true,use_data!=1,"data/pred");
1198 >    save_with_ratio(JRcorrJZBeemm,JBpred,predcomppad,subdir+"Bpred_Data_____PredictionComposition",true,true,"data/pred",BpredSys);
1199      
1200      TCanvas *specialcanv = new TCanvas("specialcanv","specialcanv");
1201 <    THStack kostack = allsamples.DrawStack("RcorrJZBeemm",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,!is_data, luminosity,use_signal);
1201 >    specialcanv->SetLogy(1);
1202 > //    THStack kostack = allsamples.DrawStack("RcorrJZBeemm",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,!is_data, luminosity,use_signal);
1203      blankback->Draw();
1204 <    kostack.Draw("same");
1204 > //    kostack.Draw("same");
1205 >    predcomposition.Draw();
1206      Bpred->Draw("hist,same");
1207 <    analytical_function[0]->Draw("same"); analytical_function[1]->Draw("same");analytical_function[2]->Draw("same");
1207 >    //analytical_function[0]->Draw("same"); analytical_function[1]->Draw("same");analytical_function[2]->Draw("same");
1208      RcorrJZBeemm->Draw("e1x0,same");//HAVE IT ON TOP!
1209      legBpred->Draw();
1210      DrawPrelim();
1211      CompleteSave(specialcanv,subdir+"Bpred_Data_____PredictionCompositioninMC");
1212      Bpred->SetLineWidth((int)CurrentBpredLineWidth);
1213      
1214 +    
1215 +    //for(int i=1;i<=Bpred->GetNbinsX();i++) cout << Bpred->GetBinLowEdge(i) << ";" << Bpred->GetBinLowEdge(i)+Bpred->GetBinWidth(i) << ";;" << RcorrJZBeemm->GetBinContent(i) << ";" << LcorrJZBeemm->GetBinContent(i) << ";" << RcorrJZBem->GetBinContent(i) << ";" << LcorrJZBem->GetBinContent(i) << endl;
1216 +    
1217      delete speciallegBpred;
1218      delete Zjetspred;
1219      delete TTbarpred;
# Line 1087 | Line 1222 | void do_prediction_plot(string jzb, TCan
1222    }
1223    if(use_data==0) {
1224      RcorrJZBeemm->Draw("e1x0,same");
1225 +    //Bpred->SetLineWidth(3); // paper style. overruled.
1226      Bpred->Draw("hist,same");
1227      RcorrJZBeemm->Draw("e1x0,same");//HAVE IT ON TOP!
1228      legBpred->AddEntry(RcorrJZBeemm,"MC true","p");
1229 <    legBpred->AddEntry(Bpred,"MC predicted","l");
1229 >    legBpred->AddEntry(Bpred,"MC predicted","l");    
1230      if(versok) legBpred->AddEntry((TObject*)0,"",""); // Just for alignment // causes seg fault on root v5.18
1231      if(versok) legBpred->AddEntry((TObject*)0,"",""); // causes seg fault on root v5.18
1232      if ( overlay_signal ) legBpred->AddEntry(lm4RcorrJZBeemm,"LM4","l");
# Line 1101 | Line 1237 | void do_prediction_plot(string jzb, TCan
1237    }
1238    if(use_data==2) {
1239      RcorrJZBeemm->Draw("e1x0,same");
1240 +    //Bpred->SetLineWidth(3); // paper style. overruled.
1241      Bpred->Draw("hist,same");
1242      RcorrJZBeemm->Draw("e1x0,same");//HAVE IT ON TOP!
1243      legBpred->AddEntry(RcorrJZBeemm,"MC true","p");
# Line 1116 | Line 1253 | void do_prediction_plot(string jzb, TCan
1253   //      CompleteSave(globalcanvas,"Bpred_MCwithS"); // done below in save_with_ratio
1254      }
1255      {
1256 +      //lm4RcorrJZBeemm->SetLineWidth(3); //paper style. overruled.
1257 +      //RcorrJZBeemmNoS->SetLineWidth(3); //paper style. overruled.
1258 +      //lm4RcorrJZBeemm->SetLineStyle(2); //paper style. overruled.
1259 +      //RcorrJZBeemmNoS->SetLineStyle(3); //paper style. overruled.
1260 +      //lm4RcorrJZBeemm->SetLineColor(kOrange+1); //paper style. overruled.
1261 +      
1262        RcorrJZBeemmNoS->SetLineStyle(2);
1263        legBpred2->AddEntry(RcorrJZBeemmNoS,"MC B","l");
1264        legBpred2->AddEntry(lm4RcorrJZBeemm,"MC S","l");
# Line 1135 | Line 1278 | void do_prediction_plot(string jzb, TCan
1278    string ytitle("ratio");
1279    if ( use_data==1 ) ytitle = "data/pred";
1280    //save_with_ratio(JRcorrJZBeemm,JBpred,kinpad,Bpredsaveas,true,use_data!=1,ytitle);
1281 <  save_with_ratio(JRcorrJZBeemm,JBpred,kinpad,subdir+Bpredsaveas,true,false,ytitle);//not extending the y range anymore up to 4
1281 >  save_with_ratio(JRcorrJZBeemm,JBpred,kinpad,subdir+Bpredsaveas,true,true,ytitle,BpredSys);//not extending the y range anymore up to 4
1282  
1283    
1284    flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak
1285 <  /// The part below is meaningless for the offpeak analysis (it's a comparison of the different estimates but there is but one estimate!)
1285 >  // The part below is meaningless for the offpeak analysis (it's a comparison of the different estimates but there is but one estimate!)
1286    if(PlottingSetup::RestrictToMassPeak) {
1287      TH1F *Bpredem = (TH1F*)LcorrJZBeemm->Clone("Bpredem");
1288      Bpredem->Add(RcorrJZBem);
# Line 1201 | Line 1344 | void do_prediction_plot(string jzb, TCan
1344      }
1345    }
1346    
1347 +  TFile *f = new TFile("tester.root","RECREATE");
1348 +  RcorrJZBeemm->Write();
1349 +  Bpred->Write();
1350 +  f->Close();
1351 +  
1352    delete RcorrJZBeemm;
1353    delete LcorrJZBeemm;
1354    delete RcorrJZBem;
# Line 1213 | Line 1361 | void do_prediction_plot(string jzb, TCan
1361  
1362    delete blankback;
1363    
1364 +  delete BpredSys;
1365    if(PlottingSetup::RestrictToMassPeak) {
1366      delete RcorrJZBSBem;
1367      delete LcorrJZBSBem;
# Line 1230 | Line 1379 | void do_prediction_plot(string jzb, TCan
1379  
1380   void do_prediction_plots(string mcjzb, string datajzb, float DataSigma, float MCSigma, bool overlay_signal ) {
1381    TCanvas *globalcanvas = new TCanvas("globalcanvas","Prediction Canvas");
1382 <  do_prediction_plot(datajzb,globalcanvas,DataSigma,jzbHigh ,data,overlay_signal);
1383 <  do_prediction_plot(mcjzb,globalcanvas,MCSigma,jzbHigh ,mc,overlay_signal);
1384 <  do_prediction_plot(mcjzb,globalcanvas,MCSigma,jzbHigh ,mcwithsignal,overlay_signal);
1382 >  do_prediction_plot(datajzb,globalcanvas,jzbHigh ,data,overlay_signal);
1383 >  if ( !PlottingSetup::Approved ) {
1384 >    do_prediction_plot(mcjzb,globalcanvas,jzbHigh ,mc,overlay_signal);
1385 >    do_prediction_plot(mcjzb,globalcanvas,jzbHigh ,mcwithsignal,overlay_signal);
1386 >  } else {
1387 >    write_info(__FUNCTION__,"You set approved to true, therefore not producing prediction/observation plots for MC with and without signal.");
1388 >  }
1389   }
1390  
1391   void do_ratio_plot(int is_data,vector<float> binning, string jzb, TCanvas *can, float high=-9999) {
# Line 1652 | Line 1805 | void diboson_plots(string mcjzb, string
1805    
1806    
1807    dout << "Going to increase the cross section for diboson samples ... " << endl;
1808 <  for(int i=0;i<SamplesToBeModified.size();i++) {
1808 >  for(int i=0;i<(int)SamplesToBeModified.size();i++) {
1809      float origxs=(allsamples.collection)[SamplesToBeModified[i]].xs;
1810      (allsamples.collection)[SamplesToBeModified[i]].xs=origxs*stretchfactor;
1811      dout << "     Increased xs for sample " << (allsamples.collection)[SamplesToBeModified[i]].filename << " from " << origxs << " to " << (allsamples.collection)[SamplesToBeModified[i]].xs << " (by a factor of " << stretchfactor << ")" << endl;
# Line 1662 | Line 1815 | void diboson_plots(string mcjzb, string
1815    }
1816    
1817    dout << "Going to produce JZB plots" << endl;
1818 < //  produce_stretched_jzb_plots(mcjzb,datajzb,ratio_binning);
1818 >  produce_stretched_jzb_plots(mcjzb,datajzb,ratio_binning);
1819    TCanvas *gloca = new TCanvas("gloca","gloca");
1667 –  float sigma=123456;
1820    
1821    dout << "Going to produce prediction plots" << endl;
1822 <  do_prediction_plot(mcjzb, gloca, sigma, PlottingSetup::jzbHigh, 0, false,"Dibosons/Bpred/" ); // do only MC plots, no signal
1823 <  do_prediction_plot(mcjzb, gloca, sigma, PlottingSetup::jzbHigh, 0, false,"Dibosons/Bpred/" ); // do MC plots with signal
1822 >  do_prediction_plot(mcjzb, gloca, PlottingSetup::jzbHigh, 0, false,"Dibosons/Bpred/" ); // do only MC plots, no signal
1823 >  do_prediction_plot(mcjzb, gloca, PlottingSetup::jzbHigh, 0, false,"Dibosons/Bpred/" ); // do MC plots with signal
1824    delete gloca;
1825  
1826    dout << "Going to reset the cross section for diboson samples ... " << endl;
1827 <  for(int i=0;i<SamplesToBeModified.size();i++) {
1827 >  for(int i=0;i<(int)SamplesToBeModified.size();i++) {
1828      float Upxs=(allsamples.collection)[SamplesToBeModified[i]].xs;
1829      (allsamples.collection)[SamplesToBeModified[i]].xs=(allsamples.collection)[SamplesToBeModified[i]].xs*(1.0/stretchfactor);
1830      string Upname=(allsamples.collection)[SamplesToBeModified[i]].samplename;
# Line 1682 | Line 1834 | void diboson_plots(string mcjzb, string
1834    }
1835    
1836   }
1837 +
1838 +
1839 + void draw_normalized_data_vs_data_histo(TCut cut1, TCut cut2, string variable, string legentry1, string legentry2, string savename, TCanvas *can,vector<float> binning) {
1840 +  TPad *jzbpad = new TPad("jzbpad","jzbpad",0,0,1,1);
1841 +  jzbpad->cd();
1842 +  jzbpad->SetLogy(1);
1843 +  string xlabel="JZB [GeV]";
1844 +
1845 +  TH1F *datahisto1 = allsamples.Draw("datahisto1",variable,binning, xlabel, "events",cut1,data,luminosity);
1846 +  datahisto1->SetLineColor(kRed);
1847 +  datahisto1->SetMarkerColor(kRed);
1848 +  TH1F *datahisto2 = allsamples.Draw("datahisto2",variable,binning, xlabel, "events",cut2,data,luminosity);
1849 +  datahisto2->SetLineColor(kBlue);
1850 +  datahisto2->SetMarkerColor(kBlue);
1851 +  
1852 +  datahisto2->SetMarkerSize(DataMarkerSize);
1853 +  datahisto1->DrawNormalized("e1");
1854 +  datahisto2->DrawNormalized("histo,same");
1855 +  datahisto1->DrawNormalized("same,e1");
1856 +  
1857 +  TLegend *leg = make_legend();
1858 +  leg->AddEntry(datahisto1,legentry1.c_str());
1859 +  leg->AddEntry(datahisto2,legentry2.c_str());
1860 +  leg->Draw();
1861 +  
1862 +  save_with_ratio(datahisto1,datahisto2,jzbpad->cd(),("jzb/"+savename));
1863 +  
1864 +  datahisto1->Delete();
1865 +  datahisto2->Delete();
1866 + }
1867 +
1868 +
1869   void jzb_plots(string mcjzb, string datajzb,vector<float> ratio_binning) {
1870    TCanvas *can = new TCanvas("can","JZB Plots Canvas");
1871    float max=jzbHigh ;
# Line 1695 | Line 1879 | void jzb_plots(string mcjzb, string data
1879    for(int i=0;i<=coarserbins;i++)coarse_binning.push_back(min+i*(max-min)/((float)coarserbins));
1880    for(int i=0;i<=rebinnedbins;i++)coarsest_binning.push_back(min+i*(max-min)/((float)rebinnedbins));
1881  
1882 <  draw_pure_jzb_histo(cutOSSF&&cutnJets&&cutmass,datajzb,mcjzb,"jzb_OS_SFZP",can,binning);
1883 <  draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass,datajzb,mcjzb,"jzb_OS_OFZP",can,binning);
1884 <  draw_pure_jzb_histo(cutOSSF&&cutnJets&&cutmass&&"id1==0",datajzb,mcjzb,"ee/jzb_OS_SFZP",can,binning);
1885 <  draw_pure_jzb_histo(cutOSSF&&cutnJets&&cutmass&&"id1==1",datajzb,mcjzb,"mm/jzb_OS_SFZP",can,binning);
1886 <  draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass&&"id1==0",datajzb,mcjzb,"ee/jzb_OS_OFZP",can,binning);
1887 <  draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass&&"id1==1",datajzb,mcjzb,"mm/jzb_OS_OFZP",can,binning);
1888 <  flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak
1889 <  if(PlottingSetup::RestrictToMassPeak) draw_pure_jzb_histo(cutOSSF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_SFSB",can,binning);
1890 <  if(PlottingSetup::RestrictToMassPeak) draw_pure_jzb_histo(cutOSOF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_OFSB",can,binning);
1882 >  if ( !PlottingSetup::Approved ) {
1883 >    draw_pure_jzb_histo(cutOSSF&&cutnJets&&cutmass,datajzb,mcjzb,"jzb_OS_SFZP",can,binning);
1884 >    draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass,datajzb,mcjzb,"jzb_OS_OFZP",can,binning);
1885 >    draw_pure_jzb_histo(cutOSSF&&cutnJets&&cutmass&&"id1==0",datajzb,mcjzb,"ee/jzb_OS_SFZP",can,binning);
1886 >    draw_pure_jzb_histo(cutOSSF&&cutnJets&&cutmass&&"id1==1",datajzb,mcjzb,"mm/jzb_OS_SFZP",can,binning);
1887 >    draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass&&"id1==0",datajzb,mcjzb,"ee/jzb_OS_OFZP",can,binning);
1888 >    draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass&&"id1==1",datajzb,mcjzb,"mm/jzb_OS_OFZP",can,binning);
1889 >    flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak
1890 >    if(PlottingSetup::RestrictToMassPeak) draw_pure_jzb_histo(cutOSSF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_SFSB",can,binning);
1891 >    if(PlottingSetup::RestrictToMassPeak) draw_pure_jzb_histo(cutOSOF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_OFSB",can,binning);
1892 >    draw_normalized_data_vs_data_histo(cutOSOF&&cutnJets&&cutmass&&"id1==0",cutOSOF&&cutnJets&&cutmass&&"id1==1",datajzb,"ee","mm","jzb_ee_vs_mm",can,binning);
1893 >    draw_normalized_data_vs_data_histo(cutOSOF&&cutnJets&&cutmass&&"id1==0",cutOSOF&&cutnJets&&cutmass&&"id1==1",datajzb,"ee","mm","jzb_ee_vs_mm_coarse",can,coarse_binning);
1894 >    draw_normalized_data_vs_data_histo(cutOSOF&&cutnJets&&cutmass&&"id1==0",cutOSOF&&cutnJets&&cutmass&&"id1==1",datajzb,"ee","mm","jzb_ee_vs_mm_coarsest",can,coarsest_binning);
1895 >
1896 >  }
1897    
1898    draw_pure_jzb_histo(cutOSSF&&cutnJets&&cutmass,datajzb,mcjzb,"jzb_OS_SFZP_coarse",can,coarse_binning);
1899 <  draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass,datajzb,mcjzb,"jzb_OS_OFZP_coarse",can,coarse_binning);
1900 <  flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak
1901 <  if(PlottingSetup::RestrictToMassPeak) draw_pure_jzb_histo(cutOSSF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_SFSB_coarse",can,coarse_binning);
1902 <  if(PlottingSetup::RestrictToMassPeak) draw_pure_jzb_histo(cutOSOF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_OFSB_coarse",can,coarse_binning);
1903 <
1904 < //  draw_pure_jzb_histo(cutOSSF&&cutnJets&&cutmass,datajzb,mcjzb,"jzb_OS_SFZP_coarsest",can,coarsest_binning);
1715 < //  draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass,datajzb,mcjzb,"jzb_OS_OFZP_coarsest",can,coarsest_binning);
1716 < //  flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak
1717 < //  if(PlottingSetup::RestrictToMassPeak) draw_pure_jzb_histo(cutOSSF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_SFSB_coarsest",can,coarsest_binning);
1718 < //  if(PlottingSetup::RestrictToMassPeak) draw_pure_jzb_histo(cutOSOF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_OFSB_coarsest",can,coarsest_binning);
1899 >  if ( !PlottingSetup::Approved ) {
1900 >    draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass,datajzb,mcjzb,"jzb_OS_OFZP_coarse",can,coarse_binning);
1901 >    flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak
1902 >    if(PlottingSetup::RestrictToMassPeak) draw_pure_jzb_histo(cutOSSF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_SFSB_coarse",can,coarse_binning);
1903 >    if(PlottingSetup::RestrictToMassPeak) draw_pure_jzb_histo(cutOSOF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_OFSB_coarse",can,coarse_binning);
1904 >  }
1905    delete can;
1906   }
1907  
# Line 1771 | Line 1957 | void compute_MC_yields(string mcjzb,vect
1957    string posneg[] = {"pos","neg"};
1958    TCut tkRegions[] = {cutOSSF&&cutnJets&&cutmass,cutOSOF&&cutnJets&&cutmass,cutOSSF&&cutnJets&&sidebandcut,cutOSOF&&cutnJets&&sidebandcut};
1959  
1960 <  for(int ijzb=0;ijzb<jzb_cuts.size();ijzb++) {
1960 >  for(int ijzb=0;ijzb<(int)jzb_cuts.size();ijzb++) {
1961      TCut jzbMC[]  = { give_jzb_expression(mcjzb,jzb_cuts[ijzb],"pos"), give_jzb_expression(mcjzb,jzb_cuts[ijzb],"neg") };
1962      dout << "_________________________________________________________" << endl;
1963      dout << "Table for JZB> " << jzb_cuts[ijzb] << endl;
1964 <    for(int isample=0;isample<(allsamples.collection).size();isample++) {
1964 >    for(int isample=0;isample<(int)(allsamples.collection).size();isample++) {
1965        if(!(allsamples.collection)[isample].is_data) dout << (allsamples.collection)[isample].samplename << "  &  ";
1966        else dout << "Sample & ";
1967        for(int iregion=0;iregion<nRegions;iregion++) {
# Line 2034 | Line 2220 | void draw_ttbar_and_zjets_shape_for_one_
2220  
2221   void draw_ttbar_and_zjets_shape(string mcjzb, string datajzb) {
2222    int all_leptons=-1;
2037 –  int electrons_only=0;
2038 –  int mu_only=1;
2039 –  int twojetswith50gev=1;
2223    int threejetswith30gev=0;
2224   /*  
2225 +  int twojetswith50gev=1;
2226 +  int electrons_only=0;
2227 +  int mu_only=1;
2228 +
2229    draw_ttbar_and_zjets_shape_for_one_configuration(mcjzb,datajzb,all_leptons,twojetswith50gev);
2230    draw_ttbar_and_zjets_shape_for_one_configuration(mcjzb,datajzb,all_leptons,threejetswith30gev);
2231    
# Line 2052 | Line 2239 | void draw_ttbar_and_zjets_shape(string m
2239    draw_ttbar_and_zjets_shape_for_one_configuration(mcjzb,datajzb,all_leptons,threejetswith30gev,true);
2240   }
2241  
2242 < void find_correction_factors(string &jzbvardata,string &jzbvarmc) {
2056 <  //first: colorful plots
2242 > float find_one_correction_factor(string FindKeyword, bool dodata, TCut SpecialCut, string SaveAs) {
2243    TCanvas *cancorr = new TCanvas("cancorr","Canvas for Response Correction");
2244    cancorr->SetLogz();
2245    cancorr->SetRightMargin(0.13);
2246 <  flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak
2247 <  TCut zptforresponsepresentation("pt<600"&&cutmass&&cutOSSF&&"((sumJetPt[1]/pt)<5.0)");
2248 <  TH2F *niceresponseplotd = new TH2F("niceresponseplotd","",100,0,600,100,0,5);
2249 <  (allsamples.collection)[allsamples.FindSample("Data")[0]].events->Draw("sumJetPt[1]/pt:pt>>niceresponseplotd",zptforresponsepresentation);
2246 >  TCut zptbasecutforresponsepresentation("pt<600&&((sumJetPt[1]/pt)<5.0)"&&SpecialCut&&passtrig);
2247 >    
2248 > //  TCut zptforresponsepresentation("pt<600"&&cutmass&&cutOSSF&&"((sumJetPt[1]/pt)<5.0)"&&SpecialCut&&passtrig);
2249 >  if(PlottingSetup::DoBTag) zptbasecutforresponsepresentation=zptbasecutforresponsepresentation&&PlottingSetup::bTagRequirement;
2250 >    TH2F *niceresponseplotd = new TH2F("niceresponseplotd","",100,0,600,100,0,5);
2251 >    TH2F *niceresponseplotd_SFSB = new TH2F("niceresponseplotd_SFSB","",100,0,600,100,0,5);
2252 >    TH2F *niceresponseplotd_OFSB = new TH2F("niceresponseplotd_OFSB","",100,0,600,100,0,5);
2253 >    TH2F *niceresponseplotd_OFZP = new TH2F("niceresponseplotd_OFZP","",100,0,600,100,0,5);
2254 >  vector<int> SampleIndices=allsamples.FindSample(FindKeyword);
2255 >  for(int iSample=0;iSample<(int)SampleIndices.size();iSample++) {
2256 >    if((allsamples.collection)[SampleIndices[iSample]].is_data && !dodata) continue;
2257 >    if((allsamples.collection)[SampleIndices[iSample]].is_data ==false && dodata) continue;
2258 >    
2259 >    dout << "   Response correction : Using sample " << (allsamples.collection)[SampleIndices[iSample]].filename << " for " << FindKeyword << endl;
2260 >    (allsamples.collection)[SampleIndices[iSample]].events->Draw("sumJetPt[1]/pt:pt>>+niceresponseplotd",(zptbasecutforresponsepresentation&&cutmass&&cutOSSF)*cutWeight);
2261 >    if(PlottingSetup::RestrictToMassPeak) (allsamples.collection)[SampleIndices[iSample]].events->Draw("sumJetPt[1]/pt:pt>>+niceresponseplotd_OFSB",(zptbasecutforresponsepresentation&&sidebandcut&&cutOSOF)*cutWeight);
2262 >    if(PlottingSetup::RestrictToMassPeak) (allsamples.collection)[SampleIndices[iSample]].events->Draw("sumJetPt[1]/pt:pt>>+niceresponseplotd_SFSB",(zptbasecutforresponsepresentation&&sidebandcut&&cutOSSF)*cutWeight);
2263 >    (allsamples.collection)[SampleIndices[iSample]].events->Draw("sumJetPt[1]/pt:pt>>+niceresponseplotd_OFZP",(zptbasecutforresponsepresentation&&cutmass&&cutOSOF)*cutWeight);
2264 >  }
2265 >    
2266 >    if(PlottingSetup::RestrictToMassPeak) {
2267 >        niceresponseplotd->Add(niceresponseplotd_SFSB,-1.0/3);
2268 >        niceresponseplotd->Add(niceresponseplotd_OFSB,-1.0/3);
2269 >        niceresponseplotd->Add(niceresponseplotd_OFZP,-1.0/3);
2270 >    } else {
2271 >        niceresponseplotd->Add(niceresponseplotd_OFZP,-1.0);
2272 >    }
2273 >    
2274    niceresponseplotd->SetStats(0);
2275    niceresponseplotd->GetXaxis()->SetTitle("Z p_{T} [GeV]");
2276    niceresponseplotd->GetYaxis()->SetTitle("Response");
# Line 2069 | Line 2279 | void find_correction_factors(string &jzb
2279    niceresponseplotd->Draw("COLZ");
2280    TProfile * profd = (TProfile*)niceresponseplotd->ProfileX();
2281    profd->SetMarkerSize(DataMarkerSize);
2282 <  profd->Fit("pol0","","same,e1",30,400);
2282 >  profd->Fit("pol0","E","same,e1",100,400); //use MINOS
2283    DrawPrelim();
2284 <  TText* title = write_text(0.5,0.7,"Data");
2284 >  string stitle="Data";
2285 >  if(!Contains(FindKeyword,"Data")) stitle="MC";
2286 >  TText* title = write_text(0.5,0.7,stitle.c_str());
2287    title->SetTextAlign(12);
2288    title->Draw();
2289    TF1 *datapol=(TF1*)profd->GetFunction("pol0");
2290 <  float datacorrection=datapol->GetParameter(0);
2291 <  stringstream dataresstring;
2292 <  dataresstring<<"Response: "<<std::setprecision(2)<<100*datacorrection<<" %";
2293 <  TText* restitle = write_text(0.5,0.65,dataresstring.str());
2290 >  float correction=datapol->GetParameter(0);
2291 >  stringstream resstring;
2292 >  resstring<<"Response: "<<std::setprecision(2)<<100*correction<<" %";
2293 >  TText* restitle = write_text(0.5,0.65,resstring.str());
2294    restitle->SetTextAlign(12);
2295    restitle->SetTextSize(0.03);
2296    restitle->Draw();
2297 <  CompleteSave(cancorr,"ResponseCorrection/Response_Correction_Illustration_Data");
2298 <  
2299 <  TH2F *niceresponseplotm = new TH2F("niceresponseplotm","",100,0,600,100,0,5);
2300 <  (allsamples.collection)[allsamples.FindSample("DY")[0]].events->Draw("sumJetPt[1]/pt:pt>>niceresponseplotm",zptforresponsepresentation);
2301 <  niceresponseplotm->SetStats(0);
2302 <  niceresponseplotm->GetXaxis()->SetTitle("Z p_{T} [GeV]");
2303 <  niceresponseplotm->GetYaxis()->SetTitle("Response");
2304 <  niceresponseplotm->GetXaxis()->CenterTitle();
2305 <  niceresponseplotm->GetYaxis()->CenterTitle();
2306 <  niceresponseplotm->Draw("COLZ");
2095 <  (allsamples.collection)[allsamples.FindSample("DY")[0]].events->Draw("sumJetPt[1]/pt:pt",zptforresponsepresentation,"PROF,same");
2096 <  TProfile * profm = (TProfile*)niceresponseplotm->ProfileX();
2097 <  profm->SetMarkerSize(DataMarkerSize);
2098 <  profm->Fit("pol0","","same,e1",30,400);
2099 <  DrawMCPrelim();
2100 <  title = write_text(0.5,0.7,"MC simulation");
2101 <  title->SetTextAlign(12);
2102 <  title->Draw();
2103 <  TF1 *mcpol=(TF1*)profm->GetFunction("pol0");
2104 <  float mccorrection=mcpol->GetParameter(0);
2105 <  stringstream mcresstring;
2106 <  mcresstring<<"Response: "<<std::setprecision(2)<<100*mccorrection<<" %";
2107 <  TText* mcrestitle = write_text(0.5,0.65,mcresstring.str());
2108 <  mcrestitle->SetTextAlign(12);
2109 <  mcrestitle->SetTextSize(0.03);
2110 <  mcrestitle->Draw();
2111 <  CompleteSave(cancorr,"ResponseCorrection/Response_Correction_Illustration_MC");
2297 >  CompleteSave(cancorr,"ResponseCorrection/Response_Correction_Illustration_New_"+SaveAs);
2298 >  delete cancorr;
2299 >  delete niceresponseplotd;
2300 >  delete niceresponseplotd_OFZP;
2301 >  delete niceresponseplotd_OFSB;
2302 >  delete niceresponseplotd_SFSB;
2303 >  return correction;
2304 > }
2305 >
2306 > void find_correction_factors(string &jzbvardata,string &jzbvarmc) {
2307    
2308 +  dout << "Computing response corrections: " << endl;
2309 +  //Step 1 : Get results
2310 +  float datacorrection=find_one_correction_factor("Data",true,"","Data");
2311 +  float mccorrection=find_one_correction_factor("DY",false,"","MC");
2312 +  
2313 +  float dataEEcorrection=find_one_correction_factor("Data",true,"id1==0","Data_ee");
2314 +  float mcEEcorrection=find_one_correction_factor("DY",false,"id1==0","MC_ee");
2315 +  
2316 +  float dataMMcorrection=find_one_correction_factor("Data",true,"id1==1","Data_mm");
2317 +  float mcMMcorrection=find_one_correction_factor("DY",false,"id1==1","MC_mm");
2318 +  
2319 +  cout << "Corrections : " << endl;
2320 +  cout << "   Data : " << datacorrection << endl;
2321 +  cout << "     ee (" << dataEEcorrection << ") , mm (" << dataMMcorrection << ")" << endl;
2322 +  cout << "   MC : " << mccorrection << endl;
2323 +  cout << "     ee (" << mcEEcorrection << ") , mm (" << mcMMcorrection << ")" << endl;
2324    
2325 <  //Step 2: Getting the result
2115 < //  TCut zptcutforresponse("pt>30&&pt<300&&TMath::Abs(91.2-mll)<20&&id1==id2&&(ch1*ch2<0)");
2325 >  //Step 2: Processing the result and making it into something useful :-)
2326    stringstream jzbvardatas;
2327 <  if(datacorrection>1) jzbvardatas<<"(jzb[1]-"<<datacorrection-1<<"*pt)";
2328 <  if(datacorrection<1) jzbvardatas<<"(jzb[1]+"<<1-datacorrection<<"*pt)";
2327 >  jzbvardatas << "(";
2328 >  
2329 >  if(dataEEcorrection>=1) jzbvardatas<<"((id1==0&&id1==id2)*(jzb[1]-" << dataEEcorrection-1 << "*pt))";
2330 >  if(dataEEcorrection<1)  jzbvardatas<<"((id1==0&&id1==id2)*(jzb[1]+" << 1-dataEEcorrection << "*pt))";
2331 >  
2332 >  if(dataMMcorrection>=1) jzbvardatas<<"+((id1==1&&id1==id2)*(jzb[1]-" << dataMMcorrection-1 << "*pt))";
2333 >  if(dataMMcorrection<1)  jzbvardatas<<"+((id1==1&&id1==id2)*(jzb[1]+" << 1-dataMMcorrection << "*pt))";
2334 >  
2335 >  float averagecorrection=(dataMMcorrection+dataEEcorrection)/2.0;
2336 >  
2337 >  if(datacorrection>=1) jzbvardatas<<"+((id1!=id2)*(jzb[1]-" << datacorrection-1 << "*pt))";
2338 >  if(datacorrection<1) jzbvardatas<<"+((id1!=id2)*(jzb[1]+" << 1-datacorrection << "*pt))";
2339 >  
2340 >  jzbvardatas << ")";
2341    jzbvardata=jzbvardatas.str();
2342 +  
2343    stringstream jzbvarmcs;
2344 <  if(mccorrection>1) jzbvarmcs<<"(jzb[1]-"<<mccorrection-1<<"*pt)";
2345 <  if(mccorrection<1) jzbvarmcs<<"(jzb[1]+"<<1-mccorrection<<"*pt)";
2344 >  jzbvarmcs << "(";
2345 >  
2346 >  if(mcEEcorrection>=1) jzbvarmcs<<"((id1==0&&id1==id2)*(jzb[1]-" << mcEEcorrection-1 << "*pt))";
2347 >  if(mcEEcorrection<1)  jzbvarmcs<<"((id1==0&&id1==id2)*(jzb[1]+" << 1-mcEEcorrection << "*pt))";
2348 >  
2349 >  if(mcMMcorrection>=1) jzbvarmcs<<"+((id1==1&&id1==id2)*(jzb[1]-" << mcMMcorrection-1 << "*pt))";
2350 >  if(mcMMcorrection<1)  jzbvarmcs<<"+((id1==1&&id1==id2)*(jzb[1]+" << 1-mcMMcorrection << "*pt))";
2351 >  
2352 >  float averagemccorrection=(mcMMcorrection+mcEEcorrection)/2.0;
2353 >  
2354 >  if(mccorrection>=1) jzbvarmcs<<"+((id1!=id2)*(jzb[1]-" << mccorrection-1 << "*pt))";
2355 >  if(mccorrection<1) jzbvarmcs<<"+((id1!=id2)*(jzb[1]+" << 1-mccorrection << "*pt))";
2356 >  
2357 >  jzbvarmcs << ")";
2358    jzbvarmc=jzbvarmcs.str();
2359 +
2360    dout << "JZB Z pt correction summary : " << endl;
2361    dout << "  Data: The response is " << datacorrection << "  --> jzb variable is now : " << jzbvardata << endl;
2362    dout << "  MC  : The response is " << mccorrection << "  --> jzb variable is now : " << jzbvarmc << endl;
2363 +  
2364   }
2365  
2366   void pick_up_events(string cut) {
# Line 2131 | Line 2368 | void pick_up_events(string cut) {
2368    allsamples.PickUpEvents(cut);
2369   }
2370  
2371 < void save_template(string mcjzb, string datajzb,vector<float> jzb_cuts,float MCPeakError,float DataPeakError) {
2371 > void save_template(string mcjzb, string datajzb,vector<float> jzb_cuts,float MCPeakError,float DataPeakError, vector<float> jzb_shape_limit_bins) {
2372    dout << "Saving configuration template!" << endl;
2373    ofstream configfile;
2374    configfile.open("../DistributedModelCalculations/last_configuration.C");
# Line 2151 | Line 2388 | void save_template(string mcjzb, string
2388    configfile<<"string datajzb=\"datajzb_ERROR\";\n";
2389    configfile<<"string mcjzb=\"mcjzb_ERROR\";\n";
2390    configfile<<"vector<float>jzb_cuts;\n";
2391 +  configfile<<"vector<float>jzb_shape_limit_bins;\n";
2392    configfile<<"float MCPeakError=-999;\n";
2393    configfile<<"float DataPeakError=-999;\n";
2394    configfile<<"}\n\n";
# Line 2160 | Line 2398 | void save_template(string mcjzb, string
2398    configfile<<"mcjzb=\""<<mcjzb<<"\";\n\n";
2399    configfile<<"\n\nMCPeakError="<<MCPeakError<<";\n";
2400    configfile<<"DataPeakError="<<DataPeakError<<";\n\n";
2401 <  for(int i=0;i<jzb_cuts.size();i++) configfile<<"jzb_cuts.push_back("<<jzb_cuts[i]<<"); // JZB cut at " << jzb_cuts[i] << "\n";
2401 >  for(int i=0;i<(int)jzb_cuts.size();i++) configfile<<"jzb_cuts.push_back("<<jzb_cuts[i]<<"); // JZB cut at " << jzb_cuts[i] << "\n";
2402    configfile<<"\n\n";
2403 <  for(int i=0;i<Nobs.size();i++) configfile<<"Nobs.push_back("<<Nobs[i]<<"); // JZB cut at " << jzb_cuts[i] << "\n";
2404 <  for(int i=0;i<Npred.size();i++) configfile<<"Npred.push_back("<<Npred[i]<<"); // JZB cut at " << jzb_cuts[i] << "\n";
2405 <  for(int i=0;i<Nprederr.size();i++) configfile<<"Nprederr.push_back("<<Nprederr[i]<<"); // JZB cut at " << jzb_cuts[i] << "\n";
2403 >  for(int i=0;i<(int)Nobs.size();i++) configfile<<"Nobs.push_back("<<Nobs[i]<<"); // JZB cut at " << jzb_cuts[i] << "\n";
2404 >  for(int i=0;i<(int)Npred.size();i++) configfile<<"Npred.push_back("<<Npred[i]<<"); // JZB cut at " << jzb_cuts[i] << "\n";
2405 >  for(int i=0;i<(int)Nprederr.size();i++) configfile<<"Nprederr.push_back("<<Nprederr[i]<<"); // JZB cut at " << jzb_cuts[i] << "\n";
2406 >  configfile<<"\n\n";
2407 >  for(int i=0;i<(int)flippedNobs.size();i++) configfile<<"flippedNobs.push_back("<<flippedNobs[i]<<"); // JZB cut at " << jzb_cuts[i] << "\n";
2408 >  for(int i=0;i<(int)flippedNpred.size();i++) configfile<<"flippedNpred.push_back("<<flippedNpred[i]<<"); // JZB cut at " << jzb_cuts[i] << "\n";
2409 >  for(int i=0;i<(int)flippedNprederr.size();i++) configfile<<"flippedNprederr.push_back("<<flippedNprederr[i]<<"); // JZB cut at " << jzb_cuts[i] << "\n";
2410 >  for(int i=0;i<(int)jzb_shape_limit_bins.size();i++) configfile<<"jzb_shape_limit_bins.push_back("<<jzb_shape_limit_bins[i]<<"); // JZB shape bin boundary at " << jzb_shape_limit_bins[i] << "\n";
2411    configfile<<"\n\n";
2169 –  for(int i=0;i<flippedNobs.size();i++) configfile<<"flippedNobs.push_back("<<flippedNobs[i]<<"); // JZB cut at " << jzb_cuts[i] << "\n";
2170 –  for(int i=0;i<flippedNpred.size();i++) configfile<<"flippedNpred.push_back("<<flippedNpred[i]<<"); // JZB cut at " << jzb_cuts[i] << "\n";
2171 –  for(int i=0;i<flippedNprederr.size();i++) configfile<<"flippedNprederr.push_back("<<flippedNprederr[i]<<"); // JZB cut at " << jzb_cuts[i] << "\n";
2412    configfile<<"\n\n";
2413    configfile<<"luminosity="<<luminosity<<";\n";
2414    configfile<<"RestrictToMassPeak="<<RestrictToMassPeak<<";//defines the type of analysis we're running\n";
# Line 2194 | Line 2434 | void draw_all_ttbar_histos(TCanvas *can,
2434    float max=histos[0]->GetMaximum();
2435    if(manualmin>=0) min=manualmin;
2436    else {
2437 <    for(int i=1;i<histos.size();i++) {
2437 >    for(int i=1;i<(int)histos.size();i++) {
2438        float curmin=get_nonzero_minimum(histos[i]);
2439        float curmax=histos[i]->GetMaximum();
2440        if(curmin<min) min=curmin;
# Line 2205 | Line 2445 | void draw_all_ttbar_histos(TCanvas *can,
2445    histos[0]->Draw(drawoption.c_str());
2446    stringstream drawopt;
2447    drawopt << drawoption << ",same";
2448 <  for(int i=1;i<histos.size();i++) {
2448 >  for(int i=1;i<(int)histos.size();i++) {
2449      histos[i]->Draw(drawopt.str().c_str());
2450    }
2451   }
# Line 2214 | Line 2454 | void ttbar_sidebands_comparison(string m
2454    //in the case of the on peak analysis, we compare the 3 control regions to the real value
2455    //in the case of the OFF peak analysis, we compare our control region to the real value
2456    TCut weightbackup=cutWeight;
2217 –  cutWeight="1.0";
2218 –  float simulatedlumi = luminosity; //in pb please - adjust to your likings
2457    
2458 +  bool doPURW=false;
2459 +  
2460 +  
2461 +  if(!doPURW) {
2462 +    cutWeight="1.0";
2463 +    // Do it without PU re-weighting
2464 +    float MCPeakNoPU=0,MCPeakErrorNoPU=0,DataPeakNoPU=0,DataPeakErrorNoPU=0,MCSigma=0,DataSigma=0;
2465 +    stringstream resultsNoPU;
2466 +    stringstream noPUdatajzb;
2467 +    stringstream noPUmcjzb;
2468 +    
2469 +    stringstream mcjzbnoPU;
2470 +    find_peaks(MCPeakNoPU,MCPeakErrorNoPU, DataPeakNoPU, DataPeakErrorNoPU,resultsNoPU,true,noPUdatajzb,noPUmcjzb);
2471 +    mcjzb = noPUmcjzb.str();
2472 +  }
2473 +
2474 +    
2475 +    
2476 +    
2477 +    
2478 +    
2479 +  float simulatedlumi = luminosity; //in pb please - adjust to your likings
2480  
2481    TH1F *TZem = systsamples.Draw("TZem",mcjzb,binning,"JZB [GeV]","events",cutmass&&cutOSOF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTJets"));
2482    TH1F *nTZem = systsamples.Draw("nTZem","-"+mcjzb,binning,"JZB [GeV]","events",cutmass&&cutOSOF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTJets"));
# Line 2254 | Line 2514 | void ttbar_sidebands_comparison(string m
2514    }
2515    
2516    vector<TH1F*> histos;
2517 +  TZem->GetXaxis()->SetRangeUser(-100,binning[binning.size()-1]);
2518 +  TZeemm->GetXaxis()->SetRangeUser(-100,binning[binning.size()-1]);
2519    histos.push_back(TZem);
2520    histos.push_back(TZeemm);
2521    if(PlottingSetup::RestrictToMassPeak) {
2522 +    TSeemm->GetXaxis()->SetRangeUser(-100,binning[binning.size()-1]);
2523 +    TSem->GetXaxis()->SetRangeUser(-100,binning[binning.size()-1]);
2524      histos.push_back(TSem);
2525      histos.push_back(TSeemm);
2526    }
# Line 2272 | Line 2536 | void ttbar_sidebands_comparison(string m
2536    leg->Draw("same");
2537    DrawMCPrelim(simulatedlumi);
2538    CompleteSave(tcan,"Systematics/"+prestring+"/ttbar_shape_comparison");
2275 – cout << __LINE__ << endl;  
2539    TH1F *TZemcopy = (TH1F*)TZem->Clone("TZemcopy");
2277 – cout << __LINE__ << endl;  
2540    TH1F *TZeemmcopy = (TH1F*)TZeemm->Clone("TZeemmcopy");
2279 – cout << __LINE__ << endl;  
2541    TH1F *TSeemmcopy;
2542    TH1F *TSemcopy;
2543    if(PlottingSetup::RestrictToMassPeak) {
# Line 2302 | Line 2563 | cout << __LINE__ << endl;
2563      TSeemm->Draw("same");
2564    }
2565    
2566 <  float linepos=0.25;
2567 <  if(PlottingSetup::RestrictToMassPeak) linepos=0.25;
2568 <  if(!PlottingSetup::RestrictToMassPeak) linepos=0.1; //sys uncertainty for iJZB
2566 >  float linepos=emuncertONPEAK;
2567 >  if(!PlottingSetup::RestrictToMassPeak) linepos=emuncertOFFPEAK;
2568 >  
2569    TLine *top = new TLine(binning[0],1.0+linepos,binning[binning.size()-1],1.0+linepos);
2570    TLine *center = new TLine(binning[0],1.0,binning[binning.size()-1],1.0);
2571    TLine *bottom = new TLine(binning[0],1.0-linepos,binning[binning.size()-1],1.0-linepos);
# Line 2386 | Line 2647 | cout << __LINE__ << endl;
2647    tcan->SetLogy(0);
2648    rightofzp->Divide(rightsfzp);
2649    rightofzp->GetXaxis()->SetRangeUser(0.0,binning[binning.size()-1]);
2650 <  rightofzp->GetYaxis()->SetRangeUser(0.0,2.0);
2650 >  rightofzp->GetYaxis()->SetRangeUser(0.0,2.5);
2651    rightofzp->GetYaxis()->SetTitle("#deltaJZB ratio");
2652    rightofzp->Draw();
2653    if(PlottingSetup::RestrictToMassPeak) {
# Line 2446 | Line 2707 | cout << __LINE__ << endl;
2707  
2708   void ttbar_sidebands_comparison(string mcjzb, vector<float> jzb_binning) {
2709    vector<float> nicer_binning;
2710 <  nicer_binning.push_back(-125);
2710 >  
2711 > /*  nicer_binning.push_back(-400);
2712 >  nicer_binning.push_back(-250);
2713 >  nicer_binning.push_back(-200);
2714 >  nicer_binning.push_back(-150);
2715 >  nicer_binning.push_back(-100);
2716 >  nicer_binning.push_back(-50);
2717 >  nicer_binning.push_back(-20);
2718 >  
2719 >  nicer_binning.push_back(0);
2720 >  nicer_binning.push_back(20);
2721 >  nicer_binning.push_back(50);
2722 >  nicer_binning.push_back(100);
2723 >  nicer_binning.push_back(150);
2724 >  nicer_binning.push_back(200);
2725 >  nicer_binning.push_back(250);
2726 >  nicer_binning.push_back(400);*/
2727 >  
2728    nicer_binning.push_back(-100);
2451 –  nicer_binning.push_back(-75);
2729    nicer_binning.push_back(-50);
2730    nicer_binning.push_back(-25);
2731    nicer_binning.push_back(0);
# Line 2463 | Line 2740 | void ttbar_sidebands_comparison(string m
2740    nicer_binning.push_back(230);
2741    nicer_binning.push_back(280);
2742    nicer_binning.push_back(400);
2743 +  
2744    ttbar_sidebands_comparison(mcjzb,nicer_binning, "ttbar/");
2745   }
2746  
2747  
2748 < void zjets_prediction_comparison() {
2749 <  // Do it without PU re-weighting
2750 <  float MCPeakNoPU=0,MCPeakErrorNoPU=0,DataPeakNoPU=0,DataPeakErrorNoPU=0,MCSigma=0,DataSigma=0;
2751 <  stringstream resultsNoPU;
2752 <
2753 <  stringstream mcjzbnoPU;
2754 <  find_peaks(MCPeakNoPU,MCPeakErrorNoPU, DataPeakNoPU, DataPeakErrorNoPU,MCSigma,DataSigma,resultsNoPU,false);
2755 <  if(MCPeakNoPU>0) mcjzbnoPU<<"("<<jzbvariablemc<<"-"<<TMath::Abs(MCPeakNoPU)<<")";
2756 <  else mcjzbnoPU<<"("<<jzbvariablemc<<"+"<<TMath::Abs(MCPeakNoPU)<<")";
2748 > void zjets_prediction_comparison(string mcjzbWithPUa) {
2749 >  TCanvas *zcan = new TCanvas("zcan","zcan");  
2750 > //  zcan->SetLogy(1);
2751 >  TCut weightbackup=cutWeight;
2752 >  
2753 >  bool UsePURW=false;
2754 >  
2755 >  
2756 >  string mcjzb;
2757 >  if(UsePURW) {
2758 >    mcjzb=mcjzbWithPUa;
2759 >  } else {
2760 >    // Do it without PU re-weighting
2761 >    float MCPeakNoPU=0,MCPeakErrorNoPU=0,DataPeakNoPU=0,DataPeakErrorNoPU=0,MCSigma=0,DataSigma=0;
2762 >    stringstream resultsNoPU;
2763 >    stringstream noPUdatajzb;
2764 >    stringstream noPUmcjzb;
2765 >    
2766 >    find_peaks(MCPeakNoPU,MCPeakErrorNoPU, DataPeakNoPU, DataPeakErrorNoPU,resultsNoPU,false,noPUdatajzb,noPUmcjzb);
2767 >    dout << "The peak corrected JZB expression for MC without pileup is : " <<  noPUmcjzb.str() << endl;
2768 >    
2769 >    mcjzb = noPUmcjzb.str();
2770 >    
2771 >    cutWeight="1.0";
2772 >  }
2773  
2774 <  string mcjzb = mcjzbnoPU.str();
2775 <  dout << "The peak corrected JZB expression for MC without pileup is : " <<  mcjzb << endl;
2774 >  
2775 >  vector<float> binning;
2776 >  binning.push_back(0);
2777 >  binning.push_back(10);
2778 >  binning.push_back(20);
2779 > //  binning.push_back(30);
2780 >  binning.push_back(40);
2781 > //   binning.push_back(50);
2782 > //   binning.push_back(60);
2783 > //   binning.push_back(70);
2784 > //   binning.push_back(80);
2785 > //   binning.push_back(90);
2786 >  binning.push_back(100);
2787  
2483 –  TCut weightbackup=cutWeight;
2484 –  cutWeight="1.0";
2485 –  float sbg_min=0.;
2486 –  float sbg_max=100.;
2487 –  int sbg_nbins=5;
2788    float simulatedlumi = luminosity;//in pb please - adjust to your likings
2789    
2790    TCut kPos((mcjzb+">0").c_str());
2791    TCut kNeg((mcjzb+"<0").c_str());
2792    string var( "abs("+mcjzb+")" );
2793 +  
2794 +  TCut notTau("abs(genMID1)!=15");
2795 +  TCut ONLYTau("mll>20");
2796 +  
2797  
2798 <  TCut kcut(cutmass&&cutOSSF&&"pfJetGoodNum>2");
2799 <  TH1F *hJZBpos = systsamples.Draw("hJZBpos",var,sbg_nbins,sbg_min,sbg_max, "JZB [GeV]", "events",
2800 <                                  kcut&&kPos,mc,simulatedlumi,systsamples.FindSample("/DY"));
2497 <  TH1F *hJZBneg = systsamples.Draw("hJZBneg",var,sbg_nbins,sbg_min,sbg_max, "JZB [GeV]", "events",
2498 <                                  kcut&&kNeg,mc,simulatedlumi,systsamples.FindSample("/DY"));
2798 >  TH1F *hJZBpos = systsamples.Draw("hJZBpos",var,binning, "JZB [GeV]", "events",cutmass&&cutOSSF&&cutnJets&&notTau&&kPos,mc,simulatedlumi,systsamples.FindSample("/DY"));
2799 >  TH1F *hJZBneg = systsamples.Draw("hJZBneg",var,binning, "JZB [GeV]", "events",cutmass&&cutOSSF&&cutnJets&&notTau&&kNeg,mc,simulatedlumi,systsamples.FindSample("/DY"));
2800 >  
2801    hJZBpos->SetLineColor(kBlack);
2802    hJZBneg->SetLineColor(kRed);
2803    
2804 <  Int_t nbins = 5;
2503 <  Float_t xmax = 100.;
2504 <
2505 <  
2506 <  TCanvas *zcan = new TCanvas("zcan","zcan");  
2507 <  zcan->SetLogy(1);
2508 <
2804 >  hJZBpos->SetMinimum(1.0);
2805    hJZBpos->Draw("e1");
2806    hJZBneg->Draw("same,hist");
2807    hJZBpos->Draw("same,e1"); // So it's on top...
2808    
2809 <  TLegend *leg = make_legend("MC Z+jets",0.55,0.75,false);
2809 >  TLegend *leg = make_legend("MC Z+jets #rightarrow ee,#mu#mu",0.55,0.75,false);
2810    leg->AddEntry(hJZBpos,"Observed","pe");
2811    leg->AddEntry(hJZBneg,"Predicted","l");
2812    leg->Draw("same");
2813    DrawMCPrelim(simulatedlumi);
2814 <  CompleteSave(zcan,"Systematics/zjets_prediction");
2814 >  CompleteSave(zcan,"Systematics/ZJets/zjets_eemm_prediction");
2815    
2816    TH1F* hratio = (TH1F*)hJZBpos->Clone("hratio");
2817    hratio->Divide(hJZBneg);
2818    
2819 +  for(int i=1;i<=hJZBpos->GetNbinsX();i++) {
2820 +    cout << "Positive: " << hJZBpos->GetBinContent(i) << "   vs    Negative : " << hJZBneg->GetBinContent(i) << "   (ratio : " << hJZBpos->GetBinContent(i) / hJZBneg->GetBinContent(i) << endl;
2821 +  }
2822 +  
2823    zcan->SetLogy(0);
2824    hratio->GetYaxis()->SetRangeUser(0,2.5);
2825    hratio->GetYaxis()->SetTitle("Observed/Predicted");
2826    hratio->Draw("e1");
2827    
2828 <  TLine *top = new TLine(sbg_min,1.25,sbg_max,1.25);
2829 <  TLine *center = new TLine(sbg_min,1.0,sbg_max,1.0);
2830 <  TLine *bottom = new TLine(sbg_min,0.75,sbg_max,0.75);
2828 >  TLine *top = new TLine(binning[0],1.25,binning[binning.size()-1],1.25);
2829 >  TLine *center = new TLine(binning[0],1.0,binning[binning.size()-1],1.0);
2830 >  TLine *bottom = new TLine(binning[0],0.75,binning[binning.size()-1],0.75);
2831    
2832  
2833    top->SetLineColor(kBlue);top->SetLineStyle(2);
# Line 2538 | Line 2838 | void zjets_prediction_comparison() {
2838    center->Draw("same");
2839    bottom->Draw("same");
2840    
2841 <  TLegend *leg2 = make_legend("MC Z+jets",0.25,0.75,false);
2841 >  TLegend *leg2 = make_legend("MC Z+jets #rightarrow ee,#mu#mu",0.25,0.75,false);
2842    leg2->AddEntry(hratio,"obs / pred","pe");
2843    leg2->AddEntry(bottom,"syst. envelope","l");
2844    leg2->Draw("same");
2845    DrawMCPrelim(simulatedlumi);
2846 <  CompleteSave(zcan,"Systematics/zjets_prediction_ratio");
2846 >  CompleteSave(zcan,"Systematics/ZJets/zjets_eemm_prediction_ratio");
2847 >  
2848 >  TCut reducedNJets(cutnJets);
2849 >  
2850 >  TH1F *TAUhJZBpos = systsamples.Draw("TAUhJZBpos",var,binning, "JZB [GeV]", "events",cutmass&&cutOSSF&&reducedNJets&&ONLYTau&&kPos,mc,simulatedlumi,systsamples.FindSample("/DY"));
2851 >  TH1F *LcorrJZBeemm     = systsamples.Draw("LcorrJZBeemm",var,binning, "JZB [GeV]", "events",cutmass&&cutOSSF&&reducedNJets&&ONLYTau&&kNeg,mc,simulatedlumi,systsamples.FindSample("/DY"));
2852 >  TH1F *RcorrJZBem       = systsamples.Draw("RcorrJZBem",var,binning, "JZB [GeV]", "events",cutmass&&cutOSOF&&reducedNJets&&ONLYTau&&kPos,mc,simulatedlumi,systsamples.FindSample("/DY"));
2853 >  TH1F *LcorrJZBem       = systsamples.Draw("LcorrJZBem",var,binning, "JZB [GeV]", "events",cutmass&&cutOSOF&&reducedNJets&&ONLYTau&&kNeg,mc,simulatedlumi,systsamples.FindSample("/DY"));
2854 >
2855 >  TH1F *RcorrJZBSBem;
2856 >  TH1F *LcorrJZBSBem;
2857 >  TH1F *RcorrJZBSBeemm;
2858 >  TH1F *LcorrJZBSBeemm;
2859 >
2860 >  if(PlottingSetup::RestrictToMassPeak) {
2861 >    RcorrJZBSBem   = systsamples.Draw("RcorrJZBSBem",var,binning, "JZB [GeV]", "events",sidebandcut&&cutOSOF&&reducedNJets&&ONLYTau&&kPos,mc,simulatedlumi,systsamples.FindSample("/DY"));
2862 >    LcorrJZBSBem   = systsamples.Draw("LcorrJZBSBem",var,binning, "JZB [GeV]", "events",sidebandcut&&cutOSOF&&reducedNJets&&ONLYTau&&kNeg,mc,simulatedlumi,systsamples.FindSample("/DY"));
2863 >    RcorrJZBSBeemm = systsamples.Draw("RcorrJZBSBeemm",var,binning, "JZB [GeV]", "events",sidebandcut&&cutOSSF&&reducedNJets&&ONLYTau&&kPos,mc,simulatedlumi,systsamples.FindSample("/DY"));
2864 >    LcorrJZBSBeemm = systsamples.Draw("LcorrJZBSBeemm",var,binning, "JZB [GeV]", "events",sidebandcut&&cutOSSF&&reducedNJets&&ONLYTau&&kNeg,mc,simulatedlumi,systsamples.FindSample("/DY"));
2865 >  }
2866 >  
2867 >  TH1F *Bpred = (TH1F*)LcorrJZBeemm->Clone("Bpred");
2868 >  if(PlottingSetup::RestrictToMassPeak) {
2869 >    Bpred->Add(RcorrJZBem,1.0/3.);
2870 >    Bpred->Add(LcorrJZBem,-1.0/3.);
2871 >    Bpred->Add(RcorrJZBSBem,1.0/3.);
2872 >    Bpred->Add(LcorrJZBSBem,-1.0/3.);
2873 >    Bpred->Add(RcorrJZBSBeemm,1.0/3.);
2874 >    Bpred->Add(LcorrJZBSBeemm,-1.0/3.);
2875 >  } else {
2876 >    Bpred->Add(RcorrJZBem,1.0);
2877 >    Bpred->Add(LcorrJZBem,-1.0);
2878 >  }
2879 >  
2880 >  Bpred->SetLineColor(kRed);
2881 >
2882 >  TAUhJZBpos->SetLineColor(kBlack);
2883 >  Bpred->SetLineColor(kRed);
2884 >  
2885 >  TAUhJZBpos->SetMinimum(1.0);
2886 >  TAUhJZBpos->Draw("e1");
2887 >  Bpred->Draw("same,hist");
2888 >  TAUhJZBpos->Draw("same,e1");
2889 >  
2890 >  TLegend *TAUleg = make_legend("MC Z+jets #rightarrow ee,#mu#mu,#tau#tau",0.55,0.75,false);
2891 >  TAUleg->AddEntry(TAUhJZBpos,"Observed","pe");
2892 >  TAUleg->AddEntry(Bpred,"Predicted","l");
2893 >  TAUleg->Draw("same");
2894 >  DrawMCPrelim(simulatedlumi);
2895 >  CompleteSave(zcan,"Systematics/ZJets/zjets_eemumutautau_prediction");
2896 >  
2897 >  TH1F* TAUhratio = (TH1F*)TAUhJZBpos->Clone("TAUhratio");
2898 >  TAUhratio->Divide(Bpred);
2899 >  
2900 >  for(int i=1;i<=TAUhJZBpos->GetNbinsX();i++) {
2901 >    cout << "ee/mm/tautau observed: " << TAUhJZBpos->GetBinContent(i) << "   vs    predicted : " << Bpred->GetBinContent(i) << "   (ratio : " << TAUhJZBpos->GetBinContent(i) / Bpred->GetBinContent(i) << endl;
2902 >  }
2903 >  
2904 >  zcan->SetLogy(0);
2905 >  TAUhratio->GetYaxis()->SetRangeUser(0,2.5);
2906 >  TAUhratio->GetYaxis()->SetTitle("Observed/Predicted");
2907 >  TAUhratio->Draw("e1");
2908 >  
2909 >  top->Draw("same");
2910 >  center->Draw("same");
2911 >  bottom->Draw("same");
2912 >  
2913 >  TLegend *TAUleg2 = make_legend("MC Z+jets #rightarrow #tau#tau",0.25,0.75,false);
2914 >  TAUleg2->AddEntry(TAUhratio,"obs / pred","pe");
2915 >  TAUleg2->AddEntry(bottom,"syst. envelope","l");
2916 >  TAUleg2->Draw("same");
2917 >  DrawMCPrelim(simulatedlumi);
2918 >  CompleteSave(zcan,"Systematics/ZJets/zjets_eemumutautau_prediction_ratio");
2919 >  
2920 >  delete Bpred;
2921 >  delete TAUhJZBpos;
2922 >  delete LcorrJZBeemm;
2923 >  delete RcorrJZBem;
2924 >  delete LcorrJZBem;
2925 >  
2926 >  if(PlottingSetup::RestrictToMassPeak) {
2927 >    delete RcorrJZBSBem;
2928 >    delete LcorrJZBSBem;
2929 >    delete RcorrJZBSBeemm;
2930 >    delete LcorrJZBSBeemm;
2931 >  }
2932 >  
2933    
2934    delete zcan;
2935    cutWeight=weightbackup;
# Line 2569 | Line 2955 | void sideband_assessment(string datajzb,
2955    tout << "\\begin{tabular}{l|cc}" << endl;
2956    tout << "\\hline" << endl;
2957    tout << "& {\\OFZP} & {\\OFSB} \\\\\\hline" << endl;
2958 <  tout << "\\#(events) & "<<OFSB<<" & "<<OFZP<<"\\\\ \\hline" << endl;
2958 >  tout << "\\#(events) & "<<OFZP<<" & "<<OFSB<<"\\\\ \\hline" << endl;
2959    tout << "\\end{tabular}" << endl;
2960    tout << "\\end{center}" << endl;
2961    tout << "\\end{table}" << endl;
# Line 2587 | Line 2973 | void make_table(samplecollection &coll,
2973    
2974    TCanvas *cannie = new TCanvas("cannie","cannie");
2975    
2976 <  for(int icut=0;icut<jzb_cuts.size();icut++) {
2976 >  for(int icut=0;icut<(int)jzb_cuts.size();icut++) {
2977      float currcut=jzb_cuts[icut];
2978      int nbins=1;float low=currcut;
2979      vector<int> mysample;
# Line 2646 | Line 3032 | void make_table(samplecollection &coll,
3032    //prediction part
3033    if(is_data) cout << "Data prediction & ";
3034    if(subselection!="none") cout << subselection << " prediction &";
3035 <  for(int ij=0;ij<jzb_cuts.size();ij++) cout << jzbcutprediction[ij] << " vs " << metcutprediction[ij] << " & ";
3035 >  for(int ij=0;ij<(int)jzb_cuts.size();ij++) cout << jzbcutprediction[ij] << " vs " << metcutprediction[ij] << " & ";
3036    
3037    cout << endl;
3038    //observation part
3039    if(is_data) cout << "Data observation & ";
3040    if(subselection!="none") cout << subselection << " observation &";
3041 <  for(int ij=0;ij<jzb_cuts.size();ij++) cout << jzbcutobservation[ij] << " vs " << metcutobservation[ij] << " & ";
3041 >  for(int ij=0;ij<(int)jzb_cuts.size();ij++) cout << jzbcutobservation[ij] << " vs " << metcutobservation[ij] << " & ";
3042    cout << endl;
3043    cout << "_________________________________________________________________" << endl;
3044    delete cannie;
# Line 2687 | Line 3073 | void JZBSelEff(string mcjzb, TTree* even
3073    int nbins = sizeof(xbins)/sizeof(float)-1;
3074    int markers[] = { 20, 26, 21, 24, 22, 25, 28 };
3075  
3076 <  TH1F* heff  = new TH1F("heff", "JZB eff ; generator-level JZB [GeV]; efficiency",nbins,xbins);
3077 <  TH1F* hgen  = new TH1F("hgen", "JZB gen ; generator-level JZB [GeV]; efficiency",nbins,xbins);
3078 <  TH1F* hreco = new TH1F("hreco","JZB reco ; generator-level JZB [GeV]; efficiency",nbins,xbins);
3076 >  
3077 >  TH1F* heff  = new TH1F("heff", "JZB eff ; generator JZB [GeV]; efficiency",nbins,xbins);
3078 >  TH1F* hgen  = new TH1F("hgen", "JZB gen ; generator JZB [GeV]; efficiency",nbins,xbins);
3079 >  TH1F* hreco = new TH1F("hreco","JZB reco ; generator JZB [GeV]; efficiency",nbins,xbins);
3080  
3081    TCut kgen(genMassCut&&"genZPt>0&&genNjets>2&&abs(genMID)==23"&&cutOSSF);
3082    TCut kreco(cutmass);
# Line 2705 | Line 3092 | void JZBSelEff(string mcjzb, TTree* even
3092    TCanvas *can = new TCanvas("can","Canvas for JZB Efficiency",600,600);
3093    can->SetGridx(1);
3094    can->SetGridy(1);
3095 +  can->SetLeftMargin(0.16);
3096 +  can->SetRightMargin(0.05);
3097    TLegend *leg = make_legend("",0.6,0.2,false,0.89,0.5);
3098 +  leg->SetBorderSize(1);
3099 +  leg->SetLineColor(kBlack);
3100 +  leg->SetTextFont(62);
3101  
3102 <  
2711 <
2712 <  for ( int icut=0; icut<jzb_bins.size(); ++icut ) {
3102 >  for ( int icut=0; icut<(int)jzb_bins.size(); ++icut ) {
3103  
3104      ostringstream selection;
3105      selection << mcjzb << ">" << jzb_bins[icut];
# Line 2725 | Line 3115 | void JZBSelEff(string mcjzb, TTree* even
3115      }
3116    
3117      heff->GetXaxis()->SetRangeUser(min, max);
3118 + //    heff->GetXaxis()->SetLabelSize(0.05); // paper style. overruled.
3119 + //    heff->GetYaxis()->SetLabelSize(0.05); // paper style. overruled.
3120 + //    heff->GetXaxis()->SetTitleSize(0.06); // paper style. overruled.
3121 + //    heff->GetYaxis()->SetTitleSize(0.06); // paper style. overruled.
3122      heff->SetMarkerStyle(markers[icut]);
3123      heff->Fit("func","Q+","same");
3124  
# Line 2736 | Line 3130 | void JZBSelEff(string mcjzb, TTree* even
3130  
3131      // Store plot
3132      TH1F* h = (TH1F*)heff->Clone(hname);
3133 +    h->SetNdivisions(505,"X");
3134      if ( icut) h->Draw("same");
3135      else h->Draw();
3136      char htitle[256]; sprintf(htitle,"JZB > %3.0f GeV", jzb_bins[icut]);
# Line 2756 | Line 3151 | void JZBSelEff(string mcjzb, TTree* even
3151   // Calls the above function for each signal sample
3152   void plot_jzb_sel_eff(string mcjzb, samplecollection &signalsamples, vector<float> bins )
3153   {  
3154 <  for (int isignal=0; isignal<signalsamples.collection.size();isignal++) {
3154 >  for (int isignal=0; isignal<(int)signalsamples.collection.size();isignal++) {
3155      dout << "JZB selection efficiency curve: " << std::endl;
3156      JZBSelEff(mcjzb,(signalsamples.collection)[isignal].events,(signalsamples.collection)[isignal].samplename,bins); // Only for some selected samples
3157    }
# Line 2799 | Line 3194 | void qcd_plots(string datajzb, string mc
3194    TH1F *RcorrJZBSBeemm;
3195    TH1F *LcorrJZBSBeemm;
3196    
3197 <  TH1F *RcorrJZBeemmNoS;
3197 > //  TH1F *RcorrJZBeemmNoS;
3198  
3199      //these are for the ratio
3200    TH1F *JRcorrJZBeemm   = qcdsamples.Draw("JRcorrJZBeemm",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
# Line 2883 | Line 3278 | void qcd_plots(string datajzb, string mc
3278    //3rd last argument: do special bpred ratio, 2nd last argument: extended range!, last: y-axis title
3279    string ytitle("ratio");
3280    if ( use_data==1 ) ytitle = "data/pred";
3281 <  save_with_ratio(JRcorrJZBeemm,JBpred,kinpad,"QCD/Bpred",true,use_data!=1,ytitle);
3281 >  save_with_ratio(JRcorrJZBeemm,JBpred,kinpad,"QCD/Bpred",true,false,ytitle);
3282    
3283    TH1F *allevents = qcdsamples.Draw("allevents","pfJetGoodNum",1,0,100, "internal code", "events", "" ,mc, luminosity);
3284    TH1F *ossf = qcdsamples.Draw("ossf","pfJetGoodNum",1,0,100, "internal code", "events", cutOSSF ,mc, luminosity);
# Line 2930 | Line 3325 | void qcd_plots(string datajzb, string mc
3325    dout << "    Observation increases by : " << RcorrJZBeemm->Integral() << endl;
3326    
3327    dout << endl;
3328 <  for(int i=0;i<bins.size();i++) {
3328 >  for(int i=0;i<(int)bins.size();i++) {
3329      dout << " JZB > " << bins[i] << " : " << endl;
3330      dout << "    Observation increases by : " << RcorrJZBeemm->Integral(RcorrJZBeemm->FindBin(bins[i]),RcorrJZBeemm->GetNbinsX()) << endl;
3331      if(PlottingSetup::RestrictToMassPeak) {
# Line 2978 | Line 3373 | void check_ptsanity() {
3373    leg->SetY2(1.0);
3374    
3375    
3376 <  for(int isample=0;isample<allsamples.collection.size();isample++) {
3376 >  for(int isample=0;isample<(int)allsamples.collection.size();isample++) {
3377      string nowname=(allsamples.collection)[isample].filename;
3378      cout << "Drawing: " << nowname << " (sample " << isample+1 << " / " << allsamples.collection.size() << ")" << endl;
3379      individualpt1histos[isample] = allsamples.Draw(GetNumericHistoName(),"pt1",50,0,50, "p_{T,1}", "events",cutOSSF&&cutnJets,mc,luminosity,allsamples.FindSample(nowname));
# Line 3002 | Line 3397 | void check_ptsanity() {
3397    ptsancan->cd(2);
3398    fpt2->Draw();
3399  
3400 <  for(int isample=0;isample<allsamples.collection.size();isample++) {
3400 >  for(int isample=0;isample<(int)allsamples.collection.size();isample++) {
3401      ptsancan->cd(1);
3402      individualpt1histos[isample]->DrawNormalized("same,histo");
3403      ptsancan->cd(2);
# Line 3018 | Line 3413 | void check_ptsanity() {
3413   void do_mlls_plot(string mcjzb) {
3414    cout << "At this point we'd plot the mll distribution" << endl;
3415    TCanvas *sigcan = new TCanvas("sigcan","sigcan");
3416 <  for(int isig=0;isig<(signalsamples.collection).size();isig++) {
3416 >  for(int isig=0;isig<(int)(signalsamples.collection).size();isig++) {
3417      if(!(signalsamples.collection)[isig].events) continue;
3418      string nowname=(signalsamples.collection)[isig].filename;
3419      TH1F *mll = signalsamples.Draw("mllhisto","mll",150,0,150, "m_{ll}", "events",cutOSSF&&cutnJets,mc,luminosity,signalsamples.FindSample(nowname));
# Line 3057 | Line 3452 | void met_vs_jzb_plots() {
3452    findme.push_back("TTJets");
3453    findme.push_back("LM");
3454    
3455 <  for(int ifind=0;ifind<findme.size();ifind++) {
3455 >  for(int ifind=0;ifind<(int)findme.size();ifind++) {
3456      vector<int> selsamples = allsamples.FindSample(findme[ifind]);
3457      TH2F *metvsjzb = new TH2F("metvsjzb","metvsjzb",200,0,100,400,-100,100);
3458 <    for(int isel=0;isel<selsamples.size();isel++) {
3458 >    for(int isel=0;isel<(int)selsamples.size();isel++) {
3459        cout << "Producing MET:JZB plot ... working on sample: " << allsamples.collection[selsamples[isel]].filename << endl;
3460        allsamples.collection[selsamples[isel]].events->Draw("jzb[1]:met[4]>>+metvsjzb",cutmass&&cutOSSF);
3461      }
# Line 3083 | Line 3478 | void test() {
3478    
3479    TCanvas *testcanv = new TCanvas("testcanv","testcanv");
3480    testcanv->cd();
3481 <  switch_overunderflow(true);
3481 > //  switch_overunderflow(true);
3482    TH1F *ptdistr   = allsamples.Draw("ptdistr","pt1",100,30,200, "p_{T} [GeV]", "events", cutOSSF,data,luminosity);
3483    switch_overunderflow(false);
3484    ptdistr->Draw();

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines