Mods/src/ElectronIDMod.cc

// $Id: ElectronIDMod.cc,v 1.16 2009/04/06 11:00:22 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;

    if (fApplyD0Cut) {
      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);

  if (fApplyConvFilter)
    ReqBranch(fConversionBranchName, fConversions);

  if (fApplyD0Cut)
    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.17
Committed:	Tue Apr 7 15:37:09 2009 UTC (16 years, 1 month ago) by loizides
Content type:	text/plain
Branch:	MAIN
CVS Tags:	Mit_009
Changes since 1.16:	+3 -1 lines
Log Message:	Cleanup
#	User	Rev	Content
1	loizides	1.17	// $Id: ElectronIDMod.cc,v 1.16 2009/04/06 11:00:22 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	ceballos	1.15	if (fApplyD0Cut) {
157			LoadBranch(fVertexName);
158			// d0 cut
159			double d0_real = 99999;
160			for(uint i0 = 0; i0 < fVertices->GetEntries(); i0++) {
161			double pD0 = e->GsfTrk()->D0Corrected(*fVertices->At(i0));
162			if(TMath::Abs(pD0) < TMath::Abs(d0_real)) d0_real = TMath::Abs(pD0);
163			}
164			if(d0_real >= fD0Cut) continue;
165	ceballos	1.12	}
166
167	loizides	1.5	// add good electron
168	ceballos	1.12	GoodElectrons->Add(e);
169	loizides	1.5	}
170	loizides	1.1
171	loizides	1.9	// sort according to pt
172			GoodElectrons->Sort();
173
174	loizides	1.5	// add to event for other modules to use
175	loizides	1.6	AddObjThisEvt(GoodElectrons);
176	loizides	1.1	}
177
178			//--------------------------------------------------------------------------------------------------
179			void ElectronIDMod::SlaveBegin()
180			{
181			// Run startup code on the computer (slave) doing the actual analysis. Here,
182	loizides	1.5	// we just request the electron collection branch.
183	loizides	1.1
184	loizides	1.5	ReqBranch(fElectronBranchName, fElectrons);
185	loizides	1.17
186	ceballos	1.16	if (fApplyConvFilter)
187	ceballos	1.15	ReqBranch(fConversionBranchName, fConversions);
188	loizides	1.17
189	ceballos	1.15	if (fApplyD0Cut)
190			ReqBranch(fVertexName, fVertices);
191	loizides	1.1
192	loizides	1.5	if (fElectronIDType.CompareTo("Tight") == 0)
193			fElIdType = kTight;
194			else if (fElectronIDType.CompareTo("Loose") == 0)
195			fElIdType = kLoose;
196			else if (fElectronIDType.CompareTo("Likelihood") == 0)
197			fElIdType = kLikelihood;
198	loizides	1.10	else if (fElectronIDType.CompareTo("NoId") == 0)
199			fElIdType = kNoId;
200	loizides	1.5	else if (fElectronIDType.CompareTo("Custom") == 0) {
201			fElIdType = kCustomId;
202			SendError(kWarning, "SlaveBegin",
203			"Custom electron identification is not yet implemented.");
204			} else {
205			SendError(kAbortAnalysis, "SlaveBegin",
206			"The specified electron identification %s is not defined.",
207			fElectronIDType.Data());
208			return;
209			}
210
211			if (fElectronIsoType.CompareTo("TrackCalo") == 0 )
212			fElIsoType = kTrackCalo;
213			else if (fElectronIsoType.CompareTo("TrackJura") == 0)
214			fElIsoType = kTrackJura;
215			else if(fElectronIsoType.CompareTo("TrackJuraSliding") == 0)
216			fElIsoType = kTrackJuraSliding;
217			else if (fElectronIsoType.CompareTo("NoIso") == 0 )
218			fElIsoType = kNoIso;
219			else if (fElectronIsoType.CompareTo("Custom") == 0 ) {
220			fElIsoType = kCustomIso;
221			SendError(kWarning, "SlaveBegin",
222			"Custom electron isolation is not yet implemented.");
223			} else {
224			SendError(kAbortAnalysis, "SlaveBegin",
225			"The specified electron isolation %s is not defined.",
226			fElectronIsoType.Data());
227			return;
228			}
229	loizides	1.1	}