Corrections for memory leaks, random numbers, hit number; also some data members...
[u/mrichter/AliRoot.git] / ITS / AliITSsimulationSPD.cxx
CommitLineData
b0f5e3fc 1#include <iostream.h>
2#include <TRandom.h>
3#include <TH1.h>
e8189707 4#include <TMath.h>
9f033001 5#include <TString.h>
6#include <TParticle.h>
e8189707 7
b0f5e3fc 8
9#include "AliRun.h"
e8189707 10#include "AliITS.h"
9f033001 11#include "AliITShit.h"
12#include "AliITSdigit.h"
13#include "AliITSmodule.h"
e8189707 14#include "AliITSMapA2.h"
b0f5e3fc 15#include "AliITSsimulationSPD.h"
9f033001 16#include "AliITSsegmentation.h"
17#include "AliITSresponse.h"
18
e8189707 19
20
b0f5e3fc 21
22ClassImp(AliITSsimulationSPD)
23////////////////////////////////////////////////////////////////////////
24// Version: 0
25// Written by Boris Batyunya
26// December 20 1999
27//
28// AliITSsimulationSPD is the simulation of SPDs
b0f5e3fc 29//________________________________________________________________________
30
e8189707 31
32AliITSsimulationSPD::AliITSsimulationSPD()
33{
b0f5e3fc 34 // constructor
e8189707 35 fResponse = 0;
b0f5e3fc 36 fSegmentation = 0;
9f033001 37 fMapA2=0;
e8189707 38 fHis = 0;
39 fNoise=0.;
40 fBaseline=0.;
9f033001 41 fNPixelsZ=0;
42 fNPixelsX=0;
b0f5e3fc 43}
e8189707 44
45
b0f5e3fc 46//_____________________________________________________________________________
47
48AliITSsimulationSPD::AliITSsimulationSPD(AliITSsegmentation *seg, AliITSresponse *resp) {
e8189707 49 // standard constructor
50
9f033001 51 fHis = 0;
b0f5e3fc 52 fResponse = resp;
53 fSegmentation = seg;
54
55 fResponse->GetNoiseParam(fNoise,fBaseline);
56
b0f5e3fc 57 fMapA2 = new AliITSMapA2(fSegmentation);
e8189707 58
59 //
5a200b64 60
b0f5e3fc 61 fNPixelsZ=fSegmentation->Npz();
62 fNPixelsX=fSegmentation->Npx();
63
64}
65
66//_____________________________________________________________________________
67
68AliITSsimulationSPD::~AliITSsimulationSPD() {
69 // destructor
70
71 delete fMapA2;
72
73 if (fHis) {
74 fHis->Delete();
75 delete fHis;
76 }
77}
78
e8189707 79
b0f5e3fc 80//__________________________________________________________________________
81AliITSsimulationSPD::AliITSsimulationSPD(const AliITSsimulationSPD &source){
82 // Copy Constructor
83 if(&source == this) return;
84 this->fMapA2 = source.fMapA2;
85 this->fNoise = source.fNoise;
86 this->fBaseline = source.fBaseline;
87 this->fNPixelsX = source.fNPixelsX;
88 this->fNPixelsZ = source.fNPixelsZ;
89 this->fHis = source.fHis;
90 return;
91}
92
93//_________________________________________________________________________
94AliITSsimulationSPD&
95 AliITSsimulationSPD::operator=(const AliITSsimulationSPD &source) {
96 // Assignment operator
97 if(&source == this) return *this;
98 this->fMapA2 = source.fMapA2;
99 this->fNoise = source.fNoise;
100 this->fBaseline = source.fBaseline;
101 this->fNPixelsX = source.fNPixelsX;
102 this->fNPixelsZ = source.fNPixelsZ;
103 this->fHis = source.fHis;
104 return *this;
105 }
106//_____________________________________________________________________________
107
e8189707 108void AliITSsimulationSPD::DigitiseModule(AliITSmodule *mod, Int_t module, Int_t dummy)
109{
b0f5e3fc 110 // digitize module
e8189707 111
112 const Float_t kEnToEl = 2.778e+8; // GeV->charge in electrons
b0f5e3fc 113 // for 3.6 eV/pair
114 const Float_t kconv = 10000.; // cm -> microns
115
e8189707 116 Float_t spdLength = fSegmentation->Dz();
b0f5e3fc 117 Float_t spdWidth = fSegmentation->Dx();
118
5a200b64 119 Float_t difCoef, dum;
e8189707 120 fResponse->DiffCoeff(difCoef,dum);
b0f5e3fc 121
122 Float_t zPix0 = 1e+6;
123 Float_t xPix0 = 1e+6;
e8189707 124 Float_t yPrev = 1e+6;
b0f5e3fc 125
126 Float_t zPitch = fSegmentation->Dpz(0);
127 Float_t xPitch = fSegmentation->Dpx(0);
128
b0f5e3fc 129 TObjArray *fHits = mod->GetHits();
130 Int_t nhits = fHits->GetEntriesFast();
131 if (!nhits) return;
b0f5e3fc 132
bf83d539 133 //cout<<"len,wid,dy,nx,nz,pitchx,pitchz ="<<spdLength<<","<<spdWidth<<","<<fSegmentation->Dy()<<","<<fNPixelsX<<","<<fNPixelsZ<<","<<xPitch<<","<<zPitch<<endl;
b0f5e3fc 134 // Array of pointers to the label-signal list
135
e8189707 136 Int_t maxNDigits = fNPixelsX*fNPixelsZ + fNPixelsX ;;
137 Float_t **pList = new Float_t* [maxNDigits];
138 memset(pList,0,sizeof(Float_t*)*maxNDigits);
b0f5e3fc 139 Int_t indexRange[4] = {0,0,0,0};
140
141 // Fill detector maps with GEANT hits
142 // loop over hits in the module
a3e16987 143 static Bool_t first;
5a200b64 144 Int_t lasttrack=-2;
e8189707 145 Int_t hit, iZi, jz, jx;
bf83d539 146 //cout<<"SPD: module,nhits ="<<module<<","<<nhits<<endl;
03898a57 147 Int_t idhit=-1;
e8189707 148 for (hit=0;hit<nhits;hit++) {
b0f5e3fc 149 AliITShit *iHit = (AliITShit*) fHits->At(hit);
e8189707 150 Int_t layer = iHit->GetLayer();
5a200b64 151 Float_t yPix0 = -73;
152 if(layer == 1) yPix0 = -77;
e8189707 153
03898a57 154 if(iHit->StatusEntering()) idhit=hit;
e8189707 155 Int_t itrack = iHit->GetTrack();
a3e16987 156 Int_t dray = 0;
b0f5e3fc 157
a3e16987 158 if (lasttrack != itrack || hit==(nhits-1)) first = kTRUE;
159
160 // Int_t parent = iHit->GetParticle()->GetFirstMother();
161 Int_t partcode = iHit->GetParticle()->GetPdgCode();
162
163// partcode (pdgCode): 11 - e-, 13 - mu-, 22 - gamma, 111 - pi0, 211 - pi+
164// 310 - K0s, 321 - K+, 2112 - n, 2212 - p, 3122 - lambda
165
bf83d539 166 /*
167 Float_t px = iHit->GetPXL(); // the momenta at the
168 Float_t py = iHit->GetPYL(); // each GEANT step
a3e16987 169 Float_t pz = iHit->GetPZL();
bf83d539 170 Float_t ptot = 1000*sqrt(px*px+py*py+pz*pz);
171 */
172
173 Float_t pmod = iHit->GetParticle()->P(); // total momentum at the
174 // vertex
175 pmod *= 1000;
a3e16987 176
177
178 if(partcode == 11 && pmod < 6) dray = 1; // delta ray is e-
179 // at p < 6 MeV/c
180
181
b0f5e3fc 182 // Get hit z and x(r*phi) cordinates for each module (detector)
183 // in local system.
184
e8189707 185 Float_t zPix = kconv*iHit->GetZL();
186 Float_t xPix = kconv*iHit->GetXL();
187 Float_t yPix = kconv*iHit->GetYL();
b0f5e3fc 188
189 // Get track status
e8189707 190 Int_t status = iHit->GetTrackStatus();
bf83d539 191 //cout<<"hit,status,y ="<<hit<<","<<status<<","<<yPix<<endl;
b0f5e3fc 192
bf83d539 193 // Check boundaries
194 if(zPix > spdLength/2) {
195 //cout<<"!!!1 z outside ="<<zPix<<endl;
196 zPix = spdLength/2 - 10;
197 //cout<<"!!!2 z outside ="<<zPix<<endl;
198 }
199 if(zPix < 0 && zPix < -spdLength/2) {
200 //cout<<"!!!1 z outside ="<<zPix<<endl;
201 zPix = -spdLength/2 + 10;
202 //cout<<"!!!2 z outside ="<<zPix<<endl;
203 }
204 if(xPix > spdWidth/2) {
205 //cout<<"!!!1 x outside ="<<xPix<<endl;
206 xPix = spdWidth/2 - 10;
207 //cout<<"!!!2 x outside ="<<xPix<<endl;
208 }
209 if(xPix < 0 && xPix < -spdWidth/2) {
210 //cout<<"!!!1 x outside ="<<xPix<<endl;
211 xPix = -spdWidth/2 + 10;
212 //cout<<"!!!2 x outside ="<<xPix<<endl;
213 }
e8189707 214 Int_t trdown = 0;
b0f5e3fc 215
216 // enter Si or after event in Si
217 if (status == 66 ) {
218 zPix0 = zPix;
219 xPix0 = xPix;
220 yPrev = yPix;
221 }
5a200b64 222
e8189707 223 Float_t depEnergy = iHit->GetIonization();
b0f5e3fc 224 // skip if the input point to Si
5a200b64 225
e8189707 226 if(depEnergy <= 0.) continue;
5a200b64 227
b0f5e3fc 228 // if track returns to the opposite direction:
5a200b64 229 if (yPix < yPrev) {
b0f5e3fc 230 trdown = 1;
e8189707 231 }
b0f5e3fc 232
5a200b64 233
b0f5e3fc 234 // take into account the holes diffusion inside the Silicon
235 // the straight line between the entrance and exit points in Si is
236 // divided into the several steps; the diffusion is considered
237 // for each end point of step and charge
238 // is distributed between the pixels through the diffusion.
239
240
241 // ---------- the diffusion in Z (beam) direction -------
242
e8189707 243 Float_t charge = depEnergy*kEnToEl; // charge in e-
244 Float_t drPath = 0.;
245 Float_t tang = 0.;
246 Float_t sigmaDif = 0.;
247 Float_t zdif = zPix - zPix0;
248 Float_t xdif = xPix - xPix0;
5a200b64 249 Float_t ydif = TMath::Abs(yPix - yPrev);
250 Float_t ydif0 = TMath::Abs(yPrev - yPix0);
b0f5e3fc 251
5a200b64 252 if(ydif < 1) continue; // ydif is not zero
b0f5e3fc 253
e8189707 254 Float_t projDif = sqrt(xdif*xdif + zdif*zdif);
bf83d539 255
e8189707 256 Int_t ndZ = (Int_t)TMath::Abs(zdif/zPitch) + 1;
257 Int_t ndX = (Int_t)TMath::Abs(xdif/xPitch) + 1;
b0f5e3fc 258
259 // number of the steps along the track:
e8189707 260 Int_t nsteps = ndZ;
b0f5e3fc 261 if(ndX > ndZ) nsteps = ndX;
262 if(nsteps < 6) nsteps = 6; // minimum number of the steps
263
5a200b64 264 if (projDif < 5 ) {
265 drPath = (yPix-yPix0)*1.e-4;
b0f5e3fc 266 drPath = TMath::Abs(drPath); // drift path in cm
267 sigmaDif = difCoef*sqrt(drPath); // sigma diffusion in cm
5a200b64 268 sigmaDif = sigmaDif*kconv; // sigma diffusion in microns
269 nsteps = 1;
b0f5e3fc 270 }
271
5a200b64 272 if(projDif > 5) tang = ydif/projDif;
273 Float_t dCharge = charge/nsteps; // charge in e- for one step
274 Float_t dZ = zdif/nsteps;
275 Float_t dX = xdif/nsteps;
276
e8189707 277 for (iZi = 1;iZi <= nsteps;iZi++) {
278 Float_t dZn = iZi*dZ;
279 Float_t dXn = iZi*dX;
280 Float_t zPixn = zPix0 + dZn;
281 Float_t xPixn = xPix0 + dXn;
b0f5e3fc 282
5a200b64 283 if(projDif >= 5) {
e8189707 284 Float_t dProjn = sqrt(dZn*dZn+dXn*dXn);
e8189707 285 drPath = dProjn*tang*1.e-4; // drift path for iZi step in cm
5a200b64 286 if(trdown == 0) {
287 drPath = TMath::Abs(drPath) + ydif0*1.e-4;
b0f5e3fc 288 }
289 if(trdown == 1) {
5a200b64 290 drPath = ydif0*1.e-4 - TMath::Abs(drPath);
291 drPath = TMath::Abs(drPath);
b0f5e3fc 292 }
293 sigmaDif = difCoef*sqrt(drPath);
294 sigmaDif = sigmaDif*kconv; // sigma diffusion in microns
295 }
5a200b64 296
e8189707 297 zPixn = (zPixn + spdLength/2.);
298 xPixn = (xPixn + spdWidth/2.);
299 Int_t nZpix, nXpix;
300 fSegmentation->GetPadIxz(xPixn,zPixn,nXpix,nZpix);
b0f5e3fc 301 zPitch = fSegmentation->Dpz(nZpix);
e8189707 302 fSegmentation->GetPadTxz(xPixn,zPixn);
b0f5e3fc 303 // set the window for the integration
e8189707 304 Int_t jzmin = 1;
305 Int_t jzmax = 3;
b0f5e3fc 306 if(nZpix == 1) jzmin =2;
307 if(nZpix == fNPixelsZ) jzmax = 2;
308
e8189707 309 Int_t jxmin = 1;
310 Int_t jxmax = 3;
b0f5e3fc 311 if(nXpix == 1) jxmin =2;
312 if(nXpix == fNPixelsX) jxmax = 2;
313
e8189707 314 Float_t zpix = nZpix;
315 Float_t dZright = zPitch*(zpix - zPixn);
316 Float_t dZleft = zPitch - dZright;
317
318 Float_t xpix = nXpix;
319 Float_t dXright = xPitch*(xpix - xPixn);
320 Float_t dXleft = xPitch - dXright;
321
322 Float_t dZprev = 0.;
323 Float_t dZnext = 0.;
324 Float_t dXprev = 0.;
325 Float_t dXnext = 0.;
b0f5e3fc 326
327 for(jz=jzmin; jz <=jzmax; jz++) {
328 if(jz == 1) {
329 dZprev = -zPitch - dZleft;
330 dZnext = -dZleft;
331 }
332 if(jz == 2) {
333 dZprev = -dZleft;
334 dZnext = dZright;
335 }
336 if(jz == 3) {
337 dZprev = dZright;
338 dZnext = dZright + zPitch;
339 }
e8189707 340 // kz changes from 1 to the fNofPixels(270)
341 Int_t kz = nZpix + jz -2;
b0f5e3fc 342
e8189707 343 Float_t zArg1 = dZprev/sigmaDif;
344 Float_t zArg2 = dZnext/sigmaDif;
345 Float_t zProb1 = TMath::Erfc(zArg1);
346 Float_t zProb2 = TMath::Erfc(zArg2);
347 Float_t dZCharge =0.5*(zProb1-zProb2)*dCharge;
b0f5e3fc 348
b0f5e3fc 349
350 // ----------- holes diffusion in X(r*phi) direction --------
351
352 if(dZCharge > 1.) {
353 for(jx=jxmin; jx <=jxmax; jx++) {
354 if(jx == 1) {
355 dXprev = -xPitch - dXleft;
356 dXnext = -dXleft;
357 }
358 if(jx == 2) {
359 dXprev = -dXleft;
360 dXnext = dXright;
361 }
362 if(jx == 3) {
363 dXprev = dXright;
364 dXnext = dXright + xPitch;
365 }
e8189707 366 Int_t kx = nXpix + jx -2;
b0f5e3fc 367
e8189707 368 Float_t xArg1 = dXprev/sigmaDif;
369 Float_t xArg2 = dXnext/sigmaDif;
370 Float_t xProb1 = TMath::Erfc(xArg1);
371 Float_t xProb2 = TMath::Erfc(xArg2);
372 Float_t dXCharge =0.5*(xProb1-xProb2)*dZCharge;
b0f5e3fc 373
374 if(dXCharge > 1.) {
e8189707 375 Int_t index = kz-1;
376
b0f5e3fc 377 if (first) {
378 indexRange[0]=indexRange[1]=index;
e8189707 379 indexRange[2]=indexRange[3]=kx-1;
b0f5e3fc 380 first=kFALSE;
381 }
382
e8189707 383 indexRange[0]=TMath::Min(indexRange[0],kz-1);
384 indexRange[1]=TMath::Max(indexRange[1],kz-1);
385 indexRange[2]=TMath::Min(indexRange[2],kx-1);
386 indexRange[3]=TMath::Max(indexRange[3],kx-1);
387
b0f5e3fc 388 // build the list of digits for this module
e8189707 389 Double_t signal=fMapA2->GetSignal(index,kx-1);
b0f5e3fc 390 signal+=dXCharge;
e8189707 391 fMapA2->SetHit(index,kx-1,(double)signal);
b0f5e3fc 392 } // dXCharge > 1 e-
393 } // jx loop
394 } // dZCharge > 1 e-
395 } // jz loop
396 } // iZi loop
397
398 if (status == 65) { // the step is inside of Si
399 zPix0 = zPix;
400 xPix0 = xPix;
401 }
a3e16987 402 yPrev = yPix;
b0f5e3fc 403
a3e16987 404 if(dray == 0) {
e8189707 405 GetList(itrack,idhit,pList,indexRange);
b0f5e3fc 406 }
e8189707 407
408 lasttrack=itrack;
b0f5e3fc 409 } // hit loop inside the module
410
411
412 // introduce the electronics effects and do zero-suppression
413 ChargeToSignal(pList);
414
415 // clean memory
416
417 fMapA2->ClearMap();
418
419
420}
421
422//---------------------------------------------
e8189707 423void AliITSsimulationSPD::GetList(Int_t label,Int_t idhit,Float_t **pList,Int_t *indexRange)
424{
425 // lop over nonzero digits
b0f5e3fc 426
e8189707 427
428 //set protection
429 for(int k=0;k<4;k++) {
430 if (indexRange[k] < 0) indexRange[k]=0;
431 }
b0f5e3fc 432
e8189707 433 for(Int_t iz=indexRange[0];iz<indexRange[1]+1;iz++){
434 for(Int_t ix=indexRange[2];ix<indexRange[3]+1;ix++){
b0f5e3fc 435
e8189707 436 Float_t signal=fMapA2->GetSignal(iz,ix);
a3e16987 437
e8189707 438 if (!signal) continue;
439
440 Int_t globalIndex = iz*fNPixelsX+ix; // GlobalIndex starts from 0!
b0f5e3fc 441 if(!pList[globalIndex]){
a3e16987 442
b0f5e3fc 443 //
e8189707 444 // Create new list (9 elements - 3 signals and 3 tracks + 3 hits)
b0f5e3fc 445 //
446
e8189707 447 pList[globalIndex] = new Float_t [9];
b0f5e3fc 448
e8189707 449 // set list to -3
b0f5e3fc 450
e8189707 451 *pList[globalIndex] = -3.;
452 *(pList[globalIndex]+1) = -3.;
453 *(pList[globalIndex]+2) = -3.;
b0f5e3fc 454 *(pList[globalIndex]+3) = 0.;
455 *(pList[globalIndex]+4) = 0.;
456 *(pList[globalIndex]+5) = 0.;
e8189707 457 *(pList[globalIndex]+6) = -1.;
458 *(pList[globalIndex]+7) = -1.;
459 *(pList[globalIndex]+8) = -1.;
b0f5e3fc 460
461
462 *pList[globalIndex] = (float)label;
463 *(pList[globalIndex]+3) = signal;
e8189707 464 *(pList[globalIndex]+6) = (float)idhit;
b0f5e3fc 465 }
466 else{
467
468 // check the signal magnitude
469
e8189707 470 Float_t highest = *(pList[globalIndex]+3);
471 Float_t middle = *(pList[globalIndex]+4);
472 Float_t lowest = *(pList[globalIndex]+5);
b0f5e3fc 473
474 signal -= (highest+middle+lowest);
475
476 //
477 // compare the new signal with already existing list
478 //
479
480 if(signal<lowest) continue; // neglect this track
481
482 if (signal>highest){
483 *(pList[globalIndex]+5) = middle;
484 *(pList[globalIndex]+4) = highest;
485 *(pList[globalIndex]+3) = signal;
486
487 *(pList[globalIndex]+2) = *(pList[globalIndex]+1);
488 *(pList[globalIndex]+1) = *pList[globalIndex];
489 *pList[globalIndex] = label;
e8189707 490
491 *(pList[globalIndex]+8) = *(pList[globalIndex]+7);
492 *(pList[globalIndex]+7) = *(pList[globalIndex]+6);
493 *(pList[globalIndex]+6) = idhit;
b0f5e3fc 494 }
495 else if (signal>middle){
496 *(pList[globalIndex]+5) = middle;
497 *(pList[globalIndex]+4) = signal;
498
499 *(pList[globalIndex]+2) = *(pList[globalIndex]+1);
500 *(pList[globalIndex]+1) = label;
e8189707 501
502 *(pList[globalIndex]+8) = *(pList[globalIndex]+7);
503 *(pList[globalIndex]+7) = idhit;
b0f5e3fc 504 }
505 else{
506 *(pList[globalIndex]+5) = signal;
507 *(pList[globalIndex]+2) = label;
e8189707 508 *(pList[globalIndex]+8) = idhit;
b0f5e3fc 509 }
510 }
511 } // end of loop pixels in x
512 } // end of loop over pixels in z
513
514
515}
516
517
518//---------------------------------------------
e8189707 519void AliITSsimulationSPD::ChargeToSignal(Float_t **pList)
520{
521 // add noise and electronics, perform the zero suppression and add the
522 // digit to the list
b0f5e3fc 523
524 AliITS *aliITS = (AliITS*)gAlice->GetModule("ITS");
525
526
b0f5e3fc 527 Float_t threshold = (float)fResponse->MinVal();
528
e8189707 529 Int_t digits[3], tracks[3], hits[3],gi,j1;
b0f5e3fc 530 Float_t charges[3];
531 Float_t electronics;
532 Float_t signal,phys;
e8189707 533 for(Int_t iz=0;iz<fNPixelsZ;iz++){
534 for(Int_t ix=0;ix<fNPixelsX;ix++){
03898a57 535 electronics = fBaseline + fNoise*gRandom->Gaus();
b0f5e3fc 536 signal = (float)fMapA2->GetSignal(iz,ix);
537 signal += electronics;
e8189707 538 gi =iz*fNPixelsX+ix; // global index
b0f5e3fc 539 if (signal > threshold) {
540 digits[0]=iz;
541 digits[1]=ix;
542 digits[2]=1;
b0f5e3fc 543 for(j1=0;j1<3;j1++){
e8189707 544 if (pList[gi]) {
5a200b64 545 //b.b. tracks[j1]=-3;
e8189707 546 tracks[j1] = (Int_t)(*(pList[gi]+j1));
547 hits[j1] = (Int_t)(*(pList[gi]+j1+6));
548 }else {
549 tracks[j1]=-2; //noise
550 hits[j1] = -1;
551 }
b0f5e3fc 552 charges[j1] = 0;
553 }
a3e16987 554
555 if(tracks[0] == tracks[1] && tracks[0] == tracks[2]) {
556 tracks[1] = -3;
557 hits[1] = -1;
558 tracks[2] = -3;
559 hits[2] = -1;
560 }
561 if(tracks[0] == tracks[1] && tracks[0] != tracks[2]) {
562 tracks[1] = -3;
563 hits[1] = -1;
564 }
565 if(tracks[0] == tracks[2] && tracks[0] != tracks[1]) {
566 tracks[2] = -3;
567 hits[2] = -1;
568 }
569 if(tracks[1] == tracks[2] && tracks[0] != tracks[1]) {
570 tracks[2] = -3;
571 hits[2] = -1;
572 }
573
b0f5e3fc 574 phys=0;
e8189707 575 aliITS->AddSimDigit(0,phys,digits,tracks,hits,charges);
b0f5e3fc 576 }
e8189707 577 if(pList[gi]) delete [] pList[gi];
b0f5e3fc 578 }
579 }
580 delete [] pList;
581
b0f5e3fc 582}
583
584
585//____________________________________________
586
e8189707 587void AliITSsimulationSPD::CreateHistograms()
588{
589 // create 1D histograms for tests
590
591 printf("SPD - create histograms\n");
b0f5e3fc 592
9f033001 593 fHis=new TObjArray(fNPixelsZ);
e8189707 594 for (Int_t i=0;i<fNPixelsZ;i++) {
03898a57 595 TString spdName("spd_");
e8189707 596 Char_t pixelz[4];
597 sprintf(pixelz,"%d",i+1);
9f033001 598 spdName.Append(pixelz);
599 (*fHis)[i] = new TH1F(spdName.Data(),"SPD maps",
b0f5e3fc 600 fNPixelsX,0.,(Float_t) fNPixelsX);
b0f5e3fc 601 }
b0f5e3fc 602}
603
604//____________________________________________
605
e8189707 606void AliITSsimulationSPD::ResetHistograms()
607{
b0f5e3fc 608 //
609 // Reset histograms for this detector
610 //
5a200b64 611
e8189707 612 for ( int i=0;i<fNPixelsZ;i++ ) {
b0f5e3fc 613 if ((*fHis)[i]) ((TH1F*)(*fHis)[i])->Reset();
614 }
615
616}
e8189707 617
618
619
620
621
622
623
624
625