3 #include "AliITSdigit.h"
4 #include "AliITSclusterSSD.h"
6 ClassImp(AliITSclusterSSD)
8 AliITSclusterSSD::AliITSclusterSSD()
10 // default constructor
18 fLeftNeighbour = kFALSE;
19 fRightNeighbour = kFALSE;
20 fCrossedClusterIndexes = new TArrayI(300);
24 /*************************************************************************/
26 AliITSclusterSSD::AliITSclusterSSD
27 (Int_t ndigits, Int_t *DigitIndexes,
28 TObjArray *Digits, Bool_t side)
30 // non-default constructor
35 fDigitsIndex = new TArrayI(fNDigits,DigitIndexes );
37 fCrossedClusterIndexes = new TArrayI(300);
38 fLeftNeighbour = kFALSE;
39 fRightNeighbour = kFALSE;
44 /*************************************************************************/
45 AliITSclusterSSD::~AliITSclusterSSD()
49 delete fCrossedClusterIndexes;
52 /*************************************************************************/
53 AliITSclusterSSD::AliITSclusterSSD(const AliITSclusterSSD &OneSCluster)
56 if (this == &OneSCluster) return;
57 fNDigits = OneSCluster.fNDigits;
58 fSide=OneSCluster.fSide;
59 fDigits=OneSCluster.fDigits;
60 fDigitsIndex = new TArrayI(fNDigits);
61 fLeftNeighbour = OneSCluster.fLeftNeighbour;
62 fRightNeighbour = OneSCluster.fRightNeighbour;
65 fNCrosses = OneSCluster.fNCrosses;
66 fConsumed = OneSCluster.fConsumed;
68 for (i = 0; i< fNCrosses ; i++)
70 fCrossedClusterIndexes[i] = OneSCluster.fCrossedClusterIndexes[i];
72 for (i = 0; i< fNDigits ; i++)
74 fDigitsIndex[i]=OneSCluster.fDigitsIndex[i];
79 /*************************************************************************/
80 AliITSclusterSSD& AliITSclusterSSD::operator=(const AliITSclusterSSD & OneSCluster)
82 // assignment operator
83 if (this == &OneSCluster) return *this;
84 fNDigits = OneSCluster.fNDigits;
85 fSide=OneSCluster.fSide;
86 fDigits=OneSCluster.fDigits;
87 fDigitsIndex = new TArrayI(fNDigits);
88 fLeftNeighbour = OneSCluster.fLeftNeighbour;
89 fRightNeighbour = OneSCluster.fRightNeighbour;
92 fNCrosses = OneSCluster.fNCrosses;
93 fConsumed = OneSCluster.fConsumed;
95 for (i = 0; i< fNCrosses ; i++)
97 fCrossedClusterIndexes[i] = OneSCluster.fCrossedClusterIndexes[i];
99 for (i = 0; i< fNDigits ; i++)
101 fDigitsIndex[i]=OneSCluster.fDigitsIndex[i];
106 /*************************************************************************/
107 Int_t AliITSclusterSSD::SplitCluster(Int_t where, Int_t *outdigits)
109 //This methods generate data necessery to make new object of this class
110 //I choosen this way, because methods TClonesArray::Add* dont work
111 //so I have to use constraction: new (a[i]) Creator(params...);
112 //where 'a' is a TClonesArray
113 //This method generate params - see AliITSmoduleSSD::SplitCluster;
116 Int_t tmp = fNDigits;
118 outdigits[ind++]=(*fDigitsIndex)[where];
119 //coping border strip (it is shared by this two clusters)
120 for (Int_t i = (where+1); i < tmp; i++)
122 outdigits[ind++]=(*fDigitsIndex)[i]; //"moving" strips from this to the new one
123 (*fDigitsIndex)[i]=-1;
124 fNDigits--; //deleting strips from this cluster
129 /*******************************************************************/
130 Int_t AliITSclusterSSD::GetDigitStripNo(Int_t digit)
132 // return strip no of a digit
133 if (digit<0) return -1;
134 return (digit>(fNDigits-1))?-1 :
135 ((AliITSdigitSSD*)((*fDigits)[(*fDigitsIndex)[digit]]))->GetStripNumber();
137 /************************************************************/
138 Int_t AliITSclusterSSD::GetDigitSignal(Int_t digit)
140 // returns digit signal
142 if (digit<0||digit>=fNDigits) return -1;
143 index = (*fDigitsIndex)[digit];
144 signal = ((AliITSdigitSSD*)((*fDigits)[index]))->GetSignal();
146 if(signal>1.e5) printf("GetDigitSignal: digit %d index %d signal %d\n",
147 digit,index, signal);
152 /***********************************************************/
153 void AliITSclusterSSD::AddCross(Int_t clIndex)
155 // add cluster cross to list of cluster crosses
157 (*fCrossedClusterIndexes)[fNCrosses++] = clIndex;
159 /***********************************************************/
161 Int_t AliITSclusterSSD::GetCross(Int_t crIndex)
163 // return crossing cluster
165 return ((crIndex>-1)&&(crIndex<fNCrosses))?(*fCrossedClusterIndexes)[crIndex]:-1;
167 /***********************************************************/
168 Double_t AliITSclusterSSD::CentrOfGravity()
170 // return center of gravity of the cluster
173 if (fLeftNeighbour) ret+=(GetDigitStripNo(0)*0.5*GetDigitSignal(0));
174 else ret+=(GetDigitStripNo(0)*GetDigitSignal(0));
176 if (fRightNeighbour) ret+=(GetDigitStripNo(fNDigits -1)*0.5*GetDigitSignal(fNDigits -1));
177 else ret+=(GetDigitStripNo(fNDigits -1)*GetDigitSignal(fNDigits-1));
179 for (Int_t i=1;i<fNDigits-1;i++)
181 ret +=GetDigitStripNo(i)*GetDigitSignal(i);
184 if (fTotalSignal<0) GetTotalSignal();
186 return (ret/fTotalSignal);
189 /***********************************************************/
190 Float_t AliITSclusterSSD::GetTotalSignal()
192 // return total signal
198 fTotalSignal = (Float_t)GetDigitSignal(0);
199 //printf("1 digit: signal %d \n",GetDigitSignal(0));
203 if (fLeftNeighbour) fTotalSignal += (Float_t)(0.5*GetDigitSignal(0));
204 else fTotalSignal += (Float_t) GetDigitSignal(0);
205 //printf("GetTotalSignal :i DigitSignal %d %d \n",0,GetDigitSignal(0));
207 if (fRightNeighbour) fTotalSignal += (Float_t)(0.5*GetDigitSignal(fNDigits -1));
208 else fTotalSignal += (Float_t)GetDigitSignal(fNDigits-1);
209 //printf("GetTotalSignal :i DigitSignal %d %d \n",fNDigits -1,GetDigitSignal(fNDigits -1));
211 for (Int_t i = 1;i<fNDigits -1;i++)
213 fTotalSignal += (Float_t)GetDigitSignal(i);
214 //printf("GetTotalSignal :i DigitSignal %d %d \n",i,GetDigitSignal(i));
216 //printf("GetTotalSignal: fNDigits %d fTotalSignal %.0f \n",fNDigits,fTotalSignal);
220 /***********************************************************/
222 Float_t AliITSclusterSSD::GetTotalSignalError()
224 // return the error on the signal
226 for (Int_t i =1; i<fNDigits -1; i++)
228 err+=0.1*GetDigitSignal(i);
230 if (GetLeftNeighbour())
232 err+=GetDigitSignal(0);
236 err+=0.1*GetDigitSignal(0);
238 if (GetRightNeighbour())
240 err+=GetDigitSignal(fNDigits -1);
244 err+=0.1*GetDigitSignal(fNDigits -1);
250 /***********************************************************/
252 void AliITSclusterSSD::DelCross(Int_t index)
254 // remove cross clusters from the list of cross clusters
255 Int_t i,j; //iterators
257 for (i =0;i<fNCrosses;i++)
259 if ((*fCrossedClusterIndexes)[i] == index)
261 for (j=i;j<fNCrosses-1;j++)
263 (*fCrossedClusterIndexes)[j]=(*fCrossedClusterIndexes)[j+1];
271 /***********************************************************/
273 Int_t *AliITSclusterSSD::GetTracks(Int_t &nt)
275 // return the track number of the cluster
288 tidx=GetDigit(0)->GetTracks();
293 if (fTrack[i] != 0) fNTrack++;
295 for (i = 1; i<fNDigits; i++)
297 tidx=GetDigit(i)->GetTracks();
298 for (Int_t j = 0; j<3;j++)
301 if (tidx[j]==0) break;
302 for (Int_t k = 0; k < fNTrack;k++)
304 if (tidx[j]==fTrack[k]) bit =0;
306 if (bit) fTrack[fNTrack++]=tidx[j];
313 cout<<"\n\n Error AliITSclusterSSD::GetTracks OUT "<<fNDigits<<" "<<fNTrack<<"\n\n\n\n\n";
322 /***********************************************************/
324 Double_t AliITSclusterSSD::GetPosition()
326 // return position of the cluster
331 ret = GetDigitStripNo(0);
334 ret = EtaAlgorithm();
337 ret = CentrOfGravity();
342 /***********************************************************/
344 Double_t AliITSclusterSSD::EtaAlgorithm()
346 // algorithm for determing cluster position
347 if (fNDigits != 2) return -1;
349 Int_t strip1 = GetDigit(0)->GetStripNumber();
350 Int_t strip2 = GetDigit(1)->GetStripNumber();
351 Int_t signal1 = GetDigit(0)->GetSignal();
352 Int_t signal2 = GetDigit(1)->GetSignal();
359 eta = ((Double_t)signal2)/((Double_t)(signal1+signal2));
360 if (eta<0.04) return strip1;
361 if (eta>0.96) return strip2;
362 return (strip1 + 0.43478261*eta + 0.2826087);
366 eta = ((Double_t)signal1)/((Double_t)(signal1+signal2));
367 if (eta<0.04) return strip2;
368 if (eta>0.96) return strip1;
369 return (strip2 + 0.43478261*eta + 0.2826087);
375 Double_t AliITSclusterSSD::GetPositionError()
377 // return the position error
378 return (GetNumOfDigits()+1)/2;
381 Bool_t AliITSclusterSSD::IsCrossingWith(Int_t idx)
383 // return the cluster to which he crosses
384 for (Int_t i =0; i< fNCrosses;i++)
386 if (GetCross(i) == idx) return kTRUE;