Thesis/src/TCMuon.cc

/* 
 * File:   TCMuon.cc
 * Author: S. Won
 */

#include "TCMuon.h"
#include <iostream>

TCMuon::TCMuon() {
}

TCMuon::~TCMuon() {
}

// "get" methods -------------------------------------

TVector3 TCMuon::Position() const {
   return _position;
}

TLorentzVector TCMuon::P4() const {
   return _p4;
}

TVector2 TCMuon::P2() const {
   TVector2 v2(_p4.Px(), _p4.Py());
   return v2;
}

float TCMuon::Et() const {
   return _p4.Et();
}

float TCMuon::Pt() const {
   return _p4.Pt();
}

int TCMuon::Charge() const{
   return charge;
}

float TCMuon::SumPt03() const { 
   return sumPt03;
}

float TCMuon::EmEt03() const {
   return emEt03;
}

float TCMuon::HadEt03() const {
   return hadEt03;
}
int TCMuon::NTracks03() const {
   return nTracks03;
}

float TCMuon::Phi() const {
   return _p4.Phi();
}

int TCMuon::numberOfValidPixelHits() const {
   return numberOfValidPixelHits_;
}

int TCMuon::numberOfValidTrackerHits() const {
   return numberOfValidTrackerHits_;
}

int TCMuon::numberOfValidMuonHits() const {
   return numberOfValidMuonHits_;
}

int TCMuon::numberOfMissingPixelHits() const {
   return numberOfMissingPixelHits_;
}

int TCMuon::numberOfMissingTrackerHits() const {
   return numberOfMissingTrackerHits_;
}

float TCMuon::normalizedChi2() const {
   return normalizedChi2_;
}

float TCMuon::dz() const {
   return dz_;
}

float TCMuon::dxy() const {
   return dxy_;
}

float TCMuon::PFRelIso(float coneSize) const {
   float relIso = 0;
   if (fabs(coneSize - 0.3) < 0.01)
      relIso = (PFiso_Pt03 + PFiso_Gamma03 + PFiso_Neutral03) / _p4.Pt();
   if (fabs(coneSize - 0.4) < 0.01)
      relIso = (PFiso_Pt04 + PFiso_Gamma04 + PFiso_Neutral04) / _p4.Pt();
   if (fabs(coneSize - 0.5) < 0.01)
      relIso = (PFiso_Pt05 + PFiso_Gamma05 + PFiso_Neutral05) / _p4.Pt();
   return relIso;
}

float TCMuon::PFSumPt(float coneSize) const {
   float sumPt = 0;
   if (fabs(coneSize - 0.3) < 0.01) sumPt = PFiso_Pt03;
   if (fabs(coneSize - 0.4) < 0.01) sumPt = PFiso_Pt04;
   if (fabs(coneSize - 0.5) < 0.01) sumPt = PFiso_Pt05;
   return sumPt;
}

float TCMuon::PFENeutral(float coneSize) const {
   float neutral = 0;
   if (fabs(coneSize - 0.3) < 0.01) neutral = PFiso_Neutral03;
   if (fabs(coneSize - 0.4) < 0.01) neutral = PFiso_Neutral04;
   if (fabs(coneSize - 0.5) < 0.01) neutral = PFiso_Neutral05;
   return neutral;
}

float TCMuon::PFEGamma(float coneSize) const {
   float gamma = 0;
   if (fabs(coneSize - 0.3) < 0.01) gamma = PFiso_Gamma03;
   if (fabs(coneSize - 0.4) < 0.01) gamma = PFiso_Gamma04;
   if (fabs(coneSize - 0.5) < 0.01) gamma = PFiso_Gamma05;
   return gamma;
}

// "set" methods ---------------------------------------------

void TCMuon::SetPosition(float x, float y, float z) {
   TVector3 p(x, y, z);
   _position = p;
}

void TCMuon::SetP4(TLorentzVector p4) {
   _p4 = p4;
}

void TCMuon::SetP4(float px, float py, float pz, float e) {
   TLorentzVector p4(px, py, pz, e);
   _p4 = p4;
}

void TCMuon::SetsumPt03(float s) {
   sumPt03 = s;
}

void TCMuon::SetemEt03(float s) {
   emEt03 = s;
}

void TCMuon::SethadEt03(float s) {
   hadEt03 = s;
}

void TCMuon::SetnTracks03(int n) {
   nTracks03 = n;
}

void TCMuon::SetCharge(int c) {
   charge = c;
}

void TCMuon::SetnumberOfValidPixelHits(int n) {
   numberOfValidPixelHits_ = n;
}

void TCMuon::SetnumberOfValidTrackerHits(int n) {
   numberOfValidTrackerHits_ = n;
}

void TCMuon::SetnumberOfMissingPixelHits(int n) {
   numberOfMissingPixelHits_ = n;
}

void TCMuon::SetnumberOfMissingTrackerHits(int n) {
   numberOfMissingTrackerHits_ = n;
}

void TCMuon::SetnumberOfValidMuonHits(int n) {
   numberOfValidMuonHits_ = n;
}

void TCMuon::SetnormalizedChi2(float n) {
   normalizedChi2_ = n;
}

void TCMuon::SetPFSumPt(float coneSize, float f) {
   if(fabs(coneSize - 0.3) < 0.01) PFiso_Pt03 = f;
   if(fabs(coneSize - 0.4) < 0.01) PFiso_Pt04 = f;
   if(fabs(coneSize - 0.5) < 0.01) PFiso_Pt05 = f;
}

void TCMuon::SetPFEGamma(float coneSize, float f) {
   if(fabs(coneSize - 0.3) < 0.01) PFiso_Gamma03 = f;
   if(fabs(coneSize - 0.4) < 0.01) PFiso_Gamma04 = f;
   if(fabs(coneSize - 0.5) < 0.01) PFiso_Gamma05 = f;
}

void TCMuon::SetPFENeutral(float coneSize, float f) {
   if(fabs(coneSize - 0.3) < 0.01) PFiso_Neutral03 = f;
   if(fabs(coneSize - 0.4) < 0.01) PFiso_Neutral04 = f;
   if(fabs(coneSize - 0.5) < 0.01) PFiso_Neutral05 = f;
}

void TCMuon::SetDxy(float n) {
   dxy_ = n;
}
 
void TCMuon::SetDz(float n) {
   dz_ = n;
}
Revision:	1.2
Committed:	Wed Jun 15 22:12:54 2011 UTC (13 years, 10 months ago) by devildog
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.1:	+0 -3 lines
Log Message:	Removed custom copy constructor
#	User	Rev	Content
1	devildog	1.1	/*
2			* File: TCMuon.cc
3			* Author: S. Won
4			*/
5
6			#include "TCMuon.h"
7			#include <iostream>
8
9			TCMuon::TCMuon() {
10			}
11
12			TCMuon::~TCMuon() {
13			}
14
15			// "get" methods -------------------------------------
16
17			TVector3 TCMuon::Position() const {
18			return _position;
19			}
20
21			TLorentzVector TCMuon::P4() const {
22			return _p4;
23			}
24
25			TVector2 TCMuon::P2() const {
26			TVector2 v2(_p4.Px(), _p4.Py());
27			return v2;
28			}
29
30			float TCMuon::Et() const {
31			return _p4.Et();
32			}
33
34			float TCMuon::Pt() const {
35			return _p4.Pt();
36			}
37
38			int TCMuon::Charge() const{
39			return charge;
40			}
41
42			float TCMuon::SumPt03() const {
43			return sumPt03;
44			}
45
46			float TCMuon::EmEt03() const {
47			return emEt03;
48			}
49
50			float TCMuon::HadEt03() const {
51			return hadEt03;
52			}
53			int TCMuon::NTracks03() const {
54			return nTracks03;
55			}
56
57			float TCMuon::Phi() const {
58			return _p4.Phi();
59			}
60
61			int TCMuon::numberOfValidPixelHits() const {
62			return numberOfValidPixelHits_;
63			}
64
65			int TCMuon::numberOfValidTrackerHits() const {
66			return numberOfValidTrackerHits_;
67			}
68
69			int TCMuon::numberOfValidMuonHits() const {
70			return numberOfValidMuonHits_;
71			}
72
73			int TCMuon::numberOfMissingPixelHits() const {
74			return numberOfMissingPixelHits_;
75			}
76
77			int TCMuon::numberOfMissingTrackerHits() const {
78			return numberOfMissingTrackerHits_;
79			}
80
81			float TCMuon::normalizedChi2() const {
82			return normalizedChi2_;
83			}
84
85			float TCMuon::dz() const {
86			return dz_;
87			}
88
89			float TCMuon::dxy() const {
90			return dxy_;
91			}
92
93			float TCMuon::PFRelIso(float coneSize) const {
94			float relIso = 0;
95			if (fabs(coneSize - 0.3) < 0.01)
96			relIso = (PFiso_Pt03 + PFiso_Gamma03 + PFiso_Neutral03) / _p4.Pt();
97			if (fabs(coneSize - 0.4) < 0.01)
98			relIso = (PFiso_Pt04 + PFiso_Gamma04 + PFiso_Neutral04) / _p4.Pt();
99			if (fabs(coneSize - 0.5) < 0.01)
100			relIso = (PFiso_Pt05 + PFiso_Gamma05 + PFiso_Neutral05) / _p4.Pt();
101			return relIso;
102			}
103
104			float TCMuon::PFSumPt(float coneSize) const {
105			float sumPt = 0;
106			if (fabs(coneSize - 0.3) < 0.01) sumPt = PFiso_Pt03;
107			if (fabs(coneSize - 0.4) < 0.01) sumPt = PFiso_Pt04;
108			if (fabs(coneSize - 0.5) < 0.01) sumPt = PFiso_Pt05;
109			return sumPt;
110			}
111
112			float TCMuon::PFENeutral(float coneSize) const {
113			float neutral = 0;
114			if (fabs(coneSize - 0.3) < 0.01) neutral = PFiso_Neutral03;
115			if (fabs(coneSize - 0.4) < 0.01) neutral = PFiso_Neutral04;
116			if (fabs(coneSize - 0.5) < 0.01) neutral = PFiso_Neutral05;
117			return neutral;
118			}
119
120			float TCMuon::PFEGamma(float coneSize) const {
121			float gamma = 0;
122			if (fabs(coneSize - 0.3) < 0.01) gamma = PFiso_Gamma03;
123			if (fabs(coneSize - 0.4) < 0.01) gamma = PFiso_Gamma04;
124			if (fabs(coneSize - 0.5) < 0.01) gamma = PFiso_Gamma05;
125			return gamma;
126			}
127
128			// "set" methods ---------------------------------------------
129
130			void TCMuon::SetPosition(float x, float y, float z) {
131			TVector3 p(x, y, z);
132			_position = p;
133			}
134
135			void TCMuon::SetP4(TLorentzVector p4) {
136			_p4 = p4;
137			}
138
139			void TCMuon::SetP4(float px, float py, float pz, float e) {
140			TLorentzVector p4(px, py, pz, e);
141			_p4 = p4;
142			}
143
144			void TCMuon::SetsumPt03(float s) {
145			sumPt03 = s;
146			}
147
148			void TCMuon::SetemEt03(float s) {
149			emEt03 = s;
150			}
151
152			void TCMuon::SethadEt03(float s) {
153			hadEt03 = s;
154			}
155
156			void TCMuon::SetnTracks03(int n) {
157			nTracks03 = n;
158			}
159
160			void TCMuon::SetCharge(int c) {
161			charge = c;
162			}
163
164			void TCMuon::SetnumberOfValidPixelHits(int n) {
165			numberOfValidPixelHits_ = n;
166			}
167
168			void TCMuon::SetnumberOfValidTrackerHits(int n) {
169			numberOfValidTrackerHits_ = n;
170			}
171
172			void TCMuon::SetnumberOfMissingPixelHits(int n) {
173			numberOfMissingPixelHits_ = n;
174			}
175
176			void TCMuon::SetnumberOfMissingTrackerHits(int n) {
177			numberOfMissingTrackerHits_ = n;
178			}
179
180			void TCMuon::SetnumberOfValidMuonHits(int n) {
181			numberOfValidMuonHits_ = n;
182			}
183
184			void TCMuon::SetnormalizedChi2(float n) {
185			normalizedChi2_ = n;
186			}
187
188			void TCMuon::SetPFSumPt(float coneSize, float f) {
189			if(fabs(coneSize - 0.3) < 0.01) PFiso_Pt03 = f;
190			if(fabs(coneSize - 0.4) < 0.01) PFiso_Pt04 = f;
191			if(fabs(coneSize - 0.5) < 0.01) PFiso_Pt05 = f;
192			}
193
194			void TCMuon::SetPFEGamma(float coneSize, float f) {
195			if(fabs(coneSize - 0.3) < 0.01) PFiso_Gamma03 = f;
196			if(fabs(coneSize - 0.4) < 0.01) PFiso_Gamma04 = f;
197			if(fabs(coneSize - 0.5) < 0.01) PFiso_Gamma05 = f;
198			}
199
200			void TCMuon::SetPFENeutral(float coneSize, float f) {
201			if(fabs(coneSize - 0.3) < 0.01) PFiso_Neutral03 = f;
202			if(fabs(coneSize - 0.4) < 0.01) PFiso_Neutral04 = f;
203			if(fabs(coneSize - 0.5) < 0.01) PFiso_Neutral05 = f;
204			}
205
206			void TCMuon::SetDxy(float n) {
207			dxy_ = n;
208			}
209
210			void TCMuon::SetDz(float n) {
211			dz_ = n;
212			}