ITS/AliITSsimulationSPD.cxx

   1 #include <iostream.h>
   2 #include <TRandom.h>
   3 #include <TH1.h>
   4 #include <TMath.h>
   5 #include <TString.h>
   6 #include <TParticle.h>
   7
   8
   9 #include "AliRun.h"
  10 #include "AliITS.h"
  11 #include "AliITShit.h"
  12 #include "AliITSdigit.h"
  13 #include "AliITSmodule.h"
  14 #include "AliITSMapA2.h"
  15 #include "AliITSsimulationSPD.h"
  16 #include "AliITSsegmentation.h"
  17 #include "AliITSresponse.h"
  18
  19
  20 ClassImp(AliITSsimulationSPD)
  21 ////////////////////////////////////////////////////////////////////////
  22 // Version: 0
  23 // Written by Rocco Caliandro
  24 // from a model developed with T. Virgili and R.A. Fini
  25 // June 15 2000
  26 //
  27 // AliITSsimulationSPD is the simulation of SPDs
  28 //
  29 //________________________________________________________________________
  30
  31 AliITSsimulationSPD::AliITSsimulationSPD(){
  32   // constructor
  33   fResponse     = 0;
  34   fSegmentation = 0;
  35   fHis          = 0;
  36   fThresh       = 0.;
  37   fSigma        = 0.;
  38   fCouplCol     = 0.;
  39   fCouplRow     = 0.;
  40 }
  41 //_____________________________________________________________________________
  42
  43 AliITSsimulationSPD::AliITSsimulationSPD(AliITSsegmentation *seg, AliITSresponse *resp) {
  44   // constructor
  45       fResponse = resp;
  46       fSegmentation = seg;
  47
  48       fResponse->Thresholds(fThresh,fSigma);
  49       fResponse->GetNoiseParam(fCouplCol,fCouplRow);
  50
  51       fMapA2 = new AliITSMapA2(fSegmentation);
  52
  53       //
  54       fNPixelsZ=fSegmentation->Npz();
  55       fNPixelsX=fSegmentation->Npx();
  56       fHis=0;
  57 }
  58
  59 //_____________________________________________________________________________
  60
  61 AliITSsimulationSPD::~AliITSsimulationSPD() {
  62   // destructor
  63
  64   delete fMapA2;
  65
  66   if (fHis) {
  67      fHis->Delete();
  68      delete fHis;
  69   }
  70 }
  71
  72 //__________________________________________________________________________
  73 AliITSsimulationSPD::AliITSsimulationSPD(const AliITSsimulationSPD &source){
  74   //     Copy Constructor
  75   if(&source == this) return;
  76   this->fMapA2 = source.fMapA2;
  77   this->fThresh = source.fThresh;
  78   this->fSigma = source.fSigma;
  79   this->fCouplCol = source.fCouplCol;
  80   this->fCouplRow = source.fCouplRow;
  81   this->fNPixelsX = source.fNPixelsX;
  82   this->fNPixelsZ = source.fNPixelsZ;
  83   this->fHis = source.fHis;
  84   return;
  85 }
  86
  87 //_________________________________________________________________________
  88 AliITSsimulationSPD&
  89   AliITSsimulationSPD::operator=(const AliITSsimulationSPD &source) {
  90   //    Assignment operator
  91   if(&source == this) return *this;
  92   this->fMapA2 = source.fMapA2;
  93   this->fThresh = source.fThresh;
  94   this->fSigma = source.fSigma;
  95   this->fCouplCol = source.fCouplCol;
  96   this->fCouplRow = source.fCouplRow;
  97   this->fNPixelsX = source.fNPixelsX;
  98   this->fNPixelsZ = source.fNPixelsZ;
  99   this->fHis = source.fHis;
 100   return *this;
 101   }
 102 //_____________________________________________________________________________
 103
 104 void AliITSsimulationSPD::DigitiseModule(AliITSmodule *mod, Int_t module,
 105                                              Int_t dummy) {
 106   // digitize module
 107
 108
 109   TObjArray *fHits = mod->GetHits();
 110   Int_t nhits = fHits->GetEntriesFast();
 111   if (!nhits) return;
 112
 113
 114   //printf("Module %d (%d hits) \n",module+1,nhits);
 115
 116
 117   Int_t  number=10000;
 118   Int_t    *frowpixel = new Int_t[number];
 119   Int_t    *fcolpixel = new Int_t[number];
 120   Double_t *fenepixel = new Double_t[number];
 121
 122   // Array of pointers to store the track index of the digits
 123   // leave +1, otherwise pList crashes when col=256, row=192
 124     Int_t maxNdigits = fNPixelsX*fNPixelsZ+fNPixelsX+1;
 125   Float_t  **pList = new Float_t* [maxNdigits];
 126   memset(pList,0,sizeof(Float_t*)*maxNdigits);
 127
 128
 129   // noise setting
 130   SetFluctuations(pList);
 131
 132
 133
 134   // loop over hits in the module
 135   Int_t hitpos;
 136   for (hitpos=0;hitpos<nhits;hitpos++) {
 137      HitToDigit(mod,hitpos,module,frowpixel,fcolpixel,fenepixel,pList);
 138   }// end loop over digits
 139
 140   CreateDigit(nhits,module,pList);
 141
 142   // clean memory
 143   delete[] frowpixel;
 144   delete[] fcolpixel;
 145   delete[] fenepixel;
 146   fMapA2->ClearMap();
 147   delete [] pList;
 148
 149 }
 150 //_____________________________________________________________________________
 151
 152 void AliITSsimulationSPD::UpdateMap( Int_t row, Int_t col, Double_t ene) {
 153 //
 154 // updates the Map of signal, adding the energy  (ene) released by the current track
 155 //
 156       Double_t signal;
 157       signal = fMapA2->GetSignal(row,col);
 158       signal += ene;
 159       fMapA2->SetHit(row,col,signal);
 160
 161  }
 162 //_____________________________________________________________________________
 163 void AliITSsimulationSPD::HitToDigit(AliITSmodule *mod, Int_t hitpos, Int_t module,
 164                                         Int_t *frowpixel, Int_t *fcolpixel,
 165                                         Double_t *fenepixel, Float_t **pList) {
 166 //
 167 //  Steering function to determine the digits associated to a given hit (hitpos)
 168 //  The digits are created by charge sharing (ChargeSharing) and by
 169 //  capacitive coupling (SetCoupling). At all the created digits is associated
 170 //  the track number of the hit (ntrack)
 171 //
 172
 173
 174    static Float_t x1l,y1l,z1l;
 175    Float_t x2l,y2l,z2l,etot;
 176    Int_t layer,r1,r2,c1,c2,row,col,npixel = 0;
 177    Int_t ntrack,idhit;
 178    Double_t ene;
 179    const Float_t kconv = 10000.;     // cm -> microns
 180    const Float_t kconv1= 0.277e9;     // GeV -> electrons equivalent
 181
 182    TObjArray *fHits = mod->GetHits();
 183    AliITShit *hit = (AliITShit*) fHits->At(hitpos);
 184    layer = hit->GetLayer();
 185    etot=kconv1*hit->GetIonization();
 186    ntrack=hit->GetTrack();
 187    idhit=mod->GetHitHitIndex(hitpos);
 188
 189
 190     /*
 191     printf("\n layer,etot,ntrack,status %d %f %d %d\n",layer,etot,ntrack,hit->GetTrackStatus()); //debug
 192     Int_t idtrack; //debug
 193     mod->GetHitTrackAndHitIndex(hitpos,idtrack,idhit);
 194     printf("idtrack,idhit %d %d\n",idtrack,idhit); //debug
 195     printf("(Dx, Dz)=(%f, %f)\n",fSegmentation->Dx(),fSegmentation->Dz()); //debug
 196     */
 197
 198
 199
 200         if (hit->GetTrackStatus()==66) {
 201               hit->GetPositionL(x1l,y1l,z1l);
 202           // positions shifted and converted in microns
 203           x1l = x1l*kconv + fSegmentation->Dx()/2.;
 204           z1l = z1l*kconv + fSegmentation->Dz()/2.;
 205           //printf("(x1l, z2l)=(%f, %f)\n",x1l,z1l); //debug
 206         }
 207         else {
 208               hit->GetPositionL(x2l,y2l,z2l);
 209           // positions  shifted and converted in microns
 210           x2l = x2l*kconv + fSegmentation->Dx()/2.;
 211           z2l = z2l*kconv + fSegmentation->Dz()/2.;
 212           //printf("(x2l, z2l)=(%f, %f)\n",x2l,z2l); //debug
 213
 214
 215
 216           // to account for the effective sensitive area
 217           // introduced in geometry
 218           if (z1l<0 || z1l>fSegmentation->Dz()) return;
 219           if (z2l<0 || z2l>fSegmentation->Dz()) return;
 220           if (x1l<0 || x1l>fSegmentation->Dx()) return;
 221           if (x2l<0 || x2l>fSegmentation->Dx()) return;
 222
 223           //Get the col and row number starting from 1
 224           // the x direction is not inverted for the second layer!!!
 225               fSegmentation->GetPadIxz(x1l, z1l, c1, r1);
 226               fSegmentation->GetPadIxz(x2l, z2l, c2, r2);
 227
 228           //printf("(c1, r1)=(%d, %d) (c2, r2)=(%d, %d)\n",c1,r1,c2,r2); //debug
 229
 230           // to account for unexpected equal entrance and
 231           // exit coordinates
 232           if (x1l==x2l) x2l=x2l+x2l*0.000001;
 233           if (z1l==z2l) z2l=z2l+z2l*0.000001;
 234
 235
 236               if ((r1==r2) && (c1==c2))
 237               {
 238              // no charge sharing
 239                  npixel = 1;
 240                      frowpixel[npixel-1] = r1;
 241                      fcolpixel[npixel-1] = c1;
 242                      fenepixel[npixel-1] = etot;
 243           }
 244               else {
 245              // charge sharing
 246                  ChargeSharing(x1l,z1l,x2l,z2l,c1,r1,c2,r2,etot,
 247                                        npixel,frowpixel,fcolpixel,fenepixel);
 248
 249           }
 250
 251
 252           for (Int_t npix=0;npix<npixel;npix++)
 253               {
 254                    row = frowpixel[npix];
 255                    col = fcolpixel[npix];
 256                    ene = fenepixel[npix];
 257                    UpdateMap(row,col,ene);
 258                    GetList(ntrack,idhit,pList,row,col);
 259                    // Starting capacitive coupling effect
 260                    SetCoupling(row,col,ntrack,idhit,pList);
 261               }
 262             x1l=x2l;
 263             y1l=y2l;
 264             z1l=z2l;
 265         }
 266 }
 267
 268 //_________________________________________________________________________
 269
 270 void AliITSsimulationSPD::ChargeSharing(Float_t x1l,Float_t z1l,Float_t x2l,
 271                     Float_t z2l,Int_t c1,Int_t r1,Int_t c2,
 272                                     Int_t r2,Float_t etot,
 273                                     Int_t &npixel,Int_t *frowpixel,
 274                                     Int_t *fcolpixel,Double_t *fenepixel){
 275   //
 276   //  Take into account the geometrical charge sharing when the track
 277   //  crosses more than one pixel.
 278   //
 279   //Begin_Html
 280   /*
 281   <img src="picts/ITS/barimodel_2.gif">
 282   </pre>
 283   <br clear=left>
 284   <font size=+2 color=red>
 285   <a href="mailto:Rocco.Caliandro@ba.infn.it"></a>.
 286   </font>
 287   <pre>
 288   */
 289   //End_Html
 290
 291
 292    Float_t xa,za,xb,zb,dx,dz,dtot,dm,refr,refm,refc;
 293    Float_t refn=0.;
 294    Float_t arefm, arefr, arefn, arefc, azb, az2l, axb, ax2l;
 295    Int_t   dirx,dirz,rb,cb;
 296
 297
 298    Int_t flag,flagrow,flagcol;
 299
 300    Double_t epar;
 301
 302
 303    npixel = 0;
 304    xa = x1l;
 305    za = z1l;
 306    dx = TMath::Abs(x1l-x2l);
 307    dz = TMath::Abs(z1l-z2l);
 308    dtot = TMath::Sqrt((dx*dx)+(dz*dz));
 309    dm = (x2l - x1l) / (z2l - z1l);
 310
 311    dirx = (Int_t) ((x2l - x1l) / dx);
 312    dirz = (Int_t) ((z2l - z1l) / dz);
 313
 314
 315    // calculate the x coordinate of  the pixel in the next column
 316    // and the z coordinate of  the pixel in the next row
 317
 318    Float_t xpos, zpos;
 319
 320    fSegmentation->GetPadCxz(c1, r1-1, xpos, zpos);
 321
 322    Float_t xsize = fSegmentation->Dpx(0);
 323    Float_t zsize = fSegmentation->Dpz(r1-1);
 324
 325    if (dirx == 1) refr = xpos+xsize/2.;
 326              else refr = xpos-xsize/2.;
 327
 328    if (dirz == 1) refn = zpos+zsize/2.;
 329              else refn = zpos-zsize/2.;
 330
 331
 332    flag = 0;
 333    flagrow = 0;
 334    flagcol = 0;
 335    do
 336    {
 337
 338       // calculate the x coordinate of the intersection with the pixel
 339       // in the next cell in row  direction
 340
 341       refm = (refn - z1l)*dm + x1l;
 342
 343       // calculate the z coordinate of the intersection with the pixel
 344       // in the next cell in column direction
 345
 346       refc = (refr - x1l)/dm + z1l;
 347
 348
 349       arefm = refm * dirx;
 350       arefr = refr * dirx;
 351       arefn = refn * dirz;
 352       arefc = refc * dirz;
 353
 354
 355       if ((arefm < arefr) && (arefn < arefc)){
 356
 357          // the track goes in the pixel in the next cell in row direction
 358              xb = refm;
 359              zb = refn;
 360              cb = c1;
 361              rb = r1 + dirz;
 362              azb = zb * dirz;
 363          az2l = z2l * dirz;
 364              if (rb == r2) flagrow=1;
 365              if (azb > az2l) {
 366                 zb = z2l;
 367                 xb = x2l;
 368              }
 369
 370          // shift to the pixel in the next cell in row direction
 371          Float_t zsizeNext = fSegmentation->Dpz(rb-1);
 372          //to account for cell at the borders of the detector
 373          if(zsizeNext==0) zsizeNext = zsize;
 374
 375              refn += zsizeNext*dirz;
 376
 377       }
 378       else {
 379
 380          // the track goes in the pixel in the next cell in column direction
 381              xb = refr;
 382              zb = refc;
 383              cb = c1 + dirx;
 384              rb = r1;
 385              axb = xb * dirx;
 386          ax2l = x2l * dirx;
 387          if (cb == c2) flagcol=1;
 388              if (axb > ax2l) {
 389                 zb = z2l;
 390                 xb = x2l;
 391              }
 392
 393          // shift to the pixel in the next cell in column direction
 394          Float_t xsizeNext = fSegmentation->Dpx(cb-1);
 395          //to account for cell at the borders of the detector
 396          if(xsizeNext==0) xsizeNext = xsize;
 397
 398              refr += xsizeNext*dirx;
 399
 400       }
 401
 402       //calculate the energy lost in the crossed pixel
 403       epar = TMath::Sqrt((xb-xa)*(xb-xa)+(zb-za)*(zb-za));
 404       epar = etot*(epar/dtot);
 405
 406       //store row, column and energy lost in the crossed pixel
 407       frowpixel[npixel] = r1;
 408       fcolpixel[npixel] = c1;
 409       fenepixel[npixel] = epar;
 410       npixel++;
 411
 412       // the exit point of the track is reached
 413       if (epar == 0) flag = 1;
 414       if ((r1 == r2) && (c1 == c2)) flag = 1;
 415       if (flag!=1) {
 416         r1 = rb;
 417         c1 = cb;
 418         xa = xb;
 419         za = zb;
 420       }
 421
 422    } while (flag==0);
 423
 424 }
 425 //___________________________________________________________________________
 426 void AliITSsimulationSPD::SetCoupling(Int_t row, Int_t col, Int_t ntrack,
 427                                           Int_t idhit, Float_t **pList) {
 428    //
 429    //  Take into account the coupling between adiacent pixels.
 430    //  The parameters probcol and probrow are the fractions of the
 431    //  signal in one pixel shared in the two adjacent pixels along
 432    //  the column and row direction, respectively.
 433    //
 434    //Begin_Html
 435    /*
 436    <img src="picts/ITS/barimodel_3.gif">
 437    </pre>
 438    <br clear=left>
 439    <font size=+2 color=red>
 440    <a href="mailto:Rocco.Caliandro@ba.infn.it"></a>.
 441    </font>
 442    <pre>
 443    */
 444    //End_Html
 445
 446
 447    Int_t j1,j2,flag=0;
 448    Double_t pulse1,pulse2;
 449
 450
 451    j1 = row;
 452    j2 = col;
 453
 454    pulse1 = fMapA2->GetSignal(row,col);
 455    pulse2 = pulse1;
 456
 457    for (Int_t isign=-1;isign<=1;isign+=2)
 458    {
 459
 460 // loop in row direction
 461
 462       do
 463       {
 464          j1 += isign;
 465          pulse1 *= fCouplRow;
 466
 467          if ((j1 < 0) || (j1 > fNPixelsZ-1) || (pulse1 < fThresh))
 468          {
 469                pulse1 = fMapA2->GetSignal(row,col);
 470                j1 = row;
 471                flag = 1;
 472          }
 473           else{
 474                    UpdateMap(j1,col,pulse1);
 475                    GetList(ntrack,idhit,pList,j1,col);
 476            flag = 0;
 477              }
 478
 479       } while(flag == 0);
 480
 481
 482 // loop in column direction
 483
 484       do
 485       {
 486          j2 += isign;
 487          pulse2 *= fCouplCol;
 488
 489          if ((j2 < 0) || (j2 > (fNPixelsX-1)) || (pulse2 < fThresh))
 490          {
 491                pulse2 = fMapA2->GetSignal(row,col);
 492                j2 = col;
 493                flag = 1;
 494          }
 495           else{
 496                    UpdateMap(row,j2,pulse2);
 497                    GetList(ntrack,idhit,pList,row,j2);
 498            flag = 0;
 499              }
 500
 501       } while(flag == 0);
 502
 503    }
 504
 505 }
 506 //___________________________________________________________________________
 507 void AliITSsimulationSPD::CreateDigit(Int_t nhits, Int_t module, Float_t
 508 **pList) {
 509   //
 510   // The pixels are fired if the energy deposited inside them is above
 511   // the threshold parameter ethr. Fired pixed are interpreted as digits
 512   // and stored in the file digitfilename.
 513   //
 514
 515    AliITS *aliITS  = (AliITS*)gAlice->GetModule("ITS");
 516
 517
 518    Int_t digits[3];
 519    Int_t tracks[3];
 520    Int_t hits[3];
 521    Float_t charges[3];
 522    Int_t gi,j1;
 523
 524    if (nhits > 0) {
 525
 526      for (Int_t r=1;r<=fNPixelsZ;r++) {
 527         for (Int_t c=1;c<=fNPixelsX;c++) {
 528
 529            // check if the deposited energy in a pixel is above the threshold
 530            Float_t signal = (Float_t) fMapA2->GetSignal(r,c);
 531            gi =r*fNPixelsX+c; // global index
 532            if ( signal > fThresh) {
 533                   digits[0] = r-1;  // digits starts from 0
 534                   digits[1] = c-1;  // digits starts from 0
 535                   //digits[2] = 1;
 536                   digits[2] =  (Int_t) signal;  // the signal is stored in electrons
 537                   for(j1=0;j1<3;j1++){
 538                     tracks[j1] = (Int_t)(*(pList[gi]+j1));
 539                     hits[j1] = (Int_t)(*(pList[gi]+j1+6));
 540                     charges[j1] = 0;
 541                   }
 542               /* debug
 543               printf("digits %d %d %d\n",digits[0],digits[1],digits[2]); //debug
 544               printf("tracks %d %d %d\n",tracks[0],tracks[1],tracks[2]); //debug
 545               printf("hits %d %d %d\n",hits[0],hits[1],hits[2]); //debug
 546               */
 547               Float_t phys = 0;
 548               aliITS->AddSimDigit(0,phys,digits,tracks,hits,charges);
 549            }//endif of threshold condition
 550            if(pList[gi]) delete [] pList[gi];
 551         }
 552      }// enddo on pixels
 553     }
 554
 555 }
 556 //_____________________________________________________________________________
 557
 558 void AliITSsimulationSPD::GetList(Int_t label,Int_t idhit, Float_t **pList,
 559                                       Int_t row, Int_t col) {
 560   // loop over nonzero digits
 561
 562   Int_t ix = col;
 563   Int_t iz = row;
 564   Int_t globalIndex;
 565   Float_t signal;
 566   Float_t highest,middle,lowest;
 567
 568
 569   signal=fMapA2->GetSignal(iz,ix);
 570
 571
 572   globalIndex = iz*fNPixelsX+ix; // globalIndex starts from 1
 573
 574
 575   if(!pList[globalIndex])
 576   {
 577      //
 578      // Create new list (9 elements - 3 signals and 3 tracks + 3 hits)
 579      //
 580
 581      pList[globalIndex] = new Float_t [9];
 582
 583
 584      // set list to -3
 585      *(pList[globalIndex]) = -3.;
 586      *(pList[globalIndex]+1) = -3.;
 587      *(pList[globalIndex]+2) = -3.;
 588      *(pList[globalIndex]+3) =  0.;
 589      *(pList[globalIndex]+4) =  0.;
 590      *(pList[globalIndex]+5) =  0.;
 591      *(pList[globalIndex]+6) = -1.;
 592      *(pList[globalIndex]+7) = -1.;
 593      *(pList[globalIndex]+8) = -1.;
 594
 595      *pList[globalIndex] = (float)label;
 596      *(pList[globalIndex]+3) = signal;
 597      *(pList[globalIndex]+6) = (float)idhit;
 598   }
 599   else{
 600
 601
 602           // check the signal magnitude
 603       highest = *(pList[globalIndex]+3);
 604       middle  = *(pList[globalIndex]+4);
 605       lowest  = *(pList[globalIndex]+5);
 606
 607
 608       signal -= (highest+middle+lowest);
 609
 610
 611           //
 612           //  compare the new signal with already existing list
 613           //
 614       if(signal<lowest) return; // neglect this track
 615
 616       if (signal>highest)
 617       {
 618          *(pList[globalIndex]+8) = *(pList[globalIndex]+7);
 619          *(pList[globalIndex]+7) = *(pList[globalIndex]+6);
 620          *(pList[globalIndex]+6) = idhit;
 621          *(pList[globalIndex]+5) = middle;
 622          *(pList[globalIndex]+4) = highest;
 623          *(pList[globalIndex]+3) = signal;
 624          *(pList[globalIndex]+2) = *(pList[globalIndex]+1);
 625          *(pList[globalIndex]+1) = *pList[globalIndex];
 626          *(pList[globalIndex]) = label;
 627           }
 628         else if (signal>middle)
 629       {
 630          *(pList[globalIndex]+8) = *(pList[globalIndex]+7);
 631          *(pList[globalIndex]+7) = idhit;
 632          *(pList[globalIndex]+5) = middle;
 633          *(pList[globalIndex]+4) = signal;
 634          *(pList[globalIndex]+2) = *(pList[globalIndex]+1);
 635          *(pList[globalIndex]+1) = label;
 636           }
 637         else
 638       {
 639          *(pList[globalIndex]+8) = idhit;
 640          *(pList[globalIndex]+5) = signal;
 641          *(pList[globalIndex]+2) = label;
 642           }
 643   }
 644 }
 645 //_________________________________________________________________________
 646 void AliITSsimulationSPD::SetFluctuations(Float_t **pList) {
 647   //
 648   //  Set the electronic noise and threshold non-uniformities to all the
 649   //  pixels in a detector.
 650   //  The parameter fSigma is the squared sum of the sigma due to noise
 651   //  and the sigma of the threshold distribution among pixels.
 652   //
 653   //Begin_Html
 654   /*
 655   <img src="picts/ITS/barimodel_1.gif">
 656   </pre>
 657   <br clear=left>
 658   <font size=+2 color=red>
 659   <a href="mailto:Rocco.Caliandro@ba.infn.it"></a>.
 660   </font>
 661   <pre>
 662   */
 663   //End_Html
 664
 665
 666   Double_t signal;
 667
 668   Int_t iz,ix;
 669   for(iz=1;iz<=fNPixelsZ;iz++){
 670     for(ix=1;ix<=fNPixelsX;ix++){
 671       signal = fSigma*gRandom->Gaus();
 672       fMapA2->SetHit(iz,ix,signal);
 673
 674       // insert in the label-signal-hit list the pixels fired only by noise
 675       if ( signal > fThresh) {
 676         Int_t globalIndex = iz*fNPixelsX+ix;
 677         pList[globalIndex] = new Float_t [9];
 678         *(pList[globalIndex]) = -2.;
 679         *(pList[globalIndex]+1) = -2.;
 680         *(pList[globalIndex]+2) = -2.;
 681         *(pList[globalIndex]+3) =  signal;
 682         *(pList[globalIndex]+4) =  0.;
 683         *(pList[globalIndex]+5) =  0.;
 684         *(pList[globalIndex]+6) =  -1.;
 685         *(pList[globalIndex]+7) =  -1.;
 686         *(pList[globalIndex]+8) =  -1.;
 687       }
 688     } // end of loop on pixels
 689   } // end of loop on pixels
 690
 691  }
 692 //____________________________________________
 693
 694 void AliITSsimulationSPD::CreateHistograms() {
 695   // CreateHistograms
 696
 697       Int_t i;
 698       fHis=new TObjArray(fNPixelsZ);
 699       for(i=0;i<fNPixelsZ;i++) {
 700            TString spdname("spd_");
 701            Char_t candnum[4];
 702            sprintf(candnum,"%d",i+1);
 703            spdname.Append(candnum);
 704        //PH        (*fHis)[i] = new TH1F(spdname.Data(),"SPD maps",
 705        //PH                              fNPixelsX,0.,(Float_t) fNPixelsX);
 706            fHis->AddAt(new TH1F(spdname.Data(),"SPD maps",
 707                               fNPixelsX,0.,(Float_t) fNPixelsX), i);
 708       }
 709
 710 }
 711
 712 //____________________________________________
 713
 714 void AliITSsimulationSPD::ResetHistograms() {
 715     //
 716     // Reset histograms for this detector
 717     //
 718     Int_t i;
 719     for(i=0;i<fNPixelsZ;i++ ) {
 720       //PH      if ((*fHis)[i])    ((TH1F*)(*fHis)[i])->Reset();
 721         if (fHis->At(i))    ((TH1F*)fHis->At(i))->Reset();
 722     }
 723
 724 }