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

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

//#include "AliTRDv1.h"

#include <Reve/RGTopFrame.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 Reve;
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;
	}

	gReve->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 Exc_t 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();
	gReve->Redraw3D();
	//gReve->EnableRedraw();
	return kTRUE;
}

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