Adding router nr in dcs configuration file and removing ClassDef macro in AliITSOnlin...
[u/mrichter/AliRoot.git] / ITS / AliITSOnlineCalibrationSPDhandler.cxx
1 /**************************************************************************
2  * Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16
17 /* $Id$ */
18
19 //////////////////////////////////////////////////////////////////////
20 // Author: Henrik Tydesjo                                           //
21 // For easier handling of dead and noisy pixels they are kept in    //
22 // container maps (AliITSIntMap).                                   //
23 // The TArrayI objects that are put in the AliITSCalibrationSPD     //
24 // objects can be obtained from the methods GetDeadArray and        //
25 // GetNoisyArray.                                                   //
26 //////////////////////////////////////////////////////////////////////   
27
28 #include "AliITSOnlineCalibrationSPDhandler.h"
29 #include "AliITSOnlineCalibrationSPD.h"
30 #include "AliITSIntMap.h"
31 #include <TObjArray.h>
32 #include <TArrayI.h>
33 #include <TFile.h>
34 #include <TError.h>
35 #include <fstream>
36
37 #ifndef SPD_DA_OFF // you may want to exclude cdb classes, if using this class outside aliroot
38 #include "AliITSCalibrationSPD.h"
39 #include "AliCDBManager.h"
40 #include "AliCDBEntry.h"
41 #endif
42
43 AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler():
44   fFileLocation("."),
45   fModuleMapInited(kFALSE)
46 {
47   // constructor
48   for (UInt_t module=0; module<240; module++) {
49     fNrDead[module]=0;
50     fNrNoisy[module]=0;
51     fDeadPixelMap[module] = new AliITSIntMap();
52     fNoisyPixelMap[module] = new AliITSIntMap();
53   }
54 }
55
56 AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler(const AliITSOnlineCalibrationSPDhandler& handle): 
57   fFileLocation("."),
58   fModuleMapInited(kFALSE)
59 {
60   // copy constructor
61   for (UInt_t module=0; module<240; module++) {
62     fNrDead[module] = handle.fNrDead[module];
63     fNrNoisy[module] = handle.fNrNoisy[module];
64     fDeadPixelMap[module] = handle.fDeadPixelMap[module]->Clone();
65     fNoisyPixelMap[module] = handle.fNoisyPixelMap[module]->Clone();
66   }
67   fFileLocation = handle.fFileLocation;
68 }
69
70 AliITSOnlineCalibrationSPDhandler::~AliITSOnlineCalibrationSPDhandler() {
71   ClearMaps();
72 }
73
74 AliITSOnlineCalibrationSPDhandler& AliITSOnlineCalibrationSPDhandler::operator=(const AliITSOnlineCalibrationSPDhandler& handle) {
75   // assignment operator
76   if (this!=&handle) {
77     this->ClearMaps();
78     for (UInt_t module=0; module<240; module++) {
79       fNrDead[module] = handle.fNrDead[module];
80       fNrNoisy[module] = handle.fNrNoisy[module];
81       fDeadPixelMap[module] = handle.fDeadPixelMap[module]->Clone();
82       fNoisyPixelMap[module] = handle.fNoisyPixelMap[module]->Clone();
83     }
84     fFileLocation = handle.fFileLocation;
85   }
86   return *this;
87 }
88
89 void AliITSOnlineCalibrationSPDhandler::ClearMaps() {
90   // clear the lists of dead and noisy
91   ResetDead();
92   ResetNoisy();
93 }
94
95 Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromFiles() {
96   // read dead and noisy files from file location. returns true if at least one file found
97   Bool_t returnval=kFALSE;
98   for (UInt_t module=0; module<240; module++) {
99     if (ReadFromFile(module)) {
100       returnval=kTRUE;
101     }
102   }
103   return returnval;
104 }
105 Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromFile(UInt_t module) {
106   // read dead and noisy files for module from file location. 
107   TString fileName = Form("%s/SPD_DeadNoisy_%d.root",fFileLocation.Data(),module);
108   return ReadFromFileName(fileName.Data());
109 }
110 Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromFileName(const char *fileName) {
111   // read dead and noisy from file fileName
112   AliITSOnlineCalibrationSPD* calib;
113   FILE* fp0 = fopen(fileName, "r");
114   if (fp0 == NULL) {return kFALSE;}
115   else {
116     fclose(fp0);
117     TFile file(fileName, "READ");
118     if (file.IsOpen()) {
119       file.GetObject("AliITSOnlineCalibrationSPD", calib);
120       file.Close();
121       if (calib!=NULL) {
122         UInt_t module = calib->GetModuleNr();
123         Int_t nrDead=calib->GetNrDead();
124         for (Int_t index=0; index<nrDead; index++) {
125           UInt_t colM=calib->GetDeadColAt(index);
126           UInt_t row=calib->GetDeadRowAt(index);
127           SetDeadPixelM(module,colM,row);
128         }
129         Int_t nrNoisy=calib->GetNrNoisy();
130         for (Int_t index=0; index<nrNoisy; index++) {
131           UInt_t colM=calib->GetNoisyColAt(index);
132           UInt_t row=calib->GetNoisyRowAt(index);
133           SetNoisyPixelM(module,colM,row);
134         }
135       }
136     }
137   }
138   return kTRUE;
139 }
140 Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFiles() {
141   // read dead files from file location. returns true if at least one file found
142   Bool_t returnval=kFALSE;
143   for (UInt_t module=0; module<240; module++) {
144     if (ReadDeadFromFile(module)) {
145       returnval=kTRUE;
146     }
147   }
148   return returnval;
149 }
150 Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFile(UInt_t module) {
151   // read dead for module from file location. 
152   TString fileName = Form("%s/SPD_DeadNoisy_%d.root",fFileLocation.Data(),module);
153   return ReadDeadFromFileName(fileName.Data());
154 }
155 Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFileName(const char *fileName) {
156   // read dead from file fileName
157   AliITSOnlineCalibrationSPD* calib;
158   FILE* fp0 = fopen(fileName, "r");
159   if (fp0 == NULL) {return kFALSE;}
160   else {
161     fclose(fp0);
162     TFile file(fileName, "READ");
163     if (file.IsOpen()) {
164       file.GetObject("AliITSOnlineCalibrationSPD", calib);
165       file.Close();
166       if (calib!=NULL) {
167         UInt_t module = calib->GetModuleNr();
168         Int_t nrDead=calib->GetNrDead();
169         for (Int_t index=0; index<nrDead; index++) {
170           UInt_t colM=calib->GetDeadColAt(index);
171           UInt_t row=calib->GetDeadRowAt(index);
172           SetDeadPixelM(module,colM,row);
173         }
174       }
175     }
176   }
177   return kTRUE;
178 }
179 Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFiles() {
180   // read noisy files from file location. returns true if at least one file found
181   Bool_t returnval=kFALSE;
182   for (UInt_t module=0; module<240; module++) {
183     if (ReadNoisyFromFile(module)) {
184       returnval=kTRUE;
185     }
186   }
187   return returnval;
188 }
189 Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFile(UInt_t module) {
190   // read noisy for module from file location. 
191   TString fileName = Form("%s/SPD_DeadNoisy_%d.root",fFileLocation.Data(),module);
192   return ReadNoisyFromFileName(fileName.Data());
193 }
194 Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFileName(const char *fileName) {
195   // read noisy from file fileName
196   AliITSOnlineCalibrationSPD* calib;
197   FILE* fp0 = fopen(fileName, "r");
198   if (fp0 == NULL) {return kFALSE;}
199   else {
200     fclose(fp0);
201     TFile file(fileName, "READ");
202     if (file.IsOpen()) {
203       file.GetObject("AliITSOnlineCalibrationSPD", calib);
204       file.Close();
205       if (calib!=NULL) {
206         UInt_t module = calib->GetModuleNr();
207         Int_t nrNoisy=calib->GetNrNoisy();
208         for (Int_t index=0; index<nrNoisy; index++) {
209           UInt_t colM=calib->GetNoisyColAt(index);
210           UInt_t row=calib->GetNoisyRowAt(index);
211           SetNoisyPixelM(module,colM,row);
212         }
213       }
214     }
215   }
216   return kTRUE;
217 }
218
219
220 UInt_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromText(const char *fileName) {
221   // read dead from a text file (lines with eqId,hs,chip,col,row). returns nr of pixels added (not already there)
222   UInt_t newNrDead=0;
223   ifstream textFile;
224   textFile.open(fileName, ifstream::in);
225   if (textFile.fail()) {
226     Error("AliITSOnlineCalibrationSPDhandler::ReadDeadFromText","No noisy text file (%s) present.",fileName);
227   }
228   else {
229     while(1) {
230       UInt_t eqId,hs,chip,col,row;
231       textFile >> eqId; if (textFile.eof()) break;
232       textFile >> hs; if (textFile.eof()) break;
233       textFile >> chip; if (textFile.eof()) break;
234       textFile >> col; if (textFile.eof()) break;
235       textFile >> row; 
236       if (SetDeadPixel(eqId,hs,chip,col,row)) {
237         newNrDead++;
238       }
239       if (textFile.eof()) break;
240     }
241     textFile.close();
242   }
243   return newNrDead;
244 }
245
246 UInt_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromText(const char *fileName) {
247   // read noisy from a text file (lines with eqId,hs,chip,col,row). returns nr of pixels added (not already here)
248   UInt_t newNrNoisy=0;
249   ifstream textFile;
250   textFile.open(fileName, ifstream::in);
251   if (textFile.fail()) {
252     Error("AliITSOnlineCalibrationSPDhandler::ReadNoisyFromText","No noisy text file (%s) present.",fileName);
253   }
254   else {
255     while(1) {
256       UInt_t eqId,hs,chip,col,row;
257       textFile >> eqId; if (textFile.eof()) break;
258       textFile >> hs; if (textFile.eof()) break;
259       textFile >> chip; if (textFile.eof()) break;
260       textFile >> col; if (textFile.eof()) break;
261       textFile >> row; 
262       if (SetNoisyPixel(eqId,hs,chip,col,row)) {
263         newNrNoisy++;
264       }
265       if (textFile.eof()) break;
266     }
267     textFile.close();
268   }
269   return newNrNoisy;
270 }
271
272
273 #ifndef SPD_DA_OFF
274 Bool_t AliITSOnlineCalibrationSPDhandler::ReadModuleFromDB(UInt_t module, Int_t runNr) {
275   // reads dead and noisy pixels from DB for given module and runNr
276   AliCDBManager* man = AliCDBManager::Instance();
277   if(!man->IsDefaultStorageSet()) {
278     man->SetDefaultStorage("local://$ALICE_ROOT");
279   }
280   AliCDBEntry *cdbEntry = man->Get("ITS/Calib/CalibSPD", runNr);
281   TObjArray* spdEntry;
282   if(cdbEntry) {
283     spdEntry = (TObjArray*)cdbEntry->GetObject();
284     if(!spdEntry) return kFALSE;
285   }
286   else {
287     Warning("AliITSOnlineCalibrationSPDhandler::ReadModuleFromDB","Calibration for run %d not found in database.",runNr);
288     return kFALSE;
289   }
290   AliITSCalibrationSPD* calibSPD;
291   calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module);
292   UInt_t nrDead = calibSPD->GetNrDead();
293   for (UInt_t index=0; index<nrDead; index++) {
294     UInt_t colM = calibSPD->GetDeadColAt(index);
295     UInt_t row  = calibSPD->GetDeadRowAt(index);
296     SetDeadPixelM(module,colM,row);
297   }
298   UInt_t nrNoisy = calibSPD->GetNrNoisy();
299   for (UInt_t index=0; index<nrNoisy; index++) {
300     UInt_t colM = calibSPD->GetNoisyColAt(index);
301     UInt_t row  = calibSPD->GetNoisyRowAt(index);
302     SetNoisyPixelM(module,colM,row);
303   }
304   spdEntry->SetOwner(kTRUE);
305   spdEntry->Clear();
306   return kTRUE;
307 }
308
309 Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromDB(Int_t runNr) {
310   // reads dead and noisy pixels from DB for given runNr
311   // note that you may want to clear the lists (if they are not empty) before reading
312   AliCDBManager* man = AliCDBManager::Instance();
313   if(!man->IsDefaultStorageSet()) {
314     man->SetDefaultStorage("local://$ALICE_ROOT");
315   }
316   AliCDBEntry *cdbEntry = man->Get("ITS/Calib/CalibSPD", runNr);
317   TObjArray* spdEntry;
318   if(cdbEntry) {
319     spdEntry = (TObjArray*)cdbEntry->GetObject();
320     if(!spdEntry) return kFALSE;
321   }
322   else {
323     Warning("AliITSOnlineCalibrationSPDhandler::ReadFromDB","Calibration for run %d not found in database.",runNr);
324     return kFALSE;
325   }
326   AliITSCalibrationSPD* calibSPD;
327   for (UInt_t module=0; module<240; module++) {
328     //    printf("Reading module %d\n",module);
329     calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module);
330     UInt_t nrDead = calibSPD->GetNrDead();
331     for (UInt_t index=0; index<nrDead; index++) {
332       UInt_t colM = calibSPD->GetDeadColAt(index);
333       UInt_t row  = calibSPD->GetDeadRowAt(index);
334       SetDeadPixelM(module,colM,row);
335     }
336     UInt_t nrNoisy = calibSPD->GetNrNoisy();
337     for (UInt_t index=0; index<nrNoisy; index++) {
338       UInt_t colM = calibSPD->GetNoisyColAt(index);
339       UInt_t row  = calibSPD->GetNoisyRowAt(index);
340       SetNoisyPixelM(module,colM,row);
341     }
342   }
343   spdEntry->SetOwner(kTRUE);
344   spdEntry->Clear();
345   return kTRUE;
346 }
347
348 Bool_t AliITSOnlineCalibrationSPDhandler::WriteToDB(Int_t runNrStart, Int_t runNrEnd) {
349   // writes dead and noisy pixels to DB for given runNr
350   // overwrites any previous entries
351   AliCDBManager* man = AliCDBManager::Instance();
352   if(!man->IsDefaultStorageSet()) {
353     man->SetDefaultStorage("local://$ALICE_ROOT");
354   }
355   AliCDBMetaData* metaData = new AliCDBMetaData();
356   metaData->SetResponsible("Henrik Tydesjo");
357   metaData->SetComment("Created by AliITSOnlineCalibrationSPDhandler.");
358   AliCDBId idCalSPD("ITS/Calib/CalibSPD",runNrStart,runNrEnd);
359   TObjArray* spdEntry = new TObjArray(240);
360   spdEntry->SetOwner(kTRUE);
361   for(UInt_t module=0; module<240; module++){
362     AliITSCalibrationSPD* calObj = new AliITSCalibrationSPD();
363     spdEntry->Add(calObj);
364   }
365   for(UInt_t module=0; module<240; module++){
366     ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetNrDead( GetNrDead(module) );
367     ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetDeadList( GetDeadArray(module) );
368     ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetNrNoisy( GetNrNoisy(module) );
369     ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetNoisyList( GetNoisyArray(module) );
370   }
371   AliCDBEntry* cdbEntry = new AliCDBEntry((TObject*)spdEntry,idCalSPD,metaData);
372   man->Put(cdbEntry);
373   delete spdEntry;
374   delete cdbEntry;
375   delete metaData;
376   return kTRUE;
377 }
378 #endif
379
380 void AliITSOnlineCalibrationSPDhandler::WriteToFiles() {
381   // write the lists of dead and noisy to files (only if there are >0 dead or noisy pixels)
382   for (UInt_t module=0; module<240; module++) {
383     if (fNrDead[module]+fNrNoisy[module] > 0) {
384       WriteToFile(module);
385     }
386   }
387 }
388 void AliITSOnlineCalibrationSPDhandler::WriteToFile(UInt_t module) {
389   // write the lists of dead and noisy for module to file
390   AliITSOnlineCalibrationSPD* calib = new AliITSOnlineCalibrationSPD();
391   calib->SetModuleNr(module);
392   calib->SetDeadList(GetDeadArray(module));
393   calib->SetNoisyList(GetNoisyArray(module));
394   calib->SetNrDead(GetNrDead(module));
395   calib->SetNrNoisy(GetNrNoisy(module));
396   TString fileName = Form("%s/SPD_DeadNoisy_%d.root",fFileLocation.Data(),module);
397   TFile file(fileName.Data(), "RECREATE");
398   file.WriteTObject(calib, "AliITSOnlineCalibrationSPD");
399   file.Close();
400   delete calib;
401 }
402 void AliITSOnlineCalibrationSPDhandler::WriteDeadToFiles() {
403   // write the lists of dead to files (only if there are >0 dead pixels)
404   for (UInt_t module=0; module<240; module++) {
405     if (fNrDead[module] > 0) {
406       WriteDeadToFile(module);
407     }
408   }
409 }
410 void AliITSOnlineCalibrationSPDhandler::WriteDeadToFile(UInt_t module) {
411   // write the lists of dead for module to file
412   AliITSOnlineCalibrationSPD* calib = new AliITSOnlineCalibrationSPD();
413   calib->SetModuleNr(module);
414   calib->SetDeadList(GetDeadArray(module));
415   calib->SetNrDead(GetNrDead(module));
416   TString fileName = Form("%s/SPD_DeadNoisy_%d.root",fFileLocation.Data(),module);
417   TFile file(fileName.Data(), "RECREATE");
418   file.WriteTObject(calib, "AliITSOnlineCalibrationSPD");
419   file.Close();
420   delete calib;
421 }
422 void AliITSOnlineCalibrationSPDhandler::WriteNoisyToFiles() {
423   // write the lists of noisy to files (only if there are >0 dead pixels)
424   for (UInt_t module=0; module<240; module++) {
425     if (fNrNoisy[module] > 0) {
426       printf("writing noisy to file for module %d\n",module);
427       WriteNoisyToFile(module);
428     }
429   }
430 }
431 void AliITSOnlineCalibrationSPDhandler::WriteNoisyToFile(UInt_t module) {
432   // write the lists of noisy for module to file
433   AliITSOnlineCalibrationSPD* calib = new AliITSOnlineCalibrationSPD();
434   calib->SetModuleNr(module);
435   calib->SetNoisyList(GetNoisyArray(module));
436   calib->SetNrNoisy(GetNrNoisy(module));
437   TString fileName = Form("%s/SPD_DeadNoisy_%d.root",fFileLocation.Data(),module);
438   TFile file(fileName.Data(), "RECREATE");
439   file.WriteTObject(calib, "AliITSOnlineCalibrationSPD");
440   file.Close();
441   delete calib;
442 }
443
444 TArrayI AliITSOnlineCalibrationSPDhandler::GetDeadArray(UInt_t module) {
445   // get a TArrayI of the dead pixels (format for the AliITSCalibrationSPD object)
446   TArrayI returnArray;
447   returnArray.Set(GetNrDead(module)*2);
448   fDeadPixelMap[module]->PrepareSerialize(); // for tree ordered values
449   for (UInt_t index=0; index<GetNrDead(module); index++) {
450     Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
451     Int_t colM = GetColMFromKey(key);
452     Int_t row = GetRowFromKey(key);
453     returnArray.AddAt(colM,index*2);
454     returnArray.AddAt(row,index*2+1);
455   }
456   return returnArray;
457 }
458 TArrayI AliITSOnlineCalibrationSPDhandler::GetNoisyArray(UInt_t module) {
459   // get a TArrayI of the noisy pixels (format for the AliITSCalibrationSPD object)
460   TArrayI returnArray;
461   returnArray.Set(GetNrNoisy(module)*2);
462   fNoisyPixelMap[module]->PrepareSerialize(); // for tree ordered values
463   for (UInt_t index=0; index<GetNrNoisy(module); index++) {
464     Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
465     Int_t colM = GetColMFromKey(key);
466     Int_t row = GetRowFromKey(key);
467     returnArray.AddAt(colM,index*2);
468     returnArray.AddAt(row,index*2+1);
469   }
470   return returnArray;
471 }
472
473 void AliITSOnlineCalibrationSPDhandler::ResetDead() {
474   // reset the dead pixel map
475   for (UInt_t module=0; module<240; module++) {
476     fNrDead[module]=0;
477     fDeadPixelMap[module]->Clear();
478   }
479 }
480
481 void AliITSOnlineCalibrationSPDhandler::ResetDeadForChip(UInt_t eqId, UInt_t hs, UInt_t chip) {
482   // clear the noisy pixels for this chip
483   UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
484   for (UInt_t col=0; col<32; col++) {
485     for (UInt_t row=0; row<256; row++) {
486       Int_t key = GetKey(eqId,hs,chip,col,row);
487       if (fDeadPixelMap[module]->Remove(key)) {
488         fNrDead[module]--;
489       }
490     }
491   }
492 }
493
494 Bool_t AliITSOnlineCalibrationSPDhandler::SetDeadPixel(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
495   // set a dead pixel, returns false if pixel is already dead
496   UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
497   Int_t key = GetKey(eqId,hs,chip,col,row);
498 //!!!  // if noisy we dont want to add it...
499 //!!!  if (fNoisyPixelMap[module]->Find(key) != NULL) return kFALSE;
500   if (fDeadPixelMap[module]->Insert(key,module)) {
501     fNrDead[module]++;
502     return kTRUE;
503   }
504   return kFALSE;
505 }
506
507 Bool_t AliITSOnlineCalibrationSPDhandler::SetDeadPixelM(UInt_t module, UInt_t colM, UInt_t row) {
508   // set a dead pixel, returns false if pixel is already dead
509   UInt_t eqId = GetEqIdFromOffline(module);
510   UInt_t hs = GetHSFromOffline(module);
511   UInt_t chip = GetChipFromOffline(module,colM);
512   UInt_t col = GetColFromOffline(colM);
513   Int_t key = GetKey(eqId,hs,chip,col,row);
514 //!!!  // if noisy we dont want to add it...
515 //!!!  if (fNoisyPixelMap[module]->Find(key) != NULL) return kFALSE;
516   if (fDeadPixelMap[module]->Insert(key,module)) {
517     fNrDead[module]++;
518     return kTRUE;
519   }
520   return kFALSE;
521 }
522
523 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDeadKey(Int_t key) const {
524   // is this pixel noisy?
525   UInt_t eqId = GetEqIdFromKey(key);
526   UInt_t hs = GetHSFromKey(key);
527   UInt_t chip = GetChipFromKey(key);
528   UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
529   return IsPixelDeadMKey(module,key);
530 }
531
532 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDeadMKey(UInt_t module, Int_t key) const {
533   // is this pixel dead?
534   if ( fDeadPixelMap[module]->Find(key) != NULL ) {
535     return kTRUE;
536   }
537   else {
538     return kFALSE;
539   }
540 }
541
542 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDead(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const {
543   // is the pixel dead?
544   UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
545   Int_t key = GetKey(eqId,hs,chip,col,row);
546   return IsPixelDeadMKey(module,key);
547 }
548
549 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDeadM(UInt_t module, UInt_t colM, UInt_t row) {
550   // is the pixel dead?
551   UInt_t eqId = GetEqIdFromOffline(module);
552   UInt_t hs = GetHSFromOffline(module);
553   UInt_t chip = GetChipFromOffline(module,colM);
554   UInt_t col = GetColFromOffline(colM);
555   Int_t key = GetKey(eqId,hs,chip,col,row);
556   return IsPixelDeadMKey(module,key);
557 }
558
559 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDead() const {
560   // returns the total nr of dead pixels
561   UInt_t nrDead = 0;
562   for (UInt_t module=0; module<240; module++) {
563     nrDead+=fNrDead[module];
564   }
565   return nrDead;
566 }
567
568 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDead(UInt_t module) const {
569   // returns the number of dead pixels for a certain module
570   if (module<240) {
571     return fNrDead[module];
572   }
573   else {
574     return 0;
575   }
576 }
577
578 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAt(UInt_t module, UInt_t index) {
579   // get eqId for the dead pixel at position index in list of dead
580   if (index<GetNrDead(module)) {
581     Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
582     return GetEqIdFromKey(key);
583   }
584   else {
585     Error("AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAt", "Index %d out of bounds.", index);
586     return 0;
587   }
588 }
589 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAt(UInt_t module, UInt_t index) {
590   // get hs for the dead pixel at position index in list of dead
591   if (index<GetNrDead(module)) {
592     Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
593     return GetHSFromKey(key);
594   }
595   else {
596     Error("AliITSOnlineCalibrationSPDhandler::GetDeadHSAt", "Index %d out of bounds.", index);
597     return 0;
598   }
599 }
600 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAt(UInt_t module, UInt_t index) {
601   // get chip for the dead pixel at position index in list of dead
602   if (index<GetNrDead(module)) {
603     Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
604     return GetChipFromKey(key);
605   }
606   else {
607     Error("AliITSOnlineCalibrationSPDhandler::GetDeadChipAt", "Index %d out of bounds.", index);
608     return 0;
609   }
610 }
611 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAt(UInt_t module, UInt_t index) {
612   // get column for the dead pixel at position index in list of dead
613   if (index<GetNrDead(module)) {
614     Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
615     return GetColFromKey(key);
616   }
617   else {
618     Error("AliITSOnlineCalibrationSPDhandler::GetDeadColAt", "Index %d out of bounds.", index);
619     return 0;
620   }
621 }
622 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAt(UInt_t module, UInt_t index) {
623   // get row for the dead pixel at position index in list of dead
624   if (index<GetNrDead(module)) {
625     Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
626     return GetRowFromKey(key);
627   }
628   else {
629     Error("AliITSOnlineCalibrationSPDhandler::GetDeadRowAt", "Index %d out of bounds.", index);
630     return 0;
631   }
632 }
633
634 void AliITSOnlineCalibrationSPDhandler::ResetNoisy() {
635   // clear the list of noisy pixels
636   for (UInt_t module=0; module<240; module++) {
637     fNrNoisy[module]=0;
638     fNoisyPixelMap[module]->Clear();
639   }
640 }
641 void AliITSOnlineCalibrationSPDhandler::ResetNoisyForChip(UInt_t eqId, UInt_t hs, UInt_t chip) {
642   // clear the noisy pixels for this chip
643   UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
644   for (UInt_t col=0; col<32; col++) {
645     for (UInt_t row=0; row<256; row++) {
646       Int_t key = GetKey(eqId,hs,chip,col,row);
647       if (fNoisyPixelMap[module]->Remove(key)) {
648         fNrNoisy[module]--;
649       }
650     }
651   }
652 }
653
654
655 Bool_t AliITSOnlineCalibrationSPDhandler::SetNoisyPixel(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
656   // set a noisy pixel, returns false if already there
657   UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
658   Int_t key = GetKey(eqId,hs,chip,col,row);
659 //!!!  // if dead before - remove from the dead list 
660 //!!!  UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
661 //!!!  if (fDeadPixelMap.Remove(key)) {
662 //!!!    fNrDead[module]--;
663 //!!!  }
664   if (fNoisyPixelMap[module]->Insert(key,col)) {
665     fNrNoisy[module]++;
666     return kTRUE;
667   }
668   return kFALSE;
669 }
670
671 Bool_t AliITSOnlineCalibrationSPDhandler::SetNoisyPixelM(UInt_t module, UInt_t colM, UInt_t row) {
672   // set a noisy pixel, returns false if already there
673   UInt_t eqId = GetEqIdFromOffline(module);
674   UInt_t hs = GetHSFromOffline(module);
675   UInt_t chip = GetChipFromOffline(module,colM);
676   UInt_t col = GetColFromOffline(colM);
677   Int_t key = GetKey(eqId,hs,chip,col,row);
678 //!!!  // if dead before - remove from the dead list 
679 //!!!  if (fDeadPixelMap[module]->Remove(key)) {
680 //!!!    fNrDead[module]--;
681 //!!!  }
682   if (fNoisyPixelMap[module]->Insert(key,col)) {
683     fNrNoisy[module]++;
684     return kTRUE;
685   }
686   return kFALSE;
687 }
688
689 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyKey(Int_t key) const {
690   // is this pixel noisy?
691   UInt_t eqId = GetEqIdFromKey(key);
692   UInt_t hs = GetHSFromKey(key);
693   UInt_t chip = GetChipFromKey(key);
694   UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
695   return IsPixelNoisyMKey(module,key);
696 }
697
698 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyMKey(UInt_t module, Int_t key) const {
699   // is this pixel noisy?
700   if ( fNoisyPixelMap[module]->Find(key) != NULL ) {
701     return kTRUE;
702   }
703   else {
704     return kFALSE;
705   }
706 }
707
708 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisy(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const {
709   // is this pixel noisy?
710   UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
711   Int_t key = GetKey(eqId,hs,chip,col,row);
712   return IsPixelNoisyMKey(module,key);
713 }
714
715 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyM(UInt_t module, UInt_t colM, UInt_t row) {
716   // is this pixel noisy?
717   UInt_t eqId = GetEqIdFromOffline(module);
718   UInt_t hs = GetHSFromOffline(module);
719   UInt_t chip = GetChipFromOffline(module,colM);
720   UInt_t col = GetColFromOffline(colM);
721   Int_t key = GetKey(eqId,hs,chip,col,row);
722   return IsPixelNoisyMKey(module,key);
723 }
724
725 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisy() const {
726   // returns the total nr of noisy pixels
727   UInt_t nrNoisy = 0;
728   for (UInt_t module=0; module<240; module++) {
729     nrNoisy+=fNrNoisy[module];
730   }
731   return nrNoisy;
732 }
733
734 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisy(UInt_t module) const {
735 // returns the number of noisy pixels for a certain module
736   if (module<240) {
737     return fNrNoisy[module];
738   }
739   else {
740     return 0;
741   }
742 }
743
744 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAt(UInt_t module, UInt_t index) {
745   // get chip for the noisy pixel at position index in list of noisy
746   if (index<GetNrNoisy(module)) {
747     Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
748     return GetEqIdFromKey(key);
749   }
750   else {
751     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAt", "Index %d out of bounds.", index);
752     return 0;
753   }
754 }
755 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAt(UInt_t module, UInt_t index) {
756   // get chip for the noisy pixel at position index in list of noisy
757   if (index<GetNrNoisy(module)) {
758     Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
759     return GetHSFromKey(key);
760   }
761   else {
762     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyHSAt", "Index %d out of bounds.", index);
763     return 0;
764   }
765 }
766 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAt(UInt_t module, UInt_t index) {
767   // get chip for the noisy pixel at position index in list of noisy
768   if (index<GetNrNoisy(module)) {
769     Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
770     return GetChipFromKey(key);
771   }
772   else {
773     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyChipAt", "Index %d out of bounds.", index);
774     return 0;
775   }
776 }
777 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAt(UInt_t module, UInt_t index) {
778   // get column for the noisy pixel at position index in list of noisy
779   if (index<GetNrNoisy(module)) {
780     Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
781     return GetColFromKey(key);
782   }
783   else {
784     Warning("AliITSOnlineCalibrationSPDhandler::GetNoisyColAt", "Index %d out of bounds.", index);
785     return 0;
786   }
787 }
788 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAt(UInt_t module, UInt_t index) {
789   // get row for the noisy pixel at position index in list of noisy
790   if (index<GetNrNoisy(module)) {
791     Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
792     return GetRowFromKey(key);
793   }
794   else {
795     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyRowAt", "Index %d out of bounds.", index);
796     return 0;
797   }
798 }
799
800 void AliITSOnlineCalibrationSPDhandler::PrintDead() const {
801   // print the dead pixels to screen
802   printf("-----------------------------------\n");
803   printf("Dead Pixels: (eqId,hs,chip,col,row)\n");
804   printf("-----------------------------------\n");
805   for (UInt_t module=0; module<240; module++) {
806     for (UInt_t index=0; index<GetNrDead(module); index++) {
807       Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
808       UInt_t eqId = GetEqIdFromKey(key);
809       UInt_t hs = GetHSFromKey(key);
810       UInt_t chip = GetChipFromKey(key);
811       UInt_t col = GetColFromKey(key);
812       UInt_t row = GetRowFromKey(key);
813       printf("%d,%d,%d,%d,%d\n",eqId,hs,chip,col,row);
814     }
815   }
816 }
817
818 void AliITSOnlineCalibrationSPDhandler::PrintNoisy() const {
819   // print the dead pixels to screen
820   printf("-----------------------------------\n");
821   printf("Noisy Pixels: (eqId,hs,chip,col,row)\n");
822   printf("-----------------------------------\n");
823   for (UInt_t module=0; module<240; module++) {
824     for (UInt_t index=0; index<GetNrNoisy(module); index++) {
825       Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
826       UInt_t eqId = GetEqIdFromKey(key);
827       UInt_t hs = GetHSFromKey(key);
828       UInt_t chip = GetChipFromKey(key);
829       UInt_t col = GetColFromKey(key);
830       UInt_t row = GetRowFromKey(key);
831       printf("%d,%d,%d,%d,%d\n",eqId,hs,chip,col,row);
832     }
833   }
834 }
835
836 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadDiff(AliITSOnlineCalibrationSPDhandler* other) const {
837   // returns nr of dead in this' lists and not in other's lists
838   UInt_t returnval=0;
839   for (UInt_t module=0; module<240; module++) {
840     for (UInt_t ind1=0; ind1<fNrDead[module]; ind1++) {
841       Int_t key = fDeadPixelMap[module]->GetKeyIndex(ind1);
842       UInt_t eqId = GetEqIdFromKey(key);
843       UInt_t hs = GetHSFromKey(key);
844       UInt_t chip = GetChipFromKey(key);
845       UInt_t col = GetColFromKey(key);
846       UInt_t row = GetRowFromKey(key);
847       if (!(other->IsPixelDead(eqId,hs,chip,col,row))) {
848         returnval++;
849       }
850     }
851   }
852   return returnval;
853 }
854
855 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisyDiff(AliITSOnlineCalibrationSPDhandler* other) const {
856   // returns nr of noisy in this' lists and not in other's lists
857   UInt_t returnval=0;
858   for (UInt_t module=0; module<240; module++) {
859     for (UInt_t ind1=0; ind1<fNrNoisy[module]; ind1++) {
860       Int_t key = fNoisyPixelMap[module]->GetKeyIndex(ind1);
861       UInt_t eqId = GetEqIdFromKey(key);
862       UInt_t hs = GetHSFromKey(key);
863       UInt_t chip = GetChipFromKey(key);
864       UInt_t col = GetColFromKey(key);
865       UInt_t row = GetRowFromKey(key);
866       if (!(other->IsPixelNoisy(eqId,hs,chip,col,row))) {
867         returnval++;
868       }
869     }
870   }
871   return returnval;
872 }
873
874 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDiff(AliITSOnlineCalibrationSPDhandler* other) const {
875   // returns nr of dead/noisy in this' lists and not in other's lists
876   return GetNrDeadDiff(other) + GetNrNoisyDiff(other);
877 }
878
879 AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetDiff(AliITSOnlineCalibrationSPDhandler* other) const {
880   // returns handler with dead/noisy in this' lists, except for those in other's lists
881   AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler();
882   for (UInt_t module=0; module<240; module++) {
883     for (UInt_t ind1=0; ind1<fNrDead[module]; ind1++) {
884       Int_t key = fDeadPixelMap[module]->GetKeyIndex(ind1);
885       UInt_t eqId = GetEqIdFromKey(key);
886       UInt_t hs = GetHSFromKey(key);
887       UInt_t chip = GetChipFromKey(key);
888       UInt_t col = GetColFromKey(key);
889       UInt_t row = GetRowFromKey(key);
890       if (!(other->IsPixelDead(eqId,hs,chip,col,row))) {
891         newHandler->SetDeadPixel(eqId,hs,chip,col,row);
892       }
893     }
894     for (UInt_t ind2=0; ind2<fNrNoisy[module]; ind2++) {
895       Int_t key = fNoisyPixelMap[module]->GetKeyIndex(ind2);
896       UInt_t eqId = GetEqIdFromKey(key);
897       UInt_t hs = GetHSFromKey(key);
898       UInt_t chip = GetChipFromKey(key);
899       UInt_t col = GetColFromKey(key);
900       UInt_t row = GetRowFromKey(key);
901       if (!(other->IsPixelNoisy(eqId,hs,chip,col,row))) {
902         newHandler->SetNoisyPixel(eqId,hs,chip,col,row);
903       }
904     }
905   }
906   return newHandler;
907 }
908
909 AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetDeadDiff(AliITSOnlineCalibrationSPDhandler* other) const {
910   // returns handler with dead in this' lists, except for those in other's lists
911   AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler();
912   for (UInt_t module=0; module<240; module++) {
913     for (UInt_t ind1=0; ind1<fNrDead[module]; ind1++) {
914       Int_t key = fDeadPixelMap[module]->GetKeyIndex(ind1);
915       UInt_t eqId = GetEqIdFromKey(key);
916       UInt_t hs = GetHSFromKey(key);
917       UInt_t chip = GetChipFromKey(key);
918       UInt_t col = GetColFromKey(key);
919       UInt_t row = GetRowFromKey(key);
920       if (!(other->IsPixelDead(eqId,hs,chip,col,row))) {
921         newHandler->SetDeadPixel(eqId,hs,chip,col,row);
922       }
923     }
924   }
925   return newHandler;
926 }
927
928 AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetNoisyDiff(AliITSOnlineCalibrationSPDhandler* other) const {
929   // returns handler with noisy in this' lists, except for those in other's lists
930   AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler();
931   for (UInt_t module=0; module<240; module++) {
932     for (UInt_t ind2=0; ind2<fNrNoisy[module]; ind2++) {
933       Int_t key = fNoisyPixelMap[module]->GetKeyIndex(ind2);
934       UInt_t eqId = GetEqIdFromKey(key);
935       UInt_t hs = GetHSFromKey(key);
936       UInt_t chip = GetChipFromKey(key);
937       UInt_t col = GetColFromKey(key);
938       UInt_t row = GetRowFromKey(key);
939       if (!(other->IsPixelNoisy(eqId,hs,chip,col,row))) {
940         newHandler->SetNoisyPixel(eqId,hs,chip,col,row);
941       }
942     }
943   }
944   return newHandler;
945 }
946
947 void AliITSOnlineCalibrationSPDhandler::InitModuleMaps() {
948   // initializes the module mapping arrays needed for the methods below (GetEqIdFromOffline etc.)
949   for (UInt_t iDDL=0; iDDL<20; iDDL++) {
950     for (UInt_t iModule=0; iModule<12; iModule++) {
951       UInt_t module = AliITSRawStreamSPD::GetModuleNumber(iDDL,iModule);
952       fiDDL[module] = iDDL;
953       fiModule[module] = iModule;
954     }
955   }
956 }
957
958 void AliITSOnlineCalibrationSPDhandler::GenerateDCSConfigFile(const Char_t* fileName) {
959   // generates an ascii file in the format as the one produced by online da (but with dummy runNr=0)
960   ofstream dcsfile;
961   dcsfile.open(fileName);
962   dcsfile << "[SPD SCAN]\n";
963   dcsfile << "RunNumber=" << "0" << "\n"; // dummy value
964   dcsfile << "Type=" << "4" << "\n";
965   dcsfile << "Router=" << "0" << "\n"; // dummy value
966   dcsfile << "ActualDetCoonfiguration=" << "0,-1,-1\n"; // dummy values
967   dcsfile << "[NOISY]\n";
968   for (UInt_t module=0; module<240; module++) {
969     UInt_t headkey=20*10*6;
970     for (UInt_t ind=0; ind<fNrNoisy[module]; ind++) {
971       UInt_t newkey = GetNoisyEqIdAt(module,ind)*10*6 +
972         GetNoisyHSAt(module,ind)*10 +
973         GetNoisyChipAt(module,ind);
974       if (newkey!=headkey) { // print eqId,hs,chip header
975         headkey = newkey;
976         dcsfile << "-" << newkey/(6*10) << "," << (newkey%(6*10))/10 << "," << (newkey%(6*10))%10 << "\n";
977       }
978       dcsfile << GetNoisyColAt(module,ind) << "," << GetNoisyRowAt(module,ind) << "\n";
979     }
980   }
981   dcsfile.close();
982 }
983
984 UInt_t AliITSOnlineCalibrationSPDhandler::GetEqIdFromOffline(UInt_t module) {
985   // module to eqId mapping
986   if (!fModuleMapInited) InitModuleMaps();
987   return fiDDL[module];
988 }
989 UInt_t AliITSOnlineCalibrationSPDhandler::GetHSFromOffline(UInt_t module) {
990   // module to hs mapping
991   if (!fModuleMapInited) InitModuleMaps();
992   return fiModule[module]/2;
993 }
994 UInt_t AliITSOnlineCalibrationSPDhandler::GetChipFromOffline(UInt_t module, UInt_t colM) {
995   // module,colM to chip mapping
996   if (!fModuleMapInited) InitModuleMaps();
997   return colM/32 + 5*(fiModule[module]%2);
998 }
999 UInt_t AliITSOnlineCalibrationSPDhandler::GetColFromOffline(UInt_t colM) const {
1000   // colM to col mapping
1001   return colM%32;
1002 }