Mods/src/JetCleaningMod.cc

// $Id: JetCleaningMod.cc,v 1.13 2009/06/15 15:00:21 loizides Exp $

#include "MitPhysics/Mods/interface/JetCleaningMod.h"
#include "MitAna/DataTree/interface/JetCol.h"
#include "MitAna/DataTree/interface/PhotonCol.h"
#include "MitAna/DataTree/interface/MuonCol.h"
#include "MitAna/DataTree/interface/ElectronCol.h"
#include "MitAna/DataTree/interface/TauCol.h"
#include "MitCommon/MathTools/interface/MathUtils.h"
#include "MitPhysics/Init/interface/ModNames.h"

using namespace mithep;

ClassImp(mithep::JetCleaningMod)

//--------------------------------------------------------------------------------------------------
JetCleaningMod::JetCleaningMod(const char *name, const char *title) : 
  BaseMod(name,title),
  fCleanElectronsName(ModNames::gkCleanElectronsName),        
  fCleanMuonsName(ModNames::gkCleanMuonsName),        
  fCleanPhotonsName(ModNames::gkCleanPhotonsName),        
  fCleanTausName(ModNames::gkCleanTausName),        
  fGoodJetsName(ModNames::gkGoodJetsName),        
  fCleanJetsName(ModNames::gkCleanJetsName),
  fMinDeltaRToElectron(0.3),
  fMinDeltaRToMuon(0.3),
  fMinDeltaRToPhoton(0.3),
  fMinDeltaRToTau(0.3),
  fApplyTauRemoval(kFALSE)
{
  // Constructor.
}

//--------------------------------------------------------------------------------------------------
void JetCleaningMod::Process()
{
  // Process entries of the tree.

  // get input collections
  const JetCol  *GoodJets       = GetObjThisEvt<JetCol>(fGoodJetsName);
  const ElectronCol *CleanElectrons = 0;
  if (!fCleanElectronsName.IsNull())
    CleanElectrons = GetObjThisEvt<ElectronCol>(fCleanElectronsName);
  const MuonCol *CleanMuons = 0;
  if (!fCleanMuonsName.IsNull())
    CleanMuons = GetObjThisEvt<MuonCol>(fCleanMuonsName);
  const PhotonCol   *CleanPhotons   = 0;
  if (!fCleanPhotonsName.IsNull())
    CleanPhotons    = GetObjThisEvt<PhotonCol>(fCleanPhotonsName);
  const TauCol   *CleanTaus   = 0;
  if (fApplyTauRemoval && !fCleanTausName.IsNull())
    CleanTaus    = GetObjThisEvt<TauCol>(fCleanTausName);

  // create output collection
  JetOArr *CleanJets = new JetOArr;
  CleanJets->SetName(fCleanJetsName);

  // remove any jet that overlaps in eta, phi with an isolated electron.    
  for (UInt_t i=0; i<GoodJets->GetEntries(); ++i) {
    const Jet *jet = GoodJets->At(i);        

    // check for overlap with an Electron
    Bool_t isElectronOverlap = kFALSE;
    if (CleanElectrons) {
      UInt_t n = CleanElectrons->GetEntries();
      for (UInt_t j=0; j<n; ++j) {
        Double_t deltaR = MathUtils::DeltaR(CleanElectrons->At(j)->SCluster()->Eta(), 
                                            CleanElectrons->At(j)->SCluster()->Phi(),
                                            jet->Eta(), jet->Phi());  
        if (deltaR < fMinDeltaRToElectron) {
          isElectronOverlap = kTRUE;
          break;                 
        }      
      }
    }

    if (isElectronOverlap) continue;

    // check for overlap with an Muon
    Bool_t isMuonOverlap = kFALSE;
    if (CleanMuons) {
      UInt_t n = CleanMuons->GetEntries();
      for (UInt_t j=0; j<n; ++j) {
        Double_t deltaR = MathUtils::DeltaR(CleanMuons->At(j)->Mom(),jet->Mom());  
        if (deltaR < fMinDeltaRToMuon) {
          isMuonOverlap = kTRUE;
          break;                 
        }      
      }
    }

    if (isMuonOverlap) continue;

    // check for overlap with a photon
    Bool_t isPhotonOverlap = kFALSE;
    if (CleanPhotons) {
      UInt_t n = CleanPhotons->GetEntries();
      for (UInt_t j=0; j<n; ++j) {
        Double_t deltaR = MathUtils::DeltaR(CleanPhotons->At(j)->Mom(),jet->Mom());  
        if (deltaR < fMinDeltaRToPhoton) {
          isPhotonOverlap = kTRUE;
          break;                 
        }      
      }
    }

    if (isPhotonOverlap) continue;

    // check for overlap with a tau
    Bool_t isTauOverlap = kFALSE;
    if (fApplyTauRemoval && CleanTaus) {
      UInt_t n = CleanTaus->GetEntries();
      for (UInt_t j=0; j<n; ++j) {
        Double_t deltaR = MathUtils::DeltaR(CleanTaus->At(j)->Mom(),jet->Mom());  
        if (deltaR < fMinDeltaRToTau) {
          isTauOverlap = kTRUE;
          break;                 
        }      
      }
    }

    if (isTauOverlap) continue;

    CleanJets->Add(jet);
  }

  // sort according to pt
  CleanJets->Sort();

  // add to event for other modules to use
  AddObjThisEvt(CleanJets);
}
Revision:	1.14
Committed:	Mon Nov 2 12:15:00 2009 UTC (15 years, 6 months ago) by sixie
Content type:	text/plain
Branch:	MAIN
Changes since 1.13:	+4 -2 lines
Log Message:	do jet cleaning against electrons using the electron supercluster direction instead of electron direction
#	User	Rev	Content
1	sixie	1.14	// $Id: JetCleaningMod.cc,v 1.13 2009/06/15 15:00:21 loizides Exp $
2	loizides	1.1
3			#include "MitPhysics/Mods/interface/JetCleaningMod.h"
4	loizides	1.13	#include "MitAna/DataTree/interface/JetCol.h"
5			#include "MitAna/DataTree/interface/PhotonCol.h"
6			#include "MitAna/DataTree/interface/MuonCol.h"
7			#include "MitAna/DataTree/interface/ElectronCol.h"
8			#include "MitAna/DataTree/interface/TauCol.h"
9	loizides	1.1	#include "MitCommon/MathTools/interface/MathUtils.h"
10	loizides	1.3	#include "MitPhysics/Init/interface/ModNames.h"
11	loizides	1.1
12			using namespace mithep;
13
14			ClassImp(mithep::JetCleaningMod)
15
16			//--------------------------------------------------------------------------------------------------
17	loizides	1.4	JetCleaningMod::JetCleaningMod(const char name, const char title) :
18	loizides	1.1	BaseMod(name,title),
19	loizides	1.3	fCleanElectronsName(ModNames::gkCleanElectronsName),
20	ceballos	1.10	fCleanMuonsName(ModNames::gkCleanMuonsName),
21	sixie	1.5	fCleanPhotonsName(ModNames::gkCleanPhotonsName),
22	ceballos	1.11	fCleanTausName(ModNames::gkCleanTausName),
23	loizides	1.3	fGoodJetsName(ModNames::gkGoodJetsName),
24	sixie	1.5	fCleanJetsName(ModNames::gkCleanJetsName),
25			fMinDeltaRToElectron(0.3),
26	ceballos	1.10	fMinDeltaRToMuon(0.3),
27	ceballos	1.11	fMinDeltaRToPhoton(0.3),
28			fMinDeltaRToTau(0.3),
29			fApplyTauRemoval(kFALSE)
30	loizides	1.1	{
31			// Constructor.
32			}
33
34			//--------------------------------------------------------------------------------------------------
35	loizides	1.4	void JetCleaningMod::Process()
36	loizides	1.1	{
37	loizides	1.4	// Process entries of the tree.
38	loizides	1.1
39	loizides	1.4	// get input collections
40	bendavid	1.9	const JetCol *GoodJets = GetObjThisEvt<JetCol>(fGoodJetsName);
41	loizides	1.8	const ElectronCol *CleanElectrons = 0;
42			if (!fCleanElectronsName.IsNull())
43			CleanElectrons = GetObjThisEvt<ElectronCol>(fCleanElectronsName);
44	ceballos	1.10	const MuonCol *CleanMuons = 0;
45			if (!fCleanMuonsName.IsNull())
46			CleanMuons = GetObjThisEvt<MuonCol>(fCleanMuonsName);
47	loizides	1.8	const PhotonCol *CleanPhotons = 0;
48			if (!fCleanPhotonsName.IsNull())
49	loizides	1.13	CleanPhotons = GetObjThisEvt<PhotonCol>(fCleanPhotonsName);
50	ceballos	1.11	const TauCol *CleanTaus = 0;
51			if (fApplyTauRemoval && !fCleanTausName.IsNull())
52	loizides	1.13	CleanTaus = GetObjThisEvt<TauCol>(fCleanTausName);
53	loizides	1.1
54	loizides	1.4	// create output collection
55			JetOArr *CleanJets = new JetOArr;
56			CleanJets->SetName(fCleanJetsName);
57	loizides	1.1
58	loizides	1.8	// remove any jet that overlaps in eta, phi with an isolated electron.
59	loizides	1.1	for (UInt_t i=0; i<GoodJets->GetEntries(); ++i) {
60	loizides	1.4	const Jet *jet = GoodJets->At(i);
61
62	ceballos	1.10	// check for overlap with an Electron
63	ceballos	1.6	Bool_t isElectronOverlap = kFALSE;
64	sixie	1.5	if (CleanElectrons) {
65	loizides	1.8	UInt_t n = CleanElectrons->GetEntries();
66			for (UInt_t j=0; j<n; ++j) {
67	sixie	1.14	Double_t deltaR = MathUtils::DeltaR(CleanElectrons->At(j)->SCluster()->Eta(),
68			CleanElectrons->At(j)->SCluster()->Phi(),
69			jet->Eta(), jet->Phi());
70	sixie	1.5	if (deltaR < fMinDeltaRToElectron) {
71			isElectronOverlap = kTRUE;
72			break;
73			}
74			}
75			}
76
77	ceballos	1.6	if (isElectronOverlap) continue;
78
79	ceballos	1.10	// check for overlap with an Muon
80			Bool_t isMuonOverlap = kFALSE;
81			if (CleanMuons) {
82			UInt_t n = CleanMuons->GetEntries();
83			for (UInt_t j=0; j<n; ++j) {
84			Double_t deltaR = MathUtils::DeltaR(CleanMuons->At(j)->Mom(),jet->Mom());
85			if (deltaR < fMinDeltaRToMuon) {
86			isMuonOverlap = kTRUE;
87			break;
88			}
89			}
90			}
91
92			if (isMuonOverlap) continue;
93
94	loizides	1.8	// check for overlap with a photon
95			Bool_t isPhotonOverlap = kFALSE;
96	sixie	1.5	if (CleanPhotons) {
97	loizides	1.8	UInt_t n = CleanPhotons->GetEntries();
98			for (UInt_t j=0; j<n; ++j) {
99	sixie	1.5	Double_t deltaR = MathUtils::DeltaR(CleanPhotons->At(j)->Mom(),jet->Mom());
100			if (deltaR < fMinDeltaRToPhoton) {
101			isPhotonOverlap = kTRUE;
102			break;
103			}
104			}
105	loizides	1.1	}
106
107	ceballos	1.6	if (isPhotonOverlap) continue;
108	loizides	1.1
109	ceballos	1.11	// check for overlap with a tau
110			Bool_t isTauOverlap = kFALSE;
111			if (fApplyTauRemoval && CleanTaus) {
112			UInt_t n = CleanTaus->GetEntries();
113			for (UInt_t j=0; j<n; ++j) {
114			Double_t deltaR = MathUtils::DeltaR(CleanTaus->At(j)->Mom(),jet->Mom());
115			if (deltaR < fMinDeltaRToTau) {
116			isTauOverlap = kTRUE;
117			break;
118			}
119			}
120			}
121
122			if (isTauOverlap) continue;
123
124	ceballos	1.12	CleanJets->Add(jet);
125	loizides	1.4	}
126	loizides	1.1
127	loizides	1.7	// sort according to pt
128			CleanJets->Sort();
129
130	loizides	1.4	// add to event for other modules to use
131			AddObjThisEvt(CleanJets);
132	loizides	1.1	}