Mods/src/JetCleaningMod.cc

// $Id: JetCleaningMod.cc,v 1.6 2008/12/01 08:15:53 ceballos Exp $

#include "MitPhysics/Mods/interface/JetCleaningMod.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),        
  fCleanPhotonsName(ModNames::gkCleanPhotonsName),        
  fGoodJetsName(ModNames::gkGoodJetsName),        
  fCleanJetsName(ModNames::gkCleanJetsName),
  fMinDeltaRToElectron(0.3),
  fMinDeltaRToPhoton(0.3)
{
  // Constructor.
}

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

  // get input collections
  ElectronOArr *CleanElectrons = GetObjThisEvt<ElectronOArr>(fCleanElectronsName);
  PhotonOArr *CleanPhotons = GetObjThisEvt<PhotonOArr>(fCleanPhotonsName);
  JetOArr *GoodJets = GetObjThisEvt<JetOArr>(fGoodJetsName);

  // 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);        

    Bool_t isElectronOverlap = kFALSE;
    Bool_t isPhotonOverlap = kFALSE;

    //Check for overlap with an electron
    if (CleanElectrons) {
      for (UInt_t j=0; j<CleanElectrons->Entries(); 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 a photon
    if (CleanPhotons) {
      for (UInt_t j=0; j<CleanPhotons->Entries(); j++) {
        Double_t deltaR = MathUtils::DeltaR(CleanPhotons->At(j)->Mom(),jet->Mom());  
        if (deltaR < fMinDeltaRToPhoton) {
          isPhotonOverlap = kTRUE;
          break;                 
        }      
      }
    }

    if (isPhotonOverlap) continue;

    CleanJets->Add(jet);     
  }

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

  // add to event for other modules to use
  AddObjThisEvt(CleanJets);
}
Revision:	1.7
Committed:	Wed Dec 10 11:44:33 2008 UTC (16 years, 4 months ago) by loizides
Content type:	text/plain
Branch:	MAIN
Changes since 1.6:	+4 -1 lines
Log Message:	Added sort.
#	User	Rev	Content
1	loizides	1.7	// $Id: JetCleaningMod.cc,v 1.6 2008/12/01 08:15:53 ceballos Exp $
2	loizides	1.1
3			#include "MitPhysics/Mods/interface/JetCleaningMod.h"
4			#include "MitCommon/MathTools/interface/MathUtils.h"
5	loizides	1.3	#include "MitPhysics/Init/interface/ModNames.h"
6	loizides	1.1
7			using namespace mithep;
8
9			ClassImp(mithep::JetCleaningMod)
10
11			//--------------------------------------------------------------------------------------------------
12	loizides	1.4	JetCleaningMod::JetCleaningMod(const char name, const char title) :
13	loizides	1.1	BaseMod(name,title),
14	loizides	1.3	fCleanElectronsName(ModNames::gkCleanElectronsName),
15	sixie	1.5	fCleanPhotonsName(ModNames::gkCleanPhotonsName),
16	loizides	1.3	fGoodJetsName(ModNames::gkGoodJetsName),
17	sixie	1.5	fCleanJetsName(ModNames::gkCleanJetsName),
18			fMinDeltaRToElectron(0.3),
19			fMinDeltaRToPhoton(0.3)
20	loizides	1.1	{
21			// Constructor.
22			}
23
24			//--------------------------------------------------------------------------------------------------
25	loizides	1.4	void JetCleaningMod::Process()
26	loizides	1.1	{
27	loizides	1.4	// Process entries of the tree.
28	loizides	1.1
29	loizides	1.4	// get input collections
30			ElectronOArr *CleanElectrons = GetObjThisEvt<ElectronOArr>(fCleanElectronsName);
31	sixie	1.5	PhotonOArr *CleanPhotons = GetObjThisEvt<PhotonOArr>(fCleanPhotonsName);
32	loizides	1.4	JetOArr *GoodJets = GetObjThisEvt<JetOArr>(fGoodJetsName);
33	loizides	1.1
34	loizides	1.4	// create output collection
35			JetOArr *CleanJets = new JetOArr;
36			CleanJets->SetName(fCleanJetsName);
37	loizides	1.1
38	sixie	1.5	// Remove any jet that overlaps in eta, phi with an isolated electron.
39	loizides	1.1	for (UInt_t i=0; i<GoodJets->GetEntries(); ++i) {
40	loizides	1.4	const Jet *jet = GoodJets->At(i);
41
42	ceballos	1.6	Bool_t isElectronOverlap = kFALSE;
43			Bool_t isPhotonOverlap = kFALSE;
44	sixie	1.5
45	loizides	1.1	//Check for overlap with an electron
46	sixie	1.5	if (CleanElectrons) {
47			for (UInt_t j=0; j<CleanElectrons->Entries(); j++) {
48			Double_t deltaR = MathUtils::DeltaR(CleanElectrons->At(j)->Mom(),jet->Mom());
49			if (deltaR < fMinDeltaRToElectron) {
50			isElectronOverlap = kTRUE;
51			break;
52			}
53			}
54			}
55
56	ceballos	1.6	if (isElectronOverlap) continue;
57
58	sixie	1.5	//Check for overlap with a photon
59			if (CleanPhotons) {
60			for (UInt_t j=0; j<CleanPhotons->Entries(); j++) {
61			Double_t deltaR = MathUtils::DeltaR(CleanPhotons->At(j)->Mom(),jet->Mom());
62			if (deltaR < fMinDeltaRToPhoton) {
63			isPhotonOverlap = kTRUE;
64			break;
65			}
66			}
67	loizides	1.1	}
68
69	ceballos	1.6	if (isPhotonOverlap) continue;
70	loizides	1.1
71	loizides	1.4	CleanJets->Add(jet);
72			}
73	loizides	1.1
74	loizides	1.7	// sort according to pt
75			CleanJets->Sort();
76
77	loizides	1.4	// add to event for other modules to use
78			AddObjThisEvt(CleanJets);
79	loizides	1.1	}