ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/MitHzz4l/NonMCBackground/src/SelectionEMU.cc

Comparing UserCode/MitHzz4l/NonMCBackground/src/SelectionEMU.cc (file contents):
Revision 1.2 by khahn, Tue Feb 14 21:29:18 2012 UTC vs.
Revision 1.15 by dkralph, Sat Jul 21 11:27:54 2012 UTC

#	Line 1 | Line 1
1	+	//***************************************************************************************************
2	+	//
3	+	// selection sync'ed with https://twiki.cern.ch/twiki/bin/viewauth/CMS/HiggsZZ4l2012SummerSync
4	+	//
5	+	//***************************************************************************************************
6	+
7	+	// system headers
8	+	#include <map>
9	+	#include <utility>
10	+
11	+	// mit headers
12	+	#include "Vertex.h"
13	+
14	+	// 4L stuff
15		#include "SelectionStatus.h"
16		#include "EventData.h"
17		#include "SimpleLepton.h"
18		#include "EfficiencyWeightsInterface.h"
19	<
20	<	#include "HZZBDTElectronSelection.h"
19	>	#include "ElectronSelection.h"
20	>	#include "MuonSelection.h"
21		#include "IsolationSelection.h"
8	–	#include "PassHLT.h"
22		#include "SelectionEMU.h"
23	<
24	<	#include "ExternData.h"
23	>	#include "ReferenceSelection.h"
24	>	#include "Selection.h"
25	>	#include "CommonDefs.h"
26		#include "SelectionDefs.h"
27	+	#include "FSR.h"
28	+	#include "SelectionFuncs.h"
29
30
31	<
32	<	// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
33	<	// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
34	<	EventData apply_EMU_selection(ControlFlags &ctrl,           // input control
35	<	mithep::TEventInfo *info,     // input event info
36	<	TClonesArray *electronArr,    // input electrons
37	<	SelectionStatus (*ElectronPreSelector)( ControlFlags &, const mithep::TElectron*),
38	<	SelectionStatus (*ElectronIDSelector)( ControlFlags &, const mithep::TElectron*),
39	<	SelectionStatus (*ElectronIsoSelector)( ControlFlags &, const mithep::TElectron*),
40	<	TClonesArray *muonArr,         // input muons
41	<	SelectionStatus (*MuonPreSelector)( ControlFlags &, const mithep::TMuon*),
42	<	SelectionStatus (*MuonIDSelector)( ControlFlags &, const mithep::TMuon*),
43	<	SelectionStatus (*MuonIsoSelector)( ControlFlags &, const mithep::TMuon*) )
44	<	// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
45	<	// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
31	>	extern vector<SimpleLepton> failingLeptons;
32	>	extern vector<SimpleLepton> passingLeptons;
33	>	extern vector<int> muTrigObjs,eleTrigObjs,muTriggers,eleTriggers;
34	>	extern bitset<TRIGGER_BIG_NUMBER> triggerBits;
35	>
36	>	//--------------------------------------------------------------------------------------------------
37	>	EventData apply_HZZ4L_EMU_selection(ControlFlags &ctrl,           // input control
38	>	const mithep::EventHeader *info,     // input event info
39	>	mithep::TriggerTable *hltTable,
40	>	mithep::Array<mithep::TriggerObject> *hltObjArr,
41	>	mithep::TriggerObjectsTable *fTrigObjs,
42	>	const mithep::Array<mithep::Vertex>       * vtxArr ,
43	>	const mithep::Array<mithep::PFCandidate>  *pfCandidates,
44	>	const mithep::Array<mithep::PileupEnergyDensity>  *puEnergyDensity,
45	>	const mithep::DecayParticleCol *fConversions,
46	>	const mithep::Array<mithep::Electron> *electronArr,    // input electrons
47	>	SelectionStatus (*ElectronPreSelector)( ControlFlags &,
48	>	const mithep::Electron*,
49	>	const mithep::Vertex *),
50	>	SelectionStatus (*ElectronIDSelector)( ControlFlags &,
51	>	const mithep::Electron*,
52	>	const mithep::Vertex *),
53	>	SelectionStatus (*ElectronIsoSelector)( ControlFlags &,
54	>	const mithep::Electron*,
55	>	const mithep::Vertex *,
56	>	const mithep::Array<mithep::PFCandidate> *,
57	>	const mithep::Array<mithep::PileupEnergyDensity> *,
58	>	mithep::ElectronTools::EElectronEffectiveAreaTarget,
59	>	vector<const mithep::PFCandidate*>),
60	>	const mithep::Array<mithep::Muon> *muonArr,    // input muons
61	>	SelectionStatus (*MuonPreSelector)( ControlFlags &,
62	>	const mithep::Muon*,
63	>	const mithep::Vertex *,
64	>	const mithep::Array<mithep::PFCandidate> *),
65	>	SelectionStatus (*MuonIDSelector)( ControlFlags &,
66	>	const mithep::Muon*,
67	>	// const mithep::Vertex &),
68	>	const mithep::Vertex *,
69	>	const mithep::Array<mithep::PFCandidate> *),
70	>	SelectionStatus (*MuonIsoSelector)( ControlFlags &,
71	>	const mithep::Muon*,
72	>	const mithep::Vertex *,
73	>	const mithep::Array<mithep::PFCandidate> *,
74	>	const mithep::Array<mithep::PileupEnergyDensity> *,
75	>	mithep::MuonTools::EMuonEffectiveAreaTarget,
76	>	vector<const mithep::PFCandidate*>)
77	>	)
78	>	//--------------------------------------------------------------------------------------------------
79		{
80
81		EventData ret;
82		unsigned evtfail = 0x0;
83		TRandom3 r;
35	–
36	–	if( ctrl.debug ) {
37	–	cout << "Run: " << info->runNum
38	–	<< "\tEvt: " << info->evtNum
39	–	<< "\tLumi: " << info->lumiSec
40	–	<< endl;
41	–	}
84
85	<	if( !ctrl.mc ) {
86	<	// not accounting for overlap atm
45	<	RunLumiRangeMap::RunLumiPairType rl(info->runNum, info->lumiSec);
46	<	if( !(rlrm.HasRunLumi(rl)) )  {
47	<	if( ctrl.debug ) cout << "\tfails JSON" << endl;
48	<	ret.status.setStatus(0);
49	<	return ret;
50	<	}
51	<	}
52	<
53	<
54	<	//********************************************************
55	<	// Trigger
56	<	//********************************************************
57	<	//   if( !ctrl.mc ) {
58	<	//     if( !(passHLTSingleMuon(info->triggerBits) )  ) {
59	<	//       if( ctrl.debug ) cout << "\tfails trigger" << endl;
60	<	//       evtfail |= (1<<EVTFAIL_TRIGGER);
61	<	//       ret.status.setStatus(0);
62	<	//       return ret;
63	<	//     }
64	<	//   }
65	<	if( ctrl.debug ) {
66	<	cout << "presel nlep: " << muonArr->GetEntries() + electronArr->GetEntries()
67	<	<< "\tnmuon: "    << muonArr->GetEntries()
68	<	<< "\tnelectron: " << electronArr->GetEntries()
69	<	<< endl;
70	<	}
85	>	failingLeptons.clear();
86	>	passingLeptons.clear();
87
88	<	//********************************************************
89	<	// Lepton Selection
90	<	//********************************************************
91	<	vector<SimpleLepton> lepvec;
92	<	if( muonArr->GetEntries() != 1 && electronArr->GetEntries() != 1 ) {
93	<	ret.status.setStatus(0);
88	>	mithep::MuonTools::EMuonEffectiveAreaTarget eraMu;
89	>	mithep::ElectronTools::EElectronEffectiveAreaTarget eraEle;
90	>	getEATargets(ctrl,eraMu,eraEle);
91	>
92	>	const mithep::Vertex * vtx;
93	>	bool goodVertex = setPV( ctrl, vtxArr, vtx );
94	>	if(goodVertex) {
95	>	ret.status.selectionBits.flip(PASS_SKIM2);
96	>	} else {
97	>	if(ctrl.debug) cout << "found bad vertex" << endl;
98	>	ret.status.setStatus(SelectionStatus::FAIL);
99		return ret;
100		}
101
102	<	//
102	>	//***********************************************************
103	>	// Lepton Selection
104	>	//***********************************************************
105	>	vector<SimpleLepton> lepvec;
106	>	vector<const mithep::PFCandidate*> photonsToVeto;
107	>
108	>
109		if( ctrl.debug ) cout << "\tnMuons: " << muonArr->GetEntries() << endl;
110		//----------------------------------------------------
111	<	for(Int_t i=0; i<muonArr->GetEntries(); i++)
111	>	for(int i=0; i<muonArr->GetEntries(); i++)
112		{
113	<	const mithep::TMuon *mu = (mithep::TMuon*)((*muonArr)[i]);
113	>	const mithep::Muon *mu = (mithep::Muon*)((*muonArr)[i]);
114
115	+
116	+	SelectionStatus denomSel;
117	+	denomSel |= muonPreSelectionNoD0IP(ctrl,mu,vtx,pfCandidates);
118	+	if( !denomSel.passPre() ) continue;
119	+
120		SelectionStatus musel;
121	<	if(ctrl.debug) cout << "musel.status  before anything: " << musel.getStatus() << endl;
122	<	musel |= (*MuonPreSelector)(ctrl,mu);
123	<	if(ctrl.debug) cout << "musel.status  after presel: " << musel.getStatus() << endl;
124	<	musel |= (*MuonIDSelector)(ctrl,mu);
125	<	if(ctrl.debug) cout << "musel.status  after ID: " << musel.getStatus() << endl;
126	<	musel |= (*MuonIsoSelector)(ctrl,mu);
127	<	if(ctrl.debug) cout << "musel.status  after iso: " << musel.getStatus() << endl;
128	<
129	<	if( ctrl.debug ) {
130	<	cout << "muon:: pt: " << mu->pt
99	<	<< "\teta: " << mu->eta
100	<	<< "\tisorel: " <<  mu->pfIso03/mu->pt
101	<	<< "\tstatus: " << hex << musel.getStatus() << dec
102	<	<< endl;
103	<	}
121	>	musel |= (*MuonPreSelector)(ctrl,mu,vtx,pfCandidates);
122	>	musel |= (*MuonIDSelector)(ctrl,mu,vtx,pfCandidates );
123	>	musel |= (*MuonIsoSelector)(ctrl,mu,vtx,pfCandidates,puEnergyDensity,eraMu,photonsToVeto);
124	>
125	>	SimpleLepton tmplep;
126	>	float pt = mu->Pt();
127	>	tmplep.vec.SetPtEtaPhiM(pt,
128	>	mu->Eta(),
129	>	mu->Phi(),
130	>	MUON_MASS);
131
132	<	if ( musel.pass() ) {
132	>	tmplep.type    = 13;
133	>	tmplep.index   = i;
134	>	tmplep.charge  = mu->Charge();
135	>	tmplep.isoPF04 = musel.isoPF04;
136	>	tmplep.chisoPF04 = musel.chisoPF04;
137	>	tmplep.gaisoPF04 = musel.gaisoPF04;
138	>	tmplep.neisoPF04 = musel.neisoPF04;
139	>	tmplep.ip3dSig = mu->Ip3dPVSignificance();
140	>	tmplep.is4l    = false;
141	>	tmplep.isEB    = (fabs(mu->Eta()) < 1.479 ? 1 : 0 );
142	>	tmplep.isoMVA  = musel.isoMVA;
143	>	tmplep.isLoose = musel.loose();
144	>
145	>	bitset<TRIGGER_BIG_NUMBER> hltMatchBits = fillHLTMatchBits( mu->Eta(), mu->Phi(), hltTable, hltObjArr, fTrigObjs);
146	>	tmplep.isTight = testBits(ctrl,triggerBits,muTriggers,hltMatchBits,muTrigObjs);
147	>
148	>	tmplep.bdtfail = 0;
149	>	if(triggerBits.test(kHLT_IsoMu24_eta2p1))        tmplep.bdtfail |= 1;
150	>	if(hltMatchBits.test(kHLT_IsoMu24_eta2p1_MuObj)) tmplep.bdtfail |= 2;
151	>	if(triggerBits.test(kHLT_IsoMu24))               tmplep.bdtfail |= 4;
152	>	if(hltMatchBits.test(kHLT_IsoMu24_MuObj))        tmplep.bdtfail |= 8;
153	>
154	>	tmplep.status  = musel;
155	>	tmplep.fsrRecoveryAttempted = false;
156	>	tmplep.tightCutsApplied = muon2012CutBasedIDTightVersionWithOldIsoThatWorksOn2011(ctrl,mu,vtx,pfCandidates,puEnergyDensity,eraMu);
157	>	// tmplep.d0      = mu->HasTrackerTrk() ? mu->TrackerTrk()->D0Corrected(*vtx) : 0;
158	>	// tmplep.dz      = mu->HasTrackerTrk() ? mu->TrackerTrk()->DzCorrected(*vtx) : 0;
159
160	<	SimpleLepton tmplep;
161	<	float pt = mu->pt;
162	<	tmplep.vecorig->SetPtEtaPhiM(pt,
163	<	mu->eta,
164	<	mu->phi,
165	<	MUON_MASS);
160	>	lepvec.push_back(tmplep);
161	>	if( ctrl.debug ) cout << endl;
162	>	}
163	>
164	>	if( ctrl.debug ) { cout << "\tnElectron: " << electronArr->GetEntries() << endl; }
165	>	// --------------------------------------------------------------------------------
166	>	for(int i=0; i<electronArr->GetEntries(); i++)
167	>	{
168	>	const mithep::Electron *ele = (mithep::Electron*)((*electronArr)[i]);
169	>
170	>	SelectionStatus denomSel;
171	>	denomSel |= electronPreSelectionNoD0IP(ctrl,ele,vtx);
172	>	if( !denomSel.passPre() ) continue;
173
174	<	if( ctrl.do_escale_up ) {
175	<	pt=scale_smear_muon_Up(pt, 1,  r);
176	<	}
177	<	if( ctrl.do_escale_down ) {
118	<	pt=scale_smear_muon_Down(pt, 1,  r);
119	<	}
174	>	SelectionStatus elesel;
175	>	elesel |= (*ElectronPreSelector)(ctrl,ele,vtx);
176	>	elesel |= (*ElectronIDSelector)(ctrl,ele,vtx);
177	>	elesel |= (*ElectronIsoSelector)(ctrl,ele,vtx,pfCandidates,puEnergyDensity,eraEle,photonsToVeto);
178
179	<	tmplep.vec->SetPtEtaPhiM(pt,
180	<	mu->eta,
181	<	mu->phi,
182	<	MUON_MASS);
179	>	SimpleLepton tmplep;
180	>	float pt = ele->Pt();
181	>	tmplep.vec.SetPtEtaPhiM( pt,
182	>	ele->Eta(),
183	>	ele->Phi(),
184	>	ELECTRON_MASS );
185
186	<	tmplep.type    = 13;
186	>	tmplep.type    = 11;
187		tmplep.index   = i;
188	<	tmplep.charge  = mu->q;
189	<	tmplep.isoTrk  = mu->trkIso03;
190	<	tmplep.isoEcal = mu->emIso03;
191	<	tmplep.isoHcal = mu->hadIso03;
192	<	tmplep.isoPF03 = mu->pfIso03;
193	<	tmplep.isoPF04 = mu->pfIso04;
134	<	tmplep.ip3dSig = mu->ip3dSig;
188	>	tmplep.charge  = ele->Charge();
189	>	tmplep.isoPF04 = elesel.isoPF04;
190	>	tmplep.chisoPF04 = elesel.chisoPF04;
191	>	tmplep.gaisoPF04 = elesel.gaisoPF04;
192	>	tmplep.neisoPF04 = elesel.neisoPF04;
193	>	tmplep.ip3dSig = ele->Ip3dPVSignificance();
194		tmplep.is4l    = false;
195	<	tmplep.isEB    = (fabs(mu->eta) < 1.479 ? 1 : 0 );
196	<	tmplep.isTight = musel.tight();
197	<	tmplep.isLoose = musel.loose();
195	>	tmplep.isEB    = ele->IsEB();
196	>	tmplep.scID    = ele->SCluster()->GetUniqueID();
197	>
198	>	bitset<TRIGGER_BIG_NUMBER> hltMatchBits = fillHLTMatchBits( ele->Eta(), ele->Phi(), hltTable, hltObjArr, fTrigObjs);
199	>	tmplep.isTight = testBits(ctrl,triggerBits,eleTriggers,hltMatchBits,eleTrigObjs);
200	>
201	>	tmplep.isTight = elesel.tight();
202	>	tmplep.isLoose = elesel.loose();
203	>	tmplep.status  = elesel;
204	>	tmplep.idMVA   = elesel.idMVA;
205	>	tmplep.isoMVA  = elesel.isoMVA;
206	>	tmplep.fsrRecoveryAttempted = false;
207	>	tmplep.tightCutsApplied = electron2012CutBasedIDMediumVersionThatWorksOn2011(ctrl,ele,vtx,pfCandidates,fConversions,puEnergyDensity,eraEle);
208	>	// tmplep.d0      = ele->BestTrk()->D0Corrected(*vtx);
209	>	// tmplep.dz      = ele->BestTrk()->DzCorrected(*vtx);
210	>
211		lepvec.push_back(tmplep);
212	<	if( ctrl.debug ) { cout << "muon passes ... " << endl;}
212	>	if( ctrl.debug ) cout << endl;
213		}
142	–	//  }
143	–	}
144	–
145	–
146	–
147	–	//
148	–	if( ctrl.debug ) { cout << "\tnElectron: " << electronArr->GetEntries() << endl; }
149	–	// --------------------------------------------------------------------------------
150	–	for(Int_t i=0; i<electronArr->GetEntries(); i++)
151	–	{
152	–	const mithep::TElectron *ele = (mithep::TElectron*)((*electronArr)[i]);
153	–
154	–	Bool_t isMuonOverlap = kFALSE;
155	–	for (int k=0; k<lepvec.size(); ++k) {
156	–	TVector3 tmplep;
157	–	tmplep.SetPtEtaPhi(ele->pt, ele->eta, ele->phi);
158	–	if ( abs(lepvec[k].type == 13) && lepvec[k].vec->Vect().DrEtaPhi(tmplep) < 0.15 ) {
159	–	if( ctrl.debug ) cout << "-----> isMuonOverlap! " << endl;
160	–	isMuonOverlap = kTRUE;
161	–	break;
162	–	}
163	–	}
164	–
165	–	SelectionStatus elesel;
166	–	elesel |= (*ElectronPreSelector)(ctrl,ele);
167	–	elesel |= (*ElectronIDSelector)(ctrl,ele);
168	–	elesel |= (*ElectronIsoSelector)(ctrl,ele);
169	–	if( elesel.getStatus() & SelectionStatus::PRESELECTION )
170	–	elesel.setStatus(SelectionStatus::LOOSESELECTION);
171	–
172	–	if( ctrl.debug ){
173	–	cout << "\tscEt: " << ele->scEt
174	–	<< "\tscEta: " << ele->scEta
175	–	<< "\tncluster: " << ele->ncluster
176	–	<< "\tisorel: " <<  ele->pfIso04/ele->pt
177	–	<< "\tstatus: " << hex << elesel.getStatus() << dec
178	–	<< endl;
179	–	}
214
215	<	if ( elesel.pass() && !isMuonOverlap )
216	<	{
183	<	SimpleLepton tmplep;
184	<
185	<	float pt = ele->pt;
186	<	tmplep.vecorig->SetPtEtaPhiM( pt,
187	<	ele->eta,
188	<	ele->phi,
189	<	ELECTRON_MASS );
190	<
191	<	if( ctrl.do_escale ) {
192	<	pt=scale_smear_electron(pt, ele->isEB, r);
193	<	}
194	<	if( ctrl.do_escale_up ) {
195	<	pt=scale_smear_electron_Up(pt, ele->isEB,  r);
196	<	}
197	<	if( ctrl.do_escale_down ) {
198	<	pt=scale_smear_electron_Down(pt, ele->isEB,  r);
199	<	}
200	<
201	<
202	<	tmplep.vec->SetPtEtaPhiM( pt,
203	<	ele->eta,
204	<	ele->phi,
205	<	ELECTRON_MASS );
206	<
207	<	tmplep.type    = 11;
208	<	tmplep.index   = i;
209	<	tmplep.charge  = ele->q;
210	<	tmplep.isoTrk  = ele->trkIso03;
211	<	tmplep.isoEcal = ele->emIso03;
212	<	tmplep.isoHcal = ele->hadIso03;
213	<	tmplep.isoPF03 = ele->pfIso03;
214	<	tmplep.isoPF04 = ele->pfIso04;
215	<	tmplep.ip3dSig = ele->ip3dSig;
216	<	tmplep.is4l    = false;
217	<	tmplep.isEB    = ele->isEB;
218	<	tmplep.scID    = ele->scID;
219	<	tmplep.isTight = elesel.tight();
220	<	tmplep.isLoose = elesel.pass();
221	<	lepvec.push_back(tmplep);
222	<	if( ctrl.debug ) { cout << "\telectron passes ... " << endl; }
223	<	}
224	<	}
225	<
226	<
215	>	sort( lepvec.begin(), lepvec.end(), SimpleLepton::lep_pt_sort );
216	>
217		//********************************************************
218	<	// Dump Stuff
218	>	// Step 2: Lepton Cleaning
219		//********************************************************
220	<	sort( lepvec.begin(), lepvec.end(), SimpleLepton::lep_pt_sort );
221	<	int nmu=0, nele=0;
222	<	for( int i=0; i<lepvec.size(); i++ ) {
223	<	if(ctrl.debug) cout << "lepvec :: index: " << i
224	<	<< "\tpt: " << lepvec[i].vec->Pt()
225	<	<< "\ttype: " << lepvec[i].type
226	<	<< endl;
227	<	if( abs(lepvec[i].type) == 11 ) nele++;
228	<	else nmu++;
220	>	vector<vector<SimpleLepton>::iterator> electrons_to_erase;
221	>	for (vector<SimpleLepton>::iterator it1=lepvec.begin(); it1 != lepvec.end(); it1++ ) {
222	>	if ( abs(it1->type) != 11 ) continue;
223	>	TVector3 evec = it1->vec.Vect();
224	>
225	>	bool erase_this_electron=false;
226	>	for (vector<SimpleLepton>::iterator it2=lepvec.begin(); it2 != lepvec.end(); it2++ ) {
227	>	if ( it2 == it1 )                       continue;
228	>	if ( abs(it2->type) != 13 )             continue;
229	>	// if( !(it2->status.looseIDAndPre()) )    continue;
230	>	TVector3 mvec = it2->vec.Vect();
231	>
232	>	if ( evec.DrEtaPhi(mvec) < 0.05 ) {
233	>	erase_this_electron=true;
234	>	break;
235	>	}
236	>	}
237	>	if( erase_this_electron )
238	>	electrons_to_erase.push_back(it1);
239		}
240	<	if( ctrl.debug ) {
241	<	cout << "postsel nlep: " << lepvec.size()
242	<	<< "\tnmuon: " << nmu
243	<	<< "\tnelectron: " << nele
244	<	<< endl;
240	>	for( int i=0; i<electrons_to_erase.size(); i++ ) {
241	>	lepvec.erase(electrons_to_erase[i]);
242		}
246	–
247	–
248	–	//******************************************************************************
249	–	// Selection
250	–	//******************************************************************************
251	–	float bestMass=-1; int best_mu_index=-1, best_ele_index=-1;
252	–	for(int i = 0; i<lepvec.size(); i++) {      // get a tight muon
253	–	if( abs(lepvec[i].type) != 13 ) continue;
254	–	if( !(lepvec[i].isTight) ) continue;
255	–	//      if( lepvec[i].vec->Pt() < 35 ) continue;
256	–	if( ctrl.debug ) cout << "got a muon, index: " << i << endl;
257	–
258	–	for(int j = 0; j<lepvec.size(); j++) {     // get a loose electron
259	–	if( j == i ) continue;
260	–	if( abs(lepvec[j].type) != 11 ) continue;
261	–	if( !(lepvec[j].isLoose) ) continue;
262	–	if (lepvec[i].charge == lepvec[j].charge) continue;
263	–	//      if (lepvec[i].charge != lepvec[j].charge) continue;
264	–	if( ctrl.debug ) cout << "got a electron, index: " << j << endl;
265	–
266	–	float tmpMass = ( *(lepvec[i].vec) + *(lepvec[j].vec) ).M();
267	–	if( ctrl.debug ) cout << "tmp vs best :: " << tmpMass << "," << bestMass << endl;
268	–	if( tmpMass > bestMass ) {
269	–	bestMass = tmpMass;
270	–	best_mu_index=i;
271	–	best_ele_index=j;
272	–	}
243
244	+	//********************************************************
245	+	// Step 3: Good Leptons
246	+	//********************************************************
247	+	for (int i=0; i<lepvec.size(); i++ ) {
248	+	if( !(lepvec[i].status.loose()) ) {
249	+	failingLeptons.push_back(lepvec[i]);
250	+	} else {
251	+	passingLeptons.push_back(lepvec[i]);
252		}
253		}
254
255	<	if( bestMass > 0 ) {
256	<	if( ctrl.debug ) cout << "EMU candidate, mass : " << bestMass << endl;
257	<	if( lepvec[best_ele_index].isTight )
258	<	ret.status.setStatus(SelectionStatus::TIGHTSELECTION);
259	<	else
260	<	ret.status.setStatus(SelectionStatus::LOOSESELECTION);
261	<	ret.Z1leptons.push_back(lepvec[best_mu_index]);
262	<	ret.Z1leptons.push_back(lepvec[best_ele_index]);
263	<	ret.Z2leptons.push_back(lepvec[best_mu_index]);
264	<	ret.Z2leptons.push_back(lepvec[best_ele_index]);
265	<	return ret;
255	>	//******************************************************************************
256	>	// W + (OF SS lepton) Selection
257	>	//******************************************************************************
258	>	if(has_ssof_lepton(ctrl)) {
259	>	ret.status.setStatus(SelectionStatus::EVTPASS);
260	>	ret.Z1leptons.push_back(passingLeptons[0]);
261	>	ret.Z1leptons.push_back(passingLeptons[0]);
262	>	ret.Z2leptons.push_back(passingLeptons[0]);
263	>	ret.Z2leptons.push_back(passingLeptons[0]);
264	>	} else {
265	>	ret.status.setStatus(SelectionStatus::FAIL);
266		}
289	–
290	–	ret.status.setStatus(0);
267		return ret;
292	–
268		}
269	+	//----------------------------------------------------------------------------------------
270	+	bool has_ssof_lepton(ControlFlags &ctrl)
271	+	{
272	+	bool has_ssof=false;
273	+	for(unsigned iw=0; iw<passingLeptons.size(); iw++) {
274	+	SimpleLepton w_lep = passingLeptons[iw];
275	+	//????????????????????????????????????????????????????????????????????????????????????????
276	+	// this is applied in skim (skim also applies ww muon id)
277	+	// if(abs(w_lep.type) == 11) {
278	+	//   if( !(w_lep.tightCutsApplied) )
279	+	//  continue;
280	+	// }
281	+	//????????????????????????????????????????????????????????????????????????????????????????
282	+	for(unsigned ifake=0; ifake<failingLeptons.size(); ifake++) {
283	+	SimpleLepton fake_lep = failingLeptons[ifake];
284	+	if(abs(fake_lep.type) == abs(w_lep.type)) continue;
285	+	if(fake_lep.charge != w_lep.charge) continue;
286	+	has_ssof = true;
287	+	}
288	+	for(unsigned ipass=0; ipass<passingLeptons.size(); ipass++) {
289	+	if(ipass == iw) continue;
290	+	SimpleLepton pass_lep = passingLeptons[ipass];
291	+	if(abs(pass_lep.type) == abs(w_lep.type)) continue;
292	+	if(pass_lep.charge != w_lep.charge) continue;
293	+	has_ssof = true;
294	+	}
295	+	}
296
297	<
297	>	return has_ssof;
298	>	}

Diff Legend

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