Initial calibration coefficients for beam test 2006 (B.Polichtchouk)
[u/mrichter/AliRoot.git] / TRD / AliTRDdigitizer.cxx
CommitLineData
f7336fa3 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$ */
f7336fa3 17
18///////////////////////////////////////////////////////////////////////////////
19// //
20// Creates and handles digits from TRD hits //
b08ed1cf 21// Authors: C. Blume (blume@ikf.uni-frankfurt.de) //
22// C. Lippmann //
23// B. Vulpescu //
f7336fa3 24// //
25// The following effects are included: //
26// - Diffusion //
27// - ExB effects //
28// - Gas gain including fluctuations //
29// - Pad-response (simple Gaussian approximation) //
abaf1f1d 30// - Time-response //
f7336fa3 31// - Electronics noise //
32// - Electronics gain //
33// - Digitization //
34// - ADC threshold //
35// The corresponding parameter can be adjusted via the various //
36// Set-functions. If these parameters are not explicitly set, default //
37// values are used (see Init-function). //
f7336fa3 38// //
39///////////////////////////////////////////////////////////////////////////////
40
6798b56e 41#include <stdlib.h>
42
f7336fa3 43#include <TMath.h>
44#include <TVector.h>
45#include <TRandom.h>
94de3818 46#include <TROOT.h>
47#include <TTree.h>
793ff80c 48#include <TFile.h>
49#include <TF1.h>
abaf1f1d 50#include <TList.h>
85cbec76 51#include <TTask.h>
3becff3c 52#include <TGeoManager.h>
793ff80c 53
54#include "AliRun.h"
88cb7938 55#include "AliRunLoader.h"
56#include "AliLoader.h"
57#include "AliConfig.h"
db30bf0f 58#include "AliMagF.h"
85cbec76 59#include "AliRunDigitizer.h"
88cb7938 60#include "AliRunLoader.h"
61#include "AliLoader.h"
ad2cc20b 62#include "AliLog.h"
f7336fa3 63
64#include "AliTRD.h"
793ff80c 65#include "AliTRDhit.h"
f7336fa3 66#include "AliTRDdigitizer.h"
da581aea 67#include "AliTRDdataArrayI.h"
68#include "AliTRDdataArrayF.h"
793ff80c 69#include "AliTRDsegmentArray.h"
da581aea 70#include "AliTRDdigitsManager.h"
793ff80c 71#include "AliTRDgeometry.h"
a5cadd36 72#include "AliTRDpadPlane.h"
3551db50 73#include "AliTRDcalibDB.h"
74#include "AliTRDSimParam.h"
75#include "AliTRDCommonParam.h"
f7336fa3 76
77ClassImp(AliTRDdigitizer)
78
79//_____________________________________________________________________________
85cbec76 80AliTRDdigitizer::AliTRDdigitizer()
4d18a639 81 :AliDigitizer()
82 ,fRunLoader(0)
83 ,fDigitsManager(0)
84 ,fSDigitsManager(0)
85 ,fSDigitsManagerList(0)
86 ,fTRD(0)
87 ,fGeo(0)
88 ,fEvent(0)
89 ,fMasks(0)
90 ,fCompress(kTRUE)
91 ,fSDigits(kFALSE)
92 ,fSDigitsScale(0.0)
93 ,fMergeSignalOnly(kFALSE)
94 ,fDiffLastVdrift(0)
95 ,fDiffusionT(0.0)
96 ,fDiffusionL(0.0)
97 ,fOmegaTau(0.0)
98 ,fLorentzFactor(0.0)
99 ,fTimeLastVdrift(0)
100 ,fTimeStruct1(0)
101 ,fTimeStruct2(0)
102 ,fVDlo(0)
103 ,fVDhi(0)
f7336fa3 104{
105 //
106 // AliTRDdigitizer default constructor
107 //
3551db50 108
109 Init();
3becff3c 110
f7336fa3 111}
112
113//_____________________________________________________________________________
4d18a639 114AliTRDdigitizer::AliTRDdigitizer(const Text_t *name, const Text_t *title)
115 :AliDigitizer(name,title)
116 ,fRunLoader(0)
117 ,fDigitsManager(0)
118 ,fSDigitsManager(0)
119 ,fSDigitsManagerList(0)
120 ,fTRD(0)
121 ,fGeo(0)
122 ,fEvent(0)
123 ,fMasks(0)
124 ,fCompress(kTRUE)
125 ,fSDigits(kFALSE)
126 ,fSDigitsScale(0.0)
127 ,fMergeSignalOnly(kFALSE)
128 ,fDiffLastVdrift(0)
129 ,fDiffusionT(0.0)
130 ,fDiffusionL(0.0)
131 ,fOmegaTau(0.0)
132 ,fLorentzFactor(0.0)
133 ,fTimeLastVdrift(0)
134 ,fTimeStruct1(0)
135 ,fTimeStruct2(0)
136 ,fVDlo(0)
137 ,fVDhi(0)
f7336fa3 138{
139 //
85cbec76 140 // AliTRDdigitizer constructor
141 //
142
3551db50 143 Init();
3becff3c 144
85cbec76 145}
146
147//_____________________________________________________________________________
148AliTRDdigitizer::AliTRDdigitizer(AliRunDigitizer *manager
4d18a639 149 , const Text_t *name, const Text_t *title)
150 :AliDigitizer(manager,name,title)
151 ,fRunLoader(0)
152 ,fDigitsManager(0)
153 ,fSDigitsManager(0)
154 ,fSDigitsManagerList(0)
155 ,fTRD(0)
156 ,fGeo(0)
157 ,fEvent(0)
158 ,fMasks(0)
159 ,fCompress(kTRUE)
160 ,fSDigits(kFALSE)
161 ,fSDigitsScale(0.0)
162 ,fMergeSignalOnly(kFALSE)
163 ,fDiffLastVdrift(0)
164 ,fDiffusionT(0.0)
165 ,fDiffusionL(0.0)
166 ,fOmegaTau(0.0)
167 ,fLorentzFactor(0.0)
168 ,fTimeLastVdrift(0)
169 ,fTimeStruct1(0)
170 ,fTimeStruct2(0)
171 ,fVDlo(0)
172 ,fVDhi(0)
85cbec76 173{
174 //
175 // AliTRDdigitizer constructor
f7336fa3 176 //
177
3551db50 178 Init();
3becff3c 179
bfc40adc 180}
181
182//_____________________________________________________________________________
183AliTRDdigitizer::AliTRDdigitizer(AliRunDigitizer *manager)
4d18a639 184 :AliDigitizer(manager,"AliTRDdigitizer","TRD digitizer")
185 ,fRunLoader(0)
186 ,fDigitsManager(0)
187 ,fSDigitsManager(0)
188 ,fSDigitsManagerList(0)
189 ,fTRD(0)
190 ,fGeo(0)
191 ,fEvent(0)
192 ,fMasks(0)
193 ,fCompress(kTRUE)
194 ,fSDigits(kFALSE)
195 ,fSDigitsScale(0.0)
196 ,fMergeSignalOnly(kFALSE)
197 ,fDiffLastVdrift(0)
198 ,fDiffusionT(0.0)
199 ,fDiffusionL(0.0)
200 ,fOmegaTau(0.0)
201 ,fLorentzFactor(0.0)
202 ,fTimeLastVdrift(0)
203 ,fTimeStruct1(0)
204 ,fTimeStruct2(0)
205 ,fVDlo(0)
206 ,fVDhi(0)
bfc40adc 207{
208 //
209 // AliTRDdigitizer constructor
210 //
211
3551db50 212 Init();
3becff3c 213
3551db50 214}
88cb7938 215
3551db50 216//_____________________________________________________________________________
217Bool_t AliTRDdigitizer::Init()
218{
3becff3c 219 //
220 // Initialize the digitizer with default values
221 //
222
85a5290f 223 fRunLoader = 0;
4487dad0 224 fDigitsManager = 0;
4487dad0 225 fSDigitsManager = 0;
85a5290f 226 fSDigitsManagerList = 0;
4487dad0 227 fTRD = 0;
228 fGeo = 0;
3becff3c 229
abaf1f1d 230 fEvent = 0;
85a5290f 231 fMasks = 0;
abaf1f1d 232 fCompress = kTRUE;
abaf1f1d 233 fSDigits = kFALSE;
4d18a639 234 fSDigitsScale = 100.0;
4487dad0 235 fMergeSignalOnly = kFALSE;
3551db50 236
4d18a639 237 fTimeLastVdrift = -1;
238 fTimeStruct1 = 0;
239 fTimeStruct2 = 0;
240 fVDlo = 0;
241 fVDhi = 0;
3551db50 242
4d18a639 243 fDiffLastVdrift = -1;
244 fDiffusionT = 0.0;
245 fDiffusionL = 0.0;
246 fLorentzFactor = 0.0;
793ff80c 247
3551db50 248 return AliDigitizer::Init();
3becff3c 249
f7336fa3 250}
251
252//_____________________________________________________________________________
4d18a639 253AliTRDdigitizer::AliTRDdigitizer(const AliTRDdigitizer &d)
254 :AliDigitizer(d)
255 ,fRunLoader(0)
256 ,fDigitsManager(0)
257 ,fSDigitsManager(0)
258 ,fSDigitsManagerList(0)
259 ,fTRD(0)
260 ,fGeo(0)
261 ,fEvent(0)
262 ,fMasks(0)
263 ,fCompress(d.fCompress)
264 ,fSDigits(d.fSDigits)
265 ,fSDigitsScale(d.fSDigitsScale)
266 ,fMergeSignalOnly(d.fMergeSignalOnly)
267 ,fDiffLastVdrift(-1)
268 ,fDiffusionT(0.0)
269 ,fDiffusionL(0.0)
270 ,fOmegaTau(0.0)
271 ,fLorentzFactor(0.0)
272 ,fTimeLastVdrift(-1)
273 ,fTimeStruct1(0)
274 ,fTimeStruct2(0)
275 ,fVDlo(0)
276 ,fVDhi(0)
8230f242 277{
278 //
279 // AliTRDdigitizer copy constructor
280 //
281
4d18a639 282 // Do not copy timestructs, just invalidate lastvdrift.
283 // Next time they are requested, they get recalculated
284 if (((AliTRDdigitizer &) d).fTimeStruct1) {
285 delete [] ((AliTRDdigitizer &) d).fTimeStruct1;
286 ((AliTRDdigitizer &) d).fTimeStruct1 = 0;
287 }
288 if (((AliTRDdigitizer &) d).fTimeStruct2) {
289 delete [] ((AliTRDdigitizer &) d).fTimeStruct2;
290 ((AliTRDdigitizer &) d).fTimeStruct2 = 0;
291 }
8230f242 292
293}
294
295//_____________________________________________________________________________
f7336fa3 296AliTRDdigitizer::~AliTRDdigitizer()
297{
8230f242 298 //
299 // AliTRDdigitizer destructor
300 //
f7336fa3 301
abaf1f1d 302 if (fDigitsManager) {
303 delete fDigitsManager;
4d18a639 304 fDigitsManager = 0;
f7336fa3 305 }
306
4d18a639 307 if (fDigitsManager) {
308 delete fSDigitsManager;
309 fSDigitsManager = 0;
310 }
f7336fa3 311
abaf1f1d 312 if (fSDigitsManagerList) {
47b5729a 313 fSDigitsManagerList->Delete();
abaf1f1d 314 delete fSDigitsManagerList;
4487dad0 315 fSDigitsManagerList = 0;
e23fbb27 316 }
317
318 if (fMasks) {
319 delete [] fMasks;
320 fMasks = 0;
321 }
322
4d18a639 323 if (fTimeStruct1) {
324 delete [] fTimeStruct1;
325 fTimeStruct1 = 0;
3551db50 326 }
327
4d18a639 328 if (fTimeStruct2) {
329 delete [] fTimeStruct2;
330 fTimeStruct2 = 0;
3551db50 331 }
3becff3c 332
f7336fa3 333}
334
335//_____________________________________________________________________________
dd9a6ee3 336AliTRDdigitizer &AliTRDdigitizer::operator=(const AliTRDdigitizer &d)
337{
338 //
339 // Assignment operator
340 //
341
342 if (this != &d) ((AliTRDdigitizer &) d).Copy(*this);
4d18a639 343
dd9a6ee3 344 return *this;
345
346}
347
348//_____________________________________________________________________________
e0d47c25 349void AliTRDdigitizer::Copy(TObject &d) const
8230f242 350{
351 //
352 // Copy function
353 //
354
85a5290f 355 ((AliTRDdigitizer &) d).fRunLoader = 0;
4487dad0 356 ((AliTRDdigitizer &) d).fDigitsManager = 0;
85a5290f 357 ((AliTRDdigitizer &) d).fSDigitsManager = 0;
358 ((AliTRDdigitizer &) d).fSDigitsManagerList = 0;
4487dad0 359 ((AliTRDdigitizer &) d).fTRD = 0;
360 ((AliTRDdigitizer &) d).fGeo = 0;
85a5290f 361 ((AliTRDdigitizer &) d).fEvent = 0;
362 ((AliTRDdigitizer &) d).fMasks = 0;
abaf1f1d 363 ((AliTRDdigitizer &) d).fCompress = fCompress;
abaf1f1d 364 ((AliTRDdigitizer &) d).fSDigits = fSDigits;
365 ((AliTRDdigitizer &) d).fSDigitsScale = fSDigitsScale;
4487dad0 366 ((AliTRDdigitizer &) d).fMergeSignalOnly = fMergeSignalOnly;
0c24ba98 367
3551db50 368 AliTRDdigitizer& target = (AliTRDdigitizer &) d;
369
3becff3c 370 // Do not copy timestructs, just invalidate lastvdrift.
371 // Next time they are requested, they get recalculated
4d18a639 372 if (target.fTimeStruct1) {
373 delete[] target.fTimeStruct1;
374 target.fTimeStruct1 = 0;
3551db50 375 }
4d18a639 376 if (target.fTimeStruct2) {
377 delete[] target.fTimeStruct2;
378 target.fTimeStruct2 = 0;
3becff3c 379 }
4d18a639 380 target.fTimeLastVdrift = -1;
3becff3c 381
e23fbb27 382}
383
384//_____________________________________________________________________________
4d18a639 385void AliTRDdigitizer::Exec(Option_t *option)
e23fbb27 386{
387 //
388 // Executes the merging
389 //
390
391 Int_t iInput;
392
393 AliTRDdigitsManager *sdigitsManager;
394
395 TString optionString = option;
396 if (optionString.Contains("deb")) {
9afbd7de 397 AliLog::SetClassDebugLevel("AliTRDdigitizer",1);
398 AliInfo("Called with debug option\n");
e23fbb27 399 }
400
cec4059b 401 // The AliRoot file is already connected by the manager
4d18a639 402 AliRunLoader *inrl;
88cb7938 403
9afbd7de 404 if (gAlice) {
405 AliDebug(1,"AliRun object found on file.\n");
406 }
4487dad0 407 else {
88cb7938 408 inrl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(0));
409 inrl->LoadgAlice();
410 gAlice = inrl->GetAliRun();
9afbd7de 411 if (!gAlice) {
412 AliError("Could not find AliRun object.\n")
413 return;
414 }
4487dad0 415 }
cec4059b 416
e23fbb27 417 Int_t nInput = fManager->GetNinputs();
4d18a639 418 fMasks = new Int_t[nInput];
e23fbb27 419 for (iInput = 0; iInput < nInput; iInput++) {
420 fMasks[iInput] = fManager->GetMask(iInput);
421 }
e23fbb27 422
9afbd7de 423 //
e23fbb27 424 // Initialization
9afbd7de 425 //
e23fbb27 426
67c67368 427 AliRunLoader* orl = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
428 if (InitDetector()) {
9afbd7de 429
67c67368 430 AliLoader* ogime = orl->GetLoader("TRDLoader");
431
432 TTree* tree = 0;
9afbd7de 433 if (fSDigits) {
434 // If we produce SDigits
435 tree = ogime->TreeS();
436 if (!tree) {
437 ogime->MakeTree("S");
67c67368 438 tree = ogime->TreeS();
67c67368 439 }
9afbd7de 440 }
441 else {
442 // If we produce Digits
443 tree = ogime->TreeD();
444 if (!tree) {
445 ogime->MakeTree("D");
446 tree = ogime->TreeD();
67c67368 447 }
9afbd7de 448 }
449
67c67368 450 MakeBranch(tree);
9afbd7de 451
67c67368 452 }
453
e23fbb27 454 for (iInput = 0; iInput < nInput; iInput++) {
455
9afbd7de 456 AliDebug(1,Form("Add input stream %d\n",iInput));
e23fbb27 457
9afbd7de 458 // Check if the input tree exists
88cb7938 459 inrl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(iInput));
4d18a639 460 AliLoader *gime = inrl->GetLoader("TRDLoader");
88cb7938 461
4d18a639 462 TTree *treees = gime->TreeS();
9afbd7de 463 if (treees == 0x0) {
464 if (gime->LoadSDigits()) {
465 AliError(Form("Error Occured while loading S. Digits for input %d.",iInput));
466 return;
467 }
4d18a639 468 treees = gime->TreeS();
9afbd7de 469 }
88cb7938 470
471 if (treees == 0x0) {
9afbd7de 472 AliError(Form("Input stream %d does not exist\n",iInput));
c57e2264 473 return;
474 }
475
e23fbb27 476 // Read the s-digits via digits manager
477 sdigitsManager = new AliTRDdigitsManager();
e23fbb27 478 sdigitsManager->SetSDigits(kTRUE);
88cb7938 479
4d18a639 480 AliRunLoader *rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(iInput));
481 AliLoader *gimme = rl->GetLoader("TRDLoader");
482 if (!gimme->TreeS()) {
483 gimme->LoadSDigits();
484 }
88cb7938 485 sdigitsManager->ReadDigits(gimme->TreeS());
e23fbb27 486
487 // Add the s-digits to the input list
488 AddSDigitsManager(sdigitsManager);
489
490 }
491
492 // Convert the s-digits to normal digits
9afbd7de 493 AliDebug(1,"Do the conversion\n");
e23fbb27 494 SDigits2Digits();
495
496 // Store the digits
9afbd7de 497 AliDebug(1,"Write the digits\n");
e23fbb27 498 fDigitsManager->WriteDigits();
88cb7938 499
9afbd7de 500 // Write parameters
67c67368 501 orl->CdGAFile();
67c67368 502
9afbd7de 503 AliDebug(1,"Done\n");
e23fbb27 504
b1113c6b 505 DeleteSDigitsManager();
506
e23fbb27 507}
508
509//_____________________________________________________________________________
e23fbb27 510Bool_t AliTRDdigitizer::Open(const Char_t *file, Int_t nEvent)
f7336fa3 511{
512 //
513 // Opens a ROOT-file with TRD-hits and reads in the hit-tree
514 //
f7336fa3 515 // Connect the AliRoot file containing Geometry, Kine, and Hits
3becff3c 516 //
f540341d 517
e191bb57 518 TString evfoldname = AliConfig::GetDefaultEventFolderName();
9afbd7de 519
f540341d 520 fRunLoader = AliRunLoader::GetRunLoader(evfoldname);
9afbd7de 521 if (!fRunLoader) {
522 fRunLoader = AliRunLoader::Open(file,evfoldname,"UPDATE");
523 }
9afbd7de 524 if (!fRunLoader) {
525 AliError(Form("Can not open session for file %s.",file));
88cb7938 526 return kFALSE;
4d18a639 527 }
88cb7938 528
9afbd7de 529 if (!fRunLoader->GetAliRun()) {
530 fRunLoader->LoadgAlice();
531 }
88cb7938 532 gAlice = fRunLoader->GetAliRun();
533
da581aea 534 if (gAlice) {
9afbd7de 535 AliDebug(1,"AliRun object found on file.\n");
da581aea 536 }
537 else {
9afbd7de 538 AliError("Could not find AliRun object.\n");
da581aea 539 return kFALSE;
540 }
f7336fa3 541
542 fEvent = nEvent;
543
4d18a639 544 AliLoader *loader = fRunLoader->GetLoader("TRDLoader");
9afbd7de 545 if (!loader) {
546 AliError("Can not get TRD loader from Run Loader");
547 return kFALSE;
548 }
88cb7938 549
abaf1f1d 550 if (InitDetector()) {
4d18a639 551 TTree *tree = 0;
9afbd7de 552 if (fSDigits) {
553 // If we produce SDigits
554 tree = loader->TreeS();
555 if (!tree) {
556 loader->MakeTree("S");
557 tree = loader->TreeS();
4d18a639 558 }
9afbd7de 559 }
560 else {
561 // If we produce Digits
562 if (!tree) {
563 loader->MakeTree("D");
564 tree = loader->TreeD();
4d18a639 565 }
9afbd7de 566 }
88cb7938 567 return MakeBranch(tree);
abaf1f1d 568 }
569 else {
570 return kFALSE;
571 }
793ff80c 572
573}
574
575//_____________________________________________________________________________
576Bool_t AliTRDdigitizer::InitDetector()
577{
578 //
579 // Sets the pointer to the TRD detector and the geometry
580 //
581
dd9a6ee3 582 // Get the pointer to the detector class and check for version 1
4487dad0 583 fTRD = (AliTRD *) gAlice->GetDetector("TRD");
cec4059b 584 if (!fTRD) {
9afbd7de 585 AliFatal("No TRD module found\n");
cec4059b 586 exit(1);
587 }
dd9a6ee3 588 if (fTRD->IsVersion() != 1) {
9afbd7de 589 AliFatal("TRD must be version 1 (slow simulator)\n");
dd9a6ee3 590 exit(1);
591 }
592
593 // Get the geometry
594 fGeo = fTRD->GetGeometry();
9afbd7de 595 AliDebug(1,Form("Geometry version %d\n",fGeo->IsVersion()));
dd9a6ee3 596
abaf1f1d 597 // Create a digits manager
47b5729a 598 delete fDigitsManager;
abaf1f1d 599 fDigitsManager = new AliTRDdigitsManager();
600 fDigitsManager->SetSDigits(fSDigits);
601 fDigitsManager->CreateArrays();
602 fDigitsManager->SetEvent(fEvent);
abaf1f1d 603
604 // The list for the input s-digits manager to be merged
47b5729a 605 if (fSDigitsManagerList) {
606 fSDigitsManagerList->Delete();
3becff3c 607 }
608 else {
47b5729a 609 fSDigitsManagerList = new TList();
610 }
abaf1f1d 611
4487dad0 612 return kTRUE;
f7336fa3 613
614}
615
616//_____________________________________________________________________________
88cb7938 617Bool_t AliTRDdigitizer::MakeBranch(TTree* tree) const
6244debe 618{
abaf1f1d 619 //
620 // Create the branches for the digits array
6244debe 621 //
622
88cb7938 623 return fDigitsManager->MakeBranch(tree);
6244debe 624
625}
626
627//_____________________________________________________________________________
f7336fa3 628Bool_t AliTRDdigitizer::MakeDigits()
629{
630 //
872a7aba 631 // Creates digits.
f7336fa3 632 //
633
f7336fa3 634 ///////////////////////////////////////////////////////////////
635 // Parameter
636 ///////////////////////////////////////////////////////////////
637
638 // Converts number of electrons to fC
4d18a639 639 const Double_t kEl2fC = 1.602e-19 * 1.0e15;
f7336fa3 640
641 ///////////////////////////////////////////////////////////////
642
793ff80c 643 // Number of pads included in the pad response
a5cadd36 644 const Int_t kNpad = 3;
793ff80c 645
646 // Number of track dictionary arrays
a5cadd36 647 const Int_t kNDict = AliTRDdigitsManager::kNDict;
793ff80c 648
872a7aba 649 // Half the width of the amplification region
4d18a639 650 const Float_t kAmWidth = AliTRDgeometry::AmThick() / 2.0;
3becff3c 651 // Width of the drift region
ccb4315c 652 const Float_t kDrWidth = AliTRDgeometry::DrThick();
3551db50 653
4d18a639 654 Int_t iRow;
655 Int_t iCol;
656 Int_t iTime;
657 Int_t iPad;
a5cadd36 658 Int_t iDict = 0;
659 Int_t nBytes = 0;
f7336fa3 660
a5cadd36 661 Int_t totalSizeDigits = 0;
662 Int_t totalSizeDict0 = 0;
663 Int_t totalSizeDict1 = 0;
664 Int_t totalSizeDict2 = 0;
f7336fa3 665
a5cadd36 666 Int_t timeBinTRFend = 1;
872a7aba 667
a5cadd36 668 Double_t pos[3];
669 Double_t rot[3];
670 Double_t xyz[3];
671 Double_t padSignal[kNpad];
672 Double_t signalOld[kNpad];
872a7aba 673
a5cadd36 674 AliTRDdataArrayF *signals = 0;
675 AliTRDdataArrayI *digits = 0;
8230f242 676 AliTRDdataArrayI *dictionary[kNDict];
da581aea 677
a5cadd36 678 AliTRDpadPlane *padPlane = 0;
679
9afbd7de 680 if (!gGeoManager) {
681 AliFatal("No geometry manager!");
682 }
7754cd1f 683
9afbd7de 684 AliTRDSimParam *simParam = AliTRDSimParam::Instance();
3becff3c 685 if (!simParam) {
9afbd7de 686 AliError("Could not get simulation parameters\n");
3551db50 687 return kFALSE;
688 }
689
9afbd7de 690 AliTRDCommonParam *commonParam = AliTRDCommonParam::Instance();
3becff3c 691 if (!commonParam) {
4d18a639 692 AliError("Could not get common parameterss\n");
3551db50 693 return kFALSE;
694 }
695
793ff80c 696 // Create a container for the amplitudes
9afbd7de 697 AliTRDsegmentArray *signalsArray = new AliTRDsegmentArray("AliTRDdataArrayF"
698 ,AliTRDgeometry::Ndet());
793ff80c 699
3551db50 700 AliTRDcalibDB* calibration = AliTRDcalibDB::Instance();
3becff3c 701 if (!calibration) {
9afbd7de 702 AliError("Could not get calibration object\n");
3551db50 703 return kFALSE;
704 }
705
706 if (simParam->TRFOn()) {
9afbd7de 707 timeBinTRFend = ((Int_t) (simParam->GetTRFhi()
4d18a639 708 * calibration->GetSamplingFrequency())) - 1;
9afbd7de 709 AliDebug(1,Form("Sample the TRF up to bin %d\n",timeBinTRFend));
da581aea 710 }
711
4d18a639 712 Float_t elAttachProp = simParam->GetElAttachProp() / 100.0;
793ff80c 713
872a7aba 714 if (!fGeo) {
9afbd7de 715 AliError("No geometry defined\n");
872a7aba 716 return kFALSE;
717 }
718
9afbd7de 719 AliDebug(1,"Start creating digits.\n");
872a7aba 720
4d18a639 721 AliLoader *gimme = fRunLoader->GetLoader("TRDLoader");
9afbd7de 722 if (!gimme->TreeH()) {
723 gimme->LoadHits();
724 }
4d18a639 725 TTree *hitTree = gimme->TreeH();
3becff3c 726 if (hitTree == 0x0) {
9afbd7de 727 AliError("Can not get TreeH");
728 return kFALSE;
3becff3c 729 }
88cb7938 730 fTRD->SetTreeAddress();
731
793ff80c 732 // Get the number of entries in the hit tree
733 // (Number of primary particles creating a hit somewhere)
3becff3c 734 Int_t nTrack = (Int_t) hitTree->GetEntries();
9afbd7de 735 AliDebug(1,Form("Found %d primary particles\n",nTrack));
736 AliDebug(1,Form("Sampling = %.0fMHz\n" ,calibration->GetSamplingFrequency()));
737 AliDebug(1,Form("Gain = %d\n" ,((Int_t) simParam->GetGasGain())));
f881dc35 738 AliDebug(1,Form("Noise = %d\n" ,((Int_t) simParam->GetNoise())));
9afbd7de 739 if (simParam->TimeStructOn()) {
740 AliDebug(1,"Time Structure of drift cells implemented.\n");
741 }
742 else {
743 AliDebug(1,"Constant drift velocity in drift cells.\n");
a328fff9 744 }
3551db50 745
9afbd7de 746 Int_t detectorOld = -1;
747 Int_t countHits = 0;
748
3becff3c 749 Int_t nTimeTotal = calibration->GetNumberOfTimeBins();
750 Float_t samplingRate = calibration->GetSamplingFrequency();
a328fff9 751
793ff80c 752 // Loop through all entries in the tree
753 for (Int_t iTrack = 0; iTrack < nTrack; iTrack++) {
754
3becff3c 755 gAlice->ResetHits();
756 nBytes += hitTree->GetEvent(iTrack);
793ff80c 757
e23fbb27 758 // Loop through the TRD hits
759 Int_t iHit = 0;
760 AliTRDhit *hit = (AliTRDhit *) fTRD->FirstHit(-1);
761 while (hit) {
762
793ff80c 763 countHits++;
e23fbb27 764 iHit++;
765
f881dc35 766 Float_t q = hit->GetCharge();
b08ed1cf 767 // Don't analyze test hits
f881dc35 768 if (((Int_t) q) == 0) {
769 hit = (AliTRDhit *) fTRD->NextHit();
770 continue;
771 }
e153aaf6 772
f881dc35 773 pos[0] = hit->X();
774 pos[1] = hit->Y();
775 pos[2] = hit->Z();
776 Int_t track = hit->Track();
777 Int_t detector = hit->GetDetector();
778 Int_t plane = fGeo->GetPlane(detector);
779 Int_t chamber = fGeo->GetChamber(detector);
780 Float_t time0 = AliTRDgeometry::GetTime0(plane);
781 padPlane = commonParam->GetPadPlane(plane,chamber);
782 Float_t row0 = padPlane->GetRow0();
783 Int_t nRowMax = padPlane->GetNrows();
784 Int_t nColMax = padPlane->GetNcols();
785 Int_t inDrift = 1;
786
787 // Find the current volume with the geo manager
788 gGeoManager->SetCurrentPoint(pos);
789 gGeoManager->FindNode();
790 if (strstr(gGeoManager->GetPath(),"/UK")) {
791 inDrift = 0;
792 }
793
794 if (detector != detectorOld) {
795
796 // Compress the old one if enabled
797 if ((fCompress) && (detectorOld > -1)) {
798 signals->Compress(1,0);
799 for (iDict = 0; iDict < kNDict; iDict++) {
800 dictionary[iDict]->Compress(1,0);
801 }
802 }
803 // Get the new container
804 signals = (AliTRDdataArrayF *) signalsArray->At(detector);
805 if (signals->GetNtime() == 0) {
806 // Allocate a new one if not yet existing
807 signals->Allocate(nRowMax,nColMax,nTimeTotal);
808 }
809 else {
810 // Expand an existing one
811 if (fCompress) {
812 signals->Expand();
793ff80c 813 }
f881dc35 814 }
815 // The same for the dictionary
816 for (iDict = 0; iDict < kNDict; iDict++) {
817 dictionary[iDict] = fDigitsManager->GetDictionary(detector,iDict);
818 if (dictionary[iDict]->GetNtime() == 0) {
819 dictionary[iDict]->Allocate(nRowMax,nColMax,nTimeTotal);
793ff80c 820 }
821 else {
f881dc35 822 if (fCompress) dictionary[iDict]->Expand();
823 }
824 }
825 detectorOld = detector;
826 }
793ff80c 827
f881dc35 828 // Rotate the sectors on top of each other
829 // by using the geoManager
830 Double_t aaa[3];
831 gGeoManager->MasterToLocal(pos,aaa);
832 if (inDrift) {
833 aaa[2] = time0 - (kDrWidth / 2.0 + kAmWidth) + aaa[2];
834 }
835 else {
836 aaa[2] = time0 + aaa[2];
837 }
838 aaa[1] = row0 + padPlane->GetLengthRim() + fGeo->RpadW()
839 - 0.5 * fGeo->GetChamberLength(plane,chamber)
840 + aaa[1];
841 rot[0] = aaa[2];
842 rot[1] = aaa[0];
843 rot[2] = aaa[1];
844
845 // The driftlength. It is negative if the hit is between pad plane and anode wires.
846 Double_t driftlength = time0 - rot[0];
847
848 // Loop over all electrons of this hit
849 // TR photons produce hits with negative charge
850 Int_t nEl = ((Int_t) TMath::Abs(q));
851 for (Int_t iEl = 0; iEl < nEl; iEl++) {
852
853 xyz[0] = rot[0];
854 xyz[1] = rot[1];
855 xyz[2] = rot[2];
856
857 // Stupid patch to take care of TR photons that are absorbed
858 // outside the chamber volume. A real fix would actually need
859 // a more clever implementation of the TR hit generation
860 if (q < 0.0) {
861 if ((xyz[2] < padPlane->GetRowEnd()) ||
862 (xyz[2] > padPlane->GetRow0())) {
863 if (iEl == 0) {
864 AliDebug(2,Form("Hit outside of sensitive volume, row (z=%f, row0=%f, rowE=%f)\n"
865 ,xyz[2],padPlane->GetRow0(),padPlane->GetRowEnd()));
a328fff9 866 }
f881dc35 867 continue;
868 }
869 Float_t tt = driftlength + kAmWidth;
870 if ((tt < 0.0) ||
871 (tt > kDrWidth + 2.0*kAmWidth)) {
872 if (iEl == 0) {
873 AliDebug(2,Form("Hit outside of sensitive volume, time (Q = %d)\n"
874 ,((Int_t) q)));
a328fff9 875 }
f881dc35 876 continue;
a328fff9 877 }
f881dc35 878 }
a328fff9 879
f881dc35 880 // Get row and col of unsmeared electron to retrieve drift velocity
881 // The pad row (z-direction)
882 Int_t rowE = padPlane->GetPadRowNumber(xyz[2]);
883 if (rowE < 0) continue;
884 Double_t rowOffset = padPlane->GetPadRowOffset(rowE,xyz[2]);
e23fbb27 885
f881dc35 886 // The pad column (rphi-direction)
887 Double_t offsetTilt = padPlane->GetTiltOffset(rowOffset);
888 Int_t colE = padPlane->GetPadColNumber(xyz[1]+offsetTilt,rowOffset);
889 if (colE < 0) continue;
890 Double_t colOffset = padPlane->GetPadColOffset(colE,xyz[1]+offsetTilt);
ccb4315c 891
f881dc35 892 Float_t driftvelocity = calibration->GetVdrift(detector,colE,rowE);
3551db50 893
f881dc35 894 // Normalised drift length
895 Double_t absdriftlength = TMath::Abs(driftlength);
896 if (commonParam->ExBOn()) {
897 absdriftlength /= TMath::Sqrt(GetLorentzFactor(driftvelocity));
898 }
3551db50 899
f881dc35 900 // Electron attachment
901 if (simParam->ElAttachOn()) {
902 if (gRandom->Rndm() < (absdriftlength * elAttachProp)) continue;
903 }
3551db50 904
f881dc35 905 // Apply the diffusion smearing
906 if (simParam->DiffusionOn()) {
907 if (!(Diffusion(driftvelocity,absdriftlength,xyz))) continue;
908 }
3551db50 909
f881dc35 910 // Apply E x B effects (depends on drift direction)
911 if (commonParam->ExBOn()) {
912 if (!(ExB(driftvelocity,driftlength,xyz))) continue;
913 }
3551db50 914
f881dc35 915 // The electron position after diffusion and ExB in pad coordinates.
916 // The pad row (z-direction)
917 rowE = padPlane->GetPadRowNumber(xyz[2]);
918 if (rowE < 0) continue;
919 rowOffset = padPlane->GetPadRowOffset(rowE,xyz[2]);
920
921 // The pad column (rphi-direction)
922 offsetTilt = padPlane->GetTiltOffset(rowOffset);
923 colE = padPlane->GetPadColNumber(xyz[1]+offsetTilt,rowOffset);
924 if (colE < 0) continue;
925 colOffset = padPlane->GetPadColOffset(colE,xyz[1]+offsetTilt);
3551db50 926
f881dc35 927 // Also re-retrieve drift velocity because col and row may have changed
928 driftvelocity = calibration->GetVdrift(detector,colE,rowE);
929 Float_t t0 = calibration->GetT0(detector,colE,rowE);
3551db50 930
f881dc35 931 // Convert the position to drift time, using either constant drift velocity or
932 // time structure of drift cells (non-isochronity, GARFIELD calculation).
933 Double_t drifttime;
934 if (simParam->TimeStructOn()) {
935 // Get z-position with respect to anode wire:
936 Double_t Z = row0 - xyz[2] + simParam->GetAnodeWireOffset();
937 Z -= ((Int_t)(2 * Z)) / 2.0;
938 if (Z > 0.25) {
939 Z = 0.5 - Z;
e23fbb27 940 }
f881dc35 941 // Use drift time map (GARFIELD)
942 drifttime = TimeStruct(driftvelocity,time0-xyz[0]+kAmWidth,Z);
943 }
944 else {
945 // Use constant drift velocity
946 drifttime = TMath::Abs(time0 - xyz[0]) / driftvelocity;
947 }
ccb4315c 948
f881dc35 949 // Apply the gas gain including fluctuations
950 Double_t ggRndm = 0.0;
951 do {
952 ggRndm = gRandom->Rndm();
953 } while (ggRndm <= 0);
954 Int_t signal = (Int_t) (-(simParam->GetGasGain()) * TMath::Log(ggRndm));
955
956 // Apply the pad response
957 if (simParam->PRFOn()) {
958 // The distance of the electron to the center of the pad
959 // in units of pad width
960 Double_t dist = (colOffset - 0.5*padPlane->GetColSize(colE))
961 / padPlane->GetColSize(colE);
962 if (!(calibration->PadResponse(signal,dist,plane,padSignal))) continue;
963 }
964 else {
965 padSignal[0] = 0.0;
966 padSignal[1] = signal;
967 padSignal[2] = 0.0;
968 }
e23fbb27 969
f881dc35 970 // The time bin (always positive), with t0 correction
971 Double_t timeBinIdeal = drifttime * samplingRate + t0;
972 // Protection
973 if (TMath::Abs(timeBinIdeal) > 2*nTimeTotal) {
974 timeBinIdeal = 2 * nTimeTotal;
975 }
976 Int_t timeBinTruncated = (Int_t) timeBinIdeal;
977 // The distance of the position to the middle of the timebin
978 Double_t timeOffset = ((Float_t) timeBinTruncated
979 + 0.5 - timeBinIdeal) / samplingRate;
6a739e92 980
f881dc35 981 // Sample the time response inside the drift region
982 // + additional time bins before and after.
983 // The sampling is done always in the middle of the time bin
984 for (Int_t iTimeBin = TMath::Max(timeBinTruncated, 0);
985 iTimeBin < TMath::Min(timeBinTruncated+timeBinTRFend,nTimeTotal);
986 iTimeBin++) {
987
988 // Apply the time response
989 Double_t timeResponse = 1.0;
990 Double_t crossTalk = 0.0;
991 Double_t time = (iTimeBin - timeBinTruncated) / samplingRate + timeOffset;
992 if (simParam->TRFOn()) {
993 timeResponse = simParam->TimeResponse(time);
994 }
995 if (simParam->CTOn()) {
996 crossTalk = simParam->CrossTalk(time);
997 }
e23fbb27 998
f881dc35 999 signalOld[0] = 0.0;
1000 signalOld[1] = 0.0;
1001 signalOld[2] = 0.0;
f7336fa3 1002
f881dc35 1003 for (iPad = 0; iPad < kNpad; iPad++) {
e23fbb27 1004
f881dc35 1005 Int_t colPos = colE + iPad - 1;
1006 if (colPos < 0) continue;
1007 if (colPos >= nColMax) break;
e23fbb27 1008
f881dc35 1009 // Add the signals
1010 Int_t iCurrentTimeBin = iTimeBin;
1011 signalOld[iPad] = signals->GetDataUnchecked(rowE,colPos,iCurrentTimeBin);
1012 if (colPos != colE) {
1013 signalOld[iPad] += padSignal[iPad] * (timeResponse + crossTalk);
1014 }
1015 else {
1016 signalOld[iPad] += padSignal[iPad] * timeResponse;
1017 }
1018 signals->SetDataUnchecked(rowE,colPos,iCurrentTimeBin,signalOld[iPad]);
1019
1020 // Store the track index in the dictionary
1021 // Note: We store index+1 in order to allow the array to be compressed
1022 if (signalOld[iPad] > 0) {
1023 for (iDict = 0; iDict < kNDict; iDict++) {
1024 Int_t oldTrack = dictionary[iDict]->GetDataUnchecked(rowE
1025 ,colPos
1026 ,iCurrentTimeBin);
1027 if (oldTrack == track+1) break;
1028 if (oldTrack == 0) {
1029 dictionary[iDict]->SetDataUnchecked(rowE,colPos,iCurrentTimeBin,track+1);
1030 break;
71d9fa7b 1031 }
1032 }
f881dc35 1033 }
872a7aba 1034
f881dc35 1035 } // Loop: pads
f7336fa3 1036
f881dc35 1037 } // Loop: time bins
f7336fa3 1038
f881dc35 1039 } // Loop: electrons of a single hit
f7336fa3 1040
e23fbb27 1041 hit = (AliTRDhit *) fTRD->NextHit();
f7336fa3 1042
e23fbb27 1043 } // Loop: hits of one primary track
1044
1045 } // Loop: primary tracks
1046
9afbd7de 1047 AliDebug(1,Form("Finished analyzing %d hits\n",countHits));
793ff80c 1048
0c24ba98 1049 // The coupling factor
3551db50 1050 Double_t coupling = simParam->GetPadCoupling()
9afbd7de 1051 * simParam->GetTimeCoupling();
0c24ba98 1052
1053 // The conversion factor
9afbd7de 1054 Double_t convert = kEl2fC
1055 * simParam->GetChipGain();
6244debe 1056
793ff80c 1057 // Loop through all chambers to finalize the digits
0c24ba98 1058 Int_t iDetBeg = 0;
1059 Int_t iDetEnd = AliTRDgeometry::Ndet();
0c24ba98 1060 for (Int_t iDet = iDetBeg; iDet < iDetEnd; iDet++) {
793ff80c 1061
4d18a639 1062 Int_t plane = fGeo->GetPlane(iDet);
1063 Int_t sector = fGeo->GetSector(iDet);
1064 Int_t chamber = fGeo->GetChamber(iDet);
1065 Int_t nRowMax = commonParam->GetRowMax(plane,chamber,sector);
1066 Int_t nColMax = commonParam->GetColMax(plane);
793ff80c 1067
4d18a639 1068 Double_t *inADC = new Double_t[nTimeTotal];
1069 Double_t *outADC = new Double_t[nTimeTotal];
e23fbb27 1070
793ff80c 1071 // Add a container for the digits of this detector
abaf1f1d 1072 digits = fDigitsManager->GetDigits(iDet);
793ff80c 1073 // Allocate memory space for the digits buffer
0c24ba98 1074 if (digits->GetNtime() == 0) {
1075 digits->Allocate(nRowMax,nColMax,nTimeTotal);
1076 }
0c24ba98 1077
793ff80c 1078 // Get the signal container
1079 signals = (AliTRDdataArrayF *) signalsArray->At(iDet);
1080 if (signals->GetNtime() == 0) {
1081 // Create missing containers
872a7aba 1082 signals->Allocate(nRowMax,nColMax,nTimeTotal);
793ff80c 1083 }
1084 else {
1085 // Expand the container if neccessary
1086 if (fCompress) signals->Expand();
1087 }
1088 // Create the missing dictionary containers
3becff3c 1089 for (iDict = 0; iDict < kNDict; iDict++) {
1090 dictionary[iDict] = fDigitsManager->GetDictionary(iDet,iDict);
1091 if (dictionary[iDict]->GetNtime() == 0) {
1092 dictionary[iDict]->Allocate(nRowMax,nColMax,nTimeTotal);
0c24ba98 1093 }
793ff80c 1094 }
f7336fa3 1095
793ff80c 1096 Int_t nDigits = 0;
1097
9afbd7de 1098 // Don't create noise in detectors that are switched off / not installed, etc.
f881dc35 1099 if (calibration->GetChamberStatus(iDet)) {
6244debe 1100
1101 // Create the digits for this chamber
872a7aba 1102 for (iRow = 0; iRow < nRowMax; iRow++ ) {
1103 for (iCol = 0; iCol < nColMax; iCol++ ) {
6244debe 1104
9afbd7de 1105 // Check whether pad is active / installed / whatever ...
1106 if (calibration->GetPadStatus(iDet,iCol,iRow)) continue;
1107 // Check whether MCM is active / installed / whatever ...
1108 if (calibration->GetMCMStatus(iDet,iCol,iRow)) continue;
1109
e23fbb27 1110 // Create summable digits
1111 if (fSDigits) {
6244debe 1112
e23fbb27 1113 for (iTime = 0; iTime < nTimeTotal; iTime++) {
872a7aba 1114 Float_t signalAmp = signals->GetDataUnchecked(iRow,iCol,iTime);
abaf1f1d 1115 signalAmp *= fSDigitsScale;
e23fbb27 1116 signalAmp = TMath::Min(signalAmp,(Float_t) 1.0e9);
abaf1f1d 1117 Int_t adc = (Int_t) signalAmp;
4487dad0 1118 if (adc > 0) nDigits++;
872a7aba 1119 digits->SetDataUnchecked(iRow,iCol,iTime,adc);
c1e4b257 1120 }
6244debe 1121
e23fbb27 1122 }
1123 // Create normal digits
1124 else {
6244debe 1125
e23fbb27 1126 for (iTime = 0; iTime < nTimeTotal; iTime++) {
4d18a639 1127
e23fbb27 1128 Float_t signalAmp = signals->GetDataUnchecked(iRow,iCol,iTime);
11dc3a9e 1129
0c24ba98 1130 // Pad and time coupling
1131 signalAmp *= coupling;
11dc3a9e 1132
f881dc35 1133 Float_t padgain = calibration->GetGainFactor(iDet,iCol,iRow);
9afbd7de 1134 if (padgain <= 0) {
f881dc35 1135 AliError(Form("Not a valid gain %f, %d %d %d\n",padgain,iDet,iCol,iRow));
7754cd1f 1136 }
7eea788e 1137 signalAmp *= padgain;
11dc3a9e 1138
7e582e9f 1139 // Add the noise, starting from minus ADC baseline in electrons
3551db50 1140 Double_t baselineEl = simParam->GetADCbaseline() * (simParam->GetADCinRange()
4d18a639 1141 / simParam->GetADCoutRange())
1142 / convert;
3551db50 1143 signalAmp = TMath::Max((Double_t) gRandom->Gaus(signalAmp,simParam->GetNoise())
7e582e9f 1144 ,-baselineEl);
6244debe 1145 // Convert to mV
1146 signalAmp *= convert;
7e582e9f 1147 // Add ADC baseline in mV
3551db50 1148 signalAmp += simParam->GetADCbaseline() * (simParam->GetADCinRange()
4d18a639 1149 / simParam->GetADCoutRange());
11dc3a9e 1150 // Convert to ADC counts. Set the overflow-bit fADCoutRange if the
6244debe 1151 // signal is larger than fADCinRange
1152 Int_t adc = 0;
3551db50 1153 if (signalAmp >= simParam->GetADCinRange()) {
1154 adc = ((Int_t) simParam->GetADCoutRange());
6244debe 1155 }
1156 else {
11dc3a9e 1157 adc = TMath::Nint(signalAmp * (simParam->GetADCoutRange()
4d18a639 1158 / simParam->GetADCinRange()));
6244debe 1159 }
11dc3a9e 1160
e23fbb27 1161 inADC[iTime] = adc;
1162 outADC[iTime] = adc;
4d18a639 1163
e23fbb27 1164 }
6244debe 1165
e23fbb27 1166 for (iTime = 0; iTime < nTimeTotal; iTime++) {
6244debe 1167 // Store the amplitude of the digit if above threshold
3551db50 1168 if (outADC[iTime] > simParam->GetADCthreshold()) {
6244debe 1169 nDigits++;
3583ac1a 1170 digits->SetDataUnchecked(iRow,iCol,iTime,((Int_t) outADC[iTime]));
6244debe 1171 }
6244debe 1172 }
1173
1174 }
e23fbb27 1175
6244debe 1176 }
793ff80c 1177 }
6244debe 1178
793ff80c 1179 }
1180
1181 // Compress the arrays
3becff3c 1182 digits->Compress(1,0);
1183 for (iDict = 0; iDict < kNDict; iDict++) {
1184 dictionary[iDict]->Compress(1,0);
1185 }
f7336fa3 1186
3becff3c 1187 totalSizeDigits += digits->GetSize();
1188 totalSizeDict0 += dictionary[0]->GetSize();
1189 totalSizeDict1 += dictionary[1]->GetSize();
1190 totalSizeDict2 += dictionary[2]->GetSize();
0c24ba98 1191
f881dc35 1192 if (nDigits > 0) {
1193 Float_t nPixel = nRowMax * nColMax * nTimeTotal;
1194 AliDebug(1,Form("Found %d digits in detector %d (%3.0f).\n"
1195 ,nDigits,iDet
1196 ,100.0 * ((Float_t) nDigits) / nPixel));
1197 }
abaf1f1d 1198
9afbd7de 1199 if (fCompress) {
1200 signals->Compress(1,0);
1201 }
f7336fa3 1202
e23fbb27 1203 delete [] inADC;
1204 delete [] outADC;
1205
f7336fa3 1206 }
1207
0c24ba98 1208 if (signalsArray) {
1209 delete signalsArray;
1210 signalsArray = 0;
1211 }
1212
9afbd7de 1213 AliDebug(1,Form("Total number of analyzed hits = %d\n",countHits));
1214 AliDebug(1,Form("Total digits data size = %d, %d, %d, %d\n",totalSizeDigits
1215 ,totalSizeDict0
1216 ,totalSizeDict1
1217 ,totalSizeDict2));
abaf1f1d 1218
1219 return kTRUE;
1220
1221}
1222
1223//_____________________________________________________________________________
1224void AliTRDdigitizer::AddSDigitsManager(AliTRDdigitsManager *man)
1225{
1226 //
1227 // Add a digits manager for s-digits to the input list.
1228 //
1229
1230 fSDigitsManagerList->Add(man);
1231
1232}
1233
1234//_____________________________________________________________________________
b1113c6b 1235void AliTRDdigitizer::DeleteSDigitsManager()
1236{
1237 //
1238 // Removes digits manager from the input list.
1239 //
1240
1241 fSDigitsManagerList->Delete();
1242
1243}
1244
1245//_____________________________________________________________________________
abaf1f1d 1246Bool_t AliTRDdigitizer::ConvertSDigits()
1247{
1248 //
1249 // Converts s-digits to normal digits
1250 //
1251
1252 // Number of track dictionary arrays
1253 const Int_t kNDict = AliTRDdigitsManager::kNDict;
1254
1255 // Converts number of electrons to fC
4d18a639 1256 const Double_t kEl2fC = 1.602e-19 * 1.0e15;
abaf1f1d 1257
1258 Int_t iDict = 0;
e23fbb27 1259 Int_t iRow;
1260 Int_t iCol;
1261 Int_t iTime;
abaf1f1d 1262
4d18a639 1263 AliTRDSimParam *simParam = AliTRDSimParam::Instance();
9afbd7de 1264 if (!simParam) {
1265 AliError("Could not get simulation parameters\n");
3551db50 1266 return kFALSE;
1267 }
1268
4d18a639 1269 AliTRDCommonParam *commonParam = AliTRDCommonParam::Instance();
9afbd7de 1270 if (!commonParam) {
1271 AliError("Could not get common parameters\n");
3551db50 1272 return kFALSE;
1273 }
1274
4d18a639 1275 AliTRDcalibDB *calibration = AliTRDcalibDB::Instance();
9afbd7de 1276 if (!calibration) {
1277 AliError("Could not get calibration object\n");
3551db50 1278 return kFALSE;
1279 }
1280
abaf1f1d 1281 Double_t sDigitsScale = 1.0 / GetSDigitsScale();
3551db50 1282 Double_t noise = simParam->GetNoise();
1283 Double_t padCoupling = simParam->GetPadCoupling();
1284 Double_t timeCoupling = simParam->GetTimeCoupling();
1285 Double_t chipGain = simParam->GetChipGain();
0c24ba98 1286 Double_t coupling = padCoupling * timeCoupling;
1287 Double_t convert = kEl2fC * chipGain;
3551db50 1288 Double_t adcInRange = simParam->GetADCinRange();
1289 Double_t adcOutRange = simParam->GetADCoutRange();
1290 Int_t adcThreshold = simParam->GetADCthreshold();
1291 Int_t adcBaseline = simParam->GetADCbaseline();
9afbd7de 1292 Int_t nTimeTotal = calibration->GetNumberOfTimeBins();
1293
abaf1f1d 1294 AliTRDdataArrayI *digitsIn;
1295 AliTRDdataArrayI *digitsOut;
1296 AliTRDdataArrayI *dictionaryIn[kNDict];
1297 AliTRDdataArrayI *dictionaryOut[kNDict];
3551db50 1298
abaf1f1d 1299 // Loop through the detectors
1300 for (Int_t iDet = 0; iDet < AliTRDgeometry::Ndet(); iDet++) {
da581aea 1301
abaf1f1d 1302 Int_t plane = fGeo->GetPlane(iDet);
1303 Int_t sector = fGeo->GetSector(iDet);
1304 Int_t chamber = fGeo->GetChamber(iDet);
3551db50 1305 Int_t nRowMax = commonParam->GetRowMax(plane,chamber,sector);
1306 Int_t nColMax = commonParam->GetColMax(plane);
abaf1f1d 1307
e23fbb27 1308 Double_t *inADC = new Double_t[nTimeTotal];
1309 Double_t *outADC = new Double_t[nTimeTotal];
1310
abaf1f1d 1311 digitsIn = fSDigitsManager->GetDigits(iDet);
1312 digitsIn->Expand();
1313 digitsOut = fDigitsManager->GetDigits(iDet);
1314 digitsOut->Allocate(nRowMax,nColMax,nTimeTotal);
1315 for (iDict = 0; iDict < kNDict; iDict++) {
1316 dictionaryIn[iDict] = fSDigitsManager->GetDictionary(iDet,iDict);
1317 dictionaryIn[iDict]->Expand();
1318 dictionaryOut[iDict] = fDigitsManager->GetDictionary(iDet,iDict);
1319 dictionaryOut[iDict]->Allocate(nRowMax,nColMax,nTimeTotal);
1320 }
1321
e23fbb27 1322 for (iRow = 0; iRow < nRowMax; iRow++ ) {
1323 for (iCol = 0; iCol < nColMax; iCol++ ) {
abaf1f1d 1324
11dc3a9e 1325 for (iTime = 0; iTime < nTimeTotal; iTime++) {
9afbd7de 1326
f881dc35 1327 // Scale s-digits to normal digits
abaf1f1d 1328 Double_t signal = (Double_t) digitsIn->GetDataUnchecked(iRow,iCol,iTime);
4d18a639 1329 signal *= sDigitsScale;
f881dc35 1330 // Apply the pad-by-pad gain factors
9afbd7de 1331 Float_t padgain = calibration->GetGainFactor(iDet,iCol,iRow);
1332 if (padgain <= 0.0) {
4d18a639 1333 AliError(Form("Not a valid gain %f, %d %d %d\n",padgain,iDet,iCol,iRow));
7754cd1f 1334 }
1335 signal *= padgain;
0c24ba98 1336 // Pad and time coupling
1337 signal *= coupling;
7e582e9f 1338 // Add the noise, starting from minus ADC baseline in electrons
1339 Double_t baselineEl = adcBaseline * (adcInRange / adcOutRange) / convert;
1340 signal = TMath::Max((Double_t) gRandom->Gaus(signal,noise),-baselineEl);
abaf1f1d 1341 // Convert to mV
1342 signal *= convert;
7e582e9f 1343 // add ADC baseline in mV
1344 signal += adcBaseline * (adcInRange / adcOutRange);
11dc3a9e 1345 // Convert to ADC counts. Set the overflow-bit adcOutRange if the
abaf1f1d 1346 // signal is larger than adcInRange
1347 Int_t adc = 0;
1348 if (signal >= adcInRange) {
1349 adc = ((Int_t) adcOutRange);
1350 }
1351 else {
11dc3a9e 1352 adc = TMath::Nint(signal * (adcOutRange / adcInRange));
abaf1f1d 1353 }
e23fbb27 1354 inADC[iTime] = adc;
1355 outADC[iTime] = adc;
9afbd7de 1356
e23fbb27 1357 }
1358
11dc3a9e 1359 for (iTime = 0; iTime < nTimeTotal; iTime++) {
abaf1f1d 1360 // Store the amplitude of the digit if above threshold
e23fbb27 1361 if (outADC[iTime] > adcThreshold) {
3583ac1a 1362 digitsOut->SetDataUnchecked(iRow,iCol,iTime,((Int_t) outADC[iTime]));
e23fbb27 1363 // Copy the dictionary
1364 for (iDict = 0; iDict < kNDict; iDict++) {
1365 Int_t track = dictionaryIn[iDict]->GetDataUnchecked(iRow,iCol,iTime);
1366 dictionaryOut[iDict]->SetDataUnchecked(iRow,iCol,iTime,track);
1367 }
abaf1f1d 1368 }
abaf1f1d 1369 }
e23fbb27 1370
abaf1f1d 1371 }
1372 }
1373
1374 if (fCompress) {
1375 digitsIn->Compress(1,0);
1376 digitsOut->Compress(1,0);
1377 for (iDict = 0; iDict < kNDict; iDict++) {
1378 dictionaryIn[iDict]->Compress(1,0);
1379 dictionaryOut[iDict]->Compress(1,0);
1380 }
1381 }
1382
e23fbb27 1383 delete [] inADC;
1384 delete [] outADC;
1385
abaf1f1d 1386 }
f7336fa3 1387
1388 return kTRUE;
1389
1390}
1391
1392//_____________________________________________________________________________
abaf1f1d 1393Bool_t AliTRDdigitizer::MergeSDigits()
16bf9884 1394{
1395 //
abaf1f1d 1396 // Merges the input s-digits:
1397 // - The amplitude of the different inputs are summed up.
1398 // - Of the track IDs from the input dictionaries only one is
1399 // kept for each input. This works for maximal 3 different merged inputs.
16bf9884 1400 //
1401
abaf1f1d 1402 // Number of track dictionary arrays
1403 const Int_t kNDict = AliTRDdigitsManager::kNDict;
1404
4d18a639 1405 AliTRDSimParam *simParam = AliTRDSimParam::Instance();
9afbd7de 1406 if (!simParam) {
1407 AliError("Could not get simulation parameters\n");
3551db50 1408 return kFALSE;
1409 }
1410
4d18a639 1411 AliTRDCommonParam *commonParam = AliTRDCommonParam::Instance();
9afbd7de 1412 if (!commonParam) {
1413 AliError("Could not get common parameters\n");
3551db50 1414 return kFALSE;
1415 }
1416
4d18a639 1417 AliTRDcalibDB *calibration = AliTRDcalibDB::Instance();
9afbd7de 1418 if (!calibration) {
1419 AliError("Could not get calibration object\n");
3551db50 1420 return kFALSE;
1421 }
1422
abaf1f1d 1423 Int_t iDict = 0;
e23fbb27 1424 Int_t jDict = 0;
abaf1f1d 1425
1426 AliTRDdataArrayI *digitsA;
1427 AliTRDdataArrayI *digitsB;
1428 AliTRDdataArrayI *dictionaryA[kNDict];
1429 AliTRDdataArrayI *dictionaryB[kNDict];
1430
1431 // Get the first s-digits
1432 fSDigitsManager = (AliTRDdigitsManager *) fSDigitsManagerList->First();
9afbd7de 1433 if (!fSDigitsManager) {
1434 AliError("No SDigits manager\n");
1435 return kFALSE;
1436 }
abaf1f1d 1437
1438 // Loop through the other sets of s-digits
1439 AliTRDdigitsManager *mergeSDigitsManager;
4d18a639 1440 mergeSDigitsManager = (AliTRDdigitsManager *)
1441 fSDigitsManagerList->After(fSDigitsManager);
abaf1f1d 1442
9afbd7de 1443 if (mergeSDigitsManager) {
1444 AliDebug(1,Form("Merge %d input files.\n",fSDigitsManagerList->GetSize()));
1445 }
1446 else {
1447 AliDebug(1,"Only one input file.\n");
abaf1f1d 1448 }
1449
3551db50 1450 Int_t nTimeTotal = calibration->GetNumberOfTimeBins();
1451
abaf1f1d 1452 Int_t iMerge = 0;
1453 while (mergeSDigitsManager) {
1454
1455 iMerge++;
1456
1457 // Loop through the detectors
1458 for (Int_t iDet = 0; iDet < AliTRDgeometry::Ndet(); iDet++) {
1459
4d18a639 1460 Int_t plane = fGeo->GetPlane(iDet);
1461 Int_t sector = fGeo->GetSector(iDet);
1462 Int_t chamber = fGeo->GetChamber(iDet);
1463 Int_t nRowMax = commonParam->GetRowMax(plane,chamber,sector);
1464 Int_t nColMax = commonParam->GetColMax(plane);
abaf1f1d 1465
1466 // Loop through the pixels of one detector and add the signals
1467 digitsA = fSDigitsManager->GetDigits(iDet);
1468 digitsB = mergeSDigitsManager->GetDigits(iDet);
1469 digitsA->Expand();
1470 digitsB->Expand();
1471 for (iDict = 0; iDict < kNDict; iDict++) {
1472 dictionaryA[iDict] = fSDigitsManager->GetDictionary(iDet,iDict);
1473 dictionaryB[iDict] = mergeSDigitsManager->GetDictionary(iDet,iDict);
1474 dictionaryA[iDict]->Expand();
1475 dictionaryB[iDict]->Expand();
1476 }
1477
4487dad0 1478 // Merge only detectors that contain a signal
1479 Bool_t doMerge = kTRUE;
1480 if (fMergeSignalOnly) {
1481 if (digitsA->GetOverThreshold(0) == 0) {
1482 doMerge = kFALSE;
1483 }
abaf1f1d 1484 }
1485
4487dad0 1486 if (doMerge) {
abaf1f1d 1487
9afbd7de 1488 AliDebug(1,Form("Merge detector %d of input no.%d\n",iDet,iMerge+1));
abaf1f1d 1489
4487dad0 1490 for (Int_t iRow = 0; iRow < nRowMax; iRow++ ) {
1491 for (Int_t iCol = 0; iCol < nColMax; iCol++ ) {
1492 for (Int_t iTime = 0; iTime < nTimeTotal; iTime++) {
1493
1494 // Add the amplitudes of the summable digits
1495 Int_t ampA = digitsA->GetDataUnchecked(iRow,iCol,iTime);
1496 Int_t ampB = digitsB->GetDataUnchecked(iRow,iCol,iTime);
1497 ampA += ampB;
1498 digitsA->SetDataUnchecked(iRow,iCol,iTime,ampA);
1499
9afbd7de 1500 // Add the mask to the track id if defined.
4487dad0 1501 for (iDict = 0; iDict < kNDict; iDict++) {
1502 Int_t trackB = dictionaryB[iDict]->GetDataUnchecked(iRow,iCol,iTime);
1503 if ((fMasks) && (trackB > 0)) {
1504 for (jDict = 0; jDict < kNDict; jDict++) {
1505 Int_t trackA = dictionaryA[iDict]->GetDataUnchecked(iRow,iCol,iTime);
1506 if (trackA == 0) {
1507 trackA = trackB + fMasks[iMerge];
1508 dictionaryA[iDict]->SetDataUnchecked(iRow,iCol,iTime,trackA);
1509 }
1510 }
1511 }
e23fbb27 1512 }
abaf1f1d 1513
4487dad0 1514 }
abaf1f1d 1515 }
4487dad0 1516 }
1517
abaf1f1d 1518 }
1519
1520 if (fCompress) {
1521 digitsA->Compress(1,0);
1522 digitsB->Compress(1,0);
1523 for (iDict = 0; iDict < kNDict; iDict++) {
1524 dictionaryA[iDict]->Compress(1,0);
1525 dictionaryB[iDict]->Compress(1,0);
1526 }
1527 }
1528
1529 }
1530
1531 // The next set of s-digits
4d18a639 1532 mergeSDigitsManager = (AliTRDdigitsManager *)
1533 fSDigitsManagerList->After(mergeSDigitsManager);
abaf1f1d 1534
1535 }
1536
16bf9884 1537 return kTRUE;
1538
1539}
1540
1541//_____________________________________________________________________________
abaf1f1d 1542Bool_t AliTRDdigitizer::SDigits2Digits()
1543{
1544 //
1545 // Merges the input s-digits and converts them to normal digits
1546 //
1547
4d18a639 1548 if (!MergeSDigits()) {
1549 return kFALSE;
1550 }
abaf1f1d 1551
1552 return ConvertSDigits();
1553
1554}
1555
1556//_____________________________________________________________________________
0a29d0f1 1557Bool_t AliTRDdigitizer::WriteDigits() const
f7336fa3 1558{
1559 //
1560 // Writes out the TRD-digits and the dictionaries
1561 //
1562
4d18a639 1563 // Write parameters
bdbb05bb 1564 fRunLoader->CdGAFile();
bdbb05bb 1565
da581aea 1566 // Store the digits and the dictionary in the tree
abaf1f1d 1567 return fDigitsManager->WriteDigits();
f7336fa3 1568
1569}
793ff80c 1570
1571//_____________________________________________________________________________
88cb7938 1572void AliTRDdigitizer::InitOutput(Int_t iEvent)
8e64dd77 1573{
1574 //
1575 // Initializes the output branches
1576 //
1577
1578 fEvent = iEvent;
88cb7938 1579
9afbd7de 1580 if (!fRunLoader) {
1581 AliError("Run Loader is NULL");
1582 return;
1583 }
1584
88cb7938 1585 AliLoader* loader = fRunLoader->GetLoader("TRDLoader");
9afbd7de 1586 if (!loader) {
1587 AliError("Can not get TRD loader from Run Loader");
1588 return;
1589 }
88cb7938 1590
4d18a639 1591 TTree *tree = 0;
88cb7938 1592
9afbd7de 1593 if (fSDigits) {
1594 // If we produce SDigits
88cb7938 1595 tree = loader->TreeS();
9afbd7de 1596 if (!tree) {
88cb7938 1597 loader->MakeTree("S");
1598 tree = loader->TreeS();
9afbd7de 1599 }
1600 }
1601 else {
1602 // If we produce Digits
1603 tree = loader->TreeD();
1604 if (!tree) {
1605 loader->MakeTree("D");
1606 tree = loader->TreeD();
1607 }
1608 }
1609
88cb7938 1610 fDigitsManager->SetEvent(iEvent);
1611 fDigitsManager->MakeBranch(tree);
8e64dd77 1612
1613}
3551db50 1614
1615//_____________________________________________________________________________
1616Double_t AliTRDdigitizer::TimeStruct(Float_t vdrift, Double_t dist, Double_t z)
1617{
1618 //
1619 // Applies the time structure of the drift cells (by C.Lippmann).
1620 // The drift time of electrons to the anode wires depends on the
1621 // distance to the wire (z) and on the position in the drift region.
1622 //
1623 // input :
1624 // dist = radial distance from (cathode) pad plane [cm]
1625 // z = distance from anode wire (parallel to cathode planes) [cm]
1626 //
1627 // output :
1628 // tdrift = the drift time of an electron at the given position
1629 //
1630 // We interpolate between the drift time values at the two drift
1631 // velocities fVDlo and fVDhi, being smaller and larger than
1632 // fDriftVelocity. We use the two stored drift time maps fTimeStruct1
1633 // and fTimeStruct2, calculated for the two mentioned drift velocities.
1634 //
1635
1636 SampleTimeStruct(vdrift);
1637
4d18a639 1638 // Indices:
1639 Int_t r1 = (Int_t)(10 * dist);
9afbd7de 1640 if (r1 < 0) r1 = 0;
1641 if (r1 > 37) r1 = 37;
1642 Int_t r2 = r1 + 1;
1643 if (r2 < 0) r2 = 0;
1644 if (r2 > 37) r2 = 37;
1645 const Int_t kz1 = ((Int_t)(100 * z / 2.5));
1646 const Int_t kz2 = kz1 + 1;
1647
4d18a639 1648 if ((r1 < 0) ||
1649 (r1 > 37) ||
1650 (kz1 < 0) ||
1651 (kz1 > 10)) {
9afbd7de 1652 AliWarning(Form("Indices out of range: dist=%.2f, z=%.2f, r1=%d, kz1=%d\n"
1653 ,dist,z,r1,kz1));
3551db50 1654 }
1655
4d18a639 1656 const Float_t ky111 = fTimeStruct1[r1+38*kz1];
9afbd7de 1657 const Float_t ky221 = ((r2 <= 37) && (kz2 <= 10))
4d18a639 1658 ? fTimeStruct1[r2+38*kz2]
1659 : fTimeStruct1[37+38*10];
9afbd7de 1660 const Float_t ky121 = (kz2 <= 10)
4d18a639 1661 ? fTimeStruct1[r1+38*kz2]
1662 : fTimeStruct1[r1+38*10];
9afbd7de 1663 const Float_t ky211 = (r2 <= 37)
4d18a639 1664 ? fTimeStruct1[r2+38*kz1]
1665 : fTimeStruct1[37+38*kz1];
3551db50 1666
1667 // 2D Interpolation, lower drift time map
1668 const Float_t ky11 = (ky211-ky111)*10*dist + ky111 - (ky211-ky111)*r1;
1669 const Float_t ky21 = (ky221-ky121)*10*dist + ky121 - (ky221-ky121)*r1;
1670
4d18a639 1671 const Float_t ky112 = fTimeStruct2[r1+38*kz1];
9afbd7de 1672 const Float_t ky222 = ((r2 <= 37) && (kz2 <= 10))
4d18a639 1673 ? fTimeStruct2[r2+38*kz2]
1674 : fTimeStruct2[37+38*10];
9afbd7de 1675 const Float_t ky122 = (kz2 <= 10)
4d18a639 1676 ? fTimeStruct2[r1+38*kz2]
1677 : fTimeStruct2[r1+38*10];
9afbd7de 1678 const Float_t ky212 = (r2 <= 37)
4d18a639 1679 ? fTimeStruct2[r2+38*kz1]
1680 : fTimeStruct2[37+38*kz1];
3551db50 1681
1682 // 2D Interpolation, larger drift time map
1683 const Float_t ky12 = (ky212-ky112)*10*dist + ky112 - (ky212-ky112)*r1;
1684 const Float_t ky22 = (ky222-ky122)*10*dist + ky122 - (ky222-ky122)*r1;
1685
4d18a639 1686 // Dist now is the drift distance to the anode wires (negative if electrons are
3551db50 1687 // between anode wire plane and cathode pad plane)
9afbd7de 1688 dist -= AliTRDgeometry::AmThick() / 2.0;
3551db50 1689
1690 // Get the drift times for the drift velocities fVDlo and fVDhi
9afbd7de 1691 const Float_t ktdrift1 = ((TMath::Abs(dist) > 0.005) || (z > 0.005))
1692 ? (ky21 - ky11) * 100 * z / 2.5 + ky11 - (ky21 - ky11) * kz1
1693 : 0.0;
1694 const Float_t ktdrift2 = ((TMath::Abs(dist) > 0.005) || (z > 0.005))
1695 ? (ky22 - ky12) * 100 * z / 2.5 + ky12 - (ky22 - ky12) * kz1
1696 : 0.0;
3551db50 1697
1698 // 1D Interpolation between the values at fVDlo and fVDhi
4d18a639 1699 Float_t a = (ktdrift2 - ktdrift1)
1700 / (fVDhi - fVDlo);
1701 Float_t b = ktdrift2 - a * fVDhi;
3551db50 1702
3551db50 1703 return a * vdrift + b;
1704
1705}
1706
1707//_____________________________________________________________________________
1708void AliTRDdigitizer::SampleTimeStruct(Float_t vdrift)
1709{
1710 //
1711 // Samples the timing structure of a drift cell
1712 // Drift Time data calculated with Garfield (by C.Lippmann)
1713 //
1714
9afbd7de 1715 // TODO make caching proper, if same timing structure is selected: do not update timestructs!
3551db50 1716
9afbd7de 1717 // Noting to do
4d18a639 1718 if (vdrift == fTimeLastVdrift) {
3551db50 1719 return;
9afbd7de 1720 }
3551db50 1721
4d18a639 1722 fTimeLastVdrift = vdrift;
3551db50 1723
9afbd7de 1724 // Drift time maps are saved for some drift velocity values (in drift region):
3551db50 1725 Float_t fVDsmp[8];
1726 fVDsmp[0] = 1.032;
1727 fVDsmp[1] = 1.158;
1728 fVDsmp[2] = 1.299;
1729 fVDsmp[3] = 1.450;
1730 fVDsmp[4] = 1.610;
1731 fVDsmp[5] = 1.783;
1732 fVDsmp[6] = 1.959;
1733 fVDsmp[7] = 2.134;
1734
9afbd7de 1735 if (vdrift < fVDsmp[0]) {
1736 AliWarning(Form("Drift Velocity too small (%.3f<%.3f)\n",vdrift,fVDsmp[0]));
3551db50 1737 vdrift = fVDsmp[0];
9afbd7de 1738 }
1739 else if (vdrift > fVDsmp[7]) {
1740 AliWarning(Form("Drift Velocity too large (%.3f>%.3f)\n",vdrift,fVDsmp[6]));
3551db50 1741 vdrift = fVDsmp[7];
1742 }
1743
1744 const Int_t ktimebin = 38;
9afbd7de 1745 const Int_t kZbin = 11;
3551db50 1746
1747 // Garfield simulation at UD = -1500V; vd = 1.032cm/microsec, <driftfield> = 525V/cm
1748 Float_t time1500[ktimebin][kZbin] =
1749 {{0.09170, 0.09205, 0.09306, 0.09475, 0.09716, 0.10035,
1750 0.10445, 0.10993, 0.11838, 0.13986, 0.37858},
1751 {0.06588, 0.06626, 0.06739, 0.06926, 0.07186, 0.07524,
1752 0.07951, 0.08515, 0.09381, 0.11601, 0.35673},
1753 {0.03946, 0.04003, 0.04171, 0.04435, 0.04780, 0.05193,
1754 0.05680, 0.06306, 0.07290, 0.09873, 0.34748},
1755 {0.01151, 0.01283, 0.01718, 0.02282, 0.02880, 0.03479,
1756 0.04098, 0.04910, 0.06413, 0.10567, 0.36897},
1757 {0.01116, 0.01290, 0.01721, 0.02299, 0.02863, 0.03447,
1758 0.04074, 0.04984, 0.06839, 0.11625, 0.37277},
1759 {0.03919, 0.03974, 0.04131, 0.04380, 0.04703, 0.05102,
1760 0.05602, 0.06309, 0.07651, 0.10938, 0.36838},
1761 {0.06493, 0.06560, 0.06640, 0.06802, 0.07051, 0.07392,
1762 0.07853, 0.08510, 0.09690, 0.12621, 0.38058},
1763 {0.09174, 0.09186, 0.09225, 0.09303, 0.09477, 0.00000,
1764 0.11205, 0.11952, 0.13461, 0.16984, 0.43017},
1765 {0.14356, 0.14494, 0.14959, 0.16002, 0.18328, 0.27981,
1766 0.22785, 0.21240, 0.21948, 0.25965, 0.52392},
1767 {0.23120, 0.23366, 0.24046, 0.25422, 0.28071, 0.36914,
1768 0.32999, 0.31208, 0.31772, 0.35804, 0.62249},
1769 {0.32686, 0.32916, 0.33646, 0.35053, 0.37710, 0.46292,
1770 0.42773, 0.40948, 0.41497, 0.45527, 0.71955},
1771 {0.42353, 0.42583, 0.43317, 0.44727, 0.47380, 0.55884,
1772 0.52479, 0.50650, 0.51194, 0.55225, 0.81658},
1773 {0.52038, 0.52271, 0.53000, 0.54415, 0.57064, 0.65545,
1774 0.62172, 0.60341, 0.60885, 0.64915, 0.91339},
1775 {0.61724, 0.61953, 0.62694, 0.64098, 0.66756, 0.75226,
1776 0.71862, 0.70030, 0.70575, 0.74604, 1.01035},
1777 {0.71460, 0.71678, 0.72376, 0.73786, 0.76447, 0.84913,
1778 0.81551, 0.79720, 0.80264, 0.84292, 1.10723},
1779 {0.81101, 0.81334, 0.82066, 0.83475, 0.86127, 0.94599,
1780 0.91240, 0.89408, 0.89952, 0.93981, 1.20409},
1781 {0.90788, 0.91023, 0.91752, 0.93163, 0.95815, 1.04293,
1782 1.00929, 0.99096, 0.99640, 1.03669, 1.30106},
1783 {1.00477, 1.00707, 1.01449, 1.02852, 1.05504, 1.13976,
1784 1.10617, 1.08784, 1.09329, 1.13358, 1.39796},
1785 {1.10166, 1.10397, 1.11130, 1.12541, 1.15257, 1.23672,
1786 1.20307, 1.18472, 1.19018, 1.23046, 1.49486},
1787 {1.19854, 1.20084, 1.20818, 1.22235, 1.24885, 1.33355,
1788 1.29992, 1.28156, 1.28707, 1.32735, 1.59177},
1789 {1.29544, 1.29780, 1.30507, 1.31917, 1.34575, 1.43073,
1790 1.39681, 1.37851, 1.38396, 1.42377, 1.68854},
1791 {1.39236, 1.39462, 1.40205, 1.41607, 1.44259, 1.52745,
1792 1.49368, 1.47541, 1.48083, 1.52112, 1.78546},
1793 {1.49314, 1.49149, 1.49885, 1.51297, 1.53949, 1.62420,
1794 1.59016, 1.57231, 1.57772, 1.61800, 1.88048},
1795 {1.58610, 1.58839, 1.59572, 1.60983, 1.63635, 1.72109,
1796 1.68651, 1.66921, 1.67463, 1.71489, 1.97918},
1797 {1.68400, 1.68529, 1.69261, 1.70671, 1.73331, 1.81830,
1798 1.78341, 1.76605, 1.77150, 1.81179, 2.07608},
1799 {1.77991, 1.78215, 1.78952, 1.80385, 1.83014, 1.91486,
1800 1.88128, 1.86215, 1.86837, 1.90865, 2.17304},
1801 {1.87674, 1.87904, 1.88647, 1.90052, 1.92712, 2.01173,
1802 1.97812, 1.95905, 1.96527, 2.00710, 2.26979},
1803 {1.97369, 1.97594, 1.98326, 1.99869, 2.02442, 2.10865,
1804 2.07501, 2.05666, 2.06214, 2.10243, 2.36669},
1805 {2.07052, 2.07281, 2.08016, 2.09425, 2.12132, 2.20555,
1806 2.17182, 2.15341, 2.15904, 2.19933, 2.46363},
1807 {2.16742, 2.16971, 2.17707, 2.19114, 2.21766, 2.30240,
1808 2.26877, 2.25015, 2.25573, 2.29586, 2.56060},
1809 {2.26423, 2.26659, 2.27396, 2.28803, 2.31456, 2.40828,
1810 2.36567, 2.34705, 2.35282, 2.39765, 2.65744},
1811 {2.36153, 2.36349, 2.37330, 2.38501, 2.41159, 2.49940,
1812 2.46257, 2.44420, 2.44843, 2.48987, 2.75431},
1813 {2.46558, 2.46035, 2.46822, 2.48181, 2.50849, 2.59630,
1814 2.55947, 2.54112, 2.54513, 2.58677, 2.85094},
1815 {2.56248, 2.55723, 2.56486, 2.57871, 2.60520, 2.68998,
1816 2.65626, 2.63790, 2.64316, 2.68360, 2.94813},
1817 {2.65178, 2.65441, 2.66153, 2.67556, 2.70210, 2.78687,
1818 2.75319, 2.73463, 2.74032, 2.78060, 3.04503},
1819 {2.74868, 2.75131, 2.75870, 2.77245, 2.79385, 2.88700,
1820 2.85009, 2.83177, 2.83723, 2.87750, 3.14193},
1821 {2.84574, 2.84789, 2.85560, 2.86935, 2.89075, 2.98060,
1822 2.94576, 2.92868, 2.93356, 2.97436, 3.23868},
1823 {2.94239, 2.94469, 2.95221, 2.96625, 2.99345, 3.07747,
1824 3.04266, 3.02545, 3.03051, 3.07118, 3.33555}};
1825
1826 // Garfield simulation at UD = -1600V; vd = 1.158cm/microsec, <driftfield> = 558V/cm
1827 Float_t time1600[ktimebin][kZbin] =
1828 {{0.09169, 0.09203, 0.09305, 0.09473, 0.09714, 0.10032,
1829 0.10441, 0.10990, 0.11835, 0.13986, 0.37845},
1830 {0.06589, 0.06626, 0.06738, 0.06924, 0.07184, 0.07521,
1831 0.07947, 0.08512, 0.09379, 0.11603, 0.35648},
1832 {0.03947, 0.04003, 0.04171, 0.04434, 0.04778, 0.05190,
1833 0.05678, 0.06304, 0.07292, 0.09876, 0.34759},
1834 {0.01111, 0.01281, 0.01718, 0.02281, 0.02879, 0.03477,
1835 0.04097, 0.04910, 0.06415, 0.10573, 0.36896},
1836 {0.01120, 0.01311, 0.01721, 0.02279, 0.02862, 0.03446,
1837 0.04074, 0.04981, 0.06825, 0.11595, 0.37255},
1838 {0.03919, 0.03980, 0.04132, 0.04380, 0.04704, 0.05102,
1839 0.05602, 0.06302, 0.07633, 0.10896, 0.36743},
1840 {0.06531, 0.06528, 0.06631, 0.06805, 0.07053, 0.07392,
1841 0.07853, 0.08505, 0.09669, 0.12578, 0.37967},
1842 {0.09157, 0.09171, 0.09216, 0.09301, 0.09475, 0.00000,
1843 0.11152, 0.11879, 0.13352, 0.16802, 0.42750},
1844 {0.13977, 0.14095, 0.14509, 0.15433, 0.17534, 0.26406,
1845 0.21660, 0.20345, 0.21113, 0.25067, 0.51434},
1846 {0.21816, 0.22041, 0.22631, 0.23850, 0.26208, 0.34340,
1847 0.30755, 0.29237, 0.29878, 0.33863, 0.60258},
1848 {0.30344, 0.30547, 0.31241, 0.32444, 0.34809, 0.42696,
1849 0.39464, 0.37919, 0.38546, 0.42530, 0.68926},
1850 {0.38969, 0.39164, 0.39810, 0.41059, 0.43441, 0.51246,
1851 0.48112, 0.46562, 0.47191, 0.51172, 0.77558},
1852 {0.47592, 0.47799, 0.48442, 0.49689, 0.52061, 0.59855,
1853 0.56752, 0.55201, 0.55826, 0.59808, 0.86202},
1854 {0.56226, 0.56428, 0.57074, 0.58324, 0.60696, 0.68483,
1855 0.65388, 0.63837, 0.64461, 0.68445, 0.94830},
1856 {0.64881, 0.65063, 0.65709, 0.66958, 0.69331, 0.77117,
1857 0.74023, 0.72472, 0.73098, 0.77079, 1.03486},
1858 {0.73506, 0.73698, 0.74344, 0.75596, 0.77964, 0.85751,
1859 0.82658, 0.81107, 0.81731, 0.85712, 1.12106},
1860 {0.82132, 0.82333, 0.82979, 0.84228, 0.86608, 0.94386,
1861 0.91293, 0.89742, 0.90367, 0.94335, 1.20737},
1862 {0.90767, 0.90968, 0.91614, 0.92863, 0.95236, 1.03021,
1863 0.99928, 0.98377, 0.99001, 1.02984, 1.29371},
1864 {0.99410, 0.99602, 1.00257, 1.01498, 1.03869, 1.11720,
1865 1.08563, 1.07011, 1.07637, 1.11621, 1.37873},
1866 {1.08036, 1.08240, 1.08884, 1.10138, 1.12504, 1.20301,
1867 1.17198, 1.15647, 1.16272, 1.20255, 1.46651},
1868 {1.16670, 1.16872, 1.17525, 1.18783, 1.21139, 1.28934,
1869 1.25833, 1.24281, 1.24909, 1.28889, 1.55275},
1870 {1.25307, 1.25510, 1.26153, 1.27404, 1.29773, 1.37584,
1871 1.34469, 1.32916, 1.33536, 1.37524, 1.63915},
1872 {1.33942, 1.34146, 1.34788, 1.36040, 1.38410, 1.46438,
1873 1.43105, 1.41537, 1.42176, 1.46158, 1.72538},
1874 {1.42579, 1.42782, 1.43458, 1.44674, 1.47043, 1.55085,
1875 1.51675, 1.50168, 1.50810, 1.54793, 1.81174},
1876 {1.51207, 1.51454, 1.52060, 1.53307, 1.55684, 1.63478,
1877 1.60336, 1.58820, 1.59446, 1.63414, 1.89814},
1878 {1.59856, 1.60047, 1.60693, 1.61942, 1.64317, 1.72257,
1879 1.69008, 1.67454, 1.68080, 1.72063, 1.98433},
1880 {1.68481, 1.68682, 1.69330, 1.70584, 1.72949, 1.80752,
1881 1.77643, 1.76089, 1.76716, 1.80692, 2.07069},
1882 {1.77117, 1.77319, 1.77969, 1.79260, 1.81583, 1.89376,
1883 1.86226, 1.84720, 1.85355, 1.89256, 2.15343},
1884 {1.85748, 1.85967, 1.86605, 1.87848, 1.90222, 1.98010,
1885 1.94913, 1.93271, 1.93981, 1.97968, 2.24355},
1886 {1.94386, 1.94587, 1.95233, 1.96484, 1.98854, 2.06646,
1887 2.03542, 2.01755, 2.02617, 2.06604, 2.32993},
1888 {2.03022, 2.03230, 2.03868, 2.05134, 2.07488, 2.15367,
1889 2.12178, 2.10391, 2.11252, 2.15432, 2.41623},
1890 {2.11656, 2.11857, 2.12505, 2.13772, 2.16147, 2.23919,
1891 2.20817, 2.19265, 2.20744, 2.23872, 2.49996},
1892 {2.20291, 2.20611, 2.21137, 2.22387, 2.24758, 2.32563,
1893 2.29450, 2.27901, 2.28525, 2.32507, 2.58897},
1894 {2.28922, 2.29172, 2.29774, 2.31345, 2.33400, 2.41287,
1895 2.38086, 2.36535, 2.37160, 2.40869, 2.67113},
1896 {2.37572, 2.37764, 2.38410, 2.39803, 2.42046, 2.49817,
1897 2.46721, 2.45171, 2.45794, 2.49505, 2.76061},
1898 {2.46190, 2.46396, 2.47043, 2.48340, 2.50665, 2.58453,
1899 2.55357, 2.53728, 2.54430, 2.58407, 2.84816},
1900 {2.54833, 2.55032, 2.55679, 2.56976, 2.59312, 2.67103,
1901 2.63993, 2.62364, 2.63062, 2.67040, 2.93444},
1902 {2.63456, 2.63660, 2.64304, 2.65555, 2.67938, 2.75739,
1903 2.72629, 2.71064, 2.71688, 2.75671, 3.01886}};
1904
1905 // Garfield simulation at UD = -1700V; vd = 1.299cm/microsec, <driftfield> = 590V/cm
1906 Float_t time1700[ktimebin][kZbin] =
1907 {{0.09167, 0.09201, 0.09302, 0.09471, 0.09712, 0.10029,
1908 0.10438, 0.10986, 0.11832, 0.13986, 0.37824},
1909 {0.06591, 0.06626, 0.06736, 0.06923, 0.07183, 0.07519,
1910 0.07944, 0.08511, 0.09378, 0.11603, 0.35625},
1911 {0.03946, 0.04003, 0.04170, 0.04433, 0.04777, 0.05189,
1912 0.05676, 0.06301, 0.07291, 0.09880, 0.34724},
1913 {0.01110, 0.01281, 0.01718, 0.02280, 0.02879, 0.03476,
1914 0.04096, 0.04910, 0.06417, 0.10582, 0.36861},
1915 {0.01115, 0.01294, 0.01721, 0.02276, 0.02862, 0.03447,
1916 0.04074, 0.04980, 0.06812, 0.11565, 0.37231},
1917 {0.03920, 0.03974, 0.04133, 0.04381, 0.04706, 0.05105,
1918 0.05603, 0.06299, 0.07618, 0.10860, 0.36646},
1919 {0.06498, 0.06529, 0.06634, 0.06808, 0.07055, 0.07395,
1920 0.07852, 0.08500, 0.09650, 0.12532, 0.37850},
1921 {0.09143, 0.09159, 0.09207, 0.09297, 0.09473, 0.00000,
1922 0.11102, 0.11809, 0.13245, 0.16627, 0.42496},
1923 {0.13646, 0.13750, 0.14112, 0.14926, 0.16806, 0.24960,
1924 0.20627, 0.19536, 0.20366, 0.24256, 0.50557},
1925 {0.20678, 0.20848, 0.21384, 0.22450, 0.24552, 0.32018,
1926 0.28740, 0.27477, 0.28196, 0.32128, 0.58475},
1927 {0.28287, 0.28461, 0.29020, 0.30108, 0.32224, 0.39467,
1928 0.36500, 0.35217, 0.35926, 0.39860, 0.66194},
1929 {0.35972, 0.36145, 0.36713, 0.37797, 0.39912, 0.47091,
1930 0.44212, 0.42925, 0.43632, 0.47563, 0.73892},
1931 {0.43667, 0.43841, 0.44413, 0.45494, 0.47607, 0.54780,
1932 0.51912, 0.50627, 0.51334, 0.55254, 0.81595},
1933 {0.51365, 0.51540, 0.52101, 0.53193, 0.55305, 0.62463,
1934 0.59617, 0.58328, 0.59035, 0.62965, 0.89303},
1935 {0.59064, 0.59240, 0.59801, 0.60893, 0.63009, 0.70169,
1936 0.67317, 0.66028, 0.66735, 0.70666, 0.96995},
1937 {0.66765, 0.66939, 0.67501, 0.68592, 0.70724, 0.77863,
1938 0.75016, 0.73728, 0.74435, 0.78366, 1.04696},
1939 {0.74464, 0.74636, 0.75200, 0.76293, 0.78405, 0.85561,
1940 0.82716, 0.81427, 0.82133, 0.86064, 1.12396},
1941 {0.82165, 0.82340, 0.82902, 0.83991, 0.86104, 0.93266,
1942 0.90414, 0.89128, 0.89834, 0.93763, 1.20100},
1943 {0.89863, 0.90042, 0.90659, 0.91705, 0.93805, 1.00960,
1944 0.98115, 0.96825, 0.97533, 1.01462, 1.27801},
1945 {0.97563, 0.97740, 0.98310, 0.99391, 1.01504, 1.08659,
1946 1.05814, 1.04526, 1.05233, 1.09163, 1.35503},
1947 {1.05276, 1.05451, 1.06002, 1.07090, 1.09099, 1.16357,
1948 1.13516, 1.12225, 1.12933, 1.16863, 1.43195},
1949 {1.12977, 1.13138, 1.13700, 1.14792, 1.16797, 1.24061,
1950 1.21212, 1.19926, 1.20626, 1.24554, 1.50900},
1951 {1.20664, 1.20839, 1.21400, 1.22490, 1.24606, 1.31772,
1952 1.28914, 1.27382, 1.28329, 1.32262, 1.58550},
1953 {1.28367, 1.28541, 1.29099, 1.30189, 1.32312, 1.39460,
1954 1.36612, 1.34924, 1.36030, 1.39961, 1.66310},
1955 {1.36064, 1.36249, 1.36799, 1.37896, 1.40004, 1.48030,
1956 1.44314, 1.43032, 1.43731, 1.47659, 1.73442},
1957 {1.43762, 1.43937, 1.44497, 1.45618, 1.47704, 1.54932,
1958 1.52012, 1.50725, 1.51430, 1.55357, 1.81708},
1959 {1.51462, 1.51937, 1.52203, 1.53316, 1.55403, 1.62572,
1960 1.59713, 1.58424, 1.59128, 1.63061, 1.89406},
1961 {1.59162, 1.59338, 1.59947, 1.60989, 1.63103, 1.70270,
1962 1.67411, 1.66124, 1.66799, 1.70759, 1.97103},
1963 {1.66874, 1.67037, 1.67597, 1.68687, 1.70814, 1.77969,
1964 1.75112, 1.73806, 1.74530, 1.78457, 2.04794},
1965 {1.74693, 1.74749, 1.75297, 1.76476, 1.78500, 1.85667,
1966 1.82811, 1.81504, 1.82101, 1.86161, 2.12492},
1967 {1.82260, 1.82437, 1.82995, 1.84174, 1.86202, 1.93372,
1968 1.90509, 1.89202, 1.89930, 1.93859, 2.20189},
1969 {1.89964, 1.90135, 1.90693, 1.91789, 1.93952, 2.01080,
1970 1.98207, 1.96921, 1.97628, 2.01384, 2.27887},
1971 {1.97662, 1.97917, 1.98611, 1.99487, 2.01601, 2.08778,
1972 2.05846, 2.04623, 2.05330, 2.09244, 2.35585},
1973 {2.05359, 2.05615, 2.06309, 2.07187, 2.09867, 2.16459,
1974 2.13610, 2.12322, 2.13029, 2.16942, 2.43199},
1975 {2.13063, 2.13233, 2.13795, 2.14886, 2.17008, 2.24199,
1976 2.21310, 2.20020, 2.20727, 2.24659, 2.50983},
1977 {2.20761, 2.20931, 2.21955, 2.22624, 2.24708, 2.32147,
1978 2.29009, 2.27725, 2.28276, 2.32359, 2.58680},
1979 {2.28459, 2.29108, 2.29202, 2.30286, 2.32007, 2.39559,
1980 2.36683, 2.35422, 2.36119, 2.40058, 2.66081},
1981 {2.36153, 2.36806, 2.36889, 2.37985, 2.40092, 2.47828,
1982 2.44381, 2.43099, 2.43819, 2.47750, 2.73779}};
1983
1984 // Garfield simulation at UD = -1800V; vd = 1.450cm/microsec, <driftfield> = 623V/cm
1985 Float_t time1800[ktimebin][kZbin] =
1986 {{0.09166, 0.09199, 0.09300, 0.09470, 0.09709, 0.10026,
1987 0.10434, 0.10983, 0.11831, 0.13987, 0.37802},
1988 {0.06585, 0.06623, 0.06735, 0.06921, 0.07180, 0.07520,
1989 0.07941, 0.08507, 0.09376, 0.11604, 0.35624},
1990 {0.03945, 0.04004, 0.04169, 0.04432, 0.04776, 0.05187,
1991 0.05674, 0.06300, 0.07290, 0.09884, 0.34704},
1992 {0.01108, 0.01287, 0.01717, 0.02280, 0.02880, 0.03476,
1993 0.04095, 0.04909, 0.06419, 0.10589, 0.36843},
1994 {0.01115, 0.01287, 0.01720, 0.02276, 0.02862, 0.03448,
1995 0.04073, 0.04973, 0.06799, 0.11535, 0.37224},
1996 {0.03918, 0.03975, 0.04134, 0.04382, 0.04707, 0.05105,
1997 0.05603, 0.06296, 0.07605, 0.10822, 0.36560},
1998 {0.06498, 0.06532, 0.06635, 0.06809, 0.07058, 0.07395,
1999 0.07855, 0.08495, 0.09632, 0.12488, 0.37730},
2000 {0.09130, 0.09160, 0.09199, 0.09300, 0.09472, 0.00000,
2001 0.11059, 0.11747, 0.13146, 0.16462, 0.42233},
2002 {0.13364, 0.13449, 0.13767, 0.14481, 0.16147, 0.23635,
2003 0.19706, 0.18812, 0.19704, 0.23520, 0.49749},
2004 {0.19698, 0.19844, 0.20311, 0.21236, 0.23082, 0.29920,
2005 0.26936, 0.25927, 0.26732, 0.30601, 0.56871},
2006 {0.26518, 0.26670, 0.27160, 0.28099, 0.29955, 0.36597,
2007 0.33885, 0.32858, 0.33653, 0.37524, 0.63801},
2008 {0.33441, 0.33553, 0.34040, 0.34987, 0.36841, 0.43428,
2009 0.40797, 0.39763, 0.40556, 0.44425, 0.70698},
2010 {0.40296, 0.40447, 0.40934, 0.41881, 0.43737, 0.50306,
2011 0.47695, 0.46662, 0.47455, 0.51329, 0.77600},
2012 {0.47296, 0.47344, 0.47830, 0.48779, 0.50632, 0.57200,
2013 0.54593, 0.53559, 0.54351, 0.58222, 0.84489},
2014 {0.54089, 0.54264, 0.54727, 0.55673, 0.57529, 0.64094,
2015 0.61490, 0.60457, 0.61249, 0.65118, 0.91394},
2016 {0.60987, 0.61138, 0.61624, 0.62573, 0.64428, 0.70989,
2017 0.68397, 0.67354, 0.68147, 0.72015, 0.98291},
2018 {0.67883, 0.68035, 0.68521, 0.69469, 0.71324, 0.77896,
2019 0.75287, 0.74251, 0.75043, 0.78912, 1.04458},
2020 {0.74780, 0.74932, 0.75421, 0.76367, 0.78221, 0.84785,
2021 0.82185, 0.81148, 0.81941, 0.85811, 1.12085},
2022 {0.81690, 0.81830, 0.82316, 0.83263, 0.85120, 0.91683,
2023 0.89077, 0.88045, 0.88837, 0.92707, 1.18976},
2024 {0.88574, 0.88726, 0.89228, 0.90198, 0.92017, 0.98578,
2025 0.95974, 0.94947, 0.95734, 0.99604, 1.25873},
2026 {0.95493, 0.95624, 0.96110, 0.97058, 0.98913, 1.05481,
2027 1.02873, 1.01839, 1.02631, 1.06503, 1.32772},
2028 {1.02392, 1.02524, 1.03008, 1.03955, 1.05810, 1.12378,
2029 1.09757, 1.08605, 1.09530, 1.13399, 1.39669},
2030 {1.09270, 1.09418, 1.09911, 1.10854, 1.12714, 1.19281,
2031 1.16502, 1.15633, 1.16427, 1.20271, 1.46574},
2032 {1.16168, 1.16323, 1.16801, 1.17772, 1.19604, 1.26190,
2033 1.23399, 1.22531, 1.23323, 1.27194, 1.53475},
2034 {1.23061, 1.23214, 1.23698, 1.24669, 1.26503, 1.33073,
2035 1.30461, 1.29428, 1.30220, 1.34091, 1.60372},
2036 {1.29960, 1.30110, 1.30596, 1.31544, 1.33398, 1.39962,
2037 1.37228, 1.36323, 1.37121, 1.40988, 1.67273},
2038 {1.36851, 1.37007, 1.37512, 1.38441, 1.40297, 1.46865,
2039 1.44256, 1.43222, 1.44017, 1.47878, 1.74155},
2040 {1.43752, 1.43904, 1.44773, 1.45338, 1.47220, 1.53759,
2041 1.51136, 1.50119, 1.50914, 1.54775, 1.81050},
2042 {1.50646, 1.50802, 1.51288, 1.52237, 1.54097, 1.60697,
2043 1.58049, 1.57018, 1.57811, 1.61678, 1.87947},
2044 {1.57545, 1.57720, 1.58185, 1.59134, 1.60996, 1.67787,
2045 1.64929, 1.63914, 1.64707, 1.68570, 1.94851},
2046 {1.64442, 1.64617, 1.65081, 1.66035, 1.67893, 1.74684,
2047 1.71826, 1.70745, 1.71604, 1.75310, 2.01748},
2048 {1.71337, 1.71513, 1.71978, 1.72932, 1.74645, 1.81346,
2049 1.78739, 1.77642, 1.78501, 1.82151, 2.08644},
2050 {1.78238, 1.78410, 1.78876, 1.79824, 1.81678, 1.88332,
2051 1.85639, 1.84262, 1.85397, 1.89270, 2.15533},
2052 {1.85135, 1.85306, 1.85778, 1.86728, 1.88580, 1.95615,
2053 1.92536, 1.91171, 1.92283, 1.96165, 2.22428},
2054 {1.92774, 1.92184, 1.92672, 1.93618, 1.95477, 2.02048,
2055 1.99427, 1.98068, 1.99192, 2.03062, 2.29338},
2056 {1.98929, 1.99081, 1.99567, 2.00515, 2.02373, 2.08987,
2057 2.06332, 2.05249, 2.05939, 2.09928, 2.36227},
2058 {2.05829, 2.05978, 2.06464, 2.07414, 2.09272, 2.15850,
2059 2.12928, 2.12194, 2.12987, 2.16825, 2.43083},
2060 {2.12726, 2.12869, 2.13360, 2.14425, 2.16160, 2.22872,
2061 2.20118, 2.19078, 2.19876, 2.23416, 2.50007}};
2062
2063 // Garfield simulation at UD = -1900V; vd = 1.610cm/microsec, <driftfield> = 655V/cm
2064 Float_t time1900[ktimebin][kZbin] =
2065 {{0.09166, 0.09198, 0.09298, 0.09467, 0.09707, 0.10023,
2066 0.10431, 0.10980, 0.11828, 0.13988, 0.37789},
2067 {0.06584, 0.06622, 0.06735, 0.06920, 0.07179, 0.07514,
2068 0.07938, 0.08505, 0.09374, 0.11606, 0.35599},
2069 {0.03945, 0.04002, 0.04169, 0.04432, 0.04775, 0.05185,
2070 0.05672, 0.06298, 0.07290, 0.09888, 0.34695},
2071 {0.01109, 0.01281, 0.01717, 0.02279, 0.02878, 0.03476,
2072 0.04094, 0.04909, 0.06421, 0.10597, 0.36823},
2073 {0.01115, 0.01287, 0.01720, 0.02294, 0.02862, 0.03448,
2074 0.04074, 0.04973, 0.06783, 0.11506, 0.37206},
2075 {0.03940, 0.03975, 0.04135, 0.04386, 0.04708, 0.05106,
2076 0.05604, 0.06293, 0.07592, 0.10787, 0.36484},
2077 {0.06500, 0.06534, 0.06638, 0.06811, 0.07060, 0.07413,
2078 0.07852, 0.08491, 0.09614, 0.12446, 0.37626},
2079 {0.09119, 0.09140, 0.09194, 0.09293, 0.09471, 0.00000,
2080 0.11013, 0.11685, 0.13050, 0.16302, 0.41991},
2081 {0.13111, 0.13190, 0.13466, 0.14091, 0.15554, 0.22409,
2082 0.18846, 0.18167, 0.19113, 0.22854, 0.48995},
2083 {0.18849, 0.18975, 0.19380, 0.20185, 0.21797, 0.28050,
2084 0.25368, 0.24575, 0.25446, 0.29249, 0.55442},
2085 {0.24995, 0.25125, 0.25563, 0.26366, 0.27986, 0.34065,
2086 0.31605, 0.30815, 0.31680, 0.35482, 0.61697},
2087 {0.31187, 0.31324, 0.31745, 0.32580, 0.34205, 0.40217,
2088 0.37825, 0.37031, 0.37897, 0.41696, 0.67890},
2089 {0.37401, 0.37531, 0.37955, 0.38777, 0.40395, 0.46408,
2090 0.44037, 0.43242, 0.44108, 0.47906, 0.74122},
2091 {0.43610, 0.43741, 0.44161, 0.44986, 0.46604, 0.52614,
2092 0.50248, 0.49452, 0.50316, 0.54116, 0.80326},
2093 {0.49820, 0.49988, 0.50372, 0.51196, 0.52814, 0.58822,
2094 0.56459, 0.55661, 0.56527, 0.60326, 0.86526},
2095 {0.56032, 0.56161, 0.56582, 0.57408, 0.59024, 0.65032,
2096 0.62670, 0.61872, 0.62737, 0.66537, 0.92749},
2097 {0.62240, 0.62371, 0.62792, 0.63624, 0.65236, 0.71241,
2098 0.68881, 0.68081, 0.68947, 0.72750, 0.98941},
2099 {0.68449, 0.68581, 0.69002, 0.69828, 0.71444, 0.77452,
2100 0.75089, 0.74295, 0.75157, 0.78957, 1.05157},
2101 {0.74660, 0.74790, 0.75212, 0.76036, 0.77654, 0.83748,
2102 0.81299, 0.80501, 0.81193, 0.85168, 1.11375},
2103 {0.80870, 0.81017, 0.81423, 0.82246, 0.83867, 0.89908,
2104 0.87509, 0.86660, 0.87577, 0.91376, 1.17586},
2105 {0.87080, 0.87233, 0.87632, 0.88458, 0.90074, 0.96083,
2106 0.93718, 0.92922, 0.93787, 0.97588, 1.23794},
2107 {0.93291, 0.93422, 0.93844, 0.94667, 0.96293, 1.02295,
2108 0.99929, 0.99127, 0.99997, 1.03797, 1.29995},
2109 {0.99500, 0.99645, 1.00308, 1.00877, 1.02497, 1.08504,
2110 1.06140, 1.05343, 1.06203, 1.10006, 1.36216},
2111 {1.05712, 1.05926, 1.06262, 1.07092, 1.08706, 1.14754,
2112 1.12350, 1.11550, 1.12417, 1.16218, 1.42427},
2113 {1.11921, 1.12059, 1.12473, 1.13297, 1.14916, 1.21140,
2114 1.18560, 1.17284, 1.18625, 1.22414, 1.48629},
2115 {1.18140, 1.18262, 1.18690, 1.19508, 1.21125, 1.27139,
2116 1.24164, 1.23495, 1.24838, 1.28634, 1.54852},
2117 {1.24340, 1.24473, 1.24901, 1.25732, 1.27336, 1.33358,
2118 1.30793, 1.30179, 1.31047, 1.34848, 1.61066},
2119 {1.30551, 1.30684, 1.31104, 1.32056, 1.33553, 1.39609,
2120 1.37004, 1.36392, 1.37045, 1.41057, 1.67259},
2121 {1.36755, 1.36892, 1.37315, 1.39148, 1.39755, 1.45820,
2122 1.43215, 1.42602, 1.43467, 1.47268, 1.73477},
2123 {1.42966, 1.43101, 1.43549, 1.45359, 1.45976, 1.52031,
2124 1.49601, 1.48811, 1.49677, 1.53477, 1.79691},
2125 {1.49180, 1.49321, 1.49760, 1.51570, 1.52175, 1.58185,
2126 1.55771, 1.55023, 1.55888, 1.59672, 1.85501},
2127 {1.55391, 1.55527, 1.55943, 1.57782, 1.58391, 1.64395,
2128 1.62008, 1.61233, 1.62085, 1.65883, 1.92091},
2129 {1.61599, 1.61732, 1.62154, 1.63993, 1.64612, 1.70608,
2130 1.68237, 1.67108, 1.68301, 1.72110, 1.97931},
2131 {1.67808, 1.67948, 1.68364, 1.70204, 1.70823, 1.76858,
2132 1.74404, 1.73539, 1.74512, 1.78321, 2.04522},
2133 {1.74019, 1.74152, 1.74573, 1.76415, 1.77015, 1.83040,
2134 1.80615, 1.79366, 1.80723, 1.84509, 2.10742},
2135 {1.80235, 1.80362, 1.80783, 1.82626, 1.83227, 1.89246,
2136 1.86795, 1.85405, 1.86938, 1.90720, 2.16953},
2137 {1.86442, 1.86572, 1.86994, 1.88837, 1.89438, 1.95445,
2138 1.93006, 1.92283, 1.93148, 1.96931, 2.23147},
2139 {1.92700, 1.92783, 1.93197, 1.95049, 1.95649, 2.01668,
2140 1.99217, 1.98486, 1.99352, 2.03143, 2.29358}};
2141
2142 // Garfield simulation at UD = -2000V; vd = 1.783cm/microsec, <driftfield> = 688V/cm
2143 Float_t time2000[ktimebin][kZbin] =
2144 {{0.09176, 0.09196, 0.09296, 0.09465, 0.09704, 0.10020,
2145 0.10427, 0.10977, 0.11825, 0.13988, 0.37774},
2146 {0.06583, 0.06620, 0.06735, 0.06918, 0.07177, 0.07513,
2147 0.07936, 0.08503, 0.09372, 0.11606, 0.35586},
2148 {0.03944, 0.04001, 0.04170, 0.04431, 0.04774, 0.05184,
2149 0.05670, 0.06296, 0.07291, 0.09893, 0.34680},
2150 {0.01108, 0.01281, 0.01719, 0.02279, 0.02879, 0.03474,
2151 0.04093, 0.04908, 0.06422, 0.10605, 0.36800},
2152 {0.01114, 0.01287, 0.01720, 0.02276, 0.02863, 0.03449,
2153 0.04073, 0.04970, 0.06774, 0.11478, 0.37179},
2154 {0.03925, 0.03977, 0.04135, 0.04386, 0.04711, 0.05108,
2155 0.05604, 0.06290, 0.07580, 0.10748, 0.36386},
2156 {0.06501, 0.06536, 0.06640, 0.06814, 0.07062, 0.07398,
2157 0.07852, 0.08487, 0.09598, 0.12405, 0.37519},
2158 {0.09109, 0.09127, 0.09188, 0.09292, 0.09472, 0.00000,
2159 0.10964, 0.11630, 0.12960, 0.16150, 0.41765},
2160 {0.12898, 0.12968, 0.13209, 0.13749, 0.15034, 0.21286,
2161 0.18088, 0.17590, 0.18591, 0.22254, 0.48315},
2162 {0.18122, 0.18227, 0.18574, 0.19263, 0.20674, 0.26376,
2163 0.23960, 0.23375, 0.24316, 0.28047, 0.54179},
2164 {0.23674, 0.23784, 0.24142, 0.24847, 0.26264, 0.31810,
2165 0.29602, 0.29008, 0.29944, 0.33675, 0.59795},
2166 {0.29279, 0.29382, 0.29742, 0.30448, 0.31865, 0.37364,
2167 0.35215, 0.34629, 0.35555, 0.39286, 0.65411},
2168 {0.34875, 0.34987, 0.35346, 0.36054, 0.37472, 0.42956,
2169 0.40825, 0.40229, 0.41167, 0.44894, 0.71033},
2170 {0.40484, 0.40594, 0.40954, 0.41660, 0.43077, 0.48560,
2171 0.46433, 0.45840, 0.46772, 0.50500, 0.76632},
2172 {0.46090, 0.46201, 0.46560, 0.47267, 0.48684, 0.54167,
2173 0.52041, 0.51449, 0.52382, 0.56108, 0.82227},
2174 {0.51698, 0.51809, 0.52173, 0.52874, 0.54291, 0.59776,
2175 0.57646, 0.57052, 0.57986, 0.61717, 0.87836},
2176 {0.57306, 0.57418, 0.57782, 0.58513, 0.59899, 0.65380,
2177 0.63255, 0.62661, 0.63594, 0.67325, 0.93460},
2178 {0.62912, 0.63024, 0.63383, 0.64103, 0.65506, 0.70988,
2179 0.68484, 0.68267, 0.69202, 0.72878, 0.99046},
2180 {0.68521, 0.68633, 0.68990, 0.69699, 0.71115, 0.76595,
2181 0.74468, 0.73872, 0.74814, 0.78538, 1.04674},
2182 {0.74127, 0.74239, 0.74605, 0.75303, 0.77022, 0.82204,
2183 0.80078, 0.79484, 0.80416, 0.84147, 1.10261},
2184 {0.79736, 0.79846, 0.80206, 0.80947, 0.82330, 0.87813,
2185 0.85688, 0.85087, 0.86023, 0.89752, 1.15874},
2186 {0.85342, 0.85454, 0.85815, 0.86519, 0.87936, 0.93417,
2187 0.91293, 0.90428, 0.91631, 0.95360, 1.20760},
2188 {0.90949, 0.91061, 0.91423, 0.92128, 0.93544, 0.99026,
2189 0.96807, 0.96305, 0.97239, 1.00967, 1.27078},
2190 {0.96556, 0.96669, 0.97111, 0.97734, 0.99151, 1.04664,
2191 1.02508, 1.01879, 1.02846, 1.06167, 1.32695},
2192 {1.02167, 1.02279, 1.02656, 1.03341, 1.04759, 1.10242,
2193 1.08115, 1.07003, 1.08453, 1.12184, 1.38304},
2194 {1.07776, 1.07883, 1.08242, 1.08950, 1.10384, 1.16422,
2195 1.13725, 1.13133, 1.14061, 1.17793, 1.43910},
2196 {1.13379, 1.13492, 1.13864, 1.14567, 1.15973, 1.21455,
2197 1.19323, 1.18734, 1.19668, 1.23401, 1.49528},
2198 {1.18988, 1.19098, 1.19457, 1.20164, 1.21582, 1.27064,
2199 1.24937, 1.24044, 1.25275, 1.29004, 1.55137},
2200 {1.24592, 1.24706, 1.25087, 1.25773, 1.27188, 1.32670,
2201 1.30544, 1.29953, 1.30883, 1.34613, 1.60743},
2202 {1.30202, 1.30313, 1.30673, 1.31381, 1.32797, 1.38278,
2203 1.36151, 1.35167, 1.36490, 1.40221, 1.66306},
2204 {1.35809, 1.35921, 1.36282, 1.36986, 1.38403, 1.43888,
2205 1.41760, 1.41174, 1.42083, 1.45830, 1.71915},
2206 {1.41419, 1.41528, 1.41890, 1.42595, 1.44011, 1.49496,
2207 1.47368, 1.46769, 1.47706, 1.51436, 1.77523},
2208 {1.47131, 1.47141, 1.47494, 1.48850, 1.49620, 1.55137,
2209 1.52977, 1.51820, 1.53315, 1.57042, 1.83158},
2210 {1.52635, 1.52750, 1.53103, 1.53814, 1.55228, 1.60736,
2211 1.58503, 1.57986, 1.58920, 1.62649, 1.88767},
2212 {1.58418, 1.58355, 1.58711, 1.59526, 1.60833, 1.66316,
2213 1.63345, 1.63261, 1.64556, 1.68204, 1.94359},
2214 {1.64027, 1.63958, 1.64489, 1.65024, 1.66443, 1.71925,
2215 1.69794, 1.69201, 1.70143, 1.73865, 1.99968},
2216 {1.69450, 1.69566, 1.69940, 1.70697, 1.71841, 1.77819,
2217 1.75396, 1.74814, 1.75743, 1.79083, 2.05427},
2218 {1.75054, 1.75221, 1.75527, 1.76306, 1.77662, 1.83428,
2219 1.81006, 1.81173, 1.81345, 1.85076, 2.10289}};
2220
2221 // Garfield simulation at UD = -2100V; vd = 1.959cm/microsec, <driftfield> = 720V/cm
2222 Float_t time2100[ktimebin][kZbin] =
2223 {{0.09160, 0.09194, 0.09294, 0.09462, 0.09701, 0.10017,
2224 0.10424, 0.10974, 0.11823, 0.13988, 0.37762},
2225 {0.06585, 0.06619, 0.06731, 0.06916, 0.07174, 0.07509,
2226 0.07933, 0.08500, 0.09370, 0.11609, 0.35565},
2227 {0.03960, 0.04001, 0.04171, 0.04430, 0.04774, 0.05182,
2228 0.05668, 0.06294, 0.07291, 0.09896, 0.34676},
2229 {0.01109, 0.01280, 0.01716, 0.02279, 0.02876, 0.03474,
2230 0.04096, 0.04908, 0.06424, 0.10612, 0.36790},
2231 {0.01114, 0.01285, 0.01719, 0.02287, 0.02863, 0.03449,
2232 0.04073, 0.04964, 0.06759, 0.11446, 0.37162},
2233 {0.03922, 0.03977, 0.04146, 0.04386, 0.04711, 0.05109,
2234 0.05605, 0.06287, 0.07575, 0.10713, 0.36298},
2235 {0.06504, 0.06538, 0.06641, 0.06818, 0.07064, 0.07426,
2236 0.07852, 0.08483, 0.09581, 0.12363, 0.37424},
2237 {0.09103, 0.09129, 0.09186, 0.09291, 0.09476, 0.00000,
2238 0.10923, 0.11578, 0.12873, 0.16005, 0.41525},
2239 {0.12723, 0.12777, 0.12988, 0.13458, 0.14579, 0.20264,
2240 0.17421, 0.17078, 0.18132, 0.21708, 0.47699},
2241 {0.17508, 0.17601, 0.17897, 0.18487, 0.19698, 0.24881,
2242 0.22737, 0.22337, 0.23348, 0.27000, 0.53032},
2243 {0.22571, 0.22663, 0.22969, 0.23570, 0.24787, 0.29826,
2244 0.27871, 0.27462, 0.28471, 0.32122, 0.58166},
2245 {0.27664, 0.27759, 0.28067, 0.28669, 0.29891, 0.34898,
2246 0.32982, 0.32570, 0.33576, 0.37229, 0.63268},
2247 {0.32766, 0.32862, 0.33170, 0.33778, 0.34988, 0.39973,
2248 0.38088, 0.37675, 0.38680, 0.42333, 0.68159},
2249 {0.37872, 0.37966, 0.38275, 0.38875, 0.40093, 0.45073,
2250 0.43192, 0.42780, 0.43786, 0.47438, 0.73480},
2251 {0.42974, 0.43070, 0.43378, 0.43982, 0.45196, 0.50177,
2252 0.48297, 0.47884, 0.48889, 0.52544, 0.78581},
2253 {0.48081, 0.48175, 0.48482, 0.49084, 0.50302, 0.55290,
2254 0.53398, 0.52988, 0.53994, 0.57647, 0.83687},
2255 {0.53645, 0.53295, 0.53586, 0.54188, 0.55408, 0.60398,
2256 0.58504, 0.58092, 0.59100, 0.62768, 0.88773},
2257 {0.58345, 0.58409, 0.58690, 0.59292, 0.60510, 0.65562,
2258 0.63609, 0.63197, 0.64203, 0.67856, 0.93907},
2259 {0.63397, 0.63490, 0.63795, 0.64403, 0.65613, 0.70612,
2260 0.68714, 0.68301, 0.69294, 0.72955, 0.99000},
2261 {0.68496, 0.68592, 0.68899, 0.69504, 0.70733, 0.75708,
2262 0.73818, 0.73405, 0.74412, 0.78064, 1.04100},
2263 {0.73600, 0.73696, 0.74003, 0.74624, 0.75828, 0.80805,
2264 0.78904, 0.78512, 0.79517, 0.83152, 1.09205},
2265 {0.78709, 0.78801, 0.79108, 0.79709, 0.80931, 0.85906,
2266 0.84027, 0.83614, 0.84621, 0.88269, 1.14058},
2267 {0.83808, 0.83905, 0.84215, 0.84816, 0.86031, 0.91011,
2268 0.89139, 0.88718, 0.89725, 0.93377, 1.19413},
2269 {0.88916, 0.89010, 0.89320, 0.89920, 0.91136, 0.96117,
2270 0.94235, 0.93822, 0.94828, 0.98480, 1.24538},
2271 {0.94036, 0.94113, 0.94422, 0.95023, 0.96241, 1.01220,
2272 0.99310, 0.98927, 0.99933, 1.03585, 1.29629},
2273 {0.99139, 0.99220, 0.99525, 1.00127, 1.01344, 1.06324,
2274 1.04451, 1.04033, 1.04836, 1.08690, 1.34727},
2275 {1.04261, 1.04325, 1.04628, 1.05232, 1.06448, 1.12090,
2276 1.09546, 1.09136, 1.10142, 1.13795, 1.39831},
2277 {1.09331, 1.09429, 1.09742, 1.10336, 1.11557, 1.16547,
2278 1.14658, 1.13642, 1.15247, 1.18898, 1.44936},
2279 {1.14436, 1.14539, 1.14847, 1.15443, 1.16662, 1.21794,
2280 1.19763, 1.19329, 1.20349, 1.23956, 1.50043},
2281 {1.19533, 1.19651, 1.19943, 1.20548, 1.21666, 1.26753,
2282 1.24862, 1.24434, 1.25455, 1.29106, 1.55142},
2283 {1.24638, 1.24756, 1.25046, 1.25648, 1.26764, 1.31858,
2284 1.29967, 1.29538, 1.30499, 1.34211, 1.60250},
2285 {1.29747, 1.29847, 1.30175, 1.30753, 1.31869, 1.36969,
2286 1.35069, 1.34656, 1.35663, 1.39316, 1.64644},
2287 {1.35537, 1.34952, 1.35255, 1.35869, 1.36973, 1.41387,
2288 1.40173, 1.39761, 1.40768, 1.44396, 1.70238},
2289 {1.39956, 1.40056, 1.40380, 1.40961, 1.42178, 1.46492,
2290 1.45278, 1.45423, 1.45872, 1.49522, 1.75557},
2291 {1.45080, 1.45159, 1.45463, 1.46109, 1.47287, 1.52263,
2292 1.50382, 1.50050, 1.50977, 1.54502, 1.80670},
2293 {1.50165, 1.50264, 1.50570, 1.51214, 1.52233, 1.57370,
2294 1.55484, 1.55155, 1.56080, 1.59731, 1.85778},
2295 {1.55269, 1.55364, 1.55675, 1.56274, 1.57491, 1.62598,
2296 1.60590, 1.60259, 1.61185, 1.64836, 1.90883},
2297 {1.60368, 1.60469, 1.60779, 1.61373, 1.62596, 1.67738,
2298 1.65651, 1.65249, 1.66290, 1.69936, 1.95959}};
2299
2300 // Garfield simulation at UD = -2200V; vd = 2.134cm/microsec, <driftfield> = 753V/cm
2301 Float_t time2200[ktimebin][kZbin] =
2302 {{0.09162, 0.09194, 0.09292, 0.09460, 0.09702, 0.10014,
2303 0.10421, 0.10971, 0.11820, 0.13990, 0.37745},
2304 {0.06581, 0.06618, 0.06730, 0.06915, 0.07173, 0.07507,
2305 0.07931, 0.08497, 0.09368, 0.11609, 0.35560},
2306 {0.03947, 0.04001, 0.04167, 0.04429, 0.04772, 0.05183,
2307 0.05667, 0.06293, 0.07292, 0.09900, 0.34673},
2308 {0.01111, 0.01280, 0.01716, 0.02279, 0.02876, 0.03473,
2309 0.04091, 0.04907, 0.06426, 0.10620, 0.36766},
2310 {0.01113, 0.01285, 0.01719, 0.02276, 0.02863, 0.03452,
2311 0.04076, 0.04960, 0.06745, 0.11419, 0.37139},
2312 {0.03923, 0.03978, 0.04137, 0.04387, 0.04713, 0.05110,
2313 0.05605, 0.06284, 0.07551, 0.10677, 0.36210},
2314 {0.06505, 0.06540, 0.06644, 0.06820, 0.07069, 0.07401,
2315 0.07852, 0.08479, 0.09565, 0.12325, 0.37313},
2316 {0.09107, 0.09127, 0.09181, 0.09291, 0.09474, 0.00000,
2317 0.10883, 0.11528, 0.12789, 0.15865, 0.41313},
2318 {0.12559, 0.12622, 0.12800, 0.13206, 0.14166, 0.19331,
2319 0.16832, 0.16632, 0.17724, 0.21218, 0.47098},
2320 {0.16992, 0.17070, 0.17325, 0.17831, 0.18871, 0.23557,
2321 0.21690, 0.21451, 0.22514, 0.26082, 0.52034},
2322 {0.21640, 0.21722, 0.21987, 0.22500, 0.23540, 0.28097,
2323 0.26399, 0.26154, 0.27214, 0.30784, 0.56734},
2324 {0.26318, 0.26400, 0.26679, 0.27181, 0.28220, 0.32739,
2325 0.31090, 0.30842, 0.31902, 0.35474, 0.61415},
2326 {0.31001, 0.31085, 0.31348, 0.31866, 0.32903, 0.37412,
2327 0.35777, 0.35546, 0.36588, 0.40159, 0.66103},
2328 {0.35687, 0.35769, 0.36033, 0.36556, 0.37588, 0.42094,
2329 0.40523, 0.40214, 0.41273, 0.44841, 0.70785},
2330 {0.40372, 0.40457, 0.40723, 0.41234, 0.42273, 0.46778,
2331 0.45148, 0.44903, 0.45961, 0.49526, 0.75486},
2332 {0.45062, 0.45139, 0.45404, 0.45966, 0.46958, 0.51470,
2333 0.49833, 0.49584, 0.50644, 0.54211, 0.80160},
2334 {0.49742, 0.49825, 0.50088, 0.50605, 0.51644, 0.56148,
2335 0.54518, 0.54270, 0.55330, 0.58897, 0.84854},
2336 {0.54427, 0.54510, 0.54774, 0.55290, 0.56329, 0.60846,
2337 0.59203, 0.58955, 0.60014, 0.63578, 0.89528},
2338 {0.59119, 0.59199, 0.59471, 0.59975, 0.61014, 0.65533,
2339 0.63889, 0.63636, 0.64699, 0.68269, 0.94197},
2340 {0.63866, 0.63880, 0.64145, 0.64664, 0.65701, 0.70639,
2341 0.68574, 0.68325, 0.69385, 0.72949, 0.98900},
2342 {0.68483, 0.68566, 0.68831, 0.69347, 0.70386, 0.74890,
2343 0.73260, 0.73010, 0.74069, 0.77638, 1.03320},
2344 {0.73168, 0.73255, 0.73515, 0.74031, 0.75072, 0.79576,
2345 0.77117, 0.77501, 0.78755, 0.82318, 1.08006},
2346 {0.77854, 0.78310, 0.78200, 0.79525, 0.79756, 0.84281,
2347 0.81803, 0.82393, 0.83441, 0.87008, 1.12692},
2348 {0.82541, 0.82642, 0.82916, 0.83528, 0.84442, 0.89086,
2349 0.87315, 0.87079, 0.88125, 0.91694, 1.17648},
2350 {0.87226, 0.87308, 0.87602, 0.88086, 0.89128, 0.93772,
2351 0.92001, 0.91751, 0.92811, 0.95587, 1.22328},
2352 {0.91921, 0.91994, 0.92256, 0.92772, 0.94713, 0.98566,
2353 0.96690, 0.96436, 0.97495, 1.01064, 1.26882},
2354 {0.96790, 0.96679, 0.96941, 0.97463, 0.99399, 1.03001,
2355 1.01376, 1.01112, 1.02181, 1.05749, 1.31568},
2356 {1.01278, 1.01390, 1.01674, 1.02147, 1.03182, 1.07820,
2357 1.06056, 1.05798, 1.06867, 1.10433, 1.36390},
2358 {1.05964, 1.06076, 1.06331, 1.06833, 1.07870, 1.13297,
2359 1.10742, 1.10520, 1.11543, 1.15120, 1.41069},
2360 {1.10664, 1.10762, 1.10997, 1.11519, 1.12556, 1.17531,
2361 1.15427, 1.14620, 1.16229, 1.19805, 1.45758},
2362 {1.15352, 1.15421, 1.15683, 1.16218, 1.17242, 1.21910,
2363 1.20035, 1.19863, 1.20579, 1.24473, 1.50412},
2364 {1.20019, 1.20115, 1.20369, 1.20892, 1.21928, 1.26913,
2365 1.24721, 1.24549, 1.25605, 1.29159, 1.54920},
2366 {1.24707, 1.24846, 1.25052, 1.25602, 1.26608, 1.31558,
2367 1.29448, 1.29232, 1.30293, 1.33675, 1.59798},
2368 {1.29391, 1.29475, 1.29738, 1.30255, 1.31294, 1.36244,
2369 1.34167, 1.33918, 1.34979, 1.38229, 1.64496},
2370 {1.34078, 1.34304, 1.34424, 1.35565, 1.35980, 1.40930,
2371 1.38853, 1.38229, 1.39664, 1.42863, 1.69162},
2372 {1.38762, 1.38847, 1.39110, 1.39627, 1.40666, 1.45183,
2373 1.43539, 1.43289, 1.44348, 1.47549, 1.73876},
2374 {1.43524, 1.43533, 1.43796, 1.44310, 1.45371, 1.49305,
2375 1.48224, 1.47941, 1.49034, 1.52601, 1.78552},
2376 {1.48122, 1.48219, 1.48482, 1.48991, 1.50030, 1.53991,
2377 1.52898, 1.52653, 1.53653, 1.57282, 1.82386}};
2378
4d18a639 2379 if (fTimeStruct1) {
2380 delete [] fTimeStruct1;
2381 }
2382 fTimeStruct1 = new Float_t[ktimebin*kZbin];
2383
2384 if (fTimeStruct2) {
2385 delete [] fTimeStruct2;
2386 }
2387 fTimeStruct2 = new Float_t[ktimebin*kZbin];
2388
2389 for (Int_t ctrt = 0; ctrt < ktimebin; ctrt++) {
2390 for (Int_t ctrz = 0; ctrz < kZbin; ctrz++) {
2391 if (vdrift > fVDsmp[6]) {
2392 fTimeStruct1[ctrt+ctrz*ktimebin] = time2100[ctrt][ctrz];
2393 fTimeStruct2[ctrt+ctrz*ktimebin] = time2200[ctrt][ctrz];
2394 fVDlo = fVDsmp[6];
2395 fVDhi = fVDsmp[7];
2396 }
2397 else if (vdrift > fVDsmp[5]) {
2398 fTimeStruct1[ctrt+ctrz*ktimebin] = time2000[ctrt][ctrz];
2399 fTimeStruct2[ctrt+ctrz*ktimebin] = time2100[ctrt][ctrz];
2400 fVDlo = fVDsmp[5];
2401 fVDhi = fVDsmp[6];
2402 }
2403 else if (vdrift > fVDsmp[4]) {
2404 fTimeStruct1[ctrt+ctrz*ktimebin] = time1900[ctrt][ctrz];
2405 fTimeStruct2[ctrt+ctrz*ktimebin] = time2000[ctrt][ctrz];
2406 fVDlo = fVDsmp[4];
2407 fVDhi = fVDsmp[5];
2408 }
2409 else if (vdrift > fVDsmp[3]) {
2410 fTimeStruct1[ctrt+ctrz*ktimebin] = time1800[ctrt][ctrz];
2411 fTimeStruct2[ctrt+ctrz*ktimebin] = time1900[ctrt][ctrz];
2412 fVDlo = fVDsmp[3];
2413 fVDhi = fVDsmp[4];
2414 }
2415 else if (vdrift > fVDsmp[2]) {
2416 fTimeStruct1[ctrt+ctrz*ktimebin] = time1700[ctrt][ctrz];
2417 fTimeStruct2[ctrt+ctrz*ktimebin] = time1800[ctrt][ctrz];
2418 fVDlo = fVDsmp[2];
2419 fVDhi = fVDsmp[3];
2420 }
2421 else if (vdrift > fVDsmp[1]) {
2422 fTimeStruct1[ctrt+ctrz*ktimebin] = time1600[ctrt][ctrz];
2423 fTimeStruct2[ctrt+ctrz*ktimebin] = time1700[ctrt][ctrz];
2424 fVDlo = fVDsmp[1];
2425 fVDhi = fVDsmp[2];
2426 }
2427 else if (vdrift > (fVDsmp[0] - 1.0e-5)) {
2428 fTimeStruct1[ctrt+ctrz*ktimebin] = time1500[ctrt][ctrz];
2429 fTimeStruct2[ctrt+ctrz*ktimebin] = time1600[ctrt][ctrz];
2430 fVDlo = fVDsmp[0];
2431 fVDhi = fVDsmp[1];
3551db50 2432 }
2433 }
2434 }
4d18a639 2435
3551db50 2436}
2437
2438//_____________________________________________________________________________
2439void AliTRDdigitizer::RecalcDiffusion(Float_t vdrift)
2440{
4d18a639 2441 //
2442 // Recalculates the diffusion parameters
2443 //
2444
2445 if (vdrift == fDiffLastVdrift) {
3551db50 2446 return;
4d18a639 2447 }
7754cd1f 2448
4d18a639 2449 AliTRDSimParam *simParam = AliTRDSimParam::Instance();
9afbd7de 2450 if (!simParam) {
2451 AliError("Could not get simulation parameters\n");
3551db50 2452 return;
2453 }
2454
4d18a639 2455 AliTRDCommonParam *commonParam = AliTRDCommonParam::Instance();
9afbd7de 2456 if (!commonParam) {
2457 AliError("Could not get common parameters\n");
3551db50 2458 return;
2459 }
2460
4d18a639 2461 AliTRDcalibDB *calibration = AliTRDcalibDB::Instance();
9afbd7de 2462 if (!calibration) {
2463 AliError("Could not get calibration object\n");
3551db50 2464 return;
2465 }
2466
2467 Float_t field = commonParam->GetField();
4d18a639 2468 fDiffLastVdrift = vdrift;
3551db50 2469
9afbd7de 2470 // DiffusionL
4d18a639 2471 const Int_t kNbL = 5;
2472 Float_t p0L[kNbL] = { 0.007440, 0.007493, 0.007513, 0.007672, 0.007831 };
2473 Float_t p1L[kNbL] = { 0.019252, 0.018912, 0.018636, 0.018012, 0.017343 };
2474 Float_t p2L[kNbL] = { -0.005042, -0.004926, -0.004867, -0.004650, -0.004424 };
2475 Float_t p3L[kNbL] = { 0.000195, 0.000189, 0.000195, 0.000182, 0.000169 };
2476
2477 Int_t ibL = ((Int_t) (10 * (field - 0.15)));
2478 ibL = TMath::Max( 0,ibL);
2479 ibL = TMath::Min(kNbL,ibL);
2480
2481 fDiffusionL = p0L[ibL]
2482 + p1L[ibL] * vdrift
2483 + p2L[ibL] * vdrift*vdrift
2484 + p3L[ibL] * vdrift*vdrift*vdrift;
3551db50 2485
9afbd7de 2486 // DiffusionT
4d18a639 2487 const Int_t kNbT = 5;
2488 Float_t p0T[kNbT] = { 0.009550, 0.009599, 0.009674, 0.009757, 0.009850 };
2489 Float_t p1T[kNbT] = { 0.006667, 0.006539, 0.006359, 0.006153, 0.005925 };
2490 Float_t p2T[kNbT] = { -0.000853, -0.000798, -0.000721, -0.000635, -0.000541 };
2491 Float_t p3T[kNbT] = { 0.000131, 0.000122, 0.000111, 0.000098, 0.000085 };
2492
2493 Int_t ibT= ((Int_t) (10 * (field - 0.15)));
2494 ibT = TMath::Max( 0,ibT);
2495 ibT = TMath::Min(kNbT,ibT);
2496
2497 fDiffusionT = p0T[ibT]
2498 + p1T[ibT] * vdrift
2499 + p2T[ibT] * vdrift*vdrift
2500 + p3T[ibT] * vdrift*vdrift*vdrift;
3551db50 2501
9afbd7de 2502 // OmegaTau
4d18a639 2503 fOmegaTau = calibration->GetOmegaTau(vdrift);
3551db50 2504
9afbd7de 2505 // Lorentzfactor
4d18a639 2506 if (commonParam->ExBOn()) {
2507 fLorentzFactor = 1.0 / (1.0 + fOmegaTau*fOmegaTau);
2508 }
2509 else {
2510 fLorentzFactor = 1.0;
3551db50 2511 }
9afbd7de 2512
3551db50 2513}
2514
2515//_____________________________________________________________________________
2516Float_t AliTRDdigitizer::GetDiffusionL(Float_t vdrift)
2517{
2518 //
2519 // Returns the longitudinal diffusion coefficient for a given drift
2520 // velocity <vd> and a B-field <b> for Xe/CO2 (15%).
2521 // The values are according to a GARFIELD simulation.
2522 //
2523
2524 RecalcDiffusion(vdrift);
4d18a639 2525
2526 return fDiffusionL;
9afbd7de 2527
3551db50 2528}
2529
2530//_____________________________________________________________________________
2531Float_t AliTRDdigitizer::GetDiffusionT(Float_t vdrift)
2532{
2533 //
2534 // Returns the transverse diffusion coefficient for a given drift
2535 // velocity <vd> and a B-field <b> for Xe/CO2 (15%).
2536 // The values are according to a GARFIELD simulation.
2537 //
2538
2539 RecalcDiffusion(vdrift);
4d18a639 2540
2541 return fDiffusionT;
9afbd7de 2542
3551db50 2543}
2544
2545//_____________________________________________________________________________
2546Int_t AliTRDdigitizer::Diffusion(Float_t vdrift, Double_t driftlength, Double_t *xyz)
2547{
2548 //
2549 // Applies the diffusion smearing to the position of a single electron
2550 //
2551
2552 RecalcDiffusion(vdrift);
2553
2554 Float_t driftSqrt = TMath::Sqrt(driftlength);
4d18a639 2555 Float_t sigmaT = driftSqrt * fDiffusionT;
2556 Float_t sigmaL = driftSqrt * fDiffusionL;
2557 xyz[0] = gRandom->Gaus(xyz[0],sigmaL * GetLorentzFactor(vdrift));
2558 xyz[1] = gRandom->Gaus(xyz[1],sigmaT * GetLorentzFactor(vdrift));
2559 xyz[2] = gRandom->Gaus(xyz[2],sigmaT);
3551db50 2560
2561 return 1;
9afbd7de 2562
3551db50 2563}
2564
2565//_____________________________________________________________________________
2566Float_t AliTRDdigitizer::GetLorentzFactor(Float_t vd)
2567{
9afbd7de 2568 //
2569 // Returns the recalculated Lorentz factor
2570 //
2571
3551db50 2572 RecalcDiffusion(vd);
4d18a639 2573
2574 return fLorentzFactor;
9afbd7de 2575
3551db50 2576}
2577
2578//_____________________________________________________________________________
2579Int_t AliTRDdigitizer::ExB(Float_t vdrift, Double_t driftlength, Double_t *xyz)
2580{
2581 //
2582 // Applies E x B effects to the position of a single electron
2583 //
2584
2585 RecalcDiffusion(vdrift);
2586
2587 xyz[0] = xyz[0];
4d18a639 2588 xyz[1] = xyz[1] + fOmegaTau * driftlength;
3551db50 2589 xyz[2] = xyz[2];
2590
2591 return 1;
9afbd7de 2592
3551db50 2593}