]> git.uio.no Git - u/mrichter/AliRoot.git/blame - ITS/AliITSsimulationSPD.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Added functions needed for SDD new SDigits/Digits (Add and fSigmaAfterElect).
[u/mrichter/AliRoot.git] / ITS / AliITSsimulationSPD.cxx
CommitLineData
c7a4dac0 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16/*
17$Log$
3a97c582 18Revision 1.14 2001/11/23 13:04:07 barbera
19Some protection added in case of high multiplicity
20
0fee5d51 21Revision 1.13 2001/11/13 11:13:24 barbera
22A protection against tracks with the same entrance and exit has been made more strict
23
0cadf298 24Revision 1.12 2001/10/04 22:44:31 nilsen
25Major changes in supppor of PreDigits (SDigits). Changes made with will make
26it easier to suppor expected changes in AliITSHit class. Added use of new
27class AliITSpList. Both SPD and SDD have added effects of Dead Channels. Both
28of these will require addtional work as data bases of detectors and the like
29are developed.
30
c7a4dac0 31*/
b0f5e3fc 32#include <iostream.h>
33#include <TRandom.h>
34#include <TH1.h>
e8189707 35#include <TMath.h>
9f033001 36#include <TString.h>
37#include <TParticle.h>
e8189707 38
b0f5e3fc 39#include "AliRun.h"
e8189707 40#include "AliITS.h"
9f033001 41#include "AliITShit.h"
42#include "AliITSdigit.h"
43#include "AliITSmodule.h"
21b825a4 44#include "AliITSMapA2.h"
c7a4dac0 45#include "AliITSpList.h"
b0f5e3fc 46#include "AliITSsimulationSPD.h"
9f033001 47#include "AliITSsegmentation.h"
48#include "AliITSresponse.h"
c7a4dac0 49#include "AliITSsegmentationSPD.h"
50#include "AliITSresponseSPD.h"
9f033001 51
e8189707 52
b0f5e3fc 53ClassImp(AliITSsimulationSPD)
54////////////////////////////////////////////////////////////////////////
55// Version: 0
21b825a4 56// Written by Rocco Caliandro
57// from a model developed with T. Virgili and R.A. Fini
58// June 15 2000
b0f5e3fc 59//
60// AliITSsimulationSPD is the simulation of SPDs
21b825a4 61//
c7a4dac0 62//______________________________________________________________________
21b825a4 63AliITSsimulationSPD::AliITSsimulationSPD(){
c7a4dac0 64 // Default constructor
65
66 fResponse = 0;
67 fSegmentation = 0;
68 fHis = 0;
69 fMapA2 = 0;
3a97c582 70
c7a4dac0 71/*
72 fThresh = 0.;
73 fSigma = 0.;
74 fCouplCol = 0.;
75 fCouplRow = 0.; */
b0f5e3fc 76}
c7a4dac0 77//______________________________________________________________________
78AliITSsimulationSPD::AliITSsimulationSPD(AliITSsegmentation *seg,
79 AliITSresponse *resp) {
80 // Standard constructor
81
82 fResponse = 0;
83 fSegmentation = 0;
84 fHis = 0;
85 fMapA2 = 0;
3a97c582 86
c7a4dac0 87/*
88 fThresh = 0.;
89 fSigma = 0.;
90 fCouplCol = 0.;
91 fCouplRow = 0.*/
92 Init((AliITSsegmentationSPD*)seg,(AliITSresponseSPD*)resp);
b0f5e3fc 93}
c7a4dac0 94//______________________________________________________________________
95void AliITSsimulationSPD::Init(AliITSsegmentationSPD *seg,
96 AliITSresponseSPD *resp) {
97 // Initilizes the variables of AliITSsimulation SPD.
98
99 fHis = 0;
100 fResponse = resp;
101 fSegmentation = seg;
3a97c582 102 fMapA2 = new AliITSMapA2(fSegmentation);
103 fpList = new AliITSpList(GetNPixelsZ()+1,GetNPixelsX()+1);
c7a4dac0 104/*
105 fResponse->Thresholds(fThresh,fSigma);
106 fResponse->GetNoiseParam(fCouplCol,fCouplRow);
107 fNPixelsZ = fSegmentation->Npz();
108 fNPixelsX = fSegmentation->Npx();
109*/
110}
111//______________________________________________________________________
b0f5e3fc 112AliITSsimulationSPD::~AliITSsimulationSPD() {
c7a4dac0 113 // destructor
b0f5e3fc 114
c7a4dac0 115 delete fMapA2;
3a97c582 116// delete fpList;
b0f5e3fc 117
c7a4dac0 118 if (fHis) {
119 fHis->Delete();
120 delete fHis;
121 } // end if
b0f5e3fc 122}
c7a4dac0 123//______________________________________________________________________
b0f5e3fc 124AliITSsimulationSPD::AliITSsimulationSPD(const AliITSsimulationSPD &source){
c7a4dac0 125 // Copy Constructor
126
127 if(&source == this) return;
128
129 this->fMapA2 = source.fMapA2;
130 this->fHis = source.fHis;
131/*
132 this->fThresh = source.fThresh;
133 this->fSigma = source.fSigma;
134 this->fCouplCol = source.fCouplCol;
135 this->fCouplRow = source.fCouplRow;
136 this->fNPixelsX = source.fNPixelsX;
137 this->fNPixelsZ = source.fNPixelsZ;
138*/
139 return;
b0f5e3fc 140}
c7a4dac0 141//______________________________________________________________________
142AliITSsimulationSPD& AliITSsimulationSPD::operator=(const AliITSsimulationSPD
143 &source) {
144 // Assignment operator
145
146 if(&source == this) return *this;
147
148 this->fMapA2 = source.fMapA2;
149 this->fHis = source.fHis;
150/*
151 this->fThresh = source.fThresh;
152 this->fSigma = source.fSigma;
153 this->fCouplCol = source.fCouplCol;
154 this->fCouplRow = source.fCouplRow;
155 this->fNPixelsX = source.fNPixelsX;
156 this->fNPixelsZ = source.fNPixelsZ;
157*/
158 return *this;
3a97c582 159}
160//______________________________________________________________________
161void AliITSsimulationSPD::InitSimulationModule(Int_t module,Int_t event){
162 // Creates maps to build the list of tracks for each sumable digit
163 // Inputs:
164 // Int_t module // Module number to be simulated
165 // Int_t event // Event number to be simulated
166 // Outputs:
167 // none.
168 // Return
169 // none.
170
171 fModule = module;
172 fEvent = event;
173 fMapA2->ClearMap();
174 fpList->ClearMap();
175}
176//______________________________________________________________________
177void AliITSsimulationSPD::FinishSDigitiseModule(){
178 // Does the Sdigits to Digits work
179 // Inputs:
180 // none.
181 // Outputs:
182 // none.
183 // Return:
184 // none.
185
186 SDigitsToDigits(fModule,fpList);
c7a4dac0 187}
188//______________________________________________________________________
189void AliITSsimulationSPD::SDigitiseModule(AliITSmodule *mod, Int_t dummy0,
190 Int_t dummy1) {
191 // Sum digitize module
192 if (!(mod->GetNhits())) return; // if module has no hits then no Sdigits.
193 Int_t number = 10000;
194 Int_t *frowpixel = new Int_t[number];
195 Int_t *fcolpixel = new Int_t[number];
196 Double_t *fenepixel = new Double_t[number];
197
3a97c582 198 fModule = mod->GetIndex();
199
c7a4dac0 200 // Array of pointers to store the track index of the digits
201 // leave +1, otherwise pList crashes when col=256, row=192
c7a4dac0 202
3a97c582 203 HitsToAnalogDigits(mod,frowpixel,fcolpixel,fenepixel,fpList);
c7a4dac0 204
3a97c582 205 WriteSDigits(fpList);
c7a4dac0 206
207 // clean memory
208 delete[] frowpixel;
209 delete[] fcolpixel;
210 delete[] fenepixel;
211 fMapA2->ClearMap();
3a97c582 212 fpList->ClearMap();
c7a4dac0 213}
214//______________________________________________________________________
215void AliITSsimulationSPD::DigitiseModule(AliITSmodule *mod, Int_t dummy0,
216 Int_t dummy1) {
217 // digitize module. Also need to digitize modules with only noise.
b0f5e3fc 218
c7a4dac0 219 Int_t number = 10000;
220 Int_t *frowpixel = new Int_t[number];
221 Int_t *fcolpixel = new Int_t[number];
222 Double_t *fenepixel = new Double_t[number];
b0f5e3fc 223
c7a4dac0 224 // Array of pointers to store the track index of the digits
3a97c582 225 // leave +1, otherwise pList crashes when col=256, row=192
226 fModule = mod->GetIndex();
c7a4dac0 227 // noise setting
3a97c582 228 SetFluctuations(fpList,fModule);
b0f5e3fc 229
3a97c582 230 HitsToAnalogDigits(mod,frowpixel,fcolpixel,fenepixel,fpList);
21b825a4 231
c7a4dac0 232 // apply mask to SPD module
233 SetMask();
21b825a4 234
3a97c582 235 CreateDigit(fModule,fpList);
b0f5e3fc 236
c7a4dac0 237 // clean memory
238 delete[] frowpixel;
239 delete[] fcolpixel;
240 delete[] fenepixel;
241 fMapA2->ClearMap();
3a97c582 242 fpList->ClearMap();
21b825a4 243}
c7a4dac0 244//______________________________________________________________________
245void AliITSsimulationSPD::SDigitsToDigits(Int_t module,AliITSpList *pList) {
246 // sum digits to Digits.
3a97c582 247// cout << "Entering AliITSsimulatinSPD::SDigitsToDigits for module=";
248// cout << module << endl;
249 fModule = module;
b0f5e3fc 250
c7a4dac0 251 // noise setting
252 SetFluctuations(pList,module);
b0f5e3fc 253
3a97c582 254 fMapA2->ClearMap(); // since noise is in pList aready. Zero Map so that
255 // noise is not doubled when calling FillMapFrompList.
256
257 FillMapFrompList(pList);
258
c7a4dac0 259 // apply mask to SPD module
260 SetMask();
21b825a4 261
c7a4dac0 262 CreateDigit(module,pList);
3a97c582 263
264 fMapA2->ClearMap();
265 pList->ClearMap();
c7a4dac0 266}
267//______________________________________________________________________
268void AliITSsimulationSPD::UpdateMapSignal(Int_t row,Int_t col,Int_t trk,
269 Int_t hit,Int_t mod,Double_t ene,
270 AliITSpList *pList) {
271 // updates the Map of signal, adding the energy (ene) released by
272 // the current track
273
274 fMapA2->AddSignal(row,col,ene);
275 pList->AddSignal(row,col,trk,hit,mod,ene);
276}
277//______________________________________________________________________
278void AliITSsimulationSPD::UpdateMapNoise(Int_t row,Int_t col,Int_t mod,
279 Double_t ene,AliITSpList *pList) {
280 // updates the Map of noise, adding the energy (ene) give my noise
21b825a4 281
c7a4dac0 282 fMapA2->AddSignal(row,col,ene);
283 pList->AddNoise(row,col,mod,ene);
284}
285//______________________________________________________________________
286void AliITSsimulationSPD::HitsToAnalogDigits(AliITSmodule *mod,
287 Int_t *frowpixel,Int_t *fcolpixel,
288 Double_t *fenepixel,
289 AliITSpList *pList) {
290 // Loops over all hits to produce Analog/floting point digits. This
291 // is also the first task in producing standard digits.
21b825a4 292
c7a4dac0 293 // loop over hits in the module
294 Int_t hitpos,nhits = mod->GetNhits();
295 for (hitpos=0;hitpos<nhits;hitpos++) {
296 HitToDigit(mod,hitpos,frowpixel,fcolpixel,fenepixel,pList);
297 }// end loop over digits
298}
299//______________________________________________________________________
300void AliITSsimulationSPD::HitToDigit(AliITSmodule *mod,Int_t hitpos,
301 Int_t *frowpixel,Int_t *fcolpixel,
302 Double_t *fenepixel,AliITSpList *pList) {
303 // Steering function to determine the digits associated to a given
304 // hit (hitpos)
305 // The digits are created by charge sharing (ChargeSharing) and by
306 // capacitive coupling (SetCoupling). At all the created digits is
307 // associated the track number of the hit (ntrack)
308 Double_t x1l=0.0,y1l=0.0,z1l=0.0,x2l=0.0,y2l=0.0,z2l=0.0;
309 Int_t r1,r2,c1,c2,row,col,npixel = 0;
310 Int_t ntrack;
311 Double_t ene=0.0,etot=0.0;
312 const Float_t kconv = 10000.; // cm -> microns
313 const Float_t kconv1= 0.277e9; // GeV -> electrons equivalent
314
315 if(!(mod->LineSegmentL(hitpos,x1l,x2l,y1l,y2l,z1l,z2l,etot,ntrack)))return;
316
317 x2l += x1l; y2l += y1l; z2l += z1l; // Convert to ending coordinate.
318 // positions shifted and converted in microns
319 x1l = x1l*kconv + fSegmentation->Dx()/2.;
320 z1l = z1l*kconv + fSegmentation->Dz()/2.;
321 // positions shifted and converted in microns
322 x2l = x2l*kconv + fSegmentation->Dx()/2.;
323 z2l = z2l*kconv + fSegmentation->Dz()/2.;
324 etot *= kconv1; // convert from GeV to electrons equivalent.
325 Int_t module = mod->GetIndex();
326
327 // to account for the effective sensitive area
328 // introduced in geometry
329 if (z1l<0 || z1l>fSegmentation->Dz()) return;
330 if (z2l<0 || z2l>fSegmentation->Dz()) return;
331 if (x1l<0 || x1l>fSegmentation->Dx()) return;
332 if (x2l<0 || x2l>fSegmentation->Dx()) return;
333
334 //Get the col and row number starting from 1
335 // the x direction is not inverted for the second layer!!!
336 fSegmentation->GetPadIxz(x1l, z1l, c1, r1);
337 fSegmentation->GetPadIxz(x2l, z2l, c2, r2);
338
339 // to account for unexpected equal entrance and
340 // exit coordinates
0fee5d51 341 if (x1l==x2l) x2l=x2l+x2l*0.1;
342 if (z1l==z2l) z2l=z2l+z2l*0.1;
c7a4dac0 343
344 if ((r1==r2) && (c1==c2)){
345 // no charge sharing
346 npixel = 1;
347 frowpixel[npixel-1] = r1;
348 fcolpixel[npixel-1] = c1;
349 fenepixel[npixel-1] = etot;
350 } else {
351 // charge sharing
352 ChargeSharing(x1l,z1l,x2l,z2l,c1,r1,c2,r2,etot,
353 npixel,frowpixel,fcolpixel,fenepixel);
354 } // end if r1==r2 && c1==c2.
355
356 for (Int_t npix=0;npix<npixel;npix++){
357 row = frowpixel[npix];
358 col = fcolpixel[npix];
359 ene = fenepixel[npix];
360 UpdateMapSignal(row,col,ntrack,hitpos,module,ene,pList);
361 // Starting capacitive coupling effect
362 SetCoupling(row,col,ntrack,hitpos,module,pList);
363 } // end for npix
364}
365//______________________________________________________________________
366void AliITSsimulationSPD::ChargeSharing(Float_t x1l,Float_t z1l,Float_t x2l,
367 Float_t z2l,Int_t c1,Int_t r1,Int_t c2,
368 Int_t r2,Float_t etot,
369 Int_t &npixel,Int_t *frowpixel,
370 Int_t *fcolpixel,Double_t *fenepixel){
371 // Take into account the geometrical charge sharing when the track
372 // crosses more than one pixel.
373 //
374 //Begin_Html
21b825a4 375 /*
c7a4dac0 376 <img src="picts/ITS/barimodel_2.gif">
377 </pre>
378 <br clear=left>
379 <font size=+2 color=red>
380 <a href="mailto:Rocco.Caliandro@ba.infn.it"></a>.
381 </font>
382 <pre>
21b825a4 383 */
c7a4dac0 384 //End_Html
385 Float_t xa,za,xb,zb,dx,dz,dtot,dm,refr,refm,refc;
386 Float_t refn=0.;
387 Float_t arefm, arefr, arefn, arefc, azb, az2l, axb, ax2l;
388 Int_t dirx,dirz,rb,cb;
389 Int_t flag,flagrow,flagcol;
390 Double_t epar;
391
392 npixel = 0;
393 xa = x1l;
394 za = z1l;
395 dx = TMath::Abs(x1l-x2l);
0fee5d51 396 if (dx == 0.) dx = 0.01;
c7a4dac0 397 dz = TMath::Abs(z1l-z2l);
0fee5d51 398 if (dz == 0.) dz = 0.01;
c7a4dac0 399 dtot = TMath::Sqrt((dx*dx)+(dz*dz));
400 dm = (x2l - x1l) / (z2l - z1l);
0fee5d51 401 if (dm == 0.) dm = 0.01;
c7a4dac0 402 dirx = (Int_t) ((x2l - x1l) / dx);
403 dirz = (Int_t) ((z2l - z1l) / dz);
404
405 // calculate the x coordinate of the pixel in the next column
406 // and the z coordinate of the pixel in the next row
407 Float_t xpos, zpos;
408
409 fSegmentation->GetPadCxz(c1, r1-1, xpos, zpos);
410
411 Float_t xsize = fSegmentation->Dpx(0);
412 Float_t zsize = fSegmentation->Dpz(r1-1);
21b825a4 413
c7a4dac0 414 if (dirx == 1) refr = xpos+xsize/2.;
415 else refr = xpos-xsize/2.;
416
417 if (dirz == 1) refn = zpos+zsize/2.;
418 else refn = zpos-zsize/2.;
419
420 flag = 0;
421 flagrow = 0;
422 flagcol = 0;
423 do{
424 // calculate the x coordinate of the intersection with the pixel
425 // in the next cell in row direction
426 refm = (refn - z1l)*dm + x1l;
e8189707 427
c7a4dac0 428 // calculate the z coordinate of the intersection with the pixel
429 // in the next cell in column direction
430 refc = (refr - x1l)/dm + z1l;
431
432 arefm = refm * dirx;
433 arefr = refr * dirx;
434 arefn = refn * dirz;
435 arefc = refc * dirz;
436
437 if ((arefm < arefr) && (arefn < arefc)){
438 // the track goes in the pixel in the next cell in row direction
439 xb = refm;
440 zb = refn;
441 cb = c1;
442 rb = r1 + dirz;
443 azb = zb * dirz;
444 az2l = z2l * dirz;
445 if (rb == r2) flagrow=1;
446 if (azb > az2l) {
21b825a4 447 zb = z2l;
448 xb = x2l;
c7a4dac0 449 } // end if
450 // shift to the pixel in the next cell in row direction
451 Float_t zsizeNext = fSegmentation->Dpz(rb-1);
452 //to account for cell at the borders of the detector
453 if(zsizeNext==0) zsizeNext = zsize;
454 refn += zsizeNext*dirz;
455 }else {
456 // the track goes in the pixel in the next cell in column direction
457 xb = refr;
458 zb = refc;
459 cb = c1 + dirx;
460 rb = r1;
461 axb = xb * dirx;
462 ax2l = x2l * dirx;
463 if (cb == c2) flagcol=1;
464 if (axb > ax2l) {
21b825a4 465 zb = z2l;
466 xb = x2l;
c7a4dac0 467 } // end ifaxb > ax2l
468
469 // shift to the pixel in the next cell in column direction
470 Float_t xsizeNext = fSegmentation->Dpx(cb-1);
471 //to account for cell at the borders of the detector
472 if(xsizeNext==0) xsizeNext = xsize;
473 refr += xsizeNext*dirx;
474 } // end if (arefm < arefr) && (arefn < arefc)
475
476 //calculate the energy lost in the crossed pixel
477 epar = TMath::Sqrt((xb-xa)*(xb-xa)+(zb-za)*(zb-za));
478 epar = etot*(epar/dtot);
479
480 //store row, column and energy lost in the crossed pixel
481 frowpixel[npixel] = r1;
482 fcolpixel[npixel] = c1;
483 fenepixel[npixel] = epar;
484 npixel++;
21b825a4 485
c7a4dac0 486 // the exit point of the track is reached
487 if (epar == 0) flag = 1;
488 if ((r1 == r2) && (c1 == c2)) flag = 1;
489 if (flag!=1) {
490 r1 = rb;
491 c1 = cb;
492 xa = xb;
493 za = zb;
494 } // end if flag!=1
495 } while (flag==0);
21b825a4 496}
c7a4dac0 497//______________________________________________________________________
21b825a4 498void AliITSsimulationSPD::SetCoupling(Int_t row, Int_t col, Int_t ntrack,
c7a4dac0 499 Int_t idhit,Int_t module,
500 AliITSpList *pList) {
501 // Take into account the coupling between adiacent pixels.
502 // The parameters probcol and probrow are the fractions of the
503 // signal in one pixel shared in the two adjacent pixels along
504 // the column and row direction, respectively.
505 //
506 //Begin_Html
507 /*
508 <img src="picts/ITS/barimodel_3.gif">
509 </pre>
510 <br clear=left>
511 <font size=+2 color=red>
512 <a href="mailto:Rocco.Caliandro@ba.infn.it"></a>.
513 </font>
514 <pre>
515 */
516 //End_Html
517 Int_t j1,j2,flag=0;
518 Double_t pulse1,pulse2;
519 Float_t couplR=0.0,couplC=0.0;
520
521 GetCouplings(couplR,couplC);
522 j1 = row;
523 j2 = col;
524 pulse1 = fMapA2->GetSignal(row,col);
525 pulse2 = pulse1;
526 for (Int_t isign=-1;isign<=1;isign+=2){// loop in row direction
527 do{
528 j1 += isign;
529 pulse1 *= couplR;
530 if ((j1<0) || (j1>GetNPixelsZ()-1) || (pulse1<GetThreshold())){
531 pulse1 = fMapA2->GetSignal(row,col);
532 j1 = row;
533 flag = 1;
534 }else{
535 UpdateMapSignal(j1,col,ntrack,idhit,module,pulse1,pList);
536 flag = 0;
537 } // end if
538 } while(flag == 0);
539 // loop in column direction
540 do{
541 j2 += isign;
542 pulse2 *= couplC;
543 if ((j2<0) || (j2>(GetNPixelsX()-1)) || (pulse2<GetThreshold())){
544 pulse2 = fMapA2->GetSignal(row,col);
545 j2 = col;
546 flag = 1;
547 }else{
548 UpdateMapSignal(row,j2,ntrack,idhit,module,pulse2,pList);
549 flag = 0;
550 } // end if
551 } while(flag == 0);
552 } // for isign
21b825a4 553}
c7a4dac0 554//______________________________________________________________________
555void AliITSsimulationSPD::CreateDigit(Int_t module,AliITSpList *pList) {
556 // The pixels are fired if the energy deposited inside them is above
557 // the threshold parameter ethr. Fired pixed are interpreted as digits
558 // and stored in the file digitfilename. One also needs to write out
559 // cases when there is only noise (nhits==0).
560
561 static AliITS *aliITS = (AliITS*)gAlice->GetModule("ITS");
562
563 Int_t digits[3];
564 Int_t tracks[3];
565 Int_t hits[3];
566 Float_t charges[3];
567 Int_t j1;
568
569 for (Int_t r=1;r<=GetNPixelsZ();r++) {
570 for (Int_t c=1;c<=GetNPixelsX();c++) {
571 // check if the deposited energy in a pixel is above the
572 // threshold
573 Float_t signal = (Float_t) fMapA2->GetSignal(r,c);
574 if ( signal > GetThreshold()) {
575 digits[0] = r-1; // digits starts from 0
576 digits[1] = c-1; // digits starts from 0
577 //digits[2] = 1;
578 digits[2] = (Int_t) signal; // the signal is stored in
579 // electrons
580 for(j1=0;j1<3;j1++){
581 tracks[j1] = pList->GetTrack(r,c,j1);
582 hits[j1] = pList->GetHit(r,c,j1);
21b825a4 583 charges[j1] = 0;
c7a4dac0 584 } // end for j1
3a97c582 585 Float_t phys = 0;
c7a4dac0 586 aliITS->AddSimDigit(0,phys,digits,tracks,hits,charges);
3a97c582 587// cout << " CreateSPDDigit mod=" << fModule << " r,c=" << r;
588// cout <<","<<c<< " sig=" << fpList->GetSignalOnly(r,c);
589// cout << " noise=" << fpList->GetNoise(r,c);
590// cout << " Msig="<< signal << " Thres=" << GetThreshold()<<endl;
c7a4dac0 591 } // end if of threshold condition
592 } // for c
593 }// end do on pixels
21b825a4 594}
c7a4dac0 595//______________________________________________________________________
596void AliITSsimulationSPD::SetFluctuations(AliITSpList *pList,Int_t module) {
597 // Set the electronic noise and threshold non-uniformities to all the
598 // pixels in a detector.
599 // The parameter fSigma is the squared sum of the sigma due to noise
600 // and the sigma of the threshold distribution among pixels.
601 //
602 //Begin_Html
603 /*
604 <img src="picts/ITS/barimodel_1.gif">
605 </pre>
606 <br clear=left>
607 <font size=+2 color=red>
608 <a href="mailto:Rocco.Caliandro@ba.infn.it"></a>.
609 </font>
610 <pre>
611 */
612 //End_Html
613 Float_t thr=0.0,sigm=0.0;
614 Double_t signal,sigma;
615 Int_t iz,ix;
616
617 GetThresholds(thr,sigm);
618 sigma = (Double_t) sigm;
619 for(iz=1;iz<=GetNPixelsZ();iz++){
620 for(ix=1;ix<=GetNPixelsX();ix++){
621 signal = sigma*gRandom->Gaus();
622 fMapA2->SetHit(iz,ix,signal);
623 // insert in the label-signal-hit list the pixels fired
624 // only by noise
625 pList->AddNoise(iz,ix,module,signal);
626 } // end of loop on pixels
21b825a4 627 } // end of loop on pixels
c7a4dac0 628}
629//______________________________________________________________________
630void AliITSsimulationSPD::SetMask() {
631 // Apply a mask to the SPD module. 1% of the pixel channels are
632 // masked. When the database will be ready, the masked pixels
633 // should be read from it.
634 Double_t signal;
635 Int_t iz,ix,im;
636 Float_t totMask;
637 Float_t perc = ((AliITSresponseSPD*)fResponse)->GetFractionDead();
638 // in this way we get the same set of random numbers for all runs.
639 // This is a cluge for now.
640 static TRandom *rnd = new TRandom();
641
642 totMask= perc*GetNPixelsZ()*GetNPixelsX();
643 for(im=1;im<totMask;im++){
644 do{
645 ix=(Int_t)(rnd->Rndm()*(GetNPixelsX()-1.) + 1.);
646 } while(ix<=0 || ix>GetNPixelsX());
647 do{
648 iz=(Int_t)(rnd->Rndm()*(GetNPixelsZ()-1.) + 1.);
649 } while(iz<=0 || iz>GetNPixelsZ());
650 signal = -1.;
651 fMapA2->SetHit(iz,ix,signal);
652 } // end loop on masked pixels
653}
654//______________________________________________________________________
21b825a4 655void AliITSsimulationSPD::CreateHistograms() {
c7a4dac0 656 // Create Histograms
657 Int_t i;
21b825a4 658
c7a4dac0 659 fHis=new TObjArray(GetNPixelsZ());
660 for(i=0;i<GetNPixelsZ();i++) {
661 TString spdname("spd_");
662 Char_t candnum[4];
663 sprintf(candnum,"%d",i+1);
664 spdname.Append(candnum);
665 (*fHis)[i] = new TH1F(spdname.Data(),"SPD maps",
666 GetNPixelsX(),0.,(Float_t) GetNPixelsX());
667 } // end for i
b0f5e3fc 668}
c7a4dac0 669//______________________________________________________________________
21b825a4 670void AliITSsimulationSPD::ResetHistograms() {
b0f5e3fc 671 // Reset histograms for this detector
21b825a4 672 Int_t i;
b0f5e3fc 673
c7a4dac0 674 for(i=0;i<GetNPixelsZ();i++ ) {
675 if ((*fHis)[i]) ((TH1F*)(*fHis)[i])->Reset();
676 } // end for i
677}
678//______________________________________________________________________
679void AliITSsimulationSPD::WriteSDigits(AliITSpList *pList){
680 // Fills the Summable digits Tree
681 Int_t i,ni,j,nj;
682 static AliITS *aliITS = (AliITS*)gAlice->GetModule("ITS");
683
684 pList->GetMaxMapIndex(ni,nj);
685 for(i=0;i<ni;i++)for(j=0;j<nj;j++){
686 if(pList->GetSignalOnly(i,j)>0.0){
687 aliITS->AddSumDigit(*(pList->GetpListItem(i,j)));
688// cout << "pListSPD: " << *(pList->GetpListItem(i,j)) << endl;
3a97c582 689// cout << " CreateSPDSDigit mod=" << fModule << " r,c=";
690// cout << i <<","<< j << " sig=" << fpList->GetSignalOnly(i,j);
691// cout << " noise=" << fpList->GetNoise(i,j) <<endl;
c7a4dac0 692 } // end if
693 } // end for i,j
694 return;
695}
696//______________________________________________________________________
697void AliITSsimulationSPD::FillMapFrompList(AliITSpList *pList){
698 // Fills fMap2A from the pList of Summable digits
3a97c582 699 Int_t ix,iz;
c7a4dac0 700
3a97c582 701 for(iz=0;iz<GetNPixelsZ();iz++)for(ix=0;ix<GetNPixelsX();ix++)
702 fMapA2->AddSignal(iz,ix,pList->GetSignal(iz,ix));
c7a4dac0 703 return;
b0f5e3fc 704}