Mods/src/ElectronIDMod.cc

// $Id: ElectronIDMod.cc,v 1.5 2008/11/27 16:30:27 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("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);

  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) ||
              (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);  
}

//--------------------------------------------------------------------------------------------------
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.6
Committed:	Fri Nov 28 09:13:50 2008 UTC (16 years, 5 months ago) by loizides
Content type:	text/plain
Branch:	MAIN
Changes since 1.5:	+4 -6 lines
Log Message:	Finished refurbishing
#	User	Rev	Content
1	loizides	1.6	// $Id: ElectronIDMod.cc,v 1.5 2008/11/27 16:30:27 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.4	fElectronIsoType("TrackCaloSliding"),
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			if ((totalIso < (e->Pt()-10.0)*6.0/15.0) \|\|
80			(totalIso < 6.0 && e->Pt() > 25))
81			isocut = kTRUE;
82			}
83			break;
84			case kNoIso:
85			isocut = kTRUE;
86			break;
87			case kCustomIso:
88			default:
89			break;
90	loizides	1.1	}
91
92	loizides	1.5	if (!isocut)
93			continue;
94
95			// add good electron
96			GoodElectrons->Add(fElectrons->At(i));
97			}
98	loizides	1.1
99	loizides	1.5	// add to event for other modules to use
100	loizides	1.6	AddObjThisEvt(GoodElectrons);
101	loizides	1.1	}
102
103			//--------------------------------------------------------------------------------------------------
104			void ElectronIDMod::SlaveBegin()
105			{
106			// Run startup code on the computer (slave) doing the actual analysis. Here,
107	loizides	1.5	// we just request the electron collection branch.
108	loizides	1.1
109	loizides	1.5	ReqBranch(fElectronBranchName, fElectrons);
110	loizides	1.1
111	loizides	1.5	if (fElectronIDType.CompareTo("Tight") == 0)
112			fElIdType = kTight;
113			else if (fElectronIDType.CompareTo("Loose") == 0)
114			fElIdType = kLoose;
115			else if (fElectronIDType.CompareTo("Likelihood") == 0)
116			fElIdType = kLikelihood;
117			else if (fElectronIDType.CompareTo("Custom") == 0) {
118			fElIdType = kCustomId;
119			SendError(kWarning, "SlaveBegin",
120			"Custom electron identification is not yet implemented.");
121			} else {
122			SendError(kAbortAnalysis, "SlaveBegin",
123			"The specified electron identification %s is not defined.",
124			fElectronIDType.Data());
125			return;
126			}
127
128			if (fElectronIsoType.CompareTo("TrackCalo") == 0 )
129			fElIsoType = kTrackCalo;
130			else if (fElectronIsoType.CompareTo("TrackJura") == 0)
131			fElIsoType = kTrackJura;
132			else if(fElectronIsoType.CompareTo("TrackJuraSliding") == 0)
133			fElIsoType = kTrackJuraSliding;
134			else if (fElectronIsoType.CompareTo("NoIso") == 0 )
135			fElIsoType = kNoIso;
136			else if (fElectronIsoType.CompareTo("Custom") == 0 ) {
137			fElIsoType = kCustomIso;
138			SendError(kWarning, "SlaveBegin",
139			"Custom electron isolation is not yet implemented.");
140			} else {
141			SendError(kAbortAnalysis, "SlaveBegin",
142			"The specified electron isolation %s is not defined.",
143			fElectronIsoType.Data());
144			return;
145			}
146	loizides	1.1	}