Update of digitization. Moved digit branch definition to AliTRD
[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.24  2001/01/26 19:56:49  hristov
19 Major upgrade of AliRoot code
20
21 Revision 1.23  2000/11/01 14:53:20  cblume
22 Merge with TRD-develop
23
24
25 Revision 1.17.2.6  2000/10/15 23:29:08  cblume
26 Introduced more detailed geometry for the display
27
28 Revision 1.17.2.5  2000/10/06 16:49:46  cblume
29 Made Getters const
30
31 Revision 1.17.2.4  2000/10/04 16:34:57  cblume
32 Replace include files by forward declarations
33
34 Revision 1.17.2.3  2000/09/22 14:45:17  cblume
35 Included changes for the tracking
36
37 Revision 1.17.2.2  2000/09/18 13:25:13  cblume
38 Included LoadPoints() method to display the TR photons
39
40 Revision 1.22  2000/10/02 21:28:19  fca
41 Removal of useless dependecies via forward declarations
42
43 Revision 1.21  2000/06/09 11:10:07  cblume
44 Compiler warnings and coding conventions, next round
45
46 Revision 1.20  2000/06/08 18:32:57  cblume
47 Make code compliant to coding conventions
48
49 Revision 1.19  2000/06/07 16:25:37  cblume
50 Try to remove compiler warnings on Sun and HP
51
52 Revision 1.18  2000/05/08 16:17:27  cblume
53 Merge TRD-develop
54
55 Revision 1.21  2000/06/09 11:10:07  cblume
56 Compiler warnings and coding conventions, next round
57
58 Revision 1.20  2000/06/08 18:32:57  cblume
59 Make code compliant to coding conventions
60
61 Revision 1.19  2000/06/07 16:25:37  cblume
62 Try to remove compiler warnings on Sun and HP
63
64 Revision 1.18  2000/05/08 16:17:27  cblume
65 Merge TRD-develop
66
67 Revision 1.17.2.1  2000/05/08 14:28:59  cblume
68 Introduced SetPHOShole() and SetRICHhole(). AliTRDrecPoint container is now a TObjArray
69
70 Revision 1.17  2000/02/28 19:10:26  cblume
71 Include the new TRD classes
72
73 Revision 1.16.2.2  2000/02/28 17:53:24  cblume
74 Introduce TRD geometry classes
75
76 Revision 1.16.2.1  2000/02/28 17:04:19  cblume
77 Include functions and data members for AliTRDrecPoint
78
79 Revision 1.16  2000/01/19 17:17:35  fca
80 Introducing a list of lists of hits -- more hits allowed for detector now
81
82 Revision 1.15  1999/11/02 17:04:25  fca
83 Small syntax change for HP compiler
84
85 Revision 1.14  1999/11/02 16:57:02  fca
86 Avoid non ansi warnings on HP compilers
87
88 Revision 1.13  1999/11/02 16:35:56  fca
89 New version of TRD introduced
90
91 Revision 1.12  1999/11/01 20:41:51  fca
92 Added protections against using the wrong version of FRAME
93
94 Revision 1.11  1999/09/29 09:24:34  fca
95 Introduction of the Copyright and cvs Log
96
97 */
98
99 ///////////////////////////////////////////////////////////////////////////////
100 //                                                                           //
101 //  Transition Radiation Detector                                            //
102 //  This class contains the basic functions for the Transition Radiation     //
103 //  Detector.                                                                //
104 //                                                                           //
105 ///////////////////////////////////////////////////////////////////////////////
106
107 #include <stdlib.h>
108 #include <iostream.h>
109
110 #include <TMath.h>
111 #include <TNode.h>
112 #include <TGeometry.h>
113 #include <TTree.h>                                                              
114 #include <TPGON.h> 
115
116 #include "AliRun.h"
117 #include "AliConst.h"
118 #include "AliDigit.h"
119 #include "AliMagF.h"
120 #include "AliMC.h"                                                              
121  
122 #include "AliTRD.h"
123 #include "AliTRDhit.h"
124 #include "AliTRDpoints.h"
125 #include "AliTRDdigit.h"
126 #include "AliTRDdigitizer.h"
127 #include "AliTRDclusterizer.h"
128 #include "AliTRDgeometryHole.h"
129 #include "AliTRDgeometryFull.h"
130 #include "AliTRDrecPoint.h"
131 #include "AliTRDdigitsManager.h"
132 #include "AliTRDdataArrayI.h"
133 #include "AliTRDsegmentArray.h"
134
135 ClassImp(AliTRD)
136  
137 //_____________________________________________________________________________
138 AliTRD::AliTRD()
139 {
140   //
141   // Default constructor
142   //
143
144   fIshunt        = 0;
145   fGasMix        = 0;
146   fHits          = 0;
147   fDigits        = 0;
148
149   fRecPoints     = 0;
150   fNRecPoints    = 0;
151
152   fGeometry      = 0;
153
154   fGasDensity    = 0;
155   fFoilDensity   = 0;
156
157   fDrawTR        = 0;
158   fDisplayType   = 0; 
159
160   fDigitsArray   = 0; 
161   for (Int_t iDict = 0; iDict < AliTRDdigitsManager::NDict(); iDict++) {
162     fDictionaryArray[iDict] = 0; 
163   }
164
165 }
166  
167 //_____________________________________________________________________________
168 AliTRD::AliTRD(const char *name, const char *title)
169        : AliDetector(name,title)
170 {
171   //
172   // Standard constructor for the TRD
173   //
174
175   // Check that FRAME is there otherwise we have no place where to
176   // put TRD
177   AliModule* frame = gAlice->GetModule("FRAME");
178   if (!frame) {
179     Error("Ctor","TRD needs FRAME to be present\n");
180     exit(1);
181   } 
182
183   // Define the TRD geometry according to the FRAME geometry
184   if      (frame->IsVersion() == 0) {
185     // Geometry with hole
186     fGeometry = new AliTRDgeometryHole();
187   }
188   else if (frame->IsVersion() == 1) {
189     // Geometry without hole
190     fGeometry = new AliTRDgeometryFull();
191   }
192   else {
193     Error("Ctor","Could not find valid FRAME version\n");
194     exit(1);
195   }
196
197   // Allocate the hit array
198   fHits        = new TClonesArray("AliTRDhit"     ,405);
199   gAlice->AddHitList(fHits);
200
201   // Allocate the digits array
202   fDigits      = 0;
203
204   // Allocate the rec point array
205   fRecPoints     = new TObjArray(400);
206   fNRecPoints    = 0;
207    
208   fIshunt        = 0;
209   fGasMix        = 1;
210
211   fGasDensity    = 0;
212   fFoilDensity   = 0;
213
214   fDrawTR        = 0;
215   fDisplayType   = 0;
216
217   fDigitsArray   = 0; 
218   for (Int_t iDict = 0; iDict < AliTRDdigitsManager::NDict(); iDict++) {
219     fDictionaryArray[iDict] = 0; 
220   }
221
222   SetMarkerColor(kWhite);   
223
224 }
225
226 //_____________________________________________________________________________
227 AliTRD::AliTRD(const AliTRD &trd)
228 {
229   //
230   // Copy constructor
231   //
232
233   ((AliTRD &) trd).Copy(*this);
234
235 }
236
237 //_____________________________________________________________________________
238 AliTRD::~AliTRD()
239 {
240   //
241   // TRD destructor
242   //
243
244   fIshunt = 0;
245
246   delete fGeometry;
247   delete fHits;
248   delete fRecPoints;
249   if (fDigitsArray) delete fDigitsArray;
250   for (Int_t iDict = 0; iDict < AliTRDdigitsManager::NDict(); iDict++) {
251     if (fDictionaryArray[iDict]) delete fDictionaryArray[iDict];
252   }
253
254 }
255
256 //_____________________________________________________________________________
257 void AliTRD::AddRecPoint(Float_t *pos, Int_t *digits, Int_t det, Float_t amp
258                        , Int_t *tracks)
259 {
260   //
261   // Add a reconstructed point for the TRD
262   //
263
264   AliTRDrecPoint *recPoint = new AliTRDrecPoint();
265   TVector3        posVec(pos[0],pos[1],pos[2]);
266   recPoint->SetLocalPosition(posVec);
267   recPoint->SetDetector(det);
268   recPoint->SetEnergy(amp);
269   for (Int_t iDigit = 0; iDigit < 3; iDigit++) {
270     recPoint->AddDigit(digits[iDigit]);
271   }
272
273   recPoint->AddTrackIndex(tracks);
274
275   recPoint->SetTrackingYZ(0.,0.);  // variance values set inside
276   fRecPoints->Add(recPoint);
277
278 }
279
280 //_____________________________________________________________________________
281 void AliTRD::Hits2Digits()
282 {
283   //
284   // Create digits
285   //
286
287   AliTRDdigitizer *digitizer = new AliTRDdigitizer("TRDdigitizer"
288                                                   ,"TRD digitizer class");
289
290   // Set the parameter
291   digitizer->SetDiffusion();
292   digitizer->SetExB();
293
294   // Initialization
295   //digitizer->InitDetector();
296     
297   // Create the digits
298   digitizer->MakeDigits();
299   
300   // Write the digits into the input file
301   if (digitizer->Digits()->MakeBranch(fDigitsFile)) {
302
303     digitizer->WriteDigits();
304
305     // Save the digitizer class in the AliROOT 
306     digitizer->Write();
307
308   }
309
310 }
311
312 //_____________________________________________________________________________
313 void AliTRD::Hits2SDigits()
314 {
315   //
316   // Create summable digits
317   //
318
319   AliTRDdigitizer *digitizer = new AliTRDdigitizer("TRDdigitizer"
320                                                   ,"TRD digitizer class");
321
322   // For the summable digits
323   digitizer->SetSDigits(kTRUE);
324
325   // Set the parameter
326   digitizer->SetDiffusion();
327   digitizer->SetExB();
328
329   // Initialization
330   //digitizer->InitDetector();
331     
332   // Create the digits
333   digitizer->MakeDigits();
334   
335   // Write the digits into the input file
336   if (digitizer->Digits()->MakeBranch(fDigitsFile)) {
337
338     digitizer->WriteDigits();
339
340     // Save the digitizer class in the AliROOT 
341     digitizer->Write();
342
343   }
344
345 }
346
347 //_____________________________________________________________________________
348 void AliTRD::SDigits2Digits()
349 {
350   //
351   // Create final digits from summable digits
352   //
353
354 }
355
356 //_____________________________________________________________________________
357 void AliTRD::AddDigit(Int_t *digits, Int_t *amp)
358 {
359   //
360   // Add a digit for the TRD
361   //
362
363   TClonesArray &ldigits = *fDigits;
364   new(ldigits[fNdigits++]) AliTRDdigit(kFALSE,digits,amp);
365
366 }
367
368 //_____________________________________________________________________________
369 void AliTRD::AddHit(Int_t track, Int_t det, Float_t *hits, Int_t q)
370 {
371   //
372   // Add a hit for the TRD
373   //
374
375   TClonesArray &lhits = *fHits;
376   new(lhits[fNhits++]) AliTRDhit(fIshunt,track,det,hits,q);
377
378 }
379
380 //_____________________________________________________________________________
381 void AliTRD::BuildGeometry()
382 {
383   //
384   // Create the ROOT TNode geometry for the TRD
385   //
386
387   TNode *node, *top;
388   TPGON *pgon;
389
390   Float_t rmin, rmax;
391   Float_t zmax1, zmax2;
392  
393   const Int_t kColorTRD = 46;
394   
395   // Find the top node alice
396   top = gAlice->GetGeometry()->GetNode("alice");
397   
398   switch (fDisplayType) {
399
400   case 0:
401
402     pgon = new TPGON("S_TRD","TRD","void",0,360,AliTRDgeometry::Nsect(),4);
403     rmin = AliTRDgeometry::Rmin();
404     rmax = AliTRDgeometry::Rmax();
405     pgon->DefineSection(0,-AliTRDgeometry::Zmax1(),rmax,rmax);
406     pgon->DefineSection(1,-AliTRDgeometry::Zmax2(),rmin,rmax);
407     pgon->DefineSection(2, AliTRDgeometry::Zmax2(),rmin,rmax);
408     pgon->DefineSection(3, AliTRDgeometry::Zmax1(),rmax,rmax);
409     top->cd();
410     node = new TNode("TRD","TRD","S_TRD",0,0,0,"");
411     node->SetLineColor(kColorTRD);
412     fNodes->Add(node);
413
414     break;
415
416   case 1:
417
418     Float_t slope = (AliTRDgeometry::Zmax1() - AliTRDgeometry::Zmax2())
419                   / (AliTRDgeometry::Rmax()  - AliTRDgeometry::Rmin());
420
421     rmin  = AliTRDgeometry::Rmin() + AliTRDgeometry::RaThick();
422     rmax  = rmin + AliTRDgeometry::DrThick();
423     zmax2 = AliTRDgeometry::Zmax2() + slope * AliTRDgeometry::RaThick();
424     zmax1 = zmax2 + slope * AliTRDgeometry::DrThick();
425     Char_t name[7];
426
427     for (Int_t iPlan = 0; iPlan < AliTRDgeometry::Nplan(); iPlan++) {
428
429       sprintf(name,"S_TRD%d",iPlan);
430       pgon  = new TPGON(name,"TRD","void",0,360,AliTRDgeometry::Nsect(),4);
431       pgon->DefineSection(0,-zmax1,rmax,rmax);
432       pgon->DefineSection(1,-zmax2,rmin,rmax);
433       pgon->DefineSection(2, zmax2,rmin,rmax);
434       pgon->DefineSection(3, zmax1,rmax,rmax);
435       top->cd();
436       node = new TNode("TRD","TRD",name,0,0,0,"");
437       node->SetLineColor(kColorTRD);
438       fNodes->Add(node);
439
440       Float_t height = AliTRDgeometry::Cheight() + AliTRDgeometry::Cspace(); 
441       rmin  = rmin  + height;
442       rmax  = rmax  + height;
443       zmax1 = zmax1 + slope * height;
444       zmax2 = zmax2 + slope * height;
445
446     }
447
448     break;
449
450   };
451
452 }
453  
454 //_____________________________________________________________________________
455 void AliTRD::Copy(TObject &trd)
456 {
457   //
458   // Copy function
459   //
460
461   ((AliTRD &) trd).fGasMix      = fGasMix;
462   ((AliTRD &) trd).fGeometry    = fGeometry;       
463   ((AliTRD &) trd).fRecPoints   = fRecPoints;
464   ((AliTRD &) trd).fNRecPoints  = fNRecPoints;
465   ((AliTRD &) trd).fGasDensity  = fGasDensity;
466   ((AliTRD &) trd).fFoilDensity = fFoilDensity;
467   ((AliTRD &) trd).fDrawTR      = fDrawTR;
468   ((AliTRD &) trd).fDisplayType = fDisplayType;
469
470   //AliDetector::Copy(trd);
471
472 }
473
474 //_____________________________________________________________________________
475 void AliTRD::CreateGeometry()
476 {
477   //
478   // Creates the volumes for the TRD chambers
479   //
480
481   // Check that FRAME is there otherwise we have no place where to put the TRD
482   AliModule* frame = gAlice->GetModule("FRAME");
483   if (!frame) {
484     printf(" The TRD needs the FRAME to be defined first\n");
485     return;
486   }
487
488   fGeometry->CreateGeometry(fIdtmed->GetArray() - 1299);
489
490 }
491  
492 //_____________________________________________________________________________
493 void AliTRD::CreateMaterials()
494 {
495   //
496   // Create the materials for the TRD
497   // Origin Y.Foka
498   //
499
500   Int_t   isxfld = gAlice->Field()->Integ();
501   Float_t sxmgmx = gAlice->Field()->Max();
502   
503   // For polyethilene (CH2) 
504   Float_t ape[2] = { 12., 1. };
505   Float_t zpe[2] = {  6., 1. };
506   Float_t wpe[2] = {  1., 2. };
507   Float_t dpe    = 0.95;
508
509   // For mylar (C5H4O2) 
510   Float_t amy[3] = { 12., 1., 16. };
511   Float_t zmy[3] = {  6., 1.,  8. };
512   Float_t wmy[3] = {  5., 4.,  2. };
513   Float_t dmy    = 1.39;
514
515   // For CO2 
516   Float_t aco[2] = { 12., 16. };
517   Float_t zco[2] = {  6.,  8. };
518   Float_t wco[2] = {  1.,  2. };
519   Float_t dco    = 0.001977;
520
521   // For water
522   Float_t awa[2] = {  1., 16. };
523   Float_t zwa[2] = {  1.,  8. };
524   Float_t wwa[2] = {  2.,  1. };
525   Float_t dwa    = 1.0;
526
527   // For isobutane (C4H10)
528   Float_t ais[2] = { 12.,  1. };
529   Float_t zis[2] = {  6.,  1. };
530   Float_t wis[2] = {  4., 10. };
531   Float_t dis    = 0.00267;
532
533   // For Xe/CO2-gas-mixture 
534   // Xe-content of the Xe/CO2-mixture (90% / 10%) 
535   Float_t fxc    = .90;
536   // Xe-content of the Xe/Isobutane-mixture (97% / 3%) 
537   Float_t fxi    = .97;
538   Float_t dxe    = .005858;
539   
540   // General tracking parameter
541   Float_t tmaxfd = -10.;
542   Float_t stemax = -1e10;
543   Float_t deemax = -0.1;
544   Float_t epsil  =  1e-4;
545   Float_t stmin  = -0.001;
546   
547   Float_t absl, radl, d, buf[1];
548   Float_t agm[2], zgm[2], wgm[2];
549   Float_t dgm1, dgm2;
550   Int_t   nbuf;
551   
552   //////////////////////////////////////////////////////////////////////////
553   //     Define Materials 
554   //////////////////////////////////////////////////////////////////////////
555
556   AliMaterial( 1, "Al $",  26.98, 13.0, 2.7     ,     8.9 ,    37.2);
557   AliMaterial( 2, "Air$",  14.61,  7.3, 0.001205, 30420.0 , 67500.0);
558   AliMaterial( 4, "Xe $", 131.29, 54.0, dxe     ,  1447.59,     0.0);
559   AliMaterial( 5, "Cu $",  63.54, 29.0, 8.96    ,     1.43,    14.8);
560   AliMaterial( 6, "C  $",  12.01,  6.0, 2.265   ,    18.8 ,    74.4);
561   AliMaterial(12, "G10$",  20.00, 10.0, 1.7     ,    19.4 ,   999.0);
562
563   // Mixtures 
564   AliMixture(3, "Polyethilene$",   ape, zpe, dpe, -2, wpe);
565   AliMixture(7, "Mylar$",          amy, zmy, dmy, -3, wmy);
566   AliMixture(8, "CO2$",            aco, zco, dco, -2, wco);
567   AliMixture(9, "Isobutane$",      ais, zis, dis, -2, wis);
568   AliMixture(13,"Water$",          awa, zwa, dwa, -2, wwa);
569
570   // Gas mixtures
571   Char_t namate[21];
572   // Xe/CO2-mixture
573   // Get properties of Xe 
574   gMC->Gfmate((*fIdmate)[4], namate, agm[0], zgm[0], d, radl, absl, buf, nbuf);
575   // Get properties of CO2 
576   gMC->Gfmate((*fIdmate)[8], namate, agm[1], zgm[1], d, radl, absl, buf, nbuf);
577   // Create gas mixture 
578   wgm[0] = fxc;
579   wgm[1] = 1. - fxc;
580   dgm1   = wgm[0] * dxe + wgm[1] * dco;
581   AliMixture(10, "Gas mixture 1$", agm, zgm, dgm1,  2, wgm);
582   // Xe/Isobutane-mixture
583   // Get properties of Xe 
584   gMC->Gfmate((*fIdmate)[4], namate, agm[0], zgm[0], d, radl, absl, buf, nbuf);
585   // Get properties of Isobutane
586   gMC->Gfmate((*fIdmate)[9], namate, agm[1], zgm[1], d, radl, absl, buf, nbuf);
587   // Create gas mixture 
588   wgm[0] = fxi;
589   wgm[1] = 1. - fxi;
590   dgm2   = wgm[0] * dxe + wgm[1] * dis;
591   AliMixture(11, "Gas mixture 2$", agm, zgm, dgm2,  2, wgm);
592  
593   //////////////////////////////////////////////////////////////////////////
594   //     Tracking Media Parameters 
595   //////////////////////////////////////////////////////////////////////////
596
597   // Al Frame 
598   AliMedium(1, "Al Frame$",   1, 0, isxfld, sxmgmx
599                 , tmaxfd, stemax, deemax, epsil, stmin);
600   // Air 
601   AliMedium(2, "Air$",        2, 0, isxfld, sxmgmx
602                 , tmaxfd, stemax, deemax, epsil, stmin);
603   // Polyethilene 
604   AliMedium(3, "Radiator$",   3, 0, isxfld, sxmgmx
605                 , tmaxfd, stemax, deemax, epsil, stmin);
606   // Xe 
607   AliMedium(4, "Xe$",         4, 1, isxfld, sxmgmx
608                 , tmaxfd, stemax, deemax, epsil, stmin);
609   // Cu pads 
610   AliMedium(5, "Padplane$",   5, 1, isxfld, sxmgmx
611                 , tmaxfd, stemax, deemax, epsil, stmin);
612   // Fee + cables 
613   AliMedium(6, "Readout$",    1, 0, isxfld, sxmgmx
614                 , tmaxfd, stemax, deemax, epsil, stmin);
615   // C frame 
616   AliMedium(7, "C Frame$",    6, 0, isxfld, sxmgmx
617                 , tmaxfd, stemax, deemax, epsil, stmin);
618   // Mylar foils 
619   AliMedium(8, "Mylar$",      7, 0, isxfld, sxmgmx
620                 , tmaxfd, stemax, deemax, epsil, stmin);
621   if (fGasMix == 1) {
622     // Gas-mixture (Xe/CO2) 
623     AliMedium(9, "Gas-mix$",   10, 1, isxfld, sxmgmx
624                   , tmaxfd, stemax, deemax, epsil, stmin);
625   }
626   else {
627     // Gas-mixture (Xe/Isobutane) 
628     AliMedium(9, "Gas-mix$",   11, 1, isxfld, sxmgmx
629                   , tmaxfd, stemax, deemax, epsil, stmin);
630   }
631   // Nomex-honeycomb (use carbon for the time being) 
632   AliMedium(10, "Nomex$",      6, 0, isxfld, sxmgmx
633                 , tmaxfd, stemax, deemax, epsil, stmin);
634   // Kapton foils (use Mylar for the time being) 
635   AliMedium(11, "Kapton$",     7, 0, isxfld, sxmgmx
636                 , tmaxfd, stemax, deemax, epsil, stmin);
637   // Gas-filling of the radiator 
638   AliMedium(12, "CO2$",        8, 0, isxfld, sxmgmx
639                 , tmaxfd, stemax, deemax, epsil, stmin);
640   // G10-plates
641   AliMedium(13, "G10-plates$",12, 0, isxfld, sxmgmx
642                 , tmaxfd, stemax, deemax, epsil, stmin);
643   // Cooling water
644   AliMedium(14, "Water$",     13, 0, isxfld, sxmgmx
645                 , tmaxfd, stemax, deemax, epsil, stmin);
646
647   // Save the density values for the TRD absorbtion
648   fFoilDensity = dmy;
649   if (fGasMix == 1)
650     fGasDensity = dgm1;
651   else
652     fGasDensity = dgm2;
653
654 }
655
656 //_____________________________________________________________________________
657 void AliTRD::DrawModule()
658 {
659   //
660   // Draw a shaded view of the Transition Radiation Detector version 0
661   //
662
663   // Set everything unseen
664   gMC->Gsatt("*"   ,"SEEN",-1);
665   
666   // Set ALIC mother transparent
667   gMC->Gsatt("ALIC","SEEN", 0);
668   
669   // Set the volumes visible
670   if (fGeometry->IsVersion() == 0) {
671     gMC->Gsatt("B071","SEEN", 0);
672     gMC->Gsatt("B074","SEEN", 0);
673     gMC->Gsatt("B075","SEEN", 0);
674     gMC->Gsatt("B077","SEEN", 0);
675     gMC->Gsatt("BTR1","SEEN", 0);
676     gMC->Gsatt("BTR2","SEEN", 0);
677     gMC->Gsatt("BTR3","SEEN", 0);
678     gMC->Gsatt("TRD1","SEEN", 0);
679     gMC->Gsatt("TRD2","SEEN", 0);
680     gMC->Gsatt("TRD3","SEEN", 0);
681   }
682   else {
683     gMC->Gsatt("B071","SEEN", 0);
684     gMC->Gsatt("B074","SEEN", 0);
685     gMC->Gsatt("B075","SEEN", 0);
686     gMC->Gsatt("B077","SEEN", 0);
687     gMC->Gsatt("BTR1","SEEN", 0);
688     gMC->Gsatt("BTR2","SEEN", 0);
689     gMC->Gsatt("BTR3","SEEN", 0);
690     gMC->Gsatt("TRD1","SEEN", 0);
691     if (fGeometry->GetPHOShole())
692       gMC->Gsatt("TRD2","SEEN", 0);
693     if (fGeometry->GetRICHhole())
694       gMC->Gsatt("TRD3","SEEN", 0);
695   }
696   gMC->Gsatt("UCII","SEEN", 0);
697   gMC->Gsatt("UCIM","SEEN", 0);
698   gMC->Gsatt("UCIO","SEEN", 0);
699   gMC->Gsatt("UL02","SEEN", 1);
700   gMC->Gsatt("UL05","SEEN", 1);
701   gMC->Gsatt("UL06","SEEN", 1);
702   
703   gMC->Gdopt("hide", "on");
704   gMC->Gdopt("shad", "on");
705   gMC->Gsatt("*", "fill", 7);
706   gMC->SetClipBox(".");
707   gMC->SetClipBox("*", 0, 2000, -2000, 2000, -2000, 2000);
708   gMC->DefaultRange();
709   gMC->Gdraw("alic", 40, 30, 0, 12, 9.4, .021, .021);
710   gMC->Gdhead(1111, "Transition Radiation Detector");
711   gMC->Gdman(18, 4, "MAN");
712
713 }
714
715 //_____________________________________________________________________________
716 Int_t AliTRD::DistancetoPrimitive(Int_t , Int_t )
717 {
718   //
719   // Distance between the mouse and the TRD detector on the screen
720   // Dummy routine
721   
722   return 9999;
723
724 }
725  
726 //_____________________________________________________________________________
727 void AliTRD::Init()
728 {
729   //
730   // Initialize the TRD detector after the geometry has been created
731   //
732
733   Int_t i;
734
735   printf("\n");
736   for (i = 0; i < 35; i++) printf("*");
737   printf(" TRD_INIT ");
738   for (i = 0; i < 35; i++) printf("*");
739   printf("\n");
740   printf("\n");
741
742   if      (fGeometry->IsVersion() == 0) {
743     printf("          Geometry for spaceframe with holes initialized.\n\n");
744   }
745   else if (fGeometry->IsVersion() == 1) {
746     printf("          Geometry for spaceframe without holes initialized.\n");
747     if (fGeometry->GetPHOShole())
748       printf("          Leave space in front of PHOS free.\n");
749     if (fGeometry->GetRICHhole())
750       printf("          Leave space in front of RICH free.\n");
751     printf("\n");
752   }
753
754   if (fGasMix == 1)
755     printf("          Gas Mixture: 90%% Xe + 10%% CO2\n\n");
756   else
757     printf("          Gas Mixture: 97%% Xe + 3%% Isobutane\n\n");
758
759 }
760
761 //_____________________________________________________________________________
762 void AliTRD::LoadPoints(Int_t track)
763 {
764   //
765   // Store x, y, z of all hits in memory.
766   // Hit originating from TR photons are given a different color
767   //
768
769   if (!fDrawTR) {
770     AliDetector::LoadPoints(track);
771     return;
772   }
773
774   if (fHits == 0) return;
775
776   Int_t nhits  = fHits->GetEntriesFast();
777   if (nhits == 0) return;
778
779   Int_t tracks = gAlice->GetNtrack();
780   if (fPoints == 0) fPoints = new TObjArray(tracks);
781
782   AliTRDhit *ahit;
783   
784   Int_t    *ntrkE = new Int_t[tracks];
785   Int_t    *ntrkT = new Int_t[tracks];
786   Int_t    *limiE = new Int_t[tracks];
787   Int_t    *limiT = new Int_t[tracks];
788   Float_t **coorE = new Float_t*[tracks];
789   Float_t **coorT = new Float_t*[tracks];
790   for(Int_t i = 0; i < tracks; i++) {
791     ntrkE[i] = 0;
792     ntrkT[i] = 0;
793     coorE[i] = 0;
794     coorT[i] = 0;
795     limiE[i] = 0;
796     limiT[i] = 0;
797   }
798   
799   AliTRDpoints  *points = 0;
800   Float_t       *fp     = 0;
801   Int_t          trk;
802   Int_t          chunk  = nhits / 4 + 1;
803
804   // Loop over all the hits and store their position
805   for (Int_t hit = 0; hit < nhits; hit++) {
806
807     ahit = (AliTRDhit *) fHits->UncheckedAt(hit);
808
809     // dEdx hits
810     if (ahit->GetCharge() >= 0) {
811
812       trk = ahit->GetTrack();
813       if (ntrkE[trk] == limiE[trk]) {
814         // Initialise a new track
815         fp = new Float_t[3*(limiE[trk]+chunk)];
816         if (coorE[trk]) {
817           memcpy(fp,coorE[trk],sizeof(Float_t)*3*limiE[trk]);
818           delete [] coorE[trk];
819         }
820         limiE[trk] += chunk;
821         coorE[trk]  = fp;
822       } 
823       else {
824         fp = coorE[trk];
825       }
826       fp[3*ntrkE[trk]  ] = ahit->X();
827       fp[3*ntrkE[trk]+1] = ahit->Y();
828       fp[3*ntrkE[trk]+2] = ahit->Z();
829       ntrkE[trk]++;
830
831     }
832     // TR photon hits
833     else {
834
835       trk = ahit->GetTrack();
836       if (ntrkT[trk] == limiT[trk]) {
837         // Initialise a new track
838         fp = new Float_t[3*(limiT[trk]+chunk)];
839         if (coorT[trk]) {
840           memcpy(fp,coorT[trk],sizeof(Float_t)*3*limiT[trk]);
841           delete [] coorT[trk];
842         }
843         limiT[trk] += chunk;
844         coorT[trk]  = fp;
845       } 
846       else {
847         fp = coorT[trk];
848       }
849       fp[3*ntrkT[trk]  ] = ahit->X();
850       fp[3*ntrkT[trk]+1] = ahit->Y();
851       fp[3*ntrkT[trk]+2] = ahit->Z();
852       ntrkT[trk]++;
853
854     }
855
856   }
857
858   for (trk = 0; trk < tracks; ++trk) {
859
860     if (ntrkE[trk] || ntrkT[trk]) {
861
862       points = new AliTRDpoints();
863       points->SetDetector(this);
864       points->SetParticle(trk);
865
866       // Set the dEdx points
867       if (ntrkE[trk]) {
868         points->SetMarkerColor(GetMarkerColor());
869         points->SetMarkerSize(GetMarkerSize());
870         points->SetPolyMarker(ntrkE[trk],coorE[trk],GetMarkerStyle());
871         delete [] coorE[trk];
872         coorE[trk] = 0;
873       }
874
875       // Set the TR photon points
876       if (ntrkT[trk]) {
877         points->SetTRpoints(ntrkT[trk],coorT[trk]);
878         delete [] coorT[trk];
879         coorT[trk] = 0;
880       }
881
882       fPoints->AddAt(points,trk);
883
884     }
885
886   }
887
888   delete [] coorE;
889   delete [] coorT;
890   delete [] ntrkE;
891   delete [] ntrkT;
892   delete [] limiE;
893   delete [] limiT;
894
895 }
896
897 //_____________________________________________________________________________
898 void AliTRD::MakeBranch(Option_t* option, char *file)
899 {
900   //
901   // Create Tree branches for the TRD digits and cluster.
902   //
903
904   //Int_t  buffersize = 4000;
905   //Char_t branchname[15];
906
907   AliDetector::MakeBranch(option,file);
908
909   Int_t buffersize = 64000;
910
911   fDigitsArray = new AliTRDdataArrayI();
912   gAlice->MakeBranchInTree(gAlice->TreeD() 
913                           ,"TRDdigits", fDigitsArray->IsA()->GetName()
914                           ,&fDigitsArray,buffersize,1,file);
915
916   for (Int_t iDict = 0; iDict < AliTRDdigitsManager::NDict(); iDict++) {
917     Char_t branchname[15];
918     sprintf(branchname,"TRDdictionary%d",iDict);
919     fDictionaryArray[iDict] = new AliTRDdataArrayI();
920     gAlice->MakeBranchInTree(gAlice->TreeD() 
921                             ,branchname,fDictionaryArray[iDict]->IsA()->GetName()
922                             ,&fDictionaryArray[iDict],buffersize,1,file) ;
923   }
924
925   //Char_t *r = strstr(option,"R");
926   //sprintf(branchname,"%srecPoints",GetName());
927   //if (fRecPoints && gAlice->TreeR() && r) {
928   //  MakeBranchInTree(gAlice->TreeR(), 
929   //                  branchname, &fRecPoints,buffersize, file) ;
930   //}
931
932 }
933
934 //_____________________________________________________________________________
935 void AliTRD::ResetDigits()
936 {
937   //
938   // Resets the digits
939   //
940
941   if (gAlice->TreeD()) {
942     TBranch *branch;
943     branch = gAlice->TreeD()->GetBranch("TRDdigits");
944     if (branch) {
945       branch->Reset();
946       for (Int_t iDict = 0; iDict < AliTRDdigitsManager::NDict(); iDict++) {
947         Char_t branchname[15];
948         sprintf(branchname,"TRDdictionary%d",iDict);
949         branch = gAlice->TreeD()->GetBranch(branchname);
950         branch->Reset();
951       }
952     }
953   }
954
955 }
956
957 //_____________________________________________________________________________
958 void AliTRD::ResetRecPoints()
959 {
960   //
961   // Reset number of reconstructed points and the point array
962   //
963
964   if(fRecPoints) {
965     fNRecPoints = 0;
966     Int_t nentr = fRecPoints->GetEntriesFast();
967     for(Int_t i = 0; i < nentr; i++) delete fRecPoints->RemoveAt(i);
968   }
969
970 }
971
972 //_____________________________________________________________________________
973 void AliTRD::SetTreeAddress()
974 {
975   //
976   // Set the branch addresses for the trees.
977   //
978
979   Char_t branchname[15];
980
981   AliDetector::SetTreeAddress();
982
983   TBranch *branch;
984   TTree   *treeR = gAlice->TreeR();
985
986   if (treeR) {
987     sprintf(branchname,"%srecPoints",GetName());
988     if (fRecPoints) {
989       branch = treeR->GetBranch(branchname);
990       if (branch) {
991         branch->SetAddress(&fRecPoints);
992       }
993     }
994   }
995
996 }
997
998 //_____________________________________________________________________________
999 void AliTRD::SetGasMix(Int_t imix)
1000 {
1001   //
1002   // Defines the gas mixture (imix=0:  Xe/Isobutane imix=1: Xe/CO2)
1003   //
1004   
1005   if ((imix < 0) || (imix > 1)) {
1006     printf("Wrong input value: %d\n",imix);
1007     printf("Use standard setting\n");
1008     fGasMix = 1;
1009     return;
1010   }
1011
1012   fGasMix = imix;
1013
1014 }
1015
1016 //_____________________________________________________________________________
1017 void AliTRD::SetPHOShole()
1018 {
1019   //
1020   // Selects a geometry with a hole in front of the PHOS
1021   //
1022
1023   fGeometry->SetPHOShole();
1024
1025 }
1026
1027 //_____________________________________________________________________________
1028 void AliTRD::SetRICHhole()
1029 {
1030   //
1031   // Selects a geometry with a hole in front of the RICH
1032   //
1033
1034   fGeometry->SetRICHhole();
1035
1036 }
1037
1038 //_____________________________________________________________________________
1039 AliTRD &AliTRD::operator=(const AliTRD &trd)
1040 {
1041   //
1042   // Assignment operator
1043   //
1044
1045   if (this != &trd) ((AliTRD &) trd).Copy(*this);
1046   return *this;
1047
1048 }