Mods/src/ElectronIDMod.cc

// $Id: ElectronIDMod.cc,v 1.62 2010/05/29 11:56:17 bendavid 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/TriggerObjectCol.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"),
  fTrigObjectsName("HLTModTrigObjs"),
  fElectronPtMin(10),
  fIDLikelihoodCut(0.9),
  fTrackIsolationCut(5.0),
  fCaloIsolationCut(5.0),
  fEcalJuraIsoCut(5.0),
  fHcalIsolationCut(5.0),
  fCombIsolationCut(5.0),
  fApplyConvFilterType1(kTRUE),
  fApplyConvFilterType2(kFALSE),
  fWrongHitsRequirement(kTRUE),
  fNExpectedHitsInnerCut(999),
  fCombinedIdCut(kFALSE),
  fApplySpikeRemoval(kTRUE),
  fApplyD0Cut(kTRUE),
  fChargeFilter(kTRUE),
  fD0Cut(0.020),
  fReverseIsoCut(kFALSE),
  fReverseD0Cut(kFALSE),
  fApplyTriggerMatching(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::kVBTFWorkingPoint85Id:
      idcut = ElectronTools::PassCustomID(ele, ElectronTools::kVBTFWorkingPoint85Id);
      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->EcalRecHitIsoDr03() < fEcalJuraIsoCut) &&
        (ele->HcalTowerSumEtDr03() < fHcalIsolationCut);
      break;
    case ElectronTools::kTrackJuraCombined:
      isocut = (ele->TrackIsolationDr03() + ele->EcalRecHitIsoDr03() 
                - 1.5 < fCombIsolationCut);
      break;
    case ElectronTools::kTrackJuraSliding:
    {
      Double_t totalIso = ele->TrackIsolationDr03() + 
                          TMath::Max(ele->EcalRecHitIsoDr03() - 1.0, 0.0)  +
                          ele->HcalTowerSumEtDr03();
      if (totalIso < (ele->Pt()*0.10) )
        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::kVBTFWorkingPoint85Iso:
      isocut = ElectronTools::PassCustomIso(ele, ElectronTools::kVBTFWorkingPoint85Iso);
      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);

  //get trigger object collection if trigger matching is enabled
  const TriggerObjectCol *trigObjs = 0;
  if (fApplyTriggerMatching) {
    trigObjs = GetHLTObjects(fTrigObjectsName);
  }
  
  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 trigger matching
    Bool_t matchTrigger = fApplyTriggerMatching && ElectronTools::PassTriggerMatching(e,trigObjs);
    if (fApplyTriggerMatching && !matchTrigger)
      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 filters
    Bool_t passConvVetoType1 = kFALSE;
    if (fApplyConvFilterType1) {
      LoadEventObject(fConversionBranchName, fConversions);
      passConvVetoType1 = ElectronTools::PassConversionFilter(e, fConversions, 
                                                         fWrongHitsRequirement);      
    }
    else {
      passConvVetoType1 = kTRUE;
    }

    if (passConvVetoType1 == kFALSE) continue;

    Bool_t passConvVetoType2 = kFALSE;
    if (fApplyConvFilterType2) {
      passConvVetoType2 = TMath::Abs(e->ConvPartnerDCotTheta()) >= 0.02 || 
                          TMath::Abs(e->ConvPartnerDist())      >= 0.02;
    }
    else {
      passConvVetoType2 = kTRUE;
    }
    
    if (passConvVetoType2 == kFALSE) continue;
    
    // apply NExpectedHitsInner Cut
    if(fNExpectedHitsInnerCut < 999 && 
       e->BestTrk()->NExpectedHitsInner() > fNExpectedHitsInnerCut) 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;
    }

    // apply full combined id, using Tight cuts
    if(fCombinedIdCut == kTRUE) {
      LoadEventObject(fVertexName, fVertices);
      LoadEventObject(fConversionBranchName, fConversions);
      Int_t result = ElectronTools::PassTightId(e, *&fVertices, fConversions, 2);
      if(result != 15) 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(fCombinedIdCut == kTRUE) {
    fElectronIDType       = "NoId";
    fElectronIsoType      = "NoIso";
    fApplyConvFilterType1 = kFALSE;
    fApplyConvFilterType2 = kFALSE;
    fApplyD0Cut           = kFALSE;
  }

  if (fApplyConvFilterType1 || fCombinedIdCut == kTRUE)
    ReqEventObject(fConversionBranchName, fConversions, kTRUE);

  if (fApplyD0Cut || fCombinedIdCut == kTRUE)
    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("VBTFWorkingPoint85Id") == 0) 
    fElIdType = ElectronTools::kVBTFWorkingPoint85Id;
  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("VBTFWorkingPoint85Iso") == 0 )
    fElIsoType = ElectronTools::kVBTFWorkingPoint85Iso;
  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.63
Committed:	Sun May 30 17:58:47 2010 UTC (14 years, 11 months ago) by ceballos
Content type:	text/plain
Branch:	MAIN
CVS Tags:	Mit_014a
Changes since 1.62:	+3 -3 lines
Log Message:	change in electron id cuts
#	User	Rev	Content
1	ceballos	1.63	// $Id: ElectronIDMod.cc,v 1.62 2010/05/29 11:56:17 bendavid 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	bendavid	1.62	#include "MitAna/DataTree/interface/TriggerObjectCol.h"
8	loizides	1.26	#include "MitAna/DataTree/interface/DecayParticleCol.h"
9	loizides	1.5	#include "MitPhysics/Init/interface/ModNames.h"
10	loizides	1.1
11			using namespace mithep;
12
13			ClassImp(mithep::ElectronIDMod)
14
15			//--------------------------------------------------------------------------------------------------
16	loizides	1.5	ElectronIDMod::ElectronIDMod(const char name, const char title) :
17	loizides	1.1	BaseMod(name,title),
18	loizides	1.5	fElectronBranchName(Names::gkElectronBrn),
19	ceballos	1.12	fConversionBranchName(Names::gkMvfConversionBrn),
20	loizides	1.5	fGoodElectronsName(ModNames::gkGoodElectronsName),
21	ceballos	1.54	fVertexName(string("PrimaryVertexes").c_str()),
22	ceballos	1.31	fElectronIDType("CustomTight"),
23	ceballos	1.8	fElectronIsoType("TrackJuraSliding"),
24	bendavid	1.62	fTrigObjectsName("HLTModTrigObjs"),
25	loizides	1.1	fElectronPtMin(10),
26			fIDLikelihoodCut(0.9),
27			fTrackIsolationCut(5.0),
28			fCaloIsolationCut(5.0),
29	loizides	1.5	fEcalJuraIsoCut(5.0),
30			fHcalIsolationCut(5.0),
31	ceballos	1.49	fCombIsolationCut(5.0),
32	ceballos	1.60	fApplyConvFilterType1(kTRUE),
33			fApplyConvFilterType2(kFALSE),
34	bendavid	1.38	fWrongHitsRequirement(kTRUE),
35	ceballos	1.60	fNExpectedHitsInnerCut(999),
36	ceballos	1.59	fCombinedIdCut(kFALSE),
37	sixie	1.58	fApplySpikeRemoval(kTRUE),
38	ceballos	1.18	fApplyD0Cut(kTRUE),
39	ceballos	1.45	fChargeFilter(kTRUE),
40	ceballos	1.60	fD0Cut(0.020),
41	loizides	1.25	fReverseIsoCut(kFALSE),
42			fReverseD0Cut(kFALSE),
43	bendavid	1.62	fApplyTriggerMatching(kFALSE),
44	sixie	1.56	fElIdType(ElectronTools::kIdUndef),
45			fElIsoType(ElectronTools::kIsoUndef),
46	loizides	1.14	fElectrons(0),
47			fConversions(0),
48	loizides	1.25	fVertices(0)
49	loizides	1.1	{
50			// Constructor.
51			}
52
53			//--------------------------------------------------------------------------------------------------
54	sixie	1.56	Bool_t ElectronIDMod::PassIDCut(const Electron *ele, ElectronTools::EElIdType idType) const
55	sixie	1.42	{
56
57			Bool_t idcut = kFALSE;
58			switch (idType) {
59	sixie	1.56	case ElectronTools::kTight:
60	sixie	1.42	idcut = ele->PassTightID();
61			break;
62	sixie	1.56	case ElectronTools::kLoose:
63	sixie	1.42	idcut = ele->PassLooseID();
64			break;
65	sixie	1.56	case ElectronTools::kLikelihood:
66	sixie	1.42	idcut = (ele->IDLikelihood() > fIDLikelihoodCut);
67			break;
68	sixie	1.56	case ElectronTools::kNoId:
69	sixie	1.42	idcut = kTRUE;
70			break;
71	sixie	1.56	case ElectronTools::kCustomIdLoose:
72			idcut = ElectronTools::PassCustomID(ele, ElectronTools::kCustomIdLoose);
73	sixie	1.42	break;
74	sixie	1.56	case ElectronTools::kCustomIdTight:
75			idcut = ElectronTools::PassCustomID(ele, ElectronTools::kCustomIdTight);
76	sixie	1.42	break;
77	sixie	1.56	case ElectronTools::kVBTFWorkingPoint95Id:
78			idcut = ElectronTools::PassCustomID(ele, ElectronTools::kVBTFWorkingPoint95Id);
79	ceballos	1.54	break;
80	sixie	1.56	case ElectronTools::kVBTFWorkingPoint90Id:
81			idcut = ElectronTools::PassCustomID(ele, ElectronTools::kVBTFWorkingPoint90Id);
82	ceballos	1.54	break;
83	ceballos	1.60	case ElectronTools::kVBTFWorkingPoint85Id:
84			idcut = ElectronTools::PassCustomID(ele, ElectronTools::kVBTFWorkingPoint85Id);
85			break;
86	sixie	1.56	case ElectronTools::kVBTFWorkingPoint80Id:
87			idcut = ElectronTools::PassCustomID(ele, ElectronTools::kVBTFWorkingPoint80Id);
88			break;
89			case ElectronTools::kVBTFWorkingPoint70Id:
90			idcut = ElectronTools::PassCustomID(ele, ElectronTools::kVBTFWorkingPoint70Id);
91	ceballos	1.54	break;
92	sixie	1.42	default:
93			break;
94			}
95
96			return idcut;
97			}
98
99
100			//--------------------------------------------------------------------------------------------------
101	sixie	1.56	Bool_t ElectronIDMod::PassIsolationCut(const Electron *ele, ElectronTools::EElIsoType isoType) const
102	sixie	1.42	{
103
104			Bool_t isocut = kFALSE;
105			switch (isoType) {
106	sixie	1.56	case ElectronTools::kTrackCalo:
107	sixie	1.42	isocut = (ele->TrackIsolationDr03() < fTrackIsolationCut) &&
108			(ele->CaloIsolation() < fCaloIsolationCut);
109			break;
110	sixie	1.56	case ElectronTools::kTrackJura:
111	sixie	1.42	isocut = (ele->TrackIsolationDr03() < fTrackIsolationCut) &&
112	ceballos	1.60	(ele->EcalRecHitIsoDr03() < fEcalJuraIsoCut) &&
113			(ele->HcalTowerSumEtDr03() < fHcalIsolationCut);
114	sixie	1.42	break;
115	sixie	1.56	case ElectronTools::kTrackJuraCombined:
116	ceballos	1.60	isocut = (ele->TrackIsolationDr03() + ele->EcalRecHitIsoDr03()
117	ceballos	1.49	- 1.5 < fCombIsolationCut);
118			break;
119	sixie	1.56	case ElectronTools::kTrackJuraSliding:
120	sixie	1.42	{
121	ceballos	1.60	Double_t totalIso = ele->TrackIsolationDr03() +
122	ceballos	1.61	TMath::Max(ele->EcalRecHitIsoDr03() - 1.0, 0.0) +
123			ele->HcalTowerSumEtDr03();
124	ceballos	1.60	if (totalIso < (ele->Pt()*0.10) )
125	sixie	1.42	isocut = kTRUE;
126
127			if (fReverseIsoCut == kTRUE &&
128			isocut == kFALSE && totalIso < 10)
129			isocut = kTRUE;
130			else if(fReverseIsoCut == kTRUE)
131			isocut = kFALSE;
132			}
133			break;
134	sixie	1.56	case ElectronTools::kVBTFWorkingPoint95Iso:
135			isocut = ElectronTools::PassCustomIso(ele, ElectronTools::kVBTFWorkingPoint95Iso);
136			break;
137			case ElectronTools::kVBTFWorkingPoint90Iso:
138			isocut = ElectronTools::PassCustomIso(ele, ElectronTools::kVBTFWorkingPoint90Iso);
139	sixie	1.51	break;
140	ceballos	1.60	case ElectronTools::kVBTFWorkingPoint85Iso:
141			isocut = ElectronTools::PassCustomIso(ele, ElectronTools::kVBTFWorkingPoint85Iso);
142			break;
143	sixie	1.56	case ElectronTools::kVBTFWorkingPoint80Iso:
144			isocut = ElectronTools::PassCustomIso(ele, ElectronTools::kVBTFWorkingPoint80Iso);
145	sixie	1.51	break;
146	sixie	1.56	case ElectronTools::kVBTFWorkingPoint70Iso:
147			isocut = ElectronTools::PassCustomIso(ele, ElectronTools::kVBTFWorkingPoint70Iso);
148	sixie	1.51	break;
149	sixie	1.56	case ElectronTools::kNoIso:
150	sixie	1.42	isocut = kTRUE;
151			break;
152	sixie	1.56	case ElectronTools::kCustomIso:
153	sixie	1.42	default:
154			break;
155			}
156
157			return isocut;
158			}
159
160
161			//--------------------------------------------------------------------------------------------------
162	loizides	1.1	void ElectronIDMod::Process()
163			{
164			// Process entries of the tree.
165
166	loizides	1.23	LoadEventObject(fElectronBranchName, fElectrons);
167	loizides	1.1
168	bendavid	1.62	//get trigger object collection if trigger matching is enabled
169			const TriggerObjectCol *trigObjs = 0;
170			if (fApplyTriggerMatching) {
171			trigObjs = GetHLTObjects(fTrigObjectsName);
172			}
173
174	loizides	1.6	ElectronOArr *GoodElectrons = new ElectronOArr;
175			GoodElectrons->SetName(fGoodElectronsName);
176	loizides	1.1
177	ceballos	1.18	for (UInt_t i=0; i<fElectrons->GetEntries(); ++i) {
178	loizides	1.5	const Electron *e = fElectrons->At(i);
179	loizides	1.1
180	loizides	1.5	if (e->Pt() <= fElectronPtMin)
181			continue;
182	loizides	1.1
183	bendavid	1.62	//apply trigger matching
184			Bool_t matchTrigger = fApplyTriggerMatching && ElectronTools::PassTriggerMatching(e,trigObjs);
185			if (fApplyTriggerMatching && !matchTrigger)
186			continue;
187
188	sixie	1.55	//apply ECAL spike removal
189	sixie	1.56	Bool_t spikecut = ElectronTools::PassSpikeRemovalFilter(e);
190	sixie	1.57	if (fApplySpikeRemoval && !spikecut)
191	sixie	1.55	continue;
192
193	sixie	1.42	//apply id cut
194			Bool_t idcut = PassIDCut(e, fElIdType);
195	loizides	1.5	if (!idcut)
196			continue;
197
198	sixie	1.42	//apply Isolation Cut
199			Bool_t isocut = PassIsolationCut(e, fElIsoType);
200			if (!isocut)
201	loizides	1.5	continue;
202
203	ceballos	1.60	// apply conversion filters
204			Bool_t passConvVetoType1 = kFALSE;
205			if (fApplyConvFilterType1) {
206	sixie	1.42	LoadEventObject(fConversionBranchName, fConversions);
207	ceballos	1.60	passConvVetoType1 = ElectronTools::PassConversionFilter(e, fConversions,
208	sixie	1.56	fWrongHitsRequirement);
209	ceballos	1.12	}
210	ceballos	1.60	else {
211			passConvVetoType1 = kTRUE;
212			}
213
214			if (passConvVetoType1 == kFALSE) continue;
215
216			Bool_t passConvVetoType2 = kFALSE;
217			if (fApplyConvFilterType2) {
218			passConvVetoType2 = TMath::Abs(e->ConvPartnerDCotTheta()) >= 0.02 \|\|
219			TMath::Abs(e->ConvPartnerDist()) >= 0.02;
220			}
221			else {
222			passConvVetoType2 = kTRUE;
223			}
224	sixie	1.42
225	ceballos	1.60	if (passConvVetoType2 == kFALSE) continue;
226
227			// apply NExpectedHitsInner Cut
228			if(fNExpectedHitsInnerCut < 999 &&
229			e->BestTrk()->NExpectedHitsInner() > fNExpectedHitsInnerCut) continue;
230
231	sixie	1.42	// apply d0 cut
232	ceballos	1.15	if (fApplyD0Cut) {
233	sixie	1.42	LoadEventObject(fVertexName, fVertices);
234	sixie	1.56	Bool_t passD0cut = ElectronTools::PassD0Cut(e, fVertices, fD0Cut, fReverseD0Cut);
235	sixie	1.42	if (!passD0cut)
236	ceballos	1.24	continue;
237	ceballos	1.12	}
238
239	ceballos	1.59	// apply charge filter
240	sixie	1.42	if(fChargeFilter == kTRUE) {
241	sixie	1.56	Bool_t passChargeFilter = ElectronTools::PassChargeFilter(e);
242	sixie	1.42	if (!passChargeFilter) continue;
243	ceballos	1.45	}
244
245	ceballos	1.63	// apply full combined id, using Tight cuts
246	ceballos	1.59	if(fCombinedIdCut == kTRUE) {
247			LoadEventObject(fVertexName, fVertices);
248			LoadEventObject(fConversionBranchName, fConversions);
249	ceballos	1.63	Int_t result = ElectronTools::PassTightId(e, *&fVertices, fConversions, 2);
250	ceballos	1.59	if(result != 15) continue;
251			}
252
253	loizides	1.5	// add good electron
254	ceballos	1.12	GoodElectrons->Add(e);
255	loizides	1.5	}
256	loizides	1.1
257	loizides	1.9	// sort according to pt
258			GoodElectrons->Sort();
259
260	loizides	1.5	// add to event for other modules to use
261	loizides	1.6	AddObjThisEvt(GoodElectrons);
262	loizides	1.1	}
263
264			//--------------------------------------------------------------------------------------------------
265			void ElectronIDMod::SlaveBegin()
266			{
267			// Run startup code on the computer (slave) doing the actual analysis. Here,
268	loizides	1.5	// we just request the electron collection branch.
269	loizides	1.1
270	loizides	1.23	ReqEventObject(fElectronBranchName, fElectrons, kTRUE);
271	loizides	1.17
272	ceballos	1.59	if(fCombinedIdCut == kTRUE) {
273	ceballos	1.60	fElectronIDType = "NoId";
274			fElectronIsoType = "NoIso";
275			fApplyConvFilterType1 = kFALSE;
276			fApplyConvFilterType2 = kFALSE;
277			fApplyD0Cut = kFALSE;
278	ceballos	1.59	}
279
280	ceballos	1.60	if (fApplyConvFilterType1 \|\| fCombinedIdCut == kTRUE)
281	loizides	1.23	ReqEventObject(fConversionBranchName, fConversions, kTRUE);
282	loizides	1.17
283	ceballos	1.59	if (fApplyD0Cut \|\| fCombinedIdCut == kTRUE)
284	loizides	1.23	ReqEventObject(fVertexName, fVertices, kTRUE);
285	loizides	1.1
286	sixie	1.42	Setup();
287			}
288
289			//--------------------------------------------------------------------------------------------------
290			void ElectronIDMod::Setup()
291			{
292			// Set all options properly before execution.
293
294	loizides	1.5	if (fElectronIDType.CompareTo("Tight") == 0)
295	sixie	1.56	fElIdType = ElectronTools::kTight;
296	loizides	1.5	else if (fElectronIDType.CompareTo("Loose") == 0)
297	sixie	1.56	fElIdType = ElectronTools::kLoose;
298	loizides	1.5	else if (fElectronIDType.CompareTo("Likelihood") == 0)
299	sixie	1.56	fElIdType = ElectronTools::kLikelihood;
300	loizides	1.10	else if (fElectronIDType.CompareTo("NoId") == 0)
301	sixie	1.56	fElIdType = ElectronTools::kNoId;
302	sixie	1.42	else if (fElectronIDType.CompareTo("ZeeId") == 0)
303	sixie	1.56	fElIdType = ElectronTools::kZeeId;
304	sixie	1.51	else if (fElectronIDType.CompareTo("CustomLoose") == 0)
305	sixie	1.56	fElIdType = ElectronTools::kCustomIdLoose;
306	sixie	1.51	else if (fElectronIDType.CompareTo("CustomTight") == 0)
307	sixie	1.56	fElIdType = ElectronTools::kCustomIdTight;
308	sixie	1.55	else if (fElectronIDType.CompareTo("VBTFWorkingPoint95Id") == 0)
309	sixie	1.56	fElIdType = ElectronTools::kVBTFWorkingPoint95Id;
310	sixie	1.51	else if (fElectronIDType.CompareTo("VBTFWorkingPoint90Id") == 0)
311	sixie	1.56	fElIdType = ElectronTools::kVBTFWorkingPoint90Id;
312	sixie	1.51	else if (fElectronIDType.CompareTo("VBTFWorkingPoint80Id") == 0)
313	sixie	1.56	fElIdType = ElectronTools::kVBTFWorkingPoint80Id;
314	ceballos	1.60	else if (fElectronIDType.CompareTo("VBTFWorkingPoint85Id") == 0)
315			fElIdType = ElectronTools::kVBTFWorkingPoint85Id;
316	sixie	1.51	else if (fElectronIDType.CompareTo("VBTFWorkingPoint70Id") == 0)
317	sixie	1.56	fElIdType = ElectronTools::kVBTFWorkingPoint70Id;
318	sixie	1.51
319	peveraer	1.29	else {
320	loizides	1.5	SendError(kAbortAnalysis, "SlaveBegin",
321			"The specified electron identification %s is not defined.",
322			fElectronIDType.Data());
323			return;
324			}
325	sixie	1.51
326	loizides	1.5	if (fElectronIsoType.CompareTo("TrackCalo") == 0 )
327	sixie	1.56	fElIsoType = ElectronTools::kTrackCalo;
328	loizides	1.5	else if (fElectronIsoType.CompareTo("TrackJura") == 0)
329	sixie	1.56	fElIsoType = ElectronTools::kTrackJura;
330	ceballos	1.49	else if(fElectronIsoType.CompareTo("TrackJuraCombined") == 0)
331	sixie	1.56	fElIsoType = ElectronTools::kTrackJuraCombined;
332	loizides	1.5	else if(fElectronIsoType.CompareTo("TrackJuraSliding") == 0)
333	sixie	1.56	fElIsoType = ElectronTools::kTrackJuraSliding;
334	loizides	1.5	else if (fElectronIsoType.CompareTo("NoIso") == 0 )
335	sixie	1.56	fElIsoType = ElectronTools::kNoIso;
336	sixie	1.42	else if (fElectronIsoType.CompareTo("ZeeIso") == 0 )
337	sixie	1.56	fElIsoType = ElectronTools::kZeeIso;
338	sixie	1.55	else if (fElectronIsoType.CompareTo("VBTFWorkingPoint95Iso") == 0 )
339	sixie	1.56	fElIsoType = ElectronTools::kVBTFWorkingPoint95Iso;
340	sixie	1.51	else if (fElectronIsoType.CompareTo("VBTFWorkingPoint90Iso") == 0 )
341	sixie	1.56	fElIsoType = ElectronTools::kVBTFWorkingPoint90Iso;
342	ceballos	1.60	else if (fElectronIsoType.CompareTo("VBTFWorkingPoint85Iso") == 0 )
343			fElIsoType = ElectronTools::kVBTFWorkingPoint85Iso;
344	sixie	1.51	else if (fElectronIsoType.CompareTo("VBTFWorkingPoint80Iso") == 0 )
345	sixie	1.56	fElIsoType = ElectronTools::kVBTFWorkingPoint80Iso;
346	sixie	1.51	else if (fElectronIsoType.CompareTo("VBTFWorkingPoint70Iso") == 0 )
347	sixie	1.56	fElIsoType = ElectronTools::kVBTFWorkingPoint70Iso;
348	loizides	1.5	else if (fElectronIsoType.CompareTo("Custom") == 0 ) {
349	sixie	1.56	fElIsoType = ElectronTools::kCustomIso;
350	loizides	1.5	SendError(kWarning, "SlaveBegin",
351			"Custom electron isolation is not yet implemented.");
352			} else {
353			SendError(kAbortAnalysis, "SlaveBegin",
354			"The specified electron isolation %s is not defined.",
355			fElectronIsoType.Data());
356			return;
357			}
358	sixie	1.42
359	loizides	1.30
360			}
361	sixie	1.51
362