NonMCBackground/src/SelectionEMU.cc

//***************************************************************************************************
//
// selection sync'ed with https://twiki.cern.ch/twiki/bin/viewauth/CMS/HiggsZZ4l2012SummerSync
//
//***************************************************************************************************

// system headers
#include <map>
#include <utility>

// mit headers
#include "Vertex.h"

// 4L stuff
#include "SelectionStatus.h" 
#include "EventData.h" 
#include "SimpleLepton.h" 
#include "EfficiencyWeightsInterface.h"
#include "ElectronSelection.h"
#include "MuonSelection.h"
#include "IsolationSelection.h"
#include "SelectionEMU.h"
#include "ReferenceSelection.h"
#include "Selection.h"
#include "CommonDefs.h"
#include "SelectionDefs.h"
#include "FSR.h"
#include "SelectionFuncs.h"


extern vector<SimpleLepton> failingLeptons;
extern vector<SimpleLepton> passingLeptons;
extern vector<int> muTrigObjs,eleTrigObjs,muTriggers,eleTriggers;
extern bitset<TRIGGER_BIG_NUMBER> triggerBits;

//--------------------------------------------------------------------------------------------------
EventData apply_HZZ4L_EMU_selection(ControlFlags &ctrl,           // input control 
                                    const mithep::EventHeader *info,     // input event info
                                    mithep::TriggerTable *hltTable,
                                    mithep::Array<mithep::TriggerObject> *hltObjArr,
                                    mithep::TriggerObjectsTable *fTrigObjs,
                                    const mithep::Array<mithep::Vertex>       * vtxArr ,
                                    const mithep::Array<mithep::PFCandidate>  *pfCandidates,
                                    const mithep::Array<mithep::PileupEnergyDensity>  *puEnergyDensity,
                                    const mithep::DecayParticleCol *fConversions,
                                    const mithep::Array<mithep::Electron> *electronArr,    // input electrons
                                    SelectionStatus (*ElectronPreSelector)( ControlFlags &, 
                                                                            const mithep::Electron*,
                                                                            const mithep::Vertex *),
                                    SelectionStatus (*ElectronIDSelector)( ControlFlags &, 
                                                                           const mithep::Electron*,
                                                                           const mithep::Vertex *), 
                                    SelectionStatus (*ElectronIsoSelector)( ControlFlags &, 
                                                                            const mithep::Electron*, 
                                                                            const mithep::Vertex *, 
                                                                            const mithep::Array<mithep::PFCandidate> *, 
                                                                            const mithep::Array<mithep::PileupEnergyDensity> *, 
                                                                            mithep::ElectronTools::EElectronEffectiveAreaTarget,
                                                                            vector<const mithep::PFCandidate*>),
                                    const mithep::Array<mithep::Muon> *muonArr,    // input muons
                                    SelectionStatus (*MuonPreSelector)( ControlFlags &, 
                                                                        const mithep::Muon*,
                                                                        const mithep::Vertex *,
                                                                        const mithep::Array<mithep::PFCandidate> *),
                                    SelectionStatus (*MuonIDSelector)( ControlFlags &, 
                                                                       const mithep::Muon*, 
                                                                       // const mithep::Vertex &),
                                                                       const mithep::Vertex *,
                                                                       const mithep::Array<mithep::PFCandidate> *),
                                    SelectionStatus (*MuonIsoSelector)( ControlFlags &, 
                                                                        const mithep::Muon*, 
                                                                        const mithep::Vertex *, 
                                                                        const mithep::Array<mithep::PFCandidate> *,
                                                                        const mithep::Array<mithep::PileupEnergyDensity> *, 
                                                                        mithep::MuonTools::EMuonEffectiveAreaTarget,
                                                                        vector<const mithep::PFCandidate*>)
                                    )
//--------------------------------------------------------------------------------------------------
{       

  EventData ret;
  unsigned evtfail = 0x0;
  TRandom3 r;

  failingLeptons.clear();
  passingLeptons.clear();

  mithep::MuonTools::EMuonEffectiveAreaTarget eraMu;
  mithep::ElectronTools::EElectronEffectiveAreaTarget eraEle;
  getEATargets(ctrl,eraMu,eraEle);

  const mithep::Vertex * vtx;
  bool goodVertex = setPV( ctrl, vtxArr, vtx );
  if(goodVertex) {
    ret.status.selectionBits.flip(PASS_SKIM2);
  } else {
    if(ctrl.debug) cout << "found bad vertex" << endl;
    ret.status.setStatus(SelectionStatus::FAIL);
    return ret;
  }

  //***********************************************************
  // Lepton Selection 
  //***********************************************************
  vector<SimpleLepton> lepvec;
  vector<const mithep::PFCandidate*> photonsToVeto;


  if( ctrl.debug ) cout << "\tnMuons: " << muonArr->GetEntries() << endl;
  //----------------------------------------------------
  for(int i=0; i<muonArr->GetEntries(); i++) 
    {
      const mithep::Muon *mu = (mithep::Muon*)((*muonArr)[i]);      
      

      SelectionStatus denomSel;
      denomSel |= muonPreSelectionNoD0IP(ctrl,mu,vtx,pfCandidates);
      if( !denomSel.passPre() ) continue;

      SelectionStatus musel;
      musel |= (*MuonPreSelector)(ctrl,mu,vtx,pfCandidates);
      musel |= (*MuonIDSelector)(ctrl,mu,vtx,pfCandidates );
      musel |= (*MuonIsoSelector)(ctrl,mu,vtx,pfCandidates,puEnergyDensity,eraMu,photonsToVeto);

      SimpleLepton tmplep;
      float pt = mu->Pt();
      tmplep.vec.SetPtEtaPhiM(pt, 
                               mu->Eta(), 
                               mu->Phi(),
                               MUON_MASS);
      
      tmplep.type    = 13;
      tmplep.index   = i;
      tmplep.charge  = mu->Charge();
      tmplep.isoTrk  = mu->IsoR03SumPt();
      tmplep.isoEcal = mu->IsoR03EmEt();
      tmplep.isoHcal = mu->IsoR03HadEt();
      tmplep.isoPF04 = musel.isoPF04;
      tmplep.chisoPF04 = musel.chisoPF04;
      tmplep.gaisoPF04 = musel.gaisoPF04;
      tmplep.neisoPF04 = musel.neisoPF04;
      // tmplep.isoPF03 = computePFMuonIso(mu,vtx,pfCandidates,0.3);
      // tmplep.isoPF04 = computePFMuonIso(mu,vtx,pfCandidates,0.4);
      tmplep.ip3dSig = mu->Ip3dPVSignificance();
      tmplep.is4l    = false;
      tmplep.isEB    = (fabs(mu->Eta()) < 1.479 ? 1 : 0 ); 
      tmplep.isoMVA  = musel.isoMVA;
      tmplep.isLoose = musel.loose();

      bitset<TRIGGER_BIG_NUMBER> hltMatchBits = fillHLTMatchBits( mu->Eta(), mu->Phi(), hltTable, hltObjArr, fTrigObjs);
      tmplep.isTight = testBits(ctrl,triggerBits,muTriggers,hltMatchBits,muTrigObjs);

      tmplep.bdtfail = 0;
      if(triggerBits.test(kHLT_IsoMu24_eta2p1))        tmplep.bdtfail |= 1;
      if(hltMatchBits.test(kHLT_IsoMu24_eta2p1_MuObj)) tmplep.bdtfail |= 2;
      if(triggerBits.test(kHLT_IsoMu24))               tmplep.bdtfail |= 4;
      if(hltMatchBits.test(kHLT_IsoMu24_MuObj))        tmplep.bdtfail |= 8;

      tmplep.status  = musel;     
      tmplep.fsrRecoveryAttempted = false;
      tmplep.tightCutsApplied = muon2012CutBasedIDTightVersionWithOldIsoThatWorksOn2011(ctrl,mu,vtx,pfCandidates,puEnergyDensity,eraMu);
      lepvec.push_back(tmplep);
      if( ctrl.debug ) cout << endl;
    }

    if( ctrl.debug ) { cout << "\tnElectron: " << electronArr->GetEntries() << endl; }
    // --------------------------------------------------------------------------------
    for(int i=0; i<electronArr->GetEntries(); i++) 
      {
        const mithep::Electron *ele = (mithep::Electron*)((*electronArr)[i]);

        SelectionStatus denomSel;
        denomSel |= electronPreSelectionNoD0IP(ctrl,ele,vtx);
        if( !denomSel.passPre() ) continue;
        
        SelectionStatus elesel;
        elesel |= (*ElectronPreSelector)(ctrl,ele,vtx);
        elesel |= (*ElectronIDSelector)(ctrl,ele,vtx);
        elesel |= (*ElectronIsoSelector)(ctrl,ele,vtx,pfCandidates,puEnergyDensity,eraEle,photonsToVeto);
        
        SimpleLepton tmplep;
        float pt = ele->Pt();
        tmplep.vec.SetPtEtaPhiM( pt,
                                 ele->Eta(),
                                 ele->Phi(),
                                 ELECTRON_MASS );
        
        tmplep.type    = 11;
        tmplep.index   = i;
        tmplep.charge  = ele->Charge();
        tmplep.isoTrk  = ele->TrackIsolationDr03();
        tmplep.isoEcal = ele->EcalRecHitIsoDr03();
        tmplep.isoHcal = ele->HcalTowerSumEtDr03();
        tmplep.isoPF04 = elesel.isoPF04;
        tmplep.chisoPF04 = elesel.chisoPF04;
        tmplep.gaisoPF04 = elesel.gaisoPF04;
        tmplep.neisoPF04 = elesel.neisoPF04;
        // tmplep.isoPF03 = computePFEleIso(ele,vtx,pfCandidates,0.3);
        // tmplep.isoPF04 = computePFEleIso(ele,vtx,pfCandidates,0.4);
        tmplep.ip3dSig = ele->Ip3dPVSignificance();
        tmplep.is4l    = false;
        tmplep.isEB    = ele->IsEB();
        tmplep.scID    = ele->SCluster()->GetUniqueID();

        bitset<TRIGGER_BIG_NUMBER> hltMatchBits = fillHLTMatchBits( ele->Eta(), ele->Phi(), hltTable, hltObjArr, fTrigObjs);
        tmplep.isTight = testBits(ctrl,triggerBits,eleTriggers,hltMatchBits,eleTrigObjs);

        tmplep.isTight = elesel.tight();
        tmplep.isLoose = elesel.loose();
        tmplep.status  = elesel;
        tmplep.idMVA   = elesel.idMVA;
        tmplep.isoMVA  = elesel.isoMVA;
        tmplep.fsrRecoveryAttempted = false;
        tmplep.tightCutsApplied = electron2012CutBasedIDMediumVersionThatWorksOn2011(ctrl,ele,vtx,pfCandidates,fConversions,puEnergyDensity,eraEle);
        lepvec.push_back(tmplep);
        if( ctrl.debug ) cout << endl;
      }

    sort( lepvec.begin(), lepvec.end(), SimpleLepton::lep_pt_sort );

    //********************************************************
    // Step 2: Lepton Cleaning
    //********************************************************
    vector<vector<SimpleLepton>::iterator> electrons_to_erase; 
    for (vector<SimpleLepton>::iterator it1=lepvec.begin(); it1 != lepvec.end(); it1++ ) {
      if ( abs(it1->type) != 11 ) continue;
      TVector3 evec = it1->vec.Vect();
      
      bool erase_this_electron=false;
      for (vector<SimpleLepton>::iterator it2=lepvec.begin(); it2 != lepvec.end(); it2++ ) {
        if ( it2 == it1 )                       continue;
        if ( abs(it2->type) != 13 )             continue;
        // if( !(it2->status.looseIDAndPre()) )    continue;
        TVector3 mvec = it2->vec.Vect();
        
        if ( evec.DrEtaPhi(mvec) < 0.05 ) {
          erase_this_electron=true;
          break;
        }
      }
      if( erase_this_electron )
        electrons_to_erase.push_back(it1);
    }
    for( int i=0; i<electrons_to_erase.size(); i++ ) {
      lepvec.erase(electrons_to_erase[i]);
    }

    //********************************************************
    // Step 3: Good Leptons
    //********************************************************
    for (int i=0; i<lepvec.size(); i++ ) {
      if( !(lepvec[i].status.loose()) ) { 
        failingLeptons.push_back(lepvec[i]);
      } else {
        passingLeptons.push_back(lepvec[i]);
      }
    }

    //******************************************************************************
    // W + (OF SS lepton) Selection
    //******************************************************************************
    if(has_ssof_lepton(ctrl)) {
      ret.status.setStatus(SelectionStatus::EVTPASS);
      ret.Z1leptons.push_back(passingLeptons[0]);
      ret.Z1leptons.push_back(passingLeptons[0]);
      ret.Z2leptons.push_back(passingLeptons[0]);
      ret.Z2leptons.push_back(passingLeptons[0]);
    } else {
      ret.status.setStatus(SelectionStatus::FAIL);
    }
    return ret;
}
//----------------------------------------------------------------------------------------
bool has_ssof_lepton(ControlFlags &ctrl)
{
  bool has_ssof=false;
  for(unsigned iw=0; iw<passingLeptons.size(); iw++) {
    SimpleLepton w_lep = passingLeptons[iw];
    //????????????????????????????????????????????????????????????????????????????????????????
    // this is applied in skim (skim also applies ww muon id)
    // if(abs(w_lep.type) == 11) {
    //   if( !(w_lep.tightCutsApplied) )
    //  continue;
    // }
    //????????????????????????????????????????????????????????????????????????????????????????
    for(unsigned ifake=0; ifake<failingLeptons.size(); ifake++) {
      SimpleLepton fake_lep = failingLeptons[ifake];
      if(abs(fake_lep.type) == abs(w_lep.type)) continue;
      if(fake_lep.charge != w_lep.charge) continue;
      has_ssof = true;
    }
    for(unsigned ipass=0; ipass<passingLeptons.size(); ipass++) {
      if(ipass == iw) continue;
      SimpleLepton pass_lep = passingLeptons[ipass];
      if(abs(pass_lep.type) == abs(w_lep.type)) continue;
      if(pass_lep.charge != w_lep.charge) continue;
      has_ssof = true;
    }
  }

  return has_ssof;
}
Revision:	1.13
Committed:	Tue Jul 17 10:17:22 2012 UTC (12 years, 10 months ago) by dkralph
Content type:	text/plain
Branch:	MAIN
Changes since 1.12:	+2 -2 lines
Log Message:	1) implemented a way to store the bitset of all matched triggers for the leptons in the FO branches (using TBits, since root doesn't seem to yet support bitsets). See some commented lines in applyZPlusX.cc and ZPlusX.cc (more or less moot -- see below) 2) These bitsets are almost entirely zeroes, but root didn't compress them as much as I was hoping -- adding them tripled the file size, so I had to implement another way to store trigger info in the ntuples. I decided to store info for only a few triggers in an unsigned value in SimpleLepton, with the def of the bits at the bottom of TriggerUtils.cc in the function initAnalysisTriggers (http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/UserCode/MitHzz4l/Util/src/TriggerUtils.cc?r1=1.15&r2=1.16) 3) added the same (info for a few triggers) for HLT Info to an unsigned value in InfoStruct 4) added all versions of the emu cross triggers to TriggerUtils.cc
#	User	Rev	Content
1	dkralph	1.4	//***************************************************************************************************
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	khahn	1.1	#include "SelectionStatus.h"
16			#include "EventData.h"
17			#include "SimpleLepton.h"
18			#include "EfficiencyWeightsInterface.h"
19	dkralph	1.4	#include "ElectronSelection.h"
20			#include "MuonSelection.h"
21	khahn	1.1	#include "IsolationSelection.h"
22			#include "SelectionEMU.h"
23	dkralph	1.4	#include "ReferenceSelection.h"
24			#include "Selection.h"
25			#include "CommonDefs.h"
26	khahn	1.1	#include "SelectionDefs.h"
27	dkralph	1.4	#include "FSR.h"
28	dkralph	1.5	#include "SelectionFuncs.h"
29	khahn	1.1
30
31	dkralph	1.4	extern vector<SimpleLepton> failingLeptons;
32			extern vector<SimpleLepton> passingLeptons;
33	dkralph	1.9	extern vector<int> muTrigObjs,eleTrigObjs,muTriggers,eleTriggers;
34			extern bitset<TRIGGER_BIG_NUMBER> triggerBits;
35	khahn	1.1
36	dkralph	1.4	//--------------------------------------------------------------------------------------------------
37			EventData apply_HZZ4L_EMU_selection(ControlFlags &ctrl, // input control
38	dkralph	1.9	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	dkralph	1.10	const mithep::DecayParticleCol *fConversions,
46	dkralph	1.9	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	dkralph	1.4	const mithep::Vertex *,
56	dkralph	1.9	const mithep::Array<mithep::PFCandidate> *,
57	dkralph	1.4	const mithep::Array<mithep::PileupEnergyDensity> *,
58	dkralph	1.9	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	dkralph	1.4	//--------------------------------------------------------------------------------------------------
79	khahn	1.1	{
80
81			EventData ret;
82			unsigned evtfail = 0x0;
83			TRandom3 r;
84
85	dkralph	1.4	failingLeptons.clear();
86			passingLeptons.clear();
87
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	khahn	1.1	}
101
102	dkralph	1.4	//***********************************************************
103			// Lepton Selection
104			//***********************************************************
105	khahn	1.1	vector<SimpleLepton> lepvec;
106	dkralph	1.4	vector<const mithep::PFCandidate*> photonsToVeto;
107
108	khahn	1.1
109			if( ctrl.debug ) cout << "\tnMuons: " << muonArr->GetEntries() << endl;
110			//----------------------------------------------------
111	dkralph	1.4	for(int i=0; i<muonArr->GetEntries(); i++)
112	khahn	1.1	{
113	dkralph	1.4	const mithep::Muon mu = (mithep::Muon)((*muonArr)[i]);
114	khahn	1.1
115	dkralph	1.8
116			SelectionStatus denomSel;
117	dkralph	1.13	denomSel \|= muonPreSelectionNoD0IP(ctrl,mu,vtx,pfCandidates);
118	dkralph	1.9	if( !denomSel.passPre() ) continue;
119	dkralph	1.8
120	khahn	1.1	SelectionStatus musel;
121	dkralph	1.4	musel \|= (*MuonPreSelector)(ctrl,mu,vtx,pfCandidates);
122			musel \|= (*MuonIDSelector)(ctrl,mu,vtx,pfCandidates );
123	dkralph	1.8	musel \|= (*MuonIsoSelector)(ctrl,mu,vtx,pfCandidates,puEnergyDensity,eraMu,photonsToVeto);
124	dkralph	1.4
125			SimpleLepton tmplep;
126			float pt = mu->Pt();
127			tmplep.vec.SetPtEtaPhiM(pt,
128			mu->Eta(),
129			mu->Phi(),
130			MUON_MASS);
131	khahn	1.1
132	dkralph	1.4	tmplep.type = 13;
133			tmplep.index = i;
134			tmplep.charge = mu->Charge();
135			tmplep.isoTrk = mu->IsoR03SumPt();
136			tmplep.isoEcal = mu->IsoR03EmEt();
137			tmplep.isoHcal = mu->IsoR03HadEt();
138			tmplep.isoPF04 = musel.isoPF04;
139			tmplep.chisoPF04 = musel.chisoPF04;
140			tmplep.gaisoPF04 = musel.gaisoPF04;
141			tmplep.neisoPF04 = musel.neisoPF04;
142			// tmplep.isoPF03 = computePFMuonIso(mu,vtx,pfCandidates,0.3);
143			// tmplep.isoPF04 = computePFMuonIso(mu,vtx,pfCandidates,0.4);
144			tmplep.ip3dSig = mu->Ip3dPVSignificance();
145			tmplep.is4l = false;
146			tmplep.isEB = (fabs(mu->Eta()) < 1.479 ? 1 : 0 );
147			tmplep.isoMVA = musel.isoMVA;
148			tmplep.isLoose = musel.loose();
149	dkralph	1.9
150			bitset<TRIGGER_BIG_NUMBER> hltMatchBits = fillHLTMatchBits( mu->Eta(), mu->Phi(), hltTable, hltObjArr, fTrigObjs);
151			tmplep.isTight = testBits(ctrl,triggerBits,muTriggers,hltMatchBits,muTrigObjs);
152
153			tmplep.bdtfail = 0;
154			if(triggerBits.test(kHLT_IsoMu24_eta2p1)) tmplep.bdtfail \|= 1;
155			if(hltMatchBits.test(kHLT_IsoMu24_eta2p1_MuObj)) tmplep.bdtfail \|= 2;
156			if(triggerBits.test(kHLT_IsoMu24)) tmplep.bdtfail \|= 4;
157			if(hltMatchBits.test(kHLT_IsoMu24_MuObj)) tmplep.bdtfail \|= 8;
158
159	dkralph	1.4	tmplep.status = musel;
160			tmplep.fsrRecoveryAttempted = false;
161	dkralph	1.11	tmplep.tightCutsApplied = muon2012CutBasedIDTightVersionWithOldIsoThatWorksOn2011(ctrl,mu,vtx,pfCandidates,puEnergyDensity,eraMu);
162	dkralph	1.4	lepvec.push_back(tmplep);
163			if( ctrl.debug ) cout << endl;
164			}
165
166			if( ctrl.debug ) { cout << "\tnElectron: " << electronArr->GetEntries() << endl; }
167			// --------------------------------------------------------------------------------
168			for(int i=0; i<electronArr->GetEntries(); i++)
169			{
170			const mithep::Electron ele = (mithep::Electron)((*electronArr)[i]);
171	khahn	1.1
172	dkralph	1.8	SelectionStatus denomSel;
173	dkralph	1.13	denomSel \|= electronPreSelectionNoD0IP(ctrl,ele,vtx);
174	dkralph	1.10	if( !denomSel.passPre() ) continue;
175	dkralph	1.8
176	dkralph	1.4	SelectionStatus elesel;
177			elesel \|= (*ElectronPreSelector)(ctrl,ele,vtx);
178			elesel \|= (*ElectronIDSelector)(ctrl,ele,vtx);
179	dkralph	1.8	elesel \|= (*ElectronIsoSelector)(ctrl,ele,vtx,pfCandidates,puEnergyDensity,eraEle,photonsToVeto);
180	khahn	1.1
181	dkralph	1.4	SimpleLepton tmplep;
182			float pt = ele->Pt();
183			tmplep.vec.SetPtEtaPhiM( pt,
184			ele->Eta(),
185			ele->Phi(),
186			ELECTRON_MASS );
187	khahn	1.1
188	dkralph	1.4	tmplep.type = 11;
189	khahn	1.1	tmplep.index = i;
190	dkralph	1.4	tmplep.charge = ele->Charge();
191			tmplep.isoTrk = ele->TrackIsolationDr03();
192			tmplep.isoEcal = ele->EcalRecHitIsoDr03();
193			tmplep.isoHcal = ele->HcalTowerSumEtDr03();
194			tmplep.isoPF04 = elesel.isoPF04;
195			tmplep.chisoPF04 = elesel.chisoPF04;
196			tmplep.gaisoPF04 = elesel.gaisoPF04;
197			tmplep.neisoPF04 = elesel.neisoPF04;
198			// tmplep.isoPF03 = computePFEleIso(ele,vtx,pfCandidates,0.3);
199			// tmplep.isoPF04 = computePFEleIso(ele,vtx,pfCandidates,0.4);
200			tmplep.ip3dSig = ele->Ip3dPVSignificance();
201	khahn	1.1	tmplep.is4l = false;
202	dkralph	1.4	tmplep.isEB = ele->IsEB();
203			tmplep.scID = ele->SCluster()->GetUniqueID();
204	dkralph	1.9
205			bitset<TRIGGER_BIG_NUMBER> hltMatchBits = fillHLTMatchBits( ele->Eta(), ele->Phi(), hltTable, hltObjArr, fTrigObjs);
206			tmplep.isTight = testBits(ctrl,triggerBits,eleTriggers,hltMatchBits,eleTrigObjs);
207
208	dkralph	1.4	tmplep.isTight = elesel.tight();
209			tmplep.isLoose = elesel.loose();
210			tmplep.status = elesel;
211			tmplep.idMVA = elesel.idMVA;
212			tmplep.isoMVA = elesel.isoMVA;
213			tmplep.fsrRecoveryAttempted = false;
214	dkralph	1.11	tmplep.tightCutsApplied = electron2012CutBasedIDMediumVersionThatWorksOn2011(ctrl,ele,vtx,pfCandidates,fConversions,puEnergyDensity,eraEle);
215	khahn	1.1	lepvec.push_back(tmplep);
216	dkralph	1.4	if( ctrl.debug ) cout << endl;
217	khahn	1.1	}
218	khahn	1.3
219	dkralph	1.4	sort( lepvec.begin(), lepvec.end(), SimpleLepton::lep_pt_sort );
220
221			//********************************************************
222			// Step 2: Lepton Cleaning
223			//********************************************************
224			vector<vector<SimpleLepton>::iterator> electrons_to_erase;
225			for (vector<SimpleLepton>::iterator it1=lepvec.begin(); it1 != lepvec.end(); it1++ ) {
226			if ( abs(it1->type) != 11 ) continue;
227			TVector3 evec = it1->vec.Vect();
228
229			bool erase_this_electron=false;
230			for (vector<SimpleLepton>::iterator it2=lepvec.begin(); it2 != lepvec.end(); it2++ ) {
231			if ( it2 == it1 ) continue;
232			if ( abs(it2->type) != 13 ) continue;
233	dkralph	1.7	// if( !(it2->status.looseIDAndPre()) ) continue;
234	dkralph	1.4	TVector3 mvec = it2->vec.Vect();
235	khahn	1.1
236	dkralph	1.4	if ( evec.DrEtaPhi(mvec) < 0.05 ) {
237			erase_this_electron=true;
238			break;
239	khahn	1.1	}
240	dkralph	1.4	}
241			if( erase_this_electron )
242			electrons_to_erase.push_back(it1);
243			}
244			for( int i=0; i<electrons_to_erase.size(); i++ ) {
245			lepvec.erase(electrons_to_erase[i]);
246			}
247	khahn	1.1
248			//********************************************************
249	dkralph	1.4	// Step 3: Good Leptons
250	khahn	1.1	//********************************************************
251	dkralph	1.4	for (int i=0; i<lepvec.size(); i++ ) {
252			if( !(lepvec[i].status.loose()) ) {
253	dkralph	1.10	failingLeptons.push_back(lepvec[i]);
254	dkralph	1.4	} else {
255			passingLeptons.push_back(lepvec[i]);
256			}
257	khahn	1.1	}
258	dkralph	1.4
259	khahn	1.1	//******************************************************************************
260	dkralph	1.4	// W + (OF SS lepton) Selection
261	khahn	1.1	//******************************************************************************
262	dkralph	1.7	if(has_ssof_lepton(ctrl)) {
263			ret.status.setStatus(SelectionStatus::EVTPASS);
264			ret.Z1leptons.push_back(passingLeptons[0]);
265			ret.Z1leptons.push_back(passingLeptons[0]);
266			ret.Z2leptons.push_back(passingLeptons[0]);
267			ret.Z2leptons.push_back(passingLeptons[0]);
268			} else {
269			ret.status.setStatus(SelectionStatus::FAIL);
270	khahn	1.1	}
271	dkralph	1.7	return ret;
272	dkralph	1.4	}
273			//----------------------------------------------------------------------------------------
274			bool has_ssof_lepton(ControlFlags &ctrl)
275			{
276			bool has_ssof=false;
277			for(unsigned iw=0; iw<passingLeptons.size(); iw++) {
278			SimpleLepton w_lep = passingLeptons[iw];
279			//????????????????????????????????????????????????????????????????????????????????????????
280			// this is applied in skim (skim also applies ww muon id)
281			// if(abs(w_lep.type) == 11) {
282			// if( !(w_lep.tightCutsApplied) )
283			// continue;
284			// }
285			//????????????????????????????????????????????????????????????????????????????????????????
286			for(unsigned ifake=0; ifake<failingLeptons.size(); ifake++) {
287			SimpleLepton fake_lep = failingLeptons[ifake];
288			if(abs(fake_lep.type) == abs(w_lep.type)) continue;
289			if(fake_lep.charge != w_lep.charge) continue;
290			has_ssof = true;
291			}
292			for(unsigned ipass=0; ipass<passingLeptons.size(); ipass++) {
293			if(ipass == iw) continue;
294			SimpleLepton pass_lep = passingLeptons[ipass];
295			if(abs(pass_lep.type) == abs(w_lep.type)) continue;
296			if(pass_lep.charge != w_lep.charge) continue;
297			has_ssof = true;
298	khahn	1.1	}
299	dkralph	1.4	}
300	khahn	1.1
301	dkralph	1.4	return has_ssof;
302	khahn	1.1	}