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