Mods/src/ElectronIDMod.cc

// $Id: ElectronIDMod.cc,v 1.10 2008/12/11 10:55:44 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 kNoId:
        idcut = kTRUE;
        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.11
Committed:	Thu Dec 11 15:53:03 2008 UTC (16 years, 4 months ago) by loizides
Content type:	text/plain
Branch:	MAIN
CVS Tags:	Mit_008, Mit_008pre2, Mit_008pre1, Mit_006b, Mit_006a
Changes since 1.10:	+4 -1 lines
Log Message:	Bugfix to kNoId.
#	User	Rev	Content
1	loizides	1.11	// $Id: ElectronIDMod.cc,v 1.10 2008/12/11 10:55:44 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	loizides	1.11	case kNoId:
58			idcut = kTRUE;
59			break;
60	loizides	1.5	case kCustomId:
61			default:
62			break;
63	loizides	1.1	}
64
65	loizides	1.5	if (!idcut)
66			continue;
67
68			Bool_t isocut = kFALSE;
69			switch (fElIsoType) {
70			case kTrackCalo:
71			isocut = (e->TrackIsolation() < fTrackIsolationCut) &&
72			(e->CaloIsolation() < fCaloIsolationCut);
73			break;
74			case kTrackJura:
75			isocut = (e->TrackIsolation() < fTrackIsolationCut) &&
76			(e->EcalJurassicIsolation() < fEcalJuraIsoCut) &&
77			(e->HcalIsolation() < fHcalIsolationCut);
78			break;
79			case kTrackJuraSliding:
80			{
81			Double_t totalIso = e->TrackIsolation() + e->EcalJurassicIsolation() - 1.5;
82	ceballos	1.7	if ((totalIso < (e->Pt()-10.0)*6.0/15.0 && e->Pt() <= 25) \|\|
83			(totalIso < 6.0 && e->Pt() > 25) \|\|
84			totalIso <= 0)
85	loizides	1.5	isocut = kTRUE;
86			}
87			break;
88			case kNoIso:
89			isocut = kTRUE;
90			break;
91			case kCustomIso:
92			default:
93			break;
94	loizides	1.1	}
95
96	loizides	1.5	if (!isocut)
97			continue;
98
99			// add good electron
100			GoodElectrons->Add(fElectrons->At(i));
101			}
102	loizides	1.1
103	loizides	1.9	// sort according to pt
104			GoodElectrons->Sort();
105
106	loizides	1.5	// add to event for other modules to use
107	loizides	1.6	AddObjThisEvt(GoodElectrons);
108	loizides	1.1	}
109
110			//--------------------------------------------------------------------------------------------------
111			void ElectronIDMod::SlaveBegin()
112			{
113			// Run startup code on the computer (slave) doing the actual analysis. Here,
114	loizides	1.5	// we just request the electron collection branch.
115	loizides	1.1
116	loizides	1.5	ReqBranch(fElectronBranchName, fElectrons);
117	loizides	1.1
118	loizides	1.5	if (fElectronIDType.CompareTo("Tight") == 0)
119			fElIdType = kTight;
120			else if (fElectronIDType.CompareTo("Loose") == 0)
121			fElIdType = kLoose;
122			else if (fElectronIDType.CompareTo("Likelihood") == 0)
123			fElIdType = kLikelihood;
124	loizides	1.10	else if (fElectronIDType.CompareTo("NoId") == 0)
125			fElIdType = kNoId;
126	loizides	1.5	else if (fElectronIDType.CompareTo("Custom") == 0) {
127			fElIdType = kCustomId;
128			SendError(kWarning, "SlaveBegin",
129			"Custom electron identification is not yet implemented.");
130			} else {
131			SendError(kAbortAnalysis, "SlaveBegin",
132			"The specified electron identification %s is not defined.",
133			fElectronIDType.Data());
134			return;
135			}
136
137			if (fElectronIsoType.CompareTo("TrackCalo") == 0 )
138			fElIsoType = kTrackCalo;
139			else if (fElectronIsoType.CompareTo("TrackJura") == 0)
140			fElIsoType = kTrackJura;
141			else if(fElectronIsoType.CompareTo("TrackJuraSliding") == 0)
142			fElIsoType = kTrackJuraSliding;
143			else if (fElectronIsoType.CompareTo("NoIso") == 0 )
144			fElIsoType = kNoIso;
145			else if (fElectronIsoType.CompareTo("Custom") == 0 ) {
146			fElIsoType = kCustomIso;
147			SendError(kWarning, "SlaveBegin",
148			"Custom electron isolation is not yet implemented.");
149			} else {
150			SendError(kAbortAnalysis, "SlaveBegin",
151			"The specified electron isolation %s is not defined.",
152			fElectronIsoType.Data());
153			return;
154			}
155	loizides	1.1	}