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 /* $Id$ */
  17
  18 #include <Riostream.h>
  19 #include <TRandom.h>
  20 #include <TH1.h>
  21 #include <TMath.h>
  22 #include <TString.h>
  23 #include <TParticle.h>
  24
  25 #include "AliRun.h"
  26 #include "AliITS.h"
  27 #include "AliITShit.h"
  28 #include "AliITSdigitSPD.h"
  29 #include "AliITSmodule.h"
  30 #include "AliITSMapA2.h"
  31 #include "AliITSpList.h"
  32 #include "AliITSsimulationSPD.h"
  33 #include "AliITSsegmentation.h"
  34 #include "AliITSresponse.h"
  35 #include "AliITSsegmentationSPD.h"
  36 #include "AliITSresponseSPD.h"
  37 #include "AliLog.h"
  38
  39 //#define DEBUG
  40
  41 ClassImp(AliITSsimulationSPD)
  42 ////////////////////////////////////////////////////////////////////////
  43 // Version: 0
  44 // Written by Rocco Caliandro
  45 // from a model developed with T. Virgili and R.A. Fini
  46 // June 15 2000
  47 //
  48 // AliITSsimulationSPD is the simulation of SPDs
  49 //
  50 //______________________________________________________________________
  51 AliITSsimulationSPD::AliITSsimulationSPD() : AliITSsimulation(),
  52 fMapA2(0),
  53 fHis(0){
  54     // Default constructor
  55     // Inputs:
  56     //    none.
  57     // Outputs:
  58     //    none.
  59     // Return:
  60     //    A default constructed AliITSsimulationSPD class.
  61 }
  62 //______________________________________________________________________
  63 AliITSsimulationSPD::AliITSsimulationSPD(AliITSsegmentation *seg,
  64                                          AliITSresponse *res):
  65 AliITSsimulation(seg,res),
  66 fMapA2(0),
  67 fHis(0){
  68     // Standard constructor
  69     // Inputs:
  70     //    AliITSsegmentation *seg  Segmentation class to be used
  71     //    AliITSresonse      *res  Response class to be used
  72     // Outputs:
  73     //    none.
  74     // Return:
  75     //    A standard constructed AliITSsimulationSPD class.
  76
  77     Init();
  78 }
  79 //______________________________________________________________________
  80 void AliITSsimulationSPD::Init() {
  81     // Initilizes the variables of AliITSsimulation SPD.
  82     // Inputs:
  83     //    none.
  84     // Outputs:
  85     //    none.
  86     // Return:
  87     //    none.
  88
  89     fHis = 0;
  90     if(fMapA2) delete fMapA2;
  91     fMapA2  = new AliITSMapA2(fSegmentation);
  92     if(fpList) delete fpList;
  93     fpList  = new AliITSpList(GetNPixelsZ()+1,GetNPixelsX()+1);
  94 }
  95 //______________________________________________________________________
  96 void AliITSsimulationSPD::Init(AliITSsegmentationSPD *seg,
  97                                AliITSresponseSPD *resp) {
  98     // Initilizes the variables of AliITSsimulation SPD.
  99     // Inputs:
 100     //    AliITSsegmentationSPD   replacement segmentation class to be used
 101     //    aliITSresponseSPD       replacement response class to be used
 102     // Outputs:
 103     //    none.
 104     // Return:
 105     //    none.
 106
 107     if(fHis){
 108         fHis->Delete();
 109         delete fHis;
 110     } // end if fHis
 111     fHis = 0;
 112     if(fResponse) delete fResponse;
 113     fResponse     = resp;
 114     if(fSegmentation) delete fSegmentation;
 115     fSegmentation = seg;
 116     if(fMapA2) delete fMapA2;
 117     fMapA2  = new AliITSMapA2(fSegmentation);
 118     if(fpList) delete fpList;
 119     fpList  = new AliITSpList(GetNPixelsZ()+1,GetNPixelsX()+1);
 120 }
 121 //______________________________________________________________________
 122 AliITSsimulationSPD::~AliITSsimulationSPD() {
 123     // destructor
 124     // Inputs:
 125     //    none.
 126     // Outputs:
 127     //    none.
 128     // Return:
 129     //    none.
 130
 131     if(fMapA2) delete fMapA2;
 132
 133     if (fHis) {
 134         fHis->Delete();
 135         delete fHis;
 136     } // end if
 137 }
 138 //______________________________________________________________________
 139 AliITSsimulationSPD::AliITSsimulationSPD(const AliITSsimulationSPD &source) :
 140     AliITSsimulation(source){
 141     // Copy Constructor
 142     // Inputs:
 143     //    none.
 144     // Outputs:
 145     //    none.
 146     // Return:
 147     //    A new AliITSsimulationSPD class with the same parameters as source.
 148
 149     if(&source == this) return;
 150
 151     this->fMapA2    = source.fMapA2;
 152     this->fHis      = source.fHis;
 153     return;
 154 }
 155 //______________________________________________________________________
 156 AliITSsimulationSPD& AliITSsimulationSPD::operator=(const AliITSsimulationSPD
 157                                                     &source) {
 158     //    Assignment operator
 159     // Inputs:
 160     //    none.
 161     // Outputs:
 162     //    none.
 163     // Return:
 164     //    A new AliITSsimulationSPD class with the same parameters as source.
 165
 166     if(&source == this) return *this;
 167
 168     this->fMapA2    = source.fMapA2;
 169     this->fHis      = source.fHis;
 170     return *this;
 171 }
 172 //______________________________________________________________________
 173 AliITSsimulation& AliITSsimulationSPD::operator=(const AliITSsimulation
 174                                                     &source) {
 175     //    Assignment operator
 176     // Inputs:
 177     //    none.
 178     // Outputs:
 179     //    none.
 180     // Return:
 181     //    A new AliITSsimulationSPD class with the same parameters as source.
 182
 183     if(&source == this) return *this;
 184     Error("AliITSsimulationSPD","Not allowed to make a = with "
 185           "AliITSsimulationSPD Using default creater instead");
 186
 187     return *this;
 188 }
 189
 190 //______________________________________________________________________
 191 void AliITSsimulationSPD::InitSimulationModule(Int_t module,Int_t event){
 192     // Creates maps to build the list of tracks for each sumable digit
 193     // Inputs:
 194     //   Int_t module    // Module number to be simulated
 195     //   Int_t event     // Event number to be simulated
 196     // Outputs:
 197     //   none.
 198     // Return
 199     //    none.
 200
 201     fModule = module;
 202     fEvent  = event;
 203     fMapA2->ClearMap();
 204     fpList->ClearMap();
 205 }
 206 //______________________________________________________________________
 207 void AliITSsimulationSPD::FinishSDigitiseModule(){
 208     // Does the Sdigits to Digits work
 209     // Inputs:
 210     //   none.
 211     // Outputs:
 212     //   none.
 213     // Return:
 214     //   none.
 215
 216     SDigitsToDigits(fModule,fpList);
 217 }
 218 //______________________________________________________________________
 219 void AliITSsimulationSPD::SDigitiseModule(AliITSmodule *mod, Int_t dummy0,
 220                                              Int_t dummy1) {
 221     // Sum digitize module
 222     // Inputs:
 223     //   AliITSmodule  *mod    The module to be SDgitized
 224     //   Int_t         dummy0  Not used kept for general compatibility
 225     //   Int_t         dummy1  Not used kept for general compatibility
 226     // Outputs:
 227     //   none.
 228     // Return:
 229     //   none.
 230     if (!(mod->GetNhits())) return; // if module has no hits then no Sdigits.
 231     Int_t    number     = 10000;
 232     Int_t    *frowpixel = new Int_t[number];
 233     Int_t    *fcolpixel = new Int_t[number];
 234     Double_t *fenepixel = new Double_t[number];
 235
 236     dummy0 = dummy1; // remove unsued variable warning.
 237     fModule = mod->GetIndex();
 238
 239     // Array of pointers to store the track index of the digits
 240     // leave +1, otherwise pList crashes when col=256, row=192
 241
 242     HitsToAnalogDigits(mod,frowpixel,fcolpixel,fenepixel,fpList);
 243
 244     WriteSDigits(fpList);
 245
 246     // clean memory
 247     delete[] frowpixel;
 248     delete[] fcolpixel;
 249     delete[] fenepixel;
 250     fMapA2->ClearMap();
 251     fpList->ClearMap();
 252 }
 253 //______________________________________________________________________
 254 void AliITSsimulationSPD::DigitiseModule(AliITSmodule *mod, Int_t,Int_t) {
 255     // digitize module. Also need to digitize modules with only noise.
 256     // Inputs:
 257     //   AliITSmodule  *mod    The module to be SDgitized
 258     // Outputs:
 259     //   none.
 260     // Return:
 261     //   none.
 262
 263     Int_t    number     = 10000;
 264     Int_t    *frowpixel = new Int_t[number];
 265     Int_t    *fcolpixel = new Int_t[number];
 266     Double_t *fenepixel = new Double_t[number];
 267
 268     // Array of pointers to store the track index of the digits
 269     // leave +1, otherwise pList crashes when col=256, row=192
 270     fModule = mod->GetIndex();
 271     // noise setting
 272     SetFluctuations(fpList,fModule);
 273
 274     HitsToAnalogDigits(mod,frowpixel,fcolpixel,fenepixel,fpList);
 275
 276     // apply mask to SPD module
 277     SetMask();
 278
 279     CreateDigit(fModule,fpList);
 280
 281     // clean memory
 282     delete[] frowpixel;
 283     delete[] fcolpixel;
 284     delete[] fenepixel;
 285     fMapA2->ClearMap();
 286     fpList->ClearMap();
 287 }
 288 //______________________________________________________________________
 289 void AliITSsimulationSPD::SDigitsToDigits(Int_t module,AliITSpList *pList) {
 290     // sum digits to Digits.
 291     // Inputs:
 292     //   AliITSmodule  *mod    The module to be SDgitized
 293     //   AliITSpList   *pList  the array of SDigits
 294     // Outputs:
 295     //   AliITSpList   *pList  the array of SDigits
 296     // Return:
 297     //   none.
 298
 299     AliDebug(1,Form("Entering AliITSsimulatinSPD::SDigitsToDigits for module=%d",
 300                   module));
 301     fModule = module;
 302
 303     // noise setting
 304     SetFluctuations(pList,module);
 305
 306     fMapA2->ClearMap(); // since noise is in pList aready. Zero Map so that
 307     // noise is not doubled when calling FillMapFrompList.
 308
 309     FillMapFrompList(pList);
 310
 311     // apply mask to SPD module
 312     SetMask();
 313
 314     CreateDigit(module,pList);
 315
 316     fMapA2->ClearMap();
 317     pList->ClearMap();
 318 }
 319 //______________________________________________________________________
 320 void AliITSsimulationSPD::UpdateMapSignal(Int_t row,Int_t col,Int_t trk,
 321                                           Int_t hit,Int_t mod,Double_t ene,
 322                                           AliITSpList *pList) {
 323     // updates the Map of signal, adding the energy  (ene) released by
 324     // the current track
 325     // Inputs:
 326     //   Int_t         row  pixel row number
 327     //   Int_t         col  pixel column number
 328     //   Int_t         trk  track number which contributed
 329     //   Int_t         hit  hit number which contributed
 330     //   Int_t         mod  module number
 331     //   Double_t      ene  the energy associated with this contribution
 332     //   AliITSpList   *pList  the array of SDigits
 333     // Outputs:
 334     //   AliITSpList   *pList  the array of SDigits
 335     // Return:
 336     //   none.
 337
 338     fMapA2->AddSignal(row,col,ene);
 339     pList->AddSignal(row,col,trk,hit,mod,ene);
 340 }
 341 //______________________________________________________________________
 342 void AliITSsimulationSPD::UpdateMapNoise(Int_t row,Int_t col,Int_t mod,
 343                                          Double_t ene,AliITSpList *pList) {
 344     // updates the Map of noise, adding the energy  (ene) give my noise
 345     // Inputs:
 346     //   Int_t         row  pixel row number
 347     //   Int_t         col  pixel column number
 348     //   Int_t         mod  module number
 349     //   Double_t      ene  the energy associated with this contribution
 350     //   AliITSpList   *pList  the array of SDigits
 351     // Outputs:
 352     //   AliITSpList   *pList  the array of SDigits
 353     // Return:
 354     //   none.
 355
 356     fMapA2->AddSignal(row,col,ene);
 357     pList->AddNoise(row,col,mod,ene);
 358 }
 359 //______________________________________________________________________
 360 void AliITSsimulationSPD::HitsToAnalogDigits(AliITSmodule *mod,
 361                                              Int_t *frowpixel,Int_t *fcolpixel,
 362                                              Double_t *fenepixel,
 363                                              AliITSpList *pList) {
 364     // Loops over all hits to produce Analog/floting point digits. This
 365     // is also the first task in producing standard digits.
 366     // Inputs:
 367     //   AliITSmodule  *mod        module class
 368     //   Int_t         *frowpixel  array of pixel rows
 369     //   Int_t         *fcolpixel  array of pixel columns
 370     //   Double_t      *fenepiexel array of pixel energies
 371     //   AliITSpList   *pList  the array of SDigits
 372     // Outputs:
 373     //   AliITSpList   *pList  the array of SDigits
 374     // Return:
 375     //   none.
 376
 377     // loop over hits in the module
 378     Int_t hitpos,nhits = mod->GetNhits();
 379     for (hitpos=0;hitpos<nhits;hitpos++) {
 380         HitToDigit(mod,hitpos,frowpixel,fcolpixel,fenepixel,pList);
 381     }// end loop over digits
 382 }
 383 //______________________________________________________________________
 384 void AliITSsimulationSPD::HitToDigit(AliITSmodule *mod,Int_t hitpos,
 385                                      Int_t *frowpixel,Int_t *fcolpixel,
 386                                      Double_t *fenepixel,AliITSpList *pList) {
 387     //  Steering function to determine the digits associated to a given
 388     // hit (hitpos)
 389     // The digits are created by charge sharing (ChargeSharing) and by
 390     // capacitive coupling (SetCoupling). At all the created digits is
 391     // associated the track number of the hit (ntrack)
 392     // Inputs:
 393     //   AliITSmodule  *mod        module class
 394     //   Int_t         hitpos      hit index value
 395     //   Int_t         *frowpixel  array of pixel rows
 396     //   Int_t         *fcolpixel  array of pixel columns
 397     //   Double_t      *fenepiexel array of pixel energies
 398     //   AliITSpList   *pList  the array of SDigits
 399     // Outputs:
 400     //   AliITSpList   *pList  the array of SDigits
 401     // Return:
 402     //   none.
 403     Double_t x1l=0.0,y1l=0.0,z1l=0.0,x2l=0.0,y2l=0.0,z2l=0.0;
 404     Int_t r1,r2,c1,c2,row,col,npixel = 0;
 405     Int_t ntrack;
 406     Double_t ene=0.0,etot=0.0;
 407     const Float_t kconv = 10000.;     // cm -> microns
 408     const Float_t kconv1= 0.277e9;    // GeV -> electrons equivalent
 409
 410     if(!(mod->LineSegmentL(hitpos,x1l,x2l,y1l,y2l,z1l,z2l,etot,ntrack)))return;
 411
 412     x2l += x1l; y2l += y1l; z2l += z1l; // Convert to ending coordinate.
 413     // positions shifted and converted in microns
 414     x1l   = x1l*kconv + fSegmentation->Dx()/2.;
 415     z1l   = z1l*kconv + fSegmentation->Dz()/2.;
 416     // positions  shifted and converted in microns
 417     x2l   = x2l*kconv + fSegmentation->Dx()/2.;
 418     z2l   = z2l*kconv + fSegmentation->Dz()/2.;
 419     etot *= kconv1; // convert from GeV to electrons equivalent.
 420     Int_t module = mod->GetIndex();
 421
 422     // to account for the effective sensitive area
 423     // introduced in geometry
 424     if (z1l<0 || z1l>fSegmentation->Dz()) return;
 425     if (z2l<0 || z2l>fSegmentation->Dz()) return;
 426     if (x1l<0 || x1l>fSegmentation->Dx()) return;
 427     if (x2l<0 || x2l>fSegmentation->Dx()) return;
 428
 429     //Get the col and row number starting from 1
 430     // the x direction is not inverted for the second layer!!!
 431     fSegmentation->GetPadIxz(x1l, z1l, c1, r1);
 432     fSegmentation->GetPadIxz(x2l, z2l, c2, r2);
 433
 434     // to account for unexpected equal entrance and
 435     // exit coordinates
 436     if (x1l==x2l) x2l=x2l+x2l*0.1;
 437     if (z1l==z2l) z2l=z2l+z2l*0.1;
 438
 439     if ((r1==r2) && (c1==c2)){
 440         // no charge sharing
 441         npixel = 1;
 442         frowpixel[npixel-1] = r1;
 443         fcolpixel[npixel-1] = c1;
 444         fenepixel[npixel-1] = etot;
 445     } else {
 446         // charge sharing
 447         ChargeSharing(x1l,z1l,x2l,z2l,c1,r1,c2,r2,etot,
 448                       npixel,frowpixel,fcolpixel,fenepixel);
 449     } // end if r1==r2 && c1==c2.
 450
 451     for (Int_t npix=0;npix<npixel;npix++){
 452         row = frowpixel[npix];
 453         col = fcolpixel[npix];
 454         ene = fenepixel[npix];
 455         UpdateMapSignal(row,col,ntrack,hitpos,module,ene,pList);
 456         // Starting capacitive coupling effect
 457         SetCoupling(row,col,ntrack,hitpos,module,pList);
 458     } // end for npix
 459 }
 460 //______________________________________________________________________
 461 void AliITSsimulationSPD::ChargeSharing(Float_t x1l,Float_t z1l,Float_t x2l,
 462                                         Float_t z2l,Int_t c1,Int_t r1,Int_t c2,
 463                                         Int_t r2,Float_t etot,
 464                                         Int_t &npixel,Int_t *frowpixel,
 465                                         Int_t *fcolpixel,Double_t *fenepixel){
 466     //  Take into account the geometrical charge sharing when the track
 467     //  crosses more than one pixel.
 468     // Inputs:
 469     //    Float_t  x1l
 470     //    Float_t  z1l
 471     //    Float_t  x2l
 472     //    Float_t  z2l
 473     //    Int_t    c1
 474     //    Int_t    r1
 475     //    Int_t    c2
 476     //    Int_t    r2
 477     //    Float_t  etot
 478     //    Int_t    &npixel
 479     //   Int_t     *frowpixel  array of pixel rows
 480     //   Int_t     *fcolpixel  array of pixel columns
 481     //   Double_t  *fenepiexel array of pixel energies
 482     // Outputs:
 483     //    Int_t    &npixel
 484     // Return:
 485     //   none.
 486     //
 487     //Begin_Html
 488     /*
 489       <img src="picts/ITS/barimodel_2.gif">
 490       </pre>
 491       <br clear=left>
 492       <font size=+2 color=red>
 493       <a href="mailto:Rocco.Caliandro@ba.infn.it"></a>.
 494       </font>
 495       <pre>
 496     */
 497     //End_Html
 498     //Float_t dm;
 499     Float_t xa,za,xb,zb,dx,dz,dtot,refr,refm,refc;
 500     Float_t refn=0.;
 501     Float_t arefm, arefr, arefn, arefc, azb, az2l, axb, ax2l;
 502     Int_t   dirx,dirz,rb,cb;
 503     Int_t flag,flagrow,flagcol;
 504     Double_t epar;
 505
 506     npixel = 0;
 507     xa     = x1l;
 508     za     = z1l;
 509 //    dx     = x1l-x2l;
 510 //    dz     = z1l-z2l;
 511     dx     = x2l-x1l;
 512     dz     = z2l-z1l;
 513     dtot   = TMath::Sqrt((dx*dx)+(dz*dz));
 514     if (dtot==0.0) dtot = 0.01;
 515     dirx   = (Int_t) TMath::Sign((Float_t)1,dx);
 516     dirz   = (Int_t) TMath::Sign((Float_t)1,dz);
 517
 518     // calculate the x coordinate of  the pixel in the next column
 519     // and the z coordinate of  the pixel in the next row
 520     Float_t xpos, zpos;
 521
 522     fSegmentation->GetPadCxz(c1, r1-1, xpos, zpos);
 523
 524     Float_t xsize = fSegmentation->Dpx(0);
 525     Float_t zsize = fSegmentation->Dpz(r1-1);
 526
 527     if (dirx == 1) refr = xpos+xsize/2.;
 528     else refr = xpos-xsize/2.;
 529
 530     if (dirz == 1) refn = zpos+zsize/2.;
 531     else refn = zpos-zsize/2.;
 532
 533     flag = 0;
 534     flagrow = 0;
 535     flagcol = 0;
 536     do{
 537         // calculate the x coordinate of the intersection with the pixel
 538         // in the next cell in row  direction
 539         if(dz!=0)
 540             refm = dx*((refn - z1l)/dz) + x1l;
 541         else
 542             refm = refr+dirx*xsize;
 543
 544         // calculate the z coordinate of the intersection with the pixel
 545         // in the next cell in column direction
 546         if (dx!=0)
 547             refc = dz*((refr - x1l)/dx) + z1l;
 548         else
 549             refc = refn+dirz*zsize;
 550
 551         arefm = refm * dirx;
 552         arefr = refr * dirx;
 553         arefn = refn * dirz;
 554         arefc = refc * dirz;
 555
 556         if ((arefm < arefr) && (arefn < arefc)){
 557             // the track goes in the pixel in the next cell in row direction
 558             xb = refm;
 559             zb = refn;
 560             cb = c1;
 561             rb = r1 + dirz;
 562             azb = zb * dirz;
 563             az2l = z2l * dirz;
 564             if (rb == r2) flagrow=1;
 565             if (azb > az2l) {
 566                 zb = z2l;
 567                 xb = x2l;
 568             } // end if
 569             // shift to the pixel in the next cell in row direction
 570             Float_t zsizeNext = fSegmentation->Dpz(rb-1);
 571             //to account for cell at the borders of the detector
 572             if(zsizeNext==0) zsizeNext = zsize;
 573             refn += zsizeNext*dirz;
 574         }else {
 575             // the track goes in the pixel in the next cell in column direction
 576             xb = refr;
 577             zb = refc;
 578             cb = c1 + dirx;
 579             rb = r1;
 580             axb = xb * dirx;
 581             ax2l = x2l * dirx;
 582             if (cb == c2) flagcol=1;
 583             if (axb > ax2l) {
 584                 zb = z2l;
 585                 xb = x2l;
 586             } // end ifaxb > ax2l
 587
 588             // shift to the pixel in the next cell in column direction
 589             Float_t xsizeNext = fSegmentation->Dpx(cb-1);
 590             //to account for cell at the borders of the detector
 591             if(xsizeNext==0) xsizeNext = xsize;
 592             refr += xsizeNext*dirx;
 593         } // end if (arefm < arefr) && (arefn < arefc)
 594
 595         //calculate the energy lost in the crossed pixel
 596         epar = TMath::Sqrt((xb-xa)*(xb-xa)+(zb-za)*(zb-za));
 597         epar = etot*(epar/dtot);
 598
 599         //store row, column and energy lost in the crossed pixel
 600         frowpixel[npixel] = r1;
 601         fcolpixel[npixel] = c1;
 602         fenepixel[npixel] = epar;
 603         npixel++;
 604
 605         // the exit point of the track is reached
 606         if (epar == 0) flag = 1;
 607         if ((r1 == r2) && (c1 == c2)) flag = 1;
 608         if (flag!=1) {
 609             r1 = rb;
 610             c1 = cb;
 611             xa = xb;
 612             za = zb;
 613         } // end if flag!=1
 614     } while (flag==0);
 615 }
 616 //______________________________________________________________________
 617 void AliITSsimulationSPD::SetCoupling(Int_t row, Int_t col, Int_t ntrack,
 618                                       Int_t idhit,Int_t module,
 619                                       AliITSpList *pList) {
 620     //  Take into account the coupling between adiacent pixels.
 621     //  The parameters probcol and probrow are the probability of the
 622     //  signal in one pixel shared in the two adjacent pixels along
 623     //  the column and row direction, respectively.
 624     // Inputs:
 625     //    Int_t      row    pixel row number
 626     //    Int_t      col     pixel column number
 627     //    Int_t      ntrack  track number of track contributing to this signal
 628     //    Int_t      idhit   hit number of hit contributing to this signal
 629     //    Int_t      module  module number
 630     //   AliITSpList *pList  the array of SDigits
 631     // Outputs:
 632     //   AliITSpList *pList  the array of SDigits
 633     // Return:
 634     //   none.
 635     //
 636     //Begin_Html
 637     /*
 638       <img src="picts/ITS/barimodel_3.gif">
 639       </pre>
 640       <br clear=left>
 641       <font size=+2 color=red>
 642       <a href="mailto:tiziano.virgili@cern.ch"></a>.
 643       </font>
 644       <pre>
 645     */
 646     //End_Html
 647     Int_t j1,j2,flag=0;
 648     Double_t pulse1,pulse2;
 649     Double_t couplR=0.0,couplC=0.0;
 650     Double_t xr=0.;
 651
 652     GetCouplings(couplR,couplC);
 653     j1 = row;
 654     j2 = col;
 655     pulse1 = fMapA2->GetSignal(row,col);
 656     pulse2 = pulse1;
 657     for (Int_t isign=-1;isign<=1;isign+=2){// loop in row direction
 658         do{
 659             j1 += isign;
 660             //   pulse1 *= couplR;
 661             xr = gRandom->Rndm();
 662             //if ((j1<0) || (j1>GetNPixelsZ()-1) || (pulse1<GetThreshold())){
 663             if ((j1<0) || (j1>GetNPixelsZ()-1) || (xr>couplR)){
 664                 j1 = row;
 665                 flag = 1;
 666             }else{
 667                 UpdateMapSignal(j1,col,ntrack,idhit,module,pulse1,pList);
 668                 //  flag = 0;
 669                 flag = 1; // only first next!!
 670             } // end if
 671         } while(flag == 0);
 672         // loop in column direction
 673         do{
 674             j2 += isign;
 675             // pulse2 *= couplC;
 676             xr = gRandom->Rndm();
 677             //if ((j2<0) || (j2>(GetNPixelsX()-1)) || (pulse2<GetThreshold())){
 678             if ((j2<0) || (j2>GetNPixelsX()-1) || (xr>couplC)){
 679                 j2 = col;
 680                 flag = 1;
 681             }else{
 682                 UpdateMapSignal(row,j2,ntrack,idhit,module,pulse2,pList);
 683                 //  flag = 0;
 684                 flag = 1; // only first next!!
 685             } // end if
 686         } while(flag == 0);
 687     } // for isign
 688 }
 689 //______________________________________________________________________
 690 void AliITSsimulationSPD::SetCouplingOld(Int_t row, Int_t col, Int_t ntrack,
 691                                          Int_t idhit,Int_t module,
 692                                          AliITSpList *pList) {
 693     //  Take into account the coupling between adiacent pixels.
 694     //  The parameters probcol and probrow are the fractions of the
 695     //  signal in one pixel shared in the two adjacent pixels along
 696     //  the column and row direction, respectively.
 697     // Inputs:
 698     //    Int_t    row    pixel row number
 699     //    Int_t    col    pixel column number
 700     //    Int_t    ntrack track number of track contributing to this pixel
 701     //    Int_t    idhit  hit index number of hit contributing to this pixel
 702     //    Int_t    module module number
 703     //   AliITSpList   *pList  the array of SDigits
 704     // Outputs:
 705     //   AliITSpList   *pList  the array of SDigits
 706     // Return:
 707     //   none.
 708     //
 709     //Begin_Html
 710     /*
 711       <img src="picts/ITS/barimodel_3.gif">
 712       </pre>
 713       <br clear=left>
 714       <font size=+2 color=red>
 715       <a href="mailto:Rocco.Caliandro@ba.infn.it"></a>.
 716       </font>
 717       <pre>
 718     */
 719     //End_Html
 720     Int_t j1,j2,flag=0;
 721     Double_t pulse1,pulse2;
 722     Double_t couplR=0.0,couplC=0.0;
 723
 724     GetCouplings(couplR,couplC);
 725     j1 = row;
 726     j2 = col;
 727     pulse1 = fMapA2->GetSignal(row,col);
 728     pulse2 = pulse1;
 729     for (Int_t isign=-1;isign<=1;isign+=2){// loop in row direction
 730         do{
 731             j1 += isign;
 732             pulse1 *= couplR;
 733             if ((j1<0) || (j1>GetNPixelsZ()-1) || (pulse1<GetThreshold())){
 734                 pulse1 = fMapA2->GetSignal(row,col);
 735                 j1 = row;
 736                 flag = 1;
 737             }else{
 738                 UpdateMapSignal(j1,col,ntrack,idhit,module,pulse1,pList);
 739                 flag = 0;
 740             } // end if
 741         } while(flag == 0);
 742         // loop in column direction
 743         do{
 744             j2 += isign;
 745             pulse2 *= couplC;
 746             if ((j2<0) || (j2>(GetNPixelsX()-1)) || (pulse2<GetThreshold())){
 747                 pulse2 = fMapA2->GetSignal(row,col);
 748                 j2 = col;
 749                 flag = 1;
 750             }else{
 751                 UpdateMapSignal(row,j2,ntrack,idhit,module,pulse2,pList);
 752                 flag = 0;
 753             } // end if
 754         } while(flag == 0);
 755     } // for isign
 756 }
 757 //______________________________________________________________________
 758 void AliITSsimulationSPD::CreateDigit(Int_t module,AliITSpList *pList) {
 759     // The pixels are fired if the energy deposited inside them is above
 760     // the threshold parameter ethr. Fired pixed are interpreted as digits
 761     // and stored in the file digitfilename. One also needs to write out
 762     // cases when there is only noise (nhits==0).
 763     // Inputs:
 764     //    Int_t    module
 765     //   AliITSpList   *pList  the array of SDigits
 766     // Outputs:
 767     //   AliITSpList   *pList  the array of SDigits
 768     // Return:
 769     //   none.
 770
 771     static AliITS *aliITS  = (AliITS*)gAlice->GetModule("ITS");
 772
 773     Int_t size = AliITSdigitSPD::GetNTracks();
 774     Int_t * digits = new Int_t[size];
 775     Int_t * tracks = new Int_t[size];
 776     Int_t * hits = new Int_t[size];
 777     Float_t * charges = new Float_t[size];
 778     Int_t j1;
 779
 780     module=0; // remove unused variable warning.
 781     for(j1=0;j1<size;j1++){tracks[j1]=-3;hits[j1]=-1;charges[j1]=0.0;}
 782     for (Int_t r=1;r<=GetNPixelsZ();r++) {
 783         for (Int_t c=1;c<=GetNPixelsX();c++) {
 784             // check if the deposited energy in a pixel is above the
 785             // threshold
 786             Float_t signal = (Float_t) fMapA2->GetSignal(r,c);
 787             if ( signal > GetThreshold()) {
 788                 digits[0] = r-1;  // digits starts from 0
 789                 digits[1] = c-1;  // digits starts from 0
 790                 //digits[2] = 1;
 791                 digits[2] =  (Int_t) signal;  // the signal is stored in
 792                                               //  electrons
 793                 for(j1=0;j1<size;j1++){
 794                     if(j1<pList->GetNEnteries()){
 795                         tracks[j1] = pList->GetTrack(r,c,j1);
 796                         hits[j1]   = pList->GetHit(r,c,j1);
 797                         //}else{
 798                         //tracks[j1] = -3;
 799                         //hits[j1]   = -1;
 800                     } // end if
 801                     //charges[j1] = 0;
 802                 } // end for j1
 803                 Float_t phys = 0;
 804                 aliITS->AddSimDigit(0,phys,digits,tracks,hits,charges);
 805                 AliDebug(1,Form("mod=%d r,c=%d,%d sig=%f noise=%f Msig=%d Thres=%f",
 806                                 fModule,r,c,fpList->GetSignalOnly(r,c),fpList->GetNoise(r,c),
 807                                 signal,GetThreshold()));
 808             } // end if of threshold condition
 809         } // for c
 810     }// end do on pixels
 811     delete [] digits;
 812     delete [] tracks;
 813     delete [] hits;
 814     delete [] charges;
 815 }
 816 //______________________________________________________________________
 817 void AliITSsimulationSPD::SetFluctuations(AliITSpList *pList,Int_t module) {
 818     //  Set the electronic noise and threshold non-uniformities to all the
 819     //  pixels in a detector.
 820     //  The parameter fSigma is the squared sum of the sigma due to noise
 821     //  and the sigma of the threshold distribution among pixels.
 822     // Inputs:
 823     //    Int_t      module  modulel number
 824     //   AliITSpList *pList  the array of SDigits
 825     // Outputs:
 826     //   AliITSpList *pList  the array of SDigits
 827     // Return:
 828     //   none.
 829     //
 830     //Begin_Html
 831     /*
 832       <img src="picts/ITS/barimodel_1.gif">
 833       </pre>
 834       <br clear=left>
 835       <font size=+2 color=red>
 836       <a href="mailto:Rocco.Caliandro@ba.infn.it"></a>.
 837       </font>
 838       <pre>
 839     */
 840     //End_Html
 841     Double_t  thr=0.0,sigm=0.0;
 842     Double_t signal,sigma;
 843     Int_t iz,ix;
 844
 845     GetThresholds(thr,sigm);
 846     sigma = (Double_t) sigm;
 847     for(iz=1;iz<=GetNPixelsZ();iz++){
 848         for(ix=1;ix<=GetNPixelsX();ix++){
 849             signal = sigma*gRandom->Gaus();
 850             fMapA2->SetHit(iz,ix,signal);
 851             // insert in the label-signal-hit list the pixels fired
 852             // only by noise
 853             pList->AddNoise(iz,ix,module,signal);
 854         } // end of loop on pixels
 855     } // end of loop on pixels
 856 }
 857 //______________________________________________________________________
 858 void AliITSsimulationSPD::SetMask() {
 859     //  Apply a mask to the SPD module. 1% of the pixel channels are
 860     //  masked. When the database will be ready, the masked pixels
 861     //  should be read from it.
 862     // Inputs:
 863     //   none.
 864     // Outputs:
 865     //   none.
 866     // Return:
 867     //   none.
 868     Double_t signal;
 869     Int_t iz,ix,im;
 870     Float_t totMask;
 871     Float_t perc = ((AliITSresponseSPD*)fResponse)->GetFractionDead();
 872     // in this way we get the same set of random numbers for all runs.
 873     // This is a cluge for now.
 874     static TRandom *rnd = new TRandom();
 875
 876     totMask= perc*GetNPixelsZ()*GetNPixelsX();
 877     for(im=1;im<totMask;im++){
 878         do{
 879             ix=(Int_t)(rnd->Rndm()*(GetNPixelsX()-1.) + 1.);
 880         } while(ix<=0 || ix>GetNPixelsX());
 881         do{
 882             iz=(Int_t)(rnd->Rndm()*(GetNPixelsZ()-1.) + 1.);
 883         } while(iz<=0 || iz>GetNPixelsZ());
 884         signal = -1.;
 885         fMapA2->SetHit(iz,ix,signal);
 886     } // end loop on masked pixels
 887 }
 888 //______________________________________________________________________
 889 void AliITSsimulationSPD::CreateHistograms() {
 890     // Create Histograms
 891     // Inputs:
 892     //   none.
 893     // Outputs:
 894     //   none.
 895     // Return:
 896     //   none.
 897     Int_t i;
 898
 899     fHis=new TObjArray(GetNPixelsZ());
 900     for(i=0;i<GetNPixelsZ();i++) {
 901         TString spdname("spd_");
 902         Char_t candnum[4];
 903         sprintf(candnum,"%d",i+1);
 904         spdname.Append(candnum);
 905         (*fHis)[i] = new TH1F(spdname.Data(),"SPD maps",
 906                               GetNPixelsX(),0.,(Float_t) GetNPixelsX());
 907     } // end for i
 908 }
 909 //______________________________________________________________________
 910 void AliITSsimulationSPD::ResetHistograms() {
 911     // Reset histograms for this detector
 912     // Inputs:
 913     //   none.
 914     // Outputs:
 915     //   none.
 916     // Return:
 917     //   none.
 918     Int_t i;
 919
 920     for(i=0;i<GetNPixelsZ();i++ ) {
 921         if ((*fHis)[i])    ((TH1F*)(*fHis)[i])->Reset();
 922     } // end for i
 923 }
 924 //______________________________________________________________________
 925 void AliITSsimulationSPD::WriteSDigits(AliITSpList *pList){
 926     // Fills the Summable digits Tree
 927     // Inputs:
 928     //   AliITSpList   *pList  the array of SDigits
 929     // Outputs:
 930     //   AliITSpList   *pList  the array of SDigits
 931     // Return:
 932     //   none.
 933     Int_t i,ni,j,nj;
 934     static AliITS *aliITS = (AliITS*)gAlice->GetModule("ITS");
 935
 936     pList->GetMaxMapIndex(ni,nj);
 937     for(i=0;i<ni;i++)for(j=0;j<nj;j++){
 938         if(pList->GetSignalOnly(i,j)>0.0){
 939             aliITS->AddSumDigit(*(pList->GetpListItem(i,j)));
 940             if(AliDebugLevel()>0){
 941                 cout << "pListSPD: " << *(pList->GetpListItem(i,j)) << endl;
 942                 AliDebug(1,Form("mod=%d r,c=%d %d sig=%f noise=%f",
 943                                 fModule,i,j,fpList->GetSignalOnly(i,j),fpList->GetNoise(i,j)))
 944             } //  end if GetDebug
 945         } // end if
 946     } // end for i,j
 947     return;
 948 }
 949 //______________________________________________________________________
 950 void AliITSsimulationSPD::FillMapFrompList(AliITSpList *pList){
 951     // Fills fMap2A from the pList of Summable digits
 952     // Inputs:
 953     //   AliITSpList   *pList  the array of SDigits
 954     // Outputs:
 955     //   AliITSpList   *pList  the array of SDigits
 956     // Return:
 957     //   none.
 958     Int_t ix,iz;
 959
 960     for(iz=0;iz<GetNPixelsZ();iz++)for(ix=0;ix<GetNPixelsX();ix++)
 961         fMapA2->AddSignal(iz,ix,pList->GetSignal(iz,ix));
 962     return;
 963 }