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

#include "TRDLoaderImp.h"
#include "TRDModuleImp.h"

//#include "AliTRDv1.h"

#include <TEveManager.h>

#include "TFile.h"
#include "TTree.h"

#include <TGButton.h>

#include "AliLog.h"
#include "AliRun.h"
#include "AliRunLoader.h"
#include "AliLoader.h"
#include "AliTRDrawData.h"
#include "AliRawReaderRoot.h"
#include "AliRawReaderDate.h"

#include "AliTRDv1.h"
#include "AliTRDhit.h"
#include "AliTRDdigitsManager.h"
using namespace Alieve;
using namespace std;

ClassImp(Alieve::TRDLoaderSim)
ClassImp(Alieve::TRDLoaderRaw)
ClassImp(Alieve::TRDLoaderSimEditor)
//ClassImp(Alieve::TRDLoaderRawEditor)

///////////////////////////////////////////////////////////
/////////////     TRDLoaderSim        /////////////////////
///////////////////////////////////////////////////////////


//________________________________________________________
TRDLoaderSim::TRDLoaderSim(const Text_t* n, const Text_t* t) : TRDLoader(n, t)
{
	fRunLoader     = 0x0;
}

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

//________________________________________________________
Bool_t	TRDLoaderSim::GoToEvent(int ev)
{
	if(!fChildren.size()){
		AliWarning("Please select first the chamber that you want to monitor from \"Chamber(s) selector\".");
		return kFALSE;
	}
	if(!kLoadHits && !kLoadDigits && !kLoadClusters && !kLoadTracks){
		AliWarning("Please select first the type of data that you want to monitor and then hit the \"Load\" button.");
		return kFALSE;
	}
	
	fEvent = ev;

	if(!fRunLoader){
		AliError("RunLoader not initialized.");
		return kFALSE;
	}
	fRunLoader->UnloadAll("TRD");
	Unload();
	
	if(fRunLoader->GetEvent(ev)) return kFALSE;
	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;
	}

	gEve->Redraw3D();
	return kTRUE;
}


//________________________________________________________
Bool_t	TRDLoaderSim::LoadHits(TTree *tH)
{
	Info("LoadHits()", "Loading ...");
	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	TRDLoaderSim::Open(const char *filename, const char *dir)
{
	//Info("Open()", "");

	
	fFilename = filename;
	fDir = dir;
	fDir += "/";
	
	fRunLoader = AliRunLoader::GetRunLoader();
	if(!fRunLoader) fRunLoader = AliRunLoader::Open(filename,
				AliConfig::GetDefaultEventFolderName(),"read");
	if(!fRunLoader){
		AliError("Couldn't find run loader");
		return kFALSE;
	}
	fRunLoader->SetDirName(fDir);
	
	gAlice = fRunLoader->GetAliRun();
  if(!gAlice) fRunLoader->LoadgAlice();
	if(!gAlice){
		AliError("Couldn't find gAlice object");
		return kFALSE;
	}
	fTRD = (AliTRDv1*)gAlice->GetDetector("TRD");
	if(!fTRD){
		AliError("Couldn't find TRD");
		return kFALSE;
	}
	
	return kTRUE;
}

	
///////////////////////////////////////////////////////////
/////////////     TRDLoaderRaw        /////////////////////
///////////////////////////////////////////////////////////


//________________________________________________________
TRDLoaderRaw::TRDLoaderRaw(const Text_t* n, const Text_t* t) : TRDLoader(n, t)
{
	fRawDateReader = 0x0;
	fRawRootReader = 0x0;
	fRaw           = 0x0;
	fDataRoot      = kTRUE;
	fEventOld      = -1;
}

//________________________________________________________
TRDLoaderRaw::~TRDLoaderRaw()
{

}


//________________________________________________________
Bool_t  TRDLoaderRaw::Open(const char *filename, const char *dir)
{
//	Info("Open()", Form("Open %s/%s", dir, filename));
	fFilename = filename;
	fDir = dir;
	fDir += "/";


	if(fRaw) delete fRaw;
	fRaw = new AliTRDrawData();
	
	if(fDataRoot){
		if(fRawRootReader) delete fRawRootReader;
		fRawRootReader = new AliRawReaderRoot(filename);
	} else {
		if(fRawDateReader) delete fRawDateReader;
		fRawDateReader = new AliRawReaderDate(fDir+fFilename);
	}

	return kTRUE;
}

//________________________________________________________
void	TRDLoaderRaw::SetDataType(TRDDataTypes type)
{
	fDataRoot = (type == kRawRoot) ? kTRUE : kFALSE;
}

//________________________________________________________
Bool_t	TRDLoaderRaw::GoToEvent(int ev)
{
	if(!fChildren.size()){
		AliWarning("Please select first the chamber that you want to monitor from \"Chamber(s) selector\".");
		return kFALSE;
	}

	static const TEveException eH("TRDLoader::GotoEvent ");
	if(fRawRootReader == 0x0) throw(eH + "data file not opened.");


	if(ev == fEventOld) return kTRUE;
	Bool_t checkEnd;
	if(ev < fEventOld) {
		fRawRootReader->RewindEvents();
		fEventOld = -1;
		checkEnd = kFALSE;
	} else checkEnd = kTRUE;
	
	do NextEvent(); while(fEventOld != ev && !(checkEnd == kTRUE && fEventOld == 0));
	LoadEvent();
	gEve->Redraw3D();
	//gEve->EnableRedraw();
	return kTRUE;
}

//________________________________________________________
Bool_t TRDLoaderRaw::LoadEvent()
{
	Info("LoadEvent()", "Loading ...");
	
	static const TEveException eH("TRDLoader::LoadEvent ");
	if(fRawRootReader == 0x0) throw(eH + "data file not opened.");


	fRawRootReader->Reset();

	TRDChamber *chmb;
	AliTRDdigitsManager *dm;
	dm = fRaw->Raw2Digits(fRawRootReader);

	for(int idet=0; idet<540; idet++){
		if(!(chmb=GetChamber(idet))) continue;
		chmb->LoadDigits(dm);
	}
	return kTRUE;
}

//________________________________________________________
void TRDLoaderRaw::NextEvent(Bool_t rewindOnEnd)
{
	static const TEveException eH("TRDLoader::NextEvent ");
	if(fRawRootReader == 0x0) throw(eH + "data file not opened.");


	if(fRawRootReader->NextEvent() == kTRUE) ++fEventOld;
	else {
		if(fEventOld == -1) throw(eH + "no events available.");
		if(rewindOnEnd) {
			Warning("NextEvent()", Form("Reached end of stream (event=%d), rewinding to first event.", fEventOld));
			fRawRootReader->RewindEvents();
			fRawRootReader->NextEvent();
			fEventOld = 0;
		} else throw(eH + "last event reached.");
	}
}


///////////////////////////////////////////////////////////
/////////////   TRDLoaderSimEditor    /////////////////////
///////////////////////////////////////////////////////////

//________________________________________________________
TRDLoaderSimEditor::TRDLoaderSimEditor(const TGWindow* p, Int_t width, Int_t height, UInt_t options, Pixel_t back) : TGedFrame(p, width, height, options | kVerticalFrame, back)
{
	MakeTitle("TRDLoaderSim");
	
	// "Data selector" group frame
	TGGroupFrame *fGroupFrame = new TGGroupFrame(this,"Data selector");
	fLoadHits = new TGCheckButton(fGroupFrame,"  Hits");
	fLoadHits->Connect("Clicked()", "Alieve::TRDLoaderSimEditor", this, "Toggle(=0)");
	fGroupFrame->AddFrame(fLoadHits, new TGLayoutHints(kLHintsLeft | kLHintsTop | kLHintsCenterY | kLHintsExpandX,2,2,2,2));
	
	fLoadDigits = new TGCheckButton(fGroupFrame,"  Digits");
	fLoadDigits->Connect("Clicked()", "Alieve::TRDLoaderSimEditor", this, "Toggle(=1)");
	fGroupFrame->AddFrame(fLoadDigits, new TGLayoutHints(kLHintsLeft | kLHintsTop | kLHintsCenterY | kLHintsExpandX,2,2,2,2));

	fLoadClusters = new TGCheckButton(fGroupFrame,"  Clusters");
	fLoadClusters->Connect("Clicked()", "Alieve::TRDLoaderSimEditor", this, "Toggle(=2)");
	fGroupFrame->AddFrame(fLoadClusters, new TGLayoutHints(kLHintsLeft | kLHintsTop | kLHintsCenterY | kLHintsExpandX,2,2,2,2));

	fLoadTracks = new TGCheckButton(fGroupFrame,"  Tracklets ");
	fLoadTracks->Connect("Clicked()", "Alieve::TRDLoaderSimEditor", this, "Toggle(=3)");
	fGroupFrame->AddFrame(fLoadTracks, new TGLayoutHints(kLHintsLeft | kLHintsTop | kLHintsCenterY | kLHintsExpandX,2,2,2,2));

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

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

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

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

/*	printf("\thits      %s\n", fM->kLoadHits ? "true" : "false");
	printf("\tdigits    %s\n", fM->kLoadDigits ? "true" : "false");
	printf("\tclusters  %s\n", fM->kLoadClusters ? "true" : "false");
	printf("\ttracklets %s\n", fM->kLoadTracks ? "true" : "false");*/
	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 TRDLoaderSimEditor::Toggle(Int_t id)
{
	switch(id){
	case 0:
		fM->kLoadHits = fLoadHits->IsDown() ? kTRUE : kFALSE;
		break;
	case 1:
		fM->kLoadDigits = fLoadDigits->IsDown() ? kTRUE : kFALSE;
		break;
	case 2:
		fM->kLoadClusters = fLoadClusters->IsDown() ? kTRUE : kFALSE;
		break;
	case 3:
		fM->kLoadTracks = fLoadTracks->IsDown() ? kTRUE : kFALSE;
		break;
	}
}

///////////////////////////////////////////////////////////
/////////////   TRDLoaderRawEditor    /////////////////////
///////////////////////////////////////////////////////////

// //________________________________________________________
// TRDLoaderRawEditor::TRDLoaderRawEditor(const TGWindow* p, Int_t width, Int_t height, UInt_t options, Pixel_t back) : TGedFrame(p, width, height, options | kVerticalFrame, back)
// {
// 	MakeTitle("TRDLoaderRaw");
// }
// 	
// void	TRDLoaderRawEditor::SetModel(TObject* obj)
// {
// 	Info("SetModel()", "");
// 	fM = dynamic_cast<TRDLoaderRaw*>(obj);
// }
Commit	Line	Data
edf0c4a0	1	#include "TRDLoaderImp.h"
	2	#include "TRDModuleImp.h"
	3
	4	//#include "AliTRDv1.h"
	5
84aff7a4	6	#include <TEveManager.h>
edf0c4a0	7
	8	#include "TFile.h"
	9	#include "TTree.h"
	10
	11	#include <TGButton.h>
	12
	13	#include "AliLog.h"
	14	#include "AliRun.h"
	15	#include "AliRunLoader.h"
	16	#include "AliLoader.h"
	17	#include "AliTRDrawData.h"
	18	#include "AliRawReaderRoot.h"
	19	#include "AliRawReaderDate.h"
	20
	21	#include "AliTRDv1.h"
	22	#include "AliTRDhit.h"
	23	#include "AliTRDdigitsManager.h"
edf0c4a0	24	using namespace Alieve;
	25	using namespace std;
	26
	27	ClassImp(Alieve::TRDLoaderSim)
	28	ClassImp(Alieve::TRDLoaderRaw)
	29	ClassImp(Alieve::TRDLoaderSimEditor)
	30	//ClassImp(Alieve::TRDLoaderRawEditor)
	31
	32	///////////////////////////////////////////////////////////
	33	///////////// TRDLoaderSim /////////////////////
	34	///////////////////////////////////////////////////////////
	35
	36
	37	//________________________________________________________
	38	TRDLoaderSim::TRDLoaderSim(const Text_t* n, const Text_t* t) : TRDLoader(n, t)
	39	{
	40	fRunLoader = 0x0;
	41	}
	42
	43	//________________________________________________________
	44	TRDLoaderSim::~TRDLoaderSim()
	45	{}
	46
	47	//________________________________________________________
	48	Bool_t TRDLoaderSim::GoToEvent(int ev)
	49	{
	50	if(!fChildren.size()){
	51	AliWarning("Please select first the chamber that you want to monitor from \"Chamber(s) selector\".");
	52	return kFALSE;
	53	}
	54	if(!kLoadHits && !kLoadDigits && !kLoadClusters && !kLoadTracks){
	55	AliWarning("Please select first the type of data that you want to monitor and then hit the \"Load\" button.");
	56	return kFALSE;
	57	}
	58
	59	fEvent = ev;
	60
	61	if(!fRunLoader){
	62	AliError("RunLoader not initialized.");
	63	return kFALSE;
	64	}
	65	fRunLoader->UnloadAll("TRD");
	66	Unload();
	67
	68	if(fRunLoader->GetEvent(ev)) return kFALSE;
	69	TTree *t = 0x0;
	70	if(kLoadHits){
	71	fRunLoader->LoadHits("TRD", "READ");
	72	t = fRunLoader->GetTreeH("TRD", kFALSE);
	73	if(!t) return kFALSE;
	74	fTRD->SetTreeAddress();
	75	if(!LoadHits(t)) return kFALSE;
	76	}
	77	if(kLoadDigits){
	78	fRunLoader->LoadDigits("TRD", "READ");
	79	t = fRunLoader->GetTreeD("TRD", kFALSE);
	80	if(!t) return kFALSE;
	81	fTRD->SetTreeAddress();
	82	if(!LoadDigits(t)) return kFALSE;
	83	}
	84	if(kLoadClusters){
	85	fRunLoader->LoadRecPoints("TRD", "READ");
	86	t = fRunLoader->GetTreeR("TRD", kFALSE);
	87	if(!t) return kFALSE;
88	if(!LoadClusters(t)) return kFALSE;
89	}
90	if(kLoadTracks){
91	fRunLoader->LoadTracks("TRD", "READ");
92	t = fRunLoader->GetTreeT("TRD", kFALSE);
93	if(!t) return kFALSE;
94	if(!LoadTracklets(t)) return kFALSE;
95	}
96
84aff7a4	97	gEve->Redraw3D();
edf0c4a0	98	return kTRUE;
	99	}
	100
	101
	102	//________________________________________________________
	103	Bool_t TRDLoaderSim::LoadHits(TTree *tH)
	104	{
	105	Info("LoadHits()", "Loading ...");
	106	if(!fChildren.size()) return kTRUE;
	107
	108	TRDChamber *chmb = 0x0;
	109	AliTRDhit *hit = 0x0;
	110	Int_t d;
	111	for(int iTrack=0; iTrack<tH->GetEntries(); iTrack++){
	112	gAlice->ResetHits();
	113	if(!tH->GetEvent(iTrack)) continue;
	114	hit = (AliTRDhit*)fTRD->FirstHit(-1);
	115	if(!hit) continue;
	116	d = hit->GetDetector();
	117	chmb = GetChamber(d);
	118	while(hit){
	119	if(d != hit->GetDetector()){
	120	d = hit->GetDetector();
	121	chmb = GetChamber(d);
	122	}
	123	if(chmb) chmb->AddHit(hit);
	124	hit = (AliTRDhit*)fTRD->NextHit();
	125	}
	126	}
	127	return kTRUE;
	128	}
	129
	130	//________________________________________________________
	131	Bool_t TRDLoaderSim::Open(const char filename, const char dir)
	132	{
	133	//Info("Open()", "");
	134
	135
	136	fFilename = filename;
	137	fDir = dir;
	138	fDir += "/";
	139
	140	fRunLoader = AliRunLoader::GetRunLoader();
	141	if(!fRunLoader) fRunLoader = AliRunLoader::Open(filename,
	142	AliConfig::GetDefaultEventFolderName(),"read");
	143	if(!fRunLoader){
	144	AliError("Couldn't find run loader");
	145	return kFALSE;
	146	}
	147	fRunLoader->SetDirName(fDir);
	148
	149	gAlice = fRunLoader->GetAliRun();
	150	if(!gAlice) fRunLoader->LoadgAlice();
	151	if(!gAlice){
	152	AliError("Couldn't find gAlice object");
	153	return kFALSE;
	154	}
	155	fTRD = (AliTRDv1*)gAlice->GetDetector("TRD");
	156	if(!fTRD){
	157	AliError("Couldn't find TRD");
	158	return kFALSE;
	159	}
	160
	161	return kTRUE;
162	}
163
164
165
166	///////////////////////////////////////////////////////////
167	///////////// TRDLoaderRaw /////////////////////
168	///////////////////////////////////////////////////////////
169
170
171	//________________________________________________________
172	TRDLoaderRaw::TRDLoaderRaw(const Text_t* n, const Text_t* t) : TRDLoader(n, t)
173	{
174	fRawDateReader = 0x0;
175	fRawRootReader = 0x0;
176	fRaw = 0x0;
177	fDataRoot = kTRUE;
178	fEventOld = -1;
179	}
180
181	//________________________________________________________
182	TRDLoaderRaw::~TRDLoaderRaw()
183	{
184
185	}
186
187
188	//________________________________________________________
189	Bool_t TRDLoaderRaw::Open(const char filename, const char dir)
190	{
191	// Info("Open()", Form("Open %s/%s", dir, filename));
192	fFilename = filename;
193	fDir = dir;
194	fDir += "/";
195
196
197	if(fRaw) delete fRaw;
198	fRaw = new AliTRDrawData();
199
200	if(fDataRoot){
201	if(fRawRootReader) delete fRawRootReader;
202	fRawRootReader = new AliRawReaderRoot(filename);
203	} else {
204	if(fRawDateReader) delete fRawDateReader;
205	fRawDateReader = new AliRawReaderDate(fDir+fFilename);
206	}
207
208	return kTRUE;
209	}
210
211	//________________________________________________________
212	void TRDLoaderRaw::SetDataType(TRDDataTypes type)
213	{
214	fDataRoot = (type == kRawRoot) ? kTRUE : kFALSE;
215	}
216
217	//________________________________________________________
218	Bool_t TRDLoaderRaw::GoToEvent(int ev)
219	{
220	if(!fChildren.size()){
221	AliWarning("Please select first the chamber that you want to monitor from \"Chamber(s) selector\".");
222	return kFALSE;
223	}
224
84aff7a4	225	static const TEveException eH("TRDLoader::GotoEvent ");
edf0c4a0	226	if(fRawRootReader == 0x0) throw(eH + "data file not opened.");
	227
	228
	229	if(ev == fEventOld) return kTRUE;
	230	Bool_t checkEnd;
	231	if(ev < fEventOld) {
	232	fRawRootReader->RewindEvents();
	233	fEventOld = -1;
	234	checkEnd = kFALSE;
	235	} else checkEnd = kTRUE;
	236
	237	do NextEvent(); while(fEventOld != ev && !(checkEnd == kTRUE && fEventOld == 0));
	238	LoadEvent();
84aff7a4	239	gEve->Redraw3D();
84aff7a4	240	//gEve->EnableRedraw();
edf0c4a0	241	return kTRUE;
	242	}
	243
	244	//________________________________________________________
	245	Bool_t TRDLoaderRaw::LoadEvent()
	246	{
	247	Info("LoadEvent()", "Loading ...");
	248
84aff7a4	249	static const TEveException eH("TRDLoader::LoadEvent ");
edf0c4a0	250	if(fRawRootReader == 0x0) throw(eH + "data file not opened.");
	251
	252
	253	fRawRootReader->Reset();
	254
	255	TRDChamber *chmb;
	256	AliTRDdigitsManager *dm;
	257	dm = fRaw->Raw2Digits(fRawRootReader);
	258
	259	for(int idet=0; idet<540; idet++){
	260	if(!(chmb=GetChamber(idet))) continue;
	261	chmb->LoadDigits(dm);
	262	}
	263	return kTRUE;
	264	}
	265
	266	//________________________________________________________
	267	void TRDLoaderRaw::NextEvent(Bool_t rewindOnEnd)
	268	{
84aff7a4	269	static const TEveException eH("TRDLoader::NextEvent ");
edf0c4a0	270	if(fRawRootReader == 0x0) throw(eH + "data file not opened.");
	271
	272
	273	if(fRawRootReader->NextEvent() == kTRUE) ++fEventOld;
	274	else {
	275	if(fEventOld == -1) throw(eH + "no events available.");
	276	if(rewindOnEnd) {
	277	Warning("NextEvent()", Form("Reached end of stream (event=%d), rewinding to first event.", fEventOld));
	278	fRawRootReader->RewindEvents();
	279	fRawRootReader->NextEvent();
	280	fEventOld = 0;
	281	} else throw(eH + "last event reached.");
	282	}
	283	}
	284
	285
	286
	287	///////////////////////////////////////////////////////////
	288	///////////// TRDLoaderSimEditor /////////////////////
	289	///////////////////////////////////////////////////////////
	290
	291	//________________________________________________________
	292	TRDLoaderSimEditor::TRDLoaderSimEditor(const TGWindow* p, Int_t width, Int_t height, UInt_t options, Pixel_t back) : TGedFrame(p, width, height, options \| kVerticalFrame, back)
	293	{
	294	MakeTitle("TRDLoaderSim");
	295
	296	// "Data selector" group frame
	297	TGGroupFrame *fGroupFrame = new TGGroupFrame(this,"Data selector");
	298	fLoadHits = new TGCheckButton(fGroupFrame," Hits");
	299	fLoadHits->Connect("Clicked()", "Alieve::TRDLoaderSimEditor", this, "Toggle(=0)");
	300	fGroupFrame->AddFrame(fLoadHits, new TGLayoutHints(kLHintsLeft \| kLHintsTop \| kLHintsCenterY \| kLHintsExpandX,2,2,2,2));
	301
	302	fLoadDigits = new TGCheckButton(fGroupFrame," Digits");
	303	fLoadDigits->Connect("Clicked()", "Alieve::TRDLoaderSimEditor", this, "Toggle(=1)");
	304	fGroupFrame->AddFrame(fLoadDigits, new TGLayoutHints(kLHintsLeft \| kLHintsTop \| kLHintsCenterY \| kLHintsExpandX,2,2,2,2));
	305
	306	fLoadClusters = new TGCheckButton(fGroupFrame," Clusters");
	307	fLoadClusters->Connect("Clicked()", "Alieve::TRDLoaderSimEditor", this, "Toggle(=2)");
	308	fGroupFrame->AddFrame(fLoadClusters, new TGLayoutHints(kLHintsLeft \| kLHintsTop \| kLHintsCenterY \| kLHintsExpandX,2,2,2,2));
	309
	310	fLoadTracks = new TGCheckButton(fGroupFrame," Tracklets ");
	311	fLoadTracks->Connect("Clicked()", "Alieve::TRDLoaderSimEditor", this, "Toggle(=3)");
	312	fGroupFrame->AddFrame(fLoadTracks, new TGLayoutHints(kLHintsLeft \| kLHintsTop \| kLHintsCenterY \| kLHintsExpandX,2,2,2,2));
	313
	314	fGroupFrame->SetLayoutManager(new TGVerticalLayout(fGroupFrame));
	315	// fGroupFrame->Resize(164,116);
	316	AddFrame(fGroupFrame, new TGLayoutHints(kLHintsLeft \| kLHintsTop \| kLHintsCenterY \| kLHintsExpandX,2,2,2,2));
	317	}
	318
	319	//________________________________________________________
	320	TRDLoaderSimEditor::~TRDLoaderSimEditor()
	321	{}
	322
	323	//_________________________________________________________
	324	void TRDLoaderSimEditor::SetModel(TObject* obj)
	325	{
	326	fM = dynamic_cast<TRDLoaderSim*>(obj);
	327
	328	Bool_t kFile = kTRUE;
	329	if(fM->fFilename.CompareTo("") == 0) kFile = kFALSE;
	330
	331	/* printf("\thits %s\n", fM->kLoadHits ? "true" : "false");
	332	printf("\tdigits %s\n", fM->kLoadDigits ? "true" : "false");
	333	printf("\tclusters %s\n", fM->kLoadClusters ? "true" : "false");
334	printf("\ttracklets %s\n", fM->kLoadTracks ? "true" : "false");*/
335	fLoadHits->SetEnabled(kFile);
336	if(kFile) fLoadHits->SetState(fM->kLoadHits ? kButtonDown : kButtonUp);
337	fLoadDigits->SetEnabled(kFile);
338	if(kFile) fLoadDigits->SetState(fM->kLoadDigits ? kButtonDown : kButtonUp);
339	fLoadClusters->SetEnabled(kFile);
340	if(kFile) fLoadClusters->SetState(fM->kLoadClusters ? kButtonDown : kButtonUp);
341	fLoadTracks->SetEnabled(kFile);
342	if(kFile) fLoadTracks->SetState(fM->kLoadTracks ? kButtonDown : kButtonUp);
343	}
344
345	//________________________________________________________
346	void TRDLoaderSimEditor::Toggle(Int_t id)
347	{
348	switch(id){
349	case 0:
350	fM->kLoadHits = fLoadHits->IsDown() ? kTRUE : kFALSE;
351	break;
352	case 1:
353	fM->kLoadDigits = fLoadDigits->IsDown() ? kTRUE : kFALSE;
354	break;
355	case 2:
356	fM->kLoadClusters = fLoadClusters->IsDown() ? kTRUE : kFALSE;
357	break;
358	case 3:
359	fM->kLoadTracks = fLoadTracks->IsDown() ? kTRUE : kFALSE;
360	break;
361	}
362	}
363
364	///////////////////////////////////////////////////////////
365	///////////// TRDLoaderRawEditor /////////////////////
366	///////////////////////////////////////////////////////////
367
368	// //________________________________________________________
369	// TRDLoaderRawEditor::TRDLoaderRawEditor(const TGWindow* p, Int_t width, Int_t height, UInt_t options, Pixel_t back) : TGedFrame(p, width, height, options \| kVerticalFrame, back)
370	// {
371	// MakeTitle("TRDLoaderRaw");
372	// }
373	//
374	// void TRDLoaderRawEditor::SetModel(TObject* obj)
375	// {
376	// Info("SetModel()", "");
377	// fM = dynamic_cast<TRDLoaderRaw*>(obj);
378	// }