X-Git-Url: http://git.uio.no/git/?p=u%2Fmrichter%2FAliRoot.git;a=blobdiff_plain;f=ITS%2FAliITSOnlineCalibrationSPDhandler.cxx;h=14a921984a67ea6de9cd6785fe72430e877b930b;hp=cc4d1d5e7bcb5ffb2aede2bf50587115c46b3d62;hb=e63dc6442e960bfb55149a971c344c7152e515e6;hpb=b15de2d227dc229b7a81172ca9c5e251a02fa520 diff --git a/ITS/AliITSOnlineCalibrationSPDhandler.cxx b/ITS/AliITSOnlineCalibrationSPDhandler.cxx index cc4d1d5e7bc..14a921984a6 100644 --- a/ITS/AliITSOnlineCalibrationSPDhandler.cxx +++ b/ITS/AliITSOnlineCalibrationSPDhandler.cxx @@ -2,121 +2,256 @@ // 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. // ////////////////////////////////////////////////////////////////////// #include "AliITSOnlineCalibrationSPDhandler.h" #include "AliITSOnlineCalibrationSPD.h" +#include "AliITSTriggerConditions.h" +#include "AliITSIntMap.h" +#include #include +#include #include +#include +#include -AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler(): - fModuleNr(0), - fDeadPixelMap(AliITSIntMap()), - fNoisyPixelMap(AliITSIntMap()) -{} +#ifndef SPD_DA_OFF // you may want to exclude cdb classes, if using this class outside aliroot +#include "AliITSCalibrationSPD.h" +#include "AliCDBManager.h" +#include "AliCDBEntry.h" +#endif + +/* $Id$ */ -AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler(UInt_t module): - fModuleNr(module), - fDeadPixelMap(AliITSIntMap()), - fNoisyPixelMap(AliITSIntMap()) -{} +using std::ifstream; +using std::ofstream; +//____________________________________________________________________________________________ +AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler(): + fFileLocation("."), + fTriggerConditions(0) +{ + // constructor + for (UInt_t gloChip=0; gloChip<1200; gloChip++) { + fNrDead[gloChip]=0; + fNrSparseDead[gloChip]=0; + fNrNoisy[gloChip]=0; + fDeadPixelMap[gloChip] = new AliITSIntMap(); + fSparseDeadPixelMap[gloChip] = new AliITSIntMap(); + fNoisyPixelMap[gloChip] = new AliITSIntMap(); + } + ActivateALL(); + UnSetDeadALL(); +} +//____________________________________________________________________________________________ AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler(const AliITSOnlineCalibrationSPDhandler& handle): - fModuleNr(handle.fModuleNr), - fDeadPixelMap(AliITSIntMap()), - fNoisyPixelMap(AliITSIntMap()) + fFileLocation("."), + fTriggerConditions(handle.fTriggerConditions) { // copy constructor - UInt_t nrDead = handle.GetNrDead(); - for (UInt_t index=0; indexSetDeadPixel(handle.GetDeadColAt(index),handle.GetDeadRowAt(index)); + for (UInt_t gloChip=0; gloChip<1200; gloChip++) { + fNrDead[gloChip] = handle.fNrDead[gloChip]; + fNrSparseDead[gloChip] = handle.fNrSparseDead[gloChip]; + fNrNoisy[gloChip] = handle.fNrNoisy[gloChip]; + fDeadPixelMap[gloChip] = handle.fDeadPixelMap[gloChip]->Clone(); + fSparseDeadPixelMap[gloChip] = handle.fSparseDeadPixelMap[gloChip]->Clone(); + fNoisyPixelMap[gloChip] = handle.fNoisyPixelMap[gloChip]->Clone(); } - UInt_t nrNoisy = handle.GetNrNoisy(); - for (UInt_t index=0; indexSetNoisyPixel(handle.GetNoisyColAt(index),handle.GetNoisyRowAt(index)); + for (UInt_t eq=0; eq<20; eq++) { + fActiveEq[eq] = handle.fActiveEq[eq]; + fDeadEq[eq]=handle.fDeadEq[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]; + } + } } - sprintf(fFileLocation,"%s",handle.fFileLocation); + fFileLocation = handle.fFileLocation; } - +//____________________________________________________________________________________________ AliITSOnlineCalibrationSPDhandler::~AliITSOnlineCalibrationSPDhandler() { - ClearMaps(); + // ClearMaps(); + for (UInt_t gloChip=0; gloChip<1200; gloChip++) { + delete fDeadPixelMap[gloChip]; + delete fSparseDeadPixelMap[gloChip]; + delete fNoisyPixelMap[gloChip]; + } } - +//____________________________________________________________________________________________ AliITSOnlineCalibrationSPDhandler& AliITSOnlineCalibrationSPDhandler::operator=(const AliITSOnlineCalibrationSPDhandler& handle) { // assignment operator if (this!=&handle) { this->ClearMaps(); - fModuleNr = handle.fModuleNr; - UInt_t nrDead = handle.GetNrDead(); - for (UInt_t index=0; indexSetDeadPixel(handle.GetDeadColAt(index),handle.GetDeadRowAt(index)); + for (UInt_t gloChip=0; gloChip<1200; gloChip++) { + fNrDead[gloChip] = handle.fNrDead[gloChip]; + fNrSparseDead[gloChip] = handle.fNrSparseDead[gloChip]; + fNrNoisy[gloChip] = handle.fNrNoisy[gloChip]; + fDeadPixelMap[gloChip] = handle.fDeadPixelMap[gloChip]->Clone(); + fSparseDeadPixelMap[gloChip] = handle.fSparseDeadPixelMap[gloChip]->Clone(); + fNoisyPixelMap[gloChip] = handle.fNoisyPixelMap[gloChip]->Clone(); } - UInt_t nrNoisy = handle.GetNrNoisy(); - for (UInt_t index=0; indexSetNoisyPixel(handle.GetNoisyColAt(index),handle.GetNoisyRowAt(index)); + for (UInt_t eq=0; eq<20; eq++) { + fActiveEq[eq] = handle.fActiveEq[eq]; + fDeadEq[eq] = handle.fDeadEq[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]; + } + } } - sprintf(fFileLocation,"%s",handle.fFileLocation); + fFileLocation = handle.fFileLocation; } return *this; } - +//____________________________________________________________________________________________ void AliITSOnlineCalibrationSPDhandler::ClearMaps() { // clear the lists of dead and noisy ResetDead(); ResetNoisy(); + ActivateALL(); } - -void AliITSOnlineCalibrationSPDhandler::WriteToFile() { - // write the lists of dead and noisy to default file - Char_t fileName[200]; - sprintf(fileName,"%s/SPD_DeadNoisy_%d.root",fFileLocation,fModuleNr); - WriteToFile(fileName); +//____________________________________________________________________________________________ +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; + fNrSparseDead[gloChip]=0; + fDeadPixelMap[gloChip]->Clear(); + fSparseDeadPixelMap[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]--; + } + if (fSparseDeadPixelMap[gloChip]->Remove(key)) { + fNrSparseDead[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); + } + } } -void AliITSOnlineCalibrationSPDhandler::WriteToFile(Char_t* fileName) { - // write the lists of dead and noisy to file fileName - AliITSOnlineCalibrationSPD* calib = new AliITSOnlineCalibrationSPD(); - calib->SetModuleNr(GetModuleNr()); - calib->SetDeadList(GetDeadArray()); - calib->SetNoisyList(GetNoisyArray()); - calib->SetNrDead(GetNrDead()); - calib->SetNrNoisy(GetNrNoisy()); - - TFile file(fileName, "RECREATE"); - file.WriteTObject(calib, "AliITSOnlineCalibrationSPD"); - file.Close(); - delete calib; +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromFiles() { + // 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); } - -void AliITSOnlineCalibrationSPDhandler::ReadFromFile() { - // read dead and noisy from default file - Char_t fileName[200]; - sprintf(fileName,"%s/SPD_DeadNoisy_%d.root",fFileLocation,fModuleNr); - ReadFromFile(fileName); +//____________________________________________________________________________________________ +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 eq=0; eq<20; eq++) { + if (ReadSilentFromFile(eq)) { + returnval=kTRUE; + } + } + return returnval; +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFiles() { + // read dead,active files from file location. returns true if at least one file found + Bool_t returnval=kFALSE; + for (UInt_t eq=0; eq<20; eq++) { + if (ReadDeadFromFile(eq)) { + returnval=kTRUE; + } + } + return returnval; } -void AliITSOnlineCalibrationSPDhandler::ReadDeadFromFile() { - // read dead from default file - Char_t fileName[200]; - sprintf(fileName,"%s/SPD_DeadNoisy_%d.root",fFileLocation,fModuleNr); - ReadDeadFromFile(fileName); +//____________________________________________________________________________________________ +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()); } -void AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFile() { - // read noisy from default file - Char_t fileName[200]; - sprintf(fileName,"%s/SPD_DeadNoisy_%d.root",fFileLocation,fModuleNr); - ReadNoisyFromFile(fileName); +//____________________________________________________________________________________________ +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()); } - -void AliITSOnlineCalibrationSPDhandler::ReadFromFile(Char_t* fileName) { - // read dead and noisy from file fileName (clear the previous list of dead and noisy pixels) - ClearMaps(); +//____________________________________________________________________________________________ +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"); - if (fp0 == NULL) {} + if (fp0 == NULL) {return kFALSE;} else { fclose(fp0); TFile file(fileName, "READ"); @@ -124,29 +259,68 @@ void AliITSOnlineCalibrationSPDhandler::ReadFromFile(Char_t* fileName) { file.GetObject("AliITSOnlineCalibrationSPD", calib); file.Close(); if (calib!=NULL) { - SetModuleNr(calib->GetModuleNr()); - Int_t nrDead=calib->GetNrDead(); - for (Int_t index=0; indexGetDeadColAt(index); - Int_t row=calib->GetDeadRowAt(index); - SetDeadPixel(col,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); } - Int_t nrNoisy=calib->GetNrNoisy(); - for (Int_t index=0; indexGetNoisyColAt(index); - Int_t row=calib->GetNoisyRowAt(index); - SetNoisyPixel(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; } -void AliITSOnlineCalibrationSPDhandler::ReadDeadFromFile(Char_t* fileName) { - // read dead from file fileName (clear the previous list of dead pixels) - ResetDead(); +//____________________________________________________________________________________________ +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 eq=0; eq<20; eq++) { + if (ReadNoisyFromFile(eq)) { + returnval=kTRUE; + } + } + return returnval; +} +//____________________________________________________________________________________________ +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; FILE* fp0 = fopen(fileName, "r"); - if (fp0 == NULL) {} + if (fp0 == NULL) {return kFALSE;} else { fclose(fp0); TFile file(fileName, "READ"); @@ -154,176 +328,3059 @@ void AliITSOnlineCalibrationSPDhandler::ReadDeadFromFile(Char_t* fileName) { file.GetObject("AliITSOnlineCalibrationSPD", calib); file.Close(); if (calib!=NULL) { - SetModuleNr(calib->GetModuleNr()); - Int_t nrDead=calib->GetNrDead(); - for (Int_t index=0; indexGetDeadColAt(index); - Int_t row=calib->GetDeadRowAt(index); - SetDeadPixel(col,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; } -void AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFile(Char_t* fileName) { - // read noisy from file fileName (clear the previous list of noisy pixels) - ResetNoisy(); - AliITSOnlineCalibrationSPD* calib; - FILE* fp0 = fopen(fileName, "r"); - if (fp0 == NULL) {} +//____________________________________________________________________________________________ +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()) { + Warning("AliITSOnlineCalibrationSPDhandler::ReadDeadFromText","No dead text file (%s) present.",fileName); + } else { - fclose(fp0); - TFile file(fileName, "READ"); - if (file.IsOpen()) { - file.GetObject("AliITSOnlineCalibrationSPD", calib); - file.Close(); - if (calib!=NULL) { - SetModuleNr(calib->GetModuleNr()); - Int_t nrNoisy=calib->GetNrNoisy(); - for (Int_t index=0; indexGetNoisyColAt(index); - Int_t row=calib->GetNoisyRowAt(index); - SetNoisyPixel(col,row); + while(1) { + 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 (module==240 || (Int_t)module==AliITSRawStreamSPD::GetModuleNumber(eq,hs,chip)){ + if (SetDeadPixel(eq,hs,chip,col,row)) { + newNrDead++; } } + if (textFile.eof()) break; } + textFile.close(); } + return newNrDead; } - -TArrayI AliITSOnlineCalibrationSPDhandler::GetDeadArray() { - // get a TArrayI of the dead pixels (format for the AliITSCalibrationSPD object) - TArrayI returnArray; - returnArray.Set(GetNrDead()*2); - for (UInt_t index=0; index> 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 (module==240 || (Int_t)module==AliITSRawStreamSPD::GetModuleNumber(eq,hs,chip)){ + if (SetNoisyPixel(eq,hs,chip,col,row)) { + newNrNoisy++; + } + } + if (textFile.eof()) break; + } + textFile.close(); + } + return newNrNoisy; } +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::ReadPITConditionsFromText(const char *fileName) { + // read PIT conditions file from text as printed out at P2 + // !!! please note that the chip numbering goes from 9 to 0 in the text. In PVSS panels is the opposite. + if(fTriggerConditions) fTriggerConditions->ResetAll(); + else fTriggerConditions = new AliITSTriggerConditions(); + fTriggerConditions->ReadFromTextFile(fileName); +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::ReadPITConditionsFromDB(Int_t runNr, const Char_t *storage){ +// read PIT conditions from the OCDB -TArrayI AliITSOnlineCalibrationSPDhandler::GetNoisyArray() { - // get a TArrayI of the noisy pixels (format for the AliITSCalibrationSPD object) - TArrayI returnArray; - returnArray.Set(GetNrNoisy()*2); - for (UInt_t index=0; indexIsDefaultStorageSet()) { + man->SetDefaultStorage("local://$ALICE_ROOT/OCDB"); + } } - return returnArray; + else { + storageSTR = Form("%s",storage); + man->SetDefaultStorage(storageSTR.Data()); + } + AliCDBEntry *cdbEntry = man->Get("TRIGGER/SPD/PITConditions", runNr); + if(cdbEntry) { + fTriggerConditions = (AliITSTriggerConditions*)cdbEntry->GetObject(); + return kTRUE; + } else return kFALSE; } - -void AliITSOnlineCalibrationSPDhandler::ResetDead() { - fDeadPixelMap.Clear(); +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::WriteToFilesAlways() { + // write the lists of active,dead,noisy to files + for (UInt_t eq=0; eq<20; eq++) { + WriteSilentToFile(eq); + WriteNoisyToFile(eq); + } } - - -Bool_t AliITSOnlineCalibrationSPDhandler::SetDeadPixel(Int_t col, Int_t row) { - // set a dead pixel, returns false if pixel is already dead or noisy - Int_t key = GetKey(col,row); - // if noisy we dont want to add it... - if (fNoisyPixelMap.Find(key) != NULL) return kFALSE; - return fDeadPixelMap.Insert(key,col); +//____________________________________________________________________________________________ +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()); } - -Int_t AliITSOnlineCalibrationSPDhandler::GetDeadColAt(UInt_t index) const { - // get column for the dead pixel at position index in list of dead - if (index0 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("%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); -void AliITSOnlineCalibrationSPDhandler::ResetNoisy() { - // clear the list of noisy pixels - fNoisyPixelMap.Clear(); -} + 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); + } + } -Bool_t AliITSOnlineCalibrationSPDhandler::SetNoisyPixel(Int_t col, Int_t row) { - // set a noisy pixel, returns false if already there - Int_t key = GetKey(col,row); - // if dead before - remove from the dead list - fDeadPixelMap.Remove(key); - return fNoisyPixelMap.Insert(key,col); + spdEntry->SetOwner(kTRUE); + spdEntry->Clear(); + return kTRUE; } - -Int_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAt(UInt_t index) const { - // get column for the noisy pixel at position index in list of noisy - if (indexIsDefaultStorageSet()) { + man->SetDefaultStorage("local://$ALICE_ROOT/OCDB"); + } + } + else { + storageSTR = Form("%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 return 0; + else { + Warning("AliITSOnlineCalibrationSPDhandler::ReadNoisyModuleFromDB","Calibration for run %d not found in database.",runNr); + return kFALSE; + } + AliITSCalibrationSPD* calibSPD; + 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::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(); + TString storageSTR = Form("%s",storage); + if (storageSTR.CompareTo("default")==0) { + if(!man->IsDefaultStorageSet()) { + man->SetDefaultStorage("local://$ALICE_ROOT/OCDB"); + } + } + else { + storageSTR = Form("%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::ReadDeadFromDB","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); + } -Int_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAt(UInt_t index) const { - // get row for the noisy pixel at position index in list of noisy - if (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); + } + } } - else return 0; + spdEntry->SetOwner(kTRUE); + spdEntry->Clear(); + return kTRUE; } +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::ReadSparseDeadFromDB(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(); + TString storageSTR = Form("%s",storage); + if (storageSTR.CompareTo("default")==0) { + if(!man->IsDefaultStorageSet()) { + man->SetDefaultStorage("local://$ALICE_ROOT/OCDB"); + } + } + else { + storageSTR = Form("%s",storage); + man->SetDefaultStorage(storageSTR.Data()); + } + AliCDBEntry *cdbEntry = man->Get("ITS/Calib/SPDSparseDead", runNr); + TObjArray* spdEntry; + if(cdbEntry) { + spdEntry = (TObjArray*)cdbEntry->GetObject(); + if(!spdEntry) return kFALSE; + } + else { + Warning("AliITSOnlineCalibrationSPDhandler::ReadSparseDeadFromDB","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) { + RecursiveInsertSparseDead(calibSPD,module,0,nrDead-1); + } -Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisy(Int_t col, Int_t row) const { - // is this pixel noisy? - Int_t key = GetKey(col,row); - if ( fNoisyPixelMap.Find(key) != NULL ) { - return kTRUE; + else { + for (UInt_t index=0; indexGetBadColAt(index); + UInt_t rowM = calibSPD->GetBadRowAt(index); + SetSparseDeadPixelM(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"); + } + } + else { + storageSTR = Form("%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("%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); + } -void AliITSOnlineCalibrationSPDhandler::PrintDead() const { - // print the dead pixels to screen - printf("-----------------------\n"); - printf("Dead Pixels Module %d:\n",fModuleNr); - printf("-----------------------\n"); - 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; } - -void AliITSOnlineCalibrationSPDhandler::PrintNoisy() const { - // print the noisy pixels to screen - printf("-----------------------\n"); - printf("Noisy Pixels Module %d:\n",fModuleNr); - printf("-----------------------\n"); - for (UInt_t index=0; indexAt(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(const 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(); + TString storageSTR = Form("%s",storage); + if (storageSTR.CompareTo("default")==0) { + if(!man->IsDefaultStorageSet()) { + man->SetDefaultStorage("local://$ALICE_ROOT/OCDB"); + } + } + else { + storageSTR = Form("%s",storage); + man->SetDefaultStorage(storageSTR.Data()); + } + AliCDBMetaData* metaData = new AliCDBMetaData(); + metaData->SetResponsible("Henrik Tydesjo"); + metaData->SetComment("Created by AliITSOnlineCalibrationSPDhandler."); + AliCDBId idCalSPD("ITS/Calib/SPDDead",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; +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::WriteSparseDeadToDB(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"); + } + } + else { + storageSTR = Form("%s",storage); + man->SetDefaultStorage(storageSTR.Data()); + } + AliCDBMetaData* metaData = new AliCDBMetaData(); + metaData->SetResponsible("Annalisa Mastroserio"); + metaData->SetComment("Created by AliITSOnlineCalibrationSPDhandler."); + AliCDBId idCalSPD("ITS/Calib/SPDSparseDead",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); + //printf(" AliITSOnlineCalibrationSPDhandler::WriteSparseDeadToDB : nr Sparse dead in module %i - %i \n",module,GetNrSparseDead(module)); + calibSPD->SetNrBadSingle( GetNrSparseDead(module) ); + calibSPD->SetBadList( GetSparseDeadArray(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; +} +//____________________________________________________________________________________________ +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"); + } + } + else { + storageSTR = Form("%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; } +//____________________________________________________________________________________________ +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("%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::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::RecursiveInsertSparseDead(AliITSCalibrationSPD* calibSPD, UInt_t module, Int_t lowInd, Int_t highInd) { + // inserts sparse dead pixels recursively, used when reading from db + if (lowInd>highInd) return; + Int_t thisInd = lowInd+(highInd-lowInd)/2; + SetSparseDeadPixelM(module,calibSPD->GetBadColAt(thisInd),calibSPD->GetBadRowAt(thisInd)); + RecursiveInsertSparseDead(calibSPD,module,lowInd,thisInd-1); + RecursiveInsertSparseDead(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++) { + UInt_t headkey=20*10*6; + for (UInt_t ind=0; indPrepareSerialize(); // 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; + + 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::GetSparseDeadArray(UInt_t module, Bool_t treeSerial) { + // get a TArrayS of the single dead pixels (format for the AliITSCalibrationSPD object) + TArrayS returnArray; + + UInt_t eq = GetEqIdFromOffline(module); + UInt_t hs = GetHSFromOffline(module); + UInt_t size=GetNrSparseDead(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) fSparseDeadPixelMap[gloChip]->PrepareSerialize(); // for tree ordered values + else fSparseDeadPixelMap[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; + // 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::GetNoisyArrayOnline(UInt_t eq) { + // get a TArrayI of the single noisy pixels (format for the AliITSOnlineCalibrationSPD object) + TArrayI returnArray; + // 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 sparse-dead %*d noisy\n",2,eq,6,GetNrSilentEq(eq),6,GetNrDeadEq(eq),6,GetNrSparseDeadEq(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"); + } + } + + 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"); + } + } + } + } + + 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::PrintSparseDead() const { + // print the single dead pixels to screen (disregards inactive eq,hs,chip) + printf("------------------------------------------------------\n"); + printf("Sparse 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); + + 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 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::SetSparseDeadPixel(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 gloChip = GetGloChip(eq,hs,chip); + if (gloChip>=1200) { + Error("AliITSOnlineCalibrationSPDhandler::SetSparseDeadPixel", "eq,hs,chip nrs (%d,%d,%d) out of bounds.",eq,hs,chip); + return kFALSE; + } + if (col>=32 && row>=256) { + Error("AliITSOnlineCalibrationSPDhandler::SetSparseDeadPixel", "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 (fSparseDeadPixelMap[gloChip]->Find(key) != NULL) return kFALSE; + if (fSparseDeadPixelMap[gloChip]->Insert(key,gloChip)) { + fNrSparseDead[gloChip]++; + //printf(" AliITSOnlineCalibrationSPDhandler::SetSparseDeadPixel nSparse Dead : %i \n",fNrSparseDead[gloChip]); + return kTRUE; + } + return kFALSE; +} +//____________________________________________________________________________________________ +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 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::SetSparseDeadPixelM(UInt_t module, UInt_t colM, UInt_t rowM) { + // set a dead pixel, returns false if pixel is already 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 SetSparseDeadPixel(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(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::UnSetSparseDeadPixel(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::UnSetSparseDeadPixel", "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 (fSparseDeadPixelMap[gloChip]->Remove(key)) { + fNrSparseDead[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::UnSetSparseDeadPixelM(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 UnSetSparseDeadPixel(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, %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 eq = GetEqIdFromKey(key); + UInt_t hs = GetHSFromKey(key); + UInt_t chip = GetChipFromKey(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::GetNrSparseDead(UInt_t module) const { + // returns the number of sparse dead pixels for a certain module + if (module>=240) { + Error("AliITSOnlineCalibrationSPDhandler::GetNrSparseDead", "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+=fNrSparseDead[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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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]; + } + } + + } + else { + 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]; + } + } + + } + 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]; + } + } + + } + 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]; + } + } + + } + else { + Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexTotNoisy", "Index %d out of bounds.", index); + } +} +//____________________________________________________________________________________________ +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; + } + 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::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; + } + 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::GetNrSparseDeadC2(UInt_t gloChip) const { + // returns nr of dead pixels on this chip + if (gloChip>=1200) { + Error("AliITSOnlineCalibrationSPDhandler::GetNrSparseDeadC2", "global chip nr (%d) out of bounds.",gloChip); + return 0; + } + return fNrSparseDead[gloChip]; +} +//____________________________________________________________________________________________ +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::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::GetDeadEqIdAtC", "Index %d out of bounds.", index); + return 0; + } +} +//____________________________________________________________________________________________ +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::GetNoisyEqIdAtC", "Index %d out of bounds.", index); + return 0; + } +} +//____________________________________________________________________________________________ +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; + } + if (indexGetKeyIndex(index); + return GetHSFromKey(key); + } + else { + Error("AliITSOnlineCalibrationSPDhandler::GetDeadHSAtC", "Index %d out of bounds.", index); + return 0; + } +} +//____________________________________________________________________________________________ +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; + } + if (indexGetKeyIndex(index); + return GetHSFromKey(key); + } + else { + Error("AliITSOnlineCalibrationSPDhandler::GetNoisyHSAtC", "Index %d out of bounds.", index); + return 0; + } +} +//____________________________________________________________________________________________ +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; + } + if (indexGetKeyIndex(index); + return GetChipFromKey(key); + } + else { + Error("AliITSOnlineCalibrationSPDhandler::GetDeadChipAtC", "Index %d out of bounds.", index); + return 0; + } +} +//____________________________________________________________________________________________ +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 (gloChip>=1200) { + Error("AliITSOnlineCalibrationSPDhandler::GetNoisyChipAtC", "global chip nr (%d) out of bounds.",gloChip); + return 20; + } + if (indexGetKeyIndex(index); + return GetChipFromKey(key); + } + else { + Error("AliITSOnlineCalibrationSPDhandler::GetNoisyChipAtC", "Index %d out of bounds.", index); + return 0; + } +} +//____________________________________________________________________________________________ +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::GetDeadColAtC2", "Index %d out of bounds.", index); + return 0; + } +} +//____________________________________________________________________________________________ +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::GetNoisyColAtC", "Index %d out of bounds.", index); + return 0; + } +} +//____________________________________________________________________________________________ +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 { + Error("AliITSOnlineCalibrationSPDhandler::GetDeadRowAtC", "Index %d out of bounds.", index); + return 0; + } +} +//____________________________________________________________________________________________ +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 (gloChip>=1200) { + Error("AliITSOnlineCalibrationSPDhandler::GetNoisyRowAtC", "global chip nr (%d) out of bounds.",gloChip); + return 20; + } + if (indexGetKeyIndex(index); + return GetRowFromKey(key); + } + else { + Error("AliITSOnlineCalibrationSPDhandler::GetNoisyRowAtC", "Index %d out of bounds.", index); + return 0; + } +} +//____________________________________________________________________________________________ +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::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; +} +//____________________________________________________________________________________________ +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; + } + fActiveHS[eq][hs] = setval; +} +//____________________________________________________________________________________________ +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; + } + fActiveChip[eq][hs][chip] = setval; +} +//____________________________________________________________________________________________ +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]; +} +//____________________________________________________________________________________________ +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 fActiveHS[eq][hs]; +} +//____________________________________________________________________________________________ +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); + } + } + } +} +//____________________________________________________________________________________________ +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; + } + fDeadEq[eq] = setval; +} +//____________________________________________________________________________________________ +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::SetDeadChip(UInt_t eq, UInt_t hs, UInt_t chip, Bool_t setval) { + // set chip dead + if (eq>=20 || hs>=6 || chip>=10) { + Error("AliITSOnlineCalibrationSPDhandler::SetDeadChip", "eq,hs,chip (%d,%d,%d) out of bounds.",eq,hs,chip); + return; + } + fDeadChip[eq][hs][chip] = setval; +} +//____________________________________________________________________________________________ +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]; +} +//____________________________________________________________________________________________ +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]; +} +//____________________________________________________________________________________________ +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]; +} +//____________________________________________________________________________________________ +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; iIsDefaultStorageSet()) { + man->SetDefaultStorage("local://$ALICE_ROOT/OCDB"); + } + } + else { + storageSTR = Form("%s",storage); + man->SetDefaultStorage(storageSTR.Data()); + } + AliCDBMetaData* metaData = new AliCDBMetaData(); + metaData->SetResponsible("Annalisa Mastroserio"); + metaData->SetComment("Created by AliITSOnlineCalibrationSPDhandler."); + AliCDBId idCalSPD("TRIGGER/SPD/PITConditions",runNrStart,runNrEnd); + AliCDBEntry* cdbEntry = new AliCDBEntry((TObject*)fTriggerConditions,idCalSPD,metaData); + man->Put(cdbEntry); + delete cdbEntry; + delete metaData; + return kTRUE; +} + +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::SetInactiveChipInPITmask(UInt_t eq, UInt_t hs, UInt_t chip){ + // + fTriggerConditions->SetInActiveChip(eq,hs,chip); + return kTRUE; +} +//____________________________________________________________________________________________ +Bool_t AliITSOnlineCalibrationSPDhandler::UnSetInactiveChipInPITmask(UInt_t eq, UInt_t hs, UInt_t chip){ + // + fTriggerConditions->SetInActiveChip(eq,hs,chip); + return kTRUE; +} +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::PrintDiffInDead(AliITSOnlineCalibrationSPDhandler *other) const { + // + // Printout of the differences between two ocdb files for SPD Dead channel map + // + UInt_t nrChipOk=0; + UInt_t nrDeadChipOk=0; + UInt_t nrDeadHsOk=0; + UInt_t nrDeadHs =0; + UInt_t nrDeadChip=0; + UInt_t nrDeadHsInOther =0; + UInt_t nrDeadChipInOther=0; + UInt_t nrMismatch =0; + UInt_t nrMismatchInOther =0; + printf("\n\n ****** loop over chips ***** \n"); + for(Int_t eq=0; eq<20; eq++){ + if(TMath::Abs((Int_t)GetNrBadEq(eq) - (Int_t)other->GetNrBadEq(eq)) >0) printf("-----> dead pixels differ in eq %i! %i - %i in the other \n",eq,GetNrBadEq(eq),other->GetNrBadEq(eq)); + for(Int_t hs=0; hs<6; hs++){ + Short_t nchips =0; + Short_t nchipsOther =0; + Short_t nok=0; + for(Int_t chip=0; chip<10; chip++){ + UInt_t chipkey = AliITSRawStreamSPD::GetOfflineChipKeyFromOnline(eq,hs,chip); + // test if everything is coherent + if(IsDeadChip(eq,hs,chip) && other->IsDeadChip(eq,hs,chip)) { + nok++; + nrChipOk++; + nrDeadChipOk++; + } + if(!IsDeadChip(eq,hs,chip) && !other->IsDeadChip(eq,hs,chip)) nrChipOk++; + // now testing if mismatches + if(IsDeadChip(eq,hs,chip)) { + nrDeadChip++; + nchips++; + if(!other->IsDeadChip(eq,hs,chip)) { + nrMismatch++; + printf(" mismatch -> eq %i hs %i chip %i is DEAD - ALIVE in the other (chipkey %i)\n",eq,hs,chip,chipkey); + } + } + if(other->IsDeadChip(eq,hs,chip)){ + nrDeadChipInOther++; + nchipsOther++; + if(!IsDeadChip(eq,hs,chip)) { + nrMismatchInOther++; + printf(" mismatch -> eq %i hs %i chip %i is ALIVE - DEAD in the other (chipkey %i)\n",eq,hs,chip,chipkey); + } + } + } + if(nok==10) nrDeadHsOk++; + if(nchips==10) nrDeadHs++; + if(nchipsOther==10) nrDeadHsInOther++; + } + } + +printf("\n\n\n*************SUMMARY****************\n"); +printf(" BOTH have : %i Dead HS and %i Dead chips with %i coherent chips \n",nrDeadHsOk,nrDeadChipOk,nrChipOk); +printf("\n_________MISMATCH RESULTS___________\n"); +printf(" THIS : Nr Dead HS %i - Nr Dead Chip %i \n",nrDeadHs,nrDeadChip); +printf(" OTHER : Nr Dead HS %i - Nr Dead Chip %i \n",nrDeadHsInOther,nrDeadChipInOther); +printf(" N Mismatches in Dead chips (=ALIVE in the other) %i \n",nrMismatch); +printf(" N Mismatches in Alive chips (=DEAD in the other) %i \n",nrMismatchInOther); +} +//____________________________________________________________________________________________ +void AliITSOnlineCalibrationSPDhandler::PrintDiffInPITmask(AliITSOnlineCalibrationSPDhandler *other) const { + // + // Printout of the differences between two ocdb files for SPD Dead channel map + // + +Int_t nOk =0; +Int_t nMismatch =0; +Int_t nMismatchInOther =0; + +printf("\n\n ****** loop over chips in PIT mask***** \n"); +for(Int_t eq=0; eq<20; eq++){ + for(Int_t hs=0; hs<6; hs++){ + for(Int_t chip=0; chip<10; chip++){ + + UInt_t chipkey = AliITSRawStreamSPD::GetOfflineChipKeyFromOnline(eq,hs,chip); + + if(fTriggerConditions->IsChipActive(eq,hs,chip) && (other->GetTriggerConditions())->IsChipActive(eq,hs,chip)) nOk++; + if(fTriggerConditions->IsChipActive(eq,hs,chip) && !(other->GetTriggerConditions())->IsChipActive(eq,hs,chip)) { + nMismatch++; + printf("Mismatch -> eq %i hs %i chip %i is ACTIVE - INACTIVE in the other (chipkey %i) \n",eq,hs,chip,chipkey); + } + if(!fTriggerConditions->IsChipActive(eq,hs,chip) && (other->GetTriggerConditions())->IsChipActive(eq,hs,chip)) { + nMismatchInOther++; + printf("Mismatch -> eq %i hs %i chip %i is INACTIVE - ACTIVE in the other (chipkey %i) \n",eq,hs,chip,chipkey); + } + if(!fTriggerConditions->IsChipActive(eq,hs,chip) && !(other->GetTriggerConditions())->IsChipActive(eq,hs,chip)) nOk++; + } + } +} + +printf("n Chips OK %i : ACTIVE mismatch %i - INACTIVE mismatch in %i \n",nOk,nMismatch,nMismatchInOther); + +} +