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.40 by fronga, Fri Jul 20 16:50:04 2012 UTC vs.
Revision 1.70 by buchmann, Thu Oct 11 09:00:41 2012 UTC

# Line 33 | Line 33 | void todo() {
33  
34  
35  
36 < void find_one_peak_combination(TCut specialcut, float &MCPeak,float &MCPeakError, float &DataPeak, float &DataPeakError, float &MCSigma, float &MCSigmaError, float &DataSigma, float& DataSigmaError, stringstream &result, bool doPUreweighting = true, string saveas="")
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 42 | Line 42 | void find_one_peak_combination(TCut spec
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&&specialcut,mc, luminosity);
50 <  TH1F *rawJZBeemmData    = allsamples.Draw("rawJZBeemmData",jzbvariabledata,nbins, -50,50, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&specialcut,data, luminosity);
51 <  TH1F *rawJZBemMC      = allsamples.Draw("rawJZBemMC",jzbvariablemc,nbins,-50,50, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&specialcut,mc, luminosity);
52 <  TH1F *rawJZBemData    = allsamples.Draw("rawJZBemData",jzbvariabledata,nbins, -50,50, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&specialcut,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&&specialcut,mc,luminosity,allsamples.FindSample("TTJet"));
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;
# Line 84 | Line 87 | void find_one_peak_combination(TCut spec
87    delete tempcan;
88   }
89  
90 < void find_peaks(float &MCPeak,float &MCPeakError, float &DataPeak, float &DataPeakError, stringstream &result, bool doPUreweighting, stringstream &datajzb, stringstream &mcjzb)
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 +  bool overunderflowstatus=addoverunderflowbins;
93 +  switch_overunderflow(false);
94 +  
95 +  TCut SpecialCut("mll>=0");
96 +  if(sSpecialCut!="") SpecialCut=TCut(sSpecialCut.c_str());
97    
98    bool DoInvidualeemmPeaks=false;
99    
# Line 101 | Line 109 | void find_peaks(float &MCPeak,float &MCP
109    float mcSigma,mcSigmaError, dataSigma, dataSigmaError;
110    
111    dout << "Finding global peak : " << endl;
112 <  find_one_peak_combination(TCut(""),mcpeak,mcpeakerr, datapeak,datapeakerr,mcSigma,mcSigmaError, dataSigma,dataSigmaError,result,doPUreweighting,"");
112 >  find_one_peak_combination(SpecialCut,SwitchOffNJetsCut,mcpeak,mcpeakerr, datapeak,datapeakerr,mcSigma,mcSigmaError, dataSigma,dataSigmaError,result,doPUreweighting,"");
113    
114    if(DoInvidualeemmPeaks) {
115      dout << "Finding peak for electrons : " << endl;
116 <    find_one_peak_combination(TCut("id1==0"),mceepeak,mceepeakerr,dataeepeak,dataeepeakerr,mcSigma,mcSigmaError,dataSigma,dataSigmaError,result,doPUreweighting,"_ele");
116 >    find_one_peak_combination(SpecialCut&&TCut("id1==0"),SwitchOffNJetsCut,mceepeak,mceepeakerr,dataeepeak,dataeepeakerr,mcSigma,mcSigmaError,dataSigma,dataSigmaError,result,doPUreweighting,"_ele");
117      dout << "Finding peak for muons : " << endl;
118 <    find_one_peak_combination(TCut("id1==1"),mcmmpeak,mcmmpeakerr,datammpeak,datammpeakerr,mcSigma,mcSigmaError,dataSigma,dataSigmaError,result,doPUreweighting,"_mu");
118 >    find_one_peak_combination(SpecialCut&&TCut("id1==1"),SwitchOffNJetsCut,mcmmpeak,mcmmpeakerr,datammpeak,datammpeakerr,mcSigma,mcSigmaError,dataSigma,dataSigmaError,result,doPUreweighting,"_mu");
119      
120      datajzb << "(" << jzbvariabledata;
121      mcjzb << "(" << jzbvariablemc;
# Line 133 | Line 141 | void find_peaks(float &MCPeak,float &MCP
141      else mcjzb << "+ (id1!=id2)*" << TMath::Abs(mcpeak) << " ";
142      
143      mcjzb << ")";
144 +    
145    } else {
146      datajzb << "(" << jzbvariabledata;
147        mcjzb << "(" << jzbvariablemc;
# Line 148 | Line 157 | void find_peaks(float &MCPeak,float &MCP
157      mcjzb << ")";
158    }
159    
160 <  
160 >    MCPeak=mcpeak;
161 >    MCPeakError=mcpeakerr;
162 >    DataPeak=datapeak;
163 >    DataPeakError=datapeakerr;
164 >    switch_overunderflow(overunderflowstatus);
165   }
166  
167   void make_special_obs_pred_mll_plot(string datajzb, string mcjzb, float jzbthreshold, float binWidth = 5.0) {
# Line 188 | Line 201 | void make_special_obs_pred_mll_plot(stri
201    
202   //  TH1F *RcorrJZBeemmNoS;
203  
204 <  if(PlottingSetup::RestrictToMassPeak) {
204 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
205      RcorrJZBSBem   = allsamples.Draw("RcorrJZBSBem",  "mll",nbins,min,max, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets&&largerzeroD,data, luminosity);
206      LcorrJZBSBem   = allsamples.Draw("LcorrJZBSBem",  "mll",nbins,min,max, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets&&smallerzeroD,data, luminosity);
207      RcorrJZBSBeemm = allsamples.Draw("RcorrJZBSBeemm","mll",nbins,min,max, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets&&largerzeroD,data, luminosity);
# Line 196 | Line 209 | void make_special_obs_pred_mll_plot(stri
209    }
210    
211    // Separate predictions
212 <  TH1F* Zpred = (TH1F*)LcorrJZBeemm->Clone("Zpred");
213 <  TH1F* OSpred = (TH1F*)RcorrJZBem->Clone("OSpred");
214 <  if(PlottingSetup::RestrictToMassPeak) {
215 <    OSpred->Scale(1.0/3.0);
216 <    OSpred->Add(RcorrJZBSBem,1.0/3.);
217 <    OSpred->Add(RcorrJZBSBeemm,1.0/3.);
218 <    Zpred->Add(LcorrJZBem,-1.0/3.);
219 <    Zpred->Add(LcorrJZBSBem,-1.0/3.);
220 <    Zpred->Add(LcorrJZBSBeemm,-1.0/3.);
221 <  } else {
222 <    Zpred->Add(LcorrJZBem,-1.0);
223 <  }
224 <
225 <  TH1F* Bpred = (TH1F*)Zpred->Clone("Bpred");
226 <  Bpred->Add(OSpred);
212 >  TH1F* SFN = (TH1F*)LcorrJZBeemm->Clone("SFN");
213 >  TH1F* OFP = (TH1F*)RcorrJZBem->Clone("OFP");
214 >  TH1F* OFN = (TH1F*)LcorrJZBem->Clone("OFN");
215 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
216 >    OFP->Scale(1.0/3.0);
217 >    OFP->Add(RcorrJZBSBem,1.0/3.);
218 >    OFP->Add(RcorrJZBSBeemm,1.0/3.);
219 >    OFN->Scale(1.0/3.0);
220 >    OFN->Add(LcorrJZBSBem,1.0/3.);
221 >    OFN->Add(LcorrJZBSBeemm,1.0/3.);
222 >  }
223 >
224 >  TH1F* Bpred = (TH1F*)SFN->Clone("Bpred");
225 >  Bpred->Add(OFP);
226 >  Bpred->Add(OFN,-1);
227    Bpred->SetLineColor(kRed);
228    
216 –  // Problem with negative bins: add contents to OSpred
217 –  for ( unsigned int i=0; i<=Zpred->GetNbinsX(); ++i ) {
218 –    if ( Zpred->GetBinContent(i)<0 ) {
219 –      OSpred->SetBinContent(i,OSpred->GetBinContent(i)+Zpred->GetBinContent(i));
220 –      Zpred->SetBinContent(i,0);
221 –    }
222 –  }
223 –
229    RcorrJZBeemm->SetTitleOffset(1.3,"y");
230    RcorrJZBeemm->Draw();
231    mcRcorrJZBeemm.Draw("same");
# Line 238 | Line 243 | void make_special_obs_pred_mll_plot(stri
243    CompleteSave(ckin,saveas.str());
244    
245    // Draw all predictions overlayed
246 <  Zpred->SetLineColor(kGreen+1);
247 <  Zpred->SetLineStyle(2);
248 <  OSpred->SetLineColor(kBlue-2);
249 <  OSpred->SetLineStyle(3);
246 >  unsigned int w = gStyle->GetHistLineWidth()+1; // Make line a bit wider, since we dash it
247 >  SFN->SetLineColor(kGreen+2);
248 >  SFN->SetLineStyle(2);
249 >  SFN->SetLineWidth(w);
250 >  OFP->SetLineColor(kBlue+2);
251 >  OFP->SetLineStyle(2);
252 >  OFP->SetLineWidth(w);
253 >  OFN->SetLineColor(kMagenta+2);
254 >  OFN->SetLineStyle(3);
255 >  OFN->SetLineWidth(w);
256    
257    RcorrJZBeemm->Draw();
258 <  OSpred->Draw("histo,same");
259 <  Zpred->Draw("histo,same");
258 >  SFN->Draw("histo,same");
259 >  OFP->Draw("histo,same");
260 >  OFN->Draw("histo,same");
261    Bpred->Draw("histo,same");
262    RcorrJZBeemm->Draw("same");
263    
264    TLegend *leg2 = make_legend("",0.52,0.7);
265    leg2->AddEntry(RcorrJZBeemm,"observed (data)","lp");
266    leg2->AddEntry(Bpred,"predicted (data)","l");
267 <  leg2->AddEntry(Zpred, "  bkgd w/Z (data)","l");
268 <  leg2->AddEntry(OSpred,"  bkgd w/o Z (data)","l");
267 >  leg2->AddEntry(SFN,  "  SF JZB<0","l");
268 >  leg2->AddEntry(OFN,  "  OF JZB<0","l");
269 >  leg2->AddEntry(OFP,  "  OF JZB>0","l");
270    leg2->Draw("same");
271    
272    saveas.str("");
273    saveas << "kin/Mll_After_Cut/Cut_At" << jzbthreshold << "_nomc";
274    CompleteSave(ckin,saveas.str());
275    
263 –  
264 –
276    delete RcorrJZBeemm;
277    delete LcorrJZBeemm;
278    delete RcorrJZBem;
279    delete LcorrJZBem;
280 <  if(PlottingSetup::RestrictToMassPeak) {
280 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
281      delete RcorrJZBSBeemm;
282      delete LcorrJZBSBeemm;
283      delete RcorrJZBSBem;
# Line 360 | Line 371 | void draw_ratio_plot(TH1* hdata, THStack
371    oneline->Draw("same");
372   }
373  
374 + float make_one_OFSF_plot(string variable, string addcut, string legendTitle, int nbins, float min, float max, float ymax, bool logscale,
375 +                        string xlabel, string filename, float legendPosition=0.55) {
376 +
377 +  TCut ibasiccut=basiccut;
378 +  bool draw_separation_lines=false;
379 +
380 +  if(addcut != "") ibasiccut = ibasiccut && addcut.c_str();
381 +
382 +  TCut cutSF;
383 +  TCut cutOF;
384 +
385 +  cutOF = cutOSOF&&cutnJets&&ibasiccut;
386 +  cutSF = cutOSSF&&cutnJets&&ibasiccut;
387 +
388 +  TCanvas *ckin = new TCanvas("ckin","Kinematic Plots (in the making)",600,600);
389 +  TPad* rcan = new TPad("rcan","rcan",0,0,1,1);
390 +  rcan->SetLogy(logscale);
391 +  rcan->cd();
392 +
393 +  std::cout << "OF/SF comparison: variable = " << variable << ", cut = " << cutSF.GetTitle() << std::endl;
394 +  TH1F *datahistoSF = allsamples.Draw("datahistoSF",variable,nbins,min,max, xlabel, "events",cutSF,data,luminosity);
395 +  TH1F *datahistoOF = allsamples.Draw("datahistoOF",variable,nbins,min,max, xlabel, "events",cutOF,data,luminosity);
396 + //   string signal("LM3");
397 + //   TH1F* signalhisto = new TH1F("signalhisto",signal.c_str(),nbins,min,max);
398 + //   int idx = signalsamples.FindSample(signal)[0];
399 + //   (signalsamples.collection)[idx].events->Project("signalhisto",variable.c_str(),cutSF);
400 + //   signalhisto->Scale((signalsamples.collection)[idx].weight*luminosity);
401 + //   signalhisto->SetLineColor((signalsamples.collection)[idx].samplecolor);
402 + //   signalhisto->SetLineStyle(2);
403 +  datahistoSF->SetMarkerSize(DataMarkerSize);
404 +  datahistoOF->SetLineColor(kRed);
405 +
406 +  if ( !logscale ) {
407 +    datahistoSF->SetMinimum(0); // Defaults
408 +  } else {
409 +    datahistoSF->SetMinimum(0.5);
410 +  }
411 +  if (ymax<0) {
412 +    if ( logscale ) datahistoSF->SetMaximum(5.3*datahistoSF->GetMaximum());
413 +    else datahistoSF->SetMaximum(1.8*datahistoSF->GetMaximum());
414 +  } else {
415 +    datahistoSF->SetMaximum(ymax);
416 +  }
417 +
418 +  float ymaxSet = datahistoSF->GetMaximum();
419 +
420 +  datahistoSF->GetXaxis()->SetTitle(xlabel.c_str());
421 +  datahistoSF->GetYaxis()->SetTitle("Events");
422 +  datahistoSF->GetXaxis()->CenterTitle();
423 +  datahistoSF->GetYaxis()->CenterTitle();
424 +
425 +  TLegend *mleg = make_legend(legendTitle.c_str(),legendPosition,0.7,false,legendPosition+0.2);
426 +  mleg->AddEntry(datahistoSF, "Same-flavor", "PL");
427 +  if (datahistoOF->Integral()>0) {
428 +    mleg->AddEntry(datahistoOF, "Opposite-flavor", "L");
429 +  } else {
430 +    mleg->AddEntry((TObject*)0, "", "");
431 +  }
432 +  //mleg->AddEntry(signalhisto, "LM3", "L");
433 +
434 +  datahistoSF->Draw("E1");
435 +  if (datahistoOF->Integral()>0) datahistoOF->Draw("HIST,SAMES");
436 +  //signalhisto->Draw("HIST,SAMES");
437 +  mleg->Draw();
438 +  DrawPrelim();
439 +  if (datahistoOF->Integral()>0) {
440 +    save_with_ratio( datahistoSF, datahistoOF, rcan, "SFOF/" + filename, false, false, "SF/OF" );
441 +  } else {
442 +    CompleteSave(rcan, "SFOF/" + filename);
443 +    delete rcan;
444 +  }
445 +
446 +  datahistoSF->Delete();
447 +  datahistoOF->Delete();
448 +  //signalhisto->Delete();
449 +  delete mleg;
450 +  delete ckin;
451 +
452 +  return ymaxSet;
453 +
454 + }
455 +
456 + // Compare data to data
457 + float make_data_comparison_plot(string variable, TCut cut, int nbins, float min, float max, float ymax, bool logscale,
458 +                                string xlabel, string filename, float legendPosition=0.55) {
459 +
460 +  TCut ibasiccut=basiccut&&cut;
461 +
462 +  TCanvas *ckin = new TCanvas("ckin","Kinematic Plots (in the making)",600,600);
463 +  TPad* rcan = new TPad("rcan","rcan",0,0,1,1);
464 +  rcan->SetLogy(logscale);
465 +  rcan->cd();
466 +
467 +  std::cout << "Data comparison: variable = " << variable << ", cut = " << ibasiccut.GetTitle() << std::endl;
468 +
469 +  TH1F *data1 = allsamples.Draw("data1",variable,nbins,min,max, xlabel, "events",ibasiccut,data,luminosity);
470 +  TH1F *data2 = comparesamples.Draw("data2",variable,nbins,min,max, xlabel, "events",ibasiccut,data,luminosity);
471 +  data2->Scale(4.1/5.2);
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 4.1 fb^{-1}", "PL");
497 +  mleg->AddEntry(data2, "Old 5.1 fb^{-1} (scaled) ", "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, "new/old" );
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>20","mll>15&&mll<70", "mll>75&&mll<105", "mll>120" };
516 +  string mllcutname[] = { "m_{ll} > 20 GeV", "20 < 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 368 | Line 546 | void make_kin_plot(string variable, stri
546   //  TCut basiccut("(pfJetGoodNum>=2&&pfJetGoodID[0])&&(pfJetGoodNum>=2&&pfJetGoodID[1])&&(passed_triggers||!is_data)");
547    TCut ibasiccut=basiccut;
548    bool draw_separation_lines=false;
549 +  bool drawsignal = false;
550    
551    if(isPF) ibasiccut=basiccut&&"pfjzb[0]>-998";
552  
# Line 389 | Line 568 | void make_kin_plot(string variable, stri
568    //Step 2: Refine the cut
569    TCut cut;
570    cut=cutmass&&cutOSSF&&cutnJets&&ibasiccut;
571 <  if(filename=="nJets") cut=cutmass&&cutOSSF&&ibasiccut;
572 <  if(filename=="nJets_osof") cut=cutmass&&cutOSOF&&ibasiccut;
571 >  if(filename=="nJets" || filename=="nJets_inclusive" || filename=="nJets_met100" || filename=="nJets_inclusive_met100") cut=cutmass&&cutOSSF&&ibasiccut;
572 >  if(filename=="nJets_osof" || filename=="nJets_osof_inclusive" || filename=="nJets_osof_met100" || filename=="nJets_osof_inclusive_met100") cut=cutmass&&cutOSOF&&ibasiccut;
573    if(filename=="nJets_nocuts_except_mll_ossf") cut=cutmass&&cutOSSF;
574 <  if(filename=="mll") {
574 >  if(filename=="mll"||filename=="mll_met100") {
575          cut=cutOSSF&&cutnJets&&ibasiccut;
576          draw_separation_lines=true;
577    }
578 <  if(filename=="mll_ee") cut=cutOSSF&&cutnJets&&ibasiccut&&"id1==0";
579 <  if(filename=="mll_osof") {
578 >  if(filename=="mll_ee"||filename=="mll_ee_met100") cut=cutOSSF&&cutnJets&&ibasiccut&&"id1==0";
579 >  if(filename=="mll_mm"||filename=="mll_mm_met100") cut=cutOSSF&&cutnJets&&ibasiccut&&"id1==1";
580 >  if(filename=="mll_osof"||filename=="mll_osof_met100") {
581          cut=cutOSOF&&cutnJets&&ibasiccut;
582          draw_separation_lines=true;
583    }
404 –  if(filename=="mll_mm") cut=cutOSSF&&cutnJets&&ibasiccut&&"id1==1";
584    if(Contains(filename,"aboveJZB")) cut=cutOSSF&&cutnJets&&ibasiccut;
585    if(Contains(filename,"mll_ee_above")) cut=cut&&"id1==0";
586    if(Contains(filename,"mll_mm_above")) cut=cut&&"id1==1";
# Line 412 | Line 591 | void make_kin_plot(string variable, stri
591    if(filename=="mll_inclusive_mm") cut=cutOSSF&&"id1==1";
592    if(filename=="pfJetGoodEta_0") cut=cutOSSF&&cutmass&&ibasiccut&&cutnJets;
593    if(filename=="pfJetGoodPt_0") cut=cutOSSF&&cutmass&&ibasiccut&&cutnJets;
594 +  if(filename=="numVtx") cut=cutmass&&ibasiccut;
595  
596    TCanvas *ckin = new TCanvas("ckin","Kinematic Plots (in the making)",600,600);
597    ckin->SetLogy(logscale);
# Line 429 | Line 609 | void make_kin_plot(string variable, stri
609    if (logscale) datahisto->SetMaximum(5.3*datahisto->GetMaximum());
610    else datahisto->SetMaximum(1.3*datahisto->GetMaximum());
611  
612 +  cout << "******** Cut used : " << (const char*) cut << " for plot " << filename << endl;
613    if(loadlastminmax) {
614          datahisto->SetMinimum(lastrange_min);
615          datahisto->SetMaximum(lastrange_max);
# Line 442 | Line 623 | void make_kin_plot(string variable, stri
623    string signal("LM3");
624    TH1F* signalhisto = new TH1F("signalhisto",signal.c_str(),nbins,min,max);
625    int idx = signalsamples.FindSample(signal)[0];
626 <  (signalsamples.collection)[idx].events->Project("signalhisto",variable.c_str(),cut);
627 <  signalhisto->Scale((signalsamples.collection)[idx].weight*luminosity);
628 <  signalhisto->SetLineColor((signalsamples.collection)[idx].samplecolor);
626 >  if(drawsignal) (signalsamples.collection)[idx].events->Project("signalhisto",variable.c_str(),cut);
627 >  if(drawsignal) signalhisto->Scale((signalsamples.collection)[idx].weight*luminosity);
628 >  if(drawsignal) signalhisto->SetLineColor(kOrange);
629  
630    THStack mcstack   = allsamples.DrawStack("mcstack",  variable,nbins,min,max,xlabel,"events",cut,mc,luminosity);
631    datahisto->Draw("e1");
# Line 493 | Line 674 | void make_kin_plot(string variable, stri
674          kinpad->SetLogy(logscale);
675          datahisto->Draw("e1");
676          mcstack.Draw("same");
677 <        signalhisto->Draw("same");
677 >        if(drawsignal) signalhisto->Draw("same");
678          datahisto->Draw("same,e1");
679          datahisto->Draw("same,axis");
680          if(RestrictToMassPeak&&draw_separation_lines) {
# Line 501 | Line 682 | void make_kin_plot(string variable, stri
682            upperboundary->Draw("same");
683          }
684            
685 <        kinleg->AddEntry("signalihisto",signal.c_str(),"l");
685 >        if(drawsignal) kinleg->AddEntry("signalhisto",signal.c_str(),"l");
686          kinleg->Draw();
687          write_cut->Draw();
688          DrawPrelim();
# Line 516 | Line 697 | void make_kin_plot(string variable, stri
697          else CompleteSave(ckin,"kin/"+filename);
698    }
699    datahisto->Delete();
700 +  delete signalhisto;
701    delete ckin;
702   }
703  
# Line 566 | Line 748 | void make_JES_plot(TCut cut, string name
748  
749   void do_kinematic_plots(string mcjzb, string datajzb, bool doPF=false)
750   {
751 + //  switch_overunderflow(true);
752    bool dolog=true;
753    bool nolog=false;
754 +
755 +  bool doOFSF = false;
756 +  bool doKin  = false;
757 +  bool doDataComp = true;
758 +  
759 +
760    if(doPF) write_warning(__FUNCTION__,"Please use caution when trying to produce PF plots; not all versions of the JZB trees have these variables!");
761    float mll_low=50;
762    float mll_hi=160;
763    if(!PlottingSetup::RestrictToMassPeak) {
764          mll_low=20;
765 <        mll_hi=300;
765 >        mll_hi=320;
766    }
767  
768 <  make_kin_plot("met[4]","",70,0,350,dolog,"MET [GeV]","met",doPF,true);
768 >  if ( doOFSF ) {
769 >     make_OFSF_plots("mll", "met[4]>100", 60, 20., 320., false, "m_{ll}", "mll");
770  
771 <  make_kin_plot("mll","",(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll",doPF,true);
772 <  make_kin_plot("mll","",(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_osof",doPF,true,true);
773 <  make_kin_plot("mll","",(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_ee",doPF,true);
774 <  make_kin_plot("mll","",(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_mm",doPF,true);
775 <  make_kin_plot("mll","",(int)((mll_hi-mll_low))/5,mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_inclusive",doPF,true);
776 <  make_kin_plot("mll","",(int)((mll_hi-mll_low))/5,mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_inclusive_ee",doPF,true);
777 <  make_kin_plot("mll","",(int)((mll_hi-mll_low))/5,mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_inclusive_mm",doPF,true);
778 <  make_kin_plot("mll","",(int)((mll_hi-mll_low))/5,mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_inclusive_osof",doPF,true);
779 <  make_kin_plot("mll","",(int)((350-mll_low))/5,mll_low,350,dolog,"m_{ll} [GeV]","mll_inclusive_highrange",doPF);
780 <  if(!doPF) make_special_mll_plot((int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]");
781 <
782 <  make_kin_plot("pfJetGoodPt[0]/pfJetGoodPt[1]","",45,1,10,dolog,"pt_{j}^{1}/pt_{j}^{2}","j1j2ratio",doPF,true);
783 <  make_kin_plot("TMath::Abs(pfJetDphiMet[0])","",32,0,3.2,nolog,"|#Delta#phi(jet1,MET)|","dphiJ1MET",doPF,true);
784 <
785 <  make_kin_plot("pfJetGoodNum40","",9,-0.5,8.5,dolog,"nJets","nJets",doPF);
786 <  make_kin_plot("pfJetGoodNum40","",9,-0.5,8.5,dolog,"nJets","nJets_osof",doPF);
787 <  make_kin_plot("pfJetGoodNum40","",9,-0.5,8.5,dolog,"nJets","nJets_nocuts_except_mll_ossf",doPF);
788 <
789 <  make_kin_plot("numVtx","",(int)(30.5-(-0.5)),-0.5,30.5,nolog,"N(Vtx)","numVtx",doPF);
790 < //  make_kin_plot("jetpt[0]","",40,0,200,dolog,"leading jet p_{T} [GeV]","pfJetGoodPt_0",doPF);
791 < //  make_kin_plot("jeteta[0]","",40,-5,5,nolog,"leading jet #eta","pfJetGoodEta_0",doPF);
792 <  make_kin_plot("pt","",50,0,500,dolog,"Z p_{T} [GeV]","Zpt",doPF);
793 <  make_kin_plot("pt1","",50,0,200,nolog,"p_{T} [GeV]","pt1",doPF);
794 <  make_kin_plot("pt2","",50,0,200,nolog,"p_{T} [GeV]","pt2",doPF);
795 <  make_kin_plot("eta1","",40,-3,3,nolog,"#eta_{l}","eta",doPF);
796 <  make_kin_plot("jzb[1]","",100,-150,200,dolog,"JZB [GeV]","jzb_ossf",doPF);
797 <  stringstream jzbcut;
798 <  jzbcut << "((is_data&&("<<datajzb<<")>100)||(!is_data&&("<<mcjzb<<")>100))";
799 <  make_kin_plot("mll",jzbcut.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,nolog,"m_{ll} [GeV]","mll_aboveJZB100",doPF,true);
800 <  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);
801 <  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);
802 <  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);
803 <  stringstream jzbcut2;
804 <  jzbcut2 << "((is_data&&("<<datajzb<<")>150)||(!is_data&&("<<mcjzb<<")>150))";
805 <  make_kin_plot("mll",jzbcut2.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,nolog,"m_{ll} [GeV]","mll_aboveJZB150",doPF,true);
806 <  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);
807 <  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);
808 <  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);
809 <  stringstream jzbcut3;
810 <  jzbcut3 << "((is_data&&("<<datajzb<<")>50)||(!is_data&&("<<mcjzb<<")>50))";
811 <  make_kin_plot("mll",jzbcut3.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,nolog,"m_{ll} [GeV]","mll_aboveJZB50",doPF,true);  
812 <  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);
813 <  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);  
814 <  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);  
815 <
816 <  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",doPF,true);
817 <
818 <  make_special_obs_pred_mll_plot(datajzb,mcjzb,0);
819 <  make_special_obs_pred_mll_plot(datajzb,mcjzb,50);
820 <  make_special_obs_pred_mll_plot(datajzb,mcjzb,80);
821 <  make_special_obs_pred_mll_plot(datajzb,mcjzb,100);
771 > //      make_OFSF_plots("pfJetGoodNum40", "met[4]>100",                        7, 3, 10, true, "#(jets)", "njets");
772 > //      make_OFSF_plots("pfJetGoodNum40", "met[4]>100&&pfJetGoodNumBtag30==0", 7, 3, 10, true, "#(jets)", "njets_btagVeto");
773 > //      make_OFSF_plots("pfJetGoodNum40", "met[4]>100&&pfJetGoodNumBtag30>0",  7, 3, 10, true, "#(jets)", "njets_AtLeastOneBJet30");
774 >
775 > //      make_OFSF_plots("pfJetGoodNumBtag30", "met[4]>100", 5, 0, 5, true, "#(b-jets)", "nbjets");
776 > //      make_OFSF_plots("pfJetGoodPtBtag[0]", "met[4]>100&&pfJetGoodNumBtag30>0", 20, 0, 400, true, "p_{T}(leading b-jet)", "ptb1");
777 >
778 > //     make_OFSF_plots("iso1", "met[4]>100", 20, 0, 0.3, true, "lepton 1 isolation", "iso1");
779 > //     make_OFSF_plots("iso2", "met[4]>100", 20, 0, 0.3, true, "lepton 2 isolation", "iso2");
780 >    //  make_OFSF_plots("pt1",  "met[4]>100", 30, 0., 300., true, "p_{T,1}", "pt1");
781 >    //  make_OFSF_plots("pt2",  "met[4]>100", 22, 0., 220., true, "p_{T,2}", "pt2");
782 > //     make_OFSF_plots("eta1", "met[4]>100", 10, -2.5, 2.5, false, "#eta_{1}", "eta1", 0.15);
783 > //     make_OFSF_plots("eta2", "met[4]>100", 10, -2.5, 2.5, false, "#eta_{2}", "eta2", 0.15);
784 >    //  make_OFSF_plots("phi1", "met[4]>100", 10, -TMath::Pi(), TMath::Pi(), false, "#phi_{1}", "phi1", 0.2);
785 >    //  make_OFSF_plots("phi2", "met[4]>100", 10, -TMath::Pi(), TMath::Pi(), false, "#phi_{2}", "phi2", 0.2);
786 > //     make_OFSF_plots("pfJetGoodPt[0]/pfJetGoodPt[1]", "met[4]>100", 20, 1, 10, true, "pt_{j}^{1}/pt_{j}^{2}", "jpt1pt2", 0.2);
787 >    make_OFSF_plots("TMath::Abs(pfJetDphiMet[0])", "met[4]>100", 16, 0, 3.2, false, "|#Delta#phi(jet1,MET)|", "dphij1met", 0.2);
788 > //    make_OFSF_plots("TMath::Abs(dphi)", "met[4]>100", 16, 0, 3.2, false, "|#Delta#phi(l1,l2)|", "dphi", 0.2);
789 > //    make_OFSF_plots("TMath::Abs(dphiMet1)", "met[4]>100", 16, 0, 3.2, false, "|#Delta#phi(l1,MET)|", "dphiMet1", 0.2);
790 > //    make_OFSF_plots("TMath::Abs(dphiMet2)", "met[4]>100", 16, 0, 3.2, false, "|#Delta#phi(l2,MET)|", "dphiMet2", 0.2);
791 > //    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");
792 > //    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");
793 > //    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");
794 > //    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");
795 >  }
796 >
797 >  if ( doDataComp) {
798 >    TCut mllCut("");
799 >    float massmin = 15.;
800 >    float massmax = 315;
801 >    int massnbins = 60;
802 > /*    if ( !PlottingSetup::openBox ) {
803 >      mllCut = "mll>70";
804 >      massmin = 120;
805 >      massmax = 360;
806 >      massnbins = 14;
807 >    }*/
808 >
809 >    TCut cutSignal = cutmass&&cutnJets&&"met[4]>100";
810 >    
811 > /*    make_data_comparison_plot("met[4]", cutOSSF,60, 0., 300.,-1., true, "pfMET", "met_SF_inclusive");
812 >    make_data_comparison_plot("met[1]", cutOSSF,60, 0., 300.,-1., true, "type 1 corrected pfMET", "mett1_SF_inclusive");
813 >    make_data_comparison_plot("met[4]", cutOSOF,60, 0., 300.,-1., true, "pfMET", "met_OF_inclusive");
814 >    make_data_comparison_plot("met[1]", cutOSOF,60, 0., 300.,-1., true, "type 1 corrected pfMET", "mett1_OF_inclusive");
815 >    
816 >    make_data_comparison_plot("met[4]", cutnJets&&cutOSSF,60, 0., 300.,-1., true, "pfMET", "met_SF_exclusive");
817 >    make_data_comparison_plot("met[1]", cutnJets&&cutOSSF,60, 0., 300.,-1., true, "type 1 corrected pfMET", "mett1_SF_exclusive");
818 >    make_data_comparison_plot("met[4]", cutnJets&&cutOSOF,60, 0., 300.,-1., true, "pfMET", "met_OF_exclusive");
819 >    make_data_comparison_plot("met[1]", cutnJets&&cutOSOF,60, 0., 300.,-1., true, "type 1 corrected pfMET", "mett1_OF_exclusive");
820 >  
821 >  */  
822 >    string basiccutsaved = (const char*)basiccut;
823 >    
824 >    string newbasiccut=basiccutsaved;
825 >    
826 >    size_t found;
827 >    found = newbasiccut.find( "pt2>20" );
828 >    while (found!=string::npos){
829 >      newbasiccut.replace( found, string( "pt2>20" ).length(), "pt2>10" );
830 >      found = newbasiccut.find( "pt2>20" );
831 >    }
832 > //    basiccut=TCut(newbasiccut.c_str());
833 > //    make_data_comparison_plot("mll", TCut("pfJetGoodNum40>=2&&met[4]>150")&&cutOSSF,60, 0., 300.,-1., false, "mll", "mll_SF_Aachen_pt2010_met");
834 > //    make_data_comparison_plot("mll", TCut("pfJetGoodNum40>=2&&met[4]>150")&&cutOSOF,60, 0., 300.,-1., false, "mll", "mll_OF_Aachen_pt2010_met");
835 > //    make_data_comparison_plot("mll", TCut("pfJetGoodNum40>=2&&met[1]>150")&&cutOSSF,60, 0., 300.,-1., true, "mll", "mll_SF_Aachen_pt2010_t1cpfmet");
836 > //    make_data_comparison_plot("mll", TCut("pfJetGoodNum40>=2&&met[1]>150")&&cutOSOF,60, 0., 300.,-1., true, "mll", "mll_OF_Aachen_pt2010_t1cpfmet");
837 > //    basiccut=TCut(basiccutsaved.c_str());
838 >    
839 > //     make_data_comparison_plot("pfJetGoodNum40", cutOSSF, 8, 0., 8.,-1., true, "#(jets)", "njets_SF");
840 > //     make_data_comparison_plot("pfJetGoodNum40", cutOSOF, 8, 0., 8.,-1., true, "#(jets)", "njets_OF");
841 >    
842 > //     make_data_comparison_plot("mll", TCut("pfJetGoodNum40>=3&&met[4]>100")&&cutOSSF,60, 0., 300.,-1., true, "mll", "mll_SF_ETH_met");
843 > //     make_data_comparison_plot("mll", TCut("pfJetGoodNum40>=3&&met[4]>100")&&cutOSOF,60, 0., 300.,-1., true, "mll", "mll_OF_ETH_met");
844 > //     make_data_comparison_plot("mll", TCut("pfJetGoodNum40>=3&&met[1]>100")&&cutOSSF,60, 0., 300.,-1., true, "mll", "mll_SF_ETH_t1cpfmet");
845 > //     make_data_comparison_plot("mll", TCut("pfJetGoodNum40>=3&&met[1]>100")&&cutOSOF,60, 0., 300.,-1., true, "mll", "mll_OF_ETH_t1cpfmet");
846 >
847 >    
848 > //     make_data_comparison_plot("mll", cutOSSF,60, 15., 315.,-1., true, "m_{ll}", "mll_SF_inclusive");
849 > //     make_data_comparison_plot("mll", cutOSSF&&TCut("id1==0"),60, 15., 315.,-1., true, "m_{ll}", "mll_SF_inclusive_ee");
850 > //     make_data_comparison_plot("mll", cutOSSF&&TCut("id1==1"),60, 15., 315.,-1., true, "m_{ll}", "mll_SF_inclusive_mm");
851 > //     make_data_comparison_plot("mll", cutOSOF,60, 15., 315.,-1., true, "m_{ll}", "mll_OF_inclusive");
852 >    make_data_comparison_plot("mll", cutnJets&&cutOSSF&&TCut("id1==0"),60, 15., 315.,-1., true, "m_{ll}", "mll_SF_exclusive_ee");
853 >    make_data_comparison_plot("mll", cutnJets&&cutOSSF&&TCut("id1==1"),60, 15., 315.,-1., true, "m_{ll}", "mll_SF_exclusive_mm");
854 >    make_data_comparison_plot("mll", cutnJets&&cutOSSF,60, 15., 315.,-1., true, "m_{ll}", "mll_SF_exclusive");
855 >    make_data_comparison_plot("mll", cutnJets&&cutOSOF,60, 15., 315.,-1., true, "m_{ll}", "mll_OF_exclusive");
856 > /*
857 >    make_data_comparison_plot("mll", cutOSSF&&cutSignal&&mllCut,           massnbins, 15., 315.,-1., false, "m_{ll}", "mll_SF_sig");
858 >    make_data_comparison_plot("mll", cutOSSF&&cutSignal&&mllCut&&"pfJetGoodNumBtag30==0", massnbins, 15., 315.,-1., false, "m_{ll}", "mll_SF_sig_btagVeto");
859 >    make_data_comparison_plot("mll", cutOSSF&&cutSignal&&mllCut&&"pfJetGoodNumBtag30>0",  massnbins, 15., 315.,-1., false, "m_{ll}", "mll_SF_sig_AtLeastOneBJet");
860 >
861 >    make_data_comparison_plot("mll", mllCut&&cutOSOF&&cutSignal, massnbins, 15., 315.,-1., false, "m_{ll}", "mll_OF_sig");
862 >    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");
863 >    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");
864 >
865 >    make_data_comparison_plot("pfJetGoodNum40", cutOSSF&&cutSignal&&mllCut, 8, 0., 8.,-1., false, "#(jets)", "njets_SF_sig");
866 >    make_data_comparison_plot("pfJetGoodNum40", cutOSOF&&cutSignal&&mllCut, 8, 0., 8.,-1., false, "#(jets)", "njets_OF_sig");
867 >    make_data_comparison_plot("pfJetGoodNumBtag30", cutOSSF&&cutSignal&&mllCut, 8, 0., 8.,-1., false, "#(b-jets)", "nbjets_SF_sig");
868 >    make_data_comparison_plot("pfJetGoodNumBtag30", cutOSOF&&cutSignal&&mllCut, 8, 0., 8.,-1., false, "#(b-jets)", "nbjets_OF_sig");
869 >  */  
870 >  }
871 >
872 >
873 >  if ( doKin ) {
874 >    string mllCut("");
875 >
876 >     make_kin_plot("pfJetGoodPt[0]/pfJetGoodPt[1]","",45,1,10,dolog,"pt_{j}^{1}/pt_{j}^{2}","j1j2ratio",doPF,true);
877 >     make_kin_plot("TMath::Abs(pfJetDphiMet[0])","",32,0,3.2,nolog,"|#Delta#phi(jet1,MET)|","dphiJ1MET",doPF,true);
878 >    // Plots in signal region
879 > //     make_kin_plot("met[4]","",70,0,350,dolog,"MET [GeV]","met",doPF,true);
880 >     make_kin_plot("mll","mll>20"+mllCut,(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll",doPF,true);
881 >     make_kin_plot("mll","mll>20",(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_osof",doPF,true,true);
882 >     make_kin_plot("mll","mll>20"+mllCut,(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_ee",doPF,true);
883 >     make_kin_plot("mll","mll>20"+mllCut,(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_mm",doPF,true);
884 >    
885 >     make_kin_plot("pfJetGoodNum40",mllCut,9,-0.5,8.5,dolog,"nJets","nJets",doPF);
886 >     make_kin_plot("pfJetGoodNum40","",9,-0.5,8.5,dolog,"nJets","nJets_osof",doPF);
887 >    
888 > //     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_met100",doPF,true);
889 > //     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_met100",doPF,true,true);
890 > //     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_met100",doPF,true);
891 > //     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_met100",doPF,true);
892 >    
893 >    
894 > //     make_kin_plot("pfJetGoodNum40","met[4]>100"+mllCut,9,-0.5,8.5,dolog,"nJets","nJets_met100",doPF);
895 > //     make_kin_plot("pfJetGoodNum40","met[4]>100",9,-0.5,8.5,dolog,"nJets","nJets_osof_met100",doPF);
896 >
897 >    // Further inclusive invariant mass plots
898 >    make_kin_plot("mll",mllCut,(int)((mll_hi-mll_low))/5,mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_inclusive",doPF,true);
899 > //     make_kin_plot("mll","",(int)((mll_hi-mll_low))/5,mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_inclusive_ee",doPF,true);
900 > //     make_kin_plot("mll","",(int)((mll_hi-mll_low))/5,mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_inclusive_mm",doPF,true);
901 >    make_kin_plot("mll",mllCut,(int)((mll_hi-mll_low))/5,mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_inclusive_osof",doPF,true);
902 >    
903 >    //make_kin_plot("mll","",(int)((350-mll_low))/5,mll_low,350,dolog,"m_{ll} [GeV]","mll_inclusive_highrange",doPF);
904 >    //if(!doPF) make_special_mll_plot((int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]");
905 >    
906 >    
907 >    // Number of jets
908 >    make_kin_plot("pfJetGoodNum40","",9,-0.5,8.5,dolog,"nJets","nJets_inclusive",doPF);
909 >    make_kin_plot("pfJetGoodNum40","",9,-0.5,8.5,dolog,"nJets","nJets_osof_inclusive",doPF);
910 >    //make_kin_plot("pfJetGoodNum40","",9,-0.5,8.5,dolog,"nJets","nJets_nocuts_except_mll_ossf",doPF);
911 >    
912 >    // Others
913 >    make_kin_plot("numVtx","",(int)(30.5-(-0.5)),-0.5,30.5,nolog,"N(Vtx)","numVtx",doPF);
914 >    //  make_kin_plot("jetpt[0]","",40,0,200,dolog,"leading jet p_{T} [GeV]","pfJetGoodPt_0",doPF);
915 >    //  make_kin_plot("jeteta[0]","",40,-5,5,nolog,"leading jet #eta","pfJetGoodEta_0",doPF);
916 >    make_kin_plot("pt","",50,0,500,dolog,"Z p_{T} [GeV]","Zpt",doPF);
917 >    make_kin_plot("pt1","",50,0,200,nolog,"p_{T} [GeV]","pt1",doPF);
918 >    make_kin_plot("pt2","",50,0,200,nolog,"p_{T} [GeV]","pt2",doPF);
919 >    make_kin_plot("eta1","",40,-3,3,nolog,"#eta_{l}","eta",doPF);
920 >    make_kin_plot("jzb[1]","",100,-150,200,dolog,"JZB [GeV]","jzb_ossf",doPF);
921 >    //   stringstream jzbcut;
922 >    //   jzbcut << "((is_data&&("<<datajzb<<")>100)||(!is_data&&("<<mcjzb<<")>100))";
923 >    //   make_kin_plot("mll",jzbcut.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,nolog,"m_{ll} [GeV]","mll_aboveJZB100",doPF,true);
924 >    //   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);
925 >    //   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);
926 >    //   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);
927 >    //   stringstream jzbcut2;
928 >    //   jzbcut2 << "((is_data&&("<<datajzb<<")>150)||(!is_data&&("<<mcjzb<<")>150))";
929 >    //   make_kin_plot("mll",jzbcut2.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,nolog,"m_{ll} [GeV]","mll_aboveJZB150",doPF,true);
930 >    //   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);
931 >    //   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);
932 >    //   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);
933 >    //   stringstream jzbcut3;
934 >    //   jzbcut3 << "((is_data&&("<<datajzb<<")>50)||(!is_data&&("<<mcjzb<<")>50))";
935 >    //   make_kin_plot("mll",jzbcut3.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,nolog,"m_{ll} [GeV]","mll_aboveJZB50",doPF,true);  
936 >    //   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);
937 >    //   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);  
938 >    //   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);  
939 >    
940 >    //   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);
941 >    //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);
942 >    //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);
943 >  }
944 >    
945 > //   make_special_obs_pred_mll_plot(datajzb,mcjzb,0);
946 > //   make_special_obs_pred_mll_plot(datajzb,mcjzb,50);
947 > //   make_special_obs_pred_mll_plot(datajzb,mcjzb,80);
948 >   make_special_obs_pred_mll_plot(datajzb,mcjzb,100);
949   //   make_special_obs_pred_mll_plot(datajzb,mcjzb,150);
950   //   make_special_obs_pred_mll_plot(datajzb,mcjzb,200);
951   //   make_special_obs_pred_mll_plot(datajzb,mcjzb,250);
952  
953 <  make_JES_plot(cutmass&&cutOSSF&&basiccut,"_ossf");
954 <  make_JES_plot(cutmass&&cutOSOF&&basiccut,"_osof");
638 <
953 > //   make_JES_plot(cutmass&&cutOSSF&&basiccut,"_ossf");
954 > //   make_JES_plot(cutmass&&cutOSOF&&basiccut,"_osof");
955  
956 +  switch_overunderflow(false);
957   }
958  
959   void make_comp_plot( string var, string xlabel, string filename, float jzbcut, string mcjzb, string datajzb,
# Line 652 | Line 969 | void make_comp_plot( string var, string
969  
970    flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak ---- below: the next ~20 lines changed!
971    int nRegions=4;
972 <  if(!PlottingSetup::RestrictToMassPeak) {
972 >  if(!PlottingSetup::RestrictToMassPeak||!PlottingSetup::UseSidebandsForcJZB) {
973      nRegions=2;
974    }
975    
# Line 706 | Line 1023 | void region_comparison_plots(string mcjz
1023  
1024   //  switch_overunderflow(true);  // switching overflow/underflow bins on
1025      
1026 <  
1026 >  switch_overunderflow(true);
1027      flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak ---- the arguments changed
1028    for(int ijzb=0;ijzb<(int)jzb_cuts.size();ijzb++) {
1029      float jzbcut=jzb_cuts[ijzb]; // Comparison plots are done for this JZB cut
# Line 926 | Line 1243 | vector<TF1*> do_extended_fit_to_plot(TH1
1243   //      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)
1244    TF1 *ttbarlogpar = do_logpar_fit_to_plot(Tprediction);
1245    flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak
1246 <  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);
1246 >  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);
1247  
1248  
1249    TF1 *ttbarlogparP = new TF1("ttbarlogparP",LogParabolaP,0,(prediction->GetXaxis()->GetBinLowEdge(prediction->GetNbinsX())+prediction->GetXaxis()->GetBinWidth(prediction->GetNbinsX())),8);
# Line 1023 | Line 1340 | if you want to start from scratch (witho
1340  
1341   void do_prediction_plot(string jzb, TCanvas *globalcanvas, float high, int use_data, bool overlay_signal = false,string subdir="" )
1342   {
1343 < //  switch_overunderflow(true);
1343 >  
1344    bool is_data=false;
1345    bool use_signal=false;
1346    if(use_data==1) is_data=true;
1347    if(use_data==2) use_signal=true;
1348 <  int nbins=50;//100;
1349 <  if(is_data) nbins=50;
1348 >  int nbins=int(high/10);//100;
1349 >  if(is_data) nbins=int(high/10);
1350    float low=0;
1351 <  float hi=500;
1351 >  float hi=high;
1352 >  
1353 >  stringstream cutpositiveS;
1354 >  cutpositiveS << "(" << jzb << ">0)";
1355 >  TCut cutpositive(cutpositiveS.str().c_str());
1356 >  stringstream cutnegativeS;
1357 >  cutnegativeS << "(" << jzb << "<0)";
1358 >  TCut cutnegative(cutnegativeS.str().c_str());
1359 >  
1360    
1361    TH1F *blankback = new TH1F("blankback","blankback",int(high/10),0,high);
1362 <  TH1F *RcorrJZBeemm   = allsamples.Draw("RcorrJZBeemm",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1363 <  TH1F *LcorrJZBeemm   = allsamples.Draw("LcorrJZBeemm",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1364 <  TH1F *RcorrJZBem     = allsamples.Draw("RcorrJZBem",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1365 <  TH1F *LcorrJZBem     = allsamples.Draw("LcorrJZBem",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1362 >  TH1F *RcorrJZBeemm   = allsamples.Draw("RcorrJZBeemm",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutpositive&&cutmass&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1363 >  TH1F *LcorrJZBeemm   = allsamples.Draw("LcorrJZBeemm",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", cutnegative&&cutmass&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1364 >  TH1F *RcorrJZBem     = allsamples.Draw("RcorrJZBem",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutpositive&&cutmass&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1365 >  TH1F *LcorrJZBem     = allsamples.Draw("LcorrJZBem",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", cutnegative&&cutmass&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1366  
1367    blankback->GetXaxis()->SetTitle(RcorrJZBeemm->GetXaxis()->GetTitle());
1368    blankback->GetYaxis()->SetTitle(RcorrJZBeemm->GetYaxis()->GetTitle());
# Line 1052 | Line 1377 | void do_prediction_plot(string jzb, TCan
1377    
1378    TH1F *RcorrJZBeemmNoS;
1379  
1380 <    //these are for the ratio
1381 <  
1382 <  TH1F *JRcorrJZBeemm   = allsamples.Draw("JRcorrJZBeemm",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1383 <  TH1F *JLcorrJZBeemm   = allsamples.Draw("JLcorrJZBeemm",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1384 <  TH1F *JRcorrJZBem     = allsamples.Draw("JRcorrJZBem",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1060 <  TH1F *JLcorrJZBem     = allsamples.Draw("JLcorrJZBem",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1380 >  //these are for the ratio
1381 >  TH1F *JRcorrJZBeemm   = allsamples.Draw("JRcorrJZBeemm",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutpositive&&cutmass&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1382 >  TH1F *JLcorrJZBeemm   = allsamples.Draw("JLcorrJZBeemm",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutnegative&&cutmass&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1383 >  TH1F *JRcorrJZBem     = allsamples.Draw("JRcorrJZBem",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutpositive&&cutmass&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1384 >  TH1F *JLcorrJZBem     = allsamples.Draw("JLcorrJZBem",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutnegative&&cutmass&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1385    
1386    TH1F *JRcorrJZBSBem;
1387    TH1F *JLcorrJZBSBem;
1388    TH1F *JRcorrJZBSBeemm;
1389    TH1F *JLcorrJZBSBeemm;
1390    
1391 <  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);
1391 >  if(use_data==2 || overlay_signal) RcorrJZBeemmNoS = allsamples.Draw("RcorrJZBeemmNoS",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutpositive&&cutmass&&cutOSSF&&cutnJets,is_data, luminosity,false);
1392  
1393    
1394 <  if(PlottingSetup::RestrictToMassPeak) {
1395 <    RcorrJZBSBem   = allsamples.Draw("RcorrJZBSBem",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1396 <    LcorrJZBSBem   = allsamples.Draw("LcorrJZBSBem",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1397 <    RcorrJZBSBeemm = allsamples.Draw("RcorrJZBSBeemm",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1398 <    LcorrJZBSBeemm = allsamples.Draw("LcorrJZBSBeemm",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1394 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
1395 >    RcorrJZBSBem   = allsamples.Draw("RcorrJZBSBem",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutpositive&&sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1396 >    LcorrJZBSBem   = allsamples.Draw("LcorrJZBSBem",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", cutnegative&&sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1397 >    RcorrJZBSBeemm = allsamples.Draw("RcorrJZBSBeemm",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutpositive&&sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1398 >    LcorrJZBSBeemm = allsamples.Draw("LcorrJZBSBeemm",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", cutnegative&&sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1399      
1400      //these are for the ratio
1401 <    JRcorrJZBSBem   = allsamples.Draw("JRcorrJZBSBem",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1402 <    JLcorrJZBSBem   = allsamples.Draw("JLcorrJZBSBem",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1403 <    JRcorrJZBSBeemm = allsamples.Draw("JRcorrJZBSBeemm",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1404 <    JLcorrJZBSBeemm = allsamples.Draw("JLcorrJZBSBeemm",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1401 >    JRcorrJZBSBem   = allsamples.Draw("JRcorrJZBSBem",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutpositive&&sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1402 >    JLcorrJZBSBem   = allsamples.Draw("JLcorrJZBSBem",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutnegative&&sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
1403 >    JRcorrJZBSBeemm = allsamples.Draw("JRcorrJZBSBeemm",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutpositive&&sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1404 >    JLcorrJZBSBeemm = allsamples.Draw("JLcorrJZBSBeemm",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutnegative&&sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
1405    }
1406    
1407    TH1F *lm4RcorrJZBeemm;
1408 <  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"));
1408 >  if(overlay_signal || use_data == 2 || use_data == 1) lm4RcorrJZBeemm = allsamples.Draw("lm4RcorrJZBSBeemm",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutpositive&&cutmass&&cutOSSF&&cutnJets,is_data, luminosity,allsamples.FindSample("LM"));
1409    
1410    flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak ---- prediction changed.
1411    
# Line 1094 | Line 1418 | void do_prediction_plot(string jzb, TCan
1418    TH1F *BpredSys = new TH1F("Bpredsys","Bpredsys",PlottingSetup::global_ratio_binning.size()-1,&PlottingSetup::global_ratio_binning[0]);
1419    ClearHisto(BpredSys);
1420      
1421 <  if(PlottingSetup::RestrictToMassPeak) {
1421 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
1422      Bpred->Add(RcorrJZBem,1.0/3.);
1423      Bpred->Add(LcorrJZBem,-1.0/3.);
1424      Bpred->Add(RcorrJZBSBem,1.0/3.);
# Line 1145 | Line 1469 | void do_prediction_plot(string jzb, TCan
1469    SQRT(BpredSys);
1470    BpredSys->Divide(JBpred);
1471  
1148 –  
1472    flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak ---- prediction changed
1473    TH1F *Tpred = (TH1F*)RcorrJZBem->Clone("Bpred");
1474    Tpred->Add(LcorrJZBem,-1.0);
1475 <  if(PlottingSetup::RestrictToMassPeak) {
1475 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
1476      Tpred->Add(RcorrJZBSBem,1.0);
1477      Tpred->Add(LcorrJZBSBem,-1.0);
1478      Tpred->Add(RcorrJZBSBeemm,1.0);
# Line 1198 | Line 1521 | void do_prediction_plot(string jzb, TCan
1521      Bpred->Draw("hist,same");
1522      //analytical_function[0]->Draw("same"); analytical_function[1]->Draw("same");analytical_function[2]->Draw("same");
1523      RcorrJZBeemm->Draw("e1x0,same");//HAVE IT ON TOP!
1524 <    lm4RcorrJZBeemm->Draw("hist,same");
1524 >    //lm4RcorrJZBeemm->Draw("hist,same");
1525      legBpred->AddEntry(RcorrJZBeemm,"observed","p");
1526      legBpred->AddEntry(Bpred,"predicted","l");
1527   //    legBpred->AddEntry(analytical_function[1],"predicted fit","l");
1528   //    legBpred->AddEntry(analytical_function[2],"stat. uncert.","l");
1529 <    legBpred->AddEntry(lm4RcorrJZBeemm,(allsamples.collection[allsamples.FindSample("LM")[0]].samplename).c_str(),"l");
1529 > //     legBpred->AddEntry(lm4RcorrJZBeemm,(allsamples.collection[allsamples.FindSample("LM")[0]].samplename).c_str(),"l");
1530      legBpred->Draw();
1531      DrawPrelim();
1532  
# Line 1213 | Line 1536 | void do_prediction_plot(string jzb, TCan
1536      Bpred->SetLineWidth(2);
1537      predcomppad->cd();
1538      predcomppad->SetLogy(1);
1216 –    
1539      TH1F *jzbnegative = (TH1F*)LcorrJZBeemm->Clone("jzbnegative");
1540      TH1F *sidebandsemu = (TH1F*)Bpred->Clone("sidebandsemu");
1541      sidebandsemu->Add(jzbnegative,-1);
# Line 1235 | Line 1557 | void do_prediction_plot(string jzb, TCan
1557   //    lm4RcorrJZBeemm->SetLineColor(kOrange+1);
1558      lm4RcorrJZBeemm->SetLineWidth(2);
1559      //lm4RcorrJZBeemm->SetLineWidth(2); // paper style. overruled.
1560 <    lm4RcorrJZBeemm->Draw("histo,same");
1560 > //     lm4RcorrJZBeemm->Draw("histo,same");
1561      DrawPrelim();
1562      TLegend *speciallegBpred = make_legend("",0.45,0.55);
1563      //TLegend *speciallegBpred = make_legend("",0.35,0.55); // paper style. overruled.
1564      speciallegBpred->AddEntry(RcorrJZBeemm,"Data","pl");
1565      speciallegBpred->AddEntry(Bpred,"Total background","l");
1566      speciallegBpred->AddEntry(jzbnegative,"JZB<0 (data)","f");
1567 <    if(PlottingSetup::RestrictToMassPeak) speciallegBpred->AddEntry(sidebandsemu,"Sidebands/e#mu (data)","f");
1567 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) speciallegBpred->AddEntry(sidebandsemu,"Sidebands/e#mu (data)","f");
1568      else speciallegBpred->AddEntry(sidebandsemu,"e#mu (data)","f");
1569   //    speciallegBpred->AddEntry(lm4RcorrJZBeemmC,"LM4","l");
1570 <    speciallegBpred->AddEntry(lm4RcorrJZBeemm,"LM4","l");
1570 > //     speciallegBpred->AddEntry(lm4RcorrJZBeemm,"LM4","l");
1571      speciallegBpred->Draw();
1572      save_with_ratio(JRcorrJZBeemm,JBpred,predcomppad,subdir+"Bpred_Data_____PredictionComposition",true,true,"data/pred",BpredSys);
1573      
# Line 1281 | Line 1603 | void do_prediction_plot(string jzb, TCan
1603      legBpred->AddEntry(Bpred,"MC predicted","l");    
1604      if(versok) legBpred->AddEntry((TObject*)0,"",""); // Just for alignment // causes seg fault on root v5.18
1605      if(versok) legBpred->AddEntry((TObject*)0,"",""); // causes seg fault on root v5.18
1606 <    if ( overlay_signal ) legBpred->AddEntry(lm4RcorrJZBeemm,"LM4","l");
1606 > //     if ( overlay_signal ) legBpred->AddEntry(lm4RcorrJZBeemm,"LM4","l");
1607      legBpred->Draw();
1608      DrawMCPrelim();
1609      Bpredsaveas="Bpred_MC";
# Line 1313 | Line 1635 | void do_prediction_plot(string jzb, TCan
1635        
1636        RcorrJZBeemmNoS->SetLineStyle(2);
1637        legBpred2->AddEntry(RcorrJZBeemmNoS,"MC B","l");
1638 <      legBpred2->AddEntry(lm4RcorrJZBeemm,"MC S","l");
1638 > //       legBpred2->AddEntry(lm4RcorrJZBeemm,"MC S","l");
1639        legBpred2->Draw();
1640        RcorrJZBeemmNoS->SetLineColor(TColor::GetColor("#61210B"));
1641        RcorrJZBeemmNoS->Draw("histo,same");
# Line 1330 | Line 1652 | void do_prediction_plot(string jzb, TCan
1652    string ytitle("ratio");
1653    if ( use_data==1 ) ytitle = "data/pred";
1654    //save_with_ratio(JRcorrJZBeemm,JBpred,kinpad,Bpredsaveas,true,use_data!=1,ytitle);
1655 <  save_with_ratio(JRcorrJZBeemm,JBpred,kinpad,subdir+Bpredsaveas,true,true,ytitle,BpredSys);//not extending the y range anymore up to 4
1655 >  save_with_ratio(JRcorrJZBeemm,JBpred,kinpad,subdir+Bpredsaveas,true,false,ytitle,BpredSys);//not extending the y range anymore up to 4
1656 >
1657  
1658    
1659    flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak
1660    // The part below is meaningless for the offpeak analysis (it's a comparison of the different estimates but there is but one estimate!)
1661 <  if(PlottingSetup::RestrictToMassPeak) {
1661 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
1662      TH1F *Bpredem = (TH1F*)LcorrJZBeemm->Clone("Bpredem");
1663      Bpredem->Add(RcorrJZBem);
1664      Bpredem->Add(LcorrJZBem,-1);
# Line 1390 | Line 1713 | void do_prediction_plot(string jzb, TCan
1713        legBpredc->AddEntry(Bpredem,"MC OFZP","l");
1714        legBpredc->AddEntry(BpredSBem,"MC OFSB","l");
1715        legBpredc->AddEntry(BpredSBeemm,"MC SFSB","l");
1716 <      if ( overlay_signal ) legBpred->AddEntry(lm4RcorrJZBeemm,"LM4","l");
1716 > //       if ( overlay_signal ) legBpred->AddEntry(lm4RcorrJZBeemm,"LM4","l");
1717        legBpredc->Draw();
1718        CompleteSave(globalcanvas,subdir+"Bpred_MCwithS_comparison");
1719      }
# Line 1414 | Line 1737 | void do_prediction_plot(string jzb, TCan
1737    delete blankback;
1738    
1739    delete BpredSys;
1740 <  if(PlottingSetup::RestrictToMassPeak) {
1740 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
1741      delete RcorrJZBSBem;
1742      delete LcorrJZBSBem;
1743      delete RcorrJZBSBeemm;
# Line 1426 | Line 1749 | void do_prediction_plot(string jzb, TCan
1749      delete JLcorrJZBSBeemm;
1750    }
1751    if(overlay_signal || use_data==2) delete lm4RcorrJZBeemm;
1429 –  switch_overunderflow(false);
1752   }
1753  
1754   void do_prediction_plots(string mcjzb, string datajzb, float DataSigma, float MCSigma, bool overlay_signal ) {
1755 +  switch_overunderflow(true);
1756    TCanvas *globalcanvas = new TCanvas("globalcanvas","Prediction Canvas");
1757    do_prediction_plot(datajzb,globalcanvas,jzbHigh ,data,overlay_signal);
1758    if ( !PlottingSetup::Approved ) {
# Line 1438 | Line 1761 | void do_prediction_plots(string mcjzb, s
1761    } else {
1762      write_info(__FUNCTION__,"You set approved to true, therefore not producing prediction/observation plots for MC with and without signal.");
1763    }
1764 < }
1765 <
1443 < void do_ratio_plot(int is_data,vector<float> binning, string jzb, TCanvas *can, float high=-9999) {
1444 <  bool do_data=0;
1445 <  bool dosignal=0;
1446 <  if(is_data==1) do_data=1;
1447 <  if(is_data==2) dosignal=1;
1448 <  TH1F *RcorrJZBeemm   = allsamples.Draw("RcorrJZBeemm",jzb.c_str(),binning, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,do_data, luminosity,dosignal);
1449 <  TH1F *LcorrJZBeemm   = allsamples.Draw("LcorrJZBeemm",("-"+jzb).c_str(),binning, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,do_data, luminosity,dosignal);
1450 <  TH1F *RcorrJZBem     = allsamples.Draw("RcorrJZBem",jzb.c_str(),binning, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,do_data, luminosity,dosignal);
1451 <  TH1F *LcorrJZBem     = allsamples.Draw("LcorrJZBem",("-"+jzb).c_str(),binning, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,do_data, luminosity,dosignal);
1452 <  
1453 <  TH1F *RcorrJZBSBem;
1454 <  TH1F *LcorrJZBSBem;
1455 <  TH1F *RcorrJZBSBeemm;
1456 <  TH1F *LcorrJZBSbeemm;
1457 <  
1458 <  if(PlottingSetup::RestrictToMassPeak) {
1459 <    RcorrJZBSBem   = allsamples.Draw("RcorrJZBSbem",jzb.c_str(),binning, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,do_data, luminosity,dosignal);
1460 <    LcorrJZBSBem   = allsamples.Draw("LcorrJZBSbem",("-"+jzb).c_str(),binning, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,do_data, luminosity,dosignal);
1461 <    RcorrJZBSBeemm = allsamples.Draw("RcorrJZBSbeemm",jzb.c_str(),binning, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets,do_data, luminosity,dosignal);
1462 <    LcorrJZBSbeemm = allsamples.Draw("LcorrJZBSbeemm",("-"+jzb).c_str(),binning, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets,do_data, luminosity,dosignal);
1463 <  }
1464 <  
1465 <
1466 <
1467 <
1468 <  flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak
1469 <  TH1F *Bpred = (TH1F*)LcorrJZBeemm->Clone("Bpred");
1470 <  if(PlottingSetup::RestrictToMassPeak) {
1471 <    Bpred->Add(RcorrJZBem,1.0/3);
1472 <    Bpred->Add(LcorrJZBem,-1.0/3);
1473 <    Bpred->Add(RcorrJZBSBem,1.0/3);
1474 <    Bpred->Add(LcorrJZBSBem,-1.0/3);
1475 <    Bpred->Add(RcorrJZBSBeemm,1.0/3);
1476 <    Bpred->Add(LcorrJZBSbeemm,-1.0/3);
1477 <  } else {
1478 <    Bpred->Add(RcorrJZBem,1.0);
1479 <    Bpred->Add(LcorrJZBem,-1.0);
1480 <  }
1481 <
1482 <  can->cd();
1483 <  can->SetLogy(0);
1484 <  Bpred->SetLineColor(kRed);
1485 <  Bpred->SetStats(0);
1486 <  if(high>0) Bpred->GetXaxis()->SetRangeUser(0,high);
1487 <  TH1F *JZBratioforfitting=(TH1F*)RcorrJZBeemm->Clone("JZBratioforfitting");
1488 <  JZBratioforfitting->Divide(Bpred);
1489 <  TGraphAsymmErrors *JZBratio = histRatio(RcorrJZBeemm,Bpred,is_data,binning,false);
1490 <  
1491 <  
1492 <  JZBratio->SetTitle("");
1493 <  JZBratio->GetYaxis()->SetRangeUser(0.0,9.0);
1494 < //  if(is_data==1) JZBratio->GetXaxis()->SetRangeUser(0,jzbHigh );
1495 <  
1496 <  TF1 *pol0 = new TF1("pol0","[0]",0,1000);
1497 <  TF1 *pol0d = new TF1("pol0","[0]",0,1000);
1498 < //  straightline_fit->SetParameter(0,1);
1499 <  JZBratioforfitting->Fit(pol0,"Q0R","",0,30);
1500 <  pol0d->SetParameter(0,pol0->GetParameter(0));
1501 <  
1502 <  JZBratio->GetYaxis()->SetTitle("Observed/Predicted");
1503 <  JZBratio->GetXaxis()->SetTitle("JZB [GeV]");
1504 <  if ( high>0 ) JZBratio->GetXaxis()->SetRangeUser(0.0,high);
1505 <  JZBratio->GetYaxis()->SetNdivisions(519);
1506 <  JZBratio->GetYaxis()->SetRangeUser(0.0,4.0);
1507 <  JZBratio->GetYaxis()->CenterTitle();
1508 <  JZBratio->GetXaxis()->CenterTitle();
1509 <  JZBratio->SetMarkerSize(DataMarkerSize);
1510 <  JZBratio->Draw("AP");
1511 <  /////----------------------------
1512 <  TPaveText *writeresult = new TPaveText(0.15,0.78,0.49,0.91,"blNDC");
1513 <  writeresult->SetFillStyle(4000);
1514 <  writeresult->SetFillColor(kWhite);
1515 <  writeresult->SetTextFont(42);
1516 <  writeresult->SetTextSize(0.03);
1517 <  writeresult->SetTextAlign(12);
1518 <  ostringstream jzb_agreement_data_text;
1519 <  jzb_agreement_data_text<< setprecision(2) << "mean =" << pol0->GetParameter(0) << " #pm " << setprecision(1) <<  pol0->GetParError(0);
1520 <  if(is_data==1) fitresultconstdata=pol0->GetParameter(0);// data
1521 <  if(is_data==0) fitresultconstmc=pol0->GetParameter(0); // monte carlo, no signal
1522 < /*  if(is_data) writeresult->AddText("Data closure test");
1523 <  else writeresult->AddText("MC closure test");
1524 <  */
1525 <  writeresult->AddText(jzb_agreement_data_text.str().c_str());
1526 < //  writeresult->Draw("same");
1527 < //  pol0d->Draw("same");
1528 <  TF1 *topline =  new TF1("","1.5",0,1000);
1529 <  TF1 *bottomline =  new TF1("","0.5",0,1000);
1530 <  topline->SetLineColor(kBlue);
1531 <  topline->SetLineStyle(2);
1532 <  bottomline->SetLineColor(kBlue);
1533 <  bottomline->SetLineStyle(2);
1534 < //  topline->Draw("same");
1535 < //  bottomline->Draw("same");
1536 <  TF1 *oneline = new TF1("","1.0",0,1000);
1537 <  oneline->SetLineColor(kBlue);
1538 <  oneline->SetLineStyle(1);
1539 <  oneline->Draw("same");
1540 <  TLegend *phony_leg = make_legend("ratio",0.6,0.55,false);//this line is just to have the default CMS Preliminary (...) on the canvas as well.
1541 <  if(is_data==1) DrawPrelim();
1542 <  else DrawMCPrelim();
1543 <  TLegend *leg = new TLegend(0.55,0.75,0.89,0.89);
1544 <  leg->SetTextFont(42);
1545 <  leg->SetTextSize(0.04);
1546 < //   if(is_data==1) leg->SetHeader("Ratio (data)");
1547 < //   else leg->SetHeader("Ratio (MC)");
1548 <
1549 <  TString MCtitle("MC ");
1550 <  if (is_data==1) MCtitle = "";
1551 <
1552 <  leg->SetFillStyle(4000);
1553 <  leg->SetFillColor(kWhite);
1554 <  leg->SetTextFont(42);
1555 < //  leg->AddEntry(topline,"+20\% sys envelope","l");
1556 <  leg->AddEntry(JZBratio,MCtitle+"obs / "+MCtitle+"pred","p");
1557 <  leg->AddEntry(oneline,"ratio = 1","l");
1558 < //  leg->AddEntry(pol0d,"fit in [0,30] GeV","l");
1559 < //  leg->AddEntry(bottomline,"#pm50% envelope","l");
1560 <
1561 <
1562 <  //leg->Draw("same"); // no longer drawing legend
1563 <
1564 <  if(is_data==1) CompleteSave(can, "jzb_ratio_data");
1565 <  if(is_data==0) CompleteSave(can, "jzb_ratio_mc");
1566 <  if(is_data==2) CompleteSave(can, "jzb_ratio_mc_BandS");//special case, MC with signal!
1567 <  
1568 <  delete RcorrJZBeemm;
1569 <  delete LcorrJZBeemm;
1570 <  delete RcorrJZBem;
1571 <  delete LcorrJZBem;
1572 <  
1573 <  delete RcorrJZBSBem;
1574 <  delete LcorrJZBSBem;
1575 <  delete RcorrJZBSBeemm;
1576 <  delete LcorrJZBSbeemm;
1577 < }
1578 <
1579 < void do_ratio_plots(string mcjzb,string datajzb,vector<float> ratio_binning) {
1580 <  TCanvas *globalc = new TCanvas("globalc","Ratio Plot Canvas");
1581 <  globalc->SetLogy(0);
1582 <  
1583 <  do_ratio_plot(mc,ratio_binning,mcjzb,globalc, jzbHigh  );
1584 <  do_ratio_plot(data,ratio_binning,datajzb,globalc, jzbHigh  );
1585 <  do_ratio_plot(mcwithsignal,ratio_binning,mcjzb,globalc, jzbHigh  );
1764 >  delete globalcanvas;
1765 >  switch_overunderflow(false);
1766   }
1767  
1768   string give_jzb_expression(float peak, int type) {
# Line 1774 | Line 1954 | void draw_pure_jzb_histo(TCut cut,string
1954    datahisto->Draw("same,e1");
1955    
1956    TLegend *leg;
1957 <  if(is_OF(cut) && is_ZP(cut)) leg = allsamples.allbglegend("OFZP",datahisto);
1958 <  else if(!is_OF(cut) &&  is_ZP(cut)) leg = allsamples.allbglegend("SFZP",datahisto);
1959 <  else if( is_OF(cut) && !is_ZP(cut)) leg = allsamples.allbglegend("OFSB",datahisto);
1960 <  else if(!is_OF(cut) && !is_ZP(cut)) leg = allsamples.allbglegend("SFSB",datahisto);
1961 <  else {
1962 <    std::cerr << "Unable to decode cut: " << cut.GetTitle() << std::endl;
1963 <    exit(-1);
1964 <      }
1957 >  if (!PlottingSetup::RestrictToMassPeak||!PlottingSetup::UseSidebandsForcJZB) {
1958 >    if(is_OF(cut)) leg = allsamples.allbglegend("Opposite flavor",datahisto);
1959 >    else leg = allsamples.allbglegend("Same flavor",datahisto);
1960 >  } else {
1961 >    if(is_OF(cut) && is_ZP(cut)) leg = allsamples.allbglegend("OFZP",datahisto);
1962 >    else if(!is_OF(cut) &&  is_ZP(cut)) leg = allsamples.allbglegend("SFZP",datahisto);
1963 >    else if( is_OF(cut) && !is_ZP(cut)) leg = allsamples.allbglegend("OFSB",datahisto);
1964 >    else if(!is_OF(cut) && !is_ZP(cut)) leg = allsamples.allbglegend("SFSB",datahisto);
1965 >    else {
1966 >      std::cerr << "Unable to decode cut: " << cut.GetTitle() << std::endl;
1967 >      exit(-1);
1968 >    }
1969 >  }
1970    leg->Draw();
1971    string write_cut = decipher_cut(cut,"");
1972    TText *writeline1 = write_cut_on_canvas(write_cut.c_str());
# Line 1832 | Line 2017 | void produce_stretched_jzb_plots(string
2017    draw_pure_jzb_histo(cutOSSF&&cutnJets&&cutmass&&"id1==1",datajzb,mcjzb,"Dibosons/mm/jzb_OS_SFZP",dican,binning);
2018    draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass&&"id1==0",datajzb,mcjzb,"Dibosons/ee/jzb_OS_OFZP",dican,binning);
2019    draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass&&"id1==1",datajzb,mcjzb,"Dibosons/mm/jzb_OS_OFZP",dican,binning);
2020 <  if(PlottingSetup::RestrictToMassPeak) draw_pure_jzb_histo(cutOSSF&&cutnJets&&sidebandcut,datajzb,mcjzb,"Dibosons/jzb_OS_SFSB",dican,binning);
2021 <  if(PlottingSetup::RestrictToMassPeak) draw_pure_jzb_histo(cutOSOF&&cutnJets&&sidebandcut,datajzb,mcjzb,"Dibosons/jzb_OS_OFSB",dican,binning);
2020 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) draw_pure_jzb_histo(cutOSSF&&cutnJets&&sidebandcut,datajzb,mcjzb,"Dibosons/jzb_OS_SFSB",dican,binning);
2021 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) draw_pure_jzb_histo(cutOSOF&&cutnJets&&sidebandcut,datajzb,mcjzb,"Dibosons/jzb_OS_OFSB",dican,binning);
2022    
2023    draw_pure_jzb_histo(cutOSSF&&cutnJets&&cutmass,datajzb,mcjzb,"Dibosons/jzb_OS_SFZP_coarse",dican,coarse_binning);
2024    draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass,datajzb,mcjzb,"Dibosons/jzb_OS_OFZP_coarse",dican,coarse_binning);
2025 <  if(PlottingSetup::RestrictToMassPeak) draw_pure_jzb_histo(cutOSSF&&cutnJets&&sidebandcut,datajzb,mcjzb,"Dibosons/jzb_OS_SFSB_coarse",dican,coarse_binning);
2026 <  if(PlottingSetup::RestrictToMassPeak) draw_pure_jzb_histo(cutOSOF&&cutnJets&&sidebandcut,datajzb,mcjzb,"Dibosons/jzb_OS_OFSB_coarse",dican,coarse_binning);
2025 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) draw_pure_jzb_histo(cutOSSF&&cutnJets&&sidebandcut,datajzb,mcjzb,"Dibosons/jzb_OS_SFSB_coarse",dican,coarse_binning);
2026 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) draw_pure_jzb_histo(cutOSOF&&cutnJets&&sidebandcut,datajzb,mcjzb,"Dibosons/jzb_OS_OFSB_coarse",dican,coarse_binning);
2027    
2028    delete dican;
2029   }
2030    
2031  
2032   void diboson_plots(string mcjzb, string datajzb,vector<float> ratio_binning) {
2033 +  switch_overunderflow(true);
2034    vector<int> SamplesToBeModified = allsamples.FindSampleBySampleName("WW/WZ/ZZ");
2035    
2036    if(SamplesToBeModified.size()==0 || SamplesToBeModified[0]==-1) {
# Line 1884 | Line 2070 | void diboson_plots(string mcjzb, string
2070      dout << "     Reset xs for sample " << (allsamples.collection)[SamplesToBeModified[i]].samplename << " from " << Upxs << " to " << (allsamples.collection)[SamplesToBeModified[i]].xs << " (by a factor of " << stretchfactor << ") and reset the correct name (from " << Upname << ")" << endl;
2071      
2072    }
2073 <  
2073 > //   switch_overunderflow(false);
2074   }
2075  
2076  
# Line 1919 | Line 2105 | void draw_normalized_data_vs_data_histo(
2105  
2106  
2107   void jzb_plots(string mcjzb, string datajzb,vector<float> ratio_binning) {
2108 +  switch_overunderflow(true);
2109    TCanvas *can = new TCanvas("can","JZB Plots Canvas");
2110    float max=jzbHigh ;
2111    float min=-120;
# Line 1939 | Line 2126 | void jzb_plots(string mcjzb, string data
2126      draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass&&"id1==0",datajzb,mcjzb,"ee/jzb_OS_OFZP",can,binning);
2127      draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass&&"id1==1",datajzb,mcjzb,"mm/jzb_OS_OFZP",can,binning);
2128      flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak
2129 <    if(PlottingSetup::RestrictToMassPeak) draw_pure_jzb_histo(cutOSSF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_SFSB",can,binning);
2130 <    if(PlottingSetup::RestrictToMassPeak) draw_pure_jzb_histo(cutOSOF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_OFSB",can,binning);
2129 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) draw_pure_jzb_histo(cutOSSF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_SFSB",can,binning);
2130 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) draw_pure_jzb_histo(cutOSOF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_OFSB",can,binning);
2131      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);
2132      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);
2133      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);
# Line 1951 | Line 2138 | void jzb_plots(string mcjzb, string data
2138    if ( !PlottingSetup::Approved ) {
2139      draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass,datajzb,mcjzb,"jzb_OS_OFZP_coarse",can,coarse_binning);
2140      flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak
2141 <    if(PlottingSetup::RestrictToMassPeak) draw_pure_jzb_histo(cutOSSF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_SFSB_coarse",can,coarse_binning);
2142 <    if(PlottingSetup::RestrictToMassPeak) draw_pure_jzb_histo(cutOSOF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_OFSB_coarse",can,coarse_binning);
2141 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) draw_pure_jzb_histo(cutOSSF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_SFSB_coarse",can,coarse_binning);
2142 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) draw_pure_jzb_histo(cutOSOF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_OFSB_coarse",can,coarse_binning);
2143    }
2144    delete can;
2145 +  switch_overunderflow(false);
2146   }
2147  
2148  
# Line 2004 | Line 2192 | void compute_MC_yields(string mcjzb,vect
2192    TCanvas *yica = new TCanvas("yica","yield canvas");
2193    
2194    int nRegions=4;
2195 <  if(!PlottingSetup::RestrictToMassPeak) nRegions=2;
2195 >  if(!PlottingSetup::RestrictToMassPeak||!PlottingSetup::UseSidebandsForcJZB) nRegions=2;
2196    string tsRegions[] = {"SFZP","OFZP","SFSB","OFSB"};
2197    string posneg[] = {"pos","neg"};
2198    TCut tkRegions[] = {cutOSSF&&cutnJets&&cutmass,cutOSOF&&cutnJets&&cutmass,cutOSSF&&cutnJets&&sidebandcut,cutOSOF&&cutnJets&&sidebandcut};
# Line 2452 | Line 2640 | void save_template(string mcjzb, string
2640    configfile<<"\n\n";
2641    configfile<<"luminosity="<<luminosity<<";\n";
2642    configfile<<"RestrictToMassPeak="<<RestrictToMassPeak<<";//defines the type of analysis we're running\n";
2643 +  configfile<<"UseSidebandsForcJZB="<<UseSidebandsForcJZB<<";//tells us whether to use the sidebands or not\n";
2644    
2645    configfile<<"\n\ncout << \"Configuration successfully loaded!\" << endl; \n \n } \n \n";
2646    
# Line 2494 | Line 2683 | void ttbar_sidebands_comparison(string m
2683    //in the case of the on peak analysis, we compare the 3 control regions to the real value
2684    //in the case of the OFF peak analysis, we compare our control region to the real value
2685    TCut weightbackup=cutWeight;
2686 +  switch_overunderflow(true);
2687    
2688    bool doPURW=false;
2689    
# Line 2515 | Line 2705 | void ttbar_sidebands_comparison(string m
2705        
2706    float simulatedlumi = luminosity; //in pb please - adjust to your likings
2707  
2708 <  TH1F *TZem  = systsamples.Draw("TZem",     mcjzb,binning,"JZB [GeV]","events",cutmass&&cutOSOF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTJets"));
2709 <  TH1F *nTZem = systsamples.Draw("nTZem","-"+mcjzb,binning,"JZB [GeV]","events",cutmass&&cutOSOF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTJets"));
2708 >  TH1F *TZem  = systsamples.Draw("TZem",     mcjzb,binning,"JZB [GeV]","events",cutmass&&cutOSOF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTT"));
2709 >  TH1F *nTZem = systsamples.Draw("nTZem","-"+mcjzb,binning,"JZB [GeV]","events",cutmass&&cutOSOF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTT"));
2710    TH1F *TSem;
2711    TH1F *nTSem;
2712 <  TH1F *TZeemm  = systsamples.Draw("TZeemm",     mcjzb,binning,"JZB [GeV]","events",cutmass&&cutOSSF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTJets"));
2713 <  TH1F *nTZeemm = systsamples.Draw("nTZeemm","-"+mcjzb,binning,"JZB [GeV]","events",cutmass&&cutOSSF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTJets"));
2712 >  TH1F *TZeemm  = systsamples.Draw("TZeemm",     mcjzb,binning,"JZB [GeV]","events",cutmass&&cutOSSF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTT"));
2713 >  TH1F *nTZeemm = systsamples.Draw("nTZeemm","-"+mcjzb,binning,"JZB [GeV]","events",cutmass&&cutOSSF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTT"));
2714    TH1F *TSeemm;
2715    TH1F *nTSeemm;
2716    
2717 <  if(PlottingSetup::RestrictToMassPeak) {
2718 <    TSem    = systsamples.Draw("TSem",       mcjzb,binning,"JZB [GeV]","events",sidebandcut&&cutOSOF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTJets"));
2719 <    nTSem   = systsamples.Draw("nTSem",  "-"+mcjzb,binning,"JZB [GeV]","events",sidebandcut&&cutOSOF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTJets"));
2720 <    TSeemm  = systsamples.Draw("TSeemm",     mcjzb,binning,"JZB [GeV]","events",sidebandcut&&cutOSSF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTJets"));
2721 <    nTSeemm = systsamples.Draw("nTSeemm","-"+mcjzb,binning,"JZB [GeV]","events",sidebandcut&&cutOSSF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTJets"));
2717 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2718 >    TSem    = systsamples.Draw("TSem",       mcjzb,binning,"JZB [GeV]","events",sidebandcut&&cutOSOF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTT"));
2719 >    nTSem   = systsamples.Draw("nTSem",  "-"+mcjzb,binning,"JZB [GeV]","events",sidebandcut&&cutOSOF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTT"));
2720 >    TSeemm  = systsamples.Draw("TSeemm",     mcjzb,binning,"JZB [GeV]","events",sidebandcut&&cutOSSF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTT"));
2721 >    nTSeemm = systsamples.Draw("nTSeemm","-"+mcjzb,binning,"JZB [GeV]","events",sidebandcut&&cutOSSF&&cutnJets,mc,simulatedlumi,systsamples.FindSample("TTT"));
2722    }
2723  
2724    TCanvas *tcan = new TCanvas("tcan","tcan");
# Line 2540 | Line 2730 | void ttbar_sidebands_comparison(string m
2730    TZem->SetMarkerColor(kRed);
2731  
2732  
2733 <  if(PlottingSetup::RestrictToMassPeak) {
2733 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2734          TSem->SetLineColor(TColor::GetColor("#00A616"));
2735          TSeemm->SetLineColor(kMagenta+2);
2736          TSem->SetMarkerColor(TColor::GetColor("#00A616"));
# Line 2554 | Line 2744 | void ttbar_sidebands_comparison(string m
2744    TZeemm->GetXaxis()->SetRangeUser(-100,binning[binning.size()-1]);
2745    histos.push_back(TZem);
2746    histos.push_back(TZeemm);
2747 <  if(PlottingSetup::RestrictToMassPeak) {
2747 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2748      TSeemm->GetXaxis()->SetRangeUser(-100,binning[binning.size()-1]);
2749      TSem->GetXaxis()->SetRangeUser(-100,binning[binning.size()-1]);
2750      histos.push_back(TSem);
2751      histos.push_back(TSeemm);
2752    }
2753 <  draw_all_ttbar_histos(tcan,histos,"histo",1);
2753 >  draw_all_ttbar_histos(tcan,histos,"histo",8);
2754    
2755    TLegend *leg = make_legend("MC t#bar{t}",0.6,0.65,false);
2756    leg->AddEntry(TZeemm,"SFZP","l");
2757    leg->AddEntry(TZem,"OFZP","l");
2758 <  if(PlottingSetup::RestrictToMassPeak) {
2758 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2759      leg->AddEntry(TSeemm,"SFSB","l");
2760      leg->AddEntry(TSem,"OFSB","l");
2761    }
2762    leg->Draw("same");
2763    DrawMCPrelim(simulatedlumi);
2764    CompleteSave(tcan,"Systematics/"+prestring+"/ttbar_shape_comparison");
2765 +  
2766    TH1F *TZemcopy = (TH1F*)TZem->Clone("TZemcopy");
2767    TH1F *TZeemmcopy = (TH1F*)TZeemm->Clone("TZeemmcopy");
2768    TH1F *TSeemmcopy;
2769    TH1F *TSemcopy;
2770 <  if(PlottingSetup::RestrictToMassPeak) {
2770 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2771      TSeemmcopy = (TH1F*)TSeemm->Clone("TSeemmcopy");
2772      TSemcopy = (TH1F*)TSem->Clone("TSemcopy");
2773    }
2774  
2775    TZem->Divide(TZeemm);
2776    TZem->SetMarkerStyle(21);
2777 <  if(PlottingSetup::RestrictToMassPeak) {
2777 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2778      TSem->Divide(TZeemm);
2779      TSeemm->Divide(TZeemm);
2780      TSem->SetMarkerStyle(24);
# Line 2594 | Line 2785 | void ttbar_sidebands_comparison(string m
2785    TZem->GetYaxis()->SetRangeUser(0,2.5);
2786    TZem->GetYaxis()->SetTitle("ratio");
2787    TZem->Draw();
2788 <  if(PlottingSetup::RestrictToMassPeak) {
2788 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2789      TSem->Draw("same");
2790      TSeemm->Draw("same");
2791    }
# Line 2624 | Line 2815 | void ttbar_sidebands_comparison(string m
2815    
2816    TLegend *leg2 = make_legend("MC t#bar{t}",0.55,0.75,false);
2817    leg2->AddEntry(TZem,"OFZP / SFZP","ple");
2818 <  if(PlottingSetup::RestrictToMassPeak) {
2818 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2819      leg2->AddEntry(TSeemm,"SFSB / SFZP","ple");
2820      leg2->AddEntry(TSem,"OFSB / SFZP","ple");
2821    }
# Line 2637 | Line 2828 | void ttbar_sidebands_comparison(string m
2828    DrawMCPrelim(simulatedlumi);
2829    CompleteSave(tcan,"Systematics/"+prestring+"/ttbar_shape_comparison_ratio");
2830    
2831 +  
2832    if (0) { // Turn this off: we don't need this
2833  
2834      ///-------------- second part: only look at the quantity we actually care about!
# Line 2650 | Line 2842 | void ttbar_sidebands_comparison(string m
2842      TH1F *rightofsb;
2843      TH1F *leftsfsb;
2844      TH1F *rightsfsb;
2845 <    if(PlottingSetup::RestrictToMassPeak) {
2845 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2846        leftofsb  = (TH1F*)nTSem->Clone("leftofsb");
2847        rightofsb = (TH1F*)TSemcopy->Clone("rightofsb");
2848        rightofsb->Add(leftofsb,-1);
# Line 2664 | Line 2856 | void ttbar_sidebands_comparison(string m
2856      rightsfzp->GetYaxis()->SetTitle("#deltaJZB / 25 GeV");
2857      rightsfzp->Draw("histo");
2858      rightofzp->Draw("histo,same");
2859 <    if(PlottingSetup::RestrictToMassPeak) {
2859 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2860        rightofsb->Draw("histo,same");
2861        rightsfsb->Draw("histo,same");
2862      }
# Line 2673 | Line 2865 | void ttbar_sidebands_comparison(string m
2865      TLegend *legA = make_legend("MC t#bar{t}",0.6,0.65,false);
2866      legA->AddEntry(rightsfzp,"SFZP","l");
2867      legA->AddEntry(rightofzp,"OFZP","l");
2868 <    if(PlottingSetup::RestrictToMassPeak) {
2868 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2869        legA->AddEntry(rightofsb,"SFSB","l");
2870        legA->AddEntry(rightsfsb,"OFSB","l");
2871      }
# Line 2687 | Line 2879 | void ttbar_sidebands_comparison(string m
2879      rightofzp->GetYaxis()->SetRangeUser(0.0,2.5);
2880      rightofzp->GetYaxis()->SetTitle("#deltaJZB ratio");
2881      rightofzp->Draw();
2882 <    if(PlottingSetup::RestrictToMassPeak) {
2882 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2883        rightofsb->Divide(rightsfzp);
2884        rightsfsb->Divide(rightsfzp);
2885        rightofsb->Draw("same");
# Line 2707 | Line 2899 | void ttbar_sidebands_comparison(string m
2899      bottom2->Draw("same");
2900  
2901      rightofzp->SetMarkerStyle(21);
2902 <    if(PlottingSetup::RestrictToMassPeak) {
2902 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2903        rightofsb->SetMarkerStyle(24);
2904        rightsfsb->SetMarkerStyle(32);
2905      }
2906  
2907      TLegend *leg3 = make_legend("MC t#bar{t}",0.55,0.75,false);
2908      leg3->AddEntry(rightofzp,"OFZP / SFZP","ple");
2909 <    if(PlottingSetup::RestrictToMassPeak) {
2909 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2910        leg3->AddEntry(rightsfsb,"SFSB / SFZP","ple");
2911        leg3->AddEntry(rightofsb,"OFSB / SFZP","ple");
2912      }
# Line 2733 | Line 2925 | void ttbar_sidebands_comparison(string m
2925    delete nTZem;
2926    delete TZeemm;
2927    delete nTZeemm;
2928 <  if(PlottingSetup::RestrictToMassPeak) {
2928 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
2929          delete TSem;
2930          delete nTSem;
2931          delete TSeemm;
# Line 2742 | Line 2934 | void ttbar_sidebands_comparison(string m
2934  
2935    delete tcan;
2936    cutWeight=weightbackup;
2937 +  switch_overunderflow(false);
2938   }
2939  
2940   void ttbar_sidebands_comparison(string mcjzb, vector<float> jzb_binning) {
# Line 2776 | Line 2969 | void ttbar_sidebands_comparison(string m
2969    nicer_binning.push_back(150);
2970    //nicer_binning.push_back(175);
2971    nicer_binning.push_back(200);
2972 <  nicer_binning.push_back(250);
2973 <  nicer_binning.push_back(300);
2974 <  nicer_binning.push_back(400);
2972 > //  nicer_binning.push_back(250);
2973 > //  nicer_binning.push_back(300);
2974 > //  nicer_binning.push_back(400);
2975    
2976    ttbar_sidebands_comparison(mcjzb,nicer_binning, "ttbar/");
2977   }
2978  
2979  
2980 < void zjets_prediction_comparison(string mcjzbWithPUa) {
2980 > void zjets_prediction_comparison(string mcjzbWithPUa, TCut massregioncut, string massregionname) {
2981 >  cout << "****************************************************************************************************************************************************************" << endl;
2982    TCanvas *zcan = new TCanvas("zcan","zcan");  
2983   //  zcan->SetLogy(1);
2984    TCut weightbackup=cutWeight;
2985    
2986 <  bool UsePURW=false;
2986 >  bool UsePURW=true;
2987    
2988    
2989    string mcjzb;
2990    if(UsePURW) {
2991      mcjzb=mcjzbWithPUa;
2992 +    cout << "Using PURW peak positions" << endl;
2993    } else {
2994      // Do it without PU re-weighting
2995 +    cutWeight="1.0";
2996      float MCPeakNoPU=0,MCPeakErrorNoPU=0,DataPeakNoPU=0,DataPeakErrorNoPU=0,MCSigma=0,DataSigma=0;
2997      stringstream resultsNoPU;
2998      stringstream noPUdatajzb;
# Line 2807 | Line 3003 | void zjets_prediction_comparison(string
3003      
3004      mcjzb = noPUmcjzb.str();
3005      
2810 –    cutWeight="1.0";
3006    }
3007  
3008    
# Line 2831 | Line 3026 | void zjets_prediction_comparison(string
3026    string var( "abs("+mcjzb+")" );
3027    
3028    TCut notTau("abs(genMID1)!=15");
3029 <  TCut ONLYTau("mll>20");
3029 >  TCut ee_mm_tautau("mll>0");
3030    
3031  
3032 <  TH1F *hJZBpos = systsamples.Draw("hJZBpos",var,binning, "JZB [GeV]", "events",cutmass&&cutOSSF&&cutnJets&&notTau&&kPos,mc,simulatedlumi,systsamples.FindSample("/DY"));
3033 <  TH1F *hJZBneg = systsamples.Draw("hJZBneg",var,binning, "JZB [GeV]", "events",cutmass&&cutOSSF&&cutnJets&&notTau&&kNeg,mc,simulatedlumi,systsamples.FindSample("/DY"));
3032 >  TH1F *hJZBpos = systsamples.Draw("hJZBpos",var,binning, "JZB [GeV]", "events",cutmass&&cutOSSF&&cutnJets&&notTau&&kPos&&massregioncut,mc,simulatedlumi,systsamples.FindSample("/DY"));
3033 >  TH1F *hJZBneg = systsamples.Draw("hJZBneg",var,binning, "JZB [GeV]", "events",cutmass&&cutOSSF&&cutnJets&&notTau&&kNeg&&massregioncut,mc,simulatedlumi,systsamples.FindSample("/DY"));
3034    
3035    hJZBpos->SetLineColor(kBlack);
3036    hJZBneg->SetLineColor(kRed);
# Line 2850 | Line 3045 | void zjets_prediction_comparison(string
3045    leg->AddEntry(hJZBneg,"Predicted","l");
3046    leg->Draw("same");
3047    DrawMCPrelim(simulatedlumi);
3048 <  CompleteSave(zcan,"Systematics/ZJets/zjets_eemm_prediction");
3048 >  CompleteSave(zcan,"Systematics/ZJets/zjets_eemm_prediction"+any2string(massregionname));
3049    
3050    TH1F* hratio = (TH1F*)hJZBpos->Clone("hratio");
3051    hratio->Divide(hJZBneg);
# Line 2859 | Line 3054 | void zjets_prediction_comparison(string
3054      cout << "Positive: " << hJZBpos->GetBinContent(i) << "   vs    Negative : " << hJZBneg->GetBinContent(i) << "   (ratio : " << hJZBpos->GetBinContent(i) / hJZBneg->GetBinContent(i) << endl;
3055    }
3056    
3057 <  zcan->SetLogy(0);
3058 <  hratio->GetYaxis()->SetRangeUser(0,2.0);
3057 > //  zcan->SetLogy(0);
3058 >  hratio->GetYaxis()->SetRangeUser(0,2.5);
3059    hratio->GetYaxis()->SetTitle("Observed/Predicted");
3060    hratio->Draw("e1");
3061    
# Line 2869 | Line 3064 | void zjets_prediction_comparison(string
3064    TLine *bottom = new TLine(binning[0],0.75,binning[binning.size()-1],0.75);
3065    
3066  
3067 +  cout << __LINE__ << endl;
3068    top->SetLineColor(kBlue);top->SetLineStyle(2);
3069    bottom->SetLineColor(kBlue);bottom->SetLineStyle(2);
3070    center->SetLineColor(kBlue);
# Line 2882 | Line 3078 | void zjets_prediction_comparison(string
3078    leg2->AddEntry(bottom,"syst. envelope","l");
3079    leg2->Draw("same");
3080    DrawMCPrelim(simulatedlumi);
3081 <  CompleteSave(zcan,"Systematics/ZJets/zjets_eemm_prediction_ratio");
3081 >  CompleteSave(zcan,"Systematics/ZJets/zjets_eemm_prediction_ratio"+any2string(massregionname));
3082    
3083    TCut reducedNJets(cutnJets);
3084    
3085 <  TH1F *TAUhJZBpos = systsamples.Draw("TAUhJZBpos",var,binning, "JZB [GeV]", "events",cutmass&&cutOSSF&&reducedNJets&&ONLYTau&&kPos,mc,simulatedlumi,systsamples.FindSample("/DY"));
3086 <  TH1F *LcorrJZBeemm     = systsamples.Draw("LcorrJZBeemm",var,binning, "JZB [GeV]", "events",cutmass&&cutOSSF&&reducedNJets&&ONLYTau&&kNeg,mc,simulatedlumi,systsamples.FindSample("/DY"));
3087 <  TH1F *RcorrJZBem       = systsamples.Draw("RcorrJZBem",var,binning, "JZB [GeV]", "events",cutmass&&cutOSOF&&reducedNJets&&ONLYTau&&kPos,mc,simulatedlumi,systsamples.FindSample("/DY"));
3088 <  TH1F *LcorrJZBem       = systsamples.Draw("LcorrJZBem",var,binning, "JZB [GeV]", "events",cutmass&&cutOSOF&&reducedNJets&&ONLYTau&&kNeg,mc,simulatedlumi,systsamples.FindSample("/DY"));
3085 >  TH1F *TAUhJZBpos       = systsamples.Draw("TAUhJZBpos",var,binning, "JZB [GeV]", "events",cutmass&&cutOSSF&&reducedNJets&&ee_mm_tautau&&kPos&&massregioncut,mc,simulatedlumi,systsamples.FindSample("/DY"));
3086 >  TH1F *LcorrJZBeemm     = systsamples.Draw("LcorrJZBeemm",var,binning, "JZB [GeV]", "events",cutmass&&cutOSSF&&reducedNJets&&ee_mm_tautau&&kNeg&&massregioncut,mc,simulatedlumi,systsamples.FindSample("/DY"));
3087 >  TH1F *RcorrJZBem       = systsamples.Draw("RcorrJZBem",var,binning, "JZB [GeV]", "events",cutmass&&cutOSOF&&reducedNJets&&ee_mm_tautau&&kPos&&massregioncut,mc,simulatedlumi,systsamples.FindSample("/DY"));
3088 >  TH1F *LcorrJZBem       = systsamples.Draw("LcorrJZBem",var,binning, "JZB [GeV]", "events",cutmass&&cutOSOF&&reducedNJets&&ee_mm_tautau&&kNeg&&massregioncut,mc,simulatedlumi,systsamples.FindSample("/DY"));
3089  
3090 +  cout << __LINE__ << endl;
3091    TH1F *RcorrJZBSBem;
3092    TH1F *LcorrJZBSBem;
3093    TH1F *RcorrJZBSBeemm;
3094    TH1F *LcorrJZBSBeemm;
3095  
3096 <  if(PlottingSetup::RestrictToMassPeak) {
3097 <    RcorrJZBSBem   = systsamples.Draw("RcorrJZBSBem",var,binning, "JZB [GeV]", "events",sidebandcut&&cutOSOF&&reducedNJets&&ONLYTau&&kPos,mc,simulatedlumi,systsamples.FindSample("/DY"));
3098 <    LcorrJZBSBem   = systsamples.Draw("LcorrJZBSBem",var,binning, "JZB [GeV]", "events",sidebandcut&&cutOSOF&&reducedNJets&&ONLYTau&&kNeg,mc,simulatedlumi,systsamples.FindSample("/DY"));
3099 <    RcorrJZBSBeemm = systsamples.Draw("RcorrJZBSBeemm",var,binning, "JZB [GeV]", "events",sidebandcut&&cutOSSF&&reducedNJets&&ONLYTau&&kPos,mc,simulatedlumi,systsamples.FindSample("/DY"));
3100 <    LcorrJZBSBeemm = systsamples.Draw("LcorrJZBSBeemm",var,binning, "JZB [GeV]", "events",sidebandcut&&cutOSSF&&reducedNJets&&ONLYTau&&kNeg,mc,simulatedlumi,systsamples.FindSample("/DY"));
3096 >  cout << __LINE__ << endl;
3097 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
3098 >    RcorrJZBSBem   = systsamples.Draw("RcorrJZBSBem",var,binning, "JZB [GeV]", "events",sidebandcut&&cutOSOF&&reducedNJets&&ee_mm_tautau&&kPos&&massregioncut,mc,simulatedlumi,systsamples.FindSample("/DY"));
3099 >    LcorrJZBSBem   = systsamples.Draw("LcorrJZBSBem",var,binning, "JZB [GeV]", "events",sidebandcut&&cutOSOF&&reducedNJets&&ee_mm_tautau&&kNeg&&massregioncut,mc,simulatedlumi,systsamples.FindSample("/DY"));
3100 >    RcorrJZBSBeemm = systsamples.Draw("RcorrJZBSBeemm",var,binning, "JZB [GeV]", "events",sidebandcut&&cutOSSF&&reducedNJets&&ee_mm_tautau&&kPos&&massregioncut,mc,simulatedlumi,systsamples.FindSample("/DY"));
3101 >    LcorrJZBSBeemm = systsamples.Draw("LcorrJZBSBeemm",var,binning, "JZB [GeV]", "events",sidebandcut&&cutOSSF&&reducedNJets&&ee_mm_tautau&&kNeg&&massregioncut,mc,simulatedlumi,systsamples.FindSample("/DY"));
3102    }
3103    
3104    TH1F *Bpred = (TH1F*)LcorrJZBeemm->Clone("Bpred");
3105 <  if(PlottingSetup::RestrictToMassPeak) {
3105 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
3106      Bpred->Add(RcorrJZBem,1.0/3.);
3107      Bpred->Add(LcorrJZBem,-1.0/3.);
3108      Bpred->Add(RcorrJZBSBem,1.0/3.);
# Line 2918 | Line 3116 | void zjets_prediction_comparison(string
3116    
3117    Bpred->SetLineColor(kRed);
3118  
3119 +  cout << __LINE__ << endl;
3120    TAUhJZBpos->SetLineColor(kBlack);
3121    Bpred->SetLineColor(kRed);
3122    
# Line 2931 | Line 3130 | void zjets_prediction_comparison(string
3130    TAUleg->AddEntry(Bpred,"Predicted","l");
3131    TAUleg->Draw("same");
3132    DrawMCPrelim(simulatedlumi);
3133 <  CompleteSave(zcan,"Systematics/ZJets/zjets_eemumutautau_prediction");
3133 >  CompleteSave(zcan,"Systematics/ZJets/zjets_eemumutautau_prediction__"+any2string(massregionname));
3134    
3135    TH1F* TAUhratio = (TH1F*)TAUhJZBpos->Clone("TAUhratio");
3136    TAUhratio->Divide(Bpred);
# Line 2949 | Line 3148 | void zjets_prediction_comparison(string
3148    center->Draw("same");
3149    bottom->Draw("same");
3150    
3151 <  TLegend *TAUleg2 = make_legend("MC Z+jets #rightarrow #tau#tau",0.25,0.75,false);
3151 >  TLegend *TAUleg2 = make_legend("MC Z+jets #rightarrow ee,#mu#mu",0.25,0.75,false);
3152    TAUleg2->AddEntry(TAUhratio,"obs / pred","pe");
3153    TAUleg2->AddEntry(bottom,"syst. envelope","l");
3154    TAUleg2->Draw("same");
3155    DrawMCPrelim(simulatedlumi);
3156 <  CompleteSave(zcan,"Systematics/ZJets/zjets_eemumutautau_prediction_ratio");
3156 >  CompleteSave(zcan,"Systematics/ZJets/zjets_eemumutautau_prediction_ratio"+any2string(massregionname));
3157    
3158    delete Bpred;
3159    delete TAUhJZBpos;
3160    delete LcorrJZBeemm;
3161    delete RcorrJZBem;
3162    delete LcorrJZBem;
3163 +  delete hJZBpos;
3164 +  delete hJZBneg;
3165    
3166 <  if(PlottingSetup::RestrictToMassPeak) {
3166 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
3167      delete RcorrJZBSBem;
3168      delete LcorrJZBSBem;
3169      delete RcorrJZBSBeemm;
# Line 2973 | Line 3174 | void zjets_prediction_comparison(string
3174    delete zcan;
3175    cutWeight=weightbackup;
3176  
3177 +  cout << __LINE__ << endl;
3178   }
3179  
3180  
3181 <
3181 > void zjets_prediction_comparison(string mcjzbWithPUa) {
3182 >  zjets_prediction_comparison(mcjzbWithPUa, TCut(""), "nomasscut");
3183 >  zjets_prediction_comparison(mcjzbWithPUa, TCut("abs(mll-91)<20"), "Zwindow_20");
3184 >  zjets_prediction_comparison(mcjzbWithPUa, TCut("mll>20&&mll<70"), "LowMassRegion2070");
3185 >  zjets_prediction_comparison(mcjzbWithPUa, TCut("mll>110"), "HighMassRegion110");
3186 > }
3187 >  
3188   void sideband_assessment(string datajzb, float min=30.0, float max=50.0) {
3189    tout << endl << endl;
3190    stringstream bordercut;
# Line 3027 | Line 3235 | void make_table(samplecollection &coll,
3235      TH1F *RcorrJZBSBeemm;
3236      TH1F *LcorrJZBSBeemm;
3237      
3238 <    if(PlottingSetup::RestrictToMassPeak) {
3238 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
3239        RcorrJZBSBem   = coll.Draw("RcorrJZBSBem",jzbexpr.c_str(),nbins,low,14000, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity, mysample);
3240        LcorrJZBSBem   = coll.Draw("LcorrJZBSBem",("-("+jzbexpr+")").c_str(),nbins,low,14000, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity, mysample);
3241        RcorrJZBSBeemm = coll.Draw("RcorrJZBSBeemm",jzbexpr.c_str(),nbins,low,14000, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity, mysample);
# Line 3035 | Line 3243 | void make_table(samplecollection &coll,
3243      }
3244      
3245      TH1F *Bpred = (TH1F*)LcorrJZBeemm->Clone("Bpred");
3246 <    if(PlottingSetup::RestrictToMassPeak) {
3246 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
3247        Bpred->Add(RcorrJZBem,1.0/3.);
3248        Bpred->Add(LcorrJZBem,-1.0/3.);
3249        Bpred->Add(RcorrJZBSBem,1.0/3.);
# Line 3246 | Line 3454 | void qcd_plots(string datajzb, string mc
3454    TH1F *JRcorrJZBSBeemm;
3455    TH1F *JLcorrJZBSBeemm;
3456    
3457 <  if(PlottingSetup::RestrictToMassPeak) {
3457 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
3458      RcorrJZBSBem   = qcdsamples.Draw("RcorrJZBSBem",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
3459      LcorrJZBSBem   = qcdsamples.Draw("LcorrJZBSBem",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
3460      RcorrJZBSBeemm = qcdsamples.Draw("RcorrJZBSBeemm",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
# Line 3267 | Line 3475 | void qcd_plots(string datajzb, string mc
3475      
3476    TH1F *Bpred = (TH1F*)LcorrJZBeemm->Clone("Bpred");
3477    TH1F *JBpred = (TH1F*)JLcorrJZBeemm->Clone("Bpred");
3478 <  if(PlottingSetup::RestrictToMassPeak) {
3478 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
3479      Bpred->Add(RcorrJZBem,1.0/3.);
3480      Bpred->Add(LcorrJZBem,-1.0/3.);
3481      Bpred->Add(RcorrJZBSBem,1.0/3.);
# Line 3337 | Line 3545 | void qcd_plots(string datajzb, string mc
3545    dout << "______________________________________________" << endl;
3546    dout << "How QCD shows up in the different regions: " << endl;
3547    dout << "OSSF: " << endl;
3548 <  if(PlottingSetup::RestrictToMassPeak) {
3548 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
3549      dout << "     Z window: \t" << RcorrJZBeemm->Integral() << " (JZB>0) , " << LcorrJZBeemm->Integral() << " (JZB<0) --> total: " << RcorrJZBeemm->Integral() + LcorrJZBeemm->Integral() << endl;
3550      dout << "     sideband: \t" << RcorrJZBSBeemm->Integral() << " (JZB>0) , " << LcorrJZBSBeemm->Integral() << " (JZB<0) --> total: " << RcorrJZBSBeemm->Integral() + LcorrJZBSBeemm->Integral() << endl;
3551    } else {
3552      dout << "     " << RcorrJZBeemm->Integral() << " (JZB>0) , " << LcorrJZBeemm->Integral() << " (JZB<0) --> total: " << RcorrJZBeemm->Integral() + LcorrJZBeemm->Integral() << endl;
3553    }
3554    dout << "OSOF: " << endl;
3555 <  if(PlottingSetup::RestrictToMassPeak) {
3555 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
3556      dout << "     Z window: \t" << RcorrJZBem->Integral() << " (JZB>0) , " << LcorrJZBem->Integral() << " (JZB<0) --> total: " << RcorrJZBem->Integral() + LcorrJZBem->Integral() << endl;
3557      dout << "     sideband: \t" << RcorrJZBSBem->Integral() << " (JZB>0) , " << LcorrJZBSBem->Integral() << " (JZB<0) --> total: " << RcorrJZBSBem->Integral() + LcorrJZBSBem->Integral() << endl;
3558    } else {
3559      dout << "     Z window: \t" << RcorrJZBem->Integral() << " (JZB>0) , " << LcorrJZBem->Integral() << " (JZB<0) --> total: " << RcorrJZBem->Integral() + LcorrJZBem->Integral() << endl;
3560    }
3561    dout << "Therefore: " << endl;
3562 <  if(PlottingSetup::RestrictToMassPeak) {
3562 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
3563      dout << "    Prediction increases by : " << LcorrJZBeemm->Integral() << " + (1.0/3)*(" << RcorrJZBSBeemm->Integral() <<"-"<< LcorrJZBSBeemm->Integral() << ") (SFSB) ";
3564      dout << " + (1.0/3)*(" << RcorrJZBem->Integral() <<"-"<< LcorrJZBem->Integral() << ") (OFZP) ";
3565      dout << " + (1.0/3)*(" << RcorrJZBSBem->Integral() <<"-"<< LcorrJZBSBem->Integral() << ") (OFSB) ";
# Line 3367 | Line 3575 | void qcd_plots(string datajzb, string mc
3575    for(int i=0;i<(int)bins.size();i++) {
3576      dout << " JZB > " << bins[i] << " : " << endl;
3577      dout << "    Observation increases by : " << RcorrJZBeemm->Integral(RcorrJZBeemm->FindBin(bins[i]),RcorrJZBeemm->GetNbinsX()) << endl;
3578 <    if(PlottingSetup::RestrictToMassPeak) {
3578 >    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
3579          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;
3580      } else {
3581          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 3381 | Line 3589 | void qcd_plots(string datajzb, string mc
3589    if(LcorrJZBem) delete LcorrJZBem;
3590    if(RcorrJZBeemm) delete RcorrJZBeemm;
3591    if(LcorrJZBeemm) delete LcorrJZBeemm;
3592 <  if(PlottingSetup::RestrictToMassPeak&&RcorrJZBSBem) delete RcorrJZBSBem;
3593 <  if(PlottingSetup::RestrictToMassPeak&&LcorrJZBSBem) delete LcorrJZBSBem;
3594 <  if(PlottingSetup::RestrictToMassPeak&&RcorrJZBSBeemm) delete RcorrJZBSBeemm;
3595 <  if(PlottingSetup::RestrictToMassPeak&&LcorrJZBSBeemm) delete LcorrJZBSBeemm;
3592 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB&&RcorrJZBSBem) delete RcorrJZBSBem;
3593 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB&&LcorrJZBSBem) delete LcorrJZBSBem;
3594 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB&&RcorrJZBSBeemm) delete RcorrJZBSBeemm;
3595 >  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB&&LcorrJZBSBeemm) delete LcorrJZBSBeemm;
3596   }
3597  
3598   void check_ptsanity() {
# Line 3481 | Line 3689 | void do_mlls_plot(string mcjzb) {
3689    }
3690   }
3691  
3692 < void met_vs_jzb_plots() {
3692 > void met_vs_jzb_plots(string datajzb, string mcjzb) {
3693    
3694    TCanvas *canmetjzb = new TCanvas("canmet","MET vs JZB canvas");
3695    canmetjzb->SetRightMargin(0.16);
# Line 3490 | Line 3698 | void met_vs_jzb_plots() {
3698    findme.push_back("DY");
3699    findme.push_back("TTJets");
3700    findme.push_back("LM");
3701 <  
3701 >  /*
3702    for(int ifind=0;ifind<(int)findme.size();ifind++) {
3703      vector<int> selsamples = allsamples.FindSample(findme[ifind]);
3704      TH2F *metvsjzb = new TH2F("metvsjzb","metvsjzb",200,0,100,400,-100,100);
3705      for(int isel=0;isel<(int)selsamples.size();isel++) {
3706 <      cout << "Producing MET:JZB plot ... working on sample: " << allsamples.collection[selsamples[isel]].filename << endl;
3707 <      allsamples.collection[selsamples[isel]].events->Draw("jzb[1]:met[4]>>+metvsjzb",cutmass&&cutOSSF);
3706 >      dout << "Producing MET:JZB plot ... working on sample: " << allsamples.collection[selsamples[isel]].filename << endl;
3707 >      allsamples.collection[selsamples[isel]].events->Draw("jzb[1]:met[4]>>+metvsjzb",cutmass&&cutOSSF&&cutnJets);
3708      }
3709      metvsjzb->Scale(allsamples.collection[selsamples[0]].weight);
3710      metvsjzb->SetStats(0);
# Line 3510 | Line 3718 | void met_vs_jzb_plots() {
3718      title->Draw();
3719      CompleteSave(canmetjzb,(string)"METvsJZBplots/"+findme[ifind]);
3720    }
3721 +  */
3722 +  
3723 +  dout << "About to produce MET plot for DY split up by JZB" << endl;
3724 +  
3725 +  int nbins=14;
3726 +  float low=0;
3727 +  float high=140;
3728 +  
3729 +  stringstream sLEFT;
3730 +  sLEFT << "((" << mcjzb << ")<0)";
3731 +  TCut LEFT(sLEFT.str().c_str());
3732 +  stringstream sRIGHT;
3733 +  sRIGHT << "((" << mcjzb << ")>0)";
3734 +  TCut RIGHT(sRIGHT.str().c_str());
3735 +  
3736 +  TH1F *metleft   = allsamples.Draw("metleft","met[4]",nbins,low,high, "MET [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&LEFT,mc, luminosity, allsamples.FindSample("DYJets"));
3737 +  TH1F *metleftO  = allsamples.Draw("metleftO","met[4]",nbins,low,high, "MET [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&LEFT,mc, luminosity, allsamples.FindSample("DYJets"));
3738 +  TH1F *metright  = allsamples.Draw("metright","met[4]",nbins,low,high, "MET [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&RIGHT,mc, luminosity, allsamples.FindSample("DYJets"));
3739 +  TH1F *metrightO = allsamples.Draw("metrightO","met[4]",nbins,low,high, "MET [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&RIGHT,mc, luminosity, allsamples.FindSample("DYJets"));
3740 +  
3741 +  
3742 +  TH1F *Bpred =  (TH1F*)metleft->Clone("Bpred");
3743 +  Bpred->Add(metleftO,-1);
3744 +  Bpred->Add(metrightO);
3745 +  TH1F *obs = (TH1F*)metright->Clone("obs");
3746 +  
3747 +  metleft->Add(metleftO,-1);
3748 +  metright->Add(metrightO,-1);
3749 +  
3750 +  metleft->SetLineColor(kRed);
3751 +  metright->SetLineColor(kBlack);
3752 +  TPad *metpad = new TPad("metpad","metpad",0,0,1,1);
3753 +  metpad->cd();
3754 +  metpad->SetLogy(1);
3755 +  metleft->Draw("histo");
3756 +  metright->Draw("same");
3757 +  TLegend *lg = make_legend();
3758 +  lg->SetX1(0.5);
3759 +  lg->SetY1(0.7);
3760 +  lg->AddEntry(metright,"JZB>0 (OSOF corrected)","P");
3761 +  lg->AddEntry(metleft,"JZB<0 (OSOF corrected)","L");
3762 +  lg->SetHeader("DY");
3763 +  
3764 +  lg->Draw();
3765 +  save_with_ratio(metright,metleft,metpad->cd(),"METvsJZBplots/ComparingLeftToRightinMETspectrum");
3766 +  
3767 +  TPad *metpad3 = new TPad("metpad3","metpad3",0,0,1,1);
3768 +  metpad3->cd();
3769 +  metpad3->SetLogy(1);
3770 +  Bpred->SetLineColor(kRed);
3771 +  Bpred->Draw("histo");
3772 +  obs->SetLineColor(kBlack);
3773 +  obs->Draw("same");
3774 +  TLegend *lg2 = make_legend();
3775 +  lg2->SetX1(0.5);
3776 +  lg2->SetY1(0.7);
3777 +  lg2->AddEntry(obs,"observed","P");
3778 +  lg2->AddEntry(Bpred,"predicted","L");
3779 +  lg2->SetHeader("DY");
3780 +
3781 +  lg2->Draw();
3782 +  
3783 +  save_with_ratio(obs,Bpred,metpad3->cd(),"METvsJZBplots/ComparingPredObsinMET");
3784 +  
3785 +  TPad *metpad2 = new TPad("metpad2","metpad2",0,0,1,1);
3786 +  metpad2->cd();
3787 +  metpad2->SetLogy(1);
3788 +  
3789 +  TH1F *metlefta   = allsamples.Draw("metlefta","met[2]",nbins,low,high, "MET [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&LEFT,mc, luminosity, allsamples.FindSample("DYJets"));
3790 +  TH1F *metleftOa  = allsamples.Draw("metleftOa","met[2]",nbins,low,high, "MET [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&LEFT,mc, luminosity, allsamples.FindSample("DYJets"));
3791 +  TH1F *metrighta  = allsamples.Draw("metrighta","met[2]",nbins,low,high, "MET [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&RIGHT,mc, luminosity, allsamples.FindSample("DYJets"));
3792 +  TH1F *metrightOa = allsamples.Draw("metrightOa","met[2]",nbins,low,high, "MET [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&RIGHT,mc, luminosity, allsamples.FindSample("DYJets"));
3793 +  
3794 +  metlefta->Add(metleftOa,-1);
3795 +  metrighta->Add(metrightOa,-1);
3796 +  
3797 +  metlefta->SetLineColor(kRed);
3798 +  metpad2->cd();
3799 +  metlefta->Draw("histo");
3800 +  metrighta->Draw("same");
3801 +  lg->Draw();
3802 +  save_with_ratio(metrighta,metlefta,metpad2->cd(),"METvsJZBplots/ComparingLeftToRightinMET_type1_spectrum");
3803 +  
3804 +  delete Bpred;
3805 +  delete obs;
3806 +  
3807 +  float newhigh=300;
3808 +  int newNBins=30;
3809 +  
3810 +  TPad *metpad4 = new TPad("metpad4","metpad4",0,0,1,1);
3811 +  TH1F *Ametleft   = allsamples.Draw("Ametleft","met[4]",newNBins,low,newhigh, "MET [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&LEFT,mc, luminosity);
3812 +  TH1F *AmetleftO  = allsamples.Draw("AmetleftO","met[4]",newNBins,low,newhigh, "MET [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&LEFT,mc, luminosity);
3813 +  TH1F *Ametright  = allsamples.Draw("Ametright","met[4]",newNBins,low,newhigh, "MET [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&RIGHT,mc, luminosity);
3814 +  TH1F *AmetrightO = allsamples.Draw("AmetrightO","met[4]",newNBins,low,newhigh, "MET [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&RIGHT,mc, luminosity);
3815 +  
3816 +  TH1F *aBpred = (TH1F*)Ametleft->Clone("aBpred");
3817 +  aBpred->Add(AmetleftO,-1);
3818 +  aBpred->Add(AmetrightO);
3819 +  aBpred->SetLineColor(kRed);
3820 +  
3821 +  TH1F *aobs = (TH1F*)Ametright->Clone("aobs");
3822 +  metpad4->cd();
3823 +  metpad4->SetLogy(1);
3824 +  aobs->Draw();
3825 +  aBpred->Draw("histo,same");
3826 +  aobs->Draw("same");
3827 +  lg->SetHeader("All MC");
3828 +  lg->Draw();
3829 +  save_with_ratio(aobs,aBpred,metpad4->cd(),"METvsJZBplots/ComparingPredObsinMET_ALLSAMPLES");
3830 +  
3831 +  
3832 +  delete lg;
3833 +  delete canmetjzb;
3834 +  delete metleft;
3835 +  delete metleftO;
3836 +  delete metright;
3837 +  delete metrightO;
3838   }
3839      
3840  

Diff Legend

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