TRD/AliTRD.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18 ///////////////////////////////////////////////////////////////////////////////
  19 //                                                                           //
  20 //  Transition Radiation Detector                                            //
  21 //  This class contains the basic functions for the Transition Radiation     //
  22 //  Detector.                                                                //
  23 //                                                                           //
  24 ///////////////////////////////////////////////////////////////////////////////
  25
  26 #include <stdlib.h>
  27 #include <Riostream.h>
  28
  29 #include <TFile.h>
  30 #include <TGeometry.h>
  31 #include <TLorentzVector.h>
  32 #include <TMath.h>
  33 #include <TNode.h>
  34 #include <TPGON.h>
  35 #include <TParticle.h>
  36 #include <TROOT.h>
  37 #include <TTree.h>
  38 #include <TVirtualMC.h>
  39
  40 #include "AliConst.h"
  41 #include "AliDigit.h"
  42 #include "AliLoader.h"
  43 #include "AliLog.h"
  44 #include "AliMC.h"
  45 #include "AliMagF.h"
  46 #include "AliRun.h"
  47 #include "AliTrackReference.h"
  48
  49 #include "AliTRD.h"
  50 #include "AliTRDdigit.h"
  51 #include "AliTRDdigitizer.h"
  52 #include "AliTRDdigitsManager.h"
  53 #include "AliTRDgeometry.h"
  54 #include "AliTRDhit.h"
  55 #include "AliTRDpoints.h"
  56 #include "AliTRDrawData.h"
  57 #include "AliTRDSimParam.h"
  58 #include "AliTRDRecParam.h"
  59 #include "AliTRDCommonParam.h"
  60 #include "AliTRDcalibDB.h"
  61
  62 ClassImp(AliTRD)
  63
  64 //_____________________________________________________________________________
  65 AliTRD::AliTRD()
  66   :AliDetector()
  67   ,fGeometry(0)
  68   ,fGasDensity(0)
  69   ,fFoilDensity(0)
  70   ,fDrawTR(0)
  71   ,fDisplayType(0)
  72 {
  73   //
  74   // Default constructor
  75   //
  76
  77 }
  78
  79 //_____________________________________________________________________________
  80 AliTRD::AliTRD(const char *name, const char *title)
  81   :AliDetector(name,title)
  82   ,fGeometry(0)
  83   ,fGasDensity(0)
  84   ,fFoilDensity(0)
  85   ,fDrawTR(0)
  86   ,fDisplayType(0)
  87 {
  88   //
  89   // Standard constructor for the TRD
  90   //
  91
  92   // Check that FRAME is there otherwise we have no place where to put TRD
  93   AliModule *frame = gAlice->GetModule("FRAME");
  94   if (!frame) {
  95     AliError("TRD needs FRAME to be present\n");
  96     exit(1);
  97   }
  98
  99   // Define the TRD geometry
 100   if ((frame->IsVersion() == 0) ||
 101       (frame->IsVersion() == 1)) {
 102     fGeometry = new AliTRDgeometry();
 103   }
 104   else {
 105     AliError("Could not find valid FRAME version\n");
 106     exit(1);
 107   }
 108
 109   // Save the geometry
 110   TDirectory *saveDir = gDirectory;
 111   gAlice->GetRunLoader()->CdGAFile();
 112   fGeometry->Write("TRDgeometry");
 113   saveDir->cd();
 114
 115   // Allocate the hit array
 116   fHits = new TClonesArray("AliTRDhit",405);
 117   gAlice->GetMCApp()->AddHitList(fHits);
 118
 119   //PH SetMarkerColor(kWhite);
 120
 121 }
 122
 123 //_____________________________________________________________________________
 124 AliTRD::~AliTRD()
 125 {
 126   //
 127   // TRD destructor
 128   //
 129
 130   if (fGeometry) {
 131     delete fGeometry;
 132     fGeometry = 0;
 133   }
 134
 135   if (fHits) {
 136     delete fHits;
 137     fHits     = 0;
 138   }
 139
 140 }
 141
 142 //_____________________________________________________________________________
 143 void AliTRD::Hits2Digits()
 144 {
 145   //
 146   // Create digits
 147   //
 148
 149   AliTRDdigitizer digitizer("TRDdigitizer","TRD digitizer class");
 150   AliLog::SetClassDebugLevel("TRDdigitizer",AliDebugLevel());
 151
 152   // Initialization
 153   digitizer.InitDetector();
 154
 155   if (!fLoader->TreeH()) {
 156     fLoader->LoadHits("read");
 157   }
 158   fLoader->LoadDigits("recreate");
 159
 160   AliRunLoader *runLoader = fLoader->GetRunLoader();
 161
 162   for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
 163     runLoader->GetEvent(iEvent);
 164     digitizer.Open(runLoader,iEvent);
 165     digitizer.MakeDigits();
 166     digitizer.WriteDigits();
 167   }
 168
 169   fLoader->UnloadHits();
 170   fLoader->UnloadDigits();
 171
 172 }
 173
 174 //_____________________________________________________________________________
 175 void AliTRD::Hits2SDigits()
 176 {
 177   //
 178   // Create summable digits
 179   //
 180
 181   AliTRDdigitizer digitizer("TRDdigitizer","TRD digitizer class");
 182   // For the summable digits
 183   digitizer.SetSDigits(kTRUE);
 184   AliLog::SetClassDebugLevel("TRDdigitizer",AliDebugLevel());
 185
 186   // Initialization
 187   digitizer.InitDetector();
 188
 189   if (!fLoader->TreeH()) {
 190     fLoader->LoadHits("read");
 191   }
 192   fLoader->LoadSDigits("recreate");
 193
 194   AliRunLoader *runLoader = fLoader->GetRunLoader();
 195
 196   for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
 197     runLoader->GetEvent(iEvent);
 198     digitizer.Open(runLoader,iEvent);
 199     digitizer.MakeDigits();
 200     digitizer.WriteDigits();
 201   }
 202
 203   fLoader->UnloadHits();
 204   fLoader->UnloadSDigits();
 205
 206 }
 207
 208 //_____________________________________________________________________________
 209 AliDigitizer *AliTRD::CreateDigitizer(AliRunDigitizer *manager) const
 210 {
 211   //
 212   // Creates a new digitizer object
 213   //
 214
 215   return new AliTRDdigitizer(manager);
 216
 217 }
 218
 219 //_____________________________________________________________________________
 220 void AliTRD::SDigits2Digits()
 221 {
 222   //
 223   // Create final digits from summable digits
 224   //
 225
 226   // Create the TRD digitizer
 227   AliTRDdigitizer digitizer("TRDdigitizer","TRD digitizer class");
 228   AliLog::SetClassDebugLevel("TRDdigitizer",AliDebugLevel());
 229
 230   // Set the parameter
 231   digitizer.SetEvent(gAlice->GetEvNumber());
 232
 233   // Initialization
 234   digitizer.InitDetector();
 235
 236   // Read the s-digits via digits manager
 237   AliTRDdigitsManager sdigitsManager;
 238
 239   AliLog::SetClassDebugLevel("TRDdigitisManager",AliDebugLevel());
 240   sdigitsManager.SetSDigits(kTRUE);
 241   sdigitsManager.CreateArrays();
 242
 243   if (!fLoader->TreeS()) {
 244     if (fLoader->LoadSDigits("read")) {
 245       return;
 246     }
 247   }
 248   if (!fLoader->TreeS()) {
 249     AliError(Form("Error while reading SDigits for event %d",gAlice->GetEvNumber()));
 250     return;
 251   }
 252
 253   sdigitsManager.ReadDigits(fLoader->TreeS());
 254
 255   // Add the s-digits to the input list
 256   digitizer.AddSDigitsManager(&sdigitsManager);
 257
 258   // Convert the s-digits to normal digits
 259   digitizer.SDigits2Digits();
 260
 261   // Store the digits
 262   if (!fLoader->TreeD()) {
 263     fLoader->MakeTree("D");
 264   }
 265   if (digitizer.MakeBranch(fLoader->TreeD())){
 266     digitizer.WriteDigits();
 267   }
 268
 269 }
 270
 271 //_____________________________________________________________________________
 272 void AliTRD::Digits2Raw()
 273 {
 274   //
 275   // Convert digits of the current event to raw data
 276   //
 277
 278   fLoader->LoadDigits();
 279   TTree *digits = fLoader->TreeD();
 280   if (!digits) {
 281     AliError("No digits tree");
 282     return;
 283   }
 284
 285   AliTRDrawData rawWriter;
 286   if (!rawWriter.Digits2Raw(digits)) {
 287     AliError("The raw writer could not load the digits tree");
 288   }
 289
 290   fLoader->UnloadDigits();
 291
 292 }
 293
 294 //_____________________________________________________________________________
 295 void AliTRD::AddHit(Int_t track, Int_t det, Float_t *hits, Int_t q
 296                   , Bool_t inDrift)
 297 {
 298   //
 299   // Add a hit for the TRD
 300   //
 301
 302   TClonesArray &lhits = *fHits;
 303   AliTRDhit *hit = new(lhits[fNhits++]) AliTRDhit(fIshunt,track,det,hits,q);
 304
 305   if (inDrift) {
 306     hit->SetDrift();
 307   }
 308   else {
 309     hit->SetAmplification();
 310   }
 311
 312   if (q < 0) {
 313     hit->SetTRphoton();
 314   }
 315
 316 }
 317
 318 //_____________________________________________________________________________
 319 void AliTRD::BuildGeometry()
 320 {
 321   //
 322   // Create the ROOT TNode geometry for the TRD
 323   //
 324
 325   TNode *node;
 326   TNode *top;
 327   TPGON *pgon;
 328
 329   // The dimensions of the TRD super module
 330   const Float_t kRmin  = 291.0;
 331   const Float_t kRmax  = 369.0;
 332   const Float_t kZmax1 = 378.35;
 333   const Float_t kZmax2 = 302.0;
 334
 335   Float_t rmin;
 336   Float_t rmax;
 337   Float_t zmax1;
 338   Float_t zmax2;
 339
 340   Int_t   iPlan;
 341
 342   const Int_t kColorTRD = 46;
 343
 344   // Find the top node alice
 345   top = gAlice->GetGeometry()->GetNode("alice");
 346
 347   if      (fDisplayType == 0) {
 348
 349     pgon = new TPGON("S_TRD","TRD","void",0,360,AliTRDgeometry::Nsect(),4);
 350     rmin = kRmin;
 351     rmax = kRmax;
 352     pgon->DefineSection(0,-kZmax1,rmax,rmax);
 353     pgon->DefineSection(1,-kZmax2,rmin,rmax);
 354     pgon->DefineSection(2, kZmax2,rmin,rmax);
 355     pgon->DefineSection(3, kZmax1,rmax,rmax);
 356     top->cd();
 357     node = new TNode("TRD","TRD","S_TRD",0,0,0,"");
 358     node->SetLineColor(kColorTRD);
 359     fNodes->Add(node);
 360
 361   }
 362   else if (fDisplayType == 1) {
 363
 364     Char_t name[7];
 365
 366     Float_t slope = (kZmax1 - kZmax2) / (kRmax  - kRmin);
 367
 368     rmin  = kRmin + AliTRDgeometry::CraHght();
 369     rmax  = rmin  + AliTRDgeometry::CdrHght();
 370
 371     Float_t thickness = rmin - kRmin;
 372     zmax2 = kZmax2 + slope * thickness;
 373     zmax1 = zmax2 + slope * AliTRDgeometry::DrThick();
 374
 375     for (iPlan = 0; iPlan < AliTRDgeometry::Nplan(); iPlan++) {
 376
 377       sprintf(name,"S_TR1%d",iPlan);
 378       pgon  = new TPGON(name,"TRD","void",0,360,AliTRDgeometry::Nsect(),4);
 379       pgon->DefineSection(0,-zmax1,rmax,rmax);
 380       pgon->DefineSection(1,-zmax2,rmin,rmax);
 381       pgon->DefineSection(2, zmax2,rmin,rmax);
 382       pgon->DefineSection(3, zmax1,rmax,rmax);
 383       top->cd();
 384       node = new TNode("TRD","TRD",name,0,0,0,"");
 385       node->SetLineColor(kColorTRD);
 386       fNodes->Add(node);
 387
 388       Float_t height = AliTRDgeometry::Cheight() + AliTRDgeometry::Cspace();
 389       rmin  = rmin  + height;
 390       rmax  = rmax  + height;
 391       zmax1 = zmax1 + slope * height;
 392       zmax2 = zmax2 + slope * height;
 393
 394     }
 395
 396     thickness += AliTRDgeometry::DrThick();
 397     rmin       = kRmin  + thickness;
 398     rmax       = rmin   + AliTRDgeometry::AmThick();
 399     zmax2      = kZmax2 + slope * thickness;
 400     zmax1      = zmax2  + slope * AliTRDgeometry::AmThick();
 401
 402     for (iPlan = 0; iPlan < AliTRDgeometry::Nplan(); iPlan++) {
 403
 404       sprintf(name,"S_TR2%d",iPlan);
 405       pgon  = new TPGON(name,"TRD","void",0,360,AliTRDgeometry::Nsect(),4);
 406       pgon->DefineSection(0,-zmax1,rmax,rmax);
 407       pgon->DefineSection(1,-zmax2,rmin,rmax);
 408       pgon->DefineSection(2, zmax2,rmin,rmax);
 409       pgon->DefineSection(3, zmax1,rmax,rmax);
 410       top->cd();
 411       node = new TNode("TRD","TRD",name,0,0,0,"");
 412       node->SetLineColor(kColorTRD);
 413       fNodes->Add(node);
 414
 415       Float_t height = AliTRDgeometry::Cheight() + AliTRDgeometry::Cspace();
 416       rmin  = rmin  + height;
 417       rmax  = rmax  + height;
 418       zmax1 = zmax1 + slope * height;
 419       zmax2 = zmax2 + slope * height;
 420
 421     }
 422
 423   }
 424
 425 }
 426
 427 //_____________________________________________________________________________
 428 void AliTRD::CreateGeometry()
 429 {
 430   //
 431   // Creates the volumes for the TRD chambers
 432   //
 433
 434   // Check that FRAME is there otherwise we have no place where to put the TRD
 435   AliModule *frame = gAlice->GetModule("FRAME");
 436   if (!frame) {
 437     AliFatal("The TRD needs the FRAME to be defined first");
 438   }
 439
 440   fGeometry->CreateGeometry(fIdtmed->GetArray() - 1299);
 441
 442 }
 443
 444 //_____________________________________________________________________________
 445 void AliTRD::CreateMaterials()
 446 {
 447   //
 448   // Create the materials for the TRD
 449   //
 450
 451   Int_t   isxfld = gAlice->Field()->Integ();
 452   Float_t sxmgmx = gAlice->Field()->Max();
 453
 454   // For polyethilene (CH2)
 455   Float_t ape[2]    = { 12.011 ,  1.0079 };
 456   Float_t zpe[2]    = {  6.0   ,  1.0    };
 457   Float_t wpe[2]    = {  1.0   ,  2.0    };
 458   Float_t dpe       = 0.95;
 459
 460   // For CO2
 461   Float_t aco[2]    = { 12.011 , 15.9994 };
 462   Float_t zco[2]    = {  6.0   ,  8.0    };
 463   Float_t wco[2]    = {  1.0   ,  2.0    };
 464   Float_t dco       = 0.00186;
 465
 466   // For water
 467   Float_t awa[2]    = {  1.0079, 15.9994 };
 468   Float_t zwa[2]    = {  1.0   ,  8.0    };
 469   Float_t wwa[2]    = {  2.0   ,  1.0    };
 470   Float_t dwa       = 1.0;
 471
 472   // For isobutane (C4H10)
 473   Float_t ais[2]    = { 12.011 ,  1.0079 };
 474   Float_t zis[2]    = {  6.0   ,  1.0    };
 475   Float_t wis[2]    = {  4.0   , 10.0    };
 476   Float_t dis       = 0.00267;
 477
 478   // For plexiglas (C5H8O2)
 479   Float_t apg[3]    = { 12.011 ,  1.0079, 15.9994 };
 480   Float_t zpg[3]    = {  6.0   ,  1.0   ,  8.0    };
 481   Float_t wpg[3]    = {  5.0   ,  8.0   ,  2.0    };
 482   Float_t dpg       = 1.18;
 483
 484   // For epoxy (C18H19O3)
 485   Float_t aEpoxy[3] = { 15.9994,  1.0079, 12.011  };
 486   Float_t zEpoxy[3] = {  8.0   ,  1.0   ,  6.0    };
 487   Float_t wEpoxy[3] = {  3.0   , 19.0   , 18.0    };
 488   Float_t dEpoxy    = 1.8 ;
 489
 490   // For Araldite, low density epoxy (C18H19O3)
 491   Float_t aAral[3]  = { 15.9994,  1.0079, 12.011  };
 492   Float_t zAral[3]  = {  8.0   ,  1.0   ,  6.0    };
 493   Float_t wAral[3]  = {  3.0   , 19.0   , 18.0    };
 494   Float_t dAral     = 1.05;
 495
 496   // For air
 497   Float_t aAir[4]   = { 12.011   , 14.0     , 15.9994  , 36.0      };
 498   Float_t zAir[4]   = {  6.0     ,  7.0     ,  8.0     , 18.0      };
 499   Float_t wAir[4]   = {  0.000124,  0.755267,  0.231781,  0.012827 };
 500   Float_t dAir      = 1.20479e-03;
 501
 502   // For G10
 503   Float_t aG10[4]   = {  1.0079  , 12.011   , 15.9994  , 28.086    };
 504   Float_t zG10[4]   = {  1.0     ,  6.0     ,  8.0     , 14.0      };
 505   Float_t wG10[4]   = {  0.15201 ,  0.10641 ,  0.49444 ,  0.24714  };
 506   Float_t dG10      = 1.7;
 507
 508   // For Xe/CO2-gas-mixture
 509   Float_t aXeCO2[3] = { 131.29   ,  12.0107 ,  15.9994  };
 510   Float_t zXeCO2[3] = {  54.0    ,   6.0    ,   8.0     };
 511   Float_t wXeCO2[3] = {   8.5    ,   1.5    ,   3.0     };
 512   // Xe-content of the Xe/CO2-mixture (85% / 15%)
 513   Float_t fxc       = 0.85;
 514   Float_t dxe       = 0.00549;
 515   Float_t dgm       = fxc * dxe + (1.0 - fxc) * dco;
 516
 517   // General tracking parameter
 518   Float_t tmaxfd    = -10.0;
 519   Float_t stemax    = -1.0e10;
 520   Float_t deemax    = -0.1;
 521   Float_t epsil     =  1.0e-4;
 522   Float_t stmin     = -0.001;
 523
 524   //////////////////////////////////////////////////////////////////////////
 525   //     Define Materials
 526   //////////////////////////////////////////////////////////////////////////
 527
 528   AliMaterial( 1, "Al"   ,  26.98, 13.0, 2.7     ,     8.9 ,    37.2);
 529   AliMaterial( 4, "Xe"   , 131.29, 54.0, dxe     ,  1546.16,     0.0);
 530   AliMaterial( 5, "Cu"   ,  63.54, 29.0, 8.96    ,     1.43,    14.8);
 531   AliMaterial( 6, "C"    ,  12.01,  6.0, 2.265   ,    18.8 ,    74.4);
 532   AliMaterial(15, "Sn"   , 118.71, 50.0, 7.31    ,     1.21,    14.8);
 533   AliMaterial(16, "Si"   ,  28.09, 14.0, 2.33    ,     9.36,    37.2);
 534   AliMaterial(18, "Fe"   ,  55.85, 26.0, 7.87    ,     1.76,    14.8);
 535
 536   // Mixtures
 537   AliMixture(2, "Air"         , aAir,   zAir,   dAir,    4, wAir  );
 538   AliMixture(3, "Polyethilene", ape,    zpe,    dpe,    -2, wpe   );
 539   AliMixture(8, "CO2",          aco,    zco,    dco,    -2, wco   );
 540   AliMixture(9, "Isobutane",    ais,    zis,    dis,    -2, wis   );
 541   AliMixture(10,"Gas mixture",  aXeCO2, zXeCO2, dgm,    -3, wXeCO2);
 542   AliMixture(12,"G10",          aG10,   zG10,   dG10,    4, wG10  );
 543   AliMixture(13,"Water",        awa,    zwa,    dwa,    -2, wwa   );
 544   AliMixture(14,"Plexiglas",    apg,    zpg,    dpg,    -3, wpg   );
 545   AliMixture(17,"Epoxy",        aEpoxy, zEpoxy, dEpoxy, -3, wEpoxy);
 546   AliMixture(19,"Araldite",     aAral,  zAral,  dAral,  -3, wAral );
 547
 548   //////////////////////////////////////////////////////////////////////////
 549   //     Tracking Media Parameters
 550   //////////////////////////////////////////////////////////////////////////
 551
 552   // Al Frame
 553   AliMedium( 1,"Al Frame"   , 1,0,isxfld,sxmgmx
 554               ,tmaxfd,stemax,deemax,epsil,stmin);
 555   // Air
 556   AliMedium( 2,"Air"        , 2,0,isxfld,sxmgmx
 557               ,tmaxfd,stemax,deemax,epsil,stmin);
 558   // Wires
 559   AliMedium( 3,"Wires"      , 5,0,isxfld,sxmgmx
 560               ,tmaxfd,stemax,deemax,epsil,stmin);
 561   // All other ROB materials (caps, etc.)
 562   AliMedium( 4,"ROB Other"  , 5,0,isxfld,sxmgmx
 563               ,tmaxfd,stemax,deemax,epsil,stmin);
 564   // Cu pads
 565   AliMedium( 5,"Padplane"   , 5,1,isxfld,sxmgmx
 566               ,tmaxfd,stemax,deemax,epsil,stmin);
 567   // Fee + cables
 568   AliMedium( 6,"Readout"    , 5,0,isxfld,sxmgmx
 569               ,tmaxfd,stemax,deemax,epsil,stmin);
 570   // C frame
 571   AliMedium( 7,"C Frame"    , 6,0,isxfld,sxmgmx
 572               ,tmaxfd,stemax,deemax,epsil,stmin);
 573   // INOX of cooling bus bars
 574   AliMedium( 8,"Cooling bus",18,0,isxfld,sxmgmx
 575               ,tmaxfd,stemax,deemax,epsil,stmin);
 576   // Gas-mixture (Xe/CO2)
 577   AliMedium( 9,"Gas-mix"    ,10,1,isxfld,sxmgmx
 578               ,tmaxfd,stemax,deemax,epsil,stmin);
 579   // Nomex-honeycomb
 580   AliMedium(10,"Nomex"      ,12,0,isxfld,sxmgmx
 581               ,tmaxfd,stemax,deemax,epsil,stmin);
 582   // Araldite glue
 583   AliMedium(11,"Glue"       ,19,0,isxfld,sxmgmx
 584               ,tmaxfd,stemax,deemax,epsil,stmin);
 585   // G10-plates
 586   AliMedium(13,"G10-plates" ,12,0,isxfld,sxmgmx
 587               ,tmaxfd,stemax,deemax,epsil,stmin);
 588   // Cooling water
 589   AliMedium(14,"Water"      ,13,0,isxfld,sxmgmx
 590               ,tmaxfd,stemax,deemax,epsil,stmin);
 591   // Rohacell (plexiglas) for the radiator
 592   AliMedium(15,"Rohacell"   ,14,0,isxfld,sxmgmx
 593               ,tmaxfd,stemax,deemax,epsil,stmin);
 594   // Al layer in MCMs
 595   AliMedium(16,"MCM-Al"     , 1,0,isxfld,sxmgmx
 596               ,tmaxfd,stemax,deemax,epsil,stmin);
 597   // Sn layer in MCMs
 598   AliMedium(17,"MCM-Sn"     ,15,0,isxfld,sxmgmx
 599               ,tmaxfd,stemax,deemax,epsil,stmin);
 600   // Cu layer in MCMs
 601   AliMedium(18,"MCM-Cu"     , 5,0,isxfld,sxmgmx
 602               ,tmaxfd,stemax,deemax,epsil,stmin);
 603   // G10 layer in MCMs
 604   AliMedium(19,"MCM-G10"    ,12,0,isxfld,sxmgmx
 605               ,tmaxfd,stemax,deemax,epsil,stmin);
 606   // Si in readout chips
 607   AliMedium(20,"Chip-Si"    ,16,0,isxfld,sxmgmx
 608               ,tmaxfd,stemax,deemax,epsil,stmin);
 609   // Epoxy in readout chips
 610   AliMedium(21,"Chip-Ep"    ,17,0,isxfld,sxmgmx
 611               ,tmaxfd,stemax,deemax,epsil,stmin);
 612   // PE in connectors
 613   AliMedium(22,"Conn-PE"    , 3,0,isxfld,sxmgmx
 614               ,tmaxfd,stemax,deemax,epsil,stmin);
 615   // Cu in connectors
 616   AliMedium(23,"Chip-Cu"    , 5,0,isxfld,sxmgmx
 617               ,tmaxfd,stemax,deemax,epsil,stmin);
 618   // Al of cooling pipes
 619   AliMedium(24,"Cooling"    , 1,0,isxfld,sxmgmx
 620               ,tmaxfd,stemax,deemax,epsil,stmin);
 621   // Cu in services
 622   AliMedium(25,"Serv-Cu"    , 5,0,isxfld,sxmgmx
 623               ,tmaxfd,stemax,deemax,epsil,stmin);
 624
 625   // Special tracking options for charged particles for XeCO2
 626   gMC->Gstpar((* fIdtmed)[9],"DRAY",1.0);
 627   gMC->Gstpar((* fIdtmed)[9],"STRA",1.0);
 628
 629   // Save the density values for the TRD absorbtion
 630   Float_t dmy  = 1.39;
 631   fFoilDensity = dmy;
 632   fGasDensity  = dgm;
 633
 634 }
 635
 636 //_____________________________________________________________________________
 637 void AliTRD::DrawModule() const
 638 {
 639   //
 640   // Draw a shaded view of the Transition Radiation Detector version 0
 641   //
 642
 643   // Set everything unseen
 644   gMC->Gsatt("*"   ,"SEEN",-1);
 645
 646   // Set ALIC mother transparent
 647   gMC->Gsatt("ALIC","SEEN", 0);
 648
 649   // Set the volumes visible
 650   if (fGeometry->IsVersion() == 0) {
 651     gMC->Gsatt("B071","SEEN", 0);
 652     gMC->Gsatt("B074","SEEN", 0);
 653     gMC->Gsatt("B075","SEEN", 0);
 654     gMC->Gsatt("B077","SEEN", 0);
 655     gMC->Gsatt("BTR1","SEEN", 0);
 656     gMC->Gsatt("BTR2","SEEN", 0);
 657     gMC->Gsatt("BTR3","SEEN", 0);
 658     gMC->Gsatt("UTR1","SEEN", 0);
 659     gMC->Gsatt("UTR2","SEEN", 0);
 660     gMC->Gsatt("UTR3","SEEN", 0);
 661   }
 662   else {
 663     gMC->Gsatt("B071","SEEN", 0);
 664     gMC->Gsatt("B074","SEEN", 0);
 665     gMC->Gsatt("B075","SEEN", 0);
 666     gMC->Gsatt("B077","SEEN", 0);
 667     gMC->Gsatt("BTR1","SEEN", 0);
 668     gMC->Gsatt("BTR2","SEEN", 0);
 669     gMC->Gsatt("BTR3","SEEN", 0);
 670     gMC->Gsatt("UTR1","SEEN", 0);
 671   }
 672
 673   gMC->Gdopt("hide", "on");
 674   gMC->Gdopt("shad", "on");
 675   gMC->Gsatt("*", "fill", 7);
 676   gMC->SetClipBox(".");
 677   gMC->SetClipBox("*", 0, 2000, -2000, 2000, -2000, 2000);
 678   gMC->DefaultRange();
 679   gMC->Gdraw("alic", 40, 30, 0, 12, 9.4, .021, .021);
 680   gMC->Gdhead(1111, "Transition Radiation Detector");
 681   gMC->Gdman(18, 4, "MAN");
 682
 683 }
 684
 685 //_____________________________________________________________________________
 686 Int_t AliTRD::DistancetoPrimitive(Int_t , Int_t )
 687 {
 688   //
 689   // Distance between the mouse and the TRD detector on the screen
 690   // Dummy routine
 691   //
 692
 693   return 9999;
 694
 695 }
 696
 697 //_____________________________________________________________________________
 698 void AliTRD::Init()
 699 {
 700   //
 701   // Initialize the TRD detector after the geometry has been created
 702   //
 703
 704   AliDebug(1,"++++++++++++++++++++++++++++++++++++++++++++++");
 705
 706   if (fGeometry->IsVersion() != 1) {
 707     AliError("Not a valid geometry");
 708   }
 709
 710 }
 711
 712 //_____________________________________________________________________________
 713 void AliTRD::LoadPoints(Int_t )
 714 {
 715   //
 716   // Store x, y, z of all hits in memory.
 717   // Hit originating from TR photons are given a different color
 718   //
 719
 720   if (fHits == 0) {
 721     return;
 722   }
 723
 724   Int_t nhits  = fHits->GetEntriesFast();
 725   if (nhits == 0) {
 726     return;
 727   }
 728
 729   Int_t tracks = gAlice->GetMCApp()->GetNtrack();
 730   if (fPoints == 0) {
 731     fPoints = new TObjArray(tracks);
 732   }
 733
 734   AliTRDhit *ahit;
 735
 736   Int_t    *ntrkE = new Int_t[tracks];
 737   Int_t    *ntrkT = new Int_t[tracks];
 738   Int_t    *limiE = new Int_t[tracks];
 739   Int_t    *limiT = new Int_t[tracks];
 740   Float_t **coorE = new Float_t*[tracks];
 741   Float_t **coorT = new Float_t*[tracks];
 742   for(Int_t i = 0; i < tracks; i++) {
 743     ntrkE[i] = 0;
 744     ntrkT[i] = 0;
 745     coorE[i] = 0;
 746     coorT[i] = 0;
 747     limiE[i] = 0;
 748     limiT[i] = 0;
 749   }
 750
 751   AliTRDpoints *points = 0;
 752   Float_t      *fp     = 0;
 753   Int_t         trk;
 754   Int_t         chunk  = nhits / 4 + 1;
 755
 756   // Loop over all the hits and store their position
 757   ahit = (AliTRDhit *) FirstHit(-1);
 758   while (ahit) {
 759
 760     // dEdx hits
 761     if (ahit->GetCharge() >= 0) {
 762
 763       trk = ahit->GetTrack();
 764       if (ntrkE[trk] == limiE[trk]) {
 765         // Initialise a new track
 766         fp = new Float_t[3*(limiE[trk]+chunk)];
 767         if (coorE[trk]) {
 768           memcpy(fp,coorE[trk],sizeof(Float_t)*3*limiE[trk]);
 769           delete [] coorE[trk];
 770         }
 771         limiE[trk] += chunk;
 772         coorE[trk]  = fp;
 773       }
 774       else {
 775         fp = coorE[trk];
 776       }
 777       fp[3*ntrkE[trk]  ] = ahit->X();
 778       fp[3*ntrkE[trk]+1] = ahit->Y();
 779       fp[3*ntrkE[trk]+2] = ahit->Z();
 780       ntrkE[trk]++;
 781
 782     }
 783     // TR photon hits
 784     else if ((ahit->GetCharge() < 0) &&
 785              (fDrawTR)) {
 786
 787       trk = ahit->GetTrack();
 788       if (ntrkT[trk] == limiT[trk]) {
 789         // Initialise a new track
 790         fp = new Float_t[3*(limiT[trk]+chunk)];
 791         if (coorT[trk]) {
 792           memcpy(fp,coorT[trk],sizeof(Float_t)*3*limiT[trk]);
 793           delete [] coorT[trk];
 794         }
 795         limiT[trk] += chunk;
 796         coorT[trk]  = fp;
 797       }
 798       else {
 799         fp = coorT[trk];
 800       }
 801       fp[3*ntrkT[trk]  ] = ahit->X();
 802       fp[3*ntrkT[trk]+1] = ahit->Y();
 803       fp[3*ntrkT[trk]+2] = ahit->Z();
 804       ntrkT[trk]++;
 805
 806     }
 807
 808     ahit = (AliTRDhit *) NextHit();
 809
 810   }
 811
 812   for (trk = 0; trk < tracks; ++trk) {
 813
 814     if (ntrkE[trk] || ntrkT[trk]) {
 815
 816       points = new AliTRDpoints();
 817       points->SetDetector(this);
 818       points->SetParticle(trk);
 819
 820       // Set the dEdx points
 821       if (ntrkE[trk]) {
 822         points->SetMarkerColor(kWhite); //PH This is the default color in TRD
 823         points->SetMarkerSize(1); //PH Default size=1
 824         points->SetPolyMarker(ntrkE[trk],coorE[trk],1); //PH Default style=1
 825         delete [] coorE[trk];
 826         coorE[trk] = 0;
 827       }
 828
 829       // Set the TR photon points
 830       if (ntrkT[trk]) {
 831         points->SetTRpoints(ntrkT[trk],coorT[trk]);
 832         delete [] coorT[trk];
 833         coorT[trk] = 0;
 834       }
 835
 836       fPoints->AddAt(points,trk);
 837
 838     }
 839
 840   }
 841
 842   delete [] coorE;
 843   delete [] coorT;
 844   delete [] ntrkE;
 845   delete [] ntrkT;
 846   delete [] limiE;
 847   delete [] limiT;
 848
 849 }
 850
 851 //_____________________________________________________________________________
 852 void AliTRD::MakeBranch(Option_t *option)
 853 {
 854   //
 855   // Create Tree branches for the TRD digits.
 856   //
 857
 858   Int_t  buffersize = 4000;
 859   Char_t branchname[15];
 860   sprintf(branchname,"%s",GetName());
 861
 862   const Char_t *cD = strstr(option,"D");
 863
 864   AliDetector::MakeBranch(option);
 865
 866   if (fDigits         &&
 867       gAlice->TreeD() &&
 868       cD) {
 869     MakeBranchInTree(gAlice->TreeD(),branchname,&fDigits,buffersize,0);
 870   }
 871
 872 }
 873
 874 //_____________________________________________________________________________
 875 void AliTRD::ResetDigits()
 876 {
 877   //
 878   // Reset number of digits and the digits array for this detector
 879   //
 880
 881   fNdigits = 0;
 882
 883   if (fDigits) {
 884     fDigits->Clear();
 885   }
 886
 887 }
 888
 889 //_____________________________________________________________________________
 890 void AliTRD::SetTreeAddress()
 891 {
 892   //
 893   // Set the branch addresses for the trees.
 894   //
 895
 896   if (fLoader->TreeH() &&
 897       (fHits == 0x0)) {
 898     fHits = new TClonesArray("AliTRDhit",405);
 899   }
 900   AliDetector::SetTreeAddress();
 901
 902 }
 903
 904 //_____________________________________________________________________________
 905 AliTRD &AliTRD::operator=(const AliTRD &trd)
 906 {
 907   //
 908   // Assignment operator
 909   //
 910
 911   if (this != &trd) {
 912     ((AliTRD &) trd).Copy(*this);
 913   }
 914
 915   return *this;
 916
 917 }
 918
 919
 920
 921
 922
 923
 924
 925
 926
 927
 928
 929
 930
 931
 932
 933
 934
 935
 936
 937
 938
 939
 940
 941
 942
 943
 944
 945
 946
 947
 948
 949
 950
 951
 952
 953
 954
 955
 956
 957
 958
 959
 960
 961
 962
 963
 964
 965
 966
 967
 968
 969
 970
 971
 972
 973
 974
 975
 976
 977
 978
 979
 980
 981
 982
 983
 984
 985
 986
 987
 988
 989
 990
 991
 992
 993
 994
 995
 996
 997
 998
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252