HbbAnalysis/interface/Jet.hh

#ifndef HbbAnalysis_Jet_hh
#define HbbAnalysis_Jet_hh

#include <vector>
#include <string>

#include "TMath.h"

#include "UserCode/HbbAnalysis/interface/Objects.hh"

namespace HbbAnalysis {

  class Jet {

  public:


    /** Constructors */

    Jet(){
      //Clear();
    };

    ~Jet(){};

    Jet(const HbbAnalysis::GenVars & aGen,
        const HbbAnalysis::GenVars & aGenJet,
        const HbbAnalysis::BaseVars & aReco,
        const HbbAnalysis::JetVars & aAll,
        const HbbAnalysis::CaloJetVars & aCalo,
        const HbbAnalysis::JetBtagVars & aBtag,
        const HbbAnalysis::JetIDVars & aId
             ){
      Clear();
      jetType_ = 0;//calo jet
      genVars(aGen);
      genJetVars(aGenJet);
      recoVars(aReco);
      commonVars(aAll);
      caloVars(aCalo);
      btagVars(aBtag);
      idVars(aId);
    };

    Jet(const HbbAnalysis::GenVars & aGen,
        const HbbAnalysis::GenVars & aGenJet,
        const HbbAnalysis::BaseVars & aReco,
        const HbbAnalysis::JetVars & aAll,
        const HbbAnalysis::PFJetVars & aPF,
        const HbbAnalysis::JetBtagVars & aBtag
             ){
      Clear();
      jetType_ = 1;//PF jet
      genVars(aGen);
      genJetVars(aGenJet);
      recoVars(aReco);
      commonVars(aAll);
      pfVars(aPF);
      btagVars(aBtag);
    };

    inline const unsigned short jetType() const {
      return jetType_;
    };

    inline const HbbAnalysis::GenVars & genVars() const {
      return gen_;
    };

    inline const HbbAnalysis::GenVars & genJetVars() const {
      return genJet_;
    };

    inline const HbbAnalysis::BaseVars  & recoVars() const {
      return reco_;
    };

    inline const HbbAnalysis::JetVars  & commonVars() const {
      return common_;
    };

    inline const HbbAnalysis::CaloJetVars  & caloVars() const {
      return calo_;
    };

    inline const HbbAnalysis::PFJetVars  & pfVars() const {
      return pf_;
    };

    inline const HbbAnalysis::JetBtagVars  & btagVars() const {
      return btag_;
    };

    inline const HbbAnalysis::JetIDVars  & idVars() const {
      return id_;
    };

    inline void jetType(const unsigned short aType) {
      jetType_ = aType;
    };

    inline void genVars(const HbbAnalysis::GenVars & aGen) {
      gen_ = aGen;
    };

    inline void genJetVars(const HbbAnalysis::GenVars & aGenJet) {
      genJet_ = aGenJet;
    };

    inline void recoVars(const HbbAnalysis::BaseVars & aReco) {
      reco_ = aReco;
    };

    inline void commonVars(const HbbAnalysis::JetVars & aJet) {
      common_ = aJet;
    };

    inline void caloVars(const HbbAnalysis::CaloJetVars & aCalo) {
      calo_ = aCalo;
    };
    
    inline void pfVars(const HbbAnalysis::PFJetVars & aPF){
      pf_ = aPF;
    };

    inline void btagVars(const HbbAnalysis::JetBtagVars & aBtag){
      btag_ = aBtag;
    };

    inline void idVars(const HbbAnalysis::JetIDVars & aId){
      id_ = aId;
    };

    inline void Clear(){
      gen_.valid = false;
      gen_.E = 0;
      gen_.pT = 0;
      gen_.eta = 0;
      gen_.phi = 0;
      gen_.charge = 0;
      gen_.pdgId = 0;
      gen_.status = 0;
      gen_.mass = 0;
      gen_.vx = 0;
      gen_.vy = 0;
      gen_.vz = 0;

      genJet_.valid = false;
      genJet_.E = 0;
      genJet_.pT = 0;
      genJet_.eta = 0;
      genJet_.phi = 0;
      genJet_.charge = 0;
      genJet_.pdgId = 0;
      genJet_.status = 0;
      genJet_.mass = 0;
      genJet_.vx = 0;
      genJet_.vy = 0;
      genJet_.vz = 0;
 
      reco_.E = 0;
      reco_.pT = 0;
      reco_.eta = 0;
      reco_.phi = 0;
      reco_.charge = 0;
      reco_.vx = 0;
      reco_.vy = 0;
      reco_.vz = 0;

      common_.flavour = 0;
      common_.partonFlavour = 0;
      common_.nAssociatedTracks = 0;
      common_.rawpT = 0;
      common_.etaMean = 0;
      common_.phiMean = 0;
      common_.etaEtaMoment = 0;
      common_.phiPhiMoment = 0;
      common_.etaPhiMoment = 0;
      //common_.rawEta = 0;
      //common_.rawPhi = 0;

      calo_.maxEInEmTowers = 0;
      calo_.maxEInHadTowers = 0;
      calo_.energyFractionHadronic = 0;
      calo_.emEnergyFraction = 0;
      calo_.hadEnergyInHB = 0;
      calo_.hadEnergyInHO = 0;
      calo_.hadEnergyInHE = 0;
      calo_.hadEnergyInHF = 0;
      calo_.emEnergyInEB = 0;
      calo_.emEnergyInEE = 0;
      calo_.emEnergyInHF = 0;
      calo_.towersArea = 0;
      calo_.n90 = 0;
      calo_.n60 = 0;

      pf_.chargedHadronEnergy = 0;
      pf_.chargedHadronEnergyFraction = 0;
      pf_.neutralHadronEnergy = 0;
      pf_.neutralHadronEnergyFraction = 0;
      pf_.chargedEmEnergy = 0;
      pf_.chargedEmEnergyFraction = 0;
      pf_.chargedMuEnergy = 0;
      pf_.chargedMuEnergyFraction = 0;
      pf_.neutralEmEnergy = 0;
      pf_.neutralEmEnergyFraction = 0;
      pf_.chargedMultiplicity = 0;
      pf_.neutralMultiplicity = 0;
      pf_.muonMultiplicity = 0;

      btag_.cSV = 0;
      btag_.cSVMVA = 0;
      btag_.iPMVA = 0;
      btag_.bProba = 0;
      btag_.probability = 0;
      btag_.sSV = 0;
      btag_.softElectronByPt = 0;
      btag_.softElectronByIP3d = 0;
      btag_.softMuon = 0;
      btag_.softMuonByPt = 0;
      btag_.softMuonByIP3d = 0;
      btag_.tCHE = 0;
      btag_.tCHP = 0;

      id_.fHPD = 0; 
      id_.fRBX = 0;
      id_.n90Hits = 0;


    };

    template <class T>
    const double deltaRwithLepton(const std::vector<T> & aCol) const;

  private:

    unsigned short jetType_;
    HbbAnalysis::GenVars gen_;
    HbbAnalysis::GenVars genJet_;
    HbbAnalysis::BaseVars reco_;
    HbbAnalysis::JetVars common_;
    HbbAnalysis::CaloJetVars calo_;
    HbbAnalysis::PFJetVars pf_;
    HbbAnalysis::JetBtagVars btag_;
    HbbAnalysis::JetIDVars id_;

  };

  inline bool operator < (const Jet & one, const Jet & two) 
  {
    return one.btagVars().tCHP > two.btagVars().tCHP;
  }
  

  template <class T>
  const double Jet::deltaRwithLepton(const std::vector<T> & aCol) const
  {

    double lMin = 1000;

    typename std::vector< T >::const_iterator iLepton;
  
    for (iLepton= aCol.begin(); 
         iLepton != aCol.end(); 
         iLepton++) 
      {
        double lDeltaEta = recoVars().eta-(*iLepton).recoVars().eta;
        double lDeltaPhi = recoVars().phi-(*iLepton).recoVars().phi;
        if (lDeltaPhi<0) lDeltaPhi+= 2*TMath::Pi();

        double lDeltaR = sqrt(lDeltaEta*lDeltaEta+lDeltaPhi*lDeltaPhi);

        if (lDeltaR<lMin){ 
          lMin=lDeltaR;
        }
      }

    if (lMin > 100) return -1;

    return lMin;

  }

}//namespace
#endif
Revision:	1.5
Committed:	Tue Mar 2 16:03:34 2010 UTC (15 years, 2 months ago) by amagnan
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HbbAnaFor35X, v00-04-02, v00-04-01, v00-04-00
Changes since 1.4:	+5 -0 lines
Log Message:	add E-weigthed eta-phi for jets
#	User	Rev	Content
1	amagnan	1.1	#ifndef HbbAnalysis_Jet_hh
2			#define HbbAnalysis_Jet_hh
3
4			#include <vector>
5			#include <string>
6
7	amagnan	1.2	#include "TMath.h"
8
9	amagnan	1.1	#include "UserCode/HbbAnalysis/interface/Objects.hh"
10
11			namespace HbbAnalysis {
12
13			class Jet {
14
15			public:
16
17
18			/** Constructors */
19
20			Jet(){
21			//Clear();
22			};
23
24			~Jet(){};
25
26			Jet(const HbbAnalysis::GenVars & aGen,
27			const HbbAnalysis::GenVars & aGenJet,
28			const HbbAnalysis::BaseVars & aReco,
29			const HbbAnalysis::JetVars & aAll,
30			const HbbAnalysis::CaloJetVars & aCalo,
31	amagnan	1.4	const HbbAnalysis::JetBtagVars & aBtag,
32			const HbbAnalysis::JetIDVars & aId
33	amagnan	1.1	){
34			Clear();
35			jetType_ = 0;//calo jet
36			genVars(aGen);
37			genJetVars(aGenJet);
38			recoVars(aReco);
39			commonVars(aAll);
40			caloVars(aCalo);
41			btagVars(aBtag);
42	amagnan	1.4	idVars(aId);
43	amagnan	1.1	};
44
45			Jet(const HbbAnalysis::GenVars & aGen,
46			const HbbAnalysis::GenVars & aGenJet,
47			const HbbAnalysis::BaseVars & aReco,
48			const HbbAnalysis::JetVars & aAll,
49			const HbbAnalysis::PFJetVars & aPF,
50			const HbbAnalysis::JetBtagVars & aBtag
51			){
52			Clear();
53			jetType_ = 1;//PF jet
54			genVars(aGen);
55			genJetVars(aGenJet);
56			recoVars(aReco);
57			commonVars(aAll);
58			pfVars(aPF);
59			btagVars(aBtag);
60			};
61
62			inline const unsigned short jetType() const {
63			return jetType_;
64			};
65
66			inline const HbbAnalysis::GenVars & genVars() const {
67			return gen_;
68			};
69
70			inline const HbbAnalysis::GenVars & genJetVars() const {
71			return genJet_;
72			};
73
74			inline const HbbAnalysis::BaseVars & recoVars() const {
75			return reco_;
76			};
77
78			inline const HbbAnalysis::JetVars & commonVars() const {
79			return common_;
80			};
81
82			inline const HbbAnalysis::CaloJetVars & caloVars() const {
83			return calo_;
84			};
85
86			inline const HbbAnalysis::PFJetVars & pfVars() const {
87			return pf_;
88			};
89
90			inline const HbbAnalysis::JetBtagVars & btagVars() const {
91			return btag_;
92			};
93
94	amagnan	1.4	inline const HbbAnalysis::JetIDVars & idVars() const {
95			return id_;
96			};
97
98	amagnan	1.1	inline void jetType(const unsigned short aType) {
99			jetType_ = aType;
100			};
101
102			inline void genVars(const HbbAnalysis::GenVars & aGen) {
103			gen_ = aGen;
104			};
105
106			inline void genJetVars(const HbbAnalysis::GenVars & aGenJet) {
107			genJet_ = aGenJet;
108			};
109
110			inline void recoVars(const HbbAnalysis::BaseVars & aReco) {
111			reco_ = aReco;
112			};
113
114			inline void commonVars(const HbbAnalysis::JetVars & aJet) {
115			common_ = aJet;
116			};
117
118			inline void caloVars(const HbbAnalysis::CaloJetVars & aCalo) {
119			calo_ = aCalo;
120			};
121
122			inline void pfVars(const HbbAnalysis::PFJetVars & aPF){
123			pf_ = aPF;
124			};
125
126			inline void btagVars(const HbbAnalysis::JetBtagVars & aBtag){
127			btag_ = aBtag;
128			};
129
130	amagnan	1.4	inline void idVars(const HbbAnalysis::JetIDVars & aId){
131			id_ = aId;
132			};
133
134	amagnan	1.1	inline void Clear(){
135			gen_.valid = false;
136	amagnan	1.2	gen_.E = 0;
137	amagnan	1.1	gen_.pT = 0;
138			gen_.eta = 0;
139			gen_.phi = 0;
140			gen_.charge = 0;
141			gen_.pdgId = 0;
142			gen_.status = 0;
143			gen_.mass = 0;
144			gen_.vx = 0;
145			gen_.vy = 0;
146			gen_.vz = 0;
147
148			genJet_.valid = false;
149	amagnan	1.2	genJet_.E = 0;
150	amagnan	1.1	genJet_.pT = 0;
151			genJet_.eta = 0;
152			genJet_.phi = 0;
153			genJet_.charge = 0;
154			genJet_.pdgId = 0;
155			genJet_.status = 0;
156			genJet_.mass = 0;
157			genJet_.vx = 0;
158			genJet_.vy = 0;
159			genJet_.vz = 0;
160
161	amagnan	1.2	reco_.E = 0;
162	amagnan	1.1	reco_.pT = 0;
163			reco_.eta = 0;
164			reco_.phi = 0;
165			reco_.charge = 0;
166			reco_.vx = 0;
167			reco_.vy = 0;
168			reco_.vz = 0;
169
170			common_.flavour = 0;
171			common_.partonFlavour = 0;
172			common_.nAssociatedTracks = 0;
173			common_.rawpT = 0;
174	amagnan	1.5	common_.etaMean = 0;
175			common_.phiMean = 0;
176			common_.etaEtaMoment = 0;
177			common_.phiPhiMoment = 0;
178			common_.etaPhiMoment = 0;
179	amagnan	1.1	//common_.rawEta = 0;
180			//common_.rawPhi = 0;
181
182			calo_.maxEInEmTowers = 0;
183			calo_.maxEInHadTowers = 0;
184			calo_.energyFractionHadronic = 0;
185			calo_.emEnergyFraction = 0;
186			calo_.hadEnergyInHB = 0;
187			calo_.hadEnergyInHO = 0;
188			calo_.hadEnergyInHE = 0;
189			calo_.hadEnergyInHF = 0;
190			calo_.emEnergyInEB = 0;
191			calo_.emEnergyInEE = 0;
192			calo_.emEnergyInHF = 0;
193			calo_.towersArea = 0;
194			calo_.n90 = 0;
195			calo_.n60 = 0;
196
197			pf_.chargedHadronEnergy = 0;
198			pf_.chargedHadronEnergyFraction = 0;
199			pf_.neutralHadronEnergy = 0;
200			pf_.neutralHadronEnergyFraction = 0;
201			pf_.chargedEmEnergy = 0;
202			pf_.chargedEmEnergyFraction = 0;
203			pf_.chargedMuEnergy = 0;
204			pf_.chargedMuEnergyFraction = 0;
205			pf_.neutralEmEnergy = 0;
206			pf_.neutralEmEnergyFraction = 0;
207			pf_.chargedMultiplicity = 0;
208			pf_.neutralMultiplicity = 0;
209			pf_.muonMultiplicity = 0;
210
211			btag_.cSV = 0;
212			btag_.cSVMVA = 0;
213			btag_.iPMVA = 0;
214			btag_.bProba = 0;
215			btag_.probability = 0;
216			btag_.sSV = 0;
217	amagnan	1.4	btag_.softElectronByPt = 0;
218			btag_.softElectronByIP3d = 0;
219	amagnan	1.1	btag_.softMuon = 0;
220	amagnan	1.4	btag_.softMuonByPt = 0;
221			btag_.softMuonByIP3d = 0;
222	amagnan	1.1	btag_.tCHE = 0;
223			btag_.tCHP = 0;
224
225	amagnan	1.4	id_.fHPD = 0;
226			id_.fRBX = 0;
227			id_.n90Hits = 0;
228
229
230	amagnan	1.1	};
231
232	amagnan	1.2	template <class T>
233			const double deltaRwithLepton(const std::vector<T> & aCol) const;
234
235	amagnan	1.1	private:
236
237			unsigned short jetType_;
238			HbbAnalysis::GenVars gen_;
239			HbbAnalysis::GenVars genJet_;
240			HbbAnalysis::BaseVars reco_;
241			HbbAnalysis::JetVars common_;
242			HbbAnalysis::CaloJetVars calo_;
243			HbbAnalysis::PFJetVars pf_;
244			HbbAnalysis::JetBtagVars btag_;
245	amagnan	1.4	HbbAnalysis::JetIDVars id_;
246	amagnan	1.1
247			};
248
249			inline bool operator < (const Jet & one, const Jet & two)
250			{
251	amagnan	1.3	return one.btagVars().tCHP > two.btagVars().tCHP;
252	amagnan	1.1	}
253
254	amagnan	1.2
255
256			template <class T>
257			const double Jet::deltaRwithLepton(const std::vector<T> & aCol) const
258			{
259
260			double lMin = 1000;
261
262			typename std::vector< T >::const_iterator iLepton;
263	amagnan	1.1
264	amagnan	1.2	for (iLepton= aCol.begin();
265			iLepton != aCol.end();
266			iLepton++)
267			{
268			double lDeltaEta = recoVars().eta-(*iLepton).recoVars().eta;
269			double lDeltaPhi = recoVars().phi-(*iLepton).recoVars().phi;
270			if (lDeltaPhi<0) lDeltaPhi+= 2*TMath::Pi();
271
272			double lDeltaR = sqrt(lDeltaEtalDeltaEta+lDeltaPhilDeltaPhi);
273
274			if (lDeltaR<lMin){
275			lMin=lDeltaR;
276			}
277			}
278
279			if (lMin > 100) return -1;
280
281			return lMin;
282
283			}
284
285	amagnan	1.1	}//namespace
286			#endif