Mods/src/JetCleaningMod.cc

// $Id: JetCleaningMod.cc,v 1.12 2009/06/01 17:31:38 ceballos 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)->Mom(),jet->Mom());  
        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.13
Committed:	Mon Jun 15 15:00:21 2009 UTC (15 years, 10 months ago) by loizides
Content type:	text/plain
Branch:	MAIN
CVS Tags:	Mit_011a, Mit_011, Mit_010a, Mit_010, Mit_009c, Mit_009b
Changes since 1.12:	+8 -3 lines
Log Message:	Added proper fwd defs plus split up complilation of MitAna/DataTree LinkDefs.
#	User	Rev	Content
1	loizides	1.13	// $Id: JetCleaningMod.cc,v 1.12 2009/06/01 17:31:38 ceballos 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.5	Double_t deltaR = MathUtils::DeltaR(CleanElectrons->At(j)->Mom(),jet->Mom());
68			if (deltaR < fMinDeltaRToElectron) {
69			isElectronOverlap = kTRUE;
70			break;
71			}
72			}
73			}
74
75	ceballos	1.6	if (isElectronOverlap) continue;
76
77	ceballos	1.10	// check for overlap with an Muon
78			Bool_t isMuonOverlap = kFALSE;
79			if (CleanMuons) {
80			UInt_t n = CleanMuons->GetEntries();
81			for (UInt_t j=0; j<n; ++j) {
82			Double_t deltaR = MathUtils::DeltaR(CleanMuons->At(j)->Mom(),jet->Mom());
83			if (deltaR < fMinDeltaRToMuon) {
84			isMuonOverlap = kTRUE;
85			break;
86			}
87			}
88			}
89
90			if (isMuonOverlap) continue;
91
92	loizides	1.8	// check for overlap with a photon
93			Bool_t isPhotonOverlap = kFALSE;
94	sixie	1.5	if (CleanPhotons) {
95	loizides	1.8	UInt_t n = CleanPhotons->GetEntries();
96			for (UInt_t j=0; j<n; ++j) {
97	sixie	1.5	Double_t deltaR = MathUtils::DeltaR(CleanPhotons->At(j)->Mom(),jet->Mom());
98			if (deltaR < fMinDeltaRToPhoton) {
99			isPhotonOverlap = kTRUE;
100			break;
101			}
102			}
103	loizides	1.1	}
104
105	ceballos	1.6	if (isPhotonOverlap) continue;
106	loizides	1.1
107	ceballos	1.11	// check for overlap with a tau
108			Bool_t isTauOverlap = kFALSE;
109			if (fApplyTauRemoval && CleanTaus) {
110			UInt_t n = CleanTaus->GetEntries();
111			for (UInt_t j=0; j<n; ++j) {
112			Double_t deltaR = MathUtils::DeltaR(CleanTaus->At(j)->Mom(),jet->Mom());
113			if (deltaR < fMinDeltaRToTau) {
114			isTauOverlap = kTRUE;
115			break;
116			}
117			}
118			}
119
120			if (isTauOverlap) continue;
121
122	ceballos	1.12	CleanJets->Add(jet);
123	loizides	1.4	}
124	loizides	1.1
125	loizides	1.7	// sort according to pt
126			CleanJets->Sort();
127
128	loizides	1.4	// add to event for other modules to use
129			AddObjThisEvt(CleanJets);
130	loizides	1.1	}