41587fb620eaa485d001ecb80355ff14f92ffe6b
[u/mrichter/AliRoot.git] / 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