bb2a3da011cc10ec710c33cccfe3d8f3973fd2ab
[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.10.12.2  2002/07/24 10:09:30  alibrary
19 Updating VirtualMC
20
21 Revision 1.10.12.1  2002/06/10 15:28:58  hristov
22 Merged with v3-08-02
23
24 Revision 1.11  2002/03/28 14:59:07  cblume
25 Coding conventions
26
27 Revision 1.11  2002/03/28 14:59:07  cblume
28 Coding conventions
29
30 Revision 1.10  2000/11/20 08:56:51  cblume
31 Fix the binning of the histograms
32
33 Revision 1.9  2000/11/01 14:53:21  cblume
34 Merge with TRD-develop
35
36 Revision 1.4.2.5  2000/10/17 02:27:34  cblume
37 Get rid of global constants
38
39 Revision 1.4.2.4  2000/10/06 16:49:46  cblume
40 Made Getters const
41
42 Revision 1.4.2.3  2000/10/04 16:34:58  cblume
43 Replace include files by forward declarations
44
45 Revision 1.8  2000/06/09 11:10:07  cblume
46 Compiler warnings and coding conventions, next round
47
48 Revision 1.7  2000/06/08 18:32:58  cblume
49 Make code compliant to coding conventions
50
51 Revision 1.6  2000/05/08 15:48:30  cblume
52 Resolved merge conflict
53
54 Revision 1.4.2.2  2000/05/08 14:50:58  cblume
55 Add functions ProjRow(), ProjCol(), and ProjTime()
56
57 Revision 1.4.2.1  2000/04/27 12:47:02  cblume
58 Replace Fill3() by Fill()
59
60 Revision 1.4  2000/02/28 19:10:26  cblume
61 Include the new TRD classes
62
63 Revision 1.3.4.1  2000/02/28 17:57:47  cblume
64 GetTrack returns now -1 if no track is found
65
66 Revision 1.3  1999/10/04 14:48:07  fca
67 Avoid warnings on non-ansi compiler HP-UX CC
68
69 Revision 1.2  1999/09/29 09:24:35  fca
70 Introduction of the Copyright and cvs Log
71
72 */
73
74 ///////////////////////////////////////////////////////////////////////////////
75 //                                                                           //
76 //  Contains the pixel information for one TRD chamber                       //
77 //                                                                           //
78 //                                                                           //
79 ///////////////////////////////////////////////////////////////////////////////
80
81 #include <TObjArray.h>
82 #include <TH2.h>
83 #include <TH3.h>
84 #include <TStyle.h>
85 #include <TCanvas.h>
86
87 #include "AliTRDmatrix.h"
88 #include "AliTRDpixel.h"
89
90 ClassImp(AliTRDmatrix)
91
92 //_____________________________________________________________________________
93 AliTRDmatrix::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 //_____________________________________________________________________________
111 AliTRDmatrix::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
134 //_____________________________________________________________________________
135 AliTRDmatrix::AliTRDmatrix(const AliTRDmatrix &m)
136 {
137   //
138   // AliTRDmatrix copy constructor
139   //
140
141   ((AliTRDmatrix &) m).Copy(*this);
142
143 }
144
145 //_____________________________________________________________________________
146 AliTRDmatrix::~AliTRDmatrix()
147 {
148   //
149   // AliTRDmatrix destructor
150   //
151
152   if (fPixelArray) {
153     fPixelArray->Delete();
154     delete fPixelArray;
155   }
156
157 }
158
159 //_____________________________________________________________________________
160 AliTRDmatrix &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
171 //_____________________________________________________________________________
172 void 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
186 //_____________________________________________________________________________
187 void AliTRDmatrix::Copy(TObject &m)
188 {
189   //
190   // Copy function
191   //
192
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;
200
201   ((AliTRDmatrix &) m).fPixelArray = new TObjArray(*fPixelArray);
202
203 }
204
205 //_____________________________________________________________________________
206 void AliTRDmatrix::Draw(Option_t *)
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);
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);
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);
223         if (pixel) hMatrix->Fill(iRow,iCol,iTime,pixel->GetSignal());
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 //_____________________________________________________________________________
240 void 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)) {
247     printf("AliTRDmatrix::DrawRow -- ");
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);
255   TH2F *hSliceRow = new TH2F("hSliceRow",ctitle,fCol ,-0.5,fCol -0.5
256                                                ,fTime,-0.5,fTime-0.5);
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 //_____________________________________________________________________________
276 void 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)) {
283     printf("AliTRDmatrix::DrawCol -- ");
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);
291   TH2F *hSliceCol = new TH2F("hSliceCol",ctitle,fRow ,-0.5,fRow -0.5
292                                                ,fTime,-0.5,fTime-0.5);
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 //_____________________________________________________________________________
312 void 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)) {
319     printf("AliTRDmatrix::DrawTime -- ");
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);
327   TH2F *hSliceTime = new TH2F("hSliceTime",ctitle,fRow,-0.5,fRow-0.5
328                                                  ,fCol,-0.5,fCol-0.5);
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
347 //_____________________________________________________________________________
348 void 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);
357   TH2F *hProjRow = new TH2F("hProjRow",ctitle,fCol ,-0.5,fCol -0.5
358                                              ,fTime,-0.5,fTime-0.5);
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 //_____________________________________________________________________________
380 void 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);
389   TH2F *hProjCol = new TH2F("hProjCol",ctitle,fRow ,-0.5,fRow -0.5
390                                              ,fTime,-0.5,fTime-0.5);
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 //_____________________________________________________________________________
412 void 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);
421   TH2F *hProjTime = new TH2F("hProjTime",ctitle,fRow,-0.5,fRow-0.5
422                                                ,fCol,-0.5,fCol-0.5);
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
443 //_____________________________________________________________________________
444 void 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 //_____________________________________________________________________________
458 Bool_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;
469   for (Int_t i = 0; i < AliTRDpixel::NTrackPixel(); i++) {
470     if (pixel->GetTrack(i) == track) {
471       trackSet = kTRUE;
472       break;
473     }
474     if (pixel->GetTrack(i) ==    -1) {
475       pixel->SetTrack(i,track);
476       trackSet = kTRUE;
477       break;
478     }
479   }    
480
481   return trackSet;
482
483 }
484
485 //_____________________________________________________________________________
486 void 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 //_____________________________________________________________________________
501 Float_t AliTRDmatrix::GetSignal(Int_t iRow, Int_t iCol, Int_t iTime) const
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 //_____________________________________________________________________________
518 Int_t AliTRDmatrix::GetTrack(Int_t iRow, Int_t iCol, Int_t iTime
519                            , Int_t iTrack) const 
520 {
521   //
522   // Returns the numbers of the tracks passing through one specific pixel
523   //
524
525   if ((iTrack < 0) || (iTrack >= AliTRDpixel::NTrackPixel())) {
526     printf("AliTRDmatrix::GetTrack -- ");
527     printf("Index out of bounds (%d)\n",iTrack);
528     return -1;
529   }
530
531   AliTRDpixel *pixel = GetPixel(iRow,iCol,iTime);
532   if (pixel) {
533     return (pixel->GetTrack(iTrack));
534   }
535   else {
536     return -1;
537   }
538
539 }
540
541 //_____________________________________________________________________________
542 Int_t AliTRDmatrix::GetIndex(Int_t iRow, Int_t iCol, Int_t iTime) const
543 {
544   //
545   // Get the index of a given pixel
546   //
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 //_____________________________________________________________________________
560 AliTRDpixel *AliTRDmatrix::GetPixel(Int_t iRow, Int_t iCol, Int_t iTime) const
561 {
562   //
563   // Get one pixel
564   //
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 }