PollackPrograms/src/TCMuon.cc

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

TCMuon::TCMuon() {
}
TCMuon::~TCMuon() {
}


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


float TCMuon::PtError() const {
   return _ptError;
}

bool TCMuon::IsGLB() const {
   return _isGLB;
}
bool TCMuon::IsTRK() const {
   return _isTRK;
}

bool TCMuon::IsPF() const {
   return _isPF;
}

int TCMuon::NumberOfMatchedStations() const {
  return _numberOfMatchedStations;
}

int TCMuon::TrackLayersWithMeasurement() const {
  return _trackLayersWithMeasurement;
}

int TCMuon::NumberOfValidPixelHits() const {
  return _numberOfValidPixelHits;
}

int TCMuon::NumberOfValidTrackerHits() const {
  return _numberOfValidTrackerHits;
}

int TCMuon::NumberOfValidMuonHits() const {
  return _numberOfValidMuonHits;
}

int TCMuon::NumberOfLostPixelHits() const {
  return _numberOfLostPixelHits;
}

int TCMuon::NumberOfLostTrackerHits() const {
  return _numberOfLostTrackerHits;
}

float TCMuon::NormalizedChi2() const {
  return _normalizedChi2;
}

int TCMuon::NumberOfMatches() const {
   return _numberOfMatches;
}

float TCMuon::CaloComp() const {
   return _caloComp;
}

float TCMuon::SegComp() const {
   return _segComp;
}

// "set" methods ---------------------------------------------
void TCMuon::SetNumberOfMatchedStations(int n){
  _numberOfMatchedStations = n;
}

void TCMuon::SetTrackLayersWithMeasurement(int n) {
  _trackLayersWithMeasurement = n;
}

void TCMuon::SetPtError(float er){
   _ptError = er;
}

void TCMuon::SetIsGLB(bool t){
   _isGLB = t;
}

void TCMuon::SetIsTRK(bool t){
   _isTRK = t;
}
void TCMuon::SetIsPF(bool t){
   _isPF = t;
}

void TCMuon::SetNumberOfValidMuonHits(int n) {
  _numberOfValidMuonHits = n;
}

void TCMuon::SetNumberOfValidPixelHits(int n) {
  _numberOfValidPixelHits = n;
}

void TCMuon::SetNumberOfValidTrackerHits(int n) {
  _numberOfValidTrackerHits = n;
}

void TCMuon::SetNumberOfLostPixelHits(int n) {
  _numberOfLostPixelHits = n;
}

void TCMuon::SetNumberOfLostTrackerHits(int n) {
  _numberOfLostTrackerHits = n;
}

void TCMuon::SetNormalizedChi2(float n) {
  _normalizedChi2 = n;
}

void TCMuon::SetNumberOfMatches(int n) {
  _numberOfMatches = n;
}

void TCMuon::SetCaloComp(float c){
   _caloComp = c;
}

void TCMuon::SetSegComp(float s){
   _segComp = s;
}

Revision:	1.2
Committed:	Wed Feb 20 21:39:43 2013 UTC (12 years, 2 months ago) by bpollack
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.1:	+86 -58 lines
Log Message:	commiting moriond analysis package
#	User	Rev	Content
1	bpollack	1.1	#include "TCMuon.h"
2	bpollack	1.2	#include <iostream>
3	bpollack	1.1
4			TCMuon::TCMuon() {
5			}
6			TCMuon::~TCMuon() {
7			}
8
9
10			// "get" methods -------------------------------------
11
12
13	bpollack	1.2	float TCMuon::PtError() const {
14			return _ptError;
15			}
16
17			bool TCMuon::IsGLB() const {
18			return _isGLB;
19			}
20			bool TCMuon::IsTRK() const {
21			return _isTRK;
22			}
23
24			bool TCMuon::IsPF() const {
25			return _isPF;
26			}
27
28			int TCMuon::NumberOfMatchedStations() const {
29			return _numberOfMatchedStations;
30			}
31
32			int TCMuon::TrackLayersWithMeasurement() const {
33			return _trackLayersWithMeasurement;
34	bpollack	1.1	}
35
36	bpollack	1.2	int TCMuon::NumberOfValidPixelHits() const {
37			return _numberOfValidPixelHits;
38	bpollack	1.1	}
39
40	bpollack	1.2	int TCMuon::NumberOfValidTrackerHits() const {
41			return _numberOfValidTrackerHits;
42			}
43
44			int TCMuon::NumberOfValidMuonHits() const {
45			return _numberOfValidMuonHits;
46			}
47
48			int TCMuon::NumberOfLostPixelHits() const {
49			return _numberOfLostPixelHits;
50			}
51
52			int TCMuon::NumberOfLostTrackerHits() const {
53			return _numberOfLostTrackerHits;
54	bpollack	1.1	}
55
56	bpollack	1.2	float TCMuon::NormalizedChi2() const {
57			return _normalizedChi2;
58	bpollack	1.1	}
59
60	bpollack	1.2	int TCMuon::NumberOfMatches() const {
61			return _numberOfMatches;
62	bpollack	1.1	}
63
64			float TCMuon::CaloComp() const {
65			return _caloComp;
66			}
67
68			float TCMuon::SegComp() const {
69			return _segComp;
70			}
71
72	bpollack	1.2	// "set" methods ---------------------------------------------
73			void TCMuon::SetNumberOfMatchedStations(int n){
74			_numberOfMatchedStations = n;
75			}
76
77			void TCMuon::SetTrackLayersWithMeasurement(int n) {
78			_trackLayersWithMeasurement = n;
79			}
80
81			void TCMuon::SetPtError(float er){
82			_ptError = er;
83	bpollack	1.1	}
84
85	bpollack	1.2	void TCMuon::SetIsGLB(bool t){
86			_isGLB = t;
87			}
88
89			void TCMuon::SetIsTRK(bool t){
90			_isTRK = t;
91			}
92			void TCMuon::SetIsPF(bool t){
93			_isPF = t;
94			}
95
96			void TCMuon::SetNumberOfValidMuonHits(int n) {
97			_numberOfValidMuonHits = n;
98			}
99
100			void TCMuon::SetNumberOfValidPixelHits(int n) {
101			_numberOfValidPixelHits = n;
102			}
103
104			void TCMuon::SetNumberOfValidTrackerHits(int n) {
105			_numberOfValidTrackerHits = n;
106			}
107	bpollack	1.1
108	bpollack	1.2	void TCMuon::SetNumberOfLostPixelHits(int n) {
109			_numberOfLostPixelHits = n;
110			}
111	bpollack	1.1
112	bpollack	1.2	void TCMuon::SetNumberOfLostTrackerHits(int n) {
113			_numberOfLostTrackerHits = n;
114	bpollack	1.1	}
115
116	bpollack	1.2	void TCMuon::SetNormalizedChi2(float n) {
117			_normalizedChi2 = n;
118	bpollack	1.1	}
119	bpollack	1.2
120			void TCMuon::SetNumberOfMatches(int n) {
121			_numberOfMatches = n;
122	bpollack	1.1	}
123
124			void TCMuon::SetCaloComp(float c){
125			_caloComp = c;
126			}
127
128			void TCMuon::SetSegComp(float s){
129			_segComp = s;
130			}
131	bpollack	1.2