Coding violations in HLT/MUON
[u/mrichter/AliRoot.git] / HLT / MUON / src / AliRoot / Track.cxx
1 ////////////////////////////////////////////////////////////////////////////////
2 //
3 // Author: Artur Szostak
4 // Email:  artur@alice.phy.uct.ac.za | artursz@iafrica.com
5 //
6 ////////////////////////////////////////////////////////////////////////////////
7
8 #include "AliRoot/Track.hpp"
9 #include <TMath.h>
10 #include "Utils.hpp"
11
12 ClassImp(AliHLTMUONTrack)
13
14
15 AliHLTMUONTrack::AliHLTMUONTrack() : TObject()
16 {
17 // Default constructor initialises everything to zero and fTriggerID to -1.
18
19         Init();
20 }
21
22
23 AliHLTMUONTrack::AliHLTMUONTrack(
24                 Int_t triggerid, Int_t sign, Float_t momentum, Float_t pt,
25                 const AliHLTMUONPoint hits[10], const AliHLTMUONRegion regions[10]
26         ) : TObject()
27 {
28 // Create a track object from the given parameters.
29 // This constructor checks that momentum >= pt and sign is one of the
30 // following values: -1, 0 or +1. If these conditions are violated then
31 // the internal data is initialised as in the default constructor and an
32 // error message is displayed.
33
34         if (sign < -1 || +1 < sign)
35         {
36                 Init();
37                 Error("AliHLTMUONTrack", "The particle sign was not one of -1, 0 or +1. Got %d", sign);
38         }
39         else if (momentum < pt)
40         {
41                 Init();
42                 Error("AliHLTMUONTrack", "The momentum (%f) must be larger or equal to the pt (%f).",
43                         momentum, pt
44                 );
45         }
46         else if (pt < 0.0)
47         {
48                 Init();
49                 Error("AliHLTMUONTrack", "The pt must be a positive number. Got: %f", pt);
50         }
51         else
52         {
53                 fTriggerID = triggerid;
54                 fParticleSign = sign;
55                 fP = momentum;
56                 fPt = pt;
57                 for (Int_t i = 0; i < 10; i++)
58                 {
59                         fHit[i] = hits[i];
60                         fRegionOfInterest[i] = regions[i];
61                 }
62         }
63 }
64
65
66 void AliHLTMUONTrack::Init()
67 {
68 // Internal initialisation routine used by the constructors.
69
70         fTriggerID = -1;
71         fParticleSign = 0;
72         fP = fPt = 0.0;
73 }
74
75
76 void AliHLTMUONTrack::ParticleSign(Int_t value)
77 {
78 // Set method for the particle sign. The particle sign must be one
79 // of the following values: -1, 0 or +1
80 // If the new value is not in this range then an error message is
81 // displayed and the internal value remain unchanged.
82
83         if (-1 <= value && value <= +1)
84                 fParticleSign = value;
85         else
86                 Error("ParticleSign",
87                         "The particle sign must be a value of -1, 0 or +1, but got %d",
88                         value
89                 );
90 }
91
92
93 void AliHLTMUONTrack::P(Float_t value)
94 {
95 // The set method for the momentum.
96 // This method checks that the momentum is always equal or larger than
97 // the pt. If not then the internal values are left unchanged and an
98 // error message is displayed. The numbers must also be positive.
99
100         if (value >= fPt)
101                 fP = value;
102         else
103                 Error("P",
104                         "Trying to assing momentum (%f) which is smaller than the pt value (%f).",
105                         value, fPt
106                 );
107 }
108
109 void AliHLTMUONTrack::Pt(Float_t value)
110 {
111 // The set method for the pt.
112 // This method checks that the momentum is always equal or larger than
113 // the pt. If not then the internal values are left unchanged and an
114 // error message is displayed. The numbers must also be positive.
115
116         if (value >= 0.0)
117         {
118                 if (value <= fP)
119                         fPt = value;
120                 else
121                         Error("Pt",
122                                 "Trying to assign pt (%f) which is larger than the momentum value (%f).",
123                                 value, fP
124                         );
125         }
126         else
127                 Error("Pt", "Cannot have a negative value pt. Got: %f", value);
128 };
129
130
131 AliHLTMUONPoint& AliHLTMUONTrack::Hit(UInt_t chamber)
132 {
133 // Returns the hit point for the specified chamber.
134 // If the chamber number in out of bounds the point on the first
135 // chamber is returned and an error message displayed.
136
137         if (chamber < 10)
138                 return fHit[chamber];
139         else
140         {
141                 Error("Hit",
142                         "The chamber is out of range. Got: %d, but should be in [0..9].",
143                         chamber
144                 );
145                 return fHit[0];
146         }
147 }
148
149
150 const AliHLTMUONPoint& AliHLTMUONTrack::Hit(UInt_t chamber) const
151 {
152 // Returns a constant hit object for the specified chamber.
153 // If the chamber number in out of bounds the point on the first
154 // chamber is returned and an error message displayed.
155
156         if (chamber < 10)
157                 return fHit[chamber];
158         else
159         {
160                 Error("Hit",
161                         "The chamber is out of range. Got: %d, but should be in [0..9].",
162                         chamber
163                 );
164                 return fHit[0];
165         };
166 };
167
168
169 void AliHLTMUONTrack::Hit(UInt_t chamber, const AliHLTMUONPoint& value)
170 {
171 // Set method for hits. The chamber must be in the range [0..9]
172
173         if (chamber < 10)
174                 fHit[chamber] = value;
175         else
176                 Error("Hit",
177                         "The chamber is out of range. Got: %d, but should be in [0..9].",
178                         chamber
179                 );
180 }
181
182
183 AliHLTMUONRegion& AliHLTMUONTrack::RegionOfInterest(UInt_t chamber)
184 {
185 // Returns the region of interest for the specified chamber.
186 // If the chamber number in out of bounds the region on the first
187 // chamber is returned and an error message displayed.
188
189         if (chamber < 10)
190                 return fRegionOfInterest[chamber];
191         else
192         {
193                 Error("RegionOfInterest",
194                         "The chamber is out of range. Got: %d, but should be in [0..9].",
195                         chamber
196                 );
197                 return fRegionOfInterest[0];
198         }
199 }
200
201
202 const AliHLTMUONRegion& AliHLTMUONTrack::RegionOfInterest(UInt_t chamber) const
203 {
204 // Returns the constatn region of interest object for the specified chamber.
205 // If the chamber number in out of bounds the region on the first
206 // chamber is returned and an error message displayed.
207
208         if (chamber < 10)
209                 return fRegionOfInterest[chamber];
210         else
211         {
212                 Error("RegionOfInterest",
213                         "The chamber is out of range. Got: %d, but should be in [0..9].",
214                         chamber
215                 );
216                 return fRegionOfInterest[0];
217         }
218 }
219
220
221 void AliHLTMUONTrack::RegionOfInterest(UInt_t chamber, const AliHLTMUONRegion& value)
222 {
223 // Set method for regions. The chamber must be in the range [0..9]
224
225         if (chamber < 10)
226                 fRegionOfInterest[chamber] = value;
227         else
228                 Error("RegionOfInterest",
229                         "The chamber is out of range. Got: %d, but should be in [0..9].",
230                         chamber
231                 );
232 }
233
234
235 Bool_t AliHLTMUONTrack::HitsInRegions() const
236 {
237 // Checks to see if the all the hits are within their respective regions
238 // of interest for each chamber. kTRUE is returned if they are and kFALSE
239 // otherwise.
240
241         for (Int_t i = 0; i < 10; i++)
242         {
243                 if ( ! fRegionOfInterest[i].Contains(fHit[i]) )
244                         return kFALSE;
245         }
246         return kTRUE;
247 }
248
249
250 ostream& operator << (ostream& os, const AliHLTMUONTrack& t)
251 {
252         os << "{trigid: " << t.fTriggerID << ", sign: " << t.fParticleSign
253            << ", p: " << t.fP << ", pt: " << t.fPt << "}";
254         return os;
255 }
256