ITS/AliITSOnlineCalibrationSPDhandler.cxx

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