Fixes for Coverity warnings (M. van Leeuwen)
[u/mrichter/AliRoot.git] / ITS / AliITSCalibrationSPD.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, 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 #include "AliITSCalibrationSPD.h"
17 ///////////////////////////////////////////////////////////////////////////
18 //  Calibration class for set:ITS                   
19 //  Specific subdetector implementation for         
20 //  Silicon pixels                                  
21 //
22 //  Modified by D. Elia, G.E. Bruno, H. Tydesjo
23 ///////////////////////////////////////////////////////////////////////////
24
25 ClassImp(AliITSCalibrationSPD)
26
27 //______________________________________________________________________
28 AliITSCalibrationSPD::AliITSCalibrationSPD():
29 AliITSCalibration(),
30 fNrBad(0),
31 fBadChannels(0){
32   // constructor
33
34    SetDataType("simulated");
35    ClearBad();
36 }
37 //____________________________________________________________________________
38 void AliITSCalibrationSPD::ClearBad() {
39   // clear all bad pixels (single+chips)
40   fBadChannels.Reset();
41   fNrBad=0;
42   for (UInt_t chip=0; chip<5; chip++) {
43     fBadChip[chip]=kFALSE;
44   }
45 }
46 //____________________________________________________________________________
47 void AliITSCalibrationSPD::AddBad(UInt_t col, UInt_t row) {
48   // add single bad pixel 
49   fBadChannels.Set(fNrBad*2+2);
50   fBadChannels.AddAt(col,fNrBad*2);
51   fBadChannels.AddAt(row,fNrBad*2+1);
52   fNrBad++;
53 }
54 //____________________________________________________________________________
55 void AliITSCalibrationSPD::SetChipBad(UInt_t chip) {
56   // set full chip bad
57   if (chip>=5) {AliError("Wrong chip number");
58   }
59   else {
60     fBadChip[chip]=kTRUE;
61   }
62 }
63 //____________________________________________________________________________
64 void AliITSCalibrationSPD::UnSetChipBad(UInt_t chip) {
65   // unset full chip bad
66   if (chip>=5 ) {AliError("Wrong chip number");
67   }
68   else {
69     fBadChip[chip]=kFALSE;
70   }
71 }
72 //____________________________________________________________________________
73 Int_t AliITSCalibrationSPD::GetBadColAt(UInt_t index) const {
74   // Get column of index-th bad pixel
75   if ((Int_t)index<GetNrBadSingle()) {
76     return fBadChannels.At(index*2);
77   }
78   else {
79     Int_t badChipIndex=(index-GetNrBadSingle())/(32*256);
80     Int_t badChipsFound =0;
81     for (UInt_t chip=0; chip<5; chip++) {
82       if (fBadChip[chip]) badChipsFound++;
83       if (badChipIndex==badChipsFound-1) {
84         Int_t badPixelIndex=(index-GetNrBadSingle())%(32*256);
85         return chip*32 + badPixelIndex/256;
86       }
87     }
88   }
89   AliError(Form("Index %d is out of bounds - returning -1",index));
90   return -1;
91 }
92 //____________________________________________________________________________
93 Int_t AliITSCalibrationSPD::GetBadRowAt(UInt_t index) const {
94   // Get row of index-th bad pixel
95   if ((Int_t)index<GetNrBadSingle()) {
96     return fBadChannels.At(index*2+1);
97   }
98   else {
99     Int_t badChipIndex=(index-GetNrBadSingle())/(32*256);
100     Int_t badChipsFound =0;
101     for (UInt_t chip=0; chip<5; chip++) {
102       if (fBadChip[chip]) badChipsFound++;
103       if (badChipIndex==badChipsFound-1) {
104         Int_t badPixelIndex=(index-GetNrBadSingle())%(32*256);
105         return badPixelIndex%256;
106       }
107     }
108   }
109   AliError(Form("Index %d is out of bounds - returning -1",index));
110   return -1;
111 }
112 //____________________________________________________________________________
113 void AliITSCalibrationSPD::GetBadPixel(Int_t index, Int_t &row, Int_t &col) const {
114   // i: is the i-th bad pixel in single bad pixel list
115   // row: is the corresponding row (-1 if i is out of range)
116   // col: is the corresponding column (-1 if i is out of range)
117   row = -1;
118   col = -1;
119   if(index>=0 && index<GetNrBadSingle()){
120     col = GetBadColAt(index);
121     row = GetBadRowAt(index);
122     return;
123   }
124   else {
125     if (index>=0) {
126       Int_t badChipIndex=(index-GetNrBadSingle())/(32*256);
127       Int_t badChipsFound =0;
128       for (UInt_t chip=0; chip<5; chip++) {
129         if (fBadChip[chip]) badChipsFound++;
130         if (badChipIndex==badChipsFound-1) {
131           Int_t badPixelIndex=(index-GetNrBadSingle())%(32*256);
132           col = chip*32 + badPixelIndex/256;
133           row = badPixelIndex%256;
134           return;
135         }
136       }
137     }
138   }
139   AliError(Form("Index %d is out of bounds - nothing done",index));
140 }
141 //___________________________________________________________________________
142 Int_t  AliITSCalibrationSPD::GetNrBad() const {
143   // Total number of bad pixels (including bad chips) in a given module
144   Int_t bad=0;
145   // single pixels:
146   bad+=fNrBad;
147   // whole chips:
148   for (UInt_t chip=0; chip<5; chip++) {
149     bad+=fBadChip[chip]*32*256;
150   }
151   return bad;
152 }
153 //___________________________________________________________________________
154 Int_t  AliITSCalibrationSPD::GetNrBadInChip(Int_t chip) const {
155   // Total number of bad pixels (including bad chips) in a given chip: chip range [0,4]
156   if(chip<0 || chip>4) {AliError("Wrong chip number"); return -1;}
157   if (fBadChip[chip]) return 32*256;
158   else {
159     Int_t bad=0;
160     for (UInt_t i=0; i<fNrBad; i++) {
161       Int_t col = GetBadColAt(i);
162       if (col!=-1) {
163         if (GetChipIndexFromCol(col)==chip) bad++;
164       }
165     }
166     return bad;
167   }
168 }
169 //___________________________________________________________________________
170 Int_t  AliITSCalibrationSPD::GetNrBadInColumn(Int_t col) const {
171   // Total number of bad pixels (including bad chips) in a given column: col. range [0,159]
172   if(col<0 || col>159) {AliError("Wrong column number"); return -1;}
173   if (fBadChip[GetChipIndexFromCol(col)]) return 256;
174   else {
175     Int_t bad=0;
176     for (UInt_t i=0; i<fNrBad; i++) {
177       if (GetBadColAt(i)==col) bad++;
178     }
179     return bad;
180   }
181 }
182 //______________________________________________________________________
183 Bool_t AliITSCalibrationSPD::IsBad() const {
184   // Are all chips of this module bad?
185   for (UInt_t chip=0; chip<5; chip++) {
186     if (!fBadChip[chip]) return kFALSE;
187   }
188   return kTRUE;
189 }
190 //______________________________________________________________________
191 Bool_t AliITSCalibrationSPD::IsChipBad(Int_t chip) const {
192   // Is the full chip bad?
193   return (GetNrBadInChip(chip)==32*256);
194 }
195 //______________________________________________________________________
196 Bool_t AliITSCalibrationSPD::IsColumnBad(Int_t col) const {
197   // Is the full column bad?
198   return (GetNrBadInColumn(col)==256);
199 }
200 //____________________________________________________________________________
201 Bool_t AliITSCalibrationSPD::IsPixelBad(Int_t col, Int_t row) const {
202   // Is this pixel bad?
203   if(col<0 || col>159) {AliError("Wrong column number"); return kFALSE;}
204   Int_t chip = GetChipIndexFromCol(col);
205   if (fBadChip[chip]) return kTRUE;
206   for (UInt_t i=0; i<fNrBad; i++) { 
207     if (GetBadColAt(i)==col && GetBadRowAt(i)==row) {
208       return kTRUE;
209     }
210   }
211   return kFALSE;
212 }
213 //______________________________________________________________________
214 Int_t AliITSCalibrationSPD::GetChipIndexFromCol(UInt_t col) const {
215   // returns chip index for specific column
216   if(col>=160) {AliWarning("Wrong column number"); return -1;}
217   return col/32;
218 }
219 //______________________________________________________________________
220 void AliITSCalibrationSPD::SetNrBad(UInt_t /*nr*/) {
221   // should not be used anymore !!!
222   AliError("This method should not be used anymore. Use SetNrBadSingle instead!!!");
223 }
224 //______________________________________________________________________
225 void AliITSCalibrationSPD::Streamer(TBuffer &R__b) {
226   // Stream an object of class AliITSCalibrationSPD.
227   UInt_t R__s, R__c;
228   if (R__b.IsReading()) {
229     Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
230     AliITSCalibration::Streamer(R__b);
231     if (R__v >= 8) {
232       R__b >> fNrBad;
233       fBadChannels.Streamer(R__b);
234       R__b.ReadStaticArray((bool*)fBadChip);
235     }
236     else {
237       Double_t dummy;
238       R__b >> dummy;
239       R__b >> dummy;
240       R__b >> dummy;
241       R__b >> dummy;
242       R__b >> dummy;
243       R__b >> dummy;
244       R__b >> dummy;
245       R__b >> fNrBad;
246       if (R__v == 7) {
247         fBadChannels.Streamer(R__b);
248         R__b.ReadStaticArray((bool*)fBadChip);
249       }
250       else {
251         if (R__v == 6) {
252           fBadChannels.Streamer(R__b);
253         }
254         else {
255           TArrayI fBadChannelsV1;
256           fBadChannelsV1.Streamer(R__b);
257           fBadChannels.Set(fNrBad*2);
258           for (UInt_t i=0; i<fNrBad*2; i++) {
259             fBadChannels[i] = fBadChannelsV1[i];
260           }
261         }
262         for (UInt_t i=0; i<5; i++) {
263           fBadChip[i]=kFALSE;
264         }
265       }
266     }
267     R__b.CheckByteCount(R__s, R__c, AliITSCalibrationSPD::IsA());
268   }
269   else {
270     R__c = R__b.WriteVersion(AliITSCalibrationSPD::IsA(), kTRUE);
271     AliITSCalibration::Streamer(R__b);
272     R__b << fNrBad;
273     fBadChannels.Streamer(R__b);
274     R__b.WriteArray(fBadChip, 5);
275     R__b.SetByteCount(R__c, kTRUE);
276   }
277 }