Fork me on GitHub

Context Navigation

source: git/validation/DelphesValidation.cpp@ ae061c1

Visit:

ImprovedOutputFile Timing dual_readout llp

Last change on this file since ae061c1 was 181c061, checked in by Pavel Demin <pavel-demin@…>, 8 years ago
rename Validation.cpp to DelphesValidation.cpp
Property mode set to `100644`
File size: 107.7 KB

Rev	Line
[734b267]	1	/*
	2	* Delphes: a framework for fast simulation of a generic collider experiment
	3	* Copyright (C) 2012-2014 Universite catholique de Louvain (UCL), Belgium
	4	*
	5	* This program is free software: you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation, either version 3 of the License, or
	8	* (at your option) any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	17	*/
	18
	19
	20	#include <iostream>
	21	#include <utility>
	22	#include <vector>
[1408174]	23	#include <typeinfo>
[734b267]	24
	25	#include "TROOT.h"
	26	#include "TSystem.h"
	27	#include "TApplication.h"
	28
	29	#include "TString.h"
	30
[1408174]	31	#include "TH1.h"
[734b267]	32	#include "TH2.h"
[1408174]	33	#include "TMath.h"
	34	#include "TStyle.h"
	35	#include "TGraph.h"
	36	#include "TCanvas.h"
[734b267]	37	#include "THStack.h"
	38	#include "TLegend.h"
	39	#include "TPaveText.h"
	40	#include "TClonesArray.h"
	41	#include "TLorentzVector.h"
[1408174]	42	#include "TGraphErrors.h"
	43	#include "TMultiGraph.h"
[734b267]	44
	45	#include "classes/DelphesClasses.h"
	46
	47	#include "ExRootAnalysis/ExRootTreeReader.h"
	48	#include "ExRootAnalysis/ExRootTreeWriter.h"
	49	#include "ExRootAnalysis/ExRootTreeBranch.h"
	50	#include "ExRootAnalysis/ExRootResult.h"
	51	#include "ExRootAnalysis/ExRootUtilities.h"
	52
	53	using namespace std;
	54
	55	//------------------------------------------------------------------------------
	56
[92237ca]	57	static const int Nbins = 50;
[1408174]	58
	59	int objStyle = 1;
	60	int trackStyle = 7;
	61	int towerStyle = 3;
	62
	63	Color_t objColor = kBlack;
	64	Color_t trackColor = kBlack;
	65	Color_t towerColor = kBlack;
	66
	67	double effLegXmin = 0.22;
	68	double effLegXmax = 0.7;
	69	double effLegYmin = 0.22;
	70	double effLegYmax = 0.5;
	71
	72	double resLegXmin = 0.62;
	73	double resLegXmax = 0.9;
	74	double resLegYmin = 0.52;
	75	double resLegYmax = 0.85;
	76
	77	double topLeftLegXmin = 0.22;
	78	double topLeftLegXmax = 0.7;
	79	double topLeftLegYmin = 0.52;
	80	double topLeftLegYmax = 0.85;
	81
[92237ca]	82	unsigned int k;
	83
[1408174]	84
	85	struct resolPlot
	86	{
[92237ca]	87	TH1* resolHist;
[1408174]	88	double ptmin;
	89	double ptmax;
[92237ca]	90	double etamin;
	91	double etamax;
[1408174]	92	double xmin;
	93	double xmax;
	94	TString obj;
	95
	96	resolPlot();
	97	resolPlot(double ptdown, double ptup, TString object);
[92237ca]	98	resolPlot(double etadown, double etaup, double ptdown, double ptup, TString object);
[1408174]	99	void set(double ptdown, double ptup, TString object, double xmin = 0, double xmax = 2);
[92237ca]	100	void set(double etadown, double etaup, double ptdown, double ptup, TString object, double xmin = 0, double xmax = 2);
[1408174]	101	void print(){std::cout << ptmin << std::endl;}
	102	};
	103
	104
	105	resolPlot::resolPlot()
	106	{
	107	}
	108
	109	resolPlot::resolPlot(double ptdown, double ptup, TString object)
	110	{
	111	this->set(ptdown,ptup,object);
	112	}
	113
[92237ca]	114	resolPlot::resolPlot(double etadown, double etaup, double ptdown, double ptup, TString object)
	115	{
	116	this->set(etadown, etaup, ptdown, ptup, object);
	117	}
	118
[1408174]	119	void resolPlot::set(double ptdown, double ptup, TString object, double xmin, double xmax)
	120	{
	121	ptmin = ptdown;
	122	ptmax = ptup;
	123	obj = object;
	124
[92237ca]	125	resolHist = new TH1D(obj+"_delta_pt_"+Form("%4.2f",ptmin)+"_"+Form("%4.2f",ptmax), obj+"_delta_pt_"+Form("%4.2f",ptmin)+"_"+Form("%4.2f",ptmax), 1000, xmin, xmax);
	126	}
	127
	128	void resolPlot::set(double etadown, double etaup, double ptdown, double ptup, TString object, double xmin, double xmax)
	129	{
	130	etamin = etadown;
	131	etamax = etaup;
	132	ptmin = ptdown;
	133	ptmax = ptup;
	134	obj = object;
	135
	136	resolHist = new TH1D(obj+"_delta_pt_"+Form("%4.2f",ptmin)+"_"+Form("%4.2f",ptmax)+"_"+Form("%4.2f",etamin)+"_"+Form("%4.2f",etamax), obj+"_delta_pt_"+Form("%4.2f",ptmin)+"_"+Form("%4.2f",ptmax)+"_"+Form("%4.2f",etamin)+"_"+Form("%4.2f",etamax), 1000, xmin, xmax);
[1408174]	137	}
	138
[92237ca]	139
	140
[1408174]	141	void HistogramsCollection(std::vector<resolPlot> *histos, double ptmin, double ptmax, TString obj, double xmin = 0, double xmax = 2)
	142	{
	143	double width;
	144	double ptdown;
	145	double ptup;
	146	resolPlot ptemp;
	147
	148	for (int i = 0; i < Nbins; i++)
	149	{
	150	width = (ptmax - ptmin) / Nbins;
	151	ptdown = TMath::Power(10,ptmin + i * width );
	152	ptup = TMath::Power(10,ptmin + (i+1) * width );
	153	ptemp.set(ptdown, ptup, obj, xmin, xmax);
	154	histos->push_back(ptemp);
	155	}
	156	}
	157
[92237ca]	158
	159	void HistogramsCollectionVsEta(std::vector<resolPlot> *histos, double etamin, double etamax, double ptmin, double ptmax, TString obj, double xmin = 0, double xmax = 2)
	160	{
	161	resolPlot ptemp;
	162	double width;
	163	double etadown;
	164	double etaup;
	165
	166	for (int i = 0; i < Nbins; i++)
	167	{
	168	width = (etamax - etamin) / Nbins;
	169	etadown = etamin + i * width;
	170	etaup = etamin + (i+1) * width;
	171
	172	ptemp.set(etadown, etaup, ptmin, ptmax, obj, xmin, xmax);
	173	histos->push_back(ptemp);
	174	}
	175	}
	176
	177
[1408174]	178	//------------------------------------------------------------------------------
	179
	180	class ExRootResult;
	181	class ExRootTreeReader;
	182
	183	//------------------------------------------------------------------------------
	184
	185	void BinLogX(TH1*h)
	186	{
	187	TAxis *axis = h->GetXaxis();
	188	int bins = axis->GetNbins();
	189
	190	Axis_t from = axis->GetXmin();
	191	Axis_t to = axis->GetXmax();
	192	Axis_t width = (to - from) / bins;
	193	Axis_t *new_bins = new Axis_t[bins + 1];
	194
	195	for (int i = 0; i <= bins; i++)
	196	{
	197	new_bins[i] = TMath::Power(10, from + i * width);
	198	}
	199	axis->Set(bins, new_bins);
	200	delete new_bins;
	201	}
	202
	203
	204	//------------------------------------------------------------------------------
	205
	206	template<typename T>
[92237ca]	207	TH1D* GetEffPt(TClonesArray branchReco, TClonesArray branchParticle, TString name, int pdgID, double ptmin, double ptmax, double etamin, double etamax, ExRootTreeReader *treeReader)
[1408174]	208	{
	209
	210	cout << "** Computing Efficiency of reconstructing "<< branchReco->GetName() << " induced by " << branchParticle->GetName() << " with PID " << pdgID << endl;
	211
	212	Long64_t allEntries = treeReader->GetEntries();
	213
	214	GenParticle *particle;
	215	T *recoObj;
	216
	217	TLorentzVector recoMomentum, genMomentum, bestRecoMomentum;
	218
	219	Float_t deltaR;
	220	Float_t pt, eta;
	221	Long64_t entry;
	222
	223	Int_t i, j;
	224
[92237ca]	225	TH1D *histGenPt = new TH1D(name+" gen spectra Pt",name+" gen spectra cen", Nbins, TMath::Log10(ptmin), TMath::Log10(ptmax));
	226	TH1D *histRecoPt = new TH1D(name+" reco spectra Pt",name+" reco spectra cen", Nbins, TMath::Log10(ptmin), TMath::Log10(ptmax));
[1408174]	227
[92237ca]	228	histGenPt->SetDirectory(0);
	229	histRecoPt->SetDirectory(0);
[1408174]	230
[92237ca]	231	BinLogX(histGenPt);
	232	BinLogX(histRecoPt);
[1408174]	233
	234	// Loop over all events
	235	for(entry = 0; entry < allEntries; ++entry)
	236	{
	237	// Load selected branches with data from specified event
	238	treeReader->ReadEntry(entry);
	239
	240	// Loop over all generated particle in event
	241	for(i = 0; i < branchParticle->GetEntriesFast(); ++i)
	242	{
	243
	244	particle = (GenParticle*) branchParticle->At(i);
	245	genMomentum = particle->P4();
	246
	247	deltaR = 999;
	248
[92237ca]	249	pt = genMomentum.Pt();
	250	eta = TMath::Abs(genMomentum.Eta());
	251
[cb159ed]	252
[92237ca]	253	if(eta > etamax \|\| eta < etamin ) continue;
[1408174]	254
[92237ca]	255	if (particle->PID == pdgID && genMomentum.Pt() > ptmin && genMomentum.Pt() < ptmax )
[534d945]	256	//if (TMath::Abs(particle->PID) == pdgID && (particle->Status>20 && particle->Status <30) && genMomentum.Pt() > ptmin && genMomentum.Pt() < ptmax )
[92237ca]	257	{
[1408174]	258	// Loop over all reco object in event
	259	for(j = 0; j < branchReco->GetEntriesFast(); ++j)
	260	{
	261	recoObj = (T*)branchReco->At(j);
	262	recoMomentum = recoObj->P4();
	263	//if(Momentum.Px() == 0 && genMomentum.Py() == 0) continue;
	264
[06a83b3]	265
	266
[1408174]	267	// take the closest parton candidate
	268	if(TMath::Abs(pdgID) == 5)
	269	{
	270	Jet jet = (Jet )recoObj;
[92237ca]	271	if( !(jet->BTag & (1 << 0)) ) continue;
	272
	273	//if(jet->BTag != ) continue;
	274	}
	275
	276	if(TMath::Abs(pdgID) == 4)
	277	{
	278	Jet jet = (Jet )recoObj;
	279	if( !(jet->BTag & (1 << 0)) ) continue;
	280	}
[cb159ed]	281
	282	if(TMath::Abs(pdgID) == 1)
[92237ca]	283	{
	284	Jet jet = (Jet )recoObj;
[06a83b3]	285	if( !(jet->BTag & (1 << 0)) ) continue;
[1408174]	286	}
[92237ca]	287
[1408174]	288	if(TMath::Abs(pdgID) == 15)
	289	{
	290	Jet jet = (Jet )recoObj;
	291	if(jet->TauTag != 1) continue;
	292	}
[92237ca]	293
	294
[1408174]	295	if(genMomentum.DeltaR(recoMomentum) < deltaR)
	296	{
	297	deltaR = genMomentum.DeltaR(recoMomentum);
	298	bestRecoMomentum = recoMomentum;
	299	}
	300	}
[92237ca]	301	histGenPt->Fill(pt);
[cb159ed]	302	if(deltaR < 0.3 && bestRecoMomentum.Pt()> 0.20*pt ) { histRecoPt->Fill(pt);}
[1408174]	303
[92237ca]	304	}
	305	}
	306	}
	307
	308	histRecoPt->Sumw2();
	309	histGenPt->Sumw2();
	310
	311	histRecoPt->Divide(histGenPt);
	312	histRecoPt->Scale(100.);
	313
	314	return histRecoPt;
	315	}
	316
[534d945]	317
[92237ca]	318	template<typename T>
	319	TH1D* GetEffEta(TClonesArray branchReco, TClonesArray branchParticle, TString name, int pdgID, double ptmin, double ptmax, double etamin, double etamax, ExRootTreeReader *treeReader)
	320	{
	321
	322	cout << "** Computing Efficiency of reconstructing "<< branchReco->GetName() << " induced by " << branchParticle->GetName() << " with PID " << pdgID << endl;
	323
	324	Long64_t allEntries = treeReader->GetEntries();
	325
	326	GenParticle *particle;
	327	T *recoObj;
	328
	329	TLorentzVector recoMomentum, genMomentum, bestRecoMomentum;
	330
	331	Float_t deltaR;
	332	Float_t pt, eta;
	333	Long64_t entry;
	334
	335	Int_t i, j;
	336
	337	TH1D *histGenEta = new TH1D(name+" gen spectra Eta",name+" gen spectra", Nbins, etamin, etamax);
	338	TH1D *histRecoEta = new TH1D(name+" reco spectra Eta",name+" reco spectra", Nbins, etamin, etamax);
	339
	340	histGenEta->SetDirectory(0);
	341	histRecoEta->SetDirectory(0);
	342
	343	// Loop over all events
	344	for(entry = 0; entry < allEntries; ++entry)
	345	{
	346	// Load selected branches with data from specified event
	347	treeReader->ReadEntry(entry);
	348
	349	// Loop over all generated particle in event
	350	for(i = 0; i < branchParticle->GetEntriesFast(); ++i)
	351	{
	352
	353	particle = (GenParticle*) branchParticle->At(i);
	354	genMomentum = particle->P4();
	355
	356	deltaR = 999;
	357
	358	pt = genMomentum.Pt();
	359	eta = genMomentum.Eta();
	360
	361	if(pt > ptmax \|\| pt < ptmin ) continue;
	362
	363	if (particle->PID == pdgID && genMomentum.Pt() > ptmin && genMomentum.Pt() < ptmax )
[534d945]	364	//if (TMath::Abs(particle->PID) == pdgID && (particle->Status>20 && particle->Status <30) && genMomentum.Pt() > ptmin && genMomentum.Pt() < ptmax )
[92237ca]	365	{
	366	// Loop over all reco object in event
	367	for(j = 0; j < branchReco->GetEntriesFast(); ++j)
[1408174]	368	{
[92237ca]	369	recoObj = (T*)branchReco->At(j);
	370	recoMomentum = recoObj->P4();
	371	// this is simply to avoid warnings from initial state particle
	372	// having infite rapidity ...
	373	//if(Momentum.Px() == 0 && genMomentum.Py() == 0) continue;
[1408174]	374
[92237ca]	375	// take the closest parton candidate
	376	if(TMath::Abs(pdgID) == 5)
	377	{
	378	Jet jet = (Jet )recoObj;
	379	if( !(jet->BTag & (1 << 0)) ) continue;
	380
	381	}
	382
	383	if(TMath::Abs(pdgID) == 4)
	384	{
	385	Jet jet = (Jet )recoObj;
	386	if( !(jet->BTag & (1 << 0)) ) continue;
	387	}
	388
	389	if(TMath::Abs(pdgID) == 1)
	390	{
	391	Jet jet = (Jet )recoObj;
	392	if( !(jet->BTag & (1 << 0)) ) continue;
	393	}
	394
	395	if(TMath::Abs(pdgID) == 15)
	396	{
	397	Jet jet = (Jet )recoObj;
	398	if(jet->TauTag != 1) continue;
	399	}
	400	if(genMomentum.DeltaR(recoMomentum) < deltaR)
	401	{
	402	deltaR = genMomentum.DeltaR(recoMomentum);
	403	bestRecoMomentum = recoMomentum;
	404	}
[1408174]	405	}
[92237ca]	406
	407	histGenEta->Fill(eta);
	408	if(deltaR < 0.3) { histRecoEta->Fill(eta); }
	409
[1408174]	410	}
	411	}
	412	}
	413
[92237ca]	414	histRecoEta->Sumw2();
	415	histGenEta->Sumw2();
[1408174]	416
[92237ca]	417	histRecoEta->Divide(histGenEta);
	418	histRecoEta->Scale(100.);
[1408174]	419
[92237ca]	420	return histRecoEta;
	421	}
[1408174]	422
	423
[534d945]	424	//------------------------------------------------------------------------------
	425
	426	template<typename T>
	427	TH1D* GetJetEffPt(TClonesArray branchJet, TString name, int pdgID, double ptmin, double ptmax, double etamin, double etamax, ExRootTreeReader treeReader)
	428	{
	429
	430	cout << "** Computing Efficiency of reconstructing "<< branchJet->GetName() << " with PID " << pdgID << endl;
	431
	432	Long64_t allEntries = treeReader->GetEntries();
	433
	434	T *recoObj;
	435
	436	TLorentzVector recoMomentum, genMomentum, bestRecoMomentum;
	437
	438	Float_t pt, eta;
	439	Long64_t entry;
	440
	441	Int_t j;
	442
	443	TH1D *histGenPt = new TH1D(name+" gen spectra Pt",name+" gen spectra cen", Nbins, TMath::Log10(ptmin), TMath::Log10(ptmax));
	444	TH1D *histRecoPt = new TH1D(name+" reco spectra Pt",name+" reco spectra cen", Nbins, TMath::Log10(ptmin), TMath::Log10(ptmax));
	445
	446	histGenPt->SetDirectory(0);
	447	histRecoPt->SetDirectory(0);
	448
	449	BinLogX(histGenPt);
	450	BinLogX(histRecoPt);
	451
	452	// Loop over all events
	453	for(entry = 0; entry < allEntries; ++entry)
	454	{
	455	// Load selected branches with data from specified event
	456	treeReader->ReadEntry(entry);
	457
	458	// Loop over all reco object in event
	459	for(j = 0; j < branchJet->GetEntriesFast(); ++j)
	460	{
	461	recoObj = (T*)branchJet->At(j);
	462	recoMomentum = recoObj->P4();
	463	pt = recoMomentum.Pt();
	464	eta = TMath::Abs(recoMomentum.Eta());
	465	Jet jet = (Jet )recoObj;
	466
	467	if(eta > etamax \|\| eta < etamin ) continue;
	468	if(pt < ptmin \|\| pt > ptmax) continue;
	469
	470	Int_t flavor = jet->Flavor;
	471	if(flavor == 21) flavor = 0;
	472
	473	if(TMath::Abs(pdgID) == 1)
	474	{
	475
	476	if(flavor < 4)
	477	{
	478	histGenPt->Fill(pt);
	479	if( jet->BTag & (1 << 0) ) histRecoPt->Fill(pt);
	480	}
	481	}
	482	if(TMath::Abs(pdgID) == 4)
	483	{
	484	if(flavor == 4)
	485	{
	486	histGenPt->Fill(pt);
	487	if( jet->BTag & (1 << 0) ) histRecoPt->Fill(pt);
	488	}
	489	}
	490	if(TMath::Abs(pdgID) == 5)
	491	{
	492	if(flavor == 5)
	493	{
	494	histGenPt->Fill(pt);
	495	if( jet->BTag & (1 << 0) ) histRecoPt->Fill(pt);
	496	}
	497	}
	498	}
	499
	500	}
	501
	502	histRecoPt->Sumw2();
	503	histGenPt->Sumw2();
	504
	505	histRecoPt->Divide(histGenPt);
	506	histRecoPt->Scale(100.);
	507
	508	return histRecoPt;
	509	}
	510
	511	// ------------------------------------------------------------------------------------------------------------------------------------------------------
	512
	513	template<typename T>
	514	TH1D* GetJetEffEta(TClonesArray branchJet, TString name, int pdgID, double ptmin, double ptmax, double etamin, double etamax, ExRootTreeReader treeReader)
	515	{
	516
	517	cout << "** Computing Efficiency of reconstructing "<< branchJet->GetName() << " with PID " << pdgID << endl;
	518
	519	Long64_t allEntries = treeReader->GetEntries();
	520
	521	T *recoObj;
	522
	523	TLorentzVector recoMomentum, genMomentum, bestRecoMomentum;
	524
	525	Float_t pt, eta;
	526	Long64_t entry;
	527
	528	Int_t j;
	529
	530	TH1D *histGenEta = new TH1D(name+" gen spectra Eta",name+" gen spectra", Nbins, etamin, etamax);
	531	TH1D *histRecoEta = new TH1D(name+" reco spectra Eta",name+" reco spectra", Nbins, etamin, etamax);
	532
	533	histGenEta->SetDirectory(0);
	534	histRecoEta->SetDirectory(0);
	535	// Loop over all events
	536	for(entry = 0; entry < allEntries; ++entry)
	537	{
	538	// Load selected branches with data from specified event
	539	treeReader->ReadEntry(entry);
	540
	541	// Loop over all reco object in event
	542	for(j = 0; j < branchJet->GetEntriesFast(); ++j)
	543	{
	544	recoObj = (T*)branchJet->At(j);
	545	recoMomentum = recoObj->P4();
	546	pt = recoMomentum.Pt();
	547	eta = recoMomentum.Eta();
	548	Jet jet = (Jet )recoObj;
	549
	550	if(eta > etamax \|\| eta < etamin ) continue;
	551	if(pt < ptmin \|\| pt > ptmax) continue;
	552
	553	Int_t flavor = jet->Flavor;
	554	if(flavor == 21) flavor = 0;
	555
	556	if(TMath::Abs(pdgID) == 1)
	557	{
	558	if(flavor == 1 \|\| flavor == 21)
	559	{
	560	histGenEta->Fill(eta);
	561	if( jet->BTag & (1 << 0) ) histRecoEta->Fill(eta);
	562	}
	563	}
	564	if(TMath::Abs(pdgID) == 4)
	565	{
	566	if(flavor == 4)
	567	{
	568	histGenEta->Fill(eta);
	569	if( jet->BTag & (1 << 0) ) histRecoEta->Fill(eta);
	570	}
	571	}
	572	if(TMath::Abs(pdgID) == 5)
	573	{
	574	if(flavor == 5)
	575	{
	576	histGenEta->Fill(eta);
	577	if( jet->BTag & (1 << 0) ) histRecoEta->Fill(eta);
	578	}
	579	}
	580	}
	581
	582	}
	583
	584
	585	histRecoEta->Sumw2();
	586	histGenEta->Sumw2();
	587
	588	histRecoEta->Divide(histGenEta);
	589	histRecoEta->Scale(100.);
	590
	591	return histRecoEta;
	592	}
	593
	594
	595	// -----------------------------------------------------------------------------------------------------------------------------------------------------
[1408174]	596
	597	template<typename T>
[92237ca]	598	TH1D* GetTauEffPt(TClonesArray branchReco, TClonesArray branchParticle, TString name, int pdgID, double ptmin, double ptmax, double etamin, double etamax, ExRootTreeReader *treeReader)
[1408174]	599	{
	600
[92237ca]	601	cout << "** Computing Efficiency of reconstructing "<< branchReco->GetName() << " induced by " << branchParticle->GetName() << " with PID " << pdgID << endl;
	602
	603	Long64_t allEntries = treeReader->GetEntries();
[1408174]	604
	605	GenParticle *particle;
[92237ca]	606	T *recoObj;
[1408174]	607
[92237ca]	608	TLorentzVector recoMomentum, genMomentum, bestRecoMomentum;
[1408174]	609
	610	Float_t deltaR;
	611	Float_t pt, eta;
	612	Long64_t entry;
	613
[92237ca]	614	Int_t i, j;
	615
	616	TH1D *histGenPt = new TH1D(name+" gen spectra Pt",name+" gen spectra cen", Nbins, TMath::Log10(ptmin), TMath::Log10(ptmax));
	617	TH1D *histRecoPt = new TH1D(name+" reco spectra Pt",name+" reco spectra cen", Nbins, TMath::Log10(ptmin), TMath::Log10(ptmax));
	618
	619	histGenPt->SetDirectory(0);
	620	histRecoPt->SetDirectory(0);
	621
	622	BinLogX(histGenPt);
	623	BinLogX(histRecoPt);
[1408174]	624
	625	// Loop over all events
	626	for(entry = 0; entry < allEntries; ++entry)
	627	{
	628	// Load selected branches with data from specified event
	629	treeReader->ReadEntry(entry);
	630
[92237ca]	631	// Loop over all generated particle in event
	632	for(i = 0; i < branchParticle->GetEntriesFast(); ++i)
[1408174]	633	{
[92237ca]	634
	635	particle = (GenParticle*) branchParticle->At(i);
	636	genMomentum = particle->P4();
[1408174]	637
	638	deltaR = 999;
	639
[92237ca]	640	pt = genMomentum.Pt();
	641	eta = TMath::Abs(genMomentum.Eta());
[1408174]	642
[92237ca]	643	if(eta > etamax \|\| eta < etamin ) continue;
	644
	645	if (particle->PID == pdgID && genMomentum.Pt() > ptmin && genMomentum.Pt() < ptmax )
	646	{
	647	// Loop over all reco object in event
	648	for(j = 0; j < branchReco->GetEntriesFast(); ++j)
	649	{
	650	recoObj = (T*)branchReco->At(j);
	651	recoMomentum = recoObj->P4();
[1408174]	652	// this is simply to avoid warnings from initial state particle
	653	// having infite rapidity ...
[92237ca]	654	//if(Momentum.Px() == 0 && genMomentum.Py() == 0) continue;
	655
	656	if(TMath::Abs(pdgID) == 1)
	657	{
	658	Jet jet = (Jet )recoObj;
	659	if( jet->TauTag != 1 ) continue;
	660	}
	661
	662	if(TMath::Abs(pdgID) == 15)
	663	{
	664	Jet jet = (Jet )recoObj;
	665	if(jet->TauTag != 1) continue;
	666	}
[1408174]	667
	668	if(genMomentum.DeltaR(recoMomentum) < deltaR)
	669	{
[92237ca]	670	deltaR = genMomentum.DeltaR(recoMomentum);
	671	bestRecoMomentum = recoMomentum;
[1408174]	672	}
	673	}
[92237ca]	674
	675	histGenPt->Fill(pt);
	676	if(deltaR < 0.3) { histRecoPt->Fill(pt); }
	677
[1408174]	678	}
[92237ca]	679	}
	680	}
[1408174]	681
[92237ca]	682	histRecoPt->Sumw2();
	683	histGenPt->Sumw2();
[1408174]	684
[92237ca]	685
	686	histRecoPt->Divide(histGenPt);
	687	histRecoPt->Scale(100.);
	688	if(TMath::Abs(pdgID) == 15) histRecoPt->Scale(1/0.648);
	689
	690	return histRecoPt;
	691	}
	692
	693	template<typename T>
	694	TH1D* GetTauEffEta(TClonesArray branchReco, TClonesArray branchParticle, TString name, int pdgID, double ptmin, double ptmax, double etamin, double etamax, ExRootTreeReader *treeReader)
	695	{
	696
	697	cout << "** Computing Efficiency of reconstructing "<< branchReco->GetName() << " induced by " << branchParticle->GetName() << " with PID " << pdgID << endl;
	698
	699	Long64_t allEntries = treeReader->GetEntries();
	700
	701	GenParticle *particle;
	702	T *recoObj;
	703
	704	TLorentzVector recoMomentum, genMomentum, bestRecoMomentum;
	705
	706	Float_t deltaR;
	707	Float_t pt, eta;
	708	Long64_t entry;
	709
	710	Int_t i, j;
	711
	712	TH1D *histGenEta = new TH1D(name+" gen spectra Eta",name+" gen spectra", Nbins, etamin, etamax);
	713	TH1D *histRecoEta = new TH1D(name+" reco spectra Eta",name+" reco spectra", Nbins, etamin, etamax);
	714
	715	histGenEta->SetDirectory(0);
	716	histRecoEta->SetDirectory(0);
	717
	718	// Loop over all events
	719	for(entry = 0; entry < allEntries; ++entry)
	720	{
	721	// Load selected branches with data from specified event
	722	treeReader->ReadEntry(entry);
	723
	724	// Loop over all generated particle in event
	725	for(i = 0; i < branchParticle->GetEntriesFast(); ++i)
	726	{
	727
	728	particle = (GenParticle*) branchParticle->At(i);
	729	genMomentum = particle->P4();
	730
	731	deltaR = 999;
	732
	733	pt = genMomentum.Pt();
	734	eta = genMomentum.Eta();
	735
	736	if(pt > ptmax \|\| pt < ptmin ) continue;
	737
	738	if (particle->PID == pdgID && genMomentum.Pt() > ptmin && genMomentum.Pt() < ptmax )
	739	{
	740	// Loop over all reco object in event
	741	for(j = 0; j < branchReco->GetEntriesFast(); ++j)
[1408174]	742	{
[92237ca]	743	recoObj = (T*)branchReco->At(j);
	744	recoMomentum = recoObj->P4();
	745	// this is simply to avoid warnings from initial state particle
	746	// having infite rapidity ...
	747	//if(Momentum.Px() == 0 && genMomentum.Py() == 0) continue;
	748
	749	if(TMath::Abs(pdgID) == 1)
	750	{
	751	Jet jet = (Jet )recoObj;
	752	if( jet->TauTag != 1 ) continue;
	753	}
	754
	755	if(TMath::Abs(pdgID) == 15)
[1408174]	756	{
[92237ca]	757	Jet jet = (Jet )recoObj;
	758	if(jet->TauTag != 1) continue;
	759	}
	760
	761	if(genMomentum.DeltaR(recoMomentum) < deltaR)
	762	{
	763	deltaR = genMomentum.DeltaR(recoMomentum);
	764	bestRecoMomentum = recoMomentum;
[1408174]	765	}
	766	}
[92237ca]	767
	768	histGenEta->Fill(eta);
	769	if(deltaR < 0.3) { histRecoEta->Fill(eta); }
	770
[1408174]	771	}
	772	}
	773	}
[92237ca]	774
	775	histRecoEta->Sumw2();
	776	histGenEta->Sumw2();
	777
	778	histRecoEta->Divide(histGenEta);
	779	histRecoEta->Scale(100.);
	780	if(TMath::Abs(pdgID) == 15) histRecoEta->Scale(1/0.648);
	781
	782	return histRecoEta;
[1408174]	783	}
[32677fb]	784
	785
	786	template<typename T>
[92237ca]	787	void GetPtres(std::vector<resolPlot> histos, TClonesArray branchReco, TClonesArray branchParticle, int pdgID, Double_t etaMin, Double_t etaMax, ExRootTreeReader treeReader)
[32677fb]	788	{
	789	Long64_t allEntries = treeReader->GetEntries();
	790
	791	cout << "** Computing pt resolution of " << branchReco->GetName() << " induced by " << branchParticle->GetName() << " with PID " << pdgID << endl;
	792
	793	GenParticle *particle;
	794	T* recoObj;
	795
	796	TLorentzVector recoMomentum, genMomentum, bestGenMomentum;
	797
	798	Float_t deltaR;
	799	Float_t pt, eta;
	800	Long64_t entry;
	801
	802	Int_t i, j, bin;
	803
	804	// Loop over all events
	805	for(entry = 0; entry < allEntries; ++entry)
	806	{
	807	// Load selected branches with data from specified event
	808	treeReader->ReadEntry(entry);
	809
	810	// Loop over all reconstructed jets in event
	811	for(i = 0; i < branchReco->GetEntriesFast(); ++i)
	812	{
	813	recoObj = (T*) branchReco->At(i);
	814	recoMomentum = recoObj->P4();
	815
	816	deltaR = 999;
	817
	818	// Loop over all hard partons in event
	819	for(j = 0; j < branchParticle->GetEntriesFast(); ++j)
	820	{
	821	particle = (GenParticle*) branchParticle->At(j);
	822	if (particle->PID == pdgID && particle->Status == 1)
	823	{
	824	genMomentum = particle->P4();
	825
	826	// this is simply to avoid warnings from initial state particle
	827	// having infite rapidity ...
	828	if(genMomentum.Px() == 0 && genMomentum.Py() == 0) continue;
	829
	830	// take the closest parton candidate
	831	if(genMomentum.DeltaR(recoMomentum) < deltaR)
	832	{
	833	deltaR = genMomentum.DeltaR(recoMomentum);
	834	bestGenMomentum = genMomentum;
	835	}
	836	}
	837	}
	838
	839	if(deltaR < 0.3)
	840	{
	841	pt = bestGenMomentum.Pt();
	842	eta = TMath::Abs(bestGenMomentum.Eta());
	843
	844	for (bin = 0; bin < Nbins; bin++)
	845	{
[92237ca]	846	if(pt > histos->at(bin).ptmin && pt < histos->at(bin).ptmax && eta > etaMin && eta < etaMax)
[32677fb]	847	{
[92237ca]	848	histos->at(bin).resolHist->Fill(recoMomentum.Pt()/bestGenMomentum.Pt());
[32677fb]	849	}
	850	}
	851	}
	852	}
	853	}
	854	}
	855
	856
[92237ca]	857	template<typename T>
	858	void GetEres(std::vector<resolPlot> histos, TClonesArray branchReco, TClonesArray branchParticle, int pdgID, Double_t etaMin, Double_t etaMax, ExRootTreeReader treeReader)
[1408174]	859	{
	860	Long64_t allEntries = treeReader->GetEntries();
	861
[92237ca]	862	cout << "** Computing e resolution of " << branchReco->GetName() << " induced by " << branchParticle->GetName() << " with PID " << pdgID << endl;
	863
	864	GenParticle *particle;
	865	T* recoObj;
	866
	867	TLorentzVector recoMomentum, genMomentum, bestGenMomentum;
	868
	869	Float_t deltaR;
	870	Float_t e, eta;
	871	Long64_t entry;
	872
	873	Int_t i, j, bin;
	874
	875	// Loop over all events
	876	for(entry = 0; entry < allEntries; ++entry)
	877	{
	878	// Load selected branches with data from specified event
	879	treeReader->ReadEntry(entry);
	880
	881	// Loop over all reconstructed jets in event
	882	for(i = 0; i < branchReco->GetEntriesFast(); ++i)
	883	{
	884	recoObj = (T*) branchReco->At(i);
	885	recoMomentum = recoObj->P4();
	886
	887	deltaR = 999;
	888
	889	// Loop over all hard partons in event
	890	for(j = 0; j < branchParticle->GetEntriesFast(); ++j)
	891	{
	892	particle = (GenParticle*) branchParticle->At(j);
	893	if (particle->PID == pdgID && particle->Status == 1)
	894	{
	895	genMomentum = particle->P4();
	896
	897	// this is simply to avoid warnings from initial state particle
	898	// having infite rapidity ...
	899	if(genMomentum.Px() == 0 && genMomentum.Py() == 0) continue;
	900
	901	// take the closest parton candidate
	902	if(genMomentum.DeltaR(recoMomentum) < deltaR)
	903	{
	904	deltaR = genMomentum.DeltaR(recoMomentum);
	905	bestGenMomentum = genMomentum;
	906	}
	907	}
	908	}
	909
	910	if(deltaR < 0.3)
	911	{
	912	e = bestGenMomentum.E();
	913	eta = TMath::Abs(bestGenMomentum.Eta());
	914
	915	for (bin = 0; bin < Nbins; bin++)
	916	{
	917	if(e > histos->at(bin).ptmin && e < histos->at(bin).ptmax && eta > etaMin && eta < etaMax)
	918	{
	919	histos->at(bin).resolHist->Fill(recoMomentum.E()/bestGenMomentum.E());
	920	}
	921	}
	922	}
	923	}
	924	}
	925	}
	926
	927
	928	template<typename T>
	929	void GetPtresVsEta(std::vector<resolPlot> histos, TClonesArray branchReco, TClonesArray branchParticle, int pdgID, Double_t ptMin, Double_t ptMax, ExRootTreeReader treeReader)
	930	{
	931	Long64_t allEntries = treeReader->GetEntries();
	932
	933	cout << "** Computing pt resolution of " << branchReco->GetName() << " induced by " << branchParticle->GetName() << " with PID " << pdgID << endl;
	934
	935	GenParticle *particle;
	936	T* recoObj;
	937
	938	TLorentzVector recoMomentum, genMomentum, bestGenMomentum;
	939
	940	Float_t deltaR;
	941	Float_t pt, eta;
	942	Long64_t entry;
	943
	944	Int_t i, j, bin;
	945
	946	// Loop over all events
	947	for(entry = 0; entry < allEntries; ++entry)
	948	{
	949	// Load selected branches with data from specified event
	950	treeReader->ReadEntry(entry);
	951
	952	// Loop over all reconstructed jets in event
	953	for(i = 0; i < branchReco->GetEntriesFast(); ++i)
	954	{
	955	recoObj = (T*) branchReco->At(i);
	956	recoMomentum = recoObj->P4();
	957
	958	deltaR = 999;
	959
	960	// Loop over all hard partons in event
	961	for(j = 0; j < branchParticle->GetEntriesFast(); ++j)
	962	{
	963	particle = (GenParticle*) branchParticle->At(j);
	964	if (particle->PID == pdgID && particle->Status == 1)
	965	{
	966	genMomentum = particle->P4();
	967
	968	// this is simply to avoid warnings from initial state particle
	969	// having infite rapidity ...
	970	if(genMomentum.Px() == 0 && genMomentum.Py() == 0) continue;
	971
	972	// take the closest parton candidate
	973	if(genMomentum.DeltaR(recoMomentum) < deltaR)
	974	{
	975	deltaR = genMomentum.DeltaR(recoMomentum);
	976	bestGenMomentum = genMomentum;
	977	}
	978	}
	979	}
	980
	981	if(deltaR < 0.3)
	982	{
	983	pt = bestGenMomentum.Pt();
	984	eta = bestGenMomentum.Eta();
	985
	986	for (bin = 0; bin < Nbins; bin++)
	987	{
	988	if(eta > histos->at(bin).etamin && eta < histos->at(bin).etamax && pt > ptMin && pt < ptMax)
	989	{
	990	histos->at(bin).resolHist->Fill(recoMomentum.Pt()/bestGenMomentum.Pt());
	991	}
	992	}
	993	}
	994	}
	995	}
	996	}
	997
	998	template<typename T>
	999	void GetEresVsEta(std::vector<resolPlot> histos, TClonesArray branchReco, TClonesArray branchParticle, int pdgID, Double_t eMin, Double_t eMax, ExRootTreeReader treeReader)
	1000	{
	1001	Long64_t allEntries = treeReader->GetEntries();
	1002
	1003	cout << "** Computing E resolution of " << branchReco->GetName() << " induced by " << branchParticle->GetName() << " with PID " << pdgID << endl;
	1004
	1005	GenParticle *particle;
	1006	T* recoObj;
	1007
	1008	TLorentzVector recoMomentum, genMomentum, bestGenMomentum;
	1009
	1010	Float_t deltaR;
	1011	Float_t e, eta;
	1012	Long64_t entry;
	1013
	1014	Int_t i, j, bin;
	1015
	1016	// Loop over all events
	1017	for(entry = 0; entry < allEntries; ++entry)
	1018	{
	1019	// Load selected branches with data from specified event
	1020	treeReader->ReadEntry(entry);
	1021
	1022	// Loop over all reconstructed jets in event
	1023	for(i = 0; i < branchReco->GetEntriesFast(); ++i)
	1024	{
	1025	recoObj = (T*) branchReco->At(i);
	1026	recoMomentum = recoObj->P4();
	1027
	1028	deltaR = 999;
	1029
	1030	// Loop over all hard partons in event
	1031	for(j = 0; j < branchParticle->GetEntriesFast(); ++j)
	1032	{
	1033	particle = (GenParticle*) branchParticle->At(j);
	1034	if (particle->PID == pdgID && particle->Status == 1)
	1035	{
	1036	genMomentum = particle->P4();
	1037
	1038	// this is simply to avoid warnings from initial state particle
	1039	// having infite rapidity ...
	1040	if(genMomentum.Px() == 0 && genMomentum.Py() == 0) continue;
	1041
	1042	// take the closest parton candidate
	1043	if(genMomentum.DeltaR(recoMomentum) < deltaR)
	1044	{
	1045	deltaR = genMomentum.DeltaR(recoMomentum);
	1046	bestGenMomentum = genMomentum;
	1047	}
	1048	}
	1049	}
	1050
	1051	if(deltaR < 0.3)
	1052	{
	1053	e = bestGenMomentum.E();
	1054	eta = bestGenMomentum.Eta();
	1055
	1056
	1057
	1058	for (bin = 0; bin < Nbins; bin++)
	1059	{
	1060	if(eta > histos->at(bin).etamin && eta < histos->at(bin).etamax && e > eMin && e < eMax)
	1061	{
	1062	histos->at(bin).resolHist->Fill(recoMomentum.E()/bestGenMomentum.E());
	1063	}
	1064	}
	1065	}
	1066	}
	1067	}
	1068	}
	1069
	1070
	1071
	1072	void GetJetsEres(std::vector<resolPlot> histos, TClonesArray branchJet, TClonesArray branchGenJet, ExRootTreeReader treeReader, Double_t etaMin, Double_t etaMax)
	1073	{
	1074
	1075	Long64_t allEntries = treeReader->GetEntries();
	1076
	1077	cout << "** Computing resolution of " << branchJet->GetName() << " induced by " << branchGenJet->GetName() << endl;
[1408174]	1078
	1079	Jet jet, genjet;
	1080
[92237ca]	1081	TLorentzVector jetMomentum, genJetMomentum, bestGenJetMomentum;
	1082
	1083	Float_t deltaR;
	1084	Float_t pt, eta;
	1085	Long64_t entry;
	1086
	1087	Int_t i, j, bin;
	1088
	1089	// Loop over all events
	1090	for(entry = 0; entry < allEntries; ++entry)
	1091	{
	1092	// Load selected branches with data from specified event
	1093	treeReader->ReadEntry(entry);
	1094
	1095	if(entry%10000 == 0) cout << "Event number: "<< entry <<endl;
	1096
	1097	// Loop over all reconstructed jets in event
	1098	for(i = 0; i < TMath::Min(2,branchJet->GetEntriesFast()); ++i) //branchJet->GetEntriesFast(); ++i)
	1099	{
	1100
	1101	jet = (Jet*) branchJet->At(i);
	1102	jetMomentum = jet->P4();
	1103
	1104	deltaR = 999;
	1105
	1106	// Loop over all hard partons in event
	1107	for(j = 0; j < TMath::Min(2,branchGenJet->GetEntriesFast()); ++j)
	1108	{
	1109	genjet = (Jet*) branchGenJet->At(j);
	1110
	1111	genJetMomentum = genjet->P4();
	1112
	1113	// this is simply to avoid warnings from initial state particle
	1114	// having infite rapidity ...
	1115	if(genJetMomentum.Px() == 0 && genJetMomentum.Py() == 0) continue;
	1116
	1117	// take the closest parton candidate
	1118	if(genJetMomentum.DeltaR(jetMomentum) < deltaR)
	1119	{
	1120	deltaR = genJetMomentum.DeltaR(jetMomentum);
	1121	bestGenJetMomentum = genJetMomentum;
	1122	}
	1123	}
	1124
	1125	if(deltaR < 0.3)
	1126	{
	1127	pt = genJetMomentum.E();
	1128	eta = genJetMomentum.Eta();
	1129
	1130	for (bin = 0; bin < Nbins; bin++)
	1131	{
	1132	if(pt > histos->at(bin).ptmin && pt < histos->at(bin).ptmax && eta < etaMax && eta > etaMin)
	1133	{
	1134	histos->at(bin).resolHist->Fill(jetMomentum.E()/bestGenJetMomentum.E());
	1135	}
	1136	}
	1137	}
	1138	}
	1139	}
	1140	}
	1141
	1142	void GetJetsEresVsEta(std::vector<resolPlot> histos, TClonesArray branchJet, TClonesArray branchGenJet, ExRootTreeReader treeReader, Double_t eMin, Double_t eMax)
	1143	{
	1144
	1145	Long64_t allEntries = treeReader->GetEntries();
	1146
	1147	cout << "** Computing resolution of " << branchJet->GetName() << " induced by " << branchGenJet->GetName() << endl;
	1148
	1149	Jet jet, genjet;
	1150
	1151	TLorentzVector jetMomentum, genJetMomentum, bestGenJetMomentum;
	1152
	1153	Float_t deltaR;
	1154	Float_t pt, eta;
	1155	Long64_t entry;
	1156
	1157	Int_t i, j, bin;
	1158
	1159	// Loop over all events
	1160	for(entry = 0; entry < allEntries; ++entry)
	1161	{
	1162	// Load selected branches with data from specified event
	1163	treeReader->ReadEntry(entry);
	1164
	1165	if(entry%10000 == 0) cout << "Event number: "<< entry <<endl;
	1166
	1167	// Loop over all reconstructed jets in event
	1168	for(i = 0; i < TMath::Min(2,branchJet->GetEntriesFast()); ++i) //branchJet->GetEntriesFast(); ++i)
	1169	{
	1170
	1171	jet = (Jet*) branchJet->At(i);
	1172	jetMomentum = jet->P4();
	1173
	1174	deltaR = 999;
	1175
	1176	// Loop over all hard partons in event
	1177	for(j = 0; j < TMath::Min(2,branchGenJet->GetEntriesFast()); ++j)
	1178	{
	1179	genjet = (Jet*) branchGenJet->At(j);
	1180
	1181	genJetMomentum = genjet->P4();
	1182
	1183	// this is simply to avoid warnings from initial state particle
	1184	// having infite rapidity ...
	1185	if(genJetMomentum.Px() == 0 && genJetMomentum.Py() == 0) continue;
	1186
	1187	// take the closest parton candidate
	1188	if(genJetMomentum.DeltaR(jetMomentum) < deltaR)
	1189	{
	1190	deltaR = genJetMomentum.DeltaR(jetMomentum);
	1191	bestGenJetMomentum = genJetMomentum;
	1192	}
	1193	}
	1194
	1195	if(deltaR < 0.3)
	1196	{
	1197
	1198	pt = genJetMomentum.E();
	1199	eta = genJetMomentum.Eta();
	1200
	1201	for (bin = 0; bin < Nbins; bin++)
	1202	{
	1203	if(eta > histos->at(bin).etamin && eta < histos->at(bin).etamax && pt < eMax && pt > eMin)
	1204	{
	1205	histos->at(bin).resolHist->Fill(jetMomentum.E()/bestGenJetMomentum.E());
	1206	}
	1207	}
	1208	}
	1209	}
	1210	}
	1211	}
	1212
	1213
	1214
	1215	std::pair<Double_t, Double_t> GausFit(TH1* hist)
	1216	{
	1217	TF1 f1 = new TF1("f1", "gaus", hist->GetMean()-2hist->GetRMS(), hist->GetMean()+2*hist->GetRMS());
	1218	hist->Fit("f1","RQ");
	1219
	1220	TF1 f2 = new TF1("f2", "gaus", f1->GetParameter(1) - 2f1->GetParameter(2), f1->GetParameter(1) + 2*f1->GetParameter(2));
	1221	hist->Fit("f2","RQ");
	1222
	1223	Double_t sig = f2->GetParameter(2);
	1224	Double_t sigErr = f2->GetParError(2);
	1225
	1226	delete f1;
	1227	delete f2;
	1228	return make_pair (sig, sigErr);
	1229	}
	1230
	1231
	1232	TGraphErrors EresGraph(std::vector<resolPlot> *histos, bool rms = false)
	1233	{
	1234	Int_t bin;
	1235	Int_t count = 0;
	1236	TGraphErrors gr = TGraphErrors(Nbins/2);
	1237	double val, error;
	1238	for (bin = 0; bin < Nbins; bin++)
	1239	{
	1240	std::pair<Double_t, Double_t> sigvalues = GausFit(histos->at(bin).resolHist);
	1241	if (rms == true)
	1242	{
	1243	gr.SetPoint(count,(histos->at(bin).ptmin+histos->at(bin).ptmax)/2.0, 100*histos->at(bin).resolHist->GetRMS());
	1244	//gr.SetPointError(count,0, 100*sigvalues.second); // to correct
	1245	error = 100*histos->at(bin).resolHist->GetRMSError();
	1246	val = 100*histos->at(bin).resolHist->GetRMS();
	1247	if(error > 0.2val) error = 0.2val;
	1248	gr.SetPointError(count,0, error); // to correct
	1249	}
	1250	else
	1251	{
	1252
	1253	gr.SetPoint(count,(histos->at(bin).ptmin+histos->at(bin).ptmax)/2.0, 100*sigvalues.first);
	1254	error = 100*sigvalues.second;
	1255	val = 100*sigvalues.first;
	1256	if(error > 0.2val) error = 0.2val;
	1257	gr.SetPointError(count,0, error); // to correct
	1258	//gr.SetPointError(count,0, 100*sigvalues.second);
	1259	}
	1260	count++;
	1261	}
	1262
	1263	return gr;
	1264	}
	1265
	1266	TGraphErrors MetResGraph(std::vector<resolPlot> *histos, bool rms = false)
	1267	{
	1268	Int_t bin;
	1269	Int_t count = 0;
	1270	TGraphErrors gr = TGraphErrors(Nbins/2);
	1271	double val, error;
	1272	for (bin = 0; bin < Nbins; bin++)
	1273	{
	1274	std::pair<Double_t, Double_t> sigvalues = GausFit(histos->at(bin).resolHist);
	1275	if (rms == true)
	1276	{
	1277	gr.SetPoint(count,(histos->at(bin).ptmin+histos->at(bin).ptmax)/2.0, histos->at(bin).resolHist->GetRMS());
	1278	error = histos->at(bin).resolHist->GetRMSError();
	1279	val = histos->at(bin).resolHist->GetRMS();
	1280	if(error > 0.2val) error = 0.2val;
	1281	gr.SetPointError(count,0, error); // to correct
	1282	}
	1283	else
	1284	{
	1285
	1286	gr.SetPoint(count,(histos->at(bin).ptmin+histos->at(bin).ptmax)/2.0, sigvalues.first);
	1287	val = sigvalues.first;
	1288	error = sigvalues.second;
	1289	if(error > 0.2val) error = 0.2val;
	1290	gr.SetPointError(count,0, error);
	1291	//gr.SetPointError(count,0, 100*sigvalues.second);
	1292	}
	1293	count++;
	1294	}
	1295
	1296	return gr;
	1297	}
	1298
	1299
	1300
	1301	TGraphErrors EresGraphVsEta(std::vector<resolPlot> *histos, bool rms = false)
	1302	{
	1303	Int_t bin;
	1304	Int_t count = 0;
	1305	TGraphErrors gr = TGraphErrors(Nbins/2);
	1306	double val, error;
	1307	for (bin = 0; bin < Nbins; bin++)
	1308	{
	1309
	1310	std::pair<Double_t, Double_t> sigvalues = GausFit(histos->at(bin).resolHist);
	1311	if (rms == true)
	1312	{
	1313	gr.SetPoint(count,(histos->at(bin).etamin+histos->at(bin).etamax)/2.0, histos->at(bin).resolHist->GetRMS());
	1314	error = 100*histos->at(bin).resolHist->GetRMSError();
	1315	val = 100*histos->at(bin).resolHist->GetRMS();
	1316	if(error > 0.2val) error = 0.2val;
	1317	gr.SetPointError(count,0, error); // to correct
	1318	}
	1319	else
	1320	{
	1321	gr.SetPoint(count,(histos->at(bin).etamin+histos->at(bin).etamax)/2.0, 100*sigvalues.first);
	1322	val = 100*sigvalues.first;
	1323	error = 100*sigvalues.second;
	1324	if(error > 0.2val) error = 0.2val;
	1325	gr.SetPointError(count,0, error);
	1326	//gr.SetPointError(count,0, 100*sigvalues.second);
	1327	}
	1328	count++;
	1329	}
	1330
	1331	return gr;
	1332	}
	1333
	1334	void GetMetres(std::vector<resolPlot> histos, TClonesArray branchScalarHT, TClonesArray branchMet, TClonesArray branchJet, ExRootTreeReader *treeReader)
	1335	{
	1336
	1337	Long64_t allEntries = treeReader->GetEntries();
	1338
	1339	cout << "** Computing resolution of " << branchMet->GetName() << " vs " << branchScalarHT->GetName() << endl;
	1340
	1341	MissingET *met;
	1342	ScalarHT *scalarHT;
	1343
	1344	Long64_t entry;
	1345
	1346	Int_t bin;
	1347	Double_t ht;
	1348
	1349	Jet *jet;
	1350	TLorentzVector p1, p2;
	1351
	1352	// Loop over all events
	1353	for(entry = 0; entry < allEntries; ++entry)
	1354	{
	1355	// Load selected branches with data from specified event
	1356	treeReader->ReadEntry(entry);
	1357
	1358	if(entry%10000 == 0) cout << "Event number: "<< entry <<endl;
	1359
	1360	if (branchJet->GetEntriesFast() > 1)
	1361	{
	1362
	1363	jet = (Jet*) branchJet->At(0);
	1364	p1 = jet->P4();
	1365	jet = (Jet*) branchJet->At(1);
	1366	p2 = jet->P4();
	1367
	1368	met = (MissingET*) branchMet->At(0);
	1369	scalarHT = (ScalarHT*) branchScalarHT->At(0);
	1370	ht = scalarHT->HT;
	1371
	1372	if(p1.Pt() < 0.75*ht/2) continue;
	1373	if(p2.Pt() < 0.75*ht/2) continue;
	1374
	1375	for (bin = 0; bin < Nbins; bin++)
	1376	{
	1377	if(ht > histos->at(bin).ptmin && ht < histos->at(bin).ptmax )
	1378	{
	1379	histos->at(bin).resolHist->Fill(met->P4().Px());
	1380	}
	1381	}
	1382	}
	1383	}
	1384	}
	1385
	1386
	1387
	1388	//------------------------------------------------------------------------------
	1389
	1390
	1391	void addResoGraph(TMultiGraph mg, TGraphErrors gr, TLegend *leg, int style, Color_t color, TString text)
	1392	{
	1393
	1394	gr->SetLineWidth(2);
	1395	gr->SetLineColor(color);
	1396	gr->SetMarkerStyle(style);
	1397	gr->SetMarkerColor(color);
	1398	gr->SetMarkerSize(1.5);
	1399
	1400	std::cout << "Adding " << gr->GetName() << std::endl;
	1401	mg->Add(gr);
	1402	leg->AddEntry(gr,text,"p");
	1403
	1404	}
	1405
	1406
	1407	void DrawAxis(TMultiGraph mg, TLegend leg, double xmin, double xmax, double ymin, double ymax, TString tx, TString ty, bool logx = 0, bool logy = 0)
	1408	{
	1409	mg->SetMinimum(ymin);
	1410	mg->SetMaximum(ymax);
	1411	mg->GetXaxis()->SetLimits(xmin,xmax);
	1412
	1413	mg->GetXaxis()->SetTitle(tx);
	1414	mg->GetYaxis()->SetTitle(ty);
	1415
	1416	mg->GetYaxis()->SetTitleSize(0.07);
	1417	mg->GetXaxis()->SetTitleSize(0.07);
	1418	mg->GetYaxis()->SetLabelSize(0.06);
	1419	mg->GetXaxis()->SetLabelSize(0.06);
	1420	mg->GetYaxis()->SetLabelOffset(0.03);
	1421	mg->GetYaxis()->SetTitleOffset(1.4);
	1422	mg->GetXaxis()->SetTitleOffset(1.4);
	1423
	1424	mg->GetXaxis()->SetTitleFont(132);
	1425	mg->GetYaxis()->SetTitleFont(132);
	1426	mg->GetXaxis()->SetLabelFont(132);
	1427	mg->GetYaxis()->SetLabelFont(132);
	1428
	1429	mg->GetYaxis()->SetNdivisions(505);
	1430
	1431	leg->SetTextFont(132);
	1432	leg->SetBorderSize(0);
	1433	leg->SetShadowColor(0);
	1434	leg->SetFillColor(0);
	1435	leg->SetFillStyle(0);
	1436
	1437	gStyle->SetOptTitle(0);
	1438
	1439	if(logx) gPad->SetLogx();
	1440	if(logy) gPad->SetLogy();
	1441
[85ad2b9]	1442
[92237ca]	1443	//gPad->SetGridx();
	1444	//gPad->SetGridy();
	1445	gPad->SetBottomMargin(0.2);
	1446	gPad->SetLeftMargin(0.2);
	1447	gPad->Modified();
	1448	gPad->Update();
	1449
	1450	}
	1451
	1452
[181c061]	1453	void DelphesValidation(
	1454	const char *inputFilePion,
	1455	const char *inputFileElectron,
	1456	const char *inputFileMuon,
	1457	const char *inputFilePhoton,
	1458	const char *inputFileNeutralHadron,
	1459	const char *inputFileJet,
	1460	const char *inputFileBJet,
	1461	const char *inputFileCJet,
	1462	const char *inputFileTauJet,
	1463	const char *outputFile,
	1464	const char *version)
[92237ca]	1465	{
	1466
	1467	TChain *chainPion = new TChain("Delphes");
	1468	chainPion->Add(inputFilePion);
	1469	ExRootTreeReader *treeReaderPion = new ExRootTreeReader(chainPion);
	1470
	1471	TChain *chainElectron = new TChain("Delphes");
	1472	chainElectron->Add(inputFileElectron);
	1473	ExRootTreeReader *treeReaderElectron = new ExRootTreeReader(chainElectron);
	1474
	1475	TChain *chainMuon = new TChain("Delphes");
	1476	chainMuon->Add(inputFileMuon);
	1477	ExRootTreeReader *treeReaderMuon = new ExRootTreeReader(chainMuon);
	1478
	1479	TChain *chainPhoton = new TChain("Delphes");
	1480	chainPhoton->Add(inputFilePhoton);
	1481	ExRootTreeReader *treeReaderPhoton = new ExRootTreeReader(chainPhoton);
	1482
	1483	TChain *chainNeutralHadron = new TChain("Delphes");
	1484	chainNeutralHadron->Add(inputFileNeutralHadron);
	1485	ExRootTreeReader *treeReaderNeutralHadron = new ExRootTreeReader(chainNeutralHadron);
	1486
	1487	TChain *chainJet = new TChain("Delphes");
	1488	chainJet->Add(inputFileJet);
	1489	ExRootTreeReader *treeReaderJet = new ExRootTreeReader(chainJet);
	1490
	1491	TChain *chainBJet = new TChain("Delphes");
	1492	chainBJet->Add(inputFileBJet);
	1493	ExRootTreeReader *treeReaderBJet = new ExRootTreeReader(chainBJet);
	1494
	1495	TChain *chainCJet = new TChain("Delphes");
	1496	chainCJet->Add(inputFileCJet);
	1497	ExRootTreeReader *treeReaderCJet = new ExRootTreeReader(chainCJet);
	1498
	1499	TChain *chainTauJet = new TChain("Delphes");
	1500	chainTauJet->Add(inputFileTauJet);
	1501	ExRootTreeReader *treeReaderTauJet = new ExRootTreeReader(chainTauJet);
	1502
	1503	TClonesArray *branchParticleElectron = treeReaderElectron->UseBranch("Particle");
	1504	TClonesArray *branchTrackElectron = treeReaderElectron->UseBranch("Track");
	1505	TClonesArray *branchElectron = treeReaderElectron->UseBranch("Electron");
[b4ec6ac]	1506	TClonesArray *branchElectronPF = treeReaderElectron->UseBranch("ElectronPF");
[92237ca]	1507
	1508	TClonesArray *branchParticleMuon = treeReaderMuon->UseBranch("Particle");
	1509	TClonesArray *branchTrackMuon = treeReaderMuon->UseBranch("Track");
	1510	TClonesArray *branchMuon = treeReaderMuon->UseBranch("Muon");
	1511
	1512	TClonesArray *branchParticlePion = treeReaderPion->UseBranch("Particle");
	1513	TClonesArray *branchTrackPion = treeReaderPion->UseBranch("Track");
	1514	TClonesArray *branchPion = treeReaderPion->UseBranch("Pion");
	1515
	1516	TClonesArray *branchParticlePhoton = treeReaderPhoton->UseBranch("Particle");
	1517	TClonesArray *branchTowerPhoton = treeReaderPhoton->UseBranch("Tower");
	1518	TClonesArray *branchPhoton = treeReaderPhoton->UseBranch("Photon");
	1519
	1520	TClonesArray *branchParticleNeutralHadron = treeReaderNeutralHadron->UseBranch("Particle");
	1521	TClonesArray *branchTowerNeutralHadron = treeReaderNeutralHadron->UseBranch("Tower");
	1522
	1523	TClonesArray *branchGenJet = treeReaderJet->UseBranch("GenJet");
	1524	TClonesArray *branchParticleJet = treeReaderJet->UseBranch("Particle");
[13cb1b6]	1525	TClonesArray *branchPFJet = treeReaderJet->UseBranch("PFJet");
[92237ca]	1526	TClonesArray *branchCaloJet = treeReaderJet->UseBranch("CaloJet");
[06a83b3]	1527	TClonesArray *branchJet = treeReaderJet->UseBranch("Jet");
[cb159ed]	1528
[92237ca]	1529	TClonesArray *branchParticleBJet = treeReaderBJet->UseBranch("Particle");
	1530	TClonesArray *branchPFBJet = treeReaderBJet->UseBranch("Jet");
	1531
	1532	TClonesArray *branchParticleCJet = treeReaderCJet->UseBranch("Particle");
	1533	TClonesArray *branchPFCJet = treeReaderCJet->UseBranch("Jet");
	1534
	1535	TClonesArray *branchParticleTauJet = treeReaderTauJet->UseBranch("Particle");
	1536	TClonesArray *branchPFTauJet = treeReaderTauJet->UseBranch("Jet");
	1537
	1538	TClonesArray *branchGenScalarHT = treeReaderJet->UseBranch("GenScalarHT");
[13cb1b6]	1539	TClonesArray *branchMet = treeReaderJet->UseBranch("PFMissingET");
[92237ca]	1540	TClonesArray *branchCaloMet = treeReaderJet->UseBranch("CaloMissingET");
	1541
	1542	std::vector<Color_t> colors;
	1543
	1544	colors.push_back(kBlack);
	1545	colors.push_back(kBlue);
	1546	colors.push_back(kRed);
	1547	colors.push_back(kGreen+1);
	1548	colors.push_back(kMagenta+1);
	1549	colors.push_back(kOrange);
	1550
	1551	std::vector<Int_t> markerStyles;
	1552
	1553	markerStyles.push_back(20);
	1554	markerStyles.push_back(21);
	1555	markerStyles.push_back(22);
	1556	markerStyles.push_back(23);
	1557	markerStyles.push_back(33);
	1558	markerStyles.push_back(34);
	1559
	1560	TString pdfOutput(outputFile);
	1561	pdfOutput.ReplaceAll(".root", ".pdf");
	1562
	1563	TString figPath = inputFilePion;
	1564	figPath.ReplaceAll(".root", "");
	1565	figPath.ReplaceAll("root", "www/fig");
	1566	Int_t lastSlash = figPath.Last('/');
	1567	Int_t sizePath = figPath.Length();
	1568	figPath.Remove(lastSlash+1,sizePath);
	1569
[85ad2b9]	1570	TString header = pdfOutput;
	1571	header.ReplaceAll(".pdf", "");
	1572	header.ReplaceAll("validation_", "");
	1573	lastSlash = header.Last('/');
	1574	sizePath = header.Length();
	1575	header.Remove(0,lastSlash+1);
	1576
	1577	TString vrs(version);
	1578
	1579	TPaveText *pave = new TPaveText(0.0, 0.89, 0.94, 0.94,"NDC");
[bba3653]	1580	pave->SetTextAlign(30);
[85ad2b9]	1581	pave->SetTextFont(132);
	1582	pave->SetBorderSize(0);
	1583	pave->SetShadowColor(0);
	1584	pave->SetFillColor(0);
	1585	pave->SetFillStyle(0);
	1586	pave->AddText("Delphes "+vrs+" - "+header);
	1587
[92237ca]	1588	TString s_etaMin, s_etaMax, s_eta, s_pt, s_e;
	1589
	1590	Double_t ptMin = 1.;
	1591	Double_t ptMax = 50000.;
	1592
	1593	Double_t etaMin = -6.;
	1594	Double_t etaMax = 6.;
	1595
	1596	std::vector<Double_t> ptVals;
	1597
	1598	ptVals.push_back(1.);
	1599	ptVals.push_back(10.);
	1600	ptVals.push_back(100.);
	1601	ptVals.push_back(1000.);
	1602	ptVals.push_back(10000.);
	1603
	1604	std::vector<Double_t> etaVals;
	1605
	1606	etaVals.push_back(0.);
	1607	etaVals.push_back(1.5);
	1608	etaVals.push_back(2.5);
	1609	etaVals.push_back(4.0);
	1610	etaVals.push_back(6.0);
	1611
	1612	const int n_etabins = etaVals.size()-1;
	1613	const int n_ptbins = ptVals.size();
	1614
	1615	//////////////////////////
	1616	// Tracking performance //
	1617	//////////////////////////
	1618
	1619	// --------- Pion Tracks --------- //
	1620
	1621	TMultiGraph *mg_trkpi_res_pt = new TMultiGraph("","");
	1622	TMultiGraph *mg_trkpi_eff_pt = new TMultiGraph("","");
	1623	TMultiGraph *mg_trkpi_res_eta = new TMultiGraph("","");
	1624	TMultiGraph *mg_trkpi_eff_eta = new TMultiGraph("","");
	1625
	1626	TLegend *leg_trkpi_res_pt = new TLegend(0.55,0.22,0.90,0.48);
	1627	TLegend leg_trkpi_eff_pt = (TLegend)leg_trkpi_res_pt->Clone();
	1628	TLegend leg_trkpi_res_eta = (TLegend)leg_trkpi_res_pt->Clone();
	1629	TLegend leg_trkpi_eff_eta = (TLegend)leg_trkpi_res_eta->Clone();
	1630
[dd5e213]	1631	TGraphErrors *gr_trkpi_res_pt = new TGraphErrors[n_etabins];
	1632	TGraphErrors *gr_trkpi_eff_pt = new TGraphErrors[n_etabins];
	1633	TGraphErrors *gr_trkpi_res_eta = new TGraphErrors[n_ptbins];
	1634	TGraphErrors *gr_trkpi_eff_eta = new TGraphErrors[n_ptbins];
[92237ca]	1635	TH1D* h_trkpi_eff_pt, *h_trkpi_eff_eta;
	1636
[dd5e213]	1637	std::vector<resolPlot> *plots_trkpi_res_pt = new std::vector<resolPlot>[n_etabins];
	1638	std::vector<resolPlot> *plots_trkpi_res_eta = new std::vector<resolPlot>[n_ptbins];
[92237ca]	1639
	1640	// loop over eta bins
	1641	for (k = 0; k < etaVals.size()-1; k++)
	1642	{
	1643	HistogramsCollection(&plots_trkpi_res_pt[k], TMath::Log10(ptMin), TMath::Log10(ptMax), "trkpi");
	1644	GetPtres<Track>(&plots_trkpi_res_pt[k], branchTrackPion, branchParticlePion, 211, etaVals.at(k), etaVals.at(k+1), treeReaderPion);
	1645	gr_trkpi_res_pt[k] = EresGraph(&plots_trkpi_res_pt[k]);
	1646
	1647	h_trkpi_eff_pt = GetEffPt<Track>(branchTrackPion, branchParticlePion, "Pion", 211, ptMin, ptMax, etaVals.at(k), etaVals.at(k+1), treeReaderPion);
	1648	gr_trkpi_eff_pt[k] = TGraphErrors(h_trkpi_eff_pt);
	1649
	1650	s_etaMin = Form("%.1f",etaVals.at(k));
	1651	s_etaMax = Form("%.1f",etaVals.at(k+1));
	1652
	1653	s_eta = "#pi^{ #pm} , " + s_etaMin + " < \| #eta \| < "+s_etaMax;
	1654
	1655	gr_trkpi_res_pt[k].SetName("trkRes_"+s_etaMin+"_"+s_etaMax);
	1656	gr_trkpi_eff_pt[k].SetName("trkEff_"+s_etaMin+"_"+s_etaMax);
	1657
	1658	addResoGraph(mg_trkpi_res_pt, &gr_trkpi_res_pt[k], leg_trkpi_res_pt, markerStyles.at(k), colors.at(k), s_eta);
	1659	addResoGraph(mg_trkpi_eff_pt, &gr_trkpi_eff_pt[k], leg_trkpi_eff_pt, markerStyles.at(k), colors.at(k), s_eta);
	1660	}
	1661
	1662	// loop over pt
	1663	for (k = 0; k < ptVals.size(); k++)
	1664	{
	1665	HistogramsCollectionVsEta(&plots_trkpi_res_eta[k], etaMin, etaMax, 0.5ptVals.at(k), 2.0ptVals.at(k), "trkpi", 0.0, 2.0);
	1666	GetPtresVsEta<Track>(&plots_trkpi_res_eta[k], branchTrackPion, branchParticlePion, 211, 0.5ptVals.at(k), 2.0ptVals.at(k), treeReaderPion);
	1667	gr_trkpi_res_eta[k] = EresGraphVsEta(&plots_trkpi_res_eta[k]);
	1668
	1669	h_trkpi_eff_eta = GetEffEta<Track>(branchTrackPion, branchParticlePion, "Pion", 211, 0.5ptVals.at(k), 2.0ptVals.at(k) ,etaMin, etaMax , treeReaderPion);
	1670	gr_trkpi_eff_eta[k] = TGraphErrors(h_trkpi_eff_eta);
	1671
	1672	s_pt = Form("#pi^{ #pm} , p_{T} = %.0f GeV",ptVals.at(k));
	1673	if(ptVals.at(k) >= 1000.) s_pt = Form("#pi^{ #pm} , p_{T} = %.0f TeV",ptVals.at(k)/1000.);
	1674
	1675	addResoGraph(mg_trkpi_res_eta, &gr_trkpi_res_eta[k], leg_trkpi_res_eta, markerStyles.at(k), colors.at(k), s_pt );
	1676	addResoGraph(mg_trkpi_eff_eta, &gr_trkpi_eff_eta[k], leg_trkpi_eff_eta, markerStyles.at(k), colors.at(k), s_pt );
	1677
	1678	}
	1679
	1680	TCanvas *c_trkpi_res_pt = new TCanvas("","", 800, 600);
	1681
	1682	mg_trkpi_res_pt->Draw("APE");
	1683	DrawAxis(mg_trkpi_res_pt, leg_trkpi_res_pt, ptMin, ptMax, 0.01, 100, "p_{T} [GeV]", "(track resolution in p_{T})/p_{T} (%)", true, true);
	1684	leg_trkpi_res_pt->Draw();
[85ad2b9]	1685	pave->Draw();
[92237ca]	1686
	1687	c_trkpi_res_pt->Print(pdfOutput+"(","pdf");
	1688	c_trkpi_res_pt->Print(figPath+"img_trkpi_res_pt.pdf","pdf");
	1689	c_trkpi_res_pt->Print(figPath+"img_trkpi_res_pt.png","png");
	1690
	1691	TCanvas *c_trkpi_res_eta = new TCanvas("","", 800, 600);
	1692
	1693	mg_trkpi_res_eta->Draw("APE");
	1694	DrawAxis(mg_trkpi_res_eta, leg_trkpi_res_eta, etaMin, etaMax, 0.01, 100, " #eta ", "(track resolution in p_{T})/p_{T} (%)", false, true);
	1695	leg_trkpi_res_eta->Draw();
[85ad2b9]	1696	pave->Draw();
[92237ca]	1697
	1698	c_trkpi_res_eta->Print(pdfOutput,"pdf");
	1699	c_trkpi_res_eta->Print(figPath+"img_trkpi_res_eta.pdf","pdf");
	1700	c_trkpi_res_eta->Print(figPath+"img_trkpi_res_eta.png","png");
	1701
	1702	TCanvas *c_trkpi_eff_pt = new TCanvas("","", 800, 600);
	1703
	1704	mg_trkpi_eff_pt->Draw("APE");
	1705	DrawAxis(mg_trkpi_eff_pt, leg_trkpi_eff_pt, ptMin, ptMax, 0.0, 100, "p_{T} [GeV]", "tracking efficiency (%)", true, false);
	1706	leg_trkpi_eff_pt->Draw();
[85ad2b9]	1707	pave->Draw();
[92237ca]	1708
	1709	c_trkpi_eff_pt->Print(pdfOutput,"pdf");
	1710	c_trkpi_eff_pt->Print(figPath+"img_trkpi_eff_pt.pdf","pdf");
	1711	c_trkpi_eff_pt->Print(figPath+"img_trkpi_eff_pt.png","png");
	1712
	1713	TCanvas *c_trkpi_eff_eta = new TCanvas("","", 800, 600);
	1714
	1715	mg_trkpi_eff_eta->Draw("APE");
	1716	DrawAxis(mg_trkpi_eff_eta, leg_trkpi_eff_eta, etaMin, etaMax, 0.0, 100, " #eta ", "tracking efficiency (%)", false, false);
	1717	leg_trkpi_eff_eta->Draw();
[85ad2b9]	1718	pave->Draw();
	1719
[92237ca]	1720
	1721	c_trkpi_eff_eta->Print(pdfOutput,"pdf");
	1722	c_trkpi_eff_eta->Print(figPath+"img_trkpi_eff_eta.pdf","pdf");
	1723	c_trkpi_eff_eta->Print(figPath+"img_trkpi_eff_eta.png","png");
	1724
	1725	// --------- Electron Tracks --------- //
	1726
	1727	TMultiGraph *mg_trkele_res_pt = new TMultiGraph("","");
	1728	TMultiGraph *mg_trkele_eff_pt = new TMultiGraph("","");
	1729	TMultiGraph *mg_trkele_res_eta = new TMultiGraph("","");
	1730	TMultiGraph *mg_trkele_eff_eta = new TMultiGraph("","");
	1731
	1732	TLegend *leg_trkele_res_pt = new TLegend(0.55,0.22,0.90,0.48);
	1733	TLegend leg_trkele_eff_pt = (TLegend)leg_trkele_res_pt->Clone();
	1734	TLegend leg_trkele_res_eta = (TLegend)leg_trkele_res_pt->Clone();
	1735	TLegend leg_trkele_eff_eta = (TLegend)leg_trkele_res_eta->Clone();
	1736
[dd5e213]	1737	TGraphErrors *gr_trkele_res_pt = new TGraphErrors[n_etabins];
	1738	TGraphErrors *gr_trkele_eff_pt = new TGraphErrors[n_etabins];
	1739	TGraphErrors *gr_trkele_res_eta = new TGraphErrors[n_ptbins];
	1740	TGraphErrors *gr_trkele_eff_eta = new TGraphErrors[n_ptbins];
	1741
[92237ca]	1742	TH1D* h_trkele_eff_pt, *h_trkele_eff_eta;
	1743
[dd5e213]	1744	std::vector<resolPlot> *plots_trkele_res_pt = new std::vector<resolPlot>[n_etabins];
	1745	std::vector<resolPlot> *plots_trkele_res_eta = new std::vector<resolPlot>[n_ptbins];
[92237ca]	1746
	1747	// loop over eta bins
	1748	for (k = 0; k < etaVals.size()-1; k++)
	1749	{
	1750	HistogramsCollection(&plots_trkele_res_pt[k], TMath::Log10(ptMin), TMath::Log10(ptMax), "trkele");
	1751	GetPtres<Track>(&plots_trkele_res_pt[k], branchTrackElectron, branchParticleElectron, 11, etaVals.at(k), etaVals.at(k+1), treeReaderElectron);
	1752	gr_trkele_res_pt[k] = EresGraph(&plots_trkele_res_pt[k]);
	1753
	1754	h_trkele_eff_pt = GetEffPt<Track>(branchTrackElectron, branchParticleElectron, "Electron", 11, ptMin, ptMax, etaVals.at(k), etaVals.at(k+1), treeReaderElectron);
	1755	gr_trkele_eff_pt[k] = TGraphErrors(h_trkele_eff_pt);
	1756
	1757	s_etaMin = Form("%.1f",etaVals.at(k));
	1758	s_etaMax = Form("%.1f",etaVals.at(k+1));
	1759
	1760	s_eta = "e^{ #pm} , " + s_etaMin + " < \| #eta \| < "+s_etaMax;
	1761
	1762	gr_trkele_res_pt[k].SetName("trkRes_"+s_etaMin+"_"+s_etaMax);
	1763	gr_trkele_eff_pt[k].SetName("trkEff_"+s_etaMin+"_"+s_etaMax);
	1764
	1765	addResoGraph(mg_trkele_res_pt, &gr_trkele_res_pt[k], leg_trkele_res_pt, markerStyles.at(k), colors.at(k), s_eta);
	1766	addResoGraph(mg_trkele_eff_pt, &gr_trkele_eff_pt[k], leg_trkele_eff_pt, markerStyles.at(k), colors.at(k), s_eta);
	1767	}
	1768
	1769	// loop over pt
	1770	for (k = 0; k < ptVals.size(); k++)
	1771	{
	1772	HistogramsCollectionVsEta(&plots_trkele_res_eta[k], etaMin, etaMax, 0.5ptVals.at(k), 2.0ptVals.at(k), "trkele", 0.0, 2.0);
	1773	GetPtresVsEta<Track>(&plots_trkele_res_eta[k], branchTrackElectron, branchParticleElectron, 11, 0.5ptVals.at(k), 2.0ptVals.at(k), treeReaderElectron);
	1774	gr_trkele_res_eta[k] = EresGraphVsEta(&plots_trkele_res_eta[k]);
	1775
	1776	h_trkele_eff_eta = GetEffEta<Track>(branchTrackElectron, branchParticleElectron, "Electron", 11, 0.5ptVals.at(k), 2.0ptVals.at(k) ,etaMin, etaMax , treeReaderElectron);
	1777	gr_trkele_eff_eta[k] = TGraphErrors(h_trkele_eff_eta);
	1778
	1779	s_pt = Form("e^{ #pm} , p_{T} = %.0f GeV",ptVals.at(k));
	1780	if(ptVals.at(k) >= 1000.) s_pt = Form("e^{ #pm} , p_{T} = %.0f TeV",ptVals.at(k)/1000.);
	1781
	1782	addResoGraph(mg_trkele_res_eta, &gr_trkele_res_eta[k], leg_trkele_res_eta, markerStyles.at(k), colors.at(k), s_pt );
	1783	addResoGraph(mg_trkele_eff_eta, &gr_trkele_eff_eta[k], leg_trkele_eff_eta, markerStyles.at(k), colors.at(k), s_pt );
	1784
	1785	}
	1786
	1787	TCanvas *c_trkele_res_pt = new TCanvas("","", 800, 600);
	1788
	1789	mg_trkele_res_pt->Draw("APE");
	1790	DrawAxis(mg_trkele_res_pt, leg_trkele_res_pt, ptMin, ptMax, 0.01, 100, "p_{T} [GeV]", "(track resolution in p_{T})/p_{T} (%)", true, true);
	1791	leg_trkele_res_pt->Draw();
[85ad2b9]	1792	pave->Draw();
[92237ca]	1793
	1794	c_trkele_res_pt->Print(pdfOutput,"pdf");
	1795	c_trkele_res_pt->Print(figPath+"img_trkele_res_pt.pdf","pdf");
	1796	c_trkele_res_pt->Print(figPath+"img_trkele_res_pt.png","png");
	1797
	1798	TCanvas *c_trkele_res_eta = new TCanvas("","", 800, 600);
	1799
	1800	mg_trkele_res_eta->Draw("APE");
	1801	DrawAxis(mg_trkele_res_eta, leg_trkele_res_eta, etaMin, etaMax, 0.01, 100, " #eta ", "(track resolution in p_{T})/p_{T} (%)", false, true);
	1802	leg_trkele_res_eta->Draw();
[85ad2b9]	1803	pave->Draw();
[92237ca]	1804
	1805	c_trkele_res_eta->Print(pdfOutput,"pdf");
	1806	c_trkele_res_eta->Print(figPath+"img_trkele_res_eta.pdf","pdf");
	1807	c_trkele_res_eta->Print(figPath+"img_trkele_res_eta.png","png");
	1808
	1809	TCanvas *c_trkele_eff_pt = new TCanvas("","", 800, 600);
	1810
	1811	mg_trkele_eff_pt->Draw("APE");
	1812	DrawAxis(mg_trkele_eff_pt, leg_trkele_eff_pt, ptMin, ptMax, 0.0, 100, "p_{T} [GeV]", "tracking efficiency (%)", true, false);
	1813	leg_trkele_eff_pt->Draw();
[85ad2b9]	1814	pave->Draw();
[92237ca]	1815
	1816	c_trkele_eff_pt->Print(pdfOutput,"pdf");
	1817	c_trkele_eff_pt->Print(figPath+"img_trkele_eff_pt.pdf","pdf");
	1818	c_trkele_eff_pt->Print(figPath+"img_trkele_eff_pt.png","png");
	1819
	1820	TCanvas *c_trkele_eff_eta = new TCanvas("","", 800, 600);
	1821
	1822	mg_trkele_eff_eta->Draw("APE");
	1823	DrawAxis(mg_trkele_eff_eta, leg_trkele_eff_eta, etaMin, etaMax, 0.0, 100, " #eta ", "tracking efficiency (%)", false, false);
	1824	leg_trkele_eff_eta->Draw();
[85ad2b9]	1825	pave->Draw();
[92237ca]	1826
	1827	c_trkele_eff_eta->Print(pdfOutput,"pdf");
	1828	c_trkele_eff_eta->Print(figPath+"img_trkele_eff_eta.pdf","pdf");
	1829	c_trkele_eff_eta->Print(figPath+"img_trkele_eff_eta.png","png");
	1830
	1831
	1832	// --------- Muon Tracks --------- //
	1833
	1834	TMultiGraph *mg_trkmu_res_pt = new TMultiGraph("","");
	1835	TMultiGraph *mg_trkmu_eff_pt = new TMultiGraph("","");
	1836	TMultiGraph *mg_trkmu_res_eta = new TMultiGraph("","");
	1837	TMultiGraph *mg_trkmu_eff_eta = new TMultiGraph("","");
	1838
	1839	TLegend *leg_trkmu_res_pt = new TLegend(0.55,0.22,0.90,0.48);
	1840	TLegend leg_trkmu_eff_pt = (TLegend)leg_trkmu_res_pt->Clone();
	1841
	1842	TLegend leg_trkmu_res_eta = (TLegend)leg_trkmu_res_pt->Clone();
	1843	TLegend leg_trkmu_eff_eta = (TLegend)leg_trkmu_res_eta->Clone();
	1844
	1845
[dd5e213]	1846	TGraphErrors *gr_trkmu_res_pt = new TGraphErrors[n_etabins];
	1847	TGraphErrors *gr_trkmu_eff_pt = new TGraphErrors[n_etabins];
	1848	TGraphErrors *gr_trkmu_res_eta = new TGraphErrors[n_ptbins];
	1849	TGraphErrors *gr_trkmu_eff_eta = new TGraphErrors[n_ptbins];
	1850
[92237ca]	1851	TH1D* h_trkmu_eff_pt, *h_trkmu_eff_eta;
	1852
[dd5e213]	1853	std::vector<resolPlot> *plots_trkmu_res_pt = new std::vector<resolPlot>[n_etabins];
	1854	std::vector<resolPlot> *plots_trkmu_res_eta = new std::vector<resolPlot>[n_ptbins];
[92237ca]	1855
	1856	// loop over eta bins
	1857	for (k = 0; k < etaVals.size()-1; k++)
	1858	{
	1859	HistogramsCollection(&plots_trkmu_res_pt[k], TMath::Log10(ptMin), TMath::Log10(ptMax), "trkmu");
	1860	GetPtres<Track>(&plots_trkmu_res_pt[k], branchTrackMuon, branchParticleMuon, 13, etaVals.at(k), etaVals.at(k+1), treeReaderMuon);
	1861	gr_trkmu_res_pt[k] = EresGraph(&plots_trkmu_res_pt[k]);
	1862
	1863	h_trkmu_eff_pt = GetEffPt<Track>(branchTrackMuon, branchParticleMuon, "Muon", 13, ptMin, ptMax, etaVals.at(k), etaVals.at(k+1), treeReaderMuon);
	1864	gr_trkmu_eff_pt[k] = TGraphErrors(h_trkmu_eff_pt);
	1865
	1866	s_etaMin = Form("%.1f",etaVals.at(k));
	1867	s_etaMax = Form("%.1f",etaVals.at(k+1));
	1868
	1869	s_eta = "#mu^{ #pm} , " + s_etaMin + " < \| #eta \| < "+s_etaMax;
	1870
	1871	gr_trkmu_res_pt[k].SetName("trkRes_"+s_etaMin+"_"+s_etaMax);
	1872	gr_trkmu_eff_pt[k].SetName("trkEff_"+s_etaMin+"_"+s_etaMax);
	1873
	1874	addResoGraph(mg_trkmu_res_pt, &gr_trkmu_res_pt[k], leg_trkmu_res_pt, markerStyles.at(k), colors.at(k), s_eta);
	1875	addResoGraph(mg_trkmu_eff_pt, &gr_trkmu_eff_pt[k], leg_trkmu_eff_pt, markerStyles.at(k), colors.at(k), s_eta);
	1876	}
	1877
	1878	// loop over pt
	1879	for (k = 0; k < ptVals.size(); k++)
	1880	{
	1881	HistogramsCollectionVsEta(&plots_trkmu_res_eta[k], etaMin, etaMax, 0.5ptVals.at(k), 2.0ptVals.at(k), "trkmu", 0.0, 2.0);
	1882	GetPtresVsEta<Track>(&plots_trkmu_res_eta[k], branchTrackMuon, branchParticleMuon, 13, 0.5ptVals.at(k), 2.0ptVals.at(k), treeReaderMuon);
	1883	gr_trkmu_res_eta[k] = EresGraphVsEta(&plots_trkmu_res_eta[k]);
	1884
	1885	h_trkmu_eff_eta = GetEffEta<Track>(branchTrackMuon, branchParticleMuon, "Muon", 13, 0.5ptVals.at(k), 2.0ptVals.at(k) ,etaMin, etaMax , treeReaderMuon);
	1886	gr_trkmu_eff_eta[k] = TGraphErrors(h_trkmu_eff_eta);
	1887
	1888	s_pt = Form("#mu^{ #pm} , p_{T} = %.0f GeV",ptVals.at(k));
	1889	if(ptVals.at(k) >= 1000.) s_pt = Form("#mu^{ #pm} , p_{T} = %.0f TeV",ptVals.at(k)/1000.);
	1890
	1891	addResoGraph(mg_trkmu_res_eta, &gr_trkmu_res_eta[k], leg_trkmu_res_eta, markerStyles.at(k), colors.at(k), s_pt );
	1892	addResoGraph(mg_trkmu_eff_eta, &gr_trkmu_eff_eta[k], leg_trkmu_eff_eta, markerStyles.at(k), colors.at(k), s_pt );
	1893
	1894	}
	1895
	1896	TCanvas *c_trkmu_res_pt = new TCanvas("","", 800, 600);
	1897
	1898	mg_trkmu_res_pt->Draw("APE");
	1899	DrawAxis(mg_trkmu_res_pt, leg_trkmu_res_pt, ptMin, ptMax, 0.01, 100, "p_{T} [GeV]", "(track resolution in p_{T})/p_{T} (%)", true, true);
	1900	leg_trkmu_res_pt->Draw();
[85ad2b9]	1901	pave->Draw();
[92237ca]	1902
	1903	c_trkmu_res_pt->Print(pdfOutput,"pdf");
	1904	c_trkmu_res_pt->Print(figPath+"img_trkmu_res_pt.pdf","pdf");
	1905	c_trkmu_res_pt->Print(figPath+"img_trkmu_res_pt.png","png");
	1906
	1907	TCanvas *c_trkmu_res_eta = new TCanvas("","", 800, 600);
	1908
	1909	mg_trkmu_res_eta->Draw("APE");
	1910	DrawAxis(mg_trkmu_res_eta, leg_trkmu_res_eta, etaMin, etaMax, 0.01, 100, " #eta ", "(track resolution in p_{T})/p_{T} (%)", false, true);
	1911	leg_trkmu_res_eta->Draw();
[85ad2b9]	1912	pave->Draw();
[92237ca]	1913
	1914	c_trkmu_res_eta->Print(pdfOutput,"pdf");
	1915	c_trkmu_res_eta->Print(figPath+"img_trkmu_res_eta.pdf","pdf");
	1916	c_trkmu_res_eta->Print(figPath+"img_trkmu_res_eta.png","png");
	1917
	1918	TCanvas *c_trkmu_eff_pt = new TCanvas("","", 800, 600);
	1919
	1920	mg_trkmu_eff_pt->Draw("APE");
	1921	DrawAxis(mg_trkmu_eff_pt, leg_trkmu_eff_pt, ptMin, ptMax, 0.0, 100, "p_{T} [GeV]", "tracking efficiency (%)", true, false);
	1922	leg_trkmu_eff_pt->Draw();
[85ad2b9]	1923	pave->Draw();
[92237ca]	1924
	1925	c_trkmu_eff_pt->Print(pdfOutput,"pdf");
	1926	c_trkmu_eff_pt->Print(figPath+"img_trkmu_eff_pt.pdf","pdf");
	1927	c_trkmu_eff_pt->Print(figPath+"img_trkmu_eff_pt.png","png");
	1928
	1929	TCanvas *c_trkmu_eff_eta = new TCanvas("","", 800, 600);
	1930
	1931	mg_trkmu_eff_eta->Draw("APE");
	1932	DrawAxis(mg_trkmu_eff_eta, leg_trkmu_eff_eta, etaMin, etaMax, 0.0, 100, " #eta ", "tracking efficiency (%)", false, false);
	1933	leg_trkmu_eff_eta->Draw();
[85ad2b9]	1934	pave->Draw();
[92237ca]	1935
	1936	c_trkmu_eff_eta->Print(pdfOutput,"pdf");
	1937	c_trkmu_eff_eta->Print(figPath+"img_trkmu_eff_eta.pdf","pdf");
	1938	c_trkmu_eff_eta->Print(figPath+"img_trkmu_eff_eta.png","png");
	1939
	1940
	1941	//////////////////////
	1942	// Ecal performance //
	1943	//////////////////////
	1944
	1945
	1946	TMultiGraph *mg_ecal_res_e = new TMultiGraph("","");
	1947	TMultiGraph *mg_ecal_res_eta = new TMultiGraph("","");
	1948
	1949	TLegend *leg_ecal_res_e = new TLegend(0.55,0.64,0.90,0.90);
	1950	TLegend *leg_ecal_res_eta = new TLegend(0.60,0.59,0.95,0.90);
	1951
[dd5e213]	1952	TGraphErrors *gr_ecal_res_e = new TGraphErrors[n_etabins];
	1953	TGraphErrors *gr_ecal_res_eta = new TGraphErrors[n_ptbins];
[92237ca]	1954
[dd5e213]	1955	std::vector<resolPlot> *plots_ecal_res_e = new std::vector<resolPlot>[n_etabins];
	1956	std::vector<resolPlot> *plots_ecal_res_eta = new std::vector<resolPlot>[n_ptbins];
[92237ca]	1957
	1958	// loop over eta bins
	1959	for (k = 0; k < etaVals.size()-1; k++)
	1960	{
	1961	HistogramsCollection(&plots_ecal_res_e[k], TMath::Log10(ptMin), TMath::Log10(ptMax), "ecal");
	1962	GetEres<Tower>(&plots_ecal_res_e[k], branchTowerPhoton, branchParticlePhoton, 22, etaVals.at(k), etaVals.at(k+1), treeReaderPhoton);
	1963	gr_ecal_res_e[k] = EresGraph(&plots_ecal_res_e[k]);
	1964
	1965	s_etaMin = Form("%.1f",etaVals.at(k));
	1966	s_etaMax = Form("%.1f",etaVals.at(k+1));
	1967
	1968	s_eta = "#gamma , " + s_etaMin + " < \| #eta \| < "+s_etaMax;
	1969
	1970	gr_ecal_res_e[k].SetName("trkRes_"+s_etaMin+"_"+s_etaMax);
	1971
	1972	addResoGraph(mg_ecal_res_e, &gr_ecal_res_e[k], leg_ecal_res_e, markerStyles.at(k), colors.at(k), s_eta);
	1973	}
	1974
	1975	// loop over pt
	1976	for (k = 0; k < ptVals.size(); k++)
	1977	{
	1978	HistogramsCollectionVsEta(&plots_ecal_res_eta[k], etaMin, etaMax, 0.5ptVals.at(k), 2.0ptVals.at(k), "ecal", 0.0, 2.0);
	1979	GetEresVsEta<Tower>(&plots_ecal_res_eta[k], branchTowerPhoton, branchParticlePhoton, 22, 0.5ptVals.at(k), 2.0ptVals.at(k), treeReaderPhoton);
	1980	gr_ecal_res_eta[k] = EresGraphVsEta(&plots_ecal_res_eta[k]);
	1981
	1982	s_e = Form("#gamma , E = %.0f GeV",ptVals.at(k));
	1983	if(ptVals.at(k) >= 1000.) s_e = Form("#gamma , E = %.0f TeV",ptVals.at(k)/1000.);
	1984
	1985	addResoGraph(mg_ecal_res_eta, &gr_ecal_res_eta[k], leg_ecal_res_eta, markerStyles.at(k), colors.at(k), s_e );
	1986	}
	1987
	1988	TCanvas *c_ecal_res_e = new TCanvas("","", 800, 600);
	1989
	1990	mg_ecal_res_e->Draw("APE");
	1991	// DrawAxis(mg_ecal_res_e, leg_ecal_res_e, ptMin, ptMax, 0.5, 100, "E [GeV]", "(ECAL resolution in E)/E (%)", true, true);
	1992	DrawAxis(mg_ecal_res_e, leg_ecal_res_e, ptMin, ptMax, 0.0, 20, "E [GeV]", "(ECAL resolution in E)/E (%)", true, false);
	1993	leg_ecal_res_e->Draw();
[85ad2b9]	1994	pave->Draw();
[92237ca]	1995
	1996	c_ecal_res_e->Print(pdfOutput,"pdf");
	1997	c_ecal_res_e->Print(figPath+"img_ecal_res_e.pdf","pdf");
	1998	c_ecal_res_e->Print(figPath+"img_ecal_res_e.png","png");
	1999
	2000	TCanvas *c_ecal_res_eta = new TCanvas("","", 800, 600);
	2001
	2002	mg_ecal_res_eta->Draw("APE");
	2003	//DrawAxis(mg_ecal_res_eta, leg_ecal_res_eta, etaMin, etaMax, 0.5, 100, " #eta ", "(ECAL resolution in E)/E (%)", false, true);
	2004	DrawAxis(mg_ecal_res_eta, leg_ecal_res_eta, etaMin, etaMax, 0.0, 20, " #eta ", "(ECAL resolution in E)/E (%)", false, false);
	2005	leg_ecal_res_eta->Draw();
[85ad2b9]	2006	pave->Draw();
[92237ca]	2007
	2008	c_ecal_res_eta->Print(pdfOutput,"pdf");
	2009	c_ecal_res_eta->Print(figPath+"img_ecal_res_eta.pdf","pdf");
	2010	c_ecal_res_eta->Print(figPath+"img_ecal_res_eta.png","png");
	2011
	2012	//////////////////////
	2013	// Hcal performance //
	2014	//////////////////////
	2015
	2016
	2017	TMultiGraph *mg_hcal_res_e = new TMultiGraph("","");
	2018	TMultiGraph *mg_hcal_res_eta = new TMultiGraph("","");
	2019
	2020	TLegend *leg_hcal_res_e = new TLegend(0.55,0.64,0.90,0.90);
	2021	TLegend *leg_hcal_res_eta = new TLegend(0.60,0.59,0.95,0.90);
	2022
[dd5e213]	2023	TGraphErrors *gr_hcal_res_e = new TGraphErrors[n_etabins];
	2024	TGraphErrors *gr_hcal_res_eta = new TGraphErrors[n_ptbins];
[92237ca]	2025
[dd5e213]	2026	std::vector<resolPlot> *plots_hcal_res_e = new std::vector<resolPlot>[n_etabins];
	2027	std::vector<resolPlot> *plots_hcal_res_eta = new std::vector<resolPlot>[n_ptbins];
[92237ca]	2028
	2029	// loop over eta bins
	2030	for (k = 0; k < etaVals.size()-1; k++)
	2031	{
	2032	HistogramsCollection(&plots_hcal_res_e[k], TMath::Log10(ptMin), TMath::Log10(ptMax), "hcal");
	2033	GetEres<Tower>(&plots_hcal_res_e[k], branchTowerNeutralHadron, branchParticleNeutralHadron, 2112, etaVals.at(k), etaVals.at(k+1), treeReaderNeutralHadron);
	2034
	2035	gr_hcal_res_e[k] = EresGraph(&plots_hcal_res_e[k]);
	2036
	2037	s_etaMin = Form("%.1f",etaVals.at(k));
	2038	s_etaMax = Form("%.1f",etaVals.at(k+1));
	2039
	2040	s_eta = "n , " + s_etaMin + " < \| #eta \| < "+s_etaMax;
	2041
	2042	gr_hcal_res_e[k].SetName("trkRes_"+s_etaMin+"_"+s_etaMax);
	2043
	2044	addResoGraph(mg_hcal_res_e, &gr_hcal_res_e[k], leg_hcal_res_e, markerStyles.at(k), colors.at(k), s_eta);
	2045	}
	2046
	2047	// loop over pt
	2048	for (k = 0; k < ptVals.size(); k++)
	2049	{
	2050	HistogramsCollectionVsEta(&plots_hcal_res_eta[k], etaMin, etaMax, 0.5ptVals.at(k), 2.0ptVals.at(k), "hcal", 0.0, 2.0);
	2051	GetEresVsEta<Tower>(&plots_hcal_res_eta[k], branchTowerNeutralHadron, branchParticleNeutralHadron, 2112, 0.5ptVals.at(k), 2.0ptVals.at(k), treeReaderNeutralHadron);
	2052	gr_hcal_res_eta[k] = EresGraphVsEta(&plots_hcal_res_eta[k]);
	2053
	2054	s_e = Form("n , E = %.0f GeV",ptVals.at(k));
	2055	if(ptVals.at(k) >= 1000.) s_e = Form("n , E = %.0f TeV",ptVals.at(k)/1000.);
	2056
	2057	addResoGraph(mg_hcal_res_eta, &gr_hcal_res_eta[k], leg_hcal_res_eta, markerStyles.at(k), colors.at(k), s_e );
	2058	}
	2059
	2060
	2061	TCanvas *c_hcal_res_e = new TCanvas("","", 800, 600);
	2062
	2063	mg_hcal_res_e->Draw("APE");
	2064	//DrawAxis(mg_hcal_res_e, leg_hcal_res_e, ptMin, ptMax, 1, 100, "E [GeV]", "(HCAL resolution in E)/E (%)", true, true);
	2065	DrawAxis(mg_hcal_res_e, leg_hcal_res_e, ptMin, ptMax, 0.0, 50, "E [GeV]", "(HCAL resolution in E)/E (%)", true, false);
	2066	leg_hcal_res_e->Draw();
[85ad2b9]	2067	pave->Draw();
[92237ca]	2068
	2069	c_hcal_res_e->Print(pdfOutput,"pdf");
	2070	c_hcal_res_e->Print(figPath+"img_hcal_res_e.pdf","pdf");
	2071	c_hcal_res_e->Print(figPath+"img_hcal_res_e.png","png");
	2072
	2073	TCanvas *c_hcal_res_eta = new TCanvas("","", 800, 600);
	2074
	2075	mg_hcal_res_eta->Draw("APE");
	2076	//DrawAxis(mg_hcal_res_eta, leg_hcal_res_eta, etaMin, etaMax, 1, 100, " #eta ", "(HCAL resolution in E)/E (%)", false, true);
	2077	DrawAxis(mg_hcal_res_eta, leg_hcal_res_eta, etaMin, etaMax, 0.0, 50, " #eta ", "(HCAL resolution in E)/E (%)", false, false);
	2078	leg_hcal_res_eta->Draw();
[85ad2b9]	2079	pave->Draw();
[92237ca]	2080
	2081	c_hcal_res_eta->Print(pdfOutput,"pdf");
	2082	c_hcal_res_eta->Print(figPath+"img_hcal_res_eta.pdf","pdf");
	2083	c_hcal_res_eta->Print(figPath+"img_hcal_res_eta.png","png");
	2084
	2085	////////////////////
	2086	// PF - electrons //
	2087	////////////////////
	2088
	2089	TMultiGraph *mg_pfele_res_e[n_etabins];
	2090	TMultiGraph *mg_pfele_res_eta[n_ptbins];
	2091
	2092	TLegend *leg_pfele_res_e[n_etabins];
	2093	TLegend *leg_pfele_res_eta[n_ptbins];
	2094
[dd5e213]	2095	TGraphErrors *gr_pfele_res_e = new TGraphErrors[n_etabins];
	2096	TGraphErrors *gr_pfele_res_eta = new TGraphErrors[n_ptbins];
	2097	TGraphErrors *gr_trkele_res_e = new TGraphErrors[n_etabins];
	2098	TGraphErrors *gr_trkele_res_eeta = new TGraphErrors[n_ptbins];
[cb159ed]	2099
[dd5e213]	2100	std::vector<resolPlot> *plots_pfele_res_e = new std::vector<resolPlot>[n_etabins];
	2101	std::vector<resolPlot> *plots_pfele_res_eta = new std::vector<resolPlot>[n_ptbins];
	2102	std::vector<resolPlot> *plots_trkele_res_e = new std::vector<resolPlot>[n_etabins];
	2103	std::vector<resolPlot> *plots_trkele_res_eeta = new std::vector<resolPlot>[n_ptbins];
[92237ca]	2104
	2105	TCanvas *c_pfele_res_e[n_etabins];
	2106	TCanvas *c_pfele_res_eta[n_ptbins];
	2107
	2108
	2109	// loop over eta bins
	2110	for (k = 0; k < etaVals.size()-1; k++)
	2111	{
	2112	mg_pfele_res_e[k] = new TMultiGraph("","");
	2113	leg_pfele_res_e[k] = new TLegend(0.40,0.60,0.75,0.90);
	2114
	2115	HistogramsCollection(&plots_pfele_res_e[k], TMath::Log10(ptMin), TMath::Log10(ptMax), "pfele");
[b4ec6ac]	2116	GetEres<Electron>(&plots_pfele_res_e[k], branchElectronPF, branchParticleElectron, 11, etaVals.at(k), etaVals.at(k+1), treeReaderElectron);
[92237ca]	2117	gr_pfele_res_e[k] = EresGraph(&plots_pfele_res_e[k]);
	2118
[cb159ed]	2119	HistogramsCollection(&plots_trkele_res_e[k], TMath::Log10(ptMin), TMath::Log10(ptMax), "trkele");
	2120	GetEres<Track>(&plots_trkele_res_e[k], branchTrackElectron, branchParticleElectron, 11, etaVals.at(k), etaVals.at(k+1), treeReaderElectron);
	2121	gr_trkele_res_e[k] = EresGraph(&plots_trkele_res_e[k]);
	2122
[92237ca]	2123	s_etaMin = Form("%.1f",etaVals.at(k));
	2124	s_etaMax = Form("%.1f",etaVals.at(k+1));
	2125	s_eta = "e^{ #pm}, "+ s_etaMin + " < \| #eta \| < " + s_etaMax;
	2126
	2127	leg_pfele_res_e[k]->SetTextFont(132);
	2128	leg_pfele_res_e[k]->SetHeader(s_eta);
	2129
[b4ec6ac]	2130	addResoGraph(mg_pfele_res_e[k], &gr_ecal_res_e[k], leg_pfele_res_e[k], markerStyles.at(0), colors.at(0), "ECAL");
[cb159ed]	2131	addResoGraph(mg_pfele_res_e[k], &gr_trkele_res_e[k], leg_pfele_res_e[k], markerStyles.at(1), colors.at(1), "Track");
[b4ec6ac]	2132	addResoGraph(mg_pfele_res_e[k], &gr_pfele_res_e[k], leg_pfele_res_e[k], markerStyles.at(2), colors.at(2), "Particle-flow");
[92237ca]	2133
	2134	c_pfele_res_e[k] = new TCanvas("","", 800, 600);
	2135
	2136	mg_pfele_res_e[k]->Draw("APE");
	2137	//DrawAxis(mg_pfele_res_e[k], leg_pfele_res_e[k], ptMin, ptMax, 0.1, 100, "E [GeV]", "(resolution in E)/E (%)", true, true);
	2138	DrawAxis(mg_pfele_res_e[k], leg_pfele_res_e[k], ptMin, ptMax, 0.0, 20, "E [GeV]", "(resolution in E)/E (%)", true, false);
	2139	leg_pfele_res_e[k]->Draw();
[85ad2b9]	2140	pave->Draw();
[92237ca]	2141
	2142	TString s_etarange = "eta_"+s_etaMin+"_"+s_etaMax+"_";
	2143
	2144	c_pfele_res_e[k]->Print(pdfOutput,"pdf");
	2145	c_pfele_res_e[k]->Print(figPath+"img_pfele_res_"+s_etarange+"e.pdf","pdf");
	2146	c_pfele_res_e[k]->Print(figPath+"img_pfele_res_"+s_etarange+"e.png","png");
	2147
	2148	}
	2149
	2150
	2151	// loop over eta bins
	2152	for (k = 0; k < ptVals.size(); k++)
	2153	{
	2154
	2155	mg_pfele_res_eta[k] = new TMultiGraph("","");
	2156	leg_pfele_res_eta[k] = new TLegend(0.40,0.60,0.75,0.90);
	2157
	2158	HistogramsCollectionVsEta(&plots_pfele_res_eta[k], etaMin, etaMax, 0.5ptVals.at(k), 2.0ptVals.at(k), "pfele", 0.0, 2.0);
[b4ec6ac]	2159	GetEresVsEta<Electron>(&plots_pfele_res_eta[k], branchElectronPF, branchParticleElectron, 11, 0.5ptVals.at(k), 2.0ptVals.at(k), treeReaderElectron);
[92237ca]	2160	gr_pfele_res_eta[k] = EresGraphVsEta(&plots_pfele_res_eta[k]);
	2161
[cb159ed]	2162	HistogramsCollectionVsEta(&plots_trkele_res_eeta[k], etaMin, etaMax, 0.5ptVals.at(k), 2.0ptVals.at(k), "trkele", 0.0, 2.0);
	2163	GetEresVsEta<Track>(&plots_trkele_res_eeta[k], branchTrackElectron, branchParticleElectron, 11, 0.5ptVals.at(k), 2.0ptVals.at(k), treeReaderElectron);
	2164	gr_trkele_res_eeta[k] = EresGraphVsEta(&plots_trkele_res_eeta[k]);
	2165
[92237ca]	2166	s_e = Form("e^{ #pm}, E = %.0f GeV",ptVals.at(k));
	2167	if(ptVals.at(k) >= 1000.) s_e = Form("e^{ #pm}, E = %.0f TeV",ptVals.at(k)/1000.);
	2168
	2169
	2170	leg_pfele_res_eta[k]->SetTextFont(132);
	2171	leg_pfele_res_eta[k]->SetHeader(s_e);
	2172
[b4ec6ac]	2173	addResoGraph(mg_pfele_res_eta[k], &gr_ecal_res_eta[k], leg_pfele_res_eta[k], markerStyles.at(0), colors.at(0), "ECAL");
[cb159ed]	2174	addResoGraph(mg_pfele_res_eta[k], &gr_trkele_res_eeta[k], leg_pfele_res_eta[k], markerStyles.at(1), colors.at(1), "Track");
[b4ec6ac]	2175	addResoGraph(mg_pfele_res_eta[k], &gr_pfele_res_eta[k], leg_pfele_res_eta[k], markerStyles.at(2), colors.at(2), "Particle-flow");
[92237ca]	2176
	2177	c_pfele_res_eta[k] = new TCanvas("","", 800, 600);
	2178
	2179	mg_pfele_res_eta[k]->Draw("APE");
	2180	//DrawAxis(mg_pfele_res_eta[k], leg_pfele_res_eta[k], etaMin, etaMax, 0.1, 1000, "#eta", "(resolution in E)/E (%)", false, true);
	2181	DrawAxis(mg_pfele_res_eta[k], leg_pfele_res_eta[k], etaMin, etaMax, 0.0, 50, "#eta", "(resolution in E)/E (%)", false, false);
	2182	leg_pfele_res_eta[k]->Draw();
[85ad2b9]	2183	pave->Draw();
[92237ca]	2184
	2185	TString s_ptrange = Form("pt_%.0f_",ptVals.at(k));
	2186
	2187	c_pfele_res_eta[k]->Print(pdfOutput,"pdf");
	2188	c_pfele_res_eta[k]->Print(figPath+"img_pfele_res_"+s_ptrange+"eta.pdf","pdf");
	2189	c_pfele_res_eta[k]->Print(figPath+"img_pfele_res_"+s_ptrange+"eta.png","png");
	2190
	2191	}
	2192
	2193	/////////////////
	2194	// PF - Pions //
	2195	/////////////////
	2196
	2197	TMultiGraph *mg_pfpi_res_e[n_etabins];
	2198	TMultiGraph *mg_pfpi_res_eta[n_ptbins];
	2199
	2200	TLegend *leg_pfpi_res_e[n_etabins];
	2201	TLegend *leg_pfpi_res_eta[n_ptbins];
	2202
[dd5e213]	2203	TGraphErrors *gr_pfpi_res_e = new TGraphErrors[n_etabins];
	2204	TGraphErrors *gr_pfpi_res_eta = new TGraphErrors[n_ptbins];
[92237ca]	2205
[dd5e213]	2206	TGraphErrors *gr_trkpi_res_e = new TGraphErrors[n_etabins];
	2207	TGraphErrors *gr_trkpi_res_eeta = new TGraphErrors[n_ptbins];
[cb159ed]	2208
[dd5e213]	2209	std::vector<resolPlot> *plots_pfpi_res_e = new std::vector<resolPlot>[n_etabins];
	2210	std::vector<resolPlot> *plots_pfpi_res_eta = new std::vector<resolPlot>[n_ptbins];
	2211	std::vector<resolPlot> *plots_trkpi_res_e = new std::vector<resolPlot>[n_etabins];
	2212	std::vector<resolPlot> *plots_trkpi_res_eeta = new std::vector<resolPlot>[n_ptbins];
[92237ca]	2213
	2214	TCanvas *c_pfpi_res_e[n_etabins];
	2215	TCanvas *c_pfpi_res_eta[n_ptbins];
	2216
	2217
	2218	// loop over eta bins
	2219	for (k = 0; k < etaVals.size()-1; k++)
	2220	{
	2221	mg_pfpi_res_e[k] = new TMultiGraph("","");
	2222	leg_pfpi_res_e[k] = new TLegend(0.40,0.60,0.75,0.90);
	2223
	2224	HistogramsCollection(&plots_pfpi_res_e[k], TMath::Log10(ptMin), TMath::Log10(ptMax), "pfpi");
	2225	GetEres<Track>(&plots_pfpi_res_e[k], branchPion, branchParticlePion, 211, etaVals.at(k), etaVals.at(k+1), treeReaderPion);
	2226	gr_pfpi_res_e[k] = EresGraph(&plots_pfpi_res_e[k]);
	2227
[cb159ed]	2228	HistogramsCollection(&plots_trkpi_res_e[k], TMath::Log10(ptMin), TMath::Log10(ptMax), "trkpi");
	2229	GetEres<Track>(&plots_trkpi_res_e[k], branchTrackPion, branchParticlePion, 211, etaVals.at(k), etaVals.at(k+1), treeReaderPion);
	2230	gr_trkpi_res_e[k] = EresGraph(&plots_trkpi_res_e[k]);
	2231
	2232
[92237ca]	2233	s_etaMin = Form("%.1f",etaVals.at(k));
	2234	s_etaMax = Form("%.1f",etaVals.at(k+1));
	2235	s_eta = "#pi^{ #pm}, "+ s_etaMin + " < \| #eta \| < " + s_etaMax;
	2236
	2237	leg_pfpi_res_e[k]->SetTextFont(132);
	2238	leg_pfpi_res_e[k]->SetHeader(s_eta);
	2239
[b4ec6ac]	2240	addResoGraph(mg_pfpi_res_e[k], &gr_hcal_res_e[k], leg_pfpi_res_e[k], markerStyles.at(0), colors.at(0), "HCAL");
[cb159ed]	2241	addResoGraph(mg_pfpi_res_e[k], &gr_trkpi_res_e[k], leg_pfpi_res_e[k], markerStyles.at(1), colors.at(1), "Track");
[b4ec6ac]	2242	addResoGraph(mg_pfpi_res_e[k], &gr_pfpi_res_e[k], leg_pfpi_res_e[k], markerStyles.at(2), colors.at(2), "Particle-flow");
[92237ca]	2243
	2244	c_pfpi_res_e[k] = new TCanvas("","", 800, 600);
	2245
	2246	mg_pfpi_res_e[k]->Draw("APE");
	2247	//DrawAxis(mg_pfpi_res_e[k], leg_pfpi_res_e[k], ptMin, ptMax, 0.1, 100, "E [GeV]", "(resolution in E)/E (%)", true, true);
	2248	DrawAxis(mg_pfpi_res_e[k], leg_pfpi_res_e[k], ptMin, ptMax, 0.1, 50, "E [GeV]", "(resolution in E)/E (%)", true, false);
	2249	leg_pfpi_res_e[k]->Draw();
[85ad2b9]	2250	pave->Draw();
[92237ca]	2251
	2252	TString s_etarange = "eta_"+s_etaMin+"_"+s_etaMax+"_";
	2253
	2254	c_pfpi_res_e[k]->Print(pdfOutput,"pdf");
	2255	c_pfpi_res_e[k]->Print(figPath+"img_pfpi_res_"+s_etarange+"e.pdf","pdf");
	2256	c_pfpi_res_e[k]->Print(figPath+"img_pfpi_res_"+s_etarange+"e.png","png");
	2257
	2258	}
	2259
	2260
	2261	// loop over eta bins
	2262	for (k = 0; k < ptVals.size(); k++)
	2263	{
	2264
	2265	mg_pfpi_res_eta[k] = new TMultiGraph("","");
	2266	leg_pfpi_res_eta[k] = new TLegend(0.40,0.60,0.75,0.90);
	2267
	2268	HistogramsCollectionVsEta(&plots_pfpi_res_eta[k], etaMin, etaMax, 0.5ptVals.at(k), 2.0ptVals.at(k), "pfpi", 0.0, 2.0);
	2269	GetEresVsEta<Track>(&plots_pfpi_res_eta[k], branchPion, branchParticlePion, 211, 0.5ptVals.at(k), 2.0ptVals.at(k), treeReaderPion);
	2270	gr_pfpi_res_eta[k] = EresGraphVsEta(&plots_pfpi_res_eta[k]);
	2271
[cb159ed]	2272	HistogramsCollectionVsEta(&plots_trkpi_res_eeta[k], etaMin, etaMax, 0.5ptVals.at(k), 2.0ptVals.at(k), "trkpi", 0.0, 2.0);
	2273	GetEresVsEta<Track>(&plots_trkpi_res_eeta[k], branchPion, branchParticlePion, 211, 0.5ptVals.at(k), 2.0ptVals.at(k), treeReaderPion);
	2274	gr_trkpi_res_eeta[k] = EresGraphVsEta(&plots_trkpi_res_eeta[k]);
	2275
	2276
[92237ca]	2277	s_e = Form("#pi^{ #pm}, E = %.0f GeV",ptVals.at(k));
	2278	if(ptVals.at(k) >= 1000.) s_e = Form("#pi^{ #pm}, E = %.0f TeV",ptVals.at(k)/1000.);
	2279
	2280	leg_pfpi_res_eta[k]->SetTextFont(132);
	2281	leg_pfpi_res_eta[k]->SetHeader(s_e);
	2282
[b4ec6ac]	2283	addResoGraph(mg_pfpi_res_eta[k], &gr_hcal_res_eta[k], leg_pfpi_res_eta[k], markerStyles.at(0), colors.at(0), "HCAL");
[cb159ed]	2284	addResoGraph(mg_pfpi_res_eta[k], &gr_trkpi_res_eeta[k], leg_pfpi_res_eta[k], markerStyles.at(1), colors.at(1), "Track");
[b4ec6ac]	2285	addResoGraph(mg_pfpi_res_eta[k], &gr_pfpi_res_eta[k], leg_pfpi_res_eta[k], markerStyles.at(2), colors.at(2), "Particle-flow");
[92237ca]	2286
	2287	c_pfpi_res_eta[k] = new TCanvas("","", 800, 600);
	2288
	2289	mg_pfpi_res_eta[k]->Draw("APE");
	2290	//DrawAxis(mg_pfpi_res_eta[k], leg_pfpi_res_eta[k], etaMin, etaMax, 0.1, 1000, "#eta", "(resolution in E)/E (%)", false, true);
	2291	DrawAxis(mg_pfpi_res_eta[k], leg_pfpi_res_eta[k], etaMin, etaMax, 0.0, 50, "#eta", "(resolution in E)/E (%)", false, false);
	2292	leg_pfpi_res_eta[k]->Draw();
[85ad2b9]	2293	pave->Draw();
[92237ca]	2294
	2295	TString s_ptrange = Form("pt_%.0f_",ptVals.at(k));
	2296
	2297	c_pfpi_res_eta[k]->Print(pdfOutput,"pdf");
	2298	c_pfpi_res_eta[k]->Print(figPath+"img_pfpi_res_"+s_ptrange+"eta.pdf","pdf");
	2299	c_pfpi_res_eta[k]->Print(figPath+"img_pfpi_res_"+s_ptrange+"eta.png","png");
	2300
	2301	}
	2302
	2303
	2304	/////////////////
	2305	// PF - jets //
	2306	/////////////////
	2307
	2308	TMultiGraph *mg_pfjet_res_e[n_etabins];
	2309	TMultiGraph *mg_pfjet_res_eta[n_ptbins];
	2310
	2311	TLegend *leg_pfjet_res_e[n_etabins];
	2312	TLegend *leg_pfjet_res_eta[n_ptbins];
	2313
[dd5e213]	2314	TGraphErrors *gr_pfjet_res_e = new TGraphErrors[n_etabins];
	2315	TGraphErrors *gr_pfjet_res_eta = new TGraphErrors[n_ptbins];
[92237ca]	2316
[dd5e213]	2317	TGraphErrors *gr_cajet_res_e = new TGraphErrors[n_etabins];
	2318	TGraphErrors *gr_cajet_res_eta = new TGraphErrors[n_ptbins];
[92237ca]	2319
[dd5e213]	2320	std::vector<resolPlot> *plots_pfjet_res_e = new std::vector<resolPlot>[n_etabins];
	2321	std::vector<resolPlot> *plots_pfjet_res_eta = new std::vector<resolPlot>[n_ptbins];
	2322	std::vector<resolPlot> *plots_cajet_res_e = new std::vector<resolPlot>[n_etabins];
	2323	std::vector<resolPlot> *plots_cajet_res_eta = new std::vector<resolPlot>[n_ptbins];
[92237ca]	2324
	2325	TCanvas *c_pfjet_res_e[n_etabins];
	2326	TCanvas *c_pfjet_res_eta[n_ptbins];
	2327
	2328
	2329	// loop over eta bins
	2330	for (k = 0; k < etaVals.size()-1; k++)
	2331	{
	2332
	2333	mg_pfjet_res_e[k] = new TMultiGraph("","");
[b4ec6ac]	2334	leg_pfjet_res_e[k] = new TLegend(0.40,0.70,0.90,0.90);
[92237ca]	2335
	2336	HistogramsCollection(&plots_pfjet_res_e[k], TMath::Log10(ptMin), TMath::Log10(ptMax), "pfjet");
	2337	HistogramsCollection(&plots_cajet_res_e[k], TMath::Log10(ptMin), TMath::Log10(ptMax), "cajet");
	2338
	2339	GetJetsEres(&plots_pfjet_res_e[k], branchPFJet, branchGenJet, treeReaderJet, etaVals.at(k), etaVals.at(k+1));
	2340	GetJetsEres(&plots_cajet_res_e[k], branchCaloJet, branchGenJet, treeReaderJet, etaVals.at(k), etaVals.at(k+1));
	2341
	2342	gr_pfjet_res_e[k] = EresGraph(&plots_pfjet_res_e[k]);
	2343	gr_cajet_res_e[k] = EresGraph(&plots_cajet_res_e[k]);
	2344
	2345	s_etaMin = Form("%.1f",etaVals.at(k));
	2346	s_etaMax = Form("%.1f",etaVals.at(k+1));
[b4ec6ac]	2347	s_eta = "anti-k_{T}, R = 0.4, "+ s_etaMin + " < \| #eta \| < " + s_etaMax;
[92237ca]	2348
	2349	leg_pfjet_res_e[k]->SetTextFont(132);
	2350	leg_pfjet_res_e[k]->SetHeader(s_eta);
	2351
[b4ec6ac]	2352	addResoGraph(mg_pfjet_res_e[k], &gr_cajet_res_e[k], leg_pfjet_res_e[k], markerStyles.at(0), colors.at(0), "Calorimeter Jets");
	2353	addResoGraph(mg_pfjet_res_e[k], &gr_pfjet_res_e[k], leg_pfjet_res_e[k], markerStyles.at(1), colors.at(1), "Particle-flow Jets");
[92237ca]	2354
	2355	c_pfjet_res_e[k] = new TCanvas("","", 800, 600);
	2356
	2357	mg_pfjet_res_e[k]->Draw("APE");
	2358	//DrawAxis(mg_pfjet_res_e[k], leg_pfjet_res_e[k], 10, ptMax, 0.5, 100, "E [GeV]", "(resolution in E)/E (%)", true, true);
	2359	DrawAxis(mg_pfjet_res_e[k], leg_pfjet_res_e[k], 10, ptMax, 0.0, 30, "E [GeV]", "(resolution in E)/E (%)", true, false);
	2360	leg_pfjet_res_e[k]->Draw();
[85ad2b9]	2361	pave->Draw();
[92237ca]	2362
	2363	TString s_etarange = "eta_"+s_etaMin+"_"+s_etaMax+"_";
	2364
	2365	c_pfjet_res_e[k]->Print(pdfOutput,"pdf");
	2366	c_pfjet_res_e[k]->Print(figPath+"img_pfjet_res_"+s_etarange+"e.pdf","pdf");
	2367	c_pfjet_res_e[k]->Print(figPath+"img_pfjet_res_"+s_etarange+"e.png","png");
	2368
	2369	}
	2370
	2371
	2372	// loop over eta bins
	2373	for (k = 0; k < ptVals.size(); k++)
	2374	{
	2375
	2376	mg_pfjet_res_eta[k] = new TMultiGraph("","");
[b4ec6ac]	2377	leg_pfjet_res_eta[k] = new TLegend(0.30,0.70,0.85,0.90);
[92237ca]	2378
	2379	HistogramsCollectionVsEta(&plots_pfjet_res_eta[k], etaMin, etaMax, 0.5ptVals.at(k), 2.0ptVals.at(k), "pfjet", 0.0, 2.0);
	2380	HistogramsCollectionVsEta(&plots_cajet_res_eta[k], etaMin, etaMax, 0.5ptVals.at(k), 2.0ptVals.at(k), "cajet", 0.0, 2.0);
	2381
	2382	GetJetsEresVsEta(&plots_pfjet_res_eta[k], branchPFJet, branchGenJet, treeReaderJet, 0.5ptVals.at(k), 2.0ptVals.at(k));
	2383	GetJetsEresVsEta(&plots_cajet_res_eta[k], branchCaloJet, branchGenJet, treeReaderJet, 0.5ptVals.at(k), 2.0ptVals.at(k));
	2384
	2385	gr_pfjet_res_eta[k] = EresGraphVsEta(&plots_pfjet_res_eta[k]);
	2386	gr_cajet_res_eta[k] = EresGraphVsEta(&plots_cajet_res_eta[k]);
	2387
[b4ec6ac]	2388	s_e = Form("anti-k_{T}, R = 0.4, jets, E = %.0f GeV",ptVals.at(k));
	2389	if(ptVals.at(k) >= 1000.) s_e = Form("anti-k_{T}, R = 0.4, E = %.0f TeV",ptVals.at(k)/1000.);
[92237ca]	2390
	2391	leg_pfjet_res_eta[k]->SetTextFont(132);
	2392	leg_pfjet_res_eta[k]->SetHeader(s_e);
	2393
[b4ec6ac]	2394	addResoGraph(mg_pfjet_res_eta[k], &gr_cajet_res_eta[k], leg_pfjet_res_eta[k], markerStyles.at(0), colors.at(0), "Calorimeter Jets");
	2395	addResoGraph(mg_pfjet_res_eta[k], &gr_pfjet_res_eta[k], leg_pfjet_res_eta[k], markerStyles.at(1), colors.at(1), "Particle-flow Jets");
[92237ca]	2396
	2397	c_pfjet_res_eta[k] = new TCanvas("","", 800, 600);
	2398
	2399	mg_pfjet_res_eta[k]->Draw("APE");
	2400	//DrawAxis(mg_pfjet_res_eta[k], leg_pfjet_res_eta[k], etaMin, etaMax, 0.1, 1000, "#eta", "(resolution in E)/E (%)", false, true);
	2401	DrawAxis(mg_pfjet_res_eta[k], leg_pfjet_res_eta[k], etaMin, etaMax, 0.0, 50, "#eta", "(resolution in E)/E (%)", false, false);
	2402	leg_pfjet_res_eta[k]->Draw();
[85ad2b9]	2403	pave->Draw();
[92237ca]	2404
	2405	TString s_ptrange = Form("pt_%.0f_",ptVals.at(k));
	2406
	2407	c_pfjet_res_eta[k]->Print(pdfOutput,"pdf");
	2408	c_pfjet_res_eta[k]->Print(figPath+"img_pfjet_res_"+s_ptrange+"eta.pdf","pdf");
	2409	c_pfjet_res_eta[k]->Print(figPath+"img_pfjet_res_"+s_ptrange+"eta.png","png");
	2410
	2411	}
	2412
	2413
	2414	/////////////////////
	2415	// PF Missing ET ///
	2416	/////////////////////
	2417
	2418	TMultiGraph *mg_met_res_ht = new TMultiGraph("","");
	2419	TLegend *leg_met_res_ht = new TLegend(0.60,0.22,0.90,0.42);
	2420
	2421	std::vector<resolPlot> plots_pfmet, plots_camet;
	2422
	2423	HistogramsCollection(&plots_pfmet, TMath::Log10(ptMin), TMath::Log10(ptMax), "pfMET", -500, 500);
	2424	HistogramsCollection(&plots_camet, TMath::Log10(ptMin), TMath::Log10(ptMax), "caMET", -500, 500);
	2425
	2426	GetMetres(&plots_pfmet, branchGenScalarHT, branchMet, branchPFJet, treeReaderJet);
	2427	GetMetres(&plots_camet, branchGenScalarHT, branchCaloMet, branchCaloJet, treeReaderJet);
	2428
	2429	TGraphErrors gr_pfmet_res_ht = MetResGraph(&plots_pfmet, true);
	2430	TGraphErrors gr_camet_res_ht = MetResGraph(&plots_camet, true);
	2431
[b4ec6ac]	2432	addResoGraph(mg_met_res_ht, &gr_camet_res_ht, leg_met_res_ht, markerStyles.at(0), colors.at(0), "Calorimeter E_{T}^{miss}");
	2433	addResoGraph(mg_met_res_ht, &gr_pfmet_res_ht, leg_met_res_ht, markerStyles.at(1), colors.at(1), "Particle-flow E_{T}^{miss}");
[92237ca]	2434
	2435	TCanvas *c_met_res_ht = new TCanvas("","", 800, 600);
	2436
	2437	mg_met_res_ht->Draw("APE");
[3718b36]	2438	DrawAxis(mg_met_res_ht, leg_met_res_ht, 1000, 100000, 0.1, 1000, " #sum p_{T} [GeV]", "resolution in E_{x,y}^{miss} [GeV]", true, true);
[92237ca]	2439
	2440	leg_met_res_ht->Draw();
[85ad2b9]	2441	pave->Draw();
[92237ca]	2442	c_met_res_ht->Print(pdfOutput,"pdf");
	2443	c_met_res_ht->Print(figPath+"img_met_res_ht.pdf","pdf");
	2444	c_met_res_ht->Print(figPath+"img_met_res_ht.png","png");
	2445
	2446
	2447	/////////////////////////////////////////
	2448	// Electron Reconstruction Efficiency ///
	2449	/////////////////////////////////////////
	2450
	2451	TMultiGraph *mg_recele_eff_pt = new TMultiGraph("","");
	2452	TMultiGraph *mg_recele_eff_eta = new TMultiGraph("","");
	2453
	2454	TLegend *leg_recele_eff_pt = new TLegend(0.55,0.22,0.90,0.48);
	2455	TLegend *leg_recele_eff_eta = new TLegend(0.55,0.22,0.90,0.48);
	2456
[dd5e213]	2457	TGraphErrors *gr_recele_eff_pt = new TGraphErrors[n_etabins];
	2458	TGraphErrors *gr_recele_eff_eta = new TGraphErrors[n_ptbins];
[92237ca]	2459	TH1D* h_recele_eff_pt, *h_recele_eff_eta;
	2460
	2461	// loop over eta bins
	2462	for (k = 0; k < etaVals.size()-1; k++)
	2463	{
	2464
	2465	h_recele_eff_pt = GetEffPt<Electron>(branchElectron, branchParticleElectron, "Electron", 11, ptMin, ptMax, etaVals.at(k), etaVals.at(k+1), treeReaderElectron);
	2466	gr_recele_eff_pt[k] = TGraphErrors(h_recele_eff_pt);
	2467
	2468	s_etaMin = Form("%.1f",etaVals.at(k));
	2469	s_etaMax = Form("%.1f",etaVals.at(k+1));
	2470
	2471	s_eta = "e^{ #pm} , " + s_etaMin + " < \| #eta \| < "+s_etaMax;
	2472
	2473	gr_recele_eff_pt[k].SetName("recEff_"+s_etaMin+"_"+s_etaMax);
	2474
	2475	addResoGraph(mg_recele_eff_pt, &gr_recele_eff_pt[k], leg_recele_eff_pt, markerStyles.at(k), colors.at(k), s_eta);
	2476	}
	2477
	2478	// loop over pt
	2479	for (k = 0; k < ptVals.size(); k++)
	2480	{
	2481	h_recele_eff_eta = GetEffEta<Electron>(branchElectron, branchParticleElectron, "Electron", 11, 0.5ptVals.at(k), 2.0ptVals.at(k) ,etaMin, etaMax , treeReaderElectron);
	2482	gr_recele_eff_eta[k] = TGraphErrors(h_recele_eff_eta);
	2483
	2484	s_pt = Form("e^{ #pm} , p_{T} = %.0f GeV",ptVals.at(k));
	2485	if(ptVals.at(k) >= 1000.) s_pt = Form("e^{ #pm} , p_{T} = %.0f TeV",ptVals.at(k)/1000.);
	2486
	2487	addResoGraph(mg_recele_eff_eta, &gr_recele_eff_eta[k], leg_recele_eff_eta, markerStyles.at(k), colors.at(k), s_pt );
	2488	}
	2489
	2490	TCanvas *c_recele_eff_pt = new TCanvas("","", 800, 600);
	2491
	2492	mg_recele_eff_pt->Draw("APE");
	2493	DrawAxis(mg_recele_eff_pt, leg_recele_eff_pt, ptMin, ptMax, 0.0, 100, "p_{T} [GeV]", "reconstruction efficiency (%)", true, false);
	2494	leg_recele_eff_pt->Draw();
[85ad2b9]	2495	pave->Draw();
[92237ca]	2496
	2497	c_recele_eff_pt->Print(pdfOutput,"pdf");
	2498	c_recele_eff_pt->Print(figPath+"img_recele_eff_pt.pdf","pdf");
	2499	c_recele_eff_pt->Print(figPath+"img_recele_eff_pt.png","png");
	2500
	2501	TCanvas *c_recele_eff_eta = new TCanvas("","", 800, 600);
[1408174]	2502
[92237ca]	2503	mg_recele_eff_eta->Draw("APE");
	2504	DrawAxis(mg_recele_eff_eta, leg_recele_eff_eta, etaMin, etaMax, 0.0, 100, " #eta ", "reconstruction efficiency (%)", false, false);
	2505	leg_recele_eff_eta->Draw();
[85ad2b9]	2506	pave->Draw();
[1408174]	2507
[92237ca]	2508	c_recele_eff_eta->Print(pdfOutput,"pdf");
	2509	c_recele_eff_eta->Print(figPath+"img_recele_eff_eta.pdf","pdf");
	2510	c_recele_eff_eta->Print(figPath+"img_recele_eff_eta.png","png");
[1408174]	2511
	2512
[92237ca]	2513	/////////////////////////////////////////
	2514	// Muon Reconstruction Efficiency ///
	2515	/////////////////////////////////////////
[1408174]	2516
[92237ca]	2517	TMultiGraph *mg_recmu_eff_pt = new TMultiGraph("","");
	2518	TMultiGraph *mg_recmu_eff_eta = new TMultiGraph("","");
	2519
	2520	TLegend *leg_recmu_eff_pt = new TLegend(0.55,0.22,0.90,0.48);
	2521	TLegend *leg_recmu_eff_eta = new TLegend(0.55,0.22,0.90,0.48);
	2522
[dd5e213]	2523	TGraphErrors *gr_recmu_eff_pt = new TGraphErrors[n_etabins];
	2524	TGraphErrors *gr_recmu_eff_eta = new TGraphErrors[n_ptbins];
[92237ca]	2525	TH1D* h_recmu_eff_pt, *h_recmu_eff_eta;
	2526
	2527	// loop over eta bins
	2528	for (k = 0; k < etaVals.size()-1; k++)
[1408174]	2529	{
	2530
[92237ca]	2531	h_recmu_eff_pt = GetEffPt<Muon>(branchMuon, branchParticleMuon, "muon", 13, ptMin, ptMax, etaVals.at(k), etaVals.at(k+1), treeReaderMuon);
	2532	gr_recmu_eff_pt[k] = TGraphErrors(h_recmu_eff_pt);
[1408174]	2533
[92237ca]	2534	s_etaMin = Form("%.1f",etaVals.at(k));
	2535	s_etaMax = Form("%.1f",etaVals.at(k+1));
[1408174]	2536
[92237ca]	2537	s_eta = "#mu^{ #pm} , " + s_etaMin + " < \| #eta \| < "+s_etaMax;
[1408174]	2538
[92237ca]	2539	gr_recmu_eff_pt[k].SetName("recEff_"+s_etaMin+"_"+s_etaMax);
[1408174]	2540
[92237ca]	2541	addResoGraph(mg_recmu_eff_pt, &gr_recmu_eff_pt[k], leg_recmu_eff_pt, markerStyles.at(k), colors.at(k), s_eta);
	2542	}
[1408174]	2543
[92237ca]	2544	// loop over pt
	2545	for (k = 0; k < ptVals.size(); k++)
	2546	{
	2547	h_recmu_eff_eta = GetEffEta<Muon>(branchMuon, branchParticleMuon, "muon", 13, 0.5ptVals.at(k), 2.0ptVals.at(k) ,etaMin, etaMax , treeReaderMuon);
	2548	gr_recmu_eff_eta[k] = TGraphErrors(h_recmu_eff_eta);
[1408174]	2549
[92237ca]	2550	s_pt = Form("#mu^{ #pm} , p_{T} = %.0f GeV",ptVals.at(k));
	2551	if(ptVals.at(k) >= 1000.) s_pt = Form("#mu^{ #pm} , p_{T} = %.0f TeV",ptVals.at(k)/1000.);
[1408174]	2552
[92237ca]	2553	addResoGraph(mg_recmu_eff_eta, &gr_recmu_eff_eta[k], leg_recmu_eff_eta, markerStyles.at(k), colors.at(k), s_pt );
[1408174]	2554	}
	2555
[92237ca]	2556	TCanvas *c_recmu_eff_pt = new TCanvas("","", 800, 600);
[1408174]	2557
[92237ca]	2558	mg_recmu_eff_pt->Draw("APE");
	2559	DrawAxis(mg_recmu_eff_pt, leg_recmu_eff_pt, ptMin, ptMax, 0.0, 100, "p_{T} [GeV]", "reconstruction efficiency (%)", true, false);
	2560	leg_recmu_eff_pt->Draw();
[85ad2b9]	2561	pave->Draw();
[1408174]	2562
[92237ca]	2563	c_recmu_eff_pt->Print(pdfOutput,"pdf");
	2564	c_recmu_eff_pt->Print(figPath+"img_recmu_eff_pt.pdf","pdf");
	2565	c_recmu_eff_pt->Print(figPath+"img_recmu_eff_pt.png","png");
[1408174]	2566
[92237ca]	2567	TCanvas *c_recmu_eff_eta = new TCanvas("","", 800, 600);
[1408174]	2568
[92237ca]	2569	mg_recmu_eff_eta->Draw("APE");
	2570	DrawAxis(mg_recmu_eff_eta, leg_recmu_eff_eta, etaMin, etaMax, 0.0, 100, " #eta ", "reconstruction efficiency (%)", false, false);
	2571	leg_recmu_eff_eta->Draw();
[85ad2b9]	2572	pave->Draw();
[1408174]	2573
[92237ca]	2574	c_recmu_eff_eta->Print(pdfOutput,"pdf");
	2575	c_recmu_eff_eta->Print(figPath+"img_recmu_eff_eta.pdf","pdf");
	2576	c_recmu_eff_eta->Print(figPath+"img_recmu_eff_eta.png","png");
[1408174]	2577
	2578
[92237ca]	2579	/////////////////////////////////////////
	2580	// Photon Reconstruction Efficiency ///
	2581	/////////////////////////////////////////
[1408174]	2582
[92237ca]	2583	TMultiGraph *mg_recpho_eff_pt = new TMultiGraph("","");
	2584	TMultiGraph *mg_recpho_eff_eta = new TMultiGraph("","");
[1408174]	2585
[92237ca]	2586	TLegend *leg_recpho_eff_pt = new TLegend(0.55,0.22,0.90,0.48);
	2587	TLegend *leg_recpho_eff_eta = new TLegend(0.55,0.22,0.90,0.48);
	2588
[dd5e213]	2589	TGraphErrors *gr_recpho_eff_pt = new TGraphErrors[n_etabins];
	2590	TGraphErrors *gr_recpho_eff_eta = new TGraphErrors[n_ptbins];
[92237ca]	2591	TH1D* h_recpho_eff_pt, *h_recpho_eff_eta;
	2592
	2593	// loop over eta bins
	2594	for (k = 0; k < etaVals.size()-1; k++)
[1408174]	2595	{
	2596
[92237ca]	2597	h_recpho_eff_pt = GetEffPt<Photon>(branchPhoton, branchParticlePhoton, "Photon", 22, ptMin, ptMax, etaVals.at(k), etaVals.at(k+1), treeReaderPhoton);
	2598	gr_recpho_eff_pt[k] = TGraphErrors(h_recpho_eff_pt);
[1408174]	2599
[92237ca]	2600	s_etaMin = Form("%.1f",etaVals.at(k));
	2601	s_etaMax = Form("%.1f",etaVals.at(k+1));
[1408174]	2602
[92237ca]	2603	s_eta = "#gamma , " + s_etaMin + " < \| #eta \| < "+s_etaMax;
[1408174]	2604
[92237ca]	2605	gr_recpho_eff_pt[k].SetName("recEff_"+s_etaMin+"_"+s_etaMax);
	2606
	2607	addResoGraph(mg_recpho_eff_pt, &gr_recpho_eff_pt[k], leg_recpho_eff_pt, markerStyles.at(k), colors.at(k), s_eta);
[1408174]	2608	}
	2609
[92237ca]	2610	// loop over pt
	2611	for (k = 0; k < ptVals.size(); k++)
	2612	{
	2613	h_recpho_eff_eta = GetEffEta<Photon>(branchPhoton, branchParticlePhoton, "Photon", 22, 0.5ptVals.at(k), 2.0ptVals.at(k) ,etaMin, etaMax , treeReaderPhoton);
	2614	gr_recpho_eff_eta[k] = TGraphErrors(h_recpho_eff_eta);
[1408174]	2615
[92237ca]	2616	s_pt = Form("#gamma , p_{T} = %.0f GeV",ptVals.at(k));
	2617	if(ptVals.at(k) >= 1000.) s_pt = Form("#gamma , p_{T} = %.0f TeV",ptVals.at(k)/1000.);
[1160e4f]	2618
[92237ca]	2619	addResoGraph(mg_recpho_eff_eta, &gr_recpho_eff_eta[k], leg_recpho_eff_eta, markerStyles.at(k), colors.at(k), s_pt );
	2620	}
[1160e4f]	2621
[92237ca]	2622	TCanvas *c_recpho_eff_pt = new TCanvas("","", 800, 600);
[1160e4f]	2623
[92237ca]	2624	mg_recpho_eff_pt->Draw("APE");
	2625	DrawAxis(mg_recpho_eff_pt, leg_recpho_eff_pt, ptMin, ptMax, 0.0, 100, "p_{T} [GeV]", "reconstruction efficiency (%)", true, false);
	2626	leg_recpho_eff_pt->Draw();
[85ad2b9]	2627	pave->Draw();
[1408174]	2628
[92237ca]	2629	c_recpho_eff_pt->Print(pdfOutput,"pdf");
	2630	c_recpho_eff_pt->Print(figPath+"img_recpho_eff_pt.pdf","pdf");
	2631	c_recpho_eff_pt->Print(figPath+"img_recpho_eff_pt.png","png");
[1408174]	2632
[92237ca]	2633	TCanvas *c_recpho_eff_eta = new TCanvas("","", 800, 600);
	2634
	2635	mg_recpho_eff_eta->Draw("APE");
	2636	DrawAxis(mg_recpho_eff_eta, leg_recpho_eff_eta, etaMin, etaMax, 0.0, 100, " #eta ", "reconstruction efficiency (%)", false, false);
	2637	leg_recpho_eff_eta->Draw();
[85ad2b9]	2638	pave->Draw();
[92237ca]	2639
	2640	c_recpho_eff_eta->Print(pdfOutput,"pdf");
	2641	c_recpho_eff_eta->Print(figPath+"img_recpho_eff_eta.pdf","pdf");
	2642	c_recpho_eff_eta->Print(figPath+"img_recpho_eff_eta.png","png");
[534d945]	2643
[92237ca]	2644	/////////////////////////////////////////
	2645	// B-jets Efficiency/ mistag rates ///
	2646	/////////////////////////////////////////
	2647
	2648	TMultiGraph *mg_recbjet_eff_pt = new TMultiGraph("","");
	2649	TMultiGraph *mg_recbjet_eff_eta = new TMultiGraph("","");
	2650
	2651	TLegend *leg_recbjet_eff_pt = new TLegend(0.50,0.22,0.90,0.48);
	2652	TLegend *leg_recbjet_eff_eta = new TLegend(0.50,0.22,0.90,0.48);
	2653
[dd5e213]	2654	TGraphErrors *gr_recbjet_eff_pt = new TGraphErrors[n_etabins];
	2655	TGraphErrors *gr_recbjet_eff_eta = new TGraphErrors[n_ptbins];
[92237ca]	2656	TH1D* h_recbjet_eff_pt, *h_recbjet_eff_eta;
	2657
	2658	// loop over eta bins
	2659	for (k = 0; k < etaVals.size()-1; k++)
[1408174]	2660	{
[92237ca]	2661
[534d945]	2662	h_recbjet_eff_pt = GetJetEffPt<Jet>(branchPFBJet, "BJet", 5, ptMin, ptMax, etaVals.at(k), etaVals.at(k+1), treeReaderBJet);
	2663	//h_recbjet_eff_pt = GetEffPt<Jet>(branchPFBJet, branchParticleBJet, "BJet", 5, ptMin, ptMax, etaVals.at(k), etaVals.at(k+1), treeReaderBJet);
[92237ca]	2664	gr_recbjet_eff_pt[k] = TGraphErrors(h_recbjet_eff_pt);
	2665
	2666	s_etaMin = Form("%.1f",etaVals.at(k));
	2667	s_etaMax = Form("%.1f",etaVals.at(k+1));
	2668
	2669	s_eta = "b-jet , " + s_etaMin + " < \| #eta \| < "+s_etaMax;
	2670
	2671	gr_recbjet_eff_pt[k].SetName("recEff_"+s_etaMin+"_"+s_etaMax);
	2672
	2673	addResoGraph(mg_recbjet_eff_pt, &gr_recbjet_eff_pt[k], leg_recbjet_eff_pt, markerStyles.at(k), colors.at(k), s_eta);
[1408174]	2674	}
	2675
[92237ca]	2676	// loop over pt
	2677	for (k = 0; k < ptVals.size(); k++)
[1408174]	2678	{
[534d945]	2679	h_recbjet_eff_eta = GetJetEffEta<Jet>(branchPFBJet, "BJet", 5, 0.5ptVals.at(k), 2.0ptVals.at(k) ,etaMin, etaMax , treeReaderBJet);
	2680	//h_recbjet_eff_eta = GetEffEta<Jet>(branchPFBJet, branchParticleBJet, "BJet", 5, 0.5ptVals.at(k), 2.0ptVals.at(k) ,etaMin, etaMax , treeReaderBJet);
[92237ca]	2681	gr_recbjet_eff_eta[k] = TGraphErrors(h_recbjet_eff_eta);
	2682
	2683	s_pt = Form("b-jet , p_{T} = %.0f GeV",ptVals.at(k));
	2684	if(ptVals.at(k) >= 1000.) s_pt = Form("b-jet , p_{T} = %.0f TeV",ptVals.at(k)/1000.);
	2685
	2686	addResoGraph(mg_recbjet_eff_eta, &gr_recbjet_eff_eta[k], leg_recbjet_eff_eta, markerStyles.at(k), colors.at(k), s_pt );
[1408174]	2687	}
	2688
[92237ca]	2689	TCanvas *c_recbjet_eff_pt = new TCanvas("","", 800, 600);
[734b267]	2690
[92237ca]	2691	mg_recbjet_eff_pt->Draw("APE");
	2692	DrawAxis(mg_recbjet_eff_pt, leg_recbjet_eff_pt, ptMin, ptMax, 0.0, 100, "p_{T} [GeV]", "b - tag efficiency (%)", true, false);
	2693	leg_recbjet_eff_pt->Draw();
[85ad2b9]	2694	pave->Draw();
[1408174]	2695
[92237ca]	2696	c_recbjet_eff_pt->Print(pdfOutput,"pdf");
	2697	c_recbjet_eff_pt->Print(figPath+"img_recbjet_eff_pt.pdf","pdf");
	2698	c_recbjet_eff_pt->Print(figPath+"img_recbjet_eff_pt.png","png");
[1408174]	2699
[92237ca]	2700	TCanvas *c_recbjet_eff_eta = new TCanvas("","", 800, 600);
[1408174]	2701
[92237ca]	2702	mg_recbjet_eff_eta->Draw("APE");
	2703	DrawAxis(mg_recbjet_eff_eta, leg_recbjet_eff_eta, etaMin, etaMax, 0.0, 100, " #eta ", "b - tag efficiency (%)", false, false);
	2704	leg_recbjet_eff_eta->Draw();
[85ad2b9]	2705	pave->Draw();
[1408174]	2706
[92237ca]	2707	c_recbjet_eff_eta->Print(pdfOutput,"pdf");
	2708	c_recbjet_eff_eta->Print(figPath+"img_recbjet_eff_eta.pdf","pdf");
	2709	c_recbjet_eff_eta->Print(figPath+"img_recbjet_eff_eta.png","png");
[1408174]	2710
[92237ca]	2711	// ------ c - mistag ------
[1408174]	2712
[92237ca]	2713	TMultiGraph *mg_recbjet_cmis_pt = new TMultiGraph("","");
	2714	TMultiGraph *mg_recbjet_cmis_eta = new TMultiGraph("","");
[1408174]	2715
[92237ca]	2716	TLegend *leg_recbjet_cmis_pt = new TLegend(0.50,0.64,0.90,0.90);
	2717	TLegend *leg_recbjet_cmis_eta = new TLegend(0.50,0.64,0.90,0.90);
[1408174]	2718
[dd5e213]	2719	TGraphErrors *gr_recbjet_cmis_pt = new TGraphErrors[n_etabins];
	2720	TGraphErrors *gr_recbjet_cmis_eta = new TGraphErrors[n_ptbins];
[92237ca]	2721	TH1D* h_recbjet_cmis_pt, *h_recbjet_cmis_eta;
[1408174]	2722
[92237ca]	2723	// loop over eta bins
	2724	for (k = 0; k < etaVals.size()-1; k++)
	2725	{
[1408174]	2726
[534d945]	2727	h_recbjet_cmis_pt = GetJetEffPt<Jet>(branchPFCJet, "CJet", 4, ptMin, ptMax, etaVals.at(k), etaVals.at(k+1), treeReaderCJet);
	2728	//h_recbjet_cmis_pt = GetEffPt<Jet>(branchPFCJet, branchParticleCJet, "CJet", 4, ptMin, ptMax, etaVals.at(k), etaVals.at(k+1), treeReaderCJet);
[92237ca]	2729	gr_recbjet_cmis_pt[k] = TGraphErrors(h_recbjet_cmis_pt);
[1408174]	2730
[92237ca]	2731	s_etaMin = Form("%.1f",etaVals.at(k));
	2732	s_etaMax = Form("%.1f",etaVals.at(k+1));
[1408174]	2733
[92237ca]	2734	s_eta = "c-jet , " + s_etaMin + " < \| #eta \| < "+s_etaMax;
[1408174]	2735
[92237ca]	2736	gr_recbjet_cmis_pt[k].SetName("recEff_"+s_etaMin+"_"+s_etaMax);
[1408174]	2737
[92237ca]	2738	addResoGraph(mg_recbjet_cmis_pt, &gr_recbjet_cmis_pt[k], leg_recbjet_cmis_pt, markerStyles.at(k), colors.at(k), s_eta);
	2739	}
[1408174]	2740
[92237ca]	2741	// loop over pt
	2742	for (k = 0; k < ptVals.size(); k++)
	2743	{
[534d945]	2744	h_recbjet_cmis_eta = GetJetEffEta<Jet>(branchPFCJet, "CJet", 4, 0.5ptVals.at(k), 2.0ptVals.at(k) ,etaMin, etaMax , treeReaderCJet);
	2745	//h_recbjet_cmis_eta = GetEffEta<Jet>(branchPFCJet, branchParticleCJet, "CJet", 4, 0.5ptVals.at(k), 2.0ptVals.at(k) ,etaMin, etaMax , treeReaderCJet);
[92237ca]	2746	gr_recbjet_cmis_eta[k] = TGraphErrors(h_recbjet_cmis_eta);
[1408174]	2747
[92237ca]	2748	s_pt = Form("c-jet , p_{T} = %.0f GeV",ptVals.at(k));
	2749	if(ptVals.at(k) >= 1000.) s_pt = Form("c-jet , p_{T} = %.0f TeV",ptVals.at(k)/1000.);
[1408174]	2750
[92237ca]	2751	addResoGraph(mg_recbjet_cmis_eta, &gr_recbjet_cmis_eta[k], leg_recbjet_cmis_eta, markerStyles.at(k), colors.at(k), s_pt );
	2752	}
[1408174]	2753
[92237ca]	2754	TCanvas *c_recbjet_cmis_pt = new TCanvas("","", 800, 600);
[1408174]	2755
[92237ca]	2756	mg_recbjet_cmis_pt->Draw("APE");
	2757	DrawAxis(mg_recbjet_cmis_pt, leg_recbjet_cmis_pt, ptMin, ptMax, 0.0, 20, "p_{T} [GeV]", "c - mistag rate (%)", true, false);
	2758	leg_recbjet_cmis_pt->Draw();
[85ad2b9]	2759	pave->Draw();
[1408174]	2760
[92237ca]	2761	c_recbjet_cmis_pt->Print(pdfOutput,"pdf");
	2762	c_recbjet_cmis_pt->Print(figPath+"img_recbjet_cmis_pt.pdf","pdf");
	2763	c_recbjet_cmis_pt->Print(figPath+"img_recbjet_cmis_pt.png","png");
[1408174]	2764
[92237ca]	2765	TCanvas *c_recbjet_cmis_eta = new TCanvas("","", 800, 600);
[1408174]	2766
[92237ca]	2767	mg_recbjet_cmis_eta->Draw("APE");
	2768	DrawAxis(mg_recbjet_cmis_eta, leg_recbjet_cmis_eta, etaMin, etaMax, 0.0, 20, " #eta ", "c - mistag rate (%)", false, false);
	2769	leg_recbjet_cmis_eta->Draw();
[85ad2b9]	2770	pave->Draw();
[1408174]	2771
[92237ca]	2772	c_recbjet_cmis_eta->Print(pdfOutput,"pdf");
	2773	c_recbjet_cmis_eta->Print(figPath+"img_recbjet_cmis_eta.pdf","pdf");
	2774	c_recbjet_cmis_eta->Print(figPath+"img_recbjet_cmis_eta.png","png");
[1408174]	2775
[92237ca]	2776	// ------ light - mistag ------
[1408174]	2777
[92237ca]	2778	TMultiGraph *mg_recbjet_lmis_pt = new TMultiGraph("","");
	2779	TMultiGraph *mg_recbjet_lmis_eta = new TMultiGraph("","");
[1408174]	2780
[92237ca]	2781	TLegend *leg_recbjet_lmis_pt = new TLegend(0.50,0.64,0.90,0.90);
	2782	TLegend *leg_recbjet_lmis_eta = new TLegend(0.50,0.64,0.90,0.90);
[1408174]	2783
[dd5e213]	2784	TGraphErrors *gr_recbjet_lmis_pt = new TGraphErrors[n_etabins];
	2785	TGraphErrors *gr_recbjet_lmis_eta = new TGraphErrors[n_ptbins];
[92237ca]	2786	TH1D* h_recbjet_lmis_pt, *h_recbjet_lmis_eta;
[1408174]	2787
[92237ca]	2788	// loop over eta bins
	2789	for (k = 0; k < etaVals.size()-1; k++)
	2790	{
[cb159ed]	2791
[534d945]	2792	h_recbjet_lmis_pt = GetJetEffPt<Jet>(branchJet, "Jet", 1, ptMin, ptMax, etaVals.at(k), etaVals.at(k+1), treeReaderJet);
	2793	//h_recbjet_lmis_pt = GetEffPt<Jet>(branchJet, branchParticleJet, "Jet", 1, ptMin, ptMax, etaVals.at(k), etaVals.at(k+1), treeReaderJet);
[92237ca]	2794	gr_recbjet_lmis_pt[k] = TGraphErrors(h_recbjet_lmis_pt);
[1408174]	2795
[92237ca]	2796	s_etaMin = Form("%.1f",etaVals.at(k));
	2797	s_etaMax = Form("%.1f",etaVals.at(k+1));
[1408174]	2798
[92237ca]	2799	s_eta = "uds-jet , " + s_etaMin + " < \| #eta \| < "+s_etaMax;
[1408174]	2800
[92237ca]	2801	gr_recbjet_lmis_pt[k].SetName("recEff_"+s_etaMin+"_"+s_etaMax);
[1408174]	2802
[92237ca]	2803	addResoGraph(mg_recbjet_lmis_pt, &gr_recbjet_lmis_pt[k], leg_recbjet_lmis_pt, markerStyles.at(k), colors.at(k), s_eta);
	2804	}
[1408174]	2805
[92237ca]	2806	// loop over pt
	2807	for (k = 0; k < ptVals.size(); k++)
	2808	{
[534d945]	2809	h_recbjet_lmis_eta = GetJetEffEta<Jet>(branchJet, "Jet", 1, 0.5ptVals.at(k), 2.0ptVals.at(k) ,etaMin, etaMax , treeReaderJet);
	2810	//h_recbjet_lmis_eta = GetEffEta<Jet>(branchJet, branchParticleJet, "Jet", 1, 0.5ptVals.at(k), 2.0ptVals.at(k) ,etaMin, etaMax , treeReaderJet);
[92237ca]	2811	gr_recbjet_lmis_eta[k] = TGraphErrors(h_recbjet_lmis_eta);
	2812
	2813	s_pt = Form("uds-jet , p_{T} = %.0f GeV",ptVals.at(k));
	2814	if(ptVals.at(k) >= 1000.) s_pt = Form("uds-jet , p_{T} = %.0f TeV",ptVals.at(k)/1000.);
	2815
	2816	addResoGraph(mg_recbjet_lmis_eta, &gr_recbjet_lmis_eta[k], leg_recbjet_lmis_eta, markerStyles.at(k), colors.at(k), s_pt );
	2817	}
	2818
	2819	TCanvas *c_recbjet_lmis_pt = new TCanvas("","", 800, 600);
	2820
	2821	mg_recbjet_lmis_pt->Draw("APE");
[c4e18da]	2822
[534d945]	2823	DrawAxis(mg_recbjet_lmis_pt, leg_recbjet_lmis_pt, ptMin, ptMax, 0.0, 1.0, "p_{T} [GeV]", "light - mistag rate (%)", true, false);
[c4e18da]	2824
[92237ca]	2825	leg_recbjet_lmis_pt->Draw();
[85ad2b9]	2826	pave->Draw();
[92237ca]	2827
	2828	c_recbjet_lmis_pt->Print(pdfOutput,"pdf");
	2829	c_recbjet_lmis_pt->Print(figPath+"img_recbjet_lmis_pt.pdf","pdf");
	2830	c_recbjet_lmis_pt->Print(figPath+"img_recbjet_lmis_pt.png","png");
	2831
	2832	TCanvas *c_recbjet_lmis_eta = new TCanvas("","", 800, 600);
	2833
	2834	mg_recbjet_lmis_eta->Draw("APE");
[534d945]	2835	DrawAxis(mg_recbjet_lmis_eta, leg_recbjet_lmis_eta, etaMin, etaMax, 0.0, 1.0, " #eta ", "light - mistag rate (%)", false, false);
[92237ca]	2836	leg_recbjet_lmis_eta->Draw();
[85ad2b9]	2837	pave->Draw();
[92237ca]	2838
	2839	c_recbjet_lmis_eta->Print(pdfOutput,"pdf");
	2840	c_recbjet_lmis_eta->Print(figPath+"img_recbjet_lmis_eta.pdf","pdf");
	2841	c_recbjet_lmis_eta->Print(figPath+"img_recbjet_lmis_eta.png","png");
	2842
	2843
	2844	///////////////////////////////////////////
	2845	// tau-jets Efficiency/ mistag rates ///
	2846	///////////////////////////////////////////
	2847
	2848	TMultiGraph *mg_rectaujet_eff_pt = new TMultiGraph("","");
	2849	TMultiGraph *mg_rectaujet_eff_eta = new TMultiGraph("","");
[fa068d3]	2850
[92237ca]	2851	TLegend *leg_rectaujet_eff_pt = new TLegend(0.50,0.22,0.90,0.48);
	2852	TLegend *leg_rectaujet_eff_eta = new TLegend(0.50,0.22,0.90,0.48);
[1408174]	2853
[dd5e213]	2854	TGraphErrors *gr_rectaujet_eff_pt = new TGraphErrors[n_etabins];
	2855	TGraphErrors *gr_rectaujet_eff_eta = new TGraphErrors[n_ptbins];
[92237ca]	2856	TH1D* h_rectaujet_eff_pt, *h_rectaujet_eff_eta;
[1408174]	2857
[92237ca]	2858	// loop over eta bins
	2859	for (k = 0; k < etaVals.size()-1; k++)
	2860	{
	2861
	2862	h_rectaujet_eff_pt = GetTauEffPt<Jet>(branchPFTauJet, branchParticleTauJet, "TauJet", 15, ptMin, ptMax, etaVals.at(k), etaVals.at(k+1), treeReaderTauJet);
	2863	gr_rectaujet_eff_pt[k] = TGraphErrors(h_rectaujet_eff_pt);
	2864
	2865	s_etaMin = Form("%.1f",etaVals.at(k));
	2866	s_etaMax = Form("%.1f",etaVals.at(k+1));
	2867
	2868	s_eta = "#tau-jet , " + s_etaMin + " < \| #eta \| < "+s_etaMax;
	2869
	2870	gr_rectaujet_eff_pt[k].SetName("recEff_"+s_etaMin+"_"+s_etaMax);
	2871
	2872	addResoGraph(mg_rectaujet_eff_pt, &gr_rectaujet_eff_pt[k], leg_rectaujet_eff_pt, markerStyles.at(k), colors.at(k), s_eta);
	2873	}
	2874
	2875	// loop over pt
	2876	for (k = 0; k < ptVals.size(); k++)
	2877	{
	2878	h_rectaujet_eff_eta = GetTauEffEta<Jet>(branchPFTauJet, branchParticleTauJet, "TauJet", 15, 0.5ptVals.at(k), 2.0ptVals.at(k) ,etaMin, etaMax , treeReaderTauJet);
	2879	gr_rectaujet_eff_eta[k] = TGraphErrors(h_rectaujet_eff_eta);
	2880
	2881	s_pt = Form("#tau-jet , p_{T} = %.0f GeV",ptVals.at(k));
	2882	if(ptVals.at(k) >= 1000.) s_pt = Form("#tau-jet , p_{T} = %.0f TeV",ptVals.at(k)/1000.);
	2883
	2884	addResoGraph(mg_rectaujet_eff_eta, &gr_rectaujet_eff_eta[k], leg_rectaujet_eff_eta, markerStyles.at(k), colors.at(k), s_pt );
	2885	}
	2886
	2887
	2888	TCanvas *c_rectaujet_eff_pt = new TCanvas("","", 800, 600);
	2889
	2890	mg_rectaujet_eff_pt->Draw("APE");
	2891	DrawAxis(mg_rectaujet_eff_pt, leg_rectaujet_eff_pt, ptMin, ptMax, 0.0, 100, "p_{T} [GeV]", "#tau - tag efficiency (%)", true, false);
	2892	leg_rectaujet_eff_pt->Draw();
[85ad2b9]	2893	pave->Draw();
[92237ca]	2894
	2895	c_rectaujet_eff_pt->Print(pdfOutput,"pdf");
	2896	c_rectaujet_eff_pt->Print(figPath+"img_rectaujet_eff_pt.pdf","pdf");
	2897	c_rectaujet_eff_pt->Print(figPath+"img_rectaujet_eff_pt.png","png");
[1408174]	2898
[92237ca]	2899	TCanvas *c_rectaujet_eff_eta = new TCanvas("","", 800, 600);
[1408174]	2900
[92237ca]	2901	mg_rectaujet_eff_eta->Draw("APE");
[f3be533]	2902	DrawAxis(mg_rectaujet_eff_eta, leg_rectaujet_eff_eta, etaMin, etaMax, 0.0, 100., " #eta ", "#tau - tag efficiency (%)", false, false);
[92237ca]	2903	leg_rectaujet_eff_eta->Draw();
[85ad2b9]	2904	pave->Draw();
[1408174]	2905
[92237ca]	2906	c_rectaujet_eff_eta->Print(pdfOutput,"pdf");
	2907	c_rectaujet_eff_eta->Print(figPath+"img_rectaujet_eff_eta.pdf","pdf");
	2908	c_rectaujet_eff_eta->Print(figPath+"img_rectaujet_eff_eta.png","png");
[1408174]	2909
	2910
[92237ca]	2911	//--------------- tau mistag rate ----------
[1408174]	2912
[92237ca]	2913	TMultiGraph *mg_rectaujet_mis_pt = new TMultiGraph("","");
	2914	TMultiGraph *mg_rectaujet_mis_eta = new TMultiGraph("","");
[1408174]	2915
[92237ca]	2916	TLegend *leg_rectaujet_mis_pt = new TLegend(0.50,0.64,0.90,0.90);
	2917	TLegend *leg_rectaujet_mis_eta = new TLegend(0.50,0.64,0.90,0.90);
[1408174]	2918
[dd5e213]	2919	TGraphErrors *gr_rectaujet_mis_pt = new TGraphErrors[n_etabins];
	2920	TGraphErrors *gr_rectaujet_mis_eta = new TGraphErrors[n_ptbins];
[92237ca]	2921	TH1D* h_rectaujet_mis_pt, *h_rectaujet_mis_eta;
[1408174]	2922
[92237ca]	2923	// loop over eta bins
	2924	for (k = 0; k < etaVals.size()-1; k++)
	2925	{
[1408174]	2926
[06a83b3]	2927	h_rectaujet_mis_pt = GetTauEffPt<Jet>(branchJet, branchParticleJet, "TauJet", 1, ptMin, ptMax, etaVals.at(k), etaVals.at(k+1), treeReaderJet);
[92237ca]	2928	gr_rectaujet_mis_pt[k] = TGraphErrors(h_rectaujet_mis_pt);
[1408174]	2929
[92237ca]	2930	s_etaMin = Form("%.1f",etaVals.at(k));
	2931	s_etaMax = Form("%.1f",etaVals.at(k+1));
[1408174]	2932
[92237ca]	2933	s_eta = "uds-jet , " + s_etaMin + " < \| #eta \| < "+s_etaMax;
[1408174]	2934
[92237ca]	2935	gr_rectaujet_mis_pt[k].SetName("recEff_"+s_etaMin+"_"+s_etaMax);
[1408174]	2936
[92237ca]	2937	addResoGraph(mg_rectaujet_mis_pt, &gr_rectaujet_mis_pt[k], leg_rectaujet_mis_pt, markerStyles.at(k), colors.at(k), s_eta);
	2938	}
[1408174]	2939
[92237ca]	2940	// loop over pt
	2941	for (k = 0; k < ptVals.size(); k++)
	2942	{
[06a83b3]	2943	h_rectaujet_mis_eta = GetTauEffEta<Jet>(branchJet, branchParticleJet, "TauJet", 1, 0.5ptVals.at(k), 2.0ptVals.at(k) ,etaMin, etaMax , treeReaderJet);
[92237ca]	2944	gr_rectaujet_mis_eta[k] = TGraphErrors(h_rectaujet_mis_eta);
[1408174]	2945
[92237ca]	2946	s_pt = Form("uds-jet , p_{T} = %.0f GeV",ptVals.at(k));
	2947	if(ptVals.at(k) >= 1000.) s_pt = Form("uds-jet , p_{T} = %.0f TeV",ptVals.at(k)/1000.);
[1408174]	2948
[92237ca]	2949	addResoGraph(mg_rectaujet_mis_eta, &gr_rectaujet_mis_eta[k], leg_rectaujet_mis_eta, markerStyles.at(k), colors.at(k), s_pt );
	2950	}
[1408174]	2951
[92237ca]	2952	TCanvas *c_rectaujet_mis_pt = new TCanvas("","", 800, 600);
[1408174]	2953
[92237ca]	2954	mg_rectaujet_mis_pt->Draw("APE");
[cb159ed]	2955	DrawAxis(mg_rectaujet_mis_pt, leg_rectaujet_mis_pt, ptMin, ptMax, 0.0, 5., "p_{T} [GeV]", "#tau - mistag(%)", true, false);
[92237ca]	2956	leg_rectaujet_mis_pt->Draw();
[85ad2b9]	2957	pave->Draw();
[1408174]	2958
[92237ca]	2959	c_rectaujet_mis_pt->Print(pdfOutput,"pdf");
	2960	c_rectaujet_mis_pt->Print(figPath+"img_rectaujet_mis_pt.pdf","pdf");
	2961	c_rectaujet_mis_pt->Print(figPath+"img_rectaujet_mis_pt.png","png");
[1408174]	2962
[92237ca]	2963	TCanvas *c_rectaujet_mis_eta = new TCanvas("","", 800, 600);
[1408174]	2964
[92237ca]	2965	mg_rectaujet_mis_eta->Draw("APE");
	2966	DrawAxis(mg_rectaujet_mis_eta, leg_rectaujet_mis_eta, etaMin, etaMax, 0.0, 5., " #eta ", "#tau - mistag (%)", false, false);
	2967	leg_rectaujet_mis_eta->Draw();
[85ad2b9]	2968	pave->Draw();
[1408174]	2969
[92237ca]	2970	c_rectaujet_mis_eta->Print(pdfOutput+")","pdf");
	2971	c_rectaujet_mis_eta->Print(figPath+"img_rectaujet_mis_eta.pdf","pdf");
	2972	c_rectaujet_mis_eta->Print(figPath+"img_rectaujet_mis_eta.png","png");
[1408174]	2973
	2974
[92237ca]	2975	// ---- store resolution histograms in the output (for leave efficiencies out) ---
[1408174]	2976
	2977
	2978	TFile *fout = new TFile(outputFile,"recreate");
	2979
	2980	for (int bin = 0; bin < Nbins; bin++)
	2981	{
	2982
[92237ca]	2983	for (k = 0; k < etaVals.size()-1; k++)
	2984	{
	2985	plots_trkpi_res_pt[k].at(bin).resolHist->Write();
	2986	plots_trkele_res_pt[k].at(bin).resolHist->Write();
[cb159ed]	2987	plots_trkmu_res_pt[k].at(bin).resolHist->Write();
[92237ca]	2988	plots_ecal_res_e[k].at(bin).resolHist->Write();
	2989	plots_hcal_res_e[k].at(bin).resolHist->Write();
	2990	plots_pfele_res_e[k].at(bin).resolHist->Write();
	2991	plots_pfpi_res_e[k].at(bin).resolHist->Write();
	2992	plots_pfjet_res_e[k].at(bin).resolHist->Write();
	2993	plots_cajet_res_e[k].at(bin).resolHist->Write();
[1408174]	2994
[92237ca]	2995	}
	2996
	2997	for (k = 0; k < ptVals.size(); k++)
	2998	{
	2999	plots_trkpi_res_eta[k].at(bin).resolHist->Write();
	3000	plots_trkele_res_eta[k].at(bin).resolHist->Write();
	3001	plots_trkmu_res_eta[k].at(bin).resolHist->Write();
	3002	plots_ecal_res_eta[k].at(bin).resolHist->Write();
	3003	plots_hcal_res_eta[k].at(bin).resolHist->Write();
	3004	plots_pfele_res_eta[k].at(bin).resolHist->Write();
	3005	plots_pfpi_res_eta[k].at(bin).resolHist->Write();
	3006	plots_pfjet_res_eta[k].at(bin).resolHist->Write();
	3007	plots_cajet_res_eta[k].at(bin).resolHist->Write();
[32677fb]	3008
[92237ca]	3009	}
[1408174]	3010
[92237ca]	3011	plots_pfmet.at(bin).resolHist->Write();
	3012	plots_camet.at(bin).resolHist->Write();
[1408174]	3013
	3014	}
	3015
	3016	fout->Write();
	3017
[cb159ed]	3018
[1408174]	3019	cout << "** Exiting..." << endl;
	3020
	3021	delete treeReaderElectron;
	3022	delete treeReaderMuon;
	3023	delete treeReaderPhoton;
	3024	delete treeReaderJet;
	3025	delete treeReaderBJet;
	3026	delete treeReaderTauJet;
	3027	delete chainElectron;
	3028	delete chainMuon;
	3029	delete chainPhoton;
	3030	delete chainJet;
	3031	delete chainBJet;
	3032	delete chainTauJet;
	3033	}
[734b267]	3034
	3035	//------------------------------------------------------------------------------
	3036
	3037	int main(int argc, char *argv[])
	3038	{
[181c061]	3039	char *appName = "DelphesValidation";
[734b267]	3040
[85ad2b9]	3041	if(argc != 12)
[734b267]	3042	{
[181c061]	3043	cout << " Usage: " << appName << " input_file_electron input_file_muon input_file_photon input_file_jet input_file_bjet input_file_taujet output_file version" << endl;
	3044	cout << " input_file_pion - input file in ROOT format ('Delphes' tree)," << endl;
	3045	cout << " input_file_electron - input file in ROOT format ('Delphes' tree)," << endl;
[1408174]	3046	cout << " input_file_muon - input file in ROOT format ('Delphes' tree)," << endl;
	3047	cout << " input_file_photon - input file in ROOT format ('Delphes' tree)," << endl;
[92237ca]	3048	cout << " input_file_neutralhadron - input file in ROOT format ('Delphes' tree)," << endl;
[1408174]	3049	cout << " input_file_jet - input file in ROOT format ('Delphes' tree)," << endl;
	3050	cout << " input_file_bjet - input file in ROOT format ('Delphes' tree)," << endl;
[92237ca]	3051	cout << " input_file_cjet - input file in ROOT format ('Delphes' tree)," << endl;
[1408174]	3052	cout << " input_file_taujet - input file in ROOT format ('Delphes' tree)," << endl;
[181c061]	3053	cout << " output_file - output file in ROOT format," << endl;
	3054	cout << " version - Delphes version" << endl;
[85ad2b9]	3055
[734b267]	3056	return 1;
	3057	}
	3058
	3059	gROOT->SetBatch();
	3060
	3061	int appargc = 1;
	3062	char *appargv[] = {appName};
	3063	TApplication app(appName, &appargc, appargv);
	3064
[181c061]	3065	DelphesValidation(argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11]);
[734b267]	3066	}
	3067
	3068
[92237ca]	3069

Note: See TracBrowser for help on using the repository browser.

Download in other formats: