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