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

#include "TRDLoader.h"
#include "TRDModuleImp.h"

#include <Reve/RGTopFrame.h>
#include <Reve/RGValuators.h>

#include <TSystem.h>
#include <TGLabel.h>
#include <TGButton.h>
#include <TGTextEntry.h>
#include <TGNumberEntry.h>
#include <TGFileDialog.h>
#include <TGListTree.h>
#include <TGToolTip.h>

#include "AliRun.h"
#include "AliRunLoader.h"
#include "AliLoader.h"
#include "AliCDBManager.h"

#include "AliTRDv1.h"
#include "AliTRDhit.h"
#include "AliTRDcluster.h"
#include "AliTRDmcmTracklet.h"
#include "AliTRDdigitsManager.h"
#include "AliTRDgeometry.h"

#include <algorithm>

using namespace Reve;
using namespace Alieve;
using namespace std;
class AliTRDdataArrayI;

ClassImp(Alieve::TRDLoader)
ClassImp(Alieve::TRDLoaderEditor)

///////////////////////////////////////////////////////////
/////////////         TRDLoader       /////////////////////
///////////////////////////////////////////////////////////


//________________________________________________________
TRDLoader::TRDLoader(const Text_t* n, const Text_t* t) : Reve::RenderElement(), TNamed(n,t), fSM(-1), fStack(-1), fLy(-1), fEvent(0)
{	
	kLoadHits = kFALSE;
	kLoadDigits = kFALSE;
	kLoadClusters = kFALSE;
	kLoadTracks = kFALSE;
	fFilename = "";
	fDir = ".";
	
	fRunLoader = 0x0;
	fGeo = new AliTRDgeometry();
	
	AliCDBManager *fCDBManager=AliCDBManager::Instance();
	fCDBManager->SetDefaultStorage("local://$ALICE_ROOT");
	fCDBManager->SetRun(0);
}

//________________________________________________________
TRDLoader::~TRDLoader()
{
//	if(fChambers) {fChambers->clear(); delete fChambers;}
}

//________________________________________________________
template<class T>
class ID
{
public:
	ID( int value ) : id(value) {}
	bool operator()(const T &t) const {
		return ((dynamic_cast<TRDModule*>(t))->GetID() == id);
	}
private:
	const int id;
};
void	TRDLoader::AddChambers(int sm, int stk, int ly)
{
	Int_t ism_start = (sm == -1) ?  0 : sm;
	Int_t ism_stop  = (sm == -1) ? 18 : sm+1;
	Int_t istk_start= (stk == -1)?  0 : stk;
	Int_t istk_stop = (stk == -1)?  5 : stk+1;
	Int_t ily_start = (ly == -1) ?  0 : ly;
	Int_t ily_stop  = (ly == -1) ?  6 : ly+1;

	List_i ichmb;
	ichmb = fChildren.begin();
	while(ichmb != fChildren.end()){
		(*ichmb)->SetRnrSelf(kFALSE);
		ichmb++;
	}

	TRDNode *SM=0x0, *STK=0x0;
	TRDChamber *CHMB = 0x0;
	int det;
	for(int ism=ism_start; ism<ism_stop; ism++){
		ichmb = find_if(fChildren.begin(), fChildren.end(), ID<RenderElement*>(ism));
		if(ichmb != fChildren.end()){
			SM = (TRDNode*)(*ichmb);
			SM->SetRnrSelf(kTRUE);
		}else{
			gReve->AddRenderElement(this, SM = new TRDNode("SM", ism));
			SM->FindListTreeItem(gReve->GetListTree())->SetTipText(Form("Supermodule %2d", ism));
		}
		for(int istk=istk_start; istk<istk_stop; istk++){
			ichmb = find_if(SM->begin(), SM->end(), ID<RenderElement*>(istk));
			if(ichmb != SM->end()){
				STK = (TRDNode*)(*ichmb);
				STK->SetRnrSelf(kTRUE);
			}else{
				gReve->AddRenderElement(SM, STK = new TRDNode("Stack", istk));
				STK->FindListTreeItem(gReve->GetListTree())->SetTipText(Form("SM %2d Stack %1d", ism, istk));
			}
			for(int ily=ily_start; ily<ily_stop; ily++){
				det = fGeo->GetDetector(ily, istk, ism);
				ichmb = find_if(STK->begin(), STK->end(), ID<RenderElement*>(det));
				if(ichmb != STK->end()) (*ichmb)->SetRnrSelf(kTRUE);
				else{
					gReve->AddRenderElement(STK, CHMB = new TRDChamber(det));
					CHMB->SetGeometry(fGeo);
					CHMB->FindListTreeItem(gReve->GetListTree())->SetTipText(Form("SM %2d Stack %1d Layer %1d", ism, istk, ily));
				}
			}
		}
	}
	gReve->Redraw3D();
}

//________________________________________________________
TRDChamber*	TRDLoader::GetChamber(int d)
{
	List_i ism, istack, ichmb;
	
	ism = find_if(fChildren.begin(), fChildren.end(), ID<RenderElement*>(fGeo->GetSector(d)));
	if(ism == fChildren.end()) return 0x0;
	istack = find_if(((TRDNode*)(*ism))->begin(), ((TRDNode*)(*ism))->end(), ID<RenderElement*>(fGeo->GetChamber(d)));
	if(istack == ((TRDNode*)(*ism))->end()) return 0x0;
	ichmb = find_if(((TRDNode*)(*istack))->begin(), ((TRDNode*)(*istack))->end(), ID<RenderElement*>(d));
	if(ichmb == ((TRDNode*)(*istack))->end()) return 0x0;
	return dynamic_cast<TRDChamber*>(*ichmb);
}

//________________________________________________________
Bool_t	TRDLoader::GoToEvent(int ev)
{
	Info("GoToEvent", Form("Event = %d", ev));
	fEvent = ev;

	if(!fRunLoader) return kFALSE;
	fRunLoader->UnloadAll("TRD");
	Unload();
	
	fRunLoader->GetEvent(ev);
	TTree *t = 0x0;
	if(kLoadHits){
		fRunLoader->LoadHits("TRD", "READ");
		t = fRunLoader->GetTreeH("TRD", kFALSE);
		if(!t) return kFALSE;
		fTRD->SetTreeAddress();
		if(!LoadHits(t)) return kFALSE;
	}
	if(kLoadDigits){
		fRunLoader->LoadDigits("TRD", "READ");
		t = fRunLoader->GetTreeD("TRD", kFALSE);
		if(!t) return kFALSE;
		fTRD->SetTreeAddress();
		if(!LoadDigits(t)) return kFALSE;
	}
	if(kLoadClusters){
		fRunLoader->LoadRecPoints("TRD", "READ");
		t = fRunLoader->GetTreeR("TRD", kFALSE);
		if(!t) return kFALSE;
		if(!LoadClusters(t)) return kFALSE;
	}
	if(kLoadTracks){
		fRunLoader->LoadTracks("TRD", "READ");
		t = fRunLoader->GetTreeT("TRD", kFALSE);
		if(!t) return kFALSE;
		if(!LoadTracklets(t)) return kFALSE;
	}
	gReve->Redraw3D();
	return kTRUE;
}


//________________________________________________________
Bool_t	TRDLoader::LoadClusters(TTree *tC)
{
	Info("LoadClusters()", Form("Clusters tree 0x%x", tC));
	if(!fChildren.size()) return kTRUE;

	TObjArray *clusters = new TObjArray();
	tC->SetBranchAddress("TRDcluster",&clusters);

	TRDChamber *chmb = 0x0;	
	AliTRDcluster *c=0x0;
	for(int idet=0; idet<540; idet++){
		if(!tC->GetEntry(idet)) continue;
		if(clusters->GetEntriesFast()) c = (AliTRDcluster*)clusters->UncheckedAt(0);
		if((chmb = GetChamber(c->GetDetector()))) chmb->LoadClusters(clusters);
	}
	return kTRUE;
}


//________________________________________________________
Bool_t	TRDLoader::LoadDigits(TTree *tD)
{
	Info("LoadDigits()", Form("Digits tree 0x%x", tD));
	
	if(!fChildren.size()) return kTRUE;
	
	TRDChamber *chmb;
	AliTRDdigitsManager dm;
	dm.ReadDigits(tD);
	for(int idet=0; idet<540; idet++){
		if(!(chmb=GetChamber(idet))) continue;
//		digits = dm.GetDigits(idet);
//		if(!digits) continue;
//		chmb->LoadDigits(digits);
		chmb->LoadDigits(&dm);
	}
	return kTRUE;
}


//________________________________________________________
Bool_t	TRDLoader::LoadHits(TTree *tH)
{
	Info("LoadHits()", Form("Hits tree 0x%x", tH));
	if(!fChildren.size()) return kTRUE;
	
	TRDChamber *chmb = 0x0;
	AliTRDhit *hit = 0x0;
	Int_t d;
	for(int iTrack=0; iTrack<tH->GetEntries(); iTrack++){
		gAlice->ResetHits();
		if(!tH->GetEvent(iTrack)) continue;
		hit = (AliTRDhit*)fTRD->FirstHit(-1);
		if(!hit) continue;
		d = hit->GetDetector();
		chmb = GetChamber(d);
		while(hit){
			if(d != hit->GetDetector()){
				d = hit->GetDetector();
				chmb = GetChamber(d);
			}
			if(chmb) chmb->AddHit(hit);
			hit = (AliTRDhit*)fTRD->NextHit();
		}
	}
	return kTRUE;
}

//________________________________________________________
Bool_t	TRDLoader::LoadTracklets(TTree *tT)
{
	Info("LoadTracklets()", Form("Tracks tree 0x%x", tT));
	if(!fChildren.size()) return kTRUE;

	TObjArray *tracks = new TObjArray();
	tT->SetBranchAddress("TRDmcmTracklet",&tracks);
	
	TRDChamber *chmb = 0x0;
	AliTRDmcmTracklet *trk=0x0;
	for(int idet=0; idet<540; idet++){
		if(!tT->GetEntry(idet)) continue;
		if(tracks->GetEntriesFast()) trk = (AliTRDmcmTracklet*)tracks->UncheckedAt(0);
		if((chmb = GetChamber(trk->GetDetector()))) chmb->LoadTracklets(tracks);
	}
	
	return kTRUE;
}
	
//________________________________________________________
Bool_t	TRDLoader::Open(const char *filename, const char *dir)
{
	fFilename = filename;
	fDir = dir;
	fDir += "/";
	
	fRunLoader = AliRunLoader::GetRunLoader();
	if(!fRunLoader) fRunLoader = AliRunLoader::Open(filename,
				AliConfig::GetDefaultEventFolderName(),"read");
	if(!fRunLoader){
		Error("Open()", "Couldn't find run loader");
		return kFALSE;
	}
	fRunLoader->SetDirName(fDir);
	
	gAlice = fRunLoader->GetAliRun();
  if(!gAlice) fRunLoader->LoadgAlice();
	if(!gAlice){
		Error("Open()", "Couldn't find gAlice object");
		return kFALSE;
	}
	fTRD = (AliTRDv1*)gAlice->GetDetector("TRD");
	if(!fTRD){
		Error("Open()", "Couldn't find TRD");
		return kFALSE;
	}
	
	return kTRUE;
}

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

///////////////////////////////////////////////////////////
/////////////   TRDLoaderEditor       /////////////////////
///////////////////////////////////////////////////////////

//________________________________________________________
TRDLoaderEditor::TRDLoaderEditor(const TGWindow* p, Int_t width, Int_t height, UInt_t options, Pixel_t back) : TGedFrame(p, width, height, options | kVerticalFrame, back)
{
	MakeTitle("TRDLoader");
	
  fFile = 0x0;
	TGTextButton *fOpenFile = 0x0;
	Int_t labelW = 42;
  {
    TGHorizontalFrame* f = new TGHorizontalFrame(this);
    TGHorizontalFrame* g = new TGHorizontalFrame(f, labelW, 0, kFixedWidth);
    TGLabel* l = new TGLabel(g, "File: ");
    g->AddFrame(l, new TGLayoutHints(kLHintsLeft, 0,0,4,0));
    f->AddFrame(g);
    fFile = new TGTextEntry(f);
    fFile->SetWidth(140);
    f->AddFrame(fFile);
/*    
		fFile->Connect("DoubleClicked()",
		   "Alieve::TPCLoaderEditor", this, "FileSelect()");
    fFile->Connect("TextChanged(const char *)",
		   "Alieve::TPCLoaderEditor", this, "FileChanged()");
*/    
		fOpenFile = new TGTextButton(f, "Open");
    f->AddFrame(fOpenFile);
    fOpenFile->Connect("Clicked()",
		       "Alieve::TRDLoaderEditor", this, "FileOpen()");
		AddFrame(f);
  }

  fEvent = new RGValuator(this, "Event:", 110, 0);
  fEvent->SetShowSlider(kFALSE);
  fEvent->SetLabelWidth(labelW);
  fEvent->SetNELength(6);
  fEvent->Build();
  fEvent->SetLimits(-1, 1000);
  fEvent->SetToolTip("Current event number");
/*  fEvent->Connect("ValueSet(Double_t)",
		  "Alieve::TPCLoaderEditor", this, "DoEvent()");
*/  
	AddFrame(fEvent);


	// "Chamber(s) selector" group frame
	TGGroupFrame *fGroupFrame1974 = new TGGroupFrame(this,"Chamber(s) selector");
	TGVerticalFrame *fVerticalFrame1974 = new TGVerticalFrame(fGroupFrame1974, 150, 50,kVerticalFrame);
  
	fSMNumber = new RGValuator(fVerticalFrame1974, "SM:", 0, 0);
  fSMNumber->SetShowSlider(kFALSE);
  fSMNumber->SetLabelWidth(labelW);
  fSMNumber->SetNELength(6);
  fSMNumber->Build();
  fSMNumber->SetLimits(-1, 17);
  fSMNumber->SetToolTip("Supermodule id [-1 for all]");
	fVerticalFrame1974->AddFrame(fSMNumber, new TGLayoutHints(kLHintsLeft | kLHintsTop | kLHintsCenterX | kLHintsExpandY,2,2,2,2));

	fStackNumber = new RGValuator(fVerticalFrame1974, "Stack:", 0, 0);
  fStackNumber->SetShowSlider(kFALSE);
  fStackNumber->SetLabelWidth(labelW);
  fStackNumber->SetNELength(6);
  fStackNumber->Build();
  fStackNumber->SetLimits(-1, 4);
  fStackNumber->SetToolTip("Stack id [-1 for all in this SM]");
	fVerticalFrame1974->AddFrame(fStackNumber, new TGLayoutHints(kLHintsLeft | kLHintsTop | kLHintsCenterX | kLHintsExpandY,2,2,2,2));

	fPlaneNumber = new RGValuator(fVerticalFrame1974, "Plane:", 0, 0);
  fPlaneNumber->SetShowSlider(kFALSE);
  fPlaneNumber->SetLabelWidth(labelW);
  fPlaneNumber->SetNELength(6);
  fPlaneNumber->Build();
  fPlaneNumber->SetLimits(-1, 5);
  fPlaneNumber->SetToolTip("Plane id [-1 for all in this stack]");

	fVerticalFrame1974->AddFrame(fPlaneNumber, new TGLayoutHints(kLHintsLeft | kLHintsTop | kLHintsCenterX | kLHintsExpandY,2,2,2,2));
	
	fGroupFrame1974->AddFrame(fVerticalFrame1974, new TGLayoutHints(kLHintsLeft | kLHintsTop | kLHintsExpandY | kLHintsCenterX,2,2,2,2));

	TGTextButton *fTextButton2037 = new TGTextButton(fGroupFrame1974,"Select");
	fTextButton2037->SetTextJustify(36);
//	fTextButton2037->Resize(128,22);
	fGroupFrame1974->AddFrame(fTextButton2037, new TGLayoutHints(kLHintsExpandY | kLHintsCenterX,2,2,2,2));
	fTextButton2037->Connect("Clicked()",
					"Alieve::TRDLoaderEditor", this, "AddChambers()");

	fGroupFrame1974->SetLayoutManager(new TGHorizontalLayout(fGroupFrame1974));
//	fGroupFrame1974->Resize(164,150);
	AddFrame(fGroupFrame1974, new TGLayoutHints(kLHintsLeft | kLHintsTop | kLHintsCenterY | kLHintsExpandX,2,2,2,2));

	
	// "Data selector" group frame
	TGGroupFrame *fGroupFrame1987 = new TGGroupFrame(this,"Data selector");
	fLoadHits = new TGCheckButton(fGroupFrame1987,"  Hits");
	fGroupFrame1987->AddFrame(fLoadHits, new TGLayoutHints(kLHintsLeft | kLHintsTop | kLHintsCenterY | kLHintsExpandX,2,2,2,2));
	fLoadDigits = new TGCheckButton(fGroupFrame1987,"  Digits");
	fGroupFrame1987->AddFrame(fLoadDigits, new TGLayoutHints(kLHintsLeft | kLHintsTop | kLHintsCenterY | kLHintsExpandX,2,2,2,2));
	fLoadClusters = new TGCheckButton(fGroupFrame1987,"  Clusters");
	fGroupFrame1987->AddFrame(fLoadClusters, new TGLayoutHints(kLHintsLeft | kLHintsTop | kLHintsCenterY | kLHintsExpandX,2,2,2,2));
	fLoadTracks = new TGCheckButton(fGroupFrame1987,"  Tracklets ");
	fGroupFrame1987->AddFrame(fLoadTracks, new TGLayoutHints(kLHintsLeft | kLHintsTop | kLHintsCenterY | kLHintsExpandX,2,2,2,2));

	fGroupFrame1987->SetLayoutManager(new TGVerticalLayout(fGroupFrame1987));
//	fGroupFrame1987->Resize(164,116);
	AddFrame(fGroupFrame1987, new TGLayoutHints(kLHintsLeft | kLHintsTop | kLHintsCenterY | kLHintsExpandX,2,2,2,2));

	TGTextButton *fTextButton2004 = new TGTextButton(this,"Load");
	fTextButton2004->SetTextJustify(36);
	fTextButton2004->Resize(164,22);
	AddFrame(fTextButton2004, new TGLayoutHints(kLHintsLeft | kLHintsTop | kLHintsCenterY | kLHintsExpandX,2,2,2,2));

	fTextButton2004->Connect("Clicked()",
					"Alieve::TRDLoaderEditor", this, "Load()");
}

//________________________________________________________
TRDLoaderEditor::~TRDLoaderEditor()
{}

//_________________________________________________________
void TRDLoaderEditor::SetModel(TObject* obj)
{
	fM = dynamic_cast<TRDLoader*>(obj);

	fFile->SetText(gSystem->BaseName(fM->fFilename.Data()));

	Bool_t kFile = kTRUE;
	if(fM->fFilename.CompareTo("") == 0) kFile = kFALSE;

	fEvent->SetEnabled(kFile);
	if(kFile) fEvent->GetEntry()->SetIntNumber(fM->fEvent);
	
	fSMNumber->SetEnabled(kFile);
	if(kFile) fSMNumber->GetEntry()->SetIntNumber(fM->fSM);
	fStackNumber->SetEnabled(kFile);
	if(kFile) fStackNumber->GetEntry()->SetIntNumber(fM->fStack);
	fPlaneNumber->SetEnabled(kFile);
	if(kFile) fPlaneNumber->GetEntry()->SetIntNumber(fM->fLy);
	
	fLoadHits->SetEnabled(kFile);
	if(kFile) fLoadHits->SetState(fM->kLoadHits ? kButtonDown : kButtonUp);
	fLoadDigits->SetEnabled(kFile);
	if(kFile) fLoadDigits->SetState(fM->kLoadDigits ? kButtonDown : kButtonUp);
	fLoadClusters->SetEnabled(kFile);
	if(kFile) fLoadClusters->SetState(fM->kLoadClusters ? kButtonDown : kButtonUp);
	fLoadTracks->SetEnabled(kFile);
	if(kFile) fLoadTracks->SetState(fM->kLoadTracks ? kButtonDown : kButtonUp);
}

//________________________________________________________
void TRDLoaderEditor::AddChambers()
{
	fM->fSM    = (int)fSMNumber->GetEntry()->GetNumber();
	fM->fStack = (int)fStackNumber->GetEntry()->GetNumber();
	fM->fLy    = (int)fPlaneNumber->GetEntry()->GetNumber();
	fM->AddChambers(fM->fSM, fM->fStack, fM->fLy);
}

//________________________________________________________
void TRDLoaderEditor::FileOpen()
{
  TGFileInfo fi;
  fi.fIniDir    = StrDup(gSystem->DirName (fM->fFilename.Data()));
  fi.fFilename  = StrDup(gSystem->BaseName(fM->fFilename.Data()));
//  fi.fFileTypes = tpcfiletypes;

  new TGFileDialog(fClient->GetRoot(), gReve, kFDOpen, &fi);
  if (!fi.fFilename) return;

  fFile->SetToolTipText(gSystem->DirName (fi.fFilename));
  fFile->SetText       (gSystem->BaseName(fi.fFilename));

	fM->Open(gSystem->BaseName(fi.fFilename), gSystem->DirName (fi.fFilename));
	SetModel(fM);
}

//________________________________________________________
void TRDLoaderEditor::Load()
{
	fM->kLoadHits     = kFALSE;
	fM->kLoadDigits   = kFALSE;
	fM->kLoadClusters = kFALSE;
	fM->kLoadTracks   = kFALSE;
	if(fLoadHits->IsDown()) fM->kLoadHits = kTRUE;
	if(fLoadDigits->IsDown()) fM->kLoadDigits = kTRUE;
	if(fLoadClusters->IsDown()) fM->kLoadClusters = kTRUE;
	if(fLoadTracks->IsDown()) fM->kLoadTracks = kTRUE;
	
	fM->GoToEvent((int)fEvent->GetEntry()->GetNumber());
}
Commit	Line	Data
a282bf09	1	#include "TRDLoader.h"
	2	#include "TRDModuleImp.h"
	3
	4	#include <Reve/RGTopFrame.h>
	5	#include <Reve/RGValuators.h>
	6
	7	#include <TSystem.h>
	8	#include <TGLabel.h>
	9	#include <TGButton.h>
	10	#include <TGTextEntry.h>
	11	#include <TGNumberEntry.h>
	12	#include <TGFileDialog.h>
	13	#include <TGListTree.h>
	14	#include <TGToolTip.h>
	15
	16	#include "AliRun.h"
	17	#include "AliRunLoader.h"
	18	#include "AliLoader.h"
	19	#include "AliCDBManager.h"
	20
	21	#include "AliTRDv1.h"
	22	#include "AliTRDhit.h"
	23	#include "AliTRDcluster.h"
	24	#include "AliTRDmcmTracklet.h"
	25	#include "AliTRDdigitsManager.h"
	26	#include "AliTRDgeometry.h"
	27
	28	#include <algorithm>
	29
	30	using namespace Reve;
	31	using namespace Alieve;
	32	using namespace std;
	33	class AliTRDdataArrayI;
	34
	35	ClassImp(Alieve::TRDLoader)
	36	ClassImp(Alieve::TRDLoaderEditor)
	37
	38	///////////////////////////////////////////////////////////
	39	///////////// TRDLoader /////////////////////
	40	///////////////////////////////////////////////////////////
	41
	42
	43	//________________________________________________________
2caed564	44	TRDLoader::TRDLoader(const Text_t* n, const Text_t* t) : Reve::RenderElement(), TNamed(n,t), fSM(-1), fStack(-1), fLy(-1), fEvent(0)
14217b5f	45	{
a282bf09	46	kLoadHits = kFALSE;
	47	kLoadDigits = kFALSE;
	48	kLoadClusters = kFALSE;
	49	kLoadTracks = kFALSE;
14217b5f	50	fFilename = "";
	51	fDir = ".";
	52
	53	fRunLoader = 0x0;
	54	fGeo = new AliTRDgeometry();
a282bf09	55
	56	AliCDBManager *fCDBManager=AliCDBManager::Instance();
	57	fCDBManager->SetDefaultStorage("local://$ALICE_ROOT");
	58	fCDBManager->SetRun(0);
	59	}
	60
	61	//________________________________________________________
	62	TRDLoader::~TRDLoader()
	63	{
	64	// if(fChambers) {fChambers->clear(); delete fChambers;}
	65	}
	66
	67	//________________________________________________________
	68	template<class T>
	69	class ID
	70	{
	71	public:
f5790a4c	72	ID( int value ) : id(value) {}
a282bf09	73	bool operator()(const T &t) const {
	74	return ((dynamic_cast<TRDModule*>(t))->GetID() == id);
	75	}
	76	private:
	77	const int id;
	78	};
f5790a4c	79	void TRDLoader::AddChambers(int sm, int stk, int ly)
a282bf09	80	{
	81	Int_t ism_start = (sm == -1) ? 0 : sm;
	82	Int_t ism_stop = (sm == -1) ? 18 : sm+1;
	83	Int_t istk_start= (stk == -1)? 0 : stk;
	84	Int_t istk_stop = (stk == -1)? 5 : stk+1;
	85	Int_t ily_start = (ly == -1) ? 0 : ly;
	86	Int_t ily_stop = (ly == -1) ? 6 : ly+1;
	87
e6ac3950	88	List_i ichmb;
a282bf09	89	ichmb = fChildren.begin();
a282bf09	90	while(ichmb != fChildren.end()){
2caed564	91	(*ichmb)->SetRnrSelf(kFALSE);
a282bf09	92	ichmb++;
	93	}
	94
	95	TRDNode SM=0x0, STK=0x0;
	96	TRDChamber *CHMB = 0x0;
	97	int det;
	98	for(int ism=ism_start; ism<ism_stop; ism++){
	99	ichmb = find_if(fChildren.begin(), fChildren.end(), ID<RenderElement*>(ism));
	100	if(ichmb != fChildren.end()){
	101	SM = (TRDNode)(ichmb);
2caed564	102	SM->SetRnrSelf(kTRUE);
a282bf09	103	}else{
	104	gReve->AddRenderElement(this, SM = new TRDNode("SM", ism));
	105	SM->FindListTreeItem(gReve->GetListTree())->SetTipText(Form("Supermodule %2d", ism));
	106	}
	107	for(int istk=istk_start; istk<istk_stop; istk++){
	108	ichmb = find_if(SM->begin(), SM->end(), ID<RenderElement*>(istk));
	109	if(ichmb != SM->end()){
	110	STK = (TRDNode)(ichmb);
2caed564	111	STK->SetRnrSelf(kTRUE);
a282bf09	112	}else{
	113	gReve->AddRenderElement(SM, STK = new TRDNode("Stack", istk));
	114	STK->FindListTreeItem(gReve->GetListTree())->SetTipText(Form("SM %2d Stack %1d", ism, istk));
	115	}
	116	for(int ily=ily_start; ily<ily_stop; ily++){
14217b5f	117	det = fGeo->GetDetector(ily, istk, ism);
a282bf09	118	ichmb = find_if(STK->begin(), STK->end(), ID<RenderElement*>(det));
2caed564	119	if(ichmb != STK->end()) (*ichmb)->SetRnrSelf(kTRUE);
a282bf09	120	else{
a282bf09	121	gReve->AddRenderElement(STK, CHMB = new TRDChamber(det));
14217b5f	122	CHMB->SetGeometry(fGeo);
a282bf09	123	CHMB->FindListTreeItem(gReve->GetListTree())->SetTipText(Form("SM %2d Stack %1d Layer %1d", ism, istk, ily));
	124	}
	125	}
	126	}
	127	}
	128	gReve->Redraw3D();
	129	}
	130
	131	//________________________________________________________
f5790a4c	132	TRDChamber* TRDLoader::GetChamber(int d)
a282bf09	133	{
e6ac3950	134	List_i ism, istack, ichmb;
a282bf09	135
14217b5f	136	ism = find_if(fChildren.begin(), fChildren.end(), ID<RenderElement*>(fGeo->GetSector(d)));
a282bf09	137	if(ism == fChildren.end()) return 0x0;
14217b5f	138	istack = find_if(((TRDNode)(ism))->begin(), ((TRDNode)(ism))->end(), ID<RenderElement*>(fGeo->GetChamber(d)));
a282bf09	139	if(istack == ((TRDNode)(ism))->end()) return 0x0;
	140	ichmb = find_if(((TRDNode)(istack))->begin(), ((TRDNode)(istack))->end(), ID<RenderElement*>(d));
	141	if(ichmb == ((TRDNode)(istack))->end()) return 0x0;
	142	return dynamic_cast<TRDChamber>(ichmb);
	143	}
	144
	145	//________________________________________________________
f5790a4c	146	Bool_t TRDLoader::GoToEvent(int ev)
a282bf09	147	{
a282bf09	148	Info("GoToEvent", Form("Event = %d", ev));
14217b5f	149	fEvent = ev;
14217b5f	150
a282bf09	151	if(!fRunLoader) return kFALSE;
	152	fRunLoader->UnloadAll("TRD");
	153	Unload();
	154
	155	fRunLoader->GetEvent(ev);
	156	TTree *t = 0x0;
	157	if(kLoadHits){
	158	fRunLoader->LoadHits("TRD", "READ");
	159	t = fRunLoader->GetTreeH("TRD", kFALSE);
	160	if(!t) return kFALSE;
	161	fTRD->SetTreeAddress();
	162	if(!LoadHits(t)) return kFALSE;
	163	}
	164	if(kLoadDigits){
	165	fRunLoader->LoadDigits("TRD", "READ");
	166	t = fRunLoader->GetTreeD("TRD", kFALSE);
	167	if(!t) return kFALSE;
	168	fTRD->SetTreeAddress();
	169	if(!LoadDigits(t)) return kFALSE;
	170	}
	171	if(kLoadClusters){
	172	fRunLoader->LoadRecPoints("TRD", "READ");
	173	t = fRunLoader->GetTreeR("TRD", kFALSE);
	174	if(!t) return kFALSE;
	175	if(!LoadClusters(t)) return kFALSE;
	176	}
	177	if(kLoadTracks){
	178	fRunLoader->LoadTracks("TRD", "READ");
	179	t = fRunLoader->GetTreeT("TRD", kFALSE);
	180	if(!t) return kFALSE;
	181	if(!LoadTracklets(t)) return kFALSE;
	182	}
	183	gReve->Redraw3D();
	184	return kTRUE;
	185	}
	186
	187
	188	//________________________________________________________
	189	Bool_t TRDLoader::LoadClusters(TTree *tC)
	190	{
	191	Info("LoadClusters()", Form("Clusters tree 0x%x", tC));
	192	if(!fChildren.size()) return kTRUE;
	193
	194	TObjArray *clusters = new TObjArray();
	195	tC->SetBranchAddress("TRDcluster",&clusters);
	196
	197	TRDChamber *chmb = 0x0;
	198	AliTRDcluster *c=0x0;
	199	for(int idet=0; idet<540; idet++){
	200	if(!tC->GetEntry(idet)) continue;
	201	if(clusters->GetEntriesFast()) c = (AliTRDcluster*)clusters->UncheckedAt(0);
	202	if((chmb = GetChamber(c->GetDetector()))) chmb->LoadClusters(clusters);
	203	}
	204	return kTRUE;
	205	}
	206
	207
	208	//________________________________________________________
	209	Bool_t TRDLoader::LoadDigits(TTree *tD)
	210	{
	211	Info("LoadDigits()", Form("Digits tree 0x%x", tD));
	212
	213	if(!fChildren.size()) return kTRUE;
	214
215	TRDChamber *chmb;
a282bf09	216	AliTRDdigitsManager dm;
	217	dm.ReadDigits(tD);
	218	for(int idet=0; idet<540; idet++){
	219	if(!(chmb=GetChamber(idet))) continue;
14217b5f	220	// digits = dm.GetDigits(idet);
	221	// if(!digits) continue;
	222	// chmb->LoadDigits(digits);
	223	chmb->LoadDigits(&dm);
a282bf09	224	}
	225	return kTRUE;
	226	}
	227
	228
	229	//________________________________________________________
	230	Bool_t TRDLoader::LoadHits(TTree *tH)
	231	{
	232	Info("LoadHits()", Form("Hits tree 0x%x", tH));
	233	if(!fChildren.size()) return kTRUE;
	234
	235	TRDChamber *chmb = 0x0;
14217b5f	236	AliTRDhit *hit = 0x0;
a282bf09	237	Int_t d;
	238	for(int iTrack=0; iTrack<tH->GetEntries(); iTrack++){
	239	gAlice->ResetHits();
	240	if(!tH->GetEvent(iTrack)) continue;
	241	hit = (AliTRDhit*)fTRD->FirstHit(-1);
	242	if(!hit) continue;
	243	d = hit->GetDetector();
	244	chmb = GetChamber(d);
	245	while(hit){
	246	if(d != hit->GetDetector()){
	247	d = hit->GetDetector();
	248	chmb = GetChamber(d);
	249	}
	250	if(chmb) chmb->AddHit(hit);
	251	hit = (AliTRDhit*)fTRD->NextHit();
	252	}
	253	}
	254	return kTRUE;
	255	}
	256
	257	//________________________________________________________
	258	Bool_t TRDLoader::LoadTracklets(TTree *tT)
	259	{
	260	Info("LoadTracklets()", Form("Tracks tree 0x%x", tT));
	261	if(!fChildren.size()) return kTRUE;
	262
	263	TObjArray *tracks = new TObjArray();
	264	tT->SetBranchAddress("TRDmcmTracklet",&tracks);
	265
	266	TRDChamber *chmb = 0x0;
	267	AliTRDmcmTracklet *trk=0x0;
	268	for(int idet=0; idet<540; idet++){
	269	if(!tT->GetEntry(idet)) continue;
	270	if(tracks->GetEntriesFast()) trk = (AliTRDmcmTracklet*)tracks->UncheckedAt(0);
	271	if((chmb = GetChamber(trk->GetDetector()))) chmb->LoadTracklets(tracks);
	272	}
	273
	274	return kTRUE;
	275	}
	276
	277	//________________________________________________________
14217b5f	278	Bool_t TRDLoader::Open(const char filename, const char dir)
a282bf09	279	{
14217b5f	280	fFilename = filename;
	281	fDir = dir;
	282	fDir += "/";
	283
	284	fRunLoader = AliRunLoader::GetRunLoader();
a282bf09	285	if(!fRunLoader) fRunLoader = AliRunLoader::Open(filename,
	286	AliConfig::GetDefaultEventFolderName(),"read");
	287	if(!fRunLoader){
	288	Error("Open()", "Couldn't find run loader");
	289	return kFALSE;
	290	}
14217b5f	291	fRunLoader->SetDirName(fDir);
14217b5f	292
a282bf09	293	gAlice = fRunLoader->GetAliRun();
	294	if(!gAlice) fRunLoader->LoadgAlice();
	295	if(!gAlice){
	296	Error("Open()", "Couldn't find gAlice object");
	297	return kFALSE;
	298	}
	299	fTRD = (AliTRDv1*)gAlice->GetDetector("TRD");
	300	if(!fTRD){
	301	Error("Open()", "Couldn't find TRD");
	302	return kFALSE;
	303	}
14217b5f	304
a282bf09	305	return kTRUE;
	306	}
	307
a282bf09	308	//________________________________________________________
	309	void TRDLoader::Unload()
	310	{
e6ac3950	311	List_i ichmb = fChildren.begin();
a282bf09	312	while(ichmb != fChildren.end()){
	313	(dynamic_cast<TRDModule>(ichmb))->Reset();
	314	ichmb++;
	315	}
	316	}
	317
	318	///////////////////////////////////////////////////////////
	319	///////////// TRDLoaderEditor /////////////////////
	320	///////////////////////////////////////////////////////////
	321
	322	//________________________________________________________
	323	TRDLoaderEditor::TRDLoaderEditor(const TGWindow* p, Int_t width, Int_t height, UInt_t options, Pixel_t back) : TGedFrame(p, width, height, options \| kVerticalFrame, back)
	324	{
	325	MakeTitle("TRDLoader");
	326
	327	fFile = 0x0;
14217b5f	328	TGTextButton *fOpenFile = 0x0;
a282bf09	329	Int_t labelW = 42;
	330	{
	331	TGHorizontalFrame* f = new TGHorizontalFrame(this);
	332	TGHorizontalFrame* g = new TGHorizontalFrame(f, labelW, 0, kFixedWidth);
	333	TGLabel* l = new TGLabel(g, "File: ");
	334	g->AddFrame(l, new TGLayoutHints(kLHintsLeft, 0,0,4,0));
	335	f->AddFrame(g);
	336	fFile = new TGTextEntry(f);
	337	fFile->SetWidth(140);
	338	f->AddFrame(fFile);
	339	/*
	340	fFile->Connect("DoubleClicked()",
	341	"Alieve::TPCLoaderEditor", this, "FileSelect()");
	342	fFile->Connect("TextChanged(const char *)",
	343	"Alieve::TPCLoaderEditor", this, "FileChanged()");
	344	*/
	345	fOpenFile = new TGTextButton(f, "Open");
	346	f->AddFrame(fOpenFile);
	347	fOpenFile->Connect("Clicked()",
	348	"Alieve::TRDLoaderEditor", this, "FileOpen()");
	349	AddFrame(f);
	350	}
	351
	352	fEvent = new RGValuator(this, "Event:", 110, 0);
	353	fEvent->SetShowSlider(kFALSE);
	354	fEvent->SetLabelWidth(labelW);
	355	fEvent->SetNELength(6);
	356	fEvent->Build();
	357	fEvent->SetLimits(-1, 1000);
	358	fEvent->SetToolTip("Current event number");
	359	/* fEvent->Connect("ValueSet(Double_t)",
	360	"Alieve::TPCLoaderEditor", this, "DoEvent()");
	361	*/
	362	AddFrame(fEvent);
	363
	364
	365	// "Chamber(s) selector" group frame
	366	TGGroupFrame *fGroupFrame1974 = new TGGroupFrame(this,"Chamber(s) selector");
14217b5f	367	TGVerticalFrame *fVerticalFrame1974 = new TGVerticalFrame(fGroupFrame1974, 150, 50,kVerticalFrame);
	368
	369	fSMNumber = new RGValuator(fVerticalFrame1974, "SM:", 0, 0);
	370	fSMNumber->SetShowSlider(kFALSE);
	371	fSMNumber->SetLabelWidth(labelW);
	372	fSMNumber->SetNELength(6);
	373	fSMNumber->Build();
	374	fSMNumber->SetLimits(-1, 17);
	375	fSMNumber->SetToolTip("Supermodule id [-1 for all]");
	376	fVerticalFrame1974->AddFrame(fSMNumber, new TGLayoutHints(kLHintsLeft \| kLHintsTop \| kLHintsCenterX \| kLHintsExpandY,2,2,2,2));
	377
	378	fStackNumber = new RGValuator(fVerticalFrame1974, "Stack:", 0, 0);
	379	fStackNumber->SetShowSlider(kFALSE);
	380	fStackNumber->SetLabelWidth(labelW);
	381	fStackNumber->SetNELength(6);
	382	fStackNumber->Build();
	383	fStackNumber->SetLimits(-1, 4);
	384	fStackNumber->SetToolTip("Stack id [-1 for all in this SM]");
	385	fVerticalFrame1974->AddFrame(fStackNumber, new TGLayoutHints(kLHintsLeft \| kLHintsTop \| kLHintsCenterX \| kLHintsExpandY,2,2,2,2));
	386
	387	fPlaneNumber = new RGValuator(fVerticalFrame1974, "Plane:", 0, 0);
	388	fPlaneNumber->SetShowSlider(kFALSE);
	389	fPlaneNumber->SetLabelWidth(labelW);
	390	fPlaneNumber->SetNELength(6);
	391	fPlaneNumber->Build();
	392	fPlaneNumber->SetLimits(-1, 5);
	393	fPlaneNumber->SetToolTip("Plane id [-1 for all in this stack]");
	394
	395	fVerticalFrame1974->AddFrame(fPlaneNumber, new TGLayoutHints(kLHintsLeft \| kLHintsTop \| kLHintsCenterX \| kLHintsExpandY,2,2,2,2));
a282bf09	396
14217b5f	397	fGroupFrame1974->AddFrame(fVerticalFrame1974, new TGLayoutHints(kLHintsLeft \| kLHintsTop \| kLHintsExpandY \| kLHintsCenterX,2,2,2,2));
a282bf09	398
	399	TGTextButton *fTextButton2037 = new TGTextButton(fGroupFrame1974,"Select");
	400	fTextButton2037->SetTextJustify(36);
14217b5f	401	// fTextButton2037->Resize(128,22);
14217b5f	402	fGroupFrame1974->AddFrame(fTextButton2037, new TGLayoutHints(kLHintsExpandY \| kLHintsCenterX,2,2,2,2));
a282bf09	403	fTextButton2037->Connect("Clicked()",
	404	"Alieve::TRDLoaderEditor", this, "AddChambers()");
	405
	406	fGroupFrame1974->SetLayoutManager(new TGHorizontalLayout(fGroupFrame1974));
	407	// fGroupFrame1974->Resize(164,150);
	408	AddFrame(fGroupFrame1974, new TGLayoutHints(kLHintsLeft \| kLHintsTop \| kLHintsCenterY \| kLHintsExpandX,2,2,2,2));
	409
	410
	411	// "Data selector" group frame
	412	TGGroupFrame *fGroupFrame1987 = new TGGroupFrame(this,"Data selector");
	413	fLoadHits = new TGCheckButton(fGroupFrame1987," Hits");
	414	fGroupFrame1987->AddFrame(fLoadHits, new TGLayoutHints(kLHintsLeft \| kLHintsTop \| kLHintsCenterY \| kLHintsExpandX,2,2,2,2));
	415	fLoadDigits = new TGCheckButton(fGroupFrame1987," Digits");
	416	fGroupFrame1987->AddFrame(fLoadDigits, new TGLayoutHints(kLHintsLeft \| kLHintsTop \| kLHintsCenterY \| kLHintsExpandX,2,2,2,2));
	417	fLoadClusters = new TGCheckButton(fGroupFrame1987," Clusters");
	418	fGroupFrame1987->AddFrame(fLoadClusters, new TGLayoutHints(kLHintsLeft \| kLHintsTop \| kLHintsCenterY \| kLHintsExpandX,2,2,2,2));
14217b5f	419	fLoadTracks = new TGCheckButton(fGroupFrame1987," Tracklets ");
14217b5f	420	fGroupFrame1987->AddFrame(fLoadTracks, new TGLayoutHints(kLHintsLeft \| kLHintsTop \| kLHintsCenterY \| kLHintsExpandX,2,2,2,2));
a282bf09	421
	422	fGroupFrame1987->SetLayoutManager(new TGVerticalLayout(fGroupFrame1987));
	423	// fGroupFrame1987->Resize(164,116);
	424	AddFrame(fGroupFrame1987, new TGLayoutHints(kLHintsLeft \| kLHintsTop \| kLHintsCenterY \| kLHintsExpandX,2,2,2,2));
	425
	426	TGTextButton *fTextButton2004 = new TGTextButton(this,"Load");
	427	fTextButton2004->SetTextJustify(36);
	428	fTextButton2004->Resize(164,22);
	429	AddFrame(fTextButton2004, new TGLayoutHints(kLHintsLeft \| kLHintsTop \| kLHintsCenterY \| kLHintsExpandX,2,2,2,2));
	430
	431	fTextButton2004->Connect("Clicked()",
	432	"Alieve::TRDLoaderEditor", this, "Load()");
	433	}
	434
	435	//________________________________________________________
	436	TRDLoaderEditor::~TRDLoaderEditor()
	437	{}
	438
	439	//_________________________________________________________
	440	void TRDLoaderEditor::SetModel(TObject* obj)
	441	{
	442	fM = dynamic_cast<TRDLoader*>(obj);
14217b5f	443
	444	fFile->SetText(gSystem->BaseName(fM->fFilename.Data()));
	445
	446	Bool_t kFile = kTRUE;
	447	if(fM->fFilename.CompareTo("") == 0) kFile = kFALSE;
	448
	449	fEvent->SetEnabled(kFile);
	450	if(kFile) fEvent->GetEntry()->SetIntNumber(fM->fEvent);
	451
	452	fSMNumber->SetEnabled(kFile);
	453	if(kFile) fSMNumber->GetEntry()->SetIntNumber(fM->fSM);
	454	fStackNumber->SetEnabled(kFile);
	455	if(kFile) fStackNumber->GetEntry()->SetIntNumber(fM->fStack);
	456	fPlaneNumber->SetEnabled(kFile);
	457	if(kFile) fPlaneNumber->GetEntry()->SetIntNumber(fM->fLy);
	458
	459	fLoadHits->SetEnabled(kFile);
	460	if(kFile) fLoadHits->SetState(fM->kLoadHits ? kButtonDown : kButtonUp);
	461	fLoadDigits->SetEnabled(kFile);
	462	if(kFile) fLoadDigits->SetState(fM->kLoadDigits ? kButtonDown : kButtonUp);
	463	fLoadClusters->SetEnabled(kFile);
	464	if(kFile) fLoadClusters->SetState(fM->kLoadClusters ? kButtonDown : kButtonUp);
	465	fLoadTracks->SetEnabled(kFile);
	466	if(kFile) fLoadTracks->SetState(fM->kLoadTracks ? kButtonDown : kButtonUp);
a282bf09	467	}
	468
	469	//________________________________________________________
	470	void TRDLoaderEditor::AddChambers()
	471	{
14217b5f	472	fM->fSM = (int)fSMNumber->GetEntry()->GetNumber();
	473	fM->fStack = (int)fStackNumber->GetEntry()->GetNumber();
	474	fM->fLy = (int)fPlaneNumber->GetEntry()->GetNumber();
	475	fM->AddChambers(fM->fSM, fM->fStack, fM->fLy);
a282bf09	476	}
	477
	478	//________________________________________________________
	479	void TRDLoaderEditor::FileOpen()
	480	{
	481	TGFileInfo fi;
14217b5f	482	fi.fIniDir = StrDup(gSystem->DirName (fM->fFilename.Data()));
	483	fi.fFilename = StrDup(gSystem->BaseName(fM->fFilename.Data()));
	484	// fi.fFileTypes = tpcfiletypes;
	485
a282bf09	486	new TGFileDialog(fClient->GetRoot(), gReve, kFDOpen, &fi);
	487	if (!fi.fFilename) return;
	488
	489	fFile->SetToolTipText(gSystem->DirName (fi.fFilename));
	490	fFile->SetText (gSystem->BaseName(fi.fFilename));
	491
14217b5f	492	fM->Open(gSystem->BaseName(fi.fFilename), gSystem->DirName (fi.fFilename));
14217b5f	493	SetModel(fM);
a282bf09	494	}
	495
	496	//________________________________________________________
	497	void TRDLoaderEditor::Load()
	498	{
	499	fM->kLoadHits = kFALSE;
	500	fM->kLoadDigits = kFALSE;
	501	fM->kLoadClusters = kFALSE;
	502	fM->kLoadTracks = kFALSE;
	503	if(fLoadHits->IsDown()) fM->kLoadHits = kTRUE;
	504	if(fLoadDigits->IsDown()) fM->kLoadDigits = kTRUE;
	505	if(fLoadClusters->IsDown()) fM->kLoadClusters = kTRUE;
14217b5f	506	if(fLoadTracks->IsDown()) fM->kLoadTracks = kTRUE;
a282bf09	507
	508	fM->GoToEvent((int)fEvent->GetEntry()->GetNumber());
	509	}
	510