Mods/src/ElectronIDMod.cc

// $Id: ElectronIDMod.cc,v 1.74 2011/01/21 11:25:28 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),
  fBeamSpotName(Names::gkBeamSpotBrn),
  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),
  fNWrongHitsMax(1),
  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),
  fBeamSpot(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);
  LoadEventObject(fBeamSpotName, fBeamSpot);

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