Mods/src/ElectronIDMod.cc

// $Id: ElectronIDMod.cc,v 1.68 2010/10/20 02:44:48 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(ModNames::gkGoodVertexesName),
  fElectronIDType("CustomTight"),
  fElectronIsoType("TrackJuraSliding"),
  fTrigObjectsName("HLTModTrigObjs"),
  fElectronPtMin(10),
  fElectronEtMin(0.0),  
  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),
  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->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() + ele->EcalRecHitIsoDr03() + ele->HcalTowerSumEtDr03();
      if(ele->IsEB()) 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, 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, 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) {
      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, kTRUE);

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