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