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