Mods/src/ElectronIDMod.cc

// $Id: ElectronIDMod.cc,v 1.9 2008/12/10 11:44:33 loizides Exp $

#include "MitPhysics/Mods/interface/ElectronIDMod.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),
  fGoodElectronsName(ModNames::gkGoodElectronsName),  
  fElectronIDType("Tight"),
  fElectronIsoType("TrackJuraSliding"),
  fElectronPtMin(10),
  fIDLikelihoodCut(0.9),
  fTrackIsolationCut(5.0),
  fCaloIsolationCut(5.0),
  fEcalJuraIsoCut(5.0),
  fHcalIsolationCut(5.0),
  fElectrons(0),
  fElIdType(kIdUndef),
  fElIsoType(kIsoUndef)
{
  // Constructor.
}

//--------------------------------------------------------------------------------------------------
void ElectronIDMod::Process()
{
  // Process entries of the tree. 

  LoadBranch(fElectronBranchName);

  ElectronOArr *GoodElectrons = new ElectronOArr;
  GoodElectrons->SetName(fGoodElectronsName);

  for (UInt_t i=0; i<fElectrons->GetEntries(); ++i) {    
    const Electron *e = fElectrons->At(i);        

    if (e->Pt() <= fElectronPtMin) 
      continue;
    
    Bool_t idcut = kFALSE;
    switch (fElIdType) {
      case kTight:
        idcut = e->PassTightID();
        break;
      case kLoose:
        idcut = e->PassLooseID();
       break;
      case kLikelihood:
        idcut = (e->IDLikelihood() > fIDLikelihoodCut);
        break;
      case kCustomId:
      default:
        break;
    }

    if (!idcut) 
      continue;

    Bool_t isocut = kFALSE;
    switch (fElIsoType) {
      case kTrackCalo:
        isocut = (e->TrackIsolation() < fTrackIsolationCut) &&
                 (e->CaloIsolation() < fCaloIsolationCut);
        break;
      case kTrackJura:
        isocut = (e->TrackIsolation() < fTrackIsolationCut) &&
                 (e->EcalJurassicIsolation() < fEcalJuraIsoCut) &&
                 (e->HcalIsolation() < fHcalIsolationCut);
        break;
      case kTrackJuraSliding:
        { 
          Double_t totalIso = e->TrackIsolation() + e->EcalJurassicIsolation() - 1.5;
          if ((totalIso < (e->Pt()-10.0)*6.0/15.0 && e->Pt() <= 25) ||
              (totalIso < 6.0 && e->Pt() > 25) ||
               totalIso <= 0)
            isocut = kTRUE;
        }
        break;
      case kNoIso:
        isocut = kTRUE;
        break;
      case kCustomIso:
      default:
        break;
    }

    if (!isocut) 
      continue;

    // add good electron
    GoodElectrons->Add(fElectrons->At(i));
  }

  // 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.

  ReqBranch(fElectronBranchName, fElectrons);

  if (fElectronIDType.CompareTo("Tight") == 0) 
    fElIdType = kTight;
  else if (fElectronIDType.CompareTo("Loose") == 0) 
    fElIdType = kLoose;
  else if (fElectronIDType.CompareTo("Likelihood") == 0) 
    fElIdType = kLikelihood;
  else if (fElectronIDType.CompareTo("NoId") == 0) 
    fElIdType = kNoId;
  else if (fElectronIDType.CompareTo("Custom") == 0) {
    fElIdType = kCustomId;
    SendError(kWarning, "SlaveBegin",
              "Custom electron identification is not yet implemented.");
  } else {
    SendError(kAbortAnalysis, "SlaveBegin",
              "The specified electron identification %s is not defined.",
              fElectronIDType.Data());
    return;
  }

  if (fElectronIsoType.CompareTo("TrackCalo") == 0 )
    fElIsoType = kTrackCalo;
  else if (fElectronIsoType.CompareTo("TrackJura") == 0) 
    fElIsoType = kTrackJura;
  else if(fElectronIsoType.CompareTo("TrackJuraSliding") == 0)
    fElIsoType = kTrackJuraSliding;
  else if (fElectronIsoType.CompareTo("NoIso") == 0 )
    fElIsoType = kNoIso;
  else if (fElectronIsoType.CompareTo("Custom") == 0 ) {
    fElIsoType = 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.10
Committed:	Thu Dec 11 10:55:44 2008 UTC (16 years, 4 months ago) by loizides
Content type:	text/plain
Branch:	MAIN
Changes since 1.9:	+3 -1 lines
Log Message:	Small improvements. Added NoId.
#	User	Rev	Content
1	loizides	1.10	// $Id: ElectronIDMod.cc,v 1.9 2008/12/10 11:44:33 loizides Exp $
2	loizides	1.1
3			#include "MitPhysics/Mods/interface/ElectronIDMod.h"
4	loizides	1.5	#include "MitPhysics/Init/interface/ModNames.h"
5	loizides	1.1
6			using namespace mithep;
7
8			ClassImp(mithep::ElectronIDMod)
9
10			//--------------------------------------------------------------------------------------------------
11	loizides	1.5	ElectronIDMod::ElectronIDMod(const char name, const char title) :
12	loizides	1.1	BaseMod(name,title),
13	loizides	1.5	fElectronBranchName(Names::gkElectronBrn),
14			fGoodElectronsName(ModNames::gkGoodElectronsName),
15	loizides	1.1	fElectronIDType("Tight"),
16	ceballos	1.8	fElectronIsoType("TrackJuraSliding"),
17	loizides	1.1	fElectronPtMin(10),
18			fIDLikelihoodCut(0.9),
19			fTrackIsolationCut(5.0),
20			fCaloIsolationCut(5.0),
21	loizides	1.5	fEcalJuraIsoCut(5.0),
22			fHcalIsolationCut(5.0),
23			fElectrons(0),
24			fElIdType(kIdUndef),
25			fElIsoType(kIsoUndef)
26	loizides	1.1	{
27			// Constructor.
28			}
29
30			//--------------------------------------------------------------------------------------------------
31			void ElectronIDMod::Process()
32			{
33			// Process entries of the tree.
34
35	loizides	1.5	LoadBranch(fElectronBranchName);
36	loizides	1.1
37	loizides	1.6	ElectronOArr *GoodElectrons = new ElectronOArr;
38			GoodElectrons->SetName(fGoodElectronsName);
39	loizides	1.1
40	loizides	1.5	for (UInt_t i=0; i<fElectrons->GetEntries(); ++i) {
41			const Electron *e = fElectrons->At(i);
42	loizides	1.1
43	loizides	1.5	if (e->Pt() <= fElectronPtMin)
44			continue;
45	loizides	1.1
46	loizides	1.5	Bool_t idcut = kFALSE;
47			switch (fElIdType) {
48			case kTight:
49			idcut = e->PassTightID();
50			break;
51			case kLoose:
52			idcut = e->PassLooseID();
53			break;
54			case kLikelihood:
55			idcut = (e->IDLikelihood() > fIDLikelihoodCut);
56			break;
57			case kCustomId:
58			default:
59			break;
60	loizides	1.1	}
61
62	loizides	1.5	if (!idcut)
63			continue;
64
65			Bool_t isocut = kFALSE;
66			switch (fElIsoType) {
67			case kTrackCalo:
68			isocut = (e->TrackIsolation() < fTrackIsolationCut) &&
69			(e->CaloIsolation() < fCaloIsolationCut);
70			break;
71			case kTrackJura:
72			isocut = (e->TrackIsolation() < fTrackIsolationCut) &&
73			(e->EcalJurassicIsolation() < fEcalJuraIsoCut) &&
74			(e->HcalIsolation() < fHcalIsolationCut);
75			break;
76			case kTrackJuraSliding:
77			{
78			Double_t totalIso = e->TrackIsolation() + e->EcalJurassicIsolation() - 1.5;
79	ceballos	1.7	if ((totalIso < (e->Pt()-10.0)*6.0/15.0 && e->Pt() <= 25) \|\|
80			(totalIso < 6.0 && e->Pt() > 25) \|\|
81			totalIso <= 0)
82	loizides	1.5	isocut = kTRUE;
83			}
84			break;
85			case kNoIso:
86			isocut = kTRUE;
87			break;
88			case kCustomIso:
89			default:
90			break;
91	loizides	1.1	}
92
93	loizides	1.5	if (!isocut)
94			continue;
95
96			// add good electron
97			GoodElectrons->Add(fElectrons->At(i));
98			}
99	loizides	1.1
100	loizides	1.9	// sort according to pt
101			GoodElectrons->Sort();
102
103	loizides	1.5	// add to event for other modules to use
104	loizides	1.6	AddObjThisEvt(GoodElectrons);
105	loizides	1.1	}
106
107			//--------------------------------------------------------------------------------------------------
108			void ElectronIDMod::SlaveBegin()
109			{
110			// Run startup code on the computer (slave) doing the actual analysis. Here,
111	loizides	1.5	// we just request the electron collection branch.
112	loizides	1.1
113	loizides	1.5	ReqBranch(fElectronBranchName, fElectrons);
114	loizides	1.1
115	loizides	1.5	if (fElectronIDType.CompareTo("Tight") == 0)
116			fElIdType = kTight;
117			else if (fElectronIDType.CompareTo("Loose") == 0)
118			fElIdType = kLoose;
119			else if (fElectronIDType.CompareTo("Likelihood") == 0)
120			fElIdType = kLikelihood;
121	loizides	1.10	else if (fElectronIDType.CompareTo("NoId") == 0)
122			fElIdType = kNoId;
123	loizides	1.5	else if (fElectronIDType.CompareTo("Custom") == 0) {
124			fElIdType = kCustomId;
125			SendError(kWarning, "SlaveBegin",
126			"Custom electron identification is not yet implemented.");
127			} else {
128			SendError(kAbortAnalysis, "SlaveBegin",
129			"The specified electron identification %s is not defined.",
130			fElectronIDType.Data());
131			return;
132			}
133
134			if (fElectronIsoType.CompareTo("TrackCalo") == 0 )
135			fElIsoType = kTrackCalo;
136			else if (fElectronIsoType.CompareTo("TrackJura") == 0)
137			fElIsoType = kTrackJura;
138			else if(fElectronIsoType.CompareTo("TrackJuraSliding") == 0)
139			fElIsoType = kTrackJuraSliding;
140			else if (fElectronIsoType.CompareTo("NoIso") == 0 )
141			fElIsoType = kNoIso;
142			else if (fElectronIsoType.CompareTo("Custom") == 0 ) {
143			fElIsoType = kCustomIso;
144			SendError(kWarning, "SlaveBegin",
145			"Custom electron isolation is not yet implemented.");
146			} else {
147			SendError(kAbortAnalysis, "SlaveBegin",
148			"The specified electron isolation %s is not defined.",
149			fElectronIsoType.Data());
150			return;
151			}
152	loizides	1.1	}