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