Mods/src/ElectronIDMod.cc

// $Id: ElectronIDMod.cc,v 1.4 2008/11/26 10:55:51 ceballos Exp $

#include "MitPhysics/Mods/interface/ElectronIDMod.h"
#include "MitAna/DataUtil/interface/Debug.h"
#include "MitCommon/MathTools/interface/MathUtils.h"
#include "MitPhysics/Init/interface/ModNames.h"
#include "MitPhysics/Utils/interface/IsolationTools.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("TrackCaloSliding"),
  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);

  ObjArray<Electron> *GoodElectrons = new ObjArray<Electron>;

  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) ||
              (totalIso < 6.0 && e->Pt() > 25)) 
            isocut = kTRUE;
        }
        break;
      case kNoIso:
        isocut = kTRUE;
        break;
      case kCustomIso:
      default:
        break;
    }

    if (!isocut) 
      continue;

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

  // add to event for other modules to use
  AddObjThisEvt(GoodElectrons, fGoodElectronsName);  
}

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