Mods/src/ElectronIDMod.cc

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