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