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