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 // The TArrayI objects that are put in the AliITSCalibrationSPD     //
   6 // objects can be obtained from the methods GetDeadArray and        //
   7 // GetNoisyArray.                                                   //
   8 //////////////////////////////////////////////////////////////////////
   9
  10 #include "AliITSOnlineCalibrationSPDhandler.h"
  11 #include "AliITSOnlineCalibrationSPD.h"
  12 #include "AliITSIntMap.h"
  13 #include <TObjArray.h>
  14 #include <TArrayI.h>
  15 #include <TFile.h>
  16 #include <TError.h>
  17 #include <fstream>
  18
  19 #ifndef SPD_DA_OFF // you may want to exclude cdb classes, if using this class outside aliroot
  20 #include "AliITSCalibrationSPD.h"
  21 #include "AliCDBManager.h"
  22 #include "AliCDBEntry.h"
  23 #endif
  24
  25 AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler():
  26   fFileLocation("."),
  27   fModuleMapInited(kFALSE)
  28 {
  29   // constructor
  30   for (UInt_t module=0; module<240; module++) {
  31     fNrDead[module]=0;
  32     fNrNoisy[module]=0;
  33     fDeadPixelMap[module] = new AliITSIntMap();
  34     fNoisyPixelMap[module] = new AliITSIntMap();
  35   }
  36 }
  37
  38 AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler(const AliITSOnlineCalibrationSPDhandler& handle):
  39   fFileLocation("."),
  40   fModuleMapInited(kFALSE)
  41 {
  42   // copy constructor
  43   for (UInt_t module=0; module<240; module++) {
  44     fNrDead[module] = handle.fNrDead[module];
  45     fNrNoisy[module] = handle.fNrNoisy[module];
  46     fDeadPixelMap[module] = handle.fDeadPixelMap[module]->Clone();
  47     fNoisyPixelMap[module] = handle.fNoisyPixelMap[module]->Clone();
  48   }
  49   fFileLocation = handle.fFileLocation;
  50 }
  51
  52 AliITSOnlineCalibrationSPDhandler::~AliITSOnlineCalibrationSPDhandler() {
  53   ClearMaps();
  54 }
  55
  56 AliITSOnlineCalibrationSPDhandler& AliITSOnlineCalibrationSPDhandler::operator=(const AliITSOnlineCalibrationSPDhandler& handle) {
  57   // assignment operator
  58   if (this!=&handle) {
  59     this->ClearMaps();
  60     for (UInt_t module=0; module<240; module++) {
  61       fNrDead[module] = handle.fNrDead[module];
  62       fNrNoisy[module] = handle.fNrNoisy[module];
  63       fDeadPixelMap[module] = handle.fDeadPixelMap[module]->Clone();
  64       fNoisyPixelMap[module] = handle.fNoisyPixelMap[module]->Clone();
  65     }
  66     fFileLocation = handle.fFileLocation;
  67   }
  68   return *this;
  69 }
  70
  71 void AliITSOnlineCalibrationSPDhandler::ClearMaps() {
  72   // clear the lists of dead and noisy
  73   ResetDead();
  74   ResetNoisy();
  75 }
  76
  77 Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromFiles() {
  78   // read dead and noisy files from file location. returns true if at least one file found
  79   Bool_t returnval=kFALSE;
  80   for (UInt_t module=0; module<240; module++) {
  81     if (ReadFromFile(module)) {
  82       returnval=kTRUE;
  83     }
  84   }
  85   return returnval;
  86 }
  87 Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromFile(UInt_t module) {
  88   // read dead and noisy files for module from file location.
  89   TString fileName = Form("%s/SPD_DeadNoisy_%d.root",fFileLocation.Data(),module);
  90   return ReadFromFileName(fileName.Data());
  91 }
  92 Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromFileName(const char *fileName) {
  93   // read dead and noisy from file fileName
  94   AliITSOnlineCalibrationSPD* calib;
  95   FILE* fp0 = fopen(fileName, "r");
  96   if (fp0 == NULL) {return kFALSE;}
  97   else {
  98     fclose(fp0);
  99     TFile file(fileName, "READ");
 100     if (file.IsOpen()) {
 101       file.GetObject("AliITSOnlineCalibrationSPD", calib);
 102       file.Close();
 103       if (calib!=NULL) {
 104         UInt_t module = calib->GetModuleNr();
 105         Int_t nrDead=calib->GetNrDead();
 106         for (Int_t index=0; index<nrDead; index++) {
 107           UInt_t colM=calib->GetDeadColAt(index);
 108           UInt_t row=calib->GetDeadRowAt(index);
 109           SetDeadPixelM(module,colM,row);
 110         }
 111         Int_t nrNoisy=calib->GetNrNoisy();
 112         for (Int_t index=0; index<nrNoisy; index++) {
 113           UInt_t colM=calib->GetNoisyColAt(index);
 114           UInt_t row=calib->GetNoisyRowAt(index);
 115           SetNoisyPixelM(module,colM,row);
 116         }
 117       }
 118     }
 119   }
 120   return kTRUE;
 121 }
 122 Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFiles() {
 123   // read dead files from file location. returns true if at least one file found
 124   Bool_t returnval=kFALSE;
 125   for (UInt_t module=0; module<240; module++) {
 126     if (ReadDeadFromFile(module)) {
 127       returnval=kTRUE;
 128     }
 129   }
 130   return returnval;
 131 }
 132 Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFile(UInt_t module) {
 133   // read dead for module from file location.
 134   TString fileName = Form("%s/SPD_DeadNoisy_%d.root",fFileLocation.Data(),module);
 135   return ReadDeadFromFileName(fileName.Data());
 136 }
 137 Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFileName(const char *fileName) {
 138   // read dead from file fileName
 139   AliITSOnlineCalibrationSPD* calib;
 140   FILE* fp0 = fopen(fileName, "r");
 141   if (fp0 == NULL) {return kFALSE;}
 142   else {
 143     fclose(fp0);
 144     TFile file(fileName, "READ");
 145     if (file.IsOpen()) {
 146       file.GetObject("AliITSOnlineCalibrationSPD", calib);
 147       file.Close();
 148       if (calib!=NULL) {
 149         UInt_t module = calib->GetModuleNr();
 150         Int_t nrDead=calib->GetNrDead();
 151         for (Int_t index=0; index<nrDead; index++) {
 152           UInt_t colM=calib->GetDeadColAt(index);
 153           UInt_t row=calib->GetDeadRowAt(index);
 154           SetDeadPixelM(module,colM,row);
 155         }
 156       }
 157     }
 158   }
 159   return kTRUE;
 160 }
 161 Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFiles() {
 162   // read noisy files from file location. returns true if at least one file found
 163   Bool_t returnval=kFALSE;
 164   for (UInt_t module=0; module<240; module++) {
 165     if (ReadNoisyFromFile(module)) {
 166       returnval=kTRUE;
 167     }
 168   }
 169   return returnval;
 170 }
 171 Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFile(UInt_t module) {
 172   // read noisy for module from file location.
 173   TString fileName = Form("%s/SPD_DeadNoisy_%d.root",fFileLocation.Data(),module);
 174   return ReadNoisyFromFileName(fileName.Data());
 175 }
 176 Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFileName(const char *fileName) {
 177   // read noisy from file fileName
 178   AliITSOnlineCalibrationSPD* calib;
 179   FILE* fp0 = fopen(fileName, "r");
 180   if (fp0 == NULL) {return kFALSE;}
 181   else {
 182     fclose(fp0);
 183     TFile file(fileName, "READ");
 184     if (file.IsOpen()) {
 185       file.GetObject("AliITSOnlineCalibrationSPD", calib);
 186       file.Close();
 187       if (calib!=NULL) {
 188         UInt_t module = calib->GetModuleNr();
 189         Int_t nrNoisy=calib->GetNrNoisy();
 190         for (Int_t index=0; index<nrNoisy; index++) {
 191           UInt_t colM=calib->GetNoisyColAt(index);
 192           UInt_t row=calib->GetNoisyRowAt(index);
 193           SetNoisyPixelM(module,colM,row);
 194         }
 195       }
 196     }
 197   }
 198   return kTRUE;
 199 }
 200
 201
 202 UInt_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromText(const char *fileName) {
 203   // read dead from a text file (lines with eqId,hs,chip,col,row). returns nr of pixels added (not already there)
 204   UInt_t newNrDead=0;
 205   ifstream textFile;
 206   textFile.open(fileName, ifstream::in);
 207   if (textFile.fail()) {
 208     Error("AliITSOnlineCalibrationSPDhandler::ReadDeadFromText","No noisy text file (%s) present.",fileName);
 209   }
 210   else {
 211     while(1) {
 212       UInt_t eqId,hs,chip,col,row;
 213       textFile >> eqId; if (textFile.eof()) break;
 214       textFile >> hs; if (textFile.eof()) break;
 215       textFile >> chip; if (textFile.eof()) break;
 216       textFile >> col; if (textFile.eof()) break;
 217       textFile >> row;
 218       if (SetDeadPixel(eqId,hs,chip,col,row)) {
 219         newNrDead++;
 220       }
 221       if (textFile.eof()) break;
 222     }
 223     textFile.close();
 224   }
 225   return newNrDead;
 226 }
 227
 228 UInt_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromText(const char *fileName) {
 229   // read noisy from a text file (lines with eqId,hs,chip,col,row). returns nr of pixels added (not already here)
 230   UInt_t newNrNoisy=0;
 231   ifstream textFile;
 232   textFile.open(fileName, ifstream::in);
 233   if (textFile.fail()) {
 234     Error("AliITSOnlineCalibrationSPDhandler::ReadNoisyFromText","No noisy text file (%s) present.",fileName);
 235   }
 236   else {
 237     while(1) {
 238       UInt_t eqId,hs,chip,col,row;
 239       textFile >> eqId; if (textFile.eof()) break;
 240       textFile >> hs; if (textFile.eof()) break;
 241       textFile >> chip; if (textFile.eof()) break;
 242       textFile >> col; if (textFile.eof()) break;
 243       textFile >> row;
 244       if (SetNoisyPixel(eqId,hs,chip,col,row)) {
 245         newNrNoisy++;
 246       }
 247       if (textFile.eof()) break;
 248     }
 249     textFile.close();
 250   }
 251   return newNrNoisy;
 252 }
 253
 254
 255 #ifndef SPD_DA_OFF
 256 Bool_t AliITSOnlineCalibrationSPDhandler::ReadModuleFromDB(UInt_t module, Int_t runNr) {
 257   // reads dead and noisy pixels from DB for given module and runNr
 258   AliCDBManager* man = AliCDBManager::Instance();
 259   if(!man->IsDefaultStorageSet()) {
 260     man->SetDefaultStorage("local://$ALICE_ROOT");
 261   }
 262   AliCDBEntry *cdbEntry = man->Get("ITS/Calib/CalibSPD", runNr);
 263   TObjArray* spdEntry;
 264   if(cdbEntry) {
 265     spdEntry = (TObjArray*)cdbEntry->GetObject();
 266     if(!spdEntry) return kFALSE;
 267   }
 268   else {
 269     Warning("AliITSOnlineCalibrationSPDhandler::ReadModuleFromDB","Calibration for run %d not found in database.",runNr);
 270     return kFALSE;
 271   }
 272   AliITSCalibrationSPD* calibSPD;
 273   calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module);
 274   UInt_t nrDead = calibSPD->GetNrDead();
 275   for (UInt_t index=0; index<nrDead; index++) {
 276     UInt_t colM = calibSPD->GetDeadColAt(index);
 277     UInt_t row  = calibSPD->GetDeadRowAt(index);
 278     SetDeadPixelM(module,colM,row);
 279   }
 280   UInt_t nrNoisy = calibSPD->GetNrNoisy();
 281   for (UInt_t index=0; index<nrNoisy; index++) {
 282     UInt_t colM = calibSPD->GetNoisyColAt(index);
 283     UInt_t row  = calibSPD->GetNoisyRowAt(index);
 284     SetNoisyPixelM(module,colM,row);
 285   }
 286   spdEntry->SetOwner(kTRUE);
 287   spdEntry->Clear();
 288   return kTRUE;
 289 }
 290
 291 Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromDB(Int_t runNr) {
 292   // reads dead and noisy pixels from DB for given runNr
 293   // note that you may want to clear the lists (if they are not empty) before reading
 294   AliCDBManager* man = AliCDBManager::Instance();
 295   if(!man->IsDefaultStorageSet()) {
 296     man->SetDefaultStorage("local://$ALICE_ROOT");
 297   }
 298   AliCDBEntry *cdbEntry = man->Get("ITS/Calib/CalibSPD", runNr);
 299   TObjArray* spdEntry;
 300   if(cdbEntry) {
 301     spdEntry = (TObjArray*)cdbEntry->GetObject();
 302     if(!spdEntry) return kFALSE;
 303   }
 304   else {
 305     Warning("AliITSOnlineCalibrationSPDhandler::ReadFromDB","Calibration for run %d not found in database.",runNr);
 306     return kFALSE;
 307   }
 308   AliITSCalibrationSPD* calibSPD;
 309   for (UInt_t module=0; module<240; module++) {
 310     //    printf("Reading module %d\n",module);
 311     calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module);
 312     UInt_t nrDead = calibSPD->GetNrDead();
 313     for (UInt_t index=0; index<nrDead; index++) {
 314       UInt_t colM = calibSPD->GetDeadColAt(index);
 315       UInt_t row  = calibSPD->GetDeadRowAt(index);
 316       SetDeadPixelM(module,colM,row);
 317     }
 318     UInt_t nrNoisy = calibSPD->GetNrNoisy();
 319     for (UInt_t index=0; index<nrNoisy; index++) {
 320       UInt_t colM = calibSPD->GetNoisyColAt(index);
 321       UInt_t row  = calibSPD->GetNoisyRowAt(index);
 322       SetNoisyPixelM(module,colM,row);
 323     }
 324   }
 325   spdEntry->SetOwner(kTRUE);
 326   spdEntry->Clear();
 327   return kTRUE;
 328 }
 329
 330 Bool_t AliITSOnlineCalibrationSPDhandler::WriteToDB(Int_t runNrStart, Int_t runNrEnd) {
 331   // writes dead and noisy pixels to DB for given runNr
 332   // overwrites any previous entries
 333   AliCDBManager* man = AliCDBManager::Instance();
 334   if(!man->IsDefaultStorageSet()) {
 335     man->SetDefaultStorage("local://$ALICE_ROOT");
 336   }
 337   AliCDBMetaData* metaData = new AliCDBMetaData();
 338   metaData->SetResponsible("Henrik Tydesjo");
 339   metaData->SetComment("Created by AliITSOnlineCalibrationSPDhandler.");
 340   AliCDBId idCalSPD("ITS/Calib/CalibSPD",runNrStart,runNrEnd);
 341   TObjArray* spdEntry = new TObjArray(240);
 342   spdEntry->SetOwner(kTRUE);
 343   for(UInt_t module=0; module<240; module++){
 344     AliITSCalibrationSPD* calObj = new AliITSCalibrationSPD();
 345     spdEntry->Add(calObj);
 346   }
 347   for(UInt_t module=0; module<240; module++){
 348     ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetNrDead( GetNrDead(module) );
 349     ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetDeadList( GetDeadArray(module) );
 350     ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetNrNoisy( GetNrNoisy(module) );
 351     ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetNoisyList( GetNoisyArray(module) );
 352   }
 353   AliCDBEntry* cdbEntry = new AliCDBEntry((TObject*)spdEntry,idCalSPD,metaData);
 354   man->Put(cdbEntry);
 355   delete spdEntry;
 356   delete cdbEntry;
 357   delete metaData;
 358   return kTRUE;
 359 }
 360 #endif
 361
 362 void AliITSOnlineCalibrationSPDhandler::WriteToFiles() {
 363   // write the lists of dead and noisy to files (only if there are >0 dead or noisy pixels)
 364   for (UInt_t module=0; module<240; module++) {
 365     if (fNrDead[module]+fNrNoisy[module] > 0) {
 366       WriteToFile(module);
 367     }
 368   }
 369 }
 370 void AliITSOnlineCalibrationSPDhandler::WriteToFile(UInt_t module) {
 371   // write the lists of dead and noisy for module to file
 372   AliITSOnlineCalibrationSPD* calib = new AliITSOnlineCalibrationSPD();
 373   calib->SetModuleNr(module);
 374   calib->SetDeadList(GetDeadArray(module));
 375   calib->SetNoisyList(GetNoisyArray(module));
 376   calib->SetNrDead(GetNrDead(module));
 377   calib->SetNrNoisy(GetNrNoisy(module));
 378   TString fileName = Form("%s/SPD_DeadNoisy_%d.root",fFileLocation.Data(),module);
 379   TFile file(fileName.Data(), "RECREATE");
 380   file.WriteTObject(calib, "AliITSOnlineCalibrationSPD");
 381   file.Close();
 382   delete calib;
 383 }
 384 void AliITSOnlineCalibrationSPDhandler::WriteDeadToFiles() {
 385   // write the lists of dead to files (only if there are >0 dead pixels)
 386   for (UInt_t module=0; module<240; module++) {
 387     if (fNrDead[module] > 0) {
 388       WriteDeadToFile(module);
 389     }
 390   }
 391 }
 392 void AliITSOnlineCalibrationSPDhandler::WriteDeadToFile(UInt_t module) {
 393   // write the lists of dead for module to file
 394   AliITSOnlineCalibrationSPD* calib = new AliITSOnlineCalibrationSPD();
 395   calib->SetModuleNr(module);
 396   calib->SetDeadList(GetDeadArray(module));
 397   calib->SetNrDead(GetNrDead(module));
 398   TString fileName = Form("%s/SPD_DeadNoisy_%d.root",fFileLocation.Data(),module);
 399   TFile file(fileName.Data(), "RECREATE");
 400   file.WriteTObject(calib, "AliITSOnlineCalibrationSPD");
 401   file.Close();
 402   delete calib;
 403 }
 404 void AliITSOnlineCalibrationSPDhandler::WriteNoisyToFiles() {
 405   // write the lists of noisy to files (only if there are >0 dead pixels)
 406   for (UInt_t module=0; module<240; module++) {
 407     if (fNrNoisy[module] > 0) {
 408       printf("writing noisy to file for module %d\n",module);
 409       WriteNoisyToFile(module);
 410     }
 411   }
 412 }
 413 void AliITSOnlineCalibrationSPDhandler::WriteNoisyToFile(UInt_t module) {
 414   // write the lists of noisy for module to file
 415   AliITSOnlineCalibrationSPD* calib = new AliITSOnlineCalibrationSPD();
 416   calib->SetModuleNr(module);
 417   calib->SetNoisyList(GetNoisyArray(module));
 418   calib->SetNrNoisy(GetNrNoisy(module));
 419   TString fileName = Form("%s/SPD_DeadNoisy_%d.root",fFileLocation.Data(),module);
 420   TFile file(fileName.Data(), "RECREATE");
 421   file.WriteTObject(calib, "AliITSOnlineCalibrationSPD");
 422   file.Close();
 423   delete calib;
 424 }
 425
 426 TArrayI AliITSOnlineCalibrationSPDhandler::GetDeadArray(UInt_t module) {
 427   // get a TArrayI of the dead pixels (format for the AliITSCalibrationSPD object)
 428   TArrayI returnArray;
 429   returnArray.Set(GetNrDead(module)*2);
 430   fDeadPixelMap[module]->PrepareSerialize(); // for tree ordered values
 431   for (UInt_t index=0; index<GetNrDead(module); index++) {
 432     Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
 433     Int_t colM = GetColMFromKey(key);
 434     Int_t row = GetRowFromKey(key);
 435     returnArray.AddAt(colM,index*2);
 436     returnArray.AddAt(row,index*2+1);
 437   }
 438   return returnArray;
 439 }
 440 TArrayI AliITSOnlineCalibrationSPDhandler::GetNoisyArray(UInt_t module) {
 441   // get a TArrayI of the noisy pixels (format for the AliITSCalibrationSPD object)
 442   TArrayI returnArray;
 443   returnArray.Set(GetNrNoisy(module)*2);
 444   fNoisyPixelMap[module]->PrepareSerialize(); // for tree ordered values
 445   for (UInt_t index=0; index<GetNrNoisy(module); index++) {
 446     Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
 447     Int_t colM = GetColMFromKey(key);
 448     Int_t row = GetRowFromKey(key);
 449     returnArray.AddAt(colM,index*2);
 450     returnArray.AddAt(row,index*2+1);
 451   }
 452   return returnArray;
 453 }
 454
 455 void AliITSOnlineCalibrationSPDhandler::ResetDead() {
 456   // reset the dead pixel map
 457   for (UInt_t module=0; module<240; module++) {
 458     fNrDead[module]=0;
 459     fDeadPixelMap[module]->Clear();
 460   }
 461 }
 462
 463 void AliITSOnlineCalibrationSPDhandler::ResetDeadForChip(UInt_t eqId, UInt_t hs, UInt_t chip) {
 464   // clear the noisy pixels for this chip
 465   UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
 466   for (UInt_t col=0; col<32; col++) {
 467     for (UInt_t row=0; row<256; row++) {
 468       Int_t key = GetKey(eqId,hs,chip,col,row);
 469       if (fDeadPixelMap[module]->Remove(key)) {
 470         fNrDead[module]--;
 471       }
 472     }
 473   }
 474 }
 475
 476 Bool_t AliITSOnlineCalibrationSPDhandler::SetDeadPixel(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
 477   // set a dead pixel, returns false if pixel is already dead
 478   UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
 479   Int_t key = GetKey(eqId,hs,chip,col,row);
 480 //!!!  // if noisy we dont want to add it...
 481 //!!!  if (fNoisyPixelMap[module]->Find(key) != NULL) return kFALSE;
 482   if (fDeadPixelMap[module]->Insert(key,module)) {
 483     fNrDead[module]++;
 484     return kTRUE;
 485   }
 486   return kFALSE;
 487 }
 488
 489 Bool_t AliITSOnlineCalibrationSPDhandler::SetDeadPixelM(UInt_t module, UInt_t colM, UInt_t row) {
 490   // set a dead pixel, returns false if pixel is already dead
 491   UInt_t eqId = GetEqIdFromOffline(module);
 492   UInt_t hs = GetHSFromOffline(module);
 493   UInt_t chip = GetChipFromOffline(module,colM);
 494   UInt_t col = GetColFromOffline(colM);
 495   Int_t key = GetKey(eqId,hs,chip,col,row);
 496 //!!!  // if noisy we dont want to add it...
 497 //!!!  if (fNoisyPixelMap[module]->Find(key) != NULL) return kFALSE;
 498   if (fDeadPixelMap[module]->Insert(key,module)) {
 499     fNrDead[module]++;
 500     return kTRUE;
 501   }
 502   return kFALSE;
 503 }
 504
 505 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDeadKey(Int_t key) const {
 506   // is this pixel noisy?
 507   UInt_t eqId = GetEqIdFromKey(key);
 508   UInt_t hs = GetHSFromKey(key);
 509   UInt_t chip = GetChipFromKey(key);
 510   UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
 511   return IsPixelDeadMKey(module,key);
 512 }
 513
 514 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDeadMKey(UInt_t module, Int_t key) const {
 515   // is this pixel dead?
 516   if ( fDeadPixelMap[module]->Find(key) != NULL ) {
 517     return kTRUE;
 518   }
 519   else {
 520     return kFALSE;
 521   }
 522 }
 523
 524 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDead(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const {
 525   // is the pixel dead?
 526   UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
 527   Int_t key = GetKey(eqId,hs,chip,col,row);
 528   return IsPixelDeadMKey(module,key);
 529 }
 530
 531 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDeadM(UInt_t module, UInt_t colM, UInt_t row) {
 532   // is the pixel dead?
 533   UInt_t eqId = GetEqIdFromOffline(module);
 534   UInt_t hs = GetHSFromOffline(module);
 535   UInt_t chip = GetChipFromOffline(module,colM);
 536   UInt_t col = GetColFromOffline(colM);
 537   Int_t key = GetKey(eqId,hs,chip,col,row);
 538   return IsPixelDeadMKey(module,key);
 539 }
 540
 541 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDead() const {
 542   // returns the total nr of dead pixels
 543   UInt_t nrDead = 0;
 544   for (UInt_t module=0; module<240; module++) {
 545     nrDead+=fNrDead[module];
 546   }
 547   return nrDead;
 548 }
 549
 550 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDead(UInt_t module) const {
 551   // returns the number of dead pixels for a certain module
 552   if (module<240) {
 553     return fNrDead[module];
 554   }
 555   else {
 556     return 0;
 557   }
 558 }
 559
 560 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAt(UInt_t module, UInt_t index) {
 561   // get eqId for the dead pixel at position index in list of dead
 562   if (index<GetNrDead(module)) {
 563     Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
 564     return GetEqIdFromKey(key);
 565   }
 566   else {
 567     Error("AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAt", "Index %d out of bounds.", index);
 568     return 0;
 569   }
 570 }
 571 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAt(UInt_t module, UInt_t index) {
 572   // get hs for the dead pixel at position index in list of dead
 573   if (index<GetNrDead(module)) {
 574     Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
 575     return GetHSFromKey(key);
 576   }
 577   else {
 578     Error("AliITSOnlineCalibrationSPDhandler::GetDeadHSAt", "Index %d out of bounds.", index);
 579     return 0;
 580   }
 581 }
 582 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAt(UInt_t module, UInt_t index) {
 583   // get chip for the dead pixel at position index in list of dead
 584   if (index<GetNrDead(module)) {
 585     Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
 586     return GetChipFromKey(key);
 587   }
 588   else {
 589     Error("AliITSOnlineCalibrationSPDhandler::GetDeadChipAt", "Index %d out of bounds.", index);
 590     return 0;
 591   }
 592 }
 593 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAt(UInt_t module, UInt_t index) {
 594   // get column for the dead pixel at position index in list of dead
 595   if (index<GetNrDead(module)) {
 596     Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
 597     return GetColFromKey(key);
 598   }
 599   else {
 600     Error("AliITSOnlineCalibrationSPDhandler::GetDeadColAt", "Index %d out of bounds.", index);
 601     return 0;
 602   }
 603 }
 604 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAt(UInt_t module, UInt_t index) {
 605   // get row for the dead pixel at position index in list of dead
 606   if (index<GetNrDead(module)) {
 607     Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
 608     return GetRowFromKey(key);
 609   }
 610   else {
 611     Error("AliITSOnlineCalibrationSPDhandler::GetDeadRowAt", "Index %d out of bounds.", index);
 612     return 0;
 613   }
 614 }
 615
 616 void AliITSOnlineCalibrationSPDhandler::ResetNoisy() {
 617   // clear the list of noisy pixels
 618   for (UInt_t module=0; module<240; module++) {
 619     fNrNoisy[module]=0;
 620     fNoisyPixelMap[module]->Clear();
 621   }
 622 }
 623 void AliITSOnlineCalibrationSPDhandler::ResetNoisyForChip(UInt_t eqId, UInt_t hs, UInt_t chip) {
 624   // clear the noisy pixels for this chip
 625   UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
 626   for (UInt_t col=0; col<32; col++) {
 627     for (UInt_t row=0; row<256; row++) {
 628       Int_t key = GetKey(eqId,hs,chip,col,row);
 629       if (fNoisyPixelMap[module]->Remove(key)) {
 630         fNrNoisy[module]--;
 631       }
 632     }
 633   }
 634 }
 635
 636
 637 Bool_t AliITSOnlineCalibrationSPDhandler::SetNoisyPixel(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
 638   // set a noisy pixel, returns false if already there
 639   UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
 640   Int_t key = GetKey(eqId,hs,chip,col,row);
 641 //!!!  // if dead before - remove from the dead list
 642 //!!!  UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
 643 //!!!  if (fDeadPixelMap.Remove(key)) {
 644 //!!!    fNrDead[module]--;
 645 //!!!  }
 646   if (fNoisyPixelMap[module]->Insert(key,col)) {
 647     fNrNoisy[module]++;
 648     return kTRUE;
 649   }
 650   return kFALSE;
 651 }
 652
 653 Bool_t AliITSOnlineCalibrationSPDhandler::SetNoisyPixelM(UInt_t module, UInt_t colM, UInt_t row) {
 654   // set a noisy pixel, returns false if already there
 655   UInt_t eqId = GetEqIdFromOffline(module);
 656   UInt_t hs = GetHSFromOffline(module);
 657   UInt_t chip = GetChipFromOffline(module,colM);
 658   UInt_t col = GetColFromOffline(colM);
 659   Int_t key = GetKey(eqId,hs,chip,col,row);
 660 //!!!  // if dead before - remove from the dead list
 661 //!!!  if (fDeadPixelMap[module]->Remove(key)) {
 662 //!!!    fNrDead[module]--;
 663 //!!!  }
 664   if (fNoisyPixelMap[module]->Insert(key,col)) {
 665     fNrNoisy[module]++;
 666     return kTRUE;
 667   }
 668   return kFALSE;
 669 }
 670
 671 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyKey(Int_t key) const {
 672   // is this pixel noisy?
 673   UInt_t eqId = GetEqIdFromKey(key);
 674   UInt_t hs = GetHSFromKey(key);
 675   UInt_t chip = GetChipFromKey(key);
 676   UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
 677   return IsPixelNoisyMKey(module,key);
 678 }
 679
 680 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyMKey(UInt_t module, Int_t key) const {
 681   // is this pixel noisy?
 682   if ( fNoisyPixelMap[module]->Find(key) != NULL ) {
 683     return kTRUE;
 684   }
 685   else {
 686     return kFALSE;
 687   }
 688 }
 689
 690 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisy(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const {
 691   // is this pixel noisy?
 692   UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
 693   Int_t key = GetKey(eqId,hs,chip,col,row);
 694   return IsPixelNoisyMKey(module,key);
 695 }
 696
 697 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyM(UInt_t module, UInt_t colM, UInt_t row) {
 698   // is this pixel noisy?
 699   UInt_t eqId = GetEqIdFromOffline(module);
 700   UInt_t hs = GetHSFromOffline(module);
 701   UInt_t chip = GetChipFromOffline(module,colM);
 702   UInt_t col = GetColFromOffline(colM);
 703   Int_t key = GetKey(eqId,hs,chip,col,row);
 704   return IsPixelNoisyMKey(module,key);
 705 }
 706
 707 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisy() const {
 708   // returns the total nr of noisy pixels
 709   UInt_t nrNoisy = 0;
 710   for (UInt_t module=0; module<240; module++) {
 711     nrNoisy+=fNrNoisy[module];
 712   }
 713   return nrNoisy;
 714 }
 715
 716 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisy(UInt_t module) const {
 717 // returns the number of noisy pixels for a certain module
 718   if (module<240) {
 719     return fNrNoisy[module];
 720   }
 721   else {
 722     return 0;
 723   }
 724 }
 725
 726 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAt(UInt_t module, UInt_t index) {
 727   // get chip for the noisy pixel at position index in list of noisy
 728   if (index<GetNrNoisy(module)) {
 729     Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
 730     return GetEqIdFromKey(key);
 731   }
 732   else {
 733     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAt", "Index %d out of bounds.", index);
 734     return 0;
 735   }
 736 }
 737 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAt(UInt_t module, UInt_t index) {
 738   // get chip for the noisy pixel at position index in list of noisy
 739   if (index<GetNrNoisy(module)) {
 740     Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
 741     return GetHSFromKey(key);
 742   }
 743   else {
 744     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyHSAt", "Index %d out of bounds.", index);
 745     return 0;
 746   }
 747 }
 748 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAt(UInt_t module, UInt_t index) {
 749   // get chip for the noisy pixel at position index in list of noisy
 750   if (index<GetNrNoisy(module)) {
 751     Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
 752     return GetChipFromKey(key);
 753   }
 754   else {
 755     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyChipAt", "Index %d out of bounds.", index);
 756     return 0;
 757   }
 758 }
 759 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAt(UInt_t module, UInt_t index) {
 760   // get column for the noisy pixel at position index in list of noisy
 761   if (index<GetNrNoisy(module)) {
 762     Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
 763     return GetColFromKey(key);
 764   }
 765   else {
 766     Warning("AliITSOnlineCalibrationSPDhandler::GetNoisyColAt", "Index %d out of bounds.", index);
 767     return 0;
 768   }
 769 }
 770 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAt(UInt_t module, UInt_t index) {
 771   // get row for the noisy pixel at position index in list of noisy
 772   if (index<GetNrNoisy(module)) {
 773     Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
 774     return GetRowFromKey(key);
 775   }
 776   else {
 777     Error("AliITSOnlineCalibrationSPDhandler::GetNoisyRowAt", "Index %d out of bounds.", index);
 778     return 0;
 779   }
 780 }
 781
 782 void AliITSOnlineCalibrationSPDhandler::PrintDead() const {
 783   // print the dead pixels to screen
 784   printf("-----------------------------------\n");
 785   printf("Dead Pixels: (eqId,hs,chip,col,row)\n");
 786   printf("-----------------------------------\n");
 787   for (UInt_t module=0; module<240; module++) {
 788     for (UInt_t index=0; index<GetNrDead(module); index++) {
 789       Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
 790       UInt_t eqId = GetEqIdFromKey(key);
 791       UInt_t hs = GetHSFromKey(key);
 792       UInt_t chip = GetChipFromKey(key);
 793       UInt_t col = GetColFromKey(key);
 794       UInt_t row = GetRowFromKey(key);
 795       printf("%d,%d,%d,%d,%d\n",eqId,hs,chip,col,row);
 796     }
 797   }
 798 }
 799
 800 void AliITSOnlineCalibrationSPDhandler::PrintNoisy() const {
 801   // print the dead pixels to screen
 802   printf("-----------------------------------\n");
 803   printf("Noisy Pixels: (eqId,hs,chip,col,row)\n");
 804   printf("-----------------------------------\n");
 805   for (UInt_t module=0; module<240; module++) {
 806     for (UInt_t index=0; index<GetNrNoisy(module); index++) {
 807       Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
 808       UInt_t eqId = GetEqIdFromKey(key);
 809       UInt_t hs = GetHSFromKey(key);
 810       UInt_t chip = GetChipFromKey(key);
 811       UInt_t col = GetColFromKey(key);
 812       UInt_t row = GetRowFromKey(key);
 813       printf("%d,%d,%d,%d,%d\n",eqId,hs,chip,col,row);
 814     }
 815   }
 816 }
 817
 818 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadDiff(AliITSOnlineCalibrationSPDhandler* other) const {
 819   // returns nr of dead in this' lists and not in other's lists
 820   UInt_t returnval=0;
 821   for (UInt_t module=0; module<240; module++) {
 822     for (UInt_t ind1=0; ind1<fNrDead[module]; ind1++) {
 823       Int_t key = fDeadPixelMap[module]->GetKeyIndex(ind1);
 824       UInt_t eqId = GetEqIdFromKey(key);
 825       UInt_t hs = GetHSFromKey(key);
 826       UInt_t chip = GetChipFromKey(key);
 827       UInt_t col = GetColFromKey(key);
 828       UInt_t row = GetRowFromKey(key);
 829       if (!(other->IsPixelDead(eqId,hs,chip,col,row))) {
 830         returnval++;
 831       }
 832     }
 833   }
 834   return returnval;
 835 }
 836
 837 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisyDiff(AliITSOnlineCalibrationSPDhandler* other) const {
 838   // returns nr of noisy in this' lists and not in other's lists
 839   UInt_t returnval=0;
 840   for (UInt_t module=0; module<240; module++) {
 841     for (UInt_t ind1=0; ind1<fNrNoisy[module]; ind1++) {
 842       Int_t key = fNoisyPixelMap[module]->GetKeyIndex(ind1);
 843       UInt_t eqId = GetEqIdFromKey(key);
 844       UInt_t hs = GetHSFromKey(key);
 845       UInt_t chip = GetChipFromKey(key);
 846       UInt_t col = GetColFromKey(key);
 847       UInt_t row = GetRowFromKey(key);
 848       if (!(other->IsPixelNoisy(eqId,hs,chip,col,row))) {
 849         returnval++;
 850       }
 851     }
 852   }
 853   return returnval;
 854 }
 855
 856 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDiff(AliITSOnlineCalibrationSPDhandler* other) const {
 857   // returns nr of dead/noisy in this' lists and not in other's lists
 858   return GetNrDeadDiff(other) + GetNrNoisyDiff(other);
 859 }
 860
 861 AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetDiff(AliITSOnlineCalibrationSPDhandler* other) const {
 862   // returns handler with dead/noisy in this' lists, except for those in other's lists
 863   AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler();
 864   for (UInt_t module=0; module<240; module++) {
 865     for (UInt_t ind1=0; ind1<fNrDead[module]; ind1++) {
 866       Int_t key = fDeadPixelMap[module]->GetKeyIndex(ind1);
 867       UInt_t eqId = GetEqIdFromKey(key);
 868       UInt_t hs = GetHSFromKey(key);
 869       UInt_t chip = GetChipFromKey(key);
 870       UInt_t col = GetColFromKey(key);
 871       UInt_t row = GetRowFromKey(key);
 872       if (!(other->IsPixelDead(eqId,hs,chip,col,row))) {
 873         newHandler->SetDeadPixel(eqId,hs,chip,col,row);
 874       }
 875     }
 876     for (UInt_t ind2=0; ind2<fNrNoisy[module]; ind2++) {
 877       Int_t key = fNoisyPixelMap[module]->GetKeyIndex(ind2);
 878       UInt_t eqId = GetEqIdFromKey(key);
 879       UInt_t hs = GetHSFromKey(key);
 880       UInt_t chip = GetChipFromKey(key);
 881       UInt_t col = GetColFromKey(key);
 882       UInt_t row = GetRowFromKey(key);
 883       if (!(other->IsPixelNoisy(eqId,hs,chip,col,row))) {
 884         newHandler->SetNoisyPixel(eqId,hs,chip,col,row);
 885       }
 886     }
 887   }
 888   return newHandler;
 889 }
 890
 891 AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetDeadDiff(AliITSOnlineCalibrationSPDhandler* other) const {
 892   // returns handler with dead in this' lists, except for those in other's lists
 893   AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler();
 894   for (UInt_t module=0; module<240; module++) {
 895     for (UInt_t ind1=0; ind1<fNrDead[module]; ind1++) {
 896       Int_t key = fDeadPixelMap[module]->GetKeyIndex(ind1);
 897       UInt_t eqId = GetEqIdFromKey(key);
 898       UInt_t hs = GetHSFromKey(key);
 899       UInt_t chip = GetChipFromKey(key);
 900       UInt_t col = GetColFromKey(key);
 901       UInt_t row = GetRowFromKey(key);
 902       if (!(other->IsPixelDead(eqId,hs,chip,col,row))) {
 903         newHandler->SetDeadPixel(eqId,hs,chip,col,row);
 904       }
 905     }
 906   }
 907   return newHandler;
 908 }
 909
 910 AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetNoisyDiff(AliITSOnlineCalibrationSPDhandler* other) const {
 911   // returns handler with noisy in this' lists, except for those in other's lists
 912   AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler();
 913   for (UInt_t module=0; module<240; module++) {
 914     for (UInt_t ind2=0; ind2<fNrNoisy[module]; ind2++) {
 915       Int_t key = fNoisyPixelMap[module]->GetKeyIndex(ind2);
 916       UInt_t eqId = GetEqIdFromKey(key);
 917       UInt_t hs = GetHSFromKey(key);
 918       UInt_t chip = GetChipFromKey(key);
 919       UInt_t col = GetColFromKey(key);
 920       UInt_t row = GetRowFromKey(key);
 921       if (!(other->IsPixelNoisy(eqId,hs,chip,col,row))) {
 922         newHandler->SetNoisyPixel(eqId,hs,chip,col,row);
 923       }
 924     }
 925   }
 926   return newHandler;
 927 }
 928
 929 void AliITSOnlineCalibrationSPDhandler::InitModuleMaps() {
 930   // initializes the module mapping arrays needed for the methods below (GetEqIdFromOffline etc.)
 931   for (UInt_t iDDL=0; iDDL<20; iDDL++) {
 932     for (UInt_t iModule=0; iModule<12; iModule++) {
 933       UInt_t module = AliITSRawStreamSPD::GetModuleNumber(iDDL,iModule);
 934       fiDDL[module] = iDDL;
 935       fiModule[module] = iModule;
 936     }
 937   }
 938 }
 939
 940 void AliITSOnlineCalibrationSPDhandler::GenerateDCSConfigFile(const Char_t* fileName) {
 941   // generates an ascii file in the format as the one produced by online da (but with dummy runNr=0)
 942   ofstream dcsfile;
 943   dcsfile.open(fileName);
 944   dcsfile << "[SPD SCAN]\n";
 945   dcsfile << "RunNumber=" << "0" << "\n"; // dummy value
 946   dcsfile << "Type=" << "4" << "\n";
 947   dcsfile << "ActualDetCoonfiguration=" << "0,-1,-1\n"; // dummy values
 948   dcsfile << "[NOISY]\n";
 949   for (UInt_t module=0; module<240; module++) {
 950     UInt_t headkey=20*10*6;
 951     for (UInt_t ind=0; ind<fNrNoisy[module]; ind++) {
 952       UInt_t newkey = GetNoisyEqIdAt(module,ind)*10*6 +
 953         GetNoisyHSAt(module,ind)*10 +
 954         GetNoisyChipAt(module,ind);
 955       if (newkey!=headkey) { // print eqId,hs,chip header
 956         headkey = newkey;
 957         dcsfile << "-" << newkey/(6*10) << "," << (newkey%(6*10))/10 << "," << (newkey%(6*10))%10 << "\n";
 958       }
 959       dcsfile << GetNoisyColAt(module,ind) << "," << GetNoisyRowAt(module,ind) << "\n";
 960     }
 961   }
 962   dcsfile.close();
 963 }
 964
 965 UInt_t AliITSOnlineCalibrationSPDhandler::GetEqIdFromOffline(UInt_t module) {
 966   // module to eqId mapping
 967   if (!fModuleMapInited) InitModuleMaps();
 968   return fiDDL[module];
 969 }
 970 UInt_t AliITSOnlineCalibrationSPDhandler::GetHSFromOffline(UInt_t module) {
 971   // module to hs mapping
 972   if (!fModuleMapInited) InitModuleMaps();
 973   return fiModule[module]/2;
 974 }
 975 UInt_t AliITSOnlineCalibrationSPDhandler::GetChipFromOffline(UInt_t module, UInt_t colM) {
 976   // module,colM to chip mapping
 977   if (!fModuleMapInited) InitModuleMaps();
 978   return colM/32 + 5*(fiModule[module]%2);
 979 }
 980 UInt_t AliITSOnlineCalibrationSPDhandler::GetColFromOffline(UInt_t colM) const {
 981   // colM to col mapping
 982   return colM%32;
 983 }