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