]> git.uio.no Git - u/mrichter/AliRoot.git/blame - TRD/AliTRDmatrix.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
New class to make V2 clusters starting from digits or hits (fast simulation). Origin...
[u/mrichter/AliRoot.git] / TRD / AliTRDmatrix.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
16/*
17$Log$
b9d0a01d 18Revision 1.10.12.2 2002/07/24 10:09:30 alibrary
19Updating VirtualMC
20
21Revision 1.10.12.1 2002/06/10 15:28:58 hristov
22Merged with v3-08-02
23
24Revision 1.11 2002/03/28 14:59:07 cblume
25Coding conventions
26
27Revision 1.11 2002/03/28 14:59:07 cblume
28Coding conventions
29
0a29d0f1 30Revision 1.10 2000/11/20 08:56:51 cblume
31Fix the binning of the histograms
32
580727b0 33Revision 1.9 2000/11/01 14:53:21 cblume
34Merge with TRD-develop
35
793ff80c 36Revision 1.4.2.5 2000/10/17 02:27:34 cblume
37Get rid of global constants
38
39Revision 1.4.2.4 2000/10/06 16:49:46 cblume
40Made Getters const
41
42Revision 1.4.2.3 2000/10/04 16:34:58 cblume
43Replace include files by forward declarations
44
45Revision 1.8 2000/06/09 11:10:07 cblume
46Compiler warnings and coding conventions, next round
47
dd9a6ee3 48Revision 1.7 2000/06/08 18:32:58 cblume
49Make code compliant to coding conventions
50
8230f242 51Revision 1.6 2000/05/08 15:48:30 cblume
52Resolved merge conflict
53
9583ab1c 54Revision 1.4.2.2 2000/05/08 14:50:58 cblume
55Add functions ProjRow(), ProjCol(), and ProjTime()
56
57Revision 1.4.2.1 2000/04/27 12:47:02 cblume
58Replace Fill3() by Fill()
59
1befd3b2 60Revision 1.4 2000/02/28 19:10:26 cblume
61Include the new TRD classes
62
851d3db9 63Revision 1.3.4.1 2000/02/28 17:57:47 cblume
64GetTrack returns now -1 if no track is found
65
66Revision 1.3 1999/10/04 14:48:07 fca
67Avoid warnings on non-ansi compiler HP-UX CC
68
7d83513f 69Revision 1.2 1999/09/29 09:24:35 fca
70Introduction of the Copyright and cvs Log
71
4c039060 72*/
73
99d5402e 74///////////////////////////////////////////////////////////////////////////////
75// //
76// Contains the pixel information for one TRD chamber //
77// //
0a29d0f1 78// //
99d5402e 79///////////////////////////////////////////////////////////////////////////////
80
793ff80c 81#include <TObjArray.h>
82#include <TH2.h>
83#include <TH3.h>
84#include <TStyle.h>
85#include <TCanvas.h>
86
99d5402e 87#include "AliTRDmatrix.h"
793ff80c 88#include "AliTRDpixel.h"
99d5402e 89
90ClassImp(AliTRDmatrix)
91
92//_____________________________________________________________________________
93AliTRDmatrix::AliTRDmatrix():TObject()
94{
95 //
96 // Create a TRD detector matrix
97 //
98
99 fRow = 0;
100 fCol = 0;
101 fTime = 0;
102 fPixel = 0;
103 fSector = 0;
104 fChamber = 0;
105 fPlane = 0;
106 fPixelArray = NULL;
107
108}
109
110//_____________________________________________________________________________
111AliTRDmatrix::AliTRDmatrix(Int_t nRow, Int_t nCol, Int_t nTime
112 , Int_t iSec, Int_t iCha, Int_t iPla)
113 :TObject()
114{
115 //
116 // Create a TRD detector matrix with a given size
117 //
118
119 fRow = nRow;
120 fCol = nCol;
121 fTime = nTime;
122 fPixel = nRow * nCol * nTime;
123 fSector = iSec;
124 fChamber = iCha;
125 fPlane = iPla;
126 fPixelArray = new TObjArray(fPixel);
127 for (Int_t iPixel = 0; iPixel < fPixel; iPixel++) {
128 AliTRDpixel *pixel = new AliTRDpixel();
129 fPixelArray->Add(pixel);
130 }
131
132}
133
8230f242 134//_____________________________________________________________________________
dd9a6ee3 135AliTRDmatrix::AliTRDmatrix(const AliTRDmatrix &m)
8230f242 136{
137 //
138 // AliTRDmatrix copy constructor
139 //
140
dd9a6ee3 141 ((AliTRDmatrix &) m).Copy(*this);
8230f242 142
143}
144
99d5402e 145//_____________________________________________________________________________
146AliTRDmatrix::~AliTRDmatrix()
147{
8230f242 148 //
149 // AliTRDmatrix destructor
150 //
99d5402e 151
152 if (fPixelArray) {
153 fPixelArray->Delete();
154 delete fPixelArray;
155 }
156
157}
158
dd9a6ee3 159//_____________________________________________________________________________
160AliTRDmatrix &AliTRDmatrix::operator=(const AliTRDmatrix &m)
161{
162 //
163 // Assignment operator
164 //
165
166 if (this != &m) ((AliTRDmatrix &) m).Copy(*this);
167 return *this;
168
169}
170
99d5402e 171//_____________________________________________________________________________
172void AliTRDmatrix::AddSignal(Int_t iRow, Int_t iCol, Int_t iTime, Float_t signal)
173{
174 //
175 // Add a value to the amplitude of the signal for one specific pixel
176 //
177
178 AliTRDpixel *pixel = GetPixel(iRow,iCol,iTime);
179 if (pixel) {
180 signal += pixel->GetSignal();
181 pixel->SetSignal(signal);
182 }
183
184}
185
8230f242 186//_____________________________________________________________________________
dd9a6ee3 187void AliTRDmatrix::Copy(TObject &m)
8230f242 188{
189 //
190 // Copy function
191 //
192
dd9a6ee3 193 ((AliTRDmatrix &) m).fRow = fRow;
194 ((AliTRDmatrix &) m).fCol = fCol;
195 ((AliTRDmatrix &) m).fTime = fTime;
196 ((AliTRDmatrix &) m).fPixel = fPixel;
197 ((AliTRDmatrix &) m).fSector = fSector;
198 ((AliTRDmatrix &) m).fChamber = fChamber;
199 ((AliTRDmatrix &) m).fPlane = fPlane;
8230f242 200
dd9a6ee3 201 ((AliTRDmatrix &) m).fPixelArray = new TObjArray(*fPixelArray);
8230f242 202
203}
204
99d5402e 205//_____________________________________________________________________________
7d83513f 206void AliTRDmatrix::Draw(Option_t *)
99d5402e 207{
208 //
209 // Draws a 3D view of the detector matrix
210 //
211
212 Char_t ctitle[50];
213 sprintf(ctitle,"Matrix (Sector:%d Chamber:%d Plane:%d)"
214 ,fSector,fChamber,fPlane);
580727b0 215 TH3F *hMatrix = new TH3F("hMatrix",ctitle,fRow ,-0.5,fRow -0.5
216 ,fCol ,-0.5,fCol -0.5
217 ,fTime,-0.5,fTime-0.5);
99d5402e 218
219 for (Int_t iRow = 0; iRow < fRow; iRow++ ) {
220 for (Int_t iCol = 0; iCol < fCol; iCol++ ) {
221 for (Int_t iTime = 0; iTime < fTime; iTime++) {
222 AliTRDpixel *pixel = GetPixel(iRow,iCol,iTime);
1befd3b2 223 if (pixel) hMatrix->Fill(iRow,iCol,iTime,pixel->GetSignal());
99d5402e 224 }
225 }
226 }
227
228 gStyle->SetOptStat(0);
229 TCanvas *cMatrix = new TCanvas("cMatrix","Detector matrix 3D-view"
230 ,50,50,600,400);
231 cMatrix->ToggleEventStatus();
232 hMatrix->SetXTitle("Pad-row (z)");
233 hMatrix->SetYTitle("Pad-column (rphi)");
234 hMatrix->SetZTitle("Timebucket");
235 hMatrix->Draw("BOX");
236
237}
238
239//_____________________________________________________________________________
240void AliTRDmatrix::DrawRow(Int_t iRow)
241{
242 //
243 // Draws a 2D slice of the detector matrix along one row
244 //
245
246 if ((iRow < 0) || (iRow >= fRow)) {
851d3db9 247 printf("AliTRDmatrix::DrawRow -- ");
99d5402e 248 printf("Index out of bounds (%d/%d)\n",iRow,fRow);
249 return;
250 }
251
252 Char_t ctitle[50];
253 sprintf(ctitle,"Pad-row %d (Sector:%d Chamber:%d Plane:%d)"
254 ,iRow,fSector,fChamber,fPlane);
580727b0 255 TH2F *hSliceRow = new TH2F("hSliceRow",ctitle,fCol ,-0.5,fCol -0.5
256 ,fTime,-0.5,fTime-0.5);
99d5402e 257
258 for (Int_t iCol = 0; iCol < fCol; iCol++ ) {
259 for (Int_t iTime = 0; iTime < fTime; iTime++) {
260 AliTRDpixel *pixel = GetPixel(iRow,iCol,iTime);
261 if (pixel) hSliceRow->Fill(iCol,iTime,pixel->GetSignal());
262 }
263 }
264
265 gStyle->SetOptStat(0);
266 TCanvas *cSliceRow = new TCanvas("cSliceRow","Detector matrix 2D-slice"
267 ,50,50,600,400);
268 cSliceRow->ToggleEventStatus();
269 hSliceRow->SetXTitle("Pad-column (rphi)");
270 hSliceRow->SetYTitle("Timebucket");
271 hSliceRow->Draw("COLZ");
272
273}
274
275//_____________________________________________________________________________
276void AliTRDmatrix::DrawCol(Int_t iCol)
277{
278 //
279 // Draws a 2D slice of the detector matrix along one column
280 //
281
282 if ((iCol < 0) || (iCol >= fCol)) {
851d3db9 283 printf("AliTRDmatrix::DrawCol -- ");
99d5402e 284 printf("Index out of bounds (%d/%d)\n",iCol,fCol);
285 return;
286 }
287
288 Char_t ctitle[50];
289 sprintf(ctitle,"Pad-column %d (Sector:%d Chamber:%d Plane:%d)"
290 ,iCol,fSector,fChamber,fPlane);
580727b0 291 TH2F *hSliceCol = new TH2F("hSliceCol",ctitle,fRow ,-0.5,fRow -0.5
292 ,fTime,-0.5,fTime-0.5);
99d5402e 293
294 for (Int_t iRow = 0; iRow < fRow; iRow++ ) {
295 for (Int_t iTime = 0; iTime < fTime; iTime++) {
296 AliTRDpixel *pixel = GetPixel(iRow,iCol,iTime);
297 if (pixel) hSliceCol->Fill(iRow,iTime,pixel->GetSignal());
298 }
299 }
300
301 gStyle->SetOptStat(0);
302 TCanvas *cSliceCol = new TCanvas("cSliceCol","Detector matrix 2D-slice"
303 ,50,50,600,400);
304 cSliceCol->ToggleEventStatus();
305 hSliceCol->SetXTitle("Pad-row (z)");
306 hSliceCol->SetYTitle("Timebucket");
307 hSliceCol->Draw("COLZ");
308
309}
310
311//_____________________________________________________________________________
312void AliTRDmatrix::DrawTime(Int_t iTime)
313{
314 //
315 // Draws a 2D slice of the detector matrix along one time slice
316 //
317
318 if ((iTime < 0) || (iTime >= fTime)) {
851d3db9 319 printf("AliTRDmatrix::DrawTime -- ");
99d5402e 320 printf("Index out of bounds (%d/%d)\n",iTime,fTime);
321 return;
322 }
323
324 Char_t ctitle[50];
325 sprintf(ctitle,"Time-slice %d (Sector:%d Chamber:%d Plane:%d)"
326 ,iTime,fSector,fChamber,fPlane);
580727b0 327 TH2F *hSliceTime = new TH2F("hSliceTime",ctitle,fRow,-0.5,fRow-0.5
328 ,fCol,-0.5,fCol-0.5);
99d5402e 329
330 for (Int_t iRow = 0; iRow < fRow; iRow++) {
331 for (Int_t iCol = 0; iCol < fCol; iCol++) {
332 AliTRDpixel *pixel = GetPixel(iRow,iCol,iTime);
333 if (pixel) hSliceTime->Fill(iRow,iCol,pixel->GetSignal());
334 }
335 }
336
337 gStyle->SetOptStat(0);
338 TCanvas *cSliceTime = new TCanvas("cSliceTime","Detector matrix 2D-slice"
339 ,50,50,600,400);
340 cSliceTime->ToggleEventStatus();
341 hSliceTime->SetXTitle("Pad-row (z)");
342 hSliceTime->SetYTitle("Pad-column (rphi)");
343 hSliceTime->Draw("COLZ");
344
345}
346
9583ab1c 347//_____________________________________________________________________________
348void AliTRDmatrix::ProjRow()
349{
350 //
351 // Projects the detector matrix along the row-axis
352 //
353
354 Char_t ctitle[60];
355 sprintf(ctitle,"Row-projection (Sector:%d Chamber:%d Plane:%d)"
356 ,fSector,fChamber,fPlane);
580727b0 357 TH2F *hProjRow = new TH2F("hProjRow",ctitle,fCol ,-0.5,fCol -0.5
358 ,fTime,-0.5,fTime-0.5);
9583ab1c 359
360 for (Int_t iRow = 0; iRow < fRow; iRow++ ) {
361 for (Int_t iCol = 0; iCol < fCol; iCol++ ) {
362 for (Int_t iTime = 0; iTime < fTime; iTime++) {
363 AliTRDpixel *pixel = GetPixel(iRow,iCol,iTime);
364 if (pixel) hProjRow->Fill(iCol,iTime,pixel->GetSignal());
365 }
366 }
367 }
368
369 gStyle->SetOptStat(0);
370 TCanvas *cProjRow = new TCanvas("cProjRow","Detector matrix 2D-projection"
371 ,50,50,600,400);
372 cProjRow->ToggleEventStatus();
373 hProjRow->SetXTitle("Pad-column (rphi)");
374 hProjRow->SetYTitle("Timebucket");
375 hProjRow->Draw("COLZ");
376
377}
378
379//_____________________________________________________________________________
380void AliTRDmatrix::ProjCol()
381{
382 //
383 // Projects the detector matrix along the column-axis
384 //
385
386 Char_t ctitle[60];
387 sprintf(ctitle,"Column-projection (Sector:%d Chamber:%d Plane:%d)"
388 ,fSector,fChamber,fPlane);
580727b0 389 TH2F *hProjCol = new TH2F("hProjCol",ctitle,fRow ,-0.5,fRow -0.5
390 ,fTime,-0.5,fTime-0.5);
9583ab1c 391
392 for (Int_t iRow = 0; iRow < fRow; iRow++ ) {
393 for (Int_t iCol = 0; iCol < fCol; iCol++ ) {
394 for (Int_t iTime = 0; iTime < fTime; iTime++) {
395 AliTRDpixel *pixel = GetPixel(iRow,iCol,iTime);
396 if (pixel) hProjCol->Fill(iRow,iTime,pixel->GetSignal());
397 }
398 }
399 }
400
401 gStyle->SetOptStat(0);
402 TCanvas *cProjCol = new TCanvas("cProjCol","Detector matrix 2D-projection"
403 ,50,50,600,400);
404 cProjCol->ToggleEventStatus();
405 hProjCol->SetXTitle("Pad-row (z)");
406 hProjCol->SetYTitle("Timebucket");
407 hProjCol->Draw("COLZ");
408
409}
410
411//_____________________________________________________________________________
412void AliTRDmatrix::ProjTime()
413{
414 //
415 // Projects the detector matrix along the time-axis
416 //
417
418 Char_t ctitle[60];
419 sprintf(ctitle,"Time-projection (Sector:%d Chamber:%d Plane:%d)"
420 ,fSector,fChamber,fPlane);
580727b0 421 TH2F *hProjTime = new TH2F("hProjTime",ctitle,fRow,-0.5,fRow-0.5
422 ,fCol,-0.5,fCol-0.5);
9583ab1c 423
424 for (Int_t iRow = 0; iRow < fRow; iRow++) {
425 for (Int_t iCol = 0; iCol < fCol; iCol++) {
426 for (Int_t iTime = 0; iTime < fTime; iTime++) {
427 AliTRDpixel *pixel = GetPixel(iRow,iCol,iTime);
428 if (pixel) hProjTime->Fill(iRow,iCol,pixel->GetSignal());
429 }
430 }
431 }
432
433 gStyle->SetOptStat(0);
434 TCanvas *cProjTime = new TCanvas("cProjTime","Detector matrix 2D-projection"
435 ,50,50,600,400);
436 cProjTime->ToggleEventStatus();
437 hProjTime->SetXTitle("Pad-row (z)");
438 hProjTime->SetYTitle("Pad-column (rphi)");
439 hProjTime->Draw("COLZ");
440
441}
442
99d5402e 443//_____________________________________________________________________________
444void AliTRDmatrix::SetSignal(Int_t iRow, Int_t iCol, Int_t iTime, Float_t signal)
445{
446 //
447 // Set the amplitude of the signal for one specific pixel
448 //
449
450 AliTRDpixel *pixel = GetPixel(iRow,iCol,iTime);
451 if (pixel) {
452 pixel->SetSignal(signal);
453 }
454
455}
456
457//_____________________________________________________________________________
458Bool_t AliTRDmatrix::AddTrack(Int_t iRow, Int_t iCol, Int_t iTime, Int_t track)
459{
460 //
461 // Add this track number to the stored tracks passing through this pixel.
462 // If there are already three stored the return status is FALSE.
463 //
464
465 AliTRDpixel *pixel = GetPixel(iRow,iCol,iTime);
466 if (!(pixel)) return kTRUE;
467
468 Bool_t trackSet = kFALSE;
793ff80c 469 for (Int_t i = 0; i < AliTRDpixel::NTrackPixel(); i++) {
99d5402e 470 if (pixel->GetTrack(i) == track) {
471 trackSet = kTRUE;
472 break;
473 }
851d3db9 474 if (pixel->GetTrack(i) == -1) {
99d5402e 475 pixel->SetTrack(i,track);
476 trackSet = kTRUE;
477 break;
478 }
479 }
480
481 return trackSet;
482
483}
484
485//_____________________________________________________________________________
486void AliTRDmatrix::SetTrack(Int_t iRow, Int_t iCol, Int_t iTime
487 , Int_t iTrack, Int_t track)
488{
489 //
490 // Store the number of a track which is passing through this pixel
491 //
492
493 AliTRDpixel *pixel = GetPixel(iRow,iCol,iTime);
494 if (pixel) {
495 pixel->SetTrack(iTrack,track);
496 }
497
498}
499
500//_____________________________________________________________________________
793ff80c 501Float_t AliTRDmatrix::GetSignal(Int_t iRow, Int_t iCol, Int_t iTime) const
99d5402e 502{
503 //
504 // Returns the amplitude of the signal for one specific pixel
505 //
506
507 AliTRDpixel *pixel = GetPixel(iRow,iCol,iTime);
508 if (pixel) {
509 return (pixel->GetSignal());
510 }
511 else {
512 return 0;
513 }
514
515}
516
517//_____________________________________________________________________________
793ff80c 518Int_t AliTRDmatrix::GetTrack(Int_t iRow, Int_t iCol, Int_t iTime
519 , Int_t iTrack) const
99d5402e 520{
521 //
522 // Returns the numbers of the tracks passing through one specific pixel
523 //
524
793ff80c 525 if ((iTrack < 0) || (iTrack >= AliTRDpixel::NTrackPixel())) {
851d3db9 526 printf("AliTRDmatrix::GetTrack -- ");
527 printf("Index out of bounds (%d)\n",iTrack);
528 return -1;
99d5402e 529 }
530
531 AliTRDpixel *pixel = GetPixel(iRow,iCol,iTime);
532 if (pixel) {
533 return (pixel->GetTrack(iTrack));
534 }
535 else {
851d3db9 536 return -1;
99d5402e 537 }
538
539}
540
541//_____________________________________________________________________________
793ff80c 542Int_t AliTRDmatrix::GetIndex(Int_t iRow, Int_t iCol, Int_t iTime) const
99d5402e 543{
0a29d0f1 544 //
545 // Get the index of a given pixel
546 //
99d5402e 547
548 if ((iRow >= 0) && (iRow < fRow ) &&
549 (iCol >= 0) && (iCol < fCol ) &&
550 (iTime >= 0) && (iTime < fTime)) {
551 return (iTime + iCol * fTime + iRow * fTime * fCol);
552 }
553 else {
554 return -1;
555 }
556
557}
558
559//_____________________________________________________________________________
793ff80c 560AliTRDpixel *AliTRDmatrix::GetPixel(Int_t iRow, Int_t iCol, Int_t iTime) const
99d5402e 561{
0a29d0f1 562 //
563 // Get one pixel
564 //
99d5402e 565
566 Int_t iPixel = GetIndex(iRow,iCol,iTime);
567 if (iPixel < 0) {
568 return NULL;
569 }
570 else {
571 return ((AliTRDpixel *) fPixelArray->At(iPixel));
572 }
573
574}