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