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