.
```    */
//End_Html
//Float_t dm;
Float_t xa,za,xb,zb,dx,dz,dtot,refr,refm,refc;
Float_t refn=0.;
Float_t arefm, arefr, arefn, arefc, azb, az2l, axb, ax2l;
Int_t   dirx,dirz,rb,cb;
Int_t flag,flagrow,flagcol;
Double_t epar;

npixel = 0;
xa     = x1l;
za     = z1l;
//    dx     = x1l-x2l;
//    dz     = z1l-z2l;
dx     = x2l-x1l;
dz     = z2l-z1l;
dtot   = TMath::Sqrt((dx*dx)+(dz*dz));
if (dtot==0.0) dtot = 0.01;
dirx   = (Int_t) TMath::Sign((Float_t)1,dx);
dirz   = (Int_t) TMath::Sign((Float_t)1,dz);

// calculate the x coordinate of  the pixel in the next column
// and the z coordinate of  the pixel in the next row
Float_t xpos, zpos;

Float_t xsize = fSegmentation->Dpx(0);
Float_t zsize = fSegmentation->Dpz(r1-1);

if (dirx == 1) refr = xpos+xsize/2.;
else refr = xpos-xsize/2.;

if (dirz == 1) refn = zpos+zsize/2.;
else refn = zpos-zsize/2.;

flag = 0;
flagrow = 0;
flagcol = 0;
do{
// calculate the x coordinate of the intersection with the pixel
// in the next cell in row  direction
if(dz!=0)
refm = dx*((refn - z1l)/dz) + x1l;
else
refm = refr+dirx*xsize;

// calculate the z coordinate of the intersection with the pixel
// in the next cell in column direction
if (dx!=0)
refc = dz*((refr - x1l)/dx) + z1l;
else
refc = refn+dirz*zsize;

arefm = refm * dirx;
arefr = refr * dirx;
arefn = refn * dirz;
arefc = refc * dirz;

if ((arefm < arefr) && (arefn < arefc)){
// the track goes in the pixel in the next cell in row direction
xb = refm;
zb = refn;
cb = c1;
rb = r1 + dirz;
azb = zb * dirz;
az2l = z2l * dirz;
if (rb == r2) flagrow=1;
if (azb > az2l) {
zb = z2l;
xb = x2l;
} // end if
// shift to the pixel in the next cell in row direction
Float_t zsizeNext = fSegmentation->Dpz(rb-1);
//to account for cell at the borders of the detector
if(zsizeNext==0) zsizeNext = zsize;
refn += zsizeNext*dirz;
}else {
// the track goes in the pixel in the next cell in column direction
xb = refr;
zb = refc;
cb = c1 + dirx;
rb = r1;
axb = xb * dirx;
ax2l = x2l * dirx;
if (cb == c2) flagcol=1;
if (axb > ax2l) {
zb = z2l;
xb = x2l;
} // end ifaxb > ax2l

// shift to the pixel in the next cell in column direction
Float_t xsizeNext = fSegmentation->Dpx(cb-1);
//to account for cell at the borders of the detector
if(xsizeNext==0) xsizeNext = xsize;
refr += xsizeNext*dirx;
} // end if (arefm < arefr) && (arefn < arefc)

//calculate the energy lost in the crossed pixel
epar = TMath::Sqrt((xb-xa)*(xb-xa)+(zb-za)*(zb-za));
epar = etot*(epar/dtot);

//store row, column and energy lost in the crossed pixel
frowpixel[npixel] = r1;
fcolpixel[npixel] = c1;
fenepixel[npixel] = epar;
npixel++;

// the exit point of the track is reached
if (epar == 0) flag = 1;
if ((r1 == r2) && (c1 == c2)) flag = 1;
if (flag!=1) {
r1 = rb;
c1 = cb;
xa = xb;
za = zb;
} // end if flag!=1
} while (flag==0);
}
//______________________________________________________________________
void AliITSsimulationSPD::SetCoupling(Int_t row, Int_t col, Int_t ntrack,
Int_t idhit,Int_t module,
AliITSpList *pList) {
//  Take into account the coupling between adiacent pixels.
//  The parameters probcol and probrow are the probability of the
//  signal in one pixel shared in the two adjacent pixels along
//  the column and row direction, respectively.
// Inputs:
//    Int_t      row    pixel row number
//    Int_t      col     pixel column number
//    Int_t      ntrack  track number of track contributing to this signal
//    Int_t      idhit   hit number of hit contributing to this signal
//    Int_t      module  module number
//   AliITSpList *pList  the array of SDigits
// Outputs:
//   AliITSpList *pList  the array of SDigits
// Return:
//   none.
//
//Begin_Html
/*

```

.
```    */
//End_Html
Int_t j1,j2,flag=0;
Double_t pulse1,pulse2;
Double_t couplR=0.0,couplC=0.0;
Double_t xr=0.;

GetCouplings(couplR,couplC);
j1 = row;
j2 = col;
pulse1 = fMapA2->GetSignal(row,col);
pulse2 = pulse1;
for (Int_t isign=-1;isign<=1;isign+=2){// loop in row direction
do{
j1 += isign;
//   pulse1 *= couplR;
xr = gRandom->Rndm();
//if ((j1<0) || (j1>GetNPixelsZ()-1) || (pulse1GetNPixelsZ()-1) || (xr>couplR)){
j1 = row;
flag = 1;
}else{
UpdateMapSignal(j1,col,ntrack,idhit,module,pulse1,pList);
//  flag = 0;
flag = 1; // only first next!!
} // end if
} while(flag == 0);
// loop in column direction
do{
j2 += isign;
// pulse2 *= couplC;
xr = gRandom->Rndm();
//if ((j2<0) || (j2>(GetNPixelsX()-1)) || (pulse2GetNPixelsX()-1) || (xr>couplC)){
j2 = col;
flag = 1;
}else{
UpdateMapSignal(row,j2,ntrack,idhit,module,pulse2,pList);
//  flag = 0;
flag = 1; // only first next!!
} // end if
} while(flag == 0);
} // for isign
}
//______________________________________________________________________
void AliITSsimulationSPD::SetCouplingOld(Int_t row, Int_t col, Int_t ntrack,
Int_t idhit,Int_t module,
AliITSpList *pList) {
//  Take into account the coupling between adiacent pixels.
//  The parameters probcol and probrow are the fractions of the
//  signal in one pixel shared in the two adjacent pixels along
//  the column and row direction, respectively.
// Inputs:
//    Int_t    row    pixel row number
//    Int_t    col    pixel column number
//    Int_t    ntrack track number of track contributing to this pixel
//    Int_t    idhit  hit index number of hit contributing to this pixel
//    Int_t    module module number
//   AliITSpList   *pList  the array of SDigits
// Outputs:
//   AliITSpList   *pList  the array of SDigits
// Return:
//   none.
//
//Begin_Html
/*

```

.
```    */
//End_Html
Int_t j1,j2,flag=0;
Double_t pulse1,pulse2;
Double_t couplR=0.0,couplC=0.0;

GetCouplings(couplR,couplC);
j1 = row;
j2 = col;
pulse1 = fMapA2->GetSignal(row,col);
pulse2 = pulse1;
for (Int_t isign=-1;isign<=1;isign+=2){// loop in row direction
do{
j1 += isign;
pulse1 *= couplR;
if ((j1<0) || (j1>GetNPixelsZ()-1) || (pulse1GetSignal(row,col);
j1 = row;
flag = 1;
}else{
UpdateMapSignal(j1,col,ntrack,idhit,module,pulse1,pList);
flag = 0;
} // end if
} while(flag == 0);
// loop in column direction
do{
j2 += isign;
pulse2 *= couplC;
if ((j2<0) || (j2>(GetNPixelsX()-1)) || (pulse2GetSignal(row,col);
j2 = col;
flag = 1;
}else{
UpdateMapSignal(row,j2,ntrack,idhit,module,pulse2,pList);
flag = 0;
} // end if
} while(flag == 0);
} // for isign
}
//______________________________________________________________________
void AliITSsimulationSPD::CreateDigit(Int_t module,AliITSpList *pList) {
// The pixels are fired if the energy deposited inside them is above
// the threshold parameter ethr. Fired pixed are interpreted as digits
// and stored in the file digitfilename. One also needs to write out
// cases when there is only noise (nhits==0).
// Inputs:
//    Int_t    module
//   AliITSpList   *pList  the array of SDigits
// Outputs:
//   AliITSpList   *pList  the array of SDigits
// Return:
//   none.

static AliITS *aliITS  = (AliITS*)gAlice->GetModule("ITS");

Int_t size = AliITSdigitSPD::GetNTracks();
Int_t * digits = new Int_t[size];
Int_t * tracks = new Int_t[size];
Int_t * hits = new Int_t[size];
Float_t * charges = new Float_t[size];
Int_t j1;

module=0; // remove unused variable warning.
for(j1=0;j1GetSignal(r,c);
if ( signal > GetThreshold()) {
digits[0] = r-1;  // digits starts from 0
digits[1] = c-1;  // digits starts from 0
//digits[2] = 1;
digits[2] =  (Int_t) signal;  // the signal is stored in
//  electrons
for(j1=0;j1GetNEnteries()){
tracks[j1] = pList->GetTrack(r,c,j1);
hits[j1]   = pList->GetHit(r,c,j1);
//}else{
//tracks[j1] = -3;
//hits[j1]   = -1;
} // end if
//charges[j1] = 0;
} // end for j1
Float_t phys = 0;
if(GetDebug()){
cout << " CreateSPDDigit mod=" << fModule << " r,c=" << r;
cout <<","<
```

.
```    */
//End_Html
Double_t  thr=0.0,sigm=0.0;
Double_t signal,sigma;
Int_t iz,ix;

GetThresholds(thr,sigm);
sigma = (Double_t) sigm;
for(iz=1;iz<=GetNPixelsZ();iz++){
for(ix=1;ix<=GetNPixelsX();ix++){
signal = sigma*gRandom->Gaus();
fMapA2->SetHit(iz,ix,signal);
// insert in the label-signal-hit list the pixels fired
// only by noise
} // end of loop on pixels
} // end of loop on pixels
}
//______________________________________________________________________
//  Apply a mask to the SPD module. 1% of the pixel channels are
//  should be read from it.
// Inputs:
//   none.
// Outputs:
//   none.
// Return:
//   none.
Double_t signal;
Int_t iz,ix,im;
// in this way we get the same set of random numbers for all runs.
// This is a cluge for now.
static TRandom *rnd = new TRandom();

for(im=1;imRndm()*(GetNPixelsX()-1.) + 1.);
} while(ix<=0 || ix>GetNPixelsX());
do{
iz=(Int_t)(rnd->Rndm()*(GetNPixelsZ()-1.) + 1.);
} while(iz<=0 || iz>GetNPixelsZ());
signal = -1.;
fMapA2->SetHit(iz,ix,signal);
} // end loop on masked pixels
}
//______________________________________________________________________
void AliITSsimulationSPD::CreateHistograms() {
// Create Histograms
// Inputs:
//   none.
// Outputs:
//   none.
// Return:
//   none.
Int_t i;

fHis=new TObjArray(GetNPixelsZ());
for(i=0;iReset();
} // end for i
}
//______________________________________________________________________
void AliITSsimulationSPD::WriteSDigits(AliITSpList *pList){
// Fills the Summable digits Tree
// Inputs:
//   AliITSpList   *pList  the array of SDigits
// Outputs:
//   AliITSpList   *pList  the array of SDigits
// Return:
//   none.
Int_t i,ni,j,nj;
static AliITS *aliITS = (AliITS*)gAlice->GetModule("ITS");

pList->GetMaxMapIndex(ni,nj);
for(i=0;iGetSignalOnly(i,j)>0.0){