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 "AliTRDgeometryFull.h"
  52 #include "AliTRDhit.h"
  53 #include "AliTRDpoints.h"
  54 #include "AliTRDrawData.h"
  55 #include "AliTrackReference.h"
  56
  57 ClassImp(AliTRD)
  58
  59 //_____________________________________________________________________________
  60 AliTRD::AliTRD()
  61 {
  62   //
  63   // Default constructor
  64   //
  65
  66   fIshunt        = 0;
  67   fHits          = 0;
  68   fDigits        = 0;
  69
  70   fGeometry      = 0;
  71
  72   fGasDensity    = 0;
  73   fFoilDensity   = 0;
  74
  75   fDrawTR        = 0;
  76   fDisplayType   = 0;
  77
  78 }
  79
  80 //_____________________________________________________________________________
  81 AliTRD::AliTRD(const char *name, const char *title)
  82        : AliDetector(name,title)
  83 {
  84   //
  85   // Standard constructor for the TRD
  86   //
  87
  88   // Check that FRAME is there otherwise we have no place where to
  89   // put TRD
  90   AliModule* frame = gAlice->GetModule("FRAME");
  91   if (!frame) {
  92     Error("Ctor","TRD needs FRAME to be present\n");
  93     exit(1);
  94   }
  95
  96   // Define the TRD geometry
  97   if ((frame->IsVersion() == 0) ||
  98       (frame->IsVersion() == 1)) {
  99     fGeometry = new AliTRDgeometryFull();
 100   }
 101   else {
 102     Error("Ctor","Could not find valid FRAME version\n");
 103     exit(1);
 104   }
 105
 106   // Save the geometry
 107   TDirectory* saveDir = gDirectory;
 108   gAlice->GetRunLoader()->CdGAFile();
 109   fGeometry->Write("TRDgeometry");
 110   saveDir->cd();
 111
 112   // Allocate the hit array
 113   fHits          = new TClonesArray("AliTRDhit"     ,405);
 114   gAlice->GetMCApp()->AddHitList(fHits);
 115
 116   // Allocate the digits array
 117   fDigits        = 0;
 118
 119   fIshunt        = 0;
 120
 121   fGasDensity    = 0;
 122   fFoilDensity   = 0;
 123
 124   fDrawTR        = 0;
 125   fDisplayType   = 0;
 126
 127   SetMarkerColor(kWhite);
 128
 129 }
 130
 131 //_____________________________________________________________________________
 132 AliTRD::AliTRD(const AliTRD &trd):AliDetector(trd)
 133 {
 134   //
 135   // Copy constructor
 136   //
 137
 138   ((AliTRD &) trd).Copy(*this);
 139
 140 }
 141
 142 //_____________________________________________________________________________
 143 AliTRD::~AliTRD()
 144 {
 145   //
 146   // TRD destructor
 147   //
 148
 149   fIshunt = 0;
 150
 151   if (fGeometry) {
 152     delete fGeometry;
 153     fGeometry  = 0;
 154   }
 155   if (fHits) {
 156     delete fHits;
 157     fHits      = 0;
 158   }
 159
 160 }
 161
 162 //_____________________________________________________________________________
 163 void AliTRD::Hits2Digits()
 164 {
 165   //
 166   // Create digits
 167   //
 168   AliTRDdigitizer digitizer("TRDdigitizer","TRD digitizer class");
 169   AliLog::SetClassDebugLevel("TRDdigitizer",AliDebugLevel());
 170
 171   // Initialization
 172   digitizer.InitDetector();
 173
 174   if (!fLoader->TreeH()) fLoader->LoadHits("read");
 175   fLoader->LoadDigits("recreate");
 176   AliRunLoader* runLoader = fLoader->GetRunLoader();
 177
 178   for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
 179     digitizer.Open(runLoader->GetFileName().Data(), iEvent);
 180     digitizer.MakeDigits();
 181     digitizer.WriteDigits();
 182   }
 183
 184   fLoader->UnloadHits();
 185   fLoader->UnloadDigits();
 186
 187 }
 188
 189 //_____________________________________________________________________________
 190 void AliTRD::Hits2SDigits()
 191 {
 192   //
 193   // Create summable digits
 194   //
 195
 196   AliTRDdigitizer digitizer("TRDdigitizer","TRD digitizer class");
 197   // For the summable digits
 198   digitizer.SetSDigits(kTRUE);
 199   AliLog::SetClassDebugLevel("TRDdigitizer",AliDebugLevel());
 200
 201   // Initialization
 202   digitizer.InitDetector();
 203
 204   if (!fLoader->TreeH()) fLoader->LoadHits("read");
 205   fLoader->LoadSDigits("recreate");
 206   AliRunLoader* runLoader = fLoader->GetRunLoader();
 207
 208   for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
 209     digitizer.Open(runLoader->GetFileName().Data(), iEvent);
 210     digitizer.MakeDigits();
 211     digitizer.WriteDigits();
 212   }
 213
 214   fLoader->UnloadHits();
 215   fLoader->UnloadSDigits();
 216
 217 }
 218
 219 //_____________________________________________________________________________
 220 AliDigitizer* AliTRD::CreateDigitizer(AliRunDigitizer* manager) const
 221 {
 222   //
 223   // Creates a new digitizer object
 224   //
 225
 226   return new AliTRDdigitizer(manager);
 227
 228 }
 229
 230 //_____________________________________________________________________________
 231 void AliTRD::SDigits2Digits()
 232 {
 233   //
 234   // Create final digits from summable digits
 235   //
 236
 237    // Create the TRD digitizer
 238   AliTRDdigitizer digitizer("TRDdigitizer","TRD digitizer class");
 239   AliLog::SetClassDebugLevel("TRDdigitizer",AliDebugLevel());
 240
 241   // Set the parameter
 242   digitizer.SetEvent(gAlice->GetEvNumber());
 243
 244   // Initialization
 245   digitizer.InitDetector();
 246
 247   // Read the s-digits via digits manager
 248   AliTRDdigitsManager sdigitsManager;
 249
 250   AliLog::SetClassDebugLevel("TRDdigitisManager",AliDebugLevel());
 251   sdigitsManager.SetSDigits(kTRUE);
 252   sdigitsManager.CreateArrays();
 253
 254   if (!fLoader->TreeS())
 255     if (fLoader->LoadSDigits("read"))
 256      {
 257        Error("SDigits2Digits","Error while reading SDigits for event %d",gAlice->GetEvNumber());
 258        return;
 259      }
 260   if (!fLoader->TreeS()) return;
 261
 262   sdigitsManager.ReadDigits(fLoader->TreeS());
 263
 264   // Add the s-digits to the input list
 265   digitizer.AddSDigitsManager(&sdigitsManager);
 266
 267   // Convert the s-digits to normal digits
 268   digitizer.SDigits2Digits();
 269
 270   // Store the digits
 271   if (!fLoader->TreeD()) fLoader->MakeTree("D");
 272   if (digitizer.MakeBranch(fLoader->TreeD())){
 273     digitizer.WriteDigits();
 274   }
 275
 276 }
 277
 278 //_____________________________________________________________________________
 279 void AliTRD::Digits2Raw()
 280 {
 281   //
 282   // convert digits of the current event to raw data
 283   //
 284
 285   fLoader->LoadDigits();
 286   TTree* digits = fLoader->TreeD();
 287   if (!digits) {
 288     Error("Digits2Raw", "no digits tree");
 289     return;
 290   }
 291
 292   AliTRDrawData rawWriter;
 293 //  rawWriter.SetDebug(2);
 294   if (!rawWriter.Digits2Raw(digits)) {
 295     Error("AliTRD::Digits2Raw","The raw writer could not load the digits tree");
 296   }
 297
 298   fLoader->UnloadDigits();
 299
 300 }
 301
 302 //_____________________________________________________________________________
 303 void AliTRD::AddHit(Int_t track, Int_t det, Float_t *hits, Int_t q
 304                   , Bool_t inDrift)
 305 {
 306   //
 307   // Add a hit for the TRD
 308   //
 309
 310   TClonesArray &lhits = *fHits;
 311   AliTRDhit *hit = new(lhits[fNhits++]) AliTRDhit(fIshunt,track,det,hits,q);
 312   if (inDrift) {
 313     hit->SetDrift();
 314   }
 315   else {
 316     hit->SetAmplification();
 317   }
 318   if (q < 0) {
 319     hit->SetTRphoton();
 320   }
 321
 322 }
 323
 324 //_____________________________________________________________________________
 325 void AliTRD::BuildGeometry()
 326 {
 327   //
 328   // Create the ROOT TNode geometry for the TRD
 329   //
 330
 331   TNode *node, *top;
 332   TPGON *pgon;
 333
 334   Float_t rmin, rmax;
 335   Float_t zmax1, zmax2;
 336
 337   Int_t   iPlan;
 338
 339   const Int_t kColorTRD = 46;
 340
 341   // Find the top node alice
 342   top = gAlice->GetGeometry()->GetNode("alice");
 343
 344   if      (fDisplayType == 0) {
 345
 346     pgon = new TPGON("S_TRD","TRD","void",0,360,AliTRDgeometry::Nsect(),4);
 347     rmin = AliTRDgeometry::Rmin();
 348     rmax = AliTRDgeometry::Rmax();
 349     pgon->DefineSection(0,-AliTRDgeometry::Zmax1(),rmax,rmax);
 350     pgon->DefineSection(1,-AliTRDgeometry::Zmax2(),rmin,rmax);
 351     pgon->DefineSection(2, AliTRDgeometry::Zmax2(),rmin,rmax);
 352     pgon->DefineSection(3, AliTRDgeometry::Zmax1(),rmax,rmax);
 353     top->cd();
 354     node = new TNode("TRD","TRD","S_TRD",0,0,0,"");
 355     node->SetLineColor(kColorTRD);
 356     fNodes->Add(node);
 357
 358   }
 359   else if (fDisplayType == 1) {
 360
 361     Char_t name[7];
 362
 363     Float_t slope = (AliTRDgeometry::Zmax1() - AliTRDgeometry::Zmax2())
 364                   / (AliTRDgeometry::Rmax()  - AliTRDgeometry::Rmin());
 365
 366     rmin  = AliTRDgeometry::Rmin() + AliTRDgeometry::CraHght();
 367     rmax  = rmin                   + AliTRDgeometry::CdrHght();
 368
 369     Float_t thickness = rmin - AliTRDgeometry::Rmin();
 370     zmax2 = AliTRDgeometry::Zmax2() + slope * thickness;
 371     zmax1 = zmax2 + slope * AliTRDgeometry::DrThick();
 372
 373     for (iPlan = 0; iPlan < AliTRDgeometry::Nplan(); iPlan++) {
 374
 375       sprintf(name,"S_TR1%d",iPlan);
 376       pgon  = new TPGON(name,"TRD","void",0,360,AliTRDgeometry::Nsect(),4);
 377       pgon->DefineSection(0,-zmax1,rmax,rmax);
 378       pgon->DefineSection(1,-zmax2,rmin,rmax);
 379       pgon->DefineSection(2, zmax2,rmin,rmax);
 380       pgon->DefineSection(3, zmax1,rmax,rmax);
 381       top->cd();
 382       node = new TNode("TRD","TRD",name,0,0,0,"");
 383       node->SetLineColor(kColorTRD);
 384       fNodes->Add(node);
 385
 386       Float_t height = AliTRDgeometry::Cheight() + AliTRDgeometry::Cspace();
 387       rmin  = rmin  + height;
 388       rmax  = rmax  + height;
 389       zmax1 = zmax1 + slope * height;
 390       zmax2 = zmax2 + slope * height;
 391
 392     }
 393
 394     thickness += AliTRDgeometry::DrThick();
 395     rmin  = AliTRDgeometry::Rmin() + thickness;
 396     rmax  = rmin + AliTRDgeometry::AmThick();
 397     zmax2 = AliTRDgeometry::Zmax2() + slope * thickness;
 398     zmax1 = zmax2 + slope * AliTRDgeometry::AmThick();
 399
 400     for (iPlan = 0; iPlan < AliTRDgeometry::Nplan(); iPlan++) {
 401
 402       sprintf(name,"S_TR2%d",iPlan);
 403       pgon  = new TPGON(name,"TRD","void",0,360,AliTRDgeometry::Nsect(),4);
 404       pgon->DefineSection(0,-zmax1,rmax,rmax);
 405       pgon->DefineSection(1,-zmax2,rmin,rmax);
 406       pgon->DefineSection(2, zmax2,rmin,rmax);
 407       pgon->DefineSection(3, zmax1,rmax,rmax);
 408       top->cd();
 409       node = new TNode("TRD","TRD",name,0,0,0,"");
 410       node->SetLineColor(kColorTRD);
 411       fNodes->Add(node);
 412
 413       Float_t height = AliTRDgeometry::Cheight() + AliTRDgeometry::Cspace();
 414       rmin  = rmin  + height;
 415       rmax  = rmax  + height;
 416       zmax1 = zmax1 + slope * height;
 417       zmax2 = zmax2 + slope * height;
 418
 419     }
 420
 421   }
 422
 423 }
 424
 425 //_____________________________________________________________________________
 426 void AliTRD::Copy(TObject &trd) const
 427 {
 428   //
 429   // Copy function
 430   //
 431
 432   ((AliTRD &) trd).fGeometry    = fGeometry;
 433   ((AliTRD &) trd).fGasDensity  = fGasDensity;
 434   ((AliTRD &) trd).fFoilDensity = fFoilDensity;
 435   ((AliTRD &) trd).fDrawTR      = fDrawTR;
 436   ((AliTRD &) trd).fDisplayType = fDisplayType;
 437
 438   //AliDetector::Copy(trd);
 439
 440 }
 441
 442 //_____________________________________________________________________________
 443 void AliTRD::CreateGeometry()
 444 {
 445   //
 446   // Creates the volumes for the TRD chambers
 447   //
 448
 449   // Check that FRAME is there otherwise we have no place where to put the TRD
 450   AliModule* frame = gAlice->GetModule("FRAME");
 451   if (!frame) {
 452     AliFatal("The TRD needs the FRAME to be defined first");
 453   }
 454
 455   fGeometry->CreateGeometry(fIdtmed->GetArray() - 1299);
 456
 457 }
 458
 459 //_____________________________________________________________________________
 460 void AliTRD::CreateMaterials()
 461 {
 462   //
 463   // Create the materials for the TRD
 464   //
 465
 466   Int_t   isxfld = gAlice->Field()->Integ();
 467   Float_t sxmgmx = gAlice->Field()->Max();
 468
 469   // For polyethilene (CH2)
 470   Float_t ape[2] = { 12.011 ,  1.0079 };
 471   Float_t zpe[2] = {  6.0   ,  1.0    };
 472   Float_t wpe[2] = {  1.0   ,  2.0    };
 473   Float_t dpe    = 0.95;
 474
 475   // For mylar (C5H4O2)
 476   Float_t amy[3] = { 12.011 ,  1.0079, 15.9994 };
 477   Float_t zmy[3] = {  6.0   ,  1.0   ,  8.0    };
 478   Float_t wmy[3] = {  5.0   ,  4.0   ,  2.0    };
 479   Float_t dmy    = 1.39;
 480
 481   // For CO2
 482   Float_t aco[2] = { 12.011 , 15.9994 };
 483   Float_t zco[2] = {  6.0   ,  8.0    };
 484   Float_t wco[2] = {  1.0   ,  2.0    };
 485   Float_t dco    = 0.001977;
 486
 487   // For water
 488   Float_t awa[2] = {  1.0079, 15.9994 };
 489   Float_t zwa[2] = {  1.0   ,  8.0    };
 490   Float_t wwa[2] = {  2.0   ,  1.0    };
 491   Float_t dwa    = 1.0;
 492
 493   // For isobutane (C4H10)
 494   Float_t ais[2] = { 12.011 ,  1.0079 };
 495   Float_t zis[2] = {  6.0   ,  1.0    };
 496   Float_t wis[2] = {  4.0   , 10.0    };
 497   Float_t dis    = 0.00267;
 498
 499   // For plexiglas (C5H8O2)
 500   Float_t apg[3] = { 12.011 ,  1.0079, 15.9994 };
 501   Float_t zpg[3] = {  6.0   ,  1.0   ,  8.0    };
 502   Float_t wpg[3] = {  5.0   ,  8.0   ,  2.0    };
 503   Float_t dpg    = 1.18;
 504
 505   // For epoxy (C18H19O3)
 506   Float_t aEpoxy[3] = { 15.9994,  1.0079, 12.011  };
 507   Float_t zEpoxy[3] = {  8.0   ,  1.0   ,  6.0    };
 508   Float_t wEpoxy[3] = {  3.0   , 19.0   , 18.0    };
 509   Float_t dEpoxy    = 1.8 ;
 510
 511   // For air
 512   Float_t aAir[4]   = { 12.011   , 14.0     , 15.9994  , 36.0      };
 513   Float_t zAir[4]   = {  6.0     ,  7.0     ,  8.0     , 18.0      };
 514   Float_t wAir[4]   = {  0.000124,  0.755267,  0.231781,  0.012827 };
 515   Float_t dAir      = 1.20479E-3;
 516
 517   // For G10
 518   Float_t aG10[4]   = {  1.0079  , 12.011   , 15.9994  , 28.086    };
 519   Float_t zG10[4]   = {  1.0     ,  6.0     ,  8.0     , 14.0      };
 520   Float_t wG10[4]   = {  0.15201 ,  0.10641 ,  0.49444 ,  0.24714  };
 521   Float_t dG10      = 1.7;
 522
 523   // For Xe/CO2-gas-mixture
 524   Float_t aXeCO2[3] = { 131.29   ,  12.0107 ,  15.9994  };
 525   Float_t zXeCO2[3] = {  54.0    ,   6.0    ,   8.0     };
 526   Float_t wXeCO2[3] = {   0.85   ,   0.0375 ,   0.1125  };
 527   // Xe-content of the Xe/CO2-mixture (85% / 15%)
 528   Float_t fxc       = 0.85;
 529   Float_t dxe       = 0.00549;
 530   Float_t dgm       = fxc * dxe + (1.0 - fxc) * dco;
 531
 532   // General tracking parameter
 533   Float_t tmaxfd = -10.;
 534   Float_t stemax = -1e10;
 535   Float_t deemax = -0.1;
 536   Float_t epsil  =  1e-4;
 537   Float_t stmin  = -0.001;
 538
 539   //////////////////////////////////////////////////////////////////////////
 540   //     Define Materials
 541   //////////////////////////////////////////////////////////////////////////
 542
 543   AliMaterial( 1, "Al"   ,  26.98, 13.0, 2.7     ,     8.9 ,    37.2);
 544   AliMaterial( 4, "Xe"   , 131.29, 54.0, dxe     ,  1546.16,     0.0);
 545   AliMaterial( 5, "Cu"   ,  63.54, 29.0, 8.96    ,     1.43,    14.8);
 546   AliMaterial( 6, "C"    ,  12.01,  6.0, 2.265   ,    18.8 ,    74.4);
 547   AliMaterial(15, "Sn"   , 118.71, 50.0, 7.31    ,     1.21,    14.8);
 548   AliMaterial(16, "Si"   ,  28.09, 14.0, 2.33    ,     9.36,    37.2);
 549
 550   // Mixtures
 551   AliMixture(2, "Air"         , aAir,   zAir,   dAir,    4, wAir  );
 552   AliMixture(3, "Polyethilene", ape,    zpe,    dpe,    -2, wpe   );
 553   AliMixture(7, "Mylar",        amy,    zmy,    dmy,    -3, wmy   );
 554   AliMixture(8, "CO2",          aco,    zco,    dco,    -2, wco   );
 555   AliMixture(9, "Isobutane",    ais,    zis,    dis,    -2, wis   );
 556   AliMixture(10,"Gas mixture",  aXeCO2, zXeCO2, dgm,     3, wXeCO2);
 557   AliMixture(12,"G10",          aG10,   zG10,   dG10,    4, wG10  );
 558   AliMixture(13,"Water",        awa,    zwa,    dwa,    -2, wwa   );
 559   AliMixture(14,"Plexiglas",    apg,    zpg,    dpg,    -3, wpg   );
 560   AliMixture(17,"Epoxy",        aEpoxy, zEpoxy, dEpoxy, -3, wEpoxy);
 561
 562   //////////////////////////////////////////////////////////////////////////
 563   //     Tracking Media Parameters
 564   //////////////////////////////////////////////////////////////////////////
 565
 566   // Al Frame
 567   AliMedium(1, "Al Frame",   1, 0, isxfld, sxmgmx
 568                 , tmaxfd, stemax, deemax, epsil, stmin);
 569   // Air
 570   AliMedium(2, "Air",        2, 0, isxfld, sxmgmx
 571                 , tmaxfd, stemax, deemax, epsil, stmin);
 572   // Polyethilene
 573   AliMedium(3, "Radiator",   3, 0, isxfld, sxmgmx
 574                 , tmaxfd, stemax, deemax, epsil, stmin);
 575   // Xe
 576   AliMedium(4, "Xe",         4, 1, isxfld, sxmgmx
 577                 , tmaxfd, stemax, deemax, epsil, stmin);
 578   // Cu pads
 579   AliMedium(5, "Padplane",   5, 1, isxfld, sxmgmx
 580                 , tmaxfd, stemax, deemax, epsil, stmin);
 581   // Fee + cables
 582   AliMedium(6, "Readout",    1, 0, isxfld, sxmgmx
 583                 , tmaxfd, stemax, deemax, epsil, stmin);
 584   // C frame
 585   AliMedium(7, "C Frame",    6, 0, isxfld, sxmgmx
 586                 , tmaxfd, stemax, deemax, epsil, stmin);
 587   // Mylar foils
 588   AliMedium(8, "Mylar",      7, 0, isxfld, sxmgmx
 589                 , tmaxfd, stemax, deemax, epsil, stmin);
 590   // Gas-mixture (Xe/CO2)
 591   AliMedium(9, "Gas-mix",   10, 1, isxfld, sxmgmx
 592                 , tmaxfd, stemax, deemax, epsil, stmin);
 593   // Nomex-honeycomb (use carbon for the time being)
 594   AliMedium(10, "Nomex",      6, 0, isxfld, sxmgmx
 595                 , tmaxfd, stemax, deemax, epsil, stmin);
 596   // Kapton foils (use Mylar for the time being)
 597   AliMedium(11, "Kapton",     7, 0, isxfld, sxmgmx
 598                 , tmaxfd, stemax, deemax, epsil, stmin);
 599   // Gas-filling of the radiator
 600   AliMedium(12, "CO2",        8, 0, isxfld, sxmgmx
 601                 , tmaxfd, stemax, deemax, epsil, stmin);
 602   // G10-plates
 603   AliMedium(13, "G10-plates",12, 0, isxfld, sxmgmx
 604                 , tmaxfd, stemax, deemax, epsil, stmin);
 605   // Cooling water
 606   AliMedium(14, "Water",     13, 0, isxfld, sxmgmx
 607                 , tmaxfd, stemax, deemax, epsil, stmin);
 608   // Rohacell (plexiglas) for the radiator
 609   AliMedium(15, "Rohacell",  14, 0, isxfld, sxmgmx
 610                 , tmaxfd, stemax, deemax, epsil, stmin);
 611   // Al layer in MCMs
 612   AliMedium(16, "MCM-Al"  ,   1, 0, isxfld, sxmgmx
 613                 , tmaxfd, stemax, deemax, epsil, stmin);
 614   // Sn layer in MCMs
 615   AliMedium(17, "MCM-Sn"  ,  15, 0, isxfld, sxmgmx
 616                 , tmaxfd, stemax, deemax, epsil, stmin);
 617   // Cu layer in MCMs
 618   AliMedium(18, "MCM-Cu"  ,   5, 0, isxfld, sxmgmx
 619                 , tmaxfd, stemax, deemax, epsil, stmin);
 620   // G10 layer in MCMs
 621   AliMedium(19, "MCM-G10" ,  12, 0, isxfld, sxmgmx
 622                 , tmaxfd, stemax, deemax, epsil, stmin);
 623   // Si in readout chips
 624   AliMedium(20, "Chip-Si" ,  16, 0, isxfld, sxmgmx
 625                 , tmaxfd, stemax, deemax, epsil, stmin);
 626   // Epoxy in readout chips
 627   AliMedium(21, "Chip-Ep" ,  17, 0, isxfld, sxmgmx
 628                 , tmaxfd, stemax, deemax, epsil, stmin);
 629   // PE in connectors
 630   AliMedium(22, "Conn-PE" ,   3, 0, isxfld, sxmgmx
 631                 , tmaxfd, stemax, deemax, epsil, stmin);
 632   // Cu in connectors
 633   AliMedium(23, "Chip-Cu" ,   5, 0, isxfld, sxmgmx
 634                 , tmaxfd, stemax, deemax, epsil, stmin);
 635   // Al of cooling pipes
 636   AliMedium(24, "Cooling" ,   1, 0, isxfld, sxmgmx
 637                 , tmaxfd, stemax, deemax, epsil, stmin);
 638   // Cu in services
 639   AliMedium(25, "Serv-Cu" ,   5, 0, isxfld, sxmgmx
 640                 , tmaxfd, stemax, deemax, epsil, stmin);
 641
 642   // Save the density values for the TRD absorbtion
 643   fFoilDensity = dmy;
 644   fGasDensity  = dgm;
 645
 646 }
 647
 648 //_____________________________________________________________________________
 649 void AliTRD::DrawModule() const
 650 {
 651   //
 652   // Draw a shaded view of the Transition Radiation Detector version 0
 653   //
 654
 655   // Set everything unseen
 656   gMC->Gsatt("*"   ,"SEEN",-1);
 657
 658   // Set ALIC mother transparent
 659   gMC->Gsatt("ALIC","SEEN", 0);
 660
 661   // Set the volumes visible
 662   if (fGeometry->IsVersion() == 0) {
 663     gMC->Gsatt("B071","SEEN", 0);
 664     gMC->Gsatt("B074","SEEN", 0);
 665     gMC->Gsatt("B075","SEEN", 0);
 666     gMC->Gsatt("B077","SEEN", 0);
 667     gMC->Gsatt("BTR1","SEEN", 0);
 668     gMC->Gsatt("BTR2","SEEN", 0);
 669     gMC->Gsatt("BTR3","SEEN", 0);
 670     gMC->Gsatt("UTR1","SEEN", 0);
 671     gMC->Gsatt("UTR2","SEEN", 0);
 672     gMC->Gsatt("UTR3","SEEN", 0);
 673   }
 674   else {
 675     gMC->Gsatt("B071","SEEN", 0);
 676     gMC->Gsatt("B074","SEEN", 0);
 677     gMC->Gsatt("B075","SEEN", 0);
 678     gMC->Gsatt("B077","SEEN", 0);
 679     gMC->Gsatt("BTR1","SEEN", 0);
 680     gMC->Gsatt("BTR2","SEEN", 0);
 681     gMC->Gsatt("BTR3","SEEN", 0);
 682     gMC->Gsatt("UTR1","SEEN", 0);
 683     if (fGeometry->GetPHOShole())
 684       gMC->Gsatt("UTR2","SEEN", 0);
 685     if (fGeometry->GetRICHhole())
 686       gMC->Gsatt("UTR3","SEEN", 0);
 687   }
 688 //   gMC->Gsatt("UCII","SEEN", 0);
 689 //   gMC->Gsatt("UCIM","SEEN", 0);
 690 //   gMC->Gsatt("UCIO","SEEN", 0);
 691 //   gMC->Gsatt("UL02","SEEN", 1);
 692 //   gMC->Gsatt("UL05","SEEN", 1);
 693 //   gMC->Gsatt("UL06","SEEN", 1);
 694
 695   gMC->Gdopt("hide", "on");
 696   gMC->Gdopt("shad", "on");
 697   gMC->Gsatt("*", "fill", 7);
 698   gMC->SetClipBox(".");
 699   gMC->SetClipBox("*", 0, 2000, -2000, 2000, -2000, 2000);
 700   gMC->DefaultRange();
 701   gMC->Gdraw("alic", 40, 30, 0, 12, 9.4, .021, .021);
 702   gMC->Gdhead(1111, "Transition Radiation Detector");
 703   gMC->Gdman(18, 4, "MAN");
 704
 705 }
 706
 707 //_____________________________________________________________________________
 708 Int_t AliTRD::DistancetoPrimitive(Int_t , Int_t )
 709 {
 710   //
 711   // Distance between the mouse and the TRD detector on the screen
 712   // Dummy routine
 713
 714   return 9999;
 715
 716 }
 717
 718 //_____________________________________________________________________________
 719 void AliTRD::Init()
 720 {
 721   //
 722   // Initialize the TRD detector after the geometry has been created
 723   //
 724
 725   AliDebug(1,"++++++++++++++++++++++++++++++++++++++++++++++");
 726
 727   if (fGeometry->IsVersion() == 1) {
 728     AliInfo("Full geometry version initialized");
 729     if (fGeometry->GetPHOShole())
 730       AliInfo("Leave space in front of PHOS free");
 731     if (fGeometry->GetRICHhole())
 732       AliInfo("Leave space in front of RICH free");
 733   }
 734   else {
 735     AliError("Not a valid geometry");
 736   }
 737
 738 }
 739
 740 //_____________________________________________________________________________
 741 void AliTRD::LoadPoints(Int_t )
 742 {
 743   //
 744   // Store x, y, z of all hits in memory.
 745   // Hit originating from TR photons are given a different color
 746   //
 747
 748   //if (!fDrawTR) {
 749   //  AliDetector::LoadPoints(track);
 750   //  return;
 751   //}
 752
 753   if (fHits == 0) return;
 754
 755   Int_t nhits = fHits->GetEntriesFast();
 756   if (nhits == 0) return;
 757
 758   Int_t tracks = gAlice->GetMCApp()->GetNtrack();
 759   if (fPoints == 0) fPoints = new TObjArray(tracks);
 760
 761   AliTRDhit *ahit;
 762
 763   Int_t    *ntrkE = new Int_t[tracks];
 764   Int_t    *ntrkT = new Int_t[tracks];
 765   Int_t    *limiE = new Int_t[tracks];
 766   Int_t    *limiT = new Int_t[tracks];
 767   Float_t **coorE = new Float_t*[tracks];
 768   Float_t **coorT = new Float_t*[tracks];
 769   for(Int_t i = 0; i < tracks; i++) {
 770     ntrkE[i] = 0;
 771     ntrkT[i] = 0;
 772     coorE[i] = 0;
 773     coorT[i] = 0;
 774     limiE[i] = 0;
 775     limiT[i] = 0;
 776   }
 777
 778   AliTRDpoints *points = 0;
 779   Float_t      *fp     = 0;
 780   Int_t         trk;
 781   Int_t         chunk  = nhits / 4 + 1;
 782
 783   // Loop over all the hits and store their position
 784   ahit = (AliTRDhit *) FirstHit(-1);
 785   while (ahit) {
 786
 787     // dEdx hits
 788     if (ahit->GetCharge() >= 0) {
 789
 790       trk = ahit->GetTrack();
 791       if (ntrkE[trk] == limiE[trk]) {
 792         // Initialise a new track
 793         fp = new Float_t[3*(limiE[trk]+chunk)];
 794         if (coorE[trk]) {
 795           memcpy(fp,coorE[trk],sizeof(Float_t)*3*limiE[trk]);
 796           delete [] coorE[trk];
 797         }
 798         limiE[trk] += chunk;
 799         coorE[trk]  = fp;
 800       }
 801       else {
 802         fp = coorE[trk];
 803       }
 804       fp[3*ntrkE[trk]  ] = ahit->X();
 805       fp[3*ntrkE[trk]+1] = ahit->Y();
 806       fp[3*ntrkE[trk]+2] = ahit->Z();
 807       ntrkE[trk]++;
 808
 809     }
 810     // TR photon hits
 811     else if ((ahit->GetCharge() < 0) && (fDrawTR)) {
 812
 813       trk = ahit->GetTrack();
 814       if (ntrkT[trk] == limiT[trk]) {
 815         // Initialise a new track
 816         fp = new Float_t[3*(limiT[trk]+chunk)];
 817         if (coorT[trk]) {
 818           memcpy(fp,coorT[trk],sizeof(Float_t)*3*limiT[trk]);
 819           delete [] coorT[trk];
 820         }
 821         limiT[trk] += chunk;
 822         coorT[trk]  = fp;
 823       }
 824       else {
 825         fp = coorT[trk];
 826       }
 827       fp[3*ntrkT[trk]  ] = ahit->X();
 828       fp[3*ntrkT[trk]+1] = ahit->Y();
 829       fp[3*ntrkT[trk]+2] = ahit->Z();
 830       ntrkT[trk]++;
 831
 832     }
 833
 834     ahit = (AliTRDhit *) NextHit();
 835
 836   }
 837
 838   for (trk = 0; trk < tracks; ++trk) {
 839
 840     if (ntrkE[trk] || ntrkT[trk]) {
 841
 842       points = new AliTRDpoints();
 843       points->SetDetector(this);
 844       points->SetParticle(trk);
 845
 846       // Set the dEdx points
 847       if (ntrkE[trk]) {
 848         points->SetMarkerColor(GetMarkerColor());
 849         points->SetMarkerSize(GetMarkerSize());
 850         points->SetPolyMarker(ntrkE[trk],coorE[trk],GetMarkerStyle());
 851         delete [] coorE[trk];
 852         coorE[trk] = 0;
 853       }
 854
 855       // Set the TR photon points
 856       if (ntrkT[trk]) {
 857         points->SetTRpoints(ntrkT[trk],coorT[trk]);
 858         delete [] coorT[trk];
 859         coorT[trk] = 0;
 860       }
 861
 862       fPoints->AddAt(points,trk);
 863
 864     }
 865
 866   }
 867
 868   delete [] coorE;
 869   delete [] coorT;
 870   delete [] ntrkE;
 871   delete [] ntrkT;
 872   delete [] limiE;
 873   delete [] limiT;
 874
 875 }
 876
 877 //_____________________________________________________________________________
 878 void AliTRD::MakeBranch(Option_t* option)
 879 {
 880   //
 881   // Create Tree branches for the TRD digits.
 882   //
 883
 884   Int_t  buffersize = 4000;
 885   Char_t branchname[15];
 886   sprintf(branchname,"%s",GetName());
 887
 888   const char *cD = strstr(option,"D");
 889
 890   AliDetector::MakeBranch(option);
 891
 892   if (fDigits && gAlice->TreeD() && cD) {
 893     MakeBranchInTree(gAlice->TreeD(),branchname,&fDigits,buffersize,0);
 894   }
 895
 896 }
 897
 898 //_____________________________________________________________________________
 899 void AliTRD::ResetDigits()
 900 {
 901   //
 902   // Reset number of digits and the digits array for this detector
 903   //
 904
 905   fNdigits = 0;
 906   if (fDigits) fDigits->Clear();
 907
 908 }
 909
 910 //_____________________________________________________________________________
 911 void AliTRD::SetTreeAddress()
 912 {
 913   //
 914   // Set the branch addresses for the trees.
 915   //
 916
 917   if ( fLoader->TreeH() && (fHits == 0x0)) {
 918     fHits = new TClonesArray("AliTRDhit",405);
 919   }
 920   AliDetector::SetTreeAddress();
 921
 922 }
 923
 924 //_____________________________________________________________________________
 925 void AliTRD::SetPHOShole()
 926 {
 927   //
 928   // Selects a geometry with a hole in front of the PHOS
 929   //
 930
 931   fGeometry->SetPHOShole();
 932
 933 }
 934
 935 //_____________________________________________________________________________
 936 void AliTRD::SetRICHhole()
 937 {
 938   //
 939   // Selects a geometry with a hole in front of the RICH
 940   //
 941
 942   fGeometry->SetRICHhole();
 943
 944 }
 945
 946 //_____________________________________________________________________________
 947 AliTRD &AliTRD::operator=(const AliTRD &trd)
 948 {
 949   //
 950   // Assignment operator
 951   //
 952
 953   if (this != &trd) ((AliTRD &) trd).Copy(*this);
 954   return *this;
 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
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291