]> git.uio.no Git - u/mrichter/AliRoot.git/blame - TOF/AliTOFSDigitizer.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
uuhhhhaaa - what did I change? Added the run number and fixed coding conventions ;-)
[u/mrichter/AliRoot.git] / TOF / AliTOFSDigitizer.cxx
CommitLineData
517b7f8f 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
88cb7938 16/* $Id$ */
17
0e46b9ae 18//__________________________________________________________//
19// //
20// This is a TTask that constructs SDigits out of Hits //
21// A Summable Digits is the "sum" of all hits in a pad //
22// Detector response has been simulated via the method //
23// SimulateDetectorResponse //
24// //
25// -- Authors: F. Pierella, A. De Caro //
26// Use case: see AliTOFhits2sdigits.C macro in the CVS //
27//__________________________________________________________//
28
29#include "TBenchmark.h"
30#include "TF1.h"
31#include "TFile.h"
32#include "TParticle.h"
33#include "TTree.h"
88cb7938 34
88cb7938 35#include "AliLoader.h"
0e46b9ae 36#include "AliLog.h"
d3c7bfac 37#include "AliMC.h"
88cb7938 38#include "AliRunLoader.h"
0e46b9ae 39#include "AliRun.h"
d3c7bfac 40
0f4a7374 41#include "AliTOFGeometry.h"
5919c40c 42#include "AliTOFHitMap.h"
016e1f91 43#include "AliTOFhitT0.h"
0e46b9ae 44#include "AliTOFhit.h"
45#include "AliTOFSDigitizer.h"
46#include "AliTOFSDigit.h"
47#include "AliTOF.h"
48
49extern TBenchmark *gBenchmark;
50extern TDirectory *gDirectory;
51extern TFile *gFile;
52extern TRandom *gRandom;
53extern TROOT *gROOT;
54
55extern AliRun *gAlice;
56
517b7f8f 57
58ClassImp(AliTOFSDigitizer)
59
60//____________________________________________________________________________
655e379f 61AliTOFSDigitizer::AliTOFSDigitizer():
62 TTask("TOFSDigitizer",""),
63 fEvent1(-1),
64 fEvent2(-1),
65 ftail(0x0),
66 fHeadersFile(""),
67 fRunLoader(0x0),
68 fTOFLoader(0x0),
69 fTOFGeometry(new AliTOFGeometry()),
70 fSelectedSector(-1),
71 fSelectedPlate(-1),
72 fTimeResolution(0),
73 fpadefficiency(0),
74 fEdgeEffect(-1),
75 fEdgeTails(-1),
76 fHparameter(0),
77 fH2parameter(0),
78 fKparameter(0),
79 fK2parameter(0),
80 fEffCenter(0),
81 fEffBoundary(0),
82 fEff2Boundary(0),
83 fEff3Boundary(0),
84 fAddTRes(0),
85 fResCenter(0),
86 fResBoundary(0),
87 fResSlope(0),
88 fTimeWalkCenter(0),
89 fTimeWalkBoundary(0),
90 fTimeWalkSlope(0),
91 fTimeDelayFlag(-1),
92 fPulseHeightSlope(0),
93 fTimeDelaySlope(0),
94 fMinimumCharge(0),
95 fChargeSmearing(0),
96 fLogChargeSmearing(0),
97 fTimeSmearing(0),
98 fAverageTimeFlag(-1),
99 fAdcBin(0),
100 fAdcMean(0),
101 fAdcRms(0)
517b7f8f 102{
103 // ctor
517b7f8f 104}
d61f73d9 105
7aeeaf38 106//------------------------------------------------------------------------
655e379f 107AliTOFSDigitizer::AliTOFSDigitizer(const AliTOFSDigitizer &source):
108 TTask(source),
109 fEvent1(-1),
110 fEvent2(-1),
111 ftail(0x0),
112 fHeadersFile(""),
113 fRunLoader(0x0),
114 fTOFLoader(0x0),
115 fTOFGeometry(0x0),
116 fSelectedSector(-1),
117 fSelectedPlate(-1),
118 fTimeResolution(0),
119 fpadefficiency(0),
120 fEdgeEffect(-1),
121 fEdgeTails(-1),
122 fHparameter(0),
123 fH2parameter(0),
124 fKparameter(0),
125 fK2parameter(0),
126 fEffCenter(0),
127 fEffBoundary(0),
128 fEff2Boundary(0),
129 fEff3Boundary(0),
130 fAddTRes(0),
131 fResCenter(0),
132 fResBoundary(0),
133 fResSlope(0),
134 fTimeWalkCenter(0),
135 fTimeWalkBoundary(0),
136 fTimeWalkSlope(0),
137 fTimeDelayFlag(-1),
138 fPulseHeightSlope(0),
139 fTimeDelaySlope(0),
140 fMinimumCharge(0),
141 fChargeSmearing(0),
142 fLogChargeSmearing(0),
143 fTimeSmearing(0),
144 fAverageTimeFlag(-1),
145 fAdcBin(0),
146 fAdcMean(0),
147 fAdcRms(0)
7aeeaf38 148{
149 // copy constructor
150 this->fTOFGeometry=source.fTOFGeometry;
151
152}
153
154//____________________________________________________________________________
155AliTOFSDigitizer& AliTOFSDigitizer::operator=(const AliTOFSDigitizer &source)
156{
157 // ass. op.
158 this->fTOFGeometry=source.fTOFGeometry;
159 return *this;
160
161}
162
517b7f8f 163//____________________________________________________________________________
655e379f 164AliTOFSDigitizer::AliTOFSDigitizer(const char* HeaderFile, Int_t evNumber1, Int_t nEvents):
165 TTask("TOFSDigitizer",""),
166 fEvent1(-1),
167 fEvent2(-1),
168 ftail(0x0),
169 fHeadersFile(HeaderFile), // input filename (with hits)
170 fRunLoader(0x0),
171 fTOFLoader(0x0),
172 fTOFGeometry(0x0),
173 fSelectedSector(-1), // by default we sdigitize all sectors
174 fSelectedPlate(-1), // by default we sdigitize all plates in all sectors
175 fTimeResolution(0),
176 fpadefficiency(0),
177 fEdgeEffect(-1),
178 fEdgeTails(-1),
179 fHparameter(0),
180 fH2parameter(0),
181 fKparameter(0),
182 fK2parameter(0),
183 fEffCenter(0),
184 fEffBoundary(0),
185 fEff2Boundary(0),
186 fEff3Boundary(0),
187 fAddTRes(0),
188 fResCenter(0),
189 fResBoundary(0),
190 fResSlope(0),
191 fTimeWalkCenter(0),
192 fTimeWalkBoundary(0),
193 fTimeWalkSlope(0),
194 fTimeDelayFlag(-1),
195 fPulseHeightSlope(0),
196 fTimeDelaySlope(0),
197 fMinimumCharge(0),
198 fChargeSmearing(0),
199 fLogChargeSmearing(0),
200 fTimeSmearing(0),
201 fAverageTimeFlag(-1),
202 fAdcBin(0),
203 fAdcMean(0),
204 fAdcRms(0)
517b7f8f 205{
340693af 206 //ctor, reading from input file
d61f73d9 207
d61f73d9 208 TFile * file = (TFile*) gROOT->GetFile(fHeadersFile.Data());
209
210 //File was not opened yet open file and get alirun object
211 if (file == 0) {
212 file = TFile::Open(fHeadersFile.Data(),"update") ;
213 gAlice = (AliRun *) file->Get("gAlice") ;
ea7a588a 214 }
26e447bd 215
517b7f8f 216 // add Task to //root/Tasks folder
e191bb57 217 TString evfoldname = AliConfig::GetDefaultEventFolderName();
f540341d 218 fRunLoader = AliRunLoader::GetRunLoader(evfoldname);
219 if (!fRunLoader)
220 fRunLoader = AliRunLoader::Open(HeaderFile);//open session and mount on default event folder
88cb7938 221 if (fRunLoader == 0x0)
d61f73d9 222 {
d076c8d5 223 AliFatal("Event is not loaded. Exiting");
d61f73d9 224 return;
225 }
26e447bd 226
d3c7bfac 227 fRunLoader->CdGAFile();
228 TDirectory *savedir=gDirectory;
229 TFile *in=(TFile*)gFile;
230
231 if (!in->IsOpen()) {
232 AliWarning("Geometry file is not open default TOF geometry will be used");
233 fTOFGeometry = new AliTOFGeometry();
234 }
235 else {
236 in->cd();
237 fTOFGeometry = (AliTOFGeometry*)in->Get("TOFgeometry");
238 }
239
240 savedir->cd();
241
f540341d 242 if (fRunLoader->TreeE() == 0x0) fRunLoader->LoadHeader();
d61f73d9 243
244 if (evNumber1>=0) fEvent1 = evNumber1;
245 else fEvent1=0;
246
247 if (nEvents==0) fEvent2 = (Int_t)(fRunLoader->GetNumberOfEvents());
248 else if (nEvents>0) fEvent2 = evNumber1+nEvents;
249 else fEvent2 = 1;
250
251 if (!(fEvent2>fEvent1)) {
d076c8d5 252 AliError(Form("fEvent2 = %d <= fEvent1 = %d", fEvent2, fEvent1));
d61f73d9 253 fEvent1 = 0;
254 fEvent2 = 1;
d076c8d5 255 AliError(Form("Correction: fEvent2 = %d <= fEvent1 = %d", fEvent2, fEvent1));
26e447bd 256 }
d61f73d9 257
26e447bd 258 // init parameters for sdigitization
259 InitParameters();
d61f73d9 260
261 fTOFLoader = fRunLoader->GetLoader("TOFLoader");
262 if (fTOFLoader == 0x0)
263 {
d076c8d5 264 AliFatal("Can not find TOF loader in event. Exiting.");
d61f73d9 265 return;
266 }
267 fTOFLoader->PostSDigitizer(this);
517b7f8f 268}
269
270//____________________________________________________________________________
d61f73d9 271AliTOFSDigitizer::~AliTOFSDigitizer()
517b7f8f 272{
273 // dtor
797e311f 274 fTOFLoader->CleanSDigitizer();
d3c7bfac 275
afd804a3 276 delete fTOFGeometry;
d3c7bfac 277
f73548c4 278}
279
280//____________________________________________________________________________
281void AliTOFSDigitizer::InitParameters()
282{
283 // set parameters for detector simulation
d61f73d9 284
7e6dce66 285 fTimeResolution = 0.080; //0.120; OLD
286 fpadefficiency = 0.99 ;
f73548c4 287 fEdgeEffect = 2 ;
288 fEdgeTails = 0 ;
289 fHparameter = 0.4 ;
290 fH2parameter = 0.15;
291 fKparameter = 0.5 ;
292 fK2parameter = 0.35;
293 fEffCenter = fpadefficiency;
294 fEffBoundary = 0.65;
295 fEff2Boundary = 0.90;
296 fEff3Boundary = 0.08;
8d6daa31 297 fAddTRes = 68. ; // \sqrt{2x20^2 + 15^2 + 2x10^2 + 30^2 + 50^2} (p-p)
298 //fAddTRes = 48. ; // \sqrt{2x20^2 + 15^2 + 2x10^2 + 30^2 + 15^2} (Pb-Pb)
7e6dce66 299 // 30^2+20^2+40^2+50^2+50^2+50^2 = 10400 ps^2 (very old value)
300 fResCenter = 35. ; //50. ; // OLD
f73548c4 301 fResBoundary = 70. ;
7e6dce66 302 fResSlope = 37. ; //40. ; // OLD
f73548c4 303 fTimeWalkCenter = 0. ;
304 fTimeWalkBoundary=0. ;
305 fTimeWalkSlope = 0. ;
306 fTimeDelayFlag = 1 ;
307 fPulseHeightSlope=2.0 ;
308 fTimeDelaySlope =0.060;
309 // was fMinimumCharge = TMath::Exp(fPulseHeightSlope*fKparameter/2.);
310 fMinimumCharge = TMath::Exp(-fPulseHeightSlope*fHparameter);
311 fChargeSmearing=0.0 ;
312 fLogChargeSmearing=0.13;
313 fTimeSmearing =0.022;
314 fAverageTimeFlag=0 ;
43f77f2d 315
d61f73d9 316 fAdcBin = 0.25; // 1 ADC bin = 0.25 pC (or 0.03 pC)
ea7a588a 317 fAdcMean = 50.; // ADC distribution mpv value for Landau (in bins)
318 // it corresponds to a mean value of ~100 bins
319 fAdcRms = 25.; // ADC distribution rms value (in bins)
320 // it corresponds to distribution rms ~50 bins
f73548c4 321}
322
323//__________________________________________________________________
ea7a588a 324Double_t TimeWithTail(Double_t* x, Double_t* par)
f73548c4 325{
326 // sigma - par[0], alpha - par[1], part - par[2]
327 // at x<part*sigma - gauss
328 // at x>part*sigma - TMath::Exp(-x/alpha)
329 Float_t xx =x[0];
330 Double_t f;
331 if(xx<par[0]*par[2]) {
332 f = TMath::Exp(-xx*xx/(2*par[0]*par[0]));
333 } else {
334 f = TMath::Exp(-(xx-par[0]*par[2])/par[1]-0.5*par[2]*par[2]);
335 }
336 return f;
517b7f8f 337}
338
339//____________________________________________________________________________
d61f73d9 340void AliTOFSDigitizer::Exec(Option_t *verboseOption) {
340693af 341 //execute TOF sdigitization
d61f73d9 342 if (strstr(verboseOption,"tim") || strstr(verboseOption,"all"))
ea7a588a 343 gBenchmark->Start("TOFSDigitizer");
517b7f8f 344
ea7a588a 345 if (fEdgeTails) ftail = new TF1("tail",TimeWithTail,-2,2,3);
d61f73d9 346
ea7a588a 347 Int_t nselectedHits=0;
348 Int_t ntotalsdigits=0;
349 Int_t ntotalupdates=0;
350 Int_t nnoisesdigits=0;
351 Int_t nsignalsdigits=0;
352 Int_t nHitsFromPrim=0;
353 Int_t nHitsFromSec=0;
354 Int_t nlargeTofDiff=0;
f73548c4 355
da3d3acd 356 Bool_t thereIsNotASelection=(fSelectedSector==-1) && (fSelectedPlate==-1);
55991c8b 357
f540341d 358 if (fRunLoader->GetAliRun() == 0x0) fRunLoader->LoadgAlice();
d61f73d9 359 gAlice = fRunLoader->GetAliRun();
ea7a588a 360
d61f73d9 361 fRunLoader->LoadKinematics();
362
7e6dce66 363 AliTOF *tof = (AliTOF *) gAlice->GetDetector("TOF");
d61f73d9 364
7e6dce66 365 if (!tof) {
d076c8d5 366 AliError("TOF not found");
d61f73d9 367 return;
368 }
369
370 fTOFLoader->LoadHits("read");
371 fTOFLoader->LoadSDigits("recreate");
372
373 for (Int_t iEvent=fEvent1; iEvent<fEvent2; iEvent++) {
0e46b9ae 374 //AliInfo(Form("------------------- %s -------------", GetName()));
375 //AliInfo(Form("Sdigitizing event %i", iEvent));
517b7f8f 376
d61f73d9 377 fRunLoader->GetEvent(iEvent);
378
7e6dce66 379 TTree *hitTree = fTOFLoader->TreeH ();
380 if (!hitTree) return;
517b7f8f 381
d61f73d9 382 if (fTOFLoader->TreeS () == 0) fTOFLoader->MakeTree ("S");
383
5919c40c 384 //Make branch for digits
7e6dce66 385 tof->MakeBranch("S");
517b7f8f 386
d61f73d9 387 // recreate TClonesArray fSDigits - for backward compatibility
7e6dce66 388 if (tof->SDigits() == 0) {
389 tof->CreateSDigitsArray();
d61f73d9 390 } else {
7e6dce66 391 tof->RecreateSDigitsArray();
d61f73d9 392 }
5919c40c 393
7e6dce66 394 tof->SetTreeAddress();
87e54ebb 395
7e6dce66 396 Int_t version=tof->IsVersion();
d61f73d9 397
398 Int_t nselectedHitsinEv=0;
399 Int_t ntotalsdigitsinEv=0;
400 Int_t ntotalupdatesinEv=0;
401 Int_t nnoisesdigitsinEv=0;
402 Int_t nsignalsdigitsinEv=0;
016e1f91 403
5919c40c 404 TParticle *particle;
016e1f91 405 //AliTOFhit *tofHit;
7e6dce66 406 TClonesArray *tofHitArray = tof->Hits();
5919c40c 407
f73548c4 408 // create hit map
d3c7bfac 409 AliTOFHitMap *hitMap = new AliTOFHitMap(tof->SDigits(), fTOFGeometry);
5919c40c 410
7e6dce66 411 TBranch * tofHitsBranch = hitTree->GetBranch("TOF");
bfec09a6 412
7e6dce66 413 Int_t ntracks = static_cast<Int_t>(hitTree->GetEntries());
5919c40c 414 for (Int_t track = 0; track < ntracks; track++)
415 {
416 gAlice->ResetHits();
d7ccea72 417 tofHitsBranch->GetEvent(track);
0e46b9ae 418
419 AliMC *mcApplication = (AliMC*)gAlice->GetMCApp();
420
421 particle = mcApplication->Particle(track);
7e6dce66 422 Int_t nhits = tofHitArray->GetEntriesFast();
f73548c4 423 // cleaning all hits of the same track in the same pad volume
424 // it is a rare event, however it happens
425
d61f73d9 426 Int_t previousTrack =-1;
427 Int_t previousSector=-1;
428 Int_t previousPlate =-1;
429 Int_t previousStrip =-1;
430 Int_t previousPadX =-1;
431 Int_t previousPadZ =-1;
5919c40c 432
d61f73d9 433 for (Int_t hit = 0; hit < nhits; hit++) {
016e1f91 434 Int_t vol[5]; // location for a digit
435 Float_t digit[2]; // TOF digit variables
436 Int_t tracknum;
7e6dce66 437 Float_t dxPad;
438 Float_t dzPad;
016e1f91 439 Float_t geantTime;
440
441 // fp: really sorry for this, it is a temporary trick to have
442 // track length too
d3c7bfac 443 if(version!=6 && version!=7){
7e6dce66 444 AliTOFhit *tofHit = (AliTOFhit *) tofHitArray->UncheckedAt(hit);
016e1f91 445 tracknum = tofHit->GetTrack();
446 vol[0] = tofHit->GetSector();
447 vol[1] = tofHit->GetPlate();
448 vol[2] = tofHit->GetStrip();
449 vol[3] = tofHit->GetPadx();
450 vol[4] = tofHit->GetPadz();
7e6dce66 451 dxPad = tofHit->GetDx();
452 dzPad = tofHit->GetDz();
016e1f91 453 geantTime = tofHit->GetTof(); // unit [s]
454 } else {
7e6dce66 455 AliTOFhitT0 *tofHit = (AliTOFhitT0 *) tofHitArray->UncheckedAt(hit);
016e1f91 456 tracknum = tofHit->GetTrack();
457 vol[0] = tofHit->GetSector();
458 vol[1] = tofHit->GetPlate();
55991c8b 459 vol[2] = tofHit->GetStrip();
460 vol[3] = tofHit->GetPadx();
461 vol[4] = tofHit->GetPadz();
7e6dce66 462 dxPad = tofHit->GetDx();
463 dzPad = tofHit->GetDz();
016e1f91 464 geantTime = tofHit->GetTof(); // unit [s]
465 }
d61f73d9 466
016e1f91 467 geantTime *= 1.e+09; // conversion from [s] to [ns]
d61f73d9 468
016e1f91 469 // selection case for sdigitizing only hits in a given plate of a given sector
470 if(thereIsNotASelection || (vol[0]==fSelectedSector && vol[1]==fSelectedPlate)){
55991c8b 471
472 Bool_t dummy=((tracknum==previousTrack) && (vol[0]==previousSector) && (vol[1]==previousPlate) && (vol[2]==previousStrip));
473
474 Bool_t isCloneOfThePrevious=dummy && ((vol[3]==previousPadX) && (vol[4]==previousPadZ));
475
b213b8bd 476 Bool_t isNeighOfThePrevious=dummy && ((((vol[3]==previousPadX-1) || (vol[3]==previousPadX+1)) && (vol[4]==previousPadZ)) || ((vol[3]==previousPadX) && ((vol[4]==previousPadZ+1) || (vol[4]==previousPadZ-1))));
55991c8b 477
b213b8bd 478 if(!isCloneOfThePrevious && !isNeighOfThePrevious){
55991c8b 479 // update "previous" values
480 // in fact, we are yet in the future, so the present is past
481 previousTrack=tracknum;
482 previousSector=vol[0];
483 previousPlate=vol[1];
484 previousStrip=vol[2];
485 previousPadX=vol[3];
486 previousPadZ=vol[4];
487
488 nselectedHits++;
489 nselectedHitsinEv++;
d61f73d9 490 if (particle->GetFirstMother() < 0) nHitsFromPrim++; // counts hits due to primary particles
55991c8b 491
7e6dce66 492 Float_t xStrip=AliTOFGeometry::XPad()*(vol[3]+0.5-0.5*AliTOFGeometry::NpadX())+dxPad;
493 Float_t zStrip=AliTOFGeometry::ZPad()*(vol[4]+0.5-0.5*AliTOFGeometry::NpadZ())+dzPad;
016e1f91 494
55991c8b 495 Int_t nActivatedPads = 0, nFiredPads = 0;
496 Bool_t isFired[4] = {kFALSE, kFALSE, kFALSE, kFALSE};
497 Float_t tofAfterSimul[4] = {0., 0., 0., 0.};
498 Float_t qInduced[4] = {0.,0.,0.,0.};
499 Int_t nPlace[4] = {0, 0, 0, 0};
500 Float_t averageTime = 0.;
501 SimulateDetectorResponse(zStrip,xStrip,geantTime,nActivatedPads,nFiredPads,isFired,nPlace,qInduced,tofAfterSimul,averageTime);
502 if(nFiredPads) {
503 for(Int_t indexOfPad=0; indexOfPad<nActivatedPads; indexOfPad++) {
504 if(isFired[indexOfPad]){ // the pad has fired
505 Float_t timediff=geantTime-tofAfterSimul[indexOfPad];
506
507 if(timediff>=0.2) nlargeTofDiff++;
508
845fe446 509 digit[0] = (Int_t) ((tofAfterSimul[indexOfPad]*1.e+03)/AliTOFGeometry::TdcBinWidth()); // TDC bin number (each bin -> 24.4 ps)
55991c8b 510
511 Float_t landauFactor = gRandom->Landau(fAdcMean, fAdcRms);
512 digit[1] = (Int_t) (qInduced[indexOfPad] * landauFactor); // ADC bins (each bin -> 0.25 (or 0.03) pC)
d61f73d9 513
55991c8b 514 // recalculate the volume only for neighbouring pads
ea7a588a 515 if(indexOfPad){
0f4a7374 516 (nPlace[indexOfPad]<=AliTOFGeometry::NpadX()) ? vol[4] = 0 : vol[4] = 1;
517 (nPlace[indexOfPad]<=AliTOFGeometry::NpadX()) ? vol[3] = nPlace[indexOfPad] - 1 : vol[3] = nPlace[indexOfPad] - AliTOFGeometry::NpadX() - 1;
ea7a588a 518 }
d61f73d9 519 // check if two sdigit are on the same pad;
520 // in that case we sum the two or more sdigits
55991c8b 521 if (hitMap->TestHit(vol) != kEmpty) {
522 AliTOFSDigit *sdig = static_cast<AliTOFSDigit*>(hitMap->GetHit(vol));
523 Int_t tdctime = (Int_t) digit[0];
524 Int_t adccharge = (Int_t) digit[1];
43f77f2d 525 sdig->Update(AliTOFGeometry::TdcBinWidth(),tdctime,adccharge,tracknum);
55991c8b 526 ntotalupdatesinEv++;
527 ntotalupdates++;
528 } else {
529
7e6dce66 530 tof->AddSDigit(tracknum, vol, digit);
55991c8b 531
532 if(indexOfPad){
533 nnoisesdigits++;
534 nnoisesdigitsinEv++;
535 } else {
536 nsignalsdigits++;
537 nsignalsdigitsinEv++;
538 }
539 ntotalsdigitsinEv++;
540 ntotalsdigits++;
541 hitMap->SetHit(vol);
542 } // if (hitMap->TestHit(vol) != kEmpty)
543 } // if(isFired[indexOfPad])
544 } // end loop on nActivatedPads
545 } // if(nFiredPads) i.e. if some pads has fired
546 } // close if(!isCloneOfThePrevious)
547 } // close the selection on sector and plate
5919c40c 548 } // end loop on hits for the current track
549 } // end loop on ntracks
55991c8b 550
5919c40c 551 delete hitMap;
d61f73d9 552
553 fTOFLoader->TreeS()->Reset();
554 fTOFLoader->TreeS()->Fill();
555 fTOFLoader->WriteSDigits("OVERWRITE");
556
7e6dce66 557 if (tof->SDigits()) tof->ResetSDigits();
d61f73d9 558
559 if (strstr(verboseOption,"all")) {
d076c8d5 560 AliInfo("----------------------------------------");
561 AliInfo(" <AliTOFSDigitizer> ");
562 AliInfo(Form("After sdigitizing %d hits in event %d", nselectedHitsinEv, iEvent));
ea7a588a 563 //" (" << nHitsFromPrim << " from primaries and " << nHitsFromSec << " from secondaries) TOF hits, "
d076c8d5 564 AliInfo(Form("%d digits have been created", ntotalsdigitsinEv));
565 AliInfo(Form("(%d due to signals and %d due to border effect)", nsignalsdigitsinEv, nnoisesdigitsinEv));
566 AliInfo(Form("%d total updates of the hit map have been performed in current event", ntotalupdatesinEv));
567 AliInfo("----------------------------------------");
ea7a588a 568 }
569
570 } //event loop on events
571
d61f73d9 572 fTOFLoader->UnloadSDigits();
573 fTOFLoader->UnloadHits();
574 fRunLoader->UnloadKinematics();
e615b5b5 575 //fRunLoader->UnloadgAlice();
d61f73d9 576
ea7a588a 577 // free used memory
578 if (ftail){
579 delete ftail;
580 ftail = 0;
581 }
582
583 nHitsFromSec=nselectedHits-nHitsFromPrim;
584 if(strstr(verboseOption,"all")){
d076c8d5 585 AliInfo("----------------------------------------");
586 AliInfo("----------------------------------------");
587 AliInfo("-----------SDigitization Summary--------");
588 AliInfo(" <AliTOFSDigitizer> ");
589 AliInfo(Form("After sdigitizing %d hits", nselectedHits));
590 AliInfo(Form("in %d events", fEvent2-fEvent1));
ea7a588a 591//" (" << nHitsFromPrim << " from primaries and " << nHitsFromSec << " from secondaries) TOF hits, "
d076c8d5 592 AliInfo(Form("%d sdigits have been created", ntotalsdigits));
593 AliInfo(Form("(%d due to signals and "
594 "%d due to border effect)", nsignalsdigits, nnoisesdigits));
595 AliInfo(Form("%d total updates of the hit map have been performed", ntotalupdates));
596 AliInfo(Form("in %d cases the time of flight difference is greater than 200 ps", nlargeTofDiff));
ea7a588a 597 }
598
517b7f8f 599
ea7a588a 600 if(strstr(verboseOption,"tim") || strstr(verboseOption,"all")){
601 gBenchmark->Stop("TOFSDigitizer");
d076c8d5 602 AliInfo("AliTOFSDigitizer:");
603 AliInfo(Form(" took %f seconds in order to make sdigits "
604 "%f seconds per event", gBenchmark->GetCpuTime("TOFSDigitizer"), gBenchmark->GetCpuTime("TOFSDigitizer")/(fEvent2-fEvent1)));
605 AliInfo(" +++++++++++++++++++++++++++++++++++++++++++++++++++ ");
ea7a588a 606 }
517b7f8f 607
608}
ea7a588a 609
517b7f8f 610//__________________________________________________________________
5c016a7b 611void AliTOFSDigitizer::Print(Option_t* /*opt*/)const
517b7f8f 612{
0e46b9ae 613 AliInfo(Form(" ------------------- %s ------------- ", GetName()));
517b7f8f 614}
f73548c4 615
55991c8b 616//__________________________________________________________________
617void AliTOFSDigitizer::SelectSectorAndPlate(Int_t sector, Int_t plate)
618{
340693af 619 //Select sector and plate
0f4a7374 620 Bool_t isaWrongSelection=(sector < 0) || (sector >= AliTOFGeometry::NSectors()) || (plate < 0) || (plate >= AliTOFGeometry::NPlates());
55991c8b 621 if(isaWrongSelection){
d076c8d5 622 AliError("You have selected an invalid value for sector or plate ");
623 AliError(Form("The correct range for sector is [0,%d]", AliTOFGeometry::NSectors()-1));
624 AliError(Form("The correct range for plate is [0,%d]", AliTOFGeometry::NPlates()-1));
625 AliError("By default we continue sdigitizing all hits in all plates of all sectors");
55991c8b 626 } else {
627 fSelectedSector=sector;
628 fSelectedPlate =plate;
d076c8d5 629 AliInfo(Form("SDigitizing only hits in plate %d of the sector %d", fSelectedPlate, fSelectedSector));
55991c8b 630 }
631}
632
f73548c4 633//__________________________________________________________________
634void AliTOFSDigitizer::SimulateDetectorResponse(Float_t z0, Float_t x0, Float_t geantTime, Int_t& nActivatedPads, Int_t& nFiredPads, Bool_t* isFired, Int_t* nPlace, Float_t* qInduced, Float_t* tofTime, Float_t& averageTime)
635{
636 // Description:
637 // Input: z0, x0 - hit position in the strip system (0,0 - center of the strip), cm
638 // geantTime - time generated by Geant, ns
639 // Output: nActivatedPads - the number of pads activated by the hit (1 || 2 || 4)
640 // nFiredPads - the number of pads fired (really activated) by the hit (nFiredPads <= nActivatedPads)
641 // qInduced[iPad]- charge induced on pad, arb. units
642 // this array is initialized at zero by the caller
643 // tofAfterSimul[iPad] - time calculated with edge effect algorithm, ns
644 // this array is initialized at zero by the caller
645 // averageTime - time given by pad hited by the Geant track taking into account the times (weighted) given by the pads fired for edge effect also.
646 // The weight is given by the qInduced[iPad]/qCenterPad
647 // this variable is initialized at zero by the caller
648 // nPlace[iPad] - the number of the pad place, iPad = 0, 1, 2, 3
649 // this variable is initialized at zero by the caller
650 //
651 // Description of used variables:
652 // eff[iPad] - efficiency of the pad
653 // res[iPad] - resolution of the pad, ns
654 // timeWalk[iPad] - time walk of the pad, ns
655 // timeDelay[iPad] - time delay for neighbouring pad to hited pad, ns
656 // PadId[iPad] - Pad Identifier
657 // E | F --> PadId[iPad] = 5 | 6
658 // A | B --> PadId[iPad] = 1 | 2
659 // C | D --> PadId[iPad] = 3 | 4
660 // nTail[iPad] - the tail number, = 1 for tailA, = 2 for tailB
661 // qCenterPad - charge extimated for each pad, arb. units
662 // weightsSum - sum of weights extimated for each pad fired, arb. units
663
0f4a7374 664 const Float_t kSigmaForTail[2] = {AliTOFGeometry::SigmaForTail1(),AliTOFGeometry::SigmaForTail2()}; //for tail
f73548c4 665 Int_t iz = 0, ix = 0;
666 Float_t dX = 0., dZ = 0., x = 0., z = 0.;
667 Float_t h = fHparameter, h2 = fH2parameter, k = fKparameter, k2 = fK2parameter;
668 Float_t effX = 0., effZ = 0., resX = 0., resZ = 0., timeWalkX = 0., timeWalkZ = 0.;
669 Float_t logOfqInd = 0.;
670 Float_t weightsSum = 0.;
671 Int_t nTail[4] = {0,0,0,0};
672 Int_t padId[4] = {0,0,0,0};
673 Float_t eff[4] = {0.,0.,0.,0.};
674 Float_t res[4] = {0.,0.,0.,0.};
675 // Float_t qCenterPad = fMinimumCharge * fMinimumCharge;
676 Float_t qCenterPad = 1.;
677 Float_t timeWalk[4] = {0.,0.,0.,0.};
678 Float_t timeDelay[4] = {0.,0.,0.,0.};
679
680 nActivatedPads = 0;
681 nFiredPads = 0;
682
683 (z0 <= 0) ? iz = 0 : iz = 1;
0f4a7374 684 dZ = z0 + (0.5 * AliTOFGeometry::NpadZ() - iz - 0.5) * AliTOFGeometry::ZPad(); // hit position in the pad frame, (0,0) - center of the pad
685 z = 0.5 * AliTOFGeometry::ZPad() - TMath::Abs(dZ); // variable for eff., res. and timeWalk. functions
686 iz++; // z row: 1, ..., AliTOFGeometry::NpadZ = 2
687 ix = (Int_t)((x0 + 0.5 * AliTOFGeometry::NpadX() * AliTOFGeometry::XPad()) / AliTOFGeometry::XPad());
688 dX = x0 + (0.5 * AliTOFGeometry::NpadX() - ix - 0.5) * AliTOFGeometry::XPad(); // hit position in the pad frame, (0,0) - center of the pad
689 x = 0.5 * AliTOFGeometry::XPad() - TMath::Abs(dX); // variable for eff., res. and timeWalk. functions;
690 ix++; // x row: 1, ..., AliTOFGeometry::NpadX = 48
f73548c4 691
692 ////// Pad A:
693 nActivatedPads++;
0f4a7374 694 nPlace[nActivatedPads-1] = (iz - 1) * AliTOFGeometry::NpadX() + ix;
f73548c4 695 qInduced[nActivatedPads-1] = qCenterPad;
696 padId[nActivatedPads-1] = 1;
697
698 if (fEdgeEffect == 0) {
699 eff[nActivatedPads-1] = fEffCenter;
700 if (gRandom->Rndm() < eff[nActivatedPads-1]) {
701 nFiredPads = 1;
7e6dce66 702 res[nActivatedPads-1] = 0.001 * TMath::Sqrt(fAddTRes*fAddTRes + fResCenter * fResCenter); // ns
f73548c4 703 isFired[nActivatedPads-1] = kTRUE;
704 tofTime[nActivatedPads-1] = gRandom->Gaus(geantTime + fTimeWalkCenter, res[0]);
705 averageTime = tofTime[nActivatedPads-1];
706 }
707 } else {
708
709 if(z < h) {
710 if(z < h2) {
711 effZ = fEffBoundary + (fEff2Boundary - fEffBoundary) * z / h2;
712 } else {
713 effZ = fEff2Boundary + (fEffCenter - fEff2Boundary) * (z - h2) / (h - h2);
714 }
715 resZ = fResBoundary + (fResCenter - fResBoundary) * z / h;
716 timeWalkZ = fTimeWalkBoundary + (fTimeWalkCenter - fTimeWalkBoundary) * z / h;
717 nTail[nActivatedPads-1] = 1;
718 } else {
719 effZ = fEffCenter;
720 resZ = fResCenter;
721 timeWalkZ = fTimeWalkCenter;
722 }
723
724 if(x < h) {
725 if(x < h2) {
726 effX = fEffBoundary + (fEff2Boundary - fEffBoundary) * x / h2;
727 } else {
728 effX = fEff2Boundary + (fEffCenter - fEff2Boundary) * (x - h2) / (h - h2);
729 }
730 resX = fResBoundary + (fResCenter - fResBoundary) * x / h;
731 timeWalkX = fTimeWalkBoundary + (fTimeWalkCenter - fTimeWalkBoundary) * x / h;
732 nTail[nActivatedPads-1] = 1;
733 } else {
734 effX = fEffCenter;
735 resX = fResCenter;
736 timeWalkX = fTimeWalkCenter;
737 }
738
739 (effZ<effX) ? eff[nActivatedPads-1] = effZ : eff[nActivatedPads-1] = effX;
7e6dce66 740 (resZ<resX) ? res[nActivatedPads-1] = 0.001 * TMath::Sqrt(fAddTRes*fAddTRes + resX * resX) : res[nActivatedPads-1] = 0.001 * TMath::Sqrt(fAddTRes*fAddTRes + resZ * resZ); // ns
f73548c4 741 (timeWalkZ<timeWalkX) ? timeWalk[nActivatedPads-1] = 0.001 * timeWalkZ : timeWalk[nActivatedPads-1] = 0.001 * timeWalkX; // ns
742
743
744 ////// Pad B:
745 if(z < k2) {
746 effZ = fEffBoundary - (fEffBoundary - fEff3Boundary) * (z / k2);
747 } else {
748 effZ = fEff3Boundary * (k - z) / (k - k2);
749 }
750 resZ = fResBoundary + fResSlope * z / k;
751 timeWalkZ = fTimeWalkBoundary + fTimeWalkSlope * z / k;
752
753 if(z < k && z > 0) {
754 if( (iz == 1 && dZ > 0) || (iz == 2 && dZ < 0) ) {
755 nActivatedPads++;
0f4a7374 756 nPlace[nActivatedPads-1] = nPlace[0] + (3 - 2 * iz) * AliTOFGeometry::NpadX();
f73548c4 757 eff[nActivatedPads-1] = effZ;
7e6dce66 758 res[nActivatedPads-1] = 0.001 * TMath::Sqrt(fAddTRes*fAddTRes + resZ * resZ); // ns
f73548c4 759 timeWalk[nActivatedPads-1] = 0.001 * timeWalkZ; // ns
760 nTail[nActivatedPads-1] = 2;
761 if (fTimeDelayFlag) {
762 // qInduced[0] = fMinimumCharge * TMath::Exp(fPulseHeightSlope * z / 2.);
763 // qInduced[nActivatedPads-1] = fMinimumCharge * TMath::Exp(-fPulseHeightSlope * z / 2.);
764 qInduced[nActivatedPads-1] = TMath::Exp(-fPulseHeightSlope * z);
765 logOfqInd = gRandom->Gaus(-fPulseHeightSlope * z, fLogChargeSmearing);
766 timeDelay[nActivatedPads-1] = gRandom->Gaus(-fTimeDelaySlope * logOfqInd, fTimeSmearing);
767 } else {
768 timeDelay[nActivatedPads-1] = 0.;
769 }
770 padId[nActivatedPads-1] = 2;
771 }
772 }
773
774
775 ////// Pad C, D, E, F:
776 if(x < k2) {
777 effX = fEffBoundary - (fEffBoundary - fEff3Boundary) * (x / k2);
778 } else {
779 effX = fEff3Boundary * (k - x) / (k - k2);
780 }
781 resX = fResBoundary + fResSlope*x/k;
782 timeWalkX = fTimeWalkBoundary + fTimeWalkSlope*x/k;
783
784 if(x < k && x > 0) {
785 // C:
786 if(ix > 1 && dX < 0) {
787 nActivatedPads++;
788 nPlace[nActivatedPads-1] = nPlace[0] - 1;
789 eff[nActivatedPads-1] = effX;
7e6dce66 790 res[nActivatedPads-1] = 0.001 * TMath::Sqrt(fAddTRes*fAddTRes + resX * resX); // ns
f73548c4 791 timeWalk[nActivatedPads-1] = 0.001 * timeWalkX; // ns
792 nTail[nActivatedPads-1] = 2;
793 if (fTimeDelayFlag) {
794 // qInduced[0] = fMinimumCharge * TMath::Exp(fPulseHeightSlope * x / 2.);
795 // qInduced[nActivatedPads-1] = fMinimumCharge * TMath::Exp(-fPulseHeightSlope * x / 2.);
796 qInduced[nActivatedPads-1] = TMath::Exp(-fPulseHeightSlope * x);
797 logOfqInd = gRandom->Gaus(-fPulseHeightSlope * x, fLogChargeSmearing);
798 timeDelay[nActivatedPads-1] = gRandom->Gaus(-fTimeDelaySlope * logOfqInd, fTimeSmearing);
799 } else {
800 timeDelay[nActivatedPads-1] = 0.;
801 }
802 padId[nActivatedPads-1] = 3;
803
804 // D:
805 if(z < k && z > 0) {
806 if( (iz == 1 && dZ > 0) || (iz == 2 && dZ < 0) ) {
807 nActivatedPads++;
0f4a7374 808 nPlace[nActivatedPads-1] = nPlace[0] + (3 - 2 * iz) * AliTOFGeometry::NpadX() - 1;
f73548c4 809 eff[nActivatedPads-1] = effX * effZ;
7e6dce66 810 (resZ<resX) ? res[nActivatedPads-1] = 0.001 * TMath::Sqrt(fAddTRes*fAddTRes + resX * resX) : res[nActivatedPads-1] = 0.001 * TMath::Sqrt(fAddTRes*fAddTRes + resZ * resZ); // ns
f73548c4 811 (timeWalkZ<timeWalkX) ? timeWalk[nActivatedPads-1] = 0.001 * timeWalkZ : timeWalk[nActivatedPads-1] = 0.001 * timeWalkX; // ns
812
813 nTail[nActivatedPads-1] = 2;
814 if (fTimeDelayFlag) {
815 if (TMath::Abs(x) < TMath::Abs(z)) {
816 // qInduced[0] = fMinimumCharge * TMath::Exp(fPulseHeightSlope * z / 2.);
817 // qInduced[nActivatedPads-1] = fMinimumCharge * TMath::Exp(-fPulseHeightSlope * z / 2.);
818 qInduced[nActivatedPads-1] = TMath::Exp(-fPulseHeightSlope * z);
819 logOfqInd = gRandom->Gaus(-fPulseHeightSlope * z, fLogChargeSmearing);
820 } else {
821 // qInduced[0] = fMinimumCharge * TMath::Exp(fPulseHeightSlope * x / 2.);
822 // qInduced[nActivatedPads-1] = fMinimumCharge * TMath::Exp(-fPulseHeightSlope * x / 2.);
823 qInduced[nActivatedPads-1] = TMath::Exp(-fPulseHeightSlope * x);
824 logOfqInd = gRandom->Gaus(-fPulseHeightSlope * x, fLogChargeSmearing);
825 }
826 timeDelay[nActivatedPads-1] = gRandom->Gaus(-fTimeDelaySlope * logOfqInd, fTimeSmearing);
827 } else {
828 timeDelay[nActivatedPads-1] = 0.;
829 }
830 padId[nActivatedPads-1] = 4;
831 }
832 } // end D
833 } // end C
834
835 // E:
0f4a7374 836 if(ix < AliTOFGeometry::NpadX() && dX > 0) {
f73548c4 837 nActivatedPads++;
838 nPlace[nActivatedPads-1] = nPlace[0] + 1;
839 eff[nActivatedPads-1] = effX;
7e6dce66 840 res[nActivatedPads-1] = 0.001 * (TMath::Sqrt(fAddTRes*fAddTRes + resX * resX)); // ns
f73548c4 841 timeWalk[nActivatedPads-1] = 0.001 * timeWalkX; // ns
842 nTail[nActivatedPads-1] = 2;
843 if (fTimeDelayFlag) {
844 // qInduced[0] = fMinimumCharge * TMath::Exp(fPulseHeightSlope * x / 2.);
845 // qInduced[nActivatedPads-1] = fMinimumCharge * TMath::Exp(-fPulseHeightSlope * x / 2.);
846 qInduced[nActivatedPads-1] = TMath::Exp(-fPulseHeightSlope * x);
847 logOfqInd = gRandom->Gaus(-fPulseHeightSlope * x, fLogChargeSmearing);
848 timeDelay[nActivatedPads-1] = gRandom->Gaus(-fTimeDelaySlope * logOfqInd, fTimeSmearing);
849 } else {
850 timeDelay[nActivatedPads-1] = 0.;
851 }
852 padId[nActivatedPads-1] = 5;
853
854
855 // F:
856 if(z < k && z > 0) {
857 if( (iz == 1 && dZ > 0) || (iz == 2 && dZ < 0) ) {
858 nActivatedPads++;
0f4a7374 859 nPlace[nActivatedPads - 1] = nPlace[0] + (3 - 2 * iz) * AliTOFGeometry::NpadX() + 1;
f73548c4 860 eff[nActivatedPads - 1] = effX * effZ;
7e6dce66 861 (resZ<resX) ? res[nActivatedPads-1] = 0.001 * TMath::Sqrt(fAddTRes*fAddTRes + resX * resX) : res[nActivatedPads-1] = 0.001 * TMath::Sqrt(fAddTRes*fAddTRes + resZ * resZ); // ns
f73548c4 862 (timeWalkZ<timeWalkX) ? timeWalk[nActivatedPads-1] = 0.001 * timeWalkZ : timeWalk[nActivatedPads-1] = 0.001*timeWalkX; // ns
863 nTail[nActivatedPads-1] = 2;
864 if (fTimeDelayFlag) {
865 if (TMath::Abs(x) < TMath::Abs(z)) {
866 // qInduced[0] = fMinimumCharge * TMath::Exp(fPulseHeightSlope * z / 2.);
867 // qInduced[nActivatedPads-1] = fMinimumCharge * TMath::Exp(-fPulseHeightSlope * z / 2.);
868 qInduced[nActivatedPads-1] = TMath::Exp(-fPulseHeightSlope * z);
869 logOfqInd = gRandom->Gaus(-fPulseHeightSlope * z, fLogChargeSmearing);
870 } else {
871 // qInduced[0] = fMinimumCharge * TMath::Exp(fPulseHeightSlope * x / 2.);
872 // qInduced[nActivatedPads-1] = fMinimumCharge * TMath::Exp(-fPulseHeightSlope * x / 2.);
873 qInduced[nActivatedPads-1] = TMath::Exp(-fPulseHeightSlope * x);
874 logOfqInd = gRandom->Gaus(-fPulseHeightSlope * x, fLogChargeSmearing);
875 }
876 timeDelay[nActivatedPads-1] = gRandom->Gaus(-fTimeDelaySlope * logOfqInd, fTimeSmearing);
877 } else {
878 timeDelay[nActivatedPads-1] = 0.;
879 }
880 padId[nActivatedPads-1] = 6;
881 }
882 } // end F
883 } // end E
884 } // end if(x < k)
885
886
887 for (Int_t iPad = 0; iPad < nActivatedPads; iPad++) {
888 if (res[iPad] < fTimeResolution) res[iPad] = fTimeResolution;
889 if(gRandom->Rndm() < eff[iPad]) {
890 isFired[iPad] = kTRUE;
891 nFiredPads++;
892 if(fEdgeTails) {
893 if(nTail[iPad] == 0) {
894 tofTime[iPad] = gRandom->Gaus(geantTime + timeWalk[iPad] + timeDelay[iPad], res[iPad]);
895 } else {
896 ftail->SetParameters(res[iPad], 2. * res[iPad], kSigmaForTail[nTail[iPad]-1]);
897 Double_t timeAB = ftail->GetRandom();
898 tofTime[iPad] = geantTime + timeWalk[iPad] + timeDelay[iPad] + timeAB;
899 }
900 } else {
901 tofTime[iPad] = gRandom->Gaus(geantTime + timeWalk[iPad] + timeDelay[iPad], res[iPad]);
902 }
903 if (fAverageTimeFlag) {
904 averageTime += tofTime[iPad] * qInduced[iPad];
905 weightsSum += qInduced[iPad];
906 } else {
907 averageTime += tofTime[iPad];
908 weightsSum += 1.;
909 }
910 }
911 }
912 if (weightsSum!=0) averageTime /= weightsSum;
913 } // end else (fEdgeEffect != 0)
914}
915
916//__________________________________________________________________
917void AliTOFSDigitizer::PrintParameters()const
918{
919 //
920 // Print parameters used for sdigitization
921 //
0e46b9ae 922 AliInfo(Form(" ------------------- %s -------------", GetName()));
923 AliInfo(" Parameters used for TOF SDigitization ");
f73548c4 924 // Printing the parameters
925
0e46b9ae 926 AliInfo(Form(" Number of events: %i ", (fEvent2-fEvent1)));
927 AliInfo(Form(" from event %i to event %i", fEvent1, (fEvent2-1)));
928 AliInfo(Form(" Time Resolution (ns) %d Pad Efficiency: %d ", fTimeResolution, fpadefficiency));
929 AliInfo(Form(" Edge Effect option: %d", fEdgeEffect));
930
931 AliInfo(" Boundary Effect Simulation Parameters ");
932 AliInfo(Form(" Hparameter: %d H2parameter: %d Kparameter: %d K2parameter: %d", fHparameter, fH2parameter, fKparameter, fK2parameter));
933 AliInfo(Form(" Efficiency in the central region of the pad: %d", fEffCenter));
934 AliInfo(Form(" Efficiency at the boundary region of the pad: %d", fEffBoundary));
935 AliInfo(Form(" Efficiency value at H2parameter %d", fEff2Boundary));
936 AliInfo(Form(" Efficiency value at K2parameter %d", fEff3Boundary));
937 AliInfo(Form(" Resolution (ps) in the central region of the pad: %d", fResCenter));
938 AliInfo(Form(" Resolution (ps) at the boundary of the pad : %d", fResBoundary));
939 AliInfo(Form(" Slope (ps/K) for neighbouring pad : %d", fResSlope));
940 AliInfo(Form(" Time walk (ps) in the central region of the pad : %d", fTimeWalkCenter));
941 AliInfo(Form(" Time walk (ps) at the boundary of the pad : %d", fTimeWalkBoundary));
942 AliInfo(Form(" Slope (ps/K) for neighbouring pad : %d", fTimeWalkSlope));
943 AliInfo(" Pulse Heigth Simulation Parameters ");
944 AliInfo(Form(" Flag for delay due to the PulseHeightEffect : %d", fTimeDelayFlag));
945 AliInfo(Form(" Pulse Height Slope : %d", fPulseHeightSlope));
946 AliInfo(Form(" Time Delay Slope : %d", fTimeDelaySlope));
947 AliInfo(Form(" Minimum charge amount which could be induced : %d", fMinimumCharge));
948 AliInfo(Form(" Smearing in charge in (q1/q2) vs x plot : %d", fChargeSmearing));
949 AliInfo(Form(" Smearing in log of charge ratio : %d", fLogChargeSmearing));
950 AliInfo(Form(" Smearing in time in time vs log(q1/q2) plot : %d", fTimeSmearing));
951 AliInfo(Form(" Flag for average time : %d", fAverageTimeFlag));
952 AliInfo(Form(" Edge tails option : %d", fEdgeTails));
f73548c4 953
954}