[u/mrichter/AliRoot.git] / ITS / AliITSOnlineCalibrationSPDhandler.cxx

//////////////////////////////////////////////////////////////////////
// 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     //
// objects can be obtained from the methods GetDeadArray and        //
// GetNoisyArray.                                                   //
//////////////////////////////////////////////////////////////////////   

#include "AliITSOnlineCalibrationSPDhandler.h"
#include "AliITSOnlineCalibrationSPD.h"
#include <TArrayI.h>
#include <TFile.h>

AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler():
  fModuleNr(0),
  fDeadPixelMap(AliITSIntMap()),
  fNoisyPixelMap(AliITSIntMap())
{}

AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler(UInt_t module):
  fModuleNr(module),
  fDeadPixelMap(AliITSIntMap()),
  fNoisyPixelMap(AliITSIntMap())
{}

AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler(const AliITSOnlineCalibrationSPDhandler& handle): 
  fModuleNr(handle.fModuleNr),
  fDeadPixelMap(AliITSIntMap()),
  fNoisyPixelMap(AliITSIntMap())
{
  // copy constructor
  UInt_t nrDead = handle.GetNrDead();
  for (UInt_t index=0; index<nrDead; index++) {
    this->SetDeadPixel(handle.GetDeadColAt(index),handle.GetDeadRowAt(index));
  }
  UInt_t nrNoisy = handle.GetNrNoisy();
  for (UInt_t index=0; index<nrNoisy; index++) {
    this->SetNoisyPixel(handle.GetNoisyColAt(index),handle.GetNoisyRowAt(index));
  }
  sprintf(fFileLocation,"%s",handle.fFileLocation);
}

AliITSOnlineCalibrationSPDhandler::~AliITSOnlineCalibrationSPDhandler() {
  ClearMaps();
}

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; index<nrDead; index++) {
      this->SetDeadPixel(handle.GetDeadColAt(index),handle.GetDeadRowAt(index));
    }
    UInt_t nrNoisy = handle.GetNrNoisy();
    for (UInt_t index=0; index<nrNoisy; index++) {
      this->SetNoisyPixel(handle.GetNoisyColAt(index),handle.GetNoisyRowAt(index));
    }
    sprintf(fFileLocation,"%s",handle.fFileLocation);
  }
  return *this;
}

void AliITSOnlineCalibrationSPDhandler::ClearMaps() {
  // clear the lists of dead and noisy
  ResetDead();
  ResetNoisy();
}

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::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::ReadFromFile() {
  // read dead and noisy from default file
  Char_t fileName[200];
  sprintf(fileName,"%s/SPD_DeadNoisy_%d.root",fFileLocation,fModuleNr);
  return ReadFromFile(fileName);
}
Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFile() {
  // read dead from default file
  Char_t fileName[200];
  sprintf(fileName,"%s/SPD_DeadNoisy_%d.root",fFileLocation,fModuleNr);
  return ReadDeadFromFile(fileName);
}
Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFile() {
  // read noisy from default file
  Char_t fileName[200];
  sprintf(fileName,"%s/SPD_DeadNoisy_%d.root",fFileLocation,fModuleNr);
  return ReadNoisyFromFile(fileName);
}

Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromFile(Char_t* fileName) {
  // read dead and noisy from file fileName (clear the previous list of dead and noisy pixels)
  ClearMaps();
  AliITSOnlineCalibrationSPD* calib;
  FILE* fp0 = fopen(fileName, "r");
  if (fp0 == NULL) {return kFALSE;}
  else {
    fclose(fp0);
    TFile file(fileName, "READ");
    if (file.IsOpen()) {
      file.GetObject("AliITSOnlineCalibrationSPD", calib);
      file.Close();
      if (calib!=NULL) {
	SetModuleNr(calib->GetModuleNr());
	Int_t nrDead=calib->GetNrDead();
	for (Int_t index=0; index<nrDead; index++) {
	  Int_t col=calib->GetDeadColAt(index);
	  Int_t row=calib->GetDeadRowAt(index);
	  SetDeadPixel(col,row);
	}
	Int_t nrNoisy=calib->GetNrNoisy();
	for (Int_t index=0; index<nrNoisy; index++) {
	  Int_t col=calib->GetNoisyColAt(index);
	  Int_t row=calib->GetNoisyRowAt(index);
	  SetNoisyPixel(col,row);
	}
      }
    }
  }
  return kTRUE;
}
Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFile(Char_t* fileName) {
  // read dead from file fileName (clear the previous list of dead pixels)
  ResetDead();
  AliITSOnlineCalibrationSPD* calib;
  FILE* fp0 = fopen(fileName, "r");
  if (fp0 == NULL) {return kFALSE;}
  else {
    fclose(fp0);
    TFile file(fileName, "READ");
    if (file.IsOpen()) {
      file.GetObject("AliITSOnlineCalibrationSPD", calib);
      file.Close();
      if (calib!=NULL) {
	SetModuleNr(calib->GetModuleNr());
	Int_t nrDead=calib->GetNrDead();
	for (Int_t index=0; index<nrDead; index++) {
	  Int_t col=calib->GetDeadColAt(index);
	  Int_t row=calib->GetDeadRowAt(index);
	  SetDeadPixel(col,row);
	}
      }
    }
  }
  return kTRUE;
}
Bool_t 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) {return kFALSE;}
  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; index<nrNoisy; index++) {
	  Int_t col=calib->GetNoisyColAt(index);
	  Int_t row=calib->GetNoisyRowAt(index);
	  SetNoisyPixel(col,row);
	}
      }
    }
  }
  return kTRUE;
}

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<fDeadPixelMap.GetNrEntries(); index++) {
    Int_t key = fDeadPixelMap.GetKey(index);
    Int_t col = GetColFromKey(key);
    Int_t row = GetRowFromKey(key);
    returnArray.AddAt(col,index*2);
    returnArray.AddAt(row,index*2+1);
  }
  return returnArray;
}

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; index<fNoisyPixelMap.GetNrEntries(); index++) {
    Int_t key = fNoisyPixelMap.GetKey(index);
    Int_t col = GetColFromKey(key);
    Int_t row = GetRowFromKey(key);
    returnArray.AddAt(col,index*2);
    returnArray.AddAt(row,index*2+1);
  }
  return returnArray;
}

void AliITSOnlineCalibrationSPDhandler::ResetDead() {
  fDeadPixelMap.Clear();
}


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);
}

Int_t AliITSOnlineCalibrationSPDhandler::GetDeadColAt(UInt_t index) const {
  // get column for the dead pixel at position index in list of dead
  if (index<fDeadPixelMap.GetNrEntries()) {
    Int_t key = fDeadPixelMap.GetKey(index);
    return GetColFromKey(key);
  }
  else return 0;
}

Int_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAt(UInt_t index) const {
  // get row for the dead pixel at position index in list of dead
  if (index<fDeadPixelMap.GetNrEntries()) {
    Int_t key = fDeadPixelMap.GetKey(index);
    return GetRowFromKey(key);
  }
  else return 0;
}

Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDead(Int_t col, Int_t row) const {
  // is the pixel dead?
  Int_t key = GetKey(col,row);
  if ( fDeadPixelMap.Find(key) != NULL) {
    return kTRUE;
  }
  else {
    return kFALSE;
  }
}

void AliITSOnlineCalibrationSPDhandler::ResetNoisy() {
  // clear the list of noisy pixels
  fNoisyPixelMap.Clear();
}

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);
}

Int_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAt(UInt_t index) const {
  // get column for the noisy pixel at position index in list of noisy
  if (index<fNoisyPixelMap.GetNrEntries()) {
    Int_t key = fNoisyPixelMap.GetKey(index);
    return GetColFromKey(key);
  }
  else return 0;
}

Int_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAt(UInt_t index) const {
  // get row for the noisy pixel at position index in list of noisy
  if (index<fNoisyPixelMap.GetNrEntries()) {
    Int_t key = fNoisyPixelMap.GetKey(index);
    return GetRowFromKey(key);
  }
  else return 0;
}

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 {
    return kFALSE;
  }
}

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; index<fDeadPixelMap.GetNrEntries(); index++) {
    Int_t key = fDeadPixelMap.GetKey(index);
    Int_t col = GetColFromKey(key);
    Int_t row = GetRowFromKey(key);
    printf("%d,%d\n",col,row);
  }
}

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; index<fNoisyPixelMap.GetNrEntries(); index++) {
    Int_t key = fNoisyPixelMap.GetKey(index);
    Int_t col = GetColFromKey(key);
    Int_t row = GetRowFromKey(key);
    printf("%d,%d\n",col,row);
  }
}
Commit	Line	Data
b15de2d2	1	//////////////////////////////////////////////////////////////////////
	2	// Author: Henrik Tydesjo //
	3	// For easier handling of dead and noisy pixels they are kept in //
	4	// container maps (AliITSIntMap). //
	5	// The TArrayI objects that are put in the AliITSCalibrationSPD //
	6	// objects can be obtained from the methods GetDeadArray and //
	7	// GetNoisyArray. //
	8	//////////////////////////////////////////////////////////////////////
	9
	10	#include "AliITSOnlineCalibrationSPDhandler.h"
	11	#include "AliITSOnlineCalibrationSPD.h"
	12	#include <TArrayI.h>
	13	#include <TFile.h>
	14
	15	AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler():
	16	fModuleNr(0),
	17	fDeadPixelMap(AliITSIntMap()),
	18	fNoisyPixelMap(AliITSIntMap())
	19	{}
	20
	21	AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler(UInt_t module):
	22	fModuleNr(module),
	23	fDeadPixelMap(AliITSIntMap()),
	24	fNoisyPixelMap(AliITSIntMap())
	25	{}
	26
	27	AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler(const AliITSOnlineCalibrationSPDhandler& handle):
	28	fModuleNr(handle.fModuleNr),
	29	fDeadPixelMap(AliITSIntMap()),
	30	fNoisyPixelMap(AliITSIntMap())
	31	{
	32	// copy constructor
	33	UInt_t nrDead = handle.GetNrDead();
	34	for (UInt_t index=0; index<nrDead; index++) {
	35	this->SetDeadPixel(handle.GetDeadColAt(index),handle.GetDeadRowAt(index));
	36	}
	37	UInt_t nrNoisy = handle.GetNrNoisy();
	38	for (UInt_t index=0; index<nrNoisy; index++) {
	39	this->SetNoisyPixel(handle.GetNoisyColAt(index),handle.GetNoisyRowAt(index));
	40	}
	41	sprintf(fFileLocation,"%s",handle.fFileLocation);
	42	}
	43
	44	AliITSOnlineCalibrationSPDhandler::~AliITSOnlineCalibrationSPDhandler() {
	45	ClearMaps();
	46	}
	47
	48	AliITSOnlineCalibrationSPDhandler& AliITSOnlineCalibrationSPDhandler::operator=(const AliITSOnlineCalibrationSPDhandler& handle) {
	49	// assignment operator
	50	if (this!=&handle) {
	51	this->ClearMaps();
	52	fModuleNr = handle.fModuleNr;
	53	UInt_t nrDead = handle.GetNrDead();
	54	for (UInt_t index=0; index<nrDead; index++) {
	55	this->SetDeadPixel(handle.GetDeadColAt(index),handle.GetDeadRowAt(index));
	56	}
	57	UInt_t nrNoisy = handle.GetNrNoisy();
	58	for (UInt_t index=0; index<nrNoisy; index++) {
	59	this->SetNoisyPixel(handle.GetNoisyColAt(index),handle.GetNoisyRowAt(index));
	60	}
	61	sprintf(fFileLocation,"%s",handle.fFileLocation);
	62	}
	63	return *this;
	64	}
65
66	void AliITSOnlineCalibrationSPDhandler::ClearMaps() {
67	// clear the lists of dead and noisy
68	ResetDead();
69	ResetNoisy();
70	}
71
72	void AliITSOnlineCalibrationSPDhandler::WriteToFile() {
73	// write the lists of dead and noisy to default file
74	Char_t fileName[200];
75	sprintf(fileName,"%s/SPD_DeadNoisy_%d.root",fFileLocation,fModuleNr);
76	WriteToFile(fileName);
77	}
78
79	void AliITSOnlineCalibrationSPDhandler::WriteToFile(Char_t* fileName) {
80	// write the lists of dead and noisy to file fileName
81	AliITSOnlineCalibrationSPD* calib = new AliITSOnlineCalibrationSPD();
82	calib->SetModuleNr(GetModuleNr());
83	calib->SetDeadList(GetDeadArray());
84	calib->SetNoisyList(GetNoisyArray());
85	calib->SetNrDead(GetNrDead());
86	calib->SetNrNoisy(GetNrNoisy());
87
88	TFile file(fileName, "RECREATE");
89	file.WriteTObject(calib, "AliITSOnlineCalibrationSPD");
90	file.Close();
91
92	delete calib;
93	}
94
03fc6773	95	Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromFile() {
b15de2d2	96	// read dead and noisy from default file
	97	Char_t fileName[200];
	98	sprintf(fileName,"%s/SPD_DeadNoisy_%d.root",fFileLocation,fModuleNr);
03fc6773	99	return ReadFromFile(fileName);
b15de2d2	100	}
03fc6773	101	Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFile() {
b15de2d2	102	// read dead from default file
	103	Char_t fileName[200];
	104	sprintf(fileName,"%s/SPD_DeadNoisy_%d.root",fFileLocation,fModuleNr);
03fc6773	105	return ReadDeadFromFile(fileName);
b15de2d2	106	}
03fc6773	107	Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFile() {
b15de2d2	108	// read noisy from default file
	109	Char_t fileName[200];
	110	sprintf(fileName,"%s/SPD_DeadNoisy_%d.root",fFileLocation,fModuleNr);
03fc6773	111	return ReadNoisyFromFile(fileName);
b15de2d2	112	}
b15de2d2	113
03fc6773	114	Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromFile(Char_t* fileName) {
b15de2d2	115	// read dead and noisy from file fileName (clear the previous list of dead and noisy pixels)
	116	ClearMaps();
	117	AliITSOnlineCalibrationSPD* calib;
	118	FILE* fp0 = fopen(fileName, "r");
03fc6773	119	if (fp0 == NULL) {return kFALSE;}
b15de2d2	120	else {
	121	fclose(fp0);
	122	TFile file(fileName, "READ");
	123	if (file.IsOpen()) {
	124	file.GetObject("AliITSOnlineCalibrationSPD", calib);
	125	file.Close();
	126	if (calib!=NULL) {
	127	SetModuleNr(calib->GetModuleNr());
	128	Int_t nrDead=calib->GetNrDead();
	129	for (Int_t index=0; index<nrDead; index++) {
	130	Int_t col=calib->GetDeadColAt(index);
	131	Int_t row=calib->GetDeadRowAt(index);
	132	SetDeadPixel(col,row);
	133	}
	134	Int_t nrNoisy=calib->GetNrNoisy();
	135	for (Int_t index=0; index<nrNoisy; index++) {
	136	Int_t col=calib->GetNoisyColAt(index);
	137	Int_t row=calib->GetNoisyRowAt(index);
	138	SetNoisyPixel(col,row);
	139	}
	140	}
	141	}
	142	}
03fc6773	143	return kTRUE;
b15de2d2	144	}
03fc6773	145	Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFile(Char_t* fileName) {
b15de2d2	146	// read dead from file fileName (clear the previous list of dead pixels)
	147	ResetDead();
	148	AliITSOnlineCalibrationSPD* calib;
	149	FILE* fp0 = fopen(fileName, "r");
03fc6773	150	if (fp0 == NULL) {return kFALSE;}
b15de2d2	151	else {
	152	fclose(fp0);
	153	TFile file(fileName, "READ");
	154	if (file.IsOpen()) {
	155	file.GetObject("AliITSOnlineCalibrationSPD", calib);
	156	file.Close();
	157	if (calib!=NULL) {
	158	SetModuleNr(calib->GetModuleNr());
	159	Int_t nrDead=calib->GetNrDead();
	160	for (Int_t index=0; index<nrDead; index++) {
	161	Int_t col=calib->GetDeadColAt(index);
	162	Int_t row=calib->GetDeadRowAt(index);
	163	SetDeadPixel(col,row);
	164	}
	165	}
	166	}
	167	}
03fc6773	168	return kTRUE;
b15de2d2	169	}
03fc6773	170	Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFile(Char_t* fileName) {
b15de2d2	171	// read noisy from file fileName (clear the previous list of noisy pixels)
	172	ResetNoisy();
	173	AliITSOnlineCalibrationSPD* calib;
	174	FILE* fp0 = fopen(fileName, "r");
03fc6773	175	if (fp0 == NULL) {return kFALSE;}
b15de2d2	176	else {
	177	fclose(fp0);
	178	TFile file(fileName, "READ");
	179	if (file.IsOpen()) {
	180	file.GetObject("AliITSOnlineCalibrationSPD", calib);
	181	file.Close();
	182	if (calib!=NULL) {
	183	SetModuleNr(calib->GetModuleNr());
	184	Int_t nrNoisy=calib->GetNrNoisy();
	185	for (Int_t index=0; index<nrNoisy; index++) {
	186	Int_t col=calib->GetNoisyColAt(index);
	187	Int_t row=calib->GetNoisyRowAt(index);
	188	SetNoisyPixel(col,row);
	189	}
	190	}
	191	}
	192	}
03fc6773	193	return kTRUE;
b15de2d2	194	}
	195
	196	TArrayI AliITSOnlineCalibrationSPDhandler::GetDeadArray() {
	197	// get a TArrayI of the dead pixels (format for the AliITSCalibrationSPD object)
	198	TArrayI returnArray;
	199	returnArray.Set(GetNrDead()*2);
	200	for (UInt_t index=0; index<fDeadPixelMap.GetNrEntries(); index++) {
	201	Int_t key = fDeadPixelMap.GetKey(index);
	202	Int_t col = GetColFromKey(key);
	203	Int_t row = GetRowFromKey(key);
	204	returnArray.AddAt(col,index*2);
	205	returnArray.AddAt(row,index*2+1);
	206	}
	207	return returnArray;
	208	}
	209
	210	TArrayI AliITSOnlineCalibrationSPDhandler::GetNoisyArray() {
	211	// get a TArrayI of the noisy pixels (format for the AliITSCalibrationSPD object)
	212	TArrayI returnArray;
	213	returnArray.Set(GetNrNoisy()*2);
	214	for (UInt_t index=0; index<fNoisyPixelMap.GetNrEntries(); index++) {
	215	Int_t key = fNoisyPixelMap.GetKey(index);
	216	Int_t col = GetColFromKey(key);
	217	Int_t row = GetRowFromKey(key);
	218	returnArray.AddAt(col,index*2);
	219	returnArray.AddAt(row,index*2+1);
	220	}
	221	return returnArray;
	222	}
	223
	224	void AliITSOnlineCalibrationSPDhandler::ResetDead() {
	225	fDeadPixelMap.Clear();
	226	}
	227
	228
	229	Bool_t AliITSOnlineCalibrationSPDhandler::SetDeadPixel(Int_t col, Int_t row) {
	230	// set a dead pixel, returns false if pixel is already dead or noisy
	231	Int_t key = GetKey(col,row);
	232	// if noisy we dont want to add it...
	233	if (fNoisyPixelMap.Find(key) != NULL) return kFALSE;
	234	return fDeadPixelMap.Insert(key,col);
	235	}
	236
	237	Int_t AliITSOnlineCalibrationSPDhandler::GetDeadColAt(UInt_t index) const {
	238	// get column for the dead pixel at position index in list of dead
	239	if (index<fDeadPixelMap.GetNrEntries()) {
	240	Int_t key = fDeadPixelMap.GetKey(index);
	241	return GetColFromKey(key);
	242	}
	243	else return 0;
	244	}
	245
	246	Int_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAt(UInt_t index) const {
	247	// get row for the dead pixel at position index in list of dead
	248	if (index<fDeadPixelMap.GetNrEntries()) {
	249	Int_t key = fDeadPixelMap.GetKey(index);
	250	return GetRowFromKey(key);
	251	}
	252	else return 0;
	253	}
	254
	255	Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDead(Int_t col, Int_t row) const {
	256	// is the pixel dead?
	257	Int_t key = GetKey(col,row);
258	if ( fDeadPixelMap.Find(key) != NULL) {
259	return kTRUE;
260	}
261	else {
262	return kFALSE;
263	}
264	}
265
266	void AliITSOnlineCalibrationSPDhandler::ResetNoisy() {
267	// clear the list of noisy pixels
268	fNoisyPixelMap.Clear();
269	}
270
271	Bool_t AliITSOnlineCalibrationSPDhandler::SetNoisyPixel(Int_t col, Int_t row) {
272	// set a noisy pixel, returns false if already there
273	Int_t key = GetKey(col,row);
274	// if dead before - remove from the dead list
275	fDeadPixelMap.Remove(key);
276	return fNoisyPixelMap.Insert(key,col);
277	}
278
279	Int_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAt(UInt_t index) const {
280	// get column for the noisy pixel at position index in list of noisy
281	if (index<fNoisyPixelMap.GetNrEntries()) {
282	Int_t key = fNoisyPixelMap.GetKey(index);
283	return GetColFromKey(key);
284	}
285	else return 0;
286	}
287
288	Int_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAt(UInt_t index) const {
289	// get row for the noisy pixel at position index in list of noisy
290	if (index<fNoisyPixelMap.GetNrEntries()) {
291	Int_t key = fNoisyPixelMap.GetKey(index);
292	return GetRowFromKey(key);
293	}
294	else return 0;
295	}
296
297	Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisy(Int_t col, Int_t row) const {
298	// is this pixel noisy?
299	Int_t key = GetKey(col,row);
300	if ( fNoisyPixelMap.Find(key) != NULL ) {
301	return kTRUE;
302	}
303	else {
304	return kFALSE;
305	}
306	}
307
308	void AliITSOnlineCalibrationSPDhandler::PrintDead() const {
309	// print the dead pixels to screen
310	printf("-----------------------\n");
311	printf("Dead Pixels Module %d:\n",fModuleNr);
312	printf("-----------------------\n");
313	for (UInt_t index=0; index<fDeadPixelMap.GetNrEntries(); index++) {
314	Int_t key = fDeadPixelMap.GetKey(index);
315	Int_t col = GetColFromKey(key);
316	Int_t row = GetRowFromKey(key);
317	printf("%d,%d\n",col,row);
318	}
319	}
320
321	void AliITSOnlineCalibrationSPDhandler::PrintNoisy() const {
322	// print the noisy pixels to screen
323	printf("-----------------------\n");
324	printf("Noisy Pixels Module %d:\n",fModuleNr);
325	printf("-----------------------\n");
326	for (UInt_t index=0; index<fNoisyPixelMap.GetNrEntries(); index++) {
327	Int_t key = fNoisyPixelMap.GetKey(index);
328	Int_t col = GetColFromKey(key);
329	Int_t row = GetRowFromKey(key);
330	printf("%d,%d\n",col,row);
331	}
332	}