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