Mods/src/ElectronIDMod.cc

// $Id: ElectronIDMod.cc,v 1.73 2011/01/21 09:26:06 dkralph 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(ModNames::gkGoodVertexesName),
  fElectronIDType("CustomTight"),
  fElectronIsoType("TrackJuraSliding"),
  fTrigObjectsName("HLTModTrigObjs"),
  fElectronPtMin(10),
  fElectronEtMin(0.0),  
  fElectronEtaMax(2.5),
  fIDLikelihoodCut(0.75),
  fTrackIsolationCut(5.0),
  fCaloIsolationCut(5.0),
  fEcalJuraIsoCut(5.0),
  fHcalIsolationCut(5.0),
  fCombIsolationCut(0.10),
  fApplyConvFilterType1(kTRUE),
  fApplyConvFilterType2(kFALSE),
  fWrongHitsRequirement(kTRUE),
  fElectronsFromBranch(kTRUE),
  fNExpectedHitsInnerCut(999),
  fCombinedIdCut(kFALSE),
  fApplySpikeRemoval(kTRUE),
  fApplyD0Cut(kTRUE),
  fChargeFilter(kTRUE),
  fD0Cut(0.020),
  fApplyTriggerMatching(kFALSE),
  fApplyEcalSeeded(kFALSE),
  fApplyCombinedIso(kTRUE),
  fApplyEcalFiducial(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->Pt() >  15 && ele->IDLikelihood() > fIDLikelihoodCut) ||
              (ele->Pt() <= 15 && ElectronTools::PassCustomID(ele, ElectronTools::kVBTFWorkingPoint80Id));
      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() + ele->EcalRecHitIsoDr03() + ele->HcalTowerSumEtDr03();
      if(ele->SCluster()->AbsEta() < 1.479) totalIso = ele->TrackIsolationDr03() + TMath::Max(ele->EcalRecHitIsoDr03() - 1.0, 0.0) + ele->HcalTowerSumEtDr03();
      if (totalIso < (ele->Pt()*fCombIsolationCut) )
        isocut = kTRUE;
    }
    break;
    case ElectronTools::kVBTFWorkingPoint95Iso:
      isocut = ElectronTools::PassCustomIso(ele, ElectronTools::kVBTFWorkingPoint95Iso, fApplyCombinedIso);
      break;
    case ElectronTools::kVBTFWorkingPoint90Iso:
      isocut = ElectronTools::PassCustomIso(ele, ElectronTools::kVBTFWorkingPoint90Iso, fApplyCombinedIso);
      break;
    case ElectronTools::kVBTFWorkingPoint85Iso:
      isocut = ElectronTools::PassCustomIso(ele, ElectronTools::kVBTFWorkingPoint85Iso, fApplyCombinedIso);
      break;
    case ElectronTools::kVBTFWorkingPoint80Iso:
      isocut = ElectronTools::PassCustomIso(ele, ElectronTools::kVBTFWorkingPoint80Iso, fApplyCombinedIso);
      break;
    case ElectronTools::kVBTFWorkingPoint70Iso:
      isocut = ElectronTools::PassCustomIso(ele, ElectronTools::kVBTFWorkingPoint70Iso, fApplyCombinedIso);
      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->SCluster() == 0) 
      continue;
    
    if (e->Pt() < fElectronPtMin) 
      continue;
    
    if (e->SCluster()->Et() < fElectronEtMin)
      continue;    
    
    if (e->AbsEta() > fElectronEtaMax) 
      continue;
    
    if (fApplyEcalFiducial && ( (e->SCluster()->AbsEta()>1.4442 && e->SCluster()->AbsEta()<1.5666) || e->SCluster()->AbsEta()>2.5 )) {
      continue;
    }
    
    if (fApplyEcalSeeded && !e->IsEcalDriven()) {
      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->CorrectedNExpectedHitsInner() > fNExpectedHitsInnerCut) continue;

    // apply d0 cut
    if (fApplyD0Cut) {
      fVertices = GetObjThisEvt<VertexOArr>(fVertexName);
      Bool_t passD0cut = ElectronTools::PassD0Cut(e, fVertices, fD0Cut);
      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) {
      fVertices = GetObjThisEvt<VertexOArr>(fVertexName);
      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,fElectronsFromBranch);

  if(fCombinedIdCut == kTRUE) {
    fElectronIDType       = "NoId";
    fElectronIsoType      = "NoIso";
    fApplyConvFilterType1 = kFALSE;
    fApplyConvFilterType2 = kFALSE;
    fApplyD0Cut           = kFALSE;
  }

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