TRD/AliTRD.cxx

   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
  16 /*
  17 $Log$
  18 Revision 1.45  2003/02/11 16:54:07  hristov
  19 Updated AliTrackReference class (S.Radomski)
  20
  21 Revision 1.44  2003/01/28 14:38:18  cblume
  22 Add track length to track references
  23
  24 Revision 1.43  2002/11/21 22:38:47  alibrary
  25 Removing AliMC and AliMCProcess
  26
  27 Revision 1.42  2002/10/22 15:53:08  alibrary
  28 Introducing Riostream.h
  29
  30 Revision 1.41  2002/10/14 14:57:43  hristov
  31 Merging the VirtualMC branch to the main development branch (HEAD)
  32
  33 Revision 1.36.6.2  2002/07/24 10:09:30  alibrary
  34 Updating VirtualMC
  35
  36 Revision 1.40  2002/06/13 08:11:56  cblume
  37 Add the track references
  38
  39 Revision 1.39  2002/06/12 09:54:35  cblume
  40 Update of tracking code provided by Sergei
  41
  42 Revision 1.38  2002/03/28 14:59:07  cblume
  43 Coding conventions
  44
  45 Revision 1.37  2002/03/25 20:01:49  cblume
  46 Introduce parameter class
  47
  48 Revision 1.36  2002/02/11 14:25:27  cblume
  49 Geometry update, compressed hit structure
  50
  51 Revision 1.35  2001/11/14 12:08:44  cblume
  52 Remove unneccessary header files
  53
  54 Revision 1.34  2001/11/14 10:50:45  cblume
  55 Changes in digits IO. Add merging of summable digits
  56
  57 Revision 1.33  2001/11/06 17:19:41  cblume
  58 Add detailed geometry and simple simulator
  59
  60 Revision 1.32  2001/10/08 06:57:33  hristov
  61 Branches for  TRD digits are created only during the digitisation
  62
  63 Revision 1.31  2001/08/30 09:30:30  hristov
  64 The split level of branches is set to 99
  65
  66 Revision 1.30  2001/05/28 17:07:58  hristov
  67 Last minute changes; ExB correction in AliTRDclusterizerV1; taking into account of material in G10 TEC frames and material between TEC planes (C.Blume,S.Sedykh)
  68
  69 Revision 1.29  2001/05/21 16:45:47  hristov
  70 Last minute changes (C.Blume)
  71
  72 Revision 1.28  2001/05/16 14:57:27  alibrary
  73 New files for folders and Stack
  74
  75 Revision 1.27  2001/05/08 07:05:02  hristov
  76 Loop variable declared once (HP, Sun)
  77
  78 Revision 1.26  2001/05/07 08:03:22  cblume
  79 Generate also hits in the amplification region
  80
  81 Revision 1.25  2001/03/13 09:30:35  cblume
  82 Update of digitization. Moved digit branch definition to AliTRD
  83
  84 Revision 1.24  2001/01/26 19:56:49  hristov
  85 Major upgrade of AliRoot code
  86
  87 Revision 1.23  2000/11/01 14:53:20  cblume
  88 Merge with TRD-develop
  89
  90 Revision 1.17.2.6  2000/10/15 23:29:08  cblume
  91 Introduced more detailed geometry for the display
  92
  93 Revision 1.17.2.5  2000/10/06 16:49:46  cblume
  94 Made Getters const
  95
  96 Revision 1.17.2.4  2000/10/04 16:34:57  cblume
  97 Replace include files by forward declarations
  98
  99 Revision 1.17.2.3  2000/09/22 14:45:17  cblume
 100 Included changes for the tracking
 101
 102 Revision 1.17.2.2  2000/09/18 13:25:13  cblume
 103 Included LoadPoints() method to display the TR photons
 104
 105 Revision 1.22  2000/10/02 21:28:19  fca
 106 Removal of useless dependecies via forward declarations
 107
 108 Revision 1.21  2000/06/09 11:10:07  cblume
 109 Compiler warnings and coding conventions, next round
 110
 111 Revision 1.20  2000/06/08 18:32:57  cblume
 112 Make code compliant to coding conventions
 113
 114 Revision 1.19  2000/06/07 16:25:37  cblume
 115 Try to remove compiler warnings on Sun and HP
 116
 117 Revision 1.18  2000/05/08 16:17:27  cblume
 118 Merge TRD-develop
 119
 120 Revision 1.21  2000/06/09 11:10:07  cblume
 121 Compiler warnings and coding conventions, next round
 122
 123 Revision 1.20  2000/06/08 18:32:57  cblume
 124 Make code compliant to coding conventions
 125
 126 Revision 1.19  2000/06/07 16:25:37  cblume
 127 Try to remove compiler warnings on Sun and HP
 128
 129 Revision 1.18  2000/05/08 16:17:27  cblume
 130 Merge TRD-develop
 131
 132 Revision 1.17.2.1  2000/05/08 14:28:59  cblume
 133 Introduced SetPHOShole() and SetRICHhole(). AliTRDrecPoint container is now a TObjArray
 134
 135 Revision 1.17  2000/02/28 19:10:26  cblume
 136 Include the new TRD classes
 137
 138 Revision 1.16.2.2  2000/02/28 17:53:24  cblume
 139 Introduce TRD geometry classes
 140
 141 Revision 1.16.2.1  2000/02/28 17:04:19  cblume
 142 Include functions and data members for AliTRDrecPoint
 143
 144 Revision 1.16  2000/01/19 17:17:35  fca
 145 Introducing a list of lists of hits -- more hits allowed for detector now
 146
 147 Revision 1.15  1999/11/02 17:04:25  fca
 148 Small syntax change for HP compiler
 149
 150 Revision 1.14  1999/11/02 16:57:02  fca
 151 Avoid non ansi warnings on HP compilers
 152
 153 Revision 1.13  1999/11/02 16:35:56  fca
 154 New version of TRD introduced
 155
 156 Revision 1.12  1999/11/01 20:41:51  fca
 157 Added protections against using the wrong version of FRAME
 158
 159 Revision 1.11  1999/09/29 09:24:34  fca
 160 Introduction of the Copyright and cvs Log
 161
 162 */
 163
 164 ///////////////////////////////////////////////////////////////////////////////
 165 //                                                                           //
 166 //  Transition Radiation Detector                                            //
 167 //  This class contains the basic functions for the Transition Radiation     //
 168 //  Detector.                                                                //
 169 //                                                                           //
 170 ///////////////////////////////////////////////////////////////////////////////
 171
 172 #include <stdlib.h>
 173 #include <Riostream.h>
 174
 175 #include <TMath.h>
 176 #include <TNode.h>
 177 #include <TGeometry.h>
 178 #include <TTree.h>
 179 #include <TPGON.h>
 180 #include <TFile.h>
 181 #include <TROOT.h>
 182 #include <TParticle.h>
 183 #include <TLorentzVector.h>
 184
 185 #include "AliRun.h"
 186 #include "AliConst.h"
 187 #include "AliDigit.h"
 188 #include "AliMagF.h"
 189
 190 #include "AliTrackReference.h"
 191
 192 #include "AliTRD.h"
 193 #include "AliTRDhit.h"
 194 #include "AliTRDpoints.h"
 195 #include "AliTRDdigit.h"
 196 #include "AliTRDdigitizer.h"
 197 #include "AliTRDclusterizer.h"
 198 #include "AliTRDgeometryHole.h"
 199 #include "AliTRDgeometryFull.h"
 200 #include "AliTRDrecPoint.h"
 201 #include "AliTRDcluster.h"
 202 #include "AliTRDdigitsManager.h"
 203 #include "AliTRDtrackHits.h"
 204
 205 ClassImp(AliTRD)
 206
 207 //_____________________________________________________________________________
 208 AliTRD::AliTRD()
 209 {
 210   //
 211   // Default constructor
 212   //
 213
 214   fIshunt        = 0;
 215   fGasMix        = 0;
 216   fHits          = 0;
 217   fDigits        = 0;
 218
 219   fRecPoints     = 0;
 220   fNRecPoints    = 0;
 221
 222   fGeometry      = 0;
 223
 224   fGasDensity    = 0;
 225   fFoilDensity   = 0;
 226
 227   fDrawTR        = 0;
 228   fDisplayType   = 0;
 229
 230   fTrackHits     = 0;
 231   fHitType       = 0;
 232
 233 }
 234
 235 //_____________________________________________________________________________
 236 AliTRD::AliTRD(const char *name, const char *title)
 237        : AliDetector(name,title)
 238 {
 239   //
 240   // Standard constructor for the TRD
 241   //
 242
 243   // Check that FRAME is there otherwise we have no place where to
 244   // put TRD
 245   AliModule* frame = gAlice->GetModule("FRAME");
 246   if (!frame) {
 247     Error("Ctor","TRD needs FRAME to be present\n");
 248     exit(1);
 249   }
 250
 251   // Define the TRD geometry according to the FRAME geometry
 252   if      (frame->IsVersion() == 0) {
 253     // Geometry with hole
 254     fGeometry = new AliTRDgeometryHole();
 255   }
 256   else if (frame->IsVersion() == 1) {
 257     // Geometry without hole
 258     fGeometry = new AliTRDgeometryFull();
 259   }
 260   else {
 261     Error("Ctor","Could not find valid FRAME version\n");
 262     exit(1);
 263   }
 264
 265   // Allocate the hit array
 266   fHits           = new TClonesArray("AliTRDhit"     ,405);
 267   gAlice->AddHitList(fHits);
 268
 269   // Allocate the digits array
 270   fDigits         = 0;
 271
 272   // Allocate the rec point array
 273   fRecPoints     = new TObjArray(400);
 274   fNRecPoints    = 0;
 275
 276   fIshunt        = 0;
 277   fGasMix        = 1;
 278
 279   fGasDensity    = 0;
 280   fFoilDensity   = 0;
 281
 282   fDrawTR        = 0;
 283   fDisplayType   = 0;
 284
 285   fTrackHits     = 0;
 286   fHitType       = 2;
 287
 288   SetMarkerColor(kWhite);
 289
 290 }
 291
 292 //_____________________________________________________________________________
 293 AliTRD::AliTRD(const AliTRD &trd)
 294 {
 295   //
 296   // Copy constructor
 297   //
 298
 299   ((AliTRD &) trd).Copy(*this);
 300
 301 }
 302
 303 //_____________________________________________________________________________
 304 AliTRD::~AliTRD()
 305 {
 306   //
 307   // TRD destructor
 308   //
 309
 310   fIshunt = 0;
 311
 312   if (fGeometry) {
 313     delete fGeometry;
 314     fGeometry  = 0;
 315   }
 316   if (fHits) {
 317     delete fHits;
 318     fHits      = 0;
 319   }
 320   if (fRecPoints) {
 321     delete fRecPoints;
 322     fRecPoints = 0;
 323   }
 324   if (fTrackHits) {
 325     delete fTrackHits;
 326     fTrackHits = 0;
 327   }
 328
 329 }
 330
 331 //_____________________________________________________________________________
 332 void AliTRD::AddCluster(Float_t *pos, Int_t det, Float_t amp
 333                       , Int_t *tracks, Float_t *sig, Int_t iType)
 334 {
 335   //
 336   // Add a cluster for the TRD
 337   //
 338
 339   AliTRDcluster *c = new AliTRDcluster();
 340
 341   c->SetDetector(det);
 342   c->AddTrackIndex(tracks);
 343   c->SetQ(amp);
 344   c->SetY(pos[0]);
 345   c->SetZ(pos[1]);
 346   c->SetSigmaY2(sig[0]);
 347   c->SetSigmaZ2(sig[1]);
 348   c->SetLocalTimeBin(((Int_t) pos[2]));
 349
 350   switch (iType) {
 351   case 0:
 352     c->Set2pad();
 353     break;
 354   case 1:
 355     c->Set3pad();
 356     break;
 357   case 2:
 358     c->Set4pad();
 359     break;
 360   case 3:
 361     c->Set5pad();
 362     break;
 363   case 4:
 364     c->SetLarge();
 365     break;
 366   };
 367
 368   fRecPoints->Add(c);
 369
 370 }
 371
 372 //_____________________________________________________________________________
 373 void AliTRD::Hits2Digits()
 374 {
 375   //
 376   // Create digits
 377   //
 378
 379   AliTRDdigitizer *digitizer = new AliTRDdigitizer("TRDdigitizer"
 380                                                   ,"TRD digitizer class");
 381   digitizer->SetDebug(GetDebug());
 382   digitizer->SetEvent(gAlice->GetEvNumber());
 383
 384   // Initialization
 385   digitizer->InitDetector();
 386
 387   // Create the digits
 388   digitizer->MakeDigits();
 389
 390   // Write the digits into the input file
 391   if (digitizer->MakeBranch(fDigitsFile)) {
 392
 393     digitizer->WriteDigits();
 394
 395     // Save the digitizer class in the AliROOT
 396     digitizer->Write();
 397
 398   }
 399
 400 }
 401
 402 //_____________________________________________________________________________
 403 void AliTRD::Hits2SDigits()
 404 {
 405   //
 406   // Create summable digits
 407   //
 408
 409   AliTRDdigitizer *digitizer = new AliTRDdigitizer("TRDdigitizer"
 410                                                   ,"TRD digitizer class");
 411   digitizer->SetDebug(GetDebug());
 412
 413   // For the summable digits
 414   digitizer->SetSDigits(kTRUE);
 415   digitizer->SetEvent(gAlice->GetEvNumber());
 416
 417   // Initialization
 418   digitizer->InitDetector();
 419
 420   // Create the TRD s-digits branch
 421   digitizer->MakeDigits();
 422
 423   // Write the digits into the input file
 424   if (digitizer->MakeBranch(fDigitsFile)) {
 425
 426     digitizer->WriteDigits();
 427
 428     // Save the digitizer class in the AliROOT
 429     digitizer->Write();
 430
 431   }
 432
 433 }
 434
 435 //_____________________________________________________________________________
 436 void AliTRD::SDigits2Digits()
 437 {
 438   //
 439   // Create final digits from summable digits
 440   //
 441
 442    // Create the TRD digitizer
 443   AliTRDdigitizer *digitizer = new AliTRDdigitizer("TRDdigitizer"
 444                                                   ,"TRD digitizer class");
 445   digitizer->SetDebug(GetDebug());
 446
 447   // Set the parameter
 448   digitizer->SetEvent(gAlice->GetEvNumber());
 449
 450   // Initialization
 451   digitizer->InitDetector();
 452
 453   // Read the s-digits via digits manager
 454   AliTRDdigitsManager *sdigitsManager = new AliTRDdigitsManager();
 455   sdigitsManager->SetDebug(GetDebug());
 456   sdigitsManager->SetSDigits(kTRUE);
 457   if (fDigitsFile) {
 458     sdigitsManager->Open(fDigitsFile);
 459   }
 460   sdigitsManager->CreateArrays();
 461   sdigitsManager->ReadDigits();
 462
 463   // Add the s-digits to the input list
 464   digitizer->AddSDigitsManager(sdigitsManager);
 465
 466   // Convert the s-digits to normal digits
 467   digitizer->SDigits2Digits();
 468
 469   // Store the digits
 470   if (digitizer->MakeBranch(fDigitsFile)) {
 471
 472     digitizer->WriteDigits();
 473
 474   }
 475
 476 }
 477
 478 //_____________________________________________________________________________
 479 void AliTRD::AddHit(Int_t track, Int_t det, Float_t *hits, Int_t q
 480                   , Bool_t inDrift)
 481 {
 482   //
 483   // Add a hit for the TRD
 484   //
 485   // The data structure is set according to fHitType:
 486   //   bit0: standard TClonesArray
 487   //   bit1: compressed trackHits structure
 488   //
 489
 490   if (fHitType & 1) {
 491     TClonesArray &lhits = *fHits;
 492     new(lhits[fNhits++]) AliTRDhit(fIshunt,track,det,hits,q);
 493   }
 494
 495   if (fHitType > 1) {
 496     AddHit2(track,det,hits,q,inDrift);
 497   }
 498
 499 }
 500
 501 //_____________________________________________________________________________
 502 void AliTRD::BuildGeometry()
 503 {
 504   //
 505   // Create the ROOT TNode geometry for the TRD
 506   //
 507
 508   TNode *node, *top;
 509   TPGON *pgon;
 510
 511   Float_t rmin, rmax;
 512   Float_t zmax1, zmax2;
 513
 514   Int_t   iPlan;
 515
 516   const Int_t kColorTRD = 46;
 517
 518   // Find the top node alice
 519   top = gAlice->GetGeometry()->GetNode("alice");
 520
 521   if      (fDisplayType == 0) {
 522
 523     pgon = new TPGON("S_TRD","TRD","void",0,360,AliTRDgeometry::Nsect(),4);
 524     rmin = AliTRDgeometry::Rmin();
 525     rmax = AliTRDgeometry::Rmax();
 526     pgon->DefineSection(0,-AliTRDgeometry::Zmax1(),rmax,rmax);
 527     pgon->DefineSection(1,-AliTRDgeometry::Zmax2(),rmin,rmax);
 528     pgon->DefineSection(2, AliTRDgeometry::Zmax2(),rmin,rmax);
 529     pgon->DefineSection(3, AliTRDgeometry::Zmax1(),rmax,rmax);
 530     top->cd();
 531     node = new TNode("TRD","TRD","S_TRD",0,0,0,"");
 532     node->SetLineColor(kColorTRD);
 533     fNodes->Add(node);
 534
 535   }
 536   else if (fDisplayType == 1) {
 537
 538     Char_t name[7];
 539
 540     Float_t slope = (AliTRDgeometry::Zmax1() - AliTRDgeometry::Zmax2())
 541                   / (AliTRDgeometry::Rmax()  - AliTRDgeometry::Rmin());
 542
 543     rmin  = AliTRDgeometry::Rmin() + AliTRDgeometry::CraHght();
 544     rmax  = rmin                   + AliTRDgeometry::CdrHght();
 545
 546     Float_t thickness = rmin - AliTRDgeometry::Rmin();
 547     zmax2 = AliTRDgeometry::Zmax2() + slope * thickness;
 548     zmax1 = zmax2 + slope * AliTRDgeometry::DrThick();
 549
 550     for (iPlan = 0; iPlan < AliTRDgeometry::Nplan(); iPlan++) {
 551
 552       sprintf(name,"S_TR1%d",iPlan);
 553       pgon  = new TPGON(name,"TRD","void",0,360,AliTRDgeometry::Nsect(),4);
 554       pgon->DefineSection(0,-zmax1,rmax,rmax);
 555       pgon->DefineSection(1,-zmax2,rmin,rmax);
 556       pgon->DefineSection(2, zmax2,rmin,rmax);
 557       pgon->DefineSection(3, zmax1,rmax,rmax);
 558       top->cd();
 559       node = new TNode("TRD","TRD",name,0,0,0,"");
 560       node->SetLineColor(kColorTRD);
 561       fNodes->Add(node);
 562
 563       Float_t height = AliTRDgeometry::Cheight() + AliTRDgeometry::Cspace();
 564       rmin  = rmin  + height;
 565       rmax  = rmax  + height;
 566       zmax1 = zmax1 + slope * height;
 567       zmax2 = zmax2 + slope * height;
 568
 569     }
 570
 571     thickness += AliTRDgeometry::DrThick();
 572     rmin  = AliTRDgeometry::Rmin() + thickness;
 573     rmax  = rmin + AliTRDgeometry::AmThick();
 574     zmax2 = AliTRDgeometry::Zmax2() + slope * thickness;
 575     zmax1 = zmax2 + slope * AliTRDgeometry::AmThick();
 576
 577     for (iPlan = 0; iPlan < AliTRDgeometry::Nplan(); iPlan++) {
 578
 579       sprintf(name,"S_TR2%d",iPlan);
 580       pgon  = new TPGON(name,"TRD","void",0,360,AliTRDgeometry::Nsect(),4);
 581       pgon->DefineSection(0,-zmax1,rmax,rmax);
 582       pgon->DefineSection(1,-zmax2,rmin,rmax);
 583       pgon->DefineSection(2, zmax2,rmin,rmax);
 584       pgon->DefineSection(3, zmax1,rmax,rmax);
 585       top->cd();
 586       node = new TNode("TRD","TRD",name,0,0,0,"");
 587       node->SetLineColor(kColorTRD);
 588       fNodes->Add(node);
 589
 590       Float_t height = AliTRDgeometry::Cheight() + AliTRDgeometry::Cspace();
 591       rmin  = rmin  + height;
 592       rmax  = rmax  + height;
 593       zmax1 = zmax1 + slope * height;
 594       zmax2 = zmax2 + slope * height;
 595
 596     }
 597
 598   }
 599
 600 }
 601
 602 //_____________________________________________________________________________
 603 void AliTRD::Copy(TObject &trd)
 604 {
 605   //
 606   // Copy function
 607   //
 608
 609   ((AliTRD &) trd).fGasMix      = fGasMix;
 610   ((AliTRD &) trd).fGeometry    = fGeometry;
 611   ((AliTRD &) trd).fRecPoints   = fRecPoints;
 612   ((AliTRD &) trd).fNRecPoints  = fNRecPoints;
 613   ((AliTRD &) trd).fGasDensity  = fGasDensity;
 614   ((AliTRD &) trd).fFoilDensity = fFoilDensity;
 615   ((AliTRD &) trd).fDrawTR      = fDrawTR;
 616   ((AliTRD &) trd).fDisplayType = fDisplayType;
 617   ((AliTRD &) trd).fHitType     = fHitType;
 618
 619   //AliDetector::Copy(trd);
 620
 621 }
 622
 623 //_____________________________________________________________________________
 624 void AliTRD::CreateGeometry()
 625 {
 626   //
 627   // Creates the volumes for the TRD chambers
 628   //
 629
 630   // Check that FRAME is there otherwise we have no place where to put the TRD
 631   AliModule* frame = gAlice->GetModule("FRAME");
 632   if (!frame) {
 633     printf(" The TRD needs the FRAME to be defined first\n");
 634     return;
 635   }
 636
 637   fGeometry->CreateGeometry(fIdtmed->GetArray() - 1299);
 638
 639 }
 640
 641 //_____________________________________________________________________________
 642 void AliTRD::CreateMaterials()
 643 {
 644   //
 645   // Create the materials for the TRD
 646   // Origin Y.Foka
 647   //
 648
 649   Int_t   isxfld = gAlice->Field()->Integ();
 650   Float_t sxmgmx = gAlice->Field()->Max();
 651
 652   // For polyethilene (CH2)
 653   Float_t ape[2] = { 12., 1. };
 654   Float_t zpe[2] = {  6., 1. };
 655   Float_t wpe[2] = {  1., 2. };
 656   Float_t dpe    = 0.95;
 657
 658   // For mylar (C5H4O2)
 659   Float_t amy[3] = { 12., 1., 16. };
 660   Float_t zmy[3] = {  6., 1.,  8. };
 661   Float_t wmy[3] = {  5., 4.,  2. };
 662   Float_t dmy    = 1.39;
 663
 664   // For CO2
 665   Float_t aco[2] = { 12., 16. };
 666   Float_t zco[2] = {  6.,  8. };
 667   Float_t wco[2] = {  1.,  2. };
 668   Float_t dco    = 0.001977;
 669
 670   // For water
 671   Float_t awa[2] = {  1., 16. };
 672   Float_t zwa[2] = {  1.,  8. };
 673   Float_t wwa[2] = {  2.,  1. };
 674   Float_t dwa    = 1.0;
 675
 676   // For isobutane (C4H10)
 677   Float_t ais[2] = { 12.,  1. };
 678   Float_t zis[2] = {  6.,  1. };
 679   Float_t wis[2] = {  4., 10. };
 680   Float_t dis    = 0.00267;
 681
 682   // For plexiglas (C5H8O2)
 683   Float_t apg[3] = { 12.011 ,  1.0    , 15.9994 };
 684   Float_t zpg[3] = {  6.0   ,  1.0    ,  8.0    };
 685   Float_t wpg[3] = {  5.0   ,  8.0    ,  2.0    };
 686   Float_t dpg    = 1.18;
 687
 688   // For Xe/CO2-gas-mixture
 689   // Xe-content of the Xe/CO2-mixture (85% / 15%)
 690   Float_t fxc    = .85;
 691   // Xe-content of the Xe/Isobutane-mixture (97% / 3%)
 692   Float_t fxi    = .97;
 693   Float_t dxe    = .005858;
 694
 695   // General tracking parameter
 696   Float_t tmaxfd = -10.;
 697   Float_t stemax = -1e10;
 698   Float_t deemax = -0.1;
 699   Float_t epsil  =  1e-4;
 700   Float_t stmin  = -0.001;
 701
 702   Float_t absl, radl, d, buf[1];
 703   Float_t agm[2], zgm[2], wgm[2];
 704   Float_t dgm1, dgm2;
 705   Int_t   nbuf;
 706
 707   //////////////////////////////////////////////////////////////////////////
 708   //     Define Materials
 709   //////////////////////////////////////////////////////////////////////////
 710
 711   AliMaterial( 1, "Al"   ,  26.98, 13.0, 2.7     ,     8.9 ,    37.2);
 712   AliMaterial( 2, "Air"  ,  14.61,  7.3, 0.001205, 30420.0 , 67500.0);
 713   AliMaterial( 4, "Xe"   , 131.29, 54.0, dxe     ,  1447.59,     0.0);
 714   AliMaterial( 5, "Cu"   ,  63.54, 29.0, 8.96    ,     1.43,    14.8);
 715   AliMaterial( 6, "C"    ,  12.01,  6.0, 2.265   ,    18.8 ,    74.4);
 716   AliMaterial(12, "G10"  ,  20.00, 10.0, 1.7     ,    19.4 ,   999.0);
 717   AliMaterial(15, "Sn"   , 118.71, 50.0, 7.31    ,     1.21,    14.8);
 718   AliMaterial(16, "Si"   ,  28.09, 14.0, 2.33    ,     9.36,    37.2);
 719   AliMaterial(17, "Epoxy",  17.75,  8.9, 1.8     ,    21.82,   999.0);
 720
 721   // Mixtures
 722   AliMixture(3, "Polyethilene",   ape, zpe, dpe, -2, wpe);
 723   AliMixture(7, "Mylar",          amy, zmy, dmy, -3, wmy);
 724   AliMixture(8, "CO2",            aco, zco, dco, -2, wco);
 725   AliMixture(9, "Isobutane",      ais, zis, dis, -2, wis);
 726   AliMixture(13,"Water",          awa, zwa, dwa, -2, wwa);
 727   AliMixture(14,"Plexiglas",      apg, zpg, dpg, -3, wpg);
 728
 729   // Gas mixtures
 730   Char_t namate[21];
 731   // Xe/CO2-mixture
 732   // Get properties of Xe
 733   gMC->Gfmate((*fIdmate)[4], namate, agm[0], zgm[0], d, radl, absl, buf, nbuf);
 734   // Get properties of CO2
 735   gMC->Gfmate((*fIdmate)[8], namate, agm[1], zgm[1], d, radl, absl, buf, nbuf);
 736   // Create gas mixture
 737   wgm[0] = fxc;
 738   wgm[1] = 1. - fxc;
 739   dgm1   = wgm[0] * dxe + wgm[1] * dco;
 740   AliMixture(10, "Gas mixture 1", agm, zgm, dgm1,  2, wgm);
 741   // Xe/Isobutane-mixture
 742   // Get properties of Xe
 743   gMC->Gfmate((*fIdmate)[4], namate, agm[0], zgm[0], d, radl, absl, buf, nbuf);
 744   // Get properties of Isobutane
 745   gMC->Gfmate((*fIdmate)[9], namate, agm[1], zgm[1], d, radl, absl, buf, nbuf);
 746   // Create gas mixture
 747   wgm[0] = fxi;
 748   wgm[1] = 1. - fxi;
 749   dgm2   = wgm[0] * dxe + wgm[1] * dis;
 750   AliMixture(11, "Gas mixture 2", agm, zgm, dgm2,  2, wgm);
 751
 752   //////////////////////////////////////////////////////////////////////////
 753   //     Tracking Media Parameters
 754   //////////////////////////////////////////////////////////////////////////
 755
 756   // Al Frame
 757   AliMedium(1, "Al Frame",   1, 0, isxfld, sxmgmx
 758                 , tmaxfd, stemax, deemax, epsil, stmin);
 759   // Air
 760   AliMedium(2, "Air",        2, 0, isxfld, sxmgmx
 761                 , tmaxfd, stemax, deemax, epsil, stmin);
 762   // Polyethilene
 763   AliMedium(3, "Radiator",   3, 0, isxfld, sxmgmx
 764                 , tmaxfd, stemax, deemax, epsil, stmin);
 765   // Xe
 766   AliMedium(4, "Xe",         4, 1, isxfld, sxmgmx
 767                 , tmaxfd, stemax, deemax, epsil, stmin);
 768   // Cu pads
 769   AliMedium(5, "Padplane",   5, 1, isxfld, sxmgmx
 770                 , tmaxfd, stemax, deemax, epsil, stmin);
 771   // Fee + cables
 772   AliMedium(6, "Readout",    1, 0, isxfld, sxmgmx
 773                 , tmaxfd, stemax, deemax, epsil, stmin);
 774   // C frame
 775   AliMedium(7, "C Frame",    6, 0, isxfld, sxmgmx
 776                 , tmaxfd, stemax, deemax, epsil, stmin);
 777   // Mylar foils
 778   AliMedium(8, "Mylar",      7, 0, isxfld, sxmgmx
 779                 , tmaxfd, stemax, deemax, epsil, stmin);
 780   if (fGasMix == 1) {
 781     // Gas-mixture (Xe/CO2)
 782     AliMedium(9, "Gas-mix",   10, 1, isxfld, sxmgmx
 783                   , tmaxfd, stemax, deemax, epsil, stmin);
 784   }
 785   else {
 786     // Gas-mixture (Xe/Isobutane)
 787     AliMedium(9, "Gas-mix",   11, 1, isxfld, sxmgmx
 788                   , tmaxfd, stemax, deemax, epsil, stmin);
 789   }
 790   // Nomex-honeycomb (use carbon for the time being)
 791   AliMedium(10, "Nomex",      6, 0, isxfld, sxmgmx
 792                 , tmaxfd, stemax, deemax, epsil, stmin);
 793   // Kapton foils (use Mylar for the time being)
 794   AliMedium(11, "Kapton",     7, 0, isxfld, sxmgmx
 795                 , tmaxfd, stemax, deemax, epsil, stmin);
 796   // Gas-filling of the radiator
 797   AliMedium(12, "CO2",        8, 0, isxfld, sxmgmx
 798                 , tmaxfd, stemax, deemax, epsil, stmin);
 799   // G10-plates
 800   AliMedium(13, "G10-plates",12, 0, isxfld, sxmgmx
 801                 , tmaxfd, stemax, deemax, epsil, stmin);
 802   // Cooling water
 803   AliMedium(14, "Water",     13, 0, isxfld, sxmgmx
 804                 , tmaxfd, stemax, deemax, epsil, stmin);
 805   // Rohacell (plexiglas) for the radiator
 806   AliMedium(15, "Rohacell",  14, 0, isxfld, sxmgmx
 807                 , tmaxfd, stemax, deemax, epsil, stmin);
 808   // Al layer in MCMs
 809   AliMedium(16, "MCM-Al"  ,   1, 0, isxfld, sxmgmx
 810                 , tmaxfd, stemax, deemax, epsil, stmin);
 811   // Sn layer in MCMs
 812   AliMedium(17, "MCM-Sn"  ,  15, 0, isxfld, sxmgmx
 813                 , tmaxfd, stemax, deemax, epsil, stmin);
 814   // Cu layer in MCMs
 815   AliMedium(18, "MCM-Cu"  ,   5, 0, isxfld, sxmgmx
 816                 , tmaxfd, stemax, deemax, epsil, stmin);
 817   // G10 layer in MCMs
 818   AliMedium(19, "MCM-G10" ,  12, 0, isxfld, sxmgmx
 819                 , tmaxfd, stemax, deemax, epsil, stmin);
 820   // Si in readout chips
 821   AliMedium(20, "Chip-Si" ,  16, 0, isxfld, sxmgmx
 822                 , tmaxfd, stemax, deemax, epsil, stmin);
 823   // Epoxy in readout chips
 824   AliMedium(21, "Chip-Ep" ,  17, 0, isxfld, sxmgmx
 825                 , tmaxfd, stemax, deemax, epsil, stmin);
 826   // PE in connectors
 827   AliMedium(22, "Conn-PE" ,   3, 0, isxfld, sxmgmx
 828                 , tmaxfd, stemax, deemax, epsil, stmin);
 829   // Cu in connectors
 830   AliMedium(23, "Chip-Cu" ,   5, 0, isxfld, sxmgmx
 831                 , tmaxfd, stemax, deemax, epsil, stmin);
 832   // Al of cooling pipes
 833   AliMedium(24, "Cooling" ,   1, 0, isxfld, sxmgmx
 834                 , tmaxfd, stemax, deemax, epsil, stmin);
 835
 836   // Save the density values for the TRD absorbtion
 837   fFoilDensity = dmy;
 838   if (fGasMix == 1)
 839     fGasDensity = dgm1;
 840   else
 841     fGasDensity = dgm2;
 842
 843 }
 844
 845 //_____________________________________________________________________________
 846 void AliTRD::DrawModule() const
 847 {
 848   //
 849   // Draw a shaded view of the Transition Radiation Detector version 0
 850   //
 851
 852   // Set everything unseen
 853   gMC->Gsatt("*"   ,"SEEN",-1);
 854
 855   // Set ALIC mother transparent
 856   gMC->Gsatt("ALIC","SEEN", 0);
 857
 858   // Set the volumes visible
 859   if (fGeometry->IsVersion() == 0) {
 860     gMC->Gsatt("B071","SEEN", 0);
 861     gMC->Gsatt("B074","SEEN", 0);
 862     gMC->Gsatt("B075","SEEN", 0);
 863     gMC->Gsatt("B077","SEEN", 0);
 864     gMC->Gsatt("BTR1","SEEN", 0);
 865     gMC->Gsatt("BTR2","SEEN", 0);
 866     gMC->Gsatt("BTR3","SEEN", 0);
 867     gMC->Gsatt("UTR1","SEEN", 0);
 868     gMC->Gsatt("UTR2","SEEN", 0);
 869     gMC->Gsatt("UTR3","SEEN", 0);
 870   }
 871   else {
 872     gMC->Gsatt("B071","SEEN", 0);
 873     gMC->Gsatt("B074","SEEN", 0);
 874     gMC->Gsatt("B075","SEEN", 0);
 875     gMC->Gsatt("B077","SEEN", 0);
 876     gMC->Gsatt("BTR1","SEEN", 0);
 877     gMC->Gsatt("BTR2","SEEN", 0);
 878     gMC->Gsatt("BTR3","SEEN", 0);
 879     gMC->Gsatt("UTR1","SEEN", 0);
 880     if (fGeometry->GetPHOShole())
 881       gMC->Gsatt("UTR2","SEEN", 0);
 882     if (fGeometry->GetRICHhole())
 883       gMC->Gsatt("UTR3","SEEN", 0);
 884   }
 885 //   gMC->Gsatt("UCII","SEEN", 0);
 886 //   gMC->Gsatt("UCIM","SEEN", 0);
 887 //   gMC->Gsatt("UCIO","SEEN", 0);
 888 //   gMC->Gsatt("UL02","SEEN", 1);
 889 //   gMC->Gsatt("UL05","SEEN", 1);
 890 //   gMC->Gsatt("UL06","SEEN", 1);
 891
 892   gMC->Gdopt("hide", "on");
 893   gMC->Gdopt("shad", "on");
 894   gMC->Gsatt("*", "fill", 7);
 895   gMC->SetClipBox(".");
 896   gMC->SetClipBox("*", 0, 2000, -2000, 2000, -2000, 2000);
 897   gMC->DefaultRange();
 898   gMC->Gdraw("alic", 40, 30, 0, 12, 9.4, .021, .021);
 899   gMC->Gdhead(1111, "Transition Radiation Detector");
 900   gMC->Gdman(18, 4, "MAN");
 901
 902 }
 903
 904 //_____________________________________________________________________________
 905 Int_t AliTRD::DistancetoPrimitive(Int_t , Int_t ) const
 906 {
 907   //
 908   // Distance between the mouse and the TRD detector on the screen
 909   // Dummy routine
 910
 911   return 9999;
 912
 913 }
 914
 915 //_____________________________________________________________________________
 916 void AliTRD::Init()
 917 {
 918   //
 919   // Initialize the TRD detector after the geometry has been created
 920   //
 921
 922   Int_t i;
 923
 924   if (fDebug) {
 925     printf("\n%s: ",ClassName());
 926     for (i = 0; i < 35; i++) printf("*");
 927     printf(" TRD_INIT ");
 928     for (i = 0; i < 35; i++) printf("*");
 929     printf("\n");
 930   }
 931
 932   if      (fGeometry->IsVersion() == 0) {
 933     printf("%s: Geometry for spaceframe with holes initialized\n",ClassName());
 934   }
 935   else if (fGeometry->IsVersion() == 1) {
 936     printf("%s: Geometry for spaceframe without holes initialized\n",ClassName());
 937     if (fGeometry->GetPHOShole())
 938       printf("%s: Leave space in front of PHOS free\n",ClassName());
 939     if (fGeometry->GetRICHhole())
 940       printf("%s: Leave space in front of RICH free\n",ClassName());
 941   }
 942
 943   if (fGasMix == 1) {
 944     printf("%s: Gas Mixture: 85%% Xe + 15%% CO2\n",ClassName());
 945   }
 946   else {
 947     printf("%s: Gas Mixture: 97%% Xe + 3%% Isobutane\n",ClassName());
 948   }
 949
 950 }
 951
 952 //_____________________________________________________________________________
 953 void AliTRD::LoadPoints(Int_t track)
 954 {
 955   //
 956   // Store x, y, z of all hits in memory.
 957   // Hit originating from TR photons are given a different color
 958   //
 959
 960   //if (!fDrawTR) {
 961   //  AliDetector::LoadPoints(track);
 962   //  return;
 963   //}
 964
 965   if ((fHits == 0) && (fTrackHits == 0)) return;
 966
 967   Int_t nhits;
 968   if (fHitType < 2) {
 969     nhits = fHits->GetEntriesFast();
 970   }
 971   else {
 972     nhits = fTrackHits->GetEntriesFast();
 973   }
 974   if (nhits == 0) return;
 975
 976   Int_t tracks = gAlice->GetNtrack();
 977   if (fPoints == 0) fPoints = new TObjArray(tracks);
 978
 979   AliTRDhit *ahit;
 980
 981   Int_t    *ntrkE = new Int_t[tracks];
 982   Int_t    *ntrkT = new Int_t[tracks];
 983   Int_t    *limiE = new Int_t[tracks];
 984   Int_t    *limiT = new Int_t[tracks];
 985   Float_t **coorE = new Float_t*[tracks];
 986   Float_t **coorT = new Float_t*[tracks];
 987   for(Int_t i = 0; i < tracks; i++) {
 988     ntrkE[i] = 0;
 989     ntrkT[i] = 0;
 990     coorE[i] = 0;
 991     coorT[i] = 0;
 992     limiE[i] = 0;
 993     limiT[i] = 0;
 994   }
 995
 996   AliTRDpoints *points = 0;
 997   Float_t      *fp     = 0;
 998   Int_t         trk;
 999   Int_t         chunk  = nhits / 4 + 1;
1000
1001   // Loop over all the hits and store their position
1002   ahit = (AliTRDhit *) FirstHit(-1);
1003   while (ahit) {
1004
1005     // dEdx hits
1006     if (ahit->GetCharge() >= 0) {
1007
1008       trk = ahit->GetTrack();
1009       if (ntrkE[trk] == limiE[trk]) {
1010         // Initialise a new track
1011         fp = new Float_t[3*(limiE[trk]+chunk)];
1012         if (coorE[trk]) {
1013           memcpy(fp,coorE[trk],sizeof(Float_t)*3*limiE[trk]);
1014           delete [] coorE[trk];
1015         }
1016         limiE[trk] += chunk;
1017         coorE[trk]  = fp;
1018       }
1019       else {
1020         fp = coorE[trk];
1021       }
1022       fp[3*ntrkE[trk]  ] = ahit->X();
1023       fp[3*ntrkE[trk]+1] = ahit->Y();
1024       fp[3*ntrkE[trk]+2] = ahit->Z();
1025       ntrkE[trk]++;
1026
1027     }
1028     // TR photon hits
1029     else if ((ahit->GetCharge() < 0) && (fDrawTR)) {
1030
1031       trk = ahit->GetTrack();
1032       if (ntrkT[trk] == limiT[trk]) {
1033         // Initialise a new track
1034         fp = new Float_t[3*(limiT[trk]+chunk)];
1035         if (coorT[trk]) {
1036           memcpy(fp,coorT[trk],sizeof(Float_t)*3*limiT[trk]);
1037           delete [] coorT[trk];
1038         }
1039         limiT[trk] += chunk;
1040         coorT[trk]  = fp;
1041       }
1042       else {
1043         fp = coorT[trk];
1044       }
1045       fp[3*ntrkT[trk]  ] = ahit->X();
1046       fp[3*ntrkT[trk]+1] = ahit->Y();
1047       fp[3*ntrkT[trk]+2] = ahit->Z();
1048       ntrkT[trk]++;
1049
1050     }
1051
1052     ahit = (AliTRDhit *) NextHit();
1053
1054   }
1055
1056   for (trk = 0; trk < tracks; ++trk) {
1057
1058     if (ntrkE[trk] || ntrkT[trk]) {
1059
1060       points = new AliTRDpoints();
1061       points->SetDetector(this);
1062       points->SetParticle(trk);
1063
1064       // Set the dEdx points
1065       if (ntrkE[trk]) {
1066         points->SetMarkerColor(GetMarkerColor());
1067         points->SetMarkerSize(GetMarkerSize());
1068         points->SetPolyMarker(ntrkE[trk],coorE[trk],GetMarkerStyle());
1069         delete [] coorE[trk];
1070         coorE[trk] = 0;
1071       }
1072
1073       // Set the TR photon points
1074       if (ntrkT[trk]) {
1075         points->SetTRpoints(ntrkT[trk],coorT[trk]);
1076         delete [] coorT[trk];
1077         coorT[trk] = 0;
1078       }
1079
1080       fPoints->AddAt(points,trk);
1081
1082     }
1083
1084   }
1085
1086   delete [] coorE;
1087   delete [] coorT;
1088   delete [] ntrkE;
1089   delete [] ntrkT;
1090   delete [] limiE;
1091   delete [] limiT;
1092
1093 }
1094
1095 //_____________________________________________________________________________
1096 void AliTRD::MakeBranch(Option_t* option, const char *file)
1097 {
1098   //
1099   // Create Tree branches for the TRD digits.
1100   //
1101
1102   Int_t  buffersize = 4000;
1103   Char_t branchname[15];
1104   sprintf(branchname,"%s",GetName());
1105
1106   const char *cD = strstr(option,"D");
1107
1108   AliDetector::MakeBranch(option,file);
1109
1110   if (fDigits && gAlice->TreeD() && cD) {
1111     MakeBranchInTree(gAlice->TreeD(),branchname,&fDigits,buffersize,file);
1112   }
1113
1114   if (fHitType > 1) {
1115     MakeBranch2(option,file);
1116   }
1117
1118 }
1119
1120 //_____________________________________________________________________________
1121 void AliTRD::ResetDigits()
1122 {
1123   //
1124   // Reset number of digits and the digits array for this detector
1125   //
1126
1127   fNdigits = 0;
1128   if (fDigits) fDigits->Clear();
1129
1130 }
1131
1132 //_____________________________________________________________________________
1133 void AliTRD::ResetRecPoints()
1134 {
1135   //
1136   // Reset number of reconstructed points and the point array
1137   //
1138
1139   if (fRecPoints) {
1140     fNRecPoints = 0;
1141     Int_t nentr = fRecPoints->GetEntriesFast();
1142     for (Int_t i = 0; i < nentr; i++) delete fRecPoints->RemoveAt(i);
1143   }
1144
1145 }
1146
1147 //_____________________________________________________________________________
1148 void AliTRD::SetTreeAddress()
1149 {
1150   //
1151   // Set the branch addresses for the trees.
1152   //
1153
1154   Char_t branchname[15];
1155
1156   AliDetector::SetTreeAddress();
1157
1158   TBranch *branch;
1159   TTree   *treeR = gAlice->TreeR();
1160
1161   if (treeR) {
1162     sprintf(branchname,"%scluster",GetName());
1163     if (fRecPoints) {
1164       branch = treeR->GetBranch(branchname);
1165       if (branch) {
1166         branch->SetAddress(&fRecPoints);
1167       }
1168     }
1169   }
1170
1171   if (fHitType > 0) {
1172     SetTreeAddress2();
1173   }
1174
1175 }
1176
1177 //_____________________________________________________________________________
1178 void AliTRD::SetGasMix(Int_t imix)
1179 {
1180   //
1181   // Defines the gas mixture (imix=0:  Xe/Isobutane imix=1: Xe/CO2)
1182   //
1183
1184   if ((imix < 0) || (imix > 1)) {
1185     printf("Wrong input value: %d\n",imix);
1186     printf("Use standard setting\n");
1187     fGasMix = 1;
1188     return;
1189   }
1190
1191   fGasMix = imix;
1192
1193 }
1194
1195 //_____________________________________________________________________________
1196 void AliTRD::SetPHOShole()
1197 {
1198   //
1199   // Selects a geometry with a hole in front of the PHOS
1200   //
1201
1202   fGeometry->SetPHOShole();
1203
1204 }
1205
1206 //_____________________________________________________________________________
1207 void AliTRD::SetRICHhole()
1208 {
1209   //
1210   // Selects a geometry with a hole in front of the RICH
1211   //
1212
1213   fGeometry->SetRICHhole();
1214
1215 }
1216
1217 //_____________________________________________________________________________
1218 AliTRD &AliTRD::operator=(const AliTRD &trd)
1219 {
1220   //
1221   // Assignment operator
1222   //
1223
1224   if (this != &trd) ((AliTRD &) trd).Copy(*this);
1225   return *this;
1226
1227 }
1228
1229 //_____________________________________________________________________________
1230 void AliTRD::FinishPrimary()
1231 {
1232   //
1233   // Store the hits in the containers after all primaries are finished
1234   //
1235
1236   if (fTrackHits) {
1237     fTrackHits->FlushHitStack();
1238   }
1239
1240 }
1241
1242 //_____________________________________________________________________________
1243 void AliTRD::RemapTrackHitIDs(Int_t *map)
1244 {
1245   //
1246   // Remap the track IDs
1247   //
1248
1249   if (!fTrackHits) {
1250     return;
1251   }
1252
1253   if (fTrackHits) {
1254     TClonesArray *arr = fTrackHits->GetArray();;
1255     for (Int_t i = 0; i < arr->GetEntriesFast(); i++){
1256       AliTrackHitsParamV2 *info = (AliTrackHitsParamV2 *) (arr->At(i));
1257       info->fTrackID = map[info->fTrackID];
1258     }
1259   }
1260
1261 }
1262
1263 //_____________________________________________________________________________
1264 void AliTRD::ResetHits()
1265 {
1266   //
1267   // Reset the hits
1268   //
1269
1270   AliDetector::ResetHits();
1271   if (fTrackHits) {
1272     fTrackHits->Clear();
1273   }
1274
1275 }
1276
1277 //_____________________________________________________________________________
1278 AliHit* AliTRD::FirstHit(Int_t track)
1279 {
1280   //
1281   // Return the first hit of a track
1282   //
1283
1284   if (fHitType > 1) {
1285     return FirstHit2(track);
1286   }
1287
1288   return AliDetector::FirstHit(track);
1289
1290 }
1291
1292 //_____________________________________________________________________________
1293 AliHit* AliTRD::NextHit()
1294 {
1295   //
1296   // Returns the next hit of a track
1297   //
1298
1299   if (fHitType > 1) {
1300     return NextHit2();
1301   }
1302
1303   return AliDetector::NextHit();
1304
1305 }
1306
1307 //_____________________________________________________________________________
1308 AliHit* AliTRD::FirstHit2(Int_t track)
1309 {
1310   //
1311   // Initializes the hit iterator.
1312   // Returns the address of the first hit of a track.
1313   // If <track> >= 0 the track is read from disk,
1314   // while if <track> < 0 the first hit of the current
1315   // track is returned.
1316   //
1317
1318   if (track >= 0) {
1319     gAlice->ResetHits();
1320     gAlice->TreeH()->GetEvent(track);
1321   }
1322
1323   if (fTrackHits) {
1324     fTrackHits->First();
1325     return (AliHit*) fTrackHits->GetHit();
1326   }
1327   else {
1328     return 0;
1329   }
1330
1331 }
1332
1333 //_____________________________________________________________________________
1334 AliHit* AliTRD::NextHit2()
1335 {
1336   //
1337   // Returns the next hit of the current track
1338   //
1339
1340   if (fTrackHits) {
1341     fTrackHits->Next();
1342     return (AliHit *) fTrackHits->GetHit();
1343   }
1344   else {
1345     return 0;
1346   }
1347
1348 }
1349
1350 //_____________________________________________________________________________
1351 void AliTRD::MakeBranch2(Option_t *option, const char *file)
1352 {
1353   //
1354   // Create a new branch in the current Root tree.
1355   // The branch of fHits is automatically split.
1356   //
1357
1358   if (fHitType < 2) {
1359     return;
1360   }
1361
1362   char branchname[10];
1363   sprintf(branchname,"%s2",GetName());
1364
1365   // Get the pointer to the header
1366   const char *cH = strstr(option,"H");
1367
1368   if (!fTrackHits) {
1369     fTrackHits = new AliTRDtrackHits();
1370   }
1371
1372   if (fTrackHits && gAlice->TreeH() && cH) {
1373
1374     gAlice->TreeH()->Branch(branchname,"AliTRDtrackHits"
1375                                       ,&fTrackHits
1376                                       ,fBufferSize,99);
1377
1378     if (GetDebug() > 1) {
1379       printf("<AliTRD::MakeBranch2> Making Branch %s for trackhits\n"
1380             ,branchname);
1381     }
1382
1383     const char kFolder[] = "RunMC/Event/Data";
1384
1385     if (GetDebug()) {
1386       printf("<AliTRD::MakeBranch2> %15s: Publishing %s to %s\n"
1387             ,ClassName(),branchname,kFolder);
1388     }
1389
1390     Publish(kFolder,&fTrackHits,branchname);
1391
1392     if (file) {
1393       TBranch *b = gAlice->TreeH()->GetBranch(branchname);
1394       TDirectory *wd = gDirectory;
1395       b->SetFile(file);
1396       TIter next(b->GetListOfBranches());
1397       while ((b = (TBranch*) next())) {
1398         b->SetFile(file);
1399       }
1400       wd->cd();
1401       if (GetDebug() > 1) {
1402         printf("<AliTRD::MakeBranch2> Diverting branch %s to file %s\n"
1403               ,branchname,file);
1404       }
1405     }
1406
1407   }
1408
1409 }
1410
1411 //_____________________________________________________________________________
1412 void AliTRD::SetTreeAddress2()
1413 {
1414   //
1415   // Set the branch address for the trackHits tree
1416   //
1417
1418   TBranch *branch;
1419
1420   char branchname[20];
1421
1422   sprintf(branchname,"%s2",GetName());
1423
1424   // Branch address for hit tree
1425   TTree *treeH = gAlice->TreeH();
1426   if ((treeH) && (fHitType > 0)) {
1427     branch = treeH->GetBranch(branchname);
1428     if (branch) {
1429       branch->SetAddress(&fTrackHits);
1430     }
1431   }
1432
1433 }
1434
1435 //_____________________________________________________________________________
1436 void AliTRD::AddHit2(Int_t track, Int_t det, Float_t *hits, Int_t q
1437                    , Bool_t inDrift)
1438 {
1439   //
1440   // Add a hit to the list
1441   //
1442
1443   Int_t rtrack;
1444
1445   if (fIshunt) {
1446     Int_t primary = gAlice->GetPrimary(track);
1447     gAlice->Particle(primary)->SetBit(kKeepBit);
1448     rtrack = primary;
1449   }
1450   else {
1451     rtrack = track;
1452     gAlice->FlagTrack(track);
1453   }
1454
1455   if ((fTrackHits) && (fHitType > 0)) {
1456     fTrackHits->AddHitTRD(det,rtrack,hits[0],hits[1],hits[2],q,inDrift);
1457   }
1458
1459 }
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798