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