Changes to improve the code quality (H. Tydesjo)
[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 // The TArrayI objects that are put in the AliITSCalibrationSPD     //
6 // objects can be obtained from the methods GetDeadArray and        //
7 // GetNoisyArray.                                                   //
8 //////////////////////////////////////////////////////////////////////   
9
10 #include "AliITSOnlineCalibrationSPDhandler.h"
11 #include "AliITSOnlineCalibrationSPD.h"
12 #include "AliITSIntMap.h"
13 #include <TObjArray.h>
14 #include <TArrayI.h>
15 #include <TFile.h>
16 #include <TError.h>
17 #include <fstream>
18
19 #ifndef SPD_DA_OFF // you may want to exclude cdb classes, if using this class outside aliroot
20 #include "AliITSCalibrationSPD.h"
21 #include "AliCDBManager.h"
22 #include "AliCDBEntry.h"
23 #endif
24
25 /* $Id$ */
26 //____________________________________________________________________________________________
27 AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler():
28   fFileLocation(".")
29 {
30   // constructor
31   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
32     fNrDead[gloChip]=0;
33     fNrNoisy[gloChip]=0;
34     fDeadPixelMap[gloChip] = new AliITSIntMap();
35     fNoisyPixelMap[gloChip] = new AliITSIntMap();
36   }
37 }
38 AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler(const AliITSOnlineCalibrationSPDhandler& handle): 
39   fFileLocation(".")
40 {
41   // copy constructor
42   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
43     fNrDead[gloChip] = handle.fNrDead[gloChip];
44     fNrNoisy[gloChip] = handle.fNrNoisy[gloChip];
45     fDeadPixelMap[gloChip] = handle.fDeadPixelMap[gloChip]->Clone();
46     fNoisyPixelMap[gloChip] = handle.fNoisyPixelMap[gloChip]->Clone();
47   }
48   fFileLocation = handle.fFileLocation;
49 }
50 AliITSOnlineCalibrationSPDhandler::~AliITSOnlineCalibrationSPDhandler() {
51   //  ClearMaps();
52   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
53     delete fDeadPixelMap[gloChip];
54     delete fNoisyPixelMap[gloChip];
55   }
56 }
57 AliITSOnlineCalibrationSPDhandler& AliITSOnlineCalibrationSPDhandler::operator=(const AliITSOnlineCalibrationSPDhandler& handle) {
58   // assignment operator
59   if (this!=&handle) {
60     this->ClearMaps();
61     for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
62       fNrDead[gloChip] = handle.fNrDead[gloChip];
63       fNrNoisy[gloChip] = handle.fNrNoisy[gloChip];
64       fDeadPixelMap[gloChip] = handle.fDeadPixelMap[gloChip]->Clone();
65       fNoisyPixelMap[gloChip] = handle.fNoisyPixelMap[gloChip]->Clone();
66     }
67     fFileLocation = handle.fFileLocation;
68   }
69   return *this;
70 }
71 //____________________________________________________________________________________________
72 void AliITSOnlineCalibrationSPDhandler::ClearMaps() {
73   // clear the lists of dead and noisy
74   ResetDead();
75   ResetNoisy();
76 }
77 void AliITSOnlineCalibrationSPDhandler::ResetDead() {
78   // reset the dead pixel map
79   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
80     fNrDead[gloChip]=0;
81     fDeadPixelMap[gloChip]->Clear();
82   }
83 }
84 void AliITSOnlineCalibrationSPDhandler::ResetNoisy() {
85   // clear the list of noisy pixels
86   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
87     fNrNoisy[gloChip]=0;
88     fNoisyPixelMap[gloChip]->Clear();
89   }
90 }
91 void AliITSOnlineCalibrationSPDhandler::ResetDeadForChip(UInt_t eq, UInt_t hs, UInt_t chip) {
92   // clear the dead pixels for this chip
93   UInt_t gloChip = GetGloChip(eq,hs,chip);
94   for (UInt_t col=0; col<32; col++) {
95     for (UInt_t row=0; row<256; row++) {
96       Int_t key = GetKey(eq,hs,chip,col,row);
97       if (fDeadPixelMap[gloChip]->Remove(key)) {
98         fNrDead[gloChip]--;
99       }
100     }
101   }
102 }
103 void AliITSOnlineCalibrationSPDhandler::ResetNoisyForChip(UInt_t eq, UInt_t hs, UInt_t chip) {
104   // clear the noisy pixels for this chip
105   UInt_t gloChip = GetGloChip(eq,hs,chip);
106   if (gloChip>=1200) {
107     Error("AliITSOnlineCalibrationSPDhandler::ResetNoisyForChip","global chip nr (%d) out of bounds\n",gloChip);
108     return;
109   }
110   for (UInt_t col=0; col<32; col++) {
111     for (UInt_t row=0; row<256; row++) {
112       Int_t key = GetKey(eq,hs,chip,col,row);
113       if (fNoisyPixelMap[gloChip]->Remove(key)) {
114         fNrNoisy[gloChip]--;
115       }
116     }
117   }
118 }
119 void AliITSOnlineCalibrationSPDhandler::ResetDeadForEq(UInt_t eq) {
120   // clear the dead pixels for this eq
121   if (eq>=20) {
122     Error("AliITSOnlineCalibrationSPDhandler::ResetDeadForEq", "eq (%d) out of bounds.",eq);
123     return;
124   }
125   for (UInt_t hs=0; hs<6; hs++) {
126     for (UInt_t chip=0; chip<10; chip++) {
127       ResetDeadForChip(eq, hs, chip);
128     }
129   }
130 }
131 void AliITSOnlineCalibrationSPDhandler::ResetNoisyForEq(UInt_t eq) {
132   // clear the noisy pixels for this eq
133   if (eq>=20) {
134     Error("AliITSOnlineCalibrationSPDhandler::ResetNoisyForEq", "eq (%d) out of bounds.",eq);
135     return;
136   }
137   for (UInt_t hs=0; hs<6; hs++) {
138     for (UInt_t chip=0; chip<10; chip++) {
139       ResetNoisyForChip(eq, hs, chip);
140     }
141   }
142 }
143 //____________________________________________________________________________________________
144 Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromFiles() {
145   // read dead and noisy files from file location. returns true if at least one file found
146   Bool_t b1 = ReadNoisyFromFiles();
147   Bool_t b2 = ReadDeadFromFiles();
148   return (b1 && b2);
149 }
150
151 Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFiles() {
152   // read dead files from file location. returns true if at least one file found
153   Bool_t returnval=kFALSE;
154   for (UInt_t eq=0; eq<20; eq++) {
155     if (ReadDeadFromFile(eq)) {
156       returnval=kTRUE;
157     }
158   }
159   return returnval;
160 }
161 Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFiles() {
162   // read noisy files from file location. returns true if at least one file found
163   Bool_t returnval=kFALSE;
164   for (UInt_t eq=0; eq<20; eq++) {
165     if (ReadNoisyFromFile(eq)) {
166       returnval=kTRUE;
167     }
168   }
169   return returnval;
170 }
171 Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFile(UInt_t eq) {
172   // read dead file for module from file location. 
173   TString fileName = Form("%s/SPD_Dead_%d.root",fFileLocation.Data(),eq);
174   return ReadDeadFromFileName(fileName.Data());
175 }
176 Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFile(UInt_t eq) {
177   // read noisy file for module from file location. 
178   TString fileName = Form("%s/SPD_Noisy_%d.root",fFileLocation.Data(),eq);
179   return ReadNoisyFromFileName(fileName.Data());
180 }
181 Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFileName(const char *fileName) {
182   // read dead from file fileName
183   AliITSOnlineCalibrationSPD* calib;
184   FILE* fp0 = fopen(fileName, "r");
185   if (fp0 == NULL) {return kFALSE;}
186   else {
187     fclose(fp0);
188     TFile file(fileName, "READ");
189     if (file.IsOpen()) {
190       file.GetObject("AliITSOnlineCalibrationSPD", calib);
191       file.Close();
192       if (calib!=NULL) {
193         UInt_t nrDead=calib->GetNrBad();
194         for (UInt_t index=0; index<nrDead; index++) {
195           UInt_t key = calib->GetKeyAt(index);
196           UInt_t eq = GetEqIdFromKey(key);
197           UInt_t hs = GetHSFromKey(key);
198           UInt_t chip = GetChipFromKey(key);
199           UInt_t col = GetColFromKey(key);
200           UInt_t row = GetRowFromKey(key);
201           SetDeadPixel(eq,hs,chip,col,row);
202         }
203       }
204     }
205   }
206   return kTRUE;
207 }
208 Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFileName(const char *fileName) {
209   // read noisy from file fileName
210   AliITSOnlineCalibrationSPD* calib;
211   FILE* fp0 = fopen(fileName, "r");
212   if (fp0 == NULL) {return kFALSE;}
213   else {
214     fclose(fp0);
215     TFile file(fileName, "READ");
216     if (file.IsOpen()) {
217       file.GetObject("AliITSOnlineCalibrationSPD", calib);
218       file.Close();
219       if (calib!=NULL) {
220         UInt_t nrNoisy=calib->GetNrBad();
221         for (UInt_t index=0; index<nrNoisy; index++) {
222           UInt_t key = calib->GetKeyAt(index);
223           UInt_t eq = GetEqIdFromKey(key);
224           UInt_t hs = GetHSFromKey(key);
225           UInt_t chip = GetChipFromKey(key);
226           UInt_t col = GetColFromKey(key);
227           UInt_t row = GetRowFromKey(key);
228           SetNoisyPixel(eq,hs,chip,col,row);
229         }
230       }
231     }
232   }
233   return kTRUE;
234 }
235 UInt_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromText(const char *fileName, UInt_t module) {
236   // read dead from a text file (lines with eq,hs,chip,col,row). returns nr of pixels added (not already here)
237   // insert only those pixels that belong to module (or all if module=240). 
238   UInt_t newNrDead=0;
239   ifstream textFile;
240   textFile.open(fileName, ifstream::in);
241   if (textFile.fail()) {
242     Warning("AliITSOnlineCalibrationSPDhandler::ReadDeadFromText","No dead text file (%s) present.",fileName);
243   }
244   else {
245     while(1) {
246       UInt_t eq,hs,chip,col,row;
247       textFile >> eq; if (textFile.eof()) break;
248       textFile >> hs; if (textFile.eof()) break;
249       textFile >> chip; if (textFile.eof()) break;
250       textFile >> col; if (textFile.eof()) break;
251       textFile >> row; 
252       if (module==240 || (Int_t)module==AliITSRawStreamSPD::GetModuleNumber(eq,hs,chip)){
253         if (SetDeadPixel(eq,hs,chip,col,row)) {
254           newNrDead++;
255         }
256       }
257       if (textFile.eof()) break;
258     }
259     textFile.close();
260   }
261   return newNrDead;
262 }
263 UInt_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromText(const char *fileName, UInt_t module) {
264   // read noisy from a text file (lines with eq,hs,chip,col,row). returns nr of pixels added (not already here)
265   // insert only those pixels that belong to module (or all if module=240). 
266   UInt_t newNrNoisy=0;
267   ifstream textFile;
268   textFile.open(fileName, ifstream::in);
269   if (textFile.fail()) {
270     Warning("AliITSOnlineCalibrationSPDhandler::ReadNoisyFromText","No noisy text file (%s) present.",fileName);
271   }
272   else {
273     while(1) {
274       UInt_t eq,hs,chip,col,row;
275       textFile >> eq; if (textFile.eof()) break;
276       textFile >> hs; if (textFile.eof()) break;
277       textFile >> chip; if (textFile.eof()) break;
278       textFile >> col; if (textFile.eof()) break;
279       textFile >> row; 
280       if (module==240 || (Int_t)module==AliITSRawStreamSPD::GetModuleNumber(eq,hs,chip)){
281         if (SetNoisyPixel(eq,hs,chip,col,row)) {
282           newNrNoisy++;
283         }
284       }
285       if (textFile.eof()) break;
286     }
287     textFile.close();
288   }
289   return newNrNoisy;
290 }
291 //____________________________________________________________________________________________
292 void AliITSOnlineCalibrationSPDhandler::WriteToFilesAlways() {
293   // write the lists of dead and noisy to files
294   for (UInt_t eq=0; eq<20; eq++) {
295     WriteDeadToFile(eq);
296     WriteNoisyToFile(eq);
297   }
298 }
299 UInt_t AliITSOnlineCalibrationSPDhandler::WriteToFiles() {
300   // write the lists of dead and noisy to files (only if there are >0 dead or noisy pixels) , returns nr of files produced
301   return (WriteNoisyToFiles() + WriteDeadToFiles());
302 }
303 void AliITSOnlineCalibrationSPDhandler::WriteDeadToFilesAlways() {
304   // write the lists of dead to files
305   for (UInt_t eq=0; eq<20; eq++) {
306       WriteDeadToFile(eq);
307   }
308 }
309 void AliITSOnlineCalibrationSPDhandler::WriteNoisyToFilesAlways() {
310   // write the lists of noisy to files
311   for (UInt_t eq=0; eq<20; eq++) {
312     WriteNoisyToFile(eq);
313   }
314 }
315 UInt_t AliITSOnlineCalibrationSPDhandler::WriteDeadToFiles() {
316   // write the list of dead to file (only if there are >0 dead pixels) , returns nr of files produced
317   UInt_t nrFiles=0;
318   for (UInt_t eq=0; eq<20; eq++) {
319     if (GetNrDeadEq(eq) > 0) {
320       WriteDeadToFile(eq);
321       nrFiles++;
322     }
323   }
324   return nrFiles;
325 }
326 UInt_t AliITSOnlineCalibrationSPDhandler::WriteNoisyToFiles() {
327   // write the list of noisy to file (only if there are >0 noisy pixels) , returns nr of files produced
328   UInt_t nrFiles=0;
329   for (UInt_t eq=0; eq<20; eq++) {
330     if (GetNrNoisyEq(eq) > 0) {
331       WriteNoisyToFile(eq);
332       nrFiles++;
333     }
334   }
335   return nrFiles;
336 }
337 void AliITSOnlineCalibrationSPDhandler::WriteDeadToFile(UInt_t eq) {
338   // write the lists of dead and noisy for module to file
339   AliITSOnlineCalibrationSPD* calib = new AliITSOnlineCalibrationSPD();
340   calib->SetEqNr(eq);
341   calib->SetBadList(GetDeadArrayOnline(eq));
342   calib->SetNrBad(GetNrDeadEq(eq));
343   TString fileName = Form("%s/SPD_Dead_%d.root",fFileLocation.Data(),eq);
344   TFile file(fileName.Data(), "RECREATE");
345   file.WriteTObject(calib, "AliITSOnlineCalibrationSPD");
346   file.Close();
347   delete calib;
348 }
349 void AliITSOnlineCalibrationSPDhandler::WriteNoisyToFile(UInt_t eq) {
350   // write the lists of noisy and noisy for module to file
351   AliITSOnlineCalibrationSPD* calib = new AliITSOnlineCalibrationSPD();
352   calib->SetEqNr(eq);
353   calib->SetBadList(GetNoisyArrayOnline(eq));
354   calib->SetNrBad(GetNrNoisyEq(eq));
355   TString fileName = Form("%s/SPD_Noisy_%d.root",fFileLocation.Data(),eq);
356   TFile file(fileName.Data(), "RECREATE");
357   file.WriteTObject(calib, "AliITSOnlineCalibrationSPD");
358   file.Close();
359   delete calib;
360 }
361 //____________________________________________________________________________________________
362 #ifndef SPD_DA_OFF
363 Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadModuleFromDB(UInt_t module, Int_t runNr, Bool_t treeSerial) {
364   // reads dead pixels from DB for given module and runNr
365   AliCDBManager* man = AliCDBManager::Instance();
366   if(!man->IsDefaultStorageSet()) {
367     man->SetDefaultStorage("local://$ALICE_ROOT");
368   }
369   AliCDBEntry *cdbEntry = man->Get("ITS/Calib/SPDDead", runNr);
370   TObjArray* spdEntry;
371   if(cdbEntry) {
372     spdEntry = (TObjArray*)cdbEntry->GetObject();
373     if(!spdEntry) return kFALSE;
374   }
375   else {
376     Warning("AliITSOnlineCalibrationSPDhandler::ReadDeadModuleFromDB","Calibration for run %d not found in database.",runNr);
377     return kFALSE;
378   }
379   AliITSCalibrationSPD* calibSPD;
380   calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module);
381   UInt_t nrDead = calibSPD->GetNrBad();
382   if (nrDead>0) {
383     if (!treeSerial) RecursiveInsertDead(calibSPD,module,0,nrDead-1);
384     else {
385       for (UInt_t index=0; index<nrDead; index++) {
386         UInt_t colM = calibSPD->GetBadColAt(index);
387         UInt_t rowM = calibSPD->GetBadRowAt(index);
388         SetDeadPixelM(module,colM,rowM);
389       }
390     }
391   }
392   spdEntry->SetOwner(kTRUE);
393   spdEntry->Clear();
394   return kTRUE;
395 }
396 Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyModuleFromDB(UInt_t module, Int_t runNr, Bool_t treeSerial) {
397   // reads noisy pixels from DB for given module and runNr
398   AliCDBManager* man = AliCDBManager::Instance();
399   if(!man->IsDefaultStorageSet()) {
400     man->SetDefaultStorage("local://$ALICE_ROOT");
401   }
402   AliCDBEntry *cdbEntry = man->Get("ITS/Calib/SPDNoisy", runNr);
403   TObjArray* spdEntry;
404   if(cdbEntry) {
405     spdEntry = (TObjArray*)cdbEntry->GetObject();
406     if(!spdEntry) return kFALSE;
407   }
408   else {
409     Warning("AliITSOnlineCalibrationSPDhandler::ReadNoisyModuleFromDB","Calibration for run %d not found in database.",runNr);
410     return kFALSE;
411   }
412   AliITSCalibrationSPD* calibSPD;
413   calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module);
414   UInt_t nrNoisy = calibSPD->GetNrBad();
415   if (nrNoisy>0) {
416     if (!treeSerial) RecursiveInsertNoisy(calibSPD,module,0,nrNoisy-1);
417     else {
418       for (UInt_t index=0; index<nrNoisy; index++) {
419         UInt_t colM = calibSPD->GetBadColAt(index);
420         UInt_t rowM = calibSPD->GetBadRowAt(index);
421         SetNoisyPixelM(module,colM,rowM);
422       }
423     }
424   }
425   spdEntry->SetOwner(kTRUE);
426   spdEntry->Clear();
427   return kTRUE;
428 }
429 Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromDB(Int_t runNr, Bool_t treeSerial) {
430   // reads dead and noisy pixels from DB for given runNr
431   // note that you may want to clear the lists (if they are not empty) before reading
432   return (ReadNoisyFromDB(runNr,treeSerial) && ReadDeadFromDB(runNr,treeSerial));
433 }
434 Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromDB(Int_t runNr, Bool_t treeSerial) {
435   // reads dead pixels from DB for given runNr
436   // note that you may want to clear the list (if it is not empty) before reading
437   AliCDBManager* man = AliCDBManager::Instance();
438   if(!man->IsDefaultStorageSet()) {
439     man->SetDefaultStorage("local://$ALICE_ROOT");
440   }
441   AliCDBEntry *cdbEntry = man->Get("ITS/Calib/SPDDead", runNr);
442   TObjArray* spdEntry;
443   if(cdbEntry) {
444     spdEntry = (TObjArray*)cdbEntry->GetObject();
445     if(!spdEntry) return kFALSE;
446   }
447   else {
448     Warning("AliITSOnlineCalibrationSPDhandler::ReadDeadFromDB","Calibration for run %d not found in database.",runNr);
449     return kFALSE;
450   }
451   AliITSCalibrationSPD* calibSPD;
452   for (UInt_t module=0; module<240; module++) {
453     //    printf("Reading module %d\n",module);
454     calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module);
455     UInt_t nrDead = calibSPD->GetNrBad();
456     if (nrDead>0) {    
457       if (!treeSerial) RecursiveInsertDead(calibSPD,module,0,nrDead-1);
458       else {
459         for (UInt_t index=0; index<nrDead; index++) {
460           UInt_t colM = calibSPD->GetBadColAt(index);
461           UInt_t rowM = calibSPD->GetBadRowAt(index);
462           SetDeadPixelM(module,colM,rowM);
463         }
464       }
465     }
466   }
467   spdEntry->SetOwner(kTRUE);
468   spdEntry->Clear();
469   return kTRUE;
470 }
471 Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromDB(Int_t runNr, Bool_t treeSerial) {
472   // reads noisy pixels from DB for given runNr
473   // note that you may want to clear the list (if it is not empty) before reading
474   AliCDBManager* man = AliCDBManager::Instance();
475   if(!man->IsDefaultStorageSet()) {
476     man->SetDefaultStorage("local://$ALICE_ROOT");
477   }
478   AliCDBEntry *cdbEntry = man->Get("ITS/Calib/SPDNoisy", runNr);
479   TObjArray* spdEntry;
480   if(cdbEntry) {
481     spdEntry = (TObjArray*)cdbEntry->GetObject();
482     if(!spdEntry) return kFALSE;
483   }
484   else {
485     Warning("AliITSOnlineCalibrationSPDhandler::ReadNoisyFromDB","Calibration for run %d not found in database.",runNr);
486     return kFALSE;
487   }
488   AliITSCalibrationSPD* calibSPD;
489   for (UInt_t module=0; module<240; module++) {
490     //    printf("Reading module %d\n",module);
491     calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module);
492     UInt_t nrNoisy = calibSPD->GetNrBad();
493     if (nrNoisy>0) {    
494       if (!treeSerial) {
495         printf("*** mod %d nrnoisy=%d\n",module,nrNoisy);
496         RecursiveInsertNoisy(calibSPD,module,0,nrNoisy-1);
497       }
498       else {
499         for (UInt_t index=0; index<nrNoisy; index++) {
500           UInt_t colM = calibSPD->GetBadColAt(index);
501           UInt_t rowM = calibSPD->GetBadRowAt(index);
502           SetNoisyPixelM(module,colM,rowM);
503         }
504       }
505     }
506   }
507   spdEntry->SetOwner(kTRUE);
508   spdEntry->Clear();
509   return kTRUE;
510 }
511 Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromCalibObj(TObjArray* calObj) {
512   // reads dead pixels from calib object
513   for (UInt_t module=0; module<240; module++) {
514     for (Int_t i=0; i<((AliITSCalibrationSPD*)calObj->At(module))->GetNrBad(); i++) {
515       SetDeadPixelM(module,
516                     ((AliITSCalibrationSPD*)calObj->At(module))->GetBadColAt(i),
517                     ((AliITSCalibrationSPD*)calObj->At(module))->GetBadRowAt(i));
518     }
519   }
520   return kTRUE;
521 }
522 Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromCalibObj(TObjArray* calObj) {
523   // reads noisy pixels from calib object
524   for (UInt_t module=0; module<240; module++) {
525     for (Int_t i=0; i<((AliITSCalibrationSPD*)calObj->At(module))->GetNrBad(); i++) {
526       SetNoisyPixelM(module,
527                      ((AliITSCalibrationSPD*)calObj->At(module))->GetBadColAt(i),
528                      ((AliITSCalibrationSPD*)calObj->At(module))->GetBadRowAt(i));
529     }
530   }
531   return kTRUE;
532 }
533 Bool_t AliITSOnlineCalibrationSPDhandler::WriteToDB(Int_t runNrStart, Int_t runNrEnd) {
534   // writes dead and noisy pixels to DB for given runNrs
535   // overwrites any previous entries
536   return (WriteNoisyToDB(runNrStart,runNrEnd) && WriteDeadToDB(runNrStart,runNrEnd));
537 }
538 Bool_t AliITSOnlineCalibrationSPDhandler::WriteDeadToDB(Int_t runNrStart, Int_t runNrEnd) {
539   // writes dead pixels to DB for given runNrs
540   // overwrites any previous entries
541   AliCDBManager* man = AliCDBManager::Instance();
542   if(!man->IsDefaultStorageSet()) {
543     man->SetDefaultStorage("local://$ALICE_ROOT");
544   }
545   AliCDBMetaData* metaData = new AliCDBMetaData();
546   metaData->SetResponsible("Henrik Tydesjo");
547   metaData->SetComment("Created by AliITSOnlineCalibrationSPDhandler.");
548   AliCDBId idCalSPD("ITS/Calib/SPDDead",runNrStart,runNrEnd);
549   TObjArray* spdEntry = new TObjArray(240);
550   spdEntry->SetOwner(kTRUE);
551   for(UInt_t module=0; module<240; module++){
552     AliITSCalibrationSPD* calObj = new AliITSCalibrationSPD();
553
554     // *** this is temporarily hard coded here ********************
555     // (later these parameters will be separated from the cal.obj.)
556     calObj->SetThresholds(3000, 250);
557     calObj->SetBiasVoltage(18.182);
558     calObj->SetNoiseParam(0,0);
559     calObj->SetCouplingParam(0.,0.055);
560     // *** remove later...
561     // ************************************************************
562
563     spdEntry->Add(calObj);
564   }
565   for(UInt_t module=0; module<240; module++){
566     ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetNrBad( GetNrDead(module) );
567     ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetBadList( GetDeadArray(module) );
568   }
569   AliCDBEntry* cdbEntry = new AliCDBEntry((TObject*)spdEntry,idCalSPD,metaData);
570   man->Put(cdbEntry);
571   delete spdEntry;
572   delete cdbEntry;
573   delete metaData;
574   return kTRUE;
575 }
576 Bool_t AliITSOnlineCalibrationSPDhandler::WriteNoisyToDB(Int_t runNrStart, Int_t runNrEnd) {
577   // writes noisy pixels to DB for given runNrs
578   // overwrites any previous entries
579   AliCDBManager* man = AliCDBManager::Instance();
580   if(!man->IsDefaultStorageSet()) {
581     man->SetDefaultStorage("local://$ALICE_ROOT");
582   }
583   AliCDBMetaData* metaData = new AliCDBMetaData();
584   metaData->SetResponsible("Henrik Tydesjo");
585   metaData->SetComment("Created by AliITSOnlineCalibrationSPDhandler.");
586   AliCDBId idCalSPD("ITS/Calib/SPDNoisy",runNrStart,runNrEnd);
587   TObjArray* spdEntry = new TObjArray(240);
588   spdEntry->SetOwner(kTRUE);
589   for(UInt_t module=0; module<240; module++){
590     AliITSCalibrationSPD* calObj = new AliITSCalibrationSPD();
591
592     // *** this is temporarily hard coded here ********************
593     // (later these parameters will be separated from the cal.obj.)
594     calObj->SetThresholds(3000, 250);
595     calObj->SetBiasVoltage(18.182);
596     calObj->SetNoiseParam(0,0);
597     calObj->SetCouplingParam(0.,0.055);
598     // *** remove later...
599     // ************************************************************
600
601     spdEntry->Add(calObj);
602   }
603   for(UInt_t module=0; module<240; module++){
604     ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetNrBad( GetNrNoisy(module) );
605     ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetBadList( GetNoisyArray(module) );
606   }
607   AliCDBEntry* cdbEntry = new AliCDBEntry((TObject*)spdEntry,idCalSPD,metaData);
608   man->Put(cdbEntry);
609   delete spdEntry;
610   delete cdbEntry;
611   delete metaData;
612   return kTRUE;
613 }
614 //____________________________________________________________________________________________
615 void AliITSOnlineCalibrationSPDhandler::RecursiveInsertDead(AliITSCalibrationSPD* calibSPD, UInt_t module, Int_t lowInd, Int_t highInd) {
616   // inserts dead pixels recursively, used when reading from db
617   if (lowInd>highInd) return;
618   Int_t thisInd = lowInd+(highInd-lowInd)/2;
619   SetDeadPixelM(module,calibSPD->GetBadColAt(thisInd),calibSPD->GetBadRowAt(thisInd));
620   RecursiveInsertDead(calibSPD,module,lowInd,thisInd-1);
621   RecursiveInsertDead(calibSPD,module,thisInd+1,highInd);
622 }
623 void AliITSOnlineCalibrationSPDhandler::RecursiveInsertNoisy(AliITSCalibrationSPD* calibSPD, UInt_t module, Int_t lowInd, Int_t highInd) {
624   // inserts noisy pixels recursively, used when reading from db
625   printf("Rec mod %d : %d,%d\n",module,lowInd,highInd);
626   if (lowInd>highInd) return;
627   Int_t thisInd = lowInd+(highInd-lowInd)/2;
628   SetNoisyPixelM(module,calibSPD->GetBadColAt(thisInd),calibSPD->GetBadRowAt(thisInd));
629   RecursiveInsertNoisy(calibSPD,module,lowInd,thisInd-1);
630   RecursiveInsertNoisy(calibSPD,module,thisInd+1,highInd);
631 }
632
633 #endif
634 //____________________________________________________________________________________________
635 void AliITSOnlineCalibrationSPDhandler::GenerateDCSConfigFile(const Char_t* fileName) {
636   // generates an ascii file in the format as the one produced by online da (but with dummy runNr=0)
637   ofstream dcsfile;
638   dcsfile.open(fileName);
639   dcsfile << "[SPD SCAN]\n";
640   dcsfile << "RunNumber=" << "0" << "\n"; // dummy value
641   dcsfile << "Type=" << "4" << "\n";
642   dcsfile << "Router=" << "0" << "\n"; // dummy value
643   dcsfile << "ActualDetConfiguration=" << "0,-1,-1\n"; // dummy values
644   dcsfile << "[NOISY]\n";
645   for (UInt_t module=0; module<240; module++) {
646     UInt_t headkey=20*10*6;
647     for (UInt_t ind=0; ind<GetNrNoisy(module); ind++) {
648       UInt_t newkey = GetNoisyEqIdAt(module,ind)*10*6 +
649         GetNoisyHSAt(module,ind)*10 +
650         GetNoisyChipAt(module,ind);
651       if (newkey!=headkey) { // print eq,hs,chip header
652         headkey = newkey;
653         dcsfile << "-" << newkey/(6*10) << "," << (newkey%(6*10))/10 << "," << (newkey%(6*10))%10 << "\n";
654       }
655       dcsfile << GetNoisyColAt(module,ind) << "," << GetNoisyRowAt(module,ind) << "\n";
656     }
657   }
658   dcsfile.close();
659 }
660 //____________________________________________________________________________________________
661 TArrayI AliITSOnlineCalibrationSPDhandler::GetDeadArray(UInt_t module, Bool_t treeSerial) {
662   // get a TArrayI of the dead pixels (format for the AliITSCalibrationSPD object)
663   TArrayI returnArray;
664
665   UInt_t eq = GetEqIdFromOffline(module);
666   UInt_t hs = GetHSFromOffline(module);
667   UInt_t size=0;
668   for (UInt_t chip=0; chip<5; chip++) {
669     UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,chip*32));
670     size += fNrDead[gloChip];
671   }
672   returnArray.Set(size*2);
673   UInt_t gloIndex=0;
674   for (UInt_t chip=0; chip<5; chip++) {
675     UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,chip*32));
676     if (treeSerial) fDeadPixelMap[gloChip]->PrepareSerialize(); // for tree ordered values
677     else fDeadPixelMap[gloChip]->PrepareSerializeOrdered(); // for key ordered values
678     for (UInt_t index=0; index<fNrDead[gloChip]; index++) {
679       Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
680       Int_t colM = GetColMFromKey(key);
681       Int_t rowM = GetRowMFromKey(key);
682       returnArray.AddAt(colM,gloIndex*2);
683       returnArray.AddAt(rowM,gloIndex*2+1);
684       gloIndex++;
685     }
686   }
687   return returnArray;
688 }
689 TArrayI AliITSOnlineCalibrationSPDhandler::GetNoisyArray(UInt_t module, Bool_t treeSerial) {
690   // get a TArrayI of the noisy pixels (format for the AliITSCalibrationSPD object)
691   TArrayI returnArray;
692
693   UInt_t eq = GetEqIdFromOffline(module);
694   UInt_t hs = GetHSFromOffline(module);
695   UInt_t size=0;
696   for (UInt_t chip=0; chip<5; chip++) {
697     UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,chip*32));
698     size += fNrNoisy[gloChip];
699   }
700   returnArray.Set(size*2);
701   UInt_t gloIndex=0;
702   for (UInt_t chip=0; chip<5; chip++) {
703     UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,chip*32));
704     if (treeSerial) fNoisyPixelMap[gloChip]->PrepareSerialize(); // for tree ordered values
705     else fNoisyPixelMap[gloChip]->PrepareSerializeOrdered(); // for key ordered values
706     for (UInt_t index=0; index<fNrNoisy[gloChip]; index++) {
707       Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(index);
708       Int_t colM = GetColMFromKey(key);
709       Int_t rowM = GetRowMFromKey(key);
710       returnArray.AddAt(colM,gloIndex*2);
711       returnArray.AddAt(rowM,gloIndex*2+1);
712       gloIndex++;
713     }
714   }
715   return returnArray;
716 }
717 TArrayI AliITSOnlineCalibrationSPDhandler::GetDeadArrayOnline(UInt_t eq) {
718   // get a TArrayI of the dead pixels (format for the AliITSOnlineCalibrationSPD object)
719   TArrayI returnArray;
720   // fix size of array
721   UInt_t size=0;
722   for (UInt_t hs=0; hs<6; hs++) {
723     for (UInt_t chip=0; chip<10; chip++) {
724       UInt_t gloChip = GetGloChip(eq,hs,chip);
725       size+=fNrDead[gloChip];
726     }
727   }
728   returnArray.Set(size);
729   // put keys in array
730   UInt_t gloIndex=0;
731   for (UInt_t hs=0; hs<6; hs++) {
732     for (UInt_t chip=0; chip<10; chip++) {
733       UInt_t gloChip = GetGloChip(eq,hs,chip);
734       fDeadPixelMap[gloChip]->PrepareSerialize(); // for tree ordered values
735       for (UInt_t index=0; index<fNrDead[gloChip]; index++) {
736         Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
737         returnArray.AddAt(key,gloIndex);
738         gloIndex++;
739       }
740     }
741   }
742   return returnArray;
743 }
744 TArrayI AliITSOnlineCalibrationSPDhandler::GetNoisyArrayOnline(UInt_t eq) {
745   // get a TArrayI of the noisy pixels (format for the AliITSOnlineCalibrationSPD object)
746   TArrayI returnArray;
747   // fix size of array
748   UInt_t size=0;
749   for (UInt_t hs=0; hs<6; hs++) {
750     for (UInt_t chip=0; chip<10; chip++) {
751       UInt_t gloChip = GetGloChip(eq,hs,chip);
752       size+=fNrNoisy[gloChip];
753     }
754   }
755   returnArray.Set(size);
756   // put keys in array
757   UInt_t gloIndex=0;
758   for (UInt_t hs=0; hs<6; hs++) {
759     for (UInt_t chip=0; chip<10; chip++) {
760       UInt_t gloChip = GetGloChip(eq,hs,chip);
761       fNoisyPixelMap[gloChip]->PrepareSerialize(); // for tree ordered values
762       for (UInt_t index=0; index<fNrNoisy[gloChip]; index++) {
763         Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(index);
764         returnArray.AddAt(key,gloIndex);
765         gloIndex++;
766       }
767     }
768   }
769   return returnArray;
770 }
771 //____________________________________________________________________________________________
772 void AliITSOnlineCalibrationSPDhandler::PrintEqSummary() {
773 // print summary (nr of dead and noisy) for each equipment
774   printf("-----------\n");
775   printf("Eq summary:\n");
776   printf("-----------\n");
777   for (UInt_t eq=0; eq<20; eq++) {
778     printf("Eq %*d: %*d dead , %*d noisy\n",2,eq,5,GetNrDeadEq(eq),5,GetNrNoisyEq(eq));
779   }
780 }
781 void AliITSOnlineCalibrationSPDhandler::PrintDead() const {
782   // print the dead pixels to screen
783   printf("------------------------------------------------------\n");
784   printf("Dead Pixels: (eq,hs,chip,col,row  |  module,colM,rowM)\n");
785   printf("------------------------------------------------------\n");
786   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
787     for (UInt_t index=0; index<fNrDead[gloChip]; index++) {
788       Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
789       UInt_t eq = GetEqIdFromKey(key);
790       UInt_t hs = GetHSFromKey(key);
791       UInt_t chip = GetChipFromKey(key);
792       UInt_t col = GetColFromKey(key);
793       UInt_t row = GetRowFromKey(key);
794
795       UInt_t module = AliITSRawStreamSPD::GetOfflineModuleFromOnline(eq,hs,chip);
796       UInt_t colM = AliITSRawStreamSPD::GetOfflineColFromOnline(eq,hs,chip,col);
797       UInt_t rowM = AliITSRawStreamSPD::GetOfflineRowFromOnline(eq,hs,chip,row);
798
799       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);
800     }
801   }
802 }
803 void AliITSOnlineCalibrationSPDhandler::PrintNoisy() const {
804   // print the dead pixels to screen
805   printf("-------------------------------------------------------\n");
806   printf("Noisy Pixels: (eq,hs,chip,col,row  |  module,colM,rowM)\n");
807   printf("-------------------------------------------------------\n");
808   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
809     for (UInt_t index=0; index<fNrNoisy[gloChip]; index++) {
810       Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(index);
811       UInt_t eq = GetEqIdFromKey(key);
812       UInt_t hs = GetHSFromKey(key);
813       UInt_t chip = GetChipFromKey(key);
814       UInt_t col = GetColFromKey(key);
815       UInt_t row = GetRowFromKey(key);
816
817       UInt_t module = AliITSRawStreamSPD::GetOfflineModuleFromOnline(eq,hs,chip);
818       UInt_t colM = AliITSRawStreamSPD::GetOfflineColFromOnline(eq,hs,chip,col);
819       UInt_t rowM = AliITSRawStreamSPD::GetOfflineRowFromOnline(eq,hs,chip,row);
820
821       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);
822     }
823   }
824 }
825 //____________________________________________________________________________________________
826 Bool_t AliITSOnlineCalibrationSPDhandler::SetDeadPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
827   // set a dead pixel, returns false if pixel is already dead
828   UInt_t gloChip = GetGloChip(eq,hs,chip);
829   if (gloChip>=1200) {
830     Error("AliITSOnlineCalibrationSPDhandler::SetDeadPixel", "eq,hs,chip nrs (%d,%d,%d) out of bounds.",eq,hs,chip);
831     return kFALSE;
832   }
833   if (col>=32 && row>=256) {
834     Error("AliITSOnlineCalibrationSPDhandler::SetDeadPixel", "col,row nrs (%d,%d) out of bounds.",col,row);
835     return kFALSE;
836   }
837   Int_t key = GetKey(eq,hs,chip,col,row);
838   // if noisy we dont want to add it...
839   if (fNoisyPixelMap[gloChip]->Find(key) != NULL) return kFALSE;
840   if (fDeadPixelMap[gloChip]->Insert(key,gloChip)) {
841     fNrDead[gloChip]++;
842     return kTRUE;
843   }
844   return kFALSE;
845 }
846 Bool_t AliITSOnlineCalibrationSPDhandler::SetNoisyPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
847   // set a noisy pixel, returns false if pixel is already noisy
848   UInt_t gloChip = GetGloChip(eq,hs,chip);
849   if (gloChip>=1200) {
850     Error("AliITSOnlineCalibrationSPDhandler::SetNoisyPixel", "eq,hs,chip nrs (%d,%d,%d) out of bounds.",eq,hs,chip);
851     return kFALSE;
852   }
853   if (col>=32 && row>=256) {
854     Error("AliITSOnlineCalibrationSPDhandler::SetNoisyPixel", "col,row nrs (%d,%d) out of bounds.",col,row);
855     return kFALSE;
856   }
857   Int_t key = GetKey(eq,hs,chip,col,row);
858   // if dead before - remove from the dead list 
859   if (fDeadPixelMap[gloChip]->Remove(key)) {
860     fNrDead[gloChip]--;
861   }
862   if (fNoisyPixelMap[gloChip]->Insert(key,gloChip)) {
863     fNrNoisy[gloChip]++;
864     return kTRUE;
865   }
866   return kFALSE;
867 }
868 Bool_t AliITSOnlineCalibrationSPDhandler::SetDeadPixelM(UInt_t module, UInt_t colM, UInt_t rowM) {
869   // set a dead pixel, returns false if pixel is already dead
870   UInt_t eq = GetEqIdFromOffline(module);
871   UInt_t hs = GetHSFromOffline(module);
872   UInt_t chip = GetChipFromOffline(module,colM);
873   UInt_t col = GetColFromOffline(module,colM);
874   UInt_t row = GetRowFromOffline(module,rowM);
875   return SetDeadPixel(eq,hs,chip,col,row);
876 }
877 Bool_t AliITSOnlineCalibrationSPDhandler::SetNoisyPixelM(UInt_t module, UInt_t colM, UInt_t rowM) {
878   // set a noisy pixel, returns false if pixel is already noisy
879   UInt_t eq = GetEqIdFromOffline(module);
880   UInt_t hs = GetHSFromOffline(module);
881   UInt_t chip = GetChipFromOffline(module,colM);
882   UInt_t col = GetColFromOffline(module,colM);
883   UInt_t row = GetRowFromOffline(module,rowM);
884   return SetNoisyPixel(eq,hs,chip,col,row);
885 }
886 Bool_t AliITSOnlineCalibrationSPDhandler::UnSetDeadPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
887   // unset a dead pixel, returns false if pixel is not dead
888   UInt_t gloChip = GetGloChip(eq,hs,chip);
889   if (gloChip>=1200) {
890     Error("AliITSOnlineCalibrationSPDhandler::UnSetDeadPixel", "eq,hs,chip nrs (%d,%d,%d) out of bounds.",eq,hs,chip);
891     return kFALSE;
892   }
893   Int_t key = GetKey(eq,hs,chip,col,row);
894   if (fDeadPixelMap[gloChip]->Remove(key)) {
895     fNrDead[gloChip]--;
896     return kTRUE;
897   }
898   return kFALSE;
899 }
900 Bool_t AliITSOnlineCalibrationSPDhandler::UnSetNoisyPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
901   // unset a noisy pixel, returns false if pixel is not noisy
902   UInt_t gloChip = GetGloChip(eq,hs,chip);
903   if (gloChip>=1200) {
904     Error("AliITSOnlineCalibrationSPDhandler::UnSetNoisyPixel", "eq,hs,chip nrs (%d,%d,%d) out of bounds.",eq,hs,chip);
905     return kFALSE;
906   }
907   Int_t key = GetKey(eq,hs,chip,col,row);
908   if (fNoisyPixelMap[gloChip]->Remove(key)) {
909     fNrNoisy[gloChip]--;
910     return kTRUE;
911   }
912   return kFALSE;
913 }
914 Bool_t AliITSOnlineCalibrationSPDhandler::UnSetDeadPixelM(UInt_t module, UInt_t colM, UInt_t rowM) {
915   // unset a dead pixel, returns false if pixel is not dead
916   UInt_t eq = GetEqIdFromOffline(module);
917   UInt_t hs = GetHSFromOffline(module);
918   UInt_t chip = GetChipFromOffline(module,colM);
919   UInt_t col = GetColFromOffline(module,colM);
920   UInt_t row = GetRowFromOffline(module,rowM);
921   return UnSetDeadPixel(eq,hs,chip,col,row);
922 }
923 Bool_t AliITSOnlineCalibrationSPDhandler::UnSetNoisyPixelM(UInt_t module, UInt_t colM, UInt_t rowM) {
924   // unset a noisy pixel, returns false if pixel is not noisy
925   UInt_t eq = GetEqIdFromOffline(module);
926   UInt_t hs = GetHSFromOffline(module);
927   UInt_t chip = GetChipFromOffline(module,colM);
928   UInt_t col = GetColFromOffline(module,colM);
929   UInt_t row = GetRowFromOffline(module,rowM);
930   return UnSetNoisyPixel(eq,hs,chip,col,row);
931 }
932 UInt_t AliITSOnlineCalibrationSPDhandler::SetDeadChip(UInt_t eq, UInt_t hs, UInt_t chip) {
933   // set a full chip dead, returns nr of new dead pixels
934   UInt_t nrNew = 0;
935   for (UInt_t col=0; col<32; col++) {
936     for (UInt_t row=0; row<256; row++) {
937       if (SetDeadPixel(eq,hs,chip,col,row)) {
938         nrNew++;
939       }
940     }
941   }
942   return nrNew;
943 }
944 UInt_t AliITSOnlineCalibrationSPDhandler::SetNoisyChip(UInt_t eq, UInt_t hs, UInt_t chip) {
945   // set a full chip noisy, returns nr of new noisy pixels
946   UInt_t nrNew = 0;
947   for (UInt_t col=0; col<32; col++) {
948     for (UInt_t row=0; row<256; row++) {
949       if (SetNoisyPixel(eq,hs,chip,col,row)) {
950         nrNew++;
951       }
952     }
953   }
954   return nrNew;
955 }
956 Bool_t AliITSOnlineCalibrationSPDhandler::UnSetDeadChip(UInt_t eq, UInt_t hs, UInt_t chip) {
957   // unset a full dead chip, returns false if it was not all dead before
958   UInt_t nrUnset = 0;
959   for (UInt_t col=0; col<32; col++) {
960     for (UInt_t row=0; row<256; row++) {
961       if (UnSetDeadPixel(eq,hs,chip,col,row)) {
962         nrUnset++;
963       }
964     }
965   }
966   if (nrUnset+GetNrNoisyC(eq,hs,chip)<8192) return kFALSE;
967   else return kTRUE;
968 }
969 Bool_t AliITSOnlineCalibrationSPDhandler::UnSetNoisyChip(UInt_t eq, UInt_t hs, UInt_t chip) {
970   // unset a full noisy chip, returns false if it was not all noisy before
971   UInt_t nrUnset = 0;
972   for (UInt_t col=0; col<32; col++) {
973     for (UInt_t row=0; row<256; row++) {
974       if (UnSetNoisyPixel(eq,hs,chip,col,row)) {
975         nrUnset++;
976       }
977     }
978   }
979   if (nrUnset<8192) return kFALSE;
980   else return kTRUE;
981 }
982 //____________________________________________________________________________________________
983 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDead(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const {
984   // is the pixel dead?
985   UInt_t gloChip = GetGloChip(eq,hs,chip);
986   if (gloChip>=1200) {
987     Error("AliITSOnlineCalibrationSPDhandler::IsPixelDead", "eq,hs,chip nrs (%d,%d,%d) out of bounds.",eq,hs,chip);
988     return kFALSE;
989   }
990   UInt_t key = GetKey(eq,hs,chip,col,row);
991   if ( fDeadPixelMap[gloChip]->Find(key) != NULL ) {
992     return kTRUE;
993   }
994   else {
995     return kFALSE;
996   }
997 }
998 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisy(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const {
999   // is the pixel noisy?
1000   UInt_t gloChip = GetGloChip(eq,hs,chip);
1001   if (gloChip>=1200) {
1002     Error("AliITSOnlineCalibrationSPDhandler::IsPixelNoisy", "eq,hs,chip nrs (%d,%d,%d) out of bounds.",eq,hs,chip);
1003     return kFALSE;
1004   }
1005   UInt_t key = GetKey(eq,hs,chip,col,row);
1006   if ( fNoisyPixelMap[gloChip]->Find(key) != NULL ) {
1007     return kTRUE;
1008   }
1009   else {
1010     return kFALSE;
1011   }
1012 }
1013 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDeadM(UInt_t module, UInt_t colM, UInt_t rowM) const {
1014   // is the pixel dead?
1015   UInt_t eq = GetEqIdFromOffline(module);
1016   UInt_t hs = GetHSFromOffline(module);
1017   UInt_t chip = GetChipFromOffline(module,colM);
1018   UInt_t col = GetColFromOffline(module,colM);
1019   UInt_t row = GetRowFromOffline(module,rowM);
1020   return IsPixelDead(eq,hs,chip,col,row);
1021 }
1022 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyM(UInt_t module, UInt_t colM, UInt_t rowM) const  {
1023   // is the pixel noisy?
1024   UInt_t eq = GetEqIdFromOffline(module);
1025   UInt_t hs = GetHSFromOffline(module);
1026   UInt_t chip = GetChipFromOffline(module,colM);
1027   UInt_t col = GetColFromOffline(module,colM);
1028   UInt_t row = GetRowFromOffline(module,rowM);
1029   return IsPixelNoisy(eq,hs,chip,col,row);
1030 }
1031 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDeadKey(Int_t key) const {
1032   // is this pixel dead?
1033   UInt_t eq = GetEqIdFromKey(key);
1034   UInt_t hs = GetHSFromKey(key);
1035   UInt_t chip = GetChipFromKey(key);
1036   UInt_t col = GetColFromKey(key);
1037   UInt_t row = GetRowFromKey(key);
1038   return IsPixelDead(eq,hs,chip,col,row);
1039 }
1040 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyKey(Int_t key) const {
1041   // is this pixel noisy?
1042   UInt_t eq = GetEqIdFromKey(key);
1043   UInt_t hs = GetHSFromKey(key);
1044   UInt_t chip = GetChipFromKey(key);
1045   UInt_t col = GetColFromKey(key);
1046   UInt_t row = GetRowFromKey(key);
1047   return IsPixelNoisy(eq,hs,chip,col,row);
1048 }
1049 //____________________________________________________________________________________________
1050 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDead() const {
1051   // returns the total nr of dead pixels
1052   UInt_t nrDead = 0;
1053   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
1054     nrDead+=fNrDead[gloChip];
1055   }
1056   return nrDead;
1057 }
1058 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisy() const {
1059   // returns the total nr of noisy pixels
1060   UInt_t nrNoisy = 0;
1061   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
1062     nrNoisy+=fNrNoisy[gloChip];
1063   }
1064   return nrNoisy;
1065 }
1066 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAt(UInt_t index) {
1067   // get eq for the dead pixel at position index in list of dead
1068   UInt_t gloChip;
1069   UInt_t chipIndex;
1070   GetChipAndIndexTotDead(index,gloChip,chipIndex);
1071   return GetDeadEqIdAtC2(gloChip,chipIndex);
1072 }
1073 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAt(UInt_t index) {
1074   // get eq for the noisy pixel at position index in list of noisy
1075   UInt_t gloChip;
1076   UInt_t chipIndex;
1077   GetChipAndIndexTotNoisy(index,gloChip,chipIndex);
1078   return GetNoisyEqIdAtC2(gloChip,chipIndex);
1079 }
1080 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAt(UInt_t index) {
1081   // get hs for the dead pixel at position index in list of dead
1082   UInt_t gloChip;
1083   UInt_t chipIndex;
1084   GetChipAndIndexTotDead(index,gloChip,chipIndex);
1085   return GetDeadHSAtC2(gloChip,chipIndex);
1086 }
1087 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAt(UInt_t index) {
1088   // get hs for the noisy pixel at position index in list of noisy
1089   UInt_t gloChip;
1090   UInt_t chipIndex;
1091   GetChipAndIndexTotNoisy(index,gloChip,chipIndex);
1092   return GetNoisyHSAtC2(gloChip,chipIndex);
1093 }
1094 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAt(UInt_t index) {
1095   // get chip for the dead pixel at position index in list of dead
1096   UInt_t gloChip;
1097   UInt_t chipIndex;
1098   GetChipAndIndexTotDead(index,gloChip,chipIndex);
1099   return GetDeadChipAtC2(gloChip,chipIndex);
1100 }
1101 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAt(UInt_t index) {
1102   // get chip for the noisy pixel at position index in list of noisy
1103   UInt_t gloChip;
1104   UInt_t chipIndex;
1105   GetChipAndIndexTotNoisy(index,gloChip,chipIndex);
1106   return GetNoisyChipAtC2(gloChip,chipIndex);
1107 }
1108 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAt(UInt_t index) {
1109   // get hs for the dead pixel at position index in list of dead
1110   UInt_t gloChip;
1111   UInt_t chipIndex;
1112   GetChipAndIndexTotDead(index,gloChip,chipIndex);
1113   return GetDeadColAtC2(gloChip,chipIndex);
1114 }
1115 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAt(UInt_t index) {
1116   // get hs for the noisy pixel at position index in list of noisy
1117   UInt_t gloChip;
1118   UInt_t chipIndex;
1119   GetChipAndIndexTotNoisy(index,gloChip,chipIndex);
1120   return GetNoisyColAtC2(gloChip,chipIndex);
1121 }
1122 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAt(UInt_t index) {
1123   // get hs for the dead pixel at position index in list of dead
1124   UInt_t gloChip;
1125   UInt_t chipIndex;
1126   GetChipAndIndexTotDead(index,gloChip,chipIndex);
1127   return GetDeadRowAtC2(gloChip,chipIndex);
1128 }
1129 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAt(UInt_t index) {
1130   // get hs for the noisy pixel at position index in list of noisy
1131   UInt_t gloChip;
1132   UInt_t chipIndex;
1133   GetChipAndIndexTotNoisy(index,gloChip,chipIndex);
1134   return GetNoisyRowAtC2(gloChip,chipIndex);
1135 }
1136 //____________________________________________________________________________________________
1137 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDead(UInt_t module) const {
1138   // returns the number of dead pixels for a certain module
1139   if (module>=240) {
1140     Error("AliITSOnlineCalibrationSPDhandler::GetNrDead", "module nr (%d) out of bounds.",module);
1141     return 0;
1142   }
1143   UInt_t nrDead = 0;
1144   UInt_t eq = GetEqIdFromOffline(module);
1145   UInt_t hs = GetHSFromOffline(module);
1146   for (UInt_t chip=0; chip<5; chip++) {
1147     UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,chip*32));
1148     nrDead+=fNrDead[gloChip];
1149
1150   }
1151   return nrDead;
1152 }
1153 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisy(UInt_t module) const {
1154   // returns the number of noisy pixels for a certain module
1155   if (module>=240) {
1156     Error("AliITSOnlineCalibrationSPDhandler::GetNrNoisy", "module nr (%d) out of bounds.",module);
1157     return 0;
1158   }
1159   UInt_t nrNoisy = 0;
1160   UInt_t eq = GetEqIdFromOffline(module);
1161   UInt_t hs = GetHSFromOffline(module);
1162   for (UInt_t chip=0; chip<5; chip++) {
1163     UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,chip*32));
1164     nrNoisy+=fNrNoisy[gloChip];
1165
1166   }
1167   return nrNoisy;
1168 }
1169 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAt(UInt_t module, UInt_t index) {
1170   // get eq for the dead pixel at position index in list of dead
1171   UInt_t gloChip;
1172   UInt_t chipIndex;
1173   GetChipAndIndexDead(module,index,gloChip,chipIndex);
1174   return GetDeadEqIdAtC2(gloChip,chipIndex);
1175 }
1176 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAt(UInt_t module, UInt_t index) {
1177   // get eq for the noisy pixel at position index in list of noisy
1178   UInt_t gloChip;
1179   UInt_t chipIndex;
1180   GetChipAndIndexNoisy(module,index,gloChip,chipIndex);
1181   return GetNoisyEqIdAtC2(gloChip,chipIndex);
1182 }
1183 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAt(UInt_t module, UInt_t index) {
1184   // get hs for the dead pixel at position index in list of dead
1185   UInt_t gloChip;
1186   UInt_t chipIndex;
1187   GetChipAndIndexDead(module,index,gloChip,chipIndex);
1188   return GetDeadHSAtC2(gloChip,chipIndex);
1189 }
1190 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAt(UInt_t module, UInt_t index) {
1191   // get hs for the noisy pixel at position index in list of noisy
1192   UInt_t gloChip;
1193   UInt_t chipIndex;
1194   GetChipAndIndexNoisy(module,index,gloChip,chipIndex);
1195   return GetNoisyHSAtC2(gloChip,chipIndex);
1196 }
1197 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAt(UInt_t module, UInt_t index) {
1198   // get chip for the dead pixel at position index in list of dead
1199   UInt_t gloChip;
1200   UInt_t chipIndex;
1201   GetChipAndIndexDead(module,index,gloChip,chipIndex);
1202   return GetDeadChipAtC2(gloChip,chipIndex);
1203 }
1204 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAt(UInt_t module, UInt_t index) {
1205   // get chip for the noisy pixel at position index in list of noisy
1206   UInt_t gloChip;
1207   UInt_t chipIndex;
1208   GetChipAndIndexNoisy(module,index,gloChip,chipIndex);
1209   return GetNoisyChipAtC2(gloChip,chipIndex);
1210 }
1211 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAt(UInt_t module, UInt_t index) {
1212   // get hs for the dead pixel at position index in list of dead
1213   UInt_t gloChip;
1214   UInt_t chipIndex;
1215   GetChipAndIndexDead(module,index,gloChip,chipIndex);
1216   return GetDeadColAtC2(gloChip,chipIndex);
1217 }
1218 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAt(UInt_t module, UInt_t index) {
1219   // get hs for the noisy pixel at position index in list of noisy
1220   UInt_t gloChip;
1221   UInt_t chipIndex;
1222   GetChipAndIndexNoisy(module,index,gloChip,chipIndex);
1223   return GetNoisyColAtC2(gloChip,chipIndex);
1224 }
1225 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAt(UInt_t module, UInt_t index) {
1226   // get hs for the dead pixel at position index in list of dead
1227   UInt_t gloChip;
1228   UInt_t chipIndex;
1229   GetChipAndIndexDead(module,index,gloChip,chipIndex);
1230   return GetDeadRowAtC2(gloChip,chipIndex);
1231 }
1232 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAt(UInt_t module, UInt_t index) {
1233   // get hs for the noisy pixel at position index in list of noisy
1234   UInt_t gloChip;
1235   UInt_t chipIndex;
1236   GetChipAndIndexNoisy(module,index,gloChip,chipIndex);
1237   return GetNoisyRowAtC2(gloChip,chipIndex);
1238 }
1239 //____________________________________________________________________________________________
1240 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadEq(UInt_t eq) const {
1241   // returns nr of dead for eq
1242   UInt_t returnval=0;
1243   for (UInt_t hs=0; hs<6; hs++) {
1244     for (UInt_t chip=0; chip<10; chip++) {
1245       returnval+=GetNrDeadC(eq,hs,chip);
1246     }
1247   }
1248   return returnval;
1249 }
1250 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisyEq(UInt_t eq) const {
1251   // returns nr of noisy for eq
1252   UInt_t returnval=0;
1253   for (UInt_t hs=0; hs<6; hs++) {
1254     for (UInt_t chip=0; chip<10; chip++) {
1255       returnval+=GetNrNoisyC(eq,hs,chip);
1256     }
1257   }
1258   return returnval;
1259 }
1260 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAtEq(UInt_t eq, UInt_t index) const {
1261   // get eq for the dead pixel at position index in list of dead
1262   if (eq<20 && index<GetNrDeadEq(eq)) {
1263     return eq;
1264   }
1265   else {
1266     return 20;
1267   }
1268 }
1269 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAtEq(UInt_t eq, UInt_t index) const {
1270   // get eq for the noisy pixel at position index in list of noisy
1271   if (eq<20 && index<GetNrNoisyEq(eq)) {
1272     return eq;
1273   }
1274   else {
1275     return 20;
1276   }
1277 }
1278 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAtEq(UInt_t eq, UInt_t index) {
1279   // get hs for the dead pixel at position index in list of dead
1280   UInt_t gloChip;
1281   UInt_t chipIndex;
1282   GetChipAndIndexEqDead(eq,index,gloChip,chipIndex);
1283   return GetDeadHSAtC2(gloChip,chipIndex);
1284 }
1285 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAtEq(UInt_t eq, UInt_t index) {
1286   // get hs for the noisy pixel at position index in list of noisy
1287   UInt_t gloChip;
1288   UInt_t chipIndex;
1289   GetChipAndIndexEqNoisy(eq,index,gloChip,chipIndex);
1290   return GetNoisyHSAtC2(gloChip,chipIndex);
1291 }
1292 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAtEq(UInt_t eq, UInt_t index) {
1293   // get chip for the dead pixel at position index in list of dead
1294   UInt_t gloChip;
1295   UInt_t chipIndex;
1296   GetChipAndIndexEqDead(eq,index,gloChip,chipIndex);
1297   return GetDeadChipAtC2(gloChip,chipIndex);
1298 }
1299 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAtEq(UInt_t eq, UInt_t index) {
1300   // get chip for the noisy pixel at position index in list of noisy
1301   UInt_t gloChip;
1302   UInt_t chipIndex;
1303   GetChipAndIndexEqNoisy(eq,index,gloChip,chipIndex);
1304   return GetNoisyChipAtC2(gloChip,chipIndex);
1305 }
1306 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAtEq(UInt_t eq, UInt_t index) {
1307   // get hs for the dead pixel at position index in list of dead
1308   UInt_t gloChip;
1309   UInt_t chipIndex;
1310   GetChipAndIndexEqDead(eq,index,gloChip,chipIndex);
1311   return GetDeadColAtC2(gloChip,chipIndex);
1312 }
1313 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAtEq(UInt_t eq, UInt_t index) {
1314   // get hs for the noisy pixel at position index in list of noisy
1315   UInt_t gloChip;
1316   UInt_t chipIndex;
1317   GetChipAndIndexEqNoisy(eq,index,gloChip,chipIndex);
1318   return GetNoisyColAtC2(gloChip,chipIndex);
1319 }
1320 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAtEq(UInt_t eq, UInt_t index) {
1321   // get hs for the dead pixel at position index in list of dead
1322   UInt_t gloChip;
1323   UInt_t chipIndex;
1324   GetChipAndIndexEqDead(eq,index,gloChip,chipIndex);
1325   return GetDeadRowAtC2(gloChip,chipIndex);
1326 }
1327 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAtEq(UInt_t eq, UInt_t index) {
1328   // get hs for the noisy pixel at position index in list of noisy
1329   UInt_t gloChip;
1330   UInt_t chipIndex;
1331   GetChipAndIndexEqNoisy(eq,index,gloChip,chipIndex);
1332   return GetNoisyRowAtC2(gloChip,chipIndex);
1333 }
1334 //____________________________________________________________________________________________
1335 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadC(UInt_t eq, UInt_t hs, UInt_t chip) const {
1336   UInt_t gloChip = GetGloChip(eq,hs,chip);
1337   return GetNrDeadC2(gloChip);
1338 }
1339 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisyC(UInt_t eq, UInt_t hs, UInt_t chip) const {
1340   UInt_t gloChip = GetGloChip(eq,hs,chip);
1341   return GetNrNoisyC2(gloChip);
1342 }
1343 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
1344   UInt_t gloChip = GetGloChip(eq,hs,chip);
1345   return GetDeadEqIdAtC2(gloChip,index);
1346 }
1347 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
1348   UInt_t gloChip = GetGloChip(eq,hs,chip);
1349   return GetNoisyEqIdAtC2(gloChip,index);
1350 }
1351 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
1352   UInt_t gloChip = GetGloChip(eq,hs,chip);
1353   return GetDeadHSAtC2(gloChip,index);
1354 }
1355 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
1356   UInt_t gloChip = GetGloChip(eq,hs,chip);
1357   return GetNoisyHSAtC2(gloChip,index);
1358 }
1359 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
1360   UInt_t gloChip = GetGloChip(eq,hs,chip);
1361   return GetDeadChipAtC2(gloChip,index);
1362 }
1363 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
1364   UInt_t gloChip = GetGloChip(eq,hs,chip);
1365   return GetNoisyChipAtC2(gloChip,index);
1366 }
1367 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
1368   UInt_t gloChip = GetGloChip(eq,hs,chip);
1369   return GetDeadColAtC2(gloChip,index);
1370 }
1371 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
1372   UInt_t gloChip = GetGloChip(eq,hs,chip);
1373   return GetNoisyColAtC2(gloChip,index);
1374 }
1375 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
1376   UInt_t gloChip = GetGloChip(eq,hs,chip);
1377   return GetDeadRowAtC2(gloChip,index);
1378 }
1379 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
1380   UInt_t gloChip = GetGloChip(eq,hs,chip);
1381   return GetNoisyRowAtC2(gloChip,index);
1382 }
1383 //____________________________________________________________________________________________
1384 const Char_t* AliITSOnlineCalibrationSPDhandler::GetDeadPixelAsTextC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
1385   // get a string of dead pixel info
1386   TString returnMess = "";
1387   UInt_t gloChip = GetGloChip(eq,hs,chip);
1388   if (gloChip>=1200) {
1389     Error("AliITSOnlineCalibrationSPDhandler::GetDeadPixelAsTextC", "global chip nr (%d) out of bounds.",gloChip);
1390     return returnMess.Data();
1391   }
1392   if (index<fNrDead[gloChip]) {
1393     Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
1394     UInt_t col = GetColFromKey(key);
1395     UInt_t row = GetRowFromKey(key);    
1396     UInt_t module = AliITSRawStreamSPD::GetOfflineModuleFromOnline(eq,hs,chip);
1397     UInt_t colM = AliITSRawStreamSPD::GetOfflineColFromOnline(eq,hs,chip,col);
1398     UInt_t rowM = AliITSRawStreamSPD::GetOfflineRowFromOnline(eq,hs,chip,row);
1399     returnMess = Form("%*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);
1400     return returnMess.Data();
1401   }
1402   else {
1403     Error("AliITSOnlineCalibrationSPDhandler::GetDeadPixelAsTextC", "Index %d out of bounds.", index);
1404     return returnMess.Data();
1405   }
1406 }
1407 const Char_t* AliITSOnlineCalibrationSPDhandler::GetNoisyPixelAsTextC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
1408   // get a string of noisy pixel info
1409   TString returnMess = "";
1410   UInt_t gloChip = GetGloChip(eq,hs,chip);
1411   if (gloChip>=1200) {
1412     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyPixelAsTextC", "global chip nr (%d) out of bounds.",gloChip);
1413     return returnMess.Data();
1414   }
1415   if (index<fNrNoisy[gloChip]) {
1416     Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(index);
1417     UInt_t col = GetColFromKey(key);
1418     UInt_t row = GetRowFromKey(key);    
1419     UInt_t module = AliITSRawStreamSPD::GetOfflineModuleFromOnline(eq,hs,chip);
1420     UInt_t colM = AliITSRawStreamSPD::GetOfflineColFromOnline(eq,hs,chip,col);
1421     UInt_t rowM = AliITSRawStreamSPD::GetOfflineRowFromOnline(eq,hs,chip,row);
1422     returnMess = Form("%*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);
1423     return returnMess.Data();
1424   }
1425   else {
1426     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyPixelAsTextC", "Index %d out of bounds.", index);
1427     return returnMess.Data();
1428   }
1429 }
1430 //____________________________________________________________________________________________
1431 UInt_t AliITSOnlineCalibrationSPDhandler::AddDeadFrom(AliITSOnlineCalibrationSPDhandler* other) {
1432   // returns number of new dead pixels in this' list
1433   UInt_t returnval=0;
1434   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
1435     for (UInt_t ind1=0; ind1<other->fNrDead[gloChip]; ind1++) {
1436       UInt_t eq = other->GetDeadEqIdAtC2(gloChip,ind1);
1437       UInt_t hs   = other->GetDeadHSAtC2(gloChip,ind1);
1438       UInt_t chip = other->GetDeadChipAtC2(gloChip,ind1);
1439       UInt_t col  = other->GetDeadColAtC2(gloChip,ind1);
1440       UInt_t row  = other->GetDeadRowAtC2(gloChip,ind1);
1441       if (SetDeadPixel(eq,hs,chip,col,row)) {
1442         returnval++;
1443       }
1444     }
1445   }
1446   return returnval;
1447 }
1448 UInt_t AliITSOnlineCalibrationSPDhandler::AddNoisyFrom(AliITSOnlineCalibrationSPDhandler* other) {
1449   // returns number of new noisy pixels in this' list
1450   UInt_t returnval=0;
1451   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
1452     for (UInt_t ind1=0; ind1<other->fNrNoisy[gloChip]; ind1++) {
1453       UInt_t eq = other->GetNoisyEqIdAtC2(gloChip,ind1);
1454       UInt_t hs   = other->GetNoisyHSAtC2(gloChip,ind1);
1455       UInt_t chip = other->GetNoisyChipAtC2(gloChip,ind1);
1456       UInt_t col  = other->GetNoisyColAtC2(gloChip,ind1);
1457       UInt_t row  = other->GetNoisyRowAtC2(gloChip,ind1);
1458       if (SetNoisyPixel(eq,hs,chip,col,row)) {
1459         returnval++;
1460       }
1461     }
1462   }
1463   return returnval;
1464 }
1465 //____________________________________________________________________________________________
1466 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDiff(AliITSOnlineCalibrationSPDhandler* other) const {
1467   // returns nr of dead/noisy in this' lists and not in other's lists
1468   return GetNrDeadDiff(other) + GetNrNoisyDiff(other);
1469 }
1470 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadDiff(AliITSOnlineCalibrationSPDhandler* other) const {
1471   // returns nr of dead in this' lists and not in other's lists
1472   UInt_t returnval=0;
1473   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
1474     for (UInt_t ind1=0; ind1<fNrDead[gloChip]; ind1++) {
1475       Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(ind1);
1476       UInt_t eq = GetEqIdFromKey(key);
1477       UInt_t hs = GetHSFromKey(key);
1478       UInt_t chip = GetChipFromKey(key);
1479       UInt_t col = GetColFromKey(key);
1480       UInt_t row = GetRowFromKey(key);
1481       if (!(other->IsPixelDead(eq,hs,chip,col,row))) {
1482         returnval++;
1483       }
1484     }
1485   }
1486   return returnval;
1487 }
1488 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisyDiff(AliITSOnlineCalibrationSPDhandler* other) const {
1489   // returns nr of noisy in this' lists and not in other's lists
1490   UInt_t returnval=0;
1491   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
1492     for (UInt_t ind1=0; ind1<fNrNoisy[gloChip]; ind1++) {
1493       Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(ind1);
1494       UInt_t eq = GetEqIdFromKey(key);
1495       UInt_t hs = GetHSFromKey(key);
1496       UInt_t chip = GetChipFromKey(key);
1497       UInt_t col = GetColFromKey(key);
1498       UInt_t row = GetRowFromKey(key);
1499       if (!(other->IsPixelNoisy(eq,hs,chip,col,row))) {
1500         returnval++;
1501       }
1502     }
1503   }
1504   return returnval;
1505 }
1506 AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetDiff(AliITSOnlineCalibrationSPDhandler* other) const {
1507   // returns handler with dead/noisy in this' lists, except for those in other's lists
1508   AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler();
1509   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
1510     for (UInt_t ind1=0; ind1<fNrDead[gloChip]; ind1++) {
1511       Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(ind1);
1512       UInt_t eq = GetEqIdFromKey(key);
1513       UInt_t hs = GetHSFromKey(key);
1514       UInt_t chip = GetChipFromKey(key);
1515       UInt_t col = GetColFromKey(key);
1516       UInt_t row = GetRowFromKey(key);
1517       if (!(other->IsPixelDead(eq,hs,chip,col,row))) {
1518         newHandler->SetDeadPixel(eq,hs,chip,col,row);
1519       }
1520     }
1521     for (UInt_t ind2=0; ind2<fNrNoisy[gloChip]; ind2++) {
1522       Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(ind2);
1523       UInt_t eq = GetEqIdFromKey(key);
1524       UInt_t hs = GetHSFromKey(key);
1525       UInt_t chip = GetChipFromKey(key);
1526       UInt_t col = GetColFromKey(key);
1527       UInt_t row = GetRowFromKey(key);
1528       if (!(other->IsPixelNoisy(eq,hs,chip,col,row))) {
1529         newHandler->SetNoisyPixel(eq,hs,chip,col,row);
1530       }
1531     }
1532   }
1533   return newHandler;
1534 }
1535 AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetDeadDiff(AliITSOnlineCalibrationSPDhandler* other) const {
1536   // returns handler with dead in this' lists, except for those in other's lists
1537   AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler();
1538   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
1539     for (UInt_t ind1=0; ind1<fNrDead[gloChip]; ind1++) {
1540       Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(ind1);
1541       UInt_t eq = GetEqIdFromKey(key);
1542       UInt_t hs = GetHSFromKey(key);
1543       UInt_t chip = GetChipFromKey(key);
1544       UInt_t col = GetColFromKey(key);
1545       UInt_t row = GetRowFromKey(key);
1546       if (!(other->IsPixelDead(eq,hs,chip,col,row))) {
1547         newHandler->SetDeadPixel(eq,hs,chip,col,row);
1548       }
1549     }
1550   }
1551   return newHandler;
1552 }
1553 AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetNoisyDiff(AliITSOnlineCalibrationSPDhandler* other) const {
1554   // returns handler with noisy in this' lists, except for those in other's lists
1555   AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler();
1556   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
1557     for (UInt_t ind2=0; ind2<fNrNoisy[gloChip]; ind2++) {
1558       Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(ind2);
1559       UInt_t eq = GetEqIdFromKey(key);
1560       UInt_t hs = GetHSFromKey(key);
1561       UInt_t chip = GetChipFromKey(key);
1562       UInt_t col = GetColFromKey(key);
1563       UInt_t row = GetRowFromKey(key);
1564       if (!(other->IsPixelNoisy(eq,hs,chip,col,row))) {
1565         newHandler->SetNoisyPixel(eq,hs,chip,col,row);
1566       }
1567     }
1568   }
1569   return newHandler;
1570 }
1571 //____________________________________________________________________________________________
1572 void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexDead(UInt_t module, UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) {
1573   // find gloChip and chipIndex from module and index
1574   if (index<GetNrDead(module)) {
1575     UInt_t eq = GetEqIdFromOffline(module);
1576     UInt_t hs = GetHSFromOffline(module);
1577     
1578     UInt_t glVal=0;
1579     for (UInt_t chip=0; chip<5; chip++) {
1580       gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,chip*32));
1581       if (glVal+fNrDead[gloChip]>index) {
1582         chipIndex = index-glVal;
1583         break;
1584       }
1585       else {
1586         glVal+=fNrDead[gloChip];
1587       }
1588     }
1589
1590   }
1591   else {
1592     Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexDead", "Index %d out of bounds.", index);
1593   }
1594 }
1595 void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexNoisy(UInt_t module, UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) {
1596   // find gloChip and chipIndex from module and index
1597   if (index<GetNrNoisy(module)) {
1598     UInt_t eq = GetEqIdFromOffline(module);
1599     UInt_t hs = GetHSFromOffline(module);
1600     
1601     UInt_t glVal=0;
1602     for (UInt_t chip=0; chip<5; chip++) {
1603       gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,chip*32));
1604       if (glVal+fNrNoisy[gloChip]>index) {
1605         chipIndex = index-glVal;
1606         break;
1607       }
1608       else {
1609         glVal+=fNrNoisy[gloChip];
1610       }
1611     }
1612
1613   }
1614   else {
1615     Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexNoisy", "Index %d out of bounds.", index);
1616   }
1617 }
1618 void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexEqDead(UInt_t eq, UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) {
1619   // find gloChip and chipIndex from module and index
1620   if (index<GetNrDeadEq(eq)) {
1621
1622     UInt_t glVal=0;
1623     for (UInt_t hs=0; hs<6; hs++) {
1624       for (UInt_t chip=0; chip<10; chip++) {
1625         gloChip = GetGloChip(eq,hs,chip);
1626         if (glVal+fNrDead[gloChip]>index) {
1627           chipIndex = index-glVal;
1628           break;
1629         }
1630         else {
1631           glVal+=fNrDead[gloChip];
1632         }
1633       }
1634     }
1635
1636   }
1637   else {
1638     Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexEqDead", "Index %d out of bounds.", index);
1639   }
1640 }
1641 void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexEqNoisy(UInt_t eq, UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) {
1642   // find gloChip and chipIndex from module and index
1643   if (index<GetNrNoisyEq(eq)) {
1644
1645     UInt_t glVal=0;
1646     for (UInt_t hs=0; hs<6; hs++) {
1647       for (UInt_t chip=0; chip<10; chip++) {
1648         gloChip = GetGloChip(eq,hs,chip);
1649         if (glVal+fNrNoisy[gloChip]>index) {
1650           chipIndex = index-glVal;
1651           break;
1652         }
1653         else {
1654           glVal+=fNrNoisy[gloChip];
1655         }
1656       }
1657     }
1658
1659   }
1660   else {
1661     Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexEqNoisy", "Index %d out of bounds.", index);
1662   }
1663 }
1664 void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexTotDead(UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) {
1665   // find gloChip and chipIndex from global index
1666   if (index<GetNrDead()) {
1667     
1668     UInt_t glVal=0;
1669     for (gloChip=0; gloChip<1200; gloChip++) {
1670       if (glVal+fNrDead[gloChip]>index) {
1671         chipIndex = index-glVal;
1672         break;
1673       }
1674       else {
1675         glVal+=fNrDead[gloChip];
1676       }
1677     }
1678
1679   }
1680   else {
1681     Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexTotDead", "Index %d out of bounds.", index);
1682   }
1683 }
1684 void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexTotNoisy(UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) {
1685   // find gloChip and chipIndex from global index
1686   if (index<GetNrNoisy()) {
1687     
1688     UInt_t glVal=0;
1689     for (gloChip=0; gloChip<1200; gloChip++) {
1690       if (glVal+fNrNoisy[gloChip]>index) {
1691         chipIndex = index-glVal;
1692         break;
1693       }
1694       else {
1695         glVal+=fNrNoisy[gloChip];
1696       }
1697     }
1698
1699   }
1700   else {
1701     Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexTotNoisy", "Index %d out of bounds.", index);
1702   }
1703 }
1704 //____________________________________________________________________________________________
1705 UInt_t AliITSOnlineCalibrationSPDhandler::GetEqIdFromOffline(UInt_t module) const {
1706   // module to eq mapping
1707   if (module>=240) {
1708     Error("AliITSOnlineCalibrationSPDhandler::GetEqIdFromOffline", "module nr (%d) out of bounds.",module);
1709     return 20;
1710   }
1711   return AliITSRawStreamSPD::GetOnlineEqIdFromOffline(module);
1712 }
1713 UInt_t AliITSOnlineCalibrationSPDhandler::GetHSFromOffline(UInt_t module) const {
1714   // module to hs mapping
1715   if (module>=240) {
1716     Error("AliITSOnlineCalibrationSPDhandler::GetHSFromOffline", "module nr (%d) out of bounds.",module);
1717     return 6;
1718   }
1719   return AliITSRawStreamSPD::GetOnlineHSFromOffline(module);
1720 }
1721 UInt_t AliITSOnlineCalibrationSPDhandler::GetChipFromOffline(UInt_t module, UInt_t colM) const {
1722   // module,colM to chip mapping
1723   if (module>=240 || colM>=160) {
1724     Error("AliITSOnlineCalibrationSPDhandler::GetChipFromOffline", "module,colM nrs (%d,%d) out of bounds.",module,colM);
1725     return 10;
1726   }
1727   return AliITSRawStreamSPD::GetOnlineChipFromOffline(module,colM);
1728 }
1729 UInt_t AliITSOnlineCalibrationSPDhandler::GetColFromOffline(UInt_t module, UInt_t colM) const {
1730   // colM to col mapping
1731   if (colM>=160) {
1732     Error("AliITSOnlineCalibrationSPDhandler::GetColFromOffline", "colM nr (%d) out of bounds.",colM);
1733     return 160;
1734   }
1735   return AliITSRawStreamSPD::GetOnlineColFromOffline(module,colM);
1736 }
1737
1738 UInt_t AliITSOnlineCalibrationSPDhandler::GetRowFromOffline(UInt_t module, UInt_t rowM) const {
1739   // rowM to row mapping
1740   if (rowM>=256) {
1741     Error("AliITSOnlineCalibrationSPDhandler::GetRowFromOffline", "rowM nr (%d) out of bounds.",rowM);
1742     return 256;
1743   }
1744   return AliITSRawStreamSPD::GetOnlineRowFromOffline(module,rowM);
1745 }
1746 //____________________________________________________________________________________________
1747 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadC2(UInt_t gloChip) const {
1748   // returns nr of dead pixels on this chip
1749   if (gloChip>=1200) {
1750     Error("AliITSOnlineCalibrationSPDhandler::GetNrDeadC2", "global chip nr (%d) out of bounds.",gloChip);
1751     return 0;
1752   }
1753   return fNrDead[gloChip];
1754 }
1755 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisyC2(UInt_t gloChip) const {
1756   // returns nr of noisy pixels on this chip
1757   if (gloChip>=1200) {
1758     Error("AliITSOnlineCalibrationSPDhandler::GetNrNoisyC2", "global chip nr (%d) out of bounds.",gloChip);
1759     return 0;
1760   }
1761   return fNrNoisy[gloChip];
1762 }
1763 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAtC2(UInt_t gloChip, UInt_t index) const {
1764   // get eq for the dead pixel at position index in list of dead
1765   if (gloChip>=1200) {
1766     Error("AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAtC", "global chip nr (%d) out of bounds.",gloChip);
1767     return 20;
1768   }
1769   if (index<fNrDead[gloChip]) {
1770     Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
1771     return GetEqIdFromKey(key);
1772   }
1773   else {
1774     Error("AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAtC", "Index %d out of bounds.", index);
1775     return 0;
1776   }
1777 }
1778 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAtC2(UInt_t gloChip, UInt_t index) const {
1779   // get eq for the noisy pixel at position index in list of noisy
1780   if (gloChip>=1200) {
1781     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAtC", "global chip nr (%d) out of bounds.",gloChip);
1782     return 20;
1783   }
1784   if (index<fNrNoisy[gloChip]) {
1785     Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(index);
1786     return GetEqIdFromKey(key);
1787   }
1788   else {
1789     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAtC", "Index %d out of bounds.", index);
1790     return 0;
1791   }
1792 }
1793 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAtC2(UInt_t gloChip, UInt_t index) const {
1794   // get hs for the dead pixel at position index in list of dead
1795   if (gloChip>=1200) {
1796     Error("AliITSOnlineCalibrationSPDhandler::GetDeadHSAtC", "global chip nr (%d) out of bounds.",gloChip);
1797     return 20;
1798   }
1799   if (index<fNrDead[gloChip]) {
1800     Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
1801     return GetHSFromKey(key);
1802   }
1803   else {
1804     Error("AliITSOnlineCalibrationSPDhandler::GetDeadHSAtC", "Index %d out of bounds.", index);
1805     return 0;
1806   }
1807 }
1808 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAtC2(UInt_t gloChip, UInt_t index) const {
1809   // get hs for the noisy pixel at position index in list of noisy
1810   if (gloChip>=1200) {
1811     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyHSAtC", "global chip nr (%d) out of bounds.",gloChip);
1812     return 20;
1813   }
1814   if (index<fNrNoisy[gloChip]) {
1815     Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(index);
1816     return GetHSFromKey(key);
1817   }
1818   else {
1819     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyHSAtC", "Index %d out of bounds.", index);
1820     return 0;
1821   }
1822 }
1823 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAtC2(UInt_t gloChip, UInt_t index) const {
1824   // get chip for the dead pixel at position index in list of dead
1825   if (gloChip>=1200) {
1826     Error("AliITSOnlineCalibrationSPDhandler::GetDeadChipAtC", "global chip nr (%d) out of bounds.",gloChip);
1827     return 20;
1828   }
1829   if (index<fNrDead[gloChip]) {
1830     Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
1831     return GetChipFromKey(key);
1832   }
1833   else {
1834     Error("AliITSOnlineCalibrationSPDhandler::GetDeadChipAtC", "Index %d out of bounds.", index);
1835     return 0;
1836   }
1837 }
1838 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAtC2(UInt_t gloChip, UInt_t index) const {
1839   // get chip for the noisy pixel at position index in list of noisy
1840   if (gloChip>=1200) {
1841     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyChipAtC", "global chip nr (%d) out of bounds.",gloChip);
1842     return 20;
1843   }
1844   if (index<fNrNoisy[gloChip]) {
1845     Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(index);
1846     return GetChipFromKey(key);
1847   }
1848   else {
1849     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyChipAtC", "Index %d out of bounds.", index);
1850     return 0;
1851   }
1852 }
1853 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAtC2(UInt_t gloChip, UInt_t index) const {
1854   // get col for the dead pixel at position index in list of dead
1855   if (gloChip>=1200) {
1856     Error("AliITSOnlineCalibrationSPDhandler::GetDeadColAtC2", "global chip nr (%d) out of bounds.",gloChip);
1857     return 20;
1858   }
1859   if (index<fNrDead[gloChip]) {
1860     Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
1861     return GetColFromKey(key);
1862   }
1863   else {
1864     Error("AliITSOnlineCalibrationSPDhandler::GetDeadColAtC2", "Index %d out of bounds.", index);
1865     return 0;
1866   }
1867 }
1868 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAtC2(UInt_t gloChip, UInt_t index) const {
1869   // get col for the noisy pixel at position index in list of noisy
1870   if (gloChip>=1200) {
1871     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyColAtC", "global chip nr (%d) out of bounds.",gloChip);
1872     return 20;
1873   }
1874   if (index<fNrNoisy[gloChip]) {
1875     Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(index);
1876     return GetColFromKey(key);
1877   }
1878   else {
1879     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyColAtC", "Index %d out of bounds.", index);
1880     return 0;
1881   }
1882 }
1883 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAtC2(UInt_t gloChip, UInt_t index) const {
1884   // get row for the dead pixel at position index in list of dead
1885   if (gloChip>=1200) {
1886     Error("AliITSOnlineCalibrationSPDhandler::GetDeadRowAtC", "global chip nr (%d) out of bounds.",gloChip);
1887     return 20;
1888   }
1889   if (index<fNrDead[gloChip]) {
1890     Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
1891     return GetRowFromKey(key);
1892   }
1893   else {
1894     Error("AliITSOnlineCalibrationSPDhandler::GetDeadRowAtC", "Index %d out of bounds.", index);
1895     return 0;
1896   }
1897 }
1898 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAtC2(UInt_t gloChip, UInt_t index) const {
1899   // get row for the noisy pixel at position index in list of noisy
1900   if (gloChip>=1200) {
1901     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyRowAtC", "global chip nr (%d) out of bounds.",gloChip);
1902     return 20;
1903   }
1904   if (index<fNrNoisy[gloChip]) {
1905     Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(index);
1906     return GetRowFromKey(key);
1907   }
1908   else {
1909     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyRowAtC", "Index %d out of bounds.", index);
1910     return 0;
1911   }
1912 }
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930