Mods/src/ElectronIDMod.cc

// $Id: ElectronIDMod.cc,v 1.13 2009/04/03 17:19:24 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),
  fConversionBranchName(Names::gkMvfConversionBrn),
  fGoodElectronsName(ModNames::gkGoodElectronsName),  
  fVertexName(string("PrimaryVertexesBeamSpot").c_str()),
  fElectronIDType("Tight"),
  fElectronIsoType("TrackJuraSliding"),
  fElectronPtMin(10),
  fIDLikelihoodCut(0.9),
  fTrackIsolationCut(5.0),
  fCaloIsolationCut(5.0),
  fEcalJuraIsoCut(5.0),
  fHcalIsolationCut(5.0),
  fApplyConvFilter(kTRUE),
  fD0Cut(0.025),
  fElIdType(kIdUndef),
  fElIsoType(kIsoUndef),
  fElectrons(0),
  fConversions(0),
  fVertices(0)
{
  // 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)*5.0/15.0 && e->Pt() <= 25) ||
              (totalIso < 5.0 && e->Pt() > 25) ||
               totalIso <= 0)
            isocut = kTRUE;
        }
        break;
      case kNoIso:
        isocut = kTRUE;
        break;
      case kCustomIso:
      default:
        break;
    }

    if (!isocut) 
      continue;

    // apply conversion filter
    Bool_t isGoodConversion = kFALSE;
    if (fApplyConvFilter) {
      LoadBranch(fConversionBranchName);
      for (UInt_t ifc=0; ifc<fConversions->GetEntries(); ifc++) {
        
        Bool_t ConversionMatchFound = kFALSE;
        for (UInt_t d=0; d<fConversions->At(ifc)->NDaughters(); d++) {
          const Track *trk = dynamic_cast<const ChargedParticle*>
                       (fConversions->At(ifc)->Daughter(d))->Trk();
          if (e->GsfTrk() == trk) {
            ConversionMatchFound = kTRUE;
            break;
          }
        }

        // if match between the e-track and one of the conversion legs
        if (ConversionMatchFound == kTRUE){
          isGoodConversion =  (fConversions->At(ifc)->Prob() > 0.005) &&
                              (fConversions->At(ifc)->Lxy() > 0) &&
                              (fConversions->At(ifc)->Lz() > 0);

          if (isGoodConversion == kTRUE) {
            for (UInt_t d=0; d<fConversions->At(ifc)->NDaughters(); d++) {
              const Track *trk = dynamic_cast<const ChargedParticle*>
                           (fConversions->At(ifc)->Daughter(d))->Trk();
                      
              if (trk) {
                // These requirements are not used for the GSF track (i == 1)
                if (!(trk->NHits() > 8 && trk->Prob() > 0.005 && i == 0))
                  isGoodConversion = kFALSE;
              
                const StableData *sd = dynamic_cast<const StableData*>
                                  (fConversions->At(ifc)->DaughterDat(d));
                if (sd->NWrongHits() != 0)
                  isGoodConversion = kFALSE;
              
              } else {
                isGoodConversion = kFALSE;
              }
            }
          }
        }

        if (isGoodConversion == kTRUE) break;

      } // loop over all conversions 
      
    }
    if (isGoodConversion == kTRUE) continue;

    LoadBranch(fVertexName);
    // d0 cut
    double d0_real = 99999;
    for(uint i0 = 0; i0 < fVertices->GetEntries(); i0++) {
      double pD0 = e->GsfTrk()->D0Corrected(*fVertices->At(i0));
      if(TMath::Abs(pD0) < TMath::Abs(d0_real)) d0_real = TMath::Abs(pD0);
    }
    if(d0_real >= fD0Cut) continue;

    // add good electron
    GoodElectrons->Add(e);
  }

  // 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);
  ReqBranch(fConversionBranchName, fConversions);
  ReqBranch(fVertexName, fVertices);

  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.14
Committed:	Sun Apr 5 18:36:26 2009 UTC (16 years, 1 month ago) by loizides
Content type:	text/plain
Branch:	MAIN
Changes since 1.13:	+8 -6 lines
Log Message:	Cleanup
#	User	Rev	Content
1	loizides	1.14	// $Id: ElectronIDMod.cc,v 1.13 2009/04/03 17:19:24 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	ceballos	1.12	fConversionBranchName(Names::gkMvfConversionBrn),
15	loizides	1.5	fGoodElectronsName(ModNames::gkGoodElectronsName),
16	ceballos	1.12	fVertexName(string("PrimaryVertexesBeamSpot").c_str()),
17	loizides	1.1	fElectronIDType("Tight"),
18	ceballos	1.8	fElectronIsoType("TrackJuraSliding"),
19	loizides	1.1	fElectronPtMin(10),
20			fIDLikelihoodCut(0.9),
21			fTrackIsolationCut(5.0),
22			fCaloIsolationCut(5.0),
23	loizides	1.5	fEcalJuraIsoCut(5.0),
24			fHcalIsolationCut(5.0),
25	loizides	1.14	fApplyConvFilter(kTRUE),
26			fD0Cut(0.025),
27	loizides	1.5	fElIdType(kIdUndef),
28	ceballos	1.12	fElIsoType(kIsoUndef),
29	loizides	1.14	fElectrons(0),
30			fConversions(0),
31			fVertices(0)
32	loizides	1.1	{
33			// Constructor.
34			}
35
36			//--------------------------------------------------------------------------------------------------
37			void ElectronIDMod::Process()
38			{
39			// Process entries of the tree.
40
41	loizides	1.5	LoadBranch(fElectronBranchName);
42	loizides	1.1
43	loizides	1.6	ElectronOArr *GoodElectrons = new ElectronOArr;
44			GoodElectrons->SetName(fGoodElectronsName);
45	loizides	1.1
46	loizides	1.5	for (UInt_t i=0; i<fElectrons->GetEntries(); ++i) {
47			const Electron *e = fElectrons->At(i);
48	loizides	1.1
49	loizides	1.5	if (e->Pt() <= fElectronPtMin)
50			continue;
51	loizides	1.1
52	loizides	1.5	Bool_t idcut = kFALSE;
53			switch (fElIdType) {
54			case kTight:
55			idcut = e->PassTightID();
56			break;
57			case kLoose:
58			idcut = e->PassLooseID();
59			break;
60			case kLikelihood:
61			idcut = (e->IDLikelihood() > fIDLikelihoodCut);
62			break;
63	loizides	1.11	case kNoId:
64			idcut = kTRUE;
65			break;
66	loizides	1.5	case kCustomId:
67			default:
68			break;
69	loizides	1.1	}
70
71	loizides	1.5	if (!idcut)
72			continue;
73
74			Bool_t isocut = kFALSE;
75			switch (fElIsoType) {
76			case kTrackCalo:
77			isocut = (e->TrackIsolation() < fTrackIsolationCut) &&
78			(e->CaloIsolation() < fCaloIsolationCut);
79			break;
80			case kTrackJura:
81			isocut = (e->TrackIsolation() < fTrackIsolationCut) &&
82			(e->EcalJurassicIsolation() < fEcalJuraIsoCut) &&
83			(e->HcalIsolation() < fHcalIsolationCut);
84			break;
85			case kTrackJuraSliding:
86			{
87			Double_t totalIso = e->TrackIsolation() + e->EcalJurassicIsolation() - 1.5;
88	ceballos	1.12	if ((totalIso < (e->Pt()-10.0)*5.0/15.0 && e->Pt() <= 25) \|\|
89			(totalIso < 5.0 && e->Pt() > 25) \|\|
90	ceballos	1.7	totalIso <= 0)
91	loizides	1.5	isocut = kTRUE;
92			}
93			break;
94			case kNoIso:
95			isocut = kTRUE;
96			break;
97			case kCustomIso:
98			default:
99			break;
100	loizides	1.1	}
101
102	loizides	1.5	if (!isocut)
103			continue;
104
105	loizides	1.14	// apply conversion filter
106	ceballos	1.12	Bool_t isGoodConversion = kFALSE;
107	loizides	1.14	if (fApplyConvFilter) {
108	ceballos	1.12	LoadBranch(fConversionBranchName);
109			for (UInt_t ifc=0; ifc<fConversions->GetEntries(); ifc++) {
110
111			Bool_t ConversionMatchFound = kFALSE;
112			for (UInt_t d=0; d<fConversions->At(ifc)->NDaughters(); d++) {
113			const Track trk = dynamic_cast<const ChargedParticle>
114			(fConversions->At(ifc)->Daughter(d))->Trk();
115	ceballos	1.13	if (e->GsfTrk() == trk) {
116	ceballos	1.12	ConversionMatchFound = kTRUE;
117			break;
118			}
119			}
120
121			// if match between the e-track and one of the conversion legs
122			if (ConversionMatchFound == kTRUE){
123			isGoodConversion = (fConversions->At(ifc)->Prob() > 0.005) &&
124			(fConversions->At(ifc)->Lxy() > 0) &&
125			(fConversions->At(ifc)->Lz() > 0);
126
127			if (isGoodConversion == kTRUE) {
128			for (UInt_t d=0; d<fConversions->At(ifc)->NDaughters(); d++) {
129			const Track trk = dynamic_cast<const ChargedParticle>
130			(fConversions->At(ifc)->Daughter(d))->Trk();
131
132			if (trk) {
133			// These requirements are not used for the GSF track (i == 1)
134			if (!(trk->NHits() > 8 && trk->Prob() > 0.005 && i == 0))
135			isGoodConversion = kFALSE;
136
137			const StableData sd = dynamic_cast<const StableData>
138			(fConversions->At(ifc)->DaughterDat(d));
139			if (sd->NWrongHits() != 0)
140			isGoodConversion = kFALSE;
141
142			} else {
143			isGoodConversion = kFALSE;
144			}
145			}
146			}
147			}
148
149			if (isGoodConversion == kTRUE) break;
150
151			} // loop over all conversions
152
153			}
154			if (isGoodConversion == kTRUE) continue;
155
156			LoadBranch(fVertexName);
157			// d0 cut
158			double d0_real = 99999;
159			for(uint i0 = 0; i0 < fVertices->GetEntries(); i0++) {
160			double pD0 = e->GsfTrk()->D0Corrected(*fVertices->At(i0));
161			if(TMath::Abs(pD0) < TMath::Abs(d0_real)) d0_real = TMath::Abs(pD0);
162			}
163			if(d0_real >= fD0Cut) continue;
164
165	loizides	1.5	// add good electron
166	ceballos	1.12	GoodElectrons->Add(e);
167	loizides	1.5	}
168	loizides	1.1
169	loizides	1.9	// sort according to pt
170			GoodElectrons->Sort();
171
172	loizides	1.5	// add to event for other modules to use
173	loizides	1.6	AddObjThisEvt(GoodElectrons);
174	loizides	1.1	}
175
176			//--------------------------------------------------------------------------------------------------
177			void ElectronIDMod::SlaveBegin()
178			{
179			// Run startup code on the computer (slave) doing the actual analysis. Here,
180	loizides	1.5	// we just request the electron collection branch.
181	loizides	1.1
182	loizides	1.5	ReqBranch(fElectronBranchName, fElectrons);
183	ceballos	1.12	ReqBranch(fConversionBranchName, fConversions);
184			ReqBranch(fVertexName, fVertices);
185	loizides	1.1
186	loizides	1.5	if (fElectronIDType.CompareTo("Tight") == 0)
187			fElIdType = kTight;
188			else if (fElectronIDType.CompareTo("Loose") == 0)
189			fElIdType = kLoose;
190			else if (fElectronIDType.CompareTo("Likelihood") == 0)
191			fElIdType = kLikelihood;
192	loizides	1.10	else if (fElectronIDType.CompareTo("NoId") == 0)
193			fElIdType = kNoId;
194	loizides	1.5	else if (fElectronIDType.CompareTo("Custom") == 0) {
195			fElIdType = kCustomId;
196			SendError(kWarning, "SlaveBegin",
197			"Custom electron identification is not yet implemented.");
198			} else {
199			SendError(kAbortAnalysis, "SlaveBegin",
200			"The specified electron identification %s is not defined.",
201			fElectronIDType.Data());
202			return;
203			}
204
205			if (fElectronIsoType.CompareTo("TrackCalo") == 0 )
206			fElIsoType = kTrackCalo;
207			else if (fElectronIsoType.CompareTo("TrackJura") == 0)
208			fElIsoType = kTrackJura;
209			else if(fElectronIsoType.CompareTo("TrackJuraSliding") == 0)
210			fElIsoType = kTrackJuraSliding;
211			else if (fElectronIsoType.CompareTo("NoIso") == 0 )
212			fElIsoType = kNoIso;
213			else if (fElectronIsoType.CompareTo("Custom") == 0 ) {
214			fElIsoType = kCustomIso;
215			SendError(kWarning, "SlaveBegin",
216			"Custom electron isolation is not yet implemented.");
217			} else {
218			SendError(kAbortAnalysis, "SlaveBegin",
219			"The specified electron isolation %s is not defined.",
220			fElectronIsoType.Data());
221			return;
222			}
223	loizides	1.1	}