Plotting/Modules/Plotting_Functions.C

#include <iostream>
#include <vector>
#include <sys/stat.h>

#include <TCut.h>
#include <TROOT.h>
#include <TCanvas.h>
#include <TMath.h>
#include <TColor.h>
#include <TPaveText.h>
#include <TRandom.h>
#include <TH1.h>
#include <TH2.h>
#include <TF1.h>
#include <TSQLResult.h>
#include <TProfile.h>
#include <TLegendEntry.h>

using namespace std;

using namespace PlottingSetup;

void todo() {
  dout << "My to do list: " << endl;
  dout << "  - ExperimentalModule::Poisson_ratio_plot : Get the second part to work!" << endl;
  dout << "  - compare_onpeak_offpeak_signal_distributions: Implement this function ... " << endl;
  dout << "Info : The trigger requirement is currently set to " << (const char*) passtrig << endl;
  dout << "Info : The pt requirement is currently set to " << (const char*) passtrig << endl;
  dout << "Info : The mll requirement is currently set to " << (const char*) cutmass << endl;
  dout << "Info : The lepton requirement is currently set to " << (const char*) leptoncut << endl;
  dout << "Info : The weight applied to all MC is " << (const char*) cutWeight << endl;
}  


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="")
{
  // Temporarily switch off PU reweighting, if asked
  TCut weightbackup=cutWeight;
  if ( !doPUreweighting ) cutWeight="1.0";
  
  int nbins=100;
  if(PlottingSetup::DoBTag) nbins=25;
  
  TCut nJetsCut(cutnJets);
  if(SwitchOffNJetsCut) nJetsCut=specialcut;
  
  TCanvas *tempcan = new TCanvas("tempcan","Temporary canvas for peak finding preparations");
  TH1F *rawJZBeemmMC      = allsamples.Draw("rawJZBeemmMC",jzbvariablemc,nbins,-50,50, "JZB [GeV]", "events", cutmass&&cutOSSF&&nJetsCut&&specialcut,mc, luminosity);
  TH1F *rawJZBeemmData    = allsamples.Draw("rawJZBeemmData",jzbvariabledata,nbins, -50,50, "JZB [GeV]", "events", cutmass&&cutOSSF&&nJetsCut&&specialcut,data, luminosity);
  TH1F *rawJZBemMC      = allsamples.Draw("rawJZBemMC",jzbvariablemc,nbins,-50,50, "JZB [GeV]", "events", cutmass&&cutOSOF&&nJetsCut&&specialcut,mc, luminosity);
  TH1F *rawJZBemData    = allsamples.Draw("rawJZBemData",jzbvariabledata,nbins, -50,50, "JZB [GeV]", "events", cutmass&&cutOSOF&&nJetsCut&&specialcut,data, luminosity);
  TH1F *rawttbarjzbeemmMC;

  if(method==doKM) {
    //we only need this histo for the KM fitting...
    rawttbarjzbeemmMC = allsamples.Draw("rawttbarjzbeemmMC",jzbvariablemc,nbins, -50,50, "JZB [GeV]", "events",cutmass&&cutOSSF&&nJetsCut&&specialcut,mc,luminosity,allsamples.FindSample("TTJet"));
    MCPeak=find_peak(rawJZBeemmMC, rawttbarjzbeemmMC, -40, 40, mc, MCPeakError,MCSigma,MCSigmaError,method,saveas);
    DataPeak=find_peak(rawJZBeemmData, rawJZBeemmData, -40, 40, data, DataPeakError,DataSigma,DataSigmaError,method,saveas);
    delete rawttbarjzbeemmMC;
  }
  else {
    TH1F *reducedMC = (TH1F*)rawJZBeemmMC->Clone();
    TH1F *reducedData = (TH1F*)rawJZBeemmData->Clone();
    reducedMC->Add(rawJZBemMC,-1);
    reducedData->Add(rawJZBemData,-1);
    //this is Kostas' way of doing it - we subtract em to get rid of some of the ttbar contribution (in reality, of flavor-symmetric contribution)
    MCPeak=find_peak(reducedMC, rawttbarjzbeemmMC, -40, 40, mc, MCPeakError,MCSigma,MCSigmaError,method,saveas);
    DataPeak=find_peak(reducedData, rawJZBeemmData, -40, 40, data, DataPeakError,DataSigma,DataSigmaError,method,saveas);
    delete reducedMC;
    delete reducedData;
  }

  // Revert to original PU reweighting
  if ( !doPUreweighting ) cutWeight = weightbackup;
    
//  MCPeak=find_peak(rawJZBeemmMC, rawttbarjzbeemmMC, -40, 40, mc, MCPeakError,MCSigma,method);
//  DataPeak=find_peak(rawJZBeemmData, rawJZBeemmData, -40, 40, data, DataPeakError,DataSigma,method);
  dout   << "   We have found the peak in Data at " << DataPeak << " +/- " << DataPeakError << " with sigma=" << DataSigma << " +/- " << DataSigmaError << endl;
  result << "   We have found the peak in Data at " << DataPeak << " +/- " << DataPeakError << " with sigma=" << DataSigma << " +/- " << DataSigmaError << endl;
  dout   << "   We have found the peak in MC at " << MCPeak << " +/- " << MCPeakError << " with sigma=" << MCSigma << " +/- " << MCSigmaError << endl;
  result << "   We have found the peak in MC at " << MCPeak << " +/- " << MCPeakError << " with sigma=" << MCSigma << " +/- " << MCSigmaError << endl;
  delete rawJZBeemmData;
  delete rawJZBeemmMC;
  delete rawJZBemData;
  delete rawJZBemMC;
  delete tempcan;
}

void find_peaks(float &MCPeak,float &MCPeakError, float &DataPeak, float &DataPeakError, stringstream &result, bool doPUreweighting, stringstream &datajzb, stringstream &mcjzb, string sSpecialCut="", bool SwitchOffNJetsCut=false)
{
  bool overunderflowstatus=addoverunderflowbins;
  switch_overunderflow(false);
  
  TCut SpecialCut("mll>=0");
  if(sSpecialCut!="") SpecialCut=TCut(sSpecialCut.c_str());
  
  bool DoInvidualeemmPeaks=false;
  
  float mcpeak, datapeak;
  float mcpeakerr, datapeakerr;
  
  float mceepeak,mcmmpeak;
  float mceepeakerr,mcmmpeakerr;
  
  float datammpeak,dataeepeak;
  float datammpeakerr,dataeepeakerr;
  
  float mcSigma,mcSigmaError, dataSigma, dataSigmaError;
  
  dout << "Finding global peak : " << endl;
  find_one_peak_combination(SpecialCut,SwitchOffNJetsCut,mcpeak,mcpeakerr, datapeak,datapeakerr,mcSigma,mcSigmaError, dataSigma,dataSigmaError,result,doPUreweighting,"");
  
  if(DoInvidualeemmPeaks) {
    dout << "Finding peak for electrons : " << endl;
    find_one_peak_combination(SpecialCut&&TCut("id1==0"),SwitchOffNJetsCut,mceepeak,mceepeakerr,dataeepeak,dataeepeakerr,mcSigma,mcSigmaError,dataSigma,dataSigmaError,result,doPUreweighting,"_ele");
    dout << "Finding peak for muons : " << endl;
    find_one_peak_combination(SpecialCut&&TCut("id1==1"),SwitchOffNJetsCut,mcmmpeak,mcmmpeakerr,datammpeak,datammpeakerr,mcSigma,mcSigmaError,dataSigma,dataSigmaError,result,doPUreweighting,"_mu");
    
    datajzb << "(" << jzbvariabledata;
    mcjzb << "(" << jzbvariablemc;
    
    if(dataeepeak>0) datajzb << "- (id1==id2)*(id1==0)*" << TMath::Abs(dataeepeak) << " ";
    else datajzb << "+ (id1==id2)*(id1==0)*" << TMath::Abs(dataeepeak) << " ";
    
    if(datammpeak>0) datajzb << "- (id1==id2)*(id1==1)*" << TMath::Abs(datammpeak) << " ";
    else datajzb << "+ (id1==id2)*(id1==1)*" << TMath::Abs(datammpeak) << " ";
    
    if(datapeak>0) datajzb << "- (id1!=id2)*" << TMath::Abs(datapeak) << " ";
    else datajzb << "+ (id1!=id2)*" << TMath::Abs(datapeak) << " ";
    
    datajzb << ")";
    
    if(mceepeak>0) mcjzb << "- (id1==id2)*(id1==0)*" << TMath::Abs(mceepeak) << " ";
    else mcjzb << "+ (id1==id2)*(id1==0)*" << TMath::Abs(mceepeak) << " ";
    
    if(mcmmpeak>0) mcjzb << "- (id1==id2)*(id1==1)*" << TMath::Abs(mcmmpeak) << " ";
    else mcjzb << "+ (id1==id2)*(id1==1)*" << TMath::Abs(mcmmpeak) << " ";
    
    if(mcpeak>0) mcjzb << "- (id1!=id2)*" << TMath::Abs(mcpeak) << " ";
    else mcjzb << "+ (id1!=id2)*" << TMath::Abs(mcpeak) << " ";
    
    mcjzb << ")";
    
  } else {
    datajzb << "(" << jzbvariabledata;
      mcjzb << "(" << jzbvariablemc;
    
    if(datapeak>0) datajzb << "- " << TMath::Abs(datapeak) << " ";
    else datajzb << "+ " << TMath::Abs(datapeak) << " ";
    
    datajzb << ")";
    
    if(mcpeak>0) mcjzb << "- " << TMath::Abs(mcpeak) << " ";
    else mcjzb << "+ " << TMath::Abs(mcpeak) << " ";
    
    mcjzb << ")";
  }
  
    MCPeak=mcpeak;
    MCPeakError=mcpeakerr;
    DataPeak=datapeak;
    DataPeakError=datapeakerr;
    switch_overunderflow(overunderflowstatus);
}

void make_special_obs_pred_mll_plot(string datajzb, string mcjzb, float jzbthreshold, float binWidth = 5.0) {
  float min=70.0;
  float max=115.0;
  if(!PlottingSetup::RestrictToMassPeak) {
    min=20;
    max=300;
  }
  int nbins=int((max-min)/binWidth);
  
  TCanvas *ckin = new TCanvas("ckin","Kinematic Plots (in the making)",600,600);
  
  stringstream largerzeroS;
  largerzeroS << "(" << datajzb << ">" << jzbthreshold << ")";
  TCut largerzeroD(largerzeroS.str().c_str());
  
  stringstream smallerzeroS;
  smallerzeroS << "(" << datajzb << "<-" << jzbthreshold << ")";
  TCut smallerzeroD(smallerzeroS.str().c_str());


  stringstream largerzeroMS;
  largerzeroMS << "(" << mcjzb << ">" << jzbthreshold << ")";
  TCut largerzeroM(largerzeroMS.str().c_str());
  
  TH1F *RcorrJZBeemm     = allsamples.Draw("RcorrJZBeemm",       "mll",nbins,min,max, "m_{ll} [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&largerzeroD,data,luminosity);
  THStack mcRcorrJZBeemm = allsamples.DrawStack("mcRcorrJZBeemm","mll",nbins,min,max, "m_{ll} [GeV}", "events", cutmass&&cutOSSF&&cutnJets&&largerzeroM,mc,luminosity);
  TH1F *LcorrJZBeemm     = allsamples.Draw("LcorrJZBeemm",       "mll",nbins,min,max, "m_{ll} [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&smallerzeroD,data,luminosity);
  TH1F *RcorrJZBem       = allsamples.Draw("RcorrJZBem",         "mll",nbins,min,max, "m_{ll} [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&largerzeroD,data,luminosity);
  TH1F *LcorrJZBem       = allsamples.Draw("LcorrJZBem",         "mll",nbins,min,max, "m_{ll} [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&smallerzeroD,data,luminosity);

  TH1F *RcorrJZBSBem;
  TH1F *LcorrJZBSBem;
  TH1F *RcorrJZBSBeemm;
  TH1F *LcorrJZBSBeemm;
  
//  TH1F *RcorrJZBeemmNoS;

  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
    RcorrJZBSBem   = allsamples.Draw("RcorrJZBSBem",  "mll",nbins,min,max, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets&&largerzeroD,data, luminosity);
    LcorrJZBSBem   = allsamples.Draw("LcorrJZBSBem",  "mll",nbins,min,max, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets&&smallerzeroD,data, luminosity);
    RcorrJZBSBeemm = allsamples.Draw("RcorrJZBSBeemm","mll",nbins,min,max, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets&&largerzeroD,data, luminosity);
    LcorrJZBSBeemm = allsamples.Draw("LcorrJZBSBeemm","mll",nbins,min,max, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets&&smallerzeroD,data, luminosity);
  }
  
  // Separate predictions
  TH1F* SFN = (TH1F*)LcorrJZBeemm->Clone("SFN");
  TH1F* OFP = (TH1F*)RcorrJZBem->Clone("OFP");
  TH1F* OFN = (TH1F*)LcorrJZBem->Clone("OFN");
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
    OFP->Scale(1.0/3.0);
    OFP->Add(RcorrJZBSBem,1.0/3.);
    OFP->Add(RcorrJZBSBeemm,1.0/3.);
    OFN->Scale(1.0/3.0);
    OFN->Add(LcorrJZBSBem,1.0/3.);
    OFN->Add(LcorrJZBSBeemm,1.0/3.);
  } 

  TH1F* Bpred = (TH1F*)SFN->Clone("Bpred");
  Bpred->Add(OFP);
  Bpred->Add(OFN,-1);
  Bpred->SetLineColor(kRed);
  
  RcorrJZBeemm->SetTitleOffset(1.3,"y");
  RcorrJZBeemm->Draw();
  mcRcorrJZBeemm.Draw("histo,same");
  Bpred->Draw("histo,same");
  RcorrJZBeemm->Draw("same");
  
  TLegend *leg = allsamples.allbglegend();
  leg->SetX1(0.58);
  leg->AddEntry(RcorrJZBeemm,"observed (data)","l");
  leg->AddEntry(Bpred,"predicted (data)","l");
  leg->Draw("same");
  
  stringstream saveas;
  saveas << "kin/Mll_After_Cut/Cut_At" << jzbthreshold;
  CompleteSave(ckin,saveas.str());
  
  // Draw all predictions overlayed
  unsigned int w = gStyle->GetHistLineWidth()+1; // Make line a bit wider, since we dash it
  SFN->SetLineColor(kGreen+2);
  SFN->SetLineStyle(2);
  SFN->SetLineWidth(w);
  OFP->SetLineColor(kBlue+2);
  OFP->SetLineStyle(2);
  OFP->SetLineWidth(w);
  OFN->SetLineColor(kMagenta+2);
  OFN->SetLineStyle(3);
  OFN->SetLineWidth(w);
  
  RcorrJZBeemm->Draw();
  SFN->Draw("histo,same");
  OFP->Draw("histo,same");
  OFN->Draw("histo,same");
  Bpred->Draw("histo,same");
  RcorrJZBeemm->Draw("same");
  
  TLegend *leg2 = make_legend("",0.52,0.7);
  leg2->AddEntry(RcorrJZBeemm,"observed (data)","lp");
  leg2->AddEntry(Bpred,"predicted (data)","l");
  leg2->AddEntry(SFN,  "  SF JZB<0","l");
  leg2->AddEntry(OFN,  "  OF JZB<0","l");
  leg2->AddEntry(OFP,  "  OF JZB>0","l");
  leg2->Draw("same");
  
  saveas.str("");
  saveas << "kin/Mll_After_Cut/Cut_At" << jzbthreshold << "_nomc";
  CompleteSave(ckin,saveas.str());
  
  delete RcorrJZBeemm;
  delete LcorrJZBeemm;
  delete RcorrJZBem;
  delete LcorrJZBem;
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
    delete RcorrJZBSBeemm;
    delete LcorrJZBSBeemm;
    delete RcorrJZBSBem;
    delete LcorrJZBSBem;
  }
  delete Bpred;
  delete ckin;
}

void make_special_mll_plot(int nbins, float min, float max, bool logscale,string xlabel) {
  
  TCanvas *ckin = new TCanvas("ckin","Kinematic Plots (in the making)",600,600);

  TH1F *datahistoOSSF = allsamples.Draw("datahistoOSSF","mll",nbins,min,max, xlabel, "events",cutOSSF&&cutnJets&&basiccut,data,luminosity);
  THStack mcstackOSSF = allsamples.DrawStack("mcstackOSSF","mll",nbins,min,max, xlabel, "events",cutOSSF&&cutnJets&&basiccut,mc,luminosity);
  TH1F *datahistoOSOF = allsamples.Draw("datahistoOSOF","mll",nbins,min,max, xlabel, "events",cutOSOF&&cutnJets&&basiccut,data,luminosity);
  
  if(logscale) ckin->SetLogy(1);
  datahistoOSSF->SetMarkerSize(DataMarkerSize);
  datahistoOSSF->GetXaxis()->SetTitle(xlabel.c_str());
  datahistoOSSF->GetXaxis()->CenterTitle();
  datahistoOSSF->GetYaxis()->SetTitle("events");
  datahistoOSSF->GetYaxis()->CenterTitle();
  datahistoOSOF->SetMarkerSize(DataMarkerSize);
  datahistoOSSF->SetMarkerSize(DataMarkerSize);
  datahistoOSSF->Draw();

  mcstackOSSF.Draw("histo,same");
  datahistoOSSF->Draw("same");

  datahistoOSOF->SetMarkerColor(TColor::GetColor("#FE642E"));
  datahistoOSOF->SetLineColor(kRed);
  datahistoOSOF->SetMarkerStyle(21);
  datahistoOSOF->Draw("same");

  // Try to re-arrange legend...
  TLegend *bgleg = allsamples.allbglegend("",datahistoOSSF);
  TLegend *kinleg = make_legend();
  kinleg->AddEntry(datahistoOSSF,"SF (data)","p");
  kinleg->AddEntry(datahistoOSOF,"OF (data)","p");
  TIter next(bgleg->GetListOfPrimitives());
  TObject* obj;
  // Copy the nice bkgd legend skipping the "data"
  while ( (obj = next()) ) 
    if ( strcmp(((TLegendEntry*)obj)->GetObject()->GetName(),"datahistoOSSF") )
      kinleg->GetListOfPrimitives()->Add(obj);

  kinleg->Draw();
  CompleteSave(ckin,"kin/mll_ossf_osof_distribution");
  
  delete datahistoOSOF;
  delete datahistoOSSF;
  delete ckin;
}
  

void draw_ratio_plot(TH1* hdata, THStack& hmc, float ymin=0.5, float ymax=1.5) {

  // Make a histogram from stack
  TIter next(hmc.GetHists());
  TObject* obj;
  TH1* hratio = NULL;
  while ( (obj = next()) ) {
    if ( !hratio ) {
      hratio = (TH1*)obj->Clone();
      hratio->SetName("hratio");
    } else hratio->Add( (TH1*)obj );
  }
  hratio->Divide(hdata);
  hratio->SetMaximum(ymax);
  hratio->SetMinimum(ymin);
  hratio->SetMarkerStyle(2);
  hratio->SetLineWidth(1);
  hratio->GetYaxis()->SetLabelSize(0.08);
  hratio->GetXaxis()->SetLabelSize(0.0);

  TPad* rpad = new TPad("rpad","",0.15,0.73,0.4,0.88);
  rpad->SetTopMargin(0.0);
  rpad->SetBottomMargin(0.0);
  rpad->SetRightMargin(0.0);
  rpad->Draw();
  rpad->cd();
//  hratio->GetXaxis()->SetNdivisions(0);
  hratio->GetYaxis()->SetNdivisions(502,false);
  hratio->Draw("e1x0");

  TF1* oneline = new TF1("","1.0",0,1000);
  oneline->SetLineColor(kBlue);
  oneline->SetLineStyle(1); 
  oneline->SetLineWidth(1);
  oneline->Draw("same"); 
}

float make_one_OFSF_plot(string variable, string addcut, string legendTitle, int nbins, float min, float max, float ymax, bool logscale,
                        string xlabel, string filename, float legendPosition=0.55) {

  TCut ibasiccut=basiccut;
  bool draw_separation_lines=false;

  if(addcut != "") ibasiccut = ibasiccut && addcut.c_str();

  TCut cutSF;
  TCut cutOF;

  cutOF = cutOSOF&&cutnJets&&ibasiccut;
  cutSF = cutOSSF&&cutnJets&&ibasiccut;
  
  TCanvas *ofsf_can = new TCanvas("ofsf_can","ofsf_can");

  TPad* rcan = new TPad("rcan","rcan",0,0,1,1);
  rcan->SetLogy(logscale);
  rcan->cd();

  std::cout << "OF/SF comparison: variable = " << variable << ", cut = " << cutSF.GetTitle() << std::endl;
  TH1F *datahistoSF = allsamples.Draw("datahistoSF",variable,nbins,min,max, xlabel, "events",cutSF,data,luminosity);
  TH1F *datahistoOF = allsamples.Draw("datahistoOF",variable,nbins,min,max, xlabel, "events",cutOF,data,luminosity);
//   string signal("LM3");
//   TH1F* signalhisto = new TH1F("signalhisto",signal.c_str(),nbins,min,max);
//   int idx = signalsamples.FindSample(signal)[0];
//   (signalsamples.collection)[idx].events->Project("signalhisto",variable.c_str(),cutSF);
//   signalhisto->Scale((signalsamples.collection)[idx].weight*luminosity);
//   signalhisto->SetLineColor((signalsamples.collection)[idx].samplecolor);
//   signalhisto->SetLineStyle(2);
  datahistoSF->SetMarkerSize(DataMarkerSize);
  datahistoOF->SetLineColor(kRed);

  if ( !logscale ) {
    datahistoSF->SetMinimum(0); // Defaults
  } else {
    datahistoSF->SetMinimum(0.5);
  }
  if (ymax<0) {
    if ( logscale ) datahistoSF->SetMaximum(5.3*datahistoSF->GetMaximum());
    else datahistoSF->SetMaximum(0.8*datahistoSF->GetMaximum());
  } else {
    datahistoSF->SetMaximum(ymax);
  }

  float ymaxSet = datahistoSF->GetMaximum(); 

  datahistoSF->GetXaxis()->SetTitle(xlabel.c_str());
  datahistoSF->GetYaxis()->SetTitle("Events");
  datahistoSF->GetXaxis()->CenterTitle();
  datahistoSF->GetYaxis()->CenterTitle();

  TLegend *mleg = make_legend(legendTitle.c_str(),legendPosition,0.7,false,legendPosition+0.2);
  mleg->AddEntry(datahistoSF, "Same-flavor", "PL");
  if (datahistoOF->Integral()>0) {
    mleg->AddEntry(datahistoOF, "Opposite-flavor", "L");
  } else {
    mleg->AddEntry((TObject*)0, "", "");
  }
  //mleg->AddEntry(signalhisto, "LM3", "L");

  datahistoSF->Draw("E1");
  if (datahistoOF->Integral()>0) datahistoOF->Draw("HIST,SAMES");
  //signalhisto->Draw("HIST,SAMES");
  mleg->Draw();
  DrawPrelim();
  if (datahistoOF->Integral()>0) {
    Save_With_Ratio( datahistoSF, datahistoOF, rcan, "SFOF/" + filename, false, false, "SF/OF" );
  } else {
    CompleteSave(rcan, "SFOF/" + filename);
  }

  datahistoSF->Delete();
  datahistoOF->Delete();
  //signalhisto->Delete();
  delete mleg;
  delete rcan;
  delete ofsf_can;

  return ymaxSet;

}

// Compare data to data
float make_data_comparison_plot(string variable, TCut cut, int nbins, float min, float max, float ymax, bool logscale,
                                string xlabel, string filename, float legendPosition=0.55) {

  TCut ibasiccut=basiccut&&cut;

  TCanvas *ckin = new TCanvas("ckin","Kinematic Plots (in the making)",600,600);
  TPad* rcan = new TPad("rcan","rcan",0,0,1,1);
  rcan->SetLogy(logscale);
  rcan->cd();

  std::cout << "Data comparison: variable = " << variable << ", cut = " << ibasiccut.GetTitle() << std::endl;

  TH1F *data1 = allsamples.Draw("data1",variable,nbins,min,max, xlabel, "events",ibasiccut,data,luminosity);
  TH1F *data2 = comparesamples.Draw("data2",variable,nbins,min,max, xlabel, "events",ibasiccut,data,luminosity);
  data1->Scale(5.0/9.2);

  data1->SetMarkerSize(DataMarkerSize);
  data2->SetLineColor(kRed);

  if ( !logscale ) {
    data1->SetMinimum(0); // Defaults
  } else {
    data1->SetMinimum(0.5);
  }
  if (ymax<0) {
    if ( logscale ) data1->SetMaximum(5.3*data1->GetMaximum());
    else data1->SetMaximum(1.5*data1->GetMaximum());
  } else {
    data1->SetMaximum(ymax);
  }

  float ymaxSet = data1->GetMaximum(); 

  data1->GetXaxis()->SetTitle(xlabel.c_str());
  data1->GetYaxis()->SetTitle("Events");
  data1->GetXaxis()->CenterTitle();
  data1->GetYaxis()->CenterTitle();

  TLegend *mleg = make_legend("",legendPosition,0.7,false,legendPosition+0.2);
  mleg->AddEntry(data1, "2012 data (scaled)", "PL");
  mleg->AddEntry(data2, "2011 data", "L");

  data1->Draw("E1");
  data2->Draw("HIST,SAMES");
  mleg->Draw();
  DrawPrelim();
  Save_With_Ratio( data1, data2, rcan, "compareData/" + filename, false, false, "new/old" );

  data1->Delete();
  data2->Delete();
  delete mleg;
  delete rcan;
  delete ckin;

}

void make_OFSF_plots(string variable, string addcut, int nbins, float min, float max, bool logscale, 
                     string xlabel, string filename, float legendPosition=0.55) {

  string mllcuts[] = { "mll>20","mll>15&&mll<70", "mll>75&&mll<105", "mll>120" };
  string mllcutname[] = { "m_{ll} > 20 GeV", "20 < m_{ll} < 70 GeV", "70 < m_{ll} < 110 GeV", "m_{ll} > 120 GeV" };
  string plotname[] = {"_all","_low","_peak","_high"};
  float ymax;

  int start = 0;
  if ( !PlottingSetup::openBox ) start = 3;

  for ( int i=start; i<4; ++i ) {
    if ( addcut != "" ) mllcuts[i] += "&&"+addcut;
    if ( i==start ) {
      ymax = make_one_OFSF_plot(variable, mllcuts[i], mllcutname[i], nbins, min, max, -1, logscale, xlabel, 
                         filename+plotname[i], legendPosition );
    } else {
      make_one_OFSF_plot(variable, mllcuts[i],        mllcutname[i], nbins, min, max, ymax, logscale, xlabel, 
                         filename+plotname[i], legendPosition );
    }
    make_one_OFSF_plot(variable, "id1==1&&id1==id2&&"+mllcuts[i], mllcutname[i], nbins, min, max, ymax, logscale, xlabel, 
                       filename+plotname[i]+"_mm", legendPosition );
    make_one_OFSF_plot(variable, "id1==0&&id1==id2&&"+mllcuts[i], mllcutname[i], nbins, min, max, ymax, logscale, xlabel, 
                       filename+plotname[i]+"_ee", legendPosition );
  }

}

TCut ReplaceInCut(TCut cut, string replacethis, string withthis) {
  string scut=(string)(const char*)cut;
  string acut=ReplaceAll(scut,replacethis,withthis);
  return TCut(acut.c_str());
}

void DoMCSystPlot(string datavariable, string mcvariable, int nbins, float min, float max, TCut addcut, bool dolog, string xlabel, string filename) {
  TCut cut=addcut&&basiccut;

  TCanvas *ckin = new TCanvas("ckin","Kinematic Plots (in the making)",600,600);
  ckin->SetLogy(dolog);
  cout << "\r Creating " << filename << " : data   (1/6)" << std::flush;
  TH1F *datahisto = allsamples.Draw("datahisto",datavariable,nbins,min,max, xlabel, "events",cut,data,luminosity);
  datahisto->SetMarkerSize(DataMarkerSize);
  if ( !dolog ) datahisto->SetMinimum(0); // Defaults
  else datahisto->SetMinimum(0.5);
  if (dolog) datahisto->SetMaximum(5.3*datahisto->GetMaximum());
  else datahisto->SetMaximum(1.3*datahisto->GetMaximum());
  cout << "\r Creating " << filename << " : MC central   (2/6)" << std::flush;
  THStack mcstack   = allsamples.DrawStack("mcstack",  mcvariable,nbins,min,max,xlabel,"events",cut,mc,luminosity);
  TH1F *MCcentral = CollapseStack(mcstack);

  TCut bkpcut = cut;
  cut = ReplaceInCut(cut,"pfJetGoodNum40","pfJetGoodNum40p1sigma");
  cout << "\r Creating " << filename << " : MC JES up   (3/6)" << std::flush;
  TH1F *MCJESup   = allsamples.Draw("MCJESup",  mcvariable,nbins,min,max,xlabel,"events",cut,mc,luminosity);

  cut = ReplaceInCut(cut,"pfJetGoodNum40p1sigma","pfJetGoodNum40n1sigma");
  cout << "\r Creating " << filename << " : MC JES down   (4/6)" << std::flush;
  TH1F *MCJESdn   = allsamples.Draw("MCJESdn",  mcvariable,nbins,min,max,xlabel,"events",cut,mc,luminosity);
  
  cut=bkpcut;
  TCut bkpweight = cutWeight;
  cutWeight= ReplaceInCut(cutWeight,"weight","PUweightUP");
  cout << "\r Creating " << filename << " : MC PU up   (5/6)" << std::flush;
  TH1F *MCPUup    = allsamples.Draw("MCPUup",   mcvariable,nbins,min,max,xlabel,"events",cut,mc,luminosity);
  
  cutWeight= ReplaceInCut(cutWeight,"PUweightUP","PUweightDOWN");
  cout << "\r Creating " << filename << " : MC PU down   (6/6)" << std::flush;
  TH1F *MCPUdn    = allsamples.Draw("MCPUdn",   mcvariable,nbins,min,max,xlabel,"events",cut,mc,luminosity);
  cutWeight=bkpweight;
  cout << "\r Creating " << filename << " : Processing systematics ..." << std::flush;
  TH1F *Systematic = (TH1F*)MCPUdn->Clone("Systematic");
  for(int i=1;i<=Systematic->GetNbinsX();i++) {
    float jesdn = abs(MCcentral->GetBinContent(i)-MCJESdn->GetBinContent(i));
    float jesup = abs(MCcentral->GetBinContent(i)-MCJESup->GetBinContent(i));
    float jes   = jesdn>jesup?jesdn:jesup;
    
    float PUup = abs(MCcentral->GetBinContent(i)-MCPUup->GetBinContent(i));
    float PUdn = abs(MCcentral->GetBinContent(i)-MCPUdn->GetBinContent(i));
    float pu   = PUdn>PUup?PUdn:PUup;
    
    float sys=sqrt(jes*jes+pu*pu);
    sys/=MCcentral->GetBinContent(i);
    if(MCcentral->GetBinContent(i)==0) sys=0;
    Systematic->SetBinContent(i,sys);
  }
  
  datahisto->Draw("e1");
  ckin->Update();
  mcstack.Draw("histo,same");
  
  datahisto->Draw("same,e1");
  TLegend *kinleg = allsamples.allbglegend();
  kinleg->Draw();

  TPad *kinpad = new TPad("kinpad","kinpad",0,0,1,1);
  kinpad->SetLogy(dolog);
  kinpad->cd();
  datahisto->Draw("e1");
  mcstack.Draw("histo,same");
  datahisto->Draw("same,e1");
  datahisto->Draw("same,axis");
  
  kinleg->Draw("same");
  DrawPrelim();
  string saveas="kin/"+filename;
  
  cout << "Passing filename to be saved : " << filename << " as " << saveas << endl;
  save_with_ratio_and_sys_band( datahisto, CollapseStack(mcstack), kinpad->cd(), saveas, false, false, "data/mc",Systematic );
  
  ckin->cd();
  MCcentral->SetFillColor(kWhite);
  MCcentral->SetLineColor(kBlack);
  MCcentral->SetLineWidth(2);
  MCPUdn->SetLineColor(kRed);
  MCPUup->SetLineColor(kYellow);
  MCJESdn->SetLineColor(kBlue);
  MCJESup->SetLineColor(kGreen);
  
  TLegend *legsmall = new TLegend(0.0,0.85,1.0,1.00);
  legsmall->SetNColumns(5);
  legsmall->AddEntry(MCcentral,"central","L");
  legsmall->AddEntry(MCPUdn,"PU down","L");
  legsmall->AddEntry(MCPUup,"PU up","L");
  legsmall->AddEntry(MCJESdn,"JES down","L");
  legsmall->AddEntry(MCJESup,"JES up","L");
  legsmall->SetFillColor(kWhite);
  legsmall->SetBorderSize(0);
  
  datahisto->Draw("e1");
  MCcentral->Draw("histo,same");
  MCPUdn->Draw("histo,same");
  MCPUup->Draw("histo,same");
  MCJESdn->Draw("histo,same");
  MCJESup->Draw("histo,same");
  datahisto->Draw("e1,same");
  legsmall->Draw();
  CompleteSave(ckin,saveas+"___AllLines");
  
  delete datahisto;
  delete MCcentral;
  delete MCPUdn;
  delete MCPUup;
  delete MCJESdn;
  delete MCJESup;
  delete ckin;
}

void DoMCSystPlot(string variable, int nbins, float min, float max, TCut addcut, bool dolog, string xlabel, string filename) {
  DoMCSystPlot(variable, variable, nbins, min, max, addcut, dolog, xlabel, filename);
}
  
float lastrange_min=0;
float lastrange_max=0;

void make_kin_plot(string variable, string addcut, int nbins, float min, float max, bool logscale,
                   string xlabel, string filename, bool isPF=true, bool plotratio=true, bool loadlastminmax=false ) {
//  TCut basiccut("(pfJetGoodNum>=2&&pfJetGoodID[0])&&(pfJetGoodNum>=2&&pfJetGoodID[1])&&(passed_triggers||!is_data)");
  TCut ibasiccut=basiccut;
  bool draw_separation_lines=false;
  bool drawsignal = false;
  
  if(isPF) ibasiccut=basiccut&&"pfjzb[0]>-998";

  if(addcut != "") ibasiccut = ibasiccut && addcut.c_str();

  //Step 1: Adapt the variable (if we're dealing with PF we need to adapt the variable!)
  if(isPF) {
    if(variable=="mll") variable="pfmll[0]";
    if(variable=="jetpt[0]") variable="pfJetGoodPt[0]";
    if(variable=="jeteta[0]") variable="pfJetGoodEta[0]";
    if(variable=="pt") variable="pfpt[0]";
    if(variable=="pt1") variable="pfpt1[0]";
    if(variable=="pt2") variable="pfpt2[0]";
    if(variable=="eta1") variable="pfeta1[0]";
    if(variable=="jzb[1]") variable="pfjzb[0]";
    //if(variable=="pfJetGoodNum") variable="pfJetGoodNum"; // pointless.
  }

  //Step 2: Refine the cut
  TCut cut;
  cut=cutmass&&cutOSSF&&cutnJets&&ibasiccut;
  if(filename=="nJets" || filename=="nJets_inclusive" || filename=="nJets_met100" || filename=="nJets_inclusive_met100") cut=cutmass&&cutOSSF&&ibasiccut;
  if(filename=="nJets_osof" || filename=="nJets_osof_inclusive" || filename=="nJets_osof_met100" || filename=="nJets_osof_inclusive_met100") cut=cutmass&&cutOSOF&&ibasiccut;
  if(filename=="nJets_nocuts_except_mll_ossf") cut=cutmass&&cutOSSF;
  if(filename=="mll"||filename=="mll_met100") {
        cut=cutOSSF&&cutnJets&&ibasiccut;
        draw_separation_lines=true;
  }
  if(filename=="mll_ee"||filename=="mll_ee_met100") cut=cutOSSF&&cutnJets&&ibasiccut&&"id1==0";
  if(filename=="mll_mm"||filename=="mll_mm_met100") cut=cutOSSF&&cutnJets&&ibasiccut&&"id1==1";
  if(filename=="mll_osof"||filename=="mll_osof_met100") {
        cut=cutOSOF&&cutnJets&&ibasiccut;
        draw_separation_lines=true;
  }
  if(Contains(filename,"aboveJZB")) cut=cutOSSF&&cutnJets&&ibasiccut;
  if(Contains(filename,"mll_ee_above")) cut=cut&&"id1==0";
  if(Contains(filename,"mll_mm_above")) cut=cut&&"id1==1";
  if(Contains(filename,"mll_osof_aboveJZB")) cut=cutOSOF&&cutnJets&&ibasiccut;
  if(filename=="mll_inclusive"||filename=="mll_inclusive_highrange") cut=cutOSSF;
  if(filename=="mll_inclusive_osof") cut=cutOSOF;
  if(filename=="mll_inclusive_ee") cut=cutOSSF&&"id1==0";
  if(filename=="mll_inclusive_mm") cut=cutOSSF&&"id1==1";
  if(filename=="pfJetGoodEta_0") cut=cutOSSF&&cutmass&&ibasiccut&&cutnJets;
  if(filename=="pfJetGoodPt_0") cut=cutOSSF&&cutmass&&ibasiccut&&cutnJets;
  if(filename=="numVtx") cut=cutmass&&ibasiccut;

  TCanvas *ckin = new TCanvas("ckin","Kinematic Plots (in the making)",600,600);
  ckin->SetLogy(logscale);
  TH1F *datahisto = allsamples.Draw("datahisto",variable,nbins,min,max, xlabel, "events",cut,data,luminosity);
  datahisto->SetMarkerSize(DataMarkerSize);
  if ( !logscale ) datahisto->SetMinimum(0); // Defaults
  else datahisto->SetMinimum(0.5);
  // Custom max.
  if(variable=="TMath::Abs(pfJetDphiMet[0])") datahisto->SetMaximum(1.5*datahisto->GetMaximum());
  if(variable=="pfJetGoodPt[0]") datahisto->SetMaximum(10*datahisto->GetMaximum());
  if(variable=="pt") datahisto->SetMaximum(10*datahisto->GetMaximum());
  if(filename=="mll_inclusive"||filename=="mll_inclusive_mm"||filename=="mll_inclusive_ee") datahisto->SetMinimum(1);
  if(filename=="mll_osof") datahisto->SetMaximum(10*datahisto->GetMaximum());
  if(filename=="mll_osof") datahisto->SetMinimum(9);
  if (logscale) datahisto->SetMaximum(5.3*datahisto->GetMaximum());
  else datahisto->SetMaximum(1.3*datahisto->GetMaximum());

  cout << "******** Cut used : " << (const char*) cut << " for plot " << filename << endl;
  if(loadlastminmax) {
        datahisto->SetMinimum(lastrange_min);
        datahisto->SetMaximum(lastrange_max);
        if(logscale) {
                datahisto->SetMinimum(pow(10,lastrange_min));
                datahisto->SetMaximum(pow(10,lastrange_max));
        }               
  }

  // Draw signal by hand (for some reason I don't manage to use the sample class: it adds it to the stack!)
  string signal("LM3");
  TH1F* signalhisto = new TH1F("signalhisto",signal.c_str(),nbins,min,max);
  int idx = signalsamples.FindSample(signal)[0];
  if(drawsignal) (signalsamples.collection)[idx].events->Project("signalhisto",variable.c_str(),cut);
  if(drawsignal) signalhisto->Scale((signalsamples.collection)[idx].weight*luminosity);
  if(drawsignal) signalhisto->SetLineColor(kOrange);

  THStack mcstack   = allsamples.DrawStack("mcstack",  variable,nbins,min,max,xlabel,"events",cut,mc,luminosity);
  datahisto->Draw("e1");
  ckin->Update();
  mcstack.Draw("histo,same");
  
  datahisto->Draw("same,e1");
  TLegend *kinleg = allsamples.allbglegend();
  kinleg->Draw();
  if(filename=="mll_osof") {
        kinleg->SetHeader("Opposite flavor");
        kinleg->SetX1(0.58);
  }
  if(filename=="mll") {
        kinleg->SetHeader("Same flavor");
        kinleg->SetX1(0.58);
  }  
  TText* write_cut = write_cut_on_canvas(decipher_cut(cut,basicqualitycut));
  write_cut->Draw();
  TText* write_variable = write_text(0.99,0.01,variable);
  write_variable->SetTextAlign(31);
  write_variable->SetTextSize(0.02);

  TLine *lowerboundary;
  TLine *upperboundary;

  if(RestrictToMassPeak&&draw_separation_lines) {
        Color_t linecolor=kBlue;
        float linemin=pow(10,ckin->GetUymin());
        if(filename=="mll_osof") linemin=pow(10,lastrange_min);
        lowerboundary = new TLine(71,linemin,71,datahisto->GetMaximum());
        upperboundary = new TLine(111,linemin,111,datahisto->GetMaximum());
        lowerboundary->SetLineColor(linecolor);
        lowerboundary->SetLineStyle(2);
        upperboundary->SetLineColor(linecolor);
        upperboundary->SetLineStyle(2);
  }

  lastrange_min=ckin->GetUymin();
  lastrange_max=ckin->GetUymax();


  if ( plotratio ) {
        TPad *kinpad = new TPad("kinpad","kinpad",0,0,1,1);
        kinpad->cd();
        kinpad->SetLogy(logscale);
        datahisto->Draw("e1");
        mcstack.Draw("histo,same");
        if(drawsignal) signalhisto->Draw("same");
        datahisto->Draw("same,e1");
        datahisto->Draw("same,axis");
        if(RestrictToMassPeak&&draw_separation_lines) {
          lowerboundary->Draw("same");
          upperboundary->Draw("same");
        }
          
        if(drawsignal) kinleg->AddEntry("signalhisto",signal.c_str(),"l");
        kinleg->Draw();
        write_cut->Draw();
        DrawPrelim();
        string saveas="kin/"+filename;
        if(isPF) saveas="kin/"+filename+"__PF";
        Save_With_Ratio(datahisto,mcstack,kinpad->cd(),saveas);
//      if(isPF) CompleteSave(with_ratio,"kin/"+filename+"__PF_withratio");
//      else CompleteSave(with_ratio,"kin/"+filename+"_withratio");
//      delete with_ratio;
  } else {
        if(isPF) CompleteSave(ckin,"kin/"+filename+"__PF");
        else CompleteSave(ckin,"kin/"+filename);
  }
  datahisto->Delete();
  delete signalhisto;
  delete ckin;
}


void make_plain_kin_plot(string variable, string addcut, int nbins, float min, float max, bool logscale,
                   string xlabel, string filename, bool isPF=true, bool plotratio=true, bool loadlastminmax=false ) {
  TCut cut=TCut(addcut.c_str())&&basiccut;

  TCanvas *ckin = new TCanvas("ckin","Kinematic Plots (in the making)",600,600);
  ckin->SetLogy(logscale);
  TH1F *datahisto = allsamples.Draw("datahisto",variable,nbins,min,max, xlabel, "events",cut,data,luminosity);
  datahisto->SetMarkerSize(DataMarkerSize);
  if ( !logscale ) datahisto->SetMinimum(0); // Defaults
  else datahisto->SetMinimum(0.5);
  // Custom max.
  if (logscale) datahisto->SetMaximum(5.3*datahisto->GetMaximum());
  else datahisto->SetMaximum(1.3*datahisto->GetMaximum());

  cout << "******** Cut used : " << (const char*) cut << " for plot " << filename << endl;
  if(loadlastminmax) {
        datahisto->SetMinimum(lastrange_min);
        datahisto->SetMaximum(lastrange_max);
        if(logscale) {
                datahisto->SetMinimum(pow(10,lastrange_min));
                datahisto->SetMaximum(pow(10,lastrange_max));
        }               
  }

  THStack mcstack   = allsamples.DrawStack("mcstack",  variable,nbins,min,max,xlabel,"events",cut,mc,luminosity);
  datahisto->Draw("e1");
  ckin->Update();
  mcstack.Draw("histo,same");
  
  datahisto->Draw("same,e1");
  TLegend *kinleg = allsamples.allbglegend();
  kinleg->Draw();

  lastrange_min=ckin->GetUymin();
  lastrange_max=ckin->GetUymax();

  if ( plotratio ) {
        TPad *kinpad = new TPad("kinpad","kinpad",0,0,1,1);
        kinpad->cd();
        kinpad->SetLogy(logscale);
        datahisto->Draw("e1");
        mcstack.Draw("histo,same");
        datahisto->Draw("same,e1");
        datahisto->Draw("same,axis");
          
        kinleg->Draw();
        DrawPrelim();
        string saveas="kin/"+filename;
        if(isPF) saveas="kin/"+filename+"__PF";
        Save_With_Ratio(datahisto,mcstack,kinpad->cd(),saveas);
  } else {
        if(isPF) CompleteSave(ckin,"kin/"+filename+"__PF");
        else CompleteSave(ckin,"kin/"+filename);
  }
  datahisto->Delete();
  delete ckin;
}


void make_JES_plot(TCut cut, string name) {

  int nbins=10;
  float min=-0.5;
  float max = 9.5;
  bool logscale=true;
  string xlabel="nJets";

  TCanvas *ckin = new TCanvas("ckin","Kinematic Plots (in the making)",600,600);
  ckin->SetLogy(logscale);
  TH1F *datahisto = allsamples.Draw("datahisto","pfJetGoodNum40",nbins,min,max, xlabel, "events",cut,data,luminosity);
  datahisto->SetMarkerSize(DataMarkerSize);
  THStack mcstack = allsamples.DrawStack("mcstack","pfJetGoodNum40",nbins,min,max, xlabel, "events",cut,mc,luminosity);
  TH1F *JESup = allsamples.Draw("JESup","pfJetGoodNum40p1sigma",nbins,min,max, xlabel, "events",cut,mc,luminosity);
  TH1F *JESdn = allsamples.Draw("JESdn","pfJetGoodNum40n1sigma",nbins,min,max, xlabel, "events",cut,mc,luminosity);

  datahisto->SetMinimum(1);
  datahisto->SetMaximum(5.3*datahisto->GetMaximum()); // in line with kinematic plots style

  float xs[nbins],ys[nbins],exs[nbins],eys[nbins];
  for(int i=1;i<JESup->GetNbinsX();i++) {
    float up=JESup->GetBinContent(i);
    float dn=JESdn->GetBinContent(i);
    xs[i]=JESup->GetBinCenter(i);
    ys[i]=0.5*(up+dn);
    exs[i]=0.5*JESup->GetBinWidth(i);
    eys[i]=0.5*TMath::Abs(up-dn);
  }

  TGraphAsymmErrors *JESunc = new TGraphAsymmErrors(nbins, xs,ys,exs,exs,eys,eys);
  JESunc->SetFillColor(TColor::GetColor("#00ADE1"));
  JESunc->SetFillStyle(3002);
  datahisto->Draw("e1");
  mcstack.Draw("histo,same");
  JESunc->Draw("2");
  datahisto->Draw("same,e1");
  TLegend *kinleg = allsamples.allbglegend();
  kinleg->AddEntry(JESunc,"JES uncertainty","f");
  kinleg->Draw();
  CompleteSave(ckin,"Systematics/JES"+name);
  datahisto->Delete();
  delete ckin;

}

string Cut2Str(TCut cut) {
  return ((string)(const char*)cut);
}

void MakeElegantTwoThreeComparisons() {
    
    TCut signal("met[4]>100&&met[4]<150&&mll>20"&&PlottingSetup::basicqualitycut);
    TCut TwoJets("pfJetGoodNum40==2");
    TCut ThreeJets("pfJetGoodNum40>=3");
    
    float min=20;
    float max=300;
    int nbins=int((max-min)/5.0);
    string xlabel="m_{ll} [GeV]";
    
    TCanvas *can2 = new TCanvas("can2","can2");
    TH1F *TwoOF = allsamples.Draw("TwoOF","mll",nbins,min,max, xlabel, "events",cutOSOF&&signal&&TwoJets,mc,luminosity,allsamples.FindSample("TTJets_"));
    TH1F *TwoSF = allsamples.Draw("TwoSF","mll",nbins,min,max, xlabel, "events",cutOSSF&&signal&&TwoJets,mc,luminosity,allsamples.FindSample("TTJets_"));
    TH1F *ThreeOF = allsamples.Draw("ThreeOF","mll",nbins,min,max, xlabel, "events",cutOSOF&&signal&&ThreeJets,mc,luminosity,allsamples.FindSample("TTJets_"));
    TH1F *ThreeSF = allsamples.Draw("ThreeSF","mll",nbins,min,max, xlabel, "events",cutOSSF&&signal&&ThreeJets,mc,luminosity,allsamples.FindSample("TTJets_"));
    
    can2->cd(1);
    
    TwoSF->SetFillColor(kWhite);
    TwoOF->SetFillColor(kWhite);
    ThreeSF->SetFillColor(kWhite);
    ThreeOF->SetFillColor(kWhite);
    
    TPad *kin3 = new TPad("kin3","kin3",0,0,1,1);
    kin3->cd();
    TwoOF->Draw("histo");
    TwoSF->Draw("e1,same");
    TLegend *leg_SFOF_Two = make_legend();
    leg_SFOF_Two->SetHeader("t#bar{t} MC:");
    leg_SFOF_Two->AddEntry(TwoOF,"OF, nJets==2","l");
    leg_SFOF_Two->AddEntry(TwoSF,"SF, nJets==2","lp");
    leg_SFOF_Two->Draw();
    Save_With_Ratio(TwoSF,TwoOF,kin3->cd(),"DoubleRatios/SFOF_Two");
    
    TPad *kin4 = new TPad("kin4","kin4",0,0,1,1);
    kin4->cd();
    ThreeOF->Draw("histo");
    ThreeSF->Draw("e1,same");
    TLegend *leg_SFOF_Three = make_legend();
    leg_SFOF_Three->SetHeader("t#bar{t} MC:");
    leg_SFOF_Three->AddEntry(TwoOF,"OF, nJet#geq3","l");
    leg_SFOF_Three->AddEntry(TwoSF,"SF, nJets#geq3","lp");
    leg_SFOF_Three->Draw();
    Save_With_Ratio(ThreeSF,ThreeOF,kin4->cd(),"DoubleRatios/SFOF_Three");
    
    
    TwoSF->Scale(ThreeSF->Integral()/TwoSF->Integral());
    TPad *kin = new TPad("kin","kin",0,0,1,1);
    kin->cd();
    TwoSF->Draw("histo");
    ThreeSF->Draw("e1,same");
    TLegend *leg_SF_Two_Three = make_legend();
    leg_SF_Two_Three->SetHeader("t#bar{t} MC:");
    leg_SF_Two_Three->AddEntry(TwoSF,"#splitline{SF, nJets==2}{ (scaled)}","l");
    leg_SF_Two_Three->AddEntry(ThreeSF,"SF, nJets#geq3","lp");
    leg_SF_Two_Three->Draw();
    Save_With_Ratio(TwoSF,ThreeSF,kin->cd(),"DoubleRatios/SF_Two_Three");
    
    TwoOF->Scale(ThreeOF->Integral()/TwoOF->Integral());
    TPad *kin2 = new TPad("kin2","kin2",0,0,1,1);
    kin2->cd();
    TwoOF->Draw("histo");
    ThreeOF->Draw("e1,same");
    TLegend *leg_OF_Two_Three = make_legend();
    leg_OF_Two_Three->SetHeader("t#bar{t} MC:");
    leg_OF_Two_Three->AddEntry(TwoSF,"#splitline{OF, nJets==2}{ (scaled)}","l");
    leg_OF_Two_Three->AddEntry(ThreeSF,"OF, nJets#geq3","lp");
    leg_OF_Two_Three->Draw();
    Save_With_Ratio(TwoOF,ThreeOF,kin2->cd(),"DoubleRatios/OF_Two_Three");
    
}

void PresentRange(TH1F *Down, TH1F *Up, TH1F *central, TVirtualPad *pad, string title) {
  pad->cd();
  TGraphErrors *gr = new TGraphErrors(Down->GetNbinsX());
  for(int i=1;i<=Down->GetNbinsX();i++) {
    float average=0.5*(Down->GetBinContent(i)+Up->GetBinContent(i));
    float error=abs(Down->GetBinContent(i)-average);
    gr->SetPoint(i-1,Down->GetBinCenter(i),average);
    gr->SetPointError(i-1,Down->GetBinWidth(i)/2.0,error);
  }
  gr->SetFillColor(TColor::GetColor("#F79F81"));
  gr->GetYaxis()->SetRangeUser(0,2);
  gr->GetXaxis()->SetTitle(central->GetXaxis()->GetTitle());
  gr->GetYaxis()->SetTitle(central->GetYaxis()->GetTitle());
  gr->GetXaxis()->CenterTitle();
  gr->GetYaxis()->CenterTitle();
  
  gr->Draw("A2");
  central->Draw("e1,same");
  DrawMCPrelim();
  TText *rtitle = write_text(0.8,0.8,title);
  TLine *line = new TLine(Down->GetBinLowEdge(1),1.0,Down->GetBinLowEdge(Down->GetNbinsX())+Down->GetBinWidth(Down->GetNbinsX()),1.0);
  line->SetLineColor(kBlue);
  line->SetLineStyle(2);
  line->Draw("same");
  rtitle->Draw("same");
}

TH1F* ProduceTTbarRatio(TH1F *datahisto, TH1F *fullmc, TH1F *originalttbar, TH1F *httbar) {
  TH1F *basehisto = (TH1F*)fullmc->Clone("basehisto");
  basehisto->Add(originalttbar,-1);
  basehisto->Add(httbar);
  
  string sname=httbar->GetName();
  sname="R"+sname.substr(1,sname.length());
  TH1F *ratio = (TH1F*)datahisto->Clone(sname.c_str());
  ratio->Divide(basehisto);
  delete basehisto;
  return ratio;
}
   
void make_ttbar_comparison(string datavariable, string mcvariable, int nbins, float min, float max, TCut addcut, bool dolog, string xlabel, string filename) {
  
  TCut cut=addcut&&basiccut;
  
  TCanvas *ckin = new TCanvas("ckin","Kinematic Plots (in the making)",600,600);
  ckin->SetLogy(dolog);
  cout << "\r Creating " << filename << " : data   (1/11)" << std::flush;
  TH1F *datahisto = allsamples.Draw("datahisto",datavariable,nbins,min,max, xlabel, "events",cut,data,luminosity);
  datahisto->SetMarkerSize(DataMarkerSize);
  if ( !dolog ) datahisto->SetMinimum(0); // Defaults
  else datahisto->SetMinimum(0.5);
  if (dolog) datahisto->SetMaximum(5.3*datahisto->GetMaximum());
  else datahisto->SetMaximum(1.3*datahisto->GetMaximum());
  cout << "\r Creating " << filename << " : MC central  (stack) (2/11)" << std::flush;
  THStack mcstack   = allsamples.DrawStack("mcstack",  mcvariable,nbins,min,max,xlabel,"events",cut,mc,luminosity);
  TH1F *MCcentral = CollapseStack(mcstack);

  cout << "\r Creating " << filename << " : MC central (histo)   (3/11)" << std::flush;
  TH1F *TCentral        = allsamples.Draw ("TCentral",     mcvariable,nbins,min,max,xlabel,"events",cut,mc,luminosity,allsamples.FindSample("TTJets_"));
  TH1F *RCentral        = ProduceTTbarRatio(datahisto,MCcentral,TCentral,TCentral);
  
  cout << "\r Creating " << filename << " : MC Matching up   (4/11)" << std::flush;
  TH1F *TMatchingUp     = systsamples.Draw("TMatchingUp",  mcvariable,nbins,min,max,xlabel,"events",cut,mc,luminosity,systsamples.FindSample("TTJets_matchingup"));
  TH1F *RMatchingUp     = ProduceTTbarRatio(datahisto,MCcentral,TCentral,TMatchingUp);
  
  cout << "\r Creating " << filename << " : MC Matching down   (5/11)" << std::flush;
  TH1F *TMatchingDown   = systsamples.Draw("TMatchingDown",mcvariable,nbins,min,max,xlabel,"events",cut,mc,luminosity,systsamples.FindSample("TTJets_matchingdown"));
  TH1F *RMatchingDown   = ProduceTTbarRatio(datahisto,MCcentral,TCentral,TMatchingDown);
  
  cout << "\r Creating " << filename << " : MC Scale up   (6/11)" << std::flush;
  TH1F *TScaleUp        = systsamples.Draw("TScaleUp",     mcvariable,nbins,min,max,xlabel,"events",cut,mc,luminosity,systsamples.FindSample("TTJets_scaleup"));
  TH1F *RScaleUp        = ProduceTTbarRatio(datahisto,MCcentral,TCentral,TScaleUp);
  
  cout << "\r Creating " << filename << " : MC Scale down   (7/11)" << std::flush;
  TH1F *TScaleDown      = systsamples.Draw("TScaleDown",   mcvariable,nbins,min,max,xlabel,"events",cut,mc,luminosity,systsamples.FindSample("TTJets_scaledown"));
  TH1F *RScaleDown      = ProduceTTbarRatio(datahisto,MCcentral,TCentral,TScaleDown);
  
  cout << "\r Creating " << filename << " : MC mass=166   (8/11)" << std::flush;
  TH1F *Ttmass166       = systsamples.Draw("Ttmass166",    mcvariable,nbins,min,max,xlabel,"events",cut,mc,luminosity,systsamples.FindSample("TTJets_mass166"));
  TH1F *Rtmass166       = ProduceTTbarRatio(datahisto,MCcentral,TCentral,Ttmass166);
  
  cout << "\r Creating " << filename << " : MC mass=169   (9/11)" << std::flush;
  TH1F *Ttmass169       = systsamples.Draw("Ttmass169",    mcvariable,nbins,min,max,xlabel,"events",cut,mc,luminosity,systsamples.FindSample("TTJets_mass169"));
  TH1F *Rtmass169       = ProduceTTbarRatio(datahisto,MCcentral,TCentral,Ttmass169);
  
  cout << "\r Creating " << filename << " : MC mass=175   (10/11)" << std::flush;
  TH1F *Ttmass175       = systsamples.Draw("Ttmass175",    mcvariable,nbins,min,max,xlabel,"events",cut,mc,luminosity,systsamples.FindSample("TTJets_mass175"));
  TH1F *Rtmass175       = ProduceTTbarRatio(datahisto,MCcentral,TCentral,Ttmass175);
  
  cout << "\r Creating " << filename << " : MC mass=178   (11/11)" << std::flush;
  TH1F *Ttmass178       = systsamples.Draw("Ttmass178",    mcvariable,nbins,min,max,xlabel,"events",cut,mc,luminosity,systsamples.FindSample("TTJets_mass178"));
  TH1F *Rtmass178       = ProduceTTbarRatio(datahisto,MCcentral,TCentral,Ttmass178);
  
  
  datahisto->Draw("e1");
  ckin->Update();
  mcstack.Draw("histo,same");
  
  datahisto->Draw("same,e1");
  TLegend *kinleg = allsamples.allbglegend();
  kinleg->Draw();

  TPad *kinpad = new TPad("kinpad","kinpad",0,0,1,1);
  kinpad->SetLogy(dolog);
  kinpad->cd();
  datahisto->Draw("e1");
  mcstack.Draw("histo,same");
  datahisto->Draw("same,e1");
  datahisto->Draw("same,axis");
  
  kinleg->Draw("same");
  DrawPrelim();
  string saveas="kin/"+filename;
  
  cout << "Passing filename to be saved : " << filename << " as " << saveas << endl;
  Save_With_Ratio( datahisto, CollapseStack(mcstack), kinpad->cd(), saveas, false, false, "data/mc");
  delete kinpad;
  
  ckin->cd();
  TCentral->SetLineColor(kBlack);
  
  TMatchingUp->SetLineColor(TColor::GetColor("#2c17b1"));//blue
  TMatchingUp->SetLineStyle(2);//dashed
  TMatchingDown->SetLineColor(TColor::GetColor("#2c17b1"));
  TMatchingDown->SetLineStyle(3);//dotted
  
  TScaleUp->SetLineColor(TColor::GetColor("#FF8500"));//orange
  TScaleUp->SetLineStyle(2);//dashed
  TScaleDown->SetLineColor(TColor::GetColor("#FF8500"));
  TScaleDown->SetLineStyle(3);//dotted
  
  Ttmass166->SetLineColor(TColor::GetColor("#0acf00"));//green
  Ttmass166->SetLineStyle(3);//dotted
  Ttmass178->SetLineColor(TColor::GetColor("#0acf00"));
  Ttmass178->SetLineStyle(2);//dashed
  
  
  Ttmass169->SetLineColor(TColor::GetColor("#FF52F1"));//purple
  Ttmass169->SetLineStyle(3);//dotted
  Ttmass175->SetLineColor(TColor::GetColor("#FF52F1"));
  Ttmass175->SetLineStyle(2);//dashed
  
  
  MCcentral->SetLineStyle(3);
  MCcentral->SetLineColor(kRed);
  
  TCentral->Draw("e1,same");
  TCentral->Draw("histo,same");
  TMatchingUp->Draw("histo,same");
  TMatchingDown->Draw("histo,same");
  TScaleUp->Draw("histo,same");
  TScaleDown->Draw("histo,same");
  Ttmass166->Draw("histo,same");
  Ttmass169->Draw("histo,same");
  Ttmass175->Draw("histo,same");
  Ttmass178->Draw("histo,same");
  
  TLegend *sleg = make_legend();
  sleg->AddEntry(TCentral,"Central","L");
  sleg->AddEntry(TMatchingUp,"matching up","L");
  sleg->AddEntry(TMatchingDown,"matching down","L");
  sleg->AddEntry(TScaleUp,"scale up","L");
  sleg->AddEntry(TScaleDown,"scale down","L");
  sleg->AddEntry(Ttmass166,"m_{t}=166","L");
  sleg->AddEntry(Ttmass169,"m_{t}=169","L");
  sleg->AddEntry(Ttmass175,"m_{t}=175","L");
  sleg->AddEntry(Ttmass178,"m_{t}=178","L");
  sleg->Draw();
  
  CompleteSave(ckin,saveas+"___AllLines");
  ckin->cd();
  ckin->SetLogy(0);
  
  RCentral->SetLineColor(kBlack);
  
  RMatchingUp->SetLineColor(TColor::GetColor("#2c17b1"));//blue
  RMatchingUp->SetLineStyle(2);//dashed
  RMatchingDown->SetLineColor(TColor::GetColor("#2c17b1"));
  RMatchingDown->SetLineStyle(3);//dotted
  
  RScaleUp->SetLineColor(TColor::GetColor("#FF8500"));//orange
  RScaleUp->SetLineStyle(2);//dashed
  RScaleDown->SetLineColor(TColor::GetColor("#FF8500"));
  RScaleDown->SetLineStyle(3);//dotted
  
  Rtmass166->SetLineColor(TColor::GetColor("#0acf00"));//green
  Rtmass166->SetLineStyle(3);//dotted
  Rtmass178->SetLineColor(TColor::GetColor("#0acf00"));
  Rtmass178->SetLineStyle(2);//dashed
  
  
  Rtmass169->SetLineColor(TColor::GetColor("#FF52F1"));//purple
  Rtmass169->SetLineStyle(3);//dotted
  Rtmass175->SetLineColor(TColor::GetColor("#FF52F1"));
  Rtmass175->SetLineStyle(2);//dashed

  
  RCentral->GetYaxis()->SetRangeUser(0,2);
  RCentral->Draw("e1");
  RMatchingUp->Draw("histo,same");
  RMatchingDown->Draw("histo,same");
  RScaleUp->Draw("histo,same");
  RScaleDown->Draw("histo,same");
  Rtmass166->Draw("histo,same");
  Rtmass169->Draw("histo,same");
  Rtmass175->Draw("histo,same");
  Rtmass178->Draw("histo,same");
  
  CompleteSave(ckin,saveas+"___AllRatios");

  TCanvas *multicanvas = new TCanvas("multicanvas","multicanvas",1000,1000);
  multicanvas->Divide(2,2);
  PresentRange(RMatchingUp,RMatchingDown,RCentral,multicanvas->cd(1),"Matching");
  PresentRange(RScaleUp,RScaleDown,RCentral,multicanvas->cd(2),"Scale");
  PresentRange(Rtmass166,Rtmass178,RCentral,multicanvas->cd(3),"m_{t} (2#sigma)");
  PresentRange(Rtmass169,Rtmass175,RCentral,multicanvas->cd(4),"m_{t} (1#sigma)");
  CompleteSave(multicanvas,saveas+"___RangeIllustration");
  
  
  delete datahisto;
  delete   TCentral;
  delete   TMatchingUp;
  delete   TMatchingDown;
  delete   TScaleUp;
  delete   TScaleDown;
  delete   Ttmass166;
  delete   Ttmass169;
  delete   Ttmass175;
  delete   Ttmass178;
  
  delete ckin;
  
}
  
void make_ttbar_comparison(string variable, int nbins, float min, float max, TCut addcut, bool dolog, string xlabel, string filename) {
  make_ttbar_comparison(variable, variable, nbins, min, max, addcut, dolog, xlabel, filename);
}

void ProduceJanPlots() {
  TCanvas *c1 = new TCanvas("c1","c1");
  TH1F *metSF = allsamples.Draw("metSF","met[4]",30,100,400, "E_{T}^{miss} [GeV]", "events", cutmass&&cutOSSF&&cutnJets,data, luminosity);
  TH1F *metOF = allsamples.Draw("metOF","met[4]",30,100,400, "E_{T}^{miss} [GeV]", "events", cutmass&&cutOSOF&&cutnJets,data, luminosity);
  
  TPad* rcan = new TPad("rcan","rcan",0,0,1,1);
  rcan->cd();

  metOF->SetLineColor(kRed);
  metSF->Draw("e1");
  metOF->Draw("histo,same");
  metSF->Draw("e1,same");
  
  TLegend *leg = make_legend();
  
  leg->AddEntry(metSF,"Data SF","p");
  leg->AddEntry(metOF,"Data OF","l");
  leg->Draw();
  
  DrawPrelim();
  
  Save_With_Ratio(metSF,metOF,rcan,"JanPlots/ETHConfig",false,false,"SF/OF");
  
  delete rcan;
  delete metSF;
  delete metOF;
  delete c1;
}

THStack MakeOneSystematicsPlot(TCut cut, string saveas, string variation, TH1F *hdata, string variable, int nbins, float bmin, float bmax, string label, TH1F* &thisto) {
  THStack SystPlot = allsamples.DrawStack(variation,variable,nbins,bmin,bmax,label,"events",cut,mc,PlottingSetup::luminosity);
  
  //now need to process the plot (calculate the variation and set the member of thstack accordingly!)
  if(variation!="Central") {
    TH1F *varttbar;
    if(variation=="MatchingUp") varttbar = systsamples.Draw("varttbar",variable,nbins,bmin,bmax,label,"events",cut,mc,PlottingSetup::luminosity,systsamples.FindSample("TTJets_matchingup_TuneZ2s"));
    if(variation=="MatchingDown") varttbar = systsamples.Draw("varttbar",variable,nbins,bmin,bmax,label,"events",cut,mc,PlottingSetup::luminosity,systsamples.FindSample("TTJets_matchingdown"));
    if(variation=="ScaleUp") varttbar = systsamples.Draw("varttbar",variable,nbins,bmin,bmax,label,"events",cut,mc,PlottingSetup::luminosity,systsamples.FindSample("TTJets_scaleup"));
    if(variation=="ScaleDown") varttbar = systsamples.Draw("varttbar",variable,nbins,bmin,bmax,label,"events",cut,mc,PlottingSetup::luminosity,systsamples.FindSample("TTJets_scaledown"));
    assert(varttbar);
    
    TIter nextHisto(SystPlot.GetHists());
    TH1F* h;
    while ( h = (TH1F*)nextHisto() ) {
      if(Contains(h->GetName(),"t_bar_t")) {
        varttbar->Scale(h->Integral()/varttbar->Integral());
        for(int i=0;i<=h->GetNbinsX()+1;i++) {//note that we deliberatly consider the under/overflow bin as well!
          h->SetBinContent(i,varttbar->GetBinContent(i));
          h->SetBinError(i,varttbar->GetBinError(i));
        }
        thisto=(TH1F*)varttbar->Clone(variation.c_str());
        SystPlot.Modified();
      }
    }
    delete varttbar;
  } else {
    TIter nextHisto(SystPlot.GetHists());
    TH1F* h;
    while ( h = (TH1F*)nextHisto() ) {
      if(Contains(h->GetName(),"t_bar_t")) thisto=(TH1F*)h->Clone(variation.c_str());
    }
  }
    
  
  TLegend *fullleg = allsamples.allbglegend();
  fullleg->SetHeader(variation.c_str());
  TPad *kinpad = new TPad("kinpad","kinpad",0,0,1,1);
  kinpad->SetLogy(1);
  kinpad->cd();
  
  hdata->Draw("e1");
  SystPlot.Draw("histo,same");
  hdata->Draw("e1,same");
  fullleg->Draw();
  DrawPrelim();
  
  Save_With_Ratio(hdata,SystPlot,kinpad,saveas+"_"+variation);
  CleanLegends();
  
  delete kinpad;
  return SystPlot;
}
  

void ProduceMCSystematicPlot(string variable, int nbins, float bmin, float bmax, string label, TCut thiscut, string saveas) {
  TCanvas *ca = new TCanvas("ca","ca");
  TH1F *hdata = allsamples.Draw("hdata",variable,nbins,bmin,bmax,label,"events",thiscut,data,luminosity);
  
  TH1F *tScaleUp,*tScaleDown,*tMatchingUp,*tMatchingDown,*tCentral;
  
  THStack ScaleUp      = MakeOneSystematicsPlot(thiscut,saveas,"ScaleUp",hdata,variable, nbins, bmin, bmax, label,tScaleUp);
  THStack ScaleDown    = MakeOneSystematicsPlot(thiscut,saveas,"ScaleDown",hdata,variable, nbins, bmin, bmax, label,tScaleDown);
  THStack MatchingUp   = MakeOneSystematicsPlot(thiscut,saveas,"MatchingUp",hdata,variable, nbins, bmin, bmax, label,tMatchingUp);
  THStack MatchingDown = MakeOneSystematicsPlot(thiscut,saveas,"MatchingDown",hdata,variable, nbins, bmin, bmax, label,tMatchingDown);
  
  TH1F *HScaleUp = CollapseStack(ScaleUp);
  TH1F *HScaleDown = CollapseStack(ScaleDown);
  TH1F *HMatchingUp = CollapseStack(MatchingUp);
  TH1F *HMatchingDown = CollapseStack(MatchingDown);
  
  THStack Central = MakeOneSystematicsPlot(thiscut,saveas,"Central",hdata,variable, nbins, bmin, bmax, label,tCentral);
  TH1F *HCentral = CollapseStack(Central);
  
  TH1F *Systematic = (TH1F*)hdata->Clone("Systematic");
  for(int i=1;i<=Systematic->GetNbinsX();i++) {
    float matchingup   = abs(HMatchingUp->GetBinContent(i)-HCentral->GetBinContent(i));
    float matchingdown = abs(HMatchingDown->GetBinContent(i)-HCentral->GetBinContent(i));
    float scaleup   = abs(HScaleUp->GetBinContent(i)-HCentral->GetBinContent(i));
    float scaledown = abs(HScaleDown->GetBinContent(i)-HCentral->GetBinContent(i));
    
    float matching = matchingup>matchingdown?matchingup:matchingdown;
    float scale    = scaleup>scaledown?scaleup:scaledown;
    
    float sys=sqrt(matching*matching+scale*scale);
    sys/=HCentral->GetBinContent(i);
    if(HCentral->GetBinContent(i)==0) sys=0;
    Systematic->SetBinContent(i,sys);
  }
  
  TPad *kinpad = new TPad("kinpad","kinpad",0,0,1,1);
  kinpad->SetLogy(1);
  kinpad->cd();
  if(variable=="genMET") {
    Central.Draw("histo");
  } else {
    hdata->Draw("e1");
    Central.Draw("histo,same");
    hdata->Draw("e1,same");
  }
  
  DrawPrelim();
  
  save_with_ratio_and_sys_band( hdata, HCentral, kinpad->cd(), saveas, false, false, "data/mc",Systematic );
  
  kinpad->cd();
  tCentral->SetFillColor(kWhite);
  tCentral->SetLineColor(kBlack);
  tScaleUp->SetLineColor(kRed);
  tScaleDown->SetLineColor(kRed);
  tMatchingUp->SetLineColor(kBlue);
  tMatchingDown->SetLineColor(kBlue);
  tScaleUp->SetLineStyle(2);
  tScaleDown->SetLineStyle(3);
  tMatchingUp->SetLineStyle(2);
  tMatchingDown->SetLineStyle(3);
  
  TLegend *leg2 = make_legend();
  leg2->AddEntry(hdata,"Data","p");
  leg2->AddEntry(tCentral,"Central (ttbar)","l");
  leg2->AddEntry(tScaleUp,"ScaleUp (ttbar)","l");
  leg2->AddEntry(tScaleDown,"ScaleDown (ttbar)","l");
  leg2->AddEntry(tMatchingUp,"MatchingUp (ttbar)","l");
  leg2->AddEntry(tMatchingDown,"MatchingDown (ttbar)","l");
  if(variable=="genMET") {
    Central.Draw("histo");
  }else {
    hdata->Draw("e1");
    Central.Draw("histo,same");
    hdata->Draw("e1,same");
  }
  tCentral->Draw("histo,same");
  tScaleUp->Draw("histo,same");
  tScaleDown->Draw("histo,same");
  tMatchingUp->Draw("histo,same");
  tMatchingDown->Draw("histo,same");
  leg2->Draw();
  
  CompleteSave(kinpad,saveas+"__TTbarComparison");
  
  gStyle->SetOptFit(0);
  
  kinpad->cd();
  kinpad->SetLogy(0);
  TH1F *MatchingRatio = (TH1F*)tMatchingUp->Clone("MatchingRatio");
  MatchingRatio->Divide(tMatchingDown);
  TLine *lone = new TLine(tScaleUp->GetBinLowEdge(1),1,tScaleUp->GetBinLowEdge(tScaleUp->GetNbinsX())+tScaleUp->GetBinWidth(tScaleUp->GetNbinsX()),1);
  lone->SetLineColor(TColor::GetColor("#01DF01"));
  lone->SetLineStyle(2);
  TH1F *ScaleRatio = (TH1F*)tScaleUp->Clone("ScaleRatio");
  ScaleRatio->Divide(tScaleDown);
  MatchingRatio->GetYaxis()->SetRangeUser(0,3);
  MatchingRatio->Draw("e1");
  TF1 *QP1 = new TF1("QP1","[0]+[1]*x",50,200);//simple linear function ranging from 50 to 200
  MatchingRatio->Fit("QP1","R");
  lone->Draw();
  stringstream summary;
  summary << " #splitline{Fit result for f(x) = a+bx :}{#splitline{a=" << DigitsAfterComma(QP1->GetParameter(0),4) << " +/- " << DigitsAfterComma(QP1->GetParError(0),4) << "}{b=" << DigitsAfterComma(QP1->GetParameter(1),4);
  summary << " +/- " << DigitsAfterComma(QP1->GetParError(1),4) << "}}";
  TText *infobox = write_title(summary.str());
  infobox->SetX(0.75);
  infobox->SetTextSize(0.03);
  infobox->SetY(0.75);
  infobox->Draw();
  CompleteSave(kinpad,saveas+"__TTbarComparison_MatchingUpDividedMatchingDown");
  kinpad->cd();
  ScaleRatio->GetYaxis()->SetRangeUser(0,3);
  ScaleRatio->Draw("e1");
  ScaleRatio->Fit("QP1","R");
  summary.str("");
  summary << " #splitline{Fit result for f(x) = a+bx :}{#splitline{a=" << DigitsAfterComma(QP1->GetParameter(0),4) << " +/- " << DigitsAfterComma(QP1->GetParError(0),4) << "}{b=" << DigitsAfterComma(QP1->GetParameter(1),4);
  summary << " +/- " << DigitsAfterComma(QP1->GetParError(1),4) << "}}";
  TText *infobox2 = write_title(summary.str());
  infobox2->SetX(0.75);
  infobox2->SetTextSize(0.03);
  infobox2->SetY(0.75);
  infobox2->Draw();

  lone->Draw();
  CompleteSave(kinpad,saveas+"__TTbarComparison_ScaleUpDividedScaleDown");
  
  
  delete QP1;
  delete infobox;
  delete infobox2;
  delete MatchingRatio;
  delete ScaleRatio;
  DeleteStack(ScaleUp);
  DeleteStack(ScaleDown);
  DeleteStack(MatchingUp);
  DeleteStack(MatchingDown);
  delete leg2;
  CleanLegends();
  DeleteStack(Central);
  delete Systematic;
  delete HScaleUp;
  delete HScaleDown;
  delete HMatchingUp;
  delete HMatchingDown;
  delete hdata;
  delete HCentral;
  delete ca;
}

void QuickProduceMCSystematicPlot(string variable, int nbins, float bmin, float bmax, string label, TCut thiscut, string saveas) {
  TCanvas *ca = new TCanvas("ca","ca");
  TH1F *tScaleUp = systsamples.Draw("tScaleUp",variable,nbins,bmin,bmax,label,"events",thiscut,mc,luminosity,systsamples.FindSample("scaleup"));
  TH1F *tScaleDown = systsamples.Draw("tScaleDown",variable,nbins,bmin,bmax,label,"events",thiscut,mc,luminosity,systsamples.FindSample("scaledown"));
  TH1F *tMatchingUp = systsamples.Draw("tMatchingUp",variable,nbins,bmin,bmax,label,"events",thiscut,mc,luminosity,systsamples.FindSample("matchingup"));
  TH1F *tMatchingDown = systsamples.Draw("tMatchingDown",variable,nbins,bmin,bmax,label,"events",thiscut,mc,luminosity,systsamples.FindSample("matchingdown"));
  TH1F *tCentral = systsamples.Draw("tCentral",variable,nbins,bmin,bmax,label,"events",thiscut,mc,luminosity,systsamples.FindSample("TTJets_MassiveBinDECAY_TuneZ2sta"));
  
  tScaleUp->Scale(1.0/tScaleUp->Integral());
  tScaleDown->Scale(1.0/tScaleDown->Integral());
  tMatchingDown->Scale(1.0/tMatchingDown->Integral());
  tMatchingUp->Scale(1.0/tMatchingUp->Integral());
  
  TPad *kinpad = new TPad("kinpad","kinpad",0,0,1,1);
  kinpad->SetLogy(1);
  kinpad->cd();
  tCentral->SetFillColor(kWhite);
  tCentral->SetLineColor(kBlack);
  tScaleUp->SetLineColor(kRed);
  tScaleDown->SetLineColor(kRed);
  tMatchingUp->SetLineColor(kBlue);
  tMatchingDown->SetLineColor(kBlue);
  tScaleUp->SetLineStyle(2);
  tScaleDown->SetLineStyle(3);
  tMatchingUp->SetLineStyle(2);
  tMatchingDown->SetLineStyle(3);
  
  TLegend *leg2 = make_legend();
  leg2->AddEntry(tCentral,"Central (ttbar)","l");
  leg2->AddEntry(tScaleUp,"ScaleUp (ttbar)","l");
  leg2->AddEntry(tScaleDown,"ScaleDown (ttbar)","l");
  leg2->AddEntry(tMatchingUp,"MatchingUp (ttbar)","l");
  leg2->AddEntry(tMatchingDown,"MatchingDown (ttbar)","l");
  
  tCentral->Draw("histo");
  tScaleUp->Draw("histo,same");
  tScaleDown->Draw("histo,same");
  tMatchingUp->Draw("histo,same");
  tMatchingDown->Draw("histo,same");
  leg2->Draw();
  
  CompleteSave(kinpad,saveas+"__TTbarComparison");
  
  gStyle->SetOptFit(0);
  
  kinpad->cd();
  kinpad->SetLogy(0);
  TH1F *MatchingRatio = (TH1F*)tMatchingUp->Clone("MatchingRatio");
  MatchingRatio->Divide(tMatchingDown);
  TLine *lone = new TLine(tScaleUp->GetBinLowEdge(1),1,tScaleUp->GetBinLowEdge(tScaleUp->GetNbinsX())+tScaleUp->GetBinWidth(tScaleUp->GetNbinsX()),1);
  lone->SetLineColor(TColor::GetColor("#01DF01"));
  lone->SetLineStyle(2);
  TH1F *ScaleRatio = (TH1F*)tScaleUp->Clone("ScaleRatio");
  ScaleRatio->Divide(tScaleDown);
  MatchingRatio->GetYaxis()->SetRangeUser(0,3);
  MatchingRatio->Draw("e1");
  TF1 *QP1 = new TF1("QP1","[0]+[1]*x",50,200);//simple linear function ranging from 50 to 200
  MatchingRatio->Fit("QP1","RQ");
  lone->Draw();
  stringstream summary;
  summary << " #splitline{Fit result for f(x) = a+bx :}{#splitline{a=" << DigitsAfterComma(QP1->GetParameter(0),4) << " +/- " << DigitsAfterComma(QP1->GetParError(0),4) << "}{b=" << DigitsAfterComma(QP1->GetParameter(1),4);
  summary << " +/- " << DigitsAfterComma(QP1->GetParError(1),4) << "}}";
  TText *infobox = write_title(summary.str());
  infobox->SetX(0.75);
  infobox->SetTextSize(0.03);
  infobox->SetY(0.75);
  infobox->Draw();
  CompleteSave(kinpad,saveas+"__TTbarComparison_MatchingUpDividedMatchingDown");
  kinpad->cd();
  ScaleRatio->GetYaxis()->SetRangeUser(0,3);
  ScaleRatio->Draw("e1");
  ScaleRatio->Fit("QP1","RQ");
  summary.str("");
  summary << " #splitline{Fit result for f(x) = a+bx :}{#splitline{a=" << DigitsAfterComma(QP1->GetParameter(0),4) << " +/- " << DigitsAfterComma(QP1->GetParError(0),4) << "}{b=" << DigitsAfterComma(QP1->GetParameter(1),4);
  summary << " +/- " << DigitsAfterComma(QP1->GetParError(1),4) << "}}";
  TText *infobox2 = write_title(summary.str());
  infobox2->SetX(0.75);
  infobox2->SetTextSize(0.03);
  infobox2->SetY(0.75);
  infobox2->Draw();

  lone->Draw();
  CompleteSave(kinpad,saveas+"__TTbarComparison_ScaleUpDividedScaleDown");
  
  delete tScaleUp;
  delete tScaleDown;
  delete tCentral;
  delete tMatchingUp;
  delete tMatchingDown;
  delete QP1;
  delete infobox;
  delete infobox2;
  delete MatchingRatio;
  delete ScaleRatio;
  delete leg2;
  CleanLegends();
  delete ca;
}

void ProduceMCSystematicPlots() {
  cout << "Getting ready to produce systematic plots " << endl;
  TCut cutweightBKP = cutWeight;
  
  QuickProduceMCSystematicPlot("genMET",20,0,200,"genMET [GeV]",cutOSSF&&cutnJets&&TCut("mll>20&&mll<70"),"MCSystPlots/genMET/ETH_SameFlavor");
  QuickProduceMCSystematicPlot("genMET",20,0,200,"genMET [GeV]",cutOSOF&&cutnJets&&TCut("mll>20&&mll<70"),"MCSystPlots/genMET/ETH_OppositeFlavor");  
  QuickProduceMCSystematicPlot("met[4]",20,0,200,"PFMET [GeV]",cutOSSF&&cutnJets&&TCut("mll>20&&mll<70"),"MCSystPlots/MET/ETH_SameFlavor");
  QuickProduceMCSystematicPlot("met[4]",20,0,200,"PFMET [GeV]",cutOSOF&&cutnJets&&TCut("mll>20&&mll<70"),"MCSystPlots/MET/ETH_OppositeFlavor");
  
  QuickProduceMCSystematicPlot("genMET",20,0,200,"genMET [GeV]",cutOSSF&&TCut("mll>20&&mll<70"),"MCSystPlots/genMET/ETH_SameFlavor_INCLUSIVE");
  QuickProduceMCSystematicPlot("genMET",20,0,200,"genMET [GeV]",cutOSOF&&TCut("mll>20&&mll<70"),"MCSystPlots/genMET/ETH_OppositeFlavor_INCLUSIVE");  
  QuickProduceMCSystematicPlot("genMET",20,0,200,"genMET [GeV]",cutOSSF&&TCut("mll>120"),"MCSystPlots/genMET/ETH_SameFlavor_INCLUSIVE_HighMass");
  QuickProduceMCSystematicPlot("genMET",20,0,200,"genMET [GeV]",cutOSOF&&TCut("mll>120"),"MCSystPlots/genMET/ETH_OppositeFlavor_INCLUSIVE_HighMass");  
  
  QuickProduceMCSystematicPlot("met[4]",20,0,200,"PFMET [GeV]",cutOSSF&&TCut("mll>20&&mll<70"),"MCSystPlots/MET/ETH_SameFlavor_INCLUSIVE");
  QuickProduceMCSystematicPlot("met[4]",20,0,200,"PFMET [GeV]",cutOSOF&&TCut("mll>20&&mll<70"),"MCSystPlots/MET/ETH_OppositeFlavor_INCLUSIVE");
  QuickProduceMCSystematicPlot("met[4]",20,0,200,"PFMET [GeV]",cutOSSF&&TCut("mll>120"),"MCSystPlots/MET/ETH_SameFlavor_INCLUSIVE_HighMass");
  QuickProduceMCSystematicPlot("met[4]",20,0,200,"PFMET [GeV]",cutOSOF&&TCut("mll>120"),"MCSystPlots/MET/ETH_OppositeFlavor_INCLUSIVE_HighMass");
  QuickProduceMCSystematicPlot("pfJetGoodNum40",8,-0.5,7.5,"NJets",cutOSSF&&cutnJets&&TCut("mll>20&&mll<70&&met[4]>100"),"MCSystPlots/NJets/ETH_SameFlavor");
  QuickProduceMCSystematicPlot("pfJetGoodNum40",8,-0.5,7.5,"NJets",cutOSOF&&cutnJets&&TCut("mll>20&&mll<70&&met[4]>100"),"MCSystPlots/NJets/ETH_OppositeFlavor");
  
  
  cout << "Kicking cutWeight  " << (const char*) cutWeight << endl;
  cout << "Keeping OSSF cut " << (const char*)cutOSSF << endl;
  cutWeight="1.0";
  TCut bkpessential=essentialcut;
  essentialcut=TCut("genPt1>0");
  
  QuickProduceMCSystematicPlot("genMET",20,0,200,"genMET [GeV]",TCut("abs(genId1)==abs(genId2) && abs(genEta1)<1.4 && abs(genEta2)<1.4 && genPt1>20 && genPt2>20 &&  genMll>20&&genMll<70"),"MCSystPlots/genMET/ETH_SameFlavor_INCLUSIVE__NOPURW___GENLEVEL");
  QuickProduceMCSystematicPlot("genMET",20,0,200,"genMET [GeV]",TCut("abs(genId1)!=abs(genId2) && abs(genEta1)<1.4 && abs(genEta2)<1.4 && genPt1>20 && genPt2>20 &&  genMll>20&&genMll<70"),"MCSystPlots/genMET/ETH_OppositeFlavor_INCLUSIVE__NOPURW___GENLEVEL");
  QuickProduceMCSystematicPlot("genMET",20,0,200,"genMET [GeV]",TCut("abs(genId1)==abs(genId2) && abs(genEta1)<1.4 && abs(genEta2)<1.4 && genPt1>20 && genPt2>20 &&  genMll>120"),"MCSystPlots/genMET/ETH_SameFlavor_INCLUSIVE_HighMass__NOPURW___GENLEVEL");
  QuickProduceMCSystematicPlot("genMET",20,0,200,"genMET [GeV]",TCut("abs(genId1)!=abs(genId2) && abs(genEta1)<1.4 && abs(genEta2)<1.4 && genPt1>20 && genPt2>20 &&  genMll>120"),"MCSystPlots/genMET/ETH_OppositeFlavor_INCLUSIVE_HighMass__NOPURW___GENLEVEL");
  essentialcut=bkpessential;
  assert(0);
  
/*  QuickProduceMCSystematicPlot("genMET",20,0,200,"genMET [GeV]",cutOSSF&&TCut("mll>20&&mll<70"),"MCSystPlots/genMET/ETH_SameFlavor_INCLUSIVE__NOPURW");
  QuickProduceMCSystematicPlot("genMET",20,0,200,"genMET [GeV]",cutOSOF&&TCut("mll>20&&mll<70"),"MCSystPlots/genMET/ETH_OppositeFlavor_INCLUSIVE__NOPURW");  
  QuickProduceMCSystematicPlot("genMET",20,0,200,"genMET [GeV]",cutOSSF&&TCut("mll>120"),"MCSystPlots/genMET/ETH_SameFlavor_INCLUSIVE_HighMass__NOPURW");
  QuickProduceMCSystematicPlot("genMET",20,0,200,"genMET [GeV]",cutOSOF&&TCut("mll>120"),"MCSystPlots/genMET/ETH_OppositeFlavor_INCLUSIVE_HighMass__NOPURW");  
  
  QuickProduceMCSystematicPlot("met[4]",20,0,200,"PFMET [GeV]",cutOSSF&&TCut("mll>20&&mll<70"),"MCSystPlots/MET/ETH_SameFlavor_INCLUSIVE__NOPURW");
  QuickProduceMCSystematicPlot("met[4]",20,0,200,"PFMET [GeV]",cutOSOF&&TCut("mll>20&&mll<70"),"MCSystPlots/MET/ETH_OppositeFlavor_INCLUSIVE__NOPURW");
  QuickProduceMCSystematicPlot("met[4]",20,0,200,"PFMET [GeV]",cutOSSF&&TCut("mll>120"),"MCSystPlots/MET/ETH_SameFlavor_INCLUSIVE_HighMass__NOPURW");
  QuickProduceMCSystematicPlot("met[4]",20,0,200,"PFMET [GeV]",cutOSOF&&TCut("mll>120"),"MCSystPlots/MET/ETH_OppositeFlavor_INCLUSIVE_HighMass__NOPURW");
  */
  
  // --------------------------------------    ***** AACHEN *****      --------------------------------------    
  
  
  cutWeight=cutweightBKP;
  TCut essentialcutBKP = essentialcut;
  cout << (const char*) essentialcut << endl;
  
  essentialcut = TCut((ReplaceAll((const char*)essentialcut,"pt2>20","pt2>10")).c_str());
  essentialcut = TCut((ReplaceAll((const char*)essentialcut,"abs(eta1)<1.4","abs(eta1)<2.4")).c_str());
  essentialcut = TCut((ReplaceAll((const char*)essentialcut,"abs(eta2)<1.4","abs(eta2)<2.4")).c_str());
  
  TCut cutnJetsBKP = cutnJets;
  cutnJets = TCut((ReplaceAll((const char*)cutnJets,"pt2>20","pt2>10")).c_str());
  cutnJets = TCut((ReplaceAll((const char*)cutnJets,"pfJetGoodNum40>=3","pfJetGoodNum40>=2")).c_str());
  cutnJets = TCut((ReplaceAll((const char*)cutnJets,"abs(eta2)<1.4","abs(eta2)<2.4")).c_str());
  cutnJets = TCut((ReplaceAll((const char*)cutnJets,"abs(eta1)<1.4","abs(eta1)<2.4")).c_str());
  
  QuickProduceMCSystematicPlot("genMET",20,0,200,"genMET [GeV]",cutOSSF&&cutnJets&&TCut("mll>20&&mll<70"),"MCSystPlots/genMET/Aachen_SameFlavor");
  QuickProduceMCSystematicPlot("genMET",20,0,200,"genMET [GeV]",cutOSOF&&cutnJets&&TCut("mll>20&&mll<70"),"MCSystPlots/genMET/Aachen_OppositeFlavor");  
  QuickProduceMCSystematicPlot("met[4]",20,0,200,"PFMET [GeV]",cutOSSF&&cutnJets&&TCut("mll>20&&mll<70"),"MCSystPlots/MET/Aachen_SameFlavor");
  QuickProduceMCSystematicPlot("met[4]",20,0,200,"PFMET [GeV]",cutOSOF&&cutnJets&&TCut("mll>20&&mll<70"),"MCSystPlots/MET/Aachen_OppositeFlavor");
  
  QuickProduceMCSystematicPlot("genMET",20,0,200,"genMET [GeV]",cutOSSF&&TCut("mll>20&&mll<70"),"MCSystPlots/genMET/Aachen_SameFlavor_INCLUSIVE");
  QuickProduceMCSystematicPlot("genMET",20,0,200,"genMET [GeV]",cutOSOF&&TCut("mll>20&&mll<70"),"MCSystPlots/genMET/Aachen_OppositeFlavor_INCLUSIVE");  
  QuickProduceMCSystematicPlot("genMET",20,0,200,"genMET [GeV]",cutOSSF&&TCut("mll>120"),"MCSystPlots/genMET/Aachen_SameFlavor_INCLUSIVE_HighMass");
  QuickProduceMCSystematicPlot("genMET",20,0,200,"genMET [GeV]",cutOSOF&&TCut("mll>120"),"MCSystPlots/genMET/Aachen_OppositeFlavor_INCLUSIVE_HighMass");  
  
  QuickProduceMCSystematicPlot("met[4]",20,0,200,"PFMET [GeV]",cutOSSF&&TCut("mll>20&&mll<70"),"MCSystPlots/MET/Aachen_SameFlavor_INCLUSIVE");
  QuickProduceMCSystematicPlot("met[4]",20,0,200,"PFMET [GeV]",cutOSOF&&TCut("mll>20&&mll<70"),"MCSystPlots/MET/Aachen_OppositeFlavor_INCLUSIVE");
  QuickProduceMCSystematicPlot("met[4]",20,0,200,"PFMET [GeV]",cutOSSF&&TCut("mll>120"),"MCSystPlots/MET/Aachen_SameFlavor_INCLUSIVE_HighMass");
  QuickProduceMCSystematicPlot("met[4]",20,0,200,"PFMET [GeV]",cutOSOF&&TCut("mll>120"),"MCSystPlots/MET/Aachen_OppositeFlavor_INCLUSIVE_HighMass");
  QuickProduceMCSystematicPlot("pfJetGoodNum40",8,-0.5,7.5,"NJets",cutOSSF&&cutnJets&&TCut("mll>20&&mll<70&&met[4]>100"),"MCSystPlots/NJets/Aachen_SameFlavor");
  QuickProduceMCSystematicPlot("pfJetGoodNum40",8,-0.5,7.5,"NJets",cutOSOF&&cutnJets&&TCut("mll>20&&mll<70&&met[4]>100"),"MCSystPlots/NJets/Aachen_OppositeFlavor");
  
  
  cout << "Kicking cutWeight  " << (const char*) cutWeight << endl;
  cout << "Keeping OSSF cut " << (const char*)cutOSSF << endl;
  cutWeight="1.0";
  
  QuickProduceMCSystematicPlot("genMET",20,0,200,"genMET [GeV]",cutOSSF&&TCut("mll>20&&mll<70"),"MCSystPlots/genMET/Aachen_SameFlavor_INCLUSIVE__NOPURW");
  QuickProduceMCSystematicPlot("genMET",20,0,200,"genMET [GeV]",cutOSOF&&TCut("mll>20&&mll<70"),"MCSystPlots/genMET/Aachen_OppositeFlavor_INCLUSIVE__NOPURW");  
  QuickProduceMCSystematicPlot("genMET",20,0,200,"genMET [GeV]",cutOSSF&&TCut("mll>120"),"MCSystPlots/genMET/Aachen_SameFlavor_INCLUSIVE_HighMass__NOPURW");
  QuickProduceMCSystematicPlot("genMET",20,0,200,"genMET [GeV]",cutOSOF&&TCut("mll>120"),"MCSystPlots/genMET/Aachen_OppositeFlavor_INCLUSIVE_HighMass__NOPURW");  
  
  QuickProduceMCSystematicPlot("met[4]",20,0,200,"PFMET [GeV]",cutOSSF&&TCut("mll>20&&mll<70"),"MCSystPlots/MET/Aachen_SameFlavor_INCLUSIVE__NOPURW");
  QuickProduceMCSystematicPlot("met[4]",20,0,200,"PFMET [GeV]",cutOSOF&&TCut("mll>20&&mll<70"),"MCSystPlots/MET/Aachen_OppositeFlavor_INCLUSIVE__NOPURW");
  QuickProduceMCSystematicPlot("met[4]",20,0,200,"PFMET [GeV]",cutOSSF&&TCut("mll>120"),"MCSystPlots/MET/Aachen_SameFlavor_INCLUSIVE_HighMass__NOPURW");
  QuickProduceMCSystematicPlot("met[4]",20,0,200,"PFMET [GeV]",cutOSOF&&TCut("mll>120"),"MCSystPlots/MET/Aachen_OppositeFlavor_INCLUSIVE_HighMass__NOPURW");
  
  cutnJets  = cutnJetsBKP;
  cutWeight = cutweightBKP;
  essentialcut = essentialcutBKP;
  
  write_error(__FUNCTION__,"Still need to add systematic shape");assert(0);
}

void MakeTauPlot(string label, TCut pcut, string filename, bool TauOnly) {
  TCut cut=pcut&&basiccut;
  string variable="mll";
  string xlabel="m_{ll} [GeV]";
  int nbins=40;
  float min=0;
  float max=200;

  TCanvas *ckin = new TCanvas("ckin","Kinematic Plots (in the making)",600,600);
  TH1F *datahistoSF = allsamples.Draw("datahistoSF",variable,nbins,min,max, xlabel, "events",cut&&cutOSSF,data,luminosity);
  TH1F *datahistoOF = allsamples.Draw("datahistoOF",variable,nbins,min,max, xlabel, "events",cut&&cutOSOF,data,luminosity);
  TH1F *tauSF = allsamples.Draw("tauSF",variable,nbins,min,max, xlabel, "events",cut&&cutOSSF,data,luminosity,systsamples.FindSample("DYToTauTau"));
  TH1F *tauOF = allsamples.Draw("tauOF",variable,nbins,min,max, xlabel, "events",cut&&cutOSOF,data,luminosity,systsamples.FindSample("DYToTauTau"));
  datahistoSF->SetMarkerSize(DataMarkerSize);
  datahistoSF->SetMaximum(1.3*datahistoSF->GetMaximum());
  datahistoOF->SetMarkerSize(DataMarkerSize);
  datahistoOF->SetMaximum(1.3*datahistoOF->GetMaximum());

  THStack mcstackSF   = allsamples.DrawStack("mcstackSF",  variable,nbins,min,max,xlabel,"events",cut&&cutOSSF,mc,luminosity);
  THStack mcstackOF   = allsamples.DrawStack("mcstackOF",  variable,nbins,min,max,xlabel,"events",cut&&cutOSOF,mc,luminosity);
  datahistoSF->Draw("e1");
  ckin->Update();
  mcstackSF.Draw("histo,same");
  
  datahistoSF->Draw("same,e1");
  TLegend *kinleg = allsamples.allbglegend();
  kinleg->Draw();
  
  TPad *kinpad = new TPad("kinpad","kinpad",0,0,1,1);
  kinpad->cd();
  datahistoSF->Draw("e1");
  mcstackSF.Draw("histo,same");
  datahistoSF->Draw("same,e1");
  datahistoSF->Draw("same,axis");
  kinleg->Draw();
  DrawPrelim();
  Save_With_Ratio(datahistoSF,mcstackSF,kinpad->cd(),filename+"__SF_mc");
  
  kinpad->cd();
  datahistoOF->Draw("e1");
  mcstackOF.Draw("histo,same");
  datahistoOF->Draw("same,e1");
  datahistoOF->Draw("same,axis");
  kinleg->Draw();
  DrawPrelim();
  Save_With_Ratio(datahistoOF,mcstackOF,kinpad->cd(),filename+"__OF_mc");
  
  kinpad->cd();
  tauSF->Draw("e1");
  tauOF->Draw("histo,same");
  tauSF->Draw("e1,same");
  TLegend *legtau = make_legend();
  legtau->AddEntry(tauSF,"DY->#tau#tau, SF","p");
  legtau->AddEntry(tauSF,"DY->#tau#tau, OF","l");
  legtau->Draw();
  DrawPrelim();
  Save_With_Ratio(tauSF,tauOF,kinpad->cd(),filename+"__Tau_SF_vs_OF");
  
  delete datahistoSF;
  delete datahistoOF;
  delete tauSF;
  delete tauOF;
  delete kinpad;
  delete ckin;
  CleanLegends();
}
  

void TauQuestion() {
//   MakeTauPlot("MET>100 GeV, #geq 3 jets",cutnJets&&TCut("met[4]>100"),"TauQ/MET100_3Jets",true);
//   MakeTauPlot("MET>100 GeV",TCut("met[4]>100"),"TauQ/MET100",true);
//   MakeTauPlot("MET>0 GeV",TCut("met[4]>0"),"TauQ/MET0",true);
  MakeTauPlot("b-tag veto, 50<MET<100",TCut("pfJetGoodNumBtag30==0&&met[4]>50&&met[4]<100"),"TauQ/ControlPlots",false);
}

void do_kinematic_plots(string mcjzb, string datajzb, bool doPF=false)
{
//  switch_overunderflow(true);
  bool dolog=true;
  bool nolog=false;

  bool doOFSF = true;
  bool doKin  = true;
  bool doDataComp = false;
  bool MakeTwoThreeJetComparison = false;
  

  if(doPF) write_warning(__FUNCTION__,"Please use caution when trying to produce PF plots; not all versions of the JZB trees have these variables!");
  float mll_low=50;
  float mll_hi=160;
  if(!PlottingSetup::RestrictToMassPeak) {
        mll_low=20;
        mll_hi=320;
  }
  
  if(MakeTwoThreeJetComparison) MakeElegantTwoThreeComparisons();
  
  //TauQuestion();

  //ProduceJanPlots();
  ProduceMCSystematicPlots();
  assert(0);
//  make_plain_kin_plot("pt",Cut2Str(cutOSSF&&TCut("mll>20&&pfJetGoodNumBtag30>=2")),40,0,200,nolog,"Z p_{T}","PlotForKostas",doPF,true);
  
  if ( doOFSF ) {
     make_OFSF_plots("mll", "met[4]>100", 60, 20., 320., false, "m_{ll}", "mll");
     make_OFSF_plots("met[4]", "met[4]>100", 30, 100., 400., false, "PFMET", "met");
     make_OFSF_plots("leptonNum", "met[4]>100", 3, 2, 5., false, "N(leptons)", "NLeptons");

     make_OFSF_plots("pfJetGoodNum40", "met[4]>100",                        7, 3, 10, true, "#(jets)", "njets");
     make_OFSF_plots("pfJetGoodNum40", "met[4]>100&&pfJetGoodNumBtag30==0", 7, 3, 10, true, "#(jets)", "njets_btagVeto");
     make_OFSF_plots("pfJetGoodNum40", "met[4]>100&&pfJetGoodNumBtag30>0",  7, 3, 10, true, "#(jets)", "njets_AtLeastOneBJet30");

     make_OFSF_plots("pfJetGoodNumBtag30", "met[4]>100", 5, 0, 5, true, "#(b-jets)", "nbjets");
     make_OFSF_plots("pfJetGoodPtBtag[0]", "met[4]>100&&pfJetGoodNumBtag30>0", 20, 0, 400, true, "p_{T}(leading b-jet)", "ptb1");

     make_OFSF_plots("iso1", "met[4]>100", 20, 0, 0.3, true, "lepton 1 isolation", "iso1");
     make_OFSF_plots("iso2", "met[4]>100", 20, 0, 0.3, true, "lepton 2 isolation", "iso2");
     make_OFSF_plots("pt1",  "met[4]>100", 30, 0., 300., true, "p_{T,1}", "pt1");
     make_OFSF_plots("pt2",  "met[4]>100", 22, 0., 220., true, "p_{T,2}", "pt2");
     make_OFSF_plots("eta1", "met[4]>100", 10, -2.5, 2.5, false, "#eta_{1}", "eta1", 0.15);
     make_OFSF_plots("eta2", "met[4]>100", 10, -2.5, 2.5, false, "#eta_{2}", "eta2", 0.15);
     make_OFSF_plots("phi1", "met[4]>100", 10, -TMath::Pi(), TMath::Pi(), false, "#phi_{1}", "phi1", 0.2);
     make_OFSF_plots("phi2", "met[4]>100", 10, -TMath::Pi(), TMath::Pi(), false, "#phi_{2}", "phi2", 0.2);
     make_OFSF_plots("pfJetGoodPt[0]/pfJetGoodPt[1]", "met[4]>100", 20, 1, 10, true, "pt_{j}^{1}/pt_{j}^{2}", "jpt1pt2", 0.2);
     make_OFSF_plots("TMath::Abs(pfJetDphiMet[0])", "met[4]>100", 16, 0, 3.2, false, "|#Delta#phi(jet1,MET)|", "dphij1met", 0.2);
    make_OFSF_plots("TMath::Abs(dphi)", "met[4]>100", 16, 0, 3.2, false, "|#Delta#phi(l1,l2)|", "dphi", 0.2);
    make_OFSF_plots("TMath::Abs(dphiMet1)", "met[4]>100", 16, 0, 3.2, false, "|#Delta#phi(l1,MET)|", "dphiMet1", 0.2);
    make_OFSF_plots("TMath::Abs(dphiMet2)", "met[4]>100", 16, 0, 3.2, false, "|#Delta#phi(l2,MET)|", "dphiMet2", 0.2);
    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");
    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");
    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");
    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");
  }

  if ( doDataComp) {
    TCut mllCut("");
    float massmin = 15.;
    float massmax = 315;
    int massnbins = 60;
/*    if ( !PlottingSetup::openBox ) {
      mllCut = "mll>70";
      massmin = 120;
      massmax = 360;
      massnbins = 14;
    }*/

    TCut cutSignal = cutmass&&cutnJets&&"met[4]>100";
    
    make_data_comparison_plot("numVtx", "",40, -0.5, 39.5,-1., true, "N(Vertices)", "numVtx");
    make_data_comparison_plot("pfJetGoodEta[0]", "",50, -3.0, 3.0,-1., true, "N(Jets)", "pfJetGoodEta0");
    
    
    make_data_comparison_plot("pfJetGoodNum40", cutOSOF,10, -0.5, 9.5,-1., true, "N(Jets)", "njets_OF");
    make_data_comparison_plot("met[4]", cutOSSF,60, 0., 300.,-1., true, "pfMET", "met_SF_inclusive");
    make_data_comparison_plot("met[1]", cutOSSF,60, 0., 300.,-1., true, "type 1 corrected pfMET", "mett1_SF_inclusive");
    make_data_comparison_plot("met[4]", cutOSOF,60, 0., 300.,-1., true, "pfMET", "met_OF_inclusive");
    make_data_comparison_plot("met[1]", cutOSOF,60, 0., 300.,-1., true, "type 1 corrected pfMET", "mett1_OF_inclusive");
    
    make_data_comparison_plot("met[4]", cutnJets&&cutOSSF,60, 0., 300.,-1., true, "pfMET", "met_SF_exclusive");
    make_data_comparison_plot("met[1]", cutnJets&&cutOSSF,60, 0., 300.,-1., true, "type 1 corrected pfMET", "mett1_SF_exclusive");
    make_data_comparison_plot("met[4]", cutnJets&&cutOSOF,60, 0., 300.,-1., true, "pfMET", "met_OF_exclusive");
    make_data_comparison_plot("met[1]", cutnJets&&cutOSOF,60, 0., 300.,-1., true, "type 1 corrected pfMET", "mett1_OF_exclusive");

  
    string basiccutsaved = (const char*)basiccut;
    
    string newbasiccut=basiccutsaved;
    
    size_t found;
    found = newbasiccut.find( "pt2>20" );
    while (found!=string::npos){
      newbasiccut.replace( found, string( "pt2>20" ).length(), "pt2>10" );
      found = newbasiccut.find( "pt2>20" );
    }
    basiccut=TCut(newbasiccut.c_str());
    make_data_comparison_plot("mll", TCut("pfJetGoodNum40>=2&&met[4]>150")&&cutOSSF,60, 0., 300.,-1., false, "mll", "mll_SF_Aachen_pt2010_met");
    make_data_comparison_plot("mll", TCut("pfJetGoodNum40>=2&&met[4]>150")&&cutOSOF,60, 0., 300.,-1., false, "mll", "mll_OF_Aachen_pt2010_met");
    make_data_comparison_plot("mll", TCut("pfJetGoodNum40>=2&&met[1]>150")&&cutOSSF,60, 0., 300.,-1., true, "mll", "mll_SF_Aachen_pt2010_t1cpfmet");
    make_data_comparison_plot("mll", TCut("pfJetGoodNum40>=2&&met[1]>150")&&cutOSOF,60, 0., 300.,-1., true, "mll", "mll_OF_Aachen_pt2010_t1cpfmet");
    basiccut=TCut(basiccutsaved.c_str());
    
    make_data_comparison_plot("pfJetGoodNum40", cutOSSF, 8, 0., 8.,-1., true, "#(jets)", "njets_SF");
    make_data_comparison_plot("pfJetGoodNum40", cutOSOF, 8, 0., 8.,-1., true, "#(jets)", "njets_OF");
    
    make_data_comparison_plot("mll", TCut("pfJetGoodNum40>=3&&met[4]>100")&&cutOSSF,60, 0., 300.,-1., true, "mll", "mll_SF_ETH_met");
    make_data_comparison_plot("mll", TCut("pfJetGoodNum40>=3&&met[4]>100")&&cutOSOF,60, 0., 300.,-1., true, "mll", "mll_OF_ETH_met");
    make_data_comparison_plot("mll", TCut("pfJetGoodNum40>=3&&met[1]>100")&&cutOSSF,60, 0., 300.,-1., true, "mll", "mll_SF_ETH_t1cpfmet");
    make_data_comparison_plot("mll", TCut("pfJetGoodNum40>=3&&met[1]>100")&&cutOSOF,60, 0., 300.,-1., true, "mll", "mll_OF_ETH_t1cpfmet");

    
    make_data_comparison_plot("mll", cutOSSF,60, 15., 315.,-1., true, "m_{ll}", "mll_SF_inclusive");
    make_data_comparison_plot("mll", cutOSSF&&TCut("id1==0"),60, 15., 315.,-1., true, "m_{ll}", "mll_SF_inclusive_ee");
    make_data_comparison_plot("mll", cutOSSF&&TCut("id1==1"),60, 15., 315.,-1., true, "m_{ll}", "mll_SF_inclusive_mm");
    make_data_comparison_plot("mll", cutOSOF,60, 15., 315.,-1., true, "m_{ll}", "mll_OF_inclusive");
    make_data_comparison_plot("mll", cutnJets&&cutOSSF&&TCut("id1==0"),60, 15., 315.,-1., true, "m_{ll}", "mll_SF_exclusive_ee");
    make_data_comparison_plot("mll", cutnJets&&cutOSSF&&TCut("id1==1"),60, 15., 315.,-1., true, "m_{ll}", "mll_SF_exclusive_mm");
    make_data_comparison_plot("mll", cutnJets&&cutOSSF,60, 15., 315.,-1., true, "m_{ll}", "mll_SF_exclusive");
    make_data_comparison_plot("mll", cutnJets&&cutOSOF,60, 15., 315.,-1., true, "m_{ll}", "mll_OF_exclusive");

    make_data_comparison_plot("mll", cutOSSF&&cutSignal&&mllCut,           massnbins, 15., 315.,-1., false, "m_{ll}", "mll_SF_sig");
    make_data_comparison_plot("mll", cutOSOF&&cutSignal&&mllCut,           massnbins, 15., 315.,-1., false, "m_{ll}", "mll_OF_sig");
    
    make_data_comparison_plot("mll", TCut("abs(eta1)<1.4&&abs(eta2)<1.4") && cutOSSF&&cutSignal&&mllCut,           massnbins, 15., 315.,-1., false, "m_{ll}", "mll_SF_sig_central");
    make_data_comparison_plot("mll", TCut("abs(eta1)<1.4&&abs(eta2)<1.4") && cutOSOF&&cutSignal&&mllCut,           massnbins, 15., 315.,-1., false, "m_{ll}", "mll_OF_sig_central");
    
    make_data_comparison_plot("mll", cutOSSF&&cutSignal&&mllCut&&"pfJetGoodNumBtag30==0", massnbins, 15., 315.,-1., false, "m_{ll}", "mll_SF_sig_btagVeto");
    make_data_comparison_plot("mll", cutOSOF&&cutSignal&&mllCut&&"pfJetGoodNumBtag30==0", massnbins, 15., 315.,-1., false, "m_{ll}", "mll_OF_sig_btagVeto");
    
    make_data_comparison_plot("mll", cutOSSF&&cutSignal&&mllCut&&"pfJetGoodNumBtag30>0",  massnbins, 15., 315.,-1., false, "m_{ll}", "mll_SF_sig_AtLeastOneBJet");
    make_data_comparison_plot("mll", cutOSOF&&cutSignal&&mllCut&&"pfJetGoodNumBtag30>0",  massnbins, 15., 315.,-1., false, "m_{ll}", "mll_OF_sig_AtLeastOneBJet");


    make_data_comparison_plot("mll", mllCut&&cutOSOF&&cutSignal, massnbins, 15., 315.,-1., false, "m_{ll}", "mll_OF_sig");
    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");
    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");

    make_data_comparison_plot("pfJetGoodNum40", cutOSSF&&cutSignal&&mllCut, 8, 0., 8.,-1., false, "#(jets)", "njets_SF_sig");
    make_data_comparison_plot("pfJetGoodNum40", cutOSOF&&cutSignal&&mllCut, 8, 0., 8.,-1., false, "#(jets)", "njets_OF_sig");
    make_data_comparison_plot("pfJetGoodNumBtag30", cutOSSF&&cutSignal&&mllCut, 8, 0., 8.,-1., false, "#(b-jets)", "nbjets_SF_sig");
    make_data_comparison_plot("pfJetGoodNumBtag30", cutOSOF&&cutSignal&&mllCut, 8, 0., 8.,-1., false, "#(b-jets)", "nbjets_OF_sig");

  }


  if ( doKin ) {
    string mllCut("");
    /*
    
  
    make_plain_kin_plot("met[4]",Cut2Str(cutOSOF&&TCut("mll>30&&mll<70&&pfJetGoodNum40==0")),40,0,400,dolog,"PFMET","Debunking/MET_OF_30to70_0j",doPF,true);
    make_plain_kin_plot("met[4]",Cut2Str(cutOSOF&&TCut("mll>30&&mll<70&&pfJetGoodNum40==1")),40,0,400,dolog,"PFMET","Debunking/MET_OF_30to70_1j",doPF,true);
    make_plain_kin_plot("met[4]",Cut2Str(cutOSOF&&TCut("mll>30&&mll<70&&pfTightHT>100&&pfJetGoodNum40==2")),40,0,400,dolog,"PFMET","Debunking/MET_OF_30to70_2j",doPF,true);
    make_plain_kin_plot("met[4]",Cut2Str(cutOSOF&&TCut("mll>30&&mll<70&&pfTightHT>100&&pfJetGoodNum40==3")),40,0,400,dolog,"PFMET","Debunking/MET_OF_30to70_3j",doPF,true);

    make_plain_kin_plot("met[4]",Cut2Str(cutOSOF&&TCut("mll>80&&mll<100&&pfJetGoodNum40==0")),40,0,400,dolog,"PFMET","Debunking/MET_OF_Z_0j",doPF,true);
    make_plain_kin_plot("met[4]",Cut2Str(cutOSOF&&TCut("mll>80&&mll<100&&pfJetGoodNum40==1")),40,0,400,dolog,"PFMET","Debunking/MET_OF_Z_1j",doPF,true);
    make_plain_kin_plot("met[4]",Cut2Str(cutOSOF&&TCut("mll>80&&mll<100&&pfTightHT>100&&pfJetGoodNum40==2")),40,0,400,dolog,"PFMET","Debunking/MET_OF_Z_2j",doPF,true);
    make_plain_kin_plot("met[4]",Cut2Str(cutOSOF&&TCut("mll>80&&mll<100&&pfTightHT>100&&pfJetGoodNum40==3")),40,0,400,dolog,"PFMET","Debunking/MET_OF_Z_3j",doPF,true);


    make_plain_kin_plot("pfTightHT",Cut2Str(cutOSOF&&cutnJets),120,0,1200,dolog,"H_{T}","HT_3jets_OF",doPF,true);
    make_plain_kin_plot("pfTightHT",Cut2Str(cutOSSF&&cutnJets) ,120,0,1200,dolog,"H_{T}","HT_3jets_SF",doPF,true);
    make_plain_kin_plot("pfTightHT",Cut2Str(cutOSOF&&cutnJets&&TCut("met[4]>100")),120,0,1200,dolog,"H_{T}","HT_3jets_OF_MET100",doPF,true);
    make_plain_kin_plot("pfTightHT",Cut2Str(cutOSSF&&cutnJets&&TCut("met[4]>100")) ,120,0,1200,dolog,"H_{T}","HT_3jets_SF_MET100",doPF,true);

    
    make_plain_kin_plot("met[1]",Cut2Str(cutOSOF&&TCut("mll>30&&mll<70&&pfJetGoodNum40==0")),40,0,400,dolog,"PFMET","Debunking/T1MET_OF_30to70_0j",doPF,true);
    make_plain_kin_plot("met[1]",Cut2Str(cutOSOF&&TCut("mll>30&&mll<70&&pfJetGoodNum40==1")),40,0,400,dolog,"PFMET","Debunking/T1MET_OF_30to70_1j",doPF,true);
    make_plain_kin_plot("met[1]",Cut2Str(cutOSOF&&TCut("mll>30&&mll<70&&pfTightHT>100&&pfJetGoodNum40==2")),40,0,400,dolog,"PFMET","Debunking/T1MET_OF_30to70_2j",doPF,true);
    make_plain_kin_plot("met[1]",Cut2Str(cutOSOF&&TCut("mll>30&&mll<70&&pfTightHT>100&&pfJetGoodNum40==3")),40,0,400,dolog,"PFMET","Debunking/T1MET_OF_30to70_3j",doPF,true);

    make_plain_kin_plot("met[1]",Cut2Str(cutOSOF&&TCut("mll>80&&mll<100&&pfJetGoodNum40==0")),40,0,400,dolog,"PFMET","Debunking/T1MET_OF_Z_0j",doPF,true);
    make_plain_kin_plot("met[1]",Cut2Str(cutOSOF&&TCut("mll>80&&mll<100&&pfJetGoodNum40==1")),40,0,400,dolog,"PFMET","Debunking/T1MET_OF_Z_1j",doPF,true);
    make_plain_kin_plot("met[1]",Cut2Str(cutOSOF&&TCut("mll>80&&mll<100&&pfTightHT>100&&pfJetGoodNum40==2")),40,0,400,dolog,"PFMET","Debunking/T1MET_OF_Z_2j",doPF,true);
    make_plain_kin_plot("met[1]",Cut2Str(cutOSOF&&TCut("mll>80&&mll<100&&pfTightHT>100&&pfJetGoodNum40==3")),40,0,400,dolog,"PFMET","Debunking/T1MET_OF_Z_3j",doPF,true);

    make_plain_kin_plot("met[4]",Cut2Str(cutOSSF&&cutnJets&&TCut("mll>20&&mll<70")),50,0,300,dolog,"PFMET","MET_SF_20to70",doPF,true);
    make_plain_kin_plot("met[4]",Cut2Str(cutOSOF&&cutnJets&&TCut("mll>20&&mll<70")),50,0,300,dolog,"PFMET","MET_OF_20to70",doPF,true);
     
    make_plain_kin_plot("met[4]",Cut2Str(cutOSSF&&cutnJets&&TCut("mll>120")),50,0,300,dolog,"PFMET","MET_SF_above120",doPF,true);
    make_plain_kin_plot("met[4]",Cut2Str(cutOSOF&&cutnJets&&TCut("mll>120")),50,0,300,dolog,"PFMET","MET_OF_above120",doPF,true);
     
    make_plain_kin_plot("met[4]",Cut2Str(cutOSSF&&TCut("pfJetGoodNum40==2")&&TCut("mll>20&&mll<70")),50,0,300,dolog,"PFMET","MET_SF_20to70___2jetsonly",doPF,true);
    make_plain_kin_plot("met[4]",Cut2Str(cutOSOF&&TCut("pfJetGoodNum40==2")&&TCut("mll>20&&mll<70")),50,0,300,dolog,"PFMET","MET_OF_20to70___2jetsonly",doPF,true);
     
    make_plain_kin_plot("met[4]",Cut2Str(cutOSSF&&TCut("pfJetGoodNum40==2")&&TCut("mll>120")),50,0,300,dolog,"PFMET","MET_SF_above120___2jetsonly",doPF,true);
    make_plain_kin_plot("met[4]",Cut2Str(cutOSOF&&TCut("pfJetGoodNum40==2")&&TCut("mll>120")),50,0,300,dolog,"PFMET","MET_OF_above120___2jetsonly",doPF,true);

     
    make_kin_plot("pfJetGoodPt[0]/pfJetGoodPt[1]","",45,1,10,dolog,"pt_{j}^{1}/pt_{j}^{2}","j1j2ratio",doPF,true);
    make_kin_plot("TMath::Abs(pfJetDphiMet[0])","",32,0,3.2,nolog,"|#Delta#phi(jet1,MET)|","dphiJ1MET",doPF,true);
    // Plots in signal region
    make_kin_plot("met[4]","",70,0,350,dolog,"MET [GeV]","met",doPF,true);


    make_kin_plot("MetFactor","",20,0,2,nolog,"MetFactor","MetFactor",doPF,true);
     
    make_ttbar_comparison("met[4]",40,0,400,(cutOSOF&&TCut("mll>30&&mll<70&&pfTightHT>100&&pfJetGoodNum40==2")),dolog,"PFMET","Debunking/MET_OF_30to70_2j__ALLMCSAMPLES");
     */
    DoMCSystPlot("met[4]",40,0,400,(cutOSOF&&TCut("mll>30&&mll<70&&pfJetGoodNum40==0")),dolog,"PFMET","Debunking/MET_OF_30to70_0j");
    DoMCSystPlot("met[4]",40,0,400,(cutOSOF&&TCut("mll>30&&mll<70&&pfJetGoodNum40==1")),dolog,"PFMET","Debunking/MET_OF_30to70_1j");
    DoMCSystPlot("met[4]",40,0,400,(cutOSOF&&TCut("mll>30&&mll<70&&pfTightHT>100&&pfJetGoodNum40==2")),dolog,"PFMET","Debunking/MET_OF_30to70_2j");
    DoMCSystPlot("met[4]",40,0,400,(cutOSOF&&TCut("mll>30&&mll<70&&pfTightHT>100&&pfJetGoodNum40==3")),dolog,"PFMET","Debunking/MET_OF_30to70_3j");

    DoMCSystPlot("met[4]",40,0,400,(cutOSSF&&TCut("mll>30&&mll<70&&pfJetGoodNum40==0")),dolog,"PFMET","Debunking/MET_SF_30to70_0j");
    DoMCSystPlot("met[4]",40,0,400,(cutOSSF&&TCut("mll>30&&mll<70&&pfJetGoodNum40==1")),dolog,"PFMET","Debunking/MET_SF_30to70_1j");
    DoMCSystPlot("met[4]",40,0,400,(cutOSSF&&TCut("mll>30&&mll<70&&pfTightHT>100&&pfJetGoodNum40==2")),dolog,"PFMET","Debunking/MET_SF_30to70_2j");
    DoMCSystPlot("met[4]",40,0,400,(cutOSSF&&TCut("mll>30&&mll<70&&pfTightHT>100&&pfJetGoodNum40==3")),dolog,"PFMET","Debunking/MET_SF_30to70_3j");

    DoMCSystPlot("met[4]",40,0,400,(cutOSOF&&TCut("mll>80&&mll<100&&pfJetGoodNum40==0")),dolog,"PFMET","Debunking/MET_OF_Z_0j");
    DoMCSystPlot("met[4]",40,0,400,(cutOSOF&&TCut("mll>80&&mll<100&&pfJetGoodNum40==1")),dolog,"PFMET","Debunking/MET_OF_Z_1j");
    DoMCSystPlot("met[4]",40,0,400,(cutOSOF&&TCut("mll>80&&mll<100&&pfTightHT>100&&pfJetGoodNum40==2")),dolog,"PFMET","Debunking/MET_OF_Z_2j");
    DoMCSystPlot("met[4]",40,0,400,(cutOSOF&&TCut("mll>80&&mll<100&&pfTightHT>100&&pfJetGoodNum40==3")),dolog,"PFMET","Debunking/MET_OF_Z_3j");

    
    DoMCSystPlot("mll", (int)((mll_hi-mll_low)/5),mll_low,mll_hi,cutnJets&&cutOSSF,dolog,"m_{ll} [GeV]","kinSys/mll");
    DoMCSystPlot("mll", (int)((mll_hi-mll_low)/5),mll_low,mll_hi,cutnJets&&cutOSSF&&TCut("id1==0"),dolog,"m_{ll} [GeV]","kinSys/mll_ee");
    DoMCSystPlot("mll", (int)((mll_hi-mll_low)/5),mll_low,mll_hi,cutnJets&&cutOSSF&&TCut("id1==1"),dolog,"m_{ll} [GeV]","kinSys/mll_mm");
    DoMCSystPlot("mll", (int)((mll_hi-mll_low)/5),mll_low,mll_hi,cutnJets&&cutOSOF,dolog,"m_{ll} [GeV]","kinSys/mll_osof");

    DoMCSystPlot("mll", (int)((mll_hi-mll_low)/5),mll_low,mll_hi,cutOSSF,dolog,"m_{ll} [GeV]","kinSys/mll_inclusive");
    DoMCSystPlot("mll", (int)((mll_hi-mll_low)/5),mll_low,mll_hi,cutOSOF,dolog,"m_{ll} [GeV]","kinSys/mll_inclusive_osof");

    DoMCSystPlot("pfJetGoodNum40", 9,-0.5,8.5,cutOSSF,dolog,"nJets","kinSys/nJets_ossf");
    DoMCSystPlot("pfJetGoodNum40", 9,-0.5,8.5,cutOSOF,dolog,"nJets","kinSys/nJets_osof");
     
    DoMCSystPlot("pfJetGoodPt[0]/pfJetGoodPt[1]",45,1,10,cutnJets&&cutOSSF,dolog,"p_{T}^{J1} / p_{T}^{J2}","kinSys/j1j2ratio");
    DoMCSystPlot("TMath::Abs(pfJetDphiMet[0])",32,0,3.2,cutnJets&&cutOSSF,dolog,"|#Delta#phi(jet1,MET)|","kinSys/dphiJ1MET");
    DoMCSystPlot(datajzb,mcjzb, (int)((PlottingSetup::jzbHigh+110)/10),-110,PlottingSetup::jzbHigh,cutnJets&&cutOSSF&&Restrmasscut,dolog,"m_{ll} [GeV]","kinSys/jzb_OS_SFZP");
    DoMCSystPlot(datajzb,mcjzb, (int)((PlottingSetup::jzbHigh+110)/10),-110,PlottingSetup::jzbHigh,cutnJets&&cutOSOF&&Restrmasscut,dolog,"m_{ll} [GeV]","kinSys/jzb_OS_OFZP");

    make_kin_plot("mll","mll>20"+mllCut,(int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll",doPF,true);
    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);
    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);
    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);
    
    make_kin_plot("pfJetGoodNum40",mllCut,9,-0.5,8.5,dolog,"nJets","nJets",doPF);
    make_kin_plot("pfJetGoodNum40","",9,-0.5,8.5,dolog,"nJets","nJets_osof",doPF);
    
    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);
    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);
    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);
    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);
    
    
    make_kin_plot("pfJetGoodNum40","met[4]>100"+mllCut,9,-0.5,8.5,dolog,"nJets","nJets_met100",doPF);
    make_kin_plot("pfJetGoodNum40","met[4]>100",9,-0.5,8.5,dolog,"nJets","nJets_osof_met100",doPF);

    // Further inclusive invariant mass plots
    make_kin_plot("mll",mllCut,(int)((mll_hi-mll_low))/5,mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_inclusive",doPF,true);
    make_kin_plot("mll","",(int)((mll_hi-mll_low))/5,mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_inclusive_ee",doPF,true);
    make_kin_plot("mll","",(int)((mll_hi-mll_low))/5,mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_inclusive_mm",doPF,true);
    make_kin_plot("mll",mllCut,(int)((mll_hi-mll_low))/5,mll_low,mll_hi,dolog,"m_{ll} [GeV]","mll_inclusive_osof",doPF,true);
    
    make_kin_plot("mll","",(int)((350-mll_low))/5,mll_low,350,dolog,"m_{ll} [GeV]","mll_inclusive_highrange",doPF);
    //if(!doPF) make_special_mll_plot((int)((mll_hi-mll_low)/5),mll_low,mll_hi,dolog,"m_{ll} [GeV]");
    
    
    // Number of jets
    make_kin_plot("pfJetGoodNum40","",9,-0.5,8.5,dolog,"nJets","nJets_inclusive",doPF);
    make_kin_plot("pfJetGoodNum40","",9,-0.5,8.5,dolog,"nJets","nJets_osof_inclusive",doPF);
    make_kin_plot("pfJetGoodNum40","",9,-0.5,8.5,dolog,"nJets","nJets_nocuts_except_mll_ossf",doPF);
    
    // Others
    make_kin_plot("numVtx","",(int)(30.5-(-0.5)),-0.5,30.5,nolog,"N(Vtx)","numVtx",doPF);
    //  make_kin_plot("jetpt[0]","",40,0,200,dolog,"leading jet p_{T} [GeV]","pfJetGoodPt_0",doPF);
    //  make_kin_plot("jeteta[0]","",40,-5,5,nolog,"leading jet #eta","pfJetGoodEta_0",doPF);
    make_kin_plot("pt","",50,0,500,dolog,"Z p_{T} [GeV]","Zpt",doPF);
    make_kin_plot("pt1","",50,0,200,nolog,"p_{T} [GeV]","pt1",doPF);
    make_kin_plot("pt2","",50,0,200,nolog,"p_{T} [GeV]","pt2",doPF);
    make_kin_plot("eta1","",40,-3,3,nolog,"#eta_{l}","eta",doPF);
    make_kin_plot("jzb[1]","",100,-150,200,dolog,"JZB [GeV]","jzb_ossf",doPF);
    //   stringstream jzbcut;
    //   jzbcut << "((is_data&&("<<datajzb<<")>100)||(!is_data&&("<<mcjzb<<")>100))";
    //   make_kin_plot("mll",jzbcut.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,nolog,"m_{ll} [GeV]","mll_aboveJZB100",doPF,true);
    //   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);
    //   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);
    //   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);
    //   stringstream jzbcut2;
    //   jzbcut2 << "((is_data&&("<<datajzb<<")>150)||(!is_data&&("<<mcjzb<<")>150))";
    //   make_kin_plot("mll",jzbcut2.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,nolog,"m_{ll} [GeV]","mll_aboveJZB150",doPF,true);
    //   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);
    //   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);
    //   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);
    //   stringstream jzbcut3;
    //   jzbcut3 << "((is_data&&("<<datajzb<<")>50)||(!is_data&&("<<mcjzb<<")>50))";
    //   make_kin_plot("mll",jzbcut3.str(),(int)((mll_hi-mll_low)/5),mll_low,mll_hi,nolog,"m_{ll} [GeV]","mll_aboveJZB50",doPF,true);   
    //   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);
    //   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);   
    //   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);   
    
    //   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);
    //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);
    //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);
  }
    
   make_special_obs_pred_mll_plot(datajzb,mcjzb,0);
   make_special_obs_pred_mll_plot(datajzb,mcjzb,50);
   make_special_obs_pred_mll_plot(datajzb,mcjzb,80);
   make_special_obs_pred_mll_plot(datajzb,mcjzb,100);
   make_special_obs_pred_mll_plot(datajzb,mcjzb,150);
   make_special_obs_pred_mll_plot(datajzb,mcjzb,200);
   make_special_obs_pred_mll_plot(datajzb,mcjzb,250);

   make_JES_plot(cutmass&&cutOSSF&&basiccut,"_ossf");
   make_JES_plot(cutmass&&cutOSOF&&basiccut,"_osof");

  switch_overunderflow(false);
}

void make_comp_plot( string var, string xlabel, string filename, float jzbcut, string mcjzb, string datajzb,
                     int nbins, float xmin, float xmax, bool log,
                     float ymin=0, float ymax=0, bool leftJustified=false ) {
  flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak ---- WATCH OUT: the argument in the function changed!

  TCut weightbackup=cutWeight;//backing up the correct weight (restoring below!)
  if(weightbackup==TCut("1.0")||weightbackup==TCut("1")) write_warning(__FUNCTION__,"WATCH OUT THE WEIGHT HAS POSSIBLY NOT BEEN RESET!!!! PLEASE CHANGE LINE "+any2string(__LINE__));
  //if(var=="numVtx") cutWeight=TCut("1.0");
  TCut jzbData[]= { TCut(TString(datajzb+">"+any2string(jzbcut))),TCut(TString(datajzb+"<-"+any2string(jzbcut))) };
  TCut jzbMC[]  = { TCut(TString(mcjzb+">"+any2string(jzbcut))),TCut(TString(mcjzb+"<-"+any2string(jzbcut))) };

  flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak ---- below: the next ~20 lines changed!
  int nRegions=4;
  if(!PlottingSetup::RestrictToMassPeak||!PlottingSetup::UseSidebandsForcJZB) {
    nRegions=2;
  }
  
  string sRegions[] = { "SFZP","OFZP","SFSB","OFSB" };
  TCut kRegions[] = { cutOSSF&&cutnJets&&cutmass,     cutOSOF&&cutnJets&&cutmass,
                      cutOSSF&&cutnJets&&sidebandcut, cutOSOF&&cutnJets&&sidebandcut };
  
  //find ymax
  TH1F *Refdatahisto = allsamples.Draw("datahisto",   var,nbins,xmin,xmax,xlabel,"events",kRegions[0]&&jzbData[0],data,luminosity);
  ymax=int((Refdatahisto->GetMaximum()+2*TMath::Sqrt(Refdatahisto->GetMaximum()))*1.2+0.5);
  delete Refdatahisto;
                      
  for ( int iregion=0; iregion<nRegions; ++iregion ) 
    for ( int ijzb=0; ijzb<2; ++ijzb ) {
      TCanvas *ccomp = new TCanvas("ccomp","Comparison plot",600,400);
      ccomp->SetLogy(log);
      TH1F *datahisto = allsamples.Draw("datahisto",   var,nbins,xmin,xmax,xlabel,"events",kRegions[iregion]&&jzbData[ijzb],data,luminosity);
      TH1F *lm3histo  = signalsamples.Draw("lm3histo",   var,nbins,xmin,xmax,xlabel,"events",kRegions[iregion]&&jzbMC[ijzb],data,luminosity,signalsamples.FindSample("LM3"));
      THStack mcstack = allsamples.DrawStack("mcstack",var,nbins,xmin,xmax,xlabel,"events",kRegions[iregion]&&jzbMC[ijzb],  mc,  luminosity);
      datahisto->SetMarkerSize(DataMarkerSize);
      if (ymax>ymin) datahisto->SetMaximum(ymax);
      lm3histo->SetLineStyle(2);
      datahisto->Draw("e1");
      mcstack.Draw("histo,same");
      datahisto->Draw("same,e1");
      lm3histo->Draw("hist,same");
      TLegend *kinleg = allsamples.allbglegend((sRegions[iregion]+(ijzb?"neg":"pos")).c_str());
      if ( leftJustified ) {
        Float_t w = kinleg->GetX2()-kinleg->GetX1();
        kinleg->SetX1(0.2);
        kinleg->SetX2(0.2+w);
      }
      kinleg->AddEntry(lm3histo,"LM3","l");
      kinleg->Draw();
      TText* write_variable = write_text(0.99,0.01,var);
      write_variable->SetTextAlign(31);
      write_variable->SetTextSize(0.02);
      ccomp->RedrawAxis();
      CompleteSave(ccomp,"compare/JZBcut_at_"+any2string(jzbcut)+"/"+filename+"/"+filename+sRegions[iregion]+(ijzb?"neg":"pos"));
      delete datahisto;
      delete ccomp;
      delete lm3histo;
    }
  cutWeight=weightbackup;
}


void region_comparison_plots(string mcjzb, string datajzb, vector<float> jzb_cuts) {
  dout << "Creating comparison plots for signal and control regions" << endl;
  // Compare a few quantities in the signal region and all 7 control regions

//  switch_overunderflow(true);  // switching overflow/underflow bins on
    
  switch_overunderflow(true);
    flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak ---- the arguments changed
  for(int ijzb=0;ijzb<(int)jzb_cuts.size();ijzb++) {
    float jzbcut=jzb_cuts[ijzb]; // Comparison plots are done for this JZB cut
    float mll_low=50;float mll_high=170;
    if(!PlottingSetup::RestrictToMassPeak) {
        mll_high=300;
        mll_low=20;
    }
    make_comp_plot("pfJetGoodPt[0]/pfJetGoodPt[1]","pt_{j}^{1}/pt_{j}^{2}","j1j2ratio",jzbcut,mcjzb,datajzb,100,0,10,true);
    make_comp_plot("TMath::Abs(pfJetDphiMet[0])","|#Delta#phi(jet1,MET)|","dphiJ1MET",jzbcut,mcjzb,datajzb,32,0,3.2,false,0,0,true);

    make_comp_plot("mll","m_{ll} [GeV]","mll",jzbcut,mcjzb,datajzb,56,mll_low,mll_high,false,0,16.);
    make_comp_plot("met[4]","pfMET [GeV]","pfmet",jzbcut,mcjzb,datajzb,18,0,360,false,0,16.);
    make_comp_plot("pfJetGoodNum40","#(jets)","njets",jzbcut,mcjzb,datajzb,10,0,10, false,0,35.);
    make_comp_plot("pfJetGoodNumBtag","#(b-jets)","nBjets",jzbcut,mcjzb,datajzb,10,0,10, false,0,35.);
    make_comp_plot("pt","Z p_{T} [GeV]","Zpt",jzbcut,mcjzb,datajzb,26,0,525,false,0.,21.);
    make_comp_plot("numVtx","#(prim. vertices)","nvtx",jzbcut,mcjzb,datajzb,40,0.,40.,false,0,16.);
    make_comp_plot("TMath::Abs(dphi)","#Delta#phi(leptons)","dphilep",jzbcut,mcjzb,datajzb,10,0.,3.1415,false,0,16.,true);
    make_comp_plot("TMath::Abs(dphi_sumJetVSZ[1])","#Delta#phi(Z,jets)","dphiZjets",jzbcut,mcjzb,datajzb,10,0.,3.1415,false,0,16.,true);
    make_comp_plot("eta1","#eta_1","eta1",jzbcut,mcjzb,datajzb,10,0.,2.5,false,0,16.);
    make_comp_plot("eta2","#eta_2","eta2",jzbcut,mcjzb,datajzb,10,0.,2.5,false,0,16.);
  }

  switch_overunderflow(false); // switching overflow/underflow bins off
}


void do_kinematic_PF_plots(string mcjzb, string datajzb)
{
  do_kinematic_plots(mcjzb,datajzb,true);
}

void signal_bg_comparison()
{
  TCanvas *can = new TCanvas("can","Signal Background Comparison Canvas");
  can->SetLogy(1);

  int sbg_nbins=130;
  float sbg_min=-500; //-110;
  float sbg_max=800; //jzbHigh;
  
  float simulatedlumi=luminosity;//in pb please - adjust to your likings
  
  TH1F *JZBplotZJETs = allsamples.Draw("JZBplotZJETs",jzbvariablemc,sbg_nbins,sbg_min,sbg_max, "JZB [GeV]", "events",cutmass&&cutOSSF&&cutnJets,mc,simulatedlumi,allsamples.FindSample("/DY"));
  TH1F *JZBplotLM4;
  if(PlottingSetup::RestrictToMassPeak) JZBplotLM4 = allsamples.Draw("JZBplotLM4",jzbvariablemc,sbg_nbins,sbg_min,sbg_max, "JZB [GeV]", "events",cutmass&&cutOSSF&&cutnJets,mc,simulatedlumi,allsamples.FindSample("LM4"));
  else JZBplotLM4 = allsamples.Draw("JZBplotLM4",jzbvariablemc,sbg_nbins,sbg_min,sbg_max, "JZB [GeV]", "events",cutmass&&cutOSSF&&cutnJets,mc,simulatedlumi,allsamples.FindSample("LM3"));
  TH1F *JZBplotTtbar = allsamples.Draw("JZBplotTtbar",jzbvariablemc,sbg_nbins,sbg_min,sbg_max, "JZB [GeV]", "events",cutmass&&cutOSSF&&cutnJets,mc,simulatedlumi,allsamples.FindSample("TTJets"));
  
  JZBplotTtbar->SetLineColor(allsamples.GetColor("TTJet"));
  JZBplotZJETs->SetFillColor(allsamples.GetColor("DY"));
  JZBplotZJETs->SetLineColor(kBlack);
  JZBplotLM4->SetLineStyle(2);
  JZBplotZJETs->SetMaximum(JZBplotZJETs->GetMaximum()*5);
  JZBplotZJETs->SetMinimum(1);

  JZBplotTtbar->SetMaximum(JZBplotZJETs->GetMaximum());
  JZBplotTtbar->SetMinimum(0.01);
  JZBplotTtbar->SetFillColor(allsamples.GetColor("TTJets"));
  JZBplotTtbar->DrawClone("histo");
  JZBplotZJETs->Draw("histo,same");
  JZBplotTtbar->SetFillColor(0);
  JZBplotTtbar->DrawClone("histo,same");
  JZBplotTtbar->SetFillColor(allsamples.GetColor("TTJets"));
  JZBplotLM4->Draw("histo,same");


  TLegend *signal_bg_comparison_leg2 =  make_legend("",0.55,0.75,false);
  signal_bg_comparison_leg2->AddEntry(JZBplotZJETs,"Z+Jets","f");
  signal_bg_comparison_leg2->AddEntry(JZBplotTtbar,"t#bar{t}","f");
  if(PlottingSetup::RestrictToMassPeak) signal_bg_comparison_leg2->AddEntry(JZBplotLM4,"LM4","f");
  else signal_bg_comparison_leg2->AddEntry(JZBplotLM4,"LM3","f");
  signal_bg_comparison_leg2->Draw();
  DrawMCPrelim(simulatedlumi);
  CompleteSave(can,"jzb_bg_vs_signal_distribution");

  // Define illustrative set of SMS points
  TCut kSMS1("MassGlu==250&&MassLSP==75");
  TCut kSMS2("MassGlu==800&&MassLSP==200");
  TCut kSMS3("MassGlu==1050&&MassLSP==850");
  TCut kSMS4("MassGlu==1200&&MassLSP==100");
  
  //If the scan samples haven't been loaded yet, this is a good point to load them (all of them!)
  if((scansample.collection).size()<2) define_SMS_sample(false, allsamples, signalsamples, scansample, true); // loading ALL zones for the scans, not only the basic one.

  
  TH1F *JZBplotSMS1 = scansample.Draw("JZBplotSMS1",jzbvariablemc,sbg_nbins,sbg_min,sbg_max, "JZB [GeV]", "events",cutmass&&cutOSSF&&cutnJets&&kSMS1,mc,simulatedlumi,scansample.FindSample("t"));
  JZBplotSMS1->Scale(JZBplotLM4->Integral()/JZBplotSMS1->Integral());

  TH1F *JZBplotSMS2 = scansample.Draw("JZBplotSMS2",jzbvariablemc,sbg_nbins,sbg_min,sbg_max, "JZB [GeV]", "events",cutmass&&cutOSSF&&cutnJets&&kSMS2,mc,simulatedlumi,scansample.FindSample("t"));
  JZBplotSMS2->Scale(JZBplotLM4->Integral()/JZBplotSMS2->Integral());

  TH1F *JZBplotSMS3 = scansample.Draw("JZBplotSMS3",jzbvariablemc,sbg_nbins,sbg_min,sbg_max, "JZB [GeV]", "events",cutmass&&cutOSSF&&cutnJets&&kSMS3,mc,simulatedlumi,scansample.FindSample("t"));
  JZBplotSMS3->Scale(JZBplotLM4->Integral()/JZBplotSMS3->Integral());
  
  TH1F *JZBplotSMS4 = scansample.Draw("JZBplotSMS4",jzbvariablemc,sbg_nbins,sbg_min,sbg_max, "JZB [GeV]", "events",cutmass&&cutOSSF&&cutnJets&&kSMS4,mc,simulatedlumi,scansample.FindSample("t"));
  JZBplotSMS4->Scale(JZBplotLM4->Integral()/JZBplotSMS4->Integral());

  // Draw all plots overlaid
  JZBplotTtbar->SetMaximum(JZBplotZJETs->GetMaximum());
  JZBplotTtbar->SetMinimum(0.01);
  JZBplotTtbar->SetFillColor(allsamples.GetColor("TTJets"));
  JZBplotTtbar->DrawClone("histo");
  JZBplotZJETs->Draw("histo,same");
  JZBplotTtbar->SetFillColor(0);
  JZBplotTtbar->DrawClone("histo,same");
  JZBplotTtbar->SetFillColor(allsamples.GetColor("TTJets"));

  JZBplotSMS1->SetLineColor(kRed+1);
  JZBplotSMS2->SetLineColor(kBlue+1);
  JZBplotSMS3->SetLineColor(kRed+1);
  JZBplotSMS4->SetLineColor(kBlue+1);
  JZBplotSMS3->SetLineStyle(2);
  JZBplotSMS4->SetLineStyle(2);
  
  JZBplotSMS1->Draw("histo,same");
  JZBplotSMS2->Draw("histo,same");
  JZBplotSMS3->Draw("histo,same");
  JZBplotSMS4->Draw("histo,same");
  JZBplotLM4->SetLineColor(kGreen);JZBplotLM4->Draw("histo,same");
  TLegend *signal_bg_comparison_leg6 = make_legend("",0.55,0.55,false);
  signal_bg_comparison_leg6->AddEntry(JZBplotZJETs,"Z+Jets","f");
  signal_bg_comparison_leg6->AddEntry(JZBplotTtbar,"t#bar{t}","f");
  signal_bg_comparison_leg6->AddEntry(JZBplotSMS1,"","");
  signal_bg_comparison_leg6->AddEntry(JZBplotSMS1,"SMS parameters","");
  signal_bg_comparison_leg6->AddEntry(JZBplotSMS1,"(250,75) [GeV]","f");
  signal_bg_comparison_leg6->AddEntry(JZBplotSMS2,"(800,200) [GeV]","f");
  signal_bg_comparison_leg6->AddEntry(JZBplotSMS3,"(1050,850) [GeV]","f");
  signal_bg_comparison_leg6->AddEntry(JZBplotSMS4,"(1200,100) [GeV]","f");
  signal_bg_comparison_leg6->AddEntry(JZBplotLM4,"LM4","f");
  signal_bg_comparison_leg6->Draw();
  DrawMCPrelim(simulatedlumi);
  CompleteSave(can,"jzb_bg_vs_signal_distribution_SMS__summary");
    
  while((scansample.collection).size() > 1) scansample.RemoveLastSample();
    
}

vector<TF1*> do_cb_fit_to_plot(TH1F *histo, float Sigma, float doingfitacrosstheboard=false) {
  TF1 *BpredFunc = new TF1("BpredFunc",InvCrystalBall,0,1000,5);
  BpredFunc->SetParameter(0,histo->GetBinContent(1));
  if(doingfitacrosstheboard) BpredFunc->SetParameter(0,histo->GetMaximum());
  BpredFunc->SetParameter(1,0.);
  if(method==1) BpredFunc->SetParameter(2,10*Sigma);//KM
  else BpredFunc->SetParameter(2,Sigma);//Gaussian based methods
  if(method==-99) BpredFunc->SetParameter(2,2.0*Sigma);//Kostas
  BpredFunc->SetParameter(3,1.8);
  BpredFunc->SetParameter(4,2.5);
  histo->Fit(BpredFunc,"QN0");
  BpredFunc->SetLineColor(kBlue);
  
  TF1 *BpredFuncP = new TF1("BpredFuncP",InvCrystalBallP,-1000,histo->GetBinLowEdge(histo->GetNbinsX())+histo->GetBinWidth(histo->GetNbinsX()),5);
  TF1 *BpredFuncN = new TF1("BpredFuncN",InvCrystalBallN,-1000,histo->GetBinLowEdge(histo->GetNbinsX())+histo->GetBinWidth(histo->GetNbinsX()),5);
  
  BpredFuncP->SetParameters(BpredFunc->GetParameters());
  BpredFuncP->SetLineColor(kBlue);
  BpredFuncP->SetLineStyle(2);
  
  BpredFuncN->SetParameters(BpredFunc->GetParameters());
  BpredFuncN->SetLineColor(kBlue);
  BpredFuncN->SetLineStyle(2);
  
  vector<TF1*> functions;
  functions.push_back(BpredFuncN);
  functions.push_back(BpredFunc);
  functions.push_back(BpredFuncP);
  return functions;
}


TF1* do_logpar_fit_to_plot(TH1F *osof) {
  TCanvas *logpar_fit_can = new TCanvas("logpar_fit_can","Fit canvas for LogPar");
  TF1 *logparfunc = new TF1("logparfunc",LogParabola,0,300,3);
  TF1 *logparfunc2 = new TF1("logparfunc2",LogParabola,0,(osof->GetXaxis()->GetBinLowEdge(osof->GetNbinsX())+osof->GetXaxis()->GetBinWidth(osof->GetNbinsX())),3);
  TF1 *logparfuncN = new TF1("logparfuncN",LogParabolaN,0,(osof->GetXaxis()->GetBinLowEdge(osof->GetNbinsX())+osof->GetXaxis()->GetBinWidth(osof->GetNbinsX())),3);
  TF1 *logparfuncP = new TF1("logparfuncP",LogParabolaP,0,(osof->GetXaxis()->GetBinLowEdge(osof->GetNbinsX())+osof->GetXaxis()->GetBinWidth(osof->GetNbinsX())),3);
  osof->SetMinimum(0);
  osof->Fit(logparfunc,"QR");
  osof->Draw();
  logparfunc->SetLineWidth(2);
  logparfunc2->SetParameters(logparfunc->GetParameters());
  logparfuncN->SetParameters(logparfunc->GetParameters());
  logparfuncP->SetParameters(logparfunc->GetParameters());
  stringstream fitinfo;
  fitinfo << "#Chi^{2} / NDF : " << logparfunc->GetChisquare() << " / " << logparfunc->GetNDF();
  TText *writefitinfo = write_text(0.8,0.8,fitinfo.str());
  writefitinfo->SetTextSize(0.03);
  DrawPrelim();
  writefitinfo->Draw();
  logparfunc->Draw("same");
  logparfunc2->Draw("same");
  logparfuncN->SetLineStyle(2);
  logparfuncP->SetLineStyle(2);
  logparfuncN->Draw("same");
  logparfuncP->Draw("same");
  CompleteSave(logpar_fit_can,"MakingOfBpredFunction/Bpred_Data_LogPar_Fit_To_TTbarPred");
  delete logpar_fit_can;
  return logparfunc2;
}

vector<TF1*> do_extended_fit_to_plot(TH1F *prediction, TH1F *Tprediction, TH1F *ossf, TH1F *osof,int isdata) {
  /* there are mainly two background contributions: Z+Jets (a) and ttbar (b). So:
  a) The case is clear - we take the OSSF prediction - OSOF prediction, and fit a crystal ball function to it. We then extract the CB parameters.
  b) For ttbar, we use the OSOF distribution and look at the [10,100] GeV JZB range, and fit our log parabola. We then extract the LP parameters.
  Once we have these two components, we use the combined parameters to get the final function and we're done.
  */
  //Step 1: take the OSSF prediction - OSOF prediction, and fit a crystal ball function to it
  TH1F *step1cb = (TH1F*)ossf->Clone("step1cb");
  step1cb->Add(osof,-1);
  vector<TF1*> functions = do_cb_fit_to_plot(step1cb,PlottingSetup::JZBPeakWidthData);
  TF1 *zjetscrystalball = functions[1];
  
  //Step 2: use the OSOF distribution and look at the [10,100] GeV JZB range, and fit our log parabola
//  TH1F *ttbarprediction=(TH1F*)prediction->Clone("ttbarprediction");
//  ttbarprediction->Add(ossf,-1);//without the Z+Jets estimate, this is really just the ttbar estimate!
//      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)
  TF1 *ttbarlogpar = do_logpar_fit_to_plot(Tprediction);
  flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak
  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);


  TF1 *ttbarlogparP = new TF1("ttbarlogparP",LogParabolaP,0,(prediction->GetXaxis()->GetBinLowEdge(prediction->GetNbinsX())+prediction->GetXaxis()->GetBinWidth(prediction->GetNbinsX())),8);
  TF1 *ttbarlogparN = new TF1("ttbarlogparN",LogParabolaN,0,(prediction->GetXaxis()->GetBinLowEdge(prediction->GetNbinsX())+prediction->GetXaxis()->GetBinWidth(prediction->GetNbinsX())),8);
  
  //and now fuse the two!
  TF1 *kmlp = new TF1("kmlp", CrystalBallPlusLogParabola, 0,(prediction->GetXaxis()->GetBinLowEdge(prediction->GetNbinsX())+prediction->GetXaxis()->GetBinWidth(prediction->GetNbinsX())),8);
  TF1 *kmlpP= new TF1("kmlpP",CrystalBallPlusLogParabolaP,0,(prediction->GetXaxis()->GetBinLowEdge(prediction->GetNbinsX())+prediction->GetXaxis()->GetBinWidth(prediction->GetNbinsX())),8);
  TF1 *kmlpN= new TF1("kmlpN",CrystalBallPlusLogParabolaN,0,(prediction->GetXaxis()->GetBinLowEdge(prediction->GetNbinsX())+prediction->GetXaxis()->GetBinWidth(prediction->GetNbinsX())),8);
  double kmlp_pars[10];
  for(int i=0;i<5;i++) kmlp_pars[i]=zjetscrystalball->GetParameter(i);
  for(int i=0;i<3;i++) kmlp_pars[5+i]=ttbarlogpar->GetParameter(i);
  ttbarlogparP->SetParameters(ttbarlogpar->GetParameters());
  ttbarlogparN->SetParameters(ttbarlogpar->GetParameters());
  kmlp->SetParameters(kmlp_pars);
  prediction->Fit(kmlp,"Q");//fitting the final result (done this in the past but kicked it)
/*
if you want to start from scratch (without the partial fitting and only fitting the whole thing, some good start values could be : 
  */
  kmlp_pars[0]=kmlp->GetParameter(0);
  kmlp_pars[1]=3.6198;
  kmlp_pars[2]=16.4664;
  kmlp_pars[3]=1.92253;
  kmlp_pars[4]=3.56099;
  kmlp_pars[5]=5.83;
  kmlp_pars[6]=0.000757479;
  kmlp_pars[7]=95.6157;
  kmlp_pars[8]=0;
  kmlp_pars[9]=0;
  kmlp->SetParameters(kmlp_pars);
/**/
  prediction->Fit(kmlp,"Q");//fitting the final result (done this in the past but kicked it)

  kmlpP->SetParameters(kmlp->GetParameters());
  kmlpN->SetParameters(kmlp->GetParameters());
  
  // now that we're done, let's save all of this so we can have a look at it afterwards.
  TCanvas *can = new TCanvas("can","Prediction Fit Canvas");
  can->SetLogy(1);
  prediction->SetMarkerColor(kRed);
  prediction->Draw();
  
  kmlp->SetLineColor(TColor::GetColor("#04B404"));
  kmlpP->SetLineColor(TColor::GetColor("#04B404"));
  kmlpN->SetLineColor(TColor::GetColor("#04B404"));
  kmlp->Draw("same");
  kmlpN->SetLineStyle(2);
  kmlpP->SetLineStyle(2);
  kmlpN->Draw("same");
  kmlpP->Draw("same");
  
  ttbarlogpar->SetLineColor(TColor::GetColor("#CC2EFA"));//purple
  ttbarlogpar->Draw("same");
  ttbarlogparP->SetLineColor(TColor::GetColor("#CC2EFA"));//purple
  ttbarlogparN->SetLineColor(TColor::GetColor("#CC2EFA"));//purple
  ttbarlogparP->SetLineStyle(2);
  ttbarlogparN->SetLineStyle(2);
  ttbarlogparP->Draw("same");
  ttbarlogparN->Draw("same");
  
  functions[0]->Draw("same");functions[1]->Draw("same");functions[2]->Draw("same");

  TLegend *analyticalBpredLEG = make_legend("",0.5,0.55);
  analyticalBpredLEG->AddEntry(prediction,"predicted","p");
  analyticalBpredLEG->AddEntry(functions[1],"Crystal Ball fit","l");
  analyticalBpredLEG->AddEntry(functions[0],"1#sigma Crystal Ball fit","l");
  analyticalBpredLEG->AddEntry(ttbarlogparN,"TTbar fit","l");
  analyticalBpredLEG->AddEntry(ttbarlogpar,"1#sigma TTbar fit","l");
  analyticalBpredLEG->AddEntry(kmlp,"Combined function","l");
  analyticalBpredLEG->AddEntry(kmlpN,"1#sigma combined function","l");
  analyticalBpredLEG->Draw("same");
  
  if(isdata==0) CompleteSave(can,"MakingOfBpredFunction/Bpred_MC_Analytical_Function_Composition");
  if(isdata==1) CompleteSave(can,"MakingOfBpredFunction/Bpred_data_Analytical_Function_Composition");
  if(isdata==2) CompleteSave(can,"MakingOfBpredFunction/Bpred_MCBnS_Analytical_Function_Composition");
  delete can;
  
  //and finally: prep return functions
  vector<TF1*> return_functions;
  return_functions.push_back(kmlpN);
  return_functions.push_back(kmlp);
  return_functions.push_back(kmlpP);
  
  return_functions.push_back(ttbarlogparN);
  return_functions.push_back(ttbarlogpar);
  return_functions.push_back(ttbarlogparP);
  
  return_functions.push_back(functions[0]);
  return_functions.push_back(functions[1]);
  return_functions.push_back(functions[2]);
  
  return return_functions;
}

void do_prediction_plot(string jzb, TCanvas *globalcanvas, float high, int use_data, bool overlay_signal = false,string subdir="" )
{
  
  bool is_data=false;
  bool use_signal=false;
  if(use_data==1) is_data=true;
  if(use_data==2) use_signal=true;
  int nbins=int(high/10);//100;
  if(is_data) nbins=int(high/10);
  float low=0;
  float hi=high;
  
  stringstream cutpositiveS;
  cutpositiveS << "(" << jzb << ">0)";
  TCut cutpositive(cutpositiveS.str().c_str());
  stringstream cutnegativeS;
  cutnegativeS << "(" << jzb << "<0)";
  TCut cutnegative(cutnegativeS.str().c_str());
  
  
  TH1F *blankback = new TH1F("blankback","blankback",int(high/10),0,high);
  TH1F *RcorrJZBeemm   = allsamples.Draw("RcorrJZBeemm",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutpositive&&cutmass&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
  TH1F *LcorrJZBeemm   = allsamples.Draw("LcorrJZBeemm",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", cutnegative&&cutmass&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
  TH1F *RcorrJZBem     = allsamples.Draw("RcorrJZBem",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutpositive&&cutmass&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
  TH1F *LcorrJZBem     = allsamples.Draw("LcorrJZBem",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", cutnegative&&cutmass&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);

  blankback->GetXaxis()->SetTitle(RcorrJZBeemm->GetXaxis()->GetTitle());
  blankback->GetYaxis()->SetTitle(RcorrJZBeemm->GetYaxis()->GetTitle());
  blankback->GetXaxis()->CenterTitle();
  blankback->GetYaxis()->CenterTitle();
  
  flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak ---- prediction changed.
  TH1F *RcorrJZBSBem;
  TH1F *LcorrJZBSBem;
  TH1F *RcorrJZBSBeemm;
  TH1F *LcorrJZBSBeemm;
  
  TH1F *RcorrJZBeemmNoS;

  //these are for the ratio
  TH1F *JRcorrJZBeemm   = allsamples.Draw("JRcorrJZBeemm",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutpositive&&cutmass&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
  TH1F *JLcorrJZBeemm   = allsamples.Draw("JLcorrJZBeemm",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutnegative&&cutmass&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
  TH1F *JRcorrJZBem     = allsamples.Draw("JRcorrJZBem",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutpositive&&cutmass&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
  TH1F *JLcorrJZBem     = allsamples.Draw("JLcorrJZBem",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutnegative&&cutmass&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
  
  TH1F *JRcorrJZBSBem;
  TH1F *JLcorrJZBSBem;
  TH1F *JRcorrJZBSBeemm;
  TH1F *JLcorrJZBSBeemm;
  
  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);

  
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
    RcorrJZBSBem   = allsamples.Draw("RcorrJZBSBem",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutpositive&&sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
    LcorrJZBSBem   = allsamples.Draw("LcorrJZBSBem",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", cutnegative&&sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
    RcorrJZBSBeemm = allsamples.Draw("RcorrJZBSBeemm",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutpositive&&sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
    LcorrJZBSBeemm = allsamples.Draw("LcorrJZBSBeemm",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", cutnegative&&sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
    
    //these are for the ratio
    JRcorrJZBSBem   = allsamples.Draw("JRcorrJZBSBem",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutpositive&&sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
    JLcorrJZBSBem   = allsamples.Draw("JLcorrJZBSBem",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutnegative&&sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
    JRcorrJZBSBeemm = allsamples.Draw("JRcorrJZBSBeemm",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutpositive&&sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
    JLcorrJZBSBeemm = allsamples.Draw("JLcorrJZBSBeemm",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutnegative&&sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
  }
  
  TH1F *lm4RcorrJZBeemm;
  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"));
  
  flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak ---- prediction changed.
  
  TH1F *Zjetspred = (TH1F*)LcorrJZBeemm->Clone("Zjetspred");
  TH1F *TTbarpred = (TH1F*)RcorrJZBem->Clone("TTbarpred");
    
  TH1F *Bpred = (TH1F*)LcorrJZBeemm->Clone("Bpred");
  TH1F *JBpred = (TH1F*)JLcorrJZBeemm->Clone("Bpred");
    
  TH1F *BpredSys = new TH1F("Bpredsys","Bpredsys",PlottingSetup::global_ratio_binning.size()-1,&PlottingSetup::global_ratio_binning[0]);
  ClearHisto(BpredSys);
    
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
    Bpred->Add(RcorrJZBem,1.0/3.);
    Bpred->Add(LcorrJZBem,-1.0/3.);
    Bpred->Add(RcorrJZBSBem,1.0/3.);
    Bpred->Add(LcorrJZBSBem,-1.0/3.);
    Bpred->Add(RcorrJZBSBeemm,1.0/3.);
    Bpred->Add(LcorrJZBSBeemm,-1.0/3.);
    
    TTbarpred->Scale(1.0/3);
    Zjetspred->Add(LcorrJZBem,-1.0/3.);
    Zjetspred->Add(LcorrJZBSBem,-1.0/3.);
    TTbarpred->Add(RcorrJZBSBem,1.0/3.);
    Zjetspred->Add(LcorrJZBSBeemm,-1.0/3.);
    TTbarpred->Add(RcorrJZBSBeemm,1.0/3.);
    
    //these are for the ratio
    JBpred->Add(JRcorrJZBem,1.0/3.);
    JBpred->Add(JLcorrJZBem,-1.0/3.);
    JBpred->Add(JRcorrJZBSBem,1.0/3.);
    JBpred->Add(JLcorrJZBSBem,-1.0/3.);
    JBpred->Add(JRcorrJZBSBeemm,1.0/3.);
    JBpred->Add(JLcorrJZBSBeemm,-1.0/3.);
      
    //Systematics:
    AddSquared(BpredSys,JLcorrJZBeemm,zjetsestimateuncertONPEAK*zjetsestimateuncertONPEAK);
    AddSquared(BpredSys,JRcorrJZBem,emuncertONPEAK*emuncertONPEAK*(1.0/9));
    AddSquared(BpredSys,JLcorrJZBem,emuncertONPEAK*emuncertONPEAK*(1.0/9));
    AddSquared(BpredSys,JRcorrJZBSBem,emsidebanduncertONPEAK*emsidebanduncertONPEAK*(1.0/9));
    AddSquared(BpredSys,JLcorrJZBSBem,emsidebanduncertONPEAK*emsidebanduncertONPEAK*(1.0/9));
    AddSquared(BpredSys,JRcorrJZBSBeemm,eemmsidebanduncertONPEAK*eemmsidebanduncertONPEAK*(1.0/9));
    AddSquared(BpredSys,JLcorrJZBSBeemm,eemmsidebanduncertONPEAK*eemmsidebanduncertONPEAK*(1.0/9));
  } else {
    Bpred->Add(RcorrJZBem,1.0);
    Bpred->Add(LcorrJZBem,-1.0);
    
    Zjetspred->Add(LcorrJZBem,-1.0);
    
    //these are for the ratio
    JBpred->Add(JRcorrJZBem,1.0);
    JBpred->Add(JLcorrJZBem,-1.0);
      
    //Systematics
    AddSquared(BpredSys,JLcorrJZBeemm,zjetsestimateuncertOFFPEAK*zjetsestimateuncertOFFPEAK);
    AddSquared(BpredSys,JRcorrJZBem,emuncertOFFPEAK*emuncertOFFPEAK);
    AddSquared(BpredSys,JLcorrJZBem,emuncertOFFPEAK*emuncertOFFPEAK);

  }
    
  SQRT(BpredSys);
  BpredSys->Divide(JBpred);

  flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak ---- prediction changed
  TH1F *Tpred = (TH1F*)RcorrJZBem->Clone("Bpred");
  Tpred->Add(LcorrJZBem,-1.0);
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
    Tpred->Add(RcorrJZBSBem,1.0);
    Tpred->Add(LcorrJZBSBem,-1.0);
    Tpred->Add(RcorrJZBSBeemm,1.0);
    Tpred->Add(LcorrJZBSBeemm,-1.0);
  }
  
  globalcanvas->cd();
  globalcanvas->SetLogy(1);

  RcorrJZBeemm->SetMarkerStyle(20);
  RcorrJZBeemm->GetXaxis()->SetRangeUser(0,high);
  RcorrJZBeemm->SetMinimum(0.1);

  Bpred->SetLineColor(kRed);
  Bpred->SetStats(0);
  
  int versok=false;
  if(gROOT->GetVersionInt()>=53000) versok=true;


  if ( overlay_signal || use_data==2 ) lm4RcorrJZBeemm->SetLineColor(TColor::GetColor("#088A08"));
  RcorrJZBeemm->SetMarkerSize(DataMarkerSize);
  
  TLegend *legBpred = make_legend("",0.6,0.55);
  TLegend *legBpred2 = make_legend("",0.6,0.55);


  vector<TF1*> analytical_function;
  TPad *kinpad = new TPad("kinpad","kinpad",0,0,1,1);
  kinpad->cd();
  kinpad->SetLogy(1);

  string Bpredsaveas="Bpred_Data";
  blankback->SetMaximum(5*RcorrJZBeemm->GetMaximum());
  blankback->SetMinimum(0.1);
  if(use_data!=1) blankback->SetMinimum(0.1);
  blankback->Draw();
  if(use_data==1)
  {
    //Bpred->SetLineWidth(3); //paper style.overruled.
    //lm4RcorrJZBeemm->SetLineWidth(3); //paper style.overruled.
    analytical_function = do_extended_fit_to_plot(Bpred,Tpred,LcorrJZBeemm,LcorrJZBem,is_data);
    kinpad->cd();//necessary because the extended fit function creates its own canvas
    RcorrJZBeemm->Draw("e1x0,same");

    Bpred->Draw("hist,same");
    //analytical_function[0]->Draw("same"); analytical_function[1]->Draw("same");analytical_function[2]->Draw("same");
    RcorrJZBeemm->Draw("e1x0,same");//HAVE IT ON TOP!
    //lm4RcorrJZBeemm->Draw("hist,same");
    legBpred->AddEntry(RcorrJZBeemm,"observed","p");
    legBpred->AddEntry(Bpred,"predicted","l");
//    legBpred->AddEntry(analytical_function[1],"predicted fit","l");
//    legBpred->AddEntry(analytical_function[2],"stat. uncert.","l");
//     legBpred->AddEntry(lm4RcorrJZBeemm,(allsamples.collection[allsamples.FindSample("LM")[0]].samplename).c_str(),"l");
    legBpred->Draw();
    DrawPrelim();

    //this plot shows what the prediction is composed of
    TPad *predcomppad = new TPad("predcomppad","predcomppad",0,0,1,1);
    float CurrentBpredLineWidth=Bpred->GetLineWidth();
    Bpred->SetLineWidth(2);
    predcomppad->cd();
    predcomppad->SetLogy(1);
    TH1F *jzbnegative = (TH1F*)LcorrJZBeemm->Clone("jzbnegative");
    TH1F *sidebandsemu = (TH1F*)Bpred->Clone("sidebandsemu");
    sidebandsemu->Add(jzbnegative,-1);
    
    jzbnegative->SetFillColor(allsamples.GetColor((allsamples.FindSample("DY"))[0]));
    jzbnegative->SetLineColor(allsamples.GetColor((allsamples.FindSample("DY"))[0]));
    sidebandsemu->SetLineColor(allsamples.GetColor((allsamples.FindSample("TTJets"))[0]));
    sidebandsemu->SetFillColor(allsamples.GetColor((allsamples.FindSample("TTJets"))[0]));
    
    THStack predcomposition("predcomposition","prediction composition");
    predcomposition.Add(sidebandsemu);
    predcomposition.Add(jzbnegative);
    blankback->Draw();
    RcorrJZBeemm->Draw("e1x0,same");
    predcomposition.Draw("histo,same");//
    Bpred->Draw("hist,same");
//    analytical_function[0]->Draw("same"); analytical_function[1]->Draw("same");analytical_function[2]->Draw("same");
    RcorrJZBeemm->Draw("e1x0,same");//HAVE IT ON TOP!
//    lm4RcorrJZBeemm->SetLineColor(kOrange+1);
    lm4RcorrJZBeemm->SetLineWidth(2);
    //lm4RcorrJZBeemm->SetLineWidth(2); // paper style. overruled.
//     lm4RcorrJZBeemm->Draw("histo,same");
    DrawPrelim();
    TLegend *speciallegBpred = make_legend("",0.45,0.55);
    //TLegend *speciallegBpred = make_legend("",0.35,0.55); // paper style. overruled.
    speciallegBpred->AddEntry(RcorrJZBeemm,"Data","pl");
    speciallegBpred->AddEntry(Bpred,"Total background","l");
    speciallegBpred->AddEntry(jzbnegative,"JZB<0 (data)","f");
    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) speciallegBpred->AddEntry(sidebandsemu,"Sidebands/e#mu (data)","f");
    else speciallegBpred->AddEntry(sidebandsemu,"e#mu (data)","f");
//    speciallegBpred->AddEntry(lm4RcorrJZBeemmC,"LM4","l");
//     speciallegBpred->AddEntry(lm4RcorrJZBeemm,"LM4","l");
    speciallegBpred->Draw();
    Save_With_Ratio(JRcorrJZBeemm,JBpred,predcomppad,subdir+"Bpred_Data_____PredictionComposition",true,true,"data/pred",BpredSys);
    delete predcomppad;
    
    TCanvas *specialcanv = new TCanvas("specialcanv","specialcanv");
    specialcanv->SetLogy(1);
//    THStack kostack = allsamples.DrawStack("RcorrJZBeemm",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,!is_data, luminosity,use_signal);
    blankback->Draw();
//    kostack.Draw("same");
    predcomposition.Draw("hist");
    Bpred->Draw("hist,same");
    //analytical_function[0]->Draw("same"); analytical_function[1]->Draw("same");analytical_function[2]->Draw("same");
    RcorrJZBeemm->Draw("e1x0,same");//HAVE IT ON TOP!
    legBpred->Draw();
    DrawPrelim();
    CompleteSave(specialcanv,subdir+"Bpred_Data_____PredictionCompositioninMC");
    Bpred->SetLineWidth((int)CurrentBpredLineWidth);
    
    
    //for(int i=1;i<=Bpred->GetNbinsX();i++) cout << Bpred->GetBinLowEdge(i) << ";" << Bpred->GetBinLowEdge(i)+Bpred->GetBinWidth(i) << ";;" << RcorrJZBeemm->GetBinContent(i) << ";" << LcorrJZBeemm->GetBinContent(i) << ";" << RcorrJZBem->GetBinContent(i) << ";" << LcorrJZBem->GetBinContent(i) << endl;
    
    delete speciallegBpred;
    delete Zjetspred;
    delete TTbarpred;
    
    kinpad->cd();
  }
  if(use_data==0) {
    RcorrJZBeemm->Draw("e1x0,same");
    //Bpred->SetLineWidth(3); // paper style. overruled.
    Bpred->Draw("hist,same");
    RcorrJZBeemm->Draw("e1x0,same");//HAVE IT ON TOP!
    legBpred->AddEntry(RcorrJZBeemm,"MC true","p");
    legBpred->AddEntry(Bpred,"MC predicted","l");    
    if(versok) legBpred->AddEntry((TObject*)0,"",""); // Just for alignment // causes seg fault on root v5.18
    if(versok) legBpred->AddEntry((TObject*)0,"",""); // causes seg fault on root v5.18
//     if ( overlay_signal ) legBpred->AddEntry(lm4RcorrJZBeemm,"LM4","l");
    legBpred->Draw();
    DrawMCPrelim();
    Bpredsaveas="Bpred_MC";
//    CompleteSave(globalcanvas,"Bpred_MC"); // done below in save_with_ratio
  }
  if(use_data==2) {
    RcorrJZBeemm->Draw("e1x0,same");
    //Bpred->SetLineWidth(3); // paper style. overruled.
    Bpred->Draw("hist,same");
    RcorrJZBeemm->Draw("e1x0,same");//HAVE IT ON TOP!
    legBpred->AddEntry(RcorrJZBeemm,"MC true","p");
    legBpred->AddEntry(Bpred,"MC predicted","l");
    legBpred2->AddEntry(RcorrJZBeemm,"MC true","p");
    legBpred2->AddEntry(Bpred,"MC predicted","l");
    {
      if(versok) legBpred->AddEntry((TObject*)0,"",""); // Just for alignment // causes seg fault on root v5.18 --> now only allowed for root >=v5.30
      if(versok) legBpred->AddEntry((TObject*)0,"",""); // causes seg fault on root v5.18 --> now only allowed for root >=v5.30
      legBpred->Draw();
      DrawMCPrelim();
      Bpredsaveas="Bpred_MCwithS";
//      CompleteSave(globalcanvas,"Bpred_MCwithS"); // done below in save_with_ratio
    }
    {
      //lm4RcorrJZBeemm->SetLineWidth(3); //paper style. overruled.
      //RcorrJZBeemmNoS->SetLineWidth(3); //paper style. overruled.
      //lm4RcorrJZBeemm->SetLineStyle(2); //paper style. overruled.
      //RcorrJZBeemmNoS->SetLineStyle(3); //paper style. overruled.
      //lm4RcorrJZBeemm->SetLineColor(kOrange+1); //paper style. overruled.
      
      RcorrJZBeemmNoS->SetLineStyle(2);
      legBpred2->AddEntry(RcorrJZBeemmNoS,"MC B","l");
//       legBpred2->AddEntry(lm4RcorrJZBeemm,"MC S","l");
      legBpred2->Draw();
      RcorrJZBeemmNoS->SetLineColor(TColor::GetColor("#61210B"));
      RcorrJZBeemmNoS->Draw("histo,same");
      RcorrJZBeemm->Draw("e1x0,same");//HAVE IT ON TOP!
      lm4RcorrJZBeemm->Draw("histo,same");
      DrawMCPrelim();
      Bpredsaveas="Bpred_MCwithS__plus";
//      CompleteSave(globalcanvas,"Bpred_MCwithS__plus"); // done below in save_with_ratio
    }
  }


  //3rd last argument: do special bpred ratio, 2nd last argument: extended range!, last: y-axis title
  string ytitle("ratio");
  if ( use_data==1 ) ytitle = "data/pred";
  //save_with_ratio(JRcorrJZBeemm,JBpred,kinpad,Bpredsaveas,true,use_data!=1,ytitle);
  Save_With_Ratio(JRcorrJZBeemm,JBpred,kinpad,subdir+Bpredsaveas,true,false,ytitle,BpredSys);//not extending the y range anymore up to 4
  
  delete kinpad;


  flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak
  // The part below is meaningless for the offpeak analysis (it's a comparison of the different estimates but there is but one estimate!)
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
    TH1F *Bpredem = (TH1F*)LcorrJZBeemm->Clone("Bpredem");
    Bpredem->Add(RcorrJZBem);
    Bpredem->Add(LcorrJZBem,-1);
    TH1F *BpredSBem = (TH1F*)LcorrJZBeemm->Clone("BpredSBem");
    BpredSBem->Add(RcorrJZBSBem);
    Bpred->Add(LcorrJZBSBem,-1);
    TH1F *BpredSBeemm = (TH1F*)LcorrJZBeemm->Clone("BpredSBeemm");  
    BpredSBeemm->Add(RcorrJZBSBeemm);
    BpredSBeemm->Add(LcorrJZBSBeemm,-1.0);
    globalcanvas->cd();
    globalcanvas->SetLogy(1);
    
    RcorrJZBeemm->SetMarkerStyle(20);
    RcorrJZBeemm->GetXaxis()->SetRangeUser(0,high);
    blankback->Draw();
    RcorrJZBeemm->Draw("e1x0,same");
    RcorrJZBeemm->SetMarkerSize(DataMarkerSize);
    
    Bpredem->SetLineColor(kRed+1);
    Bpredem->SetStats(0);
    Bpredem->Draw("hist,same");
    
    BpredSBem->SetLineColor(kGreen+2);//TColor::GetColor("#0B6138"));
    BpredSBem->SetLineStyle(2);
    BpredSBem->Draw("hist,same");
    
    BpredSBeemm->SetLineColor(kBlue+1);
    BpredSBeemm->SetLineStyle(3);
    BpredSBeemm->Draw("hist,same");
    RcorrJZBeemm->Draw("e1x0,same");//HAVE IT ON TOP!
    
    TLegend *legBpredc = make_legend("",0.6,0.55);
    if(use_data==1)
    {
      legBpredc->AddEntry(RcorrJZBeemm,"observed","p");
      legBpredc->AddEntry(Bpredem,"OFZP","l");
      legBpredc->AddEntry(BpredSBem,"OFSB","l");
      legBpredc->AddEntry(BpredSBeemm,"SFSB","l");
      legBpredc->Draw();
      CompleteSave(globalcanvas,subdir+"Bpred_Data_comparison");
    }
    if(use_data==0) {
      legBpredc->AddEntry(RcorrJZBeemm,"MC true","p");
      legBpredc->AddEntry(Bpredem,"MC OFZP","l");
      legBpredc->AddEntry(BpredSBem,"MC OFSB","l");
      legBpredc->AddEntry(BpredSBeemm,"MC SFSB","l");
      legBpredc->Draw();
      CompleteSave(globalcanvas,subdir+"Bpred_MC_comparison");
    }
    if(use_data==2) {
      legBpredc->AddEntry(RcorrJZBeemm,"MC true","p");
      legBpredc->AddEntry(Bpredem,"MC OFZP","l");
      legBpredc->AddEntry(BpredSBem,"MC OFSB","l");
      legBpredc->AddEntry(BpredSBeemm,"MC SFSB","l");
//       if ( overlay_signal ) legBpred->AddEntry(lm4RcorrJZBeemm,"LM4","l");
      legBpredc->Draw();
      CompleteSave(globalcanvas,subdir+"Bpred_MCwithS_comparison");
    }
  }
  
  TFile *f = new TFile("tester.root","RECREATE");
  RcorrJZBeemm->Write();
  Bpred->Write();
  f->Close();
  
  delete RcorrJZBeemm;
  delete LcorrJZBeemm;
  delete RcorrJZBem;
  delete LcorrJZBem;
  
  delete JRcorrJZBeemm;
  delete JLcorrJZBeemm;
  delete JRcorrJZBem;
  delete JLcorrJZBem;

  delete blankback;
  
  delete BpredSys;
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
    delete RcorrJZBSBem;
    delete LcorrJZBSBem;
    delete RcorrJZBSBeemm;
    delete LcorrJZBSBeemm;

    delete JRcorrJZBSBem;
    delete JLcorrJZBSBem;
    delete JRcorrJZBSBeemm;
    delete JLcorrJZBSBeemm;
  }
  if(overlay_signal || use_data==2) delete lm4RcorrJZBeemm;
}

void do_prediction_plots(string mcjzb, string datajzb, float DataSigma, float MCSigma, bool overlay_signal ) {
  switch_overunderflow(true);
  TCanvas *globalcanvas = new TCanvas("globalcanvas","Prediction Canvas");
  do_prediction_plot(datajzb,globalcanvas,jzbHigh ,data,overlay_signal);
  if ( !PlottingSetup::Approved ) {
    do_prediction_plot(mcjzb,globalcanvas,jzbHigh ,mc,overlay_signal);
    do_prediction_plot(mcjzb,globalcanvas,jzbHigh ,mcwithsignal,overlay_signal);
  } else {
    write_info(__FUNCTION__,"You set approved to true, therefore not producing prediction/observation plots for MC with and without signal.");
  }
  delete globalcanvas;
  switch_overunderflow(false);
}

string give_jzb_expression(float peak, int type) {
  stringstream val;
  if(type==data) {
    if(peak<0) val << jzbvariabledata << "+" << TMath::Abs(peak);
    if(peak>0) val << jzbvariabledata << "-" << TMath::Abs(peak);
    if(peak==0) val << jzbvariabledata;
  }
  if(type==mc) {
    if(peak<0) val << jzbvariablemc << "+" << TMath::Abs(peak);
    if(peak>0) val << jzbvariablemc << "-" << TMath::Abs(peak);
    if(peak==0) val << jzbvariablemc;
  }
  return val.str();
}


void lepton_comparison_plots() {
  Float_t ymin = 1.e-5, ymax = 0.25;
  TCanvas *can = new TCanvas("can","Lepton Comparison Canvas");
  can->SetLogy(1);
  TH1F *eemc = allsamples.Draw("eemc","mll",50,50,150, "mll [GeV]", "events", cutOSSF&&cutnJets&&"(id1==0)",mc, luminosity,allsamples.FindSample("/DY"));
  TH1F *mmmc = allsamples.Draw("mmmc","mll",50,50,150, "mll [GeV]", "events", cutOSSF&&cutnJets&&"(id1==1)",mc, luminosity,allsamples.FindSample("/DY"));
  eemc->SetLineColor(kBlue);
  mmmc->SetLineColor(kRed);
  eemc->SetMinimum(0.1);
  eemc->SetMaximum(10*eemc->GetMaximum());
  eemc->Draw("histo");
  mmmc->Draw("histo,same");
  TLegend *leg = make_legend();
  leg->AddEntry(eemc,"ZJets->ee (MC)","l");
  leg->AddEntry(mmmc,"ZJets->#mu#mu (MC)","l");
  leg->Draw("same");
  CompleteSave(can, "lepton_comparison/mll_effratio_mc");
  
  TH1F *eed = allsamples.Draw("eed","mll",50,50,150, "mll [GeV]", "events", cutOSSF&&cutnJets&&"(id1==0)",data, luminosity);
  TH1F *mmd = allsamples.Draw("mmd","mll",50,50,150, "mll [GeV]", "events", cutOSSF&&cutnJets&&"(id1==1)",data, luminosity);
  eed->SetLineColor(kBlue);
  mmd->SetLineColor(kRed);
  eed->SetMinimum(0.1);
  eed->SetMaximum(10*eed->GetMaximum());
  eed->Draw("histo");
  mmd->Draw("histo,same");
  TLegend *leg2 = make_legend();
  leg2->AddEntry(eed,"ZJets->ee (data)","l");
  leg2->AddEntry(mmd,"ZJets->#mu#mu (data)","l");
  leg2->Draw();
  CompleteSave(can, "lepton_comparison/mll_effratio_data");
  
  TH1F *jeed = allsamples.Draw("jeed",jzbvariabledata,    int((jzbHigh+150)/5),-150,jzbHigh , "JZB [GeV]", "events", cutOSSF&&cutnJets&&"(id1==0)",data, luminosity);
  TH1F *jmmd = allsamples.Draw("jmmd",jzbvariabledata,    int((jzbHigh+150)/5),-150,jzbHigh , "JZB [GeV]", "events", cutOSSF&&cutnJets&&"(id1==1)",data, luminosity);
  TH1F *jeemmd = allsamples.Draw("jeemmd",jzbvariabledata,int((jzbHigh+150)/5),-150,jzbHigh , "JZB [GeV]", "events", cutOSSF&&cutnJets,data, luminosity);
  dout << "ee : " << jeed->GetMean() << "+/-" << jeed->GetMeanError() << endl;
  dout << "ee : " << jmmd->GetMean() << "+/-" << jmmd->GetMeanError() << endl;
  dout << "eemd : " << jeemmd->GetMean() << "+/-" << jeemmd->GetMeanError() << endl;
  jeemmd->SetLineColor(kBlack);
  jeemmd->SetMarkerStyle(25);
  jeed->SetLineColor(kBlue);
  jmmd->SetLineColor(kRed);
  jeed->SetMinimum(0.1);
  jeed->SetMaximum(10*eed->GetMaximum());
  TH1* njeemmd = jeemmd->DrawNormalized();
  njeemmd->SetMinimum(ymin);
  njeemmd->SetMaximum(ymax);

  jeed->DrawNormalized("histo,same");
  jmmd->DrawNormalized("histo,same");
  jeemmd->DrawNormalized("same");
  TLegend *jleg2 = make_legend(" ");
  jleg2->AddEntry(jeemmd,"ee and #mu#mu","p");
  jleg2->AddEntry(jeed,"ee","l");
  jleg2->AddEntry(jmmd,"#mu#mu","l");
  jleg2->Draw();
  CompleteSave(can,"lepton_comparison/jzb_effratio_data");

  TPad *eemmpad = new TPad("eemmpad","eemmpad",0,0,1,1);
  eemmpad->cd();
  eemmpad->SetLogy(1);
  jeed->Draw("histo");
  jmmd->Draw("histo,same");
  TLegend *eemmlegend = make_legend(" ");
  eemmlegend->AddEntry(jeed,"ee","l");
  eemmlegend->AddEntry(jmmd,"#mu#mu","l");
  eemmlegend->Draw();
  DrawPrelim();
  Save_With_Ratio(jeed,jmmd,eemmpad->cd(),"lepton_comparison/jzb_Comparing_ee_mm_data");
  
  TH1F *zjeed = allsamples.Draw("zjeed",jzbvariablemc,    int((jzbHigh+150)/5),-150,jzbHigh , "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&"(id1==0)",mc,  luminosity,allsamples.FindSample("/DY"));
  TH1F *zjmmd = allsamples.Draw("zjmmd",jzbvariablemc,    int((jzbHigh+150)/5),-150,jzbHigh , "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&"(id1==1)",mc,  luminosity,allsamples.FindSample("/DY"));
  TH1F *zjeemmd = allsamples.Draw("zjeemmd",jzbvariablemc,int((jzbHigh+150)/5),-150,jzbHigh , "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,            mc,  luminosity,allsamples.FindSample("/DY"));
  dout << "Z+Jets ee : " << zjeed->GetMean() << "+/-" << zjeed->GetMeanError() << endl;
  dout << "Z+Jets ee : " << zjmmd->GetMean() << "+/-" << zjmmd->GetMeanError() << endl;
  dout << "Z+Jets eemd : " << zjeemmd->GetMean() << "+/-" << zjeemmd->GetMeanError() << endl;
  zjeemmd->SetLineColor(kBlack);
  zjeemmd->SetMarkerStyle(25);
  zjeed->SetLineColor(kBlue);
  zjmmd->SetLineColor(kRed);
  zjeed->SetMinimum(0.1);
  zjeed->SetMaximum(10*eed->GetMaximum());

  TH1* nzjeemmd = zjeemmd->DrawNormalized();
  nzjeemmd->SetMinimum(ymin);
  nzjeemmd->SetMaximum(ymax);
  zjeed->DrawNormalized("histo,same");
  zjmmd->DrawNormalized("histo,same");
  zjeemmd->DrawNormalized("same");
  TLegend *zjleg2 = make_legend("Z+jets MC");
  zjleg2->AddEntry(jeemmd,"ee and #mu#mu","p");
  zjleg2->AddEntry(jeed,"ee","l");
  zjleg2->AddEntry(jmmd,"#mu#mu","l");
  zjleg2->Draw();
  CompleteSave(can,"lepton_comparison/jzb_effratio_ZJets");
  
  TH1F *ld = allsamples.Draw("ld","mll",50,50,150, "mll [GeV]", "events", cutOSSF&&cutnJets,data, luminosity);
  ld->DrawNormalized("e1");
  eed->DrawNormalized("histo,same");
  mmd->DrawNormalized("histo,same");
  TLegend *leg3 = make_legend();
  leg3->AddEntry(ld,"ZJets->ll (data)","p");
  leg3->AddEntry(eed,"ZJets->ee (data)","l");
  leg3->AddEntry(mmd,"ZJets->#mu#mu (data)","l");
  leg3->Draw();
  CompleteSave(can,"lepton_comparison/mll_effratio_data__all_compared");
  /*
  TH1F *jzbld  = allsamples.Draw("jzbld",jzbvariable,75,-150,150, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,data, luminosity);
  TH1F *jzbemd = allsamples.Draw("jzbemd",jzbvariable,75,-150,150, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,data, luminosity);
  */
  TH1F *jzbld  = allsamples.Draw("jzbld",jzbvariabledata,int((jzbHigh+110)/5),-110,jzbHigh , "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,data, luminosity);
  TH1F *jzbemd = allsamples.Draw("jzbemd",jzbvariabledata,int((jzbHigh+110)/5),-110,jzbHigh , "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,data, luminosity);
  jzbld->SetMarkerColor(kBlack);
  jzbld->SetMarkerStyle(26);
  jzbemd->SetMarkerStyle(25);
  jzbemd->SetMarkerColor(kRed);
  jzbemd->SetLineColor(kRed);
  jzbld->SetMinimum(0.35);
  jzbld->Draw("e1");
  jzbemd->Draw("e1,same");
  TLegend *leg4 = make_legend();
  leg4->AddEntry(jzbld,"SFZP","p");
  leg4->AddEntry(jzbemd,"OFZP","p");
  leg4->AddEntry((TObject*)0,"",""); //causes segmentation violation
  leg4->AddEntry((TObject*)0,"",""); //causes segmentation violation
  leg4->Draw();
  CompleteSave(can,"lepton_comparison/jzb_eemumu_emu_data");
  
  TH1F *ttbarjzbld  = allsamples.Draw("ttbarjzbld",jzbvariablemc,int((jzbHigh+150)/5),-150,jzbHigh, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,data, luminosity,allsamples.FindSample("TTJet"));
  TH1F *ttbarjzbemd = allsamples.Draw("ttbarjzbemd",jzbvariablemc,int((jzbHigh+150)/5),-150,jzbHigh, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,data, luminosity,allsamples.FindSample("TTJet"));
  ttbarjzbld->SetLineColor(allsamples.GetColor("TTJet"));
  ttbarjzbemd->SetLineColor(allsamples.GetColor("TTJet"));
  ttbarjzbld->Draw("histo");
  ttbarjzbemd->SetLineStyle(2);
  ttbarjzbemd->Draw("histo,same");
  TLegend *leg5 = make_legend();
  leg5->AddEntry(ttbarjzbld,"t#bar{t}->(ee or #mu#mu)","l");
  leg5->AddEntry(ttbarjzbemd,"t#bar{t}->e#mu","l");
  leg5->Draw();
  CompleteSave(can,"lepton_comparison/ttbar_emu_mc");

}

bool is_OF(TCut cut) {
  string scut = (const char*) cut;
  if((int)scut.find("id1!=id2")>-1) return true;
  if((int)scut.find("id1==id2")>-1) return false;
  return false;
}

bool is_ZP(TCut cut) {
  string scut = (const char*) cut;
  if((int)scut.find("91")>-1) return true;
  return false;
}


void draw_pure_jzb_histo(TCut cut,string datavariable, string mcvariable, string savename, TCanvas *can,vector<float> binning) {
  TPad *jzbpad = new TPad("jzbpad","jzbpad",0,0,1,1);
  jzbpad->cd();
  jzbpad->SetLogy(1);
  string xlabel="JZB [GeV]";

  TH1F *datahisto = allsamples.Draw("datahisto",datavariable,binning, xlabel, "events",cut,data,luminosity);
  THStack mcstack = allsamples.DrawStack("mcstack",mcvariable,binning, xlabel, "events",cut,mc,luminosity);
  
  datahisto->SetMinimum(0.1);
  datahisto->SetMarkerSize(DataMarkerSize);
  datahisto->Draw("e1");
  mcstack.Draw("histo,same");
  datahisto->Draw("same,e1");
  
  TLegend *leg;
  if (!PlottingSetup::RestrictToMassPeak||!PlottingSetup::UseSidebandsForcJZB) {
    if(is_OF(cut)) leg = allsamples.allbglegend("Opposite flavor",datahisto);
    else leg = allsamples.allbglegend("Same flavor",datahisto);
  } else { 
    if(is_OF(cut) && is_ZP(cut)) leg = allsamples.allbglegend("OFZP",datahisto);
    else if(!is_OF(cut) &&  is_ZP(cut)) leg = allsamples.allbglegend("SFZP",datahisto);
    else if( is_OF(cut) && !is_ZP(cut)) leg = allsamples.allbglegend("OFSB",datahisto);
    else if(!is_OF(cut) && !is_ZP(cut)) leg = allsamples.allbglegend("SFSB",datahisto);
    else {
      std::cerr << "Unable to decode cut: " << cut.GetTitle() << std::endl;
      exit(-1);
    }
  }
  leg->Draw();
  string write_cut = decipher_cut(cut,"");
  TText *writeline1 = write_cut_on_canvas(write_cut.c_str());
  writeline1->SetTextSize(0.035);
  writeline1->Draw();
  if(!Contains(savename,"Dibosons")) Save_With_Ratio(datahisto,mcstack,jzbpad->cd(),("jzb/"+savename));
  else Save_With_Ratio(datahisto,mcstack,jzbpad->cd(),savename);
  TPad *jzbpad2 = new TPad("jzbpad2","jzbpad2",0,0,1,1);
  jzbpad2->cd();
  jzbpad2->SetLogy(1);
  datahisto->GetXaxis()->SetRangeUser(0,binning[binning.size()-1]);
  datahisto->SetMinimum(0.1);
  datahisto->SetMarkerSize(DataMarkerSize);
  datahisto->Draw("e1");
  mcstack.Draw("histo,same");
  datahisto->Draw("same,e1");
  leg->SetHeader("");
  leg->Draw();
  writeline1->SetTextSize(0.035);
  writeline1->Draw();
  DrawPrelim();
  if(!Contains(savename,"Dibosons")) Save_With_Ratio(datahisto,mcstack,jzbpad2->cd(),("jzb/PositiveSideOnly/"+savename+""));
  else Save_With_Ratio(datahisto,mcstack,jzbpad2->cd(),(savename+"__PosOnly"));
  datahisto->Delete();
  mcstack.Delete();
}

Double_t GausR(Double_t *x, Double_t *par) {
  return gRandom->Gaus(x[0],par[0]);
}

void produce_stretched_jzb_plots(string mcjzb, string datajzb,vector<float> ratio_binning) {
  TCanvas *dican = new TCanvas("dican","JZB Plots Canvas");
  float max=jzbHigh ;
  float min=-120;
  int nbins=(int)((max-min)/5.0); // we want 5 GeV/bin
  int coarserbins=int(nbins/2.0);
  int rebinnedbins=int(nbins/4.0);
  
  vector<float>binning;vector<float>coarse_binning;vector<float>coarsest_binning;
  for(int i=0;i<=nbins;i++)binning.push_back(min+i*(max-min)/((float)nbins));
  for(int i=0;i<=coarserbins;i++)coarse_binning.push_back(min+i*(max-min)/((float)coarserbins));
  for(int i=0;i<=rebinnedbins;i++)coarsest_binning.push_back(min+i*(max-min)/((float)rebinnedbins));

  draw_pure_jzb_histo(cutOSSF&&cutnJets&&cutmass,datajzb,mcjzb,"Dibosons/jzb_OS_SFZP",dican,binning);
  draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass,datajzb,mcjzb,"Dibosons/jzb_OS_OFZP",dican,binning);
  draw_pure_jzb_histo(cutOSSF&&cutnJets&&cutmass&&"id1==0",datajzb,mcjzb,"Dibosons/ee/jzb_OS_SFZP",dican,binning);
  draw_pure_jzb_histo(cutOSSF&&cutnJets&&cutmass&&"id1==1",datajzb,mcjzb,"Dibosons/mm/jzb_OS_SFZP",dican,binning);
  draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass&&"id1==0",datajzb,mcjzb,"Dibosons/ee/jzb_OS_OFZP",dican,binning);
  draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass&&"id1==1",datajzb,mcjzb,"Dibosons/mm/jzb_OS_OFZP",dican,binning);
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) draw_pure_jzb_histo(cutOSSF&&cutnJets&&sidebandcut,datajzb,mcjzb,"Dibosons/jzb_OS_SFSB",dican,binning);
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) draw_pure_jzb_histo(cutOSOF&&cutnJets&&sidebandcut,datajzb,mcjzb,"Dibosons/jzb_OS_OFSB",dican,binning);
  
  draw_pure_jzb_histo(cutOSSF&&cutnJets&&cutmass,datajzb,mcjzb,"Dibosons/jzb_OS_SFZP_coarse",dican,coarse_binning);
  draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass,datajzb,mcjzb,"Dibosons/jzb_OS_OFZP_coarse",dican,coarse_binning);
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) draw_pure_jzb_histo(cutOSSF&&cutnJets&&sidebandcut,datajzb,mcjzb,"Dibosons/jzb_OS_SFSB_coarse",dican,coarse_binning);
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) draw_pure_jzb_histo(cutOSOF&&cutnJets&&sidebandcut,datajzb,mcjzb,"Dibosons/jzb_OS_OFSB_coarse",dican,coarse_binning);
  
  delete dican;
}
  

void diboson_plots(string mcjzb, string datajzb,vector<float> ratio_binning) {
  switch_overunderflow(true);
  vector<int> SamplesToBeModified = allsamples.FindSampleBySampleName("WW/WZ/ZZ");
  
  if(SamplesToBeModified.size()==0 || SamplesToBeModified[0]==-1) {
    write_error(__FUNCTION__,"Could not find any diboson samples - aborting diboson plots");
    return;
  }
  
  float stretchfactor = 100.0;
  vector<string> labels;
  
  
  dout << "Going to increase the cross section for diboson samples ... " << endl;
  for(int i=0;i<(int)SamplesToBeModified.size();i++) {
    float origxs=(allsamples.collection)[SamplesToBeModified[i]].xs;
    (allsamples.collection)[SamplesToBeModified[i]].xs=origxs*stretchfactor;
    dout << "     Increased xs for sample " << (allsamples.collection)[SamplesToBeModified[i]].filename << " from " << origxs << " to " << (allsamples.collection)[SamplesToBeModified[i]].xs << " (by a factor of " << stretchfactor << ")" << endl;
    labels.push_back((allsamples.collection)[SamplesToBeModified[i]].samplename);
    (allsamples.collection)[SamplesToBeModified[i]].samplename=any2string(int(stretchfactor))+" x "+(allsamples.collection)[SamplesToBeModified[i]].samplename;
    dout << "         (also renamed it to " << (allsamples.collection)[SamplesToBeModified[i]].samplename << " )" << endl;
  }
  
  dout << "Going to produce JZB plots" << endl;
  produce_stretched_jzb_plots(mcjzb,datajzb,ratio_binning);
  TCanvas *gloca = new TCanvas("gloca","gloca");
  
  dout << "Going to produce prediction plots" << endl;
  do_prediction_plot(mcjzb, gloca, PlottingSetup::jzbHigh, 0, false,"Dibosons/Bpred/" ); // do only MC plots, no signal
  do_prediction_plot(mcjzb, gloca, PlottingSetup::jzbHigh, 0, false,"Dibosons/Bpred/" ); // do MC plots with signal
  delete gloca;

  dout << "Going to reset the cross section for diboson samples ... " << endl;
  for(int i=0;i<(int)SamplesToBeModified.size();i++) {
    float Upxs=(allsamples.collection)[SamplesToBeModified[i]].xs;
    (allsamples.collection)[SamplesToBeModified[i]].xs=(allsamples.collection)[SamplesToBeModified[i]].xs*(1.0/stretchfactor);
    string Upname=(allsamples.collection)[SamplesToBeModified[i]].samplename;
    (allsamples.collection)[SamplesToBeModified[i]].samplename=labels[i];
    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;
    
  }
//   switch_overunderflow(false);
}


void draw_normalized_data_vs_data_histo(TCut cut1, TCut cut2, string variable, string legentry1, string legentry2, string savename, TCanvas *can,vector<float> binning) {
  TPad *jzbpad = new TPad("jzbpad","jzbpad",0,0,1,1);
  jzbpad->cd();
  jzbpad->SetLogy(1);
  string xlabel="JZB [GeV]";

  TH1F *datahisto1 = allsamples.Draw("datahisto1",variable,binning, xlabel, "events",cut1,data,luminosity);
  datahisto1->SetLineColor(kRed);
  datahisto1->SetMarkerColor(kRed);
  TH1F *datahisto2 = allsamples.Draw("datahisto2",variable,binning, xlabel, "events",cut2,data,luminosity);
  datahisto2->SetLineColor(kBlue);
  datahisto2->SetMarkerColor(kBlue);
  
  datahisto2->SetMarkerSize(DataMarkerSize);
  datahisto1->DrawNormalized("e1");
  datahisto2->DrawNormalized("histo,same");
  datahisto1->DrawNormalized("same,e1");
  
  TLegend *leg = make_legend();
  leg->AddEntry(datahisto1,legentry1.c_str());
  leg->AddEntry(datahisto2,legentry2.c_str());
  leg->Draw();
  
  Save_With_Ratio(datahisto1,datahisto2,jzbpad->cd(),("jzb/"+savename));
  
  datahisto1->Delete();
  datahisto2->Delete();
}


void jzb_plots(string mcjzb, string datajzb,vector<float> ratio_binning) {
  switch_overunderflow(true);
  TCanvas *can = new TCanvas("can","JZB Plots Canvas");
  float max=jzbHigh ;
  float min=-120;
  int nbins=(int)((max-min)/5.0); // we want 5 GeV/bin
  int coarserbins=int(nbins/2.0);
  int rebinnedbins=int(nbins/4.0);
  
  vector<float>binning;vector<float>coarse_binning;vector<float>coarsest_binning;
  for(int i=0;i<=nbins;i++)binning.push_back(min+i*(max-min)/((float)nbins));
  for(int i=0;i<=coarserbins;i++)coarse_binning.push_back(min+i*(max-min)/((float)coarserbins));
  for(int i=0;i<=rebinnedbins;i++)coarsest_binning.push_back(min+i*(max-min)/((float)rebinnedbins));

  if ( !PlottingSetup::Approved ) {
    draw_pure_jzb_histo(cutOSSF&&cutnJets&&cutmass,datajzb,mcjzb,"jzb_OS_SFZP",can,binning);
    draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass,datajzb,mcjzb,"jzb_OS_OFZP",can,binning);
    draw_pure_jzb_histo(cutOSSF&&cutnJets&&cutmass&&"id1==0",datajzb,mcjzb,"ee/jzb_OS_SFZP",can,binning);
    draw_pure_jzb_histo(cutOSSF&&cutnJets&&cutmass&&"id1==1",datajzb,mcjzb,"mm/jzb_OS_SFZP",can,binning);
    draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass&&"id1==0",datajzb,mcjzb,"ee/jzb_OS_OFZP",can,binning);
    draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass&&"id1==1",datajzb,mcjzb,"mm/jzb_OS_OFZP",can,binning);
    flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak
    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) draw_pure_jzb_histo(cutOSSF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_SFSB",can,binning);
    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) draw_pure_jzb_histo(cutOSOF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_OFSB",can,binning);
    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);
    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);
    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);

  }
  
  draw_pure_jzb_histo(cutOSSF&&cutnJets&&cutmass,datajzb,mcjzb,"jzb_OS_SFZP_coarse",can,coarse_binning);
  if ( !PlottingSetup::Approved ) {
    draw_pure_jzb_histo(cutOSOF&&cutnJets&&cutmass,datajzb,mcjzb,"jzb_OS_OFZP_coarse",can,coarse_binning);
    flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak
    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) draw_pure_jzb_histo(cutOSSF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_SFSB_coarse",can,coarse_binning);
    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) draw_pure_jzb_histo(cutOSOF&&cutnJets&&sidebandcut,datajzb,mcjzb,"jzb_OS_OFSB_coarse",can,coarse_binning);
  }
  delete can;
  switch_overunderflow(false);
}


void calculate_all_yields(string mcdrawcommand,vector<float> jzb_cuts) {
  dout << "Calculating background yields in MC:" << endl;
  jzb_cuts.push_back(14000);
  TH1F *allbgs = allsamples.Draw("allbgs",jzbvariablemc,jzb_cuts, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,mc,luminosity);
  float cumulative=0;
  for(int i=allbgs->GetNbinsX();i>=1;i--) {
    cumulative+=allbgs->GetBinContent(i);
    dout << "Above " << allbgs->GetBinLowEdge(i) << " GeV/c : " << cumulative << endl;
  }
}


TCut give_jzb_expression(string mcjzb, float jzbcut, string posneg="pos") {
  stringstream res;
  res << "(" << mcjzb;
  if(posneg=="pos") res << ">";
  else res << "<-";
  res << jzbcut << ")";
  return TCut(res.str().c_str());
}

string sigdig(float number, int nsigdig=3, float min=0) {
  //this function tries to extract n significant digits, and if the number is below (min), it returns "<min"
  if(number<min) return "< "+any2string(min);
  stringstream sol;
  sol << setprecision(nsigdig) << number;
  
  return sol.str();
}
  
string jzb_tex_command(string region, string posneg) {
  if(posneg=="pos") posneg="POS";
  else posneg="NEG";
  stringstream texcommand;
  texcommand<<"\\"<<region <<"JZB"<<posneg;
  return texcommand.str();
}
//  \SFZPJZBPOS
//  Sample &  \OFZPJZBPOS  & \OFZPJZBNEG &  \SFZPJZBPOS & \SFZPJZBNEG & \OFSBJZBPOS  & \OFSBJZBNEG  & \SFSBJZBPOS  & \SFSBJZBNEG  \\\hline
  
void compute_MC_yields(string mcjzb,vector<float> jzb_cuts) {
  dout << "Calculating background yields in MC:" << endl;
  
  TCanvas *yica = new TCanvas("yica","yield canvas");
  
  int nRegions=4;
  if(!PlottingSetup::RestrictToMassPeak||!PlottingSetup::UseSidebandsForcJZB) nRegions=2;
  string tsRegions[] = {"SFZP","OFZP","SFSB","OFSB"};
  string posneg[] = {"pos","neg"};
  TCut tkRegions[] = {cutOSSF&&cutnJets&&cutmass,cutOSOF&&cutnJets&&cutmass,cutOSSF&&cutnJets&&sidebandcut,cutOSOF&&cutnJets&&sidebandcut};

  for(int ijzb=0;ijzb<(int)jzb_cuts.size();ijzb++) {
    TCut jzbMC[]  = { give_jzb_expression(mcjzb,jzb_cuts[ijzb],"pos"), give_jzb_expression(mcjzb,jzb_cuts[ijzb],"neg") };
    dout << "_________________________________________________________" << endl;
    dout << "Table for JZB> " << jzb_cuts[ijzb] << endl;
    for(int isample=0;isample<(int)(allsamples.collection).size();isample++) {
      if(!(allsamples.collection)[isample].is_data) dout << (allsamples.collection)[isample].samplename << "  &  ";
      else dout << "Sample & ";
      for(int iregion=0;iregion<nRegions;iregion++) {
        for(int ipos=0;ipos<2;ipos++) {
          if((allsamples.collection)[isample].is_data) dout << jzb_tex_command(tsRegions[iregion],posneg[ipos]) << "  &  ";
          else {
            vector<int> specific;specific.push_back(isample);
            TH1F *shisto = allsamples.Draw("shisto","mll",1,0,500,"tester","events",tkRegions[iregion]&&jzbMC[ipos],mc,luminosity,specific);
            dout << sigdig(shisto->Integral(),3,0.05) <<"  &  ";
            delete shisto;
          }
      }//end of ipos
    }//end of iregion
    dout << " \\\\" << endl;
  }//end of isample
  }//end of ijzb
  dout << "  \\hline" << endl;
  
  delete yica;
}

void draw_ttbar_and_zjets_shape_for_one_configuration(string mcjzb, string datajzb, int leptontype=-1, int scenario=0,bool floating=false) {
  //Step 1: Establishing cuts
  stringstream jetcutstring;
  string writescenario="";

  if(scenario==0) jetcutstring << "(pfJetGoodNum>=3)&&"<<(const char*) basicqualitycut;
  if(scenario==1) jetcutstring << "(pfJetPt[0]>50&&pfJetPt[1]>50)&&"<<(const char*)basicqualitycut;
  TCut jetcut(jetcutstring.str().c_str());
  string leptoncut="mll>0";
  if(leptontype==0||leptontype==1) {
    if(leptontype==0) {
      leptoncut="id1==0";
      writescenario="__ee";
    }
    else {
      leptoncut="id1==1";
      writescenario="__ee";
    }
  }
  TCut lepcut(leptoncut.c_str());
  
  TCanvas *c5 = new TCanvas("c5","c5",1500,500);
  TCanvas *c6 = new TCanvas("c6","c6");
  c5->Divide(3,1);

  //STEP 2: Extract Zjets shape in data
  c5->cd(1);
  c5->cd(1)->SetLogy(1);
  TCut massat40("mll>40");
  TH1F *ossfleft   = allsamples.Draw("ossfleft",  "-"+datajzb,40,0,200, "JZB [GeV]", "events", massat40&&cutOSSF&&jetcut&&lepcut,data,luminosity);
  TH1F *osofleft   = allsamples.Draw("osofleft",  "-"+datajzb,40,0,200, "JZB [GeV]", "events", massat40&&cutOSOF&&jetcut&&lepcut,data,luminosity);
  ossfleft->SetLineColor(kRed);
  ossfleft->SetMarkerColor(kRed);
  ossfleft->Add(osofleft,-1); 
  vector<TF1*> functions = do_cb_fit_to_plot(ossfleft,10);
  ossfleft->SetMarkerSize(DataMarkerSize);
  ossfleft->Draw();
  functions[0]->Draw("same");functions[1]->Draw("same");functions[2]->Draw("same");
  TF1 *zjetsfunc = (TF1*) functions[1]->Clone();
  TF1 *zjetsfuncN = (TF1*) functions[0]->Clone();
  TF1 *zjetsfuncP = (TF1*) functions[2]->Clone();
  zjetsfunc->Draw("same");zjetsfuncN->Draw("same");zjetsfuncP->Draw("same");
  TLegend *leg1 = new TLegend(0.6,0.6,0.89,0.80);
  leg1->SetFillColor(kWhite);
  leg1->SetLineColor(kWhite);
  leg1->AddEntry(ossfleft,"OSSF (sub),JZB<peak","p");
  leg1->AddEntry(zjetsfunc,"OSSF fit ('zjets')","l");
  leg1->Draw("same");
  TText *titleleft = write_title("Extracting Z+Jets shape");
  titleleft->Draw();
  
  //Step 3: Extract ttbar shape (in data or MC?)
  c5->cd(2);
  c5->cd(2)->SetLogy(1);
  TH1F *osof;
  TText *titlecenter;
  bool frommc=false;
  if(frommc) {
    osof = allsamples.Draw("osof",datajzb,40,-200,200, "JZB [GeV]", "events", massat40&&cutOSSF&&jetcut&&lepcut,mc,luminosity,allsamples.FindSample("TTJets"));
    titlecenter = write_title("Extracting ttbar shape (from ossf MC)");
  }
  else {
    osof = allsamples.Draw("osof",datajzb,40,-200,200, "JZB [GeV]", "events", massat40&&cutOSOF&&jetcut&&lepcut,data,luminosity);
    titlecenter = write_title("Extracting ttbar shape (from osof data)");
  }
  osof->SetMarkerSize(DataMarkerSize);
  osof->Draw();
  vector<TF1*> ttbarfunctions = do_cb_fit_to_plot(osof,35,true);
  ttbarfunctions[0]->SetLineColor(kRed); ttbarfunctions[0]->SetLineStyle(2);    ttbarfunctions[0]->Draw("same");
  ttbarfunctions[1]->SetLineColor(kRed);                                        ttbarfunctions[1]->Draw("same");
  ttbarfunctions[2]->SetLineColor(kRed); ttbarfunctions[2]->SetLineStyle(2);    ttbarfunctions[2]->Draw("same");

  TLegend *leg2 = new TLegend(0.15,0.8,0.4,0.89);
  leg2->SetFillColor(kWhite);
  leg2->SetLineColor(kWhite);
  if(frommc) {
    leg2->AddEntry(osof,"t#bar{t} OSSF, MC","p");
    leg2->AddEntry(ttbarfunctions[1],"Fit to t#bar{t} OSSF,MC","l");
  } else {
    leg2->AddEntry(osof,"OSOF","p");
    leg2->AddEntry(ttbarfunctions[1],"Fit to OSOF","l");
  }
  leg2->Draw("same");
  titlecenter->Draw();

//--------------------------------------------------------------------------------------------------------------------------------
  //STEP 4: Present it!
  // actually: if we wanna let it float we need to do that first :-) 
  c5->cd(3);
  c5->cd(3)->SetLogy(1);
  TH1F *observed   = allsamples.Draw("observed",datajzb,100,0,500, "JZB [GeV]", "events", massat40&&cutOSSF&&jetcut&&lepcut,data,luminosity);
  observed->SetMarkerSize(DataMarkerSize);

  TF1 *logparc = new TF1("logparc",InvCrystalBall,0,1000,5);    logparc->SetLineColor(kRed);
  TF1 *logparcn = new TF1("logparcn",InvCrystalBallN,0,1000,5); logparcn->SetLineColor(kRed);   logparcn->SetLineStyle(2);
  TF1 *logparcp = new TF1("logparcp",InvCrystalBallP,0,1000,5); logparcp->SetLineColor(kRed);   logparcp->SetLineStyle(2);
  
  TF1 *zjetsc = new TF1("zjetsc",InvCrystalBall,0,1000,5);      zjetsc->SetLineColor(kBlue);    
  TF1 *zjetscn = new TF1("zjetscn",InvCrystalBallN,0,1000,5);   zjetscn->SetLineColor(kBlue);   zjetscn->SetLineStyle(2);
  TF1 *zjetscp = new TF1("zjetscp",InvCrystalBallP,0,1000,5);   zjetscp->SetLineColor(kBlue);   zjetscp->SetLineStyle(2);
  
  TF1 *ZplusJetsplusTTbar = new TF1("ZplusJetsplusTTbar", DoubleInvCrystalBall,0,1000,10);      ZplusJetsplusTTbar->SetLineColor(kBlue);
  TF1 *ZplusJetsplusTTbarP= new TF1("ZplusJetsplusTTbarP",DoubleInvCrystalBallP,0,1000,10);     ZplusJetsplusTTbarP->SetLineColor(kBlue);       ZplusJetsplusTTbarP->SetLineStyle(2);
  TF1 *ZplusJetsplusTTbarN= new TF1("ZplusJetsplusTTbarN",DoubleInvCrystalBallN,0,1000,10);     ZplusJetsplusTTbarN->SetLineColor(kBlue);       ZplusJetsplusTTbarN->SetLineStyle(2);
  
  zjetsc->SetParameters(zjetsfunc->GetParameters());
  zjetscp->SetParameters(zjetsfunc->GetParameters());
  zjetscn->SetParameters(zjetsfunc->GetParameters());
  
  TH1F *observeda   = allsamples.Draw("observeda",datajzb,53,80,jzbHigh, "JZB [GeV]", "events", massat40&&cutOSSF&&jetcut&&lepcut,data,luminosity);
  //blublu
  logparc->SetParameters(ttbarfunctions[1]->GetParameters());
  logparcn->SetParameters(ttbarfunctions[1]->GetParameters());
  logparcp->SetParameters(ttbarfunctions[1]->GetParameters());
  if(floating) {
    dout << "TTbar contribution assumed (before fitting) : " << logparc->GetParameter(0) << endl;
    logparc->SetParameters(ttbarfunctions[1]->GetParameters());
    for(int i=0;i<10;i++) {
      if(i<5) ZplusJetsplusTTbar->FixParameter(i,zjetsfunc->GetParameter(i));
      if(i>=5) {
        if (i>5) ZplusJetsplusTTbar->FixParameter(i,logparc->GetParameter(i-5));
        if (i==5) ZplusJetsplusTTbar->SetParameter(i,logparc->GetParameter(i-5));
      }
    }//end of setting parameters
    observeda->Draw("same");
    ZplusJetsplusTTbar->Draw("same");
    observeda->Fit(ZplusJetsplusTTbar);
    dout << "--> Quality of Z+Jets / TTbar fit : chi2/ndf = " << ZplusJetsplusTTbar->GetChisquare() << "/" << ZplusJetsplusTTbar->GetNDF() << endl;
    ZplusJetsplusTTbar->Draw("same");
    ZplusJetsplusTTbarP->SetParameters(ZplusJetsplusTTbar->GetParameters());
    ZplusJetsplusTTbarN->SetParameters(ZplusJetsplusTTbar->GetParameters());
    dout << "TTbar contribution found (after fitting) : " << ZplusJetsplusTTbar->GetParameter(5) << endl;
    float factor = ZplusJetsplusTTbar->GetParameter(5) / logparc->GetParameter(0);
    dout << "FACTOR: " << factor << endl; 
    logparc->SetParameter(0,factor*ttbarfunctions[1]->GetParameter(0));
    logparcn->SetParameter(0,factor*ttbarfunctions[1]->GetParameter(0));
    logparcp->SetParameter(0,factor*ttbarfunctions[1]->GetParameter(0));
  }
  
  c5->cd(3);
  c5->cd(3)->SetLogy(1);
  observed->Draw();
  zjetsc->Draw("same");zjetscn->Draw("same");zjetscp->Draw("same");
  logparc->Draw("same");
  logparcn->Draw("same");
  logparcp->Draw("same");

  TLegend *leg3 = new TLegend(0.6,0.6,0.89,0.80);
  leg3->SetFillColor(kWhite);
  leg3->SetLineColor(kWhite);
  leg3->AddEntry(observed,"OSSF,JZB>peak","p");
  leg3->AddEntry(ttbarfunctions[1],"OSOF fit ('ttbar')","l");
  leg3->AddEntry(zjetsfunc,"OSSF,JZB<0 fit ('zjets')","l");
  leg3->Draw("same");
  TText *titleright = write_title("Summary of shapes and observed shape");
  titleright->Draw();
  
  c6->cd()->SetLogy(1);
  observed->Draw();  
  zjetsc->Draw("same");zjetscn->Draw("same");zjetscp->Draw("same");
  logparc->Draw("same");
  logparcn->Draw("same");
  logparcp->Draw("same");
  leg3->Draw("same");
  titleright->Draw();
  
  if(scenario==0) {
    CompleteSave(c5,"Shapes2/Making_of___3jetsabove30"+writescenario);
    CompleteSave(c5->cd(1),"Shapes2/Making_of___3jetsabove30"+writescenario+"__cd1");
    CompleteSave(c5->cd(2),"Shapes2/Making_of___3jetsabove30"+writescenario+"__cd2");
    CompleteSave(c5->cd(3),"Shapes2/Making_of___3jetsabove30"+writescenario+"__cd3");
    CompleteSave(c6,"Shapes2/Background_Shapes___3jetsabove30"+writescenario);
  } else {
    CompleteSave(c5,"Shapes2/Making_of___2jetsabove50"+writescenario);
    CompleteSave(c5->cd(1),"Shapes2/Making_of___2jetsabove50"+writescenario+"__cd1");
    CompleteSave(c5->cd(2),"Shapes2/Making_of___2jetsabove50"+writescenario+"__cd2");
    CompleteSave(c5->cd(3),"Shapes2/Making_of___2jetsabove50"+writescenario+"__cd3");
    CompleteSave(c6,"Shapes2/Background_Shapes___2jetsabove50"+writescenario);
  }
  dout << "Statistics about our fits: " << endl; 
  dout << "Z+Jets shape: Chi2/ndf = " << zjetsfunc->GetChisquare() << "/" << ossfleft->GetNbinsX() << endl;
  dout << "ttbar shape: Chi2/ndf = " << ttbarfunctions[1]->GetChisquare() << "/" << osof->GetNbinsX() << endl;

  c6->cd();
  TLegend *additionallegend = new TLegend(0.6,0.6,0.89,0.89);
  additionallegend->SetFillColor(kWhite);
  additionallegend->SetLineColor(kWhite);
  additionallegend->AddEntry(observed,"Data","p");
  additionallegend->AddEntry(ZplusJetsplusTTbar,"Fitted Z+jets & TTbar","l");
  additionallegend->AddEntry(zjetsc,"Z+jets","l");
  additionallegend->AddEntry(logparc,"TTbar","l");
  observed->Draw();
  ZplusJetsplusTTbar->SetLineColor(kGreen);
  ZplusJetsplusTTbarP->SetLineColor(kGreen);
  ZplusJetsplusTTbarN->SetLineColor(kGreen);
  ZplusJetsplusTTbarP->SetLineStyle(2);
  ZplusJetsplusTTbarN->SetLineStyle(2);
  TF1 *ZplusJetsplusTTbar2 = new TF1("ZplusJetsplusTTbar2",DoubleInvCrystalBall,0,1000,10);
  ZplusJetsplusTTbar2->SetParameters(ZplusJetsplusTTbar->GetParameters());
  ZplusJetsplusTTbar2->SetLineColor(kGreen);
  ZplusJetsplusTTbarP->SetFillColor(TColor::GetColor("#81F781"));
  ZplusJetsplusTTbarN->SetFillColor(kWhite);
  ZplusJetsplusTTbarP->Draw("fcsame");
  ZplusJetsplusTTbarN->Draw("fcsame");
  TH1F *hZplusJetsplusTTbar = (TH1F*)ZplusJetsplusTTbar2->GetHistogram();
  TH1F *hZplusJetsplusTTbarN = (TH1F*)ZplusJetsplusTTbarN->GetHistogram();
  TH1F *hZplusJetsplusTTbarP = (TH1F*)ZplusJetsplusTTbarP->GetHistogram();
  hZplusJetsplusTTbar->SetMarkerSize(0);
  hZplusJetsplusTTbarP->SetMarkerSize(0);
  hZplusJetsplusTTbarN->SetMarkerSize(0);
  for (int i=1;i<=hZplusJetsplusTTbar->GetNbinsX();i++) {
    float newerror=hZplusJetsplusTTbarP->GetBinContent(i)-hZplusJetsplusTTbar->GetBinContent(i);
    hZplusJetsplusTTbar->SetBinError(i,newerror);
    if(hZplusJetsplusTTbar->GetBinContent(i)<0.05) hZplusJetsplusTTbar->SetBinContent(i,0); //avoiding a displaying probolem
  }
  hZplusJetsplusTTbarP->SetFillColor(kGreen);
  hZplusJetsplusTTbarN->SetFillColor(kWhite);
  hZplusJetsplusTTbarN->Draw("same");
  
  ZplusJetsplusTTbar2->SetMarkerSize(0);
  ZplusJetsplusTTbar2->Draw("same");

  zjetsc->Draw("same");zjetscn->Draw("same");zjetscp->Draw("same");
  logparc->Draw("same");
  logparcn->Draw("same");
  logparcp->Draw("same");
  additionallegend->Draw("same");
    if(scenario==0) {
    CompleteSave(c6,"Shapes2/Background_Shapes___3jetsabove30__allfits__"+writescenario);
  } else {
    CompleteSave(c6,"Shapes2/Background_Shapes___2jetsabove50__allfits__"+writescenario);
  }
//--------------------------------------------------------------------------------------------------------------------------------
}

void draw_ttbar_and_zjets_shape(string mcjzb, string datajzb) {
  int all_leptons=-1;
  int threejetswith30gev=0;
/*  
  int twojetswith50gev=1;
  int electrons_only=0;
  int mu_only=1;
 
  draw_ttbar_and_zjets_shape_for_one_configuration(mcjzb,datajzb,all_leptons,twojetswith50gev);
  draw_ttbar_and_zjets_shape_for_one_configuration(mcjzb,datajzb,all_leptons,threejetswith30gev);
  
  draw_ttbar_and_zjets_shape_for_one_configuration(mcjzb,datajzb,electrons_only,twojetswith50gev);
  draw_ttbar_and_zjets_shape_for_one_configuration(mcjzb,datajzb,electrons_only,threejetswith30gev);

  draw_ttbar_and_zjets_shape_for_one_configuration(mcjzb,datajzb,mu_only,twojetswith50gev);
  draw_ttbar_and_zjets_shape_for_one_configuration(mcjzb,datajzb,mu_only,threejetswith30gev);
  */

  draw_ttbar_and_zjets_shape_for_one_configuration(mcjzb,datajzb,all_leptons,threejetswith30gev,true);
}

float find_one_correction_factor(string FindKeyword, bool dodata, TCut SpecialCut, string SaveAs) {
  TCanvas *cancorr = new TCanvas("cancorr","Canvas for Response Correction");
  cancorr->SetLogz();
  cancorr->SetRightMargin(0.13);
  TCut zptforresponsepresentation(Restrmasscut&&SpecialCut&&passtrig);

  if(PlottingSetup::DoBTag) zptforresponsepresentation=zptforresponsepresentation&&PlottingSetup::bTagRequirement;
  TH2F *niceresponseplotd = new TH2F("niceresponseplotd","",100,0,600,100,0,5);
  niceresponseplotd->Sumw2();
  TH2F* emuResponse = (TH2F*)niceresponseplotd->Clone("emuResponse");
  vector<int> SampleIndices=allsamples.FindSample(FindKeyword);
  for(int iSample=0;iSample<(int)SampleIndices.size();iSample++) {
    if((allsamples.collection)[SampleIndices[iSample]].is_data && !dodata) continue;
    if((allsamples.collection)[SampleIndices[iSample]].is_data ==false && dodata) continue;
    
    dout << "   Response correction : Using sample " << (allsamples.collection)[SampleIndices[iSample]].filename << " for " << FindKeyword << endl;
    (allsamples.collection)[SampleIndices[iSample]].events->Draw("sumJetPt[1]/pt:pt>>+niceresponseplotd",(zptforresponsepresentation&&cutOSSF)*cutWeight);
    (allsamples.collection)[SampleIndices[iSample]].events->Draw("sumJetPt[1]/pt:pt>>+emuResponse",(zptforresponsepresentation&&cutOSOF)*cutWeight);
  }
  niceresponseplotd->Add(emuResponse,-1);
  
  niceresponseplotd->SetStats(0);
  niceresponseplotd->GetXaxis()->SetTitle("Z p_{T} [GeV]");
  niceresponseplotd->GetYaxis()->SetTitle("Response");
  niceresponseplotd->GetXaxis()->CenterTitle();
  niceresponseplotd->GetYaxis()->CenterTitle();
  niceresponseplotd->Draw("COLZ");
  TProfile * profd = (TProfile*)niceresponseplotd->ProfileX();
  profd->Rebin(2);
  profd->SetMarkerSize(DataMarkerSize);
  profd->Fit("pol0","","same,e1",100,400);
  DrawPrelim();
  string stitle="Data";
  if(!Contains(FindKeyword,"Data")) stitle="MC";
  TText* title = write_text(0.5,0.7,stitle.c_str());
  title->SetTextAlign(12);
  title->Draw();
  TF1 *datapol=(TF1*)profd->GetFunction("pol0");
  float correction=datapol->GetParameter(0);
  stringstream resstring;
  resstring<<"Response: "<<std::setprecision(2)<<100*correction<<" %";
  TText* restitle = write_text(0.5,0.65,resstring.str());
  restitle->SetTextAlign(12);
  restitle->SetTextSize(0.03);
  restitle->Draw();
  CompleteSave(cancorr,"ResponseCorrection/Response_Correction_Illustration_New_"+SaveAs);
  delete cancorr;
  delete niceresponseplotd;
  delete profd;
  return correction;
}

void find_correction_factors(string &jzbvardata,string &jzbvarmc) {
  
  dout << "Computing response corrections: " << endl;
  //Step 1 : Get results
  float datacorrection=find_one_correction_factor("Data",true,"","Data");
  float mccorrection=find_one_correction_factor("DY",false,"","MC");
  
  float dataEEcorrection=find_one_correction_factor("Data",true,"id1==0","Data_ee");
  float mcEEcorrection=find_one_correction_factor("DY",false,"id1==0","MC_ee");
  
  float dataMMcorrection=find_one_correction_factor("Data",true,"id1==1","Data_mm");
  float mcMMcorrection=find_one_correction_factor("DY",false,"id1==1","MC_mm");
  
  cout << "Corrections : " << endl;
  cout << "   Data : " << datacorrection << endl;
  cout << "     ee (" << dataEEcorrection << ") , mm (" << dataMMcorrection << ")" << endl;
  cout << "   MC : " << mccorrection << endl;
  cout << "     ee (" << mcEEcorrection << ") , mm (" << mcMMcorrection << ")" << endl;
  
  //Step 2: Processing the result and making it into something useful :-)
  stringstream jzbvardatas;
  jzbvardatas << "(";
  
  if(dataEEcorrection>=1) jzbvardatas<<"((id1==0&&id1==id2)*(jzb[1]-" << dataEEcorrection-1 << "*pt))";
  if(dataEEcorrection<1)  jzbvardatas<<"((id1==0&&id1==id2)*(jzb[1]+" << 1-dataEEcorrection << "*pt))";
  
  if(dataMMcorrection>=1) jzbvardatas<<"+((id1==1&&id1==id2)*(jzb[1]-" << dataMMcorrection-1 << "*pt))";
  if(dataMMcorrection<1)  jzbvardatas<<"+((id1==1&&id1==id2)*(jzb[1]+" << 1-dataMMcorrection << "*pt))";
  
  float averagecorrection=(dataMMcorrection+dataEEcorrection)/2.0;
  
  if(datacorrection>=1) jzbvardatas<<"+((id1!=id2)*(jzb[1]-" << datacorrection-1 << "*pt))";
  if(datacorrection<1) jzbvardatas<<"+((id1!=id2)*(jzb[1]+" << 1-datacorrection << "*pt))";
  
  jzbvardatas << ")";
  jzbvardata=jzbvardatas.str();
  
  stringstream jzbvarmcs;
  jzbvarmcs << "(";
  
  if(mcEEcorrection>=1) jzbvarmcs<<"((id1==0&&id1==id2)*(jzb[1]-" << mcEEcorrection-1 << "*pt))";
  if(mcEEcorrection<1)  jzbvarmcs<<"((id1==0&&id1==id2)*(jzb[1]+" << 1-mcEEcorrection << "*pt))";
  
  if(mcMMcorrection>=1) jzbvarmcs<<"+((id1==1&&id1==id2)*(jzb[1]-" << mcMMcorrection-1 << "*pt))";
  if(mcMMcorrection<1)  jzbvarmcs<<"+((id1==1&&id1==id2)*(jzb[1]+" << 1-mcMMcorrection << "*pt))";
  
  float averagemccorrection=(mcMMcorrection+mcEEcorrection)/2.0;
  
  if(mccorrection>=1) jzbvarmcs<<"+((id1!=id2)*(jzb[1]-" << mccorrection-1 << "*pt))";
  if(mccorrection<1) jzbvarmcs<<"+((id1!=id2)*(jzb[1]+" << 1-mccorrection << "*pt))";
  
  jzbvarmcs << ")";
  jzbvarmc=jzbvarmcs.str();

  dout << "JZB Z pt correction summary : " << endl;
  dout << "  Data: The response is " << datacorrection << "  --> jzb variable is now : " << jzbvardata << endl;
  dout << "  MC  : The response is " << mccorrection << "  --> jzb variable is now : " << jzbvarmc << endl;
  
}

void pick_up_events(string cut) {
  dout << "Picking up events with cut " << cut << endl;
  allsamples.PickUpEvents(cut);
}

void save_template(string mcjzb, string datajzb,vector<float> jzb_cuts,float MCPeakError,float DataPeakError, vector<float> jzb_shape_limit_bins) {
  dout << "Saving configuration template!" << endl;
  ofstream configfile;
  configfile.open("../DistributedModelCalculations/last_configuration.C");
  configfile<<"#include <iostream>\n";
  configfile<<"#include <vector>\n";
  configfile<<"#ifndef SampleClassLoaded\n";
  configfile<<"#include \"SampleClass.C\"\n";
  configfile<<"#endif\n";
  configfile<<"#define SetupLoaded\n";
  configfile<<"#ifndef ResultLibraryClassLoaded\n";
  configfile<<"#include \"ResultLibraryClass.C\"\n";
  configfile<<"#endif\n";

  configfile<<"\nusing namespace std;\n\n";
  
  configfile<<"namespace PlottingSetup { \n";
  configfile<<"string datajzb=\"datajzb_ERROR\";\n";
  configfile<<"string mcjzb=\"mcjzb_ERROR\";\n";
  configfile<<"vector<float>jzb_cuts;\n";
  configfile<<"vector<float>jzb_shape_limit_bins;\n";
  configfile<<"float MCPeakError=-999;\n";
  configfile<<"float DataPeakError=-999;\n";
  configfile<<"}\n\n";

  configfile<<"void read_config() {\n";
  configfile<<"datajzb=\""<<datajzb<<"\";\n";
  configfile<<"mcjzb=\""<<mcjzb<<"\";\n\n";
  configfile<<"\n\nMCPeakError="<<MCPeakError<<";\n";
  configfile<<"DataPeakError="<<DataPeakError<<";\n\n";
  for(int i=0;i<(int)jzb_cuts.size();i++) configfile<<"jzb_cuts.push_back("<<jzb_cuts[i]<<"); // JZB cut at " << jzb_cuts[i] << "\n";
  configfile<<"\n\n";
  for(int i=0;i<(int)Nobs.size();i++) configfile<<"Nobs.push_back("<<Nobs[i]<<"); // JZB cut at " << jzb_cuts[i] << "\n";
  for(int i=0;i<(int)Npred.size();i++) configfile<<"Npred.push_back("<<Npred[i]<<"); // JZB cut at " << jzb_cuts[i] << "\n";
  for(int i=0;i<(int)Nprederr.size();i++) configfile<<"Nprederr.push_back("<<Nprederr[i]<<"); // JZB cut at " << jzb_cuts[i] << "\n";
  configfile<<"\n\n";
  for(int i=0;i<(int)flippedNobs.size();i++) configfile<<"flippedNobs.push_back("<<flippedNobs[i]<<"); // JZB cut at " << jzb_cuts[i] << "\n";
  for(int i=0;i<(int)flippedNpred.size();i++) configfile<<"flippedNpred.push_back("<<flippedNpred[i]<<"); // JZB cut at " << jzb_cuts[i] << "\n";
  for(int i=0;i<(int)flippedNprederr.size();i++) configfile<<"flippedNprederr.push_back("<<flippedNprederr[i]<<"); // JZB cut at " << jzb_cuts[i] << "\n";
  for(int i=0;i<(int)jzb_shape_limit_bins.size();i++) configfile<<"jzb_shape_limit_bins.push_back("<<jzb_shape_limit_bins[i]<<"); // JZB shape bin boundary at " << jzb_shape_limit_bins[i] << "\n";
  configfile<<"\n\n";
  configfile<<"\n\n";
  configfile<<"luminosity="<<luminosity<<";\n";
  configfile<<"RestrictToMassPeak="<<RestrictToMassPeak<<";//defines the type of analysis we're running\n";
  configfile<<"UseSidebandsForcJZB="<<UseSidebandsForcJZB<<";//tells us whether to use the sidebands or not\n";
  
  configfile<<"\n\ncout << \"Configuration successfully loaded!\" << endl; \n \n } \n \n";
  
  configfile.close();

}

float get_nonzero_minimum(TH1F *histo) {
  float min=histo->GetMaximum();
  for(int ibin=1;ibin<=histo->GetNbinsX();ibin++) {
    float curcont=histo->GetBinContent(ibin);
    if(curcont<min&&curcont>0) min=curcont;
  }
  return min;
}

void draw_all_ttbar_histos(TCanvas *can, vector<TH1F*> histos, string drawoption="", float manualmin=-9) {
  can->cd();
  float min=1;
  float max=histos[0]->GetMaximum();
  if(manualmin>=0) min=manualmin;
  else {
    for(int i=1;i<(int)histos.size();i++) {
      float curmin=get_nonzero_minimum(histos[i]);
      float curmax=histos[i]->GetMaximum();
      if(curmin<min) min=curmin;
      if(curmax>max) max=curmax;
    }
  }
  histos[0]->GetYaxis()->SetRangeUser(min,4*max);
  histos[0]->Draw(drawoption.c_str());
  stringstream drawopt;
  drawopt << drawoption << ",same";
  for(int i=1;i<(int)histos.size();i++) {
    histos[i]->Draw(drawopt.str().c_str());
  }
}

void ttbar_sidebands_comparison(string mcjzb, vector<float> binning, string prestring) {
  //in the case of the on peak analysis, we compare the 3 control regions to the real value
  //in the case of the OFF peak analysis, we compare our control region to the real value
  TCut weightbackup=cutWeight;
  switch_overunderflow(true);
  
  bool doPURW=false;
  
  
  if(!doPURW) {
    dout << "Not doing PU reweighting for ttbar closure test" << endl;
    cutWeight="1.0";
    // Do it without PU re-weighting
    float MCPeakNoPU=0,MCPeakErrorNoPU=0,DataPeakNoPU=0,DataPeakErrorNoPU=0,MCSigma=0,DataSigma=0;
    stringstream resultsNoPU;
    stringstream noPUdatajzb;
    stringstream noPUmcjzb;
    
    stringstream mcjzbnoPU;
    find_peaks(MCPeakNoPU,MCPeakErrorNoPU, DataPeakNoPU, DataPeakErrorNoPU,resultsNoPU,true,noPUdatajzb,noPUmcjzb);
    mcjzb = noPUmcjzb.str();
  }

      
  float simulatedlumi = luminosity; //in pb please - adjust to your likings

  TH1F *TZem  = allsamples.Draw("TZem",     mcjzb,binning,"JZB [GeV]","events",cutmass&&cutOSOF&&cutnJets,mc,simulatedlumi,allsamples.FindSample("/TT"));
  TH1F *nTZem = allsamples.Draw("nTZem","-"+mcjzb,binning,"JZB [GeV]","events",cutmass&&cutOSOF&&cutnJets,mc,simulatedlumi,allsamples.FindSample("/TT"));
  TH1F *TSem;
  TH1F *nTSem;
  TH1F *TZeemm  = allsamples.Draw("TZeemm",     mcjzb,binning,"JZB [GeV]","events",cutmass&&cutOSSF&&cutnJets,mc,simulatedlumi,allsamples.FindSample("/TT"));
  TH1F *nTZeemm = allsamples.Draw("nTZeemm","-"+mcjzb,binning,"JZB [GeV]","events",cutmass&&cutOSSF&&cutnJets,mc,simulatedlumi,allsamples.FindSample("/TT"));
  TH1F *TSeemm;
  TH1F *nTSeemm;
  
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
    TSem    = allsamples.Draw("TSem",       mcjzb,binning,"JZB [GeV]","events",sidebandcut&&cutOSOF&&cutnJets,mc,simulatedlumi,allsamples.FindSample("/TT"));
    nTSem   = allsamples.Draw("nTSem",  "-"+mcjzb,binning,"JZB [GeV]","events",sidebandcut&&cutOSOF&&cutnJets,mc,simulatedlumi,allsamples.FindSample("/TT"));
    TSeemm  = allsamples.Draw("TSeemm",     mcjzb,binning,"JZB [GeV]","events",sidebandcut&&cutOSSF&&cutnJets,mc,simulatedlumi,allsamples.FindSample("/TT"));
    nTSeemm = allsamples.Draw("nTSeemm","-"+mcjzb,binning,"JZB [GeV]","events",sidebandcut&&cutOSSF&&cutnJets,mc,simulatedlumi,allsamples.FindSample("/TT"));
  }

  TCanvas *tcan = new TCanvas("tcan","tcan");
  tcan->SetLogy(1);
  
  TZeemm->SetLineColor(kBlack);
  TZem->SetLineColor(kRed);
  TZeemm->SetMarkerColor(kBlack);
  TZem->SetMarkerColor(kRed);


  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
        TSem->SetLineColor(TColor::GetColor("#00A616"));
        TSeemm->SetLineColor(kMagenta+2);
        TSem->SetMarkerColor(TColor::GetColor("#00A616"));
        TSeemm->SetMarkerColor(kMagenta+2);
        TSem->SetLineStyle(2);
        TSeemm->SetLineStyle(3);
  }
  
  vector<TH1F*> histos;
  TZem->GetXaxis()->SetRangeUser(-100,binning[binning.size()-1]);
  TZeemm->GetXaxis()->SetRangeUser(-100,binning[binning.size()-1]);
  histos.push_back(TZem);
  histos.push_back(TZeemm);
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
    TSeemm->GetXaxis()->SetRangeUser(-100,binning[binning.size()-1]);
    TSem->GetXaxis()->SetRangeUser(-100,binning[binning.size()-1]);
    histos.push_back(TSem);
    histos.push_back(TSeemm);
  }
  draw_all_ttbar_histos(tcan,histos,"histo",8);
  
  TLegend *leg = make_legend("MC t#bar{t}",0.6,0.65,false);
  leg->AddEntry(TZeemm,"SFZP","l");
  leg->AddEntry(TZem,"OFZP","l");
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
    leg->AddEntry(TSeemm,"SFSB","l");
    leg->AddEntry(TSem,"OFSB","l");
  }
  leg->Draw("same");
  DrawMCPrelim(simulatedlumi);
  CompleteSave(tcan,"Systematics/"+prestring+"/ttbar_shape_comparison");
  
  TH1F *TZemcopy = (TH1F*)TZem->Clone("TZemcopy");
  TH1F *TZeemmcopy = (TH1F*)TZeemm->Clone("TZeemmcopy");
  TH1F *TSeemmcopy;
  TH1F *TSemcopy;
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
    TSeemmcopy = (TH1F*)TSeemm->Clone("TSeemmcopy");
    TSemcopy = (TH1F*)TSem->Clone("TSemcopy");
  }

  TZem->Divide(TZeemm);
  TZem->SetMarkerStyle(21);
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
    TSem->Divide(TZeemm);
    TSeemm->Divide(TZeemm);
    TSem->SetMarkerStyle(24);
    TSeemm->SetMarkerStyle(32);
  }

  tcan->SetLogy(0);
  TZem->GetYaxis()->SetRangeUser(0,2.5);
  TZem->GetYaxis()->SetTitle("ratio");
  TZem->Draw();
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
    TSem->Draw("same");
    TSeemm->Draw("same");
  }
  
  float linepos=emuncertONPEAK;
  if(!PlottingSetup::RestrictToMassPeak) linepos=emuncertOFFPEAK;
  
  TLine *top = new TLine(binning[0],1.0+linepos,binning[binning.size()-1],1.0+linepos);
  TLine *center = new TLine(binning[0],1.0,binning[binning.size()-1],1.0);
  TLine *bottom = new TLine(binning[0],1.0-linepos,binning[binning.size()-1],1.0-linepos);
  
  /*write_warning(__FUNCTION__,"These two lines are to be removed!");
  TLine *topalt = new TLine(binning[0],1.0+0.1,binning[binning.size()-1],1.0+0.1);
  TLine *bottomalt = new TLine(binning[0],1.0-0.1,binning[binning.size()-1],1.0-0.1);
  topalt->SetLineColor(kRed);topalt->SetLineStyle(3);
  bottomalt->SetLineColor(kRed);bottomalt->SetLineStyle(3);
  topalt->Draw("same");bottomalt->Draw("same");*/
  
  
  top->SetLineColor(kBlue);top->SetLineStyle(2);
  bottom->SetLineColor(kBlue);bottom->SetLineStyle(2);
  center->SetLineColor(kBlue);
  
  top->Draw("same");
  center->Draw("same");
  bottom->Draw("same");
  
  TLegend *leg2 = make_legend("MC t#bar{t}",0.55,0.75,false);
  leg2->AddEntry(TZem,"OFZP / SFZP","ple");
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
    leg2->AddEntry(TSeemm,"SFSB / SFZP","ple");
    leg2->AddEntry(TSem,"OFSB / SFZP","ple");
  }
  leg2->AddEntry(bottom,"syst. envelope","l");
  leg2->SetX1(0.25);leg2->SetX2(0.6);
  leg2->SetY1(0.65);
  
  leg2->Draw("same");
  
  DrawMCPrelim(simulatedlumi);
  CompleteSave(tcan,"Systematics/"+prestring+"/ttbar_shape_comparison_ratio");
  
  
  if (0) { // Turn this off: we don't need this

    ///-------------- second part: only look at the quantity we actually care about!
    TH1F *leftsfzp  = (TH1F*)nTZeemm->Clone("leftsfzp");
    TH1F *rightsfzp = (TH1F*)TZeemmcopy->Clone("rightsfzp");
    rightsfzp->Add(leftsfzp,-1);
    TH1F *leftofzp  = (TH1F*)nTZem->Clone("leftofzp");
    TH1F *rightofzp = (TH1F*)TZemcopy->Clone("rightofzp");
    rightofzp->Add(leftofzp,-1);
    TH1F *leftofsb;
    TH1F *rightofsb;
    TH1F *leftsfsb;
    TH1F *rightsfsb;
    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
      leftofsb  = (TH1F*)nTSem->Clone("leftofsb");
      rightofsb = (TH1F*)TSemcopy->Clone("rightofsb");
      rightofsb->Add(leftofsb,-1);
      leftsfsb  = (TH1F*)nTSeemm->Clone("leftsfsb");
      rightsfsb = (TH1F*)TSeemmcopy->Clone("rightsfsb");
      rightsfsb->Add(leftsfsb,-1);
    }

    tcan->SetLogy(1);
    rightsfzp->GetXaxis()->SetRangeUser(0,binning[binning.size()-1]);
    rightsfzp->GetYaxis()->SetTitle("#deltaJZB / 25 GeV");
    rightsfzp->Draw("histo");
    rightofzp->Draw("histo,same");
    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
      rightofsb->Draw("histo,same");
      rightsfsb->Draw("histo,same");
    }
    DrawMCPrelim(simulatedlumi);

    TLegend *legA = make_legend("MC t#bar{t}",0.6,0.65,false);
    legA->AddEntry(rightsfzp,"SFZP","l");
    legA->AddEntry(rightofzp,"OFZP","l");
    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
      legA->AddEntry(rightofsb,"SFSB","l");
      legA->AddEntry(rightsfsb,"OFSB","l");
    }
    legA->Draw();

    CompleteSave(tcan,"Systematics/"+prestring+"/ttbar_deltajzb_comparison");

    tcan->SetLogy(0);
    rightofzp->Divide(rightsfzp);
    rightofzp->GetXaxis()->SetRangeUser(0.0,binning[binning.size()-1]);
    rightofzp->GetYaxis()->SetRangeUser(0.0,2.5);
    rightofzp->GetYaxis()->SetTitle("#deltaJZB ratio");
    rightofzp->Draw();
    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
      rightofsb->Divide(rightsfzp);
      rightsfsb->Divide(rightsfzp);
      rightofsb->Draw("same");
      rightsfsb->Draw("same");
    }

    TLine *top2 = new TLine(0.0,1.0+linepos,binning[binning.size()-1],1.0+linepos);
    TLine *center2 = new TLine(0.0,1.0,binning[binning.size()-1],1.0);
    TLine *bottom2 = new TLine(0.0,1.0-linepos,binning[binning.size()-1],1.0-linepos);
  
    top2->SetLineColor(kBlue);top2->SetLineStyle(2);
    bottom2->SetLineColor(kBlue);bottom2->SetLineStyle(2);
    center2->SetLineColor(kBlue);
  
    top2->Draw("same");
    center2->Draw("same");
    bottom2->Draw("same");

    rightofzp->SetMarkerStyle(21);
    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
      rightofsb->SetMarkerStyle(24);
      rightsfsb->SetMarkerStyle(32);
    }

    TLegend *leg3 = make_legend("MC t#bar{t}",0.55,0.75,false);
    leg3->AddEntry(rightofzp,"OFZP / SFZP","ple");
    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
      leg3->AddEntry(rightsfsb,"SFSB / SFZP","ple");
      leg3->AddEntry(rightofsb,"OFSB / SFZP","ple");
    }
    leg3->AddEntry(bottom,"syst. envelope","l");
    leg3->SetX1(0.25);leg3->SetX2(0.6);
    leg3->SetY1(0.65);
  
    leg3->Draw("same");
  
    DrawMCPrelim(simulatedlumi);
    CompleteSave(tcan,"Systematics/"+prestring+"/ttbar_deltajzb_comparison_ratio");

  }

  delete TZem;
  delete nTZem;
  delete TZeemm;
  delete nTZeemm;
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
        delete TSem;
        delete nTSem;
        delete TSeemm;
        delete nTSeemm;
  }

  delete tcan;
  cutWeight=weightbackup;
  switch_overunderflow(false);
}

void ttbar_sidebands_comparison(string mcjzb, vector<float> jzb_binning) {
  vector<float> nicer_binning;
  
/*  nicer_binning.push_back(-400);
  nicer_binning.push_back(-250);
  nicer_binning.push_back(-200);
  nicer_binning.push_back(-150);
  nicer_binning.push_back(-100);
  nicer_binning.push_back(-50);
  nicer_binning.push_back(-20);
  
  nicer_binning.push_back(0);
  nicer_binning.push_back(20);
  nicer_binning.push_back(50);
  nicer_binning.push_back(100);
  nicer_binning.push_back(150);
  nicer_binning.push_back(200);
  nicer_binning.push_back(250);
  nicer_binning.push_back(400);*/
  
  nicer_binning.push_back(-100);
  nicer_binning.push_back(-50);
  nicer_binning.push_back(-25);
  nicer_binning.push_back(0);
  nicer_binning.push_back(25);
  nicer_binning.push_back(50);
  nicer_binning.push_back(75);
  nicer_binning.push_back(100);
  nicer_binning.push_back(125);
  nicer_binning.push_back(150);
  //nicer_binning.push_back(175);
  nicer_binning.push_back(200);
//  nicer_binning.push_back(250);
//  nicer_binning.push_back(300);
//  nicer_binning.push_back(400);
  
  ttbar_sidebands_comparison(mcjzb,nicer_binning, "ttbar/");
}


void zjets_prediction_comparison(string mcjzbWithPUa, TCut massregioncut, string massregionname) {
  cout << "****************************************************************************************************************************************************************" << endl;
  TCanvas *zcan = new TCanvas("zcan","zcan");  
//  zcan->SetLogy(1);
  TCut weightbackup=cutWeight;
  
  bool UsePURW=true;
  
  
  string mcjzb;
  if(UsePURW) {
    mcjzb=mcjzbWithPUa;
    cout << "Using PURW peak positions" << endl;
  } else {
    // Do it without PU re-weighting
    cutWeight="1.0";
    float MCPeakNoPU=0,MCPeakErrorNoPU=0,DataPeakNoPU=0,DataPeakErrorNoPU=0,MCSigma=0,DataSigma=0;
    stringstream resultsNoPU;
    stringstream noPUdatajzb;
    stringstream noPUmcjzb;
    
    find_peaks(MCPeakNoPU,MCPeakErrorNoPU, DataPeakNoPU, DataPeakErrorNoPU,resultsNoPU,false,noPUdatajzb,noPUmcjzb);
    dout << "The peak corrected JZB expression for MC without pileup is : " <<  noPUmcjzb.str() << endl;
    
    mcjzb = noPUmcjzb.str();
    
  }

  
  vector<float> binning;
  binning.push_back(0);
  binning.push_back(10);
  binning.push_back(20);
  binning.push_back(40);
  binning.push_back(60);
//   binning.push_back(50);
//   binning.push_back(60);
//   binning.push_back(70);
//   binning.push_back(80);
//   binning.push_back(90);
  binning.push_back(100);

  float simulatedlumi = luminosity;//in pb please - adjust to your likings
  
  TCut kPos((mcjzb+">0").c_str());
  TCut kNeg((mcjzb+"<0").c_str());
  string var( "abs("+mcjzb+")" );
  
  TCut notTau("abs(genMID1)!=15");
  TCut ee_mm_tautau("mll>0");
  

  TH1F *hJZBpos = systsamples.Draw("hJZBpos",var,binning, "JZB [GeV]", "events",cutmass&&cutOSSF&&cutnJets&&notTau&&kPos&&massregioncut,mc,simulatedlumi,systsamples.FindSample("/DY"));
  TH1F *hJZBneg = systsamples.Draw("hJZBneg",var,binning, "JZB [GeV]", "events",cutmass&&cutOSSF&&cutnJets&&notTau&&kNeg&&massregioncut,mc,simulatedlumi,systsamples.FindSample("/DY"));
  
  hJZBpos->SetLineColor(kBlack);
  hJZBneg->SetLineColor(kRed);
  
  hJZBpos->SetMinimum(1.0);
  hJZBpos->Draw("e1");
  hJZBneg->Draw("same,hist");
  hJZBpos->Draw("same,e1"); // So it's on top...
  
  TLegend *leg = make_legend("MC Z+jets #rightarrow ee,#mu#mu",0.55,0.75,false);
  leg->AddEntry(hJZBpos,"Observed","pe");
  leg->AddEntry(hJZBneg,"Predicted","l");
  leg->Draw("same");
  DrawMCPrelim(simulatedlumi);
  CompleteSave(zcan,"Systematics/ZJets/zjets_eemm_prediction"+any2string(massregionname));
  
  TH1F* hratio = (TH1F*)hJZBpos->Clone("hratio");
  hratio->Divide(hJZBneg);
  
  for(int i=1;i<=hJZBpos->GetNbinsX();i++) {
    cout << "Positive: " << hJZBpos->GetBinContent(i) << "   vs    Negative : " << hJZBneg->GetBinContent(i) << "   (ratio : " << hJZBpos->GetBinContent(i) / hJZBneg->GetBinContent(i) << endl;
  }
  
//  zcan->SetLogy(0);
  hratio->GetYaxis()->SetRangeUser(0,2.5);
  hratio->GetYaxis()->SetTitle("Observed/Predicted");
  hratio->Draw("e1");
  
  TLine *top = new TLine(binning[0],1.25,binning[binning.size()-1],1.25);
  TLine *center = new TLine(binning[0],1.0,binning[binning.size()-1],1.0);
  TLine *bottom = new TLine(binning[0],0.75,binning[binning.size()-1],0.75);
  

  top->SetLineColor(kBlue);top->SetLineStyle(2);
  bottom->SetLineColor(kBlue);bottom->SetLineStyle(2);
  center->SetLineColor(kBlue);
  
  top->Draw("same");
  center->Draw("same");
  bottom->Draw("same");
  
  TLegend *leg2 = make_legend("MC Z+jets #rightarrow ee,#mu#mu",0.25,0.75,false);
  leg2->AddEntry(hratio,"obs / pred","pe");
  leg2->AddEntry(bottom,"syst. envelope","l");
  leg2->Draw("same");
  DrawMCPrelim(simulatedlumi);
  CompleteSave(zcan,"Systematics/ZJets/zjets_eemm_prediction_ratio"+any2string(massregionname));
  
  TCut reducedNJets(cutnJets);
  
  TH1F *TAUhJZBpos       = systsamples.Draw("TAUhJZBpos",var,binning, "JZB [GeV]", "events",cutmass&&cutOSSF&&reducedNJets&&ee_mm_tautau&&kPos&&massregioncut,mc,simulatedlumi,systsamples.FindSample("/DY"));
  TH1F *LcorrJZBeemm     = systsamples.Draw("LcorrJZBeemm",var,binning, "JZB [GeV]", "events",cutmass&&cutOSSF&&reducedNJets&&ee_mm_tautau&&kNeg&&massregioncut,mc,simulatedlumi,systsamples.FindSample("/DY"));
  TH1F *RcorrJZBem       = systsamples.Draw("RcorrJZBem",var,binning, "JZB [GeV]", "events",cutmass&&cutOSOF&&reducedNJets&&ee_mm_tautau&&kPos&&massregioncut,mc,simulatedlumi,systsamples.FindSample("/DY"));
  TH1F *LcorrJZBem       = systsamples.Draw("LcorrJZBem",var,binning, "JZB [GeV]", "events",cutmass&&cutOSOF&&reducedNJets&&ee_mm_tautau&&kNeg&&massregioncut,mc,simulatedlumi,systsamples.FindSample("/DY"));

  TH1F *RcorrJZBSBem;
  TH1F *LcorrJZBSBem;
  TH1F *RcorrJZBSBeemm;
  TH1F *LcorrJZBSBeemm;

  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
    RcorrJZBSBem   = systsamples.Draw("RcorrJZBSBem",var,binning, "JZB [GeV]", "events",sidebandcut&&cutOSOF&&reducedNJets&&ee_mm_tautau&&kPos&&massregioncut,mc,simulatedlumi,systsamples.FindSample("/DY"));
    LcorrJZBSBem   = systsamples.Draw("LcorrJZBSBem",var,binning, "JZB [GeV]", "events",sidebandcut&&cutOSOF&&reducedNJets&&ee_mm_tautau&&kNeg&&massregioncut,mc,simulatedlumi,systsamples.FindSample("/DY"));
    RcorrJZBSBeemm = systsamples.Draw("RcorrJZBSBeemm",var,binning, "JZB [GeV]", "events",sidebandcut&&cutOSSF&&reducedNJets&&ee_mm_tautau&&kPos&&massregioncut,mc,simulatedlumi,systsamples.FindSample("/DY"));
    LcorrJZBSBeemm = systsamples.Draw("LcorrJZBSBeemm",var,binning, "JZB [GeV]", "events",sidebandcut&&cutOSSF&&reducedNJets&&ee_mm_tautau&&kNeg&&massregioncut,mc,simulatedlumi,systsamples.FindSample("/DY"));
  }
  
  TH1F *Bpred = (TH1F*)LcorrJZBeemm->Clone("Bpred");
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
    Bpred->Add(RcorrJZBem,1.0/3.);
    Bpred->Add(LcorrJZBem,-1.0/3.);
    Bpred->Add(RcorrJZBSBem,1.0/3.);
    Bpred->Add(LcorrJZBSBem,-1.0/3.);
    Bpred->Add(RcorrJZBSBeemm,1.0/3.);
    Bpred->Add(LcorrJZBSBeemm,-1.0/3.);
  } else {
    Bpred->Add(RcorrJZBem,1.0);
    Bpred->Add(LcorrJZBem,-1.0);
  }
  
  Bpred->SetLineColor(kRed);

  TAUhJZBpos->SetLineColor(kBlack);
  Bpred->SetLineColor(kRed);
  
  TAUhJZBpos->SetMinimum(1.0);
  TAUhJZBpos->Draw("e1");
  Bpred->Draw("same,hist");
  TAUhJZBpos->Draw("same,e1");
  
  TLegend *TAUleg = make_legend("MC Z+jets #rightarrow ee,#mu#mu,#tau#tau",0.55,0.75,false);
  TAUleg->AddEntry(TAUhJZBpos,"Observed","pe");
  TAUleg->AddEntry(Bpred,"Predicted","l");
  TAUleg->Draw("same");
  DrawMCPrelim(simulatedlumi);
  CompleteSave(zcan,"Systematics/ZJets/zjets_eemumutautau_prediction__"+any2string(massregionname));
  
  TH1F* TAUhratio = (TH1F*)TAUhJZBpos->Clone("TAUhratio");
  TAUhratio->Divide(Bpred);
  
  for(int i=1;i<=TAUhJZBpos->GetNbinsX();i++) {
    cout << "ee/mm/tautau observed: " << TAUhJZBpos->GetBinContent(i) << "   vs    predicted : " << Bpred->GetBinContent(i) << "   (ratio : " << TAUhJZBpos->GetBinContent(i) / Bpred->GetBinContent(i) << endl;
  }
  
  zcan->SetLogy(0);
  TAUhratio->GetYaxis()->SetRangeUser(0,2.5);
  TAUhratio->GetYaxis()->SetTitle("Observed/Predicted");
  TAUhratio->Draw("e1");
  
  top->Draw("same");
  center->Draw("same");
  bottom->Draw("same");
  
  TLegend *TAUleg2 = make_legend("MC Z+jets #rightarrow ee,#mu#mu",0.25,0.75,false);
  TAUleg2->AddEntry(TAUhratio,"obs / pred","pe");
  TAUleg2->AddEntry(bottom,"syst. envelope","l");
  TAUleg2->Draw("same");
  DrawMCPrelim(simulatedlumi);
  CompleteSave(zcan,"Systematics/ZJets/zjets_eemumutautau_prediction_ratio"+any2string(massregionname));
  
  delete Bpred;
  delete TAUhJZBpos;
  delete LcorrJZBeemm;
  delete RcorrJZBem;
  delete LcorrJZBem;
  delete hJZBpos;
  delete hJZBneg;
  
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
    delete RcorrJZBSBem;
    delete LcorrJZBSBem;
    delete RcorrJZBSBeemm;
    delete LcorrJZBSBeemm;
  }
  
  
  delete zcan;
  cutWeight=weightbackup;
}


void zjets_prediction_comparison(string mcjzbWithPUa) {
  zjets_prediction_comparison(mcjzbWithPUa, TCut(""), "nomasscut");
  zjets_prediction_comparison(mcjzbWithPUa, TCut("abs(mll-91)<20"), "Zwindow_20");
  zjets_prediction_comparison(mcjzbWithPUa, TCut("mll>20&&mll<70"), "LowMassRegion2070");
  zjets_prediction_comparison(mcjzbWithPUa, TCut("mll>110"), "HighMassRegion110");
}
  
void sideband_assessment(string datajzb, float min=30.0, float max=50.0) {
  tout << endl << endl;
  stringstream bordercut;
  bordercut << "(TMath::Abs(" << datajzb << ")<" << max << ")&&(TMath::Abs(" << datajzb << ")>" << min << ")";
  tout << bordercut.str().c_str() << endl;
  TH1F *ofsb    = allsamples.Draw("ofsb",datajzb,100, 0,100, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets&&bordercut.str().c_str(),data, luminosity);
  TH1F *ofzp    = allsamples.Draw("ofzp",datajzb,100, 0,100, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&bordercut.str().c_str(),data, luminosity);
  float OFSB = ofsb->Integral();
  float OFZP = ofzp->Integral();

  tout << "\\begin{table}[hbtp]" << endl;
  tout << "\\renewcommand{\\arraystretch}{1.3}" << endl;
  tout << "\\begin{center}" << endl;
  tout << "\\caption{Total number of events observed in the auxiliary region  $|JZB|>"<<min<<"\\GeV \\cup |JZB|<"<<max<<"\\GeV$ for the {\\OFZP} and {\\OFSB}.}\\label{tab:auxcounts}" << endl;
  tout << "\\begin{tabular}{l|cc}" << endl;
  tout << "\\hline" << endl;
  tout << "& {\\OFZP} & {\\OFSB} \\\\\\hline" << endl;
  tout << "\\#(events) & "<<OFZP<<" & "<<OFSB<<"\\\\ \\hline" << endl;
  tout << "\\end{tabular}" << endl;
  tout << "\\end{center}" << endl;
  tout << "\\end{table}" << endl;


}

void make_table(samplecollection &coll, string jzbexpr, bool is_data, vector<float> jzb_cuts, string subselection="none") {
  
  vector<float> jzbcutprediction;
  vector<float> metcutprediction;

  vector<float> jzbcutobservation;
  vector<float> metcutobservation;
  
  TCanvas *cannie = new TCanvas("cannie","cannie");
  
  for(int icut=0;icut<(int)jzb_cuts.size();icut++) {
    float currcut=jzb_cuts[icut];
    int nbins=1;float low=currcut;
    vector<int> mysample;
    if(subselection!="none") mysample=coll.FindSample(subselection);
    TH1F *RcorrJZBeemm   = coll.Draw("RcorrJZBeemm",jzbexpr,1,currcut,14000, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,is_data, luminosity, mysample);
    TH1F *LcorrJZBeemm   = coll.Draw("LcorrJZBeemm",("-("+jzbexpr+")").c_str(),nbins,low,14000, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,is_data, luminosity, mysample);
    TH1F *RcorrJZBem     = coll.Draw("RcorrJZBem",jzbexpr.c_str(),nbins,low,14000, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,is_data, luminosity, mysample);
    TH1F *LcorrJZBem     = coll.Draw("LcorrJZBem",("-("+jzbexpr+")").c_str(),nbins,low,14000, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,is_data, luminosity, mysample);
    
    TH1F *RcorrJZBSBem;
    TH1F *LcorrJZBSBem;
    TH1F *RcorrJZBSBeemm;
    TH1F *LcorrJZBSBeemm;
    
    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
      RcorrJZBSBem   = coll.Draw("RcorrJZBSBem",jzbexpr.c_str(),nbins,low,14000, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity, mysample);
      LcorrJZBSBem   = coll.Draw("LcorrJZBSBem",("-("+jzbexpr+")").c_str(),nbins,low,14000, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity, mysample);
      RcorrJZBSBeemm = coll.Draw("RcorrJZBSBeemm",jzbexpr.c_str(),nbins,low,14000, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity, mysample);
      LcorrJZBSBeemm = coll.Draw("LcorrJZBSBeemm",("-("+jzbexpr+")").c_str(),nbins,low,14000, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity, mysample);
    }
    
    TH1F *Bpred = (TH1F*)LcorrJZBeemm->Clone("Bpred");
    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
      Bpred->Add(RcorrJZBem,1.0/3.);
      Bpred->Add(LcorrJZBem,-1.0/3.);
      Bpred->Add(RcorrJZBSBem,1.0/3.);
      Bpred->Add(LcorrJZBSBem,-1.0/3.);
      Bpred->Add(RcorrJZBSBeemm,1.0/3.);
      Bpred->Add(LcorrJZBSBeemm,-1.0/3.);
    } else {
      Bpred->Add(RcorrJZBem,1.0);
      Bpred->Add(LcorrJZBem,-1.0);
    }
    
    jzbcutobservation.push_back(RcorrJZBeemm->Integral());
    jzbcutprediction.push_back(Bpred->Integral());
    
    delete RcorrJZBeemm;
    delete LcorrJZBeemm;
    delete RcorrJZBem;
    delete LcorrJZBem;
    delete RcorrJZBSBem;
    delete LcorrJZBSBem;
    delete RcorrJZBSBeemm;
    delete LcorrJZBSBeemm;
    
    TH1F *MetObs         = coll.Draw("MetObs",("met[4]"),nbins,low,14000, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,is_data, luminosity, mysample);
    TH1F *MetPred        = coll.Draw("MetPred",("met[4]"),nbins,low,14000, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,is_data, luminosity, mysample);
    
    metcutobservation.push_back(MetObs->Integral());
    metcutprediction.push_back(MetPred->Integral());
    delete MetObs;
    delete MetPred;
  }//end of cut loop
    
  //prediction part
  if(is_data) cout << "Data prediction & ";
  if(subselection!="none") cout << subselection << " prediction &";
  for(int ij=0;ij<(int)jzb_cuts.size();ij++) cout << jzbcutprediction[ij] << " vs " << metcutprediction[ij] << " & ";
  
  cout << endl;
  //observation part
  if(is_data) cout << "Data observation & ";
  if(subselection!="none") cout << subselection << " observation &";
  for(int ij=0;ij<(int)jzb_cuts.size();ij++) cout << jzbcutobservation[ij] << " vs " << metcutobservation[ij] << " & ";
  cout << endl;
  cout << "_________________________________________________________________" << endl;
  delete cannie;
}

void met_jzb_cut(string datajzb, string mcjzb, vector<float> jzb_cut) {
  cout << "You probably don't want --met, you want --metplots ... " << endl;
  assert(0);
  /*we want a table like this: 
    __________________     50   |   100  | ...
    | Data prediction |  a vs b | a vs b | ...
    | Data observed   |  a vs b | a vs b | ...
    --------------------------------------
    --------------------------------------
    | LM4 prediction  |  a vs b | a vs b | ...
    | LM4 observed    |  a vs b | a vs b | ...
    | LM8 prediction  |  a vs b | a vs b | ...
    | LM8 observed    |  a vs b | a vs b | ...
    
    where a is the result for a jzb cut at X, and b is the result for a met cut at X
*/
  make_table(allsamples,datajzb, true,jzb_cut,"none");
  make_table(signalsamples,mcjzb, false,jzb_cut,"LM4");
  make_table(signalsamples,mcjzb, false,jzb_cut,"LM8");
}
  

//________________________________________________________________________________________
// JZB Efficiency plot (efficiency of passing reco. JZB cut as function of generator JZB cut)
void JZBSelEff(string mcjzb, TTree* events, string informalname, vector<float> jzb_bins) {

  float min = 0, max = 400;
  float xbins[] = {min,10,20,30,40,50,60,70,80,90,100,110,120,140,150,160,170,180,190,200,210,220,250,300,max,max+100};
  int nbins = sizeof(xbins)/sizeof(float)-1;
  int markers[] = { 20, 26, 21, 24, 22, 25, 28 };

  
  TH1F* heff  = new TH1F("heff", "JZB eff ; generator JZB [GeV]; efficiency",nbins,xbins);
  TH1F* hgen  = new TH1F("hgen", "JZB gen ; generator JZB [GeV]; efficiency",nbins,xbins);
  TH1F* hreco = new TH1F("hreco","JZB reco ; generator JZB [GeV]; efficiency",nbins,xbins);

  TCut kgen(genMassCut&&"genZPt>0&&genNjets>2&&abs(genMID)==23"&&cutOSSF);
  TCut kreco(cutmass);

  TF1* func = new TF1("func","0.5*[2]*(TMath::Erf((x-[1])/[0])+1)",min,max);
  func->SetParNames("epsilon","x_{1/2}","sigma");
  func->SetParameter(0,50.);
  func->SetParameter(1,0.);
  func->SetParameter(2,1.);
  gStyle->SetOptStat(0);
  gStyle->SetOptFit(0);

  TCanvas *can = new TCanvas("can","Canvas for JZB Efficiency",600,600);
  can->SetGridx(1);
  can->SetGridy(1);
  can->SetLeftMargin(0.16);
  can->SetRightMargin(0.05);
  TLegend *leg = make_legend("",0.6,0.2,false,0.89,0.5);
  leg->SetBorderSize(1);
  leg->SetLineColor(kBlack);
  leg->SetTextFont(62);

  for ( int icut=0; icut<(int)jzb_bins.size(); ++icut ) {

    ostringstream selection;
    selection << mcjzb << ">" << jzb_bins[icut];
    TCut ksel(selection.str().c_str());
    events->Draw("genJZB>>hgen", kgen&&kreco,      "goff");
    events->Draw("genJZB>>hreco",kgen&&kreco&&ksel,"goff");

    // Loop over steps to get efficiency curve
    for ( Int_t iBin = 0; iBin<nbins-1; ++iBin ) {
      Float_t eff = hreco->GetBinContent(iBin+1)/hgen->GetBinContent(iBin+1);
      heff->SetBinContent(iBin+1,eff);
      heff->SetBinError(iBin+1,TMath::Sqrt(eff*(1-eff)/hgen->GetBinContent(iBin+1)));
    }
  
    heff->GetXaxis()->SetRangeUser(min, max);
//    heff->GetXaxis()->SetLabelSize(0.05); // paper style. overruled.
//    heff->GetYaxis()->SetLabelSize(0.05); // paper style. overruled.
//    heff->GetXaxis()->SetTitleSize(0.06); // paper style. overruled.
//    heff->GetYaxis()->SetTitleSize(0.06); // paper style. overruled.
    heff->SetMarkerStyle(markers[icut]);
    heff->Fit("func","Q+","same");

    // Print values
    dout << "+++ For " << selection.str() << std::endl;
    for ( int i=0; i<func->GetNpar(); ++i )
      dout << "   " << func->GetParName(i) << " " << func->GetParameter(i) << " \\pm " << func->GetParError(i) << std::endl;
    char hname[256]; sprintf(hname,"heff%d",icut);

    // Store plot
    TH1F* h = (TH1F*)heff->Clone(hname);
    h->SetNdivisions(505,"X");
    if ( icut) h->Draw("same");
    else h->Draw();
    char htitle[256]; sprintf(htitle,"JZB > %3.0f GeV", jzb_bins[icut]);
    leg->AddEntry(h,htitle,"p");

  }

  leg->Draw();
  DrawMCPrelim(0.0);
  CompleteSave(can, "Systematics/jzb_efficiency_curve"+informalname );

  delete hgen;
  delete hreco;
  delete heff;
}

//________________________________________________________________________________________
// Calls the above function for each signal sample
void plot_jzb_sel_eff(string mcjzb, samplecollection &signalsamples, vector<float> bins ) 
{  
  for (int isignal=0; isignal<(int)signalsamples.collection.size();isignal++) {
    dout << "JZB selection efficiency curve: " << std::endl;
    JZBSelEff(mcjzb,(signalsamples.collection)[isignal].events,(signalsamples.collection)[isignal].samplename,bins); // Only for some selected samples
  }
}

void qcd_plots(string datajzb, string mcjzb, vector<float> bins) {
  // What this function aims to do: 
  // Illustrate cut flow for QCD (requiring only one lepton, requiring etc.)
  // Illustrate how little QCD is left over! i.e. make some pointless JZB plot with only QCD to visualize the fact that there's not much really.
  TCanvas *can = new TCanvas("can","can");
  TPad *kinpad = new TPad("kinpad","kinpad",0,0,1,1);
  kinpad->cd();
  
  string jzb=mcjzb;
  
  float hi=400;
  bool use_signal=false;
  bool use_data=false;
  
  bool is_data=false;
  int nbins=50;//100;
  float low=0;
  float high=500;
  int versok=false;
  if(gROOT->GetVersionInt()>=53000) versok=true;

  TH1F *blankback = new TH1F("blankback","blankback",int(high/10),0,high);
  TH1F *RcorrJZBeemm   = qcdsamples.Draw("RcorrJZBeemm",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
  TH1F *LcorrJZBeemm   = qcdsamples.Draw("LcorrJZBeemm",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
  TH1F *RcorrJZBem     = qcdsamples.Draw("RcorrJZBem",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
  TH1F *LcorrJZBem     = qcdsamples.Draw("LcorrJZBem",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
  blankback->GetXaxis()->SetTitle(RcorrJZBeemm->GetXaxis()->GetTitle());
  blankback->GetYaxis()->SetTitle(RcorrJZBeemm->GetYaxis()->GetTitle());
  blankback->GetXaxis()->CenterTitle();
  blankback->GetYaxis()->CenterTitle();
  
  flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak ---- prediction changed.
  TH1F *RcorrJZBSBem;
  TH1F *LcorrJZBSBem;
  TH1F *RcorrJZBSBeemm;
  TH1F *LcorrJZBSBeemm;
  
//  TH1F *RcorrJZBeemmNoS;

    //these are for the ratio
  TH1F *JRcorrJZBeemm   = qcdsamples.Draw("JRcorrJZBeemm",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
  TH1F *JLcorrJZBeemm   = qcdsamples.Draw("JLcorrJZBeemm",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutmass&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
  TH1F *JRcorrJZBem     = qcdsamples.Draw("JRcorrJZBem",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
  TH1F *JLcorrJZBem     = qcdsamples.Draw("JLcorrJZBem",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", cutmass&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
  
  TH1F *JRcorrJZBSBem;
  TH1F *JLcorrJZBSBem;
  TH1F *JRcorrJZBSBeemm;
  TH1F *JLcorrJZBSBeemm;
  
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
    RcorrJZBSBem   = qcdsamples.Draw("RcorrJZBSBem",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
    LcorrJZBSBem   = qcdsamples.Draw("LcorrJZBSBem",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
    RcorrJZBSBeemm = qcdsamples.Draw("RcorrJZBSBeemm",jzb.c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
    LcorrJZBSBeemm = qcdsamples.Draw("LcorrJZBSBeemm",("-"+jzb).c_str(),nbins,low,hi, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);

    //these are for the ratio
    JRcorrJZBSBem   = qcdsamples.Draw("JRcorrJZBSBem",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
    JLcorrJZBSBem   = qcdsamples.Draw("JLcorrJZBSBem",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", sidebandcut&&cutOSOF&&cutnJets,is_data, luminosity,use_signal);
    JRcorrJZBSBeemm = qcdsamples.Draw("JRcorrJZBSBeemm",jzb.c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);
    JLcorrJZBSBeemm = qcdsamples.Draw("JLcorrJZBSBeemm",("-"+jzb).c_str(),PlottingSetup::global_ratio_binning, "JZB [GeV]", "events", sidebandcut&&cutOSSF&&cutnJets,is_data, luminosity,use_signal);

  }
  
  flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak ---- prediction changed.
  
  TH1F *Zjetspred = (TH1F*)LcorrJZBeemm->Clone("Zjetspred");
  TH1F *TTbarpred = (TH1F*)RcorrJZBem->Clone("TTbarpred");
    
  TH1F *Bpred = (TH1F*)LcorrJZBeemm->Clone("Bpred");
  TH1F *JBpred = (TH1F*)JLcorrJZBeemm->Clone("Bpred");
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
    Bpred->Add(RcorrJZBem,1.0/3.);
    Bpred->Add(LcorrJZBem,-1.0/3.);
    Bpred->Add(RcorrJZBSBem,1.0/3.);
    Bpred->Add(LcorrJZBSBem,-1.0/3.);
    Bpred->Add(RcorrJZBSBeemm,1.0/3.);
    Bpred->Add(LcorrJZBSBeemm,-1.0/3.);
    
    TTbarpred->Scale(1.0/3);
    Zjetspred->Add(LcorrJZBem,-1.0/3.);
    Zjetspred->Add(LcorrJZBSBem,-1.0/3.);
    TTbarpred->Add(RcorrJZBSBem,1.0/3.);
    Zjetspred->Add(LcorrJZBSBeemm,-1.0/3.);
    TTbarpred->Add(RcorrJZBSBeemm,1.0/3.);
    
    //these are for the ratio
    JBpred->Add(JRcorrJZBem,1.0/3.);
    JBpred->Add(JLcorrJZBem,-1.0/3.);
    JBpred->Add(JRcorrJZBSBem,1.0/3.);
    JBpred->Add(JLcorrJZBSBem,-1.0/3.);
    JBpred->Add(JRcorrJZBSBeemm,1.0/3.);
    JBpred->Add(JLcorrJZBSBeemm,-1.0/3.);
  } else {
    Bpred->Add(RcorrJZBem,1.0);
    Bpred->Add(LcorrJZBem,-1.0);
    
    Zjetspred->Add(LcorrJZBem,-1.0);
    
    //these are for the ratio
    JBpred->Add(JRcorrJZBem,1.0);
    JBpred->Add(JLcorrJZBem,-1.0);
  }
    
  
  flag_this_change(__FUNCTION__,__LINE__,true);//PlottingSetup::RestrictToMassPeak ---- prediction changed
  
  TLegend *legBpred = make_legend("",0.6,0.55,false);
  RcorrJZBeemm->Draw("e1x0,same");
  Bpred->Draw("hist,same");
  RcorrJZBeemm->Draw("e1x0,same");//HAVE IT ON TOP!
  legBpred->AddEntry(RcorrJZBeemm,"MC observed","p");
  legBpred->AddEntry(Bpred,"MC predicted","l");
  if(versok) legBpred->AddEntry((TObject*)0,"",""); // Just for alignment // causes seg fault on root v5.18
  if(versok) legBpred->AddEntry((TObject*)0,"",""); // causes seg fault on root v5.18
  legBpred->Draw();
  DrawMCPrelim();

  //3rd last argument: do special bpred ratio, 2nd last argument: extended range!, last: y-axis title
  string ytitle("ratio");
  if ( use_data==1 ) ytitle = "data/pred";
  Save_With_Ratio(JRcorrJZBeemm,JBpred,kinpad,"QCD/Bpred",true,false,ytitle); 
  delete kinpad;
  
  TH1F *allevents = qcdsamples.Draw("allevents","pfJetGoodNum",1,0,100, "internal code", "events", "" ,mc, luminosity);
  TH1F *ossf = qcdsamples.Draw("ossf","pfJetGoodNum",1,0,100, "internal code", "events", cutOSSF ,mc, luminosity);
  TH1F *osof = qcdsamples.Draw("osof","pfJetGoodNum",1,0,100, "internal code", "events", cutOSOF ,mc, luminosity);
  TH1F *njossf = qcdsamples.Draw("njossf","pfJetGoodNum",1,0,100, "internal code", "events", cutnJets&&cutOSSF ,mc, luminosity);
  TH1F *njosof = qcdsamples.Draw("njosof","pfJetGoodNum",1,0,100, "internal code", "events", cutnJets&&cutOSOF ,mc, luminosity);
  
  dout << "______________________________________________" << endl;
  dout << "QCD contribution: " << endl;
  dout << "Total number of events: " << allevents->Integral() << endl;
  dout << "OSSF events: " << ossf->Integral() << endl;
  dout << "OSOF events: " << osof->Integral() << endl;
  dout << "OSSF events with >=3 jets:" << njossf->Integral() << endl;
  dout << "OSOF events with >=3 jets:" << njosof->Integral() << endl;
  dout << "(note that no mass requirement has been imposed)" << endl;
  
  dout << "______________________________________________" << endl;
  dout << "How QCD shows up in the different regions: " << endl;
  dout << "OSSF: " << endl;
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
    dout << "     Z window: \t" << RcorrJZBeemm->Integral() << " (JZB>0) , " << LcorrJZBeemm->Integral() << " (JZB<0) --> total: " << RcorrJZBeemm->Integral() + LcorrJZBeemm->Integral() << endl;
    dout << "     sideband: \t" << RcorrJZBSBeemm->Integral() << " (JZB>0) , " << LcorrJZBSBeemm->Integral() << " (JZB<0) --> total: " << RcorrJZBSBeemm->Integral() + LcorrJZBSBeemm->Integral() << endl;
  } else {
    dout << "     " << RcorrJZBeemm->Integral() << " (JZB>0) , " << LcorrJZBeemm->Integral() << " (JZB<0) --> total: " << RcorrJZBeemm->Integral() + LcorrJZBeemm->Integral() << endl;
  }
  dout << "OSOF: " << endl;
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
    dout << "     Z window: \t" << RcorrJZBem->Integral() << " (JZB>0) , " << LcorrJZBem->Integral() << " (JZB<0) --> total: " << RcorrJZBem->Integral() + LcorrJZBem->Integral() << endl;
    dout << "     sideband: \t" << RcorrJZBSBem->Integral() << " (JZB>0) , " << LcorrJZBSBem->Integral() << " (JZB<0) --> total: " << RcorrJZBSBem->Integral() + LcorrJZBSBem->Integral() << endl;
  } else {
    dout << "     Z window: \t" << RcorrJZBem->Integral() << " (JZB>0) , " << LcorrJZBem->Integral() << " (JZB<0) --> total: " << RcorrJZBem->Integral() + LcorrJZBem->Integral() << endl;
  }
  dout << "Therefore: " << endl;
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
    dout << "    Prediction increases by : " << LcorrJZBeemm->Integral() << " + (1.0/3)*(" << RcorrJZBSBeemm->Integral() <<"-"<< LcorrJZBSBeemm->Integral() << ") (SFSB) ";
    dout << " + (1.0/3)*(" << RcorrJZBem->Integral() <<"-"<< LcorrJZBem->Integral() << ") (OFZP) ";
    dout << " + (1.0/3)*(" << RcorrJZBSBem->Integral() <<"-"<< LcorrJZBSBem->Integral() << ") (OFSB) ";
    dout << " = " << LcorrJZBeemm->Integral() + (1.0/3)*(RcorrJZBSBeemm->Integral() - LcorrJZBSBeemm->Integral() + RcorrJZBem->Integral() - LcorrJZBem->Integral() + RcorrJZBSBem->Integral() - LcorrJZBSBem->Integral()) << endl;
  } else {
    dout << "    Prediction increases by : " << LcorrJZBeemm->Integral();
    dout << " + (" << RcorrJZBem->Integral() <<"-"<< LcorrJZBem->Integral() << ") (OFZP) ";
    dout << " = " << LcorrJZBeemm->Integral() + RcorrJZBem->Integral() - LcorrJZBem->Integral() << endl;
  }
  dout << "    Observation increases by : " << RcorrJZBeemm->Integral() << endl;
  
  dout << endl;
  for(int i=0;i<(int)bins.size();i++) {
    dout << " JZB > " << bins[i] << " : " << endl;
    dout << "    Observation increases by : " << RcorrJZBeemm->Integral(RcorrJZBeemm->FindBin(bins[i]),RcorrJZBeemm->GetNbinsX()) << endl;
    if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB) {
        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;
    } else {
        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;
    }
  }
      
  delete can;
  delete allevents;
  if(ossf) delete ossf;
  if(RcorrJZBem) delete RcorrJZBem;
  if(LcorrJZBem) delete LcorrJZBem;
  if(RcorrJZBeemm) delete RcorrJZBeemm;
  if(LcorrJZBeemm) delete LcorrJZBeemm;
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB&&RcorrJZBSBem) delete RcorrJZBSBem;
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB&&LcorrJZBSBem) delete LcorrJZBSBem;
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB&&RcorrJZBSBeemm) delete RcorrJZBSBeemm;
  if(PlottingSetup::RestrictToMassPeak&&PlottingSetup::UseSidebandsForcJZB&&LcorrJZBSBeemm) delete LcorrJZBSBeemm;
}

void check_ptsanity() {
  TCanvas *ptsancan = new TCanvas("ptsancan","ptsancan",600,1800);
  TH1F *individualpt1histos[allsamples.collection.size()];
  TH1F *individualpt2histos[allsamples.collection.size()];
  TH1F *fpt1 = new TH1F("fpt1","fpt1",50,0,50);
  fpt1->GetYaxis()->SetRangeUser(0,1);
  fpt1->GetXaxis()->SetTitle("p_{T,1}");
  fpt1->GetXaxis()->CenterTitle();

  TH1F *fpt2 = new TH1F("fpt2","fpt2",50,0,50);
  fpt2->GetXaxis()->SetTitle("p_{T,2}");
  fpt2->GetXaxis()->CenterTitle();
  
  ptsancan->Divide(1,3);
  ptsancan->cd(1);
  float maxpt1entry=0;
  float maxpt2entry=0;
  
  TLegend *leg = make_legend();
  leg->SetX1(0.0);
  leg->SetY1(0.0);
  leg->SetX2(1.0);
  leg->SetY2(1.0);
  
  
  for(int isample=0;isample<(int)allsamples.collection.size();isample++) {
    string nowname=(allsamples.collection)[isample].filename;
    cout << "Drawing: " << nowname << " (sample " << isample+1 << " / " << allsamples.collection.size() << ")" << endl;
    individualpt1histos[isample] = allsamples.Draw(GetNumericHistoName(),"pt1",50,0,50, "p_{T,1}", "events",cutOSSF&&cutnJets,mc,luminosity,allsamples.FindSample(nowname));
    individualpt2histos[isample] = allsamples.Draw(GetNumericHistoName(),"pt2",50,0,50, "p_{T,2}", "events",cutOSSF&&cutnJets,mc,luminosity,allsamples.FindSample(nowname));
    individualpt1histos[isample]->SetLineColor(isample+1);
    individualpt2histos[isample]->SetLineColor(isample+1);
    float currmaxpt1entry=individualpt1histos[isample]->GetMaximum()/individualpt1histos[isample]->Integral();
    float currmaxpt2entry=individualpt2histos[isample]->GetMaximum()/individualpt2histos[isample]->Integral();
    cout << "      pt 1 histo contains; " << individualpt1histos[isample]->Integral() << endl;
    cout << "      pt 2 histo contains; " << individualpt2histos[isample]->Integral() << endl;
    if(currmaxpt1entry>maxpt1entry)maxpt1entry=currmaxpt1entry; 
    if(currmaxpt2entry>maxpt2entry)maxpt2entry=currmaxpt2entry;
    leg->AddEntry(individualpt2histos[isample],((allsamples.collection)[isample].filename).c_str(),"f");
  }

  fpt1->GetYaxis()->SetRangeUser(0,maxpt1entry);
  fpt2->GetYaxis()->SetRangeUser(0,maxpt2entry);

  ptsancan->cd(1);
  fpt1->Draw();
  ptsancan->cd(2);
  fpt2->Draw();

  for(int isample=0;isample<(int)allsamples.collection.size();isample++) {
    ptsancan->cd(1);
    individualpt1histos[isample]->DrawNormalized("same,histo");
    ptsancan->cd(2);
    individualpt2histos[isample]->DrawNormalized("same,histo");
  }
  ptsancan->cd(3);
  leg->Draw();
  CompleteSave(ptsancan,"PtSanityCheck");
  
  delete ptsancan;
}

void do_mlls_plot(string mcjzb) {
  cout << "At this point we'd plot the mll distribution" << endl;
  TCanvas *sigcan = new TCanvas("sigcan","sigcan");
  for(int isig=0;isig<(int)(signalsamples.collection).size();isig++) {
    if(!(signalsamples.collection)[isig].events) continue;
    string nowname=(signalsamples.collection)[isig].filename;
    TH1F *mll = signalsamples.Draw("mllhisto","mll",150,0,150, "m_{ll}", "events",cutOSSF&&cutnJets,mc,luminosity,signalsamples.FindSample(nowname));
//    TH1F *mll = signalsamples.Draw("mllhisto","mll",150,0,150, "m_{ll}", "events","",mc,luminosity,signalsamples.FindSample(nowname));
    mll->SetLineColor(TColor::GetColor("#04B404"));
    stringstream poscutS;
    poscutS << "((" << mcjzb <<")>50)";
    TCut poscut(poscutS.str().c_str());
    TH1F *mllP = signalsamples.Draw("mllhistoP","mll",150,0,150, "m_{ll}", "events",cutOSSF&&cutnJets&&poscut,mc,luminosity,signalsamples.FindSample(nowname));
    mllP->SetLineColor(TColor::GetColor("#0040FF"));
    mll->Draw("histo");
    mllP->Draw("histo,same");
    TLegend *leg = make_legend();
    leg->SetY1(0.8);
    leg->AddEntry(mll,(signalsamples.collection)[isig].samplename.c_str(),"L");
    leg->AddEntry(mllP,((signalsamples.collection)[isig].samplename+", JZB>50").c_str(),"L");
    leg->Draw();
    TLine *lin = new TLine(71.2,0,71.2,mll->GetMaximum());
    TLine *lin2 = new TLine(111.2,0,111.2,mll->GetMaximum());
    lin->Draw("same");
    lin2->Draw("same");
    
    CompleteSave(sigcan,"MllShape/"+(signalsamples.collection)[isig].samplename);
    delete mll;
    delete mllP;
  }
}

void met_vs_jzb_plots(string datajzb, string mcjzb) {
  
  TCanvas *canmetjzb = new TCanvas("canmet","MET vs JZB canvas");
  canmetjzb->SetRightMargin(0.16);
  
  vector<string> findme;
  findme.push_back("DY");
  findme.push_back("TTJets");
  findme.push_back("LM");
  /*
  for(int ifind=0;ifind<(int)findme.size();ifind++) {
    vector<int> selsamples = allsamples.FindSample(findme[ifind]);
    TH2F *metvsjzb = new TH2F("metvsjzb","metvsjzb",200,0,100,400,-100,100);
    for(int isel=0;isel<(int)selsamples.size();isel++) {
      dout << "Producing MET:JZB plot ... working on sample: " << allsamples.collection[selsamples[isel]].filename << endl;
      allsamples.collection[selsamples[isel]].events->Draw("jzb[1]:met[4]>>+metvsjzb",cutmass&&cutOSSF&&cutnJets);
    }
    metvsjzb->Scale(allsamples.collection[selsamples[0]].weight);
    metvsjzb->SetStats(0);
    metvsjzb->GetXaxis()->SetTitle("MET (GeV)");
    metvsjzb->GetYaxis()->SetTitle("JZB (GeV)");
    metvsjzb->GetXaxis()->CenterTitle();
    metvsjzb->GetYaxis()->CenterTitle();
    metvsjzb->Draw("COLZ");
    TText* title = write_text(0.5,0.95,allsamples.collection[selsamples[0]].samplename);
    title->SetTextAlign(12);
    title->Draw();
    CompleteSave(canmetjzb,(string)"METvsJZBplots/"+findme[ifind]);
  }
  */
  
  dout << "About to produce MET plot for DY split up by JZB" << endl;
  
  int nbins=14;
  float low=0;
  float high=140;
  
  stringstream sLEFT;
  sLEFT << "((" << mcjzb << ")<0)";
  TCut LEFT(sLEFT.str().c_str());
  stringstream sRIGHT;
  sRIGHT << "((" << mcjzb << ")>0)";
  TCut RIGHT(sRIGHT.str().c_str());
  
  TH1F *metleft   = allsamples.Draw("metleft","met[4]",nbins,low,high, "MET [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&LEFT,mc, luminosity, allsamples.FindSample("DYJets"));
  TH1F *metleftO  = allsamples.Draw("metleftO","met[4]",nbins,low,high, "MET [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&LEFT,mc, luminosity, allsamples.FindSample("DYJets"));
  TH1F *metright  = allsamples.Draw("metright","met[4]",nbins,low,high, "MET [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&RIGHT,mc, luminosity, allsamples.FindSample("DYJets"));
  TH1F *metrightO = allsamples.Draw("metrightO","met[4]",nbins,low,high, "MET [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&RIGHT,mc, luminosity, allsamples.FindSample("DYJets"));
  
  
  TH1F *Bpred =  (TH1F*)metleft->Clone("Bpred");
  Bpred->Add(metleftO,-1);
  Bpred->Add(metrightO);
  TH1F *obs = (TH1F*)metright->Clone("obs");
  
  metleft->Add(metleftO,-1);
  metright->Add(metrightO,-1);
  
  metleft->SetLineColor(kRed);
  metright->SetLineColor(kBlack);
  TPad *metpad = new TPad("metpad","metpad",0,0,1,1);
  metpad->cd();
  metpad->SetLogy(1);
  metleft->Draw("histo");
  metright->Draw("same");
  TLegend *lg = make_legend();
  lg->SetX1(0.5);
  lg->SetY1(0.7);
  lg->AddEntry(metright,"JZB>0 (OSOF corrected)","P");
  lg->AddEntry(metleft,"JZB<0 (OSOF corrected)","L");
  lg->SetHeader("DY");
  
  lg->Draw();
  Save_With_Ratio(metright,metleft,metpad->cd(),"METvsJZBplots/ComparingLeftToRightinMETspectrum");
  
  TPad *metpad3 = new TPad("metpad3","metpad3",0,0,1,1);
  metpad3->cd();
  metpad3->SetLogy(1);
  Bpred->SetLineColor(kRed);
  Bpred->Draw("histo");
  obs->SetLineColor(kBlack);
  obs->Draw("same");
  TLegend *lg2 = make_legend();
  lg2->SetX1(0.5);
  lg2->SetY1(0.7);
  lg2->AddEntry(obs,"observed","P");
  lg2->AddEntry(Bpred,"predicted","L");
  lg2->SetHeader("DY");

  lg2->Draw();
  
  Save_With_Ratio(obs,Bpred,metpad3->cd(),"METvsJZBplots/ComparingPredObsinMET");
  
  TPad *metpad2 = new TPad("metpad2","metpad2",0,0,1,1);
  metpad2->cd();
  metpad2->SetLogy(1);
  
  TH1F *metlefta   = allsamples.Draw("metlefta","met[2]",nbins,low,high, "MET [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&LEFT,mc, luminosity, allsamples.FindSample("DYJets"));
  TH1F *metleftOa  = allsamples.Draw("metleftOa","met[2]",nbins,low,high, "MET [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&LEFT,mc, luminosity, allsamples.FindSample("DYJets"));
  TH1F *metrighta  = allsamples.Draw("metrighta","met[2]",nbins,low,high, "MET [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&RIGHT,mc, luminosity, allsamples.FindSample("DYJets"));
  TH1F *metrightOa = allsamples.Draw("metrightOa","met[2]",nbins,low,high, "MET [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&RIGHT,mc, luminosity, allsamples.FindSample("DYJets"));
  
  metlefta->Add(metleftOa,-1);
  metrighta->Add(metrightOa,-1);
  
  metlefta->SetLineColor(kRed);
  metpad2->cd();
  metlefta->Draw("histo");
  metrighta->Draw("same");
  lg->Draw();
  Save_With_Ratio(metrighta,metlefta,metpad2->cd(),"METvsJZBplots/ComparingLeftToRightinMET_type1_spectrum");
  
  delete Bpred;
  delete obs;
  
  float newhigh=300;
  int newNBins=30;
  
  TPad *metpad4 = new TPad("metpad4","metpad4",0,0,1,1);
  TH1F *Ametleft   = allsamples.Draw("Ametleft","met[4]",newNBins,low,newhigh, "MET [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&LEFT,mc, luminosity);
  TH1F *AmetleftO  = allsamples.Draw("AmetleftO","met[4]",newNBins,low,newhigh, "MET [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&LEFT,mc, luminosity);
  TH1F *Ametright  = allsamples.Draw("Ametright","met[4]",newNBins,low,newhigh, "MET [GeV]", "events", cutmass&&cutOSSF&&cutnJets&&RIGHT,mc, luminosity);
  TH1F *AmetrightO = allsamples.Draw("AmetrightO","met[4]",newNBins,low,newhigh, "MET [GeV]", "events", cutmass&&cutOSOF&&cutnJets&&RIGHT,mc, luminosity);
  
  TH1F *aBpred = (TH1F*)Ametleft->Clone("aBpred");
  aBpred->Add(AmetleftO,-1);
  aBpred->Add(AmetrightO);
  aBpred->SetLineColor(kRed);
  
  TH1F *aobs = (TH1F*)Ametright->Clone("aobs");
  metpad4->cd();
  metpad4->SetLogy(1);
  aobs->Draw();
  aBpred->Draw("histo,same");
  aobs->Draw("same");
  lg->SetHeader("All MC");
  lg->Draw();
  Save_With_Ratio(aobs,aBpred,metpad4->cd(),"METvsJZBplots/ComparingPredObsinMET_ALLSAMPLES");
  
  
  delete lg;
  delete canmetjzb;
  delete metleft;
  delete metleftO;
  delete metright;
  delete metrightO;
}
    

void test() {
  
  TCanvas *testcanv = new TCanvas("testcanv","testcanv");
  testcanv->cd();
//  switch_overunderflow(true);
  TH1F *ptdistr   = allsamples.Draw("ptdistr","pt1",100,30,200, "p_{T} [GeV]", "events", cutOSSF,data,luminosity);
  switch_overunderflow(false);
  ptdistr->Draw();
  testcanv->SaveAs("test.png");
  dout << "HELLO there!" << endl;
  
}
Revision:	1.83
Committed:	Mon Feb 11 13:32:18 2013 UTC (12 years, 2 months ago) by buchmann
Content type:	text/plain
Branch:	MAIN
Changes since 1.82:	+13 -2 lines
Log Message:	Added generator level plots (gen leptons and gen met)