[u/mrichter/AliRoot.git] / EVE / EveDet / AliEveTRDData.cxx

// $Id$
// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007

/**************************************************************************
 * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
 * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for          *
 * full copyright notice.                                                 *
 **************************************************************************/

#include "AliEveTRDData.h"
#include "AliEveTRDModuleImp.h"

#include "AliLog.h"
#include "AliTRDhit.h"
#include "AliTRDcluster.h"
#include "AliTRDcalibDB.h"
#include "AliTRDpadPlane.h"
#include "AliTRDgeometry.h"
#include "AliTRDdigitsManager.h"

ClassImp(AliEveTRDHits)
ClassImp(AliEveTRDDigits)
ClassImp(AliEveTRDClusters)

///////////////////////////////////////////////////////////
/////////////   AliEveTRDDigits       /////////////////////
///////////////////////////////////////////////////////////

//______________________________________________________________________________
AliEveTRDDigits::AliEveTRDDigits(AliEveTRDChamber *p) :
  TEveQuadSet("digits", ""), fParent(p), fBoxes(), fData()
{}

//______________________________________________________________________________
void AliEveTRDDigits::SetData(AliTRDdigitsManager *digits)
{

  fData.Allocate(fParent->fRowMax, fParent->fColMax, fParent->fTimeMax);
  //	digits->Expand();
  for (Int_t  row = 0;  row <  fParent->fRowMax;  row++)
    for (Int_t  col = 0;  col <  fParent->fColMax;  col++)
      for (Int_t time = 0; time < fParent->fTimeMax; time++) {
	if(digits->GetDigitAmp(row, col, time, fParent->GetID()) < 0) continue;
	fData.SetDataUnchecked(row, col, time, digits->GetDigitAmp(row, col, time, fParent->GetID()));
      }
}

//______________________________________________________________________________
void AliEveTRDDigits::ComputeRepresentation()
{
  // Calculate digits representation according to user settings. The
  // user can set the following parameters:
  // - digits scale (log/lin)
  // - digits threshold
  // - digits apparence (quads/boxes)

  TEveQuadSet::Reset(TEveQuadSet::kQT_FreeQuad, kTRUE, 64);
  // MT fBoxes.fBoxes.clear();

  Double_t colSize, rowSize, scale;
  Double_t x, y, z;

  Int_t charge;
  Float_t t0;
  Float_t timeBinSize;

  AliTRDcalibDB* calibration = AliTRDcalibDB::Instance();
  Double_t cloc[4][3], cglo[3];
  Int_t color, dimension;
  fData.Expand();
  for (Int_t  row = 0;  row <  fParent->fRowMax;  row++) {
    rowSize = .5 * fParent->fPadPlane->GetRowSize(row);
    z = fParent->fPadPlane->GetRowPos(row) - rowSize;

    for (Int_t  col = 0;  col <  fParent->fColMax;  col++) {
      colSize = .5 * fParent->fPadPlane->GetColSize(col);
      y = fParent->fPadPlane->GetColPos(col) - colSize;
      t0 = calibration->GetT0(fParent->fDet, col, row);
      timeBinSize = calibration->GetVdrift(fParent->fDet, col, row)/fParent->fSamplingFrequency;

      for (Int_t time = 0; time < fParent->fTimeMax; time++) {
	charge = fData.GetDataUnchecked(row, col, time);
	if (charge < fParent->GetDigitsThreshold()) continue;

	x = fParent->fX0 - (time+0.5-t0)*timeBinSize;
	scale = fParent->GetDigitsLog() ? TMath::Log(float(charge))/TMath::Log(1024.) : charge/1024.;
	color  = 50+int(scale*50.);

	cloc[0][2] = z - rowSize * scale;
	cloc[0][1] = y - colSize * scale;
	cloc[0][0] = x;

	cloc[1][2] = z - rowSize * scale;
	cloc[1][1] = y + colSize * scale;
	cloc[1][0] = x;

	cloc[2][2] = z + rowSize * scale;
	cloc[2][1] = y + colSize * scale;
	cloc[2][0] = x;

	cloc[3][2] = z + rowSize * scale;
	cloc[3][1] = y - colSize * scale;
	cloc[3][0] = x;

	Float_t* p = 0;
	if( fParent->GetDigitsBox()){
	  // MT fBoxes.fBoxes.push_back(Box());
	  // MT fBoxes.fBoxes.back().color[0] = (UChar_t)color;
	  // MT fBoxes.fBoxes.back().color[1] = (UChar_t)color;
	  // MT fBoxes.fBoxes.back().color[2] = (UChar_t)color;
	  // MT fBoxes.fBoxes.back().color[3] = (UChar_t)color;
	  // MT p = fBoxes.fBoxes.back().vertices;
	  dimension = 2;
	} else {
	  AddQuad((Float_t*)0);
	  QuadColor(color);
	  p = ((QFreeQuad_t*) fLastDigit)->fVertices;
	  dimension = 1;
	}

	for(int id=0; id<dimension; id++)
	  for (Int_t ic = 0; ic < 4; ic++) {
	    cloc[ic][0] -= .5 * id * timeBinSize;
	    fParent->fGeo->RotateBack(fParent->fDet,cloc[ic],cglo);
	    p[0] = cglo[0]; p[1] = cglo[1]; p[2] = cglo[2];
	    p+=3;
	  }
      }  // end time loop
    }  // end col loop
  }  // end row loop
  fData.Compress(1);
}

//______________________________________________________________________________
void AliEveTRDDigits::Paint(Option_t *option)
{
  if(fParent->GetDigitsBox()) fBoxes.Paint(option);
  else TEveQuadSet::Paint(option);
}

//______________________________________________________________________________
void AliEveTRDDigits::Reset()
{
  TEveQuadSet::Reset(TEveQuadSet::kQT_FreeQuad, kTRUE, 64);
  // MT fBoxes.fBoxes.clear();
  fData.Reset();
}

///////////////////////////////////////////////////////////
/////////////   AliEveTRDHits         /////////////////////
///////////////////////////////////////////////////////////

//______________________________________________________________________________
AliEveTRDHits::AliEveTRDHits(AliEveTRDChamber *p) :
  TEvePointSet("hits", 20), fParent(p)
{}

//______________________________________________________________________________
void AliEveTRDHits::PointSelected(Int_t n)
{
  fParent->SpawnEditor();
  AliTRDhit *h = dynamic_cast<AliTRDhit*>(GetPointId(n));
  printf("\nDetector             : %d\n", h->GetDetector());
  printf("Region of production : %c\n", h->FromAmplification() ? 'A' : 'D');
  printf("TR photon            : %s\n", h->FromTRphoton() ? "Yes" : "No");
  printf("Charge               : %d\n", h->GetCharge());
  printf("MC track label       : %d\n", h->GetTrack());
  printf("Time from collision  : %f\n", h->GetTime());
}


///////////////////////////////////////////////////////////
/////////////   AliEveTRDHits               /////////////////////
///////////////////////////////////////////////////////////

//______________________________________________________________________________
AliEveTRDClusters::AliEveTRDClusters(AliEveTRDChamber *p):AliEveTRDHits(p)
{}

//______________________________________________________________________________
void AliEveTRDClusters::PointSelected(Int_t n)
{
  fParent->SpawnEditor();
  AliTRDcluster *c = dynamic_cast<AliTRDcluster*>(GetPointId(n));
  printf("\nDetector             : %d\n", c->GetDetector());
  printf("Charge               : %f\n", c->GetQ());
  printf("Sum S                : %4.0f\n", c->GetSumS());
  printf("Time bin             : %d\n", c->GetLocalTimeBin());
  printf("Signals              : ");
  Short_t *cSignals = c->GetSignals();
  for(Int_t ipad=0; ipad<7; ipad++) printf("%d ", cSignals[ipad]); printf("\n");
  printf("Central pad          : %d\n", c->GetPadCol());
  printf("MC track labels      : ");
  for(Int_t itrk=0; itrk<3; itrk++) printf("%d ", c->GetLabel(itrk)); printf("\n");
  // Bool_t	AliCluster::GetGlobalCov(Float_t* cov) const
  // Bool_t	AliCluster::GetGlobalXYZ(Float_t* xyz) const
  // Float_t	AliCluster::GetSigmaY2() const
  // Float_t	AliCluster::GetSigmaYZ() const
  // Float_t	AliCluster::GetSigmaZ2() const
}

///////////////////////////////////////////////////////////
/////////////   AliEveTRDHitsEditor         /////////////////////
///////////////////////////////////////////////////////////
AliEveTRDHitsEditor::AliEveTRDHitsEditor(const TGWindow* p, Int_t width, Int_t height,
					 UInt_t options, Pixel_t back) :
  TGedFrame(p, width, height, options, back),
  fM(0)
{
  MakeTitle("TRD Hits");

}

AliEveTRDHitsEditor::~AliEveTRDHitsEditor()
{}

void AliEveTRDHitsEditor::SetModel(TObject* obj)
{
  fM = dynamic_cast<AliEveTRDHits*>(obj);

  // 	Float_t x, y, z;
  // 	for(int ihit=0; ihit<fM->GetN(); ihit++){
  // 		fM->GetPoint(ihit, x, y, z);
  // 		printf("%3d : x=%6.3f y=%6.3f z=%6.3f\n", ihit, x, y, z);
  // 	}
}

///////////////////////////////////////////////////////////
/////////////   AliEveTRDDigitsEditor /////////////////////
///////////////////////////////////////////////////////////
AliEveTRDDigitsEditor::AliEveTRDDigitsEditor(const TGWindow* p, Int_t width, Int_t height,
					     UInt_t options, Pixel_t back) :
  TGedFrame(p, width, height, options, back),
  fM(0)
{
  MakeTitle("TRD Digits");

}

AliEveTRDDigitsEditor::~AliEveTRDDigitsEditor()
{}

void AliEveTRDDigitsEditor::SetModel(TObject* obj)
{
  fM = dynamic_cast<AliEveTRDDigits*>(obj);
  fM->fParent->SpawnEditor();

  // 	printf("Chamber %d", fM->fParent->GetID());
  // 	for (Int_t  row = 0;  row <  fM->fParent->GetRowMax();  row++)
  // 		for (Int_t  col = 0;  col <  fM->fParent->GetColMax();  col++)
  // 			for (Int_t time = 0; time < fM->fParent->GetTimeMax(); time++) {
  // 				printf("\tA(%d %d %d) = %d\n", row, col, time, fM->fData.GetDataUnchecked(row, col, time));
  // 			}
}
Commit	Line	Data
d810d0de	1	// $Id$
	2	// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
	3
	4	/**************************************************************************
	5	* Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
	6	* See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
51346b82	7	* full copyright notice. *
d810d0de	8	**************************************************************************/
fd31e9de	9
d810d0de	10	#include "AliEveTRDData.h"
d810d0de	11	#include "AliEveTRDModuleImp.h"
a282bf09	12
edf0c4a0	13	#include "AliLog.h"
	14	#include "AliTRDhit.h"
	15	#include "AliTRDcluster.h"
a282bf09	16	#include "AliTRDcalibDB.h"
	17	#include "AliTRDpadPlane.h"
	18	#include "AliTRDgeometry.h"
14217b5f	19	#include "AliTRDdigitsManager.h"
a282bf09	20
d810d0de	21	ClassImp(AliEveTRDHits)
	22	ClassImp(AliEveTRDDigits)
	23	ClassImp(AliEveTRDClusters)
a282bf09	24
a282bf09	25	///////////////////////////////////////////////////////////
fd31e9de	26	///////////// AliEveTRDDigits /////////////////////
a282bf09	27	///////////////////////////////////////////////////////////
a282bf09	28
fd31e9de	29	//______________________________________________________________________________
	30	AliEveTRDDigits::AliEveTRDDigits(AliEveTRDChamber *p) :
	31	TEveQuadSet("digits", ""), fParent(p), fBoxes(), fData()
edf0c4a0	32	{}
a282bf09	33
fd31e9de	34	//______________________________________________________________________________
fd31e9de	35	void AliEveTRDDigits::SetData(AliTRDdigitsManager *digits)
a282bf09	36	{
51346b82	37
fd31e9de	38	fData.Allocate(fParent->fRowMax, fParent->fColMax, fParent->fTimeMax);
	39	// digits->Expand();
	40	for (Int_t row = 0; row < fParent->fRowMax; row++)
	41	for (Int_t col = 0; col < fParent->fColMax; col++)
	42	for (Int_t time = 0; time < fParent->fTimeMax; time++) {
	43	if(digits->GetDigitAmp(row, col, time, fParent->GetID()) < 0) continue;
	44	fData.SetDataUnchecked(row, col, time, digits->GetDigitAmp(row, col, time, fParent->GetID()));
	45	}
a282bf09	46	}
a282bf09	47
fd31e9de	48	//______________________________________________________________________________
d810d0de	49	void AliEveTRDDigits::ComputeRepresentation()
a282bf09	50	{
84aff7a4	51	// Calculate digits representation according to user settings. The
	52	// user can set the following parameters:
	53	// - digits scale (log/lin)
	54	// - digits threshold
	55	// - digits apparence (quads/boxes)
	56
	57	TEveQuadSet::Reset(TEveQuadSet::kQT_FreeQuad, kTRUE, 64);
	58	// MT fBoxes.fBoxes.clear();
51346b82	59
84aff7a4	60	Double_t colSize, rowSize, scale;
84aff7a4	61	Double_t x, y, z;
a282bf09	62
84aff7a4	63	Int_t charge;
	64	Float_t t0;
	65	Float_t timeBinSize;
51346b82	66
84aff7a4	67	AliTRDcalibDB* calibration = AliTRDcalibDB::Instance();
a282bf09	68	Double_t cloc[4][3], cglo[3];
84aff7a4	69	Int_t color, dimension;
84aff7a4	70	fData.Expand();
fd31e9de	71	for (Int_t row = 0; row < fParent->fRowMax; row++) {
84aff7a4	72	rowSize = .5 * fParent->fPadPlane->GetRowSize(row);
84aff7a4	73	z = fParent->fPadPlane->GetRowPos(row) - rowSize;
51346b82	74
fd31e9de	75	for (Int_t col = 0; col < fParent->fColMax; col++) {
84aff7a4	76	colSize = .5 * fParent->fPadPlane->GetColSize(col);
	77	y = fParent->fPadPlane->GetColPos(col) - colSize;
	78	t0 = calibration->GetT0(fParent->fDet, col, row);
fd31e9de	79	timeBinSize = calibration->GetVdrift(fParent->fDet, col, row)/fParent->fSamplingFrequency;
51346b82	80
fd31e9de	81	for (Int_t time = 0; time < fParent->fTimeMax; time++) {
84aff7a4	82	charge = fData.GetDataUnchecked(row, col, time);
84aff7a4	83	if (charge < fParent->GetDigitsThreshold()) continue;
51346b82	84
84aff7a4	85	x = fParent->fX0 - (time+0.5-t0)*timeBinSize;
	86	scale = fParent->GetDigitsLog() ? TMath::Log(float(charge))/TMath::Log(1024.) : charge/1024.;
	87	color = 50+int(scale*50.);
51346b82	88
84aff7a4	89	cloc[0][2] = z - rowSize * scale;
	90	cloc[0][1] = y - colSize * scale;
	91	cloc[0][0] = x;
51346b82	92
84aff7a4	93	cloc[1][2] = z - rowSize * scale;
	94	cloc[1][1] = y + colSize * scale;
	95	cloc[1][0] = x;
51346b82	96
84aff7a4	97	cloc[2][2] = z + rowSize * scale;
	98	cloc[2][1] = y + colSize * scale;
	99	cloc[2][0] = x;
51346b82	100
84aff7a4	101	cloc[3][2] = z + rowSize * scale;
	102	cloc[3][1] = y - colSize * scale;
	103	cloc[3][0] = x;
51346b82	104
84aff7a4	105	Float_t* p = 0;
	106	if( fParent->GetDigitsBox()){
	107	// MT fBoxes.fBoxes.push_back(Box());
	108	// MT fBoxes.fBoxes.back().color[0] = (UChar_t)color;
	109	// MT fBoxes.fBoxes.back().color[1] = (UChar_t)color;
	110	// MT fBoxes.fBoxes.back().color[2] = (UChar_t)color;
	111	// MT fBoxes.fBoxes.back().color[3] = (UChar_t)color;
	112	// MT p = fBoxes.fBoxes.back().vertices;
	113	dimension = 2;
	114	} else {
	115	AddQuad((Float_t*)0);
	116	QuadColor(color);
	117	p = ((QFreeQuad_t*) fLastDigit)->fVertices;
	118	dimension = 1;
	119	}
a282bf09	120
84aff7a4	121	for(int id=0; id<dimension; id++)
	122	for (Int_t ic = 0; ic < 4; ic++) {
	123	cloc[ic][0] -= .5 * id * timeBinSize;
	124	fParent->fGeo->RotateBack(fParent->fDet,cloc[ic],cglo);
	125	p[0] = cglo[0]; p[1] = cglo[1]; p[2] = cglo[2];
	126	p+=3;
	127	}
	128	} // end time loop
	129	} // end col loop
	130	} // end row loop
	131	fData.Compress(1);
a282bf09	132	}
a282bf09	133
fd31e9de	134	//______________________________________________________________________________
d810d0de	135	void AliEveTRDDigits::Paint(Option_t *option)
a282bf09	136	{
fd31e9de	137	if(fParent->GetDigitsBox()) fBoxes.Paint(option);
fd31e9de	138	else TEveQuadSet::Paint(option);
a282bf09	139	}
a282bf09	140
fd31e9de	141	//______________________________________________________________________________
d810d0de	142	void AliEveTRDDigits::Reset()
a282bf09	143	{
fd31e9de	144	TEveQuadSet::Reset(TEveQuadSet::kQT_FreeQuad, kTRUE, 64);
	145	// MT fBoxes.fBoxes.clear();
	146	fData.Reset();
a282bf09	147	}
	148
	149	///////////////////////////////////////////////////////////
fd31e9de	150	///////////// AliEveTRDHits /////////////////////
a282bf09	151	///////////////////////////////////////////////////////////
a282bf09	152
fd31e9de	153	//______________________________________________________________________________
	154	AliEveTRDHits::AliEveTRDHits(AliEveTRDChamber *p) :
	155	TEvePointSet("hits", 20), fParent(p)
edf0c4a0	156	{}
a282bf09	157
fd31e9de	158	//______________________________________________________________________________
d810d0de	159	void AliEveTRDHits::PointSelected(Int_t n)
edf0c4a0	160	{
fd31e9de	161	fParent->SpawnEditor();
	162	AliTRDhit h = dynamic_cast<AliTRDhit>(GetPointId(n));
	163	printf("\nDetector : %d\n", h->GetDetector());
	164	printf("Region of production : %c\n", h->FromAmplification() ? 'A' : 'D');
	165	printf("TR photon : %s\n", h->FromTRphoton() ? "Yes" : "No");
	166	printf("Charge : %d\n", h->GetCharge());
	167	printf("MC track label : %d\n", h->GetTrack());
	168	printf("Time from collision : %f\n", h->GetTime());
a282bf09	169	}
a282bf09	170
edf0c4a0	171
edf0c4a0	172	///////////////////////////////////////////////////////////
d810d0de	173	///////////// AliEveTRDHits /////////////////////
edf0c4a0	174	///////////////////////////////////////////////////////////
edf0c4a0	175
fd31e9de	176	//______________________________________________________________________________
d810d0de	177	AliEveTRDClusters::AliEveTRDClusters(AliEveTRDChamber *p):AliEveTRDHits(p)
edf0c4a0	178	{}
edf0c4a0	179
fd31e9de	180	//______________________________________________________________________________
d810d0de	181	void AliEveTRDClusters::PointSelected(Int_t n)
edf0c4a0	182	{
fd31e9de	183	fParent->SpawnEditor();
	184	AliTRDcluster c = dynamic_cast<AliTRDcluster>(GetPointId(n));
	185	printf("\nDetector : %d\n", c->GetDetector());
	186	printf("Charge : %f\n", c->GetQ());
	187	printf("Sum S : %4.0f\n", c->GetSumS());
	188	printf("Time bin : %d\n", c->GetLocalTimeBin());
	189	printf("Signals : ");
	190	Short_t *cSignals = c->GetSignals();
	191	for(Int_t ipad=0; ipad<7; ipad++) printf("%d ", cSignals[ipad]); printf("\n");
	192	printf("Central pad : %d\n", c->GetPadCol());
	193	printf("MC track labels : ");
	194	for(Int_t itrk=0; itrk<3; itrk++) printf("%d ", c->GetLabel(itrk)); printf("\n");
	195	// Bool_t AliCluster::GetGlobalCov(Float_t* cov) const
	196	// Bool_t AliCluster::GetGlobalXYZ(Float_t* xyz) const
	197	// Float_t AliCluster::GetSigmaY2() const
	198	// Float_t AliCluster::GetSigmaYZ() const
	199	// Float_t AliCluster::GetSigmaZ2() const
edf0c4a0	200	}
	201
	202	///////////////////////////////////////////////////////////
d810d0de	203	///////////// AliEveTRDHitsEditor /////////////////////
edf0c4a0	204	///////////////////////////////////////////////////////////
fd31e9de	205	AliEveTRDHitsEditor::AliEveTRDHitsEditor(const TGWindow* p, Int_t width, Int_t height,
	206	UInt_t options, Pixel_t back) :
	207	TGedFrame(p, width, height, options, back),
	208	fM(0)
edf0c4a0	209	{
fd31e9de	210	MakeTitle("TRD Hits");
edf0c4a0	211
	212	}
	213
d810d0de	214	AliEveTRDHitsEditor::~AliEveTRDHitsEditor()
edf0c4a0	215	{}
edf0c4a0	216
d810d0de	217	void AliEveTRDHitsEditor::SetModel(TObject* obj)
a282bf09	218	{
fd31e9de	219	fM = dynamic_cast<AliEveTRDHits*>(obj);
edf0c4a0	220
fd31e9de	221	// Float_t x, y, z;
	222	// for(int ihit=0; ihit<fM->GetN(); ihit++){
	223	// fM->GetPoint(ihit, x, y, z);
	224	// printf("%3d : x=%6.3f y=%6.3f z=%6.3f\n", ihit, x, y, z);
	225	// }
a282bf09	226	}
a282bf09	227
edf0c4a0	228	///////////////////////////////////////////////////////////
fd31e9de	229	///////////// AliEveTRDDigitsEditor /////////////////////
edf0c4a0	230	///////////////////////////////////////////////////////////
fd31e9de	231	AliEveTRDDigitsEditor::AliEveTRDDigitsEditor(const TGWindow* p, Int_t width, Int_t height,
	232	UInt_t options, Pixel_t back) :
	233	TGedFrame(p, width, height, options, back),
	234	fM(0)
edf0c4a0	235	{
fd31e9de	236	MakeTitle("TRD Digits");
edf0c4a0	237
	238	}
	239
d810d0de	240	AliEveTRDDigitsEditor::~AliEveTRDDigitsEditor()
edf0c4a0	241	{}
edf0c4a0	242
d810d0de	243	void AliEveTRDDigitsEditor::SetModel(TObject* obj)
edf0c4a0	244	{
fd31e9de	245	fM = dynamic_cast<AliEveTRDDigits*>(obj);
	246	fM->fParent->SpawnEditor();
	247
	248	// printf("Chamber %d", fM->fParent->GetID());
	249	// for (Int_t row = 0; row < fM->fParent->GetRowMax(); row++)
	250	// for (Int_t col = 0; col < fM->fParent->GetColMax(); col++)
	251	// for (Int_t time = 0; time < fM->fParent->GetTimeMax(); time++) {
	252	// printf("\tA(%d %d %d) = %d\n", row, col, time, fM->fData.GetDataUnchecked(row, col, time));
	253	// }
edf0c4a0	254	}