[u/mrichter/AliRoot.git] / EVE / Alieve / TRDModuleImp.cxx

#include "TRDModuleImp.h"
#include "TRDData.h"

#include "TMath.h"
#include <TGListTree.h>

#include "Reve/ReveManager.h"
#include "Reve/Track.h"

#include "AliLog.h"
#include "AliRun.h"
#include "AliTRDv1.h"
#include "AliTRDgeometry.h"
#include "AliTRDCommonParam.h"
#include "AliTRDpadPlane.h"
#include "AliTRDdigit.h"
#include "AliTRDhit.h"
#include "AliTRDcluster.h"
#include "AliTRDcalibDB.h"
#include "AliTRDdataArrayI.h"
#include "AliTRDmcmTracklet.h"


using namespace Reve;
using namespace Alieve;
using namespace std;

ClassImp(TRDChamber)
ClassImp(TRDNode)

//________________________________________________________
TRDNode::TRDNode(const char *typ, Int_t det) :
  Reve::RenderElement(), TRDModule(typ, det)
{
}

//________________________________________________________
void	TRDNode::Paint(Option_t* option)
{
	List_i iter = fChildren.begin();
	while(iter != fChildren.end()){
		(dynamic_cast<TRDModule*>(*iter))->Paint(option);
		iter++;
	}
}

//________________________________________________________
void	TRDNode::Reset()
{
	List_i iter = fChildren.begin();
	while(iter != fChildren.end()){
		(dynamic_cast<TRDModule*>(*iter))->Reset();
		iter++;
	}
}

//________________________________________________________
void TRDNode::Collapse()
{
	TGListTree *list = gReve->GetListTree();
	TRDNode *node = 0x0;
	List_i iter = fChildren.begin();
	while(iter != fChildren.end()){
		if((node = dynamic_cast<TRDNode*>(*iter))) node->Collapse();
		list->CloseItem(FindListTreeItem(list));
		iter++;
	}
}

//________________________________________________________
void TRDNode::Expand()
{
	TGListTree *list = gReve->GetListTree();
	TRDNode *node = 0x0;
	List_i iter = fChildren.begin();
	while(iter != fChildren.end()){
		if((node = dynamic_cast<TRDNode*>(*iter))) node->Expand();
		list->OpenItem(FindListTreeItem(list));
		iter++;
	}
}

//________________________________________________________
void TRDNode::EnableListElements()
{
	SetRnrSelf(kTRUE);
	TRDNode *node = 0x0;
	TRDChamber *chmb = 0x0;	
	List_i iter = fChildren.begin();
	while(iter != fChildren.end()){
		if((node = dynamic_cast<TRDNode*>(*iter))){
			node->SetRnrSelf(kTRUE);
			node->EnableListElements();
		}
		if((chmb = dynamic_cast<TRDChamber*>(*iter))) chmb->SetRnrSelf(kTRUE);
		iter++;
	}
	gReve->Redraw3D();
}

//________________________________________________________
void TRDNode::DisableListElements()
{
	SetRnrSelf(kFALSE);
	TRDNode *node = 0x0;
	TRDChamber *chmb = 0x0;	
	List_i iter = fChildren.begin();
	while(iter != fChildren.end()){
		if((node = dynamic_cast<TRDNode*>(*iter))){
			node->SetRnrSelf(kFALSE);
			node->DisableListElements();
		}
		if((chmb = dynamic_cast<TRDChamber*>(*iter))) chmb->SetRnrSelf(kFALSE);
		iter++;
	}
	gReve->Redraw3D();
}

//________________________________________________________
void TRDNode::UpdateLeaves()
{
	TRDModule *module;
	List_i iter = fChildren.begin();
	while(iter != fChildren.end()){
		module = dynamic_cast<TRDModule*>(*iter);
		if(!module) continue;
		
		module->fRnrHits = fRnrHits;
		module->fRnrDigits = fRnrDigits;
		module->fDigitsLog = fDigitsLog;
		module->fDigitsBox = fDigitsBox;
		module->fDigitsThreshold = fDigitsThreshold;
		module->kDigitsNeedRecompute = kDigitsNeedRecompute;
		module->fRnrRecPoints = fRnrRecPoints;
		module->fRnrTracklets = fRnrTracklets;
		iter++;
	}

	TRDNode *node = 0x0;
	iter = fChildren.begin();
	while(iter != fChildren.end()){
		if((node = dynamic_cast<TRDNode*>(*iter))) node->UpdateLeaves();
		iter++;
	}
}


//________________________________________________________
void TRDNode::UpdateNode()
{
//	Info("UpdateNode()", Form("%s", GetName()));
	TRDNode *node = 0x0;
	List_i iter = fChildren.begin();
	while(iter != fChildren.end()){
		if((node = dynamic_cast<TRDNode*>(*iter))) node->UpdateNode();
		iter++;
	}

	Int_t score[11];
	for(int i=0; i<11; i++) score[i] = 0;
	TRDModule *module;
	iter = fChildren.begin();
	while(iter != fChildren.end()){
		module = dynamic_cast<TRDModule*>(*iter);
		if(!module) continue;
		score[0] += (module->fLoadHits) ? 1 : 0;
		score[1] += (module->fRnrHits) ? 1 : 0;
		
		score[2] += (module->fLoadDigits) ? 1 : 0;
		score[3] += (module->fRnrDigits) ? 1 : 0;
		score[4] += (module->fDigitsLog) ? 1 : 0;
		score[5] += (module->fDigitsBox) ? 1 : 0;
		score[6] += (module->kDigitsNeedRecompute) ? 1 : 0;

		score[7] += (module->fLoadRecPoints) ? 1 : 0;
		score[8] += (module->fRnrRecPoints) ? 1 : 0;

		score[9] += (module->fLoadTracklets) ? 1 : 0;
		score[10] += (module->fRnrTracklets) ? 1 : 0;
		iter++;
	}

	Int_t size = fChildren.size(); 
	fLoadHits      = (score[0] > 0) ? kTRUE : kFALSE;
	fRnrHits       = (score[1] == size) ? kTRUE : kFALSE;

	fLoadDigits    = (score[2] > 0) ? kTRUE : kFALSE;
	fRnrDigits     = (score[3] == size) ? kTRUE : kFALSE;
	fDigitsLog     = (score[4] == size) ? kTRUE : kFALSE;
	fDigitsBox     = (score[5] == size) ? kTRUE : kFALSE;
	kDigitsNeedRecompute = (score[6] == size) ? kTRUE : kFALSE;

	fLoadRecPoints = (score[7] > 0) ? kTRUE : kFALSE;
	fRnrRecPoints  = (score[8] == size) ? kTRUE : kFALSE;

	fLoadTracklets = (score[9] > 0) ? kTRUE : kFALSE;
	fRnrTracklets  = (score[10] == size) ? kTRUE : kFALSE;
}


///////////////////////////////////////////////////////////
/////////////        TRDChamber       /////////////////////
///////////////////////////////////////////////////////////

//________________________________________________________
TRDChamber::TRDChamber(Int_t det) :
  Reve::RenderElement(), TRDModule("Chmb", det), rowMax(-1), colMax(-1), timeMax(22), fX0(0.), fPla(-1)
{
  //
  // Constructor
  //
	
	fDigits    = 0x0;
	fHits      = 0x0;
	fRecPoints = 0x0;
	fTracklets = 0x0;
	
	AliTRDCommonParam* parCom = AliTRDCommonParam::Instance();
	samplingFrequency = parCom->GetSamplingFrequency();
	
	fGeo      = 0x0;
	fPadPlane = 0x0;
}

//________________________________________________________
TRDChamber::TRDChamber(const TRDChamber &mod):
  Reve::RenderElement(), TRDModule("Chmb", mod.fDet)
{
  //
  // Copy constructor
  //
	SetMainColor(mod.GetMainColor());

	if(mod.fDigits) {}
	if(mod.fHits) {}
	if(mod.fRecPoints){} 
}

//________________________________________________________
TRDChamber& TRDChamber::operator=(const TRDChamber &mod)
{
  //
  // Assignment operator
  //

  if (this != &mod) {
    fDet    = mod.fDet;
		if(mod.fDigits) {}
		if(mod.fHits) {}
		if(mod.fRecPoints){} 
  }
  return *this;
}

//________________________________________________________
Int_t	TRDChamber::GetSM() const
{
	if(!fGeo){
		AliWarning("Fail. No TRD geometry defined.");
		return -1;
	}
	return fGeo->GetSector(fDet);
}

//________________________________________________________
Int_t	TRDChamber::GetSTK() const
{
	if(!fGeo){
		AliWarning("Fail. No TRD geometry defined.");
		return -1;
	}
	return fGeo->GetChamber(fDet);
}

//________________________________________________________
void TRDChamber::LoadClusters(TObjArray *clusters)
{
  //
  // Draw clusters
  //
	
	if(!fGeo){
		AliError(Form("Geometry not set for chamber %d. Please call first TRDChamber::SetGeometry().", fDet));
		return;
	}
	
	if(!fRecPoints){
		fRecPoints = new TRDClusters(this);
		fRecPoints->SetMarkerSize(1.);
		fRecPoints->SetMarkerStyle(24);
		fRecPoints->SetMarkerColor(6);
		fRecPoints->SetOwnIds(kTRUE);
	} else fRecPoints->Reset();

	Float_t q;
        Double_t cloc[3], cglo[3];
	
	AliTRDcluster *c=0x0;
	for(int iclus=0; iclus<clusters->GetEntriesFast(); iclus++){
		c = (AliTRDcluster*)clusters->UncheckedAt(iclus);
		cloc[0] = c->GetX();
		cloc[1] = c->GetY();
		cloc[2] = c->GetZ();
		q = c->GetQ();
		fGeo->RotateBack(fDet,cloc,cglo);
		fRecPoints->SetNextPoint(cglo[0], cglo[1], cglo[2]);
		fRecPoints->SetPointId(c);
	}
	fLoadRecPoints = kTRUE;
}

//________________________________________________________
void TRDChamber::LoadDigits(AliTRDdigitsManager *digits)
{
  //
  // Draw digits
  //
	if(!fGeo){
		AliError(Form("Geometry not set for chamber %d. Please call first TRDChamber::SetGeometry().", fDet));
		return;
	}
//	Info("LoadDigits()", Form("digits =0x%x", digits));
	
	if(!fDigits) fDigits = new TRDDigits(this);
	else fDigits->Reset();
	
	fDigits->SetData(digits);
	fLoadDigits = kTRUE;
}

//________________________________________________________
void TRDChamber::AddHit(AliTRDhit *hit)
{
  //
  // Draw hits
  //
//	Info("AddHit()", Form("%s", GetName()));

	if(!fHits){
		fHits = new TRDHits(this);
		fHits->SetMarkerSize(.1);
		fHits->SetMarkerColor(2);
		fHits->SetOwnIds(kTRUE);
	}
	
	fHits->SetNextPoint(hit->X(), hit->Y(), hit->Z());
	fHits->SetPointId(hit);
	fLoadHits = kTRUE;
}

//________________________________________________________
void TRDChamber::LoadTracklets(TObjArray *tracks)
{
  //
  // Draw tracks
  //
	if(!fGeo){
		Error("LoadTracklets()", Form("Geometry not set for chamber %d. Please call first TRDChamber::SetGeometry().", fDet));
		return;
	}
//	Info("LoadTracklets()", Form("tracks = 0x%x", tracks));
	
	if(!fTracklets){
		fTracklets = new std::vector<Reve::Track*>;
	} else fTracklets->clear();
	
	
	AliTRDmcmTracklet *trk = 0x0;
	Double_t cloc[3], cglo[3];
	for(int itrk=0; itrk<tracks->GetEntries();itrk++){
		trk = (AliTRDmcmTracklet*)tracks->At(itrk);
		trk->MakeTrackletGraph(fGeo,.5);
		fTracklets->push_back(new Reve::Track());
		fTracklets->back()->SetLineColor(4);
		
		cloc[0] = trk->GetTime0(); // x0
		cloc[1] = trk->GetOffset(); // y0
		cloc[2] = trk->GetRowz(); // z
	  fGeo->RotateBack(fDet,cloc,cglo);
		fTracklets->back()->SetNextPoint(cglo[0], cglo[1], cglo[2]);
		
		cloc[0] += 3.7; // x1
		cloc[1] += TMath::Tan(trk->GetSlope()*TMath::Pi()/180.) * 3.7; // y1
	  fGeo->RotateBack(fDet,cloc,cglo);
		fTracklets->back()->SetNextPoint(cglo[0], cglo[1], cglo[2]);
	}
	fLoadTracklets = kTRUE;
}

//____________________________________________________
void	TRDChamber::Paint(Option_t* option)
{
/*	Info("Paint()", Form("%s", GetName()));*/
	if(!fRnrSelf) return;
	if(fDigits && fRnrDigits){
		if(kDigitsNeedRecompute){
			fDigits->ComputeRepresentation();
			kDigitsNeedRecompute = kFALSE;
		}
		fDigits->Paint(option);
	}
	if(fRecPoints && fRnrRecPoints) fRecPoints->GetObject()->Paint(option);
	if(fHits && fRnrHits) fHits->GetObject()->Paint(option);
	if(fTracklets && fRnrTracklets){
		for(vector<Reve::Track*>::iterator i=fTracklets->begin(); i != fTracklets->end(); ++i) (*i)->Paint(option);
	}
}

//________________________________________________________
void	TRDChamber::Reset()
{
	if(fHits){
		fHits->Reset();
		fLoadHits = kFALSE;
	}
	if(fDigits){
		fDigits->Reset();
		fLoadDigits = kFALSE;
	}
	if(fRecPoints){
		fRecPoints->Reset();
		fLoadRecPoints = kFALSE;
	}
	if(fTracklets){
		fTracklets->clear();
		fLoadTracklets = kFALSE;
	}
}

//________________________________________________________
void TRDChamber::SetGeometry(AliTRDgeometry *geo)
{
	fGeo = geo;
		
	fPla = fGeo->GetPlane(fDet);
	fX0 = fGeo->GetTime0(fPla);
	
	fPadPlane = fGeo->GetPadPlane(fPla,fGeo->GetChamber(fDet));
	rowMax = fPadPlane->GetNrows();
	colMax = fPadPlane->GetNcols();
}
Commit	Line	Data
a282bf09	1	#include "TRDModuleImp.h"
	2	#include "TRDData.h"
	3
	4	#include "TMath.h"
	5	#include <TGListTree.h>
	6
32e219c2	7	#include "Reve/ReveManager.h"
a282bf09	8	#include "Reve/Track.h"
a282bf09	9
edf0c4a0	10	#include "AliLog.h"
a282bf09	11	#include "AliRun.h"
	12	#include "AliTRDv1.h"
	13	#include "AliTRDgeometry.h"
	14	#include "AliTRDCommonParam.h"
	15	#include "AliTRDpadPlane.h"
	16	#include "AliTRDdigit.h"
	17	#include "AliTRDhit.h"
	18	#include "AliTRDcluster.h"
	19	#include "AliTRDcalibDB.h"
	20	#include "AliTRDdataArrayI.h"
	21	#include "AliTRDmcmTracklet.h"
	22
	23
	24
	25	using namespace Reve;
	26	using namespace Alieve;
	27	using namespace std;
	28
	29	ClassImp(TRDChamber)
	30	ClassImp(TRDNode)
	31
	32	//________________________________________________________
f5790a4c	33	TRDNode::TRDNode(const char *typ, Int_t det) :
2caed564	34	Reve::RenderElement(), TRDModule(typ, det)
a282bf09	35	{
	36	}
	37
	38	//________________________________________________________
	39	void TRDNode::Paint(Option_t* option)
	40	{
e6ac3950	41	List_i iter = fChildren.begin();
a282bf09	42	while(iter != fChildren.end()){
	43	(dynamic_cast<TRDModule>(iter))->Paint(option);
	44	iter++;
	45	}
	46	}
	47
	48	//________________________________________________________
	49	void TRDNode::Reset()
	50	{
e6ac3950	51	List_i iter = fChildren.begin();
a282bf09	52	while(iter != fChildren.end()){
	53	(dynamic_cast<TRDModule>(iter))->Reset();
	54	iter++;
	55	}
	56	}
	57
	58	//________________________________________________________
14217b5f	59	void TRDNode::Collapse()
a282bf09	60	{
	61	TGListTree *list = gReve->GetListTree();
	62	TRDNode *node = 0x0;
e6ac3950	63	List_i iter = fChildren.begin();
a282bf09	64	while(iter != fChildren.end()){
14217b5f	65	if((node = dynamic_cast<TRDNode>(iter))) node->Collapse();
a282bf09	66	list->CloseItem(FindListTreeItem(list));
	67	iter++;
	68	}
	69	}
	70
	71	//________________________________________________________
	72	void TRDNode::Expand()
	73	{
	74	TGListTree *list = gReve->GetListTree();
	75	TRDNode *node = 0x0;
e6ac3950	76	List_i iter = fChildren.begin();
a282bf09	77	while(iter != fChildren.end()){
	78	if((node = dynamic_cast<TRDNode>(iter))) node->Expand();
	79	list->OpenItem(FindListTreeItem(list));
	80	iter++;
	81	}
	82	}
	83
	84	//________________________________________________________
	85	void TRDNode::EnableListElements()
	86	{
2caed564	87	SetRnrSelf(kTRUE);
a282bf09	88	TRDNode *node = 0x0;
a282bf09	89	TRDChamber *chmb = 0x0;
e6ac3950	90	List_i iter = fChildren.begin();
a282bf09	91	while(iter != fChildren.end()){
a282bf09	92	if((node = dynamic_cast<TRDNode>(iter))){
2caed564	93	node->SetRnrSelf(kTRUE);
a282bf09	94	node->EnableListElements();
a282bf09	95	}
2caed564	96	if((chmb = dynamic_cast<TRDChamber>(iter))) chmb->SetRnrSelf(kTRUE);
a282bf09	97	iter++;
	98	}
	99	gReve->Redraw3D();
	100	}
	101
	102	//________________________________________________________
	103	void TRDNode::DisableListElements()
	104	{
2caed564	105	SetRnrSelf(kFALSE);
a282bf09	106	TRDNode *node = 0x0;
a282bf09	107	TRDChamber *chmb = 0x0;
e6ac3950	108	List_i iter = fChildren.begin();
a282bf09	109	while(iter != fChildren.end()){
a282bf09	110	if((node = dynamic_cast<TRDNode>(iter))){
2caed564	111	node->SetRnrSelf(kFALSE);
a282bf09	112	node->DisableListElements();
a282bf09	113	}
2caed564	114	if((chmb = dynamic_cast<TRDChamber>(iter))) chmb->SetRnrSelf(kFALSE);
a282bf09	115	iter++;
	116	}
	117	gReve->Redraw3D();
	118	}
	119
	120	//________________________________________________________
	121	void TRDNode::UpdateLeaves()
	122	{
	123	TRDModule *module;
e6ac3950	124	List_i iter = fChildren.begin();
a282bf09	125	while(iter != fChildren.end()){
	126	module = dynamic_cast<TRDModule>(iter);
	127	if(!module) continue;
	128
	129	module->fRnrHits = fRnrHits;
	130	module->fRnrDigits = fRnrDigits;
	131	module->fDigitsLog = fDigitsLog;
	132	module->fDigitsBox = fDigitsBox;
	133	module->fDigitsThreshold = fDigitsThreshold;
	134	module->kDigitsNeedRecompute = kDigitsNeedRecompute;
	135	module->fRnrRecPoints = fRnrRecPoints;
	136	module->fRnrTracklets = fRnrTracklets;
	137	iter++;
	138	}
	139
	140	TRDNode *node = 0x0;
	141	iter = fChildren.begin();
	142	while(iter != fChildren.end()){
	143	if((node = dynamic_cast<TRDNode>(iter))) node->UpdateLeaves();
	144	iter++;
	145	}
	146	}
	147
	148
	149	//________________________________________________________
	150	void TRDNode::UpdateNode()
	151	{
	152	// Info("UpdateNode()", Form("%s", GetName()));
	153	TRDNode *node = 0x0;
e6ac3950	154	List_i iter = fChildren.begin();
a282bf09	155	while(iter != fChildren.end()){
	156	if((node = dynamic_cast<TRDNode>(iter))) node->UpdateNode();
	157	iter++;
	158	}
	159
	160	Int_t score[11];
	161	for(int i=0; i<11; i++) score[i] = 0;
	162	TRDModule *module;
	163	iter = fChildren.begin();
	164	while(iter != fChildren.end()){
	165	module = dynamic_cast<TRDModule>(iter);
	166	if(!module) continue;
	167	score[0] += (module->fLoadHits) ? 1 : 0;
	168	score[1] += (module->fRnrHits) ? 1 : 0;
	169
	170	score[2] += (module->fLoadDigits) ? 1 : 0;
	171	score[3] += (module->fRnrDigits) ? 1 : 0;
	172	score[4] += (module->fDigitsLog) ? 1 : 0;
	173	score[5] += (module->fDigitsBox) ? 1 : 0;
	174	score[6] += (module->kDigitsNeedRecompute) ? 1 : 0;
	175
	176	score[7] += (module->fLoadRecPoints) ? 1 : 0;
	177	score[8] += (module->fRnrRecPoints) ? 1 : 0;
	178
	179	score[9] += (module->fLoadTracklets) ? 1 : 0;
	180	score[10] += (module->fRnrTracklets) ? 1 : 0;
	181	iter++;
	182	}
	183
	184	Int_t size = fChildren.size();
	185	fLoadHits = (score[0] > 0) ? kTRUE : kFALSE;
	186	fRnrHits = (score[1] == size) ? kTRUE : kFALSE;
	187
	188	fLoadDigits = (score[2] > 0) ? kTRUE : kFALSE;
	189	fRnrDigits = (score[3] == size) ? kTRUE : kFALSE;
	190	fDigitsLog = (score[4] == size) ? kTRUE : kFALSE;
	191	fDigitsBox = (score[5] == size) ? kTRUE : kFALSE;
	192	kDigitsNeedRecompute = (score[6] == size) ? kTRUE : kFALSE;
	193
	194	fLoadRecPoints = (score[7] > 0) ? kTRUE : kFALSE;
	195	fRnrRecPoints = (score[8] == size) ? kTRUE : kFALSE;
	196
	197	fLoadTracklets = (score[9] > 0) ? kTRUE : kFALSE;
	198	fRnrTracklets = (score[10] == size) ? kTRUE : kFALSE;
	199	}
	200
	201
	202	///////////////////////////////////////////////////////////
	203	///////////// TRDChamber /////////////////////
	204	///////////////////////////////////////////////////////////
	205
	206	//________________________________________________________
f5790a4c	207	TRDChamber::TRDChamber(Int_t det) :
14217b5f	208	Reve::RenderElement(), TRDModule("Chmb", det), rowMax(-1), colMax(-1), timeMax(22), fX0(0.), fPla(-1)
a282bf09	209	{
	210	//
	211	// Constructor
	212	//
14217b5f	213
a282bf09	214	fDigits = 0x0;
	215	fHits = 0x0;
	216	fRecPoints = 0x0;
	217	fTracklets = 0x0;
	218
c9625b63	219	AliTRDCommonParam* parCom = AliTRDCommonParam::Instance();
c9625b63	220	samplingFrequency = parCom->GetSamplingFrequency();
14217b5f	221
	222	fGeo = 0x0;
	223	fPadPlane = 0x0;
a282bf09	224	}
	225
	226	//________________________________________________________
14217b5f	227	TRDChamber::TRDChamber(const TRDChamber &mod):
a282bf09	228	Reve::RenderElement(), TRDModule("Chmb", mod.fDet)
	229	{
	230	//
	231	// Copy constructor
	232	//
	233	SetMainColor(mod.GetMainColor());
	234
	235	if(mod.fDigits) {}
	236	if(mod.fHits) {}
	237	if(mod.fRecPoints){}
	238	}
	239
	240	//________________________________________________________
	241	TRDChamber& TRDChamber::operator=(const TRDChamber &mod)
	242	{
	243	//
	244	// Assignment operator
	245	//
	246
	247	if (this != &mod) {
	248	fDet = mod.fDet;
	249	if(mod.fDigits) {}
	250	if(mod.fHits) {}
	251	if(mod.fRecPoints){}
	252	}
	253	return *this;
	254	}
	255
edf0c4a0	256	//________________________________________________________
	257	Int_t TRDChamber::GetSM() const
	258	{
	259	if(!fGeo){
	260	AliWarning("Fail. No TRD geometry defined.");
	261	return -1;
	262	}
	263	return fGeo->GetSector(fDet);
	264	}
	265
	266	//________________________________________________________
	267	Int_t TRDChamber::GetSTK() const
	268	{
	269	if(!fGeo){
	270	AliWarning("Fail. No TRD geometry defined.");
	271	return -1;
	272	}
	273	return fGeo->GetChamber(fDet);
	274	}
	275
a282bf09	276	//________________________________________________________
	277	void TRDChamber::LoadClusters(TObjArray *clusters)
	278	{
	279	//
	280	// Draw clusters
	281	//
	282
14217b5f	283	if(!fGeo){
edf0c4a0	284	AliError(Form("Geometry not set for chamber %d. Please call first TRDChamber::SetGeometry().", fDet));
14217b5f	285	return;
14217b5f	286	}
edf0c4a0	287
a282bf09	288	if(!fRecPoints){
edf0c4a0	289	fRecPoints = new TRDClusters(this);
a282bf09	290	fRecPoints->SetMarkerSize(1.);
	291	fRecPoints->SetMarkerStyle(24);
	292	fRecPoints->SetMarkerColor(6);
edf0c4a0	293	fRecPoints->SetOwnIds(kTRUE);
14217b5f	294	} else fRecPoints->Reset();
a282bf09	295
be2031ac	296	Float_t q;
be2031ac	297	Double_t cloc[3], cglo[3];
a282bf09	298
a282bf09	299	AliTRDcluster *c=0x0;
	300	for(int iclus=0; iclus<clusters->GetEntriesFast(); iclus++){
	301	c = (AliTRDcluster*)clusters->UncheckedAt(iclus);
be2031ac	302	cloc[0] = c->GetX();
	303	cloc[1] = c->GetY();
	304	cloc[2] = c->GetZ();
a282bf09	305	q = c->GetQ();
	306	fGeo->RotateBack(fDet,cloc,cglo);
	307	fRecPoints->SetNextPoint(cglo[0], cglo[1], cglo[2]);
edf0c4a0	308	fRecPoints->SetPointId(c);
a282bf09	309	}
	310	fLoadRecPoints = kTRUE;
	311	}
	312
	313	//________________________________________________________
14217b5f	314	void TRDChamber::LoadDigits(AliTRDdigitsManager *digits)
a282bf09	315	{
	316	//
	317	// Draw digits
	318	//
14217b5f	319	if(!fGeo){
edf0c4a0	320	AliError(Form("Geometry not set for chamber %d. Please call first TRDChamber::SetGeometry().", fDet));
14217b5f	321	return;
	322	}
	323	// Info("LoadDigits()", Form("digits =0x%x", digits));
	324
a282bf09	325	if(!fDigits) fDigits = new TRDDigits(this);
	326	else fDigits->Reset();
	327
	328	fDigits->SetData(digits);
	329	fLoadDigits = kTRUE;
	330	}
	331
	332	//________________________________________________________
	333	void TRDChamber::AddHit(AliTRDhit *hit)
	334	{
	335	//
	336	// Draw hits
	337	//
14217b5f	338	// Info("AddHit()", Form("%s", GetName()));
14217b5f	339
a282bf09	340	if(!fHits){
edf0c4a0	341	fHits = new TRDHits(this);
a282bf09	342	fHits->SetMarkerSize(.1);
a282bf09	343	fHits->SetMarkerColor(2);
edf0c4a0	344	fHits->SetOwnIds(kTRUE);
a282bf09	345	}
14217b5f	346
a282bf09	347	fHits->SetNextPoint(hit->X(), hit->Y(), hit->Z());
edf0c4a0	348	fHits->SetPointId(hit);
a282bf09	349	fLoadHits = kTRUE;
	350	}
	351
	352	//________________________________________________________
	353	void TRDChamber::LoadTracklets(TObjArray *tracks)
	354	{
	355	//
	356	// Draw tracks
	357	//
14217b5f	358	if(!fGeo){
	359	Error("LoadTracklets()", Form("Geometry not set for chamber %d. Please call first TRDChamber::SetGeometry().", fDet));
	360	return;
	361	}
	362	// Info("LoadTracklets()", Form("tracks = 0x%x", tracks));
	363
a282bf09	364	if(!fTracklets){
a282bf09	365	fTracklets = new std::vector<Reve::Track*>;
14217b5f	366	} else fTracklets->clear();
a282bf09	367
a282bf09	368
	369	AliTRDmcmTracklet *trk = 0x0;
	370	Double_t cloc[3], cglo[3];
	371	for(int itrk=0; itrk<tracks->GetEntries();itrk++){
	372	trk = (AliTRDmcmTracklet*)tracks->At(itrk);
	373	trk->MakeTrackletGraph(fGeo,.5);
	374	fTracklets->push_back(new Reve::Track());
	375	fTracklets->back()->SetLineColor(4);
	376
	377	cloc[0] = trk->GetTime0(); // x0
	378	cloc[1] = trk->GetOffset(); // y0
	379	cloc[2] = trk->GetRowz(); // z
	380	fGeo->RotateBack(fDet,cloc,cglo);
	381	fTracklets->back()->SetNextPoint(cglo[0], cglo[1], cglo[2]);
	382
	383	cloc[0] += 3.7; // x1
	384	cloc[1] += TMath::Tan(trk->GetSlope()TMath::Pi()/180.) 3.7; // y1
	385	fGeo->RotateBack(fDet,cloc,cglo);
	386	fTracklets->back()->SetNextPoint(cglo[0], cglo[1], cglo[2]);
	387	}
	388	fLoadTracklets = kTRUE;
	389	}
	390
	391	//____________________________________________________
	392	void TRDChamber::Paint(Option_t* option)
	393	{
	394	/* Info("Paint()", Form("%s", GetName()));*/
2caed564	395	if(!fRnrSelf) return;
a282bf09	396	if(fDigits && fRnrDigits){
a282bf09	397	if(kDigitsNeedRecompute){
a282bf09	398	fDigits->ComputeRepresentation();
	399	kDigitsNeedRecompute = kFALSE;
	400	}
	401	fDigits->Paint(option);
	402	}
	403	if(fRecPoints && fRnrRecPoints) fRecPoints->GetObject()->Paint(option);
	404	if(fHits && fRnrHits) fHits->GetObject()->Paint(option);
	405	if(fTracklets && fRnrTracklets){
	406	for(vector<Reve::Track>::iterator i=fTracklets->begin(); i != fTracklets->end(); ++i) (i)->Paint(option);
	407	}
	408	}
	409
	410	//________________________________________________________
	411	void TRDChamber::Reset()
	412	{
	413	if(fHits){
	414	fHits->Reset();
	415	fLoadHits = kFALSE;
	416	}
	417	if(fDigits){
	418	fDigits->Reset();
	419	fLoadDigits = kFALSE;
	420	}
	421	if(fRecPoints){
	422	fRecPoints->Reset();
	423	fLoadRecPoints = kFALSE;
	424	}
	425	if(fTracklets){
	426	fTracklets->clear();
	427	fLoadTracklets = kFALSE;
	428	}
	429	}
	430
14217b5f	431	//________________________________________________________
	432	void TRDChamber::SetGeometry(AliTRDgeometry *geo)
	433	{
	434	fGeo = geo;
	435
	436	fPla = fGeo->GetPlane(fDet);
	437	fX0 = fGeo->GetTime0(fPla);
	438
2f767356	439	fPadPlane = fGeo->GetPadPlane(fPla,fGeo->GetChamber(fDet));
14217b5f	440	rowMax = fPadPlane->GetNrows();
	441	colMax = fPadPlane->GetNcols();
	442	}
	443