Print removed
[u/mrichter/AliRoot.git] / ITS / AliITSclusterSSD.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 #include <Riostream.h>
19 #include "TArrayI.h"
20 #include "TClonesArray.h"
21 #include "AliITSdigitSSD.h"
22 #include "AliITSclusterSSD.h"
23
24 ClassImp(AliITSclusterSSD)
25
26 //______________________________________________________________________
27 AliITSclusterSSD::AliITSclusterSSD(){
28     // default constructor
29
30     fSide        = kTRUE;
31     fDigits      = 0;
32     fNDigits     = 0;
33     fDigitsIndex = 0;
34     fNCrosses    = 0;
35     fTotalSignal = -1;
36     fNTracks      = -1;
37     fLeftNeighbour  = kFALSE;
38     fRightNeighbour = kFALSE;
39     fCrossedClusterIndexes = 0;
40     fConsumed=kFALSE;
41 }
42 //______________________________________________________________________
43 AliITSclusterSSD::AliITSclusterSSD(Int_t ndigits, Int_t *DigitIndexes, 
44                                    TObjArray *Digits, Bool_t side){
45     // non-default constructor
46
47     fNDigits = ndigits;
48     fDigits = Digits;
49     fSide = side;
50     fDigitsIndex = new TArrayI(fNDigits,DigitIndexes ); 
51     fNCrosses    = 0;
52     fCrossedClusterIndexes = new TArrayI(300);
53     fLeftNeighbour  = kFALSE;
54     fRightNeighbour = kFALSE;
55     fTotalSignal =-1;
56     fNTracks    = -1;
57     fConsumed=kFALSE;
58 }
59 //______________________________________________________________________
60 AliITSclusterSSD::~AliITSclusterSSD(){
61     // destructor
62
63     delete fDigitsIndex;
64     delete fCrossedClusterIndexes;
65 }
66 //______________________________________________________________________
67 AliITSclusterSSD::AliITSclusterSSD(const AliITSclusterSSD &OneSCluster) : 
68     TObject(OneSCluster){
69     // copy constructor
70
71     if (this == &OneSCluster) return;
72     fNDigits = OneSCluster.fNDigits;
73     fSide=OneSCluster.fSide;
74     fDigits=OneSCluster.fDigits;
75     fDigitsIndex = new TArrayI(fNDigits);
76     fLeftNeighbour  = OneSCluster.fLeftNeighbour;
77     fRightNeighbour = OneSCluster.fRightNeighbour;
78     fTotalSignal =-1;
79     fNTracks     = -1;
80     fNCrosses = OneSCluster.fNCrosses;
81     fConsumed = OneSCluster.fConsumed;
82     Int_t i;
83     for (i = 0; i< fNCrosses ; i++){
84         fCrossedClusterIndexes[i] = OneSCluster.fCrossedClusterIndexes[i];
85     }
86     for (i = 0; i< fNDigits ; i++){
87         fDigitsIndex[i]=OneSCluster.fDigitsIndex[i];
88     }
89     return;
90 }
91 //______________________________________________________________________
92 AliITSclusterSSD& AliITSclusterSSD::operator=(const AliITSclusterSSD 
93                                               &OneSCluster){
94     // assignment operator
95
96     if (this == &OneSCluster) return *this;
97     fNDigits = OneSCluster.fNDigits;
98     fSide=OneSCluster.fSide;
99     fDigits=OneSCluster.fDigits;
100     fDigitsIndex = new TArrayI(fNDigits);
101     fLeftNeighbour  = OneSCluster.fLeftNeighbour;
102     fRightNeighbour = OneSCluster.fRightNeighbour;
103     fTotalSignal =-1;
104     fNTracks     = -1;
105     fNCrosses = OneSCluster.fNCrosses;
106     fConsumed = OneSCluster.fConsumed;
107     Int_t i;
108     for (i = 0; i< fNCrosses ; i++){
109         fCrossedClusterIndexes[i] = OneSCluster.fCrossedClusterIndexes[i];
110     }
111     for (i = 0; i< fNDigits ; i++){
112         fDigitsIndex[i]=OneSCluster.fDigitsIndex[i];
113     }
114     return *this;
115 }
116 //______________________________________________________________________
117 Int_t AliITSclusterSSD::SplitCluster(Int_t where, Int_t *outdigits){
118     //This methods generate data necessery to make new object of this class
119     //I choosen this way, because methods TClonesArray::Add* dont work
120     //so I have to use constraction: new (a[i]) Creator(params...);
121     //where 'a' is a TClonesArray 
122     //This method generate params - see AliITSmoduleSSD::SplitCluster;
123     Int_t tmp = fNDigits;
124     Int_t ind = 0;
125
126     outdigits[ind++]=(*fDigitsIndex)[where];
127     //coping border strip (it is shared by this two clusters)
128     for (Int_t i = (where+1); i < tmp; i++) {
129         outdigits[ind++]=(*fDigitsIndex)[i];  
130         //"moving" strips from this to the new one 
131         (*fDigitsIndex)[i]=-1;   
132         fNDigits--;   //deleting strips from this cluster
133     } 
134     return ind;         
135 }
136 //______________________________________________________________________
137 Int_t AliITSclusterSSD::GetDigitStripNo(Int_t digit){
138     // return strip no of a digit
139     if (digit<0) return -1;
140     return (digit>(fNDigits-1)) ? -1 :
141         ((AliITSdigitSSD*)(fDigits->At((*fDigitsIndex)[digit])))->GetStripNumber();
142 }
143 //______________________________________________________________________
144 Int_t AliITSclusterSSD::GetDigitSignal(Int_t digit){
145     // returns digit signal
146     Int_t index,signal;
147     if (digit<0||digit>=fNDigits) return -1;
148     index  = (*fDigitsIndex)[digit];
149     signal = ((AliITSdigitSSD*)(fDigits->At(index)))->GetSignal();
150     /*
151       if(signal>1.e5) printf("GetDigitSignal: digit %d index %d signal %d\n",
152       digit,index, signal);
153     */
154     return  signal;
155 }
156 //______________________________________________________________________
157 void  AliITSclusterSSD::AddCross(Int_t clIndex){
158     // add cluster cross to list of cluster crosses
159   
160     (*fCrossedClusterIndexes)[fNCrosses++] = clIndex;
161 }
162 //______________________________________________________________________
163 Int_t AliITSclusterSSD::GetCross(Int_t crIndex){
164     // return crossing cluster
165
166     return ((crIndex>-1)&&(crIndex<fNCrosses))?(*fCrossedClusterIndexes)[crIndex]:-1;
167 }
168 //______________________________________________________________________
169 Double_t AliITSclusterSSD::CentrOfGravity(){
170     // return center of gravity of the cluster
171     Float_t ret=0;
172   
173     if (fLeftNeighbour) ret+=(GetDigitStripNo(0)*0.5*GetDigitSignal(0));
174     else ret+=(GetDigitStripNo(0)*GetDigitSignal(0));
175     if (fRightNeighbour) ret+=(GetDigitStripNo(fNDigits -1)*0.5*GetDigitSignal(fNDigits -1));
176     else ret+=(GetDigitStripNo(fNDigits -1)*GetDigitSignal(fNDigits-1));
177     for (Int_t i=1;i<fNDigits-1;i++){
178         ret +=GetDigitStripNo(i)*GetDigitSignal(i);
179     }// end for i
180   
181     if (fTotalSignal<0) GetTotalSignal();
182         
183     return (ret/fTotalSignal);
184 }
185 //______________________________________________________________________
186 Float_t AliITSclusterSSD::GetTotalSignal(){
187     // return total signal
188   
189     if(fTotalSignal <0){
190         fTotalSignal=0;
191         if (fNDigits ==1)  {
192             fTotalSignal = (Float_t)GetDigitSignal(0);
193             //printf("1 digit: signal %d \n",GetDigitSignal(0)); 
194             return fTotalSignal;
195         }
196         if (fLeftNeighbour) fTotalSignal += (Float_t)(0.5*GetDigitSignal(0));
197         else fTotalSignal += (Float_t) GetDigitSignal(0);
198         //printf("GetTotalSignal :i DigitSignal %d %d \n",0,GetDigitSignal(0));
199         if (fRightNeighbour) fTotalSignal += (Float_t)(0.5*GetDigitSignal(
200                                                                  fNDigits -1));
201       else fTotalSignal += (Float_t)GetDigitSignal(fNDigits-1);
202         //printf("GetTotalSignal :i  DigitSignal %d %d \n",fNDigits -1,GetDigitSignal(fNDigits -1));
203         for (Int_t i = 1;i<fNDigits -1;i++){
204             fTotalSignal += (Float_t)GetDigitSignal(i);
205             //printf("GetTotalSignal :i  DigitSignal %d %d \n",i,GetDigitSignal(i)); 
206         }
207         //printf("GetTotalSignal: fNDigits %d fTotalSignal %.0f \n",fNDigits,fTotalSignal); 
208     }
209     return fTotalSignal;
210 }
211 //______________________________________________________________________
212 Float_t  AliITSclusterSSD::GetTotalSignalError(){
213     // return the error on the signal
214     Float_t err =0;
215     for (Int_t i =1; i<fNDigits -1; i++){
216         err+=0.1*GetDigitSignal(i);   
217     } 
218     if (GetLeftNeighbour()){
219         err+=GetDigitSignal(0);
220     }else{
221         err+=0.1*GetDigitSignal(0);
222     } 
223     if (GetRightNeighbour()){
224         err+=GetDigitSignal(fNDigits -1);
225     }else{
226         err+=0.1*GetDigitSignal(fNDigits -1);
227     }
228     return err;
229 }
230 //______________________________________________________________________
231 void AliITSclusterSSD::DelCross(Int_t index){
232     // remove cross clusters from the list of cross clusters
233     Int_t i,j; //iterators
234
235     for (i =0;i<fNCrosses;i++){
236         if ((*fCrossedClusterIndexes)[i] == index){
237             for (j=i;j<fNCrosses-1;j++){
238                 (*fCrossedClusterIndexes)[j]=(*fCrossedClusterIndexes)[j+1];
239             }
240             fNCrosses--;
241             return; 
242         }
243     }
244 }
245 //______________________________________________________________________
246 Int_t  *AliITSclusterSSD::GetTracks(Int_t &nt){
247     // return the track number of the cluster
248     Int_t ntrk = GetDigit(0)->GetNTracks();
249     Int_t ndig = GetNumOfDigits();
250     Int_t *idig = new Int_t[ndig];
251     Int_t *sdig = new Int_t[ndig];
252     Int_t *itrk = new Int_t[ndig*ntrk];
253     Int_t i,j,k,l,trk;
254     Bool_t b;
255
256     for(i=0;i<ndig;i++){idig[i] = i;sdig[i] = GetDigit(i)->GetSignal();}
257     TMath::Sort(ndig,sdig,idig,kTRUE);
258     for(i=0;i<ndig*ntrk;i++) itrk[i] = -3;
259     j = k = l = 0;
260     for(i=0;i<ndig;i++){ // fill itrk with track numbers in order of digit size
261         j = idig[i];
262         for(k=0;k<ntrk;k++) if((trk = GetDigit(j)->GetTrack(k))>=0) {
263             itrk[l] = trk;
264             l++;
265         } // end for k/if
266     } // end for i
267     for(i=0;i<10;i++) fTrack[i] = -3;
268     fTrack[0] = itrk[0]; // first element
269     k = 1;
270     b = kTRUE;
271     for(i=1;i<l;i++){
272         for(j=0;j<k;j++) if(fTrack[j]==itrk[i]) b = kFALSE;
273         if(b){fTrack[k] = itrk[i]; k++;}
274         if(k>9) break;
275     } // end for i
276     nt = k;
277
278     delete[] idig;
279     delete[] sdig;
280     delete[] itrk;
281
282     return fTrack;
283 /*
284     Int_t *tidx=0;
285     Int_t i, j,n;
286     Int_t bit =0;
287     Int_t ntracks=0;
288     nt=0;
289
290     for (i=0;i<10;i++) fTrack[i] = -3;
291    
292     //cout<<"GetTrack start -------: fNDigits ="<<fNDigits<<endl;
293
294     for (i = 0; i<fNDigits; i++) {
295         tidx = GetDigit(i)->GetTracks();
296         n    = GetDigit(i)->GetNTracks();
297         for (j = 0; j<n && j<10;j++) {
298             if (tidx[j] >= 0) {
299                 if(ntracks == 0){
300                     fTrack[ntracks] = tidx[j];
301                     ntracks++; 
302                 }else if(tidx[j] != fTrack[ntracks-1]){
303                     ntracks++; 
304                     if(ntracks > 9) {
305                         bit = 1;
306                         break;
307                     } // end if ntracks > 9
308                     fTrack[ntracks-1] = tidx[j];
309                 } // end if ntracke == 0
310             } // end if tidx[j] >=0
311         } // 3-tracks loop for the digit 
312         if(bit == 1) break;
313     } // digit loop
314
315     SetNTracks(ntracks); 
316     nt = ntracks;
317     return &(fTrack[0]);
318 */
319 }
320 //______________________________________________________________________
321 Double_t AliITSclusterSSD::GetPosition(){
322     // return position of the cluster
323     Float_t ret;
324
325     switch(fNDigits){
326     case  1:
327         ret = GetDigitStripNo(0);
328         break;
329     case  2:
330         ret = EtaAlgorithm();
331         break;       
332     default:
333         ret = CentrOfGravity();   
334     }
335     return ret;
336 }
337 //______________________________________________________________________
338 Double_t AliITSclusterSSD::EtaAlgorithm(){
339     // algorithm for determing cluster position
340     if (fNDigits != 2) return -1;
341
342     Int_t strip1  = GetDigit(0)->GetStripNumber(); 
343     Int_t strip2  = GetDigit(1)->GetStripNumber();
344     Int_t signal1 = GetDigit(0)->GetSignal();
345     Int_t signal2 = GetDigit(1)->GetSignal();
346
347     Double_t eta;
348   
349  
350     if (strip1<strip2){
351         eta = ((Double_t)signal2)/((Double_t)(signal1+signal2));
352         if (eta<0.04) return strip1;
353         if (eta>0.96) return strip2;
354         return (strip1 + 0.43478261*eta + 0.2826087);   
355     } else{
356         eta = ((Double_t)signal1)/((Double_t)(signal1+signal2));
357         if (eta<0.04) return strip2;
358         if (eta>0.96) return strip1;
359         return (strip2 + 0.43478261*eta + 0.2826087);   
360     }
361 }
362 //______________________________________________________________________
363 Double_t  AliITSclusterSSD::GetPositionError(){
364     // return the position error
365     return (GetNumOfDigits()+1)/2;
366 }
367 //______________________________________________________________________
368 Bool_t AliITSclusterSSD::IsCrossingWith(Int_t idx){
369     // return the cluster to which he crosses
370
371     for (Int_t i =0; i< fNCrosses;i++){
372         if (GetCross(i) == idx) return kTRUE;
373     }
374     return kFALSE;
375 }