ITS/AliITSOnlineCalibrationSPDhandler.cxx

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