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

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

/**************************************************************************
 * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
 * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for          *
 * full copyright notice.                                                 *
 **************************************************************************/
#include "AliEveTRDLoaderImp.h"
#include "AliEveTRDModuleImp.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 std;

ClassImp(AliEveTRDLoaderSim)
ClassImp(AliEveTRDLoaderRaw)
ClassImp(AliEveTRDLoaderSimEditor)
//ClassImp(TRDLoaderRawEditor)

///////////////////////////////////////////////////////////
/////////////     AliEveTRDLoaderSim        /////////////////////
///////////////////////////////////////////////////////////


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

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

//________________________________________________________
Bool_t	AliEveTRDLoaderSim::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	AliEveTRDLoaderSim::LoadHits(TTree *tH)
{
	Info("LoadHits()", "Loading ...");
	if(!fChildren.size()) return kTRUE;

	AliEveTRDChamber *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	AliEveTRDLoaderSim::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;
}


///////////////////////////////////////////////////////////
/////////////     AliEveTRDLoaderRaw        /////////////////////
///////////////////////////////////////////////////////////


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

//________________________________________________________
AliEveTRDLoaderRaw::~AliEveTRDLoaderRaw()
{

}


//________________________________________________________
Bool_t  AliEveTRDLoaderRaw::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	AliEveTRDLoaderRaw::SetDataType(TRDDataTypes type)
{
	fDataRoot = (type == kRawRoot) ? kTRUE : kFALSE;
}

//________________________________________________________
Bool_t	AliEveTRDLoaderRaw::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("AliEveTRDLoader::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 AliEveTRDLoaderRaw::LoadEvent()
{
	Info("LoadEvent()", "Loading ...");

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


	fRawRootReader->Reset();

	AliEveTRDChamber *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 AliEveTRDLoaderRaw::NextEvent(Bool_t rewindOnEnd)
{
	static const TEveException eH("AliEveTRDLoader::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.");
	}
}


///////////////////////////////////////////////////////////
/////////////   AliEveTRDLoaderSimEditor    /////////////////////
///////////////////////////////////////////////////////////

//________________________________________________________
AliEveTRDLoaderSimEditor::AliEveTRDLoaderSimEditor(const TGWindow* p, Int_t width, Int_t height, UInt_t options, Pixel_t back) : TGedFrame(p, width, height, options | kVerticalFrame, back)
{
	MakeTitle("AliEveTRDLoaderSim");

	// "Data selector" group frame
	TGGroupFrame *fGroupFrame = new TGGroupFrame(this,"Data selector");
	fLoadHits = new TGCheckButton(fGroupFrame,"  Hits");
	fLoadHits->Connect("Clicked()", "AliEveTRDLoaderSimEditor", this, "Toggle(=0)");
	fGroupFrame->AddFrame(fLoadHits, new TGLayoutHints(kLHintsLeft | kLHintsTop | kLHintsCenterY | kLHintsExpandX,2,2,2,2));

	fLoadDigits = new TGCheckButton(fGroupFrame,"  Digits");
	fLoadDigits->Connect("Clicked()", "AliEveTRDLoaderSimEditor", this, "Toggle(=1)");
	fGroupFrame->AddFrame(fLoadDigits, new TGLayoutHints(kLHintsLeft | kLHintsTop | kLHintsCenterY | kLHintsExpandX,2,2,2,2));

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

	fLoadTracks = new TGCheckButton(fGroupFrame,"  Tracklets ");
	fLoadTracks->Connect("Clicked()", "AliEveTRDLoaderSimEditor", 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));
}

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

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