ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/MitHzz4l/Selection/src/Selection.cc

Comparing UserCode/MitHzz4l/Selection/src/Selection.cc (file contents):
Revision 1.2 by dkralph, Wed Sep 14 12:11:57 2011 UTC vs.
Revision 1.14 by khahn, Tue Nov 1 19:15:53 2011 UTC

#	Line 1 | Line 1
1		#include "Selection.h"
2		#include "PassHLT.h"
3	+
4	+	#include "SiMVAElectronSelection.h"
5	+
6		#include "HZZCiCElectronSelection.h"
7	+	#include "HZZLikelihoodElectronSelection.h"
8	+	#include "HZZBDTElectronSelection.h"
9		#include "RunLumiRangeMap.h"
10	+	#include "EfficiencyWeightsInterface.h"
11
12		RunLumiRangeMap rlrm;
13
14	+	// #include "TH2D.h"
15	+	// extern TH2D * h_mu_eff_idiso_2011a;
16	+	// extern TH2D * h_mu_eff_idiso_s11;
17	+	// extern TH2D * h_mu_effdata_trigger_doublemu7_2011a;
18	+	// extern TH2D * h_mu_effdata_trigger_doublemu13_8_leading_2011a;
19	+	// extern TH2D * h_mu_effdata_trigger_doublemu13_8_trailing_2011a;
20	+
21	+	// unsigned getGenChannel(mithep::TGenInfo * ginfo) {
22	+	//   int gchannel=-1;
23	+	//   if( abs(ginfo->id_1_a) == EGenType::kElectron && abs(ginfo->id_1_b) == EGenType::kElectron )  gchannel=0;
24	+	//   else if( abs(ginfo->id_1_a) == EGenType::kMuon && abs(ginfo->id_1_b) == EGenType::kMuon ) gchannel=1;
25	+	//   else if( (abs(ginfo->id_1_a) == EGenType::kElectron && abs(ginfo->id_1_b) == EGenType::kMuon) ||
26	+	//         (abs(ginfo->id_1_a) == EGenType::kMuon && abs(ginfo->id_1_b) == EGenType::kElectron) ) gchannel=2;
27	+
28	+	//   return gchannel;
29	+	// };
30	+
31		void initRunLumiRangeMap() {
32		rlrm.AddJSONFile(std::string("./data/Cert_136033-149442_7TeV_Apr21ReReco_Collisions10_JSON.txt"));
33	<	rlrm.AddJSONFile(std::string("./data/Cert_160404-173244_7TeV_PromptReco_Collisions11_JSON_v2.txt"));
33	>	//  rlrm.AddJSONFile(std::string("./data/Cert_160404-173244_7TeV_PromptReco_Collisions11_JSON_v2.txt"));
34	>	rlrm.AddJSONFile(std::string("./data/Cert_160404-178078_7TeV_PromptReco_Collisions11_JSON.txt"));
35	>	rlrm.AddJSONFile(std::string("./data/Cert_160404-163869_7TeV_May10ReReco_Collisions11_JSON_v3.txt"));
36	>	rlrm.AddJSONFile(std::string("./data/Cert_170249-172619_7TeV_ReReco5Aug_Collisions11_JSON.txt"));
37	>	};
38	>
39	>	void initRunLumiRangeMap(RunLumiRangeMap &rlrm) {
40	>	cout << "adding JSONS ... "  << endl;
41	>	rlrm.AddJSONFile(std::string("./data/Cert_136033-149442_7TeV_Apr21ReReco_Collisions10_JSON.txt"));
42	>	//  rlrm.AddJSONFile(std::string("./data/Cert_160404-173244_7TeV_PromptReco_Collisions11_JSON_v2.txt"));
43	>	rlrm.AddJSONFile(std::string("./data/Cert_160404-178078_7TeV_PromptReco_Collisions11_JSON.txt"));
44		rlrm.AddJSONFile(std::string("./data/Cert_160404-163869_7TeV_May10ReReco_Collisions11_JSON_v3.txt"));
45		rlrm.AddJSONFile(std::string("./data/Cert_170249-172619_7TeV_ReReco5Aug_Collisions11_JSON.txt"));
46		};
47
48	+	// unsigned fails_HZZ4L_selection(ControlFlags &ctrl,           // input control
49	+	//                             mithep::TEventInfo *info,     // input event inof
50	+	//                             TClonesArray *electronArr,    // input electrons
51	+	//                             TClonesArray *muonArr,        // input muons
52	+	//                             double eventweight,           // weight
53	+	//                             TTree * passtuple ) {
54	+
55	+	//   fails_HZZ4L_selection( ctrl, info, electronArr, muonArr, eventweight, passtuple, NULL );
56	+
57	+	// };
58	+
59	+
60	+
61	+	// unsigned fails_HZZ4L_selection(ControlFlags &ctrl,           // input control
62	+	//                             mithep::TEventInfo *info,     // input event inof
63	+	//                             TClonesArray *electronArr,    // input electrons
64	+	//                             TClonesArray *muonArr,        // input muons
65	+	//                             double eventweight,           // weight
66	+	//                             LabVectors  *l ) {
67	+
68	+	//   fails_HZZ4L_selection( ctrl, info, electronArr, muonArr, eventweight, NULL, l );
69	+
70	+	// };
71	+
72	+
73		unsigned fails_HZZ4L_selection(ControlFlags &ctrl,           // input control
74	<	mithep::TEventInfo *info,     // input event inof
74	>	mithep::TGenInfo *ginfo ,     // input gen info
75	>	mithep::TEventInfo *info,     // input event info
76		TClonesArray *electronArr,    // input electrons
77		TClonesArray *muonArr,        // input muons
78		double eventweight,           // weight
79	<	TNtuple * passtuple ) {
79	>	TTree * passtuple ) {
80
81	<	fails_HZZ4L_selection( ctrl, info, electronArr, muonArr, eventweight, passtuple, NULL );
81	>	fails_HZZ4L_selection( ctrl, info, electronArr, muonArr, eventweight, passtuple, NULL, NULL );
82
83		};
84
85		unsigned fails_HZZ4L_selection(ControlFlags &ctrl,           // input control
86	<	mithep::TEventInfo *info,     // input event inof
86	>	mithep::TEventInfo *info,     // input event info
87		TClonesArray *electronArr,    // input electrons
88		TClonesArray *muonArr,        // input muons
89		double eventweight,           // weight
90	<	LabVectors  *l ) {
91	<
92	<	fails_HZZ4L_selection( ctrl, info, electronArr, muonArr, eventweight, NULL, l );
93	<
35	<	};
90	>	TTree * passtuple,
91	>	LabVectors * l ) {
92	>	fails_HZZ4L_selection( ctrl, info, electronArr, muonArr, eventweight, passtuple, l, NULL );
93	>	}
94
95
96		unsigned fails_HZZ4L_selection(ControlFlags &ctrl,           // input control
97	<	mithep::TEventInfo *info,     // input event inof
97	>	mithep::TEventInfo *info,     // input event info
98		TClonesArray *electronArr,    // input electrons
99		TClonesArray *muonArr,        // input muons
100		double eventweight,           // weight
101	<	TNtuple * passtuple,
102	<	LabVectors * l ) {       // output ntuple
101	>	TTree * passtuple,
102	>	LabVectors * l=NULL,
103	>	TClonesArray *jetArr=NULL ) {       // output ntuple
104
105		unsigned evtfail = 0x0;
106	+	unsigned gchannel=0xdeaddead;
107	+
108	+	//   if( ctrl.mc && ginfo != NULL ) {
109	+	//     gchannel = getGenChannel(ginfo);
110	+	//   }
111	+
112	+
113	+	if( ctrl.debug ) {
114	+	cout << "Run: " << info->runNum
115	+	<< "\tEvt: " << info->evtNum
116	+	<< "\tLumi: " << info->lumiSec
117	+	<< endl;
118	+	}
119
120		if( !ctrl.mc ) {
121		// not accounting for overlap atm
122		RunLumiRangeMap::RunLumiPairType rl(info->runNum, info->lumiSec);
123		if( !(rlrm.HasRunLumi(rl)) )  {
124	+	if( ctrl.debug ) cout << "\tfails JSON" << endl;
125		evtfail |= (1<<EVTFAIL_JSON);
126		return evtfail;
127		}
128		}
129
130
131	<	if( ctrl.debug ) {
59	<	cout << "Run: " << info->runNum
60	<	<< "\tEvt: " << info->evtNum
61	<	<< "\tLumi: " << info->lumiSec
62	<	<< endl;
63	<	}
131	>
132
133
134		//********************************************************
#	Line 68 | Line 136 | unsigned fails_HZZ4L_selection(ControlFl
136		//********************************************************
137		if( !ctrl.mc ) {
138		//  if( !(passHLT(info->triggerBits, info->runNum, channel) )  ) {
139	<	if( !(passHLT(info->triggerBits, info->runNum, 999) )  ) {
140	<	evtfail |= (1<<EVTFAIL_TRIGGER);
141	<	return evtfail;
142	<	}
139	>	//     if( !(passHLT(info->triggerBits, info->runNum, 999) )  ) {
140	>	//       evtfail |= (1<<EVTFAIL_TRIGGER);
141	>	//       return evtfail;
142	>	//     }
143		} else {
144		if( !(passHLTMC(info->triggerBits)) ) {
145		evtfail |= (1<<EVTFAIL_TRIGGER);
#	Line 93 | Line 161 | unsigned fails_HZZ4L_selection(ControlFl
161		vector<SimpleLepton> lepvec;
162
163		//
164	<	cout << "\tnMuons: " << muonArr->GetEntries() << endl;
164	>	if( ctrl.debug ) cout << "\tnMuons: " << muonArr->GetEntries() << endl;
165		//----------------------------------------------------
166		for(Int_t i=0; i<muonArr->GetEntries(); i++) {
167		const mithep::TMuon *mu = (mithep::TMuon*)((*muonArr)[i]);
168	<	unsigned muonfail = passMuonSelectionZZ(mu);
168	>	unsigned muonfail;
169	>	if( ctrl.muSele == "ksWW" )
170	>	muonfail = passMuonSelection(mu);
171	>	else
172	>	muonfail = passMuonSelectionZZ(mu);
173		if( ctrl.debug ) {
174		cout << "muon:: pt: " << mu->pt
175		<< "\teta: " << mu->eta
#	Line 106 | Line 178 | unsigned fails_HZZ4L_selection(ControlFl
178		}
179		if ( !muonfail ) {
180		SimpleLepton tmplep;
181	<	tmplep.vec.SetPtEtaPhiM(mu->pt,
181	>
182	>	float pt = mu->pt;
183	>	if( ctrl.do_escale_up   ) pt*=(1.01);
184	>	if( ctrl.do_escale_down ) pt*=(0.99);
185	>
186	>	tmplep.vec.SetPtEtaPhiM(pt,
187		mu->eta,
188		mu->phi,
189		105.658369e-3);
190	+
191		tmplep.type    = 13;
192		tmplep.index   = i;
193		tmplep.charge  = mu->q;
194		tmplep.isoTrk  = mu->trkIso03;
195		tmplep.isoEcal = mu->emIso03;
196		tmplep.isoHcal = mu->hadIso03;
197	+	tmplep.isoPF03 = mu->pfIso03;
198	+	tmplep.isoPF04 = mu->pfIso04;
199		tmplep.ip3dSig = mu->ip3dSig;
200		tmplep.is4l    = false;
201		tmplep.isEB    = (fabs(mu->eta) < 1.479 ? 1 : 0 );
#	Line 124 | Line 204 | unsigned fails_HZZ4L_selection(ControlFl
204		}
205		}
206
127	–	//
207		if( ctrl.debug ) { cout << "\tnElectron: " << electronArr->GetEntries() << endl; }
208	+
209		//----------------------------------------------------
210		for(Int_t i=0; i<electronArr->GetEntries(); i++) {
211		const mithep::TElectron *ele = (mithep::TElectron*)((*electronArr)[i]);
212
213	+	if( !(isEleFO(ctrl,ele) ) ) continue;
214	+	if( ele->pt < 7 ) continue; //move this to ID
215	+
216		Bool_t isMuonOverlap = kFALSE;
217		for (int k=0; k<lepvec.size(); ++k) {
218		TVector3 tmplep;
219		tmplep.SetPtEtaPhi(ele->pt, ele->eta, ele->phi);
220		if ( lepvec[k].type == 13 && lepvec[k].vec.Vect().DrEtaPhi(tmplep) < 0.1 ) {
221	<	cout << "-----> isMuonOverlap! " << endl;
221	>	if( ctrl.debug ) cout << "-----> isMuonOverlap! " << endl;
222		isMuonOverlap = kTRUE;
223		break;
224		}
225		}
226
227	<	CICStruct tightcuts = getTightCuts();
228	<	unsigned failsCIC = failsCicSelection(ele, tightcuts);
227	>	unsigned FAIL=0, isEleTight=0;
228	>
229	>	unsigned  failsCIC=0;
230	>	CICStruct ciccuts_tight, ciccuts_medium, ciccuts_loose;
231	>	if(ctrl.eleSele=="cic") {
232	>	if( ctrl.eleSeleScheme == "mediumloose" ) {
233	>	ciccuts_medium = getCiCCuts("medium");
234	>	unsigned failsCICMedium = failsCicSelection(ctrl, ele, ciccuts_medium, ctrl.kinematics);
235	>	ciccuts_loose = getCiCCuts("loose");
236	>	unsigned failsCICLoose = failsCicSelection(ctrl, ele, ciccuts_loose, ctrl.kinematics);
237	>	failsCIC = ( failsCICLoose > 0 && failsCICMedium > 0 );
238	>	if( !failsCICMedium ) isEleTight=1;
239	>	}
240	>	else {
241	>	ciccuts_tight = getCiCCuts(ctrl.eleSeleScheme);
242	>	failsCIC = failsCicSelection(ctrl, ele, ciccuts_tight, ctrl.kinematics);
243	>	if( !failsCIC ) isEleTight=1;
244	>	}
245	>	FAIL = failsCIC;
246	>	}
247	>
248	>	LikStruct likcuts;
249	>	unsigned failsLike=0;
250	>	if(ctrl.eleSele=="lik") {
251	>	likcuts = getLikCuts(ctrl.eleSeleScheme);
252	>	failsLike = failsLikelihoodSelection(ele, likcuts, ctrl.kinematics);
253	>	FAIL = failsLike;
254	>	}
255	>	unsigned failsBDT=0;
256	>	if(ctrl.eleSele=="bdt") {
257	>	if( ctrl.eleSeleScheme == "mediumloose" ) {
258	>	unsigned failsBDTMedium = failsBDTSelection(ctrl,"medium",ele);
259	>	unsigned failsBDTLoose  = failsBDTSelection(ctrl,"loose",ele);
260	>	failsBDT = ( failsBDTLoose > 0 && failsBDTMedium > 0 );
261	>	if( !failsBDTMedium ) isEleTight=1;
262	>	} else {
263	>	failsBDT = failsBDTSelection(ctrl,"tight",ele);
264	>	if( !failsBDT ) isEleTight=1;
265	>	}
266	>	FAIL = failsBDT;
267	>	}
268	>
269	>
270		if( ctrl.debug ){
271		cout << "CIC category: " << cicCategory(ele)
272	<	<< "\tfailmask : 0x" << hex << failsCIC  << dec
272	>	<< "\tlikelihood: " << ele->likelihood
273	>	<< "\tFAIL:  0x"     << hex << FAIL      << dec
274	>	<< "\tfailsCIC:  0x" << hex << failsCIC  << dec
275	>	<< "\tfailsLike: 0x" << hex << failsLike << dec
276	>	<< "\tfailsBDT:  0x" << hex << failsBDT << dec
277		<< "\tscEt: " << ele->scEt
278	<	<< "\tscEta: " << ele->scEta
278	>	<< "\tscEta: " << ele->scEta
279	>	<< "\tncluster: " << ele->ncluster
280		<< endl;
281		}
282	<	if ( !failsCIC && !isMuonOverlap ) {
282	>	if ( !FAIL && !isMuonOverlap ) {
283		SimpleLepton tmplep;
284	<	tmplep.vec.SetPtEtaPhiM( ele->pt,
284	>
285	>	float pt = ele->pt;
286	>	if( ctrl.do_escale_up   ) pt*=(1.02);
287	>	if( ctrl.do_escale_down ) pt*=(0.98);
288	>
289	>	tmplep.vec.SetPtEtaPhiM( pt,
290		ele->eta,
291		ele->phi,
292		0.51099892e-3 );
#	Line 162 | Line 296 | unsigned fails_HZZ4L_selection(ControlFl
296		tmplep.isoTrk  = ele->trkIso03;
297		tmplep.isoEcal = ele->emIso03;
298		tmplep.isoHcal = ele->hadIso03;
299	+	tmplep.isoPF03 = ele->pfIso03;
300	+	tmplep.isoPF04 = ele->pfIso04;
301		tmplep.ip3dSig = ele->ip3dSig;
302		tmplep.is4l    = false;
303	+	tmplep.isTight = isEleTight;
304		tmplep.isEB    = ele->isEB;
305		lepvec.push_back(tmplep);
306		if( ctrl.debug ) { cout << "\telectron passes ... " << endl; }
#	Line 172 | Line 309 | unsigned fails_HZZ4L_selection(ControlFl
309
310		sort( lepvec.begin(), lepvec.end(), SimpleLepton::lep_pt_sort );
311
312	+	for( int i=0; i<lepvec.size(); i++ ) {
313	+	//
314	+	//  check for a matched btagged jet
315	+	//
316	+	lepvec[i].tche = -1;
317	+	lepvec[i].tchp = -1;
318	+	lepvec[i].csv = -1;
319	+	lepvec[i].csvMva = -1;
320	+
321	+	if( jetArr != NULL ) {
322	+	for(int k=0; k<jetArr->GetEntries(); k++) {
323	+	const mithep::TJet *jet = (mithep::TJet*)((*jetArr)[k]);
324	+	TVector3 jvec;
325	+	jvec.SetPtEtaPhi(jet->pt, jet->eta, jet->phi);
326	+	if( jvec.DrEtaPhi( lepvec[i].vec.Vect()) < 0.2 ) {
327	+	lepvec[i].tche = jet->tche;
328	+	lepvec[i].tchp = jet->tchp;
329	+	lepvec[i].csv = jet->csv;
330	+	lepvec[i].csvMva = jet->csvMva;
331	+	}
332	+	}
333	+	}
334	+	}
335	+
336		int nmu=0, nele=0;
337		for( int i=0; i<lepvec.size(); i++ ) {
338		if( abs(lepvec[i].type) == 11 ) nele++;
#	Line 214 | Line 375 | unsigned fails_HZZ4L_selection(ControlFl
375		}
376
377		float tmpZ1Mass = (leptonPlus+leptonMinus).M();
378	<	cout << "Z1 selection, tmpZ1Mass: " << tmpZ1Mass << endl;
378	>	if( ctrl.debug ) cout << "Z1 selection, tmpZ1Mass: " << tmpZ1Mass << endl;
379		if( tmpZ1Mass > 60 ) {
380		if (fabs(tmpZ1Mass - 91.1876) < fabs(BestZ1Mass - 91.1876)) {
381		BestZ1Mass = tmpZ1Mass;
382	<	cout << "Z1 selection, new BestZ1Mass: " << BestZ1Mass
382	>	if( ctrl.debug ) cout << "Z1 selection, new BestZ1Mass: " << BestZ1Mass
383		<< "\tdM: " << fabs(BestZ1Mass - 91.1876)
384		<< endl;
385		if (lepvec[i].charge > 0) {
#	Line 237 | Line 398 | unsigned fails_HZZ4L_selection(ControlFl
398		evtfail |= (1<<EVTFAIL_Z1);
399		return evtfail;
400		}
401	<	cout << "\tgot a Z1 ... run: " << info->runNum << "\tevt: " << info->evtNum  << endl;
402	<	cout << "\tZ1 plusindex: " << Z1LeptonPlusIndex << "\tminusindex: " << Z1LeptonMinusIndex << endl;
401	>	if( ctrl.debug ) cout << "\tgot a Z1 ... run: " << info->runNum << "\tevt: " << info->evtNum  << endl;
402	>	if( ctrl.debug ) cout << "\tZ1 plusindex: " << Z1LeptonPlusIndex << "\tminusindex: " << Z1LeptonMinusIndex << endl;
403		TLorentzVector Z1LeptonPlus  = lepvec[Z1LeptonPlusIndex].vec;
404		TLorentzVector Z1LeptonMinus = lepvec[Z1LeptonMinusIndex].vec;
405		TLorentzVector Z1Candidate   =  Z1LeptonPlus + Z1LeptonMinus;
#	Line 262 | Line 423 | unsigned fails_HZZ4L_selection(ControlFl
423		Int_t Z2LeptonPlusIndex = -1;
424		Int_t Z2LeptonMinusIndex = -1;
425		Double_t BestZ2Mass = -1;
426	<	cout << "looking for a Z2 ... out of " << lepvec.size() << " leptons" <<endl;
426	>	if( ctrl.debug ) cout << "looking for a Z2 ... out of " << lepvec.size() << " leptons" <<endl;
427		for(int i = 0; i < lepvec.size(); ++i) {
428	+	if( abs(lepvec[i].type) == 11 &&
429	+	ctrl.eleSeleScheme == "mediumloose" &&
430	+	!(lepvec[i].isTight) ) continue;
431	+
432		for(int j = i+1; j < lepvec.size(); ++j) {
433	+	if( abs(lepvec[j].type) == 11 &&
434	+	ctrl.eleSeleScheme == "mediumloose" &&
435	+	!(lepvec[j].isTight) ) continue;
436	+
437		//            cout << "i: " << i << "\tj: " << j << endl;
438		if (i == Z1LeptonPlusIndex || i == Z1LeptonMinusIndex) {
439		//            cout << "\ti matches a Z1 index, skipping ..." << endl;
#	Line 298 | Line 467 | unsigned fails_HZZ4L_selection(ControlFl
467		TLorentzVector dilepton = leptonPlus+leptonMinus;
468		TLorentzVector fourLepton = Z1Candidate + dilepton;
469
470	<	cout << "dilepton.M() : " << dilepton.M() << endl;
471	<	cout << "fourLepton.M() : " << fourLepton.M() << endl;
470	>	if( ctrl.debug ) cout << "dilepton.M() : " << dilepton.M() << endl;
471	>	if( ctrl.debug ) cout << "fourLepton.M() : " << fourLepton.M() << endl;
472
473		if (!(dilepton.M() > 12.0)) continue;
474		if (!(fourLepton.M() > 100.0)) continue;
475
476	<
476	>	/*
477		//for 4e and 4mu, require at least 1 of the other opp sign lepton pairs have mass > 12
478		if (fabs(lepvec[i].type) == fabs(lepvec[Z1LeptonPlusIndex].type)) {
479		TLorentzVector pair1 = Z1LeptonPlus+leptonMinus;
480		TLorentzVector pair2 = Z1LeptonMinus+leptonPlus;
481	<	cout << "pair1: " << pair1.M() << "\tpair2: "<< pair2.M() << endl;
481	>	if( ctrl.debug ) cout << "pair1: " << pair1.M() << "\tpair2: "<< pair2.M() << endl;
482		if (!(pair1.M() > 12 || pair2.M() > 12)) continue;
483		}
484	<
484	>	*/
485	>
486		//Disambiguiation is done by choosing the pair with the largest ptMax and largest ptMin
487		if (Z2LeptonPlusIndex < 0) {
488		if (lepvec[i].charge > 0) {
#	Line 368 | Line 538 | unsigned fails_HZZ4L_selection(ControlFl
538		//      cout << "evtfail: " << hex << evtfail << dec << endl;
539		//      continue;
540		}
541	<	cout << "\tgot a Z2 ..." << endl;
542	<	cout << "\tZ2 plusindex: " << Z2LeptonPlusIndex << "\tminusindex: " << Z2LeptonMinusIndex << endl;
541	>	if( ctrl.debug ) cout << "\tgot a Z2 ..." << endl;
542	>	if( ctrl.debug ) cout << "\tZ2 plusindex: " << Z2LeptonPlusIndex
543	>	<< "\tminusindex: " << Z2LeptonMinusIndex << endl;
544		TLorentzVector  Z2LeptonPlus  = lepvec[Z2LeptonPlusIndex].vec;
545		TLorentzVector  Z2LeptonMinus = lepvec[Z2LeptonMinusIndex].vec;
546		TLorentzVector  Z2Candidate   = Z2LeptonPlus+Z2LeptonMinus;
#	Line 390 | Line 561 | unsigned fails_HZZ4L_selection(ControlFl
561		//***************************************************************
562		bool failiso=false;
563
564	<	/*
394	<	int i,j;
395	<	i=Z1LeptonPlusIndex;
396	<	j=Z1LeptonMinusIndex;
397	<	float RIso1 = (lepvec[i].isoTrk+lepvec[i].isoEcal+lepvec[i].isoHcal)/lepvec[i].vec.Pt();
398	<	float RIso2 = (lepvec[j].isoTrk+lepvec[j].isoEcal+lepvec[j].isoHcal)/lepvec[j].vec.Pt();
399	<	float comboIso12 = RIso1 + RIso2;
400	<	i=Z2LeptonPlusIndex;
401	<	j=Z2LeptonMinusIndex;
402	<	float RIso3 = (lepvec[i].isoTrk+lepvec[i].isoEcal+lepvec[i].isoHcal)/lepvec[i].vec.Pt();
403	<	float RIso4 = (lepvec[j].isoTrk+lepvec[j].isoEcal+lepvec[j].isoHcal)/lepvec[j].vec.Pt();
404	<	float comboIso34 = RIso3 + RIso4;
405	<	if( comboIso12 > 0.35 || comboIso34 > 0.35 ) {
406	<	failiso = true;
407	<	}
408	<	*/
564	>	if( ctrl.isoScheme == "pf" ) {
565
566	<	float rho = info->rho;
567	<	for( int i=0; i<lepvec.size(); i++ ) {
568	<	if( !(lepvec[i].is4l) ) continue;
566	>	for( int i=0; i<lepvec.size(); i++ ) {
567	>
568	>	if( !(lepvec[i].is4l) ) continue;
569	>
570	>	if( abs(lepvec[i].type) == 11 ) {
571	>	float reliso = lepvec[i].isoPF04/lepvec[i].vec.Pt();
572	>	if( lepvec[i].isEB && lepvec[i].vec.Pt() > 20 && reliso > PFISO_ELE_LOOSE_EB_HIGHPT ) {
573	>	failiso = true;
574	>	break;
575	>	}
576	>	if( lepvec[i].isEB && lepvec[i].vec.Pt() < 20 && reliso > PFISO_ELE_LOOSE_EB_LOWPT ) {
577	>	failiso = true;
578	>	break;
579	>	}
580	>	if( !(lepvec[i].isEB) && lepvec[i].vec.Pt() > 20 && reliso > PFISO_ELE_LOOSE_EE_HIGHPT ) {
581	>	failiso = true;
582	>	break;
583	>	}
584	>	if( !(lepvec[i].isEB) && lepvec[i].vec.Pt() < 20 && reliso > PFISO_ELE_LOOSE_EE_LOWPT ) {
585	>	failiso = true;
586	>	break;
587	>	}
588	>	}
589	>
590	>	if( abs(lepvec[i].type) == 13 ) {
591	>
592	>	/*
593	>	float reliso = lepvec[i].isoPF03/lepvec[i].vec.Pt();
594	>	if( lepvec[i].isEB && lepvec[i].vec.Pt() > 20 && reliso > PFISO_MU_LOOSE_EB_HIGHPT ) {  //0.13
595	>	failiso = true;
596	>	break;
597	>	}
598	>	if( lepvec[i].isEB && lepvec[i].vec.Pt() < 20 && reliso > PFISO_MU_LOOSE_EB_LOWPT ) { //0.06
599	>	failiso = true;
600	>	break;
601	>	}
602	>	if( !(lepvec[i].isEB) && lepvec[i].vec.Pt() > 20 && reliso > PFISO_MU_LOOSE_EE_HIGHPT ) { //0.09
603	>	failiso = true;
604	>	break;
605	>	}
606	>	if( !(lepvec[i].isEB) && lepvec[i].vec.Pt() < 20 && reliso > PFISO_MU_LOOSE_EE_LOWPT ) { //0.05
607	>	failiso = true;
608	>	break;
609	>	}
610	>	*/
611	>	}
612	>	}
613	>	} else if ( ctrl.isoScheme == "pairwise" ) {
614	>	float rho = info->rho;
615	>	for( int i=0; i<lepvec.size(); i++ ) {
616	>	if( !(lepvec[i].is4l) ) continue;
617		float effArea_ecal_i, effArea_hcal_i;
618		if( lepvec[i].isEB ) {
619		if( lepvec[i].type == 11 ) {
#	Line 480 | Line 684 | unsigned fails_HZZ4L_selection(ControlFl
684		cout.flush();
685		}
686		if( comboIso > 0.35 ) {
687	<	cout << "combo failing for indices: " << i << "," << j << endl;
687	>	if( ctrl.debug ) cout << "combo failing for indices: " << i << "," << j << endl;
688		failiso = true;
689		//            break;
690		}
691		}
692	+	}
693		}
694	+
695	+
696		if( failiso ) {
697		evtfail |= ( 1<<EVTFAIL_ISOLATION );
698		return evtfail;
#	Line 518 | Line 725 | unsigned fails_HZZ4L_selection(ControlFl
725		//***************************************************************
726		// remaining kinematic cuts
727		//***************************************************************
728	<	if ( Z1Candidate.M() > 120 ||
729	<	Z2Candidate.M() < 20  ||
730	<	Z2Candidate.M() > 120 ||
728	>	double Z2massCut=0;
729	>	if      ( ctrl.kinematics == "loose" ) Z2massCut = 12;
730	>	else if ( ctrl.kinematics == "tight" ) Z2massCut = 20;
731	>	else { cout <<  "error! kinematic tightness not defined!" << endl; assert(0); }
732	>
733	>	if ( Z1Candidate.M() > 120        ||
734	>	Z2Candidate.M() < Z2massCut  ||
735	>	Z2Candidate.M() > 120        ||
736		!(lepvec[Z1LeptonPlusIndex].vec.Pt() > 20.0 || lepvec[Z1LeptonMinusIndex].vec.Pt() > 20.0) ||
737		!(lepvec[Z1LeptonPlusIndex].vec.Pt() > 10.0 && lepvec[Z1LeptonMinusIndex].vec.Pt() > 10.0)
738		) {
#	Line 532 | Line 744 | unsigned fails_HZZ4L_selection(ControlFl
744		//      continue;
745		}
746
747	<	int channel;
747	>	unsigned channel;
748		if( lepvec[Z1LeptonMinusIndex].type == 11 && lepvec[Z2LeptonMinusIndex].type == 11 ) channel=0;
749		if( lepvec[Z1LeptonMinusIndex].type == 13 && lepvec[Z2LeptonMinusIndex].type == 13 ) channel=1;
750		if( (lepvec[Z1LeptonMinusIndex].type == 11 && lepvec[Z2LeptonMinusIndex].type == 13) ||
751		(lepvec[Z1LeptonMinusIndex].type == 13 && lepvec[Z2LeptonMinusIndex].type == 11)) channel=2;
752
753
754	<
754	>	double w_offline=-1, werr_offline=0;
755	>	double w_online=-1, werr_online=0;
756	>
757	>	if( ctrl.mc ) {
758	>
759	>	vector< pair <double,double> > wlegs; // pair here is eff & err
760	>	vector< pair <float,float> > mvec;  // pair here is eta & pt
761	>	// now deal with medium vs loose
762	>	//      vector< pair <float,float> > evec;  // pair here is eta & pt
763	>	vector< pair< bool, pair <float,float> > > evec;  // pair here is eta & pt
764	>
765	>	for( int k=0; k<lepvec.size(); k++ ) {
766	>	if( !(lepvec[k].is4l) ) continue;
767	>	if( abs(lepvec[k].type) == 13 ) {
768	>	mvec.push_back( std::pair<float,float> (fabs(lepvec[k].vec.Eta()), lepvec[k].vec.Pt()) );
769	>	wlegs.push_back( muonPerLegOfflineEfficiencyWeight( fabs(lepvec[k].vec.Eta()),
770	>	lepvec[k].vec.Pt() ) );
771	>	} else {
772	>
773	>	// now deal with medium vs loose
774	>	//              evec.push_back( std::pair<float,float> (fabs(lepvec[k].vec.Eta()), lepvec[k].vec.Pt()) );
775	>
776	>	std::pair<float,float> tmppair(fabs(lepvec[k].vec.Eta()), lepvec[k].vec.Pt());
777	>	evec.push_back( std::pair<bool, std::pair<float,float> > (lepvec[k].isTight, tmppair) );
778	>
779	>	wlegs.push_back( elePerLegOfflineEfficiencyWeight(  fabs(lepvec[k].vec.Eta()),
780	>	lepvec[k].vec.Pt() ) );
781	>	}
782	>	}
783	>
784	>	pair<double,double> offpair = getOfflineEfficiencyWeight( wlegs );
785	>	w_offline    = offpair.first;
786	>	werr_offline = offpair.second;
787	>
788	>	pair<double,double> onpair  = getOnlineEfficiencyWeight( mvec, evec );
789	>	w_online    = onpair.first;
790	>	werr_online = onpair.second;
791	>
792	>	} // if mc
793	>
794	>
795	>	if( l != NULL ) {
796	>	l->vec4l  = ZZSystem;
797	>	l->vecz1  = Z1Candidate;
798	>	l->vecz2  = Z2Candidate;
799	>	l->vecl1p = lepvec[Z1LeptonPlusIndex].vec;
800	>	l->vecl1m = lepvec[Z1LeptonMinusIndex].vec;
801	>	l->vecl2p = lepvec[Z2LeptonPlusIndex].vec;
802	>	l->vecl2m = lepvec[Z2LeptonMinusIndex].vec;
803	>	}
804		if( passtuple != NULL ) {
805	<	passtuple->Fill( info->runNum,
806	<	info->evtNum,
807	<	info->lumiSec,
808	<	channel,
809	<	Z1Candidate.M(),
810	<	Z2Candidate.M(),
811	<	ZZSystem.M(),
812	<	ZZSystem.Pt(),
813	<	eventweight);
805	>	unsigned run   = info->runNum;
806	>	unsigned evt   = info->evtNum;
807	>	unsigned lumi  = info->lumiSec;
808	>	unsigned chan  = channel;
809	>	double   w     = eventweight;
810	>	float mZ1      = Z1Candidate.M() ;
811	>	float mZ2      = Z2Candidate.M() ;
812	>	float m4l      = ZZSystem.M() ;
813	>	float pt4l     = ZZSystem.Pt() ;
814	>	unsigned tZ1   = abs(lepvec[Z1LeptonMinusIndex].type);
815	>	unsigned tZ2   = abs(lepvec[Z2LeptonMinusIndex].type);
816	>	float l3tche   = lepvec[Z2LeptonMinusIndex].tche;
817	>	float l4tche   = lepvec[Z2LeptonPlusIndex].tche;
818	>	float l3tchp   = lepvec[Z2LeptonMinusIndex].tchp;
819	>	float l4tchp   = lepvec[Z2LeptonPlusIndex].tchp;
820	>	float l3csv    = lepvec[Z2LeptonMinusIndex].csv;
821	>	float l4csv    = lepvec[Z2LeptonPlusIndex].csv;
822	>	float l3csvMva = lepvec[Z2LeptonMinusIndex].csvMva;
823	>	float l4csvMva = lepvec[Z2LeptonPlusIndex].csvMva;
824	>
825	>
826	>	passtuple->SetBranchAddress("channel",  &channel);
827	>	passtuple->SetBranchAddress("run",  &run);
828	>	passtuple->SetBranchAddress("evt",  &evt);
829	>	passtuple->SetBranchAddress("lumi", &lumi);
830	>	passtuple->SetBranchAddress("mZ1",  &mZ1);
831	>	passtuple->SetBranchAddress("mZ2",  &mZ2);
832	>	passtuple->SetBranchAddress("tZ1",  &tZ1);
833	>	passtuple->SetBranchAddress("tZ2",  &tZ2);
834	>	passtuple->SetBranchAddress("m4l",  &m4l);
835	>	passtuple->SetBranchAddress("pt4l", &pt4l);
836	>	passtuple->SetBranchAddress("w",    &w);
837	>	if( ctrl.mc ) {
838	>	passtuple->SetBranchAddress("woff", &w_offline );
839	>	passtuple->SetBranchAddress("werroff", &werr_offline );
840	>	passtuple->SetBranchAddress("won", &w_online );
841	>	passtuple->SetBranchAddress("werron", &werr_online );
842	>	}
843	>	if( ctrl.btag ) {
844	>	passtuple->SetBranchAddress("l3tche",    &l3tche);
845	>	passtuple->SetBranchAddress("l4tche",    &l4tche);
846	>	passtuple->SetBranchAddress("l3tchp",    &l3tchp);
847	>	passtuple->SetBranchAddress("l4tchp",    &l4tchp);
848	>	passtuple->SetBranchAddress("l3csv",     &l3csv);
849	>	passtuple->SetBranchAddress("l4csv",     &l4csv);
850	>	passtuple->SetBranchAddress("l3csvMva",  &l3csvMva);
851	>	passtuple->SetBranchAddress("l4csvMva",  &l4csvMva);
852	>	}
853	>
854	>	if( ctrl.mc )           passtuple->SetBranchAddress("gchannel",  &gchannel);
855	>	passtuple->Fill( );
856	>
857		}
858
859	<	cout  << "run: " << info->runNum
859	>	if( ctrl.debug ) cout  << "run: " << info->runNum
860		<< "\tevt: " << info->evtNum
861		<< "\tZ1channel: " << lepvec[Z1LeptonMinusIndex].type
862		<< "\tZ2channel: " << lepvec[Z2LeptonMinusIndex].type

Diff Legend

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