538a1d115dd0b25f0c3d8c18a42b5ff94f8ac508
[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
364     // *** this is temporarily hard coded here ********************
365     // (later these parameters will be separated from the cal.obj.)
366     calObj->SetThresholds(3000, 250);
367     calObj->SetBiasVoltage(18.182);
368     calObj->SetNoiseParam(0,0);
369     // CouplingRaw changed to 0.055 (fine tuning), was 0.047 in PDC06
370     calObj->SetCouplingParam(0.,0.055);
371     // *** remove later...
372     // ************************************************************
373
374     spdEntry->Add(calObj);
375   }
376   for(UInt_t module=0; module<240; module++){
377     ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetNrDead( GetNrDead(module) );
378     ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetDeadList( GetDeadArray(module) );
379     ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetNrNoisy( GetNrNoisy(module) );
380     ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetNoisyList( GetNoisyArray(module) );
381   }
382   AliCDBEntry* cdbEntry = new AliCDBEntry((TObject*)spdEntry,idCalSPD,metaData);
383   man->Put(cdbEntry);
384   delete spdEntry;
385   delete cdbEntry;
386   delete metaData;
387   return kTRUE;
388 }
389 #endif
390
391 void AliITSOnlineCalibrationSPDhandler::WriteToFilesAlways() {
392   // write the lists of dead and noisy to files (only if there are >0 dead or noisy pixels)
393   for (UInt_t module=0; module<240; module++) {
394     WriteToFile(module);
395   }
396 }
397 void AliITSOnlineCalibrationSPDhandler::WriteToFiles() {
398   // write the lists of dead and noisy to files (only if there are >0 dead or noisy pixels)
399   for (UInt_t module=0; module<240; module++) {
400     if (fNrDead[module]+fNrNoisy[module] > 0) {
401       WriteToFile(module);
402     }
403   }
404 }
405 void AliITSOnlineCalibrationSPDhandler::WriteToFile(UInt_t module) {
406   // write the lists of dead and noisy for module to file
407   AliITSOnlineCalibrationSPD* calib = new AliITSOnlineCalibrationSPD();
408   calib->SetModuleNr(module);
409   calib->SetDeadList(GetDeadArray(module));
410   calib->SetNoisyList(GetNoisyArray(module));
411   calib->SetNrDead(GetNrDead(module));
412   calib->SetNrNoisy(GetNrNoisy(module));
413   TString fileName = Form("%s/SPD_DeadNoisy_%d.root",fFileLocation.Data(),module);
414   TFile file(fileName.Data(), "RECREATE");
415   file.WriteTObject(calib, "AliITSOnlineCalibrationSPD");
416   file.Close();
417   delete calib;
418 }
419 void AliITSOnlineCalibrationSPDhandler::WriteDeadToFiles() {
420   // write the lists of dead to files (only if there are >0 dead pixels)
421   for (UInt_t module=0; module<240; module++) {
422     if (fNrDead[module] > 0) {
423       WriteDeadToFile(module);
424     }
425   }
426 }
427 void AliITSOnlineCalibrationSPDhandler::WriteDeadToFile(UInt_t module) {
428   // write the lists of dead for module to file
429   AliITSOnlineCalibrationSPD* calib = new AliITSOnlineCalibrationSPD();
430   calib->SetModuleNr(module);
431   calib->SetDeadList(GetDeadArray(module));
432   calib->SetNrDead(GetNrDead(module));
433   TString fileName = Form("%s/SPD_DeadNoisy_%d.root",fFileLocation.Data(),module);
434   TFile file(fileName.Data(), "RECREATE");
435   file.WriteTObject(calib, "AliITSOnlineCalibrationSPD");
436   file.Close();
437   delete calib;
438 }
439 void AliITSOnlineCalibrationSPDhandler::WriteNoisyToFiles() {
440   // write the lists of noisy to files (only if there are >0 dead pixels)
441   for (UInt_t module=0; module<240; module++) {
442     if (fNrNoisy[module] > 0) {
443       printf("writing noisy to file for module %d\n",module);
444       WriteNoisyToFile(module);
445     }
446   }
447 }
448 void AliITSOnlineCalibrationSPDhandler::WriteNoisyToFile(UInt_t module) {
449   // write the lists of noisy for module to file
450   AliITSOnlineCalibrationSPD* calib = new AliITSOnlineCalibrationSPD();
451   calib->SetModuleNr(module);
452   calib->SetNoisyList(GetNoisyArray(module));
453   calib->SetNrNoisy(GetNrNoisy(module));
454   TString fileName = Form("%s/SPD_DeadNoisy_%d.root",fFileLocation.Data(),module);
455   TFile file(fileName.Data(), "RECREATE");
456   file.WriteTObject(calib, "AliITSOnlineCalibrationSPD");
457   file.Close();
458   delete calib;
459 }
460
461 TArrayI AliITSOnlineCalibrationSPDhandler::GetDeadArray(UInt_t module) {
462   // get a TArrayI of the dead pixels (format for the AliITSCalibrationSPD object)
463   TArrayI returnArray;
464   returnArray.Set(GetNrDead(module)*2);
465   fDeadPixelMap[module]->PrepareSerialize(); // for tree ordered values
466   for (UInt_t index=0; index<GetNrDead(module); index++) {
467     Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
468     Int_t colM = GetColMFromKey(key);
469     Int_t row = GetRowFromKey(key);
470     returnArray.AddAt(colM,index*2);
471     returnArray.AddAt(row,index*2+1);
472   }
473   return returnArray;
474 }
475 TArrayI AliITSOnlineCalibrationSPDhandler::GetNoisyArray(UInt_t module) {
476   // get a TArrayI of the noisy pixels (format for the AliITSCalibrationSPD object)
477   TArrayI returnArray;
478   returnArray.Set(GetNrNoisy(module)*2);
479   fNoisyPixelMap[module]->PrepareSerialize(); // for tree ordered values
480   for (UInt_t index=0; index<GetNrNoisy(module); index++) {
481     Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
482     Int_t colM = GetColMFromKey(key);
483     Int_t row = GetRowFromKey(key);
484     returnArray.AddAt(colM,index*2);
485     returnArray.AddAt(row,index*2+1);
486   }
487   return returnArray;
488 }
489
490 void AliITSOnlineCalibrationSPDhandler::ResetDead() {
491   // reset the dead pixel map
492   for (UInt_t module=0; module<240; module++) {
493     fNrDead[module]=0;
494     fDeadPixelMap[module]->Clear();
495   }
496 }
497
498 void AliITSOnlineCalibrationSPDhandler::ResetDeadForChip(UInt_t eqId, UInt_t hs, UInt_t chip) {
499   // clear the noisy pixels for this chip
500   UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
501   for (UInt_t col=0; col<32; col++) {
502     for (UInt_t row=0; row<256; row++) {
503       Int_t key = GetKey(eqId,hs,chip,col,row);
504       if (fDeadPixelMap[module]->Remove(key)) {
505         fNrDead[module]--;
506       }
507     }
508   }
509 }
510
511 Bool_t AliITSOnlineCalibrationSPDhandler::SetDeadPixel(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
512   // set a dead pixel, returns false if pixel is already dead
513   UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
514   Int_t key = GetKey(eqId,hs,chip,col,row);
515 //!!!  // if noisy we dont want to add it...
516 //!!!  if (fNoisyPixelMap[module]->Find(key) != NULL) return kFALSE;
517   if (fDeadPixelMap[module]->Insert(key,module)) {
518     fNrDead[module]++;
519     return kTRUE;
520   }
521   return kFALSE;
522 }
523
524 Bool_t AliITSOnlineCalibrationSPDhandler::SetDeadPixelM(UInt_t module, UInt_t colM, UInt_t row) {
525   // set a dead pixel, returns false if pixel is already dead
526   UInt_t eqId = GetEqIdFromOffline(module);
527   UInt_t hs = GetHSFromOffline(module);
528   UInt_t chip = GetChipFromOffline(module,colM);
529   UInt_t col = GetColFromOffline(colM);
530   Int_t key = GetKey(eqId,hs,chip,col,row);
531 //!!!  // if noisy we dont want to add it...
532 //!!!  if (fNoisyPixelMap[module]->Find(key) != NULL) return kFALSE;
533   if (fDeadPixelMap[module]->Insert(key,module)) {
534     fNrDead[module]++;
535     return kTRUE;
536   }
537   return kFALSE;
538 }
539
540 Bool_t AliITSOnlineCalibrationSPDhandler::UnSetDeadPixel(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
541   // unset a dead pixel, returns false if pixel is not dead
542   UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
543   Int_t key = GetKey(eqId,hs,chip,col,row);
544   if (fDeadPixelMap[module]->Remove(key)) {
545     fNrDead[module]--;
546     return kTRUE;
547   }
548   return kFALSE;
549 }
550
551 Bool_t AliITSOnlineCalibrationSPDhandler::UnSetDeadPixelM(UInt_t module, UInt_t colM, UInt_t row) {
552   // unset a dead pixel, returns false if pixel is not dead
553   UInt_t eqId = GetEqIdFromOffline(module);
554   UInt_t hs = GetHSFromOffline(module);
555   UInt_t chip = GetChipFromOffline(module,colM);
556   UInt_t col = GetColFromOffline(colM);
557   Int_t key = GetKey(eqId,hs,chip,col,row);
558   if (fDeadPixelMap[module]->Remove(key)) {
559     fNrDead[module]--;
560     return kTRUE;
561   }
562   return kFALSE;
563 }
564
565 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDeadKey(Int_t key) const {
566   // is this pixel noisy?
567   UInt_t eqId = GetEqIdFromKey(key);
568   UInt_t hs = GetHSFromKey(key);
569   UInt_t chip = GetChipFromKey(key);
570   UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
571   return IsPixelDeadMKey(module,key);
572 }
573
574 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDeadMKey(UInt_t module, Int_t key) const {
575   // is this pixel dead?
576   if ( fDeadPixelMap[module]->Find(key) != NULL ) {
577     return kTRUE;
578   }
579   else {
580     return kFALSE;
581   }
582 }
583
584 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDead(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const {
585   // is the pixel dead?
586   UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
587   Int_t key = GetKey(eqId,hs,chip,col,row);
588   return IsPixelDeadMKey(module,key);
589 }
590
591 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDeadM(UInt_t module, UInt_t colM, UInt_t row) {
592   // is the pixel dead?
593   UInt_t eqId = GetEqIdFromOffline(module);
594   UInt_t hs = GetHSFromOffline(module);
595   UInt_t chip = GetChipFromOffline(module,colM);
596   UInt_t col = GetColFromOffline(colM);
597   Int_t key = GetKey(eqId,hs,chip,col,row);
598   return IsPixelDeadMKey(module,key);
599 }
600
601 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDead() const {
602   // returns the total nr of dead pixels
603   UInt_t nrDead = 0;
604   for (UInt_t module=0; module<240; module++) {
605     nrDead+=fNrDead[module];
606   }
607   return nrDead;
608 }
609
610 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDead(UInt_t module) const {
611   // returns the number of dead pixels for a certain module
612   if (module<240) {
613     return fNrDead[module];
614   }
615   else {
616     return 0;
617   }
618 }
619
620 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAt(UInt_t module, UInt_t index) {
621   // get eqId for the dead pixel at position index in list of dead
622   if (index<GetNrDead(module)) {
623     Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
624     return GetEqIdFromKey(key);
625   }
626   else {
627     Error("AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAt", "Index %d out of bounds.", index);
628     return 0;
629   }
630 }
631 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAt(UInt_t module, UInt_t index) {
632   // get hs for the dead pixel at position index in list of dead
633   if (index<GetNrDead(module)) {
634     Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
635     return GetHSFromKey(key);
636   }
637   else {
638     Error("AliITSOnlineCalibrationSPDhandler::GetDeadHSAt", "Index %d out of bounds.", index);
639     return 0;
640   }
641 }
642 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAt(UInt_t module, UInt_t index) {
643   // get chip for the dead pixel at position index in list of dead
644   if (index<GetNrDead(module)) {
645     Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
646     return GetChipFromKey(key);
647   }
648   else {
649     Error("AliITSOnlineCalibrationSPDhandler::GetDeadChipAt", "Index %d out of bounds.", index);
650     return 0;
651   }
652 }
653 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAt(UInt_t module, UInt_t index) {
654   // get column for the dead pixel at position index in list of dead
655   if (index<GetNrDead(module)) {
656     Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
657     return GetColFromKey(key);
658   }
659   else {
660     Error("AliITSOnlineCalibrationSPDhandler::GetDeadColAt", "Index %d out of bounds.", index);
661     return 0;
662   }
663 }
664 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAt(UInt_t module, UInt_t index) {
665   // get row for the dead pixel at position index in list of dead
666   if (index<GetNrDead(module)) {
667     Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
668     return GetRowFromKey(key);
669   }
670   else {
671     Error("AliITSOnlineCalibrationSPDhandler::GetDeadRowAt", "Index %d out of bounds.", index);
672     return 0;
673   }
674 }
675
676 void AliITSOnlineCalibrationSPDhandler::ResetNoisy() {
677   // clear the list of noisy pixels
678   for (UInt_t module=0; module<240; module++) {
679     fNrNoisy[module]=0;
680     fNoisyPixelMap[module]->Clear();
681   }
682 }
683 void AliITSOnlineCalibrationSPDhandler::ResetNoisyForChip(UInt_t eqId, UInt_t hs, UInt_t chip) {
684   // clear the noisy pixels for this chip
685   UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
686   for (UInt_t col=0; col<32; col++) {
687     for (UInt_t row=0; row<256; row++) {
688       Int_t key = GetKey(eqId,hs,chip,col,row);
689       if (fNoisyPixelMap[module]->Remove(key)) {
690         fNrNoisy[module]--;
691       }
692     }
693   }
694 }
695
696
697 Bool_t AliITSOnlineCalibrationSPDhandler::SetNoisyPixel(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
698   // set a noisy pixel, returns false if already there
699   UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
700   Int_t key = GetKey(eqId,hs,chip,col,row);
701 //!!!  // if dead before - remove from the dead list 
702 //!!!  UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
703 //!!!  if (fDeadPixelMap.Remove(key)) {
704 //!!!    fNrDead[module]--;
705 //!!!  }
706   if (fNoisyPixelMap[module]->Insert(key,col)) {
707     fNrNoisy[module]++;
708     return kTRUE;
709   }
710   return kFALSE;
711 }
712
713 Bool_t AliITSOnlineCalibrationSPDhandler::SetNoisyPixelM(UInt_t module, UInt_t colM, UInt_t row) {
714   // set a noisy pixel, returns false if already there
715   UInt_t eqId = GetEqIdFromOffline(module);
716   UInt_t hs = GetHSFromOffline(module);
717   UInt_t chip = GetChipFromOffline(module,colM);
718   UInt_t col = GetColFromOffline(colM);
719   Int_t key = GetKey(eqId,hs,chip,col,row);
720 //!!!  // if dead before - remove from the dead list 
721 //!!!  if (fDeadPixelMap[module]->Remove(key)) {
722 //!!!    fNrDead[module]--;
723 //!!!  }
724   if (fNoisyPixelMap[module]->Insert(key,col)) {
725     fNrNoisy[module]++;
726     return kTRUE;
727   }
728   return kFALSE;
729 }
730
731 Bool_t AliITSOnlineCalibrationSPDhandler::UnSetNoisyPixel(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
732   // unset a noisy pixel, returns false if not there
733   UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
734   Int_t key = GetKey(eqId,hs,chip,col,row);
735   if (fNoisyPixelMap[module]->Remove(key)) {
736     fNrNoisy[module]--;
737     return kTRUE;
738   }
739   return kFALSE;
740 }
741
742 Bool_t AliITSOnlineCalibrationSPDhandler::UnSetNoisyPixelM(UInt_t module, UInt_t colM, UInt_t row) {
743   // unset a noisy pixel, returns false if not there
744   UInt_t eqId = GetEqIdFromOffline(module);
745   UInt_t hs = GetHSFromOffline(module);
746   UInt_t chip = GetChipFromOffline(module,colM);
747   UInt_t col = GetColFromOffline(colM);
748   Int_t key = GetKey(eqId,hs,chip,col,row);
749   if (fNoisyPixelMap[module]->Remove(key)) {
750     fNrNoisy[module]--;
751     return kTRUE;
752   }
753   return kFALSE;
754 }
755
756 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyKey(Int_t key) const {
757   // is this pixel noisy?
758   UInt_t eqId = GetEqIdFromKey(key);
759   UInt_t hs = GetHSFromKey(key);
760   UInt_t chip = GetChipFromKey(key);
761   UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
762   return IsPixelNoisyMKey(module,key);
763 }
764
765 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyMKey(UInt_t module, Int_t key) const {
766   // is this pixel noisy?
767   if ( fNoisyPixelMap[module]->Find(key) != NULL ) {
768     return kTRUE;
769   }
770   else {
771     return kFALSE;
772   }
773 }
774
775 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisy(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const {
776   // is this pixel noisy?
777   UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
778   Int_t key = GetKey(eqId,hs,chip,col,row);
779   return IsPixelNoisyMKey(module,key);
780 }
781
782 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyM(UInt_t module, UInt_t colM, UInt_t row) {
783   // is this pixel noisy?
784   UInt_t eqId = GetEqIdFromOffline(module);
785   UInt_t hs = GetHSFromOffline(module);
786   UInt_t chip = GetChipFromOffline(module,colM);
787   UInt_t col = GetColFromOffline(colM);
788   Int_t key = GetKey(eqId,hs,chip,col,row);
789   return IsPixelNoisyMKey(module,key);
790 }
791
792 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisy() const {
793   // returns the total nr of noisy pixels
794   UInt_t nrNoisy = 0;
795   for (UInt_t module=0; module<240; module++) {
796     nrNoisy+=fNrNoisy[module];
797   }
798   return nrNoisy;
799 }
800
801 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisy(UInt_t module) const {
802 // returns the number of noisy pixels for a certain module
803   if (module<240) {
804     return fNrNoisy[module];
805   }
806   else {
807     return 0;
808   }
809 }
810
811 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAt(UInt_t module, UInt_t index) {
812   // get chip for the noisy pixel at position index in list of noisy
813   if (index<GetNrNoisy(module)) {
814     Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
815     return GetEqIdFromKey(key);
816   }
817   else {
818     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAt", "Index %d out of bounds.", index);
819     return 0;
820   }
821 }
822 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAt(UInt_t module, UInt_t index) {
823   // get chip for the noisy pixel at position index in list of noisy
824   if (index<GetNrNoisy(module)) {
825     Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
826     return GetHSFromKey(key);
827   }
828   else {
829     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyHSAt", "Index %d out of bounds.", index);
830     return 0;
831   }
832 }
833 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAt(UInt_t module, UInt_t index) {
834   // get chip for the noisy pixel at position index in list of noisy
835   if (index<GetNrNoisy(module)) {
836     Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
837     return GetChipFromKey(key);
838   }
839   else {
840     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyChipAt", "Index %d out of bounds.", index);
841     return 0;
842   }
843 }
844 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAt(UInt_t module, UInt_t index) {
845   // get column for the noisy pixel at position index in list of noisy
846   if (index<GetNrNoisy(module)) {
847     Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
848     return GetColFromKey(key);
849   }
850   else {
851     Warning("AliITSOnlineCalibrationSPDhandler::GetNoisyColAt", "Index %d out of bounds.", index);
852     return 0;
853   }
854 }
855 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAt(UInt_t module, UInt_t index) {
856   // get row for the noisy pixel at position index in list of noisy
857   if (index<GetNrNoisy(module)) {
858     Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
859     return GetRowFromKey(key);
860   }
861   else {
862     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyRowAt", "Index %d out of bounds.", index);
863     return 0;
864   }
865 }
866
867 void AliITSOnlineCalibrationSPDhandler::PrintDead() const {
868   // print the dead pixels to screen
869   printf("-----------------------------------\n");
870   printf("Dead Pixels: (eqId,hs,chip,col,row)\n");
871   printf("-----------------------------------\n");
872   for (UInt_t module=0; module<240; module++) {
873     for (UInt_t index=0; index<GetNrDead(module); index++) {
874       Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
875       UInt_t eqId = GetEqIdFromKey(key);
876       UInt_t hs = GetHSFromKey(key);
877       UInt_t chip = GetChipFromKey(key);
878       UInt_t col = GetColFromKey(key);
879       UInt_t row = GetRowFromKey(key);
880       printf("%d,%d,%d,%d,%d\n",eqId,hs,chip,col,row);
881     }
882   }
883 }
884
885 void AliITSOnlineCalibrationSPDhandler::PrintNoisy() const {
886   // print the dead pixels to screen
887   printf("-----------------------------------\n");
888   printf("Noisy Pixels: (eqId,hs,chip,col,row)\n");
889   printf("-----------------------------------\n");
890   for (UInt_t module=0; module<240; module++) {
891     for (UInt_t index=0; index<GetNrNoisy(module); index++) {
892       Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
893       UInt_t eqId = GetEqIdFromKey(key);
894       UInt_t hs = GetHSFromKey(key);
895       UInt_t chip = GetChipFromKey(key);
896       UInt_t col = GetColFromKey(key);
897       UInt_t row = GetRowFromKey(key);
898       printf("%d,%d,%d,%d,%d\n",eqId,hs,chip,col,row);
899     }
900   }
901 }
902
903 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadDiff(AliITSOnlineCalibrationSPDhandler* other) const {
904   // returns nr of dead in this' lists and not in other's lists
905   UInt_t returnval=0;
906   for (UInt_t module=0; module<240; module++) {
907     for (UInt_t ind1=0; ind1<fNrDead[module]; ind1++) {
908       Int_t key = fDeadPixelMap[module]->GetKeyIndex(ind1);
909       UInt_t eqId = GetEqIdFromKey(key);
910       UInt_t hs = GetHSFromKey(key);
911       UInt_t chip = GetChipFromKey(key);
912       UInt_t col = GetColFromKey(key);
913       UInt_t row = GetRowFromKey(key);
914       if (!(other->IsPixelDead(eqId,hs,chip,col,row))) {
915         returnval++;
916       }
917     }
918   }
919   return returnval;
920 }
921
922 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisyDiff(AliITSOnlineCalibrationSPDhandler* other) const {
923   // returns nr of noisy in this' lists and not in other's lists
924   UInt_t returnval=0;
925   for (UInt_t module=0; module<240; module++) {
926     for (UInt_t ind1=0; ind1<fNrNoisy[module]; ind1++) {
927       Int_t key = fNoisyPixelMap[module]->GetKeyIndex(ind1);
928       UInt_t eqId = GetEqIdFromKey(key);
929       UInt_t hs = GetHSFromKey(key);
930       UInt_t chip = GetChipFromKey(key);
931       UInt_t col = GetColFromKey(key);
932       UInt_t row = GetRowFromKey(key);
933       if (!(other->IsPixelNoisy(eqId,hs,chip,col,row))) {
934         returnval++;
935       }
936     }
937   }
938   return returnval;
939 }
940
941 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDiff(AliITSOnlineCalibrationSPDhandler* other) const {
942   // returns nr of dead/noisy in this' lists and not in other's lists
943   return GetNrDeadDiff(other) + GetNrNoisyDiff(other);
944 }
945
946 AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetDiff(AliITSOnlineCalibrationSPDhandler* other) const {
947   // returns handler with dead/noisy in this' lists, except for those in other's lists
948   AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler();
949   for (UInt_t module=0; module<240; module++) {
950     for (UInt_t ind1=0; ind1<fNrDead[module]; ind1++) {
951       Int_t key = fDeadPixelMap[module]->GetKeyIndex(ind1);
952       UInt_t eqId = GetEqIdFromKey(key);
953       UInt_t hs = GetHSFromKey(key);
954       UInt_t chip = GetChipFromKey(key);
955       UInt_t col = GetColFromKey(key);
956       UInt_t row = GetRowFromKey(key);
957       if (!(other->IsPixelDead(eqId,hs,chip,col,row))) {
958         newHandler->SetDeadPixel(eqId,hs,chip,col,row);
959       }
960     }
961     for (UInt_t ind2=0; ind2<fNrNoisy[module]; ind2++) {
962       Int_t key = fNoisyPixelMap[module]->GetKeyIndex(ind2);
963       UInt_t eqId = GetEqIdFromKey(key);
964       UInt_t hs = GetHSFromKey(key);
965       UInt_t chip = GetChipFromKey(key);
966       UInt_t col = GetColFromKey(key);
967       UInt_t row = GetRowFromKey(key);
968       if (!(other->IsPixelNoisy(eqId,hs,chip,col,row))) {
969         newHandler->SetNoisyPixel(eqId,hs,chip,col,row);
970       }
971     }
972   }
973   return newHandler;
974 }
975
976 AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetDeadDiff(AliITSOnlineCalibrationSPDhandler* other) const {
977   // returns handler with dead in this' lists, except for those in other's lists
978   AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler();
979   for (UInt_t module=0; module<240; module++) {
980     for (UInt_t ind1=0; ind1<fNrDead[module]; ind1++) {
981       Int_t key = fDeadPixelMap[module]->GetKeyIndex(ind1);
982       UInt_t eqId = GetEqIdFromKey(key);
983       UInt_t hs = GetHSFromKey(key);
984       UInt_t chip = GetChipFromKey(key);
985       UInt_t col = GetColFromKey(key);
986       UInt_t row = GetRowFromKey(key);
987       if (!(other->IsPixelDead(eqId,hs,chip,col,row))) {
988         newHandler->SetDeadPixel(eqId,hs,chip,col,row);
989       }
990     }
991   }
992   return newHandler;
993 }
994
995 AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetNoisyDiff(AliITSOnlineCalibrationSPDhandler* other) const {
996   // returns handler with noisy in this' lists, except for those in other's lists
997   AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler();
998   for (UInt_t module=0; module<240; module++) {
999     for (UInt_t ind2=0; ind2<fNrNoisy[module]; ind2++) {
1000       Int_t key = fNoisyPixelMap[module]->GetKeyIndex(ind2);
1001       UInt_t eqId = GetEqIdFromKey(key);
1002       UInt_t hs = GetHSFromKey(key);
1003       UInt_t chip = GetChipFromKey(key);
1004       UInt_t col = GetColFromKey(key);
1005       UInt_t row = GetRowFromKey(key);
1006       if (!(other->IsPixelNoisy(eqId,hs,chip,col,row))) {
1007         newHandler->SetNoisyPixel(eqId,hs,chip,col,row);
1008       }
1009     }
1010   }
1011   return newHandler;
1012 }
1013
1014 void AliITSOnlineCalibrationSPDhandler::InitModuleMaps() {
1015   // initializes the module mapping arrays needed for the methods below (GetEqIdFromOffline etc.)
1016   for (UInt_t iDDL=0; iDDL<20; iDDL++) {
1017     for (UInt_t iModule=0; iModule<12; iModule++) {
1018       UInt_t module = AliITSRawStreamSPD::GetModuleNumber(iDDL,iModule);
1019       fiDDL[module] = iDDL;
1020       fiModule[module] = iModule;
1021     }
1022   }
1023 }
1024
1025 void AliITSOnlineCalibrationSPDhandler::GenerateDCSConfigFile(const Char_t* fileName) {
1026   // generates an ascii file in the format as the one produced by online da (but with dummy runNr=0)
1027   ofstream dcsfile;
1028   dcsfile.open(fileName);
1029   dcsfile << "[SPD SCAN]\n";
1030   dcsfile << "RunNumber=" << "0" << "\n"; // dummy value
1031   dcsfile << "Type=" << "4" << "\n";
1032   dcsfile << "Router=" << "0" << "\n"; // dummy value
1033   dcsfile << "ActualDetCoonfiguration=" << "0,-1,-1\n"; // dummy values
1034   dcsfile << "[NOISY]\n";
1035   for (UInt_t module=0; module<240; module++) {
1036     UInt_t headkey=20*10*6;
1037     for (UInt_t ind=0; ind<fNrNoisy[module]; ind++) {
1038       UInt_t newkey = GetNoisyEqIdAt(module,ind)*10*6 +
1039         GetNoisyHSAt(module,ind)*10 +
1040         GetNoisyChipAt(module,ind);
1041       if (newkey!=headkey) { // print eqId,hs,chip header
1042         headkey = newkey;
1043         dcsfile << "-" << newkey/(6*10) << "," << (newkey%(6*10))/10 << "," << (newkey%(6*10))%10 << "\n";
1044       }
1045       dcsfile << GetNoisyColAt(module,ind) << "," << GetNoisyRowAt(module,ind) << "\n";
1046     }
1047   }
1048   dcsfile.close();
1049 }
1050
1051 UInt_t AliITSOnlineCalibrationSPDhandler::GetEqIdFromOffline(UInt_t module) {
1052   // module to eqId mapping
1053   if (!fModuleMapInited) InitModuleMaps();
1054   return fiDDL[module];
1055 }
1056 UInt_t AliITSOnlineCalibrationSPDhandler::GetHSFromOffline(UInt_t module) {
1057   // module to hs mapping
1058   if (!fModuleMapInited) InitModuleMaps();
1059   return fiModule[module]/2;
1060 }
1061 UInt_t AliITSOnlineCalibrationSPDhandler::GetChipFromOffline(UInt_t module, UInt_t colM) {
1062   // module,colM to chip mapping
1063   if (!fModuleMapInited) InitModuleMaps();
1064   return colM/32 + 5*(fiModule[module]%2);
1065 }
1066 UInt_t AliITSOnlineCalibrationSPDhandler::GetColFromOffline(UInt_t colM) const {
1067   // colM to col mapping
1068   return colM%32;
1069 }