bae9e18b5daad75f03e8f896d07a83db6aa1c8a5
[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 /* $Id$ */
17
18 ///////////////////////////////////////////////////////////////////////////////
19 //                                                                           //
20 //  Transition Radiation Detector                                            //
21 //  This class contains the basic functions for the Transition Radiation     //
22 //  Detector.                                                                //
23 //                                                                           //
24 ///////////////////////////////////////////////////////////////////////////////
25
26 #include <stdlib.h>
27 #include <Riostream.h>
28
29 #include <TFile.h>
30 #include <TGeometry.h>
31 #include <TLorentzVector.h>
32 #include <TMath.h>
33 #include <TNode.h>
34 #include <TPGON.h> 
35 #include <TParticle.h>
36 #include <TROOT.h>
37 #include <TTree.h>
38 #include <TVirtualMC.h>
39  
40 #include "AliConst.h"
41 #include "AliDigit.h"
42 #include "AliLoader.h"
43 #include "AliLog.h"
44 #include "AliMC.h"
45 #include "AliMagF.h"
46 #include "AliRun.h"
47 #include "AliTRD.h"
48 #include "AliTRDdigit.h"
49 #include "AliTRDdigitizer.h"
50 #include "AliTRDdigitsManager.h"
51 #include "AliTRDgeometry.h"
52 #include "AliTRDhit.h"
53 #include "AliTRDpoints.h"
54 #include "AliTRDrawData.h"
55 #include "AliTrackReference.h"
56
57 #include "AliTRDSimParam.h"
58 #include "AliTRDRecParam.h"
59 #include "AliTRDCommonParam.h"
60 #include "AliTRDcalibDB.h"
61
62 ClassImp(AliTRD)
63  
64 //_____________________________________________________________________________
65 AliTRD::AliTRD()
66 {
67   //
68   // Default constructor
69   //
70
71   fIshunt        = 0;
72   fHits          = 0;
73   fDigits        = 0;
74
75   fGeometry      = 0;
76
77   fGasDensity    = 0;
78   fFoilDensity   = 0;
79
80   fDrawTR        = 0;
81   fDisplayType   = 0;
82  
83 }
84  
85 //_____________________________________________________________________________
86 AliTRD::AliTRD(const char *name, const char *title)
87        : AliDetector(name,title)
88 {
89   //
90   // Standard constructor for the TRD
91   //
92
93   // Check that FRAME is there otherwise we have no place where to
94   // put TRD
95   AliModule* frame = gAlice->GetModule("FRAME");
96   if (!frame) {
97     Error("Ctor","TRD needs FRAME to be present\n");
98     exit(1);
99   } 
100
101   // Define the TRD geometry
102   if ((frame->IsVersion() == 0) ||
103       (frame->IsVersion() == 1)) {
104     fGeometry = new AliTRDgeometry();
105   }
106   else {
107     Error("Ctor","Could not find valid FRAME version\n");
108     exit(1);
109   }
110
111   // Save the geometry
112   TDirectory* saveDir = gDirectory;
113   gAlice->GetRunLoader()->CdGAFile();
114   fGeometry->Write("TRDgeometry");
115   saveDir->cd();
116
117   // Allocate the hit array
118   fHits          = new TClonesArray("AliTRDhit"     ,405);
119   gAlice->GetMCApp()->AddHitList(fHits);
120
121   // Allocate the digits array
122   fDigits        = 0;
123
124   fIshunt        = 0;
125
126   fGasDensity    = 0;
127   fFoilDensity   = 0;
128
129   fDrawTR        = 0;
130   fDisplayType   = 0;
131
132   SetMarkerColor(kWhite);   
133
134 }
135
136 //_____________________________________________________________________________
137 AliTRD::AliTRD(const AliTRD &trd):AliDetector(trd)
138 {
139   //
140   // Copy constructor
141   //
142
143   ((AliTRD &) trd).Copy(*this);
144
145 }
146
147 //_____________________________________________________________________________
148 AliTRD::~AliTRD()
149 {
150   //
151   // TRD destructor
152   //
153
154   fIshunt = 0;
155
156   if (fGeometry) {
157     delete fGeometry;
158     fGeometry  = 0;
159   }
160   if (fHits) {
161     delete fHits;
162     fHits      = 0;
163   }
164
165 }
166
167 //_____________________________________________________________________________
168 void AliTRD::Hits2Digits()
169 {
170   //
171   // Create digits
172   //
173
174   AliTRDdigitizer digitizer("TRDdigitizer","TRD digitizer class");
175   AliLog::SetClassDebugLevel("TRDdigitizer",AliDebugLevel());
176   
177   // Initialization
178   digitizer.InitDetector();
179     
180   if (!fLoader->TreeH()) fLoader->LoadHits("read");
181   fLoader->LoadDigits("recreate");
182   AliRunLoader* runLoader = fLoader->GetRunLoader(); 
183
184   for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
185     digitizer.Open(runLoader->GetFileName().Data(), iEvent);
186     digitizer.MakeDigits();
187     digitizer.WriteDigits();
188   }
189
190   fLoader->UnloadHits();
191   fLoader->UnloadDigits();
192
193 }
194
195 //_____________________________________________________________________________
196 void AliTRD::Hits2SDigits()
197 {
198   //
199   // Create summable digits
200   //
201
202   AliTRDdigitizer digitizer("TRDdigitizer","TRD digitizer class");
203   // For the summable digits
204   digitizer.SetSDigits(kTRUE);
205   AliLog::SetClassDebugLevel("TRDdigitizer",AliDebugLevel());
206
207   // Initialization
208   digitizer.InitDetector();
209     
210   if (!fLoader->TreeH()) fLoader->LoadHits("read");
211   fLoader->LoadSDigits("recreate");
212   AliRunLoader* runLoader = fLoader->GetRunLoader(); 
213
214   for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
215     digitizer.Open(runLoader->GetFileName().Data(), iEvent);
216     digitizer.MakeDigits();
217     digitizer.WriteDigits();
218   }
219
220   fLoader->UnloadHits();
221   fLoader->UnloadSDigits();
222   
223 }
224
225 //_____________________________________________________________________________
226 AliDigitizer* AliTRD::CreateDigitizer(AliRunDigitizer* manager) const
227 {
228   //
229   // Creates a new digitizer object
230   //
231
232   return new AliTRDdigitizer(manager);
233
234 }
235
236 //_____________________________________________________________________________
237 void AliTRD::SDigits2Digits()
238 {
239   //
240   // Create final digits from summable digits
241   //
242
243   // Create the TRD digitizer
244   AliTRDdigitizer digitizer("TRDdigitizer","TRD digitizer class");  
245   AliLog::SetClassDebugLevel("TRDdigitizer",AliDebugLevel());
246
247   // Set the parameter
248   digitizer.SetEvent(gAlice->GetEvNumber());
249
250   // Initialization
251   digitizer.InitDetector();
252
253   // Read the s-digits via digits manager
254   AliTRDdigitsManager sdigitsManager;
255  
256   AliLog::SetClassDebugLevel("TRDdigitisManager",AliDebugLevel());
257   sdigitsManager.SetSDigits(kTRUE);
258   sdigitsManager.CreateArrays();
259   
260   if (!fLoader->TreeS()) 
261     if (fLoader->LoadSDigits("read"))
262      {
263        Error("SDigits2Digits","Error while reading SDigits for event %d",gAlice->GetEvNumber());
264        return;
265      }
266   if (!fLoader->TreeS()) return;
267   
268   sdigitsManager.ReadDigits(fLoader->TreeS());
269
270   // Add the s-digits to the input list 
271   digitizer.AddSDigitsManager(&sdigitsManager);
272
273   // Convert the s-digits to normal digits
274   digitizer.SDigits2Digits();
275
276   // Store the digits
277   if (!fLoader->TreeD()) fLoader->MakeTree("D");
278   if (digitizer.MakeBranch(fLoader->TreeD())){
279     digitizer.WriteDigits();
280   }
281
282 }
283
284 //_____________________________________________________________________________
285 void AliTRD::Digits2Raw() 
286 {
287   //
288   // convert digits of the current event to raw data
289   //
290
291   fLoader->LoadDigits();
292   TTree* digits = fLoader->TreeD();
293   if (!digits) {
294     Error("Digits2Raw", "no digits tree");
295     return;
296   }
297
298   AliTRDrawData rawWriter;
299   //  rawWriter.SetDebug(2);
300   if (!rawWriter.Digits2Raw(digits)) {
301     Error("AliTRD::Digits2Raw","The raw writer could not load the digits tree");
302   }
303
304   fLoader->UnloadDigits();
305
306 }
307
308 //_____________________________________________________________________________
309 void AliTRD::AddHit(Int_t track, Int_t det, Float_t *hits, Int_t q
310                   , Bool_t inDrift)
311 {
312   //
313   // Add a hit for the TRD
314   // 
315
316   TClonesArray &lhits = *fHits;
317   AliTRDhit *hit = new(lhits[fNhits++]) AliTRDhit(fIshunt,track,det,hits,q);
318   if (inDrift) {
319     hit->SetDrift();
320   }
321   else {
322     hit->SetAmplification();
323   }
324   if (q < 0) {
325     hit->SetTRphoton();
326   }
327
328 }
329
330 //_____________________________________________________________________________
331 void AliTRD::BuildGeometry()
332 {
333   //
334   // Create the ROOT TNode geometry for the TRD
335   //
336
337   TNode *node, *top;
338   TPGON *pgon;
339
340   Float_t rmin, rmax;
341   Float_t zmax1, zmax2;
342
343   Int_t   iPlan;
344  
345   const Int_t kColorTRD = 46;
346   
347   // Find the top node alice
348   top = gAlice->GetGeometry()->GetNode("alice");
349   
350   if      (fDisplayType == 0) {
351
352     pgon = new TPGON("S_TRD","TRD","void",0,360,AliTRDgeometry::Nsect(),4);
353     rmin = AliTRDgeometry::Rmin();
354     rmax = AliTRDgeometry::Rmax();
355     pgon->DefineSection(0,-AliTRDgeometry::Zmax1(),rmax,rmax);
356     pgon->DefineSection(1,-AliTRDgeometry::Zmax2(),rmin,rmax);
357     pgon->DefineSection(2, AliTRDgeometry::Zmax2(),rmin,rmax);
358     pgon->DefineSection(3, AliTRDgeometry::Zmax1(),rmax,rmax);
359     top->cd();
360     node = new TNode("TRD","TRD","S_TRD",0,0,0,"");
361     node->SetLineColor(kColorTRD);
362     fNodes->Add(node);
363
364   }
365   else if (fDisplayType == 1) {
366
367     Char_t name[7];
368
369     Float_t slope = (AliTRDgeometry::Zmax1() - AliTRDgeometry::Zmax2())
370                   / (AliTRDgeometry::Rmax()  - AliTRDgeometry::Rmin());
371
372     rmin  = AliTRDgeometry::Rmin() + AliTRDgeometry::CraHght();
373     rmax  = rmin                   + AliTRDgeometry::CdrHght();
374
375     Float_t thickness = rmin - AliTRDgeometry::Rmin();
376     zmax2 = AliTRDgeometry::Zmax2() + slope * thickness;
377     zmax1 = zmax2 + slope * AliTRDgeometry::DrThick();
378
379     for (iPlan = 0; iPlan < AliTRDgeometry::Nplan(); iPlan++) {
380
381       sprintf(name,"S_TR1%d",iPlan);
382       pgon  = new TPGON(name,"TRD","void",0,360,AliTRDgeometry::Nsect(),4);
383       pgon->DefineSection(0,-zmax1,rmax,rmax);
384       pgon->DefineSection(1,-zmax2,rmin,rmax);
385       pgon->DefineSection(2, zmax2,rmin,rmax);
386       pgon->DefineSection(3, zmax1,rmax,rmax);
387       top->cd();
388       node = new TNode("TRD","TRD",name,0,0,0,"");
389       node->SetLineColor(kColorTRD);
390       fNodes->Add(node);
391
392       Float_t height = AliTRDgeometry::Cheight() + AliTRDgeometry::Cspace(); 
393       rmin  = rmin  + height;
394       rmax  = rmax  + height;
395       zmax1 = zmax1 + slope * height;
396       zmax2 = zmax2 + slope * height;
397
398     }
399
400     thickness += AliTRDgeometry::DrThick();
401     rmin  = AliTRDgeometry::Rmin() + thickness;
402     rmax  = rmin + AliTRDgeometry::AmThick();
403     zmax2 = AliTRDgeometry::Zmax2() + slope * thickness;
404     zmax1 = zmax2 + slope * AliTRDgeometry::AmThick();
405
406     for (iPlan = 0; iPlan < AliTRDgeometry::Nplan(); iPlan++) {
407
408       sprintf(name,"S_TR2%d",iPlan);
409       pgon  = new TPGON(name,"TRD","void",0,360,AliTRDgeometry::Nsect(),4);
410       pgon->DefineSection(0,-zmax1,rmax,rmax);
411       pgon->DefineSection(1,-zmax2,rmin,rmax);
412       pgon->DefineSection(2, zmax2,rmin,rmax);
413       pgon->DefineSection(3, zmax1,rmax,rmax);
414       top->cd();
415       node = new TNode("TRD","TRD",name,0,0,0,"");
416       node->SetLineColor(kColorTRD);
417       fNodes->Add(node);
418
419       Float_t height = AliTRDgeometry::Cheight() + AliTRDgeometry::Cspace(); 
420       rmin  = rmin  + height;
421       rmax  = rmax  + height;
422       zmax1 = zmax1 + slope * height;
423       zmax2 = zmax2 + slope * height;
424
425     }
426
427   }
428
429 }
430  
431 //_____________________________________________________________________________
432 void AliTRD::Copy(TObject &trd) const
433 {
434   //
435   // Copy function
436   //
437
438   ((AliTRD &) trd).fGeometry    = fGeometry;       
439   ((AliTRD &) trd).fGasDensity  = fGasDensity;
440   ((AliTRD &) trd).fFoilDensity = fFoilDensity;
441   ((AliTRD &) trd).fDrawTR      = fDrawTR;
442   ((AliTRD &) trd).fDisplayType = fDisplayType;
443
444   //AliDetector::Copy(trd);
445
446 }
447
448 //_____________________________________________________________________________
449 void AliTRD::CreateGeometry()
450 {
451   //
452   // Creates the volumes for the TRD chambers
453   //
454
455   // Check that FRAME is there otherwise we have no place where to put the TRD
456   AliModule* frame = gAlice->GetModule("FRAME");
457   if (!frame) {
458     AliFatal("The TRD needs the FRAME to be defined first");
459   }
460
461   fGeometry->CreateGeometry(fIdtmed->GetArray() - 1299);
462
463 }
464  
465 //_____________________________________________________________________________
466 void AliTRD::CreateMaterials()
467 {
468   //
469   // Create the materials for the TRD
470   //
471
472   Int_t   isxfld = gAlice->Field()->Integ();
473   Float_t sxmgmx = gAlice->Field()->Max();
474   
475   // For polyethilene (CH2) 
476   Float_t ape[2] = { 12.011 ,  1.0079 };
477   Float_t zpe[2] = {  6.0   ,  1.0    };
478   Float_t wpe[2] = {  1.0   ,  2.0    };
479   Float_t dpe    = 0.95;
480
481   // For mylar (C5H4O2) 
482   Float_t amy[3] = { 12.011 ,  1.0079, 15.9994 };
483   Float_t zmy[3] = {  6.0   ,  1.0   ,  8.0    };
484   Float_t wmy[3] = {  5.0   ,  4.0   ,  2.0    };
485   Float_t dmy    = 1.39;
486
487   // For CO2 
488   Float_t aco[2] = { 12.011 , 15.9994 };
489   Float_t zco[2] = {  6.0   ,  8.0    };
490   Float_t wco[2] = {  1.0   ,  2.0    };
491   Float_t dco    = 0.00186;
492
493   // For water
494   Float_t awa[2] = {  1.0079, 15.9994 };
495   Float_t zwa[2] = {  1.0   ,  8.0    };
496   Float_t wwa[2] = {  2.0   ,  1.0    };
497   Float_t dwa    = 1.0;
498
499   // For isobutane (C4H10)
500   Float_t ais[2] = { 12.011 ,  1.0079 };
501   Float_t zis[2] = {  6.0   ,  1.0    };
502   Float_t wis[2] = {  4.0   , 10.0    };
503   Float_t dis    = 0.00267;
504
505   // For plexiglas (C5H8O2)
506   Float_t apg[3] = { 12.011 ,  1.0079, 15.9994 };
507   Float_t zpg[3] = {  6.0   ,  1.0   ,  8.0    };
508   Float_t wpg[3] = {  5.0   ,  8.0   ,  2.0    };
509   Float_t dpg    = 1.18; 
510   
511   // For epoxy (C18H19O3)
512   Float_t aEpoxy[3] = { 15.9994,  1.0079, 12.011  }; 
513   Float_t zEpoxy[3] = {  8.0   ,  1.0   ,  6.0    }; 
514   Float_t wEpoxy[3] = {  3.0   , 19.0   , 18.0    }; 
515   Float_t dEpoxy    = 1.8 ; 
516
517   // For air  
518   Float_t aAir[4]   = { 12.011   , 14.0     , 15.9994  , 36.0      };
519   Float_t zAir[4]   = {  6.0     ,  7.0     ,  8.0     , 18.0      };
520   Float_t wAir[4]   = {  0.000124,  0.755267,  0.231781,  0.012827 };
521   Float_t dAir      = 1.20479E-3;
522
523   // For G10
524   Float_t aG10[4]   = {  1.0079  , 12.011   , 15.9994  , 28.086    };
525   Float_t zG10[4]   = {  1.0     ,  6.0     ,  8.0     , 14.0      };
526   Float_t wG10[4]   = {  0.15201 ,  0.10641 ,  0.49444 ,  0.24714  };
527   Float_t dG10      = 1.7;
528
529   // For Xe/CO2-gas-mixture 
530   Float_t aXeCO2[3] = { 131.29   ,  12.0107 ,  15.9994  };
531   Float_t zXeCO2[3] = {  54.0    ,   6.0    ,   8.0     };
532   Float_t wXeCO2[3] = {   0.85   ,   0.0375 ,   0.1125  };
533   // Xe-content of the Xe/CO2-mixture (85% / 15%) 
534   Float_t fxc       = 0.85;
535   Float_t dxe       = 0.00549;
536   Float_t dgm       = fxc * dxe + (1.0 - fxc) * dco;
537   
538   // General tracking parameter
539   Float_t tmaxfd = -10.;
540   Float_t stemax = -1e10;
541   Float_t deemax = -0.1;
542   Float_t epsil  =  1e-4;
543   Float_t stmin  = -0.001;
544   
545   //////////////////////////////////////////////////////////////////////////
546   //     Define Materials 
547   //////////////////////////////////////////////////////////////////////////
548
549   AliMaterial( 1, "Al"   ,  26.98, 13.0, 2.7     ,     8.9 ,    37.2);
550   AliMaterial( 4, "Xe"   , 131.29, 54.0, dxe     ,  1546.16,     0.0);
551   AliMaterial( 5, "Cu"   ,  63.54, 29.0, 8.96    ,     1.43,    14.8);
552   AliMaterial( 6, "C"    ,  12.01,  6.0, 2.265   ,    18.8 ,    74.4);
553   AliMaterial(15, "Sn"   , 118.71, 50.0, 7.31    ,     1.21,    14.8);
554   AliMaterial(16, "Si"   ,  28.09, 14.0, 2.33    ,     9.36,    37.2);
555
556   // Mixtures 
557   AliMixture(2, "Air"         , aAir,   zAir,   dAir,    4, wAir  );
558   AliMixture(3, "Polyethilene", ape,    zpe,    dpe,    -2, wpe   );
559   AliMixture(7, "Mylar",        amy,    zmy,    dmy,    -3, wmy   );
560   AliMixture(8, "CO2",          aco,    zco,    dco,    -2, wco   );
561   AliMixture(9, "Isobutane",    ais,    zis,    dis,    -2, wis   );
562   AliMixture(10,"Gas mixture",  aXeCO2, zXeCO2, dgm,     3, wXeCO2);
563   AliMixture(12,"G10",          aG10,   zG10,   dG10,    4, wG10  );
564   AliMixture(13,"Water",        awa,    zwa,    dwa,    -2, wwa   );
565   AliMixture(14,"Plexiglas",    apg,    zpg,    dpg,    -3, wpg   );
566   AliMixture(17,"Epoxy",        aEpoxy, zEpoxy, dEpoxy, -3, wEpoxy);
567
568   //////////////////////////////////////////////////////////////////////////
569   //     Tracking Media Parameters 
570   //////////////////////////////////////////////////////////////////////////
571
572   // Al Frame 
573   AliMedium(1, "Al Frame",   1, 0, isxfld, sxmgmx
574                 , tmaxfd, stemax, deemax, epsil, stmin);
575   // Air 
576   AliMedium(2, "Air",        2, 0, isxfld, sxmgmx
577                 , tmaxfd, stemax, deemax, epsil, stmin);
578   // Polyethilene 
579   AliMedium(3, "Radiator",   3, 0, isxfld, sxmgmx
580                 , tmaxfd, stemax, deemax, epsil, stmin);
581   // Xe 
582   AliMedium(4, "Xe",         4, 1, isxfld, sxmgmx
583                 , tmaxfd, stemax, deemax, epsil, stmin);
584   // Cu pads 
585   AliMedium(5, "Padplane",   5, 1, isxfld, sxmgmx
586                 , tmaxfd, stemax, deemax, epsil, stmin);
587   // Fee + cables 
588   AliMedium(6, "Readout",    1, 0, isxfld, sxmgmx
589                 , tmaxfd, stemax, deemax, epsil, stmin);
590   // C frame 
591   AliMedium(7, "C Frame",    6, 0, isxfld, sxmgmx
592                 , tmaxfd, stemax, deemax, epsil, stmin);
593   // Mylar foils 
594   AliMedium(8, "Mylar",      7, 0, isxfld, sxmgmx
595                 , tmaxfd, stemax, deemax, epsil, stmin);
596   // Gas-mixture (Xe/CO2) 
597   AliMedium(9, "Gas-mix",   10, 1, isxfld, sxmgmx
598                 , tmaxfd, stemax, deemax, epsil, stmin);
599   // Nomex-honeycomb (use carbon for the time being) 
600   AliMedium(10, "Nomex",      6, 0, isxfld, sxmgmx
601                 , tmaxfd, stemax, deemax, epsil, stmin);
602   // Kapton foils (use Mylar for the time being) 
603   AliMedium(11, "Kapton",     7, 0, isxfld, sxmgmx
604                 , tmaxfd, stemax, deemax, epsil, stmin);
605   // Gas-filling of the radiator 
606   AliMedium(12, "CO2",        8, 0, isxfld, sxmgmx
607                 , tmaxfd, stemax, deemax, epsil, stmin);
608   // G10-plates
609   AliMedium(13, "G10-plates",12, 0, isxfld, sxmgmx
610                 , tmaxfd, stemax, deemax, epsil, stmin);
611   // Cooling water
612   AliMedium(14, "Water",     13, 0, isxfld, sxmgmx
613                 , tmaxfd, stemax, deemax, epsil, stmin);
614   // Rohacell (plexiglas) for the radiator
615   AliMedium(15, "Rohacell",  14, 0, isxfld, sxmgmx
616                 , tmaxfd, stemax, deemax, epsil, stmin);
617   // Al layer in MCMs
618   AliMedium(16, "MCM-Al"  ,   1, 0, isxfld, sxmgmx
619                 , tmaxfd, stemax, deemax, epsil, stmin);
620   // Sn layer in MCMs
621   AliMedium(17, "MCM-Sn"  ,  15, 0, isxfld, sxmgmx
622                 , tmaxfd, stemax, deemax, epsil, stmin);
623   // Cu layer in MCMs
624   AliMedium(18, "MCM-Cu"  ,   5, 0, isxfld, sxmgmx
625                 , tmaxfd, stemax, deemax, epsil, stmin);
626   // G10 layer in MCMs
627   AliMedium(19, "MCM-G10" ,  12, 0, isxfld, sxmgmx
628                 , tmaxfd, stemax, deemax, epsil, stmin);
629   // Si in readout chips
630   AliMedium(20, "Chip-Si" ,  16, 0, isxfld, sxmgmx
631                 , tmaxfd, stemax, deemax, epsil, stmin);
632   // Epoxy in readout chips
633   AliMedium(21, "Chip-Ep" ,  17, 0, isxfld, sxmgmx
634                 , tmaxfd, stemax, deemax, epsil, stmin);
635   // PE in connectors
636   AliMedium(22, "Conn-PE" ,   3, 0, isxfld, sxmgmx
637                 , tmaxfd, stemax, deemax, epsil, stmin);
638   // Cu in connectors
639   AliMedium(23, "Chip-Cu" ,   5, 0, isxfld, sxmgmx
640                 , tmaxfd, stemax, deemax, epsil, stmin);
641   // Al of cooling pipes
642   AliMedium(24, "Cooling" ,   1, 0, isxfld, sxmgmx
643                 , tmaxfd, stemax, deemax, epsil, stmin);
644   // Cu in services
645   AliMedium(25, "Serv-Cu" ,   5, 0, isxfld, sxmgmx
646                 , tmaxfd, stemax, deemax, epsil, stmin);
647
648   // Save the density values for the TRD absorbtion
649   fFoilDensity = dmy;
650   fGasDensity  = dgm;
651
652 }
653
654 //_____________________________________________________________________________
655 void AliTRD::DrawModule() const
656 {
657   //
658   // Draw a shaded view of the Transition Radiation Detector version 0
659   //
660
661   // Set everything unseen
662   gMC->Gsatt("*"   ,"SEEN",-1);
663   
664   // Set ALIC mother transparent
665   gMC->Gsatt("ALIC","SEEN", 0);
666   
667   // Set the volumes visible
668   if (fGeometry->IsVersion() == 0) {
669     gMC->Gsatt("B071","SEEN", 0);
670     gMC->Gsatt("B074","SEEN", 0);
671     gMC->Gsatt("B075","SEEN", 0);
672     gMC->Gsatt("B077","SEEN", 0);
673     gMC->Gsatt("BTR1","SEEN", 0);
674     gMC->Gsatt("BTR2","SEEN", 0);
675     gMC->Gsatt("BTR3","SEEN", 0);
676     gMC->Gsatt("UTR1","SEEN", 0);
677     gMC->Gsatt("UTR2","SEEN", 0);
678     gMC->Gsatt("UTR3","SEEN", 0);
679   }
680   else {
681     gMC->Gsatt("B071","SEEN", 0);
682     gMC->Gsatt("B074","SEEN", 0);
683     gMC->Gsatt("B075","SEEN", 0);
684     gMC->Gsatt("B077","SEEN", 0);
685     gMC->Gsatt("BTR1","SEEN", 0);
686     gMC->Gsatt("BTR2","SEEN", 0);
687     gMC->Gsatt("BTR3","SEEN", 0);
688     gMC->Gsatt("UTR1","SEEN", 0);
689   }
690   
691   gMC->Gdopt("hide", "on");
692   gMC->Gdopt("shad", "on");
693   gMC->Gsatt("*", "fill", 7);
694   gMC->SetClipBox(".");
695   gMC->SetClipBox("*", 0, 2000, -2000, 2000, -2000, 2000);
696   gMC->DefaultRange();
697   gMC->Gdraw("alic", 40, 30, 0, 12, 9.4, .021, .021);
698   gMC->Gdhead(1111, "Transition Radiation Detector");
699   gMC->Gdman(18, 4, "MAN");
700
701 }
702
703 //_____________________________________________________________________________
704 Int_t AliTRD::DistancetoPrimitive(Int_t , Int_t )
705 {
706   //
707   // Distance between the mouse and the TRD detector on the screen
708   // Dummy routine
709   
710   return 9999;
711
712 }
713  
714 //_____________________________________________________________________________
715 void AliTRD::Init()
716 {
717   //
718   // Initialize the TRD detector after the geometry has been created
719   //
720
721   AliDebug(1,"++++++++++++++++++++++++++++++++++++++++++++++");
722
723   if (fGeometry->IsVersion() != 1) {
724     AliError("Not a valid geometry");
725   }
726   
727 }
728
729 //_____________________________________________________________________________
730 void AliTRD::LoadPoints(Int_t )
731 {
732   //
733   // Store x, y, z of all hits in memory.
734   // Hit originating from TR photons are given a different color
735   //
736
737   if (fHits == 0) return;
738
739   Int_t nhits = fHits->GetEntriesFast();
740   if (nhits == 0) return;
741
742   Int_t tracks = gAlice->GetMCApp()->GetNtrack();
743   if (fPoints == 0) fPoints = new TObjArray(tracks);
744
745   AliTRDhit *ahit;
746   
747   Int_t    *ntrkE = new Int_t[tracks];
748   Int_t    *ntrkT = new Int_t[tracks];
749   Int_t    *limiE = new Int_t[tracks];
750   Int_t    *limiT = new Int_t[tracks];
751   Float_t **coorE = new Float_t*[tracks];
752   Float_t **coorT = new Float_t*[tracks];
753   for(Int_t i = 0; i < tracks; i++) {
754     ntrkE[i] = 0;
755     ntrkT[i] = 0;
756     coorE[i] = 0;
757     coorT[i] = 0;
758     limiE[i] = 0;
759     limiT[i] = 0;
760   }
761   
762   AliTRDpoints *points = 0;
763   Float_t      *fp     = 0;
764   Int_t         trk;
765   Int_t         chunk  = nhits / 4 + 1;
766
767   // Loop over all the hits and store their position
768   ahit = (AliTRDhit *) FirstHit(-1);
769   while (ahit) {
770
771     // dEdx hits
772     if (ahit->GetCharge() >= 0) {
773
774       trk = ahit->GetTrack();
775       if (ntrkE[trk] == limiE[trk]) {
776         // Initialise a new track
777         fp = new Float_t[3*(limiE[trk]+chunk)];
778         if (coorE[trk]) {
779           memcpy(fp,coorE[trk],sizeof(Float_t)*3*limiE[trk]);
780           delete [] coorE[trk];
781         }
782         limiE[trk] += chunk;
783         coorE[trk]  = fp;
784       } 
785       else {
786         fp = coorE[trk];
787       }
788       fp[3*ntrkE[trk]  ] = ahit->X();
789       fp[3*ntrkE[trk]+1] = ahit->Y();
790       fp[3*ntrkE[trk]+2] = ahit->Z();
791       ntrkE[trk]++;
792
793     }
794     // TR photon hits
795     else if ((ahit->GetCharge() < 0) && (fDrawTR)) {
796
797       trk = ahit->GetTrack();
798       if (ntrkT[trk] == limiT[trk]) {
799         // Initialise a new track
800         fp = new Float_t[3*(limiT[trk]+chunk)];
801         if (coorT[trk]) {
802           memcpy(fp,coorT[trk],sizeof(Float_t)*3*limiT[trk]);
803           delete [] coorT[trk];
804         }
805         limiT[trk] += chunk;
806         coorT[trk]  = fp;
807       } 
808       else {
809         fp = coorT[trk];
810       }
811       fp[3*ntrkT[trk]  ] = ahit->X();
812       fp[3*ntrkT[trk]+1] = ahit->Y();
813       fp[3*ntrkT[trk]+2] = ahit->Z();
814       ntrkT[trk]++;
815
816     }
817
818     ahit = (AliTRDhit *) NextHit();
819
820   }
821
822   for (trk = 0; trk < tracks; ++trk) {
823
824     if (ntrkE[trk] || ntrkT[trk]) {
825
826       points = new AliTRDpoints();
827       points->SetDetector(this);
828       points->SetParticle(trk);
829
830       // Set the dEdx points
831       if (ntrkE[trk]) {
832         points->SetMarkerColor(GetMarkerColor());
833         points->SetMarkerSize(GetMarkerSize());
834         points->SetPolyMarker(ntrkE[trk],coorE[trk],GetMarkerStyle());
835         delete [] coorE[trk];
836         coorE[trk] = 0;
837       }
838
839       // Set the TR photon points
840       if (ntrkT[trk]) {
841         points->SetTRpoints(ntrkT[trk],coorT[trk]);
842         delete [] coorT[trk];
843         coorT[trk] = 0;
844       }
845
846       fPoints->AddAt(points,trk);
847
848     }
849
850   }
851
852   delete [] coorE;
853   delete [] coorT;
854   delete [] ntrkE;
855   delete [] ntrkT;
856   delete [] limiE;
857   delete [] limiT;
858
859 }
860
861 //_____________________________________________________________________________
862 void AliTRD::MakeBranch(Option_t* option)
863 {
864   //
865   // Create Tree branches for the TRD digits.
866   //
867
868   Int_t  buffersize = 4000;
869   Char_t branchname[15];
870   sprintf(branchname,"%s",GetName());
871
872   const char *cD = strstr(option,"D");
873
874   AliDetector::MakeBranch(option);
875
876   if (fDigits && gAlice->TreeD() && cD) {
877     MakeBranchInTree(gAlice->TreeD(),branchname,&fDigits,buffersize,0);
878   }     
879
880 }
881
882 //_____________________________________________________________________________
883 void AliTRD::ResetDigits()
884 {
885   //
886   // Reset number of digits and the digits array for this detector
887   //
888
889   fNdigits = 0;
890   if (fDigits) fDigits->Clear();
891
892 }
893
894 //_____________________________________________________________________________
895 void AliTRD::SetTreeAddress()
896 {
897   //
898   // Set the branch addresses for the trees.
899   //
900
901   if ( fLoader->TreeH() && (fHits == 0x0)) {
902     fHits = new TClonesArray("AliTRDhit",405);
903   }
904   AliDetector::SetTreeAddress();
905
906 }
907
908 //_____________________________________________________________________________
909 AliTRD &AliTRD::operator=(const AliTRD &trd)
910 {
911   //
912   // Assignment operator
913   //
914
915   if (this != &trd) ((AliTRD &) trd).Copy(*this);
916   return *this;
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253