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