Mods/src/ElectronIDMod.cc

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