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.27 by buchmann, Mon Jun 18 13:15:39 2012 UTC vs.
Revision 1.63 by fronga, Fri Sep 7 15:10:26 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, bool SwitchOffNJetsCut, float &MCPeak,float &MCPeakError, float &DataPeak, float &DataPeakError, float &MCSigma, float &MCSigmaError, float &DataSigma, float& DataSigmaError, stringstream &result, bool doPUreweighting = true, string saveas="")
37   {
38    // Temporarily switch off PU reweighting, if asked
39    TCut weightbackup=cutWeight;
# Line 39 | Line 42 | void find_peaks(float &MCPeak,float &MCP
42    int nbins=100;
43    if(PlottingSetup::DoBTag) nbins=25;
44    
45 +  TCut nJetsCut(cutnJets);
46 +  if(SwitchOffNJetsCut) nJetsCut=specialcut;
47 +  
48    TCanvas *tempcan = new TCanvas("tempcan","Temporary canvas for peak finding preparations");
49 <  TH1F *rawJZBeemmMC      = allsamples.Draw("rawJZBeemmMC",jzbvariablemc,nbins,-50,50, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,mc, luminosity);
50 <  TH1F *rawJZBeemmData    = allsamples.Draw("rawJZBeemmData",jzbvariabledata,nbins, -50,50, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,data, luminosity);
51 <  TH1F *rawJZBemMC      = allsamples.Draw("rawJZBemMC",jzbvariablemc,nbins,-50,50, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,mc, luminosity);
52 <  TH1F *rawJZBemData    = allsamples.Draw("rawJZBemData",jzbvariabledata,nbins, -50,50, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,data, luminosity);
49 >  TH1F *rawJZBeemmMC      = allsamples.Draw("rawJZBeemmMC",jzbvariablemc,nbins,-50,50, "JZB [GeV]", "events", cutmass&&cutOSSF&&nJetsCut&&specialcut,mc, luminosity);
50 >  TH1F *rawJZBeemmData    = allsamples.Draw("rawJZBeemmData",jzbvariabledata,nbins, -50,50, "JZB [GeV]", "events", cutmass&&cutOSSF&&nJetsCut&&specialcut,data, luminosity);
51 >  TH1F *rawJZBemMC      = allsamples.Draw("rawJZBemMC",jzbvariablemc,nbins,-50,50, "JZB [GeV]", "events", cutmass&&cutOSOF&&nJetsCut&&specialcut,mc, luminosity);
52 >  TH1F *rawJZBemData    = allsamples.Draw("rawJZBemData",jzbvariabledata,nbins, -50,50, "JZB [GeV]", "events", cutmass&&cutOSOF&&nJetsCut&&specialcut,data, luminosity);
53    TH1F *rawttbarjzbeemmMC;
54  
55    if(method==doKM) {
56      //we only need this histo for the KM fitting...
57 <    rawttbarjzbeemmMC = allsamples.Draw("rawttbarjzbeemmMC",jzbvariablemc,nbins, -50,50, "JZB [GeV]", "events",cutmass&&cutOSSF&&cutnJets,mc,luminosity,allsamples.FindSample("TTJet"));
58 <    MCPeak=find_peak(rawJZBeemmMC, rawttbarjzbeemmMC, -40, 40, mc, MCPeakError,MCSigma,method);
59 <    DataPeak=find_peak(rawJZBeemmData, rawJZBeemmData, -40, 40, data, DataPeakError,DataSigma,method);
57 >    rawttbarjzbeemmMC = allsamples.Draw("rawttbarjzbeemmMC",jzbvariablemc,nbins, -50,50, "JZB [GeV]", "events",cutmass&&cutOSSF&&nJetsCut&&specialcut,mc,luminosity,allsamples.FindSample("TTJet"));
58 >    MCPeak=find_peak(rawJZBeemmMC, rawttbarjzbeemmMC, -40, 40, mc, MCPeakError,MCSigma,MCSigmaError,method,saveas);
59 >    DataPeak=find_peak(rawJZBeemmData, rawJZBeemmData, -40, 40, data, DataPeakError,DataSigma,DataSigmaError,method,saveas);
60 >    delete rawttbarjzbeemmMC;
61    }
62    else {
63      TH1F *reducedMC = (TH1F*)rawJZBeemmMC->Clone();
# Line 58 | Line 65 | void find_peaks(float &MCPeak,float &MCP
65      reducedMC->Add(rawJZBemMC,-1);
66      reducedData->Add(rawJZBemData,-1);
67      //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)
68 <    MCPeak=find_peak(reducedMC, rawttbarjzbeemmMC, -40, 40, mc, MCPeakError,MCSigma,method);
69 <    DataPeak=find_peak(reducedData, rawJZBeemmData, -40, 40, data, DataPeakError,DataSigma,method);
70 <    
68 >    MCPeak=find_peak(reducedMC, rawttbarjzbeemmMC, -40, 40, mc, MCPeakError,MCSigma,MCSigmaError,method,saveas);
69 >    DataPeak=find_peak(reducedData, rawJZBeemmData, -40, 40, data, DataPeakError,DataSigma,DataSigmaError,method,saveas);
70 >    delete reducedMC;
71 >    delete reducedData;
72    }
73  
74    // Revert to original PU reweighting
# Line 68 | Line 76 | void find_peaks(float &MCPeak,float &MCP
76      
77   //  MCPeak=find_peak(rawJZBeemmMC, rawttbarjzbeemmMC, -40, 40, mc, MCPeakError,MCSigma,method);
78   //  DataPeak=find_peak(rawJZBeemmData, rawJZBeemmData, -40, 40, data, DataPeakError,DataSigma,method);
79 <  dout << "We have found the peak in Data at " << DataPeak << " +/- " << DataPeakError << " with sigma=" << DataSigma << " +/- ?? (not impl.)" << endl;
80 <  result << "We have found the peak in Data at " << DataPeak << " +/- " << DataPeakError << " with sigma=" << DataSigma << " +/- ?? (not impl.)" << endl;
81 <  dout << "We have found the peak in MC at " << MCPeak << " +/- " << MCPeakError << " with sigma=" << MCSigma << " +/- ?? (not impl.)" << endl;
82 <  result << "We have found the peak in MC at " << MCPeak << " +/- " << MCPeakError << " with sigma=" << MCSigma << " +/- ?? (not impl.)" << endl;
79 >  dout   << "   We have found the peak in Data at " << DataPeak << " +/- " << DataPeakError << " with sigma=" << DataSigma << " +/- " << DataSigmaError << endl;
80 >  result << "   We have found the peak in Data at " << DataPeak << " +/- " << DataPeakError << " with sigma=" << DataSigma << " +/- " << DataSigmaError << endl;
81 >  dout   << "   We have found the peak in MC at " << MCPeak << " +/- " << MCPeakError << " with sigma=" << MCSigma << " +/- " << MCSigmaError << endl;
82 >  result << "   We have found the peak in MC at " << MCPeak << " +/- " << MCPeakError << " with sigma=" << MCSigma << " +/- " << MCSigmaError << endl;
83 >  delete rawJZBeemmData;
84 >  delete rawJZBeemmMC;
85 >  delete rawJZBemData;
86 >  delete rawJZBemMC;
87    delete tempcan;
88   }
89  
90 < void make_special_obs_pred_mll_plot(string mcjzb, float jzbthreshold) {
90 > void find_peaks(float &MCPeak,float &MCPeakError, float &DataPeak, float &DataPeakError, stringstream &result, bool doPUreweighting, stringstream &datajzb, stringstream &mcjzb, string sSpecialCut="", bool SwitchOffNJetsCut=false)
91 > {
92 >  switch_overunderflow(false);
93 >  
94 >  TCut SpecialCut("mll>=0");
95 >  if(sSpecialCut!="") SpecialCut=TCut(sSpecialCut.c_str());
96 >  
97 >  bool DoInvidualeemmPeaks=false;
98 >  
99 >  float mcpeak, datapeak;
100 >  float mcpeakerr, datapeakerr;
101 >  
102 >  float mceepeak,mcmmpeak;
103 >  float mceepeakerr,mcmmpeakerr;
104 >  
105 >  float datammpeak,dataeepeak;
106 >  float datammpeakerr,dataeepeakerr;
107 >  
108 >  float mcSigma,mcSigmaError, dataSigma, dataSigmaError;
109 >  
110 >  dout << "Finding global peak : " << endl;
111 >  find_one_peak_combination(SpecialCut,SwitchOffNJetsCut,mcpeak,mcpeakerr, datapeak,datapeakerr,mcSigma,mcSigmaError, dataSigma,dataSigmaError,result,doPUreweighting,"");
112 >  
113 >  if(DoInvidualeemmPeaks) {
114 >    dout << "Finding peak for electrons : " << endl;
115 >    find_one_peak_combination(SpecialCut&&TCut("id1==0"),SwitchOffNJetsCut,mceepeak,mceepeakerr,dataeepeak,dataeepeakerr,mcSigma,mcSigmaError,dataSigma,dataSigmaError,result,doPUreweighting,"_ele");
116 >    dout << "Finding peak for muons : " << endl;
117 >    find_one_peak_combination(SpecialCut&&TCut("id1==1"),SwitchOffNJetsCut,mcmmpeak,mcmmpeakerr,datammpeak,datammpeakerr,mcSigma,mcSigmaError,dataSigma,dataSigmaError,result,doPUreweighting,"_mu");
118 >    
119 >    datajzb << "(" << jzbvariabledata;
120 >    mcjzb << "(" << jzbvariablemc;
121 >    
122 >    if(dataeepeak>0) datajzb << "- (id1==id2)*(id1==0)*" << TMath::Abs(dataeepeak) << " ";
123 >    else datajzb << "+ (id1==id2)*(id1==0)*" << TMath::Abs(dataeepeak) << " ";
124 >    
125 >    if(datammpeak>0) datajzb << "- (id1==id2)*(id1==1)*" << TMath::Abs(datammpeak) << " ";
126 >    else datajzb << "+ (id1==id2)*(id1==1)*" << TMath::Abs(datammpeak) << " ";
127 >    
128 >    if(datapeak>0) datajzb << "- (id1!=id2)*" << TMath::Abs(datapeak) << " ";
129 >    else datajzb << "+ (id1!=id2)*" << TMath::Abs(datapeak) << " ";
130 >    
131 >    datajzb << ")";
132 >    
133 >    if(mceepeak>0) mcjzb << "- (id1==id2)*(id1==0)*" << TMath::Abs(mceepeak) << " ";
134 >    else mcjzb << "+ (id1==id2)*(id1==0)*" << TMath::Abs(mceepeak) << " ";
135 >    
136 >    if(mcmmpeak>0) mcjzb << "- (id1==id2)*(id1==1)*" << TMath::Abs(mcmmpeak) << " ";
137 >    else mcjzb << "+ (id1==id2)*(id1==1)*" << TMath::Abs(mcmmpeak) << " ";
138 >    
139 >    if(mcpeak>0) mcjzb << "- (id1!=id2)*" << TMath::Abs(mcpeak) << " ";
140 >    else mcjzb << "+ (id1!=id2)*" << TMath::Abs(mcpeak) << " ";
141 >    
142 >    mcjzb << ")";
143 >    
144 >  } else {
145 >    datajzb << "(" << jzbvariabledata;
146 >      mcjzb << "(" << jzbvariablemc;
147 >    
148 >    if(datapeak>0) datajzb << "- " << TMath::Abs(datapeak) << " ";
149 >    else datajzb << "+ " << TMath::Abs(datapeak) << " ";
150 >    
151 >    datajzb << ")";
152 >    
153 >    if(mcpeak>0) mcjzb << "- " << TMath::Abs(mcpeak) << " ";
154 >    else mcjzb << "+ " << TMath::Abs(mcpeak) << " ";
155 >    
156 >    mcjzb << ")";
157 >  }
158 >  
159 >    MCPeak=mcpeak;
160 >    MCPeakError=mcpeakerr;
161 >    DataPeak=datapeak;
162 >    DataPeakError=datapeakerr;
163 >    
164 >    switch_overunderflow(true);
165 >  
166 > }
167 >
168 > void make_special_obs_pred_mll_plot(string datajzb, string mcjzb, float jzbthreshold, float binWidth = 5.0) {
169    float min=70.0;
170    float max=115.0;
171    if(!PlottingSetup::RestrictToMassPeak) {
172 <    min=10;
173 <    max=150;
172 >    min=20;
173 >    max=300;
174    }
175 <  int nbins=int((max-min)/5);
175 >  int nbins=int((max-min)/binWidth);
176    
177    TCanvas *ckin = new TCanvas("ckin","Kinematic Plots (in the making)",600,600);
178    
179    stringstream largerzeroS;
180 <  largerzeroS << "(" << mcjzb << ">" << jzbthreshold << ")";
181 <  TCut largerzero(largerzeroS.str().c_str());
180 >  largerzeroS << "(" << datajzb << ">" << jzbthreshold << ")";
181 >  TCut largerzeroD(largerzeroS.str().c_str());
182    
183    stringstream smallerzeroS;
184 <  smallerzeroS << "(" << mcjzb << "<-" << jzbthreshold << ")";
185 <  TCut smallerzero(smallerzeroS.str().c_str());
186 <  
187 <  TH1F *RcorrJZBeemm     = allsamples.Draw("RcorrJZBeemm",       "mll",nbins,min,max, "m_{ll} [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&largerzero,data,luminosity);
188 <  THStack mcRcorrJZBeemm = allsamples.DrawStack("mcRcorrJZBeemm","mll",nbins,min,max, "m_{ll} [GeV}", "events", cutmass&&cutOSSF&&cutnJets&&largerzero,mc,luminosity);
189 <  TH1F *LcorrJZBeemm     = allsamples.Draw("LcorrJZBeemm",       "mll",nbins,min,max, "m_{ll} [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&smallerzero,data,luminosity);
190 <  TH1F *RcorrJZBem       = allsamples.Draw("RcorrJZBem",         "mll",nbins,min,max, "m_{ll} [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&largerzero,data,luminosity);
191 <  TH1F *LcorrJZBem       = allsamples.Draw("LcorrJZBem",         "mll",nbins,min,max, "m_{ll} [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&smallerzero,data,luminosity);
184 >  smallerzeroS << "(" << datajzb << "<-" << jzbthreshold << ")";
185 >  TCut smallerzeroD(smallerzeroS.str().c_str());
186 >
187 >
188 >  stringstream largerzeroMS;
189 >  largerzeroMS << "(" << mcjzb << ">" << jzbthreshold << ")";
190 >  TCut largerzeroM(largerzeroMS.str().c_str());
191 >  
192 >  TH1F *RcorrJZBeemm     = allsamples.Draw("RcorrJZBeemm",       "mll",nbins,min,max, "m_{ll} [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&largerzeroD,data,luminosity);
193 >  THStack mcRcorrJZBeemm = allsamples.DrawStack("mcRcorrJZBeemm","mll",nbins,min,max, "m_{ll} [GeV}", "events", cutmass&&cutOSSF&&cutnJets&&largerzeroM,mc,luminosity);
194 >  TH1F *LcorrJZBeemm     = allsamples.Draw("LcorrJZBeemm",       "mll",nbins,min,max, "m_{ll} [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&smallerzeroD,data,luminosity);
195 >  TH1F *RcorrJZBem       = allsamples.Draw("RcorrJZBem",         "mll",nbins,min,max, "m_{ll} [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&largerzeroD,data,luminosity);
196 >  TH1F *LcorrJZBem       = allsamples.Draw("LcorrJZBem",         "mll",nbins,min,max, "m_{ll} [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&smallerzeroD,data,luminosity);
197  
198    TH1F *RcorrJZBSBem;
199    TH1F *LcorrJZBSBem;
# Line 107 | Line 202 | void make_special_obs_pred_mll_plot(stri
202    
203   //  TH1F *RcorrJZBeemmNoS;
204  
205 <  if(PlottingSetup::RestrictToMassPeak) {
206 <    RcorrJZBSBem   = allsamples.Draw("RcorrJZBSBem",  "mll",nbins,min,max, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets&&largerzero,data, luminosity);
207 <    LcorrJZBSBem   = allsamples.Draw("LcorrJZBSBem",  "mll",nbins,min,max, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets&&smallerzero,data, luminosity);
208 <    RcorrJZBSBeemm = allsamples.Draw("RcorrJZBSBeemm","mll",nbins,min,max, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets&&largerzero,data, luminosity);
209 <    LcorrJZBSBeemm = allsamples.Draw("LcorrJZBSBeemm","mll",nbins,min,max, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets&&smallerzero,data, luminosity);
210 <  }
211 <  
212 <  TH1F *Bpred = (TH1F*)LcorrJZBeemm->Clone("Bpred");
213 <  if(PlottingSetup::RestrictToMassPeak) {
214 <    Bpred->Add(RcorrJZBem,1.0/3.);
215 <    Bpred->Add(LcorrJZBem,-1.0/3.);
216 <    Bpred->Add(RcorrJZBSBem,1.0/3.);
217 <    Bpred->Add(LcorrJZBSBem,-1.0/3.);
218 <    Bpred->Add(RcorrJZBSBeemm,1.0/3.);
219 <    Bpred->Add(LcorrJZBSBeemm,-1.0/3.);
220 <  } else {
221 <    Bpred->Add(RcorrJZBem,1.0);
222 <    Bpred->Add(LcorrJZBem,-1.0);
223 <  }
224 <  
205 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
206 >    RcorrJZBSBem   = allsamples.Draw("RcorrJZBSBem",  "mll",nbins,min,max, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets&&largerzeroD,data, luminosity);
207 >    LcorrJZBSBem   = allsamples.Draw("LcorrJZBSBem",  "mll",nbins,min,max, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets&&smallerzeroD,data, luminosity);
208 >    RcorrJZBSBeemm = allsamples.Draw("RcorrJZBSBeemm","mll",nbins,min,max, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets&&largerzeroD,data, luminosity);
209 >    LcorrJZBSBeemm = allsamples.Draw("LcorrJZBSBeemm","mll",nbins,min,max, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets&&smallerzeroD,data, luminosity);
210 >  }
211 >  
212 >  // Separate predictions
213 >  TH1F* SFN = (TH1F*)LcorrJZBeemm->Clone("SFN");
214 >  TH1F* OFP = (TH1F*)RcorrJZBem->Clone("OFP");
215 >  TH1F* OFN = (TH1F*)LcorrJZBem->Clone("OFN");
216 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
217 >    OFP->Scale(1.0/3.0);
218 >    OFP->Add(RcorrJZBSBem,1.0/3.);
219 >    OFP->Add(RcorrJZBSBeemm,1.0/3.);
220 >    OFN->Scale(1.0/3.0);
221 >    OFN->Add(LcorrJZBSBem,1.0/3.);
222 >    OFN->Add(LcorrJZBSBeemm,1.0/3.);
223 >  }
224 >
225 >  TH1F* Bpred = (TH1F*)SFN->Clone("Bpred");
226 >  Bpred->Add(OFP);
227 >  Bpred->Add(OFN,-1);
228    Bpred->SetLineColor(kRed);
229    
230 +  RcorrJZBeemm->SetTitleOffset(1.3,"y");
231    RcorrJZBeemm->Draw();
232    mcRcorrJZBeemm.Draw("same");
233    Bpred->Draw("histo,same");
# Line 143 | Line 242 | void make_special_obs_pred_mll_plot(stri
242    stringstream saveas;
243    saveas << "kin/Mll_After_Cut/Cut_At" << jzbthreshold;
244    CompleteSave(ckin,saveas.str());
245 <
245 >  
246 >  // Draw all predictions overlayed
247 >  unsigned int w = gStyle->GetHistLineWidth()+1; // Make line a bit wider, since we dash it
248 >  SFN->SetLineColor(kGreen+2);
249 >  SFN->SetLineStyle(2);
250 >  SFN->SetLineWidth(w);
251 >  OFP->SetLineColor(kBlue+2);
252 >  OFP->SetLineStyle(2);
253 >  OFP->SetLineWidth(w);
254 >  OFN->SetLineColor(kMagenta+2);
255 >  OFN->SetLineStyle(3);
256 >  OFN->SetLineWidth(w);
257 >  
258 >  RcorrJZBeemm->Draw();
259 >  SFN->Draw("histo,same");
260 >  OFP->Draw("histo,same");
261 >  OFN->Draw("histo,same");
262 >  Bpred->Draw("histo,same");
263 >  RcorrJZBeemm->Draw("same");
264 >  
265 >  TLegend *leg2 = make_legend("",0.52,0.7);
266 >  leg2->AddEntry(RcorrJZBeemm,"observed (data)","lp");
267 >  leg2->AddEntry(Bpred,"predicted (data)","l");
268 >  leg2->AddEntry(SFN,  "  SF JZB<0","l");
269 >  leg2->AddEntry(OFN,  "  OF JZB<0","l");
270 >  leg2->AddEntry(OFP,  "  OF JZB>0","l");
271 >  leg2->Draw("same");
272 >  
273 >  saveas.str("");
274 >  saveas << "kin/Mll_After_Cut/Cut_At" << jzbthreshold << "_nomc";
275 >  CompleteSave(ckin,saveas.str());
276 >  
277    delete RcorrJZBeemm;
278    delete LcorrJZBeemm;
279    delete RcorrJZBem;
280    delete LcorrJZBem;
281 <  if(PlottingSetup::RestrictToMassPeak) {
281 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
282      delete RcorrJZBSBeemm;
283      delete LcorrJZBSBeemm;
284      delete RcorrJZBSBem;
# Line 242 | Line 372 | void draw_ratio_plot(TH1* hdata, THStack
372    oneline->Draw("same");
373   }
374  
375 + float make_one_OFSF_plot(string variable, string addcut, string legendTitle, int nbins, float min, float max, float ymax, bool logscale,
376 +                        string xlabel, string filename, float legendPosition=0.55) {
377 +
378 +  TCut ibasiccut=basiccut;
379 +  bool draw_separation_lines=false;
380 +
381 +  if(addcut != "") ibasiccut = ibasiccut && addcut.c_str();
382 +
383 +  TCut cutSF;
384 +  TCut cutOF;
385 +
386 +  cutOF = cutOSOF&&cutnJets&&ibasiccut;
387 +  cutSF = cutOSSF&&cutnJets&&ibasiccut;
388 +
389 +  TCanvas *ckin = new TCanvas("ckin","Kinematic Plots (in the making)",600,600);
390 +  TPad* rcan = new TPad("rcan","rcan",0,0,1,1);
391 +  rcan->SetLogy(logscale);
392 +  rcan->cd();
393 +
394 +  std::cout << "OF/SF comparison: variable = " << variable << ", cut = " << cutSF.GetTitle() << std::endl;
395 +  TH1F *datahistoSF = allsamples.Draw("datahistoSF",variable,nbins,min,max, xlabel, "events",cutSF,data,luminosity);
396 +  TH1F *datahistoOF = allsamples.Draw("datahistoOF",variable,nbins,min,max, xlabel, "events",cutOF,data,luminosity);
397 + //   string signal("LM3");
398 + //   TH1F* signalhisto = new TH1F("signalhisto",signal.c_str(),nbins,min,max);
399 + //   int idx = signalsamples.FindSample(signal)[0];
400 + //   (signalsamples.collection)[idx].events->Project("signalhisto",variable.c_str(),cutSF);
401 + //   signalhisto->Scale((signalsamples.collection)[idx].weight*luminosity);
402 + //   signalhisto->SetLineColor((signalsamples.collection)[idx].samplecolor);
403 + //   signalhisto->SetLineStyle(2);
404 +  datahistoSF->SetMarkerSize(DataMarkerSize);
405 +  datahistoOF->SetLineColor(kRed);
406 +
407 +  if ( !logscale ) {
408 +    datahistoSF->SetMinimum(0); // Defaults
409 +  } else {
410 +    datahistoSF->SetMinimum(0.5);
411 +  }
412 +  if (ymax<0) {
413 +    if ( logscale ) datahistoSF->SetMaximum(5.3*datahistoSF->GetMaximum());
414 +    else datahistoSF->SetMaximum(1.5*datahistoSF->GetMaximum());
415 +  } else {
416 +    datahistoSF->SetMaximum(ymax);
417 +  }
418 +
419 +  float ymaxSet = datahistoSF->GetMaximum();
420 +
421 +  datahistoSF->GetXaxis()->SetTitle(xlabel.c_str());
422 +  datahistoSF->GetYaxis()->SetTitle("Events");
423 +  datahistoSF->GetXaxis()->CenterTitle();
424 +  datahistoSF->GetYaxis()->CenterTitle();
425 +
426 +  TLegend *mleg = make_legend(legendTitle.c_str(),legendPosition,0.7,false,legendPosition+0.2);
427 +  mleg->AddEntry(datahistoSF, "Same-flavor", "PL");
428 +  if (datahistoOF->Integral()>0) {
429 +    mleg->AddEntry(datahistoOF, "Opposite-flavor", "L");
430 +  } else {
431 +    mleg->AddEntry((TObject*)0, "", "");
432 +  }
433 +  //mleg->AddEntry(signalhisto, "LM3", "L");
434 +
435 +  datahistoSF->Draw("E1");
436 +  if (datahistoOF->Integral()>0) datahistoOF->Draw("HIST,SAMES");
437 +  //signalhisto->Draw("HIST,SAMES");
438 +  mleg->Draw();
439 +  DrawPrelim();
440 +  if (datahistoOF->Integral()>0) {
441 +    save_with_ratio( datahistoSF, datahistoOF, rcan, "SFOF/" + filename, false, false, "SF/OF" );
442 +  } else {
443 +    CompleteSave(rcan, "SFOF/" + filename);
444 +    delete rcan;
445 +  }
446 +
447 +  datahistoSF->Delete();
448 +  datahistoOF->Delete();
449 +  //signalhisto->Delete();
450 +  delete mleg;
451 +  delete ckin;
452 +
453 +  return ymaxSet;
454 +
455 + }
456 +
457 + // Compare data to data
458 + float make_data_comparison_plot(string variable, TCut cut, int nbins, float min, float max, float ymax, bool logscale,
459 +                                string xlabel, string filename, float legendPosition=0.55) {
460 +
461 +  TCut ibasiccut=basiccut&&cut;
462 +
463 +  TCanvas *ckin = new TCanvas("ckin","Kinematic Plots (in the making)",600,600);
464 +  TPad* rcan = new TPad("rcan","rcan",0,0,1,1);
465 +  rcan->SetLogy(logscale);
466 +  rcan->cd();
467 +
468 +  std::cout << "Data comparison: variable = " << variable << ", cut = " << ibasiccut.GetTitle() << std::endl;
469 +
470 +  TH1F *data1 = allsamples.Draw("data1",variable,nbins,min,max, xlabel, "events",ibasiccut,data,luminosity);
471 +  TH1F *data2 = comparesamples.Draw("data2",variable,nbins,min,max, xlabel, "events",ibasiccut,data,luminosity);
472 +
473 +  data1->SetMarkerSize(DataMarkerSize);
474 +  data2->SetLineColor(kRed);
475 +
476 +  if ( !logscale ) {
477 +    data1->SetMinimum(0); // Defaults
478 +  } else {
479 +    data1->SetMinimum(0.5);
480 +  }
481 +  if (ymax<0) {
482 +    if ( logscale ) data1->SetMaximum(5.3*data1->GetMaximum());
483 +    else data1->SetMaximum(1.5*data1->GetMaximum());
484 +  } else {
485 +    data1->SetMaximum(ymax);
486 +  }
487 +
488 +  float ymaxSet = data1->GetMaximum();
489 +
490 +  data1->GetXaxis()->SetTitle(xlabel.c_str());
491 +  data1->GetYaxis()->SetTitle("Events");
492 +  data1->GetXaxis()->CenterTitle();
493 +  data1->GetYaxis()->CenterTitle();
494 +
495 +  TLegend *mleg = make_legend("",legendPosition,0.7,false,legendPosition+0.2);
496 +  mleg->AddEntry(data1, "New 3.8/fb", "PL");
497 +  mleg->AddEntry(data2, "Old 5.1/fb", "L");
498 +
499 +  data1->Draw("E1");
500 +  data2->Draw("HIST,SAMES");
501 +  mleg->Draw();
502 +  DrawPrelim();
503 +  save_with_ratio( data1, data2, rcan, "compareData/" + filename, false, false, "old/new" );
504 +
505 +  data1->Delete();
506 +  data2->Delete();
507 +  delete mleg;
508 +  delete ckin;
509 +
510 + }
511 +
512 + void make_OFSF_plots(string variable, string addcut, int nbins, float min, float max, bool logscale,
513 +                     string xlabel, string filename, float legendPosition=0.55) {
514 +
515 +  string mllcuts[] = { "mll>15","mll>15&&mll<70", "mll>75&&mll<105", "mll>120" };
516 +  string mllcutname[] = { "m_{ll} > 15 GeV", "15 < m_{ll} < 70 GeV", "70 < m_{ll} < 110 GeV", "m_{ll} > 120 GeV" };
517 +  string plotname[] = {"_all","_low","_peak","_high"};
518 +  float ymax;
519 +
520 +  int start = 0;
521 +  if ( !PlottingSetup::openBox ) start = 3;
522 +
523 +  for ( int i=start; i<4; ++i ) {
524 +    if ( addcut != "" ) mllcuts[i] += "&&"+addcut;
525 +    if ( i==start ) {
526 +      ymax = make_one_OFSF_plot(variable, mllcuts[i], mllcutname[i], nbins, min, max, -1, logscale, xlabel,
527 +                         filename+plotname[i], legendPosition );
528 +    } else {
529 +      make_one_OFSF_plot(variable, mllcuts[i],        mllcutname[i], nbins, min, max, ymax, logscale, xlabel,
530 +                         filename+plotname[i], legendPosition );
531 +    }
532 +    make_one_OFSF_plot(variable, "id1==1&&id1==id2&&"+mllcuts[i], mllcutname[i], nbins, min, max, ymax, logscale, xlabel,
533 +                       filename+plotname[i]+"_mm", legendPosition );
534 +    make_one_OFSF_plot(variable, "id1==0&&id1==id2&&"+mllcuts[i], mllcutname[i], nbins, min, max, ymax, logscale, xlabel,
535 +                       filename+plotname[i]+"_ee", legendPosition );
536 +  }
537 +
538 + }
539 +
540 +
541   float lastrange_min=0;
542   float lastrange_max=0;
543  
# Line 271 | Line 567 | void make_kin_plot(string variable, stri
567    //Step 2: Refine the cut
568    TCut cut;
569    cut=cutmass&&cutOSSF&&cutnJets&&ibasiccut;
570 <  if(filename=="nJets") cut=cutmass&&cutOSSF&&ibasiccut;
571 <  if(filename=="nJets_osof") cut=cutmass&&cutOSOF&&ibasiccut;
570 >  if(filename=="nJets" || filename=="nJets_inclusive") cut=cutmass&&cutOSSF&&ibasiccut;
571 >  if(filename=="nJets_osof" || filename=="nJets_osof_inclusive") cut=cutmass&&cutOSOF&&ibasiccut;
572    if(filename=="nJets_nocuts_except_mll_ossf") cut=cutmass&&cutOSSF;
573    if(filename=="mll") {
574          cut=cutOSSF&&cutnJets&&ibasiccut;
575          draw_separation_lines=true;
576    }
577    if(filename=="mll_ee") cut=cutOSSF&&cutnJets&&ibasiccut&&"id1==0";
578 +  if(filename=="mll_mm") cut=cutOSSF&&cutnJets&&ibasiccut&&"id1==1";
579    if(filename=="mll_osof") {
580          cut=cutOSOF&&cutnJets&&ibasiccut;
581          draw_separation_lines=true;
582    }
583 <  if(filename=="mll_mm") cut=cutOSSF&&cutnJets&&ibasiccut&&"id1==1";
584 <  if(Contains(filename,"mll_aboveJZB100")) cut=cutOSSF&&cutnJets&&ibasiccut;
583 >  if(Contains(filename,"aboveJZB")) cut=cutOSSF&&cutnJets&&ibasiccut;
584 >  if(Contains(filename,"mll_ee_above")) cut=cut&&"id1==0";
585 >  if(Contains(filename,"mll_mm_above")) cut=cut&&"id1==1";
586    if(Contains(filename,"mll_osof_aboveJZB")) cut=cutOSOF&&cutnJets&&ibasiccut;
587 <  if(filename=="mll_inclusive"||filename=="mll_inclusive_highrange") cut=cutOSSF;
588 <  if(filename=="mll_inclusive_osof") cut=cutOSOF;
589 <  if(filename=="mll_inclusive_ee") cut=cutOSSF&&"id1==0";
590 <  if(filename=="mll_inclusive_mm") cut=cutOSSF&&"id1==1";
587 >  if(filename=="mll_inclusive"||filename=="mll_inclusive_highrange") cut=cutmass&&cutOSSF;
588 >  if(filename=="mll_inclusive_osof") cut=cutmass&&cutOSOF;
589 >  if(filename=="mll_inclusive_ee") cut=cutmass&&cutOSSF&&"id1==0";
590 >  if(filename=="mll_inclusive_mm") cut=cutmass&&cutOSSF&&"id1==1";
591    if(filename=="pfJetGoodEta_0") cut=cutOSSF&&cutmass&&ibasiccut&&cutnJets;
592    if(filename=="pfJetGoodPt_0") cut=cutOSSF&&cutmass&&ibasiccut&&cutnJets;
593 +  if(filename=="numVtx") cut=cutmass&&ibasiccut;
594  
595    TCanvas *ckin = new TCanvas("ckin","Kinematic Plots (in the making)",600,600);
596    ckin->SetLogy(logscale);
597    TH1F *datahisto = allsamples.Draw("datahisto",variable,nbins,min,max, xlabel, "events",cut,data,luminosity);
598    datahisto->SetMarkerSize(DataMarkerSize);
599 <  THStack mcstack = allsamples.DrawStack("mcstack",variable,nbins,min,max, xlabel, "events",cut,mc,luminosity);
599 >  if ( !logscale ) datahisto->SetMinimum(0); // Defaults
600 >  else datahisto->SetMinimum(0.5);
601 >  // Custom max.
602 >  if(variable=="TMath::Abs(pfJetDphiMet[0])") datahisto->SetMaximum(1.5*datahisto->GetMaximum());
603    if(variable=="pfJetGoodPt[0]") datahisto->SetMaximum(10*datahisto->GetMaximum());
604    if(variable=="pt") datahisto->SetMaximum(10*datahisto->GetMaximum());
605    if(filename=="mll_inclusive"||filename=="mll_inclusive_mm"||filename=="mll_inclusive_ee") datahisto->SetMinimum(1);
606    if(filename=="mll_osof") datahisto->SetMaximum(10*datahisto->GetMaximum());
607    if(filename=="mll_osof") datahisto->SetMinimum(9);
608 <  datahisto->SetMaximum(5.3*datahisto->GetMaximum());
609 <  datahisto->Draw("e1");
610 <  ckin->Update();
608 >  if (logscale) datahisto->SetMaximum(5.3*datahisto->GetMaximum());
609 >  else datahisto->SetMaximum(1.3*datahisto->GetMaximum());
610 >
611 >  cout << "******** Cut used : " << (const char*) cut << endl;
612    if(loadlastminmax) {
613          datahisto->SetMinimum(lastrange_min);
614          datahisto->SetMaximum(lastrange_max);
# Line 315 | Line 618 | void make_kin_plot(string variable, stri
618          }              
619    }
620  
621 +  // Draw signal by hand (for some reason I don't manage to use the sample class: it adds it to the stack!)
622 +  string signal("LM3");
623 +  TH1F* signalhisto = new TH1F("signalhisto",signal.c_str(),nbins,min,max);
624 +  int idx = signalsamples.FindSample(signal)[0];
625 +  (signalsamples.collection)[idx].events->Project("signalhisto",variable.c_str(),cut);
626 +  signalhisto->Scale((signalsamples.collection)[idx].weight*luminosity);
627 +  signalhisto->SetLineColor(kOrange);
628 +
629 +  THStack mcstack   = allsamples.DrawStack("mcstack",  variable,nbins,min,max,xlabel,"events",cut,mc,luminosity);
630 +  datahisto->Draw("e1");
631 +  ckin->Update();
632    mcstack.Draw("same");
633 +  
634    datahisto->Draw("same,e1");
635    TLegend *kinleg = allsamples.allbglegend();
636    kinleg->Draw();
# Line 358 | Line 673 | void make_kin_plot(string variable, stri
673          kinpad->SetLogy(logscale);
674          datahisto->Draw("e1");
675          mcstack.Draw("same");
676 +        signalhisto->Draw("same");
677          datahisto->Draw("same,e1");
678          datahisto->Draw("same,axis");
679          if(RestrictToMassPeak&&draw_separation_lines) {
# Line 365 | Line 681 | void make_kin_plot(string variable, stri
681            upperboundary->Draw("same");
682          }
683            
684 +        kinleg->AddEntry("signalhisto",signal.c_str(),"l");
685          kinleg->Draw();
686          write_cut->Draw();
687          DrawPrelim();
# Line 382 | Line 699 | void make_kin_plot(string variable, stri
699    delete ckin;
700   }
701  
702 < void make_JES_plot() {
702 > void make_JES_plot(TCut cut, string name) {
703  
704    int nbins=10;
705    float min=-0.5;
706    float max = 9.5;
707    bool logscale=true;
708    string xlabel="nJets";
392 –  TCut cut=cutmass&&cutOSSF&&basiccut;
709  
710    TCanvas *ckin = new TCanvas("ckin","Kinematic Plots (in the making)",600,600);
711    ckin->SetLogy(logscale);
712 <  TH1F *datahisto = allsamples.Draw("datahisto","pfJetGoodNum",nbins,min,max, xlabel, "events",cut,data,luminosity);
712 >  TH1F *datahisto = allsamples.Draw("datahisto","pfJetGoodNum40",nbins,min,max, xlabel, "events",cut,data,luminosity);
713    datahisto->SetMarkerSize(DataMarkerSize);
714 <  THStack mcstack = allsamples.DrawStack("mcstack","pfJetGoodNum",nbins,min,max, xlabel, "events",cut,mc,luminosity);
715 <  TH1F *JESup = allsamples.Draw("JESup","pfJetGoodNum315",nbins,min,max, xlabel, "events",cut,mc,luminosity);
716 <  TH1F *JESdn = allsamples.Draw("JESdn","pfJetGoodNum285",nbins,min,max, xlabel, "events",cut,mc,luminosity);
714 >  THStack mcstack = allsamples.DrawStack("mcstack","pfJetGoodNum40",nbins,min,max, xlabel, "events",cut,mc,luminosity);
715 >  TH1F *JESup = allsamples.Draw("JESup","pfJetGoodNum40p1sigma",nbins,min,max, xlabel, "events",cut,mc,luminosity);
716 >  TH1F *JESdn = allsamples.Draw("JESdn","pfJetGoodNum40n1sigma",nbins,min,max, xlabel, "events",cut,mc,luminosity);
717  
718    datahisto->SetMinimum(1);
719    datahisto->SetMaximum(5.3*datahisto->GetMaximum()); // in line with kinematic plots style
# Line 422 | Line 738 | void make_JES_plot() {
738    TLegend *kinleg = allsamples.allbglegend();
739    kinleg->AddEntry(JESunc,"JES uncertainty","f");
740    kinleg->Draw();
741 <  CompleteSave(ckin,"Systematics/JES");
741 >  CompleteSave(ckin,"Systematics/JES"+name);
742    datahisto->Delete();
743    delete ckin;
744  
# Line 432 | Line 748 | void do_kinematic_plots(string mcjzb, st
748   {
749    bool dolog=true;
750    bool nolog=false;
751 +
752 +  bool doOFSF = true;
753 +  bool doKin  = true;
754 +  bool doDataComp = true;
755 +  
756 +
757    if(doPF) write_warning(__FUNCTION__,"Please use caution when trying to produce PF plots; not all versions of the JZB trees have these variables!");
758    float mll_low=50;
759    float mll_hi=160;
760    if(!PlottingSetup::RestrictToMassPeak) {
761          mll_low=20;
762 <        mll_hi=210;
762 >        mll_hi=320;
763    }
764 <  
765 <  make_kin_plot("met[4]","",40,0,200,dolog,"MET [GeV]","met",doPF,true);
766 <  make_kin_plot("mll","",(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll",doPF,true);
767 <  make_kin_plot("mll","",(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_osof",doPF,true,true);
768 <  make_kin_plot("mll","",(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_ee",doPF,true);
769 <  make_kin_plot("mll","",(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_mm",doPF,true);
770 <  make_kin_plot("mll","",(int)((mll_hi-mll_low)),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_inclusive",doPF,true);
771 <  make_kin_plot("mll","",(int)((mll_hi-mll_low)),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_inclusive_ee",doPF,true);
772 <  make_kin_plot("mll","",(int)((mll_hi-mll_low)),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_inclusive_mm",doPF,true);
773 <  make_kin_plot("mll","",(int)((mll_hi-mll_low))/2,mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_inclusive_osof",doPF,true);
774 <  make_kin_plot("mll","",(int)((350-mll_low)),mll_low,350,dolog,"m_{ll} [GeV]","mll_inclusive_highrange",doPF);
775 <  make_kin_plot("numVtx","",(int)(30.5-(-0.5)),-0.5,30.5,nolog,"N(Vtx)","numVtx",doPF);
776 < //  make_kin_plot("jetpt[0]","",40,0,200,dolog,"leading jet p_{T} [GeV]","pfJetGoodPt_0",doPF);
777 < //  make_kin_plot("jeteta[0]","",40,-5,5,nolog,"leading jet #eta","pfJetGoodEta_0",doPF);
778 <  make_kin_plot("pt","",50,0,400,dolog,"Z p_{T} [GeV]","Zpt",doPF);
779 <  make_kin_plot("pt1","",50,0,100,nolog,"p_{T} [GeV]","pt1",doPF);
780 <  make_kin_plot("pt2","",50,0,100,nolog,"p_{T} [GeV]","pt2",doPF);
781 <  make_kin_plot("eta1","",40,-5,5,nolog,"#eta_{l}","eta",doPF);
782 <  make_kin_plot("jzb[1]","",100,-150,150,dolog,"JZB [GeV]","jzb_ossf",doPF);
783 <  make_kin_plot("pfJetGoodNum40","",9,-0.5,8.5,dolog,"nJets","nJets",doPF);
784 <  make_kin_plot("pfJetGoodNum40","",9,-0.5,8.5,dolog,"nJets","nJets_osof",doPF);
785 <  make_kin_plot("pfJetGoodNum40","",9,-0.5,8.5,dolog,"nJets","nJets_nocuts_except_mll_ossf",doPF);
786 <  if(!doPF) make_special_mll_plot((int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]");
787 <  stringstream jzbcut;
788 <  jzbcut << "((is_data&&("<<datajzb<<")>100)||(!is_data&&("<<mcjzb<<")>100))";
789 <  make_kin_plot("mll",jzbcut.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_aboveJZB100",doPF,true);
790 <  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);
791 <  make_kin_plot("mll",jzbcut.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_aboveJZB100",doPF,true);
792 <  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);
793 <  stringstream jzbcut2;
794 <  jzbcut2 << "((is_data&&("<<datajzb<<")>150)||(!is_data&&("<<mcjzb<<")>150))";
795 <  make_kin_plot("mll",jzbcut2.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_aboveJZB150",doPF,true);
796 <  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);
797 <  stringstream jzbcut3;
798 <  jzbcut3 << "((is_data&&("<<datajzb<<")>50)||(!is_data&&("<<mcjzb<<")>50))";
799 <  make_kin_plot("mll",jzbcut3.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_aboveJZB50",doPF,true);  
800 <  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);
801 <  
802 <  make_special_obs_pred_mll_plot(mcjzb,0);
803 <  make_special_obs_pred_mll_plot(mcjzb,50);
804 <  make_special_obs_pred_mll_plot(mcjzb,100);
805 <  make_special_obs_pred_mll_plot(mcjzb,150);
806 <  make_special_obs_pred_mll_plot(mcjzb,200);
807 <  make_special_obs_pred_mll_plot(mcjzb,250);
764 >
765 >  if ( doOFSF ) {
766 >    make_OFSF_plots("mll", "met[4]>100", 60, 20., 320., false, "m_{ll}", "mll");
767 >
768 >    make_OFSF_plots("pfJetGoodNum40", "met[4]>100",                        7, 3, 10, true, "#(jets)", "njets");
769 >    make_OFSF_plots("pfJetGoodNum40", "met[4]>100&&pfJetGoodNumBtag30==0", 7, 3, 10, true, "#(jets)", "njets_btagVeto");
770 >    make_OFSF_plots("pfJetGoodNum40", "met[4]>100&&pfJetGoodNumBtag30>0",  7, 3, 10, true, "#(jets)", "njets_AtLeastOneBJet30");
771 >
772 >    make_OFSF_plots("pfJetGoodNumBtag30", "met[4]>100", 5, 0, 5, true, "#(b-jets)", "nbjets");
773 >    make_OFSF_plots("pfJetGoodPtBtag[0]", "met[4]>100&&pfJetGoodNumBtag30>0", 20, 0, 400, true, "p_{T}(leading b-jet)", "ptb1");
774 >
775 >    make_OFSF_plots("iso1", "met[4]>100", 20, 0, 0.3, true, "lepton 1 isolation", "iso1");
776 >    make_OFSF_plots("iso2", "met[4]>100", 20, 0, 0.3, true, "lepton 2 isolation", "iso2");
777 >    //  make_OFSF_plots("pt1",  "met[4]>100", 30, 0., 300., true, "p_{T,1}", "pt1");
778 >    //  make_OFSF_plots("pt2",  "met[4]>100", 22, 0., 220., true, "p_{T,2}", "pt2");
779 >    make_OFSF_plots("eta1", "met[4]>100", 10, -2.5, 2.5, false, "#eta_{1}", "eta1", 0.15);
780 >    make_OFSF_plots("eta2", "met[4]>100", 10, -2.5, 2.5, false, "#eta_{2}", "eta2", 0.15);
781 >    //  make_OFSF_plots("phi1", "met[4]>100", 10, -TMath::Pi(), TMath::Pi(), false, "#phi_{1}", "phi1", 0.2);
782 >    //  make_OFSF_plots("phi2", "met[4]>100", 10, -TMath::Pi(), TMath::Pi(), false, "#phi_{2}", "phi2", 0.2);
783 >    //  make_OFSF_plots("pfJetGoodPt[0]/pfJetGoodPt[1]", "met[4]>100", 20, 1, 10, true, "pt_{j}^{1}/pt_{j}^{2}", "jpt1pt2", 0.2);
784 >    make_OFSF_plots("TMath::Abs(pfJetDphiMet[0])", "met[4]>100", 16, 0, 3.2, false, "|#Delta#phi(jet1,MET)|", "dphij1met", 0.2);
785 >    make_OFSF_plots("TMath::Abs(dphi)", "met[4]>100", 16, 0, 3.2, false, "|#Delta#phi(l1,l2)|", "dphi", 0.2);
786 >    //  make_OFSF_plots("TMath::Abs(dphiMet1)", "met[4]>100", 16, 0, 3.2, false, "|#Delta#phi(l1,MET)|", "dphiMet1", 0.2);
787 >    //  make_OFSF_plots("TMath::Abs(dphiMet2)", "met[4]>100", 16, 0, 3.2, false, "|#Delta#phi(l2,MET)|", "dphiMet2", 0.2);
788 >    make_OFSF_plots("TMath::Min(TMath::Abs(dphiMet1), TMath::Abs(dphiMet2))", "met[4]>100", 16, 0, 3.2, false, "Min(|#Delta#phi(l,MET)|)", "dphilc");
789 >    make_OFSF_plots("TMath::Min(TMath::Abs(pfJetDphiMet[0]), TMath::Min(TMath::Abs(pfJetDphiMet[1]), TMath::Abs(pfJetDphiMet[2])))", "met[4]>100", 16, 0, 3.2, false, "Min(|#Delta#phi(jet,MET)|)", "dphijc");
790 >    make_OFSF_plots("TMath::Min((TMath::Pi()-TMath::Abs(dphiMet1)), (TMath::Pi() - TMath::Abs(dphiMet2)))", "met[4]>100", 16, 0, 3.2, false, "Min(#pi - |#Delta#phi(l,MET)|)", "dphilco");
791 >    make_OFSF_plots("TMath::Min((TMath::Pi()-TMath::Abs(pfJetDphiMet[0])), TMath::Min( (TMath::Pi()-TMath::Abs(pfJetDphiMet[1])), (TMath::Pi() - TMath::Abs(pfJetDphiMet[2]))))", "met[4]>100", 16, 0, 3.2, false, "Min(#pi - |#Delta#phi(jet,MET)|)", "dphijco");
792 >  }
793 >
794 >  if ( doDataComp && !PlottingSetup::openBox ) {
795 >    TCut mllCut("");
796 >    float massmin = 15.;
797 >    float massmax = 315;
798 >    int massnbins = 60;
799 >    if ( !PlottingSetup::openBox ) {
800 >      mllCut = "mll>120";
801 >      massmin = 120;
802 >      massmax = 360;
803 >      massnbins = 14;
804 >    }
805 >
806 >    TCut cutSignal = cutmass&&cutnJets&&"met[4]>100";
807 >    make_data_comparison_plot("mll", cutOSSF,60, 15., 315.,-1., true, "m_{ll}", "mll_SF_inclusive");
808 >    make_data_comparison_plot("mll", cutOSOF,60, 15., 315.,-1., true, "m_{ll}", "mll_OF_inclusive");
809 >
810 >    make_data_comparison_plot("mll", cutOSSF&&cutSignal&&mllCut,           massnbins, 15., 315.,-1., false, "m_{ll}", "mll_SF_sig");
811 >    make_data_comparison_plot("mll", cutOSSF&&cutSignal&&mllCut&&"pfJetGoodNumBtag30==0", massnbins, 15., 315.,-1., false, "m_{ll}", "mll_SF_sig_btagVeto");
812 >    make_data_comparison_plot("mll", cutOSSF&&cutSignal&&mllCut&&"pfJetGoodNumBtag30>0",  massnbins, 15., 315.,-1., false, "m_{ll}", "mll_SF_sig_AtLeastOneBJet");
813 >
814 >    make_data_comparison_plot("mll", mllCut&&cutOSOF&&cutSignal, massnbins, 15., 315.,-1., false, "m_{ll}", "mll_OF_sig");
815 >    make_data_comparison_plot("mll", cutmass&&cutOSSF&&"met[4]>100&&met[4]<150&&pfJetGoodNum40==2", massnbins, 15., 315.,-1., false, "m_{ll}", "mll_SF_CR");
816 >    make_data_comparison_plot("mll", cutmass&&cutOSOF&&"met[4]>100&&met[4]<150&&pfJetGoodNum40==2", massnbins, 15., 315.,-1., false, "m_{ll}", "mll_OF_CR");
817 >
818 >    make_data_comparison_plot("pfJetGoodNum40", cutOSSF&&cutSignal&&mllCut, 8, 0., 8.,-1., false, "#(jets)", "njets_SF_sig");
819 >    make_data_comparison_plot("pfJetGoodNum40", cutOSOF&&cutSignal&&mllCut, 8, 0., 8.,-1., false, "#(jets)", "njets_OF_sig");
820 >    make_data_comparison_plot("pfJetGoodNumBtag30", cutOSSF&&cutSignal&&mllCut, 8, 0., 8.,-1., false, "#(b-jets)", "nbjets_SF_sig");
821 >    make_data_comparison_plot("pfJetGoodNumBtag30", cutOSOF&&cutSignal&&mllCut, 8, 0., 8.,-1., false, "#(b-jets)", "nbjets_OF_sig");
822 >  }
823 >
824 >
825 >  if ( doKin ) {
826 >    string mllCut("");
827 >    if ( !PlottingSetup::openBox ) mllCut = "&&mll>120";
828 >
829 >    // Plots in signal region
830 >    make_kin_plot("met[4]","",70,0,350,dolog,"MET [GeV]","met",doPF,true);
831 >    make_kin_plot("mll","mll>20&&met[4]>100"+mllCut,(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll",doPF,true);
832 >    make_kin_plot("mll","mll>20&&met[4]>100",(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_osof",doPF,true,true);
833 >    make_kin_plot("mll","mll>20&&met[4]>100"+mllCut,(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_ee",doPF,true);
834 >    make_kin_plot("mll","mll>20&&met[4]>100"+mllCut,(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_mm",doPF,true);
835 >    
836 >    make_kin_plot("pfJetGoodNum40","met[4]>100"+mllCut,9,-0.5,8.5,dolog,"nJets","nJets",doPF);
837 >    make_kin_plot("pfJetGoodNum40","met[4]>100",9,-0.5,8.5,dolog,"nJets","nJets_osof",doPF);
838 >
839 >    // Further inclusive invariant mass plots
840 >    make_kin_plot("mll","",(int)((mll_hi-mll_low))/5,mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_inclusive",doPF,true);
841 >    make_kin_plot("mll","",(int)((mll_hi-mll_low))/5,mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_inclusive_ee",doPF,true);
842 >    make_kin_plot("mll","",(int)((mll_hi-mll_low))/5,mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_inclusive_mm",doPF,true);
843 >    make_kin_plot("mll","",(int)((mll_hi-mll_low))/5,mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_inclusive_osof",doPF,true);
844 >    
845 >    //make_kin_plot("mll","",(int)((350-mll_low))/5,mll_low,350,dolog,"m_{ll} [GeV]","mll_inclusive_highrange",doPF);
846 >    //if(!doPF) make_special_mll_plot((int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]");
847 >    
848 >    //make_kin_plot("pfJetGoodPt[0]/pfJetGoodPt[1]","",45,1,10,dolog,"pt_{j}^{1}/pt_{j}^{2}","j1j2ratio",doPF,true);
849 >    //make_kin_plot("TMath::Abs(pfJetDphiMet[0])","",32,0,3.2,nolog,"|#Delta#phi(jet1,MET)|","dphiJ1MET",doPF,true);
850 >    
851 >    // Number of jets
852 >    make_kin_plot("pfJetGoodNum40","",9,-0.5,8.5,dolog,"nJets","nJets_inclusive",doPF);
853 >    make_kin_plot("pfJetGoodNum40","",9,-0.5,8.5,dolog,"nJets","nJets_osof_inclusive",doPF);
854 >    //make_kin_plot("pfJetGoodNum40","",9,-0.5,8.5,dolog,"nJets","nJets_nocuts_except_mll_ossf",doPF);
855 >    
856 >    // Others
857 >    make_kin_plot("numVtx","",(int)(30.5-(-0.5)),-0.5,30.5,nolog,"N(Vtx)","numVtx",doPF);
858 >    //  make_kin_plot("jetpt[0]","",40,0,200,dolog,"leading jet p_{T} [GeV]","pfJetGoodPt_0",doPF);
859 >    //  make_kin_plot("jeteta[0]","",40,-5,5,nolog,"leading jet #eta","pfJetGoodEta_0",doPF);
860 >    make_kin_plot("pt","",50,0,500,dolog,"Z p_{T} [GeV]","Zpt",doPF);
861 >    make_kin_plot("pt1","",50,0,200,nolog,"p_{T} [GeV]","pt1",doPF);
862 >    make_kin_plot("pt2","",50,0,200,nolog,"p_{T} [GeV]","pt2",doPF);
863 >    make_kin_plot("eta1","",40,-3,3,nolog,"#eta_{l}","eta",doPF);
864 >    make_kin_plot("jzb[1]","",100,-150,200,dolog,"JZB [GeV]","jzb_ossf",doPF);
865 >    //   stringstream jzbcut;
866 >    //   jzbcut << "((is_data&&("<<datajzb<<")>100)||(!is_data&&("<<mcjzb<<")>100))";
867 >    //   make_kin_plot("mll",jzbcut.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,nolog,"m_{ll} [GeV]","mll_aboveJZB100",doPF,true);
868 >    //   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);
869 >    //   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);
870 >    //   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);
871 >    //   stringstream jzbcut2;
872 >    //   jzbcut2 << "((is_data&&("<<datajzb<<")>150)||(!is_data&&("<<mcjzb<<")>150))";
873 >    //   make_kin_plot("mll",jzbcut2.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,nolog,"m_{ll} [GeV]","mll_aboveJZB150",doPF,true);
874 >    //   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);
875 >    //   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);
876 >    //   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);
877 >    //   stringstream jzbcut3;
878 >    //   jzbcut3 << "((is_data&&("<<datajzb<<")>50)||(!is_data&&("<<mcjzb<<")>50))";
879 >    //   make_kin_plot("mll",jzbcut3.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,nolog,"m_{ll} [GeV]","mll_aboveJZB50",doPF,true);  
880 >    //   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);
881 >    //   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);  
882 >    //   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);  
883 >    
884 >    //   make_kin_plot("mll","met[4]>100",(int)((mll_hi-mll_low)/5),mll_low,mll_hi,nolog,"m_{ll} [GeV] (MET>100GeV)","mll_met100_ll",doPF,true);
885 >    //make_kin_plot("mll","met[4]>150&&id1==0",(int)((mll_hi-mll_low)/5),mll_low,mll_hi,nolog,"m_{ee} [GeV] (MET>150GeV)","mll_met150_ee",doPF,true);
886 >    //make_kin_plot("mll","met[4]>150&&id1==1",(int)((mll_hi-mll_low)/5),mll_low,mll_hi,nolog,"m_{#mu#mu} [GeV] (MET>150GeV)","mll_met150_mm",doPF,true);
887 >  }
888 >    
889 > //   make_special_obs_pred_mll_plot(datajzb,mcjzb,0);
890 > //   make_special_obs_pred_mll_plot(datajzb,mcjzb,50);
891 > //   make_special_obs_pred_mll_plot(datajzb,mcjzb,80);
892 > //   make_special_obs_pred_mll_plot(datajzb,mcjzb,100);
893 > //   make_special_obs_pred_mll_plot(datajzb,mcjzb,150);
894 > //   make_special_obs_pred_mll_plot(datajzb,mcjzb,200);
895 > //   make_special_obs_pred_mll_plot(datajzb,mcjzb,250);
896 >
897 > //   make_JES_plot(cutmass&&cutOSSF&&basiccut,"_ossf");
898 > //   make_JES_plot(cutmass&&cutOSOF&&basiccut,"_osof");
899 >
900   }
901  
902   void make_comp_plot( string var, string xlabel, string filename, float jzbcut, string mcjzb, string datajzb,
903                       int nbins, float xmin, float xmax, bool log,
904                       float ymin=0, float ymax=0, bool leftJustified=false ) {
905 <      flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak ---- WATCH OUT: the argument in the function changed!
905 >  flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak ---- WATCH OUT: the argument in the function changed!
906  
907    TCut weightbackup=cutWeight;//backing up the correct weight (restoring below!)
908    if(weightbackup==TCut("1.0")||weightbackup==TCut("1")) write_warning(__FUNCTION__,"WATCH OUT THE WEIGHT HAS POSSIBLY NOT BEEN RESET!!!! PLEASE CHANGE LINE "+any2string(__LINE__));
909 <  if(var=="numVtx") cutWeight=TCut("1.0");
909 >  //if(var=="numVtx") cutWeight=TCut("1.0");
910    TCut jzbData[]= { TCut(TString(datajzb+">"+any2string(jzbcut))),TCut(TString(datajzb+"<-"+any2string(jzbcut))) };
911    TCut jzbMC[]  = { TCut(TString(mcjzb+">"+any2string(jzbcut))),TCut(TString(mcjzb+"<-"+any2string(jzbcut))) };
912  
913    flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak ---- below: the next ~20 lines changed!
914    int nRegions=4;
915 <  if(!PlottingSetup::RestrictToMassPeak) {
915 >  if(!PlottingSetup::RestrictToMassPeak||!PlottingSetup::UseSidebandsForcJZB) {
916      nRegions=2;
917    }
918    
# Line 516 | Line 930 | void make_comp_plot( string var, string
930        TCanvas *ccomp = new TCanvas("ccomp","Comparison plot",600,400);
931        ccomp->SetLogy(log);
932        TH1F *datahisto = allsamples.Draw("datahisto",   var,nbins,xmin,xmax,xlabel,"events",kRegions[iregion]&&jzbData[ijzb],data,luminosity);
933 <      TH1F *lm4histo = signalsamples.Draw("lm4histo",   var,nbins,xmin,xmax,xlabel,"events",kRegions[iregion]&&jzbData[ijzb],data,luminosity,signalsamples.FindSample("LM4"));
933 >      TH1F *lm3histo  = signalsamples.Draw("lm3histo",   var,nbins,xmin,xmax,xlabel,"events",kRegions[iregion]&&jzbMC[ijzb],data,luminosity,signalsamples.FindSample("LM3"));
934        THStack mcstack = allsamples.DrawStack("mcstack",var,nbins,xmin,xmax,xlabel,"events",kRegions[iregion]&&jzbMC[ijzb],  mc,  luminosity);
935        datahisto->SetMarkerSize(DataMarkerSize);
936        if (ymax>ymin) datahisto->SetMaximum(ymax);
937 <      lm4histo->SetLineStyle(2);
937 >      lm3histo->SetLineStyle(2);
938        datahisto->Draw("e1");
939        mcstack.Draw("same");
940        datahisto->Draw("same,e1");
941 < //      lm4histo->Draw("hist,same");
941 >      lm3histo->Draw("hist,same");
942        TLegend *kinleg = allsamples.allbglegend((sRegions[iregion]+(ijzb?"neg":"pos")).c_str());
943        if ( leftJustified ) {
944          Float_t w = kinleg->GetX2()-kinleg->GetX1();
945          kinleg->SetX1(0.2);
946          kinleg->SetX2(0.2+w);
947        }
948 < //      kinleg->AddEntry(lm4histo,"LM4","l");
948 >      kinleg->AddEntry(lm3histo,"LM3","l");
949        kinleg->Draw();
950        TText* write_variable = write_text(0.99,0.01,var);
951        write_variable->SetTextAlign(31);
# Line 540 | Line 954 | void make_comp_plot( string var, string
954        CompleteSave(ccomp,"compare/JZBcut_at_"+any2string(jzbcut)+"/"+filename+"/"+filename+sRegions[iregion]+(ijzb?"neg":"pos"));
955        delete datahisto;
956        delete ccomp;
957 <      delete lm4histo;
957 >      delete lm3histo;
958      }
959    cutWeight=weightbackup;
960   }
# Line 550 | Line 964 | void region_comparison_plots(string mcjz
964    dout << "Creating comparison plots for signal and control regions" << endl;
965    // Compare a few quantities in the signal region and all 7 control regions
966  
967 <  switch_overunderflow(true);  // switching overflow/underflow bins on
967 > //  switch_overunderflow(true);  // switching overflow/underflow bins on
968      
969    
970      flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak ---- the arguments changed
# Line 558 | Line 972 | void region_comparison_plots(string mcjz
972      float jzbcut=jzb_cuts[ijzb]; // Comparison plots are done for this JZB cut
973      float mll_low=50;float mll_high=170;
974      if(!PlottingSetup::RestrictToMassPeak) {
975 <        mll_high=200;
976 <        mll_low=50;
975 >        mll_high=300;
976 >        mll_low=20;
977      }
978 <    make_comp_plot("mll","m_{ll} [GeV]","mll",jzbcut,mcjzb,datajzb,30,mll_low,mll_high,false,0,16.);
978 >    make_comp_plot("pfJetGoodPt[0]/pfJetGoodPt[1]","pt_{j}^{1}/pt_{j}^{2}","j1j2ratio",jzbcut,mcjzb,datajzb,100,0,10,true);
979 >    make_comp_plot("TMath::Abs(pfJetDphiMet[0])","|#Delta#phi(jet1,MET)|","dphiJ1MET",jzbcut,mcjzb,datajzb,32,0,3.2,false,0,0,true);
980 >
981 >    make_comp_plot("mll","m_{ll} [GeV]","mll",jzbcut,mcjzb,datajzb,56,mll_low,mll_high,false,0,16.);
982      make_comp_plot("met[4]","pfMET [GeV]","pfmet",jzbcut,mcjzb,datajzb,18,0,360,false,0,16.);
983 <    make_comp_plot("pfJetGoodNum","#(jets)","njets",jzbcut,mcjzb,datajzb,10,0,10, false,0,35.);
983 >    make_comp_plot("pfJetGoodNum40","#(jets)","njets",jzbcut,mcjzb,datajzb,10,0,10, false,0,35.);
984 >    make_comp_plot("pfJetGoodNumBtag","#(b-jets)","nBjets",jzbcut,mcjzb,datajzb,10,0,10, false,0,35.);
985      make_comp_plot("pt","Z p_{T} [GeV]","Zpt",jzbcut,mcjzb,datajzb,26,0,525,false,0.,21.);
986 <    make_comp_plot("numVtx","#(prim. vertices)","nvtx",jzbcut,mcjzb,datajzb,20,0.,20.,false,0,16.);
986 >    make_comp_plot("numVtx","#(prim. vertices)","nvtx",jzbcut,mcjzb,datajzb,40,0.,40.,false,0,16.);
987      make_comp_plot("TMath::Abs(dphi)","#Delta#phi(leptons)","dphilep",jzbcut,mcjzb,datajzb,10,0.,3.1415,false,0,16.,true);
988      make_comp_plot("TMath::Abs(dphi_sumJetVSZ[1])","#Delta#phi(Z,jets)","dphiZjets",jzbcut,mcjzb,datajzb,10,0.,3.1415,false,0,16.,true);
989 +    make_comp_plot("eta1","#eta_1","eta1",jzbcut,mcjzb,datajzb,10,0.,2.5,false,0,16.);
990 +    make_comp_plot("eta2","#eta_2","eta2",jzbcut,mcjzb,datajzb,10,0.,2.5,false,0,16.);
991    }
992  
993    switch_overunderflow(false); // switching overflow/underflow bins off
# Line 766 | Line 1186 | vector<TF1*> do_extended_fit_to_plot(TH1
1186   //      the line above is not necessary anymore as we're now looking at a prediction without Z+Jets, and not multiplied with (1.0/3)
1187    TF1 *ttbarlogpar = do_logpar_fit_to_plot(Tprediction);
1188    flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak
1189 <  if(PlottingSetup::RestrictToMassPeak) ttbarlogpar->SetParameter(0,1.0/3*ttbarlogpar->GetParameter(0));//correcting for the fact that we didn't multiply with (1.0/3);
1189 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) ttbarlogpar->SetParameter(0,1.0/3*ttbarlogpar->GetParameter(0));//correcting for the fact that we didn't multiply with (1.0/3);
1190  
1191  
1192    TF1 *ttbarlogparP = new TF1("ttbarlogparP",LogParabolaP,0,(prediction->GetXaxis()->GetBinLowEdge(prediction->GetNbinsX())+prediction->GetXaxis()->GetBinWidth(prediction->GetNbinsX())),8);
# Line 861 | Line 1281 | if you want to start from scratch (witho
1281    return return_functions;
1282   }
1283  
1284 < void do_prediction_plot(string jzb, TCanvas *globalcanvas, float sigma, float high, int use_data, bool overlay_signal = false,string subdir="" )
1284 > void do_prediction_plot(string jzb, TCanvas *globalcanvas, float high, int use_data, bool overlay_signal = false,string subdir="" )
1285   {
1286 <  // note: sigma is not used ATM
867 <  switch_overunderflow(true);
1286 > //  switch_overunderflow(true);
1287    bool is_data=false;
1288    bool use_signal=false;
1289    if(use_data==1) is_data=true;
# Line 874 | Line 1293 | void do_prediction_plot(string jzb, TCan
1293    float low=0;
1294    float hi=500;
1295    
877 –  stringstream largerzeroS;
878 –  largerzeroS << "("<<jzb<<">0)";
879 –  TCut largerzero(largerzeroS.str().c_str());
880 –  stringstream smallerzeroS;
881 –  smallerzeroS << "("<<jzb<<"<0)";
882 –  TCut smallerzero(smallerzeroS.str().c_str());
883 –  
1296    TH1F *blankback = new TH1F("blankback","blankback",int(high/10),0,high);
1297 <  TH1F *RcorrJZBeemm   = allsamples.Draw("RcorrJZBeemm",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&largerzero,is_data, luminosity,use_signal);
1298 <  TH1F *LcorrJZBeemm   = allsamples.Draw("LcorrJZBeemm",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&smallerzero,is_data, luminosity,use_signal);
1299 <  TH1F *RcorrJZBem     = allsamples.Draw("RcorrJZBem",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&largerzero,is_data, luminosity,use_signal);
1300 <  TH1F *LcorrJZBem     = allsamples.Draw("LcorrJZBem",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&smallerzero,is_data, luminosity,use_signal);
1297 >  TH1F *RcorrJZBeemm   = allsamples.Draw("RcorrJZBeemm",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1298 >  TH1F *LcorrJZBeemm   = allsamples.Draw("LcorrJZBeemm",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1299 >  TH1F *RcorrJZBem     = allsamples.Draw("RcorrJZBem",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1300 >  TH1F *LcorrJZBem     = allsamples.Draw("LcorrJZBem",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1301  
1302    blankback->GetXaxis()->SetTitle(RcorrJZBeemm->GetXaxis()->GetTitle());
1303    blankback->GetYaxis()->SetTitle(RcorrJZBeemm->GetYaxis()->GetTitle());
# Line 902 | Line 1314 | void do_prediction_plot(string jzb, TCan
1314  
1315      //these are for the ratio
1316    
1317 <  TH1F *JRcorrJZBeemm   = allsamples.Draw("JRcorrJZBeemm",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&largerzero,is_data, luminosity,use_signal);
1318 <  TH1F *JLcorrJZBeemm   = allsamples.Draw("JLcorrJZBeemm",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&smallerzero,is_data, luminosity,use_signal);
1319 <  TH1F *JRcorrJZBem     = allsamples.Draw("JRcorrJZBem",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&largerzero,is_data, luminosity,use_signal);
1320 <  TH1F *JLcorrJZBem     = allsamples.Draw("JLcorrJZBem",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&smallerzero,is_data, luminosity,use_signal);
1317 >  TH1F *JRcorrJZBeemm   = allsamples.Draw("JRcorrJZBeemm",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1318 >  TH1F *JLcorrJZBeemm   = allsamples.Draw("JLcorrJZBeemm",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1319 >  TH1F *JRcorrJZBem     = allsamples.Draw("JRcorrJZBem",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1320 >  TH1F *JLcorrJZBem     = allsamples.Draw("JLcorrJZBem",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1321    
1322    TH1F *JRcorrJZBSBem;
1323    TH1F *JLcorrJZBSBem;
1324    TH1F *JRcorrJZBSBeemm;
1325    TH1F *JLcorrJZBSBeemm;
1326    
1327 <  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);
1327 >  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);
1328  
1329    
1330 <  if(PlottingSetup::RestrictToMassPeak) {
1331 <    RcorrJZBSBem   = allsamples.Draw("RcorrJZBSBem",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets&&largerzero,is_data, luminosity,use_signal);
1332 <    LcorrJZBSBem   = allsamples.Draw("LcorrJZBSBem",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets&&smallerzero,is_data, luminosity,use_signal);
1333 <    RcorrJZBSBeemm = allsamples.Draw("RcorrJZBSBeemm",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets&&largerzero,is_data, luminosity,use_signal);
1334 <    LcorrJZBSBeemm = allsamples.Draw("LcorrJZBSBeemm",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets&&smallerzero,is_data, luminosity,use_signal);
1330 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
1331 >    RcorrJZBSBem   = allsamples.Draw("RcorrJZBSBem",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1332 >    LcorrJZBSBem   = allsamples.Draw("LcorrJZBSBem",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1333 >    RcorrJZBSBeemm = allsamples.Draw("RcorrJZBSBeemm",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1334 >    LcorrJZBSBeemm = allsamples.Draw("LcorrJZBSBeemm",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1335      
1336      //these are for the ratio
1337 <    JRcorrJZBSBem   = allsamples.Draw("JRcorrJZBSBem",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets&&largerzero,is_data, luminosity,use_signal);
1338 <    JLcorrJZBSBem   = allsamples.Draw("JLcorrJZBSBem",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets&&smallerzero,is_data, luminosity,use_signal);
1339 <    JRcorrJZBSBeemm = allsamples.Draw("JRcorrJZBSBeemm",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets&&largerzero,is_data, luminosity,use_signal);
1340 <    JLcorrJZBSBeemm = allsamples.Draw("JLcorrJZBSBeemm",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets&&smallerzero,is_data, luminosity,use_signal);
1337 >    JRcorrJZBSBem   = allsamples.Draw("JRcorrJZBSBem",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1338 >    JLcorrJZBSBem   = allsamples.Draw("JLcorrJZBSBem",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1339 >    JRcorrJZBSBeemm = allsamples.Draw("JRcorrJZBSBeemm",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1340 >    JLcorrJZBSBeemm = allsamples.Draw("JLcorrJZBSBeemm",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1341    }
1342    
1343    TH1F *lm4RcorrJZBeemm;
1344 <  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"));
1344 >  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"));
1345    
1346    flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak ---- prediction changed.
1347    
# Line 942 | Line 1354 | void do_prediction_plot(string jzb, TCan
1354    TH1F *BpredSys = new TH1F("Bpredsys","Bpredsys",PlottingSetup::global_ratio_binning.size()-1,&PlottingSetup::global_ratio_binning[0]);
1355    ClearHisto(BpredSys);
1356      
1357 <  if(PlottingSetup::RestrictToMassPeak) {
1357 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
1358      Bpred->Add(RcorrJZBem,1.0/3.);
1359      Bpred->Add(LcorrJZBem,-1.0/3.);
1360      Bpred->Add(RcorrJZBSBem,1.0/3.);
# Line 997 | Line 1409 | void do_prediction_plot(string jzb, TCan
1409    flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak ---- prediction changed
1410    TH1F *Tpred = (TH1F*)RcorrJZBem->Clone("Bpred");
1411    Tpred->Add(LcorrJZBem,-1.0);
1412 <  if(PlottingSetup::RestrictToMassPeak) {
1412 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
1413      Tpred->Add(RcorrJZBSBem,1.0);
1414      Tpred->Add(LcorrJZBSBem,-1.0);
1415      Tpred->Add(RcorrJZBSBeemm,1.0);
# Line 1051 | Line 1463 | void do_prediction_plot(string jzb, TCan
1463      legBpred->AddEntry(Bpred,"predicted","l");
1464   //    legBpred->AddEntry(analytical_function[1],"predicted fit","l");
1465   //    legBpred->AddEntry(analytical_function[2],"stat. uncert.","l");
1466 <    legBpred->AddEntry(lm4RcorrJZBeemm,"LM4","l");
1466 >    legBpred->AddEntry(lm4RcorrJZBeemm,(allsamples.collection[allsamples.FindSample("LM")[0]].samplename).c_str(),"l");
1467      legBpred->Draw();
1468      DrawPrelim();
1469  
# Line 1090 | Line 1502 | void do_prediction_plot(string jzb, TCan
1502      speciallegBpred->AddEntry(RcorrJZBeemm,"Data","pl");
1503      speciallegBpred->AddEntry(Bpred,"Total background","l");
1504      speciallegBpred->AddEntry(jzbnegative,"JZB<0 (data)","f");
1505 <    speciallegBpred->AddEntry(sidebandsemu,"Sidebands/e#mu (data)","f");
1505 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) speciallegBpred->AddEntry(sidebandsemu,"Sidebands/e#mu (data)","f");
1506 >    else speciallegBpred->AddEntry(sidebandsemu,"e#mu (data)","f");
1507   //    speciallegBpred->AddEntry(lm4RcorrJZBeemmC,"LM4","l");
1508      speciallegBpred->AddEntry(lm4RcorrJZBeemm,"LM4","l");
1509      speciallegBpred->Draw();
1510      save_with_ratio(JRcorrJZBeemm,JBpred,predcomppad,subdir+"Bpred_Data_____PredictionComposition",true,true,"data/pred",BpredSys);
1511      
1512      TCanvas *specialcanv = new TCanvas("specialcanv","specialcanv");
1513 <    THStack kostack = allsamples.DrawStack("RcorrJZBeemm",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,!is_data, luminosity,use_signal);
1513 >    specialcanv->SetLogy(1);
1514 > //    THStack kostack = allsamples.DrawStack("RcorrJZBeemm",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,!is_data, luminosity,use_signal);
1515      blankback->Draw();
1516 <    kostack.Draw("same");
1516 > //    kostack.Draw("same");
1517 >    predcomposition.Draw();
1518      Bpred->Draw("hist,same");
1519 <    analytical_function[0]->Draw("same"); analytical_function[1]->Draw("same");analytical_function[2]->Draw("same");
1519 >    //analytical_function[0]->Draw("same"); analytical_function[1]->Draw("same");analytical_function[2]->Draw("same");
1520      RcorrJZBeemm->Draw("e1x0,same");//HAVE IT ON TOP!
1521      legBpred->Draw();
1522      DrawPrelim();
1523      CompleteSave(specialcanv,subdir+"Bpred_Data_____PredictionCompositioninMC");
1524      Bpred->SetLineWidth((int)CurrentBpredLineWidth);
1525      
1526 +    
1527 +    //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;
1528 +    
1529      delete speciallegBpred;
1530      delete Zjetspred;
1531      delete TTbarpred;
# Line 1172 | Line 1590 | void do_prediction_plot(string jzb, TCan
1590    string ytitle("ratio");
1591    if ( use_data==1 ) ytitle = "data/pred";
1592    //save_with_ratio(JRcorrJZBeemm,JBpred,kinpad,Bpredsaveas,true,use_data!=1,ytitle);
1593 <  save_with_ratio(JRcorrJZBeemm,JBpred,kinpad,subdir+Bpredsaveas,true,true,ytitle,BpredSys);//not extending the y range anymore up to 4
1593 >  save_with_ratio(JRcorrJZBeemm,JBpred,kinpad,subdir+Bpredsaveas,true,false,ytitle,BpredSys);//not extending the y range anymore up to 4
1594  
1595    
1596    flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak
1597    // The part below is meaningless for the offpeak analysis (it's a comparison of the different estimates but there is but one estimate!)
1598 <  if(PlottingSetup::RestrictToMassPeak) {
1598 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
1599      TH1F *Bpredem = (TH1F*)LcorrJZBeemm->Clone("Bpredem");
1600      Bpredem->Add(RcorrJZBem);
1601      Bpredem->Add(LcorrJZBem,-1);
# Line 1238 | Line 1656 | void do_prediction_plot(string jzb, TCan
1656      }
1657    }
1658    
1659 +  TFile *f = new TFile("tester.root","RECREATE");
1660 +  RcorrJZBeemm->Write();
1661 +  Bpred->Write();
1662 +  f->Close();
1663 +  
1664    delete RcorrJZBeemm;
1665    delete LcorrJZBeemm;
1666    delete RcorrJZBem;
# Line 1250 | Line 1673 | void do_prediction_plot(string jzb, TCan
1673  
1674    delete blankback;
1675    
1676 <  if(PlottingSetup::RestrictToMassPeak) {
1676 >  delete BpredSys;
1677 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
1678      delete RcorrJZBSBem;
1679      delete LcorrJZBSBem;
1680      delete RcorrJZBSBeemm;
# Line 1267 | Line 1691 | void do_prediction_plot(string jzb, TCan
1691  
1692   void do_prediction_plots(string mcjzb, string datajzb, float DataSigma, float MCSigma, bool overlay_signal ) {
1693    TCanvas *globalcanvas = new TCanvas("globalcanvas","Prediction Canvas");
1694 <  do_prediction_plot(datajzb,globalcanvas,DataSigma,jzbHigh ,data,overlay_signal);
1694 >  do_prediction_plot(datajzb,globalcanvas,jzbHigh ,data,overlay_signal);
1695    if ( !PlottingSetup::Approved ) {
1696 <    do_prediction_plot(mcjzb,globalcanvas,MCSigma,jzbHigh ,mc,overlay_signal);
1697 <    do_prediction_plot(mcjzb,globalcanvas,MCSigma,jzbHigh ,mcwithsignal,overlay_signal);
1696 >    do_prediction_plot(mcjzb,globalcanvas,jzbHigh ,mc,overlay_signal);
1697 >    do_prediction_plot(mcjzb,globalcanvas,jzbHigh ,mcwithsignal,overlay_signal);
1698    } else {
1699      write_info(__FUNCTION__,"You set approved to true, therefore not producing prediction/observation plots for MC with and without signal.");
1700    }
# Line 1291 | Line 1715 | void do_ratio_plot(int is_data,vector<fl
1715    TH1F *RcorrJZBSBeemm;
1716    TH1F *LcorrJZBSbeemm;
1717    
1718 <  if(PlottingSetup::RestrictToMassPeak) {
1718 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
1719      RcorrJZBSBem   = allsamples.Draw("RcorrJZBSbem",jzb.c_str(),binning, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,do_data, luminosity,dosignal);
1720      LcorrJZBSBem   = allsamples.Draw("LcorrJZBSbem",("-"+jzb).c_str(),binning, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,do_data, luminosity,dosignal);
1721      RcorrJZBSBeemm = allsamples.Draw("RcorrJZBSbeemm",jzb.c_str(),binning, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets,do_data, luminosity,dosignal);
# Line 1303 | Line 1727 | void do_ratio_plot(int is_data,vector<fl
1727  
1728    flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak
1729    TH1F *Bpred = (TH1F*)LcorrJZBeemm->Clone("Bpred");
1730 <  if(PlottingSetup::RestrictToMassPeak) {
1730 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
1731      Bpred->Add(RcorrJZBem,1.0/3);
1732      Bpred->Add(LcorrJZBem,-1.0/3);
1733      Bpred->Add(RcorrJZBSBem,1.0/3);
# Line 1610 | Line 2034 | void draw_pure_jzb_histo(TCut cut,string
2034    datahisto->Draw("same,e1");
2035    
2036    TLegend *leg;
2037 <  if(is_OF(cut) && is_ZP(cut)) leg = allsamples.allbglegend("OFZP",datahisto);
2038 <  else if(!is_OF(cut) &&  is_ZP(cut)) leg = allsamples.allbglegend("SFZP",datahisto);
2039 <  else if( is_OF(cut) && !is_ZP(cut)) leg = allsamples.allbglegend("OFSB",datahisto);
2040 <  else if(!is_OF(cut) && !is_ZP(cut)) leg = allsamples.allbglegend("SFSB",datahisto);
2041 <  else {
2042 <    std::cerr << "Unable to decode cut: " << cut.GetTitle() << std::endl;
2043 <    exit(-1);
2044 <      }
2037 >  if (!PlottingSetup::RestrictToMassPeak||!PlottingSetup::UseSidebandsForcJZB) {
2038 >    if(is_OF(cut)) leg = allsamples.allbglegend("Opposite flavor",datahisto);
2039 >    else leg = allsamples.allbglegend("Same flavor",datahisto);
2040 >  } else {
2041 >    if(is_OF(cut) && is_ZP(cut)) leg = allsamples.allbglegend("OFZP",datahisto);
2042 >    else if(!is_OF(cut) &&  is_ZP(cut)) leg = allsamples.allbglegend("SFZP",datahisto);
2043 >    else if( is_OF(cut) && !is_ZP(cut)) leg = allsamples.allbglegend("OFSB",datahisto);
2044 >    else if(!is_OF(cut) && !is_ZP(cut)) leg = allsamples.allbglegend("SFSB",datahisto);
2045 >    else {
2046 >      std::cerr << "Unable to decode cut: " << cut.GetTitle() << std::endl;
2047 >      exit(-1);
2048 >    }
2049 >  }
2050    leg->Draw();
2051    string write_cut = decipher_cut(cut,"");
2052    TText *writeline1 = write_cut_on_canvas(write_cut.c_str());
# Line 1668 | Line 2097 | void produce_stretched_jzb_plots(string
2097    draw_pure_jzb_histo(cutOSSF&&cutnJets&&cutmass&&"id1==1",datajzb,mcjzb,"Dibosons/mm/jzb_OS_SFZP",dican,binning);
2098    draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass&&"id1==0",datajzb,mcjzb,"Dibosons/ee/jzb_OS_OFZP",dican,binning);
2099    draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass&&"id1==1",datajzb,mcjzb,"Dibosons/mm/jzb_OS_OFZP",dican,binning);
2100 <  if(PlottingSetup::RestrictToMassPeak) draw_pure_jzb_histo(cutOSSF&&cutnJets&&sidebandcut,datajzb,mcjzb,"Dibosons/jzb_OS_SFSB",dican,binning);
2101 <  if(PlottingSetup::RestrictToMassPeak) draw_pure_jzb_histo(cutOSOF&&cutnJets&&sidebandcut,datajzb,mcjzb,"Dibosons/jzb_OS_OFSB",dican,binning);
2100 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) draw_pure_jzb_histo(cutOSSF&&cutnJets&&sidebandcut,datajzb,mcjzb,"Dibosons/jzb_OS_SFSB",dican,binning);
2101 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) draw_pure_jzb_histo(cutOSOF&&cutnJets&&sidebandcut,datajzb,mcjzb,"Dibosons/jzb_OS_OFSB",dican,binning);
2102    
2103    draw_pure_jzb_histo(cutOSSF&&cutnJets&&cutmass,datajzb,mcjzb,"Dibosons/jzb_OS_SFZP_coarse",dican,coarse_binning);
2104    draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass,datajzb,mcjzb,"Dibosons/jzb_OS_OFZP_coarse",dican,coarse_binning);
2105 <  if(PlottingSetup::RestrictToMassPeak) draw_pure_jzb_histo(cutOSSF&&cutnJets&&sidebandcut,datajzb,mcjzb,"Dibosons/jzb_OS_SFSB_coarse",dican,coarse_binning);
2106 <  if(PlottingSetup::RestrictToMassPeak) draw_pure_jzb_histo(cutOSOF&&cutnJets&&sidebandcut,datajzb,mcjzb,"Dibosons/jzb_OS_OFSB_coarse",dican,coarse_binning);
2105 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) draw_pure_jzb_histo(cutOSSF&&cutnJets&&sidebandcut,datajzb,mcjzb,"Dibosons/jzb_OS_SFSB_coarse",dican,coarse_binning);
2106 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) draw_pure_jzb_histo(cutOSOF&&cutnJets&&sidebandcut,datajzb,mcjzb,"Dibosons/jzb_OS_OFSB_coarse",dican,coarse_binning);
2107    
2108    delete dican;
2109   }
# Line 1705 | Line 2134 | void diboson_plots(string mcjzb, string
2134    dout << "Going to produce JZB plots" << endl;
2135    produce_stretched_jzb_plots(mcjzb,datajzb,ratio_binning);
2136    TCanvas *gloca = new TCanvas("gloca","gloca");
1708 –  float sigma=123456;
2137    
2138    dout << "Going to produce prediction plots" << endl;
2139 <  do_prediction_plot(mcjzb, gloca, sigma, PlottingSetup::jzbHigh, 0, false,"Dibosons/Bpred/" ); // do only MC plots, no signal
2140 <  do_prediction_plot(mcjzb, gloca, sigma, PlottingSetup::jzbHigh, 0, false,"Dibosons/Bpred/" ); // do MC plots with signal
2139 >  do_prediction_plot(mcjzb, gloca, PlottingSetup::jzbHigh, 0, false,"Dibosons/Bpred/" ); // do only MC plots, no signal
2140 >  do_prediction_plot(mcjzb, gloca, PlottingSetup::jzbHigh, 0, false,"Dibosons/Bpred/" ); // do MC plots with signal
2141    delete gloca;
2142  
2143    dout << "Going to reset the cross section for diboson samples ... " << endl;
# Line 1723 | Line 2151 | void diboson_plots(string mcjzb, string
2151    }
2152    
2153   }
2154 +
2155 +
2156 + void draw_normalized_data_vs_data_histo(TCut cut1, TCut cut2, string variable, string legentry1, string legentry2, string savename, TCanvas *can,vector<float> binning) {
2157 +  TPad *jzbpad = new TPad("jzbpad","jzbpad",0,0,1,1);
2158 +  jzbpad->cd();
2159 +  jzbpad->SetLogy(1);
2160 +  string xlabel="JZB [GeV]";
2161 +
2162 +  TH1F *datahisto1 = allsamples.Draw("datahisto1",variable,binning, xlabel, "events",cut1,data,luminosity);
2163 +  datahisto1->SetLineColor(kRed);
2164 +  datahisto1->SetMarkerColor(kRed);
2165 +  TH1F *datahisto2 = allsamples.Draw("datahisto2",variable,binning, xlabel, "events",cut2,data,luminosity);
2166 +  datahisto2->SetLineColor(kBlue);
2167 +  datahisto2->SetMarkerColor(kBlue);
2168 +  
2169 +  datahisto2->SetMarkerSize(DataMarkerSize);
2170 +  datahisto1->DrawNormalized("e1");
2171 +  datahisto2->DrawNormalized("histo,same");
2172 +  datahisto1->DrawNormalized("same,e1");
2173 +  
2174 +  TLegend *leg = make_legend();
2175 +  leg->AddEntry(datahisto1,legentry1.c_str());
2176 +  leg->AddEntry(datahisto2,legentry2.c_str());
2177 +  leg->Draw();
2178 +  
2179 +  save_with_ratio(datahisto1,datahisto2,jzbpad->cd(),("jzb/"+savename));
2180 +  
2181 +  datahisto1->Delete();
2182 +  datahisto2->Delete();
2183 + }
2184 +
2185 +
2186   void jzb_plots(string mcjzb, string datajzb,vector<float> ratio_binning) {
2187    TCanvas *can = new TCanvas("can","JZB Plots Canvas");
2188    float max=jzbHigh ;
# Line 1744 | Line 2204 | void jzb_plots(string mcjzb, string data
2204      draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass&&"id1==0",datajzb,mcjzb,"ee/jzb_OS_OFZP",can,binning);
2205      draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass&&"id1==1",datajzb,mcjzb,"mm/jzb_OS_OFZP",can,binning);
2206      flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak
2207 <    if(PlottingSetup::RestrictToMassPeak) draw_pure_jzb_histo(cutOSSF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_SFSB",can,binning);
2208 <    if(PlottingSetup::RestrictToMassPeak) draw_pure_jzb_histo(cutOSOF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_OFSB",can,binning);
2207 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) draw_pure_jzb_histo(cutOSSF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_SFSB",can,binning);
2208 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) draw_pure_jzb_histo(cutOSOF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_OFSB",can,binning);
2209 >    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);
2210 >    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);
2211 >    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);
2212 >
2213    }
2214    
2215    draw_pure_jzb_histo(cutOSSF&&cutnJets&&cutmass,datajzb,mcjzb,"jzb_OS_SFZP_coarse",can,coarse_binning);
2216    if ( !PlottingSetup::Approved ) {
2217      draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass,datajzb,mcjzb,"jzb_OS_OFZP_coarse",can,coarse_binning);
2218      flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak
2219 <    if(PlottingSetup::RestrictToMassPeak) draw_pure_jzb_histo(cutOSSF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_SFSB_coarse",can,coarse_binning);
2220 <    if(PlottingSetup::RestrictToMassPeak) draw_pure_jzb_histo(cutOSOF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_OFSB_coarse",can,coarse_binning);
2219 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) draw_pure_jzb_histo(cutOSSF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_SFSB_coarse",can,coarse_binning);
2220 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) draw_pure_jzb_histo(cutOSOF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_OFSB_coarse",can,coarse_binning);
2221    }
2222    delete can;
2223   }
# Line 1805 | Line 2269 | void compute_MC_yields(string mcjzb,vect
2269    TCanvas *yica = new TCanvas("yica","yield canvas");
2270    
2271    int nRegions=4;
2272 <  if(!PlottingSetup::RestrictToMassPeak) nRegions=2;
2272 >  if(!PlottingSetup::RestrictToMassPeak||!PlottingSetup::UseSidebandsForcJZB) nRegions=2;
2273    string tsRegions[] = {"SFZP","OFZP","SFSB","OFSB"};
2274    string posneg[] = {"pos","neg"};
2275    TCut tkRegions[] = {cutOSSF&&cutnJets&&cutmass,cutOSOF&&cutnJets&&cutmass,cutOSSF&&cutnJets&&sidebandcut,cutOSOF&&cutnJets&&sidebandcut};
# Line 2092 | Line 2556 | void draw_ttbar_and_zjets_shape(string m
2556    draw_ttbar_and_zjets_shape_for_one_configuration(mcjzb,datajzb,all_leptons,threejetswith30gev,true);
2557   }
2558  
2559 < float find_one_correction_factor(string FindKeyword, TCut SpecialCut, string SaveAs) {
2559 > float find_one_correction_factor(string FindKeyword, bool dodata, TCut SpecialCut, string SaveAs) {
2560    TCanvas *cancorr = new TCanvas("cancorr","Canvas for Response Correction");
2561    cancorr->SetLogz();
2562    cancorr->SetRightMargin(0.13);
2563 <  TCut zptforresponsepresentation("pt<600"&&cutmass&&cutOSSF&&"((sumJetPt[1]/pt)<5.0)"&&SpecialCut);
2563 >  TCut zptforresponsepresentation(Restrmasscut&&SpecialCut&&passtrig);
2564 >
2565    if(PlottingSetup::DoBTag) zptforresponsepresentation=zptforresponsepresentation&&PlottingSetup::bTagRequirement;
2566    TH2F *niceresponseplotd = new TH2F("niceresponseplotd","",100,0,600,100,0,5);
2567 +  niceresponseplotd->Sumw2();
2568 +  TH2F* emuResponse = (TH2F*)niceresponseplotd->Clone("emuResponse");
2569    vector<int> SampleIndices=allsamples.FindSample(FindKeyword);
2570 <  for(int iSample=0;iSample<SampleIndices.size();iSample++) {
2571 <    dout << "   Response correction : Using sample " << (allsamples.collection)[SampleIndices[iSample]].filename << endl;
2572 <    (allsamples.collection)[SampleIndices[iSample]].events->Draw("sumJetPt[1]/pt:pt>>+niceresponseplotd",zptforresponsepresentation*cutWeight);
2570 >  for(int iSample=0;iSample<(int)SampleIndices.size();iSample++) {
2571 >    if((allsamples.collection)[SampleIndices[iSample]].is_data && !dodata) continue;
2572 >    if((allsamples.collection)[SampleIndices[iSample]].is_data ==false && dodata) continue;
2573 >    
2574 >    dout << "   Response correction : Using sample " << (allsamples.collection)[SampleIndices[iSample]].filename << " for " << FindKeyword << endl;
2575 >    (allsamples.collection)[SampleIndices[iSample]].events->Draw("sumJetPt[1]/pt:pt>>+niceresponseplotd",(zptforresponsepresentation&&cutOSSF)*cutWeight);
2576 >    (allsamples.collection)[SampleIndices[iSample]].events->Draw("sumJetPt[1]/pt:pt>>+emuResponse",(zptforresponsepresentation&&cutOSOF)*cutWeight);
2577    }
2578 <    
2578 >  niceresponseplotd->Add(emuResponse,-1);
2579 >  
2580    niceresponseplotd->SetStats(0);
2581    niceresponseplotd->GetXaxis()->SetTitle("Z p_{T} [GeV]");
2582    niceresponseplotd->GetYaxis()->SetTitle("Response");
# Line 2112 | Line 2584 | float find_one_correction_factor(string
2584    niceresponseplotd->GetYaxis()->CenterTitle();
2585    niceresponseplotd->Draw("COLZ");
2586    TProfile * profd = (TProfile*)niceresponseplotd->ProfileX();
2587 +  profd->Rebin(2);
2588    profd->SetMarkerSize(DataMarkerSize);
2589    profd->Fit("pol0","","same,e1",100,400);
2590    DrawPrelim();
# Line 2131 | Line 2604 | float find_one_correction_factor(string
2604    CompleteSave(cancorr,"ResponseCorrection/Response_Correction_Illustration_New_"+SaveAs);
2605    delete cancorr;
2606    delete niceresponseplotd;
2607 +  delete profd;
2608    return correction;
2609   }
2610  
2611   void find_correction_factors(string &jzbvardata,string &jzbvarmc) {
2612    
2613 +  dout << "Computing response corrections: " << endl;
2614    //Step 1 : Get results
2615 <  float datacorrection=find_one_correction_factor("Data","","Data");
2616 <  float mccorrection=find_one_correction_factor("DY","","MC");
2615 >  float datacorrection=find_one_correction_factor("Data",true,"","Data");
2616 >  float mccorrection=find_one_correction_factor("DY",false,"","MC");
2617    
2618 <  float dataEEcorrection=find_one_correction_factor("Data","id1==0","Data_ee");
2619 <  float mcEEcorrection=find_one_correction_factor("DY","id1==0","MC_ee");
2618 >  float dataEEcorrection=find_one_correction_factor("Data",true,"id1==0","Data_ee");
2619 >  float mcEEcorrection=find_one_correction_factor("DY",false,"id1==0","MC_ee");
2620    
2621 <  float dataMMcorrection=find_one_correction_factor("Data","id1==1","Data_mm");
2622 <  float mcMMcorrection=find_one_correction_factor("DY","id1==1","MC_mm");
2621 >  float dataMMcorrection=find_one_correction_factor("Data",true,"id1==1","Data_mm");
2622 >  float mcMMcorrection=find_one_correction_factor("DY",false,"id1==1","MC_mm");
2623    
2624    cout << "Corrections : " << endl;
2625    cout << "   Data : " << datacorrection << endl;
# Line 2152 | Line 2627 | void find_correction_factors(string &jzb
2627    cout << "   MC : " << mccorrection << endl;
2628    cout << "     ee (" << mcEEcorrection << ") , mm (" << mcMMcorrection << ")" << endl;
2629    
2155 –  cout << "        result from new one for data: " << 0.937097 << endl;
2156 –  cout << "        result from old one for data: " << 0.937097 << endl;
2157 –  cout << "        result from new one for MC: " << 0.96848 << endl;
2158 –  cout << "        result from old one for MC: " << 0.963502 << endl;
2159 –  
2160 –  
2630    //Step 2: Processing the result and making it into something useful :-)
2631    stringstream jzbvardatas;
2632    jzbvardatas << "(";
# Line 2170 | Line 2639 | void find_correction_factors(string &jzb
2639    
2640    float averagecorrection=(dataMMcorrection+dataEEcorrection)/2.0;
2641    
2642 <  if(averagecorrection>1) jzbvardatas<<"+((id1!=id2)*(jzb[1]-" << averagecorrection-1 << "*pt))";
2643 <  if(averagecorrection<1) jzbvardatas<<"+((id1!=id2)*(jzb[1]-" << 1-averagecorrection << "*pt))";
2642 >  if(datacorrection>=1) jzbvardatas<<"+((id1!=id2)*(jzb[1]-" << datacorrection-1 << "*pt))";
2643 >  if(datacorrection<1) jzbvardatas<<"+((id1!=id2)*(jzb[1]+" << 1-datacorrection << "*pt))";
2644    
2645    jzbvardatas << ")";
2646    jzbvardata=jzbvardatas.str();
# Line 2187 | Line 2656 | void find_correction_factors(string &jzb
2656    
2657    float averagemccorrection=(mcMMcorrection+mcEEcorrection)/2.0;
2658    
2659 <  if(averagemccorrection>1) jzbvarmcs<<"+((id1!=id2)*(jzb[1]-" << averagemccorrection-1 << "*pt))";
2660 <  if(averagemccorrection<1) jzbvarmcs<<"+((id1!=id2)*(jzb[1]-" << 1-averagemccorrection << "*pt))";
2659 >  if(mccorrection>=1) jzbvarmcs<<"+((id1!=id2)*(jzb[1]-" << mccorrection-1 << "*pt))";
2660 >  if(mccorrection<1) jzbvarmcs<<"+((id1!=id2)*(jzb[1]+" << 1-mccorrection << "*pt))";
2661    
2662    jzbvarmcs << ")";
2663    jzbvarmc=jzbvarmcs.str();
# Line 2248 | Line 2717 | void save_template(string mcjzb, string
2717    configfile<<"\n\n";
2718    configfile<<"luminosity="<<luminosity<<";\n";
2719    configfile<<"RestrictToMassPeak="<<RestrictToMassPeak<<";//defines the type of analysis we're running\n";
2720 +  configfile<<"UseSidebandsForcJZB="<<UseSidebandsForcJZB<<";//tells us whether to use the sidebands or not\n";
2721    
2722    configfile<<"\n\ncout << \"Configuration successfully loaded!\" << endl; \n \n } \n \n";
2723    
# Line 2290 | Line 2760 | void ttbar_sidebands_comparison(string m
2760    //in the case of the on peak analysis, we compare the 3 control regions to the real value
2761    //in the case of the OFF peak analysis, we compare our control region to the real value
2762    TCut weightbackup=cutWeight;
2293 – //  cutWeight="1.0";
2294 –  float simulatedlumi = luminosity; //in pb please - adjust to your likings
2763    
2764 +  bool doPURW=false;
2765 +  
2766 +  
2767 +  if(!doPURW) {
2768 +    dout << "Not doing PU reweighting for ttbar closure test" << endl;
2769 +    cutWeight="1.0";
2770 +    // Do it without PU re-weighting
2771 +    float MCPeakNoPU=0,MCPeakErrorNoPU=0,DataPeakNoPU=0,DataPeakErrorNoPU=0,MCSigma=0,DataSigma=0;
2772 +    stringstream resultsNoPU;
2773 +    stringstream noPUdatajzb;
2774 +    stringstream noPUmcjzb;
2775 +    
2776 +    stringstream mcjzbnoPU;
2777 +    find_peaks(MCPeakNoPU,MCPeakErrorNoPU, DataPeakNoPU, DataPeakErrorNoPU,resultsNoPU,true,noPUdatajzb,noPUmcjzb);
2778 +    mcjzb = noPUmcjzb.str();
2779 +  }
2780  
2781 <  TH1F *TZem = systsamples.Draw("TZem",mcjzb,binning,"JZB [GeV]","events",cutmass&&cutOSOF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTJets"));
2781 >      
2782 >  float simulatedlumi = luminosity; //in pb please - adjust to your likings
2783 >
2784 >  TH1F *TZem  = systsamples.Draw("TZem",     mcjzb,binning,"JZB [GeV]","events",cutmass&&cutOSOF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTJets"));
2785    TH1F *nTZem = systsamples.Draw("nTZem","-"+mcjzb,binning,"JZB [GeV]","events",cutmass&&cutOSOF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTJets"));
2786    TH1F *TSem;
2787    TH1F *nTSem;
2788 <  TH1F *TZeemm = systsamples.Draw("TZeemm",mcjzb,binning,"JZB [GeV]","events",cutmass&&cutOSSF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTJets"));
2788 >  TH1F *TZeemm  = systsamples.Draw("TZeemm",     mcjzb,binning,"JZB [GeV]","events",cutmass&&cutOSSF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTJets"));
2789    TH1F *nTZeemm = systsamples.Draw("nTZeemm","-"+mcjzb,binning,"JZB [GeV]","events",cutmass&&cutOSSF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTJets"));
2790    TH1F *TSeemm;
2791    TH1F *nTSeemm;
2792    
2793 <  if(PlottingSetup::RestrictToMassPeak) {
2794 <    TSem = systsamples.Draw("TSem",mcjzb,binning,"JZB [GeV]","events",sidebandcut&&cutOSOF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTJets"));
2795 <    nTSem = systsamples.Draw("nTSem","-"+mcjzb,binning,"JZB [GeV]","events",sidebandcut&&cutOSOF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTJets"));
2796 <    TSeemm = systsamples.Draw("TSeemm",mcjzb,binning,"JZB [GeV]","events",sidebandcut&&cutOSSF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTJets"));
2793 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2794 >    TSem    = systsamples.Draw("TSem",       mcjzb,binning,"JZB [GeV]","events",sidebandcut&&cutOSOF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTJets"));
2795 >    nTSem   = systsamples.Draw("nTSem",  "-"+mcjzb,binning,"JZB [GeV]","events",sidebandcut&&cutOSOF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTJets"));
2796 >    TSeemm  = systsamples.Draw("TSeemm",     mcjzb,binning,"JZB [GeV]","events",sidebandcut&&cutOSSF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTJets"));
2797      nTSeemm = systsamples.Draw("nTSeemm","-"+mcjzb,binning,"JZB [GeV]","events",sidebandcut&&cutOSSF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTJets"));
2798    }
2799  
2800    TCanvas *tcan = new TCanvas("tcan","tcan");
2314 –  
2801    tcan->SetLogy(1);
2802    
2803    TZeemm->SetLineColor(kBlack);
# Line 2320 | Line 2806 | void ttbar_sidebands_comparison(string m
2806    TZem->SetMarkerColor(kRed);
2807  
2808  
2809 <  if(PlottingSetup::RestrictToMassPeak) {
2809 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2810          TSem->SetLineColor(TColor::GetColor("#00A616"));
2811          TSeemm->SetLineColor(kMagenta+2);
2812          TSem->SetMarkerColor(TColor::GetColor("#00A616"));
# Line 2330 | Line 2816 | void ttbar_sidebands_comparison(string m
2816    }
2817    
2818    vector<TH1F*> histos;
2819 +  TZem->GetXaxis()->SetRangeUser(-100,binning[binning.size()-1]);
2820 +  TZeemm->GetXaxis()->SetRangeUser(-100,binning[binning.size()-1]);
2821    histos.push_back(TZem);
2822    histos.push_back(TZeemm);
2823 <  if(PlottingSetup::RestrictToMassPeak) {
2823 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2824 >    TSeemm->GetXaxis()->SetRangeUser(-100,binning[binning.size()-1]);
2825 >    TSem->GetXaxis()->SetRangeUser(-100,binning[binning.size()-1]);
2826      histos.push_back(TSem);
2827      histos.push_back(TSeemm);
2828    }
2829 <  draw_all_ttbar_histos(tcan,histos,"histo",0.04);
2829 >  draw_all_ttbar_histos(tcan,histos,"histo",1);
2830    
2831    TLegend *leg = make_legend("MC t#bar{t}",0.6,0.65,false);
2832    leg->AddEntry(TZeemm,"SFZP","l");
2833    leg->AddEntry(TZem,"OFZP","l");
2834 <  if(PlottingSetup::RestrictToMassPeak) {
2834 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2835      leg->AddEntry(TSeemm,"SFSB","l");
2836      leg->AddEntry(TSem,"OFSB","l");
2837    }
# Line 2352 | Line 2842 | void ttbar_sidebands_comparison(string m
2842    TH1F *TZeemmcopy = (TH1F*)TZeemm->Clone("TZeemmcopy");
2843    TH1F *TSeemmcopy;
2844    TH1F *TSemcopy;
2845 <  if(PlottingSetup::RestrictToMassPeak) {
2845 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2846      TSeemmcopy = (TH1F*)TSeemm->Clone("TSeemmcopy");
2847      TSemcopy = (TH1F*)TSem->Clone("TSemcopy");
2848    }
2849  
2850    TZem->Divide(TZeemm);
2851    TZem->SetMarkerStyle(21);
2852 <  if(PlottingSetup::RestrictToMassPeak) {
2852 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2853      TSem->Divide(TZeemm);
2854      TSeemm->Divide(TZeemm);
2855      TSem->SetMarkerStyle(24);
2856      TSeemm->SetMarkerStyle(32);
2857 < }
2857 >  }
2858  
2859    tcan->SetLogy(0);
2860    TZem->GetYaxis()->SetRangeUser(0,2.5);
2861    TZem->GetYaxis()->SetTitle("ratio");
2862    TZem->Draw();
2863 <  if(PlottingSetup::RestrictToMassPeak) {
2863 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2864      TSem->Draw("same");
2865      TSeemm->Draw("same");
2866    }
2867    
2868 <  float linepos=0.25;
2869 <  if(PlottingSetup::RestrictToMassPeak) linepos=0.25;
2870 <  if(!PlottingSetup::RestrictToMassPeak) linepos=0.1; //sys uncertainty for iJZB
2868 >  float linepos=emuncertONPEAK;
2869 >  if(!PlottingSetup::RestrictToMassPeak) linepos=emuncertOFFPEAK;
2870 >  
2871    TLine *top = new TLine(binning[0],1.0+linepos,binning[binning.size()-1],1.0+linepos);
2872    TLine *center = new TLine(binning[0],1.0,binning[binning.size()-1],1.0);
2873    TLine *bottom = new TLine(binning[0],1.0-linepos,binning[binning.size()-1],1.0-linepos);
# Line 2400 | Line 2890 | void ttbar_sidebands_comparison(string m
2890    
2891    TLegend *leg2 = make_legend("MC t#bar{t}",0.55,0.75,false);
2892    leg2->AddEntry(TZem,"OFZP / SFZP","ple");
2893 <  if(PlottingSetup::RestrictToMassPeak) {
2893 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2894      leg2->AddEntry(TSeemm,"SFSB / SFZP","ple");
2895      leg2->AddEntry(TSem,"OFSB / SFZP","ple");
2896    }
# Line 2413 | Line 2903 | void ttbar_sidebands_comparison(string m
2903    DrawMCPrelim(simulatedlumi);
2904    CompleteSave(tcan,"Systematics/"+prestring+"/ttbar_shape_comparison_ratio");
2905    
2906 +  if (0) { // Turn this off: we don't need this
2907  
2908 < ///-------------- second part: only look at the quantity we actually care about!
2909 <  TH1F *leftsfzp  = (TH1F*)nTZeemm->Clone("leftsfzp");
2910 <  TH1F *rightsfzp = (TH1F*)TZeemmcopy->Clone("rightsfzp");
2911 <  rightsfzp->Add(leftsfzp,-1);
2912 <  TH1F *leftofzp  = (TH1F*)nTZem->Clone("leftofzp");
2913 <  TH1F *rightofzp = (TH1F*)TZemcopy->Clone("rightofzp");
2914 <  rightofzp->Add(leftofzp,-1);
2915 <  TH1F *leftofsb;
2916 <  TH1F *rightofsb;
2917 <  TH1F *leftsfsb;
2918 <  TH1F *rightsfsb;
2919 <  if(PlottingSetup::RestrictToMassPeak) {
2920 <        leftofsb  = (TH1F*)nTSem->Clone("leftofsb");
2921 <        rightofsb = (TH1F*)TSemcopy->Clone("rightofsb");
2922 <        rightofsb->Add(leftofsb,-1);
2923 <        leftsfsb  = (TH1F*)nTSeemm->Clone("leftsfsb");
2924 <        rightsfsb = (TH1F*)TSeemmcopy->Clone("rightsfsb");
2925 <        rightsfsb->Add(leftsfsb,-1);
2926 <  }
2908 >    ///-------------- second part: only look at the quantity we actually care about!
2909 >    TH1F *leftsfzp  = (TH1F*)nTZeemm->Clone("leftsfzp");
2910 >    TH1F *rightsfzp = (TH1F*)TZeemmcopy->Clone("rightsfzp");
2911 >    rightsfzp->Add(leftsfzp,-1);
2912 >    TH1F *leftofzp  = (TH1F*)nTZem->Clone("leftofzp");
2913 >    TH1F *rightofzp = (TH1F*)TZemcopy->Clone("rightofzp");
2914 >    rightofzp->Add(leftofzp,-1);
2915 >    TH1F *leftofsb;
2916 >    TH1F *rightofsb;
2917 >    TH1F *leftsfsb;
2918 >    TH1F *rightsfsb;
2919 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2920 >      leftofsb  = (TH1F*)nTSem->Clone("leftofsb");
2921 >      rightofsb = (TH1F*)TSemcopy->Clone("rightofsb");
2922 >      rightofsb->Add(leftofsb,-1);
2923 >      leftsfsb  = (TH1F*)nTSeemm->Clone("leftsfsb");
2924 >      rightsfsb = (TH1F*)TSeemmcopy->Clone("rightsfsb");
2925 >      rightsfsb->Add(leftsfsb,-1);
2926 >    }
2927  
2928 <  tcan->SetLogy(1);
2929 <  rightsfzp->GetXaxis()->SetRangeUser(0,binning[binning.size()-1]);
2930 <  rightsfzp->GetYaxis()->SetTitle("#deltaJZB / 25 GeV");
2931 <  rightsfzp->Draw("histo");
2932 <  rightofzp->Draw("histo,same");
2933 <  if(PlottingSetup::RestrictToMassPeak) {
2934 <    rightofsb->Draw("histo,same");
2935 <    rightsfsb->Draw("histo,same");
2936 <  }
2937 <  DrawMCPrelim(simulatedlumi);
2928 >    tcan->SetLogy(1);
2929 >    rightsfzp->GetXaxis()->SetRangeUser(0,binning[binning.size()-1]);
2930 >    rightsfzp->GetYaxis()->SetTitle("#deltaJZB / 25 GeV");
2931 >    rightsfzp->Draw("histo");
2932 >    rightofzp->Draw("histo,same");
2933 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2934 >      rightofsb->Draw("histo,same");
2935 >      rightsfsb->Draw("histo,same");
2936 >    }
2937 >    DrawMCPrelim(simulatedlumi);
2938  
2939 <  TLegend *legA = make_legend("MC t#bar{t}",0.6,0.65,false);
2940 <  legA->AddEntry(rightsfzp,"SFZP","l");
2941 <  legA->AddEntry(rightofzp,"OFZP","l");
2942 <  if(PlottingSetup::RestrictToMassPeak) {
2943 <    legA->AddEntry(rightofsb,"SFSB","l");
2944 <    legA->AddEntry(rightsfsb,"OFSB","l");
2945 <  }
2946 <  legA->Draw();
2939 >    TLegend *legA = make_legend("MC t#bar{t}",0.6,0.65,false);
2940 >    legA->AddEntry(rightsfzp,"SFZP","l");
2941 >    legA->AddEntry(rightofzp,"OFZP","l");
2942 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2943 >      legA->AddEntry(rightofsb,"SFSB","l");
2944 >      legA->AddEntry(rightsfsb,"OFSB","l");
2945 >    }
2946 >    legA->Draw();
2947  
2948 <  CompleteSave(tcan,"Systematics/"+prestring+"/ttbar_deltajzb_comparison");
2948 >    CompleteSave(tcan,"Systematics/"+prestring+"/ttbar_deltajzb_comparison");
2949  
2950 <  tcan->SetLogy(0);
2951 <  rightofzp->Divide(rightsfzp);
2952 <  rightofzp->GetXaxis()->SetRangeUser(0.0,binning[binning.size()-1]);
2953 <  rightofzp->GetYaxis()->SetRangeUser(0.0,2.0);
2954 <  rightofzp->GetYaxis()->SetTitle("#deltaJZB ratio");
2955 <  rightofzp->Draw();
2956 <  if(PlottingSetup::RestrictToMassPeak) {
2957 <    rightofsb->Divide(rightsfzp);
2958 <    rightsfsb->Divide(rightsfzp);
2959 <    rightofsb->Draw("same");
2960 <    rightsfsb->Draw("same");
2961 <  }
2962 <
2963 <  TLine *top2 = new TLine(0.0,1.0+linepos,binning[binning.size()-1],1.0+linepos);
2964 <  TLine *center2 = new TLine(0.0,1.0,binning[binning.size()-1],1.0);
2965 <  TLine *bottom2 = new TLine(0.0,1.0-linepos,binning[binning.size()-1],1.0-linepos);
2966 <  
2967 <  top2->SetLineColor(kBlue);top2->SetLineStyle(2);
2968 <  bottom2->SetLineColor(kBlue);bottom2->SetLineStyle(2);
2969 <  center2->SetLineColor(kBlue);
2970 <  
2971 <  top2->Draw("same");
2972 <  center2->Draw("same");
2973 <  bottom2->Draw("same");
2974 <
2975 <  rightofzp->SetMarkerStyle(21);
2976 <  if(PlottingSetup::RestrictToMassPeak) {
2977 <    rightofsb->SetMarkerStyle(24);
2978 <    rightsfsb->SetMarkerStyle(32);
2979 <  }
2980 <
2981 <  TLegend *leg3 = make_legend("MC t#bar{t}",0.55,0.75,false);
2982 <  leg3->AddEntry(rightofzp,"OFZP / SFZP","ple");
2983 <  if(PlottingSetup::RestrictToMassPeak) {
2984 <        leg3->AddEntry(rightsfsb,"SFSB / SFZP","ple");
2985 <        leg3->AddEntry(rightofsb,"OFSB / SFZP","ple");
2986 <  }
2987 <  leg3->AddEntry(bottom,"syst. envelope","l");
2988 <  leg3->SetX1(0.25);leg3->SetX2(0.6);
2989 <  leg3->SetY1(0.65);
2950 >    tcan->SetLogy(0);
2951 >    rightofzp->Divide(rightsfzp);
2952 >    rightofzp->GetXaxis()->SetRangeUser(0.0,binning[binning.size()-1]);
2953 >    rightofzp->GetYaxis()->SetRangeUser(0.0,2.5);
2954 >    rightofzp->GetYaxis()->SetTitle("#deltaJZB ratio");
2955 >    rightofzp->Draw();
2956 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2957 >      rightofsb->Divide(rightsfzp);
2958 >      rightsfsb->Divide(rightsfzp);
2959 >      rightofsb->Draw("same");
2960 >      rightsfsb->Draw("same");
2961 >    }
2962 >
2963 >    TLine *top2 = new TLine(0.0,1.0+linepos,binning[binning.size()-1],1.0+linepos);
2964 >    TLine *center2 = new TLine(0.0,1.0,binning[binning.size()-1],1.0);
2965 >    TLine *bottom2 = new TLine(0.0,1.0-linepos,binning[binning.size()-1],1.0-linepos);
2966 >  
2967 >    top2->SetLineColor(kBlue);top2->SetLineStyle(2);
2968 >    bottom2->SetLineColor(kBlue);bottom2->SetLineStyle(2);
2969 >    center2->SetLineColor(kBlue);
2970 >  
2971 >    top2->Draw("same");
2972 >    center2->Draw("same");
2973 >    bottom2->Draw("same");
2974 >
2975 >    rightofzp->SetMarkerStyle(21);
2976 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2977 >      rightofsb->SetMarkerStyle(24);
2978 >      rightsfsb->SetMarkerStyle(32);
2979 >    }
2980 >
2981 >    TLegend *leg3 = make_legend("MC t#bar{t}",0.55,0.75,false);
2982 >    leg3->AddEntry(rightofzp,"OFZP / SFZP","ple");
2983 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2984 >      leg3->AddEntry(rightsfsb,"SFSB / SFZP","ple");
2985 >      leg3->AddEntry(rightofsb,"OFSB / SFZP","ple");
2986 >    }
2987 >    leg3->AddEntry(bottom,"syst. envelope","l");
2988 >    leg3->SetX1(0.25);leg3->SetX2(0.6);
2989 >    leg3->SetY1(0.65);
2990    
2991 <  leg3->Draw("same");
2991 >    leg3->Draw("same");
2992    
2993 <  DrawMCPrelim(simulatedlumi);
2994 <  CompleteSave(tcan,"Systematics/"+prestring+"/ttbar_deltajzb_comparison_ratio");
2993 >    DrawMCPrelim(simulatedlumi);
2994 >    CompleteSave(tcan,"Systematics/"+prestring+"/ttbar_deltajzb_comparison_ratio");
2995 >
2996 >  }
2997  
2998    delete TZem;
2999    delete nTZem;
3000    delete TZeemm;
3001    delete nTZeemm;
3002 <  if(PlottingSetup::RestrictToMassPeak) {
3002 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
3003          delete TSem;
3004          delete nTSem;
3005          delete TSeemm;
# Line 2519 | Line 3012 | void ttbar_sidebands_comparison(string m
3012  
3013   void ttbar_sidebands_comparison(string mcjzb, vector<float> jzb_binning) {
3014    vector<float> nicer_binning;
3015 <  nicer_binning.push_back(-125);
3015 >  
3016 > /*  nicer_binning.push_back(-400);
3017 >  nicer_binning.push_back(-250);
3018 >  nicer_binning.push_back(-200);
3019 >  nicer_binning.push_back(-150);
3020 >  nicer_binning.push_back(-100);
3021 >  nicer_binning.push_back(-50);
3022 >  nicer_binning.push_back(-20);
3023 >  
3024 >  nicer_binning.push_back(0);
3025 >  nicer_binning.push_back(20);
3026 >  nicer_binning.push_back(50);
3027 >  nicer_binning.push_back(100);
3028 >  nicer_binning.push_back(150);
3029 >  nicer_binning.push_back(200);
3030 >  nicer_binning.push_back(250);
3031 >  nicer_binning.push_back(400);*/
3032 >  
3033    nicer_binning.push_back(-100);
2524 –  nicer_binning.push_back(-75);
3034    nicer_binning.push_back(-50);
3035    nicer_binning.push_back(-25);
3036    nicer_binning.push_back(0);
# Line 2531 | Line 3040 | void ttbar_sidebands_comparison(string m
3040    nicer_binning.push_back(100);
3041    nicer_binning.push_back(125);
3042    nicer_binning.push_back(150);
3043 <  nicer_binning.push_back(175);
3043 >  //nicer_binning.push_back(175);
3044    nicer_binning.push_back(200);
3045 <  nicer_binning.push_back(230);
3046 <  nicer_binning.push_back(280);
3045 >  nicer_binning.push_back(250);
3046 >  nicer_binning.push_back(300);
3047    nicer_binning.push_back(400);
3048 +  
3049    ttbar_sidebands_comparison(mcjzb,nicer_binning, "ttbar/");
3050   }
3051  
3052  
3053 < void zjets_prediction_comparison(string mcjzbWithPU) {
3053 > void zjets_prediction_comparison(string mcjzbWithPUa) {
3054    TCanvas *zcan = new TCanvas("zcan","zcan");  
3055 <  zcan->SetLogy(1);
3055 > //  zcan->SetLogy(1);
3056    TCut weightbackup=cutWeight;
3057 +  
3058 +  bool UsePURW=false;
3059 +  
3060 +  
3061 +  string mcjzb;
3062 +  if(UsePURW) {
3063 +    mcjzb=mcjzbWithPUa;
3064 +  } else {
3065 +    // Do it without PU re-weighting
3066 +    float MCPeakNoPU=0,MCPeakErrorNoPU=0,DataPeakNoPU=0,DataPeakErrorNoPU=0,MCSigma=0,DataSigma=0;
3067 +    stringstream resultsNoPU;
3068 +    stringstream noPUdatajzb;
3069 +    stringstream noPUmcjzb;
3070 +    
3071 +    find_peaks(MCPeakNoPU,MCPeakErrorNoPU, DataPeakNoPU, DataPeakErrorNoPU,resultsNoPU,false,noPUdatajzb,noPUmcjzb);
3072 +    dout << "The peak corrected JZB expression for MC without pileup is : " <<  noPUmcjzb.str() << endl;
3073 +    
3074 +    mcjzb = noPUmcjzb.str();
3075 +    
3076 +    cutWeight="1.0";
3077 +  }
3078  
2548 – /*
2549 –  // Do it without PU re-weighting
2550 –  float MCPeakNoPU=0,MCPeakErrorNoPU=0,DataPeakNoPU=0,DataPeakErrorNoPU=0,MCSigma=0,DataSigma=0;
2551 –  stringstream resultsNoPU;
2552 –
2553 –  stringstream mcjzbnoPU;
2554 –  find_peaks(MCPeakNoPU,MCPeakErrorNoPU, DataPeakNoPU, DataPeakErrorNoPU,MCSigma,DataSigma,resultsNoPU,true);
2555 –  if(MCPeakNoPU>0) mcjzbnoPU<<"("<<jzbvariablemc<<"-"<<TMath::Abs(MCPeakNoPU)<<")";
2556 –  else mcjzbnoPU<<"("<<jzbvariablemc<<"+"<<TMath::Abs(MCPeakNoPU)<<")";
2557 –
2558 –  string mcjzb = mcjzbnoPU.str();
2559 –  dout << "The peak corrected JZB expression for MC without pileup is : " <<  mcjzb << endl;
2560 –
2561 –  cutWeight="1.0";
2562 – */
2563 –  string mcjzb = mcjzbWithPU; // this is with PURW, if you want without it you have to uncomment the part above (and comment out this line)
3079    
3080    vector<float> binning;
3081    binning.push_back(0);
3082 +  binning.push_back(10);
3083    binning.push_back(20);
3084    binning.push_back(40);
3085    binning.push_back(60);
3086 <  binning.push_back(80);
3086 > //   binning.push_back(50);
3087 > //   binning.push_back(60);
3088 > //   binning.push_back(70);
3089 > //   binning.push_back(80);
3090 > //   binning.push_back(90);
3091    binning.push_back(100);
3092 < //  float sbg_min=0.;
2573 < //  float sbg_max=100.;
2574 < //  int sbg_nbins=5;
3092 >
3093    float simulatedlumi = luminosity;//in pb please - adjust to your likings
3094    
3095    TCut kPos((mcjzb+">0").c_str());
3096    TCut kNeg((mcjzb+"<0").c_str());
3097    string var( "abs("+mcjzb+")" );
3098 +  
3099 +  TCut notTau("abs(genMID1)!=15");
3100 +  TCut ONLYTau("mll>20");
3101 +  
3102  
3103 <  TCut kcut(cutmass&&cutOSSF&&cutnJets);
3104 <  TH1F *hJZBpos = systsamples.Draw("hJZBpos",var,binning, "JZB [GeV]", "events",kcut&&kPos,mc,simulatedlumi,systsamples.FindSample("/DY"));
3105 <  TH1F *hJZBneg = systsamples.Draw("hJZBneg",var,binning, "JZB [GeV]", "events",kcut&&kNeg,mc,simulatedlumi,systsamples.FindSample("/DY"));
3103 >  TH1F *hJZBpos = systsamples.Draw("hJZBpos",var,binning, "JZB [GeV]", "events",cutmass&&cutOSSF&&cutnJets&&notTau&&kPos,mc,simulatedlumi,systsamples.FindSample("/DY"));
3104 >  TH1F *hJZBneg = systsamples.Draw("hJZBneg",var,binning, "JZB [GeV]", "events",cutmass&&cutOSSF&&cutnJets&&notTau&&kNeg,mc,simulatedlumi,systsamples.FindSample("/DY"));
3105 >  
3106    hJZBpos->SetLineColor(kBlack);
3107    hJZBneg->SetLineColor(kRed);
3108    
# Line 2589 | Line 3111 | void zjets_prediction_comparison(string
3111    hJZBneg->Draw("same,hist");
3112    hJZBpos->Draw("same,e1"); // So it's on top...
3113    
3114 <  TLegend *leg = make_legend("MC Z+jets",0.55,0.75,false);
3114 >  TLegend *leg = make_legend("MC Z+jets #rightarrow ee,#mu#mu",0.55,0.75,false);
3115    leg->AddEntry(hJZBpos,"Observed","pe");
3116    leg->AddEntry(hJZBneg,"Predicted","l");
3117    leg->Draw("same");
3118    DrawMCPrelim(simulatedlumi);
3119 <  CompleteSave(zcan,"Systematics/zjets_prediction");
3119 >  CompleteSave(zcan,"Systematics/ZJets/zjets_eemm_prediction");
3120    
3121    TH1F* hratio = (TH1F*)hJZBpos->Clone("hratio");
3122    hratio->Divide(hJZBneg);
3123    
3124 +  for(int i=1;i<=hJZBpos->GetNbinsX();i++) {
3125 +    cout << "Positive: " << hJZBpos->GetBinContent(i) << "   vs    Negative : " << hJZBneg->GetBinContent(i) << "   (ratio : " << hJZBpos->GetBinContent(i) / hJZBneg->GetBinContent(i) << endl;
3126 +  }
3127 +  
3128    zcan->SetLogy(0);
3129 <  hratio->GetYaxis()->SetRangeUser(0,2.5);
3129 >  hratio->GetYaxis()->SetRangeUser(0,2.0);
3130    hratio->GetYaxis()->SetTitle("Observed/Predicted");
3131    hratio->Draw("e1");
3132    
# Line 2617 | Line 3143 | void zjets_prediction_comparison(string
3143    center->Draw("same");
3144    bottom->Draw("same");
3145    
3146 <  TLegend *leg2 = make_legend("MC Z+jets",0.25,0.75,false);
3146 >  TLegend *leg2 = make_legend("MC Z+jets #rightarrow ee,#mu#mu",0.25,0.75,false);
3147    leg2->AddEntry(hratio,"obs / pred","pe");
3148    leg2->AddEntry(bottom,"syst. envelope","l");
3149    leg2->Draw("same");
3150    DrawMCPrelim(simulatedlumi);
3151 <  CompleteSave(zcan,"Systematics/zjets_prediction_ratio");
3151 >  CompleteSave(zcan,"Systematics/ZJets/zjets_eemm_prediction_ratio");
3152 >  
3153 >  TCut reducedNJets(cutnJets);
3154 >  
3155 >  TH1F *TAUhJZBpos = systsamples.Draw("TAUhJZBpos",var,binning, "JZB [GeV]", "events",cutmass&&cutOSSF&&reducedNJets&&ONLYTau&&kPos,mc,simulatedlumi,systsamples.FindSample("/DY"));
3156 >  TH1F *LcorrJZBeemm     = systsamples.Draw("LcorrJZBeemm",var,binning, "JZB [GeV]", "events",cutmass&&cutOSSF&&reducedNJets&&ONLYTau&&kNeg,mc,simulatedlumi,systsamples.FindSample("/DY"));
3157 >  TH1F *RcorrJZBem       = systsamples.Draw("RcorrJZBem",var,binning, "JZB [GeV]", "events",cutmass&&cutOSOF&&reducedNJets&&ONLYTau&&kPos,mc,simulatedlumi,systsamples.FindSample("/DY"));
3158 >  TH1F *LcorrJZBem       = systsamples.Draw("LcorrJZBem",var,binning, "JZB [GeV]", "events",cutmass&&cutOSOF&&reducedNJets&&ONLYTau&&kNeg,mc,simulatedlumi,systsamples.FindSample("/DY"));
3159 >
3160 >  TH1F *RcorrJZBSBem;
3161 >  TH1F *LcorrJZBSBem;
3162 >  TH1F *RcorrJZBSBeemm;
3163 >  TH1F *LcorrJZBSBeemm;
3164 >
3165 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
3166 >    RcorrJZBSBem   = systsamples.Draw("RcorrJZBSBem",var,binning, "JZB [GeV]", "events",sidebandcut&&cutOSOF&&reducedNJets&&ONLYTau&&kPos,mc,simulatedlumi,systsamples.FindSample("/DY"));
3167 >    LcorrJZBSBem   = systsamples.Draw("LcorrJZBSBem",var,binning, "JZB [GeV]", "events",sidebandcut&&cutOSOF&&reducedNJets&&ONLYTau&&kNeg,mc,simulatedlumi,systsamples.FindSample("/DY"));
3168 >    RcorrJZBSBeemm = systsamples.Draw("RcorrJZBSBeemm",var,binning, "JZB [GeV]", "events",sidebandcut&&cutOSSF&&reducedNJets&&ONLYTau&&kPos,mc,simulatedlumi,systsamples.FindSample("/DY"));
3169 >    LcorrJZBSBeemm = systsamples.Draw("LcorrJZBSBeemm",var,binning, "JZB [GeV]", "events",sidebandcut&&cutOSSF&&reducedNJets&&ONLYTau&&kNeg,mc,simulatedlumi,systsamples.FindSample("/DY"));
3170 >  }
3171 >  
3172 >  TH1F *Bpred = (TH1F*)LcorrJZBeemm->Clone("Bpred");
3173 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
3174 >    Bpred->Add(RcorrJZBem,1.0/3.);
3175 >    Bpred->Add(LcorrJZBem,-1.0/3.);
3176 >    Bpred->Add(RcorrJZBSBem,1.0/3.);
3177 >    Bpred->Add(LcorrJZBSBem,-1.0/3.);
3178 >    Bpred->Add(RcorrJZBSBeemm,1.0/3.);
3179 >    Bpred->Add(LcorrJZBSBeemm,-1.0/3.);
3180 >  } else {
3181 >    Bpred->Add(RcorrJZBem,1.0);
3182 >    Bpred->Add(LcorrJZBem,-1.0);
3183 >  }
3184 >  
3185 >  Bpred->SetLineColor(kRed);
3186 >
3187 >  TAUhJZBpos->SetLineColor(kBlack);
3188 >  Bpred->SetLineColor(kRed);
3189 >  
3190 >  TAUhJZBpos->SetMinimum(1.0);
3191 >  TAUhJZBpos->Draw("e1");
3192 >  Bpred->Draw("same,hist");
3193 >  TAUhJZBpos->Draw("same,e1");
3194 >  
3195 >  TLegend *TAUleg = make_legend("MC Z+jets #rightarrow ee,#mu#mu,#tau#tau",0.55,0.75,false);
3196 >  TAUleg->AddEntry(TAUhJZBpos,"Observed","pe");
3197 >  TAUleg->AddEntry(Bpred,"Predicted","l");
3198 >  TAUleg->Draw("same");
3199 >  DrawMCPrelim(simulatedlumi);
3200 >  CompleteSave(zcan,"Systematics/ZJets/zjets_eemumutautau_prediction");
3201 >  
3202 >  TH1F* TAUhratio = (TH1F*)TAUhJZBpos->Clone("TAUhratio");
3203 >  TAUhratio->Divide(Bpred);
3204 >  
3205 >  for(int i=1;i<=TAUhJZBpos->GetNbinsX();i++) {
3206 >    cout << "ee/mm/tautau observed: " << TAUhJZBpos->GetBinContent(i) << "   vs    predicted : " << Bpred->GetBinContent(i) << "   (ratio : " << TAUhJZBpos->GetBinContent(i) / Bpred->GetBinContent(i) << endl;
3207 >  }
3208 >  
3209 >  zcan->SetLogy(0);
3210 >  TAUhratio->GetYaxis()->SetRangeUser(0,2.5);
3211 >  TAUhratio->GetYaxis()->SetTitle("Observed/Predicted");
3212 >  TAUhratio->Draw("e1");
3213 >  
3214 >  top->Draw("same");
3215 >  center->Draw("same");
3216 >  bottom->Draw("same");
3217 >  
3218 >  TLegend *TAUleg2 = make_legend("MC Z+jets #rightarrow #tau#tau",0.25,0.75,false);
3219 >  TAUleg2->AddEntry(TAUhratio,"obs / pred","pe");
3220 >  TAUleg2->AddEntry(bottom,"syst. envelope","l");
3221 >  TAUleg2->Draw("same");
3222 >  DrawMCPrelim(simulatedlumi);
3223 >  CompleteSave(zcan,"Systematics/ZJets/zjets_eemumutautau_prediction_ratio");
3224 >  
3225 >  delete Bpred;
3226 >  delete TAUhJZBpos;
3227 >  delete LcorrJZBeemm;
3228 >  delete RcorrJZBem;
3229 >  delete LcorrJZBem;
3230 >  
3231 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
3232 >    delete RcorrJZBSBem;
3233 >    delete LcorrJZBSBem;
3234 >    delete RcorrJZBSBeemm;
3235 >    delete LcorrJZBSBeemm;
3236 >  }
3237 >  
3238    
3239    delete zcan;
3240    cutWeight=weightbackup;
# Line 2681 | Line 3293 | void make_table(samplecollection &coll,
3293      TH1F *RcorrJZBSBeemm;
3294      TH1F *LcorrJZBSBeemm;
3295      
3296 <    if(PlottingSetup::RestrictToMassPeak) {
3296 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
3297        RcorrJZBSBem   = coll.Draw("RcorrJZBSBem",jzbexpr.c_str(),nbins,low,14000, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity, mysample);
3298        LcorrJZBSBem   = coll.Draw("LcorrJZBSBem",("-("+jzbexpr+")").c_str(),nbins,low,14000, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity, mysample);
3299        RcorrJZBSBeemm = coll.Draw("RcorrJZBSBeemm",jzbexpr.c_str(),nbins,low,14000, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity, mysample);
# Line 2689 | Line 3301 | void make_table(samplecollection &coll,
3301      }
3302      
3303      TH1F *Bpred = (TH1F*)LcorrJZBeemm->Clone("Bpred");
3304 <    if(PlottingSetup::RestrictToMassPeak) {
3304 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
3305        Bpred->Add(RcorrJZBem,1.0/3.);
3306        Bpred->Add(LcorrJZBem,-1.0/3.);
3307        Bpred->Add(RcorrJZBSBem,1.0/3.);
# Line 2900 | Line 3512 | void qcd_plots(string datajzb, string mc
3512    TH1F *JRcorrJZBSBeemm;
3513    TH1F *JLcorrJZBSBeemm;
3514    
3515 <  if(PlottingSetup::RestrictToMassPeak) {
3515 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
3516      RcorrJZBSBem   = qcdsamples.Draw("RcorrJZBSBem",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
3517      LcorrJZBSBem   = qcdsamples.Draw("LcorrJZBSBem",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
3518      RcorrJZBSBeemm = qcdsamples.Draw("RcorrJZBSBeemm",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
# Line 2921 | Line 3533 | void qcd_plots(string datajzb, string mc
3533      
3534    TH1F *Bpred = (TH1F*)LcorrJZBeemm->Clone("Bpred");
3535    TH1F *JBpred = (TH1F*)JLcorrJZBeemm->Clone("Bpred");
3536 <  if(PlottingSetup::RestrictToMassPeak) {
3536 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
3537      Bpred->Add(RcorrJZBem,1.0/3.);
3538      Bpred->Add(LcorrJZBem,-1.0/3.);
3539      Bpred->Add(RcorrJZBSBem,1.0/3.);
# Line 2991 | Line 3603 | void qcd_plots(string datajzb, string mc
3603    dout << "______________________________________________" << endl;
3604    dout << "How QCD shows up in the different regions: " << endl;
3605    dout << "OSSF: " << endl;
3606 <  if(PlottingSetup::RestrictToMassPeak) {
3606 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
3607      dout << "     Z window: \t" << RcorrJZBeemm->Integral() << " (JZB>0) , " << LcorrJZBeemm->Integral() << " (JZB<0) --> total: " << RcorrJZBeemm->Integral() + LcorrJZBeemm->Integral() << endl;
3608      dout << "     sideband: \t" << RcorrJZBSBeemm->Integral() << " (JZB>0) , " << LcorrJZBSBeemm->Integral() << " (JZB<0) --> total: " << RcorrJZBSBeemm->Integral() + LcorrJZBSBeemm->Integral() << endl;
3609    } else {
3610      dout << "     " << RcorrJZBeemm->Integral() << " (JZB>0) , " << LcorrJZBeemm->Integral() << " (JZB<0) --> total: " << RcorrJZBeemm->Integral() + LcorrJZBeemm->Integral() << endl;
3611    }
3612    dout << "OSOF: " << endl;
3613 <  if(PlottingSetup::RestrictToMassPeak) {
3613 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
3614      dout << "     Z window: \t" << RcorrJZBem->Integral() << " (JZB>0) , " << LcorrJZBem->Integral() << " (JZB<0) --> total: " << RcorrJZBem->Integral() + LcorrJZBem->Integral() << endl;
3615      dout << "     sideband: \t" << RcorrJZBSBem->Integral() << " (JZB>0) , " << LcorrJZBSBem->Integral() << " (JZB<0) --> total: " << RcorrJZBSBem->Integral() + LcorrJZBSBem->Integral() << endl;
3616    } else {
3617      dout << "     Z window: \t" << RcorrJZBem->Integral() << " (JZB>0) , " << LcorrJZBem->Integral() << " (JZB<0) --> total: " << RcorrJZBem->Integral() + LcorrJZBem->Integral() << endl;
3618    }
3619    dout << "Therefore: " << endl;
3620 <  if(PlottingSetup::RestrictToMassPeak) {
3620 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
3621      dout << "    Prediction increases by : " << LcorrJZBeemm->Integral() << " + (1.0/3)*(" << RcorrJZBSBeemm->Integral() <<"-"<< LcorrJZBSBeemm->Integral() << ") (SFSB) ";
3622      dout << " + (1.0/3)*(" << RcorrJZBem->Integral() <<"-"<< LcorrJZBem->Integral() << ") (OFZP) ";
3623      dout << " + (1.0/3)*(" << RcorrJZBSBem->Integral() <<"-"<< LcorrJZBSBem->Integral() << ") (OFSB) ";
# Line 3021 | Line 3633 | void qcd_plots(string datajzb, string mc
3633    for(int i=0;i<(int)bins.size();i++) {
3634      dout << " JZB > " << bins[i] << " : " << endl;
3635      dout << "    Observation increases by : " << RcorrJZBeemm->Integral(RcorrJZBeemm->FindBin(bins[i]),RcorrJZBeemm->GetNbinsX()) << endl;
3636 <    if(PlottingSetup::RestrictToMassPeak) {
3636 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
3637          dout << "    Prediction increases by : " << LcorrJZBeemm->Integral(RcorrJZBeemm->FindBin(bins[i]),RcorrJZBeemm->GetNbinsX()) + (1.0/3)*(RcorrJZBSBeemm->Integral(RcorrJZBeemm->FindBin(bins[i]),RcorrJZBeemm->GetNbinsX()) - LcorrJZBSBeemm->Integral(RcorrJZBeemm->FindBin(bins[i]),RcorrJZBeemm->GetNbinsX()) + RcorrJZBem->Integral(RcorrJZBeemm->FindBin(bins[i]),RcorrJZBeemm->GetNbinsX()) - LcorrJZBem->Integral(RcorrJZBeemm->FindBin(bins[i]),RcorrJZBeemm->GetNbinsX()) + RcorrJZBSBem->Integral(RcorrJZBeemm->FindBin(bins[i]),RcorrJZBeemm->GetNbinsX()) - LcorrJZBSBem->Integral(RcorrJZBeemm->FindBin(bins[i]),RcorrJZBeemm->GetNbinsX())) << endl;
3638      } else {
3639          dout << "    Prediction increases by : " << LcorrJZBeemm->Integral(RcorrJZBeemm->FindBin(bins[i]),RcorrJZBeemm->GetNbinsX()) + RcorrJZBem->Integral(RcorrJZBeemm->FindBin(bins[i]),RcorrJZBeemm->GetNbinsX()) - LcorrJZBem->Integral(RcorrJZBeemm->FindBin(bins[i]),RcorrJZBeemm->GetNbinsX()) << endl;
# Line 3035 | Line 3647 | void qcd_plots(string datajzb, string mc
3647    if(LcorrJZBem) delete LcorrJZBem;
3648    if(RcorrJZBeemm) delete RcorrJZBeemm;
3649    if(LcorrJZBeemm) delete LcorrJZBeemm;
3650 <  if(PlottingSetup::RestrictToMassPeak&&RcorrJZBSBem) delete RcorrJZBSBem;
3651 <  if(PlottingSetup::RestrictToMassPeak&&LcorrJZBSBem) delete LcorrJZBSBem;
3652 <  if(PlottingSetup::RestrictToMassPeak&&RcorrJZBSBeemm) delete RcorrJZBSBeemm;
3653 <  if(PlottingSetup::RestrictToMassPeak&&LcorrJZBSBeemm) delete LcorrJZBSBeemm;
3650 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB&&RcorrJZBSBem) delete RcorrJZBSBem;
3651 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB&&LcorrJZBSBem) delete LcorrJZBSBem;
3652 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB&&RcorrJZBSBeemm) delete RcorrJZBSBeemm;
3653 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB&&LcorrJZBSBeemm) delete LcorrJZBSBeemm;
3654   }
3655  
3656   void check_ptsanity() {
# Line 3135 | Line 3747 | void do_mlls_plot(string mcjzb) {
3747    }
3748   }
3749  
3750 < void met_vs_jzb_plots() {
3750 > void met_vs_jzb_plots(string datajzb, string mcjzb) {
3751    
3752    TCanvas *canmetjzb = new TCanvas("canmet","MET vs JZB canvas");
3753    canmetjzb->SetRightMargin(0.16);
# Line 3144 | Line 3756 | void met_vs_jzb_plots() {
3756    findme.push_back("DY");
3757    findme.push_back("TTJets");
3758    findme.push_back("LM");
3759 <  
3759 >  /*
3760    for(int ifind=0;ifind<(int)findme.size();ifind++) {
3761      vector<int> selsamples = allsamples.FindSample(findme[ifind]);
3762      TH2F *metvsjzb = new TH2F("metvsjzb","metvsjzb",200,0,100,400,-100,100);
3763      for(int isel=0;isel<(int)selsamples.size();isel++) {
3764 <      cout << "Producing MET:JZB plot ... working on sample: " << allsamples.collection[selsamples[isel]].filename << endl;
3765 <      allsamples.collection[selsamples[isel]].events->Draw("jzb[1]:met[4]>>+metvsjzb",cutmass&&cutOSSF);
3764 >      dout << "Producing MET:JZB plot ... working on sample: " << allsamples.collection[selsamples[isel]].filename << endl;
3765 >      allsamples.collection[selsamples[isel]].events->Draw("jzb[1]:met[4]>>+metvsjzb",cutmass&&cutOSSF&&cutnJets);
3766      }
3767      metvsjzb->Scale(allsamples.collection[selsamples[0]].weight);
3768      metvsjzb->SetStats(0);
# Line 3164 | Line 3776 | void met_vs_jzb_plots() {
3776      title->Draw();
3777      CompleteSave(canmetjzb,(string)"METvsJZBplots/"+findme[ifind]);
3778    }
3779 +  */
3780 +  
3781 +  dout << "About to produce MET plot for DY split up by JZB" << endl;
3782 +  
3783 +  int nbins=14;
3784 +  float low=0;
3785 +  float high=140;
3786 +  
3787 +  stringstream sLEFT;
3788 +  sLEFT << "((" << mcjzb << ")<0)";
3789 +  TCut LEFT(sLEFT.str().c_str());
3790 +  stringstream sRIGHT;
3791 +  sRIGHT << "((" << mcjzb << ")>0)";
3792 +  TCut RIGHT(sRIGHT.str().c_str());
3793 +  
3794 +  TH1F *metleft   = allsamples.Draw("metleft","met[4]",nbins,low,high, "MET [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&LEFT,mc, luminosity, allsamples.FindSample("DYJets"));
3795 +  TH1F *metleftO  = allsamples.Draw("metleftO","met[4]",nbins,low,high, "MET [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&LEFT,mc, luminosity, allsamples.FindSample("DYJets"));
3796 +  TH1F *metright  = allsamples.Draw("metright","met[4]",nbins,low,high, "MET [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&RIGHT,mc, luminosity, allsamples.FindSample("DYJets"));
3797 +  TH1F *metrightO = allsamples.Draw("metrightO","met[4]",nbins,low,high, "MET [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&RIGHT,mc, luminosity, allsamples.FindSample("DYJets"));
3798 +  
3799 +  
3800 +  TH1F *Bpred =  (TH1F*)metleft->Clone("Bpred");
3801 +  Bpred->Add(metleftO,-1);
3802 +  Bpred->Add(metrightO);
3803 +  TH1F *obs = (TH1F*)metright->Clone("obs");
3804 +  
3805 +  metleft->Add(metleftO,-1);
3806 +  metright->Add(metrightO,-1);
3807 +  
3808 +  metleft->SetLineColor(kRed);
3809 +  metright->SetLineColor(kBlack);
3810 +  TPad *metpad = new TPad("metpad","metpad",0,0,1,1);
3811 +  metpad->cd();
3812 +  metpad->SetLogy(1);
3813 +  metleft->Draw("histo");
3814 +  metright->Draw("same");
3815 +  TLegend *lg = make_legend();
3816 +  lg->SetX1(0.5);
3817 +  lg->SetY1(0.7);
3818 +  lg->AddEntry(metright,"JZB>0 (OSOF corrected)","P");
3819 +  lg->AddEntry(metleft,"JZB<0 (OSOF corrected)","L");
3820 +  lg->SetHeader("DY");
3821 +  
3822 +  lg->Draw();
3823 +  save_with_ratio(metright,metleft,metpad->cd(),"METvsJZBplots/ComparingLeftToRightinMETspectrum");
3824 +  
3825 +  TPad *metpad3 = new TPad("metpad3","metpad3",0,0,1,1);
3826 +  metpad3->cd();
3827 +  metpad3->SetLogy(1);
3828 +  Bpred->SetLineColor(kRed);
3829 +  Bpred->Draw("histo");
3830 +  obs->SetLineColor(kBlack);
3831 +  obs->Draw("same");
3832 +  TLegend *lg2 = make_legend();
3833 +  lg2->SetX1(0.5);
3834 +  lg2->SetY1(0.7);
3835 +  lg2->AddEntry(obs,"observed","P");
3836 +  lg2->AddEntry(Bpred,"predicted","L");
3837 +  lg2->SetHeader("DY");
3838 +
3839 +  lg2->Draw();
3840 +  
3841 +  save_with_ratio(obs,Bpred,metpad3->cd(),"METvsJZBplots/ComparingPredObsinMET");
3842 +  
3843 +  TPad *metpad2 = new TPad("metpad2","metpad2",0,0,1,1);
3844 +  metpad2->cd();
3845 +  metpad2->SetLogy(1);
3846 +  
3847 +  TH1F *metlefta   = allsamples.Draw("metlefta","met[2]",nbins,low,high, "MET [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&LEFT,mc, luminosity, allsamples.FindSample("DYJets"));
3848 +  TH1F *metleftOa  = allsamples.Draw("metleftOa","met[2]",nbins,low,high, "MET [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&LEFT,mc, luminosity, allsamples.FindSample("DYJets"));
3849 +  TH1F *metrighta  = allsamples.Draw("metrighta","met[2]",nbins,low,high, "MET [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&RIGHT,mc, luminosity, allsamples.FindSample("DYJets"));
3850 +  TH1F *metrightOa = allsamples.Draw("metrightOa","met[2]",nbins,low,high, "MET [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&RIGHT,mc, luminosity, allsamples.FindSample("DYJets"));
3851 +  
3852 +  metlefta->Add(metleftOa,-1);
3853 +  metrighta->Add(metrightOa,-1);
3854 +  
3855 +  metlefta->SetLineColor(kRed);
3856 +  metpad2->cd();
3857 +  metlefta->Draw("histo");
3858 +  metrighta->Draw("same");
3859 +  lg->Draw();
3860 +  save_with_ratio(metrighta,metlefta,metpad2->cd(),"METvsJZBplots/ComparingLeftToRightinMET_type1_spectrum");
3861 +  
3862 +  delete Bpred;
3863 +  delete obs;
3864 +  
3865 +  float newhigh=300;
3866 +  int newNBins=30;
3867 +  
3868 +  TPad *metpad4 = new TPad("metpad4","metpad4",0,0,1,1);
3869 +  TH1F *Ametleft   = allsamples.Draw("Ametleft","met[4]",newNBins,low,newhigh, "MET [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&LEFT,mc, luminosity);
3870 +  TH1F *AmetleftO  = allsamples.Draw("AmetleftO","met[4]",newNBins,low,newhigh, "MET [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&LEFT,mc, luminosity);
3871 +  TH1F *Ametright  = allsamples.Draw("Ametright","met[4]",newNBins,low,newhigh, "MET [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&RIGHT,mc, luminosity);
3872 +  TH1F *AmetrightO = allsamples.Draw("AmetrightO","met[4]",newNBins,low,newhigh, "MET [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&RIGHT,mc, luminosity);
3873 +  
3874 +  TH1F *aBpred = (TH1F*)Ametleft->Clone("aBpred");
3875 +  aBpred->Add(AmetleftO,-1);
3876 +  aBpred->Add(AmetrightO);
3877 +  aBpred->SetLineColor(kRed);
3878 +  
3879 +  TH1F *aobs = (TH1F*)Ametright->Clone("aobs");
3880 +  metpad4->cd();
3881 +  metpad4->SetLogy(1);
3882 +  aobs->Draw();
3883 +  aBpred->Draw("histo,same");
3884 +  aobs->Draw("same");
3885 +  lg->SetHeader("All MC");
3886 +  lg->Draw();
3887 +  save_with_ratio(aobs,aBpred,metpad4->cd(),"METvsJZBplots/ComparingPredObsinMET_ALLSAMPLES");
3888 +  
3889 +  
3890 +  delete lg;
3891 +  delete canmetjzb;
3892 +  delete metleft;
3893 +  delete metleftO;
3894 +  delete metright;
3895 +  delete metrightO;
3896   }
3897      
3898  
# Line 3171 | Line 3900 | void test() {
3900    
3901    TCanvas *testcanv = new TCanvas("testcanv","testcanv");
3902    testcanv->cd();
3903 <  switch_overunderflow(true);
3903 > //  switch_overunderflow(true);
3904    TH1F *ptdistr   = allsamples.Draw("ptdistr","pt1",100,30,200, "p_{T} [GeV]", "events", cutOSSF,data,luminosity);
3905    switch_overunderflow(false);
3906    ptdistr->Draw();

Diff Legend

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