Mods/src/ElectronIDMod.cc

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