For Pythia with tune don't switch off MI in ConfigHeavyFlavor
[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   fBadChip[chip]=kTRUE;
59 }
60 //____________________________________________________________________________
61 void AliITSCalibrationSPD::UnSetChipBad(UInt_t chip) {
62   // unset full chip bad
63   if (chip>=5) {AliError("Wrong chip number");}
64   fBadChip[chip]=kFALSE;
65 }
66 //____________________________________________________________________________
67 Int_t AliITSCalibrationSPD::GetBadColAt(UInt_t index) const {
68   // Get column of index-th bad pixel
69   if ((Int_t)index<GetNrBadSingle()) {
70     return fBadChannels.At(index*2);
71   }
72   else {
73     Int_t badChipIndex=(index-GetNrBadSingle())/(32*256);
74     Int_t badChipsFound =0;
75     for (UInt_t chip=0; chip<5; chip++) {
76       if (fBadChip[chip]) badChipsFound++;
77       if (badChipIndex==badChipsFound-1) {
78         Int_t badPixelIndex=(index-GetNrBadSingle())%(32*256);
79         return chip*32 + badPixelIndex/256;
80       }
81     }
82   }
83   AliError(Form("Index %d is out of bounds - returning -1",index));
84   return -1;
85 }
86 //____________________________________________________________________________
87 Int_t AliITSCalibrationSPD::GetBadRowAt(UInt_t index) const {
88   // Get row of index-th bad pixel
89   if ((Int_t)index<GetNrBadSingle()) {
90     return fBadChannels.At(index*2+1);
91   }
92   else {
93     Int_t badChipIndex=(index-GetNrBadSingle())/(32*256);
94     Int_t badChipsFound =0;
95     for (UInt_t chip=0; chip<5; chip++) {
96       if (fBadChip[chip]) badChipsFound++;
97       if (badChipIndex==badChipsFound-1) {
98         Int_t badPixelIndex=(index-GetNrBadSingle())%(32*256);
99         return badPixelIndex%256;
100       }
101     }
102   }
103   AliError(Form("Index %d is out of bounds - returning -1",index));
104   return -1;
105 }
106 //____________________________________________________________________________
107 void AliITSCalibrationSPD::GetBadPixel(Int_t index, Int_t &row, Int_t &col) const {
108   // i: is the i-th bad pixel in single bad pixel list
109   // row: is the corresponding row (-1 if i is out of range)
110   // col: is the corresponding column (-1 if i is out of range)
111   row = -1;
112   col = -1;
113   if(index>=0 && index<GetNrBadSingle()){
114     col = GetBadColAt(index);
115     row = GetBadRowAt(index);
116     return;
117   }
118   else {
119     if (index>=0) {
120       Int_t badChipIndex=(index-GetNrBadSingle())/(32*256);
121       Int_t badChipsFound =0;
122       for (UInt_t chip=0; chip<5; chip++) {
123         if (fBadChip[chip]) badChipsFound++;
124         if (badChipIndex==badChipsFound-1) {
125           Int_t badPixelIndex=(index-GetNrBadSingle())%(32*256);
126           col = chip*32 + badPixelIndex/256;
127           row = badPixelIndex%256;
128           return;
129         }
130       }
131     }
132   }
133   AliError(Form("Index %d is out of bounds - nothing done",index));
134 }
135 //___________________________________________________________________________
136 Int_t  AliITSCalibrationSPD::GetNrBad() const {
137   // Total number of bad pixels (including bad chips) in a given module
138   Int_t bad=0;
139   // single pixels:
140   bad+=fNrBad;
141   // whole chips:
142   for (UInt_t chip=0; chip<5; chip++) {
143     bad+=fBadChip[chip]*32*256;
144   }
145   return bad;
146 }
147 //___________________________________________________________________________
148 Int_t  AliITSCalibrationSPD::GetNrBadInChip(Int_t chip) const {
149   // Total number of bad pixels (including bad chips) in a given chip: chip range [0,4]
150   if(chip<0 || chip>4) {AliError("Wrong chip number"); return -1;}
151   if (fBadChip[chip]) return 32*256;
152   else {
153     Int_t bad=0;
154     for (UInt_t i=0; i<fNrBad; i++) {
155       Int_t col = GetBadColAt(i);
156       if (col!=-1) {
157         if (GetChipIndexFromCol(col)==chip) bad++;
158       }
159     }
160     return bad;
161   }
162 }
163 //___________________________________________________________________________
164 Int_t  AliITSCalibrationSPD::GetNrBadInColumn(Int_t col) const {
165   // Total number of bad pixels (including bad chips) in a given column: col. range [0,159]
166   if(col<0 || col>159) {AliError("Wrong column number"); return -1;}
167   if (fBadChip[GetChipIndexFromCol(col)]) return 256;
168   else {
169     Int_t bad=0;
170     for (UInt_t i=0; i<fNrBad; i++) {
171       if (GetBadColAt(i)==col) bad++;
172     }
173     return bad;
174   }
175 }
176 //______________________________________________________________________
177 Bool_t AliITSCalibrationSPD::IsBad() const {
178   // Are all chips of this module bad?
179   for (UInt_t chip=0; chip<5; chip++) {
180     if (!fBadChip[chip]) return kFALSE;
181   }
182   return kTRUE;
183 }
184 //______________________________________________________________________
185 Bool_t AliITSCalibrationSPD::IsChipBad(Int_t chip) const {
186   // Is the full chip bad?
187   return (GetNrBadInChip(chip)==32*256);
188 }
189 //______________________________________________________________________
190 Bool_t AliITSCalibrationSPD::IsColumnBad(Int_t col) const {
191   // Is the full column bad?
192   return (GetNrBadInColumn(col)==256);
193 }
194 //____________________________________________________________________________
195 Bool_t AliITSCalibrationSPD::IsPixelBad(Int_t col, Int_t row) const {
196   // Is this pixel bad?
197   if(col<0 || col>159) {AliError("Wrong column number"); return kFALSE;}
198   Int_t chip = GetChipIndexFromCol(col);
199   if (fBadChip[chip]) return kTRUE;
200   for (UInt_t i=0; i<fNrBad; i++) { 
201     if (GetBadColAt(i)==col && GetBadRowAt(i)==row) {
202       return kTRUE;
203     }
204   }
205   return kFALSE;
206 }
207 //______________________________________________________________________
208 Int_t AliITSCalibrationSPD::GetChipIndexFromCol(UInt_t col) const {
209   // returns chip index for specific column
210   if(col>=160) {AliWarning("Wrong column number"); return -1;}
211   return col/32;
212 }
213 //______________________________________________________________________
214 void AliITSCalibrationSPD::SetNrBad(UInt_t /*nr*/) {
215   // should not be used anymore !!!
216   AliError("This method should not be used anymore. Use SetNrBadSingle instead!!!");
217 }
218 //______________________________________________________________________
219 void AliITSCalibrationSPD::Streamer(TBuffer &R__b) {
220   // Stream an object of class AliITSCalibrationSPD.
221   UInt_t R__s, R__c;
222   if (R__b.IsReading()) {
223     Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
224     AliITSCalibration::Streamer(R__b);
225     if (R__v >= 8) {
226       R__b >> fNrBad;
227       fBadChannels.Streamer(R__b);
228       R__b.ReadStaticArray((bool*)fBadChip);
229     }
230     else {
231       Double_t dummy;
232       R__b >> dummy;
233       R__b >> dummy;
234       R__b >> dummy;
235       R__b >> dummy;
236       R__b >> dummy;
237       R__b >> dummy;
238       R__b >> dummy;
239       R__b >> fNrBad;
240       if (R__v == 7) {
241         fBadChannels.Streamer(R__b);
242         R__b.ReadStaticArray((bool*)fBadChip);
243       }
244       else {
245         if (R__v == 6) {
246           fBadChannels.Streamer(R__b);
247         }
248         else {
249           TArrayI fBadChannelsV1;
250           fBadChannelsV1.Streamer(R__b);
251           fBadChannels.Set(fNrBad*2);
252           for (UInt_t i=0; i<fNrBad*2; i++) {
253             fBadChannels[i] = fBadChannelsV1[i];
254           }
255         }
256         for (UInt_t i=0; i<5; i++) {
257           fBadChip[i]=kFALSE;
258         }
259       }
260     }
261     R__b.CheckByteCount(R__s, R__c, AliITSCalibrationSPD::IsA());
262   }
263   else {
264     R__c = R__b.WriteVersion(AliITSCalibrationSPD::IsA(), kTRUE);
265     AliITSCalibration::Streamer(R__b);
266     R__b << fNrBad;
267     fBadChannels.Streamer(R__b);
268     R__b.WriteArray(fBadChip, 5);
269     R__b.SetByteCount(R__c, kTRUE);
270   }
271 }