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