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