Fixing coverity 17819
[u/mrichter/AliRoot.git] / TRD / AliTRDarrayADC.cxx
CommitLineData
abf2a9d8 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: AliTRDarrayADC.cxx 25392 2008-04-23 19:40:29Z cblume $ */
17
18////////////////////////////////////////////////////////
19// //
20// Container class for ADC values //
21// //
22// Author: //
23// Hermes Leon Vargas (hleon@ikf.uni-frankfurt.de) //
24// //
25////////////////////////////////////////////////////////
26
27#include "AliTRDarrayADC.h"
28#include "Cal/AliTRDCalPadStatus.h"
29#include "AliTRDfeeParam.h"
534529cb 30#include "AliTRDSignalIndex.h"
be86b0e0 31#include "AliLog.h"
32
abf2a9d8 33ClassImp(AliTRDarrayADC)
34
35Short_t *AliTRDarrayADC::fgLutPadNumbering = 0x0;
36
37//____________________________________________________________________________________
38AliTRDarrayADC::AliTRDarrayADC()
39 :TObject()
40 ,fNdet(0)
41 ,fNrow(0)
42 ,fNcol(0)
43 ,fNumberOfChannels(0)
44 ,fNtime(0)
45 ,fNAdim(0)
46 ,fADC(0)
47{
48 //
49 // AliTRDarrayADC default constructor
50 //
51
52 CreateLut();
53
54}
55
56//____________________________________________________________________________________
57AliTRDarrayADC::AliTRDarrayADC(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 ,fNAdim(0)
65 ,fADC(0)
66{
67 //
68 // AliTRDarrayADC constructor
69 //
70
71 CreateLut();
72 Allocate(nrow,ncol,ntime);
73
74}
75
76//____________________________________________________________________________________
77AliTRDarrayADC::AliTRDarrayADC(const AliTRDarrayADC &b)
78 :TObject()
79 ,fNdet(b.fNdet)
80 ,fNrow(b.fNrow)
81 ,fNcol(b.fNcol)
82 ,fNumberOfChannels(b.fNumberOfChannels)
83 ,fNtime(b.fNtime)
84 ,fNAdim(b.fNAdim)
85 ,fADC(0)
86{
87 //
88 // AliTRDarrayADC copy constructor
89 //
90
91 fADC = new Short_t[fNAdim];
92 memcpy(fADC,b.fADC, fNAdim*sizeof(Short_t));
93
94}
95
96//____________________________________________________________________________________
97AliTRDarrayADC::~AliTRDarrayADC()
98{
99 //
100 // AliTRDarrayADC destructor
101 //
102
103 if(fADC)
104 {
105 delete [] fADC;
106 fADC=0;
107 }
108
109}
110
111//____________________________________________________________________________________
112AliTRDarrayADC &AliTRDarrayADC::operator=(const AliTRDarrayADC &b)
113{
114 //
115 // Assignment operator
116 //
117
118 if(this==&b)
119 {
120 return *this;
121 }
122 if(fADC)
123 {
124 delete [] fADC;
125 }
126 fNdet=b.fNdet;
127 fNrow=b.fNrow;
128 fNcol=b.fNcol;
129 fNumberOfChannels = b.fNumberOfChannels;
130 fNtime=b.fNtime;
131 fNAdim=b.fNAdim;
132 fADC = new Short_t[fNAdim];
133 memcpy(fADC,b.fADC, fNAdim*sizeof(Short_t));
134
135 return *this;
136
137}
138
139//____________________________________________________________________________________
140void AliTRDarrayADC::Allocate(Int_t nrow, Int_t ncol, Int_t ntime)
141{
142 //
143 // Allocate memory for an AliTRDarrayADC array with dimensions
144 // Row*NumberOfNecessaryMCMs*ADCchannelsInMCM*Time
145 //
146
147 fNrow=nrow;
148 fNcol=ncol;
149 fNtime=ntime;
150 Int_t adcchannelspermcm = AliTRDfeeParam::GetNadcMcm();
151 Int_t padspermcm = AliTRDfeeParam::GetNcolMcm();
152 Int_t numberofmcms = fNcol/padspermcm;
153 fNumberOfChannels = numberofmcms*adcchannelspermcm;
154 fNAdim=nrow*fNumberOfChannels*ntime;
155
156 if(fADC)
157 {
158 delete [] fADC;
159 }
160
161 fADC = new Short_t[fNAdim];
162 memset(fADC,0,sizeof(Short_t)*fNAdim);
163
164}
165
166//____________________________________________________________________________________
167Short_t AliTRDarrayADC::GetDataBits(Int_t row, Int_t col, Int_t time) const
168{
169 //
170 // Get the ADC value for a given position: row, col, time
171 // Taking bit masking into account
172 //
173 // Adapted from code of the class AliTRDdataArrayDigits
174 //
175
176 Short_t tempval = GetData(row,col,time);
177 // Be aware of manipulations introduced by pad masking in the RawReader
178 // Only output the manipulated Value
179 CLRBIT(tempval, 10);
180 CLRBIT(tempval, 11);
181 CLRBIT(tempval, 12);
182 return tempval;
183
184}
185
186//____________________________________________________________________________________
187UChar_t AliTRDarrayADC::GetPadStatus(Int_t row, Int_t col, Int_t time) const
188{
189 //
190 // Returns the pad status stored in the pad signal
191 //
192 // Output is a UChar_t value
193 // Status Codes:
194 // Noisy Masking: 2
195 // Bridged Left Masking 8
196 // Bridged Right Masking 8
197 // Not Connected Masking Digits
198 //
199 // Adapted from code of the class AliTRDdataArrayDigits
200 //
201
202 UChar_t padstatus = 0;
203 Short_t signal = GetData(row,col,time);
204 if(signal > 0 && TESTBIT(signal, 10)){
205 if(TESTBIT(signal, 11))
206 if(TESTBIT(signal, 12))
207 padstatus = AliTRDCalPadStatus::kPadBridgedRight;
208 else
209 padstatus = AliTRDCalPadStatus::kNotConnected;
210 else
211 if(TESTBIT(signal, 12))
212 padstatus = AliTRDCalPadStatus::kPadBridgedLeft;
213 else
214 padstatus = AliTRDCalPadStatus::kMasked;
215 }
216
217 return padstatus;
218
219}
220
221//____________________________________________________________________________________
222void AliTRDarrayADC::SetPadStatus(Int_t row, Int_t col, Int_t time, UChar_t status)
223{
224 //
225 // Setting the pad status into the signal using the Bits 10 to 14
226 // (currently used: 10 to 12)
227 //
228 // Input codes (Unsigned char):
229 // Noisy Masking: 2
230 // Bridged Left Masking 8
231 // Bridged Right Masking 8
232 // Not Connected Masking 32
233 //
234 // Status codes: Any masking: Bit 10(1)
235 // Noisy masking: Bit 11(0), Bit 12(0)
236 // No Connection masking: Bit 11(1), Bit 12(0)
237 // Bridged Left masking: Bit 11(0), Bit 12(1)
238 // Bridged Right masking: Bit 11(1), Bit 12(1)
239 //
240 // Adapted from code of the class AliTRDdataArrayDigits
241 //
242
243 Short_t signal = GetData(row,col,time);
244
245 // Only set the Pad Status if the signal is > 0
246 if(signal > 0)
247 {
248 switch(status)
249 {
250 case AliTRDCalPadStatus::kMasked:
251 SETBIT(signal, 10);
252 CLRBIT(signal, 11);
253 CLRBIT(signal, 12);
254 break;
255 case AliTRDCalPadStatus::kNotConnected:
256 SETBIT(signal, 10);
257 SETBIT(signal, 11);
258 CLRBIT(signal, 12);
259 break;
260 case AliTRDCalPadStatus::kPadBridgedLeft:
261 SETBIT(signal, 10);
262 CLRBIT(signal, 11);
263 SETBIT(signal, 12);
264 break;
265 case AliTRDCalPadStatus::kPadBridgedRight:
266 SETBIT(signal, 10);
267 SETBIT(signal, 11);
268 SETBIT(signal, 12);
024c0422 269 break;
abf2a9d8 270 default:
271 CLRBIT(signal, 10);
272 CLRBIT(signal, 11);
273 CLRBIT(signal, 12);
274 }
275 SetData(row, col, time, signal);
276 }
277
278}
279
280//____________________________________________________________________________________
281Bool_t AliTRDarrayADC::IsPadCorrupted(Int_t row, Int_t col, Int_t time)
282{
283 //
284 // Checks if the pad has any masking as corrupted (Bit 10 in signal set)
285 //
286 // Adapted from code of the class AliTRDdataArrayDigits
287 //
288
289 Short_t signal = GetData(row,col,time);
290 return (signal > 0 && TESTBIT(signal, 10)) ? kTRUE : kFALSE;
291
292}
293
294//____________________________________________________________________________________
295void AliTRDarrayADC::Compress()
296{
297 //
298 // Compress the array
299 //
300
be86b0e0 301 if(fNAdim!=fNrow*fNumberOfChannels*fNtime)
302 {
303 AliDebug(1,"The ADC array is already compressed");
304 return;
305 }
306
abf2a9d8 307 Int_t counter=0;
308 Int_t newDim=0;
309 Int_t j;
310 Int_t l;
311 Int_t r=0;
312 Int_t s=0;
abf2a9d8 313 Int_t k=0;
abf2a9d8 314
af63084f 315 Int_t *longm = new Int_t[fNAdim];
316 Int_t *longz = new Int_t[fNAdim];
317
318 if(longz && longm && fADC)
abf2a9d8 319 {
af63084f 320
321 memset(longz,0,sizeof(Int_t)*fNAdim);
322 memset(longm,0,sizeof(Int_t)*fNAdim);
323
324 for(Int_t i=0;i<fNAdim; i++)
325 {
326 j=0;
327 if(fADC[i]==-1)
abf2a9d8 328 {
af63084f 329 for(k=i;k<fNAdim;k++)
330 {
331 if((fADC[k]==-1)&&(j<16000))
332 {
333 j=j+1;
334 longm[r]=j;
335 }
336 else
337 {
338 break;
339 }
340 }
341 r=r+1;
abf2a9d8 342 }
af63084f 343 l=16001;
344 if(fADC[i]==0)
abf2a9d8 345 {
af63084f 346 for(k=i;k<fNAdim;k++)
347 {
348 if((fADC[k]==0)&&(l<32767))
349 {
350 l=l+1;
351 longz[s]=l;
352 }
353 else
354 {
355 break;
356 }
357 }
358 s=s+1;
abf2a9d8 359 }
af63084f 360 if(fADC[i]>0)
abf2a9d8 361 {
af63084f 362 i=i+1;
abf2a9d8 363 }
af63084f 364 i=i+j+(l-16001-1);
365 }
366
367 //Calculate the size of the compressed array
368 for(Int_t i=0; i<fNAdim;i++)
369 {
370 if(longm[i]!=0)
abf2a9d8 371 {
af63084f 372 counter=counter+longm[i]-1;
373 }
374 if(longz[i]!=0)
abf2a9d8 375 {
af63084f 376 counter=counter+(longz[i]-16001)-1;
377 }
378 }
379
380 Int_t counterTwo=0;
381 newDim = fNAdim-counter; //Dimension of the compressed array
382 Short_t* buffer = new Short_t[newDim];
383
384 if(buffer)
385 {
386
387 //Fill the buffer of the compressed array
388 Int_t g=0;
389 Int_t h=0;
390 for(Int_t i=0; i<newDim; i++)
391 {
392 if(counterTwo<fNAdim)
393 {
394 if(fADC[counterTwo]>0)
395 {
396 buffer[i]=fADC[counterTwo];
397 }
398 if(fADC[counterTwo]==-1)
399 {
400 buffer[i]=-(longm[g]);
401 counterTwo=counterTwo+longm[g]-1;
402 g++;
403 }
404 if(fADC[counterTwo]==0)
405 {
406 buffer[i]=-(longz[h]);
407 counterTwo=counterTwo+(longz[h]-16001)-1;
408 h++;
409 }
410 counterTwo++;
411 }
412 }
413
414 //Copy the buffer
415 delete [] fADC;
416 fADC=0;
417 fADC = new Short_t[newDim];
418 fNAdim = newDim;
419 for(Int_t i=0; i<newDim; i++)
420 {
421 fADC[i] = buffer[i];
422 }
423
424 //Delete auxiliary arrays
425 delete [] buffer;
426 buffer=0;
427 }
abf2a9d8 428
a987273c 429 }
430
431 if (longz)
432 {
abf2a9d8 433 delete [] longz;
434 longz=0;
a987273c 435 }
436 if (longm)
437 {
abf2a9d8 438 delete [] longm;
439 longm=0;
af63084f 440
abf2a9d8 441 }
442
443}
444
445//____________________________________________________________________________________
446void AliTRDarrayADC::Expand()
447{
448 //
449 // Expand the array
450 //
451
fdc15553 452 if (fADC)
abf2a9d8 453 {
fdc15553 454
455 //Check if the array has not been already expanded
456 Int_t verif=0;
457 for(Int_t i=0; i<fNAdim; i++)
458 {
459 if(fADC[i]<-1)
460 {
461 verif++;
462 }
463 }
abf2a9d8 464
fdc15553 465 if(verif==0)
466 {
be86b0e0 467 AliDebug(1,"Nothing to expand");
fdc15553 468 return;
469 }
abf2a9d8 470
fdc15553 471 Int_t dimexp=0;
472 Int_t *longz = new Int_t[fNAdim];
473 Int_t *longm = new Int_t[fNAdim];
abf2a9d8 474
fdc15553 475 if (longz && longm)
abf2a9d8 476 {
fdc15553 477
478 //Initialize arrays
479 memset(longz,0,sizeof(Int_t)*fNAdim);
480 memset(longm,0,sizeof(Int_t)*fNAdim);
481 Int_t r2=0;
482 Int_t r3=0;
483 for(Int_t i=0; i<fNAdim;i++)
484 {
485 if((fADC[i]<0)&&(fADC[i]>=-16000))
486 {
487 longm[r2]=-fADC[i];
488 r2++;
489 }
490 if(fADC[i]<-16000)
491 {
492 longz[r3]=-fADC[i]-16001;
493 r3++;
494 }
495 }
496
497 //Calculate the new dimensions of the array
498 for(Int_t i=0; i<fNAdim;i++)
499 {
500 if(longm[i]!=0)
501 {
502 dimexp=dimexp+longm[i]-1;
503 }
504 if(longz[i]!=0)
505 {
506 dimexp=dimexp+longz[i]-1;
507 }
508 }
509 dimexp=dimexp+fNAdim;
510
511 //Write in the buffer the new array
512 Int_t contaexp =0;
513 Int_t h=0;
514 Int_t l=0;
515 Short_t* bufferE = new Short_t[dimexp];
516 if(bufferE)
abf2a9d8 517 {
fdc15553 518 for(Int_t i=0; i<dimexp; i++)
519 {
520 if(fADC[contaexp]>0)
521 {
522 bufferE[i]=fADC[contaexp];
523 }
524 if((fADC[contaexp]<0)&&(fADC[contaexp]>=-16000))
525 {
526 for(Int_t j=0; j<longm[h];j++)
527 {
528 bufferE[i+j]=-1;
529 }
530 i=i+longm[h]-1;
531 h++;
532 }
533 if(fADC[contaexp]<-16000)
534 {
535 for(Int_t j=0; j<longz[l];j++)
536 {
537 bufferE[i+j]=0;
538 }
539 i=i+longz[l]-1;
540 l++;
541 }
542 contaexp++;
543 }
544 //Copy the buffer
545 delete [] fADC;
546 fADC = new Short_t[dimexp];
547 fNAdim = dimexp;
548 for(Int_t i=0; i<dimexp; i++)
549 {
550 fADC[i] = bufferE[i];
551 }
552
553 delete [] bufferE;
554
abf2a9d8 555 }
fdc15553 556
557 //Delete auxiliary arrays
558 delete [] longm;
559 delete [] longz;
560
abf2a9d8 561 }
abf2a9d8 562
abf2a9d8 563 }
564
abf2a9d8 565}
566//____________________________________________________________________________________
567void AliTRDarrayADC::DeleteNegatives()
568{
569
570 //
571 //This method modifies the digits array, changing the negative values (-1)
572 //Produced during digitization into zero.
573 //
574
575 for(Int_t a=0; a<fNAdim; a++)
576 {
577 if(fADC[a]==-1)
578 {
579 fADC[a]=0;
580 }
581 }
582}
583//________________________________________________________________________________
584void AliTRDarrayADC::Reset()
585{
586 //
587 // Reset the array, the old contents are deleted
588 // The array keeps the same dimensions as before
589 //
590
591 memset(fADC,0,sizeof(Short_t)*fNAdim);
534529cb 592}
593//________________________________________________________________________________
594void AliTRDarrayADC::ConditionalReset(AliTRDSignalIndex* idx)
595{
596 //
597 // Reset the array, the old contents are deleted
598 // The array keeps the same dimensions as before
599 //
600
601 if(idx->GetNoOfIndexes()>25)
602 memset(fADC,0,sizeof(Short_t)*fNAdim);
603 else
604 {
605 Int_t row, col;
606 while(idx->NextRCIndex(row, col)){
9a3528ba 607 Int_t colnumb = fgLutPadNumbering[col];
608 memset(&fADC[(row*fNumberOfChannels+colnumb)*fNtime],0,fNtime);
534529cb 609 }
610 }
abf2a9d8 611
612}
abf2a9d8 613
614//________________________________________________________________________________
615void AliTRDarrayADC::CreateLut()
616{
617 //
618 // Initializes the Look Up Table to relate
619 // pad numbering and mcm channel numbering
620 //
621
622 if(fgLutPadNumbering) return;
623
624 fgLutPadNumbering = new Short_t[AliTRDfeeParam::GetNcol()];
625 memset(fgLutPadNumbering,0,sizeof(Short_t)*AliTRDfeeParam::GetNcol());
626
627 for(Int_t mcm=0; mcm<8; mcm++)
628 {
629 Int_t lowerlimit=0+mcm*18;
630 Int_t upperlimit=18+mcm*18;
631 Int_t shiftposition = 1+3*mcm;
632 for(Int_t index=lowerlimit;index<upperlimit;index++)
633 {
634 fgLutPadNumbering[index]=index+shiftposition;
635 }
636 }
637}