[u/mrichter/AliRoot.git] / ITS / AliITSStoreDeadSPD.C

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// Example of usage:                                                    //
// 1. Fix the seed                                                      //
// 2. Randomly store 1% dead pixels all over the SPD                    //
// 3. Print the number of dead pixels temporarily generated             //
// 4. Store the dead pixels in calibration objects for runNrs 1 to 10   //
//                                                                      //
// root [0] .L AliITSStoreDeadSPD.C                                     //
// root [1] SetSeed(11)                                                 //
// root [2] RandomizeDeadPixelsFrac(0.01)                               //
// root [3] PrintNrDead()                                               //
// root [4] StoreCalib(1,10)                                            //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

AliITSOnlineCalibrationSPDhandler* handler = NULL;
TRandom* rnd = new TRandom();

void StoreCalib(Int_t RunNrStart=0, Int_t RunNrEnd=9999999) {
  if (handler!=NULL) {
    handler->WriteToDB(RunNrStart,RunNrEnd);
  }
}

void ReadCalib(UInt_t runNr) {
  if (handler==NULL) handler = new AliITSOnlineCalibrationSPDhandler();
  else ClearDead();
  handler->ReadFromDB(runNr);
}

void SetSeed(UInt_t seed) {
  rnd->SetSeed(seed);
}

void PrintNrDead() {
  if (handler!=NULL) {
    printf("Nr of dead pixels: %d\n",handler->GetNrDead());
  }
}

void PrintDead() {
  if (handler!=NULL) {
    handler->PrintDead();
  }
}

void ClearDead() {
  if (handler!=NULL) {
    handler->ResetDead();
  }
}

void RandomizeDeadPixelsFrac(Double_t fraction) {
  if (fraction>0 && fraction<=1) {
    UInt_t nrdeadpixels = static_cast<UInt_t>(fraction*256*160*240 + 0.5);
    RandomizeDeadPixels(nrdeadpixels);
  }
}
void RandomizeDeadPixels(UInt_t nrDead) {
  if (handler==NULL) handler = new AliITSOnlineCalibrationSPDhandler();
  UInt_t nrDeadInserted = 0;
  while (nrDeadInserted<nrDead) {
    UInt_t mod = (UInt_t)(rnd->Rndm()*240);
    UInt_t col = (UInt_t)(rnd->Rndm()*160);
    UInt_t row = (UInt_t)(rnd->Rndm()*256);
    if (handler->SetDeadPixelM(mod,col,row)) nrDeadInserted++;
  }
}

void RandomizeDeadPixelsFrac(Double_t fraction, UInt_t layer) {
  if (fraction>0 && fraction<=1) {
    UInt_t nr_pixels;
    UInt_t nrdeadpixels;
    switch(layer) {
    case 0: 
      nr_pixels = 256*160*80;
      nrdeadpixels = static_cast<UInt_t>(fraction*nr_pixels + 0.5);
      RandomizeDeadPixels(nrdeadpixels,layer);
      break;
    case 1:
      nr_pixels = 256*160*160;
      nrdeadpixels = static_cast<Int_t>(fraction*nr_pixels + 0.5);
      RandomizeDeadPixels(nrdeadpixels,layer);
      break;
    default:
      return;
    }
  }
}
void RandomizeDeadPixels(UInt_t nrDead, UInt_t layer) {
  if (handler==NULL) handler = new AliITSOnlineCalibrationSPDhandler();
  UInt_t nr_modules;
  UInt_t mod_offset;
  switch(layer) {
  case 0: 
    nr_modules=80;
    mod_offset=0;
    break;
  case 1:
    nr_modules=160;
    mod_offset=80;
    break;
  default:
    return;
  }
  UInt_t nrDeadInserted = 0;
  while (nrDeadInserted<nrDead) {
    UInt_t mod = (UInt_t)(rnd->Rndm()*nr_modules) + mod_offset;
    UInt_t col = (UInt_t)(rnd->Rndm()*160);
    UInt_t row = (UInt_t)(rnd->Rndm()*256);
    if (handler->SetDeadPixelM(mod,col,row)) nrDeadInserted++;
  }
}

void RandomizeDeadChipsFrac(Double_t fraction) {
  if (fraction>0 && fraction<=1) {
    UInt_t nrdeadchips = static_cast<UInt_t>(fraction*240*5 + 0.5);
    RandomizeDeadChips(nrdeadchips);
  }
}
void RandomizeDeadChips(UInt_t nrDeadChips) {
  if (handler==NULL) handler = new AliITSOnlineCalibrationSPDhandler();
  UInt_t nrDeadChipsInserted = 0;
  AliITSIntMap* chipMap = new AliITSIntMap();
  while (nrDeadChipsInserted<nrDeadChips) {
    UInt_t eq = (UInt_t)(rnd->Rndm()*20);
    UInt_t hs = (UInt_t)(rnd->Rndm()*6);
    UInt_t chip = (UInt_t)(rnd->Rndm()*10);
    if (!chipMap->Find(20*6*chip + 20*hs + eq)) {
      for (UInt_t col=0; col<32; col++) {
	for (UInt_t row=0; row<256; row++) {
	  handler->SetDeadPixel(eq,hs,chip,col,row); 
	}
      }
      chipMap->Insert(20*6*chip + 20*hs + eq, chip);
      nrDeadChipsInserted++;
    }
  }
  delete chipMap;
}

void RandomizeDeadChipsFrac(Double_t fraction, UInt_t layer) {
  if (fraction>0 && fraction<=1) {
    UInt_t nr_chips;
    UInt_t nrdeadchips;
    switch(layer) {
    case 0: 
      nr_chips = 400;
      nrdeadchips = static_cast<UInt_t>(fraction*nr_chips + 0.5);
      RandomizeDeadChips(nrdeadchips,layer);
      break;
    case 1:
      nr_chips = 800;
      nrdeadchips = static_cast<UInt_t>(fraction*nr_chips + 0.5);
      RandomizeDeadChips(nrdeadchips,layer);
      break;
    default:
      return;
    }
  }
}
void RandomizeDeadChips(UInt_t nrDeadChips, UInt_t layer) {
  if (handler==NULL) handler = new AliITSOnlineCalibrationSPDhandler();
  UInt_t hs_nr;
  UInt_t hs_offset;
  switch(layer) {
  case 0: 
    hs_nr=2;
    hs_offset=0;
    break;
  case 1:
    hs_nr=4;
    hs_offset=2;
    break;
  default:
    return;
  }
  UInt_t nrDeadChipsInserted = 0;
  AliITSIntMap* chipMap = new AliITSIntMap();
  while (nrDeadChipsInserted<nrDeadChips) {
    UInt_t eq = (UInt_t)(rnd->Rndm()*20);
    UInt_t hs = (UInt_t)(rnd->Rndm()*hs_nr+hs_offset);
    UInt_t chip = (UInt_t)(rnd->Rndm()*10);
    if (!chipMap->Find(20*6*chip + 20*hs + eq)) {
      for (UInt_t col=0; col<32; col++) {
	for (UInt_t row=0; row<256; row++) {
	  handler->SetDeadPixel(eq,hs,chip,col,row); 
	}
      }
      chipMap->Insert(20*6*chip + 20*hs + eq, chip);
      nrDeadChipsInserted++;
    }
  }
  delete chipMap;
}

void RandomizeDeadHalfStavesFrac(Double_t fraction) {
  if (fraction>0 && fraction<=1) {
    UInt_t nrdeadhstaves = static_cast<UInt_t>(fraction*120 + 0.5);
    RandomizeDeadHalfStaves(nrdeadhstaves);
  }
}
void RandomizeDeadHalfStaves(UInt_t nrDeadHS) {
  if (handler==NULL) handler = new AliITSOnlineCalibrationSPDhandler();
  UInt_t nrDeadHSInserted = 0;
  AliITSIntMap* hsMap = new AliITSIntMap();
  while (nrDeadHSInserted<nrDeadHS) {
    UInt_t eq = (UInt_t)(rnd->Rndm()*20);
    UInt_t hs = (UInt_t)(rnd->Rndm()*6);
    if (!hsMap->Find(20*hs + eq)) {
      for (UInt_t chip=0; chip<10; chip++) {
	for (UInt_t col=0; col<32; col++) {
	  for (UInt_t row=0; row<256; row++) {
	    handler->SetDeadPixel(eq,hs,chip,col,row); 
	  }
	}
      }
      hsMap->Insert(20*hs + eq, hs);
      nrDeadHSInserted++;
    }
  }
  delete hsMap;
}

void RandomizeDeadHalfStavesFrac(Double_t fraction, UInt_t layer) {
  if (fraction>0 && fraction<=1) {
    UInt_t nr_hstaves;
    switch(layer) {
    case 0: 
      nr_hstaves=static_cast<UInt_t>(fraction*40 + 0.5);
      RandomizeDeadHalfStaves(nr_hstaves,layer);
      break;
    case 1:
      nr_hstaves=static_cast<UInt_t>(fraction*80 + 0.5);
      RandomizeDeadHalfStaves(nr_hstaves,layer);
      break;
    default:
      return;
    }
  }
}
void RandomizeDeadHalfStaves(UInt_t nrDeadHS, UInt_t layer) {
  if (handler==NULL) handler = new AliITSOnlineCalibrationSPDhandler();
  UInt_t hs_nr;
  UInt_t hs_offset;
  switch(layer) {
  case 0: 
    hs_nr=2;
    hs_offset=0;
    break;
  case 1:
    hs_nr=4;
    hs_offset=2;
    break;
  default:
    return;
  }
  UInt_t nrDeadHSInserted = 0;
  AliITSIntMap* hsMap = new AliITSIntMap();
  while (nrDeadHSInserted<nrDeadHS) {
    UInt_t eq = (UInt_t)(rnd->Rndm()*20);
    UInt_t hs = (UInt_t)(rnd->Rndm()*hs_nr+hs_offset);
    if (!hsMap->Find(20*hs + eq)) {
      for (UInt_t chip=0; chip<10; chip++) {
	for (UInt_t col=0; col<32; col++) {
	  for (UInt_t row=0; row<256; row++) {
	    handler->SetDeadPixel(eq,hs,chip,col,row); 
	  }
	}
      }
      hsMap->Insert(20*hs + eq, hs);
      nrDeadHSInserted++;
    }
  }
  delete hsMap;
}

void RandomizeDeadColumnChipsFrac(Double_t chipfraction, Double_t columnfraction) {
  if (chipfraction>0 && chipfraction<=1 && columnfraction>0 && columnfraction<=1) {
    if (handler==NULL) handler = new AliITSOnlineCalibrationSPDhandler();
    UInt_t nrColChips = static_cast<UInt_t>(chipfraction*240*5 + 0.5);
    UInt_t nrColChipsUsed = 0;
    AliITSIntMap* colChipMap = new AliITSIntMap();
    while (nrColChipsUsed<nrColChips) {
      UInt_t eq = (UInt_t)(rnd->Rndm()*20);
      UInt_t hs = (UInt_t)(rnd->Rndm()*6);
      UInt_t chip = (UInt_t)(rnd->Rndm()*10);
      if (!colChipMap->Find(20*6*chip + 20*hs + eq)) {
	UInt_t nrCols = static_cast<UInt_t>(columnfraction*32 + 0.5);
	UInt_t nrColsInserted = 0;
	AliITSIntMap* colMap = new AliITSIntMap();
	while (nrColsInserted<nrCols) {
	  UInt_t col = (UInt_t)(rnd->Rndm()*32);
	  if (!colMap->Find(col)) {
	    for (UInt_t row=0; row<256; row++) {
	      handler->SetDeadPixel(eq,hs,chip,col,row);
	    }
	    colMap->Insert(col,col);
	    nrColsInserted++;
	  }
	}
	delete colMap;
	colChipMap->Insert(20*6*chip + 20*hs + eq, chip);
	nrColChipsUsed++;
      }
    }
    delete colChipMap;
  }
}
void RandomizeDeadColumnChipsFrac(Double_t chipfraction, Double_t columnfraction, Int_t layer) {
  if (chipfraction>0 && chipfraction<=1 && columnfraction>0 && columnfraction<=1) {
    if (handler==NULL) handler = new AliITSOnlineCalibrationSPDhandler();
    UInt_t hs_nr;
    UInt_t hs_offset;
    switch(layer) {
    case 0: 
      hs_nr=2;
      hs_offset=0;
      break;
    case 1:
      hs_nr=4;
      hs_offset=2;
      break;
    default:
      return;
    }
    UInt_t nrColChips = static_cast<UInt_t>(chipfraction*240*5 + 0.5);
    UInt_t nrColChipsUsed = 0;
    AliITSIntMap* colChipMap = new AliITSIntMap();
    while (nrColChipsUsed<nrColChips) {
      UInt_t eq = (UInt_t)(rnd->Rndm()*20);
      UInt_t hs = (UInt_t)(rnd->Rndm()*hs_nr+hs_offset);
      UInt_t chip = (UInt_t)(rnd->Rndm()*10);
      if (!colChipMap->Find(20*6*chip + 20*hs + eq)) {
	UInt_t nrCols = static_cast<UInt_t>(columnfraction*32 + 0.5);
	UInt_t nrColsInserted = 0;
	AliITSIntMap* colMap = new AliITSIntMap();
	while (nrColsInserted<nrCols) {
	  UInt_t col = (UInt_t)(rnd->Rndm()*32);
	  if (!colMap->Find(col)) {
	    for (UInt_t row=0; row<256; row++) {
	      handler->SetDeadPixel(eq,hs,chip,col,row);
	    }
	    colMap->Insert(col,col);
	    nrColsInserted++;
	  }
	}
	delete colMap;
	colChipMap->Insert(20*6*chip + 20*hs + eq, chip);
	nrColChipsUsed++;
      }
    }
    delete colChipMap;
  }
}
Commit	Line	Data
ddbe16d5	1	//////////////////////////////////////////////////////////////////////////
	2	// //
	3	// Example of usage: //
	4	// 1. Fix the seed //
	5	// 2. Randomly store 1% dead pixels all over the SPD //
	6	// 3. Print the number of dead pixels temporarily generated //
	7	// 4. Store the dead pixels in calibration objects for runNrs 1 to 10 //
	8	// //
	9	// root [0] .L AliITSStoreDeadSPD.C //
	10	// root [1] SetSeed(11) //
	11	// root [2] RandomizeDeadPixelsFrac(0.01) //
	12	// root [3] PrintNrDead() //
	13	// root [4] StoreCalib(1,10) //
	14	// //
	15	//////////////////////////////////////////////////////////////////////////
	16
	17	AliITSOnlineCalibrationSPDhandler* handler = NULL;
	18	TRandom* rnd = new TRandom();
	19
	20	void StoreCalib(Int_t RunNrStart=0, Int_t RunNrEnd=9999999) {
	21	if (handler!=NULL) {
	22	handler->WriteToDB(RunNrStart,RunNrEnd);
	23	}
	24	}
	25
	26	void ReadCalib(UInt_t runNr) {
	27	if (handler==NULL) handler = new AliITSOnlineCalibrationSPDhandler();
	28	else ClearDead();
	29	handler->ReadFromDB(runNr);
	30	}
	31
	32	void SetSeed(UInt_t seed) {
	33	rnd->SetSeed(seed);
	34	}
	35
	36	void PrintNrDead() {
	37	if (handler!=NULL) {
	38	printf("Nr of dead pixels: %d\n",handler->GetNrDead());
	39	}
	40	}
	41
	42	void PrintDead() {
	43	if (handler!=NULL) {
	44	handler->PrintDead();
	45	}
	46	}
	47
	48	void ClearDead() {
	49	if (handler!=NULL) {
	50	handler->ResetDead();
	51	}
	52	}
	53
	54	void RandomizeDeadPixelsFrac(Double_t fraction) {
	55	if (fraction>0 && fraction<=1) {
	56	UInt_t nrdeadpixels = static_cast<UInt_t>(fraction256160*240 + 0.5);
	57	RandomizeDeadPixels(nrdeadpixels);
	58	}
	59	}
	60	void RandomizeDeadPixels(UInt_t nrDead) {
	61	if (handler==NULL) handler = new AliITSOnlineCalibrationSPDhandler();
	62	UInt_t nrDeadInserted = 0;
	63	while (nrDeadInserted<nrDead) {
	64	UInt_t mod = (UInt_t)(rnd->Rndm()*240);
65	UInt_t col = (UInt_t)(rnd->Rndm()*160);
66	UInt_t row = (UInt_t)(rnd->Rndm()*256);
67	if (handler->SetDeadPixelM(mod,col,row)) nrDeadInserted++;
68	}
69	}
70
71	void RandomizeDeadPixelsFrac(Double_t fraction, UInt_t layer) {
72	if (fraction>0 && fraction<=1) {
73	UInt_t nr_pixels;
74	UInt_t nrdeadpixels;
75	switch(layer) {
76	case 0:
77	nr_pixels = 25616080;
78	nrdeadpixels = static_cast<UInt_t>(fraction*nr_pixels + 0.5);
79	RandomizeDeadPixels(nrdeadpixels,layer);
80	break;
81	case 1:
82	nr_pixels = 256160160;
83	nrdeadpixels = static_cast<Int_t>(fraction*nr_pixels + 0.5);
84	RandomizeDeadPixels(nrdeadpixels,layer);
85	break;
86	default:
87	return;
88	}
89	}
90	}
91	void RandomizeDeadPixels(UInt_t nrDead, UInt_t layer) {
92	if (handler==NULL) handler = new AliITSOnlineCalibrationSPDhandler();
93	UInt_t nr_modules;
94	UInt_t mod_offset;
95	switch(layer) {
96	case 0:
97	nr_modules=80;
98	mod_offset=0;
99	break;
100	case 1:
101	nr_modules=160;
102	mod_offset=80;
103	break;
104	default:
105	return;
106	}
107	UInt_t nrDeadInserted = 0;
108	while (nrDeadInserted<nrDead) {
109	UInt_t mod = (UInt_t)(rnd->Rndm()*nr_modules) + mod_offset;
110	UInt_t col = (UInt_t)(rnd->Rndm()*160);
111	UInt_t row = (UInt_t)(rnd->Rndm()*256);
112	if (handler->SetDeadPixelM(mod,col,row)) nrDeadInserted++;
113	}
114	}
115
116	void RandomizeDeadChipsFrac(Double_t fraction) {
117	if (fraction>0 && fraction<=1) {
118	UInt_t nrdeadchips = static_cast<UInt_t>(fraction2405 + 0.5);
119	RandomizeDeadChips(nrdeadchips);
120	}
121	}
122	void RandomizeDeadChips(UInt_t nrDeadChips) {
123	if (handler==NULL) handler = new AliITSOnlineCalibrationSPDhandler();
124	UInt_t nrDeadChipsInserted = 0;
125	AliITSIntMap* chipMap = new AliITSIntMap();
126	while (nrDeadChipsInserted<nrDeadChips) {
127	UInt_t eq = (UInt_t)(rnd->Rndm()*20);
128	UInt_t hs = (UInt_t)(rnd->Rndm()*6);
129	UInt_t chip = (UInt_t)(rnd->Rndm()*10);
130	if (!chipMap->Find(206chip + 20*hs + eq)) {
131	for (UInt_t col=0; col<32; col++) {
132	for (UInt_t row=0; row<256; row++) {
133	handler->SetDeadPixel(eq,hs,chip,col,row);
134	}
135	}
136	chipMap->Insert(206chip + 20*hs + eq, chip);
137	nrDeadChipsInserted++;
138	}
139	}
140	delete chipMap;
141	}
142
143	void RandomizeDeadChipsFrac(Double_t fraction, UInt_t layer) {
144	if (fraction>0 && fraction<=1) {
145	UInt_t nr_chips;
146	UInt_t nrdeadchips;
147	switch(layer) {
148	case 0:
149	nr_chips = 400;
150	nrdeadchips = static_cast<UInt_t>(fraction*nr_chips + 0.5);
151	RandomizeDeadChips(nrdeadchips,layer);
152	break;
153	case 1:
154	nr_chips = 800;
155	nrdeadchips = static_cast<UInt_t>(fraction*nr_chips + 0.5);
156	RandomizeDeadChips(nrdeadchips,layer);
157	break;
158	default:
159	return;
160	}
161	}
162	}
163	void RandomizeDeadChips(UInt_t nrDeadChips, UInt_t layer) {
164	if (handler==NULL) handler = new AliITSOnlineCalibrationSPDhandler();
165	UInt_t hs_nr;
166	UInt_t hs_offset;
167	switch(layer) {
168	case 0:
169	hs_nr=2;
170	hs_offset=0;
171	break;
172	case 1:
173	hs_nr=4;
174	hs_offset=2;
175	break;
176	default:
177	return;
178	}
179	UInt_t nrDeadChipsInserted = 0;
180	AliITSIntMap* chipMap = new AliITSIntMap();
181	while (nrDeadChipsInserted<nrDeadChips) {
182	UInt_t eq = (UInt_t)(rnd->Rndm()*20);
183	UInt_t hs = (UInt_t)(rnd->Rndm()*hs_nr+hs_offset);
184	UInt_t chip = (UInt_t)(rnd->Rndm()*10);
185	if (!chipMap->Find(206chip + 20*hs + eq)) {
186	for (UInt_t col=0; col<32; col++) {
187	for (UInt_t row=0; row<256; row++) {
188	handler->SetDeadPixel(eq,hs,chip,col,row);
189	}
190	}
191	chipMap->Insert(206chip + 20*hs + eq, chip);
192	nrDeadChipsInserted++;
193	}
194	}
195	delete chipMap;
196	}
197
198	void RandomizeDeadHalfStavesFrac(Double_t fraction) {
199	if (fraction>0 && fraction<=1) {
200	UInt_t nrdeadhstaves = static_cast<UInt_t>(fraction*120 + 0.5);
201	RandomizeDeadHalfStaves(nrdeadhstaves);
202	}
203	}
204	void RandomizeDeadHalfStaves(UInt_t nrDeadHS) {
205	if (handler==NULL) handler = new AliITSOnlineCalibrationSPDhandler();
206	UInt_t nrDeadHSInserted = 0;
207	AliITSIntMap* hsMap = new AliITSIntMap();
208	while (nrDeadHSInserted<nrDeadHS) {
209	UInt_t eq = (UInt_t)(rnd->Rndm()*20);
210	UInt_t hs = (UInt_t)(rnd->Rndm()*6);
211	if (!hsMap->Find(20*hs + eq)) {
212	for (UInt_t chip=0; chip<10; chip++) {
213	for (UInt_t col=0; col<32; col++) {
214	for (UInt_t row=0; row<256; row++) {
215	handler->SetDeadPixel(eq,hs,chip,col,row);
216	}
217	}
218	}
219	hsMap->Insert(20*hs + eq, hs);
220	nrDeadHSInserted++;
221	}
222	}
223	delete hsMap;
224	}
225
226	void RandomizeDeadHalfStavesFrac(Double_t fraction, UInt_t layer) {
227	if (fraction>0 && fraction<=1) {
228	UInt_t nr_hstaves;
229	switch(layer) {
230	case 0:
231	nr_hstaves=static_cast<UInt_t>(fraction*40 + 0.5);
232	RandomizeDeadHalfStaves(nr_hstaves,layer);
233	break;
234	case 1:
235	nr_hstaves=static_cast<UInt_t>(fraction*80 + 0.5);
236	RandomizeDeadHalfStaves(nr_hstaves,layer);
237	break;
238	default:
239	return;
240	}
241	}
242	}
243	void RandomizeDeadHalfStaves(UInt_t nrDeadHS, UInt_t layer) {
244	if (handler==NULL) handler = new AliITSOnlineCalibrationSPDhandler();
245	UInt_t hs_nr;
246	UInt_t hs_offset;
247	switch(layer) {
248	case 0:
249	hs_nr=2;
250	hs_offset=0;
251	break;
252	case 1:
253	hs_nr=4;
254	hs_offset=2;
255	break;
256	default:
257	return;
258	}
259	UInt_t nrDeadHSInserted = 0;
260	AliITSIntMap* hsMap = new AliITSIntMap();
261	while (nrDeadHSInserted<nrDeadHS) {
262	UInt_t eq = (UInt_t)(rnd->Rndm()*20);
263	UInt_t hs = (UInt_t)(rnd->Rndm()*hs_nr+hs_offset);
264	if (!hsMap->Find(20*hs + eq)) {
265	for (UInt_t chip=0; chip<10; chip++) {
266	for (UInt_t col=0; col<32; col++) {
267	for (UInt_t row=0; row<256; row++) {
268	handler->SetDeadPixel(eq,hs,chip,col,row);
269	}
270	}
271	}
272	hsMap->Insert(20*hs + eq, hs);
273	nrDeadHSInserted++;
274	}
275	}
276	delete hsMap;
277	}
278
279	void RandomizeDeadColumnChipsFrac(Double_t chipfraction, Double_t columnfraction) {
280	if (chipfraction>0 && chipfraction<=1 && columnfraction>0 && columnfraction<=1) {
281	if (handler==NULL) handler = new AliITSOnlineCalibrationSPDhandler();
282	UInt_t nrColChips = static_cast<UInt_t>(chipfraction2405 + 0.5);
283	UInt_t nrColChipsUsed = 0;
284	AliITSIntMap* colChipMap = new AliITSIntMap();
285	while (nrColChipsUsed<nrColChips) {
286	UInt_t eq = (UInt_t)(rnd->Rndm()*20);
287	UInt_t hs = (UInt_t)(rnd->Rndm()*6);
288	UInt_t chip = (UInt_t)(rnd->Rndm()*10);
289	if (!colChipMap->Find(206chip + 20*hs + eq)) {
290	UInt_t nrCols = static_cast<UInt_t>(columnfraction*32 + 0.5);
291	UInt_t nrColsInserted = 0;
292	AliITSIntMap* colMap = new AliITSIntMap();
293	while (nrColsInserted<nrCols) {
294	UInt_t col = (UInt_t)(rnd->Rndm()*32);
295	if (!colMap->Find(col)) {
296	for (UInt_t row=0; row<256; row++) {
297	handler->SetDeadPixel(eq,hs,chip,col,row);
298	}
299	colMap->Insert(col,col);
300	nrColsInserted++;
301	}
302	}
303	delete colMap;
304	colChipMap->Insert(206chip + 20*hs + eq, chip);
305	nrColChipsUsed++;
306	}
307	}
308	delete colChipMap;
309	}
310	}
311	void RandomizeDeadColumnChipsFrac(Double_t chipfraction, Double_t columnfraction, Int_t layer) {
312	if (chipfraction>0 && chipfraction<=1 && columnfraction>0 && columnfraction<=1) {
313	if (handler==NULL) handler = new AliITSOnlineCalibrationSPDhandler();
314	UInt_t hs_nr;
315	UInt_t hs_offset;
316	switch(layer) {
317	case 0:
318	hs_nr=2;
319	hs_offset=0;
320	break;
321	case 1:
322	hs_nr=4;
323	hs_offset=2;
324	break;
325	default:
326	return;
327	}
328	UInt_t nrColChips = static_cast<UInt_t>(chipfraction2405 + 0.5);
329	UInt_t nrColChipsUsed = 0;
330	AliITSIntMap* colChipMap = new AliITSIntMap();
331	while (nrColChipsUsed<nrColChips) {
332	UInt_t eq = (UInt_t)(rnd->Rndm()*20);
333	UInt_t hs = (UInt_t)(rnd->Rndm()*hs_nr+hs_offset);
334	UInt_t chip = (UInt_t)(rnd->Rndm()*10);
335	if (!colChipMap->Find(206chip + 20*hs + eq)) {
336	UInt_t nrCols = static_cast<UInt_t>(columnfraction*32 + 0.5);
337	UInt_t nrColsInserted = 0;
338	AliITSIntMap* colMap = new AliITSIntMap();
339	while (nrColsInserted<nrCols) {
340	UInt_t col = (UInt_t)(rnd->Rndm()*32);
341	if (!colMap->Find(col)) {
342	for (UInt_t row=0; row<256; row++) {
343	handler->SetDeadPixel(eq,hs,chip,col,row);
344	}
345	colMap->Insert(col,col);
346	nrColsInserted++;
347	}
348	}
349	delete colMap;
350	colChipMap->Insert(206chip + 20*hs + eq, chip);
351	nrColChipsUsed++;
352	}
353	}
354	delete colChipMap;
355	}
356	}
357