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