9be664b205cb409850d94b78ed91c15d2a53158c
[u/mrichter/AliRoot.git] / ITS / AliITSOnlineCalibrationSPDhandler.cxx
1 //////////////////////////////////////////////////////////////////////
2 // Author: Henrik Tydesjo                                           //
3 // For easier handling of dead and noisy pixels they are kept in    //
4 // container maps (AliITSIntMap).                                   //
5 // Handling of inactive equipments,HSs,chips have been added.       //
6 // A pixel that is either dead or inactive is called SILENT here.   //
7 // The lists of single dead and noisy pixels are separated from the //
8 // information about which eq/hs/chip are inactive.                 //
9 // The TArrayS objects that are put in the AliITSCalibrationSPD     //
10 // objects can be obtained from the methods GetDeadArray and        //
11 // GetNoisyArray.                                                   //
12 //////////////////////////////////////////////////////////////////////   
13
14 #include "AliITSOnlineCalibrationSPDhandler.h"
15 #include "AliITSOnlineCalibrationSPD.h"
16 #include "AliITSIntMap.h"
17 #include <TObjArray.h>
18 #include <TArrayI.h>
19 #include <TArrayS.h>
20 #include <TFile.h>
21 #include <TError.h>
22 #include <fstream>
23
24 #ifndef SPD_DA_OFF // you may want to exclude cdb classes, if using this class outside aliroot
25 #include "AliITSCalibrationSPD.h"
26 #include "AliCDBManager.h"
27 #include "AliCDBEntry.h"
28 #endif
29
30 /* $Id$ */
31
32 //____________________________________________________________________________________________
33 AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler():
34   fFileLocation(".")
35 {
36   // constructor
37   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
38     fNrDead[gloChip]=0;
39     fNrNoisy[gloChip]=0;
40     fDeadPixelMap[gloChip] = new AliITSIntMap();
41     fNoisyPixelMap[gloChip] = new AliITSIntMap();    
42   }
43   ActivateALL();
44   UnSetDeadALL();
45 }
46 //____________________________________________________________________________________________
47 AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler(const AliITSOnlineCalibrationSPDhandler& handle): 
48   fFileLocation(".")
49 {
50   // copy constructor
51   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
52     fNrDead[gloChip] = handle.fNrDead[gloChip];
53     fNrNoisy[gloChip] = handle.fNrNoisy[gloChip];
54     fDeadPixelMap[gloChip] = handle.fDeadPixelMap[gloChip]->Clone();
55     fNoisyPixelMap[gloChip] = handle.fNoisyPixelMap[gloChip]->Clone();
56   }
57   for (UInt_t eq=0; eq<20; eq++) {
58     fActiveEq[eq] = handle.fActiveEq[eq];
59     for (UInt_t hs=0; hs<6; hs++) {
60       fActiveHS[eq][hs] = handle.fActiveHS[eq][hs];
61       for (UInt_t chip=0; chip<10; chip++) {
62         fActiveChip[eq][hs][chip] = handle.fActiveChip[eq][hs][chip];
63       }
64     }
65   }
66   fFileLocation = handle.fFileLocation;
67 }
68 //____________________________________________________________________________________________
69 AliITSOnlineCalibrationSPDhandler::~AliITSOnlineCalibrationSPDhandler() {
70   //  ClearMaps();
71   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
72     delete fDeadPixelMap[gloChip];
73     delete fNoisyPixelMap[gloChip];
74   }
75 }
76 //____________________________________________________________________________________________
77 AliITSOnlineCalibrationSPDhandler& AliITSOnlineCalibrationSPDhandler::operator=(const AliITSOnlineCalibrationSPDhandler& handle) {
78   // assignment operator
79   if (this!=&handle) {
80     this->ClearMaps();
81     for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
82       fNrDead[gloChip] = handle.fNrDead[gloChip];
83       fNrNoisy[gloChip] = handle.fNrNoisy[gloChip];
84       fDeadPixelMap[gloChip] = handle.fDeadPixelMap[gloChip]->Clone();
85       fNoisyPixelMap[gloChip] = handle.fNoisyPixelMap[gloChip]->Clone();
86     }
87     for (UInt_t eq=0; eq<20; eq++) {
88       fActiveEq[eq] = handle.fActiveEq[eq];
89       for (UInt_t hs=0; hs<6; hs++) {
90         fActiveHS[eq][hs] = handle.fActiveHS[eq][hs];
91         for (UInt_t chip=0; chip<10; chip++) {
92           fActiveChip[eq][hs][chip] = handle.fActiveChip[eq][hs][chip];
93         }
94       }
95     }
96     fFileLocation = handle.fFileLocation;
97   }
98   return *this;
99 }
100 //____________________________________________________________________________________________
101 void AliITSOnlineCalibrationSPDhandler::ClearMaps() {
102   // clear the lists of dead and noisy
103   ResetDead();
104   ResetNoisy();
105   ActivateALL();
106 }
107 //____________________________________________________________________________________________
108 void AliITSOnlineCalibrationSPDhandler::ResetDead() {
109   // reset the dead pixel map and inactive eq,hs,chip
110   UnSetDeadALL();
111   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
112     fNrDead[gloChip]=0;
113     fDeadPixelMap[gloChip]->Clear();
114   }
115 }
116 //____________________________________________________________________________________________
117 void AliITSOnlineCalibrationSPDhandler::ResetNoisy() {
118   // clear the list of noisy pixels
119   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
120     fNrNoisy[gloChip]=0;
121     fNoisyPixelMap[gloChip]->Clear();
122   }
123 }
124 //____________________________________________________________________________________________
125 void AliITSOnlineCalibrationSPDhandler::ResetDeadForChip(UInt_t eq, UInt_t hs, UInt_t chip) {
126   // clear the dead pixels for this chip
127   SetDeadChip(eq,hs,chip,kFALSE);
128   UInt_t gloChip = GetGloChip(eq,hs,chip);
129   for (UInt_t col=0; col<32; col++) {
130     for (UInt_t row=0; row<256; row++) {
131       Int_t key = GetKey(eq,hs,chip,col,row);
132       if (fDeadPixelMap[gloChip]->Remove(key)) {
133         fNrDead[gloChip]--;
134       }
135     }
136   }
137 }
138 //____________________________________________________________________________________________
139 void AliITSOnlineCalibrationSPDhandler::ResetNoisyForChip(UInt_t eq, UInt_t hs, UInt_t chip) {
140   // clear the noisy pixels for this chip
141   UInt_t gloChip = GetGloChip(eq,hs,chip);
142   if (gloChip>=1200) {
143     Error("AliITSOnlineCalibrationSPDhandler::ResetNoisyForChip","global chip nr (%d) out of bounds\n",gloChip);
144     return;
145   }
146   for (UInt_t col=0; col<32; col++) {
147     for (UInt_t row=0; row<256; row++) {
148       Int_t key = GetKey(eq,hs,chip,col,row);
149       if (fNoisyPixelMap[gloChip]->Remove(key)) {
150         fNrNoisy[gloChip]--;
151       }
152     }
153   }
154 }
155 //____________________________________________________________________________________________
156 void AliITSOnlineCalibrationSPDhandler::ResetDeadForEq(UInt_t eq) {
157   // clear the dead pixels for this eq
158   if (eq>=20) {
159     Error("AliITSOnlineCalibrationSPDhandler::ResetDeadForEq", "eq (%d) out of bounds.",eq);
160     return;
161   }
162   for (UInt_t hs=0; hs<6; hs++) {
163     for (UInt_t chip=0; chip<10; chip++) {
164       ResetDeadForChip(eq, hs, chip);
165     }
166   }
167 }
168 //____________________________________________________________________________________________
169 void AliITSOnlineCalibrationSPDhandler::ResetNoisyForEq(UInt_t eq) {
170   // clear the noisy pixels for this eq
171   if (eq>=20) {
172     Error("AliITSOnlineCalibrationSPDhandler::ResetNoisyForEq", "eq (%d) out of bounds.",eq);
173     return;
174   }
175   for (UInt_t hs=0; hs<6; hs++) {
176     for (UInt_t chip=0; chip<10; chip++) {
177       ResetNoisyForChip(eq, hs, chip);
178     }
179   }
180 }
181
182
183 //____________________________________________________________________________________________
184 Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromFiles() {
185   // read files from file location (active,dead,noisy info). returns true if at least one file found
186   Bool_t b1 = ReadNoisyFromFiles();
187   Bool_t b2 = ReadSilentFromFiles();
188   return (b1 || b2);
189 }
190 //____________________________________________________________________________________________
191 Bool_t AliITSOnlineCalibrationSPDhandler::ReadSilentFromFiles() {
192   // read dead,active files from file location. returns true if at least one file found
193   Bool_t returnval=kFALSE;
194   for (UInt_t eq=0; eq<20; eq++) {
195     if (ReadSilentFromFile(eq)) {
196       returnval=kTRUE;
197     }
198   }
199   return returnval;
200 }
201 //____________________________________________________________________________________________
202 Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFiles() {
203   // read dead,active files from file location. returns true if at least one file found
204   Bool_t returnval=kFALSE;
205   for (UInt_t eq=0; eq<20; eq++) {
206     if (ReadDeadFromFile(eq)) {
207       returnval=kTRUE;
208     }
209   }
210   return returnval;
211 }
212 //____________________________________________________________________________________________
213 Bool_t AliITSOnlineCalibrationSPDhandler::ReadSilentFromFile(UInt_t eq) {
214   // read dead file for eq from file location. 
215   TString fileName = Form("%s/SPD_Dead_%d.root",fFileLocation.Data(),eq);
216   return ReadSilentFromFileName(fileName.Data());
217 }
218 //____________________________________________________________________________________________
219 Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFile(UInt_t eq) {
220   // read dead file for eq from file location. 
221   TString fileName = Form("%s/SPD_Dead_%d.root",fFileLocation.Data(),eq);
222   return ReadDeadFromFileName(fileName.Data());
223 }
224 //____________________________________________________________________________________________
225 Bool_t AliITSOnlineCalibrationSPDhandler::ReadSilentFromFileName(const char *fileName) {
226   // read dead from file fileName (including inactive)
227   return ReadDeadFromFileName(fileName, kTRUE);
228 }
229 //____________________________________________________________________________________________
230 Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFileName(const char *fileName, Bool_t inactive) {
231   // read dead from file fileName
232   AliITSOnlineCalibrationSPD* calib;
233   FILE* fp0 = fopen(fileName, "r");
234   if (fp0 == NULL) {return kFALSE;}
235   else {
236     fclose(fp0);
237     TFile file(fileName, "READ");
238     if (file.IsOpen()) {
239       file.GetObject("AliITSOnlineCalibrationSPD", calib);
240       file.Close();
241       if (calib!=NULL) {
242         UInt_t nrDead=calib->GetNrBad();
243         for (UInt_t index=0; index<nrDead; index++) {
244           UInt_t key = calib->GetKeyAt(index);
245           UInt_t eq = GetEqIdFromKey(key);
246           UInt_t hs = GetHSFromKey(key);
247           UInt_t chip = GetChipFromKey(key);
248           UInt_t col = GetColFromKey(key);
249           UInt_t row = GetRowFromKey(key);
250           SetDeadPixel(eq,hs,chip,col,row);
251         }
252         UInt_t eq = calib->GetEqNr();
253         if (calib->IsDeadEq()) SetDeadEq(eq);
254         else                   SetDeadEq(eq,kFALSE);
255         for (UInt_t hs=0; hs<6; hs++) {
256           if (calib->IsDeadHS(hs)) SetDeadHS(eq,hs);
257           else                     SetDeadHS(eq,hs,kFALSE);
258           for (UInt_t chip=0; chip<10; chip++) {
259             if (calib->IsDeadChip(hs,chip)) SetDeadChip(eq,hs,chip);
260             else                            SetDeadChip(eq,hs,chip,kFALSE);
261           }
262         }
263         if (inactive) {
264           UInt_t eq = calib->GetEqNr();
265           if (calib->IsActiveEq()) ActivateEq(eq);
266           else                     ActivateEq(eq,kFALSE);
267           for (UInt_t hs=0; hs<6; hs++) {
268             if (calib->IsActiveHS(hs)) ActivateHS(eq,hs);
269             else                       ActivateHS(eq,hs,kFALSE);
270             for (UInt_t chip=0; chip<10; chip++) {
271               if (calib->IsActiveChip(hs,chip)) ActivateChip(eq,hs,chip);
272               else                              ActivateChip(eq,hs,chip,kFALSE);
273             }
274           }
275         }
276       }
277     }
278   }
279   return kTRUE;
280 }
281 //____________________________________________________________________________________________
282 Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFiles() {
283   // read noisy files from file location. returns true if at least one file found
284   Bool_t returnval=kFALSE;
285   for (UInt_t eq=0; eq<20; eq++) {
286     if (ReadNoisyFromFile(eq)) {
287       returnval=kTRUE;
288     }
289   }
290   return returnval;
291 }
292 //____________________________________________________________________________________________
293 Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFile(UInt_t eq) {
294   // read noisy file for eq from file location. 
295   TString fileName = Form("%s/SPD_Noisy_%d.root",fFileLocation.Data(),eq);
296   return ReadNoisyFromFileName(fileName.Data());
297 }
298 //____________________________________________________________________________________________
299 Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFileName(const char *fileName) {
300   // read noisy from file fileName
301   AliITSOnlineCalibrationSPD* calib;
302   FILE* fp0 = fopen(fileName, "r");
303   if (fp0 == NULL) {return kFALSE;}
304   else {
305     fclose(fp0);
306     TFile file(fileName, "READ");
307     if (file.IsOpen()) {
308       file.GetObject("AliITSOnlineCalibrationSPD", calib);
309       file.Close();
310       if (calib!=NULL) {
311         UInt_t nrNoisy=calib->GetNrBad();
312         for (UInt_t index=0; index<nrNoisy; index++) {
313           UInt_t key = calib->GetKeyAt(index);
314           UInt_t eq = GetEqIdFromKey(key);
315           UInt_t hs = GetHSFromKey(key);
316           UInt_t chip = GetChipFromKey(key);
317           UInt_t col = GetColFromKey(key);
318           UInt_t row = GetRowFromKey(key);
319           SetNoisyPixel(eq,hs,chip,col,row);
320         }
321       }
322     }
323   }
324   return kTRUE;
325 }
326 //____________________________________________________________________________________________
327 UInt_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromText(const char *fileName, UInt_t module) {
328   // read dead from a text file (lines with eq,hs,chip,col,row). returns nr of pixels added (not already here)
329   // insert only those pixels that belong to module (or all if module=240). 
330   UInt_t newNrDead=0;
331   ifstream textFile;
332   textFile.open(fileName, ifstream::in);
333   if (textFile.fail()) {
334     Warning("AliITSOnlineCalibrationSPDhandler::ReadDeadFromText","No dead text file (%s) present.",fileName);
335   }
336   else {
337     while(1) {
338       UInt_t eq,hs,chip,col,row;
339       textFile >> eq; if (textFile.eof()) break;
340       textFile >> hs; if (textFile.eof()) break;
341       textFile >> chip; if (textFile.eof()) break;
342       textFile >> col; if (textFile.eof()) break;
343       textFile >> row; 
344       if (module==240 || (Int_t)module==AliITSRawStreamSPD::GetModuleNumber(eq,hs,chip)){
345         if (SetDeadPixel(eq,hs,chip,col,row)) {
346           newNrDead++;
347         }
348       }
349       if (textFile.eof()) break;
350     }
351     textFile.close();
352   }
353   return newNrDead;
354 }
355 //____________________________________________________________________________________________
356 UInt_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromText(const char *fileName, UInt_t module) {
357   // read noisy from a text file (lines with eq,hs,chip,col,row). returns nr of pixels added (not already here)
358   // insert only those pixels that belong to module (or all if module=240). 
359   UInt_t newNrNoisy=0;
360   ifstream textFile;
361   textFile.open(fileName, ifstream::in);
362   if (textFile.fail()) {
363     Warning("AliITSOnlineCalibrationSPDhandler::ReadNoisyFromText","No noisy text file (%s) present.",fileName);
364   }
365   else {
366     while(1) {
367       UInt_t eq,hs,chip,col,row;
368       textFile >> eq; if (textFile.eof()) break;
369       textFile >> hs; if (textFile.eof()) break;
370       textFile >> chip; if (textFile.eof()) break;
371       textFile >> col; if (textFile.eof()) break;
372       textFile >> row; 
373       if (module==240 || (Int_t)module==AliITSRawStreamSPD::GetModuleNumber(eq,hs,chip)){
374         if (SetNoisyPixel(eq,hs,chip,col,row)) {
375           newNrNoisy++;
376         }
377       }
378       if (textFile.eof()) break;
379     }
380     textFile.close();
381   }
382   return newNrNoisy;
383 }
384 //____________________________________________________________________________________________
385 void AliITSOnlineCalibrationSPDhandler::WriteToFilesAlways() {
386   // write the lists of active,dead,noisy to files
387   for (UInt_t eq=0; eq<20; eq++) {
388     WriteSilentToFile(eq);
389     WriteNoisyToFile(eq);
390   }
391 }
392 //____________________________________________________________________________________________
393 UInt_t AliITSOnlineCalibrationSPDhandler::WriteToFiles() {
394   // write the lists of dead and noisy to files (only if there are >0 dead or noisy pixels) , returns nr of files produced
395   return (WriteNoisyToFiles() + WriteSilentToFiles());
396 }
397 //____________________________________________________________________________________________
398 void AliITSOnlineCalibrationSPDhandler::WriteSilentToFilesAlways() {
399   // write the lists of silent to files
400   for (UInt_t eq=0; eq<20; eq++) {
401       WriteSilentToFile(eq);
402   }
403 }
404 //____________________________________________________________________________________________
405 void AliITSOnlineCalibrationSPDhandler::WriteDeadToFilesAlways() {
406   // write the lists of dead to files
407   for (UInt_t eq=0; eq<20; eq++) {
408       WriteDeadToFile(eq);
409   }
410 }
411 //____________________________________________________________________________________________
412 void AliITSOnlineCalibrationSPDhandler::WriteNoisyToFilesAlways() {
413   // write the lists of noisy to files
414   for (UInt_t eq=0; eq<20; eq++) {
415     WriteNoisyToFile(eq);
416   }
417 }
418 //____________________________________________________________________________________________
419 UInt_t AliITSOnlineCalibrationSPDhandler::WriteSilentToFiles() {
420   // write the list of silent to file (only if there are >0 silent pixels) , returns nr of files produced
421   UInt_t nrFiles=0;
422   for (UInt_t eq=0; eq<20; eq++) {
423     if (GetNrSilentEq(eq) > 0) {
424       WriteSilentToFile(eq);
425       nrFiles++;
426     }
427   }
428   return nrFiles;
429 }
430 //____________________________________________________________________________________________
431 UInt_t AliITSOnlineCalibrationSPDhandler::WriteDeadToFiles() {
432   // write the list of dead to file (only if there are >0 dead pixels) , returns nr of files produced
433   UInt_t nrFiles=0;
434   for (UInt_t eq=0; eq<20; eq++) {
435     if (GetNrDeadEq(eq) > 0) {
436       WriteDeadToFile(eq);
437       nrFiles++;
438     }
439   }
440   return nrFiles;
441 }
442 //____________________________________________________________________________________________
443 UInt_t AliITSOnlineCalibrationSPDhandler::WriteNoisyToFiles() {
444   // write the list of noisy to file (only if there are >0 noisy pixels) , returns nr of files produced
445   UInt_t nrFiles=0;
446   for (UInt_t eq=0; eq<20; eq++) {
447     if (GetNrNoisyEq(eq) > 0) {
448       WriteNoisyToFile(eq);
449       nrFiles++;
450     }
451   }
452   return nrFiles;
453 }
454 //____________________________________________________________________________________________
455 void AliITSOnlineCalibrationSPDhandler::WriteSilentToFile(UInt_t eq) {
456   WriteDeadToFile(eq,kTRUE);
457 }
458 //____________________________________________________________________________________________
459 void AliITSOnlineCalibrationSPDhandler::WriteDeadToFile(UInt_t eq, Bool_t inactive) {
460   // write the lists of dead (and inactive if input boolean is true) for eq to file
461   AliITSOnlineCalibrationSPD* calib = new AliITSOnlineCalibrationSPD();
462   calib->SetEqNr(eq);
463   calib->SetBadList(GetDeadArrayOnline(eq));
464   calib->SetNrBad(GetNrDeadEq(eq));
465   if (IsDeadEq(eq)) calib->SetDeadEq();
466   else              calib->SetDeadEq(kFALSE);
467   for (UInt_t hs=0; hs<6; hs++) {
468     if (IsDeadHS(eq,hs)) calib->SetDeadHS(hs);
469     else                 calib->SetDeadHS(hs,kFALSE);
470     for (UInt_t chip=0; chip<10; chip++) {
471       if (IsDeadChip(eq,hs,chip)) calib->SetDeadChip(hs,chip);
472       else                        calib->SetDeadChip(hs,chip,kFALSE);
473     }
474   }
475   if (inactive) {
476     if (IsActiveEq(eq)) calib->ActivateEq();
477     else                calib->ActivateEq(kFALSE);
478     for (UInt_t hs=0; hs<6; hs++) {
479       if (IsActiveHS(eq,hs)) calib->ActivateHS(hs);
480       else                   calib->ActivateHS(hs,kFALSE);
481       for (UInt_t chip=0; chip<10; chip++) {
482         if (IsActiveChip(eq,hs,chip)) calib->ActivateChip(hs,chip);
483         else                          calib->ActivateChip(hs,chip,kFALSE);
484       }
485     }
486   }
487   TString fileName = Form("%s/SPD_Dead_%d.root",fFileLocation.Data(),eq);
488   TFile file(fileName.Data(), "RECREATE");
489   file.WriteTObject(calib, "AliITSOnlineCalibrationSPD");
490   file.Close();
491   delete calib;
492 }
493 //____________________________________________________________________________________________
494 void AliITSOnlineCalibrationSPDhandler::WriteNoisyToFile(UInt_t eq) {
495   // write the lists of noisy for eq to file
496   AliITSOnlineCalibrationSPD* calib = new AliITSOnlineCalibrationSPD();
497   calib->SetEqNr(eq);
498   calib->SetBadList(GetNoisyArrayOnline(eq));
499   calib->SetNrBad(GetNrNoisyEq(eq));
500   TString fileName = Form("%s/SPD_Noisy_%d.root",fFileLocation.Data(),eq);
501   TFile file(fileName.Data(), "RECREATE");
502   file.WriteTObject(calib, "AliITSOnlineCalibrationSPD");
503   file.Close();
504   delete calib;
505 }
506 //____________________________________________________________________________________________
507 #ifndef SPD_DA_OFF
508 Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadModuleFromDB(UInt_t module, Int_t runNr, Bool_t treeSerial) {
509   // reads dead pixels from DB for given module and runNr
510   AliCDBManager* man = AliCDBManager::Instance();
511   if(!man->IsDefaultStorageSet()) {
512     man->SetDefaultStorage("local://$ALICE_ROOT");
513   }
514   AliCDBEntry *cdbEntry = man->Get("ITS/Calib/SPDDead", runNr);
515   TObjArray* spdEntry;
516   if(cdbEntry) {
517     spdEntry = (TObjArray*)cdbEntry->GetObject();
518     if(!spdEntry) return kFALSE;
519   }
520   else {
521     Warning("AliITSOnlineCalibrationSPDhandler::ReadDeadModuleFromDB","Calibration for run %d not found in database.",runNr);
522     return kFALSE;
523   }
524   AliITSCalibrationSPD* calibSPD;
525   calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module);
526
527   UInt_t nrDead = calibSPD->GetNrBadSingle();
528   if (nrDead>0) {
529     if (!treeSerial) RecursiveInsertDead(calibSPD,module,0,nrDead-1);
530     else {
531       for (UInt_t index=0; index<nrDead; index++) {
532         UInt_t colM = calibSPD->GetBadColAt(index);
533         UInt_t rowM = calibSPD->GetBadRowAt(index);
534         SetDeadPixelM(module,colM,rowM);
535       }
536     }
537   }
538   for (UInt_t chipIndex=0; chipIndex<5; chipIndex++) {
539     UInt_t eq,hs,chip,col,row;
540     AliITSRawStreamSPD::OfflineToOnline(module, chipIndex*32, 0, eq, hs, chip, col, row);
541     if (calibSPD->IsChipBad(chipIndex)) {
542       SetDeadChip(eq,hs,chip);
543     }
544     else {
545       SetDeadChip(eq,hs,chip,kFALSE);
546     }
547   }
548
549   spdEntry->SetOwner(kTRUE);
550   spdEntry->Clear();
551   return kTRUE;
552 }
553 //____________________________________________________________________________________________
554 Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyModuleFromDB(UInt_t module, Int_t runNr, Bool_t treeSerial) {
555   // reads noisy pixels from DB for given module and runNr
556   AliCDBManager* man = AliCDBManager::Instance();
557   if(!man->IsDefaultStorageSet()) {
558     man->SetDefaultStorage("local://$ALICE_ROOT");
559   }
560   AliCDBEntry *cdbEntry = man->Get("ITS/Calib/SPDNoisy", runNr);
561   TObjArray* spdEntry;
562   if(cdbEntry) {
563     spdEntry = (TObjArray*)cdbEntry->GetObject();
564     if(!spdEntry) return kFALSE;
565   }
566   else {
567     Warning("AliITSOnlineCalibrationSPDhandler::ReadNoisyModuleFromDB","Calibration for run %d not found in database.",runNr);
568     return kFALSE;
569   }
570   AliITSCalibrationSPD* calibSPD;
571   calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module);
572   UInt_t nrNoisy = calibSPD->GetNrBadSingle();
573   if (nrNoisy>0) {
574     if (!treeSerial) RecursiveInsertNoisy(calibSPD,module,0,nrNoisy-1);
575     else {
576       for (UInt_t index=0; index<nrNoisy; index++) {
577         UInt_t colM = calibSPD->GetBadColAt(index);
578         UInt_t rowM = calibSPD->GetBadRowAt(index);
579         SetNoisyPixelM(module,colM,rowM);
580       }
581     }
582   }
583   spdEntry->SetOwner(kTRUE);
584   spdEntry->Clear();
585   return kTRUE;
586 }
587 //____________________________________________________________________________________________
588 Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromDB(Int_t runNr, Bool_t treeSerial) {
589   // reads dead and noisy pixels from DB for given runNr
590   // note that you may want to clear the lists (if they are not empty) before reading
591   return (ReadNoisyFromDB(runNr,treeSerial) && ReadDeadFromDB(runNr,treeSerial));
592 }
593 //____________________________________________________________________________________________
594 Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromDB(Int_t runNr, Bool_t treeSerial) {
595   // reads dead pixels from DB for given runNr
596   // note that you may want to clear the list (if it is not empty) before reading
597   AliCDBManager* man = AliCDBManager::Instance();
598   if(!man->IsDefaultStorageSet()) {
599     man->SetDefaultStorage("local://$ALICE_ROOT");
600   }
601   AliCDBEntry *cdbEntry = man->Get("ITS/Calib/SPDDead", runNr);
602   TObjArray* spdEntry;
603   if(cdbEntry) {
604     spdEntry = (TObjArray*)cdbEntry->GetObject();
605     if(!spdEntry) return kFALSE;
606   }
607   else {
608     Warning("AliITSOnlineCalibrationSPDhandler::ReadDeadFromDB","Calibration for run %d not found in database.",runNr);
609     return kFALSE;
610   }
611   AliITSCalibrationSPD* calibSPD;
612   for (UInt_t module=0; module<240; module++) {
613     calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module);
614     UInt_t nrDead = calibSPD->GetNrBadSingle();
615     if (nrDead>0) {
616       if (!treeSerial) RecursiveInsertDead(calibSPD,module,0,nrDead-1);
617       else {
618         for (UInt_t index=0; index<nrDead; index++) {
619           UInt_t colM = calibSPD->GetBadColAt(index);
620           UInt_t rowM = calibSPD->GetBadRowAt(index);
621           SetDeadPixelM(module,colM,rowM);
622         }
623       }
624     }
625     for (UInt_t chipIndex=0; chipIndex<5; chipIndex++) {
626       UInt_t eq,hs,chip,col,row;
627       AliITSRawStreamSPD::OfflineToOnline(module, chipIndex*32, 0, eq, hs, chip, col, row);
628       if (calibSPD->IsChipBad(chipIndex)) {
629         SetDeadChip(eq,hs,chip);
630       }
631       else {
632         SetDeadChip(eq,hs,chip,kFALSE);
633       }
634     }
635   }
636   spdEntry->SetOwner(kTRUE);
637   spdEntry->Clear();
638   return kTRUE;
639 }
640 //____________________________________________________________________________________________
641 Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromDB(Int_t runNr, Bool_t treeSerial) {
642   // reads noisy pixels from DB for given runNr
643   // note that you may want to clear the list (if it is not empty) before reading
644   AliCDBManager* man = AliCDBManager::Instance();
645   if(!man->IsDefaultStorageSet()) {
646     man->SetDefaultStorage("local://$ALICE_ROOT");
647   }
648   AliCDBEntry *cdbEntry = man->Get("ITS/Calib/SPDNoisy", runNr);
649   TObjArray* spdEntry;
650   if(cdbEntry) {
651     spdEntry = (TObjArray*)cdbEntry->GetObject();
652     if(!spdEntry) return kFALSE;
653   }
654   else {
655     Warning("AliITSOnlineCalibrationSPDhandler::ReadNoisyFromDB","Calibration for run %d not found in database.",runNr);
656     return kFALSE;
657   }
658   AliITSCalibrationSPD* calibSPD;
659   for (UInt_t module=0; module<240; module++) {
660     calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module);
661     UInt_t nrNoisy = calibSPD->GetNrBadSingle();
662     if (nrNoisy>0) {    
663       if (!treeSerial) {
664         RecursiveInsertNoisy(calibSPD,module,0,nrNoisy-1);
665       }
666       else {
667         for (UInt_t index=0; index<nrNoisy; index++) {
668           UInt_t colM = calibSPD->GetBadColAt(index);
669           UInt_t rowM = calibSPD->GetBadRowAt(index);
670           SetNoisyPixelM(module,colM,rowM);
671         }
672       }
673     }
674   }
675   spdEntry->SetOwner(kTRUE);
676   spdEntry->Clear();
677   return kTRUE;
678 }
679 //____________________________________________________________________________________________
680 Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromCalibObj(TObjArray* calObj) {
681   // reads dead pixels from calib object
682   for (UInt_t module=0; module<240; module++) {
683     AliITSCalibrationSPD* calibSPD = (AliITSCalibrationSPD*)calObj->At(module);
684     for (Int_t i=0; i<calibSPD->GetNrBadSingle(); i++) {
685       SetDeadPixelM(module,calibSPD->GetBadColAt(i),calibSPD->GetBadRowAt(i));
686     }
687     for (UInt_t chipIndex=0; chipIndex<5; chipIndex++) {
688       UInt_t eq,hs,chip,col,row;
689       AliITSRawStreamSPD::OfflineToOnline(module, chipIndex*32, 0, eq, hs, chip, col, row);
690       if (calibSPD->IsChipBad(chipIndex)) {
691         SetDeadChip(eq,hs,chip);
692       }
693       else {
694         SetDeadChip(eq,hs,chip,kFALSE);
695       }
696     }
697   }
698   return kTRUE;
699 }
700 //____________________________________________________________________________________________
701 Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromCalibObj(TObjArray* calObj) {
702   // reads noisy pixels from calib object
703   for (UInt_t module=0; module<240; module++) {
704     AliITSCalibrationSPD* calibSPD = (AliITSCalibrationSPD*)calObj->At(module);
705     for (Int_t i=0; i<calibSPD->GetNrBadSingle(); i++) {
706       SetNoisyPixelM(module,calibSPD->GetBadColAt(i),calibSPD->GetBadRowAt(i));
707     }
708   }
709   return kTRUE;
710 }
711 //____________________________________________________________________________________________
712 Bool_t AliITSOnlineCalibrationSPDhandler::WriteToDB(Int_t runNrStart, Int_t runNrEnd) {
713   // writes dead and noisy pixels to DB for given runNrs
714   // overwrites any previous entries
715   return (WriteNoisyToDB(runNrStart,runNrEnd) && WriteDeadToDB(runNrStart,runNrEnd));
716 }
717 //____________________________________________________________________________________________
718 Bool_t AliITSOnlineCalibrationSPDhandler::WriteDeadToDB(Int_t runNrStart, Int_t runNrEnd) {
719   // writes dead pixels to DB for given runNrs
720   // overwrites any previous entries
721   AliCDBManager* man = AliCDBManager::Instance();
722   if(!man->IsDefaultStorageSet()) {
723     man->SetDefaultStorage("local://$ALICE_ROOT");
724   }
725   AliCDBMetaData* metaData = new AliCDBMetaData();
726   metaData->SetResponsible("Henrik Tydesjo");
727   metaData->SetComment("Created by AliITSOnlineCalibrationSPDhandler.");
728   AliCDBId idCalSPD("ITS/Calib/SPDDead",runNrStart,runNrEnd);
729   TObjArray* spdEntry = new TObjArray(240);
730   spdEntry->SetOwner(kTRUE);
731   for(UInt_t module=0; module<240; module++){
732     AliITSCalibrationSPD* calibSPD = new AliITSCalibrationSPD();
733     spdEntry->Add(calibSPD);
734   }
735   for(UInt_t module=0; module<240; module++){
736     AliITSCalibrationSPD* calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module);
737     calibSPD->SetNrBadSingle( GetNrDeadSingle(module) );
738     calibSPD->SetBadList( GetDeadArray(module) );
739     for (UInt_t chipIndex=0; chipIndex<5; chipIndex++) {
740       UInt_t eq,hs,chip,col,row;
741       AliITSRawStreamSPD::OfflineToOnline(module, chipIndex*32, 0, eq, hs, chip, col, row);
742       if (IsSilentChip(eq,hs,chip)) {
743         calibSPD->SetChipBad(chipIndex);
744       }
745       else {
746         calibSPD->UnSetChipBad(chipIndex);
747       }
748     }
749   }
750   AliCDBEntry* cdbEntry = new AliCDBEntry((TObject*)spdEntry,idCalSPD,metaData);
751   man->Put(cdbEntry);
752   delete spdEntry;
753   delete cdbEntry;
754   delete metaData;
755   return kTRUE;
756 }
757 //____________________________________________________________________________________________
758 Bool_t AliITSOnlineCalibrationSPDhandler::WriteDeadToDBasNoisy(Int_t runNrStart, Int_t runNrEnd) {
759   // writes dead pixels to DB for given runNrs
760   // overwrites any previous entries
761   AliCDBManager* man = AliCDBManager::Instance();
762   if(!man->IsDefaultStorageSet()) {
763     man->SetDefaultStorage("local://$ALICE_ROOT");
764   }
765   AliCDBMetaData* metaData = new AliCDBMetaData();
766   metaData->SetResponsible("Henrik Tydesjo");
767   metaData->SetComment("Created by AliITSOnlineCalibrationSPDhandler.");
768   AliCDBId idCalSPD("ITS/Calib/SPDNoisy",runNrStart,runNrEnd);
769   TObjArray* spdEntry = new TObjArray(240);
770   spdEntry->SetOwner(kTRUE);
771   for(UInt_t module=0; module<240; module++){
772     AliITSCalibrationSPD* calibSPD = new AliITSCalibrationSPD();
773     spdEntry->Add(calibSPD);
774   }
775   for(UInt_t module=0; module<240; module++){
776     AliITSCalibrationSPD* calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module);
777     calibSPD->SetNrBadSingle( GetNrDeadSingle(module) );
778     calibSPD->SetBadList( GetDeadArray(module) );
779     for (UInt_t chipIndex=0; chipIndex<5; chipIndex++) {
780       UInt_t eq,hs,chip,col,row;
781       AliITSRawStreamSPD::OfflineToOnline(module, chipIndex*32, 0, eq, hs, chip, col, row);
782       if (IsSilentChip(eq,hs,chip)) {
783         calibSPD->SetChipBad(chipIndex);
784       }
785       else {
786         calibSPD->UnSetChipBad(chipIndex);
787       }
788     }
789   }
790   AliCDBEntry* cdbEntry = new AliCDBEntry((TObject*)spdEntry,idCalSPD,metaData);
791   man->Put(cdbEntry);
792   delete spdEntry;
793   delete cdbEntry;
794   delete metaData;
795   return kTRUE;
796 }
797 //____________________________________________________________________________________________
798 Bool_t AliITSOnlineCalibrationSPDhandler::WriteNoisyToDB(Int_t runNrStart, Int_t runNrEnd) {
799   // writes noisy pixels to DB for given runNrs
800   // overwrites any previous entries
801   AliCDBManager* man = AliCDBManager::Instance();
802   if(!man->IsDefaultStorageSet()) {
803     man->SetDefaultStorage("local://$ALICE_ROOT");
804   }
805   AliCDBMetaData* metaData = new AliCDBMetaData();
806   metaData->SetResponsible("Henrik Tydesjo");
807   metaData->SetComment("Created by AliITSOnlineCalibrationSPDhandler.");
808   AliCDBId idCalSPD("ITS/Calib/SPDNoisy",runNrStart,runNrEnd);
809   TObjArray* spdEntry = new TObjArray(240);
810   spdEntry->SetOwner(kTRUE);
811   for(UInt_t module=0; module<240; module++){
812     AliITSCalibrationSPD* calibSPD = new AliITSCalibrationSPD();
813     spdEntry->Add(calibSPD);
814   }
815   for(UInt_t module=0; module<240; module++){
816     AliITSCalibrationSPD* calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module);
817     calibSPD->SetNrBadSingle( GetNrNoisySingle(module) );
818     calibSPD->SetBadList( GetNoisyArray(module) );
819   }
820   AliCDBEntry* cdbEntry = new AliCDBEntry((TObject*)spdEntry,idCalSPD,metaData);
821   man->Put(cdbEntry);
822   delete spdEntry;
823   delete cdbEntry;
824   delete metaData;
825   return kTRUE;
826 }
827 //____________________________________________________________________________________________
828 void AliITSOnlineCalibrationSPDhandler::RecursiveInsertDead(AliITSCalibrationSPD* calibSPD, UInt_t module, Int_t lowInd, Int_t highInd) {
829   // inserts dead pixels recursively, used when reading from db
830   if (lowInd>highInd) return;
831   Int_t thisInd = lowInd+(highInd-lowInd)/2;
832   SetDeadPixelM(module,calibSPD->GetBadColAt(thisInd),calibSPD->GetBadRowAt(thisInd));
833   RecursiveInsertDead(calibSPD,module,lowInd,thisInd-1);
834   RecursiveInsertDead(calibSPD,module,thisInd+1,highInd);
835 }
836 //____________________________________________________________________________________________
837 void AliITSOnlineCalibrationSPDhandler::RecursiveInsertNoisy(AliITSCalibrationSPD* calibSPD, UInt_t module, Int_t lowInd, Int_t highInd) {
838   // inserts noisy pixels recursively, used when reading from db
839   if (lowInd>highInd) return;
840   Int_t thisInd = lowInd+(highInd-lowInd)/2;
841   SetNoisyPixelM(module,calibSPD->GetBadColAt(thisInd),calibSPD->GetBadRowAt(thisInd));
842   RecursiveInsertNoisy(calibSPD,module,lowInd,thisInd-1);
843   RecursiveInsertNoisy(calibSPD,module,thisInd+1,highInd);
844 }
845
846 #endif
847 //____________________________________________________________________________________________
848 void AliITSOnlineCalibrationSPDhandler::GenerateDCSConfigFile(const Char_t* fileName) {
849   // generates an ascii file in the format as the one produced by online da (but with dummy runNr=0)
850   ofstream dcsfile;
851   dcsfile.open(fileName);
852   dcsfile << "[SPD SCAN]\n";
853   dcsfile << "RunNumber=" << "0" << "\n"; // dummy value
854   dcsfile << "Type=" << "4" << "\n";
855   dcsfile << "Router=" << "0" << "\n"; // dummy value
856   dcsfile << "ActualDetConfiguration=" << "0,-1,-1\n"; // dummy values
857   dcsfile << "[NOISY]\n";
858   for (UInt_t module=0; module<240; module++) {
859     UInt_t headkey=20*10*6;
860     for (UInt_t ind=0; ind<GetNrNoisy(module); ind++) {
861       UInt_t newkey = GetNoisyEqIdAt(module,ind)*10*6 +
862         GetNoisyHSAt(module,ind)*10 +
863         GetNoisyChipAt(module,ind);
864       if (newkey!=headkey) { // print eq,hs,chip header
865         headkey = newkey;
866         dcsfile << "-" << newkey/(6*10) << "," << (newkey%(6*10))/10 << "," << (newkey%(6*10))%10 << "\n";
867       }
868       dcsfile << GetNoisyColAt(module,ind) << "," << GetNoisyRowAt(module,ind) << "\n";
869     }
870   }
871   dcsfile.close();
872 }
873 //____________________________________________________________________________________________
874 TArrayS AliITSOnlineCalibrationSPDhandler::GetSilentArray(UInt_t module, Bool_t treeSerial) {
875   // get a TArrayS of the silent=dead+inactive pixels (format for the AliITSCalibrationSPD object)
876   // NB! with new implementation of AliITSCalibrationSPD this is not needed anymore
877   TArrayS returnArray;
878
879   UInt_t eq = GetEqIdFromOffline(module);
880   UInt_t hs = GetHSFromOffline(module);
881   UInt_t size=0;
882   if ( !( IsActiveEq(eq) && IsActiveHS(eq,hs) ) ) {
883     size = 8192*5;
884   }
885   else {
886     for (UInt_t ch=0; ch<5; ch++) {
887       UInt_t chip = GetChipFromOffline(module,ch*32);
888       if (!(IsActiveChip(eq,hs,chip))) {
889         size += 8192;
890       }
891       else {
892         UInt_t gloChip = GetGloChip(eq,hs,chip);
893         size += fNrDead[gloChip];
894       }
895     }
896   }
897   returnArray.Set(size*2);
898
899   UInt_t gloIndex=0;
900   if ( !( IsActiveEq(eq) && IsActiveHS(eq,hs) ) ) {
901     for (UInt_t colM=0; colM<160; colM++) {
902       for (UInt_t rowM=0; rowM<256; rowM++) {
903         returnArray.AddAt(colM,gloIndex*2);
904         returnArray.AddAt(rowM,gloIndex*2+1);
905         gloIndex++;
906       }
907     }
908   }
909   else {
910     for (UInt_t ch=0; ch<5; ch++) {
911       UInt_t chip = GetChipFromOffline(module,ch*32);
912       if (!(IsActiveChip(eq,hs,chip))) {
913         for (UInt_t colM=ch*32; colM<ch*32+32; colM++) {
914           for (UInt_t rowM=0; rowM<256; rowM++) {
915             returnArray.AddAt(colM,gloIndex*2);
916             returnArray.AddAt(rowM,gloIndex*2+1);
917             gloIndex++;
918           }
919         }
920       }
921       else {
922         UInt_t gloChip = GetGloChip(eq,hs,chip);
923         if (treeSerial) fDeadPixelMap[gloChip]->PrepareSerialize(); // for tree ordered values
924         else fDeadPixelMap[gloChip]->PrepareSerializeOrdered(); // for key ordered values
925         for (UInt_t index=0; index<fNrDead[gloChip]; index++) {
926           Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
927           Int_t colM = GetColMFromKey(key);
928           Int_t rowM = GetRowMFromKey(key);
929           returnArray.AddAt(colM,gloIndex*2);
930           returnArray.AddAt(rowM,gloIndex*2+1);
931           gloIndex++;
932         }
933       }
934     }
935   }
936   return returnArray;
937 }
938 //____________________________________________________________________________________________
939 TArrayS AliITSOnlineCalibrationSPDhandler::GetDeadArray(UInt_t module, Bool_t treeSerial) {
940   // get a TArrayS of the single dead pixels (format for the AliITSCalibrationSPD object)
941   TArrayS returnArray;
942
943   UInt_t eq = GetEqIdFromOffline(module);
944   UInt_t hs = GetHSFromOffline(module);
945   UInt_t size=GetNrDeadSingle(module);
946   returnArray.Set(size*2);
947   UInt_t gloIndex=0;
948   for (UInt_t ch=0; ch<5; ch++) {
949     UInt_t chip = GetChipFromOffline(module,ch*32);
950     UInt_t gloChip = GetGloChip(eq,hs,chip);
951     if (treeSerial) fDeadPixelMap[gloChip]->PrepareSerialize(); // for tree ordered values
952     else fDeadPixelMap[gloChip]->PrepareSerializeOrdered(); // for key ordered values
953     if (!IsSilentChip(eq,hs,chip)) {
954       for (UInt_t index=0; index<fNrDead[gloChip]; index++) {
955         Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
956         Int_t colM = GetColMFromKey(key);
957         Int_t rowM = GetRowMFromKey(key);
958         returnArray.AddAt(colM,gloIndex*2);
959         returnArray.AddAt(rowM,gloIndex*2+1);
960         gloIndex++;
961       }
962     }
963   }
964   return returnArray;
965 }
966 //____________________________________________________________________________________________
967 TArrayS AliITSOnlineCalibrationSPDhandler::GetNoisyArray(UInt_t module, Bool_t treeSerial) {
968   // get a TArrayS of the single noisy pixels (format for the AliITSCalibrationSPD object)
969   TArrayS returnArray;
970
971   UInt_t eq = GetEqIdFromOffline(module);
972   UInt_t hs = GetHSFromOffline(module);
973   UInt_t size=GetNrNoisySingle(module);
974   returnArray.Set(size*2);
975   UInt_t gloIndex=0;
976   for (UInt_t ch=0; ch<5; ch++) {
977     UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,ch*32));
978     if (treeSerial) fNoisyPixelMap[gloChip]->PrepareSerialize(); // for tree ordered values
979     else fNoisyPixelMap[gloChip]->PrepareSerializeOrdered(); // for key ordered values
980     for (UInt_t index=0; index<fNrNoisy[gloChip]; index++) {
981       Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(index);
982       Int_t colM = GetColMFromKey(key);
983       Int_t rowM = GetRowMFromKey(key);
984       returnArray.AddAt(colM,gloIndex*2);
985       returnArray.AddAt(rowM,gloIndex*2+1);
986       gloIndex++;
987     }
988   }
989   return returnArray;
990 }
991 //____________________________________________________________________________________________
992 TArrayI AliITSOnlineCalibrationSPDhandler::GetDeadArrayOnline(UInt_t eq) {
993   // get a TArrayI of the single dead pixels (format for the AliITSOnlineCalibrationSPD object)
994   TArrayI returnArray;
995   // fix size of array
996   UInt_t size=0;
997   for (UInt_t hs=0; hs<6; hs++) {
998     for (UInt_t chip=0; chip<10; chip++) {
999       UInt_t gloChip = GetGloChip(eq,hs,chip);
1000       size+=fNrDead[gloChip];
1001     }
1002   }
1003   returnArray.Set(size);
1004   // put keys in array
1005   UInt_t gloIndex=0;
1006   for (UInt_t hs=0; hs<6; hs++) {
1007     for (UInt_t chip=0; chip<10; chip++) {
1008       UInt_t gloChip = GetGloChip(eq,hs,chip);
1009       fDeadPixelMap[gloChip]->PrepareSerialize(); // for tree ordered values
1010       for (UInt_t index=0; index<fNrDead[gloChip]; index++) {
1011         Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
1012         returnArray.AddAt(key,gloIndex);
1013         gloIndex++;
1014       }
1015     }
1016   }
1017   return returnArray;
1018 }
1019 //____________________________________________________________________________________________
1020 TArrayI AliITSOnlineCalibrationSPDhandler::GetNoisyArrayOnline(UInt_t eq) {
1021   // get a TArrayI of the single noisy pixels (format for the AliITSOnlineCalibrationSPD object)
1022   TArrayI returnArray;
1023   // fix size of array
1024   UInt_t size=0;
1025   for (UInt_t hs=0; hs<6; hs++) {
1026     for (UInt_t chip=0; chip<10; chip++) {
1027       UInt_t gloChip = GetGloChip(eq,hs,chip);
1028       size+=fNrNoisy[gloChip];
1029     }
1030   }
1031   returnArray.Set(size);
1032   // put keys in array
1033   UInt_t gloIndex=0;
1034   for (UInt_t hs=0; hs<6; hs++) {
1035     for (UInt_t chip=0; chip<10; chip++) {
1036       UInt_t gloChip = GetGloChip(eq,hs,chip);
1037       fNoisyPixelMap[gloChip]->PrepareSerialize(); // for tree ordered values
1038       for (UInt_t index=0; index<fNrNoisy[gloChip]; index++) {
1039         Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(index);
1040         returnArray.AddAt(key,gloIndex);
1041         gloIndex++;
1042       }
1043     }
1044   }
1045   return returnArray;
1046 }
1047 //____________________________________________________________________________________________
1048 void AliITSOnlineCalibrationSPDhandler::PrintEqSummary() {
1049 // print summary (nr of dead and noisy) for each equipment
1050   printf("-----------\n");
1051   printf("Eq summary:\n");
1052   printf("-----------\n");
1053   for (UInt_t eq=0; eq<20; eq++) {
1054     printf("Eq %*d: %*d silent(dead+inactive) , %*d dead , %*d noisy\n",2,eq,6,GetNrSilentEq(eq),6,GetNrDeadEq(eq),6,GetNrNoisyEq(eq));
1055   }
1056 }
1057 //____________________________________________________________________________________________
1058 void AliITSOnlineCalibrationSPDhandler::PrintSilent() const {
1059   // print the inactive and dead pixels to screen
1060   printf("-----------------------------------------------------------\n");
1061   printf("Inactive or dead Equipments: (eq  |  module1 .. module12)\n");
1062   printf("-----------------------------------------------------------\n");
1063   for (UInt_t eq=0; eq<20; eq++) {
1064     if (IsSilentEq(eq)) {
1065       printf("%*d  |  ",2,eq);
1066       for (UInt_t hs=0; hs<6; hs++) {
1067         for (UInt_t chip=0; chip<10; chip+=5) {
1068           UInt_t module = AliITSRawStreamSPD::GetOfflineModuleFromOnline(eq,hs,chip);
1069           if (hs>0 || chip==5) printf(",");
1070           printf("%*d",3,module);
1071         }
1072       }
1073       printf("\n");
1074     }
1075   }
1076
1077   printf("-----------------------------------------------------------\n");
1078   printf("Inactive or dead Half-staves: (eq,hs  |  module1,module2)\n");
1079   printf("-----------------------------------------------------------\n");
1080   for (UInt_t eq=0; eq<20; eq++) {
1081     if (!IsSilentEq(eq)) {
1082       for (UInt_t hs=0; hs<6; hs++) {
1083         if (IsSilentHS(eq,hs)) {
1084           printf("%*d,%*d  |  ",2,eq,1,hs);
1085           for (UInt_t chip=0; chip<10; chip+=5) {
1086             UInt_t module = AliITSRawStreamSPD::GetOfflineModuleFromOnline(eq,hs,chip);
1087             if (chip==5) printf(",");
1088             printf("%*d",3,module);
1089           }
1090           printf("\n");
1091         }
1092       }
1093     }
1094   }
1095
1096   printf("-----------------------------------------------------------\n");
1097   printf("Inactive or dead Chips: (eq,hs,chip  |  module,colM1-colM2)\n");
1098   printf("-----------------------------------------------------------\n");
1099   for (UInt_t eq=0; eq<20; eq++) {
1100     if (!IsSilentEq(eq)) {
1101       for (UInt_t hs=0; hs<6; hs++) {
1102         if (!IsSilentHS(eq,hs)) {
1103           for (UInt_t chip=0; chip<10; chip++) {
1104             if (IsSilentChip(eq,hs,chip)) {
1105               printf("%*d,%*d,%*d  |  ",2,eq,1,hs,1,chip);
1106               UInt_t module = AliITSRawStreamSPD::GetOfflineModuleFromOnline(eq,hs,chip);
1107               UInt_t colM1 = AliITSRawStreamSPD::GetOfflineColFromOnline(eq,hs,chip,0);
1108               UInt_t colM2 = AliITSRawStreamSPD::GetOfflineColFromOnline(eq,hs,chip,31);
1109               printf("%*d,%*d-%*d\n",3,module,3,colM1,3,colM2);
1110             }
1111           }
1112         }
1113       }
1114     }
1115   }
1116
1117   PrintDead();
1118
1119 }
1120 //____________________________________________________________________________________________
1121 void AliITSOnlineCalibrationSPDhandler::PrintDead() const {
1122   // print the single dead pixels to screen (disregards inactive eq,hs,chip)
1123   printf("------------------------------------------------------\n");
1124   printf("Dead Pixels: (eq,hs,chip,col,row  |  module,colM,rowM)\n");
1125   printf("------------------------------------------------------\n");
1126   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
1127     for (UInt_t index=0; index<fNrDead[gloChip]; index++) {
1128       Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
1129       UInt_t eq = GetEqIdFromKey(key);
1130       UInt_t hs = GetHSFromKey(key);
1131       UInt_t chip = GetChipFromKey(key);
1132       UInt_t col = GetColFromKey(key);
1133       UInt_t row = GetRowFromKey(key);
1134
1135       UInt_t module = AliITSRawStreamSPD::GetOfflineModuleFromOnline(eq,hs,chip);
1136       UInt_t colM = AliITSRawStreamSPD::GetOfflineColFromOnline(eq,hs,chip,col);
1137       UInt_t rowM = AliITSRawStreamSPD::GetOfflineRowFromOnline(eq,hs,chip,row);
1138
1139       printf("%*d,%*d,%*d,%*d,%*d  |  %*d,%*d,%*d\n",2,eq,1,hs,1,chip,2,col,3,row,3,module,3,colM,3,rowM);
1140     }
1141   }
1142 }
1143 //____________________________________________________________________________________________
1144 void AliITSOnlineCalibrationSPDhandler::PrintNoisy() const {
1145   // print the dead pixels to screen
1146   printf("-------------------------------------------------------\n");
1147   printf("Noisy Pixels: (eq,hs,chip,col,row  |  module,colM,rowM)\n");
1148   printf("-------------------------------------------------------\n");
1149   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
1150     for (UInt_t index=0; index<fNrNoisy[gloChip]; index++) {
1151       Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(index);
1152       UInt_t eq = GetEqIdFromKey(key);
1153       UInt_t hs = GetHSFromKey(key);
1154       UInt_t chip = GetChipFromKey(key);
1155       UInt_t col = GetColFromKey(key);
1156       UInt_t row = GetRowFromKey(key);
1157
1158       UInt_t module = AliITSRawStreamSPD::GetOfflineModuleFromOnline(eq,hs,chip);
1159       UInt_t colM = AliITSRawStreamSPD::GetOfflineColFromOnline(eq,hs,chip,col);
1160       UInt_t rowM = AliITSRawStreamSPD::GetOfflineRowFromOnline(eq,hs,chip,row);
1161
1162       printf("%*d,%*d,%*d,%*d,%*d  |  %*d,%*d,%*d\n",2,eq,1,hs,1,chip,2,col,3,row,3,module,3,colM,3,rowM);
1163     }
1164   }
1165 }
1166 //____________________________________________________________________________________________
1167 Bool_t AliITSOnlineCalibrationSPDhandler::SetDeadPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
1168   // set a dead pixel, returns false if pixel is already dead
1169   UInt_t gloChip = GetGloChip(eq,hs,chip);
1170   if (gloChip>=1200) {
1171     Error("AliITSOnlineCalibrationSPDhandler::SetDeadPixel", "eq,hs,chip nrs (%d,%d,%d) out of bounds.",eq,hs,chip);
1172     return kFALSE;
1173   }
1174   if (col>=32 && row>=256) {
1175     Error("AliITSOnlineCalibrationSPDhandler::SetDeadPixel", "col,row nrs (%d,%d) out of bounds.",col,row);
1176     return kFALSE;
1177   }
1178   Int_t key = GetKey(eq,hs,chip,col,row);
1179   // if noisy we dont want to add it...
1180   if (fNoisyPixelMap[gloChip]->Find(key) != NULL) return kFALSE;
1181   if (fDeadPixelMap[gloChip]->Insert(key,gloChip)) {
1182     fNrDead[gloChip]++;
1183     return kTRUE;
1184   }
1185   return kFALSE;
1186 }
1187 //____________________________________________________________________________________________
1188 Bool_t AliITSOnlineCalibrationSPDhandler::SetNoisyPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
1189   // set a noisy pixel, returns false if pixel is already noisy
1190   UInt_t gloChip = GetGloChip(eq,hs,chip);
1191   if (gloChip>=1200) {
1192     Error("AliITSOnlineCalibrationSPDhandler::SetNoisyPixel", "eq,hs,chip nrs (%d,%d,%d) out of bounds.",eq,hs,chip);
1193     return kFALSE;
1194   }
1195   if (col>=32 && row>=256) {
1196     Error("AliITSOnlineCalibrationSPDhandler::SetNoisyPixel", "col,row nrs (%d,%d) out of bounds.",col,row);
1197     return kFALSE;
1198   }
1199   Int_t key = GetKey(eq,hs,chip,col,row);
1200   // if dead before - remove from the dead list 
1201   if (fDeadPixelMap[gloChip]->Remove(key)) {
1202     fNrDead[gloChip]--;
1203   }
1204   if (fNoisyPixelMap[gloChip]->Insert(key,gloChip)) {
1205     fNrNoisy[gloChip]++;
1206     return kTRUE;
1207   }
1208   return kFALSE;
1209 }
1210 //____________________________________________________________________________________________
1211 Bool_t AliITSOnlineCalibrationSPDhandler::SetDeadPixelM(UInt_t module, UInt_t colM, UInt_t rowM) {
1212   // set a dead pixel, returns false if pixel is already dead
1213   UInt_t eq = GetEqIdFromOffline(module);
1214   UInt_t hs = GetHSFromOffline(module);
1215   UInt_t chip = GetChipFromOffline(module,colM);
1216   UInt_t col = GetColFromOffline(module,colM);
1217   UInt_t row = GetRowFromOffline(module,rowM);
1218   return SetDeadPixel(eq,hs,chip,col,row);
1219 }
1220 //____________________________________________________________________________________________
1221 Bool_t AliITSOnlineCalibrationSPDhandler::SetNoisyPixelM(UInt_t module, UInt_t colM, UInt_t rowM) {
1222   // set a noisy pixel, returns false if pixel is already noisy
1223   UInt_t eq = GetEqIdFromOffline(module);
1224   UInt_t hs = GetHSFromOffline(module);
1225   UInt_t chip = GetChipFromOffline(module,colM);
1226   UInt_t col = GetColFromOffline(module,colM);
1227   UInt_t row = GetRowFromOffline(module,rowM);
1228   return SetNoisyPixel(eq,hs,chip,col,row);
1229 }
1230 //____________________________________________________________________________________________
1231 Bool_t AliITSOnlineCalibrationSPDhandler::UnSetDeadPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
1232   // unset a dead pixel, returns false if pixel is not dead
1233   UInt_t gloChip = GetGloChip(eq,hs,chip);
1234   if (gloChip>=1200) {
1235     Error("AliITSOnlineCalibrationSPDhandler::UnSetDeadPixel", "eq,hs,chip nrs (%d,%d,%d) out of bounds.",eq,hs,chip);
1236     return kFALSE;
1237   }
1238   Int_t key = GetKey(eq,hs,chip,col,row);
1239   if (fDeadPixelMap[gloChip]->Remove(key)) {
1240     fNrDead[gloChip]--;
1241     return kTRUE;
1242   }
1243   return kFALSE;
1244 }
1245 //____________________________________________________________________________________________
1246 Bool_t AliITSOnlineCalibrationSPDhandler::UnSetNoisyPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
1247   // unset a noisy pixel, returns false if pixel is not noisy
1248   UInt_t gloChip = GetGloChip(eq,hs,chip);
1249   if (gloChip>=1200) {
1250     Error("AliITSOnlineCalibrationSPDhandler::UnSetNoisyPixel", "eq,hs,chip nrs (%d,%d,%d) out of bounds.",eq,hs,chip);
1251     return kFALSE;
1252   }
1253   Int_t key = GetKey(eq,hs,chip,col,row);
1254   if (fNoisyPixelMap[gloChip]->Remove(key)) {
1255     fNrNoisy[gloChip]--;
1256     return kTRUE;
1257   }
1258   return kFALSE;
1259 }
1260 //____________________________________________________________________________________________
1261 Bool_t AliITSOnlineCalibrationSPDhandler::UnSetDeadPixelM(UInt_t module, UInt_t colM, UInt_t rowM) {
1262   // unset a dead pixel, returns false if pixel is not dead
1263   UInt_t eq = GetEqIdFromOffline(module);
1264   UInt_t hs = GetHSFromOffline(module);
1265   UInt_t chip = GetChipFromOffline(module,colM);
1266   UInt_t col = GetColFromOffline(module,colM);
1267   UInt_t row = GetRowFromOffline(module,rowM);
1268   return UnSetDeadPixel(eq,hs,chip,col,row);
1269 }
1270 //____________________________________________________________________________________________
1271 Bool_t AliITSOnlineCalibrationSPDhandler::UnSetNoisyPixelM(UInt_t module, UInt_t colM, UInt_t rowM) {
1272   // unset a noisy pixel, returns false if pixel is not noisy
1273   UInt_t eq = GetEqIdFromOffline(module);
1274   UInt_t hs = GetHSFromOffline(module);
1275   UInt_t chip = GetChipFromOffline(module,colM);
1276   UInt_t col = GetColFromOffline(module,colM);
1277   UInt_t row = GetRowFromOffline(module,rowM);
1278   return UnSetNoisyPixel(eq,hs,chip,col,row);
1279 }
1280 //____________________________________________________________________________________________
1281 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelBad(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const {
1282   // is the pixel bad (silent or noisy)
1283   return (IsPixelSilent(eq,hs,chip,col,row) || IsPixelNoisy(eq,hs,chip,col,row));
1284 }
1285 //____________________________________________________________________________________________
1286 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelSilent(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const {
1287   // is the pixel silent (dead or inactive)?
1288   UInt_t gloChip = GetGloChip(eq,hs,chip);
1289   if (gloChip>=1200 || col>=32 || row>=256) {
1290     Error("AliITSOnlineCalibrationSPDhandler::IsPixelSilent", "eq,hs,chip,col,row nrs (%d,%d,%d,%d,%d) out of bounds.",eq,hs,chip,col,row);
1291     return kFALSE;
1292   }
1293   if (IsSilentChip(eq,hs,chip)) return kTRUE;
1294   else return IsPixelDead(eq,hs,chip,col,row);
1295 }
1296 //____________________________________________________________________________________________
1297 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDead(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const {
1298   // is the pixel dead?
1299   UInt_t gloChip = GetGloChip(eq,hs,chip);
1300   if (gloChip>=1200 || col>=32 || row>=256) {
1301     Error("AliITSOnlineCalibrationSPDhandler::IsPixelDead", "eq,hs,chip,col,row nrs (%d,%d,%d,%d,%d) out of bounds.",eq,hs,chip,col,row);
1302     return kFALSE;
1303   }
1304   UInt_t key = GetKey(eq,hs,chip,col,row);
1305   if (IsDeadEq(eq) || IsDeadHS(eq,hs) || IsDeadChip(eq,hs,chip)) return kTRUE;
1306   else {
1307     if ( fDeadPixelMap[gloChip]->Find(key) != NULL ) return kTRUE;
1308     else return kFALSE;
1309   }
1310 }
1311 //____________________________________________________________________________________________
1312 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisy(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const {
1313   // is the pixel noisy?
1314   UInt_t gloChip = GetGloChip(eq,hs,chip);
1315   if (gloChip>=1200 || col>=32 || row>=256) {
1316     Error("AliITSOnlineCalibrationSPDhandler::IsPixelNoisy", "eq,hs,chip,col,row nrs (%d,%d,%d) out of bounds.",eq,hs,chip,col,row);
1317     return kFALSE;
1318   }
1319   UInt_t key = GetKey(eq,hs,chip,col,row);
1320   if ( fNoisyPixelMap[gloChip]->Find(key) != NULL ) return kTRUE;
1321   else return kFALSE;
1322 }
1323 //____________________________________________________________________________________________
1324 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelBadM(UInt_t module, UInt_t colM, UInt_t rowM) const {
1325   // is the pixel bad (silent or noisy)?
1326   return (IsPixelSilentM(module,colM,rowM) || IsPixelNoisyM(module,colM,rowM));
1327 }
1328 //____________________________________________________________________________________________
1329 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelSilentM(UInt_t module, UInt_t colM, UInt_t rowM) const {
1330   // is the pixel silent (dead or inactive)?
1331   UInt_t eq = GetEqIdFromOffline(module);
1332   UInt_t hs = GetHSFromOffline(module);
1333   UInt_t chip = GetChipFromOffline(module,colM);
1334   UInt_t col = GetColFromOffline(module,colM);
1335   UInt_t row = GetRowFromOffline(module,rowM);
1336   return IsPixelSilent(eq,hs,chip,col,row);
1337 }
1338 //____________________________________________________________________________________________
1339 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDeadM(UInt_t module, UInt_t colM, UInt_t rowM) const {
1340   // is the pixel dead?
1341   UInt_t eq = GetEqIdFromOffline(module);
1342   UInt_t hs = GetHSFromOffline(module);
1343   UInt_t chip = GetChipFromOffline(module,colM);
1344   UInt_t col = GetColFromOffline(module,colM);
1345   UInt_t row = GetRowFromOffline(module,rowM);
1346   return IsPixelDead(eq,hs,chip,col,row);
1347 }
1348 //____________________________________________________________________________________________
1349 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyM(UInt_t module, UInt_t colM, UInt_t rowM) const  {
1350   // is the pixel noisy?
1351   UInt_t eq = GetEqIdFromOffline(module);
1352   UInt_t hs = GetHSFromOffline(module);
1353   UInt_t chip = GetChipFromOffline(module,colM);
1354   UInt_t col = GetColFromOffline(module,colM);
1355   UInt_t row = GetRowFromOffline(module,rowM);
1356   return IsPixelNoisy(eq,hs,chip,col,row);
1357 }
1358 //____________________________________________________________________________________________
1359 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelBadKey(Int_t key) const {
1360   // is this pixel silent (dead or inactive)?
1361   UInt_t eq = GetEqIdFromKey(key);
1362   UInt_t hs = GetHSFromKey(key);
1363   UInt_t chip = GetChipFromKey(key);
1364   UInt_t col = GetColFromKey(key);
1365   UInt_t row = GetRowFromKey(key);
1366   return IsPixelBad(eq,hs,chip,col,row);
1367 }
1368 //____________________________________________________________________________________________
1369 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelSilentKey(Int_t key) const {
1370   // is this pixel silent (dead or inactive)?
1371   UInt_t eq = GetEqIdFromKey(key);
1372   UInt_t hs = GetHSFromKey(key);
1373   UInt_t chip = GetChipFromKey(key);
1374   UInt_t col = GetColFromKey(key);
1375   UInt_t row = GetRowFromKey(key);
1376   return IsPixelSilent(eq,hs,chip,col,row);
1377 }
1378 //____________________________________________________________________________________________
1379 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDeadKey(Int_t key) const {
1380   // is this pixel dead?
1381   UInt_t eq = GetEqIdFromKey(key);
1382   UInt_t hs = GetHSFromKey(key);
1383   UInt_t chip = GetChipFromKey(key);
1384   UInt_t col = GetColFromKey(key);
1385   UInt_t row = GetRowFromKey(key);
1386   return IsPixelDead(eq,hs,chip,col,row);
1387 }
1388 //____________________________________________________________________________________________
1389 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyKey(Int_t key) const {
1390   // is this pixel noisy?
1391   UInt_t eq = GetEqIdFromKey(key);
1392   UInt_t hs = GetHSFromKey(key);
1393   UInt_t chip = GetChipFromKey(key);
1394   UInt_t col = GetColFromKey(key);
1395   UInt_t row = GetRowFromKey(key);
1396   return IsPixelNoisy(eq,hs,chip,col,row);
1397 }
1398 //____________________________________________________________________________________________
1399 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrBad() const {
1400   // returns the total nr of bad pixels (silent or noisy)
1401   UInt_t nrBad=0;
1402   nrBad+=GetNrSilent();
1403   UInt_t nrNoisy = GetNrNoisy();
1404   for (UInt_t i=0; i<nrNoisy; i++) {
1405     UInt_t eq   = GetNoisyEqIdAt(i);
1406     UInt_t hs   = GetNoisyHSAt(i);
1407     UInt_t chip = GetNoisyChipAt(i);
1408     UInt_t col  = GetNoisyColAt(i);
1409     UInt_t row  = GetNoisyRowAt(i);
1410     if (!IsPixelSilent(eq,hs,chip,col,row)) nrBad++;
1411   }
1412   return nrBad;
1413 }
1414 //____________________________________________________________________________________________
1415 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrSilent() const {
1416   // returns the total nr of silent pixels (dead or inactive)
1417   UInt_t nrDead = 0;
1418   for (UInt_t eq=0; eq<20; eq++) {
1419     if (IsSilentEq(eq)) {
1420       nrDead+=81920*6;
1421       continue;
1422     }
1423     for (UInt_t hs=0; hs<6; hs++) {
1424       if (IsSilentHS(eq,hs)) {
1425         nrDead+=81920;
1426         continue;
1427       }
1428       for (UInt_t chip=0; chip<10; chip++) {
1429         if (IsSilentChip(eq,hs,chip)) {
1430           nrDead+=8192;
1431           continue;
1432         }
1433         else {
1434           UInt_t gloChip = GetGloChip(eq,hs,chip);
1435           nrDead+=fNrDead[gloChip];
1436         }
1437       }
1438     }
1439   }
1440   return nrDead;
1441 }
1442 //____________________________________________________________________________________________
1443 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDead() const {
1444   // returns the total nr of dead pixels
1445   UInt_t nrDead = 0;
1446   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
1447     nrDead+=fNrDead[gloChip];
1448   }
1449   return nrDead;
1450 }
1451 //____________________________________________________________________________________________
1452 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisy() const {
1453   // returns the total nr of noisy pixels
1454   UInt_t nrNoisy = 0;
1455   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
1456     nrNoisy+=fNrNoisy[gloChip];
1457   }
1458   return nrNoisy;
1459 }
1460 //____________________________________________________________________________________________
1461 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAt(UInt_t index) const {
1462   // get eq for the dead pixel at position index in list of dead
1463   UInt_t gloChip;
1464   UInt_t chipIndex;
1465   GetChipAndIndexTotDead(index,gloChip,chipIndex);
1466   return GetDeadEqIdAtC2(gloChip,chipIndex);
1467 }
1468 //____________________________________________________________________________________________
1469 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAt(UInt_t index) const {
1470   // get eq for the noisy pixel at position index in list of noisy
1471   UInt_t gloChip;
1472   UInt_t chipIndex;
1473   GetChipAndIndexTotNoisy(index,gloChip,chipIndex);
1474   return GetNoisyEqIdAtC2(gloChip,chipIndex);
1475 }
1476 //____________________________________________________________________________________________
1477 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAt(UInt_t index) const {
1478   // get hs for the dead pixel at position index in list of dead
1479   UInt_t gloChip;
1480   UInt_t chipIndex;
1481   GetChipAndIndexTotDead(index,gloChip,chipIndex);
1482   return GetDeadHSAtC2(gloChip,chipIndex);
1483 }
1484 //____________________________________________________________________________________________
1485 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAt(UInt_t index) const {
1486   // get hs for the noisy pixel at position index in list of noisy
1487   UInt_t gloChip;
1488   UInt_t chipIndex;
1489   GetChipAndIndexTotNoisy(index,gloChip,chipIndex);
1490   return GetNoisyHSAtC2(gloChip,chipIndex);
1491 }
1492 //____________________________________________________________________________________________
1493 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAt(UInt_t index) const {
1494   // get chip for the dead pixel at position index in list of dead
1495   UInt_t gloChip;
1496   UInt_t chipIndex;
1497   GetChipAndIndexTotDead(index,gloChip,chipIndex);
1498   return GetDeadChipAtC2(gloChip,chipIndex);
1499 }
1500 //____________________________________________________________________________________________
1501 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAt(UInt_t index) const {
1502   // get chip for the noisy pixel at position index in list of noisy
1503   UInt_t gloChip;
1504   UInt_t chipIndex;
1505   GetChipAndIndexTotNoisy(index,gloChip,chipIndex);
1506   return GetNoisyChipAtC2(gloChip,chipIndex);
1507 }
1508 //____________________________________________________________________________________________
1509 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAt(UInt_t index) const {
1510   // get hs for the dead pixel at position index in list of dead
1511   UInt_t gloChip;
1512   UInt_t chipIndex;
1513   GetChipAndIndexTotDead(index,gloChip,chipIndex);
1514   return GetDeadColAtC2(gloChip,chipIndex);
1515 }
1516 //____________________________________________________________________________________________
1517 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAt(UInt_t index) const {
1518   // get hs for the noisy pixel at position index in list of noisy
1519   UInt_t gloChip;
1520   UInt_t chipIndex;
1521   GetChipAndIndexTotNoisy(index,gloChip,chipIndex);
1522   return GetNoisyColAtC2(gloChip,chipIndex);
1523 }
1524 //____________________________________________________________________________________________
1525 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAt(UInt_t index) const {
1526   // get hs for the dead pixel at position index in list of dead
1527   UInt_t gloChip;
1528   UInt_t chipIndex;
1529   GetChipAndIndexTotDead(index,gloChip,chipIndex);
1530   return GetDeadRowAtC2(gloChip,chipIndex);
1531 }
1532 //____________________________________________________________________________________________
1533 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAt(UInt_t index) const {
1534   // get hs for the noisy pixel at position index in list of noisy
1535   UInt_t gloChip;
1536   UInt_t chipIndex;
1537   GetChipAndIndexTotNoisy(index,gloChip,chipIndex);
1538   return GetNoisyRowAtC2(gloChip,chipIndex);
1539 }
1540 //____________________________________________________________________________________________
1541 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrBad(UInt_t module) const {
1542   // returns the number of bad pixels for a certain module (silent or noisy)
1543   UInt_t nrBad = 0;
1544   nrBad+=GetNrSilent(module);
1545   UInt_t nrNoisy = GetNrNoisy(module);
1546   for (UInt_t i=0; i<nrNoisy; i++) {
1547     UInt_t eq   = GetNoisyEqIdAt(module,i);
1548     UInt_t hs   = GetNoisyHSAt(module,i);
1549     UInt_t chip = GetNoisyChipAt(module,i);
1550     UInt_t col  = GetNoisyColAt(module,i);
1551     UInt_t row  = GetNoisyRowAt(module,i);
1552     if (!IsPixelSilent(eq,hs,chip,col,row)) nrBad++;
1553   }
1554   return nrBad;
1555 }
1556 //____________________________________________________________________________________________
1557 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrSilent(UInt_t module) const {
1558   // returns the number of silent pixels for a certain module (dead or inactive)
1559   if (module>=240) {
1560     Error("AliITSOnlineCalibrationSPDhandler::GetNrSilent", "module nr (%d) out of bounds.",module);
1561     return 0;
1562   }
1563   UInt_t nrSilent = 0;
1564   UInt_t eq = GetEqIdFromOffline(module);
1565   if (IsSilentEq(eq)) return 160*256;
1566   UInt_t hs = GetHSFromOffline(module);
1567   if (IsSilentHS(eq,hs)) return 160*256;
1568   for (UInt_t ch=0; ch<5; ch++) {
1569     UInt_t chip = GetChipFromOffline(module,ch*32);
1570     if (IsSilentChip(eq,hs,chip)) {
1571       nrSilent+=8192;
1572     }
1573     else {
1574       UInt_t gloChip = GetGloChip(eq,hs,chip);
1575       nrSilent+=fNrDead[gloChip];
1576     }
1577   }
1578   return nrSilent;
1579 }
1580 //____________________________________________________________________________________________
1581 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadSingle(UInt_t module) const {
1582   // returns the number of single dead pixels (excluding the ones on silent chips) for a certain module
1583   if (module>=240) {
1584     Error("AliITSOnlineCalibrationSPDhandler::GetNrDeadSingle", "module nr (%d) out of bounds.",module);
1585     return 0;
1586   }
1587   UInt_t nrDead = 0;
1588   UInt_t eq = GetEqIdFromOffline(module);
1589   UInt_t hs = GetHSFromOffline(module);
1590   for (UInt_t ch=0; ch<5; ch++) {
1591     UInt_t chip = GetChipFromOffline(module,ch*32);
1592     if (!IsSilentChip(eq,hs,chip)) {
1593       UInt_t gloChip = GetGloChip(eq,hs,chip);
1594       nrDead+=fNrDead[gloChip];
1595     }
1596   }
1597   return nrDead;
1598 }
1599 //____________________________________________________________________________________________
1600 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisySingle(UInt_t module) const {
1601   // returns the number of noisy pixels for a certain module
1602   return GetNrNoisy(module);
1603 }
1604 //____________________________________________________________________________________________
1605 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDead(UInt_t module) const {
1606   // returns the number of dead pixels for a certain module
1607   if (module>=240) {
1608     Error("AliITSOnlineCalibrationSPDhandler::GetNrDead", "module nr (%d) out of bounds.",module);
1609     return 0;
1610   }
1611   UInt_t nrDead = 0;
1612   UInt_t eq = GetEqIdFromOffline(module);
1613   UInt_t hs = GetHSFromOffline(module);
1614   for (UInt_t ch=0; ch<5; ch++) {
1615     UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,ch*32));
1616     nrDead+=fNrDead[gloChip];
1617   }
1618   return nrDead;
1619 }
1620 //____________________________________________________________________________________________
1621 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisy(UInt_t module) const {
1622   // returns the number of noisy pixels for a certain module
1623   if (module>=240) {
1624     Error("AliITSOnlineCalibrationSPDhandler::GetNrNoisy", "module nr (%d) out of bounds.",module);
1625     return 0;
1626   }
1627   UInt_t nrNoisy = 0;
1628   UInt_t eq = GetEqIdFromOffline(module);
1629   UInt_t hs = GetHSFromOffline(module);
1630   for (UInt_t ch=0; ch<5; ch++) {
1631     UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,ch*32));
1632     nrNoisy+=fNrNoisy[gloChip];
1633   }
1634   return nrNoisy;
1635 }
1636 //____________________________________________________________________________________________
1637 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAt(UInt_t module, UInt_t index) const {
1638   // get eq for the dead pixel at position index in list of dead
1639   UInt_t gloChip;
1640   UInt_t chipIndex;
1641   GetChipAndIndexDead(module,index,gloChip,chipIndex);
1642   return GetDeadEqIdAtC2(gloChip,chipIndex);
1643 }
1644 //____________________________________________________________________________________________
1645 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAt(UInt_t module, UInt_t index) const {
1646   // get eq for the noisy pixel at position index in list of noisy
1647   UInt_t gloChip;
1648   UInt_t chipIndex;
1649   GetChipAndIndexNoisy(module,index,gloChip,chipIndex);
1650   return GetNoisyEqIdAtC2(gloChip,chipIndex);
1651 }
1652 //____________________________________________________________________________________________
1653 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAt(UInt_t module, UInt_t index) const {
1654   // get hs for the dead pixel at position index in list of dead
1655   UInt_t gloChip;
1656   UInt_t chipIndex;
1657   GetChipAndIndexDead(module,index,gloChip,chipIndex);
1658   return GetDeadHSAtC2(gloChip,chipIndex);
1659 }
1660 //____________________________________________________________________________________________
1661 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAt(UInt_t module, UInt_t index) const {
1662   // get hs for the noisy pixel at position index in list of noisy
1663   UInt_t gloChip;
1664   UInt_t chipIndex;
1665   GetChipAndIndexNoisy(module,index,gloChip,chipIndex);
1666   return GetNoisyHSAtC2(gloChip,chipIndex);
1667 }
1668 //____________________________________________________________________________________________
1669 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAt(UInt_t module, UInt_t index) const {
1670   // get chip for the dead pixel at position index in list of dead
1671   UInt_t gloChip;
1672   UInt_t chipIndex;
1673   GetChipAndIndexDead(module,index,gloChip,chipIndex);
1674   return GetDeadChipAtC2(gloChip,chipIndex);
1675 }
1676 //____________________________________________________________________________________________
1677 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAt(UInt_t module, UInt_t index) const {
1678   // get chip for the noisy pixel at position index in list of noisy
1679   UInt_t gloChip;
1680   UInt_t chipIndex;
1681   GetChipAndIndexNoisy(module,index,gloChip,chipIndex);
1682   return GetNoisyChipAtC2(gloChip,chipIndex);
1683 }
1684 //____________________________________________________________________________________________
1685 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAt(UInt_t module, UInt_t index) const {
1686   // get hs for the dead pixel at position index in list of dead
1687   UInt_t gloChip;
1688   UInt_t chipIndex;
1689   GetChipAndIndexDead(module,index,gloChip,chipIndex);
1690   return GetDeadColAtC2(gloChip,chipIndex);
1691 }
1692 //____________________________________________________________________________________________
1693 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAt(UInt_t module, UInt_t index) const {
1694   // get hs for the noisy pixel at position index in list of noisy
1695   UInt_t gloChip;
1696   UInt_t chipIndex;
1697   GetChipAndIndexNoisy(module,index,gloChip,chipIndex);
1698   return GetNoisyColAtC2(gloChip,chipIndex);
1699 }
1700 //____________________________________________________________________________________________
1701 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAt(UInt_t module, UInt_t index) const {
1702   // get hs for the dead pixel at position index in list of dead
1703   UInt_t gloChip;
1704   UInt_t chipIndex;
1705   GetChipAndIndexDead(module,index,gloChip,chipIndex);
1706   return GetDeadRowAtC2(gloChip,chipIndex);
1707 }
1708 //____________________________________________________________________________________________
1709 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAt(UInt_t module, UInt_t index) const {
1710   // get hs for the noisy pixel at position index in list of noisy
1711   UInt_t gloChip;
1712   UInt_t chipIndex;
1713   GetChipAndIndexNoisy(module,index,gloChip,chipIndex);
1714   return GetNoisyRowAtC2(gloChip,chipIndex);
1715 }
1716 //____________________________________________________________________________________________
1717 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrBadEq(UInt_t eq) const {
1718   // returns nr of bad for eq (silent or noisy)
1719   UInt_t nrBad = 0;
1720   nrBad+=GetNrSilentEq(eq);
1721   UInt_t nrNoisy = GetNrNoisy(eq);
1722   for (UInt_t i=0; i<nrNoisy; i++) {
1723     UInt_t hs   = GetNoisyHSAtEq(eq,i);
1724     UInt_t chip = GetNoisyChipAtEq(eq,i);
1725     UInt_t col  = GetNoisyColAtEq(eq,i);
1726     UInt_t row  = GetNoisyRowAtEq(eq,i);
1727     if (!IsPixelSilent(eq,hs,chip,col,row)) nrBad++;
1728   }
1729   return nrBad;
1730 }
1731 //____________________________________________________________________________________________
1732 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrSilentEq(UInt_t eq) const {
1733   // returns nr of silent for eq (dead or inactive)
1734   UInt_t returnval=0;
1735   if (IsSilentEq(eq)) return 81920*6;
1736   for (UInt_t hs=0; hs<6; hs++) {
1737     if (IsSilentHS(eq,hs)) {
1738       returnval+=81920;
1739       continue;
1740     }
1741     for (UInt_t chip=0; chip<10; chip++) {
1742       if (IsSilentChip(eq,hs,chip)) {
1743         returnval+=8192;
1744         continue;
1745       }
1746       else { 
1747         returnval+=GetNrDeadC(eq,hs,chip);
1748       }
1749     }
1750   }
1751   return returnval;
1752 }
1753 //____________________________________________________________________________________________
1754 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadEq(UInt_t eq) const {
1755   // returns nr of dead for eq
1756   UInt_t returnval=0;
1757   for (UInt_t hs=0; hs<6; hs++) {
1758     for (UInt_t chip=0; chip<10; chip++) {
1759       returnval+=GetNrDeadC(eq,hs,chip);
1760     }
1761   }
1762   return returnval;
1763 }
1764 //____________________________________________________________________________________________
1765 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisyEq(UInt_t eq) const {
1766   // returns nr of noisy for eq
1767   UInt_t returnval=0;
1768   for (UInt_t hs=0; hs<6; hs++) {
1769     for (UInt_t chip=0; chip<10; chip++) {
1770       returnval+=GetNrNoisyC(eq,hs,chip);
1771     }
1772   }
1773   return returnval;
1774 }
1775 //____________________________________________________________________________________________
1776 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAtEq(UInt_t eq, UInt_t index) const {
1777   // get eq for the dead pixel at position index in list of dead
1778   if (eq<20 && index<GetNrDeadEq(eq)) {
1779     return eq;
1780   }
1781   else {
1782     return 20;
1783   }
1784 }
1785 //____________________________________________________________________________________________
1786 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAtEq(UInt_t eq, UInt_t index) const {
1787   // get eq for the noisy pixel at position index in list of noisy
1788   if (eq<20 && index<GetNrNoisyEq(eq)) {
1789     return eq;
1790   }
1791   else {
1792     return 20;
1793   }
1794 }
1795 //____________________________________________________________________________________________
1796 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAtEq(UInt_t eq, UInt_t index) const {
1797   // get hs for the dead pixel at position index in list of dead
1798   UInt_t gloChip;
1799   UInt_t chipIndex;
1800   GetChipAndIndexEqDead(eq,index,gloChip,chipIndex);
1801   return GetDeadHSAtC2(gloChip,chipIndex);
1802 }
1803 //____________________________________________________________________________________________
1804 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAtEq(UInt_t eq, UInt_t index) const {
1805   // get hs for the noisy pixel at position index in list of noisy
1806   UInt_t gloChip;
1807   UInt_t chipIndex;
1808   GetChipAndIndexEqNoisy(eq,index,gloChip,chipIndex);
1809   return GetNoisyHSAtC2(gloChip,chipIndex);
1810 }
1811 //____________________________________________________________________________________________
1812 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAtEq(UInt_t eq, UInt_t index) const {
1813   // get chip for the dead pixel at position index in list of dead
1814   UInt_t gloChip;
1815   UInt_t chipIndex;
1816   GetChipAndIndexEqDead(eq,index,gloChip,chipIndex);
1817   return GetDeadChipAtC2(gloChip,chipIndex);
1818 }
1819 //____________________________________________________________________________________________
1820 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAtEq(UInt_t eq, UInt_t index) const {
1821   // get chip for the noisy pixel at position index in list of noisy
1822   UInt_t gloChip;
1823   UInt_t chipIndex;
1824   GetChipAndIndexEqNoisy(eq,index,gloChip,chipIndex);
1825   return GetNoisyChipAtC2(gloChip,chipIndex);
1826 }
1827 //____________________________________________________________________________________________
1828 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAtEq(UInt_t eq, UInt_t index) const {
1829   // get hs for the dead pixel at position index in list of dead
1830   UInt_t gloChip;
1831   UInt_t chipIndex;
1832   GetChipAndIndexEqDead(eq,index,gloChip,chipIndex);
1833   return GetDeadColAtC2(gloChip,chipIndex);
1834 }
1835 //____________________________________________________________________________________________
1836 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAtEq(UInt_t eq, UInt_t index) const {
1837   // get hs for the noisy pixel at position index in list of noisy
1838   UInt_t gloChip;
1839   UInt_t chipIndex;
1840   GetChipAndIndexEqNoisy(eq,index,gloChip,chipIndex);
1841   return GetNoisyColAtC2(gloChip,chipIndex);
1842 }
1843 //____________________________________________________________________________________________
1844 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAtEq(UInt_t eq, UInt_t index) const {
1845   // get hs for the dead pixel at position index in list of dead
1846   UInt_t gloChip;
1847   UInt_t chipIndex;
1848   GetChipAndIndexEqDead(eq,index,gloChip,chipIndex);
1849   return GetDeadRowAtC2(gloChip,chipIndex);
1850 }
1851 //____________________________________________________________________________________________
1852 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAtEq(UInt_t eq, UInt_t index) const {
1853   // get hs for the noisy pixel at position index in list of noisy
1854   UInt_t gloChip;
1855   UInt_t chipIndex;
1856   GetChipAndIndexEqNoisy(eq,index,gloChip,chipIndex);
1857   return GetNoisyRowAtC2(gloChip,chipIndex);
1858 }
1859 //____________________________________________________________________________________________
1860 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrBadC(UInt_t eq, UInt_t hs, UInt_t chip) const {
1861   // returns nr of bad for chip (silent or noisy)
1862   UInt_t nrBad = 0;
1863   nrBad+=GetNrSilentC(eq,hs,chip);
1864   UInt_t nrNoisy = GetNrNoisyC(eq,hs,chip);
1865   for (UInt_t i=0; i<nrNoisy; i++) {
1866     UInt_t col  = GetNoisyColAtC(eq,hs,chip,i);
1867     UInt_t row  = GetNoisyRowAtC(eq,hs,chip,i);
1868     if (!IsPixelSilent(eq,hs,chip,col,row)) nrBad++;
1869   }
1870   return nrBad;
1871 }
1872 //____________________________________________________________________________________________
1873 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrSilentC(UInt_t eq, UInt_t hs, UInt_t chip) const {
1874   // returns nr of silent for chip (dead or inactive)
1875   if (IsSilentChip(eq,hs,chip)) return 8192;
1876   else return GetNrDeadC(eq,hs,chip);
1877 }
1878 //____________________________________________________________________________________________
1879 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadC(UInt_t eq, UInt_t hs, UInt_t chip) const {
1880   // returns nr of dead for chip
1881   UInt_t gloChip = GetGloChip(eq,hs,chip);
1882   return GetNrDeadC2(gloChip);
1883 }
1884 //____________________________________________________________________________________________
1885 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisyC(UInt_t eq, UInt_t hs, UInt_t chip) const {
1886   // returns nr of noisy for chip
1887   UInt_t gloChip = GetGloChip(eq,hs,chip);
1888   return GetNrNoisyC2(gloChip);
1889 }
1890 //____________________________________________________________________________________________
1891 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
1892   UInt_t gloChip = GetGloChip(eq,hs,chip);
1893   return GetDeadEqIdAtC2(gloChip,index);
1894 }
1895 //____________________________________________________________________________________________
1896 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
1897   UInt_t gloChip = GetGloChip(eq,hs,chip);
1898   return GetNoisyEqIdAtC2(gloChip,index);
1899 }
1900 //____________________________________________________________________________________________
1901 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
1902   UInt_t gloChip = GetGloChip(eq,hs,chip);
1903   return GetDeadHSAtC2(gloChip,index);
1904 }
1905 //____________________________________________________________________________________________
1906 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
1907   UInt_t gloChip = GetGloChip(eq,hs,chip);
1908   return GetNoisyHSAtC2(gloChip,index);
1909 }
1910 //____________________________________________________________________________________________
1911 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
1912   UInt_t gloChip = GetGloChip(eq,hs,chip);
1913   return GetDeadChipAtC2(gloChip,index);
1914 }
1915 //____________________________________________________________________________________________
1916 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
1917   UInt_t gloChip = GetGloChip(eq,hs,chip);
1918   return GetNoisyChipAtC2(gloChip,index);
1919 }
1920 //____________________________________________________________________________________________
1921 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
1922   UInt_t gloChip = GetGloChip(eq,hs,chip);
1923   return GetDeadColAtC2(gloChip,index);
1924 }
1925 //____________________________________________________________________________________________
1926 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
1927   UInt_t gloChip = GetGloChip(eq,hs,chip);
1928   return GetNoisyColAtC2(gloChip,index);
1929 }
1930 //____________________________________________________________________________________________
1931 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
1932   UInt_t gloChip = GetGloChip(eq,hs,chip);
1933   return GetDeadRowAtC2(gloChip,index);
1934 }
1935 //____________________________________________________________________________________________
1936 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
1937   UInt_t gloChip = GetGloChip(eq,hs,chip);
1938   return GetNoisyRowAtC2(gloChip,index);
1939 }
1940 //____________________________________________________________________________________________
1941 const Char_t* AliITSOnlineCalibrationSPDhandler::GetDeadPixelAsTextC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
1942   // get a string of dead pixel info
1943   TString returnMess = "";
1944   UInt_t gloChip = GetGloChip(eq,hs,chip);
1945   if (gloChip>=1200) {
1946     Error("AliITSOnlineCalibrationSPDhandler::GetDeadPixelAsTextC", "global chip nr (%d) out of bounds.",gloChip);
1947     return returnMess.Data();
1948   }
1949   if (index<fNrDead[gloChip]) {
1950     Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
1951     UInt_t col = GetColFromKey(key);
1952     UInt_t row = GetRowFromKey(key);
1953     UInt_t module = AliITSRawStreamSPD::GetOfflineModuleFromOnline(eq,hs,chip);
1954     UInt_t colM = AliITSRawStreamSPD::GetOfflineColFromOnline(eq,hs,chip,col);
1955     UInt_t rowM = AliITSRawStreamSPD::GetOfflineRowFromOnline(eq,hs,chip,row);
1956     returnMess = Form("%*d,%*d,%*d,%*d,%*d  |  %*d,%*d,%*d",2,eq,1,hs,1,chip,2,col,3,row,3,module,3,colM,3,rowM);
1957     return returnMess.Data();
1958   }
1959   else {
1960     Error("AliITSOnlineCalibrationSPDhandler::GetDeadPixelAsTextC", "Index %d out of bounds.", index);
1961     return returnMess.Data();
1962   }
1963 }
1964 //____________________________________________________________________________________________
1965 const Char_t* AliITSOnlineCalibrationSPDhandler::GetNoisyPixelAsTextC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
1966   // get a string of noisy pixel info
1967   TString returnMess = "";
1968   UInt_t gloChip = GetGloChip(eq,hs,chip);
1969   if (gloChip>=1200) {
1970     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyPixelAsTextC", "global chip nr (%d) out of bounds.",gloChip);
1971     return returnMess.Data();
1972   }
1973   if (index<fNrNoisy[gloChip]) {
1974     Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(index);
1975     UInt_t col = GetColFromKey(key);
1976     UInt_t row = GetRowFromKey(key);    
1977     UInt_t module = AliITSRawStreamSPD::GetOfflineModuleFromOnline(eq,hs,chip);
1978     UInt_t colM = AliITSRawStreamSPD::GetOfflineColFromOnline(eq,hs,chip,col);
1979     UInt_t rowM = AliITSRawStreamSPD::GetOfflineRowFromOnline(eq,hs,chip,row);
1980     returnMess = Form("%*d,%*d,%*d,%*d,%*d  |  %*d,%*d,%*d",2,eq,1,hs,1,chip,2,col,3,row,3,module,3,colM,3,rowM);
1981     return returnMess.Data();
1982   }
1983   else {
1984     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyPixelAsTextC", "Index %d out of bounds.", index);
1985     return returnMess.Data();
1986   }
1987 }
1988 //____________________________________________________________________________________________
1989 UInt_t AliITSOnlineCalibrationSPDhandler::AddSilentFrom(AliITSOnlineCalibrationSPDhandler* other) {
1990   // returns number of new silent pixels in this' list (dead or inactive)
1991   UInt_t tmpdead = GetNrSilent();
1992
1993   for (UInt_t eq=0; eq<20; eq++) {
1994     if (!(other->IsActiveEq(eq))) ActivateEq(eq,kFALSE);
1995     if (other->IsDeadEq(eq))      SetDeadEq(eq,kTRUE);
1996     for (UInt_t hs=0; hs<6; hs++) {
1997       if (!(other->IsActiveHS(eq,hs))) ActivateHS(eq,hs,kFALSE);
1998       if (other->IsDeadHS(eq,hs))      SetDeadHS(eq,hs,kTRUE);
1999       for (UInt_t chip=0; chip<10; chip++) {
2000         if (!(other->IsActiveChip(eq,hs,chip))) ActivateChip(eq,hs,chip,kFALSE);
2001         if (other->IsDeadChip(eq,hs,chip))      SetDeadChip(eq,hs,chip,kTRUE);
2002       }
2003     }
2004   }
2005
2006   AddDeadFrom(other);
2007
2008   return GetNrSilent() - tmpdead;
2009 }
2010 //____________________________________________________________________________________________
2011 UInt_t AliITSOnlineCalibrationSPDhandler::AddDeadFrom(AliITSOnlineCalibrationSPDhandler* other) {
2012   // returns number of new dead pixels in this' list
2013   UInt_t returnval=0;
2014   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
2015     for (UInt_t ind1=0; ind1<other->fNrDead[gloChip]; ind1++) {
2016       UInt_t eq = other->GetDeadEqIdAtC2(gloChip,ind1);
2017       UInt_t hs   = other->GetDeadHSAtC2(gloChip,ind1);
2018       UInt_t chip = other->GetDeadChipAtC2(gloChip,ind1);
2019       UInt_t col  = other->GetDeadColAtC2(gloChip,ind1);
2020       UInt_t row  = other->GetDeadRowAtC2(gloChip,ind1);
2021       if (SetDeadPixel(eq,hs,chip,col,row)) {
2022         returnval++;
2023       }
2024     }
2025   }
2026   return returnval;
2027 }
2028 //____________________________________________________________________________________________
2029 UInt_t AliITSOnlineCalibrationSPDhandler::AddNoisyFrom(AliITSOnlineCalibrationSPDhandler* other) {
2030   // returns number of new noisy pixels in this' list
2031   UInt_t returnval=0;
2032   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
2033     for (UInt_t ind1=0; ind1<other->fNrNoisy[gloChip]; ind1++) {
2034       UInt_t eq = other->GetNoisyEqIdAtC2(gloChip,ind1);
2035       UInt_t hs   = other->GetNoisyHSAtC2(gloChip,ind1);
2036       UInt_t chip = other->GetNoisyChipAtC2(gloChip,ind1);
2037       UInt_t col  = other->GetNoisyColAtC2(gloChip,ind1);
2038       UInt_t row  = other->GetNoisyRowAtC2(gloChip,ind1);
2039       if (SetNoisyPixel(eq,hs,chip,col,row)) {
2040         returnval++;
2041       }
2042     }
2043   }
2044   return returnval;
2045 }
2046 //____________________________________________________________________________________________
2047 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDiff(AliITSOnlineCalibrationSPDhandler* other) const {
2048   // returns nr of dead/noisy in this' lists and not in other's lists (including inactive)
2049   return GetNrSilentDiff(other) + GetNrNoisyDiff(other);
2050 }
2051 //____________________________________________________________________________________________
2052 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrSilentDiff(AliITSOnlineCalibrationSPDhandler* other) const {
2053   // returns nr of single silent pixels in this' lists and not in other's lists (dead or inactive)
2054   UInt_t returnval=0;
2055   for (UInt_t eq=0; eq<20; eq++) {
2056     for (UInt_t hs=0; hs<6; hs++) {
2057       for (UInt_t chip=0; chip<10; chip++) {
2058         if (!IsActiveEq(eq) || IsDeadEq(eq) || !IsActiveHS(eq,hs) || IsDeadHS(eq,hs) || !IsActiveChip(eq,hs,chip) || IsDeadChip(eq,hs,chip)) {
2059           if (other->IsActiveEq(eq) && !other->IsDeadEq(eq) && other->IsActiveHS(eq,hs) && !other->IsDeadHS(eq,hs) && other->IsActiveChip(eq,hs,chip) && !other->IsDeadChip(eq,hs,chip)) {
2060             // if this is inactive and the other is active...
2061             returnval+= 8192 - other->GetNrDeadC(eq,hs,chip);
2062           }
2063         }
2064         else {
2065           UInt_t gloChip = GetGloChip(eq,hs,chip);
2066           for (UInt_t ind1=0; ind1<fNrDead[gloChip]; ind1++) {
2067             Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(ind1);
2068             UInt_t col = GetColFromKey(key);
2069             UInt_t row = GetRowFromKey(key);
2070             if (!(other->IsPixelSilent(eq,hs,chip,col,row))) {
2071               returnval++;
2072             }
2073           }
2074         }
2075       }
2076     }
2077   }
2078   return returnval;
2079 }
2080 //____________________________________________________________________________________________
2081 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadDiff(AliITSOnlineCalibrationSPDhandler* other) const {
2082   // returns nr of dead in this' lists and not in other's lists
2083   UInt_t returnval=0;
2084   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
2085     for (UInt_t ind1=0; ind1<fNrDead[gloChip]; ind1++) {
2086       Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(ind1);
2087       UInt_t eq = GetEqIdFromKey(key);
2088       UInt_t hs = GetHSFromKey(key);
2089       UInt_t chip = GetChipFromKey(key);
2090       UInt_t col = GetColFromKey(key);
2091       UInt_t row = GetRowFromKey(key);
2092       if (!(other->IsPixelDead(eq,hs,chip,col,row))) {
2093         returnval++;
2094       }
2095     }
2096   }
2097   return returnval;
2098 }
2099 //____________________________________________________________________________________________
2100 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisyDiff(AliITSOnlineCalibrationSPDhandler* other) const {
2101   // returns nr of noisy in this' lists and not in other's lists
2102   UInt_t returnval=0;
2103   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
2104     for (UInt_t ind1=0; ind1<fNrNoisy[gloChip]; ind1++) {
2105       Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(ind1);
2106       UInt_t eq = GetEqIdFromKey(key);
2107       UInt_t hs = GetHSFromKey(key);
2108       UInt_t chip = GetChipFromKey(key);
2109       UInt_t col = GetColFromKey(key);
2110       UInt_t row = GetRowFromKey(key);
2111       if (!(other->IsPixelNoisy(eq,hs,chip,col,row))) {
2112         returnval++;
2113       }
2114     }
2115   }
2116   return returnval;
2117 }
2118 //____________________________________________________________________________________________
2119 AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetDiff(AliITSOnlineCalibrationSPDhandler* other) const {
2120   // returns handler with active/dead/noisy in this' lists, removing those that are in other's lists
2121   AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler();
2122
2123   for (UInt_t eq=0; eq<20; eq++) {
2124     if (!(IsActiveEq(eq))) {
2125       newHandler->ActivateEq(eq,kFALSE);
2126       if (!other->IsActiveEq(eq)) newHandler->ActivateEq(eq);
2127     }
2128     if (IsDeadEq(eq)) {
2129       newHandler->SetDeadEq(eq);
2130       if (other->IsDeadEq(eq)) newHandler->SetDeadEq(eq,kFALSE);
2131     }
2132     for (UInt_t hs=0; hs<6; hs++) {
2133       if (!(IsActiveHS(eq,hs))) {
2134         newHandler->ActivateHS(eq,hs,kFALSE);
2135         if (!other->IsActiveHS(eq,hs)) newHandler->ActivateHS(eq,hs);
2136       }
2137       if (IsDeadHS(eq,hs)) {
2138         newHandler->SetDeadHS(eq,hs);
2139         if (other->IsDeadHS(eq,hs)) newHandler->SetDeadHS(eq,hs,kFALSE);
2140       }
2141       for (UInt_t chip=0; chip<10; chip++) {
2142         if (!(IsActiveChip(eq,hs,chip))) {
2143           newHandler->ActivateChip(eq,hs,chip,kFALSE);
2144           if (!other->IsActiveChip(eq,hs,chip)) newHandler->ActivateHS(eq,hs,chip);
2145         }
2146         if (IsDeadChip(eq,hs,chip)) {
2147           newHandler->SetDeadChip(eq,hs,chip);
2148           if (other->IsDeadChip(eq,hs,chip)) newHandler->SetDeadChip(eq,hs,chip,kFALSE);
2149         }
2150       }
2151     }
2152   }
2153
2154   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
2155     for (UInt_t ind1=0; ind1<fNrDead[gloChip]; ind1++) {
2156       Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(ind1);
2157       UInt_t eq = GetEqIdFromKey(key);
2158       UInt_t hs = GetHSFromKey(key);
2159       UInt_t chip = GetChipFromKey(key);
2160       UInt_t col = GetColFromKey(key);
2161       UInt_t row = GetRowFromKey(key);
2162       if (!(other->IsPixelDead(eq,hs,chip,col,row))) {
2163         newHandler->SetDeadPixel(eq,hs,chip,col,row);
2164       }
2165     }
2166   }
2167
2168   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
2169     for (UInt_t ind2=0; ind2<fNrNoisy[gloChip]; ind2++) {
2170       Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(ind2);
2171       UInt_t eq = GetEqIdFromKey(key);
2172       UInt_t hs = GetHSFromKey(key);
2173       UInt_t chip = GetChipFromKey(key);
2174       UInt_t col = GetColFromKey(key);
2175       UInt_t row = GetRowFromKey(key);
2176       if (!(other->IsPixelNoisy(eq,hs,chip,col,row))) {
2177         newHandler->SetNoisyPixel(eq,hs,chip,col,row);
2178       }
2179     }
2180   }
2181
2182   return newHandler;
2183 }
2184 //____________________________________________________________________________________________
2185 AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetSilentDiff(AliITSOnlineCalibrationSPDhandler* other) const {
2186   // returns handler with active/dead in this' lists, removing those that are in other's lists
2187   AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler();
2188
2189   for (UInt_t eq=0; eq<20; eq++) {
2190     if (!(IsActiveEq(eq))) {
2191       newHandler->ActivateEq(eq,kFALSE);
2192       if (!other->IsActiveEq(eq)) newHandler->ActivateEq(eq);
2193     }
2194     if (IsDeadEq(eq)) {
2195       newHandler->SetDeadEq(eq);
2196       if (other->IsDeadEq(eq)) newHandler->SetDeadEq(eq,kFALSE);
2197     }
2198     for (UInt_t hs=0; hs<6; hs++) {
2199       if (!(IsActiveHS(eq,hs))) {
2200         newHandler->ActivateHS(eq,hs,kFALSE);
2201         if (!other->IsActiveHS(eq,hs)) newHandler->ActivateHS(eq,hs);
2202       }
2203       if (IsDeadHS(eq,hs)) {
2204         newHandler->SetDeadHS(eq,hs);
2205         if (other->IsDeadHS(eq,hs)) newHandler->SetDeadHS(eq,hs,kFALSE);
2206       }
2207       for (UInt_t chip=0; chip<10; chip++) {
2208         if (!(IsActiveChip(eq,hs,chip))) {
2209           newHandler->ActivateChip(eq,hs,chip,kFALSE);
2210           if (!other->IsActiveChip(eq,hs,chip)) newHandler->ActivateHS(eq,hs,chip);
2211         }
2212         if (IsDeadChip(eq,hs,chip)) {
2213           newHandler->SetDeadChip(eq,hs,chip);
2214           if (other->IsDeadChip(eq,hs,chip)) newHandler->SetDeadChip(eq,hs,chip,kFALSE);
2215         }
2216       }
2217     }
2218   }
2219
2220   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
2221     for (UInt_t ind1=0; ind1<fNrDead[gloChip]; ind1++) {
2222       Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(ind1);
2223       UInt_t eq = GetEqIdFromKey(key);
2224       UInt_t hs = GetHSFromKey(key);
2225       UInt_t chip = GetChipFromKey(key);
2226       UInt_t col = GetColFromKey(key);
2227       UInt_t row = GetRowFromKey(key);
2228       if (!(other->IsPixelDead(eq,hs,chip,col,row))) {
2229         newHandler->SetDeadPixel(eq,hs,chip,col,row);
2230       }
2231     }
2232   }
2233
2234   return newHandler;
2235 }
2236 //____________________________________________________________________________________________
2237 AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetDeadDiff(AliITSOnlineCalibrationSPDhandler* other) const {
2238   // returns handler with dead in this' lists, except for those in other's lists
2239   AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler();
2240   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
2241     for (UInt_t ind1=0; ind1<fNrDead[gloChip]; ind1++) {
2242       Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(ind1);
2243       UInt_t eq = GetEqIdFromKey(key);
2244       UInt_t hs = GetHSFromKey(key);
2245       UInt_t chip = GetChipFromKey(key);
2246       UInt_t col = GetColFromKey(key);
2247       UInt_t row = GetRowFromKey(key);
2248       if (!(other->IsPixelDead(eq,hs,chip,col,row))) {
2249         newHandler->SetDeadPixel(eq,hs,chip,col,row);
2250       }
2251     }
2252   }
2253   return newHandler;
2254 }
2255 //____________________________________________________________________________________________
2256 AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetNoisyDiff(AliITSOnlineCalibrationSPDhandler* other) const {
2257   // returns handler with noisy in this' lists, except for those in other's lists
2258   AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler();
2259   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
2260     for (UInt_t ind2=0; ind2<fNrNoisy[gloChip]; ind2++) {
2261       Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(ind2);
2262       UInt_t eq = GetEqIdFromKey(key);
2263       UInt_t hs = GetHSFromKey(key);
2264       UInt_t chip = GetChipFromKey(key);
2265       UInt_t col = GetColFromKey(key);
2266       UInt_t row = GetRowFromKey(key);
2267       if (!(other->IsPixelNoisy(eq,hs,chip,col,row))) {
2268         newHandler->SetNoisyPixel(eq,hs,chip,col,row);
2269       }
2270     }
2271   }
2272   return newHandler;
2273 }
2274 //____________________________________________________________________________________________
2275 void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexDead(UInt_t module, UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) const {
2276   // find gloChip and chipIndex from module and index
2277   if (index<GetNrDead(module)) {
2278     UInt_t eq = GetEqIdFromOffline(module);
2279     UInt_t hs = GetHSFromOffline(module);
2280     
2281     UInt_t glVal=0;
2282     for (UInt_t ch=0; ch<5; ch++) {
2283       gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,ch*32));
2284       if (glVal+fNrDead[gloChip]>index) {
2285         chipIndex = index-glVal;
2286         break;
2287       }
2288       else {
2289         glVal+=fNrDead[gloChip];
2290       }
2291     }
2292
2293   }
2294   else {
2295     Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexDead", "Index %d out of bounds.", index);
2296   }
2297 }
2298 //____________________________________________________________________________________________
2299 void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexNoisy(UInt_t module, UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) const {
2300   // find gloChip and chipIndex from module and index
2301   if (index<GetNrNoisy(module)) {
2302     UInt_t eq = GetEqIdFromOffline(module);
2303     UInt_t hs = GetHSFromOffline(module);
2304     
2305     UInt_t glVal=0;
2306     for (UInt_t ch=0; ch<5; ch++) {
2307       gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,ch*32));
2308       if (glVal+fNrNoisy[gloChip]>index) {
2309         chipIndex = index-glVal;
2310         break;
2311       }
2312       else {
2313         glVal+=fNrNoisy[gloChip];
2314       }
2315     }
2316
2317   }
2318   else {
2319     Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexNoisy", "Index %d out of bounds.", index);
2320   }
2321 }
2322 //____________________________________________________________________________________________
2323 void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexEqDead(UInt_t eq, UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) const {
2324   // find gloChip and chipIndex from module and index
2325   if (index<GetNrDeadEq(eq)) {
2326
2327     UInt_t glVal=0;
2328     for (UInt_t hs=0; hs<6; hs++) {
2329       for (UInt_t chip=0; chip<10; chip++) {
2330         gloChip = GetGloChip(eq,hs,chip);
2331         if (glVal+fNrDead[gloChip]>index) {
2332           chipIndex = index-glVal;
2333           break;
2334         }
2335         else {
2336           glVal+=fNrDead[gloChip];
2337         }
2338       }
2339     }
2340
2341   }
2342   else {
2343     Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexEqDead", "Index %d out of bounds.", index);
2344   }
2345 }
2346 //____________________________________________________________________________________________
2347 void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexEqNoisy(UInt_t eq, UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) const {
2348   // find gloChip and chipIndex from module and index
2349   if (index<GetNrNoisyEq(eq)) {
2350
2351     UInt_t glVal=0;
2352     for (UInt_t hs=0; hs<6; hs++) {
2353       for (UInt_t chip=0; chip<10; chip++) {
2354         gloChip = GetGloChip(eq,hs,chip);
2355         if (glVal+fNrNoisy[gloChip]>index) {
2356           chipIndex = index-glVal;
2357           break;
2358         }
2359         else {
2360           glVal+=fNrNoisy[gloChip];
2361         }
2362       }
2363     }
2364
2365   }
2366   else {
2367     Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexEqNoisy", "Index %d out of bounds.", index);
2368   }
2369 }
2370 //____________________________________________________________________________________________
2371 void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexTotDead(UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) const {
2372   // find gloChip and chipIndex from global index
2373   if (index<GetNrDead()) {
2374     
2375     UInt_t glVal=0;
2376     for (gloChip=0; gloChip<1200; gloChip++) {
2377       if (glVal+fNrDead[gloChip]>index) {
2378         chipIndex = index-glVal;
2379         break;
2380       }
2381       else {
2382         glVal+=fNrDead[gloChip];
2383       }
2384     }
2385
2386   }
2387   else {
2388     Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexTotDead", "Index %d out of bounds.", index);
2389   }
2390 }
2391 //____________________________________________________________________________________________
2392 void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexTotNoisy(UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) const {
2393   // find gloChip and chipIndex from global index
2394   if (index<GetNrNoisy()) {
2395     
2396     UInt_t glVal=0;
2397     for (gloChip=0; gloChip<1200; gloChip++) {
2398       if (glVal+fNrNoisy[gloChip]>index) {
2399         chipIndex = index-glVal;
2400         break;
2401       }
2402       else {
2403         glVal+=fNrNoisy[gloChip];
2404       }
2405     }
2406
2407   }
2408   else {
2409     Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexTotNoisy", "Index %d out of bounds.", index);
2410   }
2411 }
2412 //____________________________________________________________________________________________
2413 UInt_t AliITSOnlineCalibrationSPDhandler::GetEqIdFromOffline(UInt_t module) const {
2414   // module to eq mapping
2415   if (module>=240) {
2416     Error("AliITSOnlineCalibrationSPDhandler::GetEqIdFromOffline", "module nr (%d) out of bounds.",module);
2417     return 20;
2418   }
2419   return AliITSRawStreamSPD::GetOnlineEqIdFromOffline(module);
2420 }
2421 //____________________________________________________________________________________________
2422 UInt_t AliITSOnlineCalibrationSPDhandler::GetHSFromOffline(UInt_t module) const {
2423   // module to hs mapping
2424   if (module>=240) {
2425     Error("AliITSOnlineCalibrationSPDhandler::GetHSFromOffline", "module nr (%d) out of bounds.",module);
2426     return 6;
2427   }
2428   return AliITSRawStreamSPD::GetOnlineHSFromOffline(module);
2429 }
2430 //____________________________________________________________________________________________
2431 UInt_t AliITSOnlineCalibrationSPDhandler::GetChipFromOffline(UInt_t module, UInt_t colM) const {
2432   // module,colM to chip mapping
2433   if (module>=240 || colM>=160) {
2434     Error("AliITSOnlineCalibrationSPDhandler::GetChipFromOffline", "module,colM nrs (%d,%d) out of bounds.",module,colM);
2435     return 10;
2436   }
2437   return AliITSRawStreamSPD::GetOnlineChipFromOffline(module,colM);
2438 }
2439 //____________________________________________________________________________________________
2440 UInt_t AliITSOnlineCalibrationSPDhandler::GetColFromOffline(UInt_t module, UInt_t colM) const {
2441   // colM to col mapping
2442   if (colM>=160) {
2443     Error("AliITSOnlineCalibrationSPDhandler::GetColFromOffline", "colM nr (%d) out of bounds.",colM);
2444     return 160;
2445   }
2446   return AliITSRawStreamSPD::GetOnlineColFromOffline(module,colM);
2447 }
2448 //____________________________________________________________________________________________
2449 UInt_t AliITSOnlineCalibrationSPDhandler::GetRowFromOffline(UInt_t module, UInt_t rowM) const {
2450   // rowM to row mapping
2451   if (rowM>=256) {
2452     Error("AliITSOnlineCalibrationSPDhandler::GetRowFromOffline", "rowM nr (%d) out of bounds.",rowM);
2453     return 256;
2454   }
2455   return AliITSRawStreamSPD::GetOnlineRowFromOffline(module,rowM);
2456 }
2457 //____________________________________________________________________________________________
2458 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadC2(UInt_t gloChip) const {
2459   // returns nr of dead pixels on this chip
2460   if (gloChip>=1200) {
2461     Error("AliITSOnlineCalibrationSPDhandler::GetNrDeadC2", "global chip nr (%d) out of bounds.",gloChip);
2462     return 0;
2463   }
2464   return fNrDead[gloChip];
2465 }
2466 //____________________________________________________________________________________________
2467 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisyC2(UInt_t gloChip) const {
2468   // returns nr of noisy pixels on this chip
2469   if (gloChip>=1200) {
2470     Error("AliITSOnlineCalibrationSPDhandler::GetNrNoisyC2", "global chip nr (%d) out of bounds.",gloChip);
2471     return 0;
2472   }
2473   return fNrNoisy[gloChip];
2474 }
2475 //____________________________________________________________________________________________
2476 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAtC2(UInt_t gloChip, UInt_t index) const {
2477   // get eq for the dead pixel at position index in list of dead
2478   if (gloChip>=1200) {
2479     Error("AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAtC", "global chip nr (%d) out of bounds.",gloChip);
2480     return 20;
2481   }
2482   if (index<fNrDead[gloChip]) {
2483     Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
2484     return GetEqIdFromKey(key);
2485   }
2486   else {
2487     Error("AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAtC", "Index %d out of bounds.", index);
2488     return 0;
2489   }
2490 }
2491 //____________________________________________________________________________________________
2492 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAtC2(UInt_t gloChip, UInt_t index) const {
2493   // get eq for the noisy pixel at position index in list of noisy
2494   if (gloChip>=1200) {
2495     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAtC", "global chip nr (%d) out of bounds.",gloChip);
2496     return 20;
2497   }
2498   if (index<fNrNoisy[gloChip]) {
2499     Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(index);
2500     return GetEqIdFromKey(key);
2501   }
2502   else {
2503     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAtC", "Index %d out of bounds.", index);
2504     return 0;
2505   }
2506 }
2507 //____________________________________________________________________________________________
2508 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAtC2(UInt_t gloChip, UInt_t index) const {
2509   // get hs for the dead pixel at position index in list of dead
2510   if (gloChip>=1200) {
2511     Error("AliITSOnlineCalibrationSPDhandler::GetDeadHSAtC", "global chip nr (%d) out of bounds.",gloChip);
2512     return 20;
2513   }
2514   if (index<fNrDead[gloChip]) {
2515     Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
2516     return GetHSFromKey(key);
2517   }
2518   else {
2519     Error("AliITSOnlineCalibrationSPDhandler::GetDeadHSAtC", "Index %d out of bounds.", index);
2520     return 0;
2521   }
2522 }
2523 //____________________________________________________________________________________________
2524 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAtC2(UInt_t gloChip, UInt_t index) const {
2525   // get hs for the noisy pixel at position index in list of noisy
2526   if (gloChip>=1200) {
2527     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyHSAtC", "global chip nr (%d) out of bounds.",gloChip);
2528     return 20;
2529   }
2530   if (index<fNrNoisy[gloChip]) {
2531     Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(index);
2532     return GetHSFromKey(key);
2533   }
2534   else {
2535     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyHSAtC", "Index %d out of bounds.", index);
2536     return 0;
2537   }
2538 }
2539 //____________________________________________________________________________________________
2540 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAtC2(UInt_t gloChip, UInt_t index) const {
2541   // get chip for the dead pixel at position index in list of dead
2542   if (gloChip>=1200) {
2543     Error("AliITSOnlineCalibrationSPDhandler::GetDeadChipAtC", "global chip nr (%d) out of bounds.",gloChip);
2544     return 20;
2545   }
2546   if (index<fNrDead[gloChip]) {
2547     Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
2548     return GetChipFromKey(key);
2549   }
2550   else {
2551     Error("AliITSOnlineCalibrationSPDhandler::GetDeadChipAtC", "Index %d out of bounds.", index);
2552     return 0;
2553   }
2554 }
2555 //____________________________________________________________________________________________
2556 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAtC2(UInt_t gloChip, UInt_t index) const {
2557   // get chip for the noisy pixel at position index in list of noisy
2558   if (gloChip>=1200) {
2559     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyChipAtC", "global chip nr (%d) out of bounds.",gloChip);
2560     return 20;
2561   }
2562   if (index<fNrNoisy[gloChip]) {
2563     Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(index);
2564     return GetChipFromKey(key);
2565   }
2566   else {
2567     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyChipAtC", "Index %d out of bounds.", index);
2568     return 0;
2569   }
2570 }
2571 //____________________________________________________________________________________________
2572 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAtC2(UInt_t gloChip, UInt_t index) const {
2573   // get col for the dead pixel at position index in list of dead
2574   if (gloChip>=1200) {
2575     Error("AliITSOnlineCalibrationSPDhandler::GetDeadColAtC2", "global chip nr (%d) out of bounds.",gloChip);
2576     return 20;
2577   }
2578   if (index<fNrDead[gloChip]) {
2579     Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
2580     return GetColFromKey(key);
2581   }
2582   else {
2583     Error("AliITSOnlineCalibrationSPDhandler::GetDeadColAtC2", "Index %d out of bounds.", index);
2584     return 0;
2585   }
2586 }
2587 //____________________________________________________________________________________________
2588 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAtC2(UInt_t gloChip, UInt_t index) const {
2589   // get col for the noisy pixel at position index in list of noisy
2590   if (gloChip>=1200) {
2591     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyColAtC", "global chip nr (%d) out of bounds.",gloChip);
2592     return 20;
2593   }
2594   if (index<fNrNoisy[gloChip]) {
2595     Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(index);
2596     return GetColFromKey(key);
2597   }
2598   else {
2599     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyColAtC", "Index %d out of bounds.", index);
2600     return 0;
2601   }
2602 }
2603 //____________________________________________________________________________________________
2604 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAtC2(UInt_t gloChip, UInt_t index) const {
2605   // get row for the dead pixel at position index in list of dead
2606   if (gloChip>=1200) {
2607     Error("AliITSOnlineCalibrationSPDhandler::GetDeadRowAtC", "global chip nr (%d) out of bounds.",gloChip);
2608     return 20;
2609   }
2610   if (index<fNrDead[gloChip]) {
2611     Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
2612     return GetRowFromKey(key);
2613   }
2614   else {
2615     Error("AliITSOnlineCalibrationSPDhandler::GetDeadRowAtC", "Index %d out of bounds.", index);
2616     return 0;
2617   }
2618 }
2619 //____________________________________________________________________________________________
2620 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAtC2(UInt_t gloChip, UInt_t index) const {
2621   // get row for the noisy pixel at position index in list of noisy
2622   if (gloChip>=1200) {
2623     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyRowAtC", "global chip nr (%d) out of bounds.",gloChip);
2624     return 20;
2625   }
2626   if (index<fNrNoisy[gloChip]) {
2627     Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(index);
2628     return GetRowFromKey(key);
2629   }
2630   else {
2631     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyRowAtC", "Index %d out of bounds.", index);
2632     return 0;
2633   }
2634 }
2635 //____________________________________________________________________________________________
2636 void AliITSOnlineCalibrationSPDhandler::ActivateALL() {
2637   // activate all eq,hs,chips
2638   for (UInt_t eq=0; eq<20; eq++) {
2639     ActivateEq(eq);
2640     for (UInt_t hs=0; hs<6; hs++) {
2641       ActivateHS(eq,hs);
2642       for (UInt_t chip=0; chip<10; chip++) {
2643         ActivateChip(eq,hs,chip);
2644       }
2645     }
2646   }
2647 }
2648 //____________________________________________________________________________________________
2649 void AliITSOnlineCalibrationSPDhandler::ActivateEq(UInt_t eq, Bool_t setval) {
2650   // activate eq
2651   if (eq>=20) {
2652     Error("AliITSOnlineCalibrationSPDhandler::ActivateEq", "eq (%d) out of bounds.",eq);
2653     return;
2654   }
2655   fActiveEq[eq] = setval;
2656 }
2657 //____________________________________________________________________________________________
2658 void AliITSOnlineCalibrationSPDhandler::ActivateHS(UInt_t eq, UInt_t hs, Bool_t setval) {
2659   // activate hs
2660   if (eq>=20 || hs>=6) {
2661     Error("AliITSOnlineCalibrationSPDhandler::ActivateHS", "eq,hs (%d,%d) out of bounds.",eq,hs);
2662     return;
2663   }
2664   fActiveHS[eq][hs] = setval;
2665 }
2666 //____________________________________________________________________________________________
2667 void AliITSOnlineCalibrationSPDhandler::ActivateChip(UInt_t eq, UInt_t hs, UInt_t chip, Bool_t setval) {
2668   // activate chip
2669   if (eq>=20 || hs>=6 || chip>=10) {
2670     Error("AliITSOnlineCalibrationSPDhandler::ActivateChip", "eq,hs,chip (%d,%d,%d) out of bounds.",eq,hs,chip);
2671     return;
2672   }
2673   fActiveChip[eq][hs][chip] = setval;
2674 }
2675 //____________________________________________________________________________________________
2676 Bool_t AliITSOnlineCalibrationSPDhandler::IsActiveEq(UInt_t eq) const {
2677   // Is eq active?
2678   if (eq>=20) {
2679     Error("AliITSOnlineCalibrationSPDhandler::IsActiveEq", "eq (%d) out of bounds.",eq);
2680     return kFALSE;
2681   }
2682   return fActiveEq[eq];
2683 }
2684 //____________________________________________________________________________________________
2685 Bool_t AliITSOnlineCalibrationSPDhandler::IsActiveHS(UInt_t eq, UInt_t hs) const {
2686   // Is hs active?
2687   if (eq>=20 || hs>=6) {
2688     Error("AliITSOnlineCalibrationSPDhandler::IsActiveHS", "eq,hs (%d,%d) out of bounds.",eq,hs);
2689     return kFALSE;
2690   }
2691   return fActiveHS[eq][hs];
2692 }
2693 //____________________________________________________________________________________________
2694 Bool_t AliITSOnlineCalibrationSPDhandler::IsActiveChip(UInt_t eq, UInt_t hs, UInt_t chip) const {
2695   // Is chip active?
2696   if (eq>=20 || hs>=6 || chip>=10) {
2697     Error("AliITSOnlineCalibrationSPDhandler::IsActiveChip", "eq,hs,chip (%d,%d,%d) out of bounds.",eq,hs,chip);
2698     return kFALSE;
2699   }
2700   return fActiveChip[eq][hs][chip];
2701 }
2702 //____________________________________________________________________________________________
2703 void AliITSOnlineCalibrationSPDhandler::UnSetDeadALL() {
2704   // Clear all dead eq,hs,chips
2705   for (UInt_t eq=0; eq<20; eq++) {
2706     SetDeadEq(eq,kFALSE);
2707     for (UInt_t hs=0; hs<6; hs++) {
2708       SetDeadHS(eq,hs,kFALSE);
2709       for (UInt_t chip=0; chip<10; chip++) {
2710         SetDeadChip(eq,hs,chip,kFALSE);
2711       }
2712     }
2713   }
2714 }
2715 //____________________________________________________________________________________________
2716 void AliITSOnlineCalibrationSPDhandler::SetDeadEq(UInt_t eq, Bool_t setval) {
2717   // set eq dead
2718   if (eq>=20) {
2719     Error("AliITSOnlineCalibrationSPDhandler::SetDeadEq", "eq (%d) out of bounds.",eq);
2720     return;
2721   }
2722   fDeadEq[eq] = setval;
2723 }
2724 //____________________________________________________________________________________________
2725 void AliITSOnlineCalibrationSPDhandler::SetDeadHS(UInt_t eq, UInt_t hs, Bool_t setval) {
2726   // set hs dead
2727   if (eq>=20 || hs>=6) {
2728     Error("AliITSOnlineCalibrationSPDhandler::SetDeadHS", "eq,hs (%d,%d) out of bounds.",eq,hs);
2729     return;
2730   }
2731   fDeadHS[eq][hs] = setval;
2732 }
2733 //____________________________________________________________________________________________
2734 void AliITSOnlineCalibrationSPDhandler::SetDeadChip(UInt_t eq, UInt_t hs, UInt_t chip, Bool_t setval) {
2735   // set chip dead
2736   if (eq>=20 || hs>=6 || chip>=10) {
2737     Error("AliITSOnlineCalibrationSPDhandler::SetDeadChip", "eq,hs,chip (%d,%d,%d) out of bounds.",eq,hs,chip);
2738     return;
2739   }
2740   fDeadChip[eq][hs][chip] = setval;
2741 }
2742 //____________________________________________________________________________________________
2743 Bool_t AliITSOnlineCalibrationSPDhandler::IsDeadEq(UInt_t eq) const {
2744   // is eq dead?
2745   if (eq>=20) {
2746     Error("AliITSOnlineCalibrationSPDhandler::IsDeadEq", "eq (%d) out of bounds.",eq);
2747     return kFALSE;
2748   }
2749   return fDeadEq[eq];
2750 }
2751 //____________________________________________________________________________________________
2752 Bool_t AliITSOnlineCalibrationSPDhandler::IsDeadHS(UInt_t eq, UInt_t hs) const {
2753   // is hs dead?
2754   if (eq>=20 || hs>=6) {
2755     Error("AliITSOnlineCalibrationSPDhandler::IsDeadHS", "eq,hs (%d,%d) out of bounds.",eq,hs);
2756     return kFALSE;
2757   }
2758   return fDeadHS[eq][hs];
2759 }
2760 //____________________________________________________________________________________________
2761 Bool_t AliITSOnlineCalibrationSPDhandler::IsDeadChip(UInt_t eq, UInt_t hs, UInt_t chip) const {
2762   // is chip dead?
2763   if (eq>=20 || hs>=6 || chip>=10) {
2764     Error("AliITSOnlineCalibrationSPDhandler::IsDeadChip", "eq,hs,chip (%d,%d,%d) out of bounds.",eq,hs,chip);
2765     return kFALSE;
2766   }
2767   return fDeadChip[eq][hs][chip];
2768 }
2769 //____________________________________________________________________________________________
2770 Bool_t AliITSOnlineCalibrationSPDhandler::IsSilentEq(UInt_t eq) const {
2771   // is eq silent?
2772   if (eq>=20) {
2773     Error("AliITSOnlineCalibrationSPDhandler::IsSilentEq", "eq (%d) out of bounds.",eq);
2774     return kFALSE;
2775   }
2776   return (!IsActiveEq(eq) || IsDeadEq(eq));
2777 }
2778 //____________________________________________________________________________________________
2779 Bool_t AliITSOnlineCalibrationSPDhandler::IsSilentHS(UInt_t eq, UInt_t hs) const {
2780   // is hs silent?
2781   if (eq>=20 || hs>=6) {
2782     Error("AliITSOnlineCalibrationSPDhandler::IsSilentHS", "eq,hs (%d,%d) out of bounds.",eq,hs);
2783     return kFALSE;
2784   }
2785   return (!IsActiveEq(eq) || IsDeadEq(eq) || !IsActiveHS(eq,hs) || IsDeadHS(eq,hs));
2786 }
2787 //____________________________________________________________________________________________
2788 Bool_t AliITSOnlineCalibrationSPDhandler::IsSilentChip(UInt_t eq, UInt_t hs, UInt_t chip) const {
2789   // is chip silent?
2790   if (eq>=20 || hs>=6 || chip>=10) {
2791     Error("AliITSOnlineCalibrationSPDhandler::IsSilentChip", "eq,hs,chip (%d,%d,%d) out of bounds.",eq,hs,chip);
2792     return kFALSE;
2793   }
2794   return (!IsActiveEq(eq) || IsDeadEq(eq) || !IsActiveHS(eq,hs) || IsDeadHS(eq,hs) || !IsActiveChip(eq,hs,chip) || IsDeadChip(eq,hs,chip));
2795 }