Making online tracklets usable in offline reconstruction
[u/mrichter/AliRoot.git] / TRD / AliTRDarrayDictionary.cxx
1 /************************************************************************* 
2 * Copyright(c) 1998-2008, 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: AliTRDarrayDictionary.cxx 25392 2008-04-23 19:40:29Z cblume $ */
17
18 /////////////////////////////////////////////////////////
19 //                                                     //
20 // Container Class for Dictionary Info                 //
21 //                                                     //
22 // Author:                                             //
23 //   Hermes Leon Vargas (hleon@ikf.uni-frankfurt.de)   //
24 //                                                     //
25 /////////////////////////////////////////////////////////
26
27 #include "AliTRDarrayDictionary.h"
28 #include "TArray.h"
29
30 ClassImp(AliTRDarrayDictionary)
31
32 //________________________________________________________________________________
33 AliTRDarrayDictionary::AliTRDarrayDictionary()
34                       :TObject()
35                       ,fNdet(0)
36                       ,fNrow(0)
37                       ,fNcol(0)
38                       ,fNtime(0)
39                       ,fNDdim(0)
40                       ,fDictionary(0)
41 {
42   //
43   // AliTRDarrayDictionary default contructor
44   //
45
46 }
47
48 //________________________________________________________________________________
49 AliTRDarrayDictionary::AliTRDarrayDictionary(Int_t nrow, Int_t ncol, Int_t ntime)
50                       :TObject()
51                       ,fNdet(0)
52                       ,fNrow(0)
53                       ,fNcol(0)
54                       ,fNtime(0)
55                       ,fNDdim(0)
56                       ,fDictionary(0)
57
58 {
59   //
60   // AliTRDarrayDictionary contructor
61   //
62
63   Allocate(nrow,ncol,ntime);
64
65 }
66
67 //________________________________________________________________________________
68 AliTRDarrayDictionary::AliTRDarrayDictionary(const AliTRDarrayDictionary &a)
69                       :TObject()
70                       ,fNdet(a.fNdet)
71                       ,fNrow(a.fNrow)
72                       ,fNcol(a.fNcol)
73                       ,fNtime(a.fNtime)
74                       ,fNDdim(a.fNDdim)
75                       ,fDictionary(0)
76 {
77   //
78   // AliTRDarrayDictionary copy constructor
79   //
80
81   fDictionary = new Int_t[fNDdim];
82   for(Int_t i=0; i<fNDdim; i++)
83     {
84       fDictionary[i]=a.fDictionary[i];
85     }
86
87 }
88
89 //________________________________________________________________________________
90 AliTRDarrayDictionary::~AliTRDarrayDictionary()
91 {
92   //
93   //   AliTRDarrayDictionary destructor
94   //
95
96   if(fDictionary)
97     {
98       delete [] fDictionary;
99       fDictionary=0;
100     }
101
102 }
103
104 //________________________________________________________________________________
105 AliTRDarrayDictionary &AliTRDarrayDictionary::operator=(const AliTRDarrayDictionary &a)
106 {
107   //
108   // Assignment operator
109   //
110
111   if(this==&a)
112     {
113       return *this;
114     }
115
116   if(fDictionary)
117     {
118       delete [] fDictionary;
119     }
120   fNdet=a.fNdet;
121   fNDdim=a.fNDdim;
122   fNrow=a.fNrow;
123   fNcol=a.fNcol;
124   fNtime=a.fNtime;
125   fDictionary = new Int_t[fNDdim];
126   for(Int_t i=0; i<fNDdim; i++)
127     {
128       fDictionary[i]=a.fDictionary[i];
129     }
130   return *this;
131
132 }
133
134 //________________________________________________________________________________
135 void AliTRDarrayDictionary::Allocate(Int_t nrow, Int_t ncol, Int_t ntime)
136 {
137   //
138   // Allocates memory for the dictionary array with dimensions
139   // Row*Col*Time
140   // Object initialized to -1
141   //
142
143   fNrow=nrow;
144   fNcol=ncol;
145   fNtime=ntime;
146   fNDdim=nrow*ncol*ntime;
147   if(fDictionary)
148     {
149       delete [] fDictionary;
150       fDictionary=0;
151     }
152   fDictionary = new Int_t[fNDdim];
153   for(Int_t i=0; i<fNDdim; i++)
154     {
155       fDictionary[i] = -1; 
156     }
157
158 }
159
160 //________________________________________________________________________________
161 void AliTRDarrayDictionary::Compress()
162 {
163   //
164   // Compress the array
165   //
166
167
168   //  AliDebug(1,"Compressing");
169   Int_t counter=0;
170   Int_t newDim=0;
171   Int_t j;                 
172   Int_t r=0;
173   Int_t *longArr;            
174   longArr = new Int_t[fNDdim];  
175   Int_t k=0;
176   for(Int_t i=0; i<fNDdim;i++)
177     {
178       longArr[i]=0;  
179     }
180   for(Int_t i=0;i<fNDdim; i++)
181     {
182       j=0;
183       if(fDictionary[i]==-1)
184         {
185           for(k=i;k<fNDdim;k++)
186             {
187               if(fDictionary[k]==-1)
188                 {
189                   j=j+1;
190                   longArr[r]=j;
191                 }
192               else
193                 {
194                   break;
195                 }
196             } 
197           r=r+1;    
198         }
199       i=i+j;
200     }
201   //Calculate the size of the compressed array
202   for(Int_t i=0; i<fNDdim;i++)
203     {
204       if(longArr[i]!=0)  
205         {
206           counter=counter+longArr[i]-1;
207         }
208     }
209   newDim=fNDdim-counter;   //Size of the compressed array
210   //Fill the buffer of the compressed array
211   Int_t* buffer;
212   buffer = new Int_t[newDim];
213   Int_t counterTwo=0;
214   Int_t g=0;
215   for(Int_t i=0; i<newDim; i++)
216     {
217       if(counterTwo<fNDdim)
218         {
219           if(fDictionary[counterTwo]!=-1)
220             {
221               buffer[i]=fDictionary[counterTwo];
222             }
223           if(fDictionary[counterTwo]==-1)
224             {
225               buffer[i]=-(longArr[g]);
226               counterTwo=counterTwo+longArr[g]-1;
227               g++;
228             }  
229           counterTwo++;
230         }
231     }
232
233   //Copy the buffer
234   if(fDictionary)
235     {
236       delete [] fDictionary;
237       fDictionary=0;
238     }
239   fDictionary = new Int_t[newDim];
240   fNDdim = newDim;
241   for(Int_t i=0; i<newDim; i++)
242     {
243       fDictionary[i] = buffer[i]; 
244     }
245   if(buffer)
246     {
247       delete [] buffer;
248       buffer=0;
249     }
250   if(longArr) 
251     {
252       delete [] longArr;
253       longArr=0;
254     }
255
256 }
257
258 //________________________________________________________________________________
259 void AliTRDarrayDictionary::Expand()
260 {
261   //  
262   //  Expand the array
263   //  
264
265   Int_t *longArr;
266   longArr = new Int_t[fNDdim];
267   Int_t dimexp=0;
268   for(Int_t i=0; i<fNDdim;i++)
269     {
270       longArr[i]=0;
271     }
272   Int_t r2=0;
273   for(Int_t i=0; i<fNDdim;i++)
274     {
275       if((fDictionary[i]<0)&&(fDictionary[i]!=-1))  
276         {
277           longArr[r2]=-fDictionary[i]; 
278           r2++;
279         }
280     }
281
282   //Calculate new dimensions
283   for(Int_t i=0; i<fNDdim;i++)
284     {
285       if(longArr[i]!=0)      
286         {
287           dimexp=dimexp+longArr[i]-1;
288         }
289     }
290   dimexp=dimexp+fNDdim;  
291
292   //Write in the buffer the new array
293   Int_t* bufferE;
294   bufferE = new Int_t[dimexp];
295   Int_t contaexp =0;    
296   Int_t h=0;
297   for(Int_t i=0; i<dimexp; i++)
298     {
299       if(fDictionary[contaexp]>=-1)  
300         {
301           bufferE[i]=fDictionary[contaexp];
302         }
303       if(fDictionary[contaexp]<-1)  
304         {
305           for(Int_t j=0; j<longArr[h];j++)
306             {
307               bufferE[i+j]=-1;
308             }
309           i=i+longArr[h]-1;
310           h++;
311         }
312       contaexp++;
313     }
314
315   //Copy the buffer
316   if(fDictionary)
317     {
318       delete [] fDictionary;
319       fDictionary=0;
320     }
321
322   fDictionary = new Int_t[dimexp];
323   fNDdim = dimexp;
324   for(Int_t i=0; i<dimexp; i++)
325     {
326       fDictionary[i] = bufferE[i]; 
327     }
328   if(bufferE) delete [] bufferE;
329   if(longArr) delete [] longArr;
330
331 }
332 //________________________________________________________________________________
333 void AliTRDarrayDictionary::Reset()
334 {
335   //
336   // Reset the array, the old contents are deleted
337   // and the data array elements are set to zero.
338   //
339
340   memset(fDictionary,0,sizeof(Int_t)*fNDdim);
341
342 }