Mods/src/ElectronIDMod.cc

// $Id: ElectronIDMod.cc,v 1.8 2008/11/28 11:35:29 ceballos 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("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.9
Committed:	Wed Dec 10 11:44:33 2008 UTC (16 years, 4 months ago) by loizides
Content type:	text/plain
Branch:	MAIN
Changes since 1.8:	+4 -1 lines
Log Message:	Added sort.
#	User	Rev	Content
1	loizides	1.9	// $Id: ElectronIDMod.cc,v 1.8 2008/11/28 11:35:29 ceballos 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			else if (fElectronIDType.CompareTo("Custom") == 0) {
122			fElIdType = kCustomId;
123			SendError(kWarning, "SlaveBegin",
124			"Custom electron identification is not yet implemented.");
125			} else {
126			SendError(kAbortAnalysis, "SlaveBegin",
127			"The specified electron identification %s is not defined.",
128			fElectronIDType.Data());
129			return;
130			}
131
132			if (fElectronIsoType.CompareTo("TrackCalo") == 0 )
133			fElIsoType = kTrackCalo;
134			else if (fElectronIsoType.CompareTo("TrackJura") == 0)
135			fElIsoType = kTrackJura;
136			else if(fElectronIsoType.CompareTo("TrackJuraSliding") == 0)
137			fElIsoType = kTrackJuraSliding;
138			else if (fElectronIsoType.CompareTo("NoIso") == 0 )
139			fElIsoType = kNoIso;
140			else if (fElectronIsoType.CompareTo("Custom") == 0 ) {
141			fElIsoType = kCustomIso;
142			SendError(kWarning, "SlaveBegin",
143			"Custom electron isolation is not yet implemented.");
144			} else {
145			SendError(kAbortAnalysis, "SlaveBegin",
146			"The specified electron isolation %s is not defined.",
147			fElectronIsoType.Data());
148			return;
149			}
150	loizides	1.1	}