Removing extra semicolons (FedoraCore3, gcc 3.4.2)
[u/mrichter/AliRoot.git] / MUON / AliMUONRawCluster.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id$ */
17
18 // Class for the MUON RecPoint
19 // It contains the properties of the physics cluters found in the tracking chambers
20 // RawCluster contains also the information from the both cathode of the chambers.
21 //
22 //
23
24 #include <TArrayF.h>
25
26 #include "AliMUONRawCluster.h"
27
28 ClassImp(AliMUONRawCluster)
29
30
31 AliMUONRawCluster::AliMUONRawCluster() 
32   : TObject()
33 {
34 // Constructor
35     fTracks[0]=fTracks[1]=fTracks[2]=-1; 
36     for (int j=0;j<2;j++) {
37         fQ[j]=0;
38         fX[j]=0;
39         fY[j]=0;
40         fMultiplicity[j]=0;
41         fPeakSignal[j]=-1;
42         fChi2[j]=-1;
43         
44         for (int k=0;k<50;k++) {
45             fIndexMap[k][j]=-1;
46             fOffsetMap[k][j]=0;
47             fContMap[k][j]=0;
48             fPhysicsMap[k]=-1;
49         }
50     }
51     fNcluster[0]=fNcluster[1]=-1;
52     fGhost=0;
53 }
54 //____________________________________________________
55 Int_t AliMUONRawCluster::Compare(const TObject *obj) const
56 {
57   /*
58          AliMUONRawCluster *raw=(AliMUONRawCluster *)obj;
59          Float_t r=GetRadius();
60          Float_t ro=raw->GetRadius();
61          if (r>ro) return 1;
62          else if (r<ro) return -1;
63          else return 0;
64   */
65          AliMUONRawCluster *raw=(AliMUONRawCluster *)obj;
66          Float_t y=fY[0];
67          Float_t yo=raw->fY[0];
68          if (y>yo) return 1;
69          else if (y<yo) return -1;
70          else return 0;
71
72 }
73 //____________________________________________________
74 Int_t AliMUONRawCluster::BinarySearch(Float_t y, TArrayF coord, Int_t from, Int_t upto)
75 {
76    // Find object using a binary search. Array must first have been sorted.
77    // Search can be limited by setting upto to desired index.
78
79    Int_t low=from, high=upto-1, half;
80    while(high-low>1) {
81         half=(high+low)/2;
82         if(y>coord[half]) low=half;
83         else high=half;
84    }
85    return low;
86 }
87 //____________________________________________________
88 void AliMUONRawCluster::SortMin(Int_t *idx,Float_t *xdarray,Float_t *xarray,Float_t *yarray,Float_t *qarray, Int_t ntr)
89 {
90   //
91   // Get the 3 closest points(cog) one can find on the second cathode 
92   // starting from a given cog on first cathode
93   //
94   
95   //
96   //  Loop over deltax, only 3 times
97   //
98   
99     Float_t xmin;
100     Int_t jmin;
101     Int_t id[3] = {-2,-2,-2};
102     Float_t jx[3] = {0.,0.,0.};
103     Float_t jy[3] = {0.,0.,0.};
104     Float_t jq[3] = {0.,0.,0.};
105     Int_t jid[3] = {-2,-2,-2};
106     Int_t i,j,imax;
107   
108     if (ntr<3) imax=ntr;
109     else imax=3;
110     for(i=0;i<imax;i++){
111         xmin=1001.;
112         jmin=0;
113     
114         for(j=0;j<ntr;j++){
115             if ((i == 1 && j == id[i-1]) 
116                   ||(i == 2 && (j == id[i-1] || j == id[i-2]))) continue;
117            if (TMath::Abs(xdarray[j]) < xmin) {
118               xmin = TMath::Abs(xdarray[j]);
119               jmin=j;
120            }       
121         } // j
122         if (xmin != 1001.) {    
123            id[i]=jmin;
124            jx[i]=xarray[jmin]; 
125            jy[i]=yarray[jmin]; 
126            jq[i]=qarray[jmin]; 
127            jid[i]=idx[jmin];
128         } 
129     
130     }  // i
131   
132     for (i=0;i<3;i++){
133         if (jid[i] == -2) {
134             xarray[i]=1001.;
135             yarray[i]=1001.;
136             qarray[i]=1001.;
137             idx[i]=-1;
138         } else {
139             xarray[i]=jx[i];
140             yarray[i]=jy[i];
141             qarray[i]=jq[i];
142             idx[i]=jid[i];
143         }
144     }
145
146 }
147
148 //____________________________________________________
149 Int_t AliMUONRawCluster::PhysicsContribution() const
150 {
151 // Evaluate physics contribution to cluster
152   Int_t iPhys=0;
153   Int_t iBg=0;
154   Int_t iMixed=0;
155   for (Int_t i=0; i<fMultiplicity[0]; i++) {
156     if (fPhysicsMap[i]==2) iPhys++;
157     if (fPhysicsMap[i]==1) iMixed++;
158     if (fPhysicsMap[i]==0) iBg++;
159   }
160   if (iMixed==0 && iBg==0) {
161     return 2;
162   } else if ((iPhys != 0 && iBg !=0) || iMixed != 0) {
163     return 1;
164   } else {
165     return 0;
166   }
167 }
168 //____________________________________________________
169 void AliMUONRawCluster::DumpIndex(void)
170 {
171   // Dumping IdexMap of the cluster
172     printf ("-----\n");
173     for (Int_t icat=0;icat<2;icat++) {
174         printf ("Mult %d\n",fMultiplicity[icat]);
175         for (Int_t idig=0;idig<fMultiplicity[icat];idig++){
176             printf("Index %d",fIndexMap[idig][icat]);
177         }
178         printf("\n");
179     }
180 }
181 //____________________________________________________
182 Int_t AliMUONRawCluster::AddCharge(Int_t i, Int_t Q)
183 {
184   // Adding Q to the fQ value
185   if (i==0 || i==1) {
186     fQ[i]+=Q;
187     return 1;
188   }
189   else  return 0;
190 }
191 //____________________________________________________
192 Int_t AliMUONRawCluster::AddX(Int_t i, Float_t X)
193 {
194   // Adding X to the fX value
195   if (i==0 || i==1) {
196     fX[i]+=X;
197     return 1;
198   }
199   else  return 0;
200 }
201 //____________________________________________________
202 Int_t AliMUONRawCluster::AddY(Int_t i, Float_t Y)
203 {
204   // Adding Y to the fY value 
205   if (i==0 || i==1) {
206     fY[i]+=Y;
207     return 1;
208   }
209   else return 0;
210 }
211 //____________________________________________________
212 Int_t AliMUONRawCluster::AddZ(Int_t i, Float_t Z)
213 {
214   // Adding Z to the fZ value
215   if (i==0 || i==1) {
216     fZ[i]+=Z;
217     return 1;
218   }
219   else return 0;
220 }
221 //____________________________________________________
222 Int_t AliMUONRawCluster::GetCharge(Int_t i) const
223 {
224   // Getting the charge of the cluster
225   if (i==0 || i==1) return fQ[i];
226   else  return 99999;
227 }
228 //____________________________________________________
229 Float_t AliMUONRawCluster::GetX(Int_t i)  const
230 {
231   // Getting X value of the cluster
232   if (i==0 || i==1) return fX[i];
233   else  return 99999.;
234 }
235 //____________________________________________________
236 Float_t AliMUONRawCluster::GetY(Int_t i) const 
237 {
238   // Getting Y value of the cluster
239   if (i==0 || i==1) return fY[i];
240   else  return 99999.;
241 }
242 //____________________________________________________
243 Float_t AliMUONRawCluster::GetZ(Int_t i) const 
244 {
245   // Getting Z value of the cluster
246   if (i==0 || i==1) return fZ[i];
247   else  return 99999.;
248 }
249 //____________________________________________________
250 Int_t AliMUONRawCluster::GetTrack(Int_t i) const 
251 {
252   // Getting track i contributing to the cluster
253   if (i==0 || i==1 || i==2) return fTracks[i];
254   else  return 99999;
255 }
256 //____________________________________________________
257 Int_t AliMUONRawCluster::GetPeakSignal(Int_t i) const 
258 {
259   // Getting cluster peaksignal
260   if (i==0 || i==1 ) return fPeakSignal[i];
261   else  return 99999;
262 }
263 //____________________________________________________
264 Int_t AliMUONRawCluster::GetMultiplicity(Int_t i) const 
265 {
266   // Getting cluster multiplicity
267   if (i==0 || i==1 ) return fMultiplicity[i];
268   else  return 99999;
269 }
270 //____________________________________________________
271 Int_t AliMUONRawCluster::GetClusterType() const 
272 {
273   // Getting Cluster Type
274   return fClusterType;
275 }
276 //____________________________________________________
277 Int_t AliMUONRawCluster::GetGhost() const 
278 {
279   // Getting Ghost
280   return fGhost;
281 }
282 //____________________________________________________
283 Int_t AliMUONRawCluster::GetNcluster(Int_t i) const 
284 {
285   // Getting number of clusters
286   if (i==0 || i==1 ) return fNcluster[i];
287   else  return 99999;
288 }
289 //____________________________________________________
290 Float_t AliMUONRawCluster::GetChi2(Int_t i) const 
291 {
292   // Getting chi2 value of the cluster
293   if (i==0 || i==1) return fChi2[i];
294   else  return 99999.;
295 }
296 //____________________________________________________
297 Int_t AliMUONRawCluster::SetCharge(Int_t i, Int_t Q)
298 {
299   // Setting Charge of the cluster
300   if (i==0 || i==1) {
301     fQ[i]=Q;
302     return 1;
303   }
304   else  return 0;
305 }
306 //____________________________________________________
307 Int_t AliMUONRawCluster::SetX(Int_t i, Float_t X)
308 {
309   // Setting X value of the cluster
310   if (i==0 || i==1) {
311     fX[i]=X;
312     return 1;
313   }
314   else  return 0;
315 }
316 //____________________________________________________
317 Int_t AliMUONRawCluster::SetY(Int_t i, Float_t Y)
318 {
319   // Setting Y value of the cluster
320   if (i==0 || i==1) {
321     fY[i]=Y;
322     return 1;
323   }
324   else return 0;
325 }
326 //____________________________________________________
327 Int_t AliMUONRawCluster::SetZ(Int_t i, Float_t Z)
328 {
329   // Setting Z value of the cluste
330   if (i==0 || i==1) {
331     fZ[i]=Z;
332     return 1;
333   }
334   else return 0;
335 }
336 //____________________________________________________
337 Int_t AliMUONRawCluster::SetTrack(Int_t i, Int_t track)
338 {
339   // Setting tracks contributing to the cluster
340   if (i==0 || i==1 || i==2) {
341     fTracks[i]=track;
342     return 1;
343   }
344   else return 0;
345 }
346 //____________________________________________________
347 Int_t AliMUONRawCluster::SetPeakSignal(Int_t i, Int_t peaksignal)
348 {
349   // Setting PeakSignal of the cluster
350   if (i==0 || i==1 ) {
351     fPeakSignal[i]=peaksignal;
352     return 1;
353   }
354   else return 0;
355 }
356 //____________________________________________________
357 Int_t AliMUONRawCluster::SetMultiplicity(Int_t i, Int_t mul)
358 {
359   // Setting multiplicity of the cluster
360   if (i==0 || i==1 ) {
361     fMultiplicity[i]=mul;
362     return 1;
363   }
364   else return 0;
365 }
366 //____________________________________________________
367 Int_t AliMUONRawCluster::SetClusterType(Int_t type)
368 {
369   // Setting the cluster type
370   fClusterType=type;
371   return 1;
372 }
373 //____________________________________________________
374 Int_t AliMUONRawCluster::SetGhost(Int_t ghost)
375 {
376   // Setting the ghost
377   fGhost=ghost;
378   return 1;
379 }
380 //____________________________________________________
381 Int_t AliMUONRawCluster::SetNcluster(Int_t i, Int_t ncluster)
382 {
383   // Setting number the cluster
384   if (i==0 || i==1 ) {
385     fNcluster[i]=ncluster;
386     return 1;
387   }
388   else return 0;
389 }
390 //____________________________________________________
391 Int_t AliMUONRawCluster::SetChi2(Int_t i, Float_t chi2)
392 {
393   // Setting chi2 of the cluster
394   if (i==0 || i==1) {
395     fChi2[i]=chi2;
396     return 1;
397   }
398   else return 0;
399 }