Mods/src/ElectronIDMod.cc

// $Id: ElectronIDMod.cc,v 1.55 2010/04/10 16:29:52 sixie Exp $

#include "MitPhysics/Mods/interface/ElectronIDMod.h"
#include "MitAna/DataTree/interface/StableData.h"
#include "MitAna/DataTree/interface/ElectronCol.h"
#include "MitAna/DataTree/interface/VertexCol.h"
#include "MitAna/DataTree/interface/DecayParticleCol.h"
#include "MitPhysics/Init/interface/ModNames.h"

using namespace mithep;

ClassImp(mithep::ElectronIDMod)

//--------------------------------------------------------------------------------------------------
ElectronIDMod::ElectronIDMod(const char *name, const char *title) : 
  BaseMod(name,title),
  fElectronBranchName(Names::gkElectronBrn),
  fConversionBranchName(Names::gkMvfConversionBrn),
  fGoodElectronsName(ModNames::gkGoodElectronsName),  
  fVertexName(string("PrimaryVertexes").c_str()),
  fElectronIDType("CustomTight"),
  fElectronIsoType("TrackJuraSliding"),
  fElectronPtMin(10),
  fIDLikelihoodCut(0.9),
  fTrackIsolationCut(5.0),
  fCaloIsolationCut(5.0),
  fEcalJuraIsoCut(5.0),
  fHcalIsolationCut(5.0),
  fCombIsolationCut(5.0),
  fApplyConvFilter(kTRUE),
  fWrongHitsRequirement(kTRUE),
  fApplyD0Cut(kTRUE),
  fChargeFilter(kTRUE),
  fD0Cut(0.25),
  fReverseIsoCut(kFALSE),
  fReverseD0Cut(kFALSE),
  fElIdType(ElectronTools::kIdUndef),
  fElIsoType(ElectronTools::kIsoUndef),
  fElectrons(0),
  fConversions(0),
  fVertices(0)
{
  // Constructor.
}

//--------------------------------------------------------------------------------------------------
Bool_t ElectronIDMod::PassIDCut(const Electron *ele, ElectronTools::EElIdType idType) const
{

  Bool_t idcut = kFALSE;
  switch (idType) {
    case ElectronTools::kTight:
      idcut = ele->PassTightID();
      break;
    case ElectronTools::kLoose:
      idcut = ele->PassLooseID();
      break;
    case ElectronTools::kLikelihood:
      idcut = (ele->IDLikelihood() > fIDLikelihoodCut);
      break;
    case ElectronTools::kNoId:
      idcut = kTRUE;
      break;
    case ElectronTools::kCustomIdLoose:
      idcut = ElectronTools::PassCustomID(ele, ElectronTools::kCustomIdLoose);
      break;
    case ElectronTools::kCustomIdTight:
      idcut = ElectronTools::PassCustomID(ele, ElectronTools::kCustomIdTight);
      break;
    case ElectronTools::kVBTFWorkingPoint95Id:
      idcut = ElectronTools::PassCustomID(ele, ElectronTools::kVBTFWorkingPoint95Id);
      break;
    case ElectronTools::kVBTFWorkingPoint90Id:
      idcut = ElectronTools::PassCustomID(ele, ElectronTools::kVBTFWorkingPoint90Id);
      break;
    case ElectronTools::kVBTFWorkingPoint80Id:
      idcut = ElectronTools::PassCustomID(ele, ElectronTools::kVBTFWorkingPoint80Id);
      break;
    case ElectronTools::kVBTFWorkingPoint70Id:
      idcut = ElectronTools::PassCustomID(ele, ElectronTools::kVBTFWorkingPoint70Id);
      break;
    default:
      break;
  }
  
  return idcut;
}


//--------------------------------------------------------------------------------------------------
Bool_t ElectronIDMod::PassIsolationCut(const Electron *ele, ElectronTools::EElIsoType isoType) const
{

  Bool_t isocut = kFALSE;
  switch (isoType) {
    case ElectronTools::kTrackCalo:
      isocut = (ele->TrackIsolationDr03() < fTrackIsolationCut) &&
        (ele->CaloIsolation() < fCaloIsolationCut);
      break;
    case ElectronTools::kTrackJura:
      isocut = (ele->TrackIsolationDr03() < fTrackIsolationCut) &&
        (ele->EcalRecHitIsoDr04() < fEcalJuraIsoCut) &&
        (ele->HcalIsolation() < fHcalIsolationCut);
      break;
    case ElectronTools::kTrackJuraCombined:
      isocut = (ele->TrackIsolationDr03() + ele->EcalRecHitIsoDr04() 
                - 1.5 < fCombIsolationCut);
      break;
    case ElectronTools::kTrackJuraSliding:
    {
      Double_t totalIso = ele->TrackIsolationDr03() + ele->EcalRecHitIsoDr04() - 1.5;
      if (totalIso < (ele->Pt()-10.0)*4.5/20.0 ||
          totalIso <= 0)
        isocut = kTRUE;
      
      if     (fReverseIsoCut == kTRUE &&
              isocut == kFALSE && totalIso < 10)
        isocut = kTRUE;
      else if(fReverseIsoCut == kTRUE)
        isocut = kFALSE;
    }
    break;
    case ElectronTools::kVBTFWorkingPoint95Iso:
      isocut = ElectronTools::PassCustomIso(ele, ElectronTools::kVBTFWorkingPoint95Iso);
      break;
    case ElectronTools::kVBTFWorkingPoint90Iso:
      isocut = ElectronTools::PassCustomIso(ele, ElectronTools::kVBTFWorkingPoint90Iso);
      break;
    case ElectronTools::kVBTFWorkingPoint80Iso:
      isocut = ElectronTools::PassCustomIso(ele, ElectronTools::kVBTFWorkingPoint80Iso);
      break;
    case ElectronTools::kVBTFWorkingPoint70Iso:
      isocut = ElectronTools::PassCustomIso(ele, ElectronTools::kVBTFWorkingPoint70Iso);
      break;
    case ElectronTools::kNoIso:
      isocut = kTRUE;
      break;
    case ElectronTools::kCustomIso:
    default:
      break;
  }

  return isocut;
}


//--------------------------------------------------------------------------------------------------
void ElectronIDMod::Process()
{
  // Process entries of the tree. 

  LoadEventObject(fElectronBranchName, fElectrons);

  ElectronOArr *GoodElectrons = new ElectronOArr;
  GoodElectrons->SetName(fGoodElectronsName);

  for (UInt_t i=0; i<fElectrons->GetEntries(); ++i) {
    const Electron *e = fElectrons->At(i);        

    if (e->Pt() <= fElectronPtMin) 
      continue;
    
    //apply ECAL spike removal    
    Bool_t spikecut = ElectronTools::PassSpikeRemovalFilter(e);
    if (!spikecut)
      continue;

    //apply id cut
    Bool_t idcut = PassIDCut(e, fElIdType);
    if (!idcut) 
      continue;

    //apply Isolation Cut
    Bool_t isocut = PassIsolationCut(e, fElIsoType);
    if (!isocut)
      continue;

    // apply conversion filter
    Bool_t passConvVeto = kFALSE;
    if (fApplyConvFilter) {
      LoadEventObject(fConversionBranchName, fConversions);
      passConvVeto = ElectronTools::PassConversionFilter(e, fConversions, 
                                                         fWrongHitsRequirement);      
    } else {
      passConvVeto = kTRUE;
    }
    if (passConvVeto == kFALSE) continue;
    
    // apply d0 cut
    if (fApplyD0Cut) {
      LoadEventObject(fVertexName, fVertices);
      Bool_t passD0cut = ElectronTools::PassD0Cut(e, fVertices, fD0Cut, fReverseD0Cut);
      if (!passD0cut)
        continue;
    }

    //apply charge filter
    if(fChargeFilter == kTRUE) {
      Bool_t passChargeFilter = ElectronTools::PassChargeFilter(e);
      if (!passChargeFilter) continue;
    }

    // add good electron
    GoodElectrons->Add(e);
  }

  // sort according to pt
  GoodElectrons->Sort();

  // add to event for other modules to use
  AddObjThisEvt(GoodElectrons);  
}

//--------------------------------------------------------------------------------------------------
void ElectronIDMod::SlaveBegin()
{
  // Run startup code on the computer (slave) doing the actual analysis. Here,
  // we just request the electron collection branch.

  ReqEventObject(fElectronBranchName, fElectrons, kTRUE);

  if (fApplyConvFilter)
    ReqEventObject(fConversionBranchName, fConversions, kTRUE);

  if (fApplyD0Cut)
    ReqEventObject(fVertexName, fVertices, kTRUE);

  Setup();
}

//--------------------------------------------------------------------------------------------------
void ElectronIDMod::Setup()
{
  // Set all options properly before execution.

  if (fElectronIDType.CompareTo("Tight") == 0) 
    fElIdType = ElectronTools::kTight;
  else if (fElectronIDType.CompareTo("Loose") == 0) 
    fElIdType = ElectronTools::kLoose;
  else if (fElectronIDType.CompareTo("Likelihood") == 0) 
    fElIdType = ElectronTools::kLikelihood;
  else if (fElectronIDType.CompareTo("NoId") == 0) 
    fElIdType = ElectronTools::kNoId;
  else if (fElectronIDType.CompareTo("ZeeId") == 0) 
    fElIdType = ElectronTools::kZeeId;
  else if (fElectronIDType.CompareTo("CustomLoose") == 0) 
    fElIdType = ElectronTools::kCustomIdLoose;
  else if (fElectronIDType.CompareTo("CustomTight") == 0) 
    fElIdType = ElectronTools::kCustomIdTight;
  else if (fElectronIDType.CompareTo("VBTFWorkingPoint95Id") == 0) 
    fElIdType = ElectronTools::kVBTFWorkingPoint95Id;
  else if (fElectronIDType.CompareTo("VBTFWorkingPoint90Id") == 0) 
    fElIdType = ElectronTools::kVBTFWorkingPoint90Id;
  else if (fElectronIDType.CompareTo("VBTFWorkingPoint80Id") == 0) 
    fElIdType = ElectronTools::kVBTFWorkingPoint80Id;
  else if (fElectronIDType.CompareTo("VBTFWorkingPoint70Id") == 0) 
    fElIdType = ElectronTools::kVBTFWorkingPoint70Id;
  
   else {
    SendError(kAbortAnalysis, "SlaveBegin",
              "The specified electron identification %s is not defined.",
              fElectronIDType.Data());
    return;
  }

  if (fElectronIsoType.CompareTo("TrackCalo") == 0 )
    fElIsoType = ElectronTools::kTrackCalo;
  else if (fElectronIsoType.CompareTo("TrackJura") == 0) 
    fElIsoType = ElectronTools::kTrackJura;
  else if(fElectronIsoType.CompareTo("TrackJuraCombined") == 0)
    fElIsoType = ElectronTools::kTrackJuraCombined;
  else if(fElectronIsoType.CompareTo("TrackJuraSliding") == 0)
    fElIsoType = ElectronTools::kTrackJuraSliding;
  else if (fElectronIsoType.CompareTo("NoIso") == 0 )
    fElIsoType = ElectronTools::kNoIso;
  else if (fElectronIsoType.CompareTo("ZeeIso") == 0 )
    fElIsoType = ElectronTools::kZeeIso;
  else if (fElectronIsoType.CompareTo("VBTFWorkingPoint95Iso") == 0 )
    fElIsoType = ElectronTools::kVBTFWorkingPoint95Iso;
  else if (fElectronIsoType.CompareTo("VBTFWorkingPoint90Iso") == 0 )
    fElIsoType = ElectronTools::kVBTFWorkingPoint90Iso;
  else if (fElectronIsoType.CompareTo("VBTFWorkingPoint80Iso") == 0 )
    fElIsoType = ElectronTools::kVBTFWorkingPoint80Iso;
  else if (fElectronIsoType.CompareTo("VBTFWorkingPoint70Iso") == 0 )
    fElIsoType = ElectronTools::kVBTFWorkingPoint70Iso;
  else if (fElectronIsoType.CompareTo("Custom") == 0 ) {
    fElIsoType = ElectronTools::kCustomIso;
    SendError(kWarning, "SlaveBegin",
              "Custom electron isolation is not yet implemented.");
  } else {
    SendError(kAbortAnalysis, "SlaveBegin",
              "The specified electron isolation %s is not defined.",
              fElectronIsoType.Data());
    return;
  }


}


Revision:	1.56
Committed:	Sat Apr 10 18:07:53 2010 UTC (15 years ago) by sixie
Content type:	text/plain
Branch:	MAIN
Changes since 1.55:	+64 -373 lines
Log Message:	Move Custom ID and Iso Functions to a helper class.
#	User	Rev	Content
1	sixie	1.56	// $Id: ElectronIDMod.cc,v 1.55 2010/04/10 16:29:52 sixie Exp $
2	loizides	1.1
3			#include "MitPhysics/Mods/interface/ElectronIDMod.h"
4	loizides	1.26	#include "MitAna/DataTree/interface/StableData.h"
5			#include "MitAna/DataTree/interface/ElectronCol.h"
6			#include "MitAna/DataTree/interface/VertexCol.h"
7			#include "MitAna/DataTree/interface/DecayParticleCol.h"
8	loizides	1.5	#include "MitPhysics/Init/interface/ModNames.h"
9	loizides	1.1
10			using namespace mithep;
11
12			ClassImp(mithep::ElectronIDMod)
13
14			//--------------------------------------------------------------------------------------------------
15	loizides	1.5	ElectronIDMod::ElectronIDMod(const char name, const char title) :
16	loizides	1.1	BaseMod(name,title),
17	loizides	1.5	fElectronBranchName(Names::gkElectronBrn),
18	ceballos	1.12	fConversionBranchName(Names::gkMvfConversionBrn),
19	loizides	1.5	fGoodElectronsName(ModNames::gkGoodElectronsName),
20	ceballos	1.54	fVertexName(string("PrimaryVertexes").c_str()),
21	ceballos	1.31	fElectronIDType("CustomTight"),
22	ceballos	1.8	fElectronIsoType("TrackJuraSliding"),
23	loizides	1.1	fElectronPtMin(10),
24			fIDLikelihoodCut(0.9),
25			fTrackIsolationCut(5.0),
26			fCaloIsolationCut(5.0),
27	loizides	1.5	fEcalJuraIsoCut(5.0),
28			fHcalIsolationCut(5.0),
29	ceballos	1.49	fCombIsolationCut(5.0),
30	loizides	1.14	fApplyConvFilter(kTRUE),
31	bendavid	1.38	fWrongHitsRequirement(kTRUE),
32	ceballos	1.18	fApplyD0Cut(kTRUE),
33	ceballos	1.45	fChargeFilter(kTRUE),
34	ceballos	1.54	fD0Cut(0.25),
35	loizides	1.25	fReverseIsoCut(kFALSE),
36			fReverseD0Cut(kFALSE),
37	sixie	1.56	fElIdType(ElectronTools::kIdUndef),
38			fElIsoType(ElectronTools::kIsoUndef),
39	loizides	1.14	fElectrons(0),
40			fConversions(0),
41	loizides	1.25	fVertices(0)
42	loizides	1.1	{
43			// Constructor.
44			}
45
46			//--------------------------------------------------------------------------------------------------
47	sixie	1.56	Bool_t ElectronIDMod::PassIDCut(const Electron *ele, ElectronTools::EElIdType idType) const
48	sixie	1.42	{
49
50			Bool_t idcut = kFALSE;
51			switch (idType) {
52	sixie	1.56	case ElectronTools::kTight:
53	sixie	1.42	idcut = ele->PassTightID();
54			break;
55	sixie	1.56	case ElectronTools::kLoose:
56	sixie	1.42	idcut = ele->PassLooseID();
57			break;
58	sixie	1.56	case ElectronTools::kLikelihood:
59	sixie	1.42	idcut = (ele->IDLikelihood() > fIDLikelihoodCut);
60			break;
61	sixie	1.56	case ElectronTools::kNoId:
62	sixie	1.42	idcut = kTRUE;
63			break;
64	sixie	1.56	case ElectronTools::kCustomIdLoose:
65			idcut = ElectronTools::PassCustomID(ele, ElectronTools::kCustomIdLoose);
66	sixie	1.42	break;
67	sixie	1.56	case ElectronTools::kCustomIdTight:
68			idcut = ElectronTools::PassCustomID(ele, ElectronTools::kCustomIdTight);
69	sixie	1.42	break;
70	sixie	1.56	case ElectronTools::kVBTFWorkingPoint95Id:
71			idcut = ElectronTools::PassCustomID(ele, ElectronTools::kVBTFWorkingPoint95Id);
72	ceballos	1.54	break;
73	sixie	1.56	case ElectronTools::kVBTFWorkingPoint90Id:
74			idcut = ElectronTools::PassCustomID(ele, ElectronTools::kVBTFWorkingPoint90Id);
75	ceballos	1.54	break;
76	sixie	1.56	case ElectronTools::kVBTFWorkingPoint80Id:
77			idcut = ElectronTools::PassCustomID(ele, ElectronTools::kVBTFWorkingPoint80Id);
78			break;
79			case ElectronTools::kVBTFWorkingPoint70Id:
80			idcut = ElectronTools::PassCustomID(ele, ElectronTools::kVBTFWorkingPoint70Id);
81	ceballos	1.54	break;
82	sixie	1.42	default:
83			break;
84			}
85
86			return idcut;
87			}
88
89
90			//--------------------------------------------------------------------------------------------------
91	sixie	1.56	Bool_t ElectronIDMod::PassIsolationCut(const Electron *ele, ElectronTools::EElIsoType isoType) const
92	sixie	1.42	{
93
94			Bool_t isocut = kFALSE;
95			switch (isoType) {
96	sixie	1.56	case ElectronTools::kTrackCalo:
97	sixie	1.42	isocut = (ele->TrackIsolationDr03() < fTrackIsolationCut) &&
98			(ele->CaloIsolation() < fCaloIsolationCut);
99			break;
100	sixie	1.56	case ElectronTools::kTrackJura:
101	sixie	1.42	isocut = (ele->TrackIsolationDr03() < fTrackIsolationCut) &&
102			(ele->EcalRecHitIsoDr04() < fEcalJuraIsoCut) &&
103			(ele->HcalIsolation() < fHcalIsolationCut);
104			break;
105	sixie	1.56	case ElectronTools::kTrackJuraCombined:
106	ceballos	1.49	isocut = (ele->TrackIsolationDr03() + ele->EcalRecHitIsoDr04()
107			- 1.5 < fCombIsolationCut);
108			break;
109	sixie	1.56	case ElectronTools::kTrackJuraSliding:
110	sixie	1.42	{
111			Double_t totalIso = ele->TrackIsolationDr03() + ele->EcalRecHitIsoDr04() - 1.5;
112			if (totalIso < (ele->Pt()-10.0)*4.5/20.0 \|\|
113			totalIso <= 0)
114			isocut = kTRUE;
115
116			if (fReverseIsoCut == kTRUE &&
117			isocut == kFALSE && totalIso < 10)
118			isocut = kTRUE;
119			else if(fReverseIsoCut == kTRUE)
120			isocut = kFALSE;
121			}
122			break;
123	sixie	1.56	case ElectronTools::kVBTFWorkingPoint95Iso:
124			isocut = ElectronTools::PassCustomIso(ele, ElectronTools::kVBTFWorkingPoint95Iso);
125			break;
126			case ElectronTools::kVBTFWorkingPoint90Iso:
127			isocut = ElectronTools::PassCustomIso(ele, ElectronTools::kVBTFWorkingPoint90Iso);
128	sixie	1.51	break;
129	sixie	1.56	case ElectronTools::kVBTFWorkingPoint80Iso:
130			isocut = ElectronTools::PassCustomIso(ele, ElectronTools::kVBTFWorkingPoint80Iso);
131	sixie	1.51	break;
132	sixie	1.56	case ElectronTools::kVBTFWorkingPoint70Iso:
133			isocut = ElectronTools::PassCustomIso(ele, ElectronTools::kVBTFWorkingPoint70Iso);
134	sixie	1.51	break;
135	sixie	1.56	case ElectronTools::kNoIso:
136	sixie	1.42	isocut = kTRUE;
137			break;
138	sixie	1.56	case ElectronTools::kCustomIso:
139	sixie	1.42	default:
140			break;
141			}
142
143			return isocut;
144			}
145
146
147			//--------------------------------------------------------------------------------------------------
148	loizides	1.1	void ElectronIDMod::Process()
149			{
150			// Process entries of the tree.
151
152	loizides	1.23	LoadEventObject(fElectronBranchName, fElectrons);
153	loizides	1.1
154	loizides	1.6	ElectronOArr *GoodElectrons = new ElectronOArr;
155			GoodElectrons->SetName(fGoodElectronsName);
156	loizides	1.1
157	ceballos	1.18	for (UInt_t i=0; i<fElectrons->GetEntries(); ++i) {
158	loizides	1.5	const Electron *e = fElectrons->At(i);
159	loizides	1.1
160	loizides	1.5	if (e->Pt() <= fElectronPtMin)
161			continue;
162	loizides	1.1
163	sixie	1.55	//apply ECAL spike removal
164	sixie	1.56	Bool_t spikecut = ElectronTools::PassSpikeRemovalFilter(e);
165	sixie	1.55	if (!spikecut)
166			continue;
167
168	sixie	1.42	//apply id cut
169			Bool_t idcut = PassIDCut(e, fElIdType);
170	loizides	1.5	if (!idcut)
171			continue;
172
173	sixie	1.42	//apply Isolation Cut
174			Bool_t isocut = PassIsolationCut(e, fElIsoType);
175			if (!isocut)
176	loizides	1.5	continue;
177
178	loizides	1.14	// apply conversion filter
179	ceballos	1.47	Bool_t passConvVeto = kFALSE;
180	loizides	1.14	if (fApplyConvFilter) {
181	sixie	1.42	LoadEventObject(fConversionBranchName, fConversions);
182	sixie	1.56	passConvVeto = ElectronTools::PassConversionFilter(e, fConversions,
183			fWrongHitsRequirement);
184	sixie	1.48	} else {
185			passConvVeto = kTRUE;
186	ceballos	1.12	}
187	ceballos	1.47	if (passConvVeto == kFALSE) continue;
188	sixie	1.42
189			// apply d0 cut
190	ceballos	1.15	if (fApplyD0Cut) {
191	sixie	1.42	LoadEventObject(fVertexName, fVertices);
192	sixie	1.56	Bool_t passD0cut = ElectronTools::PassD0Cut(e, fVertices, fD0Cut, fReverseD0Cut);
193	sixie	1.42	if (!passD0cut)
194	ceballos	1.24	continue;
195	ceballos	1.12	}
196
197	sixie	1.42	//apply charge filter
198			if(fChargeFilter == kTRUE) {
199	sixie	1.56	Bool_t passChargeFilter = ElectronTools::PassChargeFilter(e);
200	sixie	1.42	if (!passChargeFilter) continue;
201	ceballos	1.45	}
202
203	loizides	1.5	// add good electron
204	ceballos	1.12	GoodElectrons->Add(e);
205	loizides	1.5	}
206	loizides	1.1
207	loizides	1.9	// sort according to pt
208			GoodElectrons->Sort();
209
210	loizides	1.5	// add to event for other modules to use
211	loizides	1.6	AddObjThisEvt(GoodElectrons);
212	loizides	1.1	}
213
214			//--------------------------------------------------------------------------------------------------
215			void ElectronIDMod::SlaveBegin()
216			{
217			// Run startup code on the computer (slave) doing the actual analysis. Here,
218	loizides	1.5	// we just request the electron collection branch.
219	loizides	1.1
220	loizides	1.23	ReqEventObject(fElectronBranchName, fElectrons, kTRUE);
221	loizides	1.17
222	ceballos	1.16	if (fApplyConvFilter)
223	loizides	1.23	ReqEventObject(fConversionBranchName, fConversions, kTRUE);
224	loizides	1.17
225	ceballos	1.15	if (fApplyD0Cut)
226	loizides	1.23	ReqEventObject(fVertexName, fVertices, kTRUE);
227	loizides	1.1
228	sixie	1.42	Setup();
229			}
230
231			//--------------------------------------------------------------------------------------------------
232			void ElectronIDMod::Setup()
233			{
234			// Set all options properly before execution.
235
236	loizides	1.5	if (fElectronIDType.CompareTo("Tight") == 0)
237	sixie	1.56	fElIdType = ElectronTools::kTight;
238	loizides	1.5	else if (fElectronIDType.CompareTo("Loose") == 0)
239	sixie	1.56	fElIdType = ElectronTools::kLoose;
240	loizides	1.5	else if (fElectronIDType.CompareTo("Likelihood") == 0)
241	sixie	1.56	fElIdType = ElectronTools::kLikelihood;
242	loizides	1.10	else if (fElectronIDType.CompareTo("NoId") == 0)
243	sixie	1.56	fElIdType = ElectronTools::kNoId;
244	sixie	1.42	else if (fElectronIDType.CompareTo("ZeeId") == 0)
245	sixie	1.56	fElIdType = ElectronTools::kZeeId;
246	sixie	1.51	else if (fElectronIDType.CompareTo("CustomLoose") == 0)
247	sixie	1.56	fElIdType = ElectronTools::kCustomIdLoose;
248	sixie	1.51	else if (fElectronIDType.CompareTo("CustomTight") == 0)
249	sixie	1.56	fElIdType = ElectronTools::kCustomIdTight;
250	sixie	1.55	else if (fElectronIDType.CompareTo("VBTFWorkingPoint95Id") == 0)
251	sixie	1.56	fElIdType = ElectronTools::kVBTFWorkingPoint95Id;
252	sixie	1.51	else if (fElectronIDType.CompareTo("VBTFWorkingPoint90Id") == 0)
253	sixie	1.56	fElIdType = ElectronTools::kVBTFWorkingPoint90Id;
254	sixie	1.51	else if (fElectronIDType.CompareTo("VBTFWorkingPoint80Id") == 0)
255	sixie	1.56	fElIdType = ElectronTools::kVBTFWorkingPoint80Id;
256	sixie	1.51	else if (fElectronIDType.CompareTo("VBTFWorkingPoint70Id") == 0)
257	sixie	1.56	fElIdType = ElectronTools::kVBTFWorkingPoint70Id;
258	sixie	1.51
259	peveraer	1.29	else {
260	loizides	1.5	SendError(kAbortAnalysis, "SlaveBegin",
261			"The specified electron identification %s is not defined.",
262			fElectronIDType.Data());
263			return;
264			}
265	sixie	1.51
266	loizides	1.5	if (fElectronIsoType.CompareTo("TrackCalo") == 0 )
267	sixie	1.56	fElIsoType = ElectronTools::kTrackCalo;
268	loizides	1.5	else if (fElectronIsoType.CompareTo("TrackJura") == 0)
269	sixie	1.56	fElIsoType = ElectronTools::kTrackJura;
270	ceballos	1.49	else if(fElectronIsoType.CompareTo("TrackJuraCombined") == 0)
271	sixie	1.56	fElIsoType = ElectronTools::kTrackJuraCombined;
272	loizides	1.5	else if(fElectronIsoType.CompareTo("TrackJuraSliding") == 0)
273	sixie	1.56	fElIsoType = ElectronTools::kTrackJuraSliding;
274	loizides	1.5	else if (fElectronIsoType.CompareTo("NoIso") == 0 )
275	sixie	1.56	fElIsoType = ElectronTools::kNoIso;
276	sixie	1.42	else if (fElectronIsoType.CompareTo("ZeeIso") == 0 )
277	sixie	1.56	fElIsoType = ElectronTools::kZeeIso;
278	sixie	1.55	else if (fElectronIsoType.CompareTo("VBTFWorkingPoint95Iso") == 0 )
279	sixie	1.56	fElIsoType = ElectronTools::kVBTFWorkingPoint95Iso;
280	sixie	1.51	else if (fElectronIsoType.CompareTo("VBTFWorkingPoint90Iso") == 0 )
281	sixie	1.56	fElIsoType = ElectronTools::kVBTFWorkingPoint90Iso;
282	sixie	1.51	else if (fElectronIsoType.CompareTo("VBTFWorkingPoint80Iso") == 0 )
283	sixie	1.56	fElIsoType = ElectronTools::kVBTFWorkingPoint80Iso;
284	sixie	1.51	else if (fElectronIsoType.CompareTo("VBTFWorkingPoint70Iso") == 0 )
285	sixie	1.56	fElIsoType = ElectronTools::kVBTFWorkingPoint70Iso;
286	loizides	1.5	else if (fElectronIsoType.CompareTo("Custom") == 0 ) {
287	sixie	1.56	fElIsoType = ElectronTools::kCustomIso;
288	loizides	1.5	SendError(kWarning, "SlaveBegin",
289			"Custom electron isolation is not yet implemented.");
290			} else {
291			SendError(kAbortAnalysis, "SlaveBegin",
292			"The specified electron isolation %s is not defined.",
293			fElectronIsoType.Data());
294			return;
295			}
296	sixie	1.42
297	loizides	1.30
298			}
299	sixie	1.51
300