SchieferD/jetcalib/mcfakerate_x.cpp

////////////////////////////////////////////////////////////////////////////////
//
// mcfakerate_x
// ------------
//
//            06/28/2007 Philipp Schieferdecker <philipp.schieferdecker@cern.ch>
////////////////////////////////////////////////////////////////////////////////


#include "utils/cmdline.h"

#include <TROOT.h>
#include <TStyle.h>
#include <TRint.h>
#include <TFile.h>
#include <TTree.h>
#include <TH1F.h>
#include <TCanvas.h>
#include <TLegend.h>
#include <TMath.h>

#include <iostream>
#include <iomanip>
#include <cmath>
#include <string>
#include <vector>


using namespace std;


////////////////////////////////////////////////////////////////////////////////
// declare global functions
////////////////////////////////////////////////////////////////////////////////

//______________________________________________________________________________
void setBinomialErrors(TH1F* hEff,const TH1F* hFake, const TH1F* hAll);

////////////////////////////////////////////////////////////////////////////////
// main
////////////////////////////////////////////////////////////////////////////////

//______________________________________________________________________________
int main(int argc,char**argv)
{
  cmdline cl;
  cl.parse(argc,argv);

  vector<string> input    = cl.get_vector<string>("input");
  string         treename = cl.get_value<string> ("treename",   "t");
  float          drmax    = cl.get_value<float>  ("drmax",      0.3);
  int            netbins  = cl.get_value<int>    ("netbins",     50);
  int            netabins = cl.get_value<int>    ("netabins",    25);
  int            nphibins = cl.get_value<int>    ("nphibins",    25);
  int            nemfbins = cl.get_value<int>    ("nemfbins",    15);
  float          etmin    = cl.get_value<float>  ("etmin",      0.0);
  float          etmax    = cl.get_value<float>  ("etmax",    200.0);
  float          etamin   = cl.get_value<float>  ("etamin",    -5.0);
  float          etamax   = cl.get_value<float>  ("etamax",     5.0);
  float          phimin   = cl.get_value<float>  ("phimin",    -3.2);
  float          phimax   = cl.get_value<float>  ("phimax",     3.2);
  float          emfmin   = cl.get_value<float>  ("emfmin",     0.0);
  float          emfmax   = cl.get_value<float>  ("emfmax",     1.0);
  short          applyjes = cl.get_value<short>  ("applyjes",     0);
  
  if (!cl.check()) return 0;
  cl.print();

  
  // jetalgs
  vector<string> jetalgs;
  for (vector<string>::const_iterator it=input.begin();it!=input.end();++it) {
    string jetalg = *it;
    string::size_type pos;
    while ((pos=jetalg.find('/'))!=string::npos) jetalg = jetalg.substr(pos+1);
    jetalg = jetalg.substr(0,jetalg.find(".root"));
    jetalgs.push_back(jetalg);
  }
  
  // loop over all input samples
  vector<TH1F*> etHistos;
  vector<TH1F*> etaHistos;
  vector<TH1F*> phiHistos;
  vector<TH1F*> emfHistos;
  for (unsigned int i=0;i<input.size();++i) {
    TFile* f = new TFile(input[i].c_str(),"READ");
    TTree* t = (TTree*)f->Get(treename.c_str());
    cout<<jetalgs[i]<<" sample has "<<t->GetEntries()<<" entries."<<endl;


    string nameEtAll = "EtAll_"+jetalgs[i];
    string nameEtFake = "EtFake_"+jetalgs[i];
    string nameEtEff = "EtEff_"+jetalgs[i];
    
    TH1F* hEtAll  = new TH1F(nameEtAll.c_str(),nameEtAll.c_str(),
                             netbins,etmin,etmax);
    TH1F* hEtFake = new TH1F(nameEtFake.c_str(),nameEtFake.c_str(),
                             netbins,etmin,etmax);
    TH1F* hEtEff  = new TH1F(nameEtEff.c_str(),nameEtEff.c_str(),
                             netbins,etmin,etmax);
    
    hEtAll->Sumw2();
    hEtFake->Sumw2();
    hEtEff->Sumw2();
    
    string nameEtaAll = "EtaAll_"+jetalgs[i];
    string nameEtaFake = "EtaFake_"+jetalgs[i];
    string nameEtaEff = "EtaEff_"+jetalgs[i];
    
    TH1F* hEtaAll  = new TH1F(nameEtaAll.c_str(),nameEtaAll.c_str(),
                              netabins,etamin,etamax);
    TH1F* hEtaFake = new TH1F(nameEtaFake.c_str(),nameEtaFake.c_str(),
                              netabins,etamin,etamax);
    TH1F* hEtaEff  = new TH1F(nameEtaEff.c_str(),nameEtaEff.c_str(),
                              netabins,etamin,etamax);
    
    hEtaAll->Sumw2();
    hEtaFake->Sumw2();
    hEtaEff->Sumw2();
    
    string namePhiAll = "PhiAll_"+jetalgs[i];
    string namePhiFake = "PhiFake_"+jetalgs[i];
    string namePhiEff = "PhiEff_"+jetalgs[i];
    
    TH1F* hPhiAll = new TH1F(namePhiAll.c_str(),namePhiAll.c_str(),
                             nphibins,phimin,phimax);
    TH1F* hPhiFake = new TH1F(namePhiFake.c_str(),namePhiFake.c_str(),
                              nphibins,phimin,phimax);
    TH1F* hPhiEff = new TH1F(namePhiEff.c_str(),namePhiEff.c_str(),
                             nphibins,phimin,phimax);
    
    hPhiAll->Sumw2();
    hPhiFake->Sumw2();
    hPhiEff->Sumw2();
    
    string nameEmfAll = "EmfAll_"+jetalgs[i];
    string nameEmfFake = "EmfFake_"+jetalgs[i];
    string nameEmfEff = "EmfEff_"+jetalgs[i];
    
    TH1F* hEmfAll = new TH1F(nameEmfAll.c_str(),nameEmfAll.c_str(),
                             nemfbins,emfmin,emfmax);
    TH1F* hEmfFake = new TH1F(nameEmfFake.c_str(),nameEmfFake.c_str(),
                              nemfbins,emfmin,emfmax);
    TH1F* hEmfEff = new TH1F(nameEmfEff.c_str(),nameEmfEff.c_str(),
                             nemfbins,emfmin,emfmax);
    
    hEmfAll->Sumw2();
    hEmfFake->Sumw2();
    hEmfEff->Sumw2();
    
    float weight;       t->SetBranchAddress("weight",&weight);
    char  njt;          t->SetBranchAddress("njt",   &njt);
    float jtet[100];    t->SetBranchAddress("jtet",   jtet);
    float jteta[100];   t->SetBranchAddress("jteta",  jteta);
    float jtphi[100];   t->SetBranchAddress("jtphi",  jtphi);
    float jtemf[100];   t->SetBranchAddress("jtemf",  jtemf);
    float jtgendr[100]; t->SetBranchAddress("jtgendr",jtgendr);
    float jtjes[100][3];
    if (applyjes>0&&t->FindBranch("jtjes")) t->SetBranchAddress("jtjes",jtjes);

    int nevts=t->GetEntries();
    
    for (int ievt=0;ievt<nevts;ievt++) {
      t->GetEntry(ievt);
      for (int ijt=0;ijt<njt;ijt++) {
        
        float dr  = jtgendr[ijt];
        float et  = (applyjes==0) ? jtet[ijt]:jtet[ijt]*jtjes[ijt][applyjes-1];
        float eta = jteta[ijt];
        float phi = jtphi[ijt];
        float emf = jtemf[ijt]; if (TMath::IsNaN(emf)) emf = 0.0;
        
        if (et <etmin ||et >etmax)  continue;
        if (eta<etamin||eta>etamax) continue;
        if (phi<phimin||phi>phimax) continue;
        if (emf<emfmin||emf>emfmax) continue;
        
        hEtAll ->Fill(et, weight);
        hEtaAll->Fill(eta,weight);
        hPhiAll->Fill(phi,weight);
        hEmfAll->Fill(emf,weight);
        
        if (dr<0.0||dr>drmax) {
          hEtFake ->Fill(et, weight);
          hEtaFake->Fill(eta,weight);
          hPhiFake->Fill(phi,weight);
          hEmfFake->Fill(emf,weight);
        }
      }
    }
    
    hEtEff->Divide(hEtFake,hEtAll,1.0,1.0,"B");
    setBinomialErrors(hEtEff,hEtFake,hEtAll);
    etHistos.push_back(hEtEff);
    
    hEtaEff->Divide(hEtaFake,hEtaAll,1.0,1.0,"B");
    setBinomialErrors(hEtaEff,hEtaFake,hEtaAll);
    etaHistos.push_back(hEtaEff);
 
    hPhiEff->Divide(hPhiFake,hPhiAll,1.0,1.0,"B");
    setBinomialErrors(hPhiEff,hPhiFake,hPhiAll);
    phiHistos.push_back(hPhiEff);

    hEmfEff->Divide(hEmfFake,hEmfAll,1.0,1.0,"B");
    setBinomialErrors(hEmfEff,hEmfFake,hEmfAll);
    emfHistos.push_back(hEmfEff);
  }
  
  
  // make plots
  argc=1;
  TRint* app = new TRint(argv[0],&argc,argv);
  
  gStyle->SetOptStat(0);
  
  Color_t color;
  
  // emf canvas
  TCanvas* cEmfEff  = new TCanvas("FakeVsEmf", "FakeVsEmf",10,420,400,400);
  TLegend* lEmfEff  = new TLegend(0.65,0.85-emfHistos.size()*0.05,0.86,0.85);
  cEmfEff->cd();
  lEmfEff->SetFillColor(10);
  
  color = kBlack;
  for (unsigned int i=0;i<emfHistos.size();i++) {
    TH1F* h = emfHistos[i];
    lEmfEff->AddEntry(h,jetalgs[i].c_str(),"lp");
    h->SetLineWidth(2);
    h->SetMarkerColor(color);
    h->SetLineColor(color++);
    h->SetMarkerStyle(kFullCircle);
    h->SetMarkerSize(0.7);
    if (i==0) {
      h->SetTitle("#epsilon_{FAKE} vs emf");
      h->SetXTitle("jet emf");
      h->SetYTitle("#epsilon_{FAKE}");
      h->Draw("E");
      h->SetMinimum(0.0);
      h->SetMaximum(1.05);
    }
    else h->Draw("ESAME");
  }
  lEmfEff->Draw();

  // phi canvas
  TCanvas* cPhiEff  = new TCanvas("FakeVsPhi", "FakeVsPhi",830,10,400,400);
  TLegend* lPhiEff  = new TLegend(0.65,0.85-phiHistos.size()*0.05,0.86,0.85);
  cPhiEff->cd();
  lPhiEff->SetFillColor(10);
  
  color = kBlack;
  for (unsigned int i=0;i<phiHistos.size();i++) {
    TH1F* h = phiHistos[i];
    lPhiEff->AddEntry(h,jetalgs[i].c_str(),"lp");
    h->SetLineWidth(2);
    h->SetMarkerColor(color);
    h->SetLineColor(color++);
    h->SetMarkerStyle(kFullCircle);
    h->SetMarkerSize(0.7);
    if (i==0) {
      h->SetTitle("#epsilon_{FAKE} vs #phi");
      h->SetXTitle("jet #phi");
      h->SetYTitle("#epsilon_{FAKE}");
      h->Draw("E");
      h->SetMinimum(0.0);
      h->SetMaximum(1.05);
    }
    else h->Draw("ESAME");
  }
  lPhiEff->Draw();

  // eta canvas
  TCanvas* cEtaEff  = new TCanvas("FakeVsEta", "FakeVsEta",420,10,400,400);
  TLegend* lEtaEff  = new TLegend(0.65,0.85-etaHistos.size()*0.05,0.86,0.85);
  cEtaEff->cd();
  lEtaEff->SetFillColor(10);
  
  color = kBlack;
  for (unsigned int i=0;i<etaHistos.size();i++) {
    TH1F* h = etaHistos[i];
    lEtaEff->AddEntry(h,jetalgs[i].c_str(),"lp");
    h->SetLineWidth(2);
    h->SetMarkerColor(color);
    h->SetLineColor(color++);
    h->SetMarkerStyle(kFullCircle);
    h->SetMarkerSize(0.7);
    if (i==0) {
      h->SetTitle("#epsilon_{FAKE} vs #eta");
      h->SetXTitle("jet #eta");
      h->SetYTitle("#epsilon_{FAKE}");
      h->Draw("E");
      h->SetMinimum(0.0);
      h->SetMaximum(1.05);
    }
    else h->Draw("ESAME");
    
  }
  lEtaEff->Draw();

  // et canvas
  TCanvas* cEtEff  = new TCanvas("FakeVsEt", "FakeVsEt",10,10,400,400);
  TLegend* lEtEff  = new TLegend(0.65,0.85-etHistos.size()*0.05,0.86,0.85);
  cEtEff->cd();
  lEtEff->SetFillColor(10);
  
  color = kBlack;
  for (unsigned int i=0;i<etHistos.size();i++) {
    TH1F* h = etHistos[i];
    lEtEff->AddEntry(h,jetalgs[i].c_str(),"lp");
    h->SetLineWidth(2);
    h->SetMarkerColor(color);
    h->SetLineColor(color++);
    h->SetMarkerStyle(kFullCircle);
    h->SetMarkerSize(0.7);
    if (i==0) {
      h->SetTitle("#epsilon_{FAKE} vs E_{T}");
      h->SetXTitle("jet E_{T} [GeV]");
      h->SetYTitle("#epsilon_{FAKE}");
      h->Draw("E");
      h->SetMinimum(0.0);
      h->SetMaximum(1.05);
    }
    else h->Draw("ESAME");
  }
  lEtEff->Draw();
  
  app->Run();
  
  return 0;
}


////////////////////////////////////////////////////////////////////////////////
// implementation of global function
////////////////////////////////////////////////////////////////////////////////

//______________________________________________________________________________
void setBinomialErrors(TH1F* hEff,const TH1F* hFake, const TH1F* hAll)
{
  for (int i=1;i<hEff->GetNbinsX();i++) {
    float nfake = hFake->GetBinContent(i);
    float nall  = hAll ->GetBinContent(i);
    float eeff  = (nall>0.0) ? std::sqrt(nfake/(nall*nall)*(1-nfake/nall)):0.0;
    hEff->SetBinError(i,eeff);
  }
}
Revision:	1.3
Committed:	Tue Sep 4 12:10:40 2007 UTC (17 years, 7 months ago) by schiefer
Branch:	MAIN
Changes since 1.2:	+131 -59 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	schiefer	1.1	////////////////////////////////////////////////////////////////////////////////
2			//
3			// mcfakerate_x
4			// ------------
5			//
6			// 06/28/2007 Philipp Schieferdecker <philipp.schieferdecker@cern.ch>
7			////////////////////////////////////////////////////////////////////////////////
8
9
10			#include "utils/cmdline.h"
11
12			#include <TROOT.h>
13			#include <TStyle.h>
14			#include <TRint.h>
15			#include <TFile.h>
16			#include <TTree.h>
17			#include <TH1F.h>
18			#include <TCanvas.h>
19			#include <TLegend.h>
20	schiefer	1.3	#include <TMath.h>
21	schiefer	1.1
22			#include <iostream>
23			#include <iomanip>
24			#include <cmath>
25			#include <string>
26			#include <vector>
27
28
29			using namespace std;
30
31
32			////////////////////////////////////////////////////////////////////////////////
33			// declare global functions
34			////////////////////////////////////////////////////////////////////////////////
35
36			//______________________________________________________________________________
37			void setBinomialErrors(TH1F* hEff,const TH1F* hFake, const TH1F* hAll);
38
39			////////////////////////////////////////////////////////////////////////////////
40			// main
41			////////////////////////////////////////////////////////////////////////////////
42
43			//______________________________________________________________________________
44			int main(int argc,char**argv)
45			{
46			cmdline cl;
47			cl.parse(argc,argv);
48
49			vector<string> input = cl.get_vector<string>("input");
50			string treename = cl.get_value<string> ("treename", "t");
51	schiefer	1.3	float drmax = cl.get_value<float> ("drmax", 0.3);
52			int netbins = cl.get_value<int> ("netbins", 50);
53	schiefer	1.1	int netabins = cl.get_value<int> ("netabins", 25);
54			int nphibins = cl.get_value<int> ("nphibins", 25);
55	schiefer	1.3	int nemfbins = cl.get_value<int> ("nemfbins", 15);
56			float etmin = cl.get_value<float> ("etmin", 0.0);
57			float etmax = cl.get_value<float> ("etmax", 200.0);
58			float etamin = cl.get_value<float> ("etamin", -5.0);
59			float etamax = cl.get_value<float> ("etamax", 5.0);
60			float phimin = cl.get_value<float> ("phimin", -3.2);
61			float phimax = cl.get_value<float> ("phimax", 3.2);
62			float emfmin = cl.get_value<float> ("emfmin", 0.0);
63			float emfmax = cl.get_value<float> ("emfmax", 1.0);
64			short applyjes = cl.get_value<short> ("applyjes", 0);
65	schiefer	1.1
66			if (!cl.check()) return 0;
67			cl.print();
68
69
70			// jetalgs
71			vector<string> jetalgs;
72			for (vector<string>::const_iterator it=input.begin();it!=input.end();++it) {
73			string jetalg = *it;
74			string::size_type pos;
75			while ((pos=jetalg.find('/'))!=string::npos) jetalg = jetalg.substr(pos+1);
76			jetalg = jetalg.substr(0,jetalg.find(".root"));
77			jetalgs.push_back(jetalg);
78			}
79
80			// loop over all input samples
81	schiefer	1.3	vector<TH1F*> etHistos;
82	schiefer	1.1	vector<TH1F*> etaHistos;
83			vector<TH1F*> phiHistos;
84	schiefer	1.3	vector<TH1F*> emfHistos;
85	schiefer	1.1	for (unsigned int i=0;i<input.size();++i) {
86			TFile* f = new TFile(input[i].c_str(),"READ");
87			TTree* t = (TTree*)f->Get(treename.c_str());
88			cout<<jetalgs[i]<<" sample has "<<t->GetEntries()<<" entries."<<endl;
89
90
91	schiefer	1.3	string nameEtAll = "EtAll_"+jetalgs[i];
92			string nameEtFake = "EtFake_"+jetalgs[i];
93			string nameEtEff = "EtEff_"+jetalgs[i];
94
95			TH1F* hEtAll = new TH1F(nameEtAll.c_str(),nameEtAll.c_str(),
96			netbins,etmin,etmax);
97			TH1F* hEtFake = new TH1F(nameEtFake.c_str(),nameEtFake.c_str(),
98			netbins,etmin,etmax);
99			TH1F* hEtEff = new TH1F(nameEtEff.c_str(),nameEtEff.c_str(),
100			netbins,etmin,etmax);
101
102			hEtAll->Sumw2();
103			hEtFake->Sumw2();
104			hEtEff->Sumw2();
105	schiefer	1.1
106			string nameEtaAll = "EtaAll_"+jetalgs[i];
107			string nameEtaFake = "EtaFake_"+jetalgs[i];
108			string nameEtaEff = "EtaEff_"+jetalgs[i];
109
110			TH1F* hEtaAll = new TH1F(nameEtaAll.c_str(),nameEtaAll.c_str(),
111			netabins,etamin,etamax);
112			TH1F* hEtaFake = new TH1F(nameEtaFake.c_str(),nameEtaFake.c_str(),
113			netabins,etamin,etamax);
114			TH1F* hEtaEff = new TH1F(nameEtaEff.c_str(),nameEtaEff.c_str(),
115			netabins,etamin,etamax);
116
117			hEtaAll->Sumw2();
118			hEtaFake->Sumw2();
119			hEtaEff->Sumw2();
120
121			string namePhiAll = "PhiAll_"+jetalgs[i];
122			string namePhiFake = "PhiFake_"+jetalgs[i];
123			string namePhiEff = "PhiEff_"+jetalgs[i];
124
125			TH1F* hPhiAll = new TH1F(namePhiAll.c_str(),namePhiAll.c_str(),
126			nphibins,phimin,phimax);
127			TH1F* hPhiFake = new TH1F(namePhiFake.c_str(),namePhiFake.c_str(),
128			nphibins,phimin,phimax);
129			TH1F* hPhiEff = new TH1F(namePhiEff.c_str(),namePhiEff.c_str(),
130			nphibins,phimin,phimax);
131
132			hPhiAll->Sumw2();
133			hPhiFake->Sumw2();
134			hPhiEff->Sumw2();
135
136	schiefer	1.3	string nameEmfAll = "EmfAll_"+jetalgs[i];
137			string nameEmfFake = "EmfFake_"+jetalgs[i];
138			string nameEmfEff = "EmfEff_"+jetalgs[i];
139
140			TH1F* hEmfAll = new TH1F(nameEmfAll.c_str(),nameEmfAll.c_str(),
141			nemfbins,emfmin,emfmax);
142			TH1F* hEmfFake = new TH1F(nameEmfFake.c_str(),nameEmfFake.c_str(),
143			nemfbins,emfmin,emfmax);
144			TH1F* hEmfEff = new TH1F(nameEmfEff.c_str(),nameEmfEff.c_str(),
145			nemfbins,emfmin,emfmax);
146
147			hEmfAll->Sumw2();
148			hEmfFake->Sumw2();
149			hEmfEff->Sumw2();
150
151	schiefer	1.1	float weight; t->SetBranchAddress("weight",&weight);
152			char njt; t->SetBranchAddress("njt", &njt);
153	schiefer	1.3	float jtet[100]; t->SetBranchAddress("jtet", jtet);
154	schiefer	1.1	float jteta[100]; t->SetBranchAddress("jteta", jteta);
155			float jtphi[100]; t->SetBranchAddress("jtphi", jtphi);
156	schiefer	1.3	float jtemf[100]; t->SetBranchAddress("jtemf", jtemf);
157	schiefer	1.1	float jtgendr[100]; t->SetBranchAddress("jtgendr",jtgendr);
158	schiefer	1.3	float jtjes[100][3];
159			if (applyjes>0&&t->FindBranch("jtjes")) t->SetBranchAddress("jtjes",jtjes);
160
161	schiefer	1.1	int nevts=t->GetEntries();
162
163			for (int ievt=0;ievt<nevts;ievt++) {
164			t->GetEntry(ievt);
165			for (int ijt=0;ijt<njt;ijt++) {
166
167	schiefer	1.3	float dr = jtgendr[ijt];
168			float et = (applyjes==0) ? jtet[ijt]:jtet[ijt]*jtjes[ijt][applyjes-1];
169			float eta = jteta[ijt];
170			float phi = jtphi[ijt];
171			float emf = jtemf[ijt]; if (TMath::IsNaN(emf)) emf = 0.0;
172
173			if (et <etmin \|\|et >etmax) continue;
174			if (eta<etamin\|\|eta>etamax) continue;
175			if (phi<phimin\|\|phi>phimax) continue;
176			if (emf<emfmin\|\|emf>emfmax) continue;
177
178			hEtAll ->Fill(et, weight);
179			hEtaAll->Fill(eta,weight);
180			hPhiAll->Fill(phi,weight);
181			hEmfAll->Fill(emf,weight);
182
183			if (dr<0.0\|\|dr>drmax) {
184			hEtFake ->Fill(et, weight);
185			hEtaFake->Fill(eta,weight);
186			hPhiFake->Fill(phi,weight);
187			hEmfFake->Fill(emf,weight);
188	schiefer	1.1	}
189			}
190			}
191
192	schiefer	1.3	hEtEff->Divide(hEtFake,hEtAll,1.0,1.0,"B");
193			setBinomialErrors(hEtEff,hEtFake,hEtAll);
194			etHistos.push_back(hEtEff);
195	schiefer	1.1
196			hEtaEff->Divide(hEtaFake,hEtaAll,1.0,1.0,"B");
197			setBinomialErrors(hEtaEff,hEtaFake,hEtaAll);
198			etaHistos.push_back(hEtaEff);
199
200			hPhiEff->Divide(hPhiFake,hPhiAll,1.0,1.0,"B");
201			setBinomialErrors(hPhiEff,hPhiFake,hPhiAll);
202			phiHistos.push_back(hPhiEff);
203	schiefer	1.3
204			hEmfEff->Divide(hEmfFake,hEmfAll,1.0,1.0,"B");
205			setBinomialErrors(hEmfEff,hEmfFake,hEmfAll);
206			emfHistos.push_back(hEmfEff);
207	schiefer	1.1	}
208
209
210			// make plots
211			argc=1;
212			TRint* app = new TRint(argv[0],&argc,argv);
213
214			gStyle->SetOptStat(0);
215
216			Color_t color;
217
218	schiefer	1.3	// emf canvas
219			TCanvas* cEmfEff = new TCanvas("FakeVsEmf", "FakeVsEmf",10,420,400,400);
220			TLegend* lEmfEff = new TLegend(0.65,0.85-emfHistos.size()*0.05,0.86,0.85);
221			cEmfEff->cd();
222			lEmfEff->SetFillColor(10);
223
224			color = kBlack;
225			for (unsigned int i=0;i<emfHistos.size();i++) {
226			TH1F* h = emfHistos[i];
227			lEmfEff->AddEntry(h,jetalgs[i].c_str(),"lp");
228			h->SetLineWidth(2);
229			h->SetMarkerColor(color);
230			h->SetLineColor(color++);
231			h->SetMarkerStyle(kFullCircle);
232			h->SetMarkerSize(0.7);
233			if (i==0) {
234			h->SetTitle("#epsilon_{FAKE} vs emf");
235			h->SetXTitle("jet emf");
236			h->SetYTitle("#epsilon_{FAKE}");
237			h->Draw("E");
238			h->SetMinimum(0.0);
239			h->SetMaximum(1.05);
240			}
241			else h->Draw("ESAME");
242			}
243			lEmfEff->Draw();
244
245	schiefer	1.1	// phi canvas
246			TCanvas* cPhiEff = new TCanvas("FakeVsPhi", "FakeVsPhi",830,10,400,400);
247			TLegend* lPhiEff = new TLegend(0.65,0.85-phiHistos.size()*0.05,0.86,0.85);
248			cPhiEff->cd();
249			lPhiEff->SetFillColor(10);
250
251			color = kBlack;
252			for (unsigned int i=0;i<phiHistos.size();i++) {
253			TH1F* h = phiHistos[i];
254	schiefer	1.3	lPhiEff->AddEntry(h,jetalgs[i].c_str(),"lp");
255			h->SetLineWidth(2);
256	schiefer	1.1	h->SetMarkerColor(color);
257			h->SetLineColor(color++);
258			h->SetMarkerStyle(kFullCircle);
259	schiefer	1.3	h->SetMarkerSize(0.7);
260	schiefer	1.1	if (i==0) {
261	schiefer	1.3	h->SetTitle("#epsilon_{FAKE} vs #phi");
262	schiefer	1.1	h->SetXTitle("jet #phi");
263	schiefer	1.3	h->SetYTitle("#epsilon_{FAKE}");
264	schiefer	1.1	h->Draw("E");
265			h->SetMinimum(0.0);
266			h->SetMaximum(1.05);
267			}
268			else h->Draw("ESAME");
269			}
270			lPhiEff->Draw();
271
272			// eta canvas
273	schiefer	1.2	TCanvas* cEtaEff = new TCanvas("FakeVsEta", "FakeVsEta",420,10,400,400);
274	schiefer	1.1	TLegend* lEtaEff = new TLegend(0.65,0.85-etaHistos.size()*0.05,0.86,0.85);
275			cEtaEff->cd();
276			lEtaEff->SetFillColor(10);
277
278			color = kBlack;
279			for (unsigned int i=0;i<etaHistos.size();i++) {
280			TH1F* h = etaHistos[i];
281	schiefer	1.3	lEtaEff->AddEntry(h,jetalgs[i].c_str(),"lp");
282			h->SetLineWidth(2);
283	schiefer	1.1	h->SetMarkerColor(color);
284			h->SetLineColor(color++);
285			h->SetMarkerStyle(kFullCircle);
286	schiefer	1.3	h->SetMarkerSize(0.7);
287	schiefer	1.1	if (i==0) {
288	schiefer	1.3	h->SetTitle("#epsilon_{FAKE} vs #eta");
289	schiefer	1.1	h->SetXTitle("jet #eta");
290	schiefer	1.3	h->SetYTitle("#epsilon_{FAKE}");
291	schiefer	1.1	h->Draw("E");
292			h->SetMinimum(0.0);
293			h->SetMaximum(1.05);
294			}
295			else h->Draw("ESAME");
296
297			}
298			lEtaEff->Draw();
299
300	schiefer	1.3	// et canvas
301			TCanvas* cEtEff = new TCanvas("FakeVsEt", "FakeVsEt",10,10,400,400);
302			TLegend* lEtEff = new TLegend(0.65,0.85-etHistos.size()*0.05,0.86,0.85);
303			cEtEff->cd();
304			lEtEff->SetFillColor(10);
305	schiefer	1.1
306			color = kBlack;
307	schiefer	1.3	for (unsigned int i=0;i<etHistos.size();i++) {
308			TH1F* h = etHistos[i];
309			lEtEff->AddEntry(h,jetalgs[i].c_str(),"lp");
310			h->SetLineWidth(2);
311	schiefer	1.1	h->SetMarkerColor(color);
312			h->SetLineColor(color++);
313			h->SetMarkerStyle(kFullCircle);
314	schiefer	1.3	h->SetMarkerSize(0.7);
315	schiefer	1.1	if (i==0) {
316	schiefer	1.3	h->SetTitle("#epsilon_{FAKE} vs E_{T}");
317			h->SetXTitle("jet E_{T} [GeV]");
318			h->SetYTitle("#epsilon_{FAKE}");
319	schiefer	1.1	h->Draw("E");
320			h->SetMinimum(0.0);
321			h->SetMaximum(1.05);
322			}
323			else h->Draw("ESAME");
324			}
325	schiefer	1.3	lEtEff->Draw();
326	schiefer	1.1
327			app->Run();
328
329			return 0;
330			}
331
332
333			////////////////////////////////////////////////////////////////////////////////
334			// implementation of global function
335			////////////////////////////////////////////////////////////////////////////////
336
337			//______________________________________________________________________________
338			void setBinomialErrors(TH1F* hEff,const TH1F* hFake, const TH1F* hAll)
339			{
340			for (int i=1;i<hEff->GetNbinsX();i++) {
341	schiefer	1.3	float nfake = hFake->GetBinContent(i);
342			float nall = hAll ->GetBinContent(i);
343			float eeff = (nall>0.0) ? std::sqrt(nfake/(nallnall)(1-nfake/nall)):0.0;
344	schiefer	1.1	hEff->SetBinError(i,eeff);
345			}
346			}