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