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
Error occurred while calculating annotation data.
Log Message:	Removed custom copy constructor
#	Content
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	}