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 "AliMagF.h"
  44 #include "AliRun.h"
  45 #include "AliTRD.h"
  46 #include "AliTRDdigit.h"
  47 #include "AliTRDdigitizer.h"
  48 #include "AliTRDdigitsManager.h"
  49 #include "AliTRDgeometryFull.h"
  50 #include "AliTRDhit.h"
  51 #include "AliTRDpoints.h"
  52 #include "AliTRDrawData.h"
  53 #include "AliTrackReference.h"
  54 #include "AliMC.h"
  55
  56 ClassImp(AliTRD)
  57
  58 //_____________________________________________________________________________
  59 AliTRD::AliTRD()
  60 {
  61   //
  62   // Default constructor
  63   //
  64
  65   fIshunt        = 0;
  66   fHits          = 0;
  67   fDigits        = 0;
  68
  69   fGeometry      = 0;
  70
  71   fGasDensity    = 0;
  72   fFoilDensity   = 0;
  73
  74   fDrawTR        = 0;
  75   fDisplayType   = 0;
  76
  77 }
  78
  79 //_____________________________________________________________________________
  80 AliTRD::AliTRD(const char *name, const char *title)
  81        : AliDetector(name,title)
  82 {
  83   //
  84   // Standard constructor for the TRD
  85   //
  86
  87   // Check that FRAME is there otherwise we have no place where to
  88   // put TRD
  89   AliModule* frame = gAlice->GetModule("FRAME");
  90   if (!frame) {
  91     Error("Ctor","TRD needs FRAME to be present\n");
  92     exit(1);
  93   }
  94
  95   // Define the TRD geometry
  96   if ((frame->IsVersion() == 0) ||
  97       (frame->IsVersion() == 1)) {
  98     fGeometry = new AliTRDgeometryFull();
  99   }
 100   else {
 101     Error("Ctor","Could not find valid FRAME version\n");
 102     exit(1);
 103   }
 104
 105   // Save the geometry
 106   TDirectory* saveDir = gDirectory;
 107   gAlice->GetRunLoader()->CdGAFile();
 108   fGeometry->Write("TRDgeometry");
 109   saveDir->cd();
 110
 111   // Allocate the hit array
 112   fHits          = new TClonesArray("AliTRDhit"     ,405);
 113   gAlice->GetMCApp()->AddHitList(fHits);
 114
 115   // Allocate the digits array
 116   fDigits        = 0;
 117
 118   fIshunt        = 0;
 119
 120   fGasDensity    = 0;
 121   fFoilDensity   = 0;
 122
 123   fDrawTR        = 0;
 124   fDisplayType   = 0;
 125
 126   SetMarkerColor(kWhite);
 127
 128 }
 129
 130 //_____________________________________________________________________________
 131 AliTRD::AliTRD(const AliTRD &trd):AliDetector(trd)
 132 {
 133   //
 134   // Copy constructor
 135   //
 136
 137   ((AliTRD &) trd).Copy(*this);
 138
 139 }
 140
 141 //_____________________________________________________________________________
 142 AliTRD::~AliTRD()
 143 {
 144   //
 145   // TRD destructor
 146   //
 147
 148   fIshunt = 0;
 149
 150   if (fGeometry) {
 151     delete fGeometry;
 152     fGeometry  = 0;
 153   }
 154   if (fHits) {
 155     delete fHits;
 156     fHits      = 0;
 157   }
 158
 159 }
 160
 161 //_____________________________________________________________________________
 162 void AliTRD::Hits2Digits()
 163 {
 164   //
 165   // Create digits
 166   //
 167   AliTRDdigitizer digitizer("TRDdigitizer","TRD digitizer class");
 168   digitizer.SetDebug(GetDebug());
 169
 170   // Initialization
 171   digitizer.InitDetector();
 172
 173   if (!fLoader->TreeH()) fLoader->LoadHits("read");
 174   fLoader->LoadDigits("recreate");
 175   AliRunLoader* runLoader = fLoader->GetRunLoader();
 176
 177   for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
 178     digitizer.Open(runLoader->GetFileName().Data(), iEvent);
 179     digitizer.MakeDigits();
 180     digitizer.WriteDigits();
 181   }
 182
 183   fLoader->UnloadHits();
 184   fLoader->UnloadDigits();
 185
 186 }
 187
 188 //_____________________________________________________________________________
 189 void AliTRD::Hits2SDigits()
 190 {
 191   //
 192   // Create summable digits
 193   //
 194
 195   AliTRDdigitizer digitizer("TRDdigitizer","TRD digitizer class");
 196   // For the summable digits
 197   digitizer.SetSDigits(kTRUE);
 198   digitizer.SetDebug(GetDebug());
 199
 200   // Initialization
 201   digitizer.InitDetector();
 202
 203   if (!fLoader->TreeH()) fLoader->LoadHits("read");
 204   fLoader->LoadSDigits("recreate");
 205   AliRunLoader* runLoader = fLoader->GetRunLoader();
 206
 207   for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
 208     digitizer.Open(runLoader->GetFileName().Data(), iEvent);
 209     digitizer.MakeDigits();
 210     digitizer.WriteDigits();
 211   }
 212
 213   fLoader->UnloadHits();
 214   fLoader->UnloadSDigits();
 215
 216 }
 217
 218 //_____________________________________________________________________________
 219 AliDigitizer* AliTRD::CreateDigitizer(AliRunDigitizer* manager) const
 220 {
 221   //
 222   // Creates a new digitizer object
 223   //
 224
 225   return new AliTRDdigitizer(manager);
 226
 227 }
 228
 229 //_____________________________________________________________________________
 230 void AliTRD::SDigits2Digits()
 231 {
 232   //
 233   // Create final digits from summable digits
 234   //
 235
 236    // Create the TRD digitizer
 237   AliTRDdigitizer digitizer("TRDdigitizer","TRD digitizer class");
 238   digitizer.SetDebug(GetDebug());
 239
 240   // Set the parameter
 241   digitizer.SetEvent(gAlice->GetEvNumber());
 242
 243   // Initialization
 244   digitizer.InitDetector();
 245
 246   // Read the s-digits via digits manager
 247   AliTRDdigitsManager sdigitsManager;
 248
 249   sdigitsManager.SetDebug(GetDebug());
 250   sdigitsManager.SetSDigits(kTRUE);
 251   sdigitsManager.CreateArrays();
 252
 253   if (!fLoader->TreeS())
 254     if (fLoader->LoadSDigits("read"))
 255      {
 256        Error("SDigits2Digits","Error while reading SDigits for event %d",gAlice->GetEvNumber());
 257        return;
 258      }
 259   if (!fLoader->TreeS()) return;
 260
 261   sdigitsManager.ReadDigits(fLoader->TreeS());
 262
 263   // Add the s-digits to the input list
 264   digitizer.AddSDigitsManager(&sdigitsManager);
 265
 266   // Convert the s-digits to normal digits
 267   digitizer.SDigits2Digits();
 268
 269   // Store the digits
 270   if (!fLoader->TreeD()) fLoader->MakeTree("D");
 271   if (digitizer.MakeBranch(fLoader->TreeD())){
 272     digitizer.WriteDigits();
 273   }
 274
 275 }
 276
 277 //_____________________________________________________________________________
 278 void AliTRD::Digits2Raw()
 279 {
 280   //
 281   // convert digits of the current event to raw data
 282   //
 283
 284   fLoader->LoadDigits();
 285   TTree* digits = fLoader->TreeD();
 286   if (!digits) {
 287     Error("Digits2Raw", "no digits tree");
 288     return;
 289   }
 290
 291   AliTRDrawData rawWriter;
 292 //  rawWriter.SetDebug(2);
 293   if (!rawWriter.Digits2Raw(digits)) {
 294     Error("AliTRD::Digits2Raw","The raw writer could not load the digits tree");
 295   }
 296
 297   fLoader->UnloadDigits();
 298
 299 }
 300
 301 //_____________________________________________________________________________
 302 void AliTRD::AddHit(Int_t track, Int_t det, Float_t *hits, Int_t q
 303                   , Bool_t inDrift)
 304 {
 305   //
 306   // Add a hit for the TRD
 307   //
 308
 309   TClonesArray &lhits = *fHits;
 310   AliTRDhit *hit = new(lhits[fNhits++]) AliTRDhit(fIshunt,track,det,hits,q);
 311   if (inDrift) {
 312     hit->SetDrift();
 313   }
 314   else {
 315     hit->SetAmplification();
 316   }
 317   if (q < 0) {
 318     hit->SetTRphoton();
 319   }
 320
 321 }
 322
 323 //_____________________________________________________________________________
 324 void AliTRD::BuildGeometry()
 325 {
 326   //
 327   // Create the ROOT TNode geometry for the TRD
 328   //
 329
 330   TNode *node, *top;
 331   TPGON *pgon;
 332
 333   Float_t rmin, rmax;
 334   Float_t zmax1, zmax2;
 335
 336   Int_t   iPlan;
 337
 338   const Int_t kColorTRD = 46;
 339
 340   // Find the top node alice
 341   top = gAlice->GetGeometry()->GetNode("alice");
 342
 343   if      (fDisplayType == 0) {
 344
 345     pgon = new TPGON("S_TRD","TRD","void",0,360,AliTRDgeometry::Nsect(),4);
 346     rmin = AliTRDgeometry::Rmin();
 347     rmax = AliTRDgeometry::Rmax();
 348     pgon->DefineSection(0,-AliTRDgeometry::Zmax1(),rmax,rmax);
 349     pgon->DefineSection(1,-AliTRDgeometry::Zmax2(),rmin,rmax);
 350     pgon->DefineSection(2, AliTRDgeometry::Zmax2(),rmin,rmax);
 351     pgon->DefineSection(3, AliTRDgeometry::Zmax1(),rmax,rmax);
 352     top->cd();
 353     node = new TNode("TRD","TRD","S_TRD",0,0,0,"");
 354     node->SetLineColor(kColorTRD);
 355     fNodes->Add(node);
 356
 357   }
 358   else if (fDisplayType == 1) {
 359
 360     Char_t name[7];
 361
 362     Float_t slope = (AliTRDgeometry::Zmax1() - AliTRDgeometry::Zmax2())
 363                   / (AliTRDgeometry::Rmax()  - AliTRDgeometry::Rmin());
 364
 365     rmin  = AliTRDgeometry::Rmin() + AliTRDgeometry::CraHght();
 366     rmax  = rmin                   + AliTRDgeometry::CdrHght();
 367
 368     Float_t thickness = rmin - AliTRDgeometry::Rmin();
 369     zmax2 = AliTRDgeometry::Zmax2() + slope * thickness;
 370     zmax1 = zmax2 + slope * AliTRDgeometry::DrThick();
 371
 372     for (iPlan = 0; iPlan < AliTRDgeometry::Nplan(); iPlan++) {
 373
 374       sprintf(name,"S_TR1%d",iPlan);
 375       pgon  = new TPGON(name,"TRD","void",0,360,AliTRDgeometry::Nsect(),4);
 376       pgon->DefineSection(0,-zmax1,rmax,rmax);
 377       pgon->DefineSection(1,-zmax2,rmin,rmax);
 378       pgon->DefineSection(2, zmax2,rmin,rmax);
 379       pgon->DefineSection(3, zmax1,rmax,rmax);
 380       top->cd();
 381       node = new TNode("TRD","TRD",name,0,0,0,"");
 382       node->SetLineColor(kColorTRD);
 383       fNodes->Add(node);
 384
 385       Float_t height = AliTRDgeometry::Cheight() + AliTRDgeometry::Cspace();
 386       rmin  = rmin  + height;
 387       rmax  = rmax  + height;
 388       zmax1 = zmax1 + slope * height;
 389       zmax2 = zmax2 + slope * height;
 390
 391     }
 392
 393     thickness += AliTRDgeometry::DrThick();
 394     rmin  = AliTRDgeometry::Rmin() + thickness;
 395     rmax  = rmin + AliTRDgeometry::AmThick();
 396     zmax2 = AliTRDgeometry::Zmax2() + slope * thickness;
 397     zmax1 = zmax2 + slope * AliTRDgeometry::AmThick();
 398
 399     for (iPlan = 0; iPlan < AliTRDgeometry::Nplan(); iPlan++) {
 400
 401       sprintf(name,"S_TR2%d",iPlan);
 402       pgon  = new TPGON(name,"TRD","void",0,360,AliTRDgeometry::Nsect(),4);
 403       pgon->DefineSection(0,-zmax1,rmax,rmax);
 404       pgon->DefineSection(1,-zmax2,rmin,rmax);
 405       pgon->DefineSection(2, zmax2,rmin,rmax);
 406       pgon->DefineSection(3, zmax1,rmax,rmax);
 407       top->cd();
 408       node = new TNode("TRD","TRD",name,0,0,0,"");
 409       node->SetLineColor(kColorTRD);
 410       fNodes->Add(node);
 411
 412       Float_t height = AliTRDgeometry::Cheight() + AliTRDgeometry::Cspace();
 413       rmin  = rmin  + height;
 414       rmax  = rmax  + height;
 415       zmax1 = zmax1 + slope * height;
 416       zmax2 = zmax2 + slope * height;
 417
 418     }
 419
 420   }
 421
 422 }
 423
 424 //_____________________________________________________________________________
 425 void AliTRD::Copy(TObject &trd) const
 426 {
 427   //
 428   // Copy function
 429   //
 430
 431   ((AliTRD &) trd).fGeometry    = fGeometry;
 432   ((AliTRD &) trd).fGasDensity  = fGasDensity;
 433   ((AliTRD &) trd).fFoilDensity = fFoilDensity;
 434   ((AliTRD &) trd).fDrawTR      = fDrawTR;
 435   ((AliTRD &) trd).fDisplayType = fDisplayType;
 436
 437   //AliDetector::Copy(trd);
 438
 439 }
 440
 441 //_____________________________________________________________________________
 442 void AliTRD::CreateGeometry()
 443 {
 444   //
 445   // Creates the volumes for the TRD chambers
 446   //
 447
 448   // Check that FRAME is there otherwise we have no place where to put the TRD
 449   AliModule* frame = gAlice->GetModule("FRAME");
 450   if (!frame) {
 451     printf(" The TRD needs the FRAME to be defined first\n");
 452     return;
 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   Int_t i;
 726
 727   if (fDebug) {
 728     printf("\n%s: ",ClassName());
 729     for (i = 0; i < 35; i++) printf("*");
 730     printf(" TRD_INIT ");
 731     for (i = 0; i < 35; i++) printf("*");
 732     printf("\n");
 733   }
 734
 735   if (fGeometry->IsVersion() == 1) {
 736     printf("%s: Full geometry version initialized\n",ClassName());
 737     if (fGeometry->GetPHOShole())
 738       printf("%s: Leave space in front of PHOS free\n",ClassName());
 739     if (fGeometry->GetRICHhole())
 740       printf("%s: Leave space in front of RICH free\n",ClassName());
 741   }
 742   else {
 743     printf("%s: Not a valid geometry\n",ClassName());
 744   }
 745
 746 }
 747
 748 //_____________________________________________________________________________
 749 void AliTRD::LoadPoints(Int_t )
 750 {
 751   //
 752   // Store x, y, z of all hits in memory.
 753   // Hit originating from TR photons are given a different color
 754   //
 755
 756   //if (!fDrawTR) {
 757   //  AliDetector::LoadPoints(track);
 758   //  return;
 759   //}
 760
 761   if (fHits == 0) return;
 762
 763   Int_t nhits = fHits->GetEntriesFast();
 764   if (nhits == 0) return;
 765
 766   Int_t tracks = gAlice->GetMCApp()->GetNtrack();
 767   if (fPoints == 0) fPoints = new TObjArray(tracks);
 768
 769   AliTRDhit *ahit;
 770
 771   Int_t    *ntrkE = new Int_t[tracks];
 772   Int_t    *ntrkT = new Int_t[tracks];
 773   Int_t    *limiE = new Int_t[tracks];
 774   Int_t    *limiT = new Int_t[tracks];
 775   Float_t **coorE = new Float_t*[tracks];
 776   Float_t **coorT = new Float_t*[tracks];
 777   for(Int_t i = 0; i < tracks; i++) {
 778     ntrkE[i] = 0;
 779     ntrkT[i] = 0;
 780     coorE[i] = 0;
 781     coorT[i] = 0;
 782     limiE[i] = 0;
 783     limiT[i] = 0;
 784   }
 785
 786   AliTRDpoints *points = 0;
 787   Float_t      *fp     = 0;
 788   Int_t         trk;
 789   Int_t         chunk  = nhits / 4 + 1;
 790
 791   // Loop over all the hits and store their position
 792   ahit = (AliTRDhit *) FirstHit(-1);
 793   while (ahit) {
 794
 795     // dEdx hits
 796     if (ahit->GetCharge() >= 0) {
 797
 798       trk = ahit->GetTrack();
 799       if (ntrkE[trk] == limiE[trk]) {
 800         // Initialise a new track
 801         fp = new Float_t[3*(limiE[trk]+chunk)];
 802         if (coorE[trk]) {
 803           memcpy(fp,coorE[trk],sizeof(Float_t)*3*limiE[trk]);
 804           delete [] coorE[trk];
 805         }
 806         limiE[trk] += chunk;
 807         coorE[trk]  = fp;
 808       }
 809       else {
 810         fp = coorE[trk];
 811       }
 812       fp[3*ntrkE[trk]  ] = ahit->X();
 813       fp[3*ntrkE[trk]+1] = ahit->Y();
 814       fp[3*ntrkE[trk]+2] = ahit->Z();
 815       ntrkE[trk]++;
 816
 817     }
 818     // TR photon hits
 819     else if ((ahit->GetCharge() < 0) && (fDrawTR)) {
 820
 821       trk = ahit->GetTrack();
 822       if (ntrkT[trk] == limiT[trk]) {
 823         // Initialise a new track
 824         fp = new Float_t[3*(limiT[trk]+chunk)];
 825         if (coorT[trk]) {
 826           memcpy(fp,coorT[trk],sizeof(Float_t)*3*limiT[trk]);
 827           delete [] coorT[trk];
 828         }
 829         limiT[trk] += chunk;
 830         coorT[trk]  = fp;
 831       }
 832       else {
 833         fp = coorT[trk];
 834       }
 835       fp[3*ntrkT[trk]  ] = ahit->X();
 836       fp[3*ntrkT[trk]+1] = ahit->Y();
 837       fp[3*ntrkT[trk]+2] = ahit->Z();
 838       ntrkT[trk]++;
 839
 840     }
 841
 842     ahit = (AliTRDhit *) NextHit();
 843
 844   }
 845
 846   for (trk = 0; trk < tracks; ++trk) {
 847
 848     if (ntrkE[trk] || ntrkT[trk]) {
 849
 850       points = new AliTRDpoints();
 851       points->SetDetector(this);
 852       points->SetParticle(trk);
 853
 854       // Set the dEdx points
 855       if (ntrkE[trk]) {
 856         points->SetMarkerColor(GetMarkerColor());
 857         points->SetMarkerSize(GetMarkerSize());
 858         points->SetPolyMarker(ntrkE[trk],coorE[trk],GetMarkerStyle());
 859         delete [] coorE[trk];
 860         coorE[trk] = 0;
 861       }
 862
 863       // Set the TR photon points
 864       if (ntrkT[trk]) {
 865         points->SetTRpoints(ntrkT[trk],coorT[trk]);
 866         delete [] coorT[trk];
 867         coorT[trk] = 0;
 868       }
 869
 870       fPoints->AddAt(points,trk);
 871
 872     }
 873
 874   }
 875
 876   delete [] coorE;
 877   delete [] coorT;
 878   delete [] ntrkE;
 879   delete [] ntrkT;
 880   delete [] limiE;
 881   delete [] limiT;
 882
 883 }
 884
 885 //_____________________________________________________________________________
 886 void AliTRD::MakeBranch(Option_t* option)
 887 {
 888   //
 889   // Create Tree branches for the TRD digits.
 890   //
 891
 892   Int_t  buffersize = 4000;
 893   Char_t branchname[15];
 894   sprintf(branchname,"%s",GetName());
 895
 896   const char *cD = strstr(option,"D");
 897
 898   AliDetector::MakeBranch(option);
 899
 900   if (fDigits && gAlice->TreeD() && cD) {
 901     MakeBranchInTree(gAlice->TreeD(),branchname,&fDigits,buffersize,0);
 902   }
 903
 904 }
 905
 906 //_____________________________________________________________________________
 907 void AliTRD::ResetDigits()
 908 {
 909   //
 910   // Reset number of digits and the digits array for this detector
 911   //
 912
 913   fNdigits = 0;
 914   if (fDigits) fDigits->Clear();
 915
 916 }
 917
 918 //_____________________________________________________________________________
 919 void AliTRD::SetTreeAddress()
 920 {
 921   //
 922   // Set the branch addresses for the trees.
 923   //
 924
 925   if ( fLoader->TreeH() && (fHits == 0x0)) {
 926     fHits = new TClonesArray("AliTRDhit",405);
 927   }
 928   AliDetector::SetTreeAddress();
 929
 930 }
 931
 932 //_____________________________________________________________________________
 933 void AliTRD::SetPHOShole()
 934 {
 935   //
 936   // Selects a geometry with a hole in front of the PHOS
 937   //
 938
 939   fGeometry->SetPHOShole();
 940
 941 }
 942
 943 //_____________________________________________________________________________
 944 void AliTRD::SetRICHhole()
 945 {
 946   //
 947   // Selects a geometry with a hole in front of the RICH
 948   //
 949
 950   fGeometry->SetRICHhole();
 951
 952 }
 953
 954 //_____________________________________________________________________________
 955 AliTRD &AliTRD::operator=(const AliTRD &trd)
 956 {
 957   //
 958   // Assignment operator
 959   //
 960
 961   if (this != &trd) ((AliTRD &) trd).Copy(*this);
 962   return *this;
 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
1292
1293
1294
1295
1296
1297
1298
1299