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