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