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