ITS/AliITSOnlineCalibrationSPDhandler.cxx

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