Mods/src/ElectronIDMod.cc

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