X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ITS%2FAliITSOnlineCalibrationSPDhandler.cxx;h=3b06d490531c6d0f470c1e835e8aabfd69b41f68;hb=80b9610c2f7108e667b4b6978a00b37b5f83941c;hp=73b1f85e261c80b713189217095e22af92266391;hpb=4ee23d3de74ac317014e7539535b0f7ef5b94312;p=u%2Fmrichter%2FAliRoot.git diff --git a/ITS/AliITSOnlineCalibrationSPDhandler.cxx b/ITS/AliITSOnlineCalibrationSPDhandler.cxx index 73b1f85e261..3b06d490531 100644 --- a/ITS/AliITSOnlineCalibrationSPDhandler.cxx +++ b/ITS/AliITSOnlineCalibrationSPDhandler.cxx @@ -1,26 +1,12 @@ -/************************************************************************** - * Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. * - * * - * Author: The ALICE Off-line Project. * - * Contributors are mentioned in the code where appropriate. * - * * - * Permission to use, copy, modify and distribute this software and its * - * documentation strictly for non-commercial purposes is hereby granted * - * without fee, provided that the above copyright notice appears in all * - * copies and that both the copyright notice and this permission notice * - * appear in the supporting documentation. The authors make no claims * - * about the suitability of this software for any purpose. It is * - * provided "as is" without express or implied warranty. * - **************************************************************************/ - - -/* $Id$ */ - ////////////////////////////////////////////////////////////////////// // Author: Henrik Tydesjo // // For easier handling of dead and noisy pixels they are kept in // // container maps (AliITSIntMap). // -// The TArrayI objects that are put in the AliITSCalibrationSPD // +// Handling of inactive equipments,HSs,chips have been added. // +// A pixel that is either dead or inactive is called SILENT here. // +// The lists of single dead and noisy pixels are separated from the // +// information about which eq/hs/chip are inactive. // +// The TArrayS objects that are put in the AliITSCalibrationSPD // // objects can be obtained from the methods GetDeadArray and // // GetNoisyArray. // ////////////////////////////////////////////////////////////////////// @@ -30,6 +16,7 @@ #include "AliITSIntMap.h" #include #include +#include #include #include #include @@ -40,119 +27,207 @@ #include "AliCDBEntry.h" #endif +/* $Id$ */ + +//____________________________________________________________________________________________ AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler(): - fFileLocation("."), - fModuleMapInited(kFALSE) + fFileLocation(".") { // constructor - for (UInt_t module=0; module<240; module++) { - fNrDead[module]=0; - fNrNoisy[module]=0; - fDeadPixelMap[module] = new AliITSIntMap(); - fNoisyPixelMap[module] = new AliITSIntMap(); + for (UInt_t gloChip=0; gloChip<1200; gloChip++) { + fNrDead[gloChip]=0; + fNrNoisy[gloChip]=0; + fDeadPixelMap[gloChip] = new AliITSIntMap(); + fNoisyPixelMap[gloChip] = new AliITSIntMap(); } + ActivateALL(); + UnSetDeadALL(); } - +//____________________________________________________________________________________________ AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler(const AliITSOnlineCalibrationSPDhandler& handle): - fFileLocation("."), - fModuleMapInited(kFALSE) + fFileLocation(".") { // copy constructor - for (UInt_t module=0; module<240; module++) { - fNrDead[module] = handle.fNrDead[module]; - fNrNoisy[module] = handle.fNrNoisy[module]; - fDeadPixelMap[module] = handle.fDeadPixelMap[module]->Clone(); - fNoisyPixelMap[module] = handle.fNoisyPixelMap[module]->Clone(); + for (UInt_t gloChip=0; gloChip<1200; gloChip++) { + fNrDead[gloChip] = handle.fNrDead[gloChip]; + fNrNoisy[gloChip] = handle.fNrNoisy[gloChip]; + fDeadPixelMap[gloChip] = handle.fDeadPixelMap[gloChip]->Clone(); + fNoisyPixelMap[gloChip] = handle.fNoisyPixelMap[gloChip]->Clone(); + } + for (UInt_t eq=0; eq<20; eq++) { + fActiveEq[eq] = handle.fActiveEq[eq]; + for (UInt_t hs=0; hs<6; hs++) { + fActiveHS[eq][hs] = handle.fActiveHS[eq][hs]; + for (UInt_t chip=0; chip<10; chip++) { + fActiveChip[eq][hs][chip] = handle.fActiveChip[eq][hs][chip]; + } + } } fFileLocation = handle.fFileLocation; } - +//____________________________________________________________________________________________ AliITSOnlineCalibrationSPDhandler::~AliITSOnlineCalibrationSPDhandler() { - ClearMaps(); + // ClearMaps(); + for (UInt_t gloChip=0; gloChip<1200; gloChip++) { + delete fDeadPixelMap[gloChip]; + delete fNoisyPixelMap[gloChip]; + } } - +//____________________________________________________________________________________________ AliITSOnlineCalibrationSPDhandler& AliITSOnlineCalibrationSPDhandler::operator=(const AliITSOnlineCalibrationSPDhandler& handle) { // assignment operator if (this!=&handle) { this->ClearMaps(); - for (UInt_t module=0; module<240; module++) { - fNrDead[module] = handle.fNrDead[module]; - fNrNoisy[module] = handle.fNrNoisy[module]; - fDeadPixelMap[module] = handle.fDeadPixelMap[module]->Clone(); - fNoisyPixelMap[module] = handle.fNoisyPixelMap[module]->Clone(); + for (UInt_t gloChip=0; gloChip<1200; gloChip++) { + fNrDead[gloChip] = handle.fNrDead[gloChip]; + fNrNoisy[gloChip] = handle.fNrNoisy[gloChip]; + fDeadPixelMap[gloChip] = handle.fDeadPixelMap[gloChip]->Clone(); + fNoisyPixelMap[gloChip] = handle.fNoisyPixelMap[gloChip]->Clone(); + } + for (UInt_t eq=0; eq<20; eq++) { + fActiveEq[eq] = handle.fActiveEq[eq]; + for (UInt_t hs=0; hs<6; hs++) { + fActiveHS[eq][hs] = handle.fActiveHS[eq][hs]; + for (UInt_t chip=0; chip<10; chip++) { + fActiveChip[eq][hs][chip] = handle.fActiveChip[eq][hs][chip]; + } + } } fFileLocation = handle.fFileLocation; } return *this; } - +//____________________________________________________________________________________________ void AliITSOnlineCalibrationSPDhandler::ClearMaps() { // clear the lists of dead and noisy ResetDead(); ResetNoisy(); + ActivateALL(); +} +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::ResetDead() { + // reset the dead pixel map and inactive eq,hs,chip + UnSetDeadALL(); + for (UInt_t gloChip=0; gloChip<1200; gloChip++) { + fNrDead[gloChip]=0; + fDeadPixelMap[gloChip]->Clear(); + } +} +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::ResetNoisy() { + // clear the list of noisy pixels + for (UInt_t gloChip=0; gloChip<1200; gloChip++) { + fNrNoisy[gloChip]=0; + fNoisyPixelMap[gloChip]->Clear(); + } +} +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::ResetDeadForChip(UInt_t eq, UInt_t hs, UInt_t chip) { + // clear the dead pixels for this chip + SetDeadChip(eq,hs,chip,kFALSE); + UInt_t gloChip = GetGloChip(eq,hs,chip); + for (UInt_t col=0; col<32; col++) { + for (UInt_t row=0; row<256; row++) { + Int_t key = GetKey(eq,hs,chip,col,row); + if (fDeadPixelMap[gloChip]->Remove(key)) { + fNrDead[gloChip]--; + } + } + } +} +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::ResetNoisyForChip(UInt_t eq, UInt_t hs, UInt_t chip) { + // clear the noisy pixels for this chip + UInt_t gloChip = GetGloChip(eq,hs,chip); + if (gloChip>=1200) { + Error("AliITSOnlineCalibrationSPDhandler::ResetNoisyForChip","global chip nr (%d) out of bounds\n",gloChip); + return; + } + for (UInt_t col=0; col<32; col++) { + for (UInt_t row=0; row<256; row++) { + Int_t key = GetKey(eq,hs,chip,col,row); + if (fNoisyPixelMap[gloChip]->Remove(key)) { + fNrNoisy[gloChip]--; + } + } + } +} +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::ResetDeadForEq(UInt_t eq) { + // clear the dead pixels for this eq + if (eq>=20) { + Error("AliITSOnlineCalibrationSPDhandler::ResetDeadForEq", "eq (%d) out of bounds.",eq); + return; + } + for (UInt_t hs=0; hs<6; hs++) { + for (UInt_t chip=0; chip<10; chip++) { + ResetDeadForChip(eq, hs, chip); + } + } +} +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::ResetNoisyForEq(UInt_t eq) { + // clear the noisy pixels for this eq + if (eq>=20) { + Error("AliITSOnlineCalibrationSPDhandler::ResetNoisyForEq", "eq (%d) out of bounds.",eq); + return; + } + for (UInt_t hs=0; hs<6; hs++) { + for (UInt_t chip=0; chip<10; chip++) { + ResetNoisyForChip(eq, hs, chip); + } + } } + +//____________________________________________________________________________________________ Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromFiles() { - // read dead and noisy files from file location. returns true if at least one file found + // read files from file location (active,dead,noisy info). returns true if at least one file found + Bool_t b1 = ReadNoisyFromFiles(); + Bool_t b2 = ReadSilentFromFiles(); + return (b1 || b2); +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::ReadSilentFromFiles() { + // read dead,active files from file location. returns true if at least one file found Bool_t returnval=kFALSE; - for (UInt_t module=0; module<240; module++) { - if (ReadFromFile(module)) { + for (UInt_t eq=0; eq<20; eq++) { + if (ReadSilentFromFile(eq)) { returnval=kTRUE; } } return returnval; } -Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromFile(UInt_t module) { - // read dead and noisy files for module from file location. - TString fileName = Form("%s/SPD_DeadNoisy_%d.root",fFileLocation.Data(),module); - return ReadFromFileName(fileName.Data()); -} -Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromFileName(const char *fileName) { - // read dead and noisy from file fileName - AliITSOnlineCalibrationSPD* calib; - FILE* fp0 = fopen(fileName, "r"); - if (fp0 == NULL) {return kFALSE;} - else { - fclose(fp0); - TFile file(fileName, "READ"); - if (file.IsOpen()) { - file.GetObject("AliITSOnlineCalibrationSPD", calib); - file.Close(); - if (calib!=NULL) { - UInt_t module = calib->GetModuleNr(); - Int_t nrDead=calib->GetNrDead(); - for (Int_t index=0; indexGetDeadColAt(index); - UInt_t row=calib->GetDeadRowAt(index); - SetDeadPixelM(module,colM,row); - } - Int_t nrNoisy=calib->GetNrNoisy(); - for (Int_t index=0; indexGetNoisyColAt(index); - UInt_t row=calib->GetNoisyRowAt(index); - SetNoisyPixelM(module,colM,row); - } - } - } - } - return kTRUE; -} +//____________________________________________________________________________________________ Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFiles() { - // read dead files from file location. returns true if at least one file found + // read dead,active files from file location. returns true if at least one file found Bool_t returnval=kFALSE; - for (UInt_t module=0; module<240; module++) { - if (ReadDeadFromFile(module)) { + for (UInt_t eq=0; eq<20; eq++) { + if (ReadDeadFromFile(eq)) { returnval=kTRUE; } } return returnval; } -Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFile(UInt_t module) { - // read dead for module from file location. - TString fileName = Form("%s/SPD_DeadNoisy_%d.root",fFileLocation.Data(),module); +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::ReadSilentFromFile(UInt_t eq) { + // read dead file for eq from file location. + TString fileName = Form("%s/SPD_Dead_%d.root",fFileLocation.Data(),eq); + return ReadSilentFromFileName(fileName.Data()); +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFile(UInt_t eq) { + // read dead file for eq from file location. + TString fileName = Form("%s/SPD_Dead_%d.root",fFileLocation.Data(),eq); return ReadDeadFromFileName(fileName.Data()); } -Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFileName(const char *fileName) { +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::ReadSilentFromFileName(const char *fileName) { + // read dead from file fileName (including inactive) + return ReadDeadFromFileName(fileName, kTRUE); +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFileName(const char *fileName, Bool_t inactive) { // read dead from file fileName AliITSOnlineCalibrationSPD* calib; FILE* fp0 = fopen(fileName, "r"); @@ -164,33 +239,63 @@ Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFileName(const char *fileN file.GetObject("AliITSOnlineCalibrationSPD", calib); file.Close(); if (calib!=NULL) { - UInt_t module = calib->GetModuleNr(); - Int_t nrDead=calib->GetNrDead(); - for (Int_t index=0; indexGetDeadColAt(index); - UInt_t row=calib->GetDeadRowAt(index); - SetDeadPixelM(module,colM,row); + UInt_t nrDead=calib->GetNrBad(); + for (UInt_t index=0; indexGetKeyAt(index); + UInt_t eq = GetEqIdFromKey(key); + UInt_t hs = GetHSFromKey(key); + UInt_t chip = GetChipFromKey(key); + UInt_t col = GetColFromKey(key); + UInt_t row = GetRowFromKey(key); + SetDeadPixel(eq,hs,chip,col,row); + } + UInt_t eq1 = calib->GetEqNr(); + if (calib->IsDeadEq()) SetDeadEq(eq1); + else SetDeadEq(eq1,kFALSE); + for (UInt_t hs=0; hs<6; hs++) { + if (calib->IsDeadHS(hs)) SetDeadHS(eq1,hs); + else SetDeadHS(eq1,hs,kFALSE); + for (UInt_t chip=0; chip<10; chip++) { + if (calib->IsDeadChip(hs,chip)) SetDeadChip(eq1,hs,chip); + else SetDeadChip(eq1,hs,chip,kFALSE); + } + } + if (inactive) { + UInt_t eq = calib->GetEqNr(); + if (calib->IsActiveEq()) ActivateEq(eq); + else ActivateEq(eq,kFALSE); + for (UInt_t hs=0; hs<6; hs++) { + if (calib->IsActiveHS(hs)) ActivateHS(eq,hs); + else ActivateHS(eq,hs,kFALSE); + for (UInt_t chip=0; chip<10; chip++) { + if (calib->IsActiveChip(hs,chip)) ActivateChip(eq,hs,chip); + else ActivateChip(eq,hs,chip,kFALSE); + } + } } } } } return kTRUE; } +//____________________________________________________________________________________________ Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFiles() { // read noisy files from file location. returns true if at least one file found Bool_t returnval=kFALSE; - for (UInt_t module=0; module<240; module++) { - if (ReadNoisyFromFile(module)) { + for (UInt_t eq=0; eq<20; eq++) { + if (ReadNoisyFromFile(eq)) { returnval=kTRUE; } } return returnval; } -Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFile(UInt_t module) { - // read noisy for module from file location. - TString fileName = Form("%s/SPD_DeadNoisy_%d.root",fFileLocation.Data(),module); +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFile(UInt_t eq) { + // read noisy file for eq from file location. + TString fileName = Form("%s/SPD_Noisy_%d.root",fFileLocation.Data(),eq); return ReadNoisyFromFileName(fileName.Data()); } +//____________________________________________________________________________________________ Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFileName(const char *fileName) { // read noisy from file fileName AliITSOnlineCalibrationSPD* calib; @@ -203,38 +308,43 @@ Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFileName(const char *file file.GetObject("AliITSOnlineCalibrationSPD", calib); file.Close(); if (calib!=NULL) { - UInt_t module = calib->GetModuleNr(); - Int_t nrNoisy=calib->GetNrNoisy(); - for (Int_t index=0; indexGetNoisyColAt(index); - UInt_t row=calib->GetNoisyRowAt(index); - SetNoisyPixelM(module,colM,row); + UInt_t nrNoisy=calib->GetNrBad(); + for (UInt_t index=0; indexGetKeyAt(index); + UInt_t eq = GetEqIdFromKey(key); + UInt_t hs = GetHSFromKey(key); + UInt_t chip = GetChipFromKey(key); + UInt_t col = GetColFromKey(key); + UInt_t row = GetRowFromKey(key); + SetNoisyPixel(eq,hs,chip,col,row); } } } } return kTRUE; } - - -UInt_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromText(const char *fileName) { - // read dead from a text file (lines with eqId,hs,chip,col,row). returns nr of pixels added (not already there) +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromText(const char *fileName, UInt_t module) { + // read dead from a text file (lines with eq,hs,chip,col,row). returns nr of pixels added (not already here) + // insert only those pixels that belong to module (or all if module=240). UInt_t newNrDead=0; ifstream textFile; textFile.open(fileName, ifstream::in); if (textFile.fail()) { - Error("AliITSOnlineCalibrationSPDhandler::ReadDeadFromText","No noisy text file (%s) present.",fileName); + Warning("AliITSOnlineCalibrationSPDhandler::ReadDeadFromText","No dead text file (%s) present.",fileName); } else { while(1) { - UInt_t eqId,hs,chip,col,row; - textFile >> eqId; if (textFile.eof()) break; + UInt_t eq,hs,chip,col,row; + textFile >> eq; if (textFile.eof()) break; textFile >> hs; if (textFile.eof()) break; textFile >> chip; if (textFile.eof()) break; textFile >> col; if (textFile.eof()) break; textFile >> row; - if (SetDeadPixel(eqId,hs,chip,col,row)) { - newNrDead++; + if (module==240 || (Int_t)module==AliITSRawStreamSPD::GetModuleNumber(eq,hs,chip)){ + if (SetDeadPixel(eq,hs,chip,col,row)) { + newNrDead++; + } } if (textFile.eof()) break; } @@ -242,25 +352,28 @@ UInt_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromText(const char *fileName) } return newNrDead; } - -UInt_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromText(const char *fileName) { - // read noisy from a text file (lines with eqId,hs,chip,col,row). returns nr of pixels added (not already here) +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromText(const char *fileName, UInt_t module) { + // read noisy from a text file (lines with eq,hs,chip,col,row). returns nr of pixels added (not already here) + // insert only those pixels that belong to module (or all if module=240). UInt_t newNrNoisy=0; ifstream textFile; textFile.open(fileName, ifstream::in); if (textFile.fail()) { - Error("AliITSOnlineCalibrationSPDhandler::ReadNoisyFromText","No noisy text file (%s) present.",fileName); + Warning("AliITSOnlineCalibrationSPDhandler::ReadNoisyFromText","No noisy text file (%s) present.",fileName); } else { while(1) { - UInt_t eqId,hs,chip,col,row; - textFile >> eqId; if (textFile.eof()) break; + UInt_t eq,hs,chip,col,row; + textFile >> eq; if (textFile.eof()) break; textFile >> hs; if (textFile.eof()) break; textFile >> chip; if (textFile.eof()) break; textFile >> col; if (textFile.eof()) break; textFile >> row; - if (SetNoisyPixel(eqId,hs,chip,col,row)) { - newNrNoisy++; + if (module==240 || (Int_t)module==AliITSRawStreamSPD::GetModuleNumber(eq,hs,chip)){ + if (SetNoisyPixel(eq,hs,chip,col,row)) { + newNrNoisy++; + } } if (textFile.eof()) break; } @@ -268,105 +381,466 @@ UInt_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromText(const char *fileName } return newNrNoisy; } +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::WriteToFilesAlways() { + // write the lists of active,dead,noisy to files + for (UInt_t eq=0; eq<20; eq++) { + WriteSilentToFile(eq); + WriteNoisyToFile(eq); + } +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::WriteToFiles() { + // write the lists of dead and noisy to files (only if there are >0 dead or noisy pixels) , returns nr of files produced + return (WriteNoisyToFiles() + WriteSilentToFiles()); +} +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::WriteSilentToFilesAlways() { + // write the lists of silent to files + for (UInt_t eq=0; eq<20; eq++) { + WriteSilentToFile(eq); + } +} +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::WriteDeadToFilesAlways() { + // write the lists of dead to files + for (UInt_t eq=0; eq<20; eq++) { + WriteDeadToFile(eq); + } +} +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::WriteNoisyToFilesAlways() { + // write the lists of noisy to files + for (UInt_t eq=0; eq<20; eq++) { + WriteNoisyToFile(eq); + } +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::WriteSilentToFiles() { + // write the list of silent to file (only if there are >0 silent pixels) , returns nr of files produced + UInt_t nrFiles=0; + for (UInt_t eq=0; eq<20; eq++) { + if (GetNrSilentEq(eq) > 0) { + WriteSilentToFile(eq); + nrFiles++; + } + } + return nrFiles; +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::WriteDeadToFiles() { + // write the list of dead to file (only if there are >0 dead pixels) , returns nr of files produced + UInt_t nrFiles=0; + for (UInt_t eq=0; eq<20; eq++) { + if (GetNrDeadEq(eq) > 0) { + WriteDeadToFile(eq); + nrFiles++; + } + } + return nrFiles; +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::WriteNoisyToFiles() { + // write the list of noisy to file (only if there are >0 noisy pixels) , returns nr of files produced + UInt_t nrFiles=0; + for (UInt_t eq=0; eq<20; eq++) { + if (GetNrNoisyEq(eq) > 0) { + WriteNoisyToFile(eq); + nrFiles++; + } + } + return nrFiles; +} +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::WriteSilentToFile(UInt_t eq) { + WriteDeadToFile(eq,kTRUE); +} +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::WriteDeadToFile(UInt_t eq, Bool_t inactive) { + // write the lists of dead (and inactive if input boolean is true) for eq to file + AliITSOnlineCalibrationSPD* calib = new AliITSOnlineCalibrationSPD(); + calib->SetEqNr(eq); + calib->SetBadList(GetDeadArrayOnline(eq)); + calib->SetNrBad(GetNrDeadEq(eq)); + if (IsDeadEq(eq)) calib->SetDeadEq(); + else calib->SetDeadEq(kFALSE); + for (UInt_t hs=0; hs<6; hs++) { + if (IsDeadHS(eq,hs)) calib->SetDeadHS(hs); + else calib->SetDeadHS(hs,kFALSE); + for (UInt_t chip=0; chip<10; chip++) { + if (IsDeadChip(eq,hs,chip)) calib->SetDeadChip(hs,chip); + else calib->SetDeadChip(hs,chip,kFALSE); + } + } + if (inactive) { + if (IsActiveEq(eq)) calib->ActivateEq(); + else calib->ActivateEq(kFALSE); + for (UInt_t hs=0; hs<6; hs++) { + if (IsActiveHS(eq,hs)) calib->ActivateHS(hs); + else calib->ActivateHS(hs,kFALSE); + for (UInt_t chip=0; chip<10; chip++) { + if (IsActiveChip(eq,hs,chip)) calib->ActivateChip(hs,chip); + else calib->ActivateChip(hs,chip,kFALSE); + } + } + } + TString fileName = Form("%s/SPD_Dead_%d.root",fFileLocation.Data(),eq); + TFile file(fileName.Data(), "RECREATE"); + file.WriteTObject(calib, "AliITSOnlineCalibrationSPD"); + file.Close(); + delete calib; +} +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::WriteNoisyToFile(UInt_t eq) { + // write the lists of noisy for eq to file + AliITSOnlineCalibrationSPD* calib = new AliITSOnlineCalibrationSPD(); + calib->SetEqNr(eq); + calib->SetBadList(GetNoisyArrayOnline(eq)); + calib->SetNrBad(GetNrNoisyEq(eq)); + TString fileName = Form("%s/SPD_Noisy_%d.root",fFileLocation.Data(),eq); + TFile file(fileName.Data(), "RECREATE"); + file.WriteTObject(calib, "AliITSOnlineCalibrationSPD"); + file.Close(); + delete calib; +} +//____________________________________________________________________________________________ +#ifndef SPD_DA_OFF +Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadModuleFromDB(UInt_t module, Int_t runNr, const Char_t *storage, Bool_t treeSerial) { + // reads dead pixels from DB for given module and runNr + AliCDBManager* man = AliCDBManager::Instance(); + TString storageSTR = Form("%s",storage); + if (storageSTR.CompareTo("default")==0) { + if(!man->IsDefaultStorageSet()) { + man->SetDefaultStorage("local://$ALICE_ROOT/OCDB"); + } + } + else { + storageSTR = Form("local://%s",storage); + man->SetDefaultStorage(storageSTR.Data()); + } + AliCDBEntry *cdbEntry = man->Get("ITS/Calib/SPDDead", runNr); + TObjArray* spdEntry; + if(cdbEntry) { + spdEntry = (TObjArray*)cdbEntry->GetObject(); + if(!spdEntry) return kFALSE; + } + else { + Warning("AliITSOnlineCalibrationSPDhandler::ReadDeadModuleFromDB","Calibration for run %d not found in database.",runNr); + return kFALSE; + } + AliITSCalibrationSPD* calibSPD; + calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module); + UInt_t nrDead = calibSPD->GetNrBadSingle(); + if (nrDead>0) { + if (!treeSerial) RecursiveInsertDead(calibSPD,module,0,nrDead-1); + else { + for (UInt_t index=0; indexGetBadColAt(index); + UInt_t rowM = calibSPD->GetBadRowAt(index); + SetDeadPixelM(module,colM,rowM); + } + } + } + for (UInt_t chipIndex=0; chipIndex<5; chipIndex++) { + UInt_t eq,hs,chip,col,row; + AliITSRawStreamSPD::OfflineToOnline(module, chipIndex*32, 0, eq, hs, chip, col, row); + if (calibSPD->IsChipBad(chipIndex)) { + SetDeadChip(eq,hs,chip); + } + else { + SetDeadChip(eq,hs,chip,kFALSE); + } + } -#ifndef SPD_DA_OFF -Bool_t AliITSOnlineCalibrationSPDhandler::ReadModuleFromDB(UInt_t module, Int_t runNr) { - // reads dead and noisy pixels from DB for given module and runNr + spdEntry->SetOwner(kTRUE); + spdEntry->Clear(); + return kTRUE; +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyModuleFromDB(UInt_t module, Int_t runNr, const Char_t *storage, Bool_t treeSerial) { + // reads noisy pixels from DB for given module and runNr AliCDBManager* man = AliCDBManager::Instance(); - if(!man->IsDefaultStorageSet()) { - man->SetDefaultStorage("local://$ALICE_ROOT"); + TString storageSTR = Form("%s",storage); + if (storageSTR.CompareTo("default")==0) { + if(!man->IsDefaultStorageSet()) { + man->SetDefaultStorage("local://$ALICE_ROOT/OCDB"); + } + } + else { + storageSTR = Form("local://%s",storage); + man->SetDefaultStorage(storageSTR.Data()); } - AliCDBEntry *cdbEntry = man->Get("ITS/Calib/CalibSPD", runNr); + AliCDBEntry *cdbEntry = man->Get("ITS/Calib/SPDNoisy", runNr); TObjArray* spdEntry; if(cdbEntry) { spdEntry = (TObjArray*)cdbEntry->GetObject(); if(!spdEntry) return kFALSE; } else { - Warning("AliITSOnlineCalibrationSPDhandler::ReadModuleFromDB","Calibration for run %d not found in database.",runNr); + Warning("AliITSOnlineCalibrationSPDhandler::ReadNoisyModuleFromDB","Calibration for run %d not found in database.",runNr); return kFALSE; } AliITSCalibrationSPD* calibSPD; calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module); - UInt_t nrDead = calibSPD->GetNrDead(); - for (UInt_t index=0; indexGetDeadColAt(index); - UInt_t row = calibSPD->GetDeadRowAt(index); - SetDeadPixelM(module,colM,row); - } - UInt_t nrNoisy = calibSPD->GetNrNoisy(); - for (UInt_t index=0; indexGetNoisyColAt(index); - UInt_t row = calibSPD->GetNoisyRowAt(index); - SetNoisyPixelM(module,colM,row); + UInt_t nrNoisy = calibSPD->GetNrBadSingle(); + if (nrNoisy>0) { + if (!treeSerial) RecursiveInsertNoisy(calibSPD,module,0,nrNoisy-1); + else { + for (UInt_t index=0; indexGetBadColAt(index); + UInt_t rowM = calibSPD->GetBadRowAt(index); + SetNoisyPixelM(module,colM,rowM); + } + } } spdEntry->SetOwner(kTRUE); spdEntry->Clear(); return kTRUE; } - -Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromDB(Int_t runNr) { +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromDB(Int_t runNr, const Char_t *storage, Bool_t treeSerial) { // reads dead and noisy pixels from DB for given runNr // note that you may want to clear the lists (if they are not empty) before reading + return (ReadNoisyFromDB(runNr,storage,treeSerial) && ReadDeadFromDB(runNr,storage,treeSerial)); +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromDB(Int_t runNr, const Char_t *storage, Bool_t treeSerial) { + // reads dead pixels from DB for given runNr + // note that you may want to clear the list (if it is not empty) before reading AliCDBManager* man = AliCDBManager::Instance(); - if(!man->IsDefaultStorageSet()) { - man->SetDefaultStorage("local://$ALICE_ROOT"); + TString storageSTR = Form("%s",storage); + if (storageSTR.CompareTo("default")==0) { + if(!man->IsDefaultStorageSet()) { + man->SetDefaultStorage("local://$ALICE_ROOT/OCDB"); + } + } + else { + storageSTR = Form("local://%s",storage); + man->SetDefaultStorage(storageSTR.Data()); } - AliCDBEntry *cdbEntry = man->Get("ITS/Calib/CalibSPD", runNr); + AliCDBEntry *cdbEntry = man->Get("ITS/Calib/SPDDead", runNr); TObjArray* spdEntry; if(cdbEntry) { spdEntry = (TObjArray*)cdbEntry->GetObject(); if(!spdEntry) return kFALSE; } else { - Warning("AliITSOnlineCalibrationSPDhandler::ReadFromDB","Calibration for run %d not found in database.",runNr); + Warning("AliITSOnlineCalibrationSPDhandler::ReadDeadFromDB","Calibration for run %d not found in database.",runNr); return kFALSE; } AliITSCalibrationSPD* calibSPD; for (UInt_t module=0; module<240; module++) { - // printf("Reading module %d\n",module); calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module); - UInt_t nrDead = calibSPD->GetNrDead(); - for (UInt_t index=0; indexGetDeadColAt(index); - UInt_t row = calibSPD->GetDeadRowAt(index); - SetDeadPixelM(module,colM,row); + UInt_t nrDead = calibSPD->GetNrBadSingle(); + if (nrDead>0) { + if (!treeSerial) { + RecursiveInsertDead(calibSPD,module,0,nrDead-1); + } + + else { + for (UInt_t index=0; indexGetBadColAt(index); + UInt_t rowM = calibSPD->GetBadRowAt(index); + SetDeadPixelM(module,colM,rowM); + } + } + } + for (UInt_t chipIndex=0; chipIndex<5; chipIndex++) { + UInt_t eq,hs,chip,col,row; + AliITSRawStreamSPD::OfflineToOnline(module, chipIndex*32, 0, eq, hs, chip, col, row); + if (calibSPD->IsChipBad(chipIndex)) { + SetDeadChip(eq,hs,chip); + } + else { + SetDeadChip(eq,hs,chip,kFALSE); + } + } + } + spdEntry->SetOwner(kTRUE); + spdEntry->Clear(); + return kTRUE; +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromDB(Int_t runNr, const Char_t *storage, Bool_t treeSerial) { + // reads noisy pixels from DB for given runNr + // note that you may want to clear the list (if it is not empty) before reading + AliCDBManager* man = AliCDBManager::Instance(); + TString storageSTR = Form("%s",storage); + if (storageSTR.CompareTo("default")==0) { + if(!man->IsDefaultStorageSet()) { + man->SetDefaultStorage("local://$ALICE_ROOT/OCDB"); } - UInt_t nrNoisy = calibSPD->GetNrNoisy(); - for (UInt_t index=0; indexGetNoisyColAt(index); - UInt_t row = calibSPD->GetNoisyRowAt(index); - SetNoisyPixelM(module,colM,row); + } + else { + storageSTR = Form("local://%s",storage); + man->SetDefaultStorage(storageSTR.Data()); + } + AliCDBEntry *cdbEntry = man->Get("ITS/Calib/SPDNoisy", runNr); + TObjArray* spdEntry; + if(cdbEntry) { + spdEntry = (TObjArray*)cdbEntry->GetObject(); + if(!spdEntry) return kFALSE; + } + else { + Warning("AliITSOnlineCalibrationSPDhandler::ReadNoisyFromDB","Calibration for run %d not found in database.",runNr); + return kFALSE; + } + AliITSCalibrationSPD* calibSPD; + for (UInt_t module=0; module<240; module++) { + calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module); + UInt_t nrNoisy = calibSPD->GetNrBadSingle(); + if (nrNoisy>0) { + if (!treeSerial) { + RecursiveInsertNoisy(calibSPD,module,0,nrNoisy-1); + } + else { + for (UInt_t index=0; indexGetBadColAt(index); + UInt_t rowM = calibSPD->GetBadRowAt(index); + SetNoisyPixelM(module,colM,rowM); + } + } } } spdEntry->SetOwner(kTRUE); spdEntry->Clear(); return kTRUE; } +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromDBasNoisy(Int_t runNr, const Char_t *storage, Bool_t treeSerial) { + // reads dead pixels (put as noisy) from DB for given runNr + // note that you may want to clear the list (if it is not empty) before reading + AliCDBManager* man = AliCDBManager::Instance(); + TString storageSTR = Form("%s",storage); + if (storageSTR.CompareTo("default")==0) { + if(!man->IsDefaultStorageSet()) { + man->SetDefaultStorage("local://$ALICE_ROOT/OCDB"); + } + } + else { + storageSTR = Form("local://%s",storage); + man->SetDefaultStorage(storageSTR.Data()); + } + AliCDBEntry *cdbEntry = man->Get("ITS/Calib/SPDNoisy", runNr); + TObjArray* spdEntry; + if(cdbEntry) { + spdEntry = (TObjArray*)cdbEntry->GetObject(); + if(!spdEntry) return kFALSE; + } + else { + Warning("AliITSOnlineCalibrationSPDhandler::ReadDeadFromDBasNoisy","Calibration for run %d not found in database.",runNr); + return kFALSE; + } + AliITSCalibrationSPD* calibSPD; + for (UInt_t module=0; module<240; module++) { + calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module); + UInt_t nrDead = calibSPD->GetNrBadSingle(); + if (nrDead>0) { + if (!treeSerial) { + RecursiveInsertDead(calibSPD,module,0,nrDead-1); + } -Bool_t AliITSOnlineCalibrationSPDhandler::WriteToDB(Int_t runNrStart, Int_t runNrEnd) { - // writes dead and noisy pixels to DB for given runNr + else { + for (UInt_t index=0; indexGetBadColAt(index); + UInt_t rowM = calibSPD->GetBadRowAt(index); + SetDeadPixelM(module,colM,rowM); + } + } + } + for (UInt_t chipIndex=0; chipIndex<5; chipIndex++) { + UInt_t eq,hs,chip,col,row; + AliITSRawStreamSPD::OfflineToOnline(module, chipIndex*32, 0, eq, hs, chip, col, row); + if (calibSPD->IsChipBad(chipIndex)) { + SetDeadChip(eq,hs,chip); + } + else { + SetDeadChip(eq,hs,chip,kFALSE); + } + } + } + spdEntry->SetOwner(kTRUE); + spdEntry->Clear(); + return kTRUE; +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromCalibObj(TObjArray* calObj) { + // reads dead pixels from calib object + for (UInt_t module=0; module<240; module++) { + AliITSCalibrationSPD* calibSPD = (AliITSCalibrationSPD*)calObj->At(module); + for (Int_t i=0; iGetNrBadSingle(); i++) { + SetDeadPixelM(module,calibSPD->GetBadColAt(i),calibSPD->GetBadRowAt(i)); + } + for (UInt_t chipIndex=0; chipIndex<5; chipIndex++) { + UInt_t eq,hs,chip,col,row; + AliITSRawStreamSPD::OfflineToOnline(module, chipIndex*32, 0, eq, hs, chip, col, row); + if (calibSPD->IsChipBad(chipIndex)) { + SetDeadChip(eq,hs,chip); + } + else { + SetDeadChip(eq,hs,chip,kFALSE); + } + } + } + return kTRUE; +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromCalibObj(TObjArray* calObj) { + // reads noisy pixels from calib object + for (UInt_t module=0; module<240; module++) { + AliITSCalibrationSPD* calibSPD = (AliITSCalibrationSPD*)calObj->At(module); + for (Int_t i=0; iGetNrBadSingle(); i++) { + SetNoisyPixelM(module,calibSPD->GetBadColAt(i),calibSPD->GetBadRowAt(i)); + } + } + return kTRUE; +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::WriteToDB(Int_t runNrStart, Int_t runNrEnd, const Char_t *storage) { + // writes dead and noisy pixels to DB for given runNrs + // overwrites any previous entries + return (WriteNoisyToDB(runNrStart,runNrEnd,storage) && WriteDeadToDB(runNrStart,runNrEnd,storage)); +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::WriteDeadToDB(Int_t runNrStart, Int_t runNrEnd, const Char_t *storage) { + // writes dead pixels to DB for given runNrs // overwrites any previous entries AliCDBManager* man = AliCDBManager::Instance(); - if(!man->IsDefaultStorageSet()) { - man->SetDefaultStorage("local://$ALICE_ROOT"); + TString storageSTR = Form("%s",storage); + if (storageSTR.CompareTo("default")==0) { + if(!man->IsDefaultStorageSet()) { + man->SetDefaultStorage("local://$ALICE_ROOT/OCDB"); + } + } + else { + storageSTR = Form("local://%s",storage); + man->SetDefaultStorage(storageSTR.Data()); } AliCDBMetaData* metaData = new AliCDBMetaData(); metaData->SetResponsible("Henrik Tydesjo"); metaData->SetComment("Created by AliITSOnlineCalibrationSPDhandler."); - AliCDBId idCalSPD("ITS/Calib/CalibSPD",runNrStart,runNrEnd); + AliCDBId idCalSPD("ITS/Calib/SPDDead",runNrStart,runNrEnd); TObjArray* spdEntry = new TObjArray(240); spdEntry->SetOwner(kTRUE); for(UInt_t module=0; module<240; module++){ - AliITSCalibrationSPD* calObj = new AliITSCalibrationSPD(); - spdEntry->Add(calObj); + AliITSCalibrationSPD* calibSPD = new AliITSCalibrationSPD(); + spdEntry->Add(calibSPD); } for(UInt_t module=0; module<240; module++){ - ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetNrDead( GetNrDead(module) ); - ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetDeadList( GetDeadArray(module) ); - ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetNrNoisy( GetNrNoisy(module) ); - ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetNoisyList( GetNoisyArray(module) ); + AliITSCalibrationSPD* calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module); + calibSPD->SetNrBadSingle( GetNrDeadSingle(module) ); + calibSPD->SetBadList( GetDeadArray(module) ); + for (UInt_t chipIndex=0; chipIndex<5; chipIndex++) { + UInt_t eq,hs,chip,col,row; + AliITSRawStreamSPD::OfflineToOnline(module, chipIndex*32, 0, eq, hs, chip, col, row); + if (IsSilentChip(eq,hs,chip)) { + calibSPD->SetChipBad(chipIndex); + } + else { + calibSPD->UnSetChipBad(chipIndex); + } + } } AliCDBEntry* cdbEntry = new AliCDBEntry((TObject*)spdEntry,idCalSPD,metaData); man->Put(cdbEntry); @@ -375,628 +849,2081 @@ Bool_t AliITSOnlineCalibrationSPDhandler::WriteToDB(Int_t runNrStart, Int_t runN delete metaData; return kTRUE; } -#endif - -void AliITSOnlineCalibrationSPDhandler::WriteToFiles() { - // write the lists of dead and noisy to files (only if there are >0 dead or noisy pixels) - for (UInt_t module=0; module<240; module++) { - if (fNrDead[module]+fNrNoisy[module] > 0) { - WriteToFile(module); +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::WriteDeadToDBasNoisy(Int_t runNrStart, Int_t runNrEnd, const Char_t *storage) { + // writes dead pixels to DB for given runNrs + // overwrites any previous entries + AliCDBManager* man = AliCDBManager::Instance(); + TString storageSTR = Form("%s",storage); + if (storageSTR.CompareTo("default")==0) { + if(!man->IsDefaultStorageSet()) { + man->SetDefaultStorage("local://$ALICE_ROOT/OCDB"); } } -} -void AliITSOnlineCalibrationSPDhandler::WriteToFile(UInt_t module) { - // write the lists of dead and noisy for module to file - AliITSOnlineCalibrationSPD* calib = new AliITSOnlineCalibrationSPD(); - calib->SetModuleNr(module); - calib->SetDeadList(GetDeadArray(module)); - calib->SetNoisyList(GetNoisyArray(module)); - calib->SetNrDead(GetNrDead(module)); - calib->SetNrNoisy(GetNrNoisy(module)); - TString fileName = Form("%s/SPD_DeadNoisy_%d.root",fFileLocation.Data(),module); - TFile file(fileName.Data(), "RECREATE"); - file.WriteTObject(calib, "AliITSOnlineCalibrationSPD"); - file.Close(); - delete calib; -} -void AliITSOnlineCalibrationSPDhandler::WriteDeadToFiles() { - // write the lists of dead to files (only if there are >0 dead pixels) - for (UInt_t module=0; module<240; module++) { - if (fNrDead[module] > 0) { - WriteDeadToFile(module); + else { + storageSTR = Form("local://%s",storage); + man->SetDefaultStorage(storageSTR.Data()); + } + AliCDBMetaData* metaData = new AliCDBMetaData(); + metaData->SetResponsible("Henrik Tydesjo"); + metaData->SetComment("Created by AliITSOnlineCalibrationSPDhandler."); + AliCDBId idCalSPD("ITS/Calib/SPDNoisy",runNrStart,runNrEnd); + TObjArray* spdEntry = new TObjArray(240); + spdEntry->SetOwner(kTRUE); + for(UInt_t module=0; module<240; module++){ + AliITSCalibrationSPD* calibSPD = new AliITSCalibrationSPD(); + spdEntry->Add(calibSPD); + } + for(UInt_t module=0; module<240; module++){ + AliITSCalibrationSPD* calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module); + calibSPD->SetNrBadSingle( GetNrDeadSingle(module) ); + calibSPD->SetBadList( GetDeadArray(module) ); + for (UInt_t chipIndex=0; chipIndex<5; chipIndex++) { + UInt_t eq,hs,chip,col,row; + AliITSRawStreamSPD::OfflineToOnline(module, chipIndex*32, 0, eq, hs, chip, col, row); + if (IsSilentChip(eq,hs,chip)) { + calibSPD->SetChipBad(chipIndex); + } + else { + calibSPD->UnSetChipBad(chipIndex); + } } } + AliCDBEntry* cdbEntry = new AliCDBEntry((TObject*)spdEntry,idCalSPD,metaData); + man->Put(cdbEntry); + delete spdEntry; + delete cdbEntry; + delete metaData; + return kTRUE; } -void AliITSOnlineCalibrationSPDhandler::WriteDeadToFile(UInt_t module) { - // write the lists of dead for module to file - AliITSOnlineCalibrationSPD* calib = new AliITSOnlineCalibrationSPD(); - calib->SetModuleNr(module); - calib->SetDeadList(GetDeadArray(module)); - calib->SetNrDead(GetNrDead(module)); - TString fileName = Form("%s/SPD_DeadNoisy_%d.root",fFileLocation.Data(),module); - TFile file(fileName.Data(), "RECREATE"); - file.WriteTObject(calib, "AliITSOnlineCalibrationSPD"); - file.Close(); - delete calib; +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::WriteNoisyToDB(Int_t runNrStart, Int_t runNrEnd, const Char_t *storage) { + // writes noisy pixels to DB for given runNrs + // overwrites any previous entries + AliCDBManager* man = AliCDBManager::Instance(); + TString storageSTR = Form("%s",storage); + if (storageSTR.CompareTo("default")==0) { + if(!man->IsDefaultStorageSet()) { + man->SetDefaultStorage("local://$ALICE_ROOT/OCDB"); + } + } + else { + storageSTR = Form("local://%s",storage); + man->SetDefaultStorage(storageSTR.Data()); + } + AliCDBMetaData* metaData = new AliCDBMetaData(); + metaData->SetResponsible("Henrik Tydesjo"); + metaData->SetComment("Created by AliITSOnlineCalibrationSPDhandler."); + AliCDBId idCalSPD("ITS/Calib/SPDNoisy",runNrStart,runNrEnd); + TObjArray* spdEntry = new TObjArray(240); + spdEntry->SetOwner(kTRUE); + for(UInt_t module=0; module<240; module++){ + AliITSCalibrationSPD* calibSPD = new AliITSCalibrationSPD(); + spdEntry->Add(calibSPD); + } + for(UInt_t module=0; module<240; module++){ + AliITSCalibrationSPD* calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module); + calibSPD->SetNrBadSingle( GetNrNoisySingle(module) ); + calibSPD->SetBadList( GetNoisyArray(module) ); + } + AliCDBEntry* cdbEntry = new AliCDBEntry((TObject*)spdEntry,idCalSPD,metaData); + man->Put(cdbEntry); + delete spdEntry; + delete cdbEntry; + delete metaData; + return kTRUE; } -void AliITSOnlineCalibrationSPDhandler::WriteNoisyToFiles() { - // write the lists of noisy to files (only if there are >0 dead pixels) +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::RecursiveInsertDead(AliITSCalibrationSPD* calibSPD, UInt_t module, Int_t lowInd, Int_t highInd) { + // inserts dead pixels recursively, used when reading from db + if (lowInd>highInd) return; + Int_t thisInd = lowInd+(highInd-lowInd)/2; + SetDeadPixelM(module,calibSPD->GetBadColAt(thisInd),calibSPD->GetBadRowAt(thisInd)); + RecursiveInsertDead(calibSPD,module,lowInd,thisInd-1); + RecursiveInsertDead(calibSPD,module,thisInd+1,highInd); +} +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::RecursiveInsertNoisy(AliITSCalibrationSPD* calibSPD, UInt_t module, Int_t lowInd, Int_t highInd) { + // inserts noisy pixels recursively, used when reading from db + if (lowInd>highInd) return; + Int_t thisInd = lowInd+(highInd-lowInd)/2; + SetNoisyPixelM(module,calibSPD->GetBadColAt(thisInd),calibSPD->GetBadRowAt(thisInd)); + RecursiveInsertNoisy(calibSPD,module,lowInd,thisInd-1); + RecursiveInsertNoisy(calibSPD,module,thisInd+1,highInd); +} + +#endif +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::GenerateDCSConfigFile(const Char_t* fileName) { + // generates an ascii file in the format as the one produced by online da (but with dummy runNr=0) + ofstream dcsfile; + dcsfile.open(fileName); + dcsfile << "[SPD SCAN]\n"; + dcsfile << "RunNumber=" << "0" << "\n"; // dummy value + dcsfile << "Type=" << "4" << "\n"; + dcsfile << "Router=" << "0" << "\n"; // dummy value + dcsfile << "ActualDetConfiguration=" << "0,-1,-1\n"; // dummy values + dcsfile << "[NOISY]\n"; for (UInt_t module=0; module<240; module++) { - if (fNrNoisy[module] > 0) { - printf("writing noisy to file for module %d\n",module); - WriteNoisyToFile(module); + UInt_t headkey=20*10*6; + for (UInt_t ind=0; indSetModuleNr(module); - calib->SetNoisyList(GetNoisyArray(module)); - calib->SetNrNoisy(GetNrNoisy(module)); - TString fileName = Form("%s/SPD_DeadNoisy_%d.root",fFileLocation.Data(),module); - TFile file(fileName.Data(), "RECREATE"); - file.WriteTObject(calib, "AliITSOnlineCalibrationSPD"); - file.Close(); - delete calib; +//____________________________________________________________________________________________ +TArrayS AliITSOnlineCalibrationSPDhandler::GetSilentArray(UInt_t module, Bool_t treeSerial) { + // get a TArrayS of the silent=dead+inactive pixels (format for the AliITSCalibrationSPD object) + // NB! with new implementation of AliITSCalibrationSPD this is not needed anymore + TArrayS returnArray; + + UInt_t eq = GetEqIdFromOffline(module); + UInt_t hs = GetHSFromOffline(module); + UInt_t size=0; + if ( !( IsActiveEq(eq) && IsActiveHS(eq,hs) ) ) { + size = 8192*5; + } + else { + for (UInt_t ch=0; ch<5; ch++) { + UInt_t chip = GetChipFromOffline(module,ch*32); + if (!(IsActiveChip(eq,hs,chip))) { + size += 8192; + } + else { + UInt_t gloChip = GetGloChip(eq,hs,chip); + size += fNrDead[gloChip]; + } + } + } + returnArray.Set(size*2); + + UInt_t gloIndex=0; + if ( !( IsActiveEq(eq) && IsActiveHS(eq,hs) ) ) { + for (UInt_t colM=0; colM<160; colM++) { + for (UInt_t rowM=0; rowM<256; rowM++) { + returnArray.AddAt(colM,gloIndex*2); + returnArray.AddAt(rowM,gloIndex*2+1); + gloIndex++; + } + } + } + else { + for (UInt_t ch=0; ch<5; ch++) { + UInt_t chip = GetChipFromOffline(module,ch*32); + if (!(IsActiveChip(eq,hs,chip))) { + for (UInt_t colM=ch*32; colMPrepareSerialize(); // for tree ordered values + else fDeadPixelMap[gloChip]->PrepareSerializeOrdered(); // for key ordered values + for (UInt_t index=0; indexGetKeyIndex(index); + Int_t colM = GetColMFromKey(key); + Int_t rowM = GetRowMFromKey(key); + returnArray.AddAt(colM,gloIndex*2); + returnArray.AddAt(rowM,gloIndex*2+1); + gloIndex++; + } + } + } + } + return returnArray; } +//____________________________________________________________________________________________ +TArrayS AliITSOnlineCalibrationSPDhandler::GetDeadArray(UInt_t module, Bool_t treeSerial) { + // get a TArrayS of the single dead pixels (format for the AliITSCalibrationSPD object) + TArrayS returnArray; -TArrayI AliITSOnlineCalibrationSPDhandler::GetDeadArray(UInt_t module) { - // get a TArrayI of the dead pixels (format for the AliITSCalibrationSPD object) + UInt_t eq = GetEqIdFromOffline(module); + UInt_t hs = GetHSFromOffline(module); + UInt_t size=GetNrDeadSingle(module); + returnArray.Set(size*2); + UInt_t gloIndex=0; + for (UInt_t ch=0; ch<5; ch++) { + UInt_t chip = GetChipFromOffline(module,ch*32); + UInt_t gloChip = GetGloChip(eq,hs,chip); + if (treeSerial) fDeadPixelMap[gloChip]->PrepareSerialize(); // for tree ordered values + else fDeadPixelMap[gloChip]->PrepareSerializeOrdered(); // for key ordered values + if (!IsSilentChip(eq,hs,chip)) { + for (UInt_t index=0; indexGetKeyIndex(index); + Int_t colM = GetColMFromKey(key); + Int_t rowM = GetRowMFromKey(key); + returnArray.AddAt(colM,gloIndex*2); + returnArray.AddAt(rowM,gloIndex*2+1); + gloIndex++; + } + } + } + return returnArray; +} +//____________________________________________________________________________________________ +TArrayS AliITSOnlineCalibrationSPDhandler::GetNoisyArray(UInt_t module, Bool_t treeSerial) { + // get a TArrayS of the single noisy pixels (format for the AliITSCalibrationSPD object) + TArrayS returnArray; + + UInt_t eq = GetEqIdFromOffline(module); + UInt_t hs = GetHSFromOffline(module); + UInt_t size=GetNrNoisySingle(module); + returnArray.Set(size*2); + UInt_t gloIndex=0; + for (UInt_t ch=0; ch<5; ch++) { + UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,ch*32)); + if (treeSerial) fNoisyPixelMap[gloChip]->PrepareSerialize(); // for tree ordered values + else fNoisyPixelMap[gloChip]->PrepareSerializeOrdered(); // for key ordered values + for (UInt_t index=0; indexGetKeyIndex(index); + Int_t colM = GetColMFromKey(key); + Int_t rowM = GetRowMFromKey(key); + returnArray.AddAt(colM,gloIndex*2); + returnArray.AddAt(rowM,gloIndex*2+1); + gloIndex++; + } + } + return returnArray; +} +//____________________________________________________________________________________________ +TArrayI AliITSOnlineCalibrationSPDhandler::GetDeadArrayOnline(UInt_t eq) { + // get a TArrayI of the single dead pixels (format for the AliITSOnlineCalibrationSPD object) TArrayI returnArray; - returnArray.Set(GetNrDead(module)*2); - fDeadPixelMap[module]->PrepareSerialize(); // for tree ordered values - for (UInt_t index=0; indexGetKeyIndex(index); - Int_t colM = GetColMFromKey(key); - Int_t row = GetRowFromKey(key); - returnArray.AddAt(colM,index*2); - returnArray.AddAt(row,index*2+1); + // fix size of array + UInt_t size=0; + for (UInt_t hs=0; hs<6; hs++) { + for (UInt_t chip=0; chip<10; chip++) { + UInt_t gloChip = GetGloChip(eq,hs,chip); + size+=fNrDead[gloChip]; + } + } + returnArray.Set(size); + // put keys in array + UInt_t gloIndex=0; + for (UInt_t hs=0; hs<6; hs++) { + for (UInt_t chip=0; chip<10; chip++) { + UInt_t gloChip = GetGloChip(eq,hs,chip); + fDeadPixelMap[gloChip]->PrepareSerialize(); // for tree ordered values + for (UInt_t index=0; indexGetKeyIndex(index); + returnArray.AddAt(key,gloIndex); + gloIndex++; + } + } } return returnArray; } -TArrayI AliITSOnlineCalibrationSPDhandler::GetNoisyArray(UInt_t module) { - // get a TArrayI of the noisy pixels (format for the AliITSCalibrationSPD object) +//____________________________________________________________________________________________ +TArrayI AliITSOnlineCalibrationSPDhandler::GetNoisyArrayOnline(UInt_t eq) { + // get a TArrayI of the single noisy pixels (format for the AliITSOnlineCalibrationSPD object) TArrayI returnArray; - returnArray.Set(GetNrNoisy(module)*2); - fNoisyPixelMap[module]->PrepareSerialize(); // for tree ordered values - for (UInt_t index=0; indexGetKeyIndex(index); - Int_t colM = GetColMFromKey(key); - Int_t row = GetRowFromKey(key); - returnArray.AddAt(colM,index*2); - returnArray.AddAt(row,index*2+1); + // fix size of array + UInt_t size=0; + for (UInt_t hs=0; hs<6; hs++) { + for (UInt_t chip=0; chip<10; chip++) { + UInt_t gloChip = GetGloChip(eq,hs,chip); + size+=fNrNoisy[gloChip]; + } + } + returnArray.Set(size); + // put keys in array + UInt_t gloIndex=0; + for (UInt_t hs=0; hs<6; hs++) { + for (UInt_t chip=0; chip<10; chip++) { + UInt_t gloChip = GetGloChip(eq,hs,chip); + fNoisyPixelMap[gloChip]->PrepareSerialize(); // for tree ordered values + for (UInt_t index=0; indexGetKeyIndex(index); + returnArray.AddAt(key,gloIndex); + gloIndex++; + } + } } return returnArray; } +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::PrintEqSummary() { +// print summary (nr of dead and noisy) for each equipment + printf("-----------\n"); + printf("Eq summary:\n"); + printf("-----------\n"); + for (UInt_t eq=0; eq<20; eq++) { + printf("Eq %*d: %*d silent(dead+inactive) , %*d dead , %*d noisy\n",2,eq,6,GetNrSilentEq(eq),6,GetNrDeadEq(eq),6,GetNrNoisyEq(eq)); + } +} +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::PrintSilent() const { + // print the inactive and dead pixels to screen + printf("-----------------------------------------------------------\n"); + printf("Inactive or dead Equipments: (eq | module1 .. module12)\n"); + printf("-----------------------------------------------------------\n"); + for (UInt_t eq=0; eq<20; eq++) { + if (IsSilentEq(eq)) { + printf("%*d | ",2,eq); + for (UInt_t hs=0; hs<6; hs++) { + for (UInt_t chip=0; chip<10; chip+=5) { + UInt_t module = AliITSRawStreamSPD::GetOfflineModuleFromOnline(eq,hs,chip); + if (hs>0 || chip==5) printf(","); + printf("%*d",3,module); + } + } + printf("\n"); + } + } -void AliITSOnlineCalibrationSPDhandler::ResetDead() { - // reset the dead pixel map - for (UInt_t module=0; module<240; module++) { - fNrDead[module]=0; - fDeadPixelMap[module]->Clear(); + printf("-----------------------------------------------------------\n"); + printf("Inactive or dead Half-staves: (eq,hs | module1,module2)\n"); + printf("-----------------------------------------------------------\n"); + for (UInt_t eq=0; eq<20; eq++) { + if (!IsSilentEq(eq)) { + for (UInt_t hs=0; hs<6; hs++) { + if (IsSilentHS(eq,hs)) { + printf("%*d,%*d | ",2,eq,1,hs); + for (UInt_t chip=0; chip<10; chip+=5) { + UInt_t module = AliITSRawStreamSPD::GetOfflineModuleFromOnline(eq,hs,chip); + if (chip==5) printf(","); + printf("%*d",3,module); + } + printf("\n"); + } + } + } } -} -void AliITSOnlineCalibrationSPDhandler::ResetDeadForChip(UInt_t eqId, UInt_t hs, UInt_t chip) { - // clear the noisy pixels for this chip - UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip); - for (UInt_t col=0; col<32; col++) { - for (UInt_t row=0; row<256; row++) { - Int_t key = GetKey(eqId,hs,chip,col,row); - if (fDeadPixelMap[module]->Remove(key)) { - fNrDead[module]--; + printf("-----------------------------------------------------------\n"); + printf("Inactive or dead Chips: (eq,hs,chip | module,colM1-colM2)\n"); + printf("-----------------------------------------------------------\n"); + for (UInt_t eq=0; eq<20; eq++) { + if (!IsSilentEq(eq)) { + for (UInt_t hs=0; hs<6; hs++) { + if (!IsSilentHS(eq,hs)) { + for (UInt_t chip=0; chip<10; chip++) { + if (IsSilentChip(eq,hs,chip)) { + printf("%*d,%*d,%*d | ",2,eq,1,hs,1,chip); + UInt_t module = AliITSRawStreamSPD::GetOfflineModuleFromOnline(eq,hs,chip); + UInt_t colM1 = AliITSRawStreamSPD::GetOfflineColFromOnline(eq,hs,chip,0); + UInt_t colM2 = AliITSRawStreamSPD::GetOfflineColFromOnline(eq,hs,chip,31); + printf("%*d,%*d-%*d\n",3,module,3,colM1,3,colM2); + } + } + } } } } + + PrintDead(); + +} +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::PrintDead() const { + // print the single dead pixels to screen (disregards inactive eq,hs,chip) + printf("------------------------------------------------------\n"); + printf("Dead Pixels: (eq,hs,chip,col,row | module,colM,rowM)\n"); + printf("------------------------------------------------------\n"); + for (UInt_t gloChip=0; gloChip<1200; gloChip++) { + for (UInt_t index=0; indexGetKeyIndex(index); + UInt_t eq = GetEqIdFromKey(key); + UInt_t hs = GetHSFromKey(key); + UInt_t chip = GetChipFromKey(key); + UInt_t col = GetColFromKey(key); + UInt_t row = GetRowFromKey(key); + + UInt_t module = AliITSRawStreamSPD::GetOfflineModuleFromOnline(eq,hs,chip); + UInt_t colM = AliITSRawStreamSPD::GetOfflineColFromOnline(eq,hs,chip,col); + UInt_t rowM = AliITSRawStreamSPD::GetOfflineRowFromOnline(eq,hs,chip,row); + + 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); + } + } } +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::PrintNoisy() const { + // print the dead pixels to screen + printf("-------------------------------------------------------\n"); + printf("Noisy Pixels: (eq,hs,chip,col,row | module,colM,rowM)\n"); + printf("-------------------------------------------------------\n"); + for (UInt_t gloChip=0; gloChip<1200; gloChip++) { + for (UInt_t index=0; indexGetKeyIndex(index); + UInt_t eq = GetEqIdFromKey(key); + UInt_t hs = GetHSFromKey(key); + UInt_t chip = GetChipFromKey(key); + UInt_t col = GetColFromKey(key); + UInt_t row = GetRowFromKey(key); + + UInt_t module = AliITSRawStreamSPD::GetOfflineModuleFromOnline(eq,hs,chip); + UInt_t colM = AliITSRawStreamSPD::GetOfflineColFromOnline(eq,hs,chip,col); + UInt_t rowM = AliITSRawStreamSPD::GetOfflineRowFromOnline(eq,hs,chip,row); -Bool_t AliITSOnlineCalibrationSPDhandler::SetDeadPixel(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) { + 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); + } + } +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::SetDeadPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) { // set a dead pixel, returns false if pixel is already dead - UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip); - Int_t key = GetKey(eqId,hs,chip,col,row); -//!!! // if noisy we dont want to add it... -//!!! if (fNoisyPixelMap[module]->Find(key) != NULL) return kFALSE; - if (fDeadPixelMap[module]->Insert(key,module)) { - fNrDead[module]++; + UInt_t gloChip = GetGloChip(eq,hs,chip); + if (gloChip>=1200) { + Error("AliITSOnlineCalibrationSPDhandler::SetDeadPixel", "eq,hs,chip nrs (%d,%d,%d) out of bounds.",eq,hs,chip); + return kFALSE; + } + if (col>=32 && row>=256) { + Error("AliITSOnlineCalibrationSPDhandler::SetDeadPixel", "col,row nrs (%d,%d) out of bounds.",col,row); + return kFALSE; + } + Int_t key = GetKey(eq,hs,chip,col,row); + // if noisy we dont want to add it... + if (fNoisyPixelMap[gloChip]->Find(key) != NULL) return kFALSE; + if (fDeadPixelMap[gloChip]->Insert(key,gloChip)) { + fNrDead[gloChip]++; return kTRUE; } return kFALSE; } - -Bool_t AliITSOnlineCalibrationSPDhandler::SetDeadPixelM(UInt_t module, UInt_t colM, UInt_t row) { +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::SetNoisyPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) { + // set a noisy pixel, returns false if pixel is already noisy + UInt_t gloChip = GetGloChip(eq,hs,chip); + if (gloChip>=1200) { + Error("AliITSOnlineCalibrationSPDhandler::SetNoisyPixel", "eq,hs,chip nrs (%d,%d,%d) out of bounds.",eq,hs,chip); + return kFALSE; + } + if (col>=32 && row>=256) { + Error("AliITSOnlineCalibrationSPDhandler::SetNoisyPixel", "col,row nrs (%d,%d) out of bounds.",col,row); + return kFALSE; + } + Int_t key = GetKey(eq,hs,chip,col,row); + // if dead before - remove from the dead list + if (fDeadPixelMap[gloChip]->Remove(key)) { + fNrDead[gloChip]--; + } + if (fNoisyPixelMap[gloChip]->Insert(key,gloChip)) { + fNrNoisy[gloChip]++; + return kTRUE; + } + return kFALSE; +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::SetDeadPixelM(UInt_t module, UInt_t colM, UInt_t rowM) { // set a dead pixel, returns false if pixel is already dead - UInt_t eqId = GetEqIdFromOffline(module); + UInt_t eq = GetEqIdFromOffline(module); + UInt_t hs = GetHSFromOffline(module); + UInt_t chip = GetChipFromOffline(module,colM); + UInt_t col = GetColFromOffline(module,colM); + UInt_t row = GetRowFromOffline(module,rowM); + return SetDeadPixel(eq,hs,chip,col,row); +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::SetNoisyPixelM(UInt_t module, UInt_t colM, UInt_t rowM) { + // set a noisy pixel, returns false if pixel is already noisy + UInt_t eq = GetEqIdFromOffline(module); UInt_t hs = GetHSFromOffline(module); UInt_t chip = GetChipFromOffline(module,colM); - UInt_t col = GetColFromOffline(colM); - Int_t key = GetKey(eqId,hs,chip,col,row); -//!!! // if noisy we dont want to add it... -//!!! if (fNoisyPixelMap[module]->Find(key) != NULL) return kFALSE; - if (fDeadPixelMap[module]->Insert(key,module)) { - fNrDead[module]++; + UInt_t col = GetColFromOffline(module,colM); + UInt_t row = GetRowFromOffline(module,rowM); + return SetNoisyPixel(eq,hs,chip,col,row); +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::UnSetDeadPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) { + // unset a dead pixel, returns false if pixel is not dead + UInt_t gloChip = GetGloChip(eq,hs,chip); + if (gloChip>=1200) { + Error("AliITSOnlineCalibrationSPDhandler::UnSetDeadPixel", "eq,hs,chip nrs (%d,%d,%d) out of bounds.",eq,hs,chip); + return kFALSE; + } + Int_t key = GetKey(eq,hs,chip,col,row); + if (fDeadPixelMap[gloChip]->Remove(key)) { + fNrDead[gloChip]--; return kTRUE; } return kFALSE; } - +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::UnSetNoisyPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) { + // unset a noisy pixel, returns false if pixel is not noisy + UInt_t gloChip = GetGloChip(eq,hs,chip); + if (gloChip>=1200) { + Error("AliITSOnlineCalibrationSPDhandler::UnSetNoisyPixel", "eq,hs,chip nrs (%d,%d,%d) out of bounds.",eq,hs,chip); + return kFALSE; + } + Int_t key = GetKey(eq,hs,chip,col,row); + if (fNoisyPixelMap[gloChip]->Remove(key)) { + fNrNoisy[gloChip]--; + return kTRUE; + } + return kFALSE; +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::UnSetDeadPixelM(UInt_t module, UInt_t colM, UInt_t rowM) { + // unset a dead pixel, returns false if pixel is not dead + UInt_t eq = GetEqIdFromOffline(module); + UInt_t hs = GetHSFromOffline(module); + UInt_t chip = GetChipFromOffline(module,colM); + UInt_t col = GetColFromOffline(module,colM); + UInt_t row = GetRowFromOffline(module,rowM); + return UnSetDeadPixel(eq,hs,chip,col,row); +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::UnSetNoisyPixelM(UInt_t module, UInt_t colM, UInt_t rowM) { + // unset a noisy pixel, returns false if pixel is not noisy + UInt_t eq = GetEqIdFromOffline(module); + UInt_t hs = GetHSFromOffline(module); + UInt_t chip = GetChipFromOffline(module,colM); + UInt_t col = GetColFromOffline(module,colM); + UInt_t row = GetRowFromOffline(module,rowM); + return UnSetNoisyPixel(eq,hs,chip,col,row); +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelBad(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const { + // is the pixel bad (silent or noisy) + return (IsPixelSilent(eq,hs,chip,col,row) || IsPixelNoisy(eq,hs,chip,col,row)); +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelSilent(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const { + // is the pixel silent (dead or inactive)? + UInt_t gloChip = GetGloChip(eq,hs,chip); + if (gloChip>=1200 || col>=32 || row>=256) { + Error("AliITSOnlineCalibrationSPDhandler::IsPixelSilent", "eq,hs,chip,col,row nrs (%d,%d,%d,%d,%d) out of bounds.",eq,hs,chip,col,row); + return kFALSE; + } + if (IsSilentChip(eq,hs,chip)) return kTRUE; + else return IsPixelDead(eq,hs,chip,col,row); +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDead(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const { + // is the pixel dead? + UInt_t gloChip = GetGloChip(eq,hs,chip); + if (gloChip>=1200 || col>=32 || row>=256) { + Error("AliITSOnlineCalibrationSPDhandler::IsPixelDead", "eq,hs,chip,col,row nrs (%d,%d,%d,%d,%d) out of bounds.",eq,hs,chip,col,row); + return kFALSE; + } + UInt_t key = GetKey(eq,hs,chip,col,row); + if (IsDeadEq(eq) || IsDeadHS(eq,hs) || IsDeadChip(eq,hs,chip)) return kTRUE; + else { + if ( fDeadPixelMap[gloChip]->Find(key) != NULL ) return kTRUE; + else return kFALSE; + } +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisy(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const { + // is the pixel noisy? + UInt_t gloChip = GetGloChip(eq,hs,chip); + if (gloChip>=1200 || col>=32 || row>=256) { + Error("AliITSOnlineCalibrationSPDhandler::IsPixelNoisy", "eq,hs,chip,col,row nrs (%d,%d,%d) out of bounds.",eq,hs,chip,col,row); + return kFALSE; + } + UInt_t key = GetKey(eq,hs,chip,col,row); + if ( fNoisyPixelMap[gloChip]->Find(key) != NULL ) return kTRUE; + else return kFALSE; +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelBadM(UInt_t module, UInt_t colM, UInt_t rowM) const { + // is the pixel bad (silent or noisy)? + return (IsPixelSilentM(module,colM,rowM) || IsPixelNoisyM(module,colM,rowM)); +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelSilentM(UInt_t module, UInt_t colM, UInt_t rowM) const { + // is the pixel silent (dead or inactive)? + UInt_t eq = GetEqIdFromOffline(module); + UInt_t hs = GetHSFromOffline(module); + UInt_t chip = GetChipFromOffline(module,colM); + UInt_t col = GetColFromOffline(module,colM); + UInt_t row = GetRowFromOffline(module,rowM); + return IsPixelSilent(eq,hs,chip,col,row); +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDeadM(UInt_t module, UInt_t colM, UInt_t rowM) const { + // is the pixel dead? + UInt_t eq = GetEqIdFromOffline(module); + UInt_t hs = GetHSFromOffline(module); + UInt_t chip = GetChipFromOffline(module,colM); + UInt_t col = GetColFromOffline(module,colM); + UInt_t row = GetRowFromOffline(module,rowM); + return IsPixelDead(eq,hs,chip,col,row); +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyM(UInt_t module, UInt_t colM, UInt_t rowM) const { + // is the pixel noisy? + UInt_t eq = GetEqIdFromOffline(module); + UInt_t hs = GetHSFromOffline(module); + UInt_t chip = GetChipFromOffline(module,colM); + UInt_t col = GetColFromOffline(module,colM); + UInt_t row = GetRowFromOffline(module,rowM); + return IsPixelNoisy(eq,hs,chip,col,row); +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelBadKey(Int_t key) const { + // is this pixel silent (dead or inactive)? + UInt_t eq = GetEqIdFromKey(key); + UInt_t hs = GetHSFromKey(key); + UInt_t chip = GetChipFromKey(key); + UInt_t col = GetColFromKey(key); + UInt_t row = GetRowFromKey(key); + return IsPixelBad(eq,hs,chip,col,row); +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelSilentKey(Int_t key) const { + // is this pixel silent (dead or inactive)? + UInt_t eq = GetEqIdFromKey(key); + UInt_t hs = GetHSFromKey(key); + UInt_t chip = GetChipFromKey(key); + UInt_t col = GetColFromKey(key); + UInt_t row = GetRowFromKey(key); + return IsPixelSilent(eq,hs,chip,col,row); +} +//____________________________________________________________________________________________ Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDeadKey(Int_t key) const { + // is this pixel dead? + UInt_t eq = GetEqIdFromKey(key); + UInt_t hs = GetHSFromKey(key); + UInt_t chip = GetChipFromKey(key); + UInt_t col = GetColFromKey(key); + UInt_t row = GetRowFromKey(key); + return IsPixelDead(eq,hs,chip,col,row); +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyKey(Int_t key) const { // is this pixel noisy? - UInt_t eqId = GetEqIdFromKey(key); + UInt_t eq = GetEqIdFromKey(key); UInt_t hs = GetHSFromKey(key); UInt_t chip = GetChipFromKey(key); - UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip); - return IsPixelDeadMKey(module,key); + UInt_t col = GetColFromKey(key); + UInt_t row = GetRowFromKey(key); + return IsPixelNoisy(eq,hs,chip,col,row); +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetNrBad() const { + // returns the total nr of bad pixels (silent or noisy) + UInt_t nrBad=0; + nrBad+=GetNrSilent(); + UInt_t nrNoisy = GetNrNoisy(); + for (UInt_t i=0; i=240) { + Error("AliITSOnlineCalibrationSPDhandler::GetNrSilent", "module nr (%d) out of bounds.",module); + return 0; + } + UInt_t nrSilent = 0; + UInt_t eq = GetEqIdFromOffline(module); + if (IsSilentEq(eq)) return 160*256; + UInt_t hs = GetHSFromOffline(module); + if (IsSilentHS(eq,hs)) return 160*256; + for (UInt_t ch=0; ch<5; ch++) { + UInt_t chip = GetChipFromOffline(module,ch*32); + if (IsSilentChip(eq,hs,chip)) { + nrSilent+=8192; + } + else { + UInt_t gloChip = GetGloChip(eq,hs,chip); + nrSilent+=fNrDead[gloChip]; + } + } + return nrSilent; +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadSingle(UInt_t module) const { + // returns the number of single dead pixels (excluding the ones on silent chips) for a certain module + if (module>=240) { + Error("AliITSOnlineCalibrationSPDhandler::GetNrDeadSingle", "module nr (%d) out of bounds.",module); + return 0; + } + UInt_t nrDead = 0; + UInt_t eq = GetEqIdFromOffline(module); + UInt_t hs = GetHSFromOffline(module); + for (UInt_t ch=0; ch<5; ch++) { + UInt_t chip = GetChipFromOffline(module,ch*32); + if (!IsSilentChip(eq,hs,chip)) { + UInt_t gloChip = GetGloChip(eq,hs,chip); + nrDead+=fNrDead[gloChip]; + } + } + return nrDead; +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisySingle(UInt_t module) const { + // returns the number of noisy pixels for a certain module + return GetNrNoisy(module); } +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDead(UInt_t module) const { + // returns the number of dead pixels for a certain module + if (module>=240) { + Error("AliITSOnlineCalibrationSPDhandler::GetNrDead", "module nr (%d) out of bounds.",module); + return 0; + } + UInt_t nrDead = 0; + UInt_t eq = GetEqIdFromOffline(module); + UInt_t hs = GetHSFromOffline(module); + for (UInt_t ch=0; ch<5; ch++) { + UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,ch*32)); + nrDead+=fNrDead[gloChip]; + } + return nrDead; +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisy(UInt_t module) const { + // returns the number of noisy pixels for a certain module + if (module>=240) { + Error("AliITSOnlineCalibrationSPDhandler::GetNrNoisy", "module nr (%d) out of bounds.",module); + return 0; + } + UInt_t nrNoisy = 0; + UInt_t eq = GetEqIdFromOffline(module); + UInt_t hs = GetHSFromOffline(module); + for (UInt_t ch=0; ch<5; ch++) { + UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,ch*32)); + nrNoisy+=fNrNoisy[gloChip]; + } + return nrNoisy; +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAt(UInt_t module, UInt_t index) const { + // get eq for the dead pixel at position index in list of dead + UInt_t gloChip; + UInt_t chipIndex; + GetChipAndIndexDead(module,index,gloChip,chipIndex); + return GetDeadEqIdAtC2(gloChip,chipIndex); +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAt(UInt_t module, UInt_t index) const { + // get eq for the noisy pixel at position index in list of noisy + UInt_t gloChip; + UInt_t chipIndex; + GetChipAndIndexNoisy(module,index,gloChip,chipIndex); + return GetNoisyEqIdAtC2(gloChip,chipIndex); +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAt(UInt_t module, UInt_t index) const { + // get hs for the dead pixel at position index in list of dead + UInt_t gloChip; + UInt_t chipIndex; + GetChipAndIndexDead(module,index,gloChip,chipIndex); + return GetDeadHSAtC2(gloChip,chipIndex); +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAt(UInt_t module, UInt_t index) const { + // get hs for the noisy pixel at position index in list of noisy + UInt_t gloChip; + UInt_t chipIndex; + GetChipAndIndexNoisy(module,index,gloChip,chipIndex); + return GetNoisyHSAtC2(gloChip,chipIndex); +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAt(UInt_t module, UInt_t index) const { + // get chip for the dead pixel at position index in list of dead + UInt_t gloChip; + UInt_t chipIndex; + GetChipAndIndexDead(module,index,gloChip,chipIndex); + return GetDeadChipAtC2(gloChip,chipIndex); +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAt(UInt_t module, UInt_t index) const { + // get chip for the noisy pixel at position index in list of noisy + UInt_t gloChip; + UInt_t chipIndex; + GetChipAndIndexNoisy(module,index,gloChip,chipIndex); + return GetNoisyChipAtC2(gloChip,chipIndex); +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAt(UInt_t module, UInt_t index) const { + // get hs for the dead pixel at position index in list of dead + UInt_t gloChip; + UInt_t chipIndex; + GetChipAndIndexDead(module,index,gloChip,chipIndex); + return GetDeadColAtC2(gloChip,chipIndex); +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAt(UInt_t module, UInt_t index) const { + // get hs for the noisy pixel at position index in list of noisy + UInt_t gloChip; + UInt_t chipIndex; + GetChipAndIndexNoisy(module,index,gloChip,chipIndex); + return GetNoisyColAtC2(gloChip,chipIndex); +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAt(UInt_t module, UInt_t index) const { + // get hs for the dead pixel at position index in list of dead + UInt_t gloChip; + UInt_t chipIndex; + GetChipAndIndexDead(module,index,gloChip,chipIndex); + return GetDeadRowAtC2(gloChip,chipIndex); +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAt(UInt_t module, UInt_t index) const { + // get hs for the noisy pixel at position index in list of noisy + UInt_t gloChip; + UInt_t chipIndex; + GetChipAndIndexNoisy(module,index,gloChip,chipIndex); + return GetNoisyRowAtC2(gloChip,chipIndex); +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetNrBadEq(UInt_t eq) const { + // returns nr of bad for eq (silent or noisy) + UInt_t nrBad = 0; + nrBad+=GetNrSilentEq(eq); + UInt_t nrNoisy = GetNrNoisy(eq); + for (UInt_t i=0; i=1200) { + Error("AliITSOnlineCalibrationSPDhandler::GetDeadPixelAsTextC", "global chip nr (%d) out of bounds.",gloChip); + return returnMess.Data(); + } + if (indexGetKeyIndex(index); + UInt_t col = GetColFromKey(key); + UInt_t row = GetRowFromKey(key); + UInt_t module = AliITSRawStreamSPD::GetOfflineModuleFromOnline(eq,hs,chip); + UInt_t colM = AliITSRawStreamSPD::GetOfflineColFromOnline(eq,hs,chip,col); + UInt_t rowM = AliITSRawStreamSPD::GetOfflineRowFromOnline(eq,hs,chip,row); + 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); + return returnMess.Data(); + } + else { + Error("AliITSOnlineCalibrationSPDhandler::GetDeadPixelAsTextC", "Index %d out of bounds.", index); + return returnMess.Data(); + } +} +//____________________________________________________________________________________________ +const Char_t* AliITSOnlineCalibrationSPDhandler::GetNoisyPixelAsTextC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const { + // get a string of noisy pixel info + TString returnMess = ""; + UInt_t gloChip = GetGloChip(eq,hs,chip); + if (gloChip>=1200) { + Error("AliITSOnlineCalibrationSPDhandler::GetNoisyPixelAsTextC", "global chip nr (%d) out of bounds.",gloChip); + return returnMess.Data(); + } + if (indexGetKeyIndex(index); + UInt_t col = GetColFromKey(key); + UInt_t row = GetRowFromKey(key); + UInt_t module = AliITSRawStreamSPD::GetOfflineModuleFromOnline(eq,hs,chip); + UInt_t colM = AliITSRawStreamSPD::GetOfflineColFromOnline(eq,hs,chip,col); + UInt_t rowM = AliITSRawStreamSPD::GetOfflineRowFromOnline(eq,hs,chip,row); + 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); + return returnMess.Data(); + } + else { + Error("AliITSOnlineCalibrationSPDhandler::GetNoisyPixelAsTextC", "Index %d out of bounds.", index); + return returnMess.Data(); + } +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::AddSilentFrom(AliITSOnlineCalibrationSPDhandler* other) { + // returns number of new silent pixels in this' list (dead or inactive) + UInt_t tmpdead = GetNrSilent(); + + for (UInt_t eq=0; eq<20; eq++) { + if (!(other->IsActiveEq(eq))) ActivateEq(eq,kFALSE); + if (other->IsDeadEq(eq)) SetDeadEq(eq,kTRUE); + for (UInt_t hs=0; hs<6; hs++) { + if (!(other->IsActiveHS(eq,hs))) ActivateHS(eq,hs,kFALSE); + if (other->IsDeadHS(eq,hs)) SetDeadHS(eq,hs,kTRUE); + for (UInt_t chip=0; chip<10; chip++) { + if (!(other->IsActiveChip(eq,hs,chip))) ActivateChip(eq,hs,chip,kFALSE); + if (other->IsDeadChip(eq,hs,chip)) SetDeadChip(eq,hs,chip,kTRUE); + } + } + } + + AddDeadFrom(other); + + return GetNrSilent() - tmpdead; +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::AddDeadFrom(AliITSOnlineCalibrationSPDhandler* other) { + // returns number of new dead pixels in this' list + UInt_t returnval=0; + for (UInt_t gloChip=0; gloChip<1200; gloChip++) { + for (UInt_t ind1=0; ind1fNrDead[gloChip]; ind1++) { + UInt_t eq = other->GetDeadEqIdAtC2(gloChip,ind1); + UInt_t hs = other->GetDeadHSAtC2(gloChip,ind1); + UInt_t chip = other->GetDeadChipAtC2(gloChip,ind1); + UInt_t col = other->GetDeadColAtC2(gloChip,ind1); + UInt_t row = other->GetDeadRowAtC2(gloChip,ind1); + if (SetDeadPixel(eq,hs,chip,col,row)) { + returnval++; + } + } + } + return returnval; +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::AddNoisyFrom(AliITSOnlineCalibrationSPDhandler* other) { + // returns number of new noisy pixels in this' list + UInt_t returnval=0; + for (UInt_t gloChip=0; gloChip<1200; gloChip++) { + for (UInt_t ind1=0; ind1fNrNoisy[gloChip]; ind1++) { + UInt_t eq = other->GetNoisyEqIdAtC2(gloChip,ind1); + UInt_t hs = other->GetNoisyHSAtC2(gloChip,ind1); + UInt_t chip = other->GetNoisyChipAtC2(gloChip,ind1); + UInt_t col = other->GetNoisyColAtC2(gloChip,ind1); + UInt_t row = other->GetNoisyRowAtC2(gloChip,ind1); + if (SetNoisyPixel(eq,hs,chip,col,row)) { + returnval++; + } + } + } + return returnval; +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDiff(AliITSOnlineCalibrationSPDhandler* other) const { + // returns nr of dead/noisy in this' lists and not in other's lists (including inactive) + return GetNrSilentDiff(other) + GetNrNoisyDiff(other); +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetNrSilentDiff(AliITSOnlineCalibrationSPDhandler* other) const { + // returns nr of single silent pixels in this' lists and not in other's lists (dead or inactive) + UInt_t returnval=0; + for (UInt_t eq=0; eq<20; eq++) { + for (UInt_t hs=0; hs<6; hs++) { + for (UInt_t chip=0; chip<10; chip++) { + if (!IsActiveEq(eq) || IsDeadEq(eq) || !IsActiveHS(eq,hs) || IsDeadHS(eq,hs) || !IsActiveChip(eq,hs,chip) || IsDeadChip(eq,hs,chip)) { + 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)) { + // if this is inactive and the other is active... + returnval+= 8192 - other->GetNrDeadC(eq,hs,chip); + } + } + else { + UInt_t gloChip = GetGloChip(eq,hs,chip); + for (UInt_t ind1=0; ind1GetKeyIndex(ind1); + UInt_t col = GetColFromKey(key); + UInt_t row = GetRowFromKey(key); + if (!(other->IsPixelSilent(eq,hs,chip,col,row))) { + returnval++; + } + } + } + } + } + } + return returnval; +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadDiff(AliITSOnlineCalibrationSPDhandler* other) const { + // returns nr of dead in this' lists and not in other's lists + UInt_t returnval=0; + for (UInt_t gloChip=0; gloChip<1200; gloChip++) { + for (UInt_t ind1=0; ind1GetKeyIndex(ind1); + UInt_t eq = GetEqIdFromKey(key); + UInt_t hs = GetHSFromKey(key); + UInt_t chip = GetChipFromKey(key); + UInt_t col = GetColFromKey(key); + UInt_t row = GetRowFromKey(key); + if (!(other->IsPixelDead(eq,hs,chip,col,row))) { + returnval++; + } + } + } + return returnval; +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisyDiff(AliITSOnlineCalibrationSPDhandler* other) const { + // returns nr of noisy in this' lists and not in other's lists + UInt_t returnval=0; + for (UInt_t gloChip=0; gloChip<1200; gloChip++) { + for (UInt_t ind1=0; ind1GetKeyIndex(ind1); + UInt_t eq = GetEqIdFromKey(key); + UInt_t hs = GetHSFromKey(key); + UInt_t chip = GetChipFromKey(key); + UInt_t col = GetColFromKey(key); + UInt_t row = GetRowFromKey(key); + if (!(other->IsPixelNoisy(eq,hs,chip,col,row))) { + returnval++; + } + } + } + return returnval; +} +//____________________________________________________________________________________________ +AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetDiff(AliITSOnlineCalibrationSPDhandler* other) const { + // returns handler with active/dead/noisy in this' lists, removing those that are in other's lists + AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler(); + + for (UInt_t eq=0; eq<20; eq++) { + if (!(IsActiveEq(eq))) { + newHandler->ActivateEq(eq,kFALSE); + if (!other->IsActiveEq(eq)) newHandler->ActivateEq(eq); + } + if (IsDeadEq(eq)) { + newHandler->SetDeadEq(eq); + if (other->IsDeadEq(eq)) newHandler->SetDeadEq(eq,kFALSE); + } + for (UInt_t hs=0; hs<6; hs++) { + if (!(IsActiveHS(eq,hs))) { + newHandler->ActivateHS(eq,hs,kFALSE); + if (!other->IsActiveHS(eq,hs)) newHandler->ActivateHS(eq,hs); + } + if (IsDeadHS(eq,hs)) { + newHandler->SetDeadHS(eq,hs); + if (other->IsDeadHS(eq,hs)) newHandler->SetDeadHS(eq,hs,kFALSE); + } + for (UInt_t chip=0; chip<10; chip++) { + if (!(IsActiveChip(eq,hs,chip))) { + newHandler->ActivateChip(eq,hs,chip,kFALSE); + if (!other->IsActiveChip(eq,hs,chip)) newHandler->ActivateHS(eq,hs,chip); + } + if (IsDeadChip(eq,hs,chip)) { + newHandler->SetDeadChip(eq,hs,chip); + if (other->IsDeadChip(eq,hs,chip)) newHandler->SetDeadChip(eq,hs,chip,kFALSE); + } + } + } + } + + for (UInt_t gloChip=0; gloChip<1200; gloChip++) { + for (UInt_t ind1=0; ind1GetKeyIndex(ind1); + UInt_t eq = GetEqIdFromKey(key); + UInt_t hs = GetHSFromKey(key); + UInt_t chip = GetChipFromKey(key); + UInt_t col = GetColFromKey(key); + UInt_t row = GetRowFromKey(key); + if (!(other->IsPixelDead(eq,hs,chip,col,row))) { + newHandler->SetDeadPixel(eq,hs,chip,col,row); + } + } + } + + for (UInt_t gloChip=0; gloChip<1200; gloChip++) { + for (UInt_t ind2=0; ind2GetKeyIndex(ind2); + UInt_t eq = GetEqIdFromKey(key); + UInt_t hs = GetHSFromKey(key); + UInt_t chip = GetChipFromKey(key); + UInt_t col = GetColFromKey(key); + UInt_t row = GetRowFromKey(key); + if (!(other->IsPixelNoisy(eq,hs,chip,col,row))) { + newHandler->SetNoisyPixel(eq,hs,chip,col,row); + } + } + } + + return newHandler; +} +//____________________________________________________________________________________________ +AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetSilentDiff(AliITSOnlineCalibrationSPDhandler* other) const { + // returns handler with active/dead in this' lists, removing those that are in other's lists + AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler(); + + for (UInt_t eq=0; eq<20; eq++) { + if (!(IsActiveEq(eq))) { + newHandler->ActivateEq(eq,kFALSE); + if (!other->IsActiveEq(eq)) newHandler->ActivateEq(eq); + } + if (IsDeadEq(eq)) { + newHandler->SetDeadEq(eq); + if (other->IsDeadEq(eq)) newHandler->SetDeadEq(eq,kFALSE); + } + for (UInt_t hs=0; hs<6; hs++) { + if (!(IsActiveHS(eq,hs))) { + newHandler->ActivateHS(eq,hs,kFALSE); + if (!other->IsActiveHS(eq,hs)) newHandler->ActivateHS(eq,hs); + } + if (IsDeadHS(eq,hs)) { + newHandler->SetDeadHS(eq,hs); + if (other->IsDeadHS(eq,hs)) newHandler->SetDeadHS(eq,hs,kFALSE); + } + for (UInt_t chip=0; chip<10; chip++) { + if (!(IsActiveChip(eq,hs,chip))) { + newHandler->ActivateChip(eq,hs,chip,kFALSE); + if (!other->IsActiveChip(eq,hs,chip)) newHandler->ActivateHS(eq,hs,chip); + } + if (IsDeadChip(eq,hs,chip)) { + newHandler->SetDeadChip(eq,hs,chip); + if (other->IsDeadChip(eq,hs,chip)) newHandler->SetDeadChip(eq,hs,chip,kFALSE); + } + } + } + } + + for (UInt_t gloChip=0; gloChip<1200; gloChip++) { + for (UInt_t ind1=0; ind1GetKeyIndex(ind1); + UInt_t eq = GetEqIdFromKey(key); + UInt_t hs = GetHSFromKey(key); + UInt_t chip = GetChipFromKey(key); + UInt_t col = GetColFromKey(key); + UInt_t row = GetRowFromKey(key); + if (!(other->IsPixelDead(eq,hs,chip,col,row))) { + newHandler->SetDeadPixel(eq,hs,chip,col,row); + } + } + } + + return newHandler; +} +//____________________________________________________________________________________________ +AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetDeadDiff(AliITSOnlineCalibrationSPDhandler* other) const { + // returns handler with dead in this' lists, except for those in other's lists + AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler(); + for (UInt_t gloChip=0; gloChip<1200; gloChip++) { + for (UInt_t ind1=0; ind1GetKeyIndex(ind1); + UInt_t eq = GetEqIdFromKey(key); + UInt_t hs = GetHSFromKey(key); + UInt_t chip = GetChipFromKey(key); + UInt_t col = GetColFromKey(key); + UInt_t row = GetRowFromKey(key); + if (!(other->IsPixelDead(eq,hs,chip,col,row))) { + newHandler->SetDeadPixel(eq,hs,chip,col,row); + } + } + } + return newHandler; +} +//____________________________________________________________________________________________ +AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetNoisyDiff(AliITSOnlineCalibrationSPDhandler* other) const { + // returns handler with noisy in this' lists, except for those in other's lists + AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler(); + for (UInt_t gloChip=0; gloChip<1200; gloChip++) { + for (UInt_t ind2=0; ind2GetKeyIndex(ind2); + UInt_t eq = GetEqIdFromKey(key); + UInt_t hs = GetHSFromKey(key); + UInt_t chip = GetChipFromKey(key); + UInt_t col = GetColFromKey(key); + UInt_t row = GetRowFromKey(key); + if (!(other->IsPixelNoisy(eq,hs,chip,col,row))) { + newHandler->SetNoisyPixel(eq,hs,chip,col,row); + } + } + } + return newHandler; +} +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexDead(UInt_t module, UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) const { + // find gloChip and chipIndex from module and index + if (indexindex) { + chipIndex = index-glVal; + break; + } + else { + glVal+=fNrDead[gloChip]; + } + } -Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDeadMKey(UInt_t module, Int_t key) const { - // is this pixel dead? - if ( fDeadPixelMap[module]->Find(key) != NULL ) { - return kTRUE; } else { - return kFALSE; + Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexDead", "Index %d out of bounds.", index); } } +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexNoisy(UInt_t module, UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) const { + // find gloChip and chipIndex from module and index + if (indexindex) { + chipIndex = index-glVal; + break; + } + else { + glVal+=fNrNoisy[gloChip]; + } + } -Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDead(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const { - // is the pixel dead? - UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip); - Int_t key = GetKey(eqId,hs,chip,col,row); - return IsPixelDeadMKey(module,key); + } + else { + Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexNoisy", "Index %d out of bounds.", index); + } } +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexEqDead(UInt_t eq, UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) const { + // find gloChip and chipIndex from module and index + if (indexindex) { + chipIndex = index-glVal; + break; + } + else { + glVal+=fNrDead[gloChip]; + } + } + } + + } + else { + Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexEqDead", "Index %d out of bounds.", index); + } } +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexEqNoisy(UInt_t eq, UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) const { + // find gloChip and chipIndex from module and index + if (indexindex) { + chipIndex = index-glVal; + break; + } + else { + glVal+=fNrNoisy[gloChip]; + } + } + } + + } + else { + Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexEqNoisy", "Index %d out of bounds.", index); + } +} +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexTotDead(UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) const { + // find gloChip and chipIndex from global index + if (indexindex) { + chipIndex = index-glVal; + break; + } + else { + glVal+=fNrDead[gloChip]; + } + } -UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDead() const { - // returns the total nr of dead pixels - UInt_t nrDead = 0; - for (UInt_t module=0; module<240; module++) { - nrDead+=fNrDead[module]; } - return nrDead; -} + else { + Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexTotDead", "Index %d out of bounds.", index); + } +} +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexTotNoisy(UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) const { + // find gloChip and chipIndex from global index + if (indexindex) { + chipIndex = index-glVal; + break; + } + else { + glVal+=fNrNoisy[gloChip]; + } + } -UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDead(UInt_t module) const { - // returns the number of dead pixels for a certain module - if (module<240) { - return fNrDead[module]; } else { - return 0; + Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexTotNoisy", "Index %d out of bounds.", index); } } - -UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAt(UInt_t module, UInt_t index) { - // get eqId for the dead pixel at position index in list of dead - if (indexGetKeyIndex(index); - return GetEqIdFromKey(key); +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetEqIdFromOffline(UInt_t module) const { + // module to eq mapping + if (module>=240) { + Error("AliITSOnlineCalibrationSPDhandler::GetEqIdFromOffline", "module nr (%d) out of bounds.",module); + return 20; } - else { - Error("AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAt", "Index %d out of bounds.", index); - return 0; + return AliITSRawStreamSPD::GetOnlineEqIdFromOffline(module); +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetHSFromOffline(UInt_t module) const { + // module to hs mapping + if (module>=240) { + Error("AliITSOnlineCalibrationSPDhandler::GetHSFromOffline", "module nr (%d) out of bounds.",module); + return 6; } + return AliITSRawStreamSPD::GetOnlineHSFromOffline(module); } -UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAt(UInt_t module, UInt_t index) { - // get hs for the dead pixel at position index in list of dead - if (indexGetKeyIndex(index); - return GetHSFromKey(key); +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetChipFromOffline(UInt_t module, UInt_t colM) const { + // module,colM to chip mapping + if (module>=240 || colM>=160) { + Error("AliITSOnlineCalibrationSPDhandler::GetChipFromOffline", "module,colM nrs (%d,%d) out of bounds.",module,colM); + return 10; } - else { - Error("AliITSOnlineCalibrationSPDhandler::GetDeadHSAt", "Index %d out of bounds.", index); + return AliITSRawStreamSPD::GetOnlineChipFromOffline(module,colM); +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetColFromOffline(UInt_t module, UInt_t colM) const { + // colM to col mapping + if (colM>=160) { + Error("AliITSOnlineCalibrationSPDhandler::GetColFromOffline", "colM nr (%d) out of bounds.",colM); + return 160; + } + return AliITSRawStreamSPD::GetOnlineColFromOffline(module,colM); +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetRowFromOffline(UInt_t module, UInt_t rowM) const { + // rowM to row mapping + if (rowM>=256) { + Error("AliITSOnlineCalibrationSPDhandler::GetRowFromOffline", "rowM nr (%d) out of bounds.",rowM); + return 256; + } + return AliITSRawStreamSPD::GetOnlineRowFromOffline(module,rowM); +} +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadC2(UInt_t gloChip) const { + // returns nr of dead pixels on this chip + if (gloChip>=1200) { + Error("AliITSOnlineCalibrationSPDhandler::GetNrDeadC2", "global chip nr (%d) out of bounds.",gloChip); return 0; } + return fNrDead[gloChip]; } -UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAt(UInt_t module, UInt_t index) { - // get chip for the dead pixel at position index in list of dead - if (indexGetKeyIndex(index); - return GetChipFromKey(key); - } - else { - Error("AliITSOnlineCalibrationSPDhandler::GetDeadChipAt", "Index %d out of bounds.", index); +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisyC2(UInt_t gloChip) const { + // returns nr of noisy pixels on this chip + if (gloChip>=1200) { + Error("AliITSOnlineCalibrationSPDhandler::GetNrNoisyC2", "global chip nr (%d) out of bounds.",gloChip); return 0; } + return fNrNoisy[gloChip]; } -UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAt(UInt_t module, UInt_t index) { - // get column for the dead pixel at position index in list of dead - if (indexGetKeyIndex(index); - return GetColFromKey(key); +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAtC2(UInt_t gloChip, UInt_t index) const { + // get eq for the dead pixel at position index in list of dead + if (gloChip>=1200) { + Error("AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAtC", "global chip nr (%d) out of bounds.",gloChip); + return 20; + } + if (indexGetKeyIndex(index); + return GetEqIdFromKey(key); } else { - Error("AliITSOnlineCalibrationSPDhandler::GetDeadColAt", "Index %d out of bounds.", index); + Error("AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAtC", "Index %d out of bounds.", index); return 0; } } -UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAt(UInt_t module, UInt_t index) { - // get row for the dead pixel at position index in list of dead - if (indexGetKeyIndex(index); - return GetRowFromKey(key); +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAtC2(UInt_t gloChip, UInt_t index) const { + // get eq for the noisy pixel at position index in list of noisy + if (gloChip>=1200) { + Error("AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAtC", "global chip nr (%d) out of bounds.",gloChip); + return 20; + } + if (indexGetKeyIndex(index); + return GetEqIdFromKey(key); } else { - Error("AliITSOnlineCalibrationSPDhandler::GetDeadRowAt", "Index %d out of bounds.", index); + Error("AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAtC", "Index %d out of bounds.", index); return 0; } } - -void AliITSOnlineCalibrationSPDhandler::ResetNoisy() { - // clear the list of noisy pixels - for (UInt_t module=0; module<240; module++) { - fNrNoisy[module]=0; - fNoisyPixelMap[module]->Clear(); +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAtC2(UInt_t gloChip, UInt_t index) const { + // get hs for the dead pixel at position index in list of dead + if (gloChip>=1200) { + Error("AliITSOnlineCalibrationSPDhandler::GetDeadHSAtC", "global chip nr (%d) out of bounds.",gloChip); + return 20; } -} -void AliITSOnlineCalibrationSPDhandler::ResetNoisyForChip(UInt_t eqId, UInt_t hs, UInt_t chip) { - // clear the noisy pixels for this chip - UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip); - for (UInt_t col=0; col<32; col++) { - for (UInt_t row=0; row<256; row++) { - Int_t key = GetKey(eqId,hs,chip,col,row); - if (fNoisyPixelMap[module]->Remove(key)) { - fNrNoisy[module]--; - } - } + if (indexGetKeyIndex(index); + return GetHSFromKey(key); } -} - - -Bool_t AliITSOnlineCalibrationSPDhandler::SetNoisyPixel(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) { - // set a noisy pixel, returns false if already there - UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip); - Int_t key = GetKey(eqId,hs,chip,col,row); -//!!! // if dead before - remove from the dead list -//!!! UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip); -//!!! if (fDeadPixelMap.Remove(key)) { -//!!! fNrDead[module]--; -//!!! } - if (fNoisyPixelMap[module]->Insert(key,col)) { - fNrNoisy[module]++; - return kTRUE; + else { + Error("AliITSOnlineCalibrationSPDhandler::GetDeadHSAtC", "Index %d out of bounds.", index); + return 0; } - return kFALSE; } - -Bool_t AliITSOnlineCalibrationSPDhandler::SetNoisyPixelM(UInt_t module, UInt_t colM, UInt_t row) { - // set a noisy pixel, returns false if already there - UInt_t eqId = GetEqIdFromOffline(module); - UInt_t hs = GetHSFromOffline(module); - UInt_t chip = GetChipFromOffline(module,colM); - UInt_t col = GetColFromOffline(colM); - Int_t key = GetKey(eqId,hs,chip,col,row); -//!!! // if dead before - remove from the dead list -//!!! if (fDeadPixelMap[module]->Remove(key)) { -//!!! fNrDead[module]--; -//!!! } - if (fNoisyPixelMap[module]->Insert(key,col)) { - fNrNoisy[module]++; - return kTRUE; +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAtC2(UInt_t gloChip, UInt_t index) const { + // get hs for the noisy pixel at position index in list of noisy + if (gloChip>=1200) { + Error("AliITSOnlineCalibrationSPDhandler::GetNoisyHSAtC", "global chip nr (%d) out of bounds.",gloChip); + return 20; } - return kFALSE; -} - -Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyKey(Int_t key) const { - // is this pixel noisy? - UInt_t eqId = GetEqIdFromKey(key); - UInt_t hs = GetHSFromKey(key); - UInt_t chip = GetChipFromKey(key); - UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip); - return IsPixelNoisyMKey(module,key); -} - -Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyMKey(UInt_t module, Int_t key) const { - // is this pixel noisy? - if ( fNoisyPixelMap[module]->Find(key) != NULL ) { - return kTRUE; + if (indexGetKeyIndex(index); + return GetHSFromKey(key); } else { - return kFALSE; + Error("AliITSOnlineCalibrationSPDhandler::GetNoisyHSAtC", "Index %d out of bounds.", index); + return 0; } } - -Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisy(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const { - // is this pixel noisy? - UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip); - Int_t key = GetKey(eqId,hs,chip,col,row); - return IsPixelNoisyMKey(module,key); -} - -Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyM(UInt_t module, UInt_t colM, UInt_t row) { - // is this pixel noisy? - UInt_t eqId = GetEqIdFromOffline(module); - UInt_t hs = GetHSFromOffline(module); - UInt_t chip = GetChipFromOffline(module,colM); - UInt_t col = GetColFromOffline(colM); - Int_t key = GetKey(eqId,hs,chip,col,row); - return IsPixelNoisyMKey(module,key); -} - -UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisy() const { - // returns the total nr of noisy pixels - UInt_t nrNoisy = 0; - for (UInt_t module=0; module<240; module++) { - nrNoisy+=fNrNoisy[module]; +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAtC2(UInt_t gloChip, UInt_t index) const { + // get chip for the dead pixel at position index in list of dead + if (gloChip>=1200) { + Error("AliITSOnlineCalibrationSPDhandler::GetDeadChipAtC", "global chip nr (%d) out of bounds.",gloChip); + return 20; } - return nrNoisy; -} - -UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisy(UInt_t module) const { -// returns the number of noisy pixels for a certain module - if (module<240) { - return fNrNoisy[module]; + if (indexGetKeyIndex(index); + return GetChipFromKey(key); } else { + Error("AliITSOnlineCalibrationSPDhandler::GetDeadChipAtC", "Index %d out of bounds.", index); return 0; } } - -UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAt(UInt_t module, UInt_t index) { +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAtC2(UInt_t gloChip, UInt_t index) const { // get chip for the noisy pixel at position index in list of noisy - if (indexGetKeyIndex(index); - return GetEqIdFromKey(key); + if (gloChip>=1200) { + Error("AliITSOnlineCalibrationSPDhandler::GetNoisyChipAtC", "global chip nr (%d) out of bounds.",gloChip); + return 20; + } + if (indexGetKeyIndex(index); + return GetChipFromKey(key); } else { - Error("AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAt", "Index %d out of bounds.", index); + Error("AliITSOnlineCalibrationSPDhandler::GetNoisyChipAtC", "Index %d out of bounds.", index); return 0; } } -UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAt(UInt_t module, UInt_t index) { - // get chip for the noisy pixel at position index in list of noisy - if (indexGetKeyIndex(index); - return GetHSFromKey(key); +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAtC2(UInt_t gloChip, UInt_t index) const { + // get col for the dead pixel at position index in list of dead + if (gloChip>=1200) { + Error("AliITSOnlineCalibrationSPDhandler::GetDeadColAtC2", "global chip nr (%d) out of bounds.",gloChip); + return 20; + } + if (indexGetKeyIndex(index); + return GetColFromKey(key); } else { - Error("AliITSOnlineCalibrationSPDhandler::GetNoisyHSAt", "Index %d out of bounds.", index); + Error("AliITSOnlineCalibrationSPDhandler::GetDeadColAtC2", "Index %d out of bounds.", index); return 0; } } -UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAt(UInt_t module, UInt_t index) { - // get chip for the noisy pixel at position index in list of noisy - if (indexGetKeyIndex(index); - return GetChipFromKey(key); +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAtC2(UInt_t gloChip, UInt_t index) const { + // get col for the noisy pixel at position index in list of noisy + if (gloChip>=1200) { + Error("AliITSOnlineCalibrationSPDhandler::GetNoisyColAtC", "global chip nr (%d) out of bounds.",gloChip); + return 20; + } + if (indexGetKeyIndex(index); + return GetColFromKey(key); } else { - Error("AliITSOnlineCalibrationSPDhandler::GetNoisyChipAt", "Index %d out of bounds.", index); + Error("AliITSOnlineCalibrationSPDhandler::GetNoisyColAtC", "Index %d out of bounds.", index); return 0; } } -UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAt(UInt_t module, UInt_t index) { - // get column for the noisy pixel at position index in list of noisy - if (indexGetKeyIndex(index); - return GetColFromKey(key); +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAtC2(UInt_t gloChip, UInt_t index) const { + // get row for the dead pixel at position index in list of dead + if (gloChip>=1200) { + Error("AliITSOnlineCalibrationSPDhandler::GetDeadRowAtC", "global chip nr (%d) out of bounds.",gloChip); + return 20; + } + if (indexGetKeyIndex(index); + return GetRowFromKey(key); } else { - Warning("AliITSOnlineCalibrationSPDhandler::GetNoisyColAt", "Index %d out of bounds.", index); + Error("AliITSOnlineCalibrationSPDhandler::GetDeadRowAtC", "Index %d out of bounds.", index); return 0; } } -UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAt(UInt_t module, UInt_t index) { +//____________________________________________________________________________________________ +UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAtC2(UInt_t gloChip, UInt_t index) const { // get row for the noisy pixel at position index in list of noisy - if (indexGetKeyIndex(index); + if (gloChip>=1200) { + Error("AliITSOnlineCalibrationSPDhandler::GetNoisyRowAtC", "global chip nr (%d) out of bounds.",gloChip); + return 20; + } + if (indexGetKeyIndex(index); return GetRowFromKey(key); } else { - Error("AliITSOnlineCalibrationSPDhandler::GetNoisyRowAt", "Index %d out of bounds.", index); + Error("AliITSOnlineCalibrationSPDhandler::GetNoisyRowAtC", "Index %d out of bounds.", index); return 0; } } - -void AliITSOnlineCalibrationSPDhandler::PrintDead() const { - // print the dead pixels to screen - printf("-----------------------------------\n"); - printf("Dead Pixels: (eqId,hs,chip,col,row)\n"); - printf("-----------------------------------\n"); - for (UInt_t module=0; module<240; module++) { - for (UInt_t index=0; indexGetKeyIndex(index); - UInt_t eqId = GetEqIdFromKey(key); - UInt_t hs = GetHSFromKey(key); - UInt_t chip = GetChipFromKey(key); - UInt_t col = GetColFromKey(key); - UInt_t row = GetRowFromKey(key); - printf("%d,%d,%d,%d,%d\n",eqId,hs,chip,col,row); +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::ActivateALL() { + // activate all eq,hs,chips + for (UInt_t eq=0; eq<20; eq++) { + ActivateEq(eq); + for (UInt_t hs=0; hs<6; hs++) { + ActivateHS(eq,hs); + for (UInt_t chip=0; chip<10; chip++) { + ActivateChip(eq,hs,chip); + } } } } - -void AliITSOnlineCalibrationSPDhandler::PrintNoisy() const { - // print the dead pixels to screen - printf("-----------------------------------\n"); - printf("Noisy Pixels: (eqId,hs,chip,col,row)\n"); - printf("-----------------------------------\n"); - for (UInt_t module=0; module<240; module++) { - for (UInt_t index=0; indexGetKeyIndex(index); - UInt_t eqId = GetEqIdFromKey(key); - UInt_t hs = GetHSFromKey(key); - UInt_t chip = GetChipFromKey(key); - UInt_t col = GetColFromKey(key); - UInt_t row = GetRowFromKey(key); - printf("%d,%d,%d,%d,%d\n",eqId,hs,chip,col,row); - } +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::ActivateEq(UInt_t eq, Bool_t setval) { + // activate eq + if (eq>=20) { + Error("AliITSOnlineCalibrationSPDhandler::ActivateEq", "eq (%d) out of bounds.",eq); + return; } + fActiveEq[eq] = setval; } - -UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadDiff(AliITSOnlineCalibrationSPDhandler* other) const { - // returns nr of dead in this' lists and not in other's lists - UInt_t returnval=0; - for (UInt_t module=0; module<240; module++) { - for (UInt_t ind1=0; ind1GetKeyIndex(ind1); - UInt_t eqId = GetEqIdFromKey(key); - UInt_t hs = GetHSFromKey(key); - UInt_t chip = GetChipFromKey(key); - UInt_t col = GetColFromKey(key); - UInt_t row = GetRowFromKey(key); - if (!(other->IsPixelDead(eqId,hs,chip,col,row))) { - returnval++; - } - } +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::ActivateHS(UInt_t eq, UInt_t hs, Bool_t setval) { + // activate hs + if (eq>=20 || hs>=6) { + Error("AliITSOnlineCalibrationSPDhandler::ActivateHS", "eq,hs (%d,%d) out of bounds.",eq,hs); + return; } - return returnval; + fActiveHS[eq][hs] = setval; } - -UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisyDiff(AliITSOnlineCalibrationSPDhandler* other) const { - // returns nr of noisy in this' lists and not in other's lists - UInt_t returnval=0; - for (UInt_t module=0; module<240; module++) { - for (UInt_t ind1=0; ind1GetKeyIndex(ind1); - UInt_t eqId = GetEqIdFromKey(key); - UInt_t hs = GetHSFromKey(key); - UInt_t chip = GetChipFromKey(key); - UInt_t col = GetColFromKey(key); - UInt_t row = GetRowFromKey(key); - if (!(other->IsPixelNoisy(eqId,hs,chip,col,row))) { - returnval++; - } - } +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::ActivateChip(UInt_t eq, UInt_t hs, UInt_t chip, Bool_t setval) { + // activate chip + if (eq>=20 || hs>=6 || chip>=10) { + Error("AliITSOnlineCalibrationSPDhandler::ActivateChip", "eq,hs,chip (%d,%d,%d) out of bounds.",eq,hs,chip); + return; } - return returnval; + fActiveChip[eq][hs][chip] = setval; } - -UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDiff(AliITSOnlineCalibrationSPDhandler* other) const { - // returns nr of dead/noisy in this' lists and not in other's lists - return GetNrDeadDiff(other) + GetNrNoisyDiff(other); +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::IsActiveEq(UInt_t eq) const { + // Is eq active? + if (eq>=20) { + Error("AliITSOnlineCalibrationSPDhandler::IsActiveEq", "eq (%d) out of bounds.",eq); + return kFALSE; + } + return fActiveEq[eq]; } - -AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetDiff(AliITSOnlineCalibrationSPDhandler* other) const { - // returns handler with dead/noisy in this' lists, except for those in other's lists - AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler(); - for (UInt_t module=0; module<240; module++) { - for (UInt_t ind1=0; ind1GetKeyIndex(ind1); - UInt_t eqId = GetEqIdFromKey(key); - UInt_t hs = GetHSFromKey(key); - UInt_t chip = GetChipFromKey(key); - UInt_t col = GetColFromKey(key); - UInt_t row = GetRowFromKey(key); - if (!(other->IsPixelDead(eqId,hs,chip,col,row))) { - newHandler->SetDeadPixel(eqId,hs,chip,col,row); - } - } - for (UInt_t ind2=0; ind2GetKeyIndex(ind2); - UInt_t eqId = GetEqIdFromKey(key); - UInt_t hs = GetHSFromKey(key); - UInt_t chip = GetChipFromKey(key); - UInt_t col = GetColFromKey(key); - UInt_t row = GetRowFromKey(key); - if (!(other->IsPixelNoisy(eqId,hs,chip,col,row))) { - newHandler->SetNoisyPixel(eqId,hs,chip,col,row); - } - } +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::IsActiveHS(UInt_t eq, UInt_t hs) const { + // Is hs active? + if (eq>=20 || hs>=6) { + Error("AliITSOnlineCalibrationSPDhandler::IsActiveHS", "eq,hs (%d,%d) out of bounds.",eq,hs); + return kFALSE; } - return newHandler; + return fActiveHS[eq][hs]; } - -AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetDeadDiff(AliITSOnlineCalibrationSPDhandler* other) const { - // returns handler with dead in this' lists, except for those in other's lists - AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler(); - for (UInt_t module=0; module<240; module++) { - for (UInt_t ind1=0; ind1GetKeyIndex(ind1); - UInt_t eqId = GetEqIdFromKey(key); - UInt_t hs = GetHSFromKey(key); - UInt_t chip = GetChipFromKey(key); - UInt_t col = GetColFromKey(key); - UInt_t row = GetRowFromKey(key); - if (!(other->IsPixelDead(eqId,hs,chip,col,row))) { - newHandler->SetDeadPixel(eqId,hs,chip,col,row); +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::IsActiveChip(UInt_t eq, UInt_t hs, UInt_t chip) const { + // Is chip active? + if (eq>=20 || hs>=6 || chip>=10) { + Error("AliITSOnlineCalibrationSPDhandler::IsActiveChip", "eq,hs,chip (%d,%d,%d) out of bounds.",eq,hs,chip); + return kFALSE; + } + return fActiveChip[eq][hs][chip]; +} +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::UnSetDeadALL() { + // Clear all dead eq,hs,chips + for (UInt_t eq=0; eq<20; eq++) { + SetDeadEq(eq,kFALSE); + for (UInt_t hs=0; hs<6; hs++) { + SetDeadHS(eq,hs,kFALSE); + for (UInt_t chip=0; chip<10; chip++) { + SetDeadChip(eq,hs,chip,kFALSE); } } } - return newHandler; } - -AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetNoisyDiff(AliITSOnlineCalibrationSPDhandler* other) const { - // returns handler with noisy in this' lists, except for those in other's lists - AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler(); - for (UInt_t module=0; module<240; module++) { - for (UInt_t ind2=0; ind2GetKeyIndex(ind2); - UInt_t eqId = GetEqIdFromKey(key); - UInt_t hs = GetHSFromKey(key); - UInt_t chip = GetChipFromKey(key); - UInt_t col = GetColFromKey(key); - UInt_t row = GetRowFromKey(key); - if (!(other->IsPixelNoisy(eqId,hs,chip,col,row))) { - newHandler->SetNoisyPixel(eqId,hs,chip,col,row); - } - } +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::SetDeadEq(UInt_t eq, Bool_t setval) { + // set eq dead + if (eq>=20) { + Error("AliITSOnlineCalibrationSPDhandler::SetDeadEq", "eq (%d) out of bounds.",eq); + return; } - return newHandler; + fDeadEq[eq] = setval; } - -void AliITSOnlineCalibrationSPDhandler::InitModuleMaps() { - // initializes the module mapping arrays needed for the methods below (GetEqIdFromOffline etc.) - for (UInt_t iDDL=0; iDDL<20; iDDL++) { - for (UInt_t iModule=0; iModule<12; iModule++) { - UInt_t module = AliITSRawStreamSPD::GetModuleNumber(iDDL,iModule); - fiDDL[module] = iDDL; - fiModule[module] = iModule; - } +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::SetDeadHS(UInt_t eq, UInt_t hs, Bool_t setval) { + // set hs dead + if (eq>=20 || hs>=6) { + Error("AliITSOnlineCalibrationSPDhandler::SetDeadHS", "eq,hs (%d,%d) out of bounds.",eq,hs); + return; } + fDeadHS[eq][hs] = setval; } - -void AliITSOnlineCalibrationSPDhandler::GenerateDCSConfigFile(const Char_t* fileName) { - // generates an ascii file in the format as the one produced by online da (but with dummy runNr=0) - ofstream dcsfile; - dcsfile.open(fileName); - dcsfile << "[SPD SCAN]\n"; - dcsfile << "RunNumber=" << "0" << "\n"; // dummy value - dcsfile << "Type=" << "4" << "\n"; - dcsfile << "Router=" << "0" << "\n"; // dummy value - dcsfile << "ActualDetCoonfiguration=" << "0,-1,-1\n"; // dummy values - dcsfile << "[NOISY]\n"; - for (UInt_t module=0; module<240; module++) { - UInt_t headkey=20*10*6; - for (UInt_t ind=0; ind=20 || hs>=6 || chip>=10) { + Error("AliITSOnlineCalibrationSPDhandler::SetDeadChip", "eq,hs,chip (%d,%d,%d) out of bounds.",eq,hs,chip); + return; } - dcsfile.close(); + fDeadChip[eq][hs][chip] = setval; } - -UInt_t AliITSOnlineCalibrationSPDhandler::GetEqIdFromOffline(UInt_t module) { - // module to eqId mapping - if (!fModuleMapInited) InitModuleMaps(); - return fiDDL[module]; +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::IsDeadEq(UInt_t eq) const { + // is eq dead? + if (eq>=20) { + Error("AliITSOnlineCalibrationSPDhandler::IsDeadEq", "eq (%d) out of bounds.",eq); + return kFALSE; + } + return fDeadEq[eq]; } -UInt_t AliITSOnlineCalibrationSPDhandler::GetHSFromOffline(UInt_t module) { - // module to hs mapping - if (!fModuleMapInited) InitModuleMaps(); - return fiModule[module]/2; +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::IsDeadHS(UInt_t eq, UInt_t hs) const { + // is hs dead? + if (eq>=20 || hs>=6) { + Error("AliITSOnlineCalibrationSPDhandler::IsDeadHS", "eq,hs (%d,%d) out of bounds.",eq,hs); + return kFALSE; + } + return fDeadHS[eq][hs]; } -UInt_t AliITSOnlineCalibrationSPDhandler::GetChipFromOffline(UInt_t module, UInt_t colM) { - // module,colM to chip mapping - if (!fModuleMapInited) InitModuleMaps(); - return colM/32 + 5*(fiModule[module]%2); +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::IsDeadChip(UInt_t eq, UInt_t hs, UInt_t chip) const { + // is chip dead? + if (eq>=20 || hs>=6 || chip>=10) { + Error("AliITSOnlineCalibrationSPDhandler::IsDeadChip", "eq,hs,chip (%d,%d,%d) out of bounds.",eq,hs,chip); + return kFALSE; + } + return fDeadChip[eq][hs][chip]; } -UInt_t AliITSOnlineCalibrationSPDhandler::GetColFromOffline(UInt_t colM) const { - // colM to col mapping - return colM%32; +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::IsSilentEq(UInt_t eq) const { + // is eq silent? + if (eq>=20) { + Error("AliITSOnlineCalibrationSPDhandler::IsSilentEq", "eq (%d) out of bounds.",eq); + return kFALSE; + } + return (!IsActiveEq(eq) || IsDeadEq(eq)); +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::IsSilentHS(UInt_t eq, UInt_t hs) const { + // is hs silent? + if (eq>=20 || hs>=6) { + Error("AliITSOnlineCalibrationSPDhandler::IsSilentHS", "eq,hs (%d,%d) out of bounds.",eq,hs); + return kFALSE; + } + return (!IsActiveEq(eq) || IsDeadEq(eq) || !IsActiveHS(eq,hs) || IsDeadHS(eq,hs)); +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::IsSilentChip(UInt_t eq, UInt_t hs, UInt_t chip) const { + // is chip silent? + if (eq>=20 || hs>=6 || chip>=10) { + Error("AliITSOnlineCalibrationSPDhandler::IsSilentChip", "eq,hs,chip (%d,%d,%d) out of bounds.",eq,hs,chip); + return kFALSE; + } + return (!IsActiveEq(eq) || IsDeadEq(eq) || !IsActiveHS(eq,hs) || IsDeadHS(eq,hs) || !IsActiveChip(eq,hs,chip) || IsDeadChip(eq,hs,chip)); +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::IsNoisyChip(UInt_t eq, UInt_t hs, UInt_t chip) const { + // returns true if there is at least a noisy pixel in the chip + + if (eq>=20 || hs>=6 || chip>=10) { + Error("AliITSOnlineCalibrationSPDhandler::IsNoisyChip", "eq,hs,chip (%d,%d,%d) out of bounds.",eq,hs,chip); + return kFALSE; + } + Bool_t isNoisy = kFALSE; + + UInt_t nrNoisy = GetNrNoisy(); + for (UInt_t i=0; i