Merge branch 'master' of https://git.cern.ch/reps/AliRoot
[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 <TArray.h>
28
29 #include "AliTRDarrayDictionary.h"
30 #include "AliTRDfeeParam.h"
31 #include "AliLog.h"
32
33 ClassImp(AliTRDarrayDictionary)
34
35 Short_t *AliTRDarrayDictionary::fgLutPadNumbering = 0x0;
36
37 //________________________________________________________________________________
38 AliTRDarrayDictionary::AliTRDarrayDictionary()
39                       :TObject()
40                       ,fNdet(0)
41                       ,fNrow(0)
42                       ,fNcol(0)
43                       ,fNumberOfChannels(0)
44                       ,fNtime(0)
45                       ,fNDdim(0)
46                       ,fDictionary(0)
47                       ,fFlag(kFALSE)
48 {
49   //
50   // AliTRDarrayDictionary default contructor
51   //
52
53   CreateLut();
54
55 }
56
57 //________________________________________________________________________________
58 AliTRDarrayDictionary::AliTRDarrayDictionary(Int_t nrow, Int_t ncol, Int_t ntime)
59                       :TObject()
60                       ,fNdet(0)
61                       ,fNrow(0)
62                       ,fNcol(0)
63                       ,fNumberOfChannels(0)
64                       ,fNtime(0)
65                       ,fNDdim(0)
66                       ,fDictionary(0)
67                       ,fFlag(kFALSE)
68 {
69   //
70   // AliTRDarrayDictionary contructor
71   //
72
73   CreateLut();
74   Allocate(nrow,ncol,ntime);
75
76 }
77
78 //________________________________________________________________________________
79 AliTRDarrayDictionary::AliTRDarrayDictionary(const AliTRDarrayDictionary &a)
80                       :TObject()
81                       ,fNdet(a.fNdet)
82                       ,fNrow(a.fNrow)
83                       ,fNcol(a.fNcol)
84                       ,fNumberOfChannels(a.fNumberOfChannels)
85                       ,fNtime(a.fNtime)
86                       ,fNDdim(a.fNDdim)
87                       ,fDictionary(0)
88                       ,fFlag(a.fFlag)
89 {
90   //
91   // AliTRDarrayDictionary copy constructor
92   //
93
94   fDictionary = new Int_t[fNDdim];
95   for(Int_t i=0; i<fNDdim; i++)
96     {
97       fDictionary[i]=a.fDictionary[i];
98     }
99
100 }
101
102 //________________________________________________________________________________
103 AliTRDarrayDictionary::~AliTRDarrayDictionary()
104 {
105   //
106   //   AliTRDarrayDictionary destructor
107   //
108
109   delete [] fDictionary;
110   fDictionary=0;
111
112 }
113
114 //________________________________________________________________________________
115 AliTRDarrayDictionary &AliTRDarrayDictionary::operator=(const AliTRDarrayDictionary &a)
116 {
117   //
118   // Assignment operator
119   //
120
121   if(this==&a)
122     {
123       return *this;
124     }
125
126   if(fDictionary)
127     {
128       delete [] fDictionary;
129     }
130   fNdet=a.fNdet;
131   fNDdim=a.fNDdim;
132   fNrow=a.fNrow;
133   fNcol=a.fNcol;
134   fNumberOfChannels = a.fNumberOfChannels;
135   fNtime=a.fNtime;
136   fDictionary = new Int_t[fNDdim];
137   for(Int_t i=0; i<fNDdim; i++)
138     {
139       fDictionary[i]=a.fDictionary[i];
140     }
141   fFlag=a.fFlag;
142   return *this;
143
144 }
145
146 //________________________________________________________________________________
147 void AliTRDarrayDictionary::Allocate(Int_t nrow, Int_t ncol, Int_t ntime)
148 {
149   //
150   // Allocates memory for the dictionary array with dimensions
151   // Row*NumberOfNecessaryMCMs*ADCchannelsInMCM*Time
152   // To be consistent with AliTRDarrayADC
153   // Object initialized to -1
154   //
155
156   fNrow=nrow;
157   fNcol=ncol;
158   fNtime=ntime;
159   Int_t adcchannelspermcm = AliTRDfeeParam::GetNadcMcm(); 
160   Int_t padspermcm = AliTRDfeeParam::GetNcolMcm(); 
161   Int_t numberofmcms = fNcol/padspermcm;
162   fNumberOfChannels = numberofmcms*adcchannelspermcm;
163   fNDdim=nrow*fNumberOfChannels*ntime;
164   if(fDictionary)
165     {
166       delete [] fDictionary;
167       fDictionary=0;
168     }
169   fDictionary = new Int_t[fNDdim];
170   memset(fDictionary,-1,sizeof(Int_t)*fNDdim);
171
172 }
173
174 //________________________________________________________________________________
175 void AliTRDarrayDictionary::Compress()
176 {
177   //
178   // Compress the array
179   //
180
181
182   //  AliDebug(1,"Compressing");
183   Int_t counter=0;
184   Int_t newDim=0;
185   Int_t j;                 
186   Int_t r=0;
187   Int_t k=0;
188
189   Int_t *longArr = new Int_t[fNDdim];  
190
191   if(longArr) 
192     {
193
194       memset(longArr,0,sizeof(Int_t)*fNDdim);
195
196       for(Int_t i=0;i<fNDdim; i++)
197         {
198           j=0;
199           if(fDictionary[i]==-1)
200             {
201               for(k=i;k<fNDdim;k++)
202                 {
203                   if(fDictionary[k]==-1)
204                     {
205                       j=j+1;
206                       longArr[r]=j;
207                     }
208                   else
209                     {
210                       break;
211                     }
212                 } 
213               r=r+1;    
214             }
215           i=i+j;
216         }
217
218       //Calculate the size of the compressed array
219       for(Int_t i=0; i<fNDdim;i++)
220         {
221           if(longArr[i]!=0)  
222             {
223               counter=counter+longArr[i]-1;
224             }
225         }
226       newDim=fNDdim-counter;   //Size of the compressed array
227
228       //Fill the buffer of the compressed array
229       Int_t* buffer = new Int_t[newDim];
230       Int_t counterTwo=0;
231       Int_t g=0;
232       if(buffer)
233         {
234           for(Int_t i=0; i<newDim; i++)
235             {
236               if(counterTwo<fNDdim)
237                 {
238                   if(fDictionary[counterTwo]!=-1)
239                     {
240                       buffer[i]=fDictionary[counterTwo];
241                     }
242                   if(fDictionary[counterTwo]==-1)
243                     {
244                       buffer[i]=-(longArr[g]);
245                       counterTwo=counterTwo+longArr[g]-1;
246                       g++;
247                     }  
248                   counterTwo++;
249                 }
250             }
251
252           //Copy the buffer
253           if(fDictionary)
254             {
255               delete [] fDictionary;
256               fDictionary=0;
257             }
258           fDictionary = buffer;
259           fNDdim = newDim;
260         }
261     
262       delete [] longArr;
263       longArr=0;
264     }
265   fFlag=kFALSE; // This way it can be expanded afterwards
266 }
267
268 //________________________________________________________________________________
269 void AliTRDarrayDictionary::Expand()
270 {
271   //  
272   //  Expand the array
273   //  
274
275   if(fNDdim==0)
276     {
277       AliError("Called expand with dimension zero");
278       return;    
279     }
280
281
282   Int_t dimexp=0;
283   
284 //   if(WasExpandCalled()) 
285 //     return;
286
287   if(fNDdim==fNrow*fNumberOfChannels*fNtime)
288     return;
289
290   if(fDictionary&&fNDdim==1)
291     { 
292       dimexp = -fDictionary[0]; 
293       delete [] fDictionary;
294       fDictionary=0;
295       fDictionary = new Int_t[dimexp];
296       fNDdim = dimexp;
297       // Re-initialize the array
298       memset(fDictionary,-1,sizeof(Int_t)*dimexp);
299       fFlag=kTRUE; // Not expand again
300       return;
301     }
302
303   Int_t *longArr = new Int_t[fNDdim];
304   if(longArr && fDictionary)
305     {
306       //Initialize the array
307       memset(longArr,0,sizeof(Int_t)*fNDdim);
308
309       Int_t r2=0;
310       for(Int_t i=0; i<fNDdim;i++)
311         {
312           if((fDictionary[i]<0)&&(fDictionary[i]!=-1))  
313             {
314               longArr[r2]=-fDictionary[i]; 
315               r2++;
316             }
317         }
318
319       //Calculate new dimensions
320       for(Int_t i=0; i<fNDdim;i++)
321         {
322           if(longArr[i]!=0)      
323             dimexp=dimexp+longArr[i]-1;
324           if(longArr[i]==0)
325             break;
326         }
327       dimexp=dimexp+fNDdim;  
328
329       //Write in the buffer the new array
330       Int_t contaexp =0;    
331       Int_t h=0;
332       Int_t* bufferE = new Int_t[dimexp];
333
334       if(bufferE)
335         {
336           memset(bufferE,-1,sizeof(Int_t)*dimexp);
337           for(Int_t i=0; i<dimexp; i++)
338             {
339               if(fDictionary[contaexp]>=-1)  
340                 {
341                   bufferE[i]=fDictionary[contaexp];
342                 }
343               if(fDictionary[contaexp]<-1)  
344                 {
345                   i=i+longArr[h]-1;
346                   h++;
347                 }
348               contaexp++;
349             }
350
351           //Copy the buffer
352           delete [] fDictionary;
353           fDictionary=bufferE;
354           fNDdim = dimexp;
355         }
356     }
357   if (longArr)
358     {
359       delete [] longArr; 
360     }
361   fFlag=kTRUE; // Not expand again
362
363 }
364 //________________________________________________________________________________
365 void AliTRDarrayDictionary::Reset()
366 {
367   //
368   // Reset the array, the old contents are deleted
369   // and the data array elements are set to zero.
370   //
371
372   memset(fDictionary,0,sizeof(Int_t)*fNDdim);
373
374 }
375 //________________________________________________________________________________
376 Int_t AliTRDarrayDictionary::GetData(Int_t nrow, Int_t ncol, Int_t ntime) const
377 {
378   //
379   // Get the data using the pad numbering.
380   // To access data using the mcm scheme use instead
381   // the method GetDataByAdcCol
382   //
383
384   Int_t corrcolumn = fgLutPadNumbering[ncol];
385
386   return fDictionary[(nrow*fNumberOfChannels+corrcolumn)*fNtime+ntime];
387
388 }
389 //________________________________________________________________________________
390 void AliTRDarrayDictionary::SetData(Int_t nrow, Int_t ncol, Int_t ntime, Int_t value)
391 {
392   //
393   // Set the data using the pad numbering.
394   // To write data using the mcm scheme use instead
395   // the method SetDataByAdcCol
396   //
397
398   Int_t colnumb = fgLutPadNumbering[ncol];
399
400   fDictionary[(nrow*fNumberOfChannels+colnumb)*fNtime+ntime]=value;
401
402 }
403
404 //________________________________________________________________________________
405 void AliTRDarrayDictionary::CreateLut()
406 {
407   //
408   // Initializes the Look Up Table to relate
409   // pad numbering and mcm channel numbering
410   //
411
412   if(fgLutPadNumbering)  return;
413   
414    fgLutPadNumbering = new Short_t[AliTRDfeeParam::GetNcol()];
415    memset(fgLutPadNumbering,0,sizeof(Short_t)*AliTRDfeeParam::GetNcol());
416
417   for(Int_t mcm=0; mcm<8; mcm++)
418     {
419       Int_t lowerlimit=0+mcm*18;
420       Int_t upperlimit=18+mcm*18;
421       Int_t shiftposition = 1+3*mcm;
422       for(Int_t index=lowerlimit;index<upperlimit;index++)
423         {
424           fgLutPadNumbering[index]= index+shiftposition;
425         }
426     }
427 }