+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+
+/* $Id$ */
+
///////////////////////////////////////////////////////////////////////////////
// //
// Contains the pixel information for one TRD chamber //
// //
+// //
///////////////////////////////////////////////////////////////////////////////
+#include <TObjArray.h>
+#include <TH2.h>
+#include <TH3.h>
+#include <TStyle.h>
+#include <TCanvas.h>
+
#include "AliTRDmatrix.h"
+#include "AliTRDpixel.h"
ClassImp(AliTRDmatrix)
}
+//_____________________________________________________________________________
+AliTRDmatrix::AliTRDmatrix(const AliTRDmatrix &m):TObject(m)
+{
+ //
+ // AliTRDmatrix copy constructor
+ //
+
+ ((AliTRDmatrix &) m).Copy(*this);
+
+}
+
//_____________________________________________________________________________
AliTRDmatrix::~AliTRDmatrix()
{
+ //
+ // AliTRDmatrix destructor
+ //
if (fPixelArray) {
fPixelArray->Delete();
}
+//_____________________________________________________________________________
+AliTRDmatrix &AliTRDmatrix::operator=(const AliTRDmatrix &m)
+{
+ //
+ // Assignment operator
+ //
+
+ if (this != &m) ((AliTRDmatrix &) m).Copy(*this);
+ return *this;
+
+}
+
//_____________________________________________________________________________
void AliTRDmatrix::AddSignal(Int_t iRow, Int_t iCol, Int_t iTime, Float_t signal)
{
}
//_____________________________________________________________________________
-void AliTRDmatrix::Draw()
+void AliTRDmatrix::Copy(TObject &m)
+{
+ //
+ // Copy function
+ //
+
+ ((AliTRDmatrix &) m).fRow = fRow;
+ ((AliTRDmatrix &) m).fCol = fCol;
+ ((AliTRDmatrix &) m).fTime = fTime;
+ ((AliTRDmatrix &) m).fPixel = fPixel;
+ ((AliTRDmatrix &) m).fSector = fSector;
+ ((AliTRDmatrix &) m).fChamber = fChamber;
+ ((AliTRDmatrix &) m).fPlane = fPlane;
+
+ ((AliTRDmatrix &) m).fPixelArray = new TObjArray(*fPixelArray);
+
+}
+
+//_____________________________________________________________________________
+void AliTRDmatrix::Draw(Option_t *)
{
//
// Draws a 3D view of the detector matrix
Char_t ctitle[50];
sprintf(ctitle,"Matrix (Sector:%d Chamber:%d Plane:%d)"
,fSector,fChamber,fPlane);
- TH3F *hMatrix = new TH3F("hMatrix",ctitle,fRow ,-0.5,fRow +0.5
- ,fCol ,-0.5,fCol +0.5
- ,fTime,-0.5,fTime+0.5);
+ TH3F *hMatrix = new TH3F("hMatrix",ctitle,fRow ,-0.5,fRow -0.5
+ ,fCol ,-0.5,fCol -0.5
+ ,fTime,-0.5,fTime-0.5);
for (Int_t iRow = 0; iRow < fRow; iRow++ ) {
for (Int_t iCol = 0; iCol < fCol; iCol++ ) {
for (Int_t iTime = 0; iTime < fTime; iTime++) {
AliTRDpixel *pixel = GetPixel(iRow,iCol,iTime);
- if (pixel) hMatrix->Fill3(iRow,iCol,iTime,pixel->GetSignal());
+ if (pixel) hMatrix->Fill(iRow,iCol,iTime,pixel->GetSignal());
}
}
}
//
if ((iRow < 0) || (iRow >= fRow)) {
+ printf("AliTRDmatrix::DrawRow -- ");
printf("Index out of bounds (%d/%d)\n",iRow,fRow);
return;
}
Char_t ctitle[50];
sprintf(ctitle,"Pad-row %d (Sector:%d Chamber:%d Plane:%d)"
,iRow,fSector,fChamber,fPlane);
- TH2F *hSliceRow = new TH2F("hSliceRow",ctitle,fCol ,-0.5,fCol +0.5
- ,fTime,-0.5,fTime+0.5);
+ TH2F *hSliceRow = new TH2F("hSliceRow",ctitle,fCol ,-0.5,fCol -0.5
+ ,fTime,-0.5,fTime-0.5);
for (Int_t iCol = 0; iCol < fCol; iCol++ ) {
for (Int_t iTime = 0; iTime < fTime; iTime++) {
//
if ((iCol < 0) || (iCol >= fCol)) {
+ printf("AliTRDmatrix::DrawCol -- ");
printf("Index out of bounds (%d/%d)\n",iCol,fCol);
return;
}
Char_t ctitle[50];
sprintf(ctitle,"Pad-column %d (Sector:%d Chamber:%d Plane:%d)"
,iCol,fSector,fChamber,fPlane);
- TH2F *hSliceCol = new TH2F("hSliceCol",ctitle,fRow ,-0.5,fRow +0.5
- ,fTime,-0.5,fTime+0.5);
+ TH2F *hSliceCol = new TH2F("hSliceCol",ctitle,fRow ,-0.5,fRow -0.5
+ ,fTime,-0.5,fTime-0.5);
for (Int_t iRow = 0; iRow < fRow; iRow++ ) {
for (Int_t iTime = 0; iTime < fTime; iTime++) {
//
if ((iTime < 0) || (iTime >= fTime)) {
+ printf("AliTRDmatrix::DrawTime -- ");
printf("Index out of bounds (%d/%d)\n",iTime,fTime);
return;
}
Char_t ctitle[50];
sprintf(ctitle,"Time-slice %d (Sector:%d Chamber:%d Plane:%d)"
,iTime,fSector,fChamber,fPlane);
- TH2F *hSliceTime = new TH2F("hSliceTime",ctitle,fRow,-0.5,fRow+0.5
- ,fCol,-0.5,fCol+0.5);
+ TH2F *hSliceTime = new TH2F("hSliceTime",ctitle,fRow,-0.5,fRow-0.5
+ ,fCol,-0.5,fCol-0.5);
for (Int_t iRow = 0; iRow < fRow; iRow++) {
for (Int_t iCol = 0; iCol < fCol; iCol++) {
}
+//_____________________________________________________________________________
+void AliTRDmatrix::ProjRow()
+{
+ //
+ // Projects the detector matrix along the row-axis
+ //
+
+ Char_t ctitle[60];
+ sprintf(ctitle,"Row-projection (Sector:%d Chamber:%d Plane:%d)"
+ ,fSector,fChamber,fPlane);
+ TH2F *hProjRow = new TH2F("hProjRow",ctitle,fCol ,-0.5,fCol -0.5
+ ,fTime,-0.5,fTime-0.5);
+
+ for (Int_t iRow = 0; iRow < fRow; iRow++ ) {
+ for (Int_t iCol = 0; iCol < fCol; iCol++ ) {
+ for (Int_t iTime = 0; iTime < fTime; iTime++) {
+ AliTRDpixel *pixel = GetPixel(iRow,iCol,iTime);
+ if (pixel) hProjRow->Fill(iCol,iTime,pixel->GetSignal());
+ }
+ }
+ }
+
+ gStyle->SetOptStat(0);
+ TCanvas *cProjRow = new TCanvas("cProjRow","Detector matrix 2D-projection"
+ ,50,50,600,400);
+ cProjRow->ToggleEventStatus();
+ hProjRow->SetXTitle("Pad-column (rphi)");
+ hProjRow->SetYTitle("Timebucket");
+ hProjRow->Draw("COLZ");
+
+}
+
+//_____________________________________________________________________________
+void AliTRDmatrix::ProjCol()
+{
+ //
+ // Projects the detector matrix along the column-axis
+ //
+
+ Char_t ctitle[60];
+ sprintf(ctitle,"Column-projection (Sector:%d Chamber:%d Plane:%d)"
+ ,fSector,fChamber,fPlane);
+ TH2F *hProjCol = new TH2F("hProjCol",ctitle,fRow ,-0.5,fRow -0.5
+ ,fTime,-0.5,fTime-0.5);
+
+ for (Int_t iRow = 0; iRow < fRow; iRow++ ) {
+ for (Int_t iCol = 0; iCol < fCol; iCol++ ) {
+ for (Int_t iTime = 0; iTime < fTime; iTime++) {
+ AliTRDpixel *pixel = GetPixel(iRow,iCol,iTime);
+ if (pixel) hProjCol->Fill(iRow,iTime,pixel->GetSignal());
+ }
+ }
+ }
+
+ gStyle->SetOptStat(0);
+ TCanvas *cProjCol = new TCanvas("cProjCol","Detector matrix 2D-projection"
+ ,50,50,600,400);
+ cProjCol->ToggleEventStatus();
+ hProjCol->SetXTitle("Pad-row (z)");
+ hProjCol->SetYTitle("Timebucket");
+ hProjCol->Draw("COLZ");
+
+}
+
+//_____________________________________________________________________________
+void AliTRDmatrix::ProjTime()
+{
+ //
+ // Projects the detector matrix along the time-axis
+ //
+
+ Char_t ctitle[60];
+ sprintf(ctitle,"Time-projection (Sector:%d Chamber:%d Plane:%d)"
+ ,fSector,fChamber,fPlane);
+ TH2F *hProjTime = new TH2F("hProjTime",ctitle,fRow,-0.5,fRow-0.5
+ ,fCol,-0.5,fCol-0.5);
+
+ for (Int_t iRow = 0; iRow < fRow; iRow++) {
+ for (Int_t iCol = 0; iCol < fCol; iCol++) {
+ for (Int_t iTime = 0; iTime < fTime; iTime++) {
+ AliTRDpixel *pixel = GetPixel(iRow,iCol,iTime);
+ if (pixel) hProjTime->Fill(iRow,iCol,pixel->GetSignal());
+ }
+ }
+ }
+
+ gStyle->SetOptStat(0);
+ TCanvas *cProjTime = new TCanvas("cProjTime","Detector matrix 2D-projection"
+ ,50,50,600,400);
+ cProjTime->ToggleEventStatus();
+ hProjTime->SetXTitle("Pad-row (z)");
+ hProjTime->SetYTitle("Pad-column (rphi)");
+ hProjTime->Draw("COLZ");
+
+}
+
//_____________________________________________________________________________
void AliTRDmatrix::SetSignal(Int_t iRow, Int_t iCol, Int_t iTime, Float_t signal)
{
if (!(pixel)) return kTRUE;
Bool_t trackSet = kFALSE;
- for (Int_t i = 0; i < kTrackPixel; i++) {
+ for (Int_t i = 0; i < AliTRDpixel::NTrackPixel(); i++) {
if (pixel->GetTrack(i) == track) {
trackSet = kTRUE;
break;
}
- if (pixel->GetTrack(i) == 0) {
+ if (pixel->GetTrack(i) == -1) {
pixel->SetTrack(i,track);
trackSet = kTRUE;
break;
}
//_____________________________________________________________________________
-Float_t AliTRDmatrix::GetSignal(Int_t iRow, Int_t iCol, Int_t iTime)
+Float_t AliTRDmatrix::GetSignal(Int_t iRow, Int_t iCol, Int_t iTime) const
{
//
// Returns the amplitude of the signal for one specific pixel
}
//_____________________________________________________________________________
-Int_t AliTRDmatrix::GetTrack(Int_t iRow, Int_t iCol, Int_t iTime, Int_t iTrack)
+Int_t AliTRDmatrix::GetTrack(Int_t iRow, Int_t iCol, Int_t iTime
+ , Int_t iTrack) const
{
//
// Returns the numbers of the tracks passing through one specific pixel
//
- if ((iTrack < 0) || (iTrack >= kTrackPixel)) {
- printf("GetTrack: Index out of bounds (%d)\n",iTrack);
- return 0;
+ if ((iTrack < 0) || (iTrack >= AliTRDpixel::NTrackPixel())) {
+ printf("AliTRDmatrix::GetTrack -- ");
+ printf("Index out of bounds (%d)\n",iTrack);
+ return -1;
}
AliTRDpixel *pixel = GetPixel(iRow,iCol,iTime);
return (pixel->GetTrack(iTrack));
}
else {
- return 0;
+ return -1;
}
}
//_____________________________________________________________________________
-Int_t AliTRDmatrix::GetIndex(Int_t iRow, Int_t iCol, Int_t iTime)
+Int_t AliTRDmatrix::GetIndex(Int_t iRow, Int_t iCol, Int_t iTime) const
{
+ //
+ // Get the index of a given pixel
+ //
if ((iRow >= 0) && (iRow < fRow ) &&
(iCol >= 0) && (iCol < fCol ) &&
}
//_____________________________________________________________________________
-AliTRDpixel *AliTRDmatrix::GetPixel(Int_t iRow, Int_t iCol, Int_t iTime)
+AliTRDpixel *AliTRDmatrix::GetPixel(Int_t iRow, Int_t iCol, Int_t iTime) const
{
+ //
+ // Get one pixel
+ //
Int_t iPixel = GetIndex(iRow,iCol,iTime);
if (iPixel < 0) {
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff