WebSVN – f9daq – Blame – /lab/sipmscan/trunk_v0.9/windowed_test.C

Rev	Author	Line No.	Line
145	f9daq	1	#include "workstation.h"
		2	#include "daq.h"
		3	#include "root_include.h"
		4	#include "windowed_test.h"
		5
		6	#include <stdio.h>
		7	#include <stdlib.h>
		8	#include <unistd.h>
		9
		10	#include "daqscope.h"
		11
		12	//---------------------------------------------------------------
		13	// Subwindow layout class
		14
		15	class TGMdiSubwindow
		16	{
		17	RQ_OBJECT("TGMdiSubwindow")
		18
		19	protected:
		20	TGMdiFrame *fMdiFrame;
		21
		22	public:
		23	TGMdiSubwindow(TGMdiMainFrame *main, int w, int h);
		24
		25	TGMdiFrame *GetMdiFrame() const { return fMdiFrame; }
		26	virtual Bool_t CloseWindow();
		27	};
		28
		29	//---------------------------------------------------------------
		30	// Main window class
		31
		32	class TGAppMainFrame
		33	{
		34	RQ_OBJECT("TGAppMainFrame")
		35
		36	protected:
		37	TGMainFrame *fMain;
		38	TGMdiMainFrame *fMainFrame;
		39	TGMdiMenuBar *fMenuBar;
		40	TGLayoutHints *fMenuBarItemLayout;
		41	TGPopupMenu fMenuFile, fMenuAnalysis, fMenuTools, fMenuWindow, *fMenuHelp;
		42	TGPopupMenu *fMenuHisttype;
		43	TGMdiSubwindow settingsPane, mainSubwindow, histogramPane, histogramPaneFile, histogramPaneCtr, fieldpointPane, *headerPane;
		44
		45	void InitMenu();
		46	void MeasurementLayout();
		47	void OpenWindow(int winid);
		48	void CloseWindow();
		49	Bool_t About();
		50	public:
		51	TGAppMainFrame(const TGWindow *p, int w, int h);
		52
		53	void HandleMenu(Int_t id);
		54
		55	void EnableVoltScan();
		56	void EnableSurfScan();
		57	void EnableZaxisScan();
		58	void VoltageLimit();
		59	void ChannelLimit();
		60	void CleanPlotToggle();
		61	void ConnectToScope();
		62
		63	void SetVoltOut();
		64	void GetVoltOut();
		65	void ResetVoltOut();
		66	void SetPosition();
		67	void GetPosition();
		68	void HomePosition();
		69
		70	void InitializeScope();
		71	void StartScopeAcq();
		72	void CustomScopeCommand();
		73	void SelectedMeasType(int mtype);
		74
		75	void SaveFile();
		76	void StartAcq();
		77
		78	void SelectDirectory();
		79	void ListMultiSelect();
		80	void ListSelectAll();
		81	void FileListNavigation(int pn);
		82	void HeaderEdit();
		83
		84	void DisplayHistogram(char *histfile, int histtype);
		85	void SetHistRange();
		86	void ChangeHisttype(int type);
		87	void ChangeChannel();
		88	void HistogramExport();
		89	void MakeSurfPlot(TList *files);
		90	void MakeBreakdownPlot(int nrp, double volt, double volterr, double psep1, double pseperr1, double psep2, double pseperr2, double psep3, double pseperr3, char *plotfile, int separations);
		91
		92	void FitSpectrum(TList *files, int q);
		93	void EdgeDetection(TGraph pdf, TGraph cdf, char outname, TCanvas g1dCanvas, double pdfmax, int direction);
		94	void IntegSpectrum(TList *files, int direction);
		95	void PhotonMu(TList *files);
		96
		97	void UpdateTempPlot();
		98	void TempEndToggle();
		99	void ExportTempPlot();
		100	void GetTempFile(int set);
		101
		102	void EditTickToggle(int set);
		103	void headerchange(char histfile, bool changetype);
		104	void headeredit();
		105
		106	void RunMeas(void *ptr, int runCase, int zaxisscan, int &scanon);
		107	};
		108
		109	const char *histExt = ".root";
		110	const char histExtAll = ".root";
		111	daq *gDaq;
		112	daqscope *gScopeDaq;
		113	//int debugSig = 0;
		114	int retTemp;
		115	int gStop=0;
		116	unsigned int gBuf[BSIZE];
		117	int logchange = 0;
		118	double tdctimeconversion = 45.0909;
		119	double lenconversion = 0.3595;
		120	int oscOn;
		121	const char *allMeasNames[11] = {"Amplitude","Area","Delay","Fall","Frequency","Maximum","Mean","Minimum","Peak-to-peak","Peak width","Rise"};
		122
		123	// ROOT file variable structure -----------
		124	struct EventHeader {
		125	int nrch;
		126	int timestamp;
		127	double biasvolt;
		128	int xpos;
		129	int ypos;
		130	int zpos;
		131	double temperature;
		132	double angle;
		133	char laserinfo[256];
		134	} evtheader;
		135
		136	struct EventData {
		137	int adcdata[8];
		138	int tdcdata[8];
		139	} evtdata;
		140
		141	struct EventMeas {
		142	double measdata;
		143	} evtmeas;
		144
		145	TFile *inroot;
		146	TFile *outroot;
		147
		148	// Test graphs for scope measurements
		149	TCanvas *wCanvas;
		150	TGraph *testgraph;
		151
		152	//---------------------------------------------------------------
		153	// Global variables
		154
		155	TGCheckButton *voltscanOn;
		156	TGCheckButton *surfscanOn;
		157	TGCheckButton *zscanOn;
		158	TGTextEntry *oscIP;
		159	TGTextButton *oscConnect;
		160	TGCheckButton *histogramOn;
		161	TGNumberEntry *vHardlimit;
		162	TGNumberEntry *NCH;
		163	TGTextEntry *laserInfo;
		164	TGNumberEntry *chtemp;
		165	TGNumberEntry *incangle;
		166	TGCheckButton *cleanOn;
		167
		168	TGTab *setTab;
		169	TGComboBox *vOutCh;
		170	TGNumberEntry *vOut;
		171	TGCheckButton *vOutOnOff;
		172	TGTextButton *vOutSet;
		173	TGTextButton *vOutGet;
		174	TGTextButton *vOutReset;
		175	TGNumberEntry *vOutStart;
		176	TGNumberEntry *vOutStop;
		177	TGNumberEntry *vOutStep;
		178	TGNumberEntry *xPos;
		179	TGNumberEntry *yPos;
		180	TGNumberEntry *zPos;
		181	TGTextButton *positionSet;
		182	TGTextButton *positionGet;
		183	TGTextButton *positionHome;
		184	TGNumberEntry *xPosMin;
		185	TGNumberEntry *xPosMax;
		186	TGNumberEntry *xPosStep;
		187	TGNumberEntry *yPosMin;
		188	TGNumberEntry *yPosMax;
		189	TGNumberEntry *yPosStep;
		190	TGNumberEntry *zPosMin;
		191	TGNumberEntry *zPosMax;
		192	TGNumberEntry *zPosStep;
		193	TGNumberEntry *evtNum;
		194	TGTextEntry *timeStamp;
		195	TGTextEntry *fileName;
		196	TGTextButton *saveFile;
		197	TGTextButton *measStart;
		198	TGLabel *busyLabel;
		199	TGHProgressBar *curProgress;
		200
		201	TRootEmbeddedCanvas *histCanvas;
		202
		203	TGTextButton *selectDir;
		204	TGListBox *fileList;
		205	TGCheckButton *multiSelect;
		206	TGCheckButton *multiSelectAll;
		207	TGTextButton *prevFile;
		208	TGTextButton *nextFile;
		209	TGTextButton *editHeader;
		210
		211	TGTextEntry *disptime;
		212	TGNumberEntry *dispbias;
		213	TGTextEntry *disppos;
		214	TGNumberEntry *disptemp;
		215	TGNumberEntry *dispangle;
		216	TGTextEntry *displaser;
		217
		218	TGNumberEntry *adcMinRange;
		219	TGNumberEntry *adcMaxRange;
		220	TGNumberEntry *tdcMinwindow;
		221	TGNumberEntry *tdcMaxwindow;
		222	TGNumberEntry *yMinRange;
		223	TGNumberEntry *yMaxRange;
		224	TGNumberEntry *selectCh;
		225	TGTextButton *changeADC;
		226	TGTextButton *changeTDC;
		227	TGTextButton *changeADCTDC;
		228	TGTextButton *change2Dsurf;
		229	TGCheckButton *logscale;
		230	TGTextButton *exportHist;
		231	TGNumberEntry *fitSigma;
		232	TGNumberEntry *fitTresh;
		233	TGNumberEntry *fitInter;
		234	TGNumberEntry *accError;
		235	TGNumberEntry *minPeak;
		236	TGNumberEntry *pedesLow;
		237	TGCheckButton *exfitplots;
		238
		239	TGCheckButton *sCH[8];
		240	TGComboBox *sMeasType;
		241	TGCheckButton *sCamaclink;
		242	TGTextEntry *scopeCommand;
		243	TGTextEntry *scopeReturn;
		244	TGTextButton *sendScopeCustom;
		245	TGComboBox *sMeasgroup;
		246	TGTextButton *scopeInit;
		247
		248	TRootEmbeddedCanvas *displayCanvas;
		249	TGComboBox *tempCh;
		250	TGComboBox *tempDay[2];
		251	TGComboBox *tempMonth[2];
		252	TGComboBox *tempYear[2];
		253	TGComboBox *tempHour[2];
		254	TGComboBox *tempMinute[2];
		255	TGComboBox *tempSecond[2];
		256	TGTextButton *tempFile[2];
		257	TGCheckButton *tempEndOn;
		258	TGTextButton *updateTemp;
		259	TGTextButton *exportTemp;
		260	//TGTextButton *closeTemp;
		261
		262	TGCheckButton *biasedittick;
		263	TGNumberEntry *biasedit;
		264	TGCheckButton *posedittick;
		265	TGNumberEntry *posedit[3];
		266	TGCheckButton *tempedittick;
		267	TGNumberEntry *tempedit;
		268	TGCheckButton *angleedittick;
		269	TGNumberEntry *angleedit;
		270	TGCheckButton *laseredittick;
		271	TGTextEntry *laseredit;
		272	TGTextButton *editHead;
		273
		274	Bool_t firstrun = kTRUE;
		275	Bool_t started;
		276	Bool_t cleanPlots = kTRUE;
		277
		278	// Layout hints definitions
		279	TGLayoutHints *f0 = new TGLayoutHints(kLHintsLeft \| kLHintsTop,2,2,2,2);
		280	TGLayoutHints *f0centerx = new TGLayoutHints(kLHintsCenterX,2,2,2,2);
		281	TGLayoutHints *f0centery = new TGLayoutHints(kLHintsLeft \| kLHintsCenterY,2,2,2,2);
		282	TGLayoutHints *f0center2d = new TGLayoutHints(kLHintsCenterX \| kLHintsCenterY,2,2,2,2);
		283	TGLayoutHints *f0right = new TGLayoutHints(kLHintsRight \| kLHintsTop,2,2,2,2);
		284	TGLayoutHints *f1 = new TGLayoutHints(kLHintsExpandX \| kLHintsExpandY,2,2,2,2);
		285	TGLayoutHints *f2 = new TGLayoutHints(kLHintsExpandX,2,2,2,2);
		286	TGLayoutHints *f3 = new TGLayoutHints(kLHintsCenterY,2,2,20,2);
		287	TGLayoutHints *f3notop = new TGLayoutHints(kLHintsCenterY,4,4,2,30);
		288
		289	// Separate functions -----------------------------------------
		290	void GetTime(int intime, char *outtime)
		291	{
		292	time_t rawtime;
		293	struct tm * timeinfo;
		294	if(intime < 0)
		295	time(&rawtime);
		296	else
		297	rawtime = (time_t)intime;
		298	timeinfo = localtime(&rawtime);
		299	sprintf(outtime, "%s", asctime(timeinfo));
		300	int len = strlen(outtime);
		301	if(len) outtime[len-1] = 0;
		302	}
		303
		304	int MyTimer()
		305	{
		306	char cmd[100];
		307	GetTime(-1, cmd);
		308	if (timeStamp) timeStamp->SetText(cmd);
		309	return 0;
		310	}
		311
		312	int GetChannel()
		313	{
		314	int selectedOutput;
		315	if(vOutCh->GetSelected() < 8) selectedOutput = (vOutCh->GetSelected())+1;
		316	else if( (vOutCh->GetSelected() >= 8) && (vOutCh->GetSelected() < 16) ) selectedOutput = (vOutCh->GetSelected())+93;
		317	else selectedOutput = 1;
		318
		319	return selectedOutput;
		320	}
		321
		322	void remove_ext(char inname, char outname)
		323	{
		324	char ctemp[256];
		325	for(int i = 0; i < (int)strlen(inname); i++)
		326	{
		327	if( (inname[i] == '.') && (i > (int)(strlen(inname)-6)) )
		328	{
		329	ctemp[i] = '\0';
		330	sprintf(outname, "%s", ctemp);
		331	break;
		332	}
		333	else
		334	ctemp[i] = inname[i];
		335	}
		336
		337	if(debug)
		338	printf("Outfile (remove_ext): %s\n", outname);
		339	}
		340
		341	void remove_from_last(char inname, char search, char outname)
		342	{
		343	char ctemp[256];
		344	int searchpos = -1;
		345	for(int i = (int)strlen(inname); i >= 0; i--)
		346	{
		347	if(inname[i] == search)
		348	{
		349	searchpos = i;
		350	break;
		351	}
		352	}
		353
		354	for(int i = 0; i < searchpos; i++)
		355	ctemp[i] = inname[i];
		356
		357	ctemp[searchpos] = '\0';
		358	sprintf(outname, "%s", ctemp);
		359
		360	if(debug)
		361	printf("Outfile (remove_from_last): %s\n", outname);
		362	}
		363
		364	void SeqNumber(int innum, int maxnum, char *outstr)
		365	{
		366	int zeronum = 5;
		367
		368	// Check how many zeroes we need to add to get sequential numbers
		369	if( (maxnum > 0) && (maxnum < 1000) )
		370	zeronum = 2;
		371	else if( (maxnum >= 1000) && (maxnum < 10000) )
		372	zeronum = 3;
		373	else if( (maxnum >= 10000) && (maxnum < 100000) )
		374	zeronum = 4;
		375	else if( (maxnum >= 100000) && (maxnum < 1000000) )
		376	zeronum = 5;
		377
		378	// Make the sequence number depending on the number of zeroes
		379	if(zeronum == 2)
		380	{
		381	if(innum < 10)
		382	sprintf(outstr, "00%d", innum);
		383	else if( (innum >= 10) && (innum < 100) )
		384	sprintf(outstr, "0%d", innum);
		385	else if( (innum >= 100) && (innum < 1000) )
		386	sprintf(outstr, "%d", innum);
		387	}
		388	else if(zeronum == 3)
		389	{
		390	if(innum < 10)
		391	sprintf(outstr, "000%d", innum);
		392	else if( (innum >= 10) && (innum < 100) )
		393	sprintf(outstr, "00%d", innum);
		394	else if( (innum >= 100) && (innum < 1000) )
		395	sprintf(outstr, "0%d", innum);
		396	else if( (innum >= 1000) && (innum < 10000) )
		397	sprintf(outstr, "%d", innum);
		398	}
		399	else if(zeronum == 4)
		400	{
		401	if(innum < 10)
		402	sprintf(outstr, "0000%d", innum);
		403	else if( (innum >= 10) && (innum < 100) )
		404	sprintf(outstr, "000%d", innum);
		405	else if( (innum >= 100) && (innum < 1000) )
		406	sprintf(outstr, "00%d", innum);
		407	else if( (innum >= 1000) && (innum < 10000) )
		408	sprintf(outstr, "0%d", innum);
		409	else if( (innum >= 10000) && (innum < 100000) )
		410	sprintf(outstr, "%d", innum);
		411	}
		412	else if(zeronum == 5)
		413	{
		414	if(innum < 10)
		415	sprintf(outstr, "00000%d", innum);
		416	else if( (innum >= 10) && (innum < 100) )
		417	sprintf(outstr, "0000%d", innum);
		418	else if( (innum >= 100) && (innum < 1000) )
		419	sprintf(outstr, "000%d", innum);
		420	else if( (innum >= 1000) && (innum < 10000) )
		421	sprintf(outstr, "00%d", innum);
		422	else if( (innum >= 10000) && (innum < 100000) )
		423	sprintf(outstr, "0%d", innum);
		424	else if( (innum >= 100000) && (innum < 1000000) )
		425	sprintf(outstr, "%d", innum);
		426	}
		427	}
		428
		429	// Peak detection function
		430	int npeaks;
		431	double FindPeaks(double x, double par)
		432	{
		433	double result = 0;
		434	for(int i = 0; i < npeaks; i++)
		435	{
		436	double norm = par[3*i];
		437	double mean = par[3*i+1];
		438	double sigma = par[3*i+2];
		439	result += norm*TMath::Gaus(x[0], mean, sigma);
		440	}
		441	return result;
		442	}
		443
		444	// Temperature sensor functions -----------------------------
		445	const char* dbname = "mysql://f9lab08.ijs.si/f9phdet";
		446	const char* tblname = "fprtd122";
		447	const char* username = "f9daq";
		448	const char* userpass = "f9lab";
		449
		450	// Get the temperature from MYSQL database
		451	double GetTemperature(int ch, const char *s)
		452	{
		453	int bin=5+74-ch4;
		454	char hex[16];
		455	strncpy(hex, (const char *) &s[bin], 4);
		456	hex[4]=0;
		457	int ix;
		458	sscanf (hex,"%x",&ix);
		459	//printf("0x%s\t",hex);
		460	return (ix/65535.)*1050.-200.;
		461	}
		462
		463	// Transform local time to timestamp
		464	int GetTimeStamp(int *intime)
		465	{
		466	time_t rawtime;
		467	struct tm * timeinfo;
		468	time(&rawtime);
		469	timeinfo = localtime(&rawtime);
		470
		471	printf("%d.%d.%d, %d:%d:%d\n", intime[0], intime[1], intime[2], intime[3], intime[4], intime[5]);
		472
		473	timeinfo->tm_mday = intime[0];
		474	timeinfo->tm_mon = intime[1] - 1;
		475	timeinfo->tm_year = intime[2] - 1900;
		476	timeinfo->tm_hour = intime[3];
		477	timeinfo->tm_min = intime[4];
		478	timeinfo->tm_sec = intime[5];
		479
		480	return (int)mktime(timeinfo);
		481	}
		482
		483	// Get data from MYSQL database
		484	void fieldpoint(int *timerange, int selch)
		485	{
		486	char humantime[256];
		487
		488	// Display selected timestamps
		489	GetTime(timerange[0], humantime);
		490	printf("Minimum time set to: %s (%d)\n", humantime, timerange[0]);
		491	if(timerange[1] != -1)
		492	{
		493	GetTime(timerange[1], humantime);
		494	printf("Maximum time set to: %s (%d)\n", humantime, timerange[1]);
		495	}
		496	printf("Selected fieldpoint channel: %d\n", selch);
		497	printf("\n");
		498
		499	// Database settings
		500	TSQLServer *db = TSQLServer::Connect(dbname, username, userpass);
		501	printf("Server info: %s\n", db->ServerInfo());
		502	TSQLRow *row;
		503	TSQLResult *res;
		504
		505	// list databases available on server
		506	printf("\nList all databases on server %s\n", db->GetHost());
		507	res = db->GetDataBases();
		508	while ((row = res->Next())) {
		509	printf("%s\n", row->GetField(0));
		510	delete row;
		511	}
		512	delete res;
		513
		514	// list tables in database "test" (the permission tables)
		515	printf("\nList all tables in database \"f9phdet\" on server %s\n", db->GetHost());
		516	res = db->GetTables("f9phdet");
		517	while ((row = res->Next())) {
		518	printf("%s\n", row->GetField(0));
		519	delete row;
		520	}
		521	delete res;
		522
		523	// list columns in table "runcatalog" in database "mysql"
		524	printf("\nList all columns in table \"f9phdet\" in database \"f9rtd122\" on server %s\n", db->GetHost());
		525	res = db->GetColumns("f9phdet", "fprtd122");
		526	while ((row = res->Next())) {
		527	printf("%s\n", row->GetField(0));
		528	delete row;
		529	}
		530	delete res;
		531
		532	// query database and print results
		533	char sql[1000] = "SELECT status,data,timestamp FROM fprtd122 WHERE status='A272727272727272748' AND substring(data,1,4)='A00C' ";
		534	if(timerange[1] == -1)
		535	sprintf(sql,"%s AND timestamp>='%d'", sql, timerange[0]);
		536	else
		537	sprintf(sql,"%s AND timestamp>='%d' AND timestamp<='%d'", sql, timerange[0], timerange[1]);
		538	printf("%s\n",sql);
		539
		540	res = db->Query(sql);
		541
		542	int nrows = res->GetRowCount();
		543	printf("\nGot %d rows in result\n", nrows);
		544
		545	// Printing and plotting
		546	char timeval[256];
		547	TGraph *gr;
		548	gr = new TGraph(nrows);
		549	gr->SetLineColor(kRed);
		550	gr->SetLineWidth(1);
		551	gr->SetMarkerColor(kRed);
		552	gr->SetMarkerStyle(20);
		553	gr->SetTitle("Temperature sensor;Time;Temperature (deg.)");
		554
		555	FILE *fp;
		556	fp = fopen("./fieldpoint/dataout_fieldpoint.txt", "w");
		557
		558	if(debug)
		559	printf("Time\tTemperature\n");
		560	for (int i = 0; i < nrows; i++) {
		561	row = res->Next();
		562
		563	GetTime((int)atof(row->GetField(2)), timeval);
		564	double x = atof(row->GetField(2));
		565	double y = GetTemperature(selch,row->GetField(1));
		566	gr->SetPoint(i,x,y);
		567
		568	fprintf(fp, "%s\t%f\n",timeval,y);
		569
		570	if(debug)
		571	printf("%s\t%f\n",timeval,y);
		572
		573	delete row;
		574	}
		575
		576	fclose(fp);
		577
		578	delete res;
		579	delete db;
		580
		581	TCanvas *gCanvas = displayCanvas->GetCanvas();
		582	gCanvas->SetGrid();
		583	gr->GetXaxis()->SetTimeDisplay(1);
		584	gr->GetXaxis()->SetTimeFormat("%d.%m.%H:%M");
		585	gr->GetXaxis()->SetLabelSize(0.027);
		586	gr->GetXaxis()->SetTitleSize(0.038);
		587	gr->GetYaxis()->SetLabelSize(0.027);
		588	gr->GetYaxis()->SetTitleSize(0.038);
		589	gr->GetXaxis()->SetNdivisions(515,kTRUE);
		590	gr->Draw("AL");
		591
		592	gCanvas->Modified();
		593	gCanvas->Update();
		594	}
		595
		596	// Update the temperature plot
		597	void TGAppMainFrame::UpdateTempPlot()
		598	{
		599	int stime[6];
		600	int etime[6];
		601
		602	int timestamp[2];
		603
		604	time_t rtime;
		605	int curyear;
		606	time(&rtime);
		607	curyear = (int)(localtime(&rtime))->tm_year+1900;
		608
		609	int leapy = 0;
		610
		611	// Getting the start time
		612	stime[0] = (int)(tempDay[0]->GetSelected())+1;
		613	stime[2] = curyear - (int)(tempYear[0]->GetSelected());
		614	printf("%d, %d, %d\n", stime[2], curyear, (int)(tempYear[0]->GetSelected()));
		615	stime[3] = (int)(tempHour[0]->GetSelected());
		616	stime[4] = (int)(tempMinute[0]->GetSelected());
		617	stime[5] = (int)(tempSecond[0]->GetSelected());
		618
		619	switch( tempMonth[0]->GetSelected() )
		620	{
		621	case 0:
		622	stime[1] = (int)(tempMonth[0]->GetSelected())+1;
		623	break;
		624	case 1:
		625	if( stime[2]%4 == 0)
		626	leapy = 1;
		627
		628	if( (leapy == 1) && (stime[0] > 29) )
		629	{
		630	stime[0] = 29;
		631	tempDay[0]->Select(28);
		632	}
		633	else if( (leapy == 0) && (stime[0] > 28) )
		634	{
		635	stime[0] = 28;
		636	tempDay[0]->Select(27);
		637	}
		638	stime[1] = (int)(tempMonth[0]->GetSelected())+1;
		639	break;
		640	case 2:
		641	stime[1] = (int)(tempMonth[0]->GetSelected())+1;
		642	break;
		643	case 3:
		644	if(stime[0] > 30)
		645	{
		646	stime[0] = 30;
		647	tempDay[0]->Select(29);
		648	}
		649	stime[1] = (int)(tempMonth[0]->GetSelected())+1;
		650	break;
		651	case 4:
		652	stime[1] = (int)(tempMonth[0]->GetSelected())+1;
		653	break;
		654	case 5:
		655	if(stime[0] > 30)
		656	{
		657	stime[0] = 30;
		658	tempDay[0]->Select(29);
		659	}
		660	stime[1] = (int)(tempMonth[0]->GetSelected())+1;
		661	break;
		662	case 6:
		663	stime[1] = (int)(tempMonth[0]->GetSelected())+1;
		664	break;
		665	case 7:
		666	stime[1] = (int)(tempMonth[0]->GetSelected())+1;
		667	break;
		668	case 8:
		669	if(stime[0] > 30)
		670	{
		671	stime[0] = 30;
		672	tempDay[0]->Select(29);
		673	}
		674	stime[1] = (int)(tempMonth[0]->GetSelected())+1;
		675	break;
		676	case 9:
		677	stime[1] = (int)(tempMonth[0]->GetSelected())+1;
		678	break;
		679	case 10:
		680	if(stime[0] > 30)
		681	{
		682	stime[0] = 30;
		683	tempDay[0]->Select(29);
		684	}
		685	stime[1] = (int)(tempMonth[0]->GetSelected())+1;
		686	break;
		687	case 11:
		688	stime[1] = (int)(tempMonth[0]->GetSelected())+1;
		689	break;
		690	default:
		691	break;
		692	}
		693
		694	timestamp[0] = GetTimeStamp(stime);
		695	printf("Start time: %d\n", timestamp[0]);
		696
		697	// Getting the end time
		698	etime[0] = (int)(tempDay[1]->GetSelected())+1;
		699	etime[2] = curyear - (int)(tempYear[1]->GetSelected());
		700	etime[3] = (int)(tempHour[1]->GetSelected());
		701	etime[4] = (int)(tempMinute[1]->GetSelected());
		702	etime[5] = (int)(tempSecond[1]->GetSelected());
		703
		704	switch( tempMonth[1]->GetSelected() )
		705	{
		706	case 0:
		707	etime[1] = (int)(tempMonth[1]->GetSelected())+1;
		708	break;
		709	case 1:
		710	if( etime[2]%4 == 0)
		711	leapy = 1;
		712
		713	if( (leapy == 1) && (etime[0] > 29) )
		714	{
		715	etime[0] = 29;
		716	tempDay[1]->Select(28);
		717	}
		718	else if( (leapy == 0) && (etime[0] > 28) )
		719	{
		720	etime[0] = 28;
		721	tempDay[1]->Select(27);
		722	}
		723	etime[1] = (int)(tempMonth[1]->GetSelected())+1;
		724	break;
		725	case 2:
		726	etime[1] = (int)(tempMonth[1]->GetSelected())+1;
		727	break;
		728	case 3:
		729	if(etime[0] > 30)
		730	{
		731	etime[0] = 30;
		732	tempDay[1]->Select(29);
		733	}
		734	etime[1] = (int)(tempMonth[1]->GetSelected())+1;
		735	break;
		736	case 4:
		737	etime[1] = (int)(tempMonth[1]->GetSelected())+1;
		738	break;
		739	case 5:
		740	if(etime[0] > 30)
		741	{
		742	etime[0] = 30;
		743	tempDay[1]->Select(29);
		744	}
		745	etime[1] = (int)(tempMonth[1]->GetSelected())+1;
		746	break;
		747	case 6:
		748	etime[1] = (int)(tempMonth[1]->GetSelected())+1;
		749	break;
		750	case 7:
		751	etime[1] = (int)(tempMonth[1]->GetSelected())+1;
		752	break;
		753	case 8:
		754	if(etime[0] > 30)
		755	{
		756	etime[0] = 30;
		757	tempDay[1]->Select(29);
		758	}
		759	etime[1] = (int)(tempMonth[1]->GetSelected())+1;
		760	break;
		761	case 9:
		762	etime[1] = (int)(tempMonth[1]->GetSelected())+1;
		763	break;
		764	case 10:
		765	if(etime[0] > 30)
		766	{
		767	etime[0] = 30;
		768	tempDay[1]->Select(29);
		769	}
		770	etime[1] = (int)(tempMonth[1]->GetSelected())+1;
		771	break;
		772	case 11:
		773	etime[1] = (int)(tempMonth[1]->GetSelected())+1;
		774	break;
		775	default:
		776	break;
		777	}
		778
		779	if( tempEndOn->IsDown() )
		780	timestamp[1] = -1;
		781	else
		782	timestamp[1] = GetTimeStamp(etime);
		783	printf("End time: %d\n", timestamp[1]);
		784
		785	fieldpoint(timestamp, tempCh->GetSelected());
		786	}
		787
		788	// Export the temperature plot to pdf
		789	void TGAppMainFrame::ExportTempPlot()
		790	{
		791	TCanvas *gCanvas = displayCanvas->GetCanvas();
		792	gCanvas->Modified();
		793	gCanvas->Update();
		794	gCanvas->SaveAs("./fieldpoint/plotout_fieldpoint.pdf");
		795	}
		796
		797	// Get time information from a saved file
		798	void TGAppMainFrame::GetTempFile(int set)
		799	{
		800	TGFileInfo file_info;
		801	const char *filetypes[] = {"Histograms",histExtAll,0,0};
		802	file_info.fFileTypes = filetypes;
		803	file_info.fIniDir = StrDup("./results");
		804	file_info.fMultipleSelection = kFALSE;
		805	new TGFileDialog(gClient->GetDefaultRoot(), fMain, kFDOpen, &file_info);
		806	int i = 0;
		807
		808	TTree *header_data;
		809	time_t rtime, ctime;
		810	struct tm * timeinfo;
		811
		812	int curyear;
		813	time(&ctime);
		814	curyear = (int)(localtime(&ctime))->tm_year+1900;
		815
		816	TList *files = file_info.fFileNamesList;
		817	TString fname;
		818	// If multiple files were selected, only use the first one
		819	if(files)
		820	{
		821	printf("Using only the first selected file.\n");
		822
		823	TSystemFile *file;
		824	TIter next(files);
		825	while(i == 0)
		826	{
		827	file=(TSystemFile*)next();
		828	fname = file->GetName();
		829	i++;
		830	}
		831	}
		832	// If only one file was selected, use it
		833	else
		834	fname = file_info.fFilename;
		835
		836	if((int)fname.Length() > 0)
		837	{
		838	inroot = new TFile(fname, "READ");
		839
		840	inroot->GetObject("header_data", header_data);
		841
		842	// Reading the timestamp information
		843	header_data->SetBranchAddress("timestamp", &evtheader.timestamp);
		844	header_data->GetEntry(0);
		845
		846	rtime = (time_t)evtheader.timestamp;
		847	timeinfo = localtime(&rtime);
		848	// printf("Time: %d.%d.%d, %d:%d:%d\n", timeinfo->tm_mday, timeinfo->tm_mon+1, timeinfo->tm_year+1900, timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec);
		849
		850	tempDay[set]->Select(timeinfo->tm_mday - 1);
		851	tempMonth[set]->Select(timeinfo->tm_mon);
		852	tempYear[set]->Select(curyear - (timeinfo->tm_year+1900));
		853	tempHour[set]->Select(timeinfo->tm_hour);
		854	tempMinute[set]->Select(timeinfo->tm_min);
		855	tempSecond[set]->Select(timeinfo->tm_sec);
		856
		857	inroot->Close();
		858	}
		859	else
		860	printf("No file selected.\n");
		861
		862	delete inroot;
		863	}
		864
		865	// Toggle the endtime settings for temperature sensor
		866	void TGAppMainFrame::TempEndToggle()
		867	{
		868	if( tempEndOn->IsDown() )
		869	{
		870	tempDay[1]->SetEnabled(kFALSE);
		871	tempMonth[1]->SetEnabled(kFALSE);
		872	tempYear[1]->SetEnabled(kFALSE);
		873	tempHour[1]->SetEnabled(kFALSE);
		874	tempMinute[1]->SetEnabled(kFALSE);
		875	tempSecond[1]->SetEnabled(kFALSE);
		876	tempFile[1]->SetEnabled(kFALSE);
		877	}
		878	else
		879	{
		880	tempDay[1]->SetEnabled(kTRUE);
		881	tempMonth[1]->SetEnabled(kTRUE);
		882	tempYear[1]->SetEnabled(kTRUE);
		883	tempHour[1]->SetEnabled(kTRUE);
		884	tempMinute[1]->SetEnabled(kTRUE);
		885	tempSecond[1]->SetEnabled(kTRUE);
		886	tempFile[1]->SetEnabled(kTRUE);
		887	}
		888	}
		889
		890	// --------------------------------------------------------------
		891
		892	// Header editor functions --------------------------------------
		893
		894	// Toggle the edit possibility for header entries
		895	void TGAppMainFrame::EditTickToggle(int set)
		896	{
		897	if(set == 1)
		898	{
		899	if(biasedittick->IsDown()) biasedit->SetState(kTRUE);
		900	else biasedit->SetState(kFALSE);
		901	}
		902	else if(set == 2)
		903	{
		904	if(posedittick->IsDown())
		905	{
		906	posedit[0]->SetState(kTRUE);
		907	posedit[1]->SetState(kTRUE);
		908	posedit[2]->SetState(kTRUE);
		909	}
		910	else
		911	{
		912	posedit[0]->SetState(kFALSE);
		913	posedit[1]->SetState(kFALSE);
		914	posedit[2]->SetState(kFALSE);
		915	}
		916	}
		917	else if(set == 3)
		918	{
		919	if(tempedittick->IsDown()) tempedit->SetState(kTRUE);
		920	else tempedit->SetState(kFALSE);
		921	}
		922	else if(set == 4)
		923	{
		924	if(angleedittick->IsDown()) angleedit->SetState(kTRUE);
		925	else angleedit->SetState(kFALSE);
		926	}
		927	else if(set == 5)
		928	{
		929	if(laseredittick->IsDown()) laseredit->SetState(kTRUE);
		930	else laseredit->SetState(kFALSE);
		931	}
		932	}
		933
		934	// Run the editing of file headers
		935	void TGAppMainFrame::headerchange(char histfile, bool changetype)
		936	{
		937	if(debug)
		938	printf("Selected file: %s\n", histfile);
		939
		940	// Preparing input file and the temporary output file
		941	inroot = new TFile(histfile, "READ");
		942
		943	char outname[256];
		944	sprintf(outname, "%s/results/temp.root", rootdir);
		945	outroot = new TFile(outname, "RECREATE");
		946
		947	// Tree structure of input file
		948	TTree header_data, meas_data, *scope_data;
		949
		950	inroot->GetObject("header_data", header_data);
		951	inroot->GetObject("meas_data", meas_data);
		952	inroot->GetObject("scope_data", scope_data);
		953
		954	// Tree structure of output file
		955	TTree *new_meas_data = meas_data->CloneTree();
		956	TTree *new_scope_data = scope_data->CloneTree();
		957
		958	// Save branches from the old header to temporary variables
		959	header_data->SetBranchAddress("nrch", &evtheader.nrch);
		960	header_data->GetEntry(0);
		961	header_data->SetBranchAddress("timestamp", &evtheader.timestamp);
		962	header_data->GetEntry(0);
		963	header_data->SetBranchAddress("biasvolt", &evtheader.biasvolt);
		964	header_data->GetEntry(0);
		965	header_data->SetBranchAddress("xpos", &evtheader.xpos);
		966	header_data->GetEntry(0);
		967	header_data->SetBranchAddress("ypos", &evtheader.ypos);
		968	header_data->GetEntry(0);
		969	header_data->SetBranchAddress("zpos", &evtheader.zpos);
		970	header_data->GetEntry(0);
		971	header_data->SetBranchAddress("temperature", &evtheader.temperature);
		972	header_data->GetEntry(0);
		973	if( header_data->FindBranch("angle") )
		974	{
		975	header_data->SetBranchAddress("angle", &evtheader.angle);
		976	header_data->GetEntry(0);
		977	}
		978	header_data->SetBranchAddress("laserinfo", &evtheader.laserinfo);
		979	header_data->GetEntry(0);
		980
		981	int itemp[5] = {0,0,0,0,0};
		982	double dtemp[3] = {0.,0.,0.};
		983	char ctemp[256];
		984
		985	itemp[0] = evtheader.nrch;
		986	itemp[1] = evtheader.timestamp;
		987	itemp[2] = evtheader.xpos;
		988	itemp[3] = evtheader.ypos;
		989	itemp[4] = evtheader.zpos;
		990	dtemp[0] = evtheader.biasvolt;
		991	dtemp[1] = evtheader.temperature;
		992	if( header_data->FindBranch("angle") )
		993	dtemp[2] = evtheader.angle;
		994	else
		995	dtemp[2] = 0.;
		996	sprintf(ctemp, "%s", evtheader.laserinfo);
		997
		998	delete header_data;
		999	delete meas_data;
		1000	delete scope_data;
		1001	inroot->Close();
		1002	delete inroot;
		1003
		1004	// Prepare branches for the new header
		1005	TTree *new_header_data = new TTree("header_data", "Header information for the measurement.");
		1006	new_header_data->Branch("nrch", &evtheader.nrch, "nrch/I");
		1007	new_header_data->Branch("timestamp", &evtheader.timestamp, "timestamp/I");
		1008	new_header_data->Branch("biasvolt", &evtheader.biasvolt, "biasvolt/D");
		1009	new_header_data->Branch("xpos", &evtheader.xpos, "xpos/I");
		1010	new_header_data->Branch("ypos", &evtheader.ypos, "ypos/I");
		1011	new_header_data->Branch("zpos", &evtheader.zpos, "zpos/I");
		1012	new_header_data->Branch("temperature", &evtheader.temperature, "temperature/D");
		1013	new_header_data->Branch("angle", &evtheader.angle, "temperature/D");
		1014	new_header_data->Branch("laserinfo", &evtheader.laserinfo, "laserinfo/C");
		1015
		1016	// Save new values (and old ones where we don't want to edit anything)
		1017	evtheader.nrch = itemp[0];
		1018	evtheader.timestamp = itemp[1];
		1019	if(changetype[0])
		1020	evtheader.biasvolt = (double)biasedit->GetNumber();
		1021	else
		1022	evtheader.biasvolt = dtemp[0];
		1023	if(changetype[1])
		1024	{
		1025	evtheader.xpos = (int)posedit[0]->GetNumber();
		1026	evtheader.ypos = (int)posedit[1]->GetNumber();
		1027	evtheader.zpos = (int)posedit[2]->GetNumber();
		1028	}
		1029	else
		1030	{
		1031	evtheader.xpos = itemp[2];
		1032	evtheader.ypos = itemp[3];
		1033	evtheader.zpos = itemp[4];
		1034	}
		1035	if(changetype[2])
		1036	evtheader.temperature = (double)tempedit->GetNumber();
		1037	else
		1038	evtheader.temperature = dtemp[1];
		1039	if(changetype[3])
		1040	evtheader.angle = (double)angleedit->GetNumber();
		1041	else
		1042	evtheader.angle = dtemp[2];
		1043	if(changetype[4])
		1044	sprintf(evtheader.laserinfo, "%s", laseredit->GetText());
		1045	else
		1046	sprintf(evtheader.laserinfo, "%s", ctemp);
		1047
		1048	new_header_data->Fill();
		1049
		1050	// Write down the temporary output file
		1051	new_header_data->Write();
		1052	new_meas_data->Write();
		1053	new_scope_data->Write();
		1054
		1055	delete new_header_data;
		1056	delete new_meas_data;
		1057	delete new_scope_data;
		1058	outroot->Close();
		1059	delete outroot;
		1060
		1061	// Replace the original file with temporary output file (and delete temporary file)
		1062	sprintf(outname, "cp -f %s/results/temp.root %s", rootdir, histfile);
		1063	retTemp = system(outname);
		1064	sprintf(outname, "rm -f %s/results/temp.root", rootdir);
		1065	retTemp = system(outname);
		1066
		1067	printf("Edited header in file: %s\n", histfile);
		1068	}
		1069
		1070	// Setup the editing of file headers
		1071	void TGAppMainFrame::headeredit()
		1072	{
		1073	unsigned int nrfiles = fileList->GetNumberOfEntries();
		1074	TList *files;
		1075	// Changelist: Bias, Position, Temperature, Angle, Laser info
		1076	bool changelist[] = { biasedittick->IsDown(), posedittick->IsDown(), tempedittick->IsDown(), angleedittick->IsDown(), laseredittick->IsDown() };
		1077
		1078	if( nrfiles > 0 )
		1079	{
		1080	// check the selected file/files and return its name/their names
		1081	files = new TList();
		1082	fileList->GetSelectedEntries(files);
		1083	if(files)
		1084	{
		1085	for(int i = 0; i < (int)nrfiles; i++)
		1086	{
		1087	if(files->At(i))
		1088	{
		1089	if(debug)
		1090	printf("Filename: %s\n", files->At(i)->GetTitle());
		1091
		1092	headerchange( (char*)(files->At(i)->GetTitle()), changelist );
		1093	}
		1094	}
		1095	}
		1096	}
		1097	}
		1098
		1099	// --------------------------------------------------------------
		1100
		1101	// Class related functions --------------------------------------
		1102
		1103	// Apply the upper voltage limit from settings pane to main window
		1104	void TGAppMainFrame::VoltageLimit()
		1105	{
		1106	vOut->SetLimitValues(0, vHardlimit->GetNumber() );
		1107	}
		1108
		1109	// Apply the upper channel limit from settings pane to histogram settings
		1110	void TGAppMainFrame::ChannelLimit()
		1111	{
		1112	selectCh->SetLimitValues(0, (NCH->GetNumber()-1) );
		1113	}
		1114
		1115	// Enable or disable voltage scan controls
		1116	void TGAppMainFrame::EnableVoltScan()
		1117	{
		1118	if(voltscanOn->IsOn())
		1119	{
		1120	vOutStart->SetState(kTRUE);
		1121	vOutStop->SetState(kTRUE);
		1122	vOutStep->SetState(kTRUE);
		1123	}
		1124	else
		1125	{
		1126	vOutStart->SetState(kFALSE);
		1127	vOutStop->SetState(kFALSE);
		1128	vOutStep->SetState(kFALSE);
		1129	}
		1130	}
		1131
		1132	// Enable or disable surface scan controls
		1133	void TGAppMainFrame::EnableSurfScan()
		1134	{
		1135	if(surfscanOn->IsOn())
		1136	{
		1137	xPosMin->SetState(kTRUE);
		1138	xPosMax->SetState(kTRUE);
		1139	xPosStep->SetState(kTRUE);
		1140	yPosMin->SetState(kTRUE);
		1141	yPosMax->SetState(kTRUE);
		1142	yPosStep->SetState(kTRUE);
		1143	}
		1144	else
		1145	{
		1146	xPosMin->SetState(kFALSE);
		1147	xPosMax->SetState(kFALSE);
		1148	xPosStep->SetState(kFALSE);
		1149	yPosMin->SetState(kFALSE);
		1150	yPosMax->SetState(kFALSE);
		1151	yPosStep->SetState(kFALSE);
		1152	}
		1153	}
		1154
		1155	// Enable or disable Z axis scan controls
		1156	void TGAppMainFrame::EnableZaxisScan()
		1157	{
		1158	if(zscanOn->IsOn())
		1159	{
		1160	zPosMin->SetState(kTRUE);
		1161	zPosMax->SetState(kTRUE);
		1162	zPosStep->SetState(kTRUE);
		1163	}
		1164	else
		1165	{
		1166	zPosMin->SetState(kFALSE);
		1167	zPosMax->SetState(kFALSE);
		1168	zPosStep->SetState(kFALSE);
		1169	}
		1170	}
		1171
		1172	// Toggle clean plots on/off
		1173	void TGAppMainFrame::CleanPlotToggle()
		1174	{
		1175	cleanPlots = cleanOn->IsDown();
		1176	}
		1177
		1178	// Connect to oscilloscope
		1179	void TGAppMainFrame::ConnectToScope()
		1180	{
		1181	int scopeState = -1;
		1182	char IPaddr = (char)oscIP->GetText();
		1183	int IPcorr = 0;
		1184
		1185	if(oscOn == 0)
		1186	{
		1187	// Check if the IP address has the required three .
		1188	for(int i = 0; i < (int)strlen(IPaddr); i++)
		1189	if(IPaddr[i] == '.')
		1190	IPcorr++;
		1191
		1192	if( (IPaddr != NULL) && (IPcorr == 3) )
		1193	{
		1194	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'
		1195	printf("Connecting to oscilloscope.\n");
		1196	retTemp = gScopeDaq->connect(IPaddr);
		1197	scopeState = 1; // For testing instead of making a real connection
		1198	#else
		1199	scopeState = 1;
		1200	retTemp = 0;
		1201	#endif
		1202	}
		1203	else
		1204	{
		1205	scopeState = -1;
		1206	printf("Please enter a valid scope IP address.\n");
		1207	}
		1208	}
		1209	else if(oscOn > 0)
		1210	{
		1211	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'
		1212	printf("Disconnecting from oscilloscope.\n");
		1213	retTemp = gScopeDaq->disconnect(IPaddr);
		1214	scopeState = -1; // For testing instead of making a real disconnection
		1215	#else
		1216	scopeState = -1;
		1217	retTemp = 0;
		1218	#endif
		1219	}
		1220
		1221	if(retTemp == 0)
		1222	{
		1223	if(scopeState >= 0)
		1224	{
		1225	oscIP->SetEnabled(kFALSE);
		1226	oscConnect->SetText("Disconnect");
		1227	oscConnect->SetTextJustify(36);
		1228	oscConnect->SetWrapLength(-1);
		1229	oscConnect->Resize(60,22);
		1230
		1231	for(int i = 0; i < 8; i++)
		1232	{
		1233	sCH[i]->SetState(kButtonUp);
		1234	sCH[i]->SetEnabled(kFALSE);
		1235	}
		1236	sMeasType->SetEnabled(kTRUE);
		1237	sCamaclink->SetState(kButtonUp);
		1238	sCamaclink->SetEnabled(kFALSE);
		1239	scopeCommand->SetEnabled(kTRUE);
		1240	sendScopeCustom->SetEnabled(kTRUE);
		1241	sMeasgroup->SetEnabled(kFALSE);
		1242	scopeInit->SetEnabled(kFALSE);
		1243
		1244	oscOn = 1;
		1245	}
		1246	else
		1247	{
		1248	oscIP->SetEnabled(kTRUE);
		1249	oscConnect->SetText("Connect");
		1250	oscConnect->SetTextJustify(36);
		1251	oscConnect->SetWrapLength(-1);
		1252	oscConnect->Resize(60,22);
		1253
		1254	for(int i = 0; i < 8; i++)
		1255	{
		1256	sCH[i]->SetState(kButtonUp);
		1257	sCH[i]->SetEnabled(kFALSE);
		1258	}
		1259	sMeasType->Select(0);
		1260	sMeasType->SetEnabled(kFALSE);
		1261	sCamaclink->SetState(kButtonUp);
		1262	sCamaclink->SetEnabled(kFALSE);
		1263	scopeCommand->SetEnabled(kFALSE);
		1264	sendScopeCustom->SetEnabled(kFALSE);
		1265	sMeasgroup->SetEnabled(kFALSE);
		1266	scopeInit->SetEnabled(kFALSE);
		1267
		1268	oscOn = 0;
		1269	}
		1270	}
		1271	else
		1272	printf("Error! Connecting/disconnecting failed.\n");
		1273	}
		1274
		1275	// Set the output voltage
		1276	void TGAppMainFrame::SetVoltOut()
		1277	{
		1278	char cmd[256];
		1279	int outOn;
		1280	float outputVoltage;
		1281
		1282	outputVoltage = vOut->GetNumber();
		1283
		1284	if(vOutOnOff->IsOn()) outOn = 1;
		1285	else outOn = 0;
		1286
		1287	fflush(stdout);
		1288	sprintf(cmd, "%s/mpod/mpod_voltage.sh -o %d -v %f -s %d", rootdir, GetChannel(), outputVoltage, outOn);
		1289	#if WORKSTAT == 'I'
		1290	retTemp = system(cmd);
		1291	#else
		1292	printf("Cmd: %s\n",cmd);
		1293	#endif
		1294	fflush(stdout);
		1295	}
		1296
		1297	// Get the output voltage
		1298	void TGAppMainFrame::GetVoltOut()
		1299	{
		1300	char cmd[256];
		1301
		1302	fflush(stdout);
		1303	sprintf(cmd, "%s/mpod/mpod_voltage.sh -o %d -g > %s/curvolt.txt", rootdir, GetChannel(), rootdir);
		1304	#if WORKSTAT == 'I'
		1305	retTemp = system(cmd);
		1306	#else
		1307	printf("Cmd: %s\n",cmd);
		1308	#endif
		1309	fflush(stdout);
		1310
		1311	#if WORKSTAT == 'I'
		1312	FILE* fvolt;
		1313	double dtemp;
		1314	char ctemp[24];
		1315	sprintf(cmd, "%s/curvolt.txt", rootdir);
		1316	fvolt = fopen(cmd, "r");
		1317
		1318	if(fvolt != NULL)
		1319	{
		1320	sprintf(cmd, "WIENER-CRATE-MIB::outputVoltage.u%d = Opaque: Float: %s V\n", GetChannel()-1, "%lf" );
		1321	retTemp = fscanf(fvolt, cmd, &dtemp);
		1322	vOut->SetNumber(dtemp);
		1323	sprintf(cmd, "WIENER-CRATE-MIB::outputSwitch.u%d = INTEGER: %s\n", GetChannel()-1, "%s" );
		1324	retTemp = fscanf(fvolt, cmd, ctemp);
		1325	if( strcmp(ctemp, "On(1)") == 0 )
		1326	vOutOnOff->SetState(kButtonDown);
		1327	else if( strcmp(ctemp, "Off(0)") == 0 )
		1328	vOutOnOff->SetState(kButtonUp);
		1329	}
		1330
		1331	fclose(fvolt);
		1332	#endif
		1333	}
		1334
		1335	// Reset the output voltage
		1336	void TGAppMainFrame::ResetVoltOut()
		1337	{
		1338	char cmd[256];
		1339
		1340	vOut->SetNumber(0.000);
		1341	vOutOnOff->SetState(kButtonUp);
		1342
		1343	fflush(stdout);
		1344	sprintf(cmd, "%s/mpod/mpod_voltage.sh -r %d", rootdir, GetChannel());
		1345	#if WORKSTAT == 'I'
		1346	retTemp = system(cmd);
		1347	#else
		1348	printf("Cmd: %s\n",cmd);
		1349	#endif
		1350	fflush(stdout);
		1351	}
		1352
		1353	// Get the current table position
		1354	void TGAppMainFrame::GetPosition()
		1355	{
		1356	char cmd[256];
		1357
		1358	fflush(stdout);
		1359
		1360	sprintf(cmd, "sudo %s/MIKRO/mikro_ctrl -n 1 -p > %s/curpos.txt", rootdir, rootdir); // X-axis
		1361	fflush(stdout);
		1362	#if WORKSTAT == 'I'
		1363	retTemp = system(cmd);
		1364	#else
		1365	printf("Cmd: %s\n",cmd);
		1366	#endif
		1367
		1368	sprintf(cmd, "sudo %s/MIKRO/mikro_ctrl -n 2 -p >> %s/curpos.txt", rootdir, rootdir); // Y-axis
		1369	fflush(stdout);
		1370	#if WORKSTAT == 'I'
		1371	retTemp = system(cmd);
		1372	#else
		1373	printf("Cmd: %s\n",cmd);
		1374	#endif
		1375
		1376	sprintf(cmd, "sudo %s/MIKRO/mikro_ctrl -n 3 -p >> %s/curpos.txt", rootdir, rootdir); // Z-axis
		1377	fflush(stdout);
		1378	#if WORKSTAT == 'I'
		1379	retTemp = system(cmd);
		1380	#else
		1381	printf("Cmd: %s\n",cmd);
		1382	#endif
		1383
		1384	#if WORKSTAT == 'I'
		1385	FILE* fpos;
		1386	int itemp;
		1387	sprintf(cmd, "%s/curpos.txt", rootdir);
		1388	fpos = fopen(cmd, "r");
		1389
		1390	if(fpos != NULL)
		1391	{
		1392	retTemp = fscanf(fpos, "%d\n", &itemp);
		1393	xPos->SetNumber(itemp);
		1394	retTemp = fscanf(fpos, "%d\n", &itemp);
		1395	yPos->SetNumber(itemp);
		1396	retTemp = fscanf(fpos, "%d\n", &itemp);
		1397	zPos->SetNumber(itemp);
		1398	}
		1399
		1400	fclose(fpos);
		1401	#endif
		1402	}
		1403
		1404	// Set the current table position
		1405	void TGAppMainFrame::SetPosition()
		1406	{
		1407	char cmd[256];
		1408	int positX, positY, positZ;
		1409
		1410	positX = xPos->GetNumber();
		1411	positY = yPos->GetNumber();
		1412	positZ = zPos->GetNumber();
		1413
		1414	sprintf(cmd, "sudo %s/MIKRO/mikro_ctrl -n 1 -v %d -s la && %s/MIKRO/mikro_ctrl -n 1 -c m", rootdir, positX, rootdir);
		1415	#if WORKSTAT == 'I'
		1416	retTemp = system(cmd);
		1417	#else
		1418	printf("Cmd: %s\n",cmd);
		1419	#endif
		1420
		1421	sprintf(cmd, "sudo %s/MIKRO/mikro_ctrl -n 2 -v %d -s la && %s/MIKRO/mikro_ctrl -n 2 -c m", rootdir, positY, rootdir);
		1422	#if WORKSTAT == 'I'
		1423	retTemp = system(cmd);
		1424	#else
		1425	printf("Cmd: %s\n",cmd);
		1426	#endif
		1427
		1428	sprintf(cmd, "sudo %s/MIKRO/mikro_ctrl -n 3 -v %d -s la && %s/MIKRO/mikro_ctrl -n 3 -c m", rootdir, positZ, rootdir);
		1429	#if WORKSTAT == 'I'
		1430	retTemp = system(cmd);
		1431	#else
		1432	printf("Cmd: %s\n",cmd);
		1433	#endif
		1434	}
		1435
		1436	// Set the current table position to a predetermined HOME position
		1437	void TGAppMainFrame::HomePosition()
		1438	{
		1439	char cmd[256];
		1440
		1441	sprintf(cmd, "sudo %s/MIKRO/mikro_ctrl -n 1 -h", rootdir); // X-axis
		1442	#if WORKSTAT == 'I'
		1443	retTemp = system(cmd);
		1444	#else
		1445	printf("Cmd: %s\n",cmd);
		1446	#endif
		1447
		1448	sprintf(cmd, "sudo %s/MIKRO/mikro_ctrl -n 2 -h", rootdir); // Y-axis
		1449	#if WORKSTAT == 'I'
		1450	retTemp = system(cmd);
		1451	#else
		1452	printf("Cmd: %s\n",cmd);
		1453	#endif
		1454
		1455	sprintf(cmd, "sudo %s/MIKRO/mikro_ctrl -n 3 -h", rootdir); // Z-axis
		1456	#if WORKSTAT == 'I'
		1457	retTemp = system(cmd);
		1458	#else
		1459	printf("Cmd: %s\n",cmd);
		1460	#endif
		1461	}
		1462
		1463	// Initialize the currently connected scope for measurements
		1464	void TGAppMainFrame::InitializeScope()
		1465	{
		1466	int iTemp;
		1467	int chTemp[8];
		1468	for(int i = 0; i < 8; i++) chTemp[i] = -1;
		1469	gScopeDaq->scopeUseType = sMeasType->GetSelected();
		1470
		1471	// Check what channels are selected
		1472	iTemp = 0;
		1473	for(int i = 0; i < 8; i++)
		1474	{
		1475	if(sCH[i]->IsDown())
		1476	{
		1477	chTemp[iTemp] = i;
		1478	iTemp++;
		1479	}
		1480	}
		1481	if(iTemp == 0)
		1482	{
		1483	// If no channel is selected, we select the first one
		1484	chTemp[0] = 0;
		1485	iTemp++;
		1486	sCH[0]->SetState(kButtonDown);
		1487	}
		1488	// If measurement is used, only use the first selected channel
		1489	if(gScopeDaq->scopeUseType == 2)
		1490	{
		1491	for(int i = 1; i < iTemp; i++)
		1492	sCH[chTemp[i]]->SetState(kButtonUp);
		1493	iTemp = 1;
		1494	}
		1495
		1496	gScopeDaq->scopeChanNr = iTemp;
		1497	for(int i = 0; i < 8; i++) gScopeDaq->scopeChans[i] = chTemp[i];
		1498
		1499	// Check which measurement is selected
		1500	gScopeDaq->scopeMeasSel = sMeasgroup->GetSelected();
		1501
		1502	gScopeDaq->init();
		1503	}
		1504
		1505	// Run a scope measurement
		1506	void TGAppMainFrame::StartScopeAcq()
		1507	{
		1508	// Lock the scope front panel
		1509	gScopeDaq->lockunlock(true);
		1510
		1511	retTemp = gScopeDaq->event();
		1512
		1513	if(gScopeDaq->scopeUseType == 1)
		1514	{
		1515	char len[16];
		1516	int sval;
		1517	short *spoints;
		1518
		1519	if(retTemp == 0)
		1520	{
		1521	// Read the number of y bytes at beginning of CURVE binary data
		1522	memcpy(len, &gScopeDaq->eventbuf[1],1);
		1523	len[1] = 0;
		1524	sval = atoi(len);
		1525	// printf("Number of y bytes = %d\n", sval);
		1526
		1527	// Read the data
		1528	spoints = (short *)(&gScopeDaq->eventbuf[2+sval]);
		1529
		1530	// Read the number of data points
		1531	memcpy(len, &gScopeDaq->eventbuf[2],sval);
		1532	len[sval] = 0;
		1533	sval = atoi(len);
		1534	// printf("Number of data points = %d\n", sval/2);
		1535
		1536	double grafx, grafy;
		1537	grafx = new double[sval/2];
		1538	grafy = new double[sval/2];
		1539	// Parse data and graph it
		1540	for(int i = 0; i < sval/2; i++)
		1541	{
		1542	grafx[i] = igScopeDaq->tektime10./(sval/2.);
		1543	grafy[i] = ((double)spoints[i]5.gScopeDaq->tekvolt/32767.) - (gScopeDaq->choffset*gScopeDaq->tekvolt);
		1544	}
		1545
		1546	wCanvas->cd();
		1547	testgraph = new TGraph(sval/2, grafx, grafy);
		1548	testgraph->GetXaxis()->SetTitle("Time [s]");
		1549	testgraph->GetXaxis()->SetRangeUser(grafx[0], grafx[(sval/2)-1]);
		1550	testgraph->GetYaxis()->SetTitle("Voltage [V]");
		1551	testgraph->Draw("AL");
		1552	wCanvas->Modified();
		1553	wCanvas->Update();
		1554
		1555	delete[] grafx;
		1556	delete[] grafy;
		1557	}
		1558	}
		1559	else if(gScopeDaq->scopeUseType == 2)
		1560	{
		1561	if(retTemp == 0)
		1562	{
		1563	if(gScopeDaq->measubuf < 1.e-4)
		1564	printf("Measurement: %le\n", gScopeDaq->measubuf);
		1565	else
		1566	printf("Measurement: %lf\n", gScopeDaq->measubuf);
		1567	}
		1568	}
		1569
		1570	// Unlock the scope front panel
		1571	gScopeDaq->lockunlock(false);
		1572	}
		1573
		1574	// Send a custom command to the scope
		1575	void TGAppMainFrame::CustomScopeCommand()
		1576	{
		1577	char cmd = (char)scopeCommand->GetText();
		1578	char ret[100000];
		1579	if( strchr(cmd, '?') == NULL)
		1580	{
		1581	printf("Sending command: %s\n", cmd);
		1582	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'
		1583	gScopeDaq->customCommand(cmd, false, ret);
		1584	#endif
		1585	}
		1586	else
		1587	{
		1588	printf("Sending query: %s\n", cmd);
		1589	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'
		1590	gScopeDaq->customCommand(cmd, true, ret);
		1591	#endif
		1592	}
		1593
		1594	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'
		1595	scopeReturn->SetText(ret);
		1596	#endif
		1597
		1598	#if WORKSTAT == 'O'
		1599	sprintf(ret, "Program running in offline mode. Use I or S when configuring...");
		1600	scopeReturn->SetText(ret);
		1601	#endif
		1602	}
		1603
		1604	// When we select the measurement type, change other scope settings accordingly
		1605	void TGAppMainFrame::SelectedMeasType(int mtype)
		1606	{
		1607	// No waveform analysis
		1608	if(mtype == 0)
		1609	{
		1610	for(int i = 0; i < 8; i++)
		1611	{
		1612	sCH[i]->SetState(kButtonUp);
		1613	sCH[i]->SetEnabled(kFALSE);
		1614	}
		1615	sMeasType->SetEnabled(kTRUE);
		1616	sCamaclink->SetState(kButtonUp);
		1617	sCamaclink->SetEnabled(kFALSE);
		1618	scopeCommand->SetEnabled(kTRUE);
		1619	sendScopeCustom->SetEnabled(kTRUE);
		1620	sMeasgroup->SetEnabled(kFALSE);
		1621	scopeInit->SetEnabled(kFALSE);
		1622
		1623	oscOn = 1;
		1624	}
		1625	// Complete waveform acquisition
		1626	else if(mtype == 1)
		1627	{
		1628	for(int i = 0; i < 8; i++)
		1629	sCH[i]->SetEnabled(kTRUE);
		1630	sMeasType->SetEnabled(kTRUE);
		1631	sCamaclink->SetState(kButtonDown);
		1632	sCamaclink->SetEnabled(kTRUE);
		1633	scopeCommand->SetEnabled(kTRUE);
		1634	sendScopeCustom->SetEnabled(kTRUE);
		1635	sMeasgroup->SetEnabled(kFALSE);
		1636	scopeInit->SetEnabled(kTRUE);
		1637
		1638	oscOn = 2;
		1639	}
		1640	// Waveform measurements
		1641	else if(mtype == 2)
		1642	{
		1643	for(int i = 0; i < 8; i++)
		1644	sCH[i]->SetEnabled(kTRUE);
		1645	sMeasType->SetEnabled(kTRUE);
		1646	sCamaclink->SetState(kButtonUp);
		1647	sCamaclink->SetEnabled(kTRUE);
		1648	scopeCommand->SetEnabled(kTRUE);
		1649	sendScopeCustom->SetEnabled(kTRUE);
		1650	sMeasgroup->SetEnabled(kTRUE);
		1651	scopeInit->SetEnabled(kTRUE);
		1652
		1653	oscOn = 3;
		1654	}
		1655	}
		1656
		1657	// Make breakdown voltage plot
		1658	void TGAppMainFrame::MakeBreakdownPlot(int nrp, double volt, double volterr, double psep1, double pseperr1, double psep2, double pseperr2, double psep3, double pseperr3, char *plotfile, int separations)
		1659	{
		1660	double fparam[2], fparamerr[2], meanval;
		1661	TLatex *latex;
		1662	char ctemp[256];
		1663	int sortindex[nrp];
		1664
		1665	TCanvas *canvas;
		1666
		1667	if(separations == 1)
		1668	{
		1669	canvas = new TCanvas("canv","canv",900,400);
		1670	}
		1671	else if(separations == 2)
		1672	{
		1673	canvas = new TCanvas("canv","canv",900,800);
		1674	canvas->Divide(1,2);
		1675	}
		1676	else
		1677	{
		1678	canvas = new TCanvas("canv","canv",900,1200);
		1679	canvas->Divide(1,3);
		1680	}
		1681
		1682	// First graph is plotted always
		1683	TGraphErrors *gr1 = new TGraphErrors(nrp, volt, psep1, volterr, pseperr1);
		1684
		1685	if(!cleanPlots)
		1686	gr1->SetTitle("1st - 2nd peak separation");
		1687	else
		1688	gr1->SetTitle();
		1689	gr1->SetLineColor(kBlue);
		1690	gr1->SetMarkerColor(kBlue);
		1691	gr1->SetMarkerStyle(20);
		1692	gr1->SetMarkerSize(0.4);
		1693
		1694	// Plotting the first breakdown voltage plot
		1695	canvas->cd(1);
		1696	gPad->SetGridx(1);
		1697	gPad->SetGridy(1);
		1698
		1699	gr1->Draw("AP");
		1700	gr1->GetXaxis()->SetTitle("Bias voltage (V)");
		1701	gr1->GetYaxis()->SetTitle("Peak separation");
		1702	gr1->GetYaxis()->CenterTitle();
		1703	gr1->Fit("pol1","Q");
		1704
		1705	TF1 *fit1 = gr1->GetFunction("pol1");
		1706	fparam[0] = fit1->GetParameter(0);
		1707	fparamerr[0] = fit1->GetParError(0);
		1708	fparam[1] = fit1->GetParameter(1);
		1709	fparamerr[1] = fit1->GetParError(1);
		1710
		1711	TMath::Sort(nrp, psep1, sortindex, kFALSE);
		1712
		1713	meanval = -fparam[0]/fparam[1];
		1714	if(!cleanPlots)
		1715	{
		1716	sprintf(ctemp, "#splitline{#Delta_{p}(U) = (%.2lf #pm %.2lf)#timesU + (%.2lf #pm %.3lf)}{U_{0} = %.2lf #pm %.3lf}", fparam[0], fparamerr[0], fparam[1], fparamerr[1], meanval, meanval*(TMath::Abs(fparamerr[0]/fparam[0]) + TMath::Abs(fparamerr[1]/fparam[1])) );
		1717	latex = new TLatex();
		1718	latex->SetTextSize(0.039);
		1719	latex->DrawLatex(volt[0], 0.97*psep1[sortindex[nrp-1]], ctemp);
		1720	}
		1721	else
		1722	printf("#Delta_p(U) = (%.2lf #pm %.2lf)U + (%.2lf #pm %.3lf)\nU_0 = %.2lf #pm %.3lf", fparam[0], fparamerr[0], fparam[1], fparamerr[1], meanval, meanval(TMath::Abs(fparamerr[0]/fparam[0]) + TMath::Abs(fparamerr[1]/fparam[1])) );
		1723
		1724	// Second graph
		1725	if(separations > 1)
		1726	{
		1727	TGraphErrors *gr2 = new TGraphErrors(nrp, volt, psep2, volterr, pseperr2);
		1728
		1729	if(!cleanPlots)
		1730	gr2->SetTitle("2nd - 3rd peak separation");
		1731	else
		1732	gr2->SetTitle();
		1733	gr2->SetLineColor(kMagenta);
		1734	gr2->SetMarkerColor(kMagenta);
		1735	gr2->SetMarkerStyle(21);
		1736	gr2->SetMarkerSize(0.4);
		1737
		1738	// Plotting the second breakdown voltage plot
		1739	canvas->cd(2);
		1740	gPad->SetGridx(1);
		1741	gPad->SetGridy(1);
		1742
		1743	gr2->Draw("AP");
		1744	gr2->GetXaxis()->SetTitle("Bias voltage (V)");
		1745	gr2->GetYaxis()->SetTitle("Peak separation");
		1746	gr2->GetYaxis()->CenterTitle();
		1747	gr2->Fit("pol1","Q");
		1748
		1749	TF1 *fit2 = gr2->GetFunction("pol1");
		1750	fparam[0] = fit2->GetParameter(0);
		1751	fparamerr[0] = fit2->GetParError(0);
		1752	fparam[1] = fit2->GetParameter(1);
		1753	fparamerr[1] = fit2->GetParError(1);
		1754
		1755	meanval = -fparam[0]/fparam[1];
		1756	if(!cleanPlots)
		1757	{
		1758	sprintf(ctemp, "#splitline{#Delta_{p}(U) = (%.2lf #pm %.2lf)#timesU + (%.2lf #pm %.3lf)}{U_{0} = %.2lf #pm %.3lf}", fparam[0], fparamerr[0], fparam[1], fparamerr[1], meanval, meanval*(TMath::Abs(fparamerr[0]/fparam[0]) + TMath::Abs(fparamerr[1]/fparam[1])) );
		1759	latex = new TLatex();
		1760	latex->SetTextSize(0.039);
		1761	latex->DrawLatex(volt[0], 0.97*psep2[sortindex[nrp-1]], ctemp);
		1762	}
		1763	else
		1764	printf("#Delta_p(U) = (%.2lf #pm %.2lf)U + (%.2lf #pm %.3lf)\nU_0 = %.2lf #pm %.3lf", fparam[0], fparamerr[0], fparam[1], fparamerr[1], meanval, meanval(TMath::Abs(fparamerr[0]/fparam[0]) + TMath::Abs(fparamerr[1]/fparam[1])) );
		1765	}
		1766
		1767	// Third graph
		1768	if(separations > 2)
		1769	{
		1770	TGraphErrors *gr3 = new TGraphErrors(nrp, volt, psep3, volterr, pseperr3);
		1771
		1772	if(!cleanPlots)
		1773	gr3->SetTitle("3rd - 4th peak separation");
		1774	else
		1775	gr3->SetTitle();
		1776	gr3->SetLineColor(kGreen);
		1777	gr3->SetMarkerColor(kGreen);
		1778	gr3->SetMarkerStyle(22);
		1779	gr3->SetMarkerSize(0.4);
		1780
		1781	// Plotting the third breakdown voltage plot
		1782	canvas->cd(3);
		1783	gPad->SetGridx(1);
		1784	gPad->SetGridy(1);
		1785
		1786	gr3->Draw("AP");
		1787	gr3->GetXaxis()->SetTitle("Bias voltage (V)");
		1788	gr3->GetYaxis()->SetTitle("Peak separation");
		1789	gr3->GetYaxis()->CenterTitle();
		1790	gr3->Fit("pol1","Q");
		1791
		1792	TF1 *fit3 = gr3->GetFunction("pol1");
		1793	fparam[0] = fit3->GetParameter(0);
		1794	fparamerr[0] = fit3->GetParError(0);
		1795	fparam[1] = fit3->GetParameter(1);
		1796	fparamerr[1] = fit3->GetParError(1);
		1797
		1798	meanval = -fparam[0]/fparam[1];
		1799	if(!cleanPlots)
		1800	{
		1801	sprintf(ctemp, "#splitline{#Delta_{p}(U) = (%.2lf #pm %.2lf)#timesU + (%.2lf #pm %.3lf)}{U_{0} = %.2lf #pm %.3lf}", fparam[0], fparamerr[0], fparam[1], fparamerr[1], meanval, meanval*(TMath::Abs(fparamerr[0]/fparam[0]) + TMath::Abs(fparamerr[1]/fparam[1])) );
		1802	latex = new TLatex();
		1803	latex->SetTextSize(0.039);
		1804	latex->DrawLatex(volt[0], 0.97*psep3[sortindex[nrp-1]], ctemp);
		1805	}
		1806	else
		1807	printf("#Delta_p(U) = (%.2lf #pm %.2lf)U + (%.2lf #pm %.3lf)\nU_0 = %.2lf #pm %.3lf", fparam[0], fparamerr[0], fparam[1], fparamerr[1], meanval, meanval(TMath::Abs(fparamerr[0]/fparam[0]) + TMath::Abs(fparamerr[1]/fparam[1])) );
		1808	}
		1809
		1810	// Saving the produced plot
		1811	canvas->SaveAs(plotfile);
		1812	}
		1813
		1814	// Fit the ADC spectrum peaks and make a breakdown voltage plot
		1815	void TGAppMainFrame::FitSpectrum(TList *files, int q)
		1816	{
		1817	TCanvas *gCanvas = histCanvas->GetCanvas();
		1818	gCanvas->cd();
		1819	TH1F *histtemp;
		1820	TSpectrum *spec;
		1821	TH1 *histback;
		1822	TH1F *h2;
		1823	float *xpeaks;
		1824	TF1 *fit;
		1825	TF1 *fittingfunc;
		1826	double *fparam;
		1827	double *fparamerr;
		1828	double meanparam[20], meanparamerr[20];
		1829	int sortindex[20];
		1830	char exportname[256];
		1831	char paramname[256];
		1832	char ctemp[256];
		1833
		1834	FILE *fp;
		1835	remove_from_last((char*)files->At(0)->GetTitle(), '_', ctemp);
		1836	sprintf(paramname, "%s_fitresult.txt", ctemp);
		1837	fp = fopen(paramname, "w");
		1838	fclose(fp);
		1839
		1840	int peaklimit = minPeak->GetNumber()+1; // +1 to account for the pedestal peak
		1841	printf("The minimum peak limit is set to: %d\n", peaklimit);
		1842	int p = 0;
		1843	double dtemp;
		1844	double volt[files->GetSize()], volterr[files->GetSize()], sep[3][files->GetSize()], seperr[3][files->GetSize()];
		1845	int first = 1;
		1846
		1847	// Initialize all values
		1848	for(int m = 0; m < files->GetSize(); m++)
		1849	{
		1850	volt[m] = 0; volterr[m] = 0;
		1851	for(int i = 0; i < 3; i++)
		1852	{ sep[i][m] = 0; seperr[i][m] = 0; }
		1853	if(m < 20) { meanparam[m] = 0; meanparamerr[m] = 0; }
		1854	}
		1855
		1856	for(int m = 0; m < files->GetSize(); m++)
		1857	{
		1858	DisplayHistogram( (char*)(files->At(m)->GetTitle()), 0);
		1859	dtemp = evtheader.biasvolt;
		1860	gCanvas->Modified();
		1861	gCanvas->Update();
		1862
		1863	histtemp = (TH1F*)gCanvas->GetPrimitive(histname);
		1864	npeaks = 20;
		1865	double par[3000];
		1866	spec = new TSpectrum(npeaks);
		1867	// Find spectrum background
		1868	histback = spec->Background(histtemp, (int)fitInter->GetNumber(), "same");
		1869	// Clone histogram and subtract background from it
		1870	h2 = (TH1F*)histtemp->Clone("h2");
		1871	h2->Add(histback, -1);
		1872	// Search for the peaks
		1873	int found = spec->Search(h2, fitSigma->GetNumber(), "goff", fitTresh->GetNumber() );
		1874	printf("Found %d candidates to fit.\n",found);
		1875	npeaks = found;
		1876
		1877	xpeaks = spec->GetPositionX();
		1878	for(int i = 0; i < found; i++)
		1879	{
		1880	float xp = xpeaks[i];
		1881	int bin = h2->GetXaxis()->FindBin(xp);
		1882	float yp = h2->GetBinContent(bin);
		1883	par[3*i] = yp;
		1884	par[3*i+1] = xp;
		1885	par[3*i+2] = (double)fitSigma->GetNumber();
		1886	}
		1887
		1888	// Fit the histogram
		1889	fit = new TF1("fit", FindPeaks, 0, 400, 3*npeaks);
		1890	TVirtualFitter::Fitter(histtemp, 3*npeaks);
		1891	fit->SetParameters(par);
		1892	fit->SetNpx(300);
		1893	h2->Fit("fit","Q"); // for quiet mode, add Q
		1894	fittingfunc = h2->GetFunction("fit");
		1895	fparam = fittingfunc->GetParameters();
		1896	fparamerr = fittingfunc->GetParErrors();
		1897
		1898	// Gather the parameters (mean peak value for now)
		1899	int j = 1;
		1900	int nrfit = 0;
		1901	bool errors = false;
		1902	while(1)
		1903	{
		1904	if( (fparam[j] < 1.E-30) \|\| (fparamerr[j] < 1.E-10) )
		1905	break;
		1906	else
		1907	{
		1908	if(fparam[j] > pedesLow->GetNumber())
		1909	{
		1910	meanparam[nrfit] = fparam[j];
		1911	meanparamerr[nrfit] = fparamerr[j];
		1912	nrfit++;
		1913	}
		1914	}
		1915
		1916	j+=3;
		1917	}
		1918	printf("%d peaks fitted.\n",nrfit);
		1919
		1920	if(nrfit >= peaklimit)
		1921	{
		1922	TMath::Sort(nrfit, meanparam, sortindex, kFALSE);
		1923
		1924	// Write out parameters to a file
		1925	// fp = fopen(paramname, "a");
		1926
		1927	// Only save the ones that do not have a too large error on peak separation for the first three peaks
		1928	// if( ((TMath::Abs(meanparamerr[sortindex[2]]) + TMath::Abs(meanparamerr[sortindex[1]]))/(meanparam[sortindex[2]] - meanparam[sortindex[1]]) < accError->GetNumber()) && ((TMath::Abs(meanparamerr[sortindex[3]]) + TMath::Abs(meanparamerr[sortindex[2]]))/(meanparam[sortindex[3]] - meanparam[sortindex[2]]) < accError->GetNumber()) && ((TMath::Abs(meanparamerr[sortindex[4]]) + TMath::Abs(meanparamerr[sortindex[3]]))/(meanparam[sortindex[4]] - meanparam[sortindex[3]]) < accError->GetNumber()) )
		1929	// if( (seperr[0][0]/sep[0][0] < accError->GetNumber()) && (seperr[1][0]/sep[1][0] < accError->GetNumber()) && (seperr[2][0]/sep[2][0] < accError->GetNumber()) )
		1930	// {
		1931	// fprintf(fp, "%le\t%d\t", dtemp, nrfit);
		1932
		1933	// for(int i = 0; i < nrfit; i++)
		1934	// {
		1935	// if(debug)
		1936	// printf("Peak %d (%lfV): %lf\t%lf\n", i+1, dtemp, meanparam[sortindex[i]], meanparamerr[sortindex[i]]);
		1937	// fprintf(fp, "%le\t%le\t", meanparam[sortindex[i]], meanparamerr[sortindex[i]]);
		1938	// }
		1939	// printf("\n");
		1940	// fprintf(fp, "\n");
		1941	// }
		1942
		1943	// fclose(fp);
		1944
		1945	h2->SetStats(0);
		1946
		1947	gCanvas->Modified();
		1948	gCanvas->Update();
		1949
		1950	// Save each fitting plot
		1951	if(exfitplots->IsDown())
		1952	{
		1953	remove_ext((char*)files->At(m)->GetTitle(), ctemp);
		1954	sprintf(exportname, "%s_fit.pdf", ctemp);
		1955	gCanvas->SaveAs(exportname);
		1956	}
		1957
		1958	volt[p] = dtemp;
		1959	volterr[p] = 1.e-4;
		1960
		1961	if(nrfit == 3)
		1962	{
		1963	sep[0][p] = meanparam[sortindex[2]] - meanparam[sortindex[1]];
		1964	seperr[0][p] = TMath::Abs(meanparamerr[sortindex[2]]) + TMath::Abs(meanparamerr[sortindex[1]]);
		1965
		1966	errors = (seperr[0][p]/sep[0][p] < accError->GetNumber());
		1967
		1968	if(debug)
		1969	printf("p=%d:\t%lf\t%lf\t%lf\n", p, volt[p], sep[0][p], seperr[0][p]);
		1970	}
		1971	else if(nrfit == 4)
		1972	{
		1973	sep[0][p] = meanparam[sortindex[2]] - meanparam[sortindex[1]];
		1974	sep[1][p] = meanparam[sortindex[3]] - meanparam[sortindex[2]];
		1975	seperr[0][p] = TMath::Abs(meanparamerr[sortindex[2]]) + TMath::Abs(meanparamerr[sortindex[1]]);
		1976	seperr[1][p] = TMath::Abs(meanparamerr[sortindex[3]]) + TMath::Abs(meanparamerr[sortindex[2]]);
		1977
		1978	errors = ((seperr[0][p]/sep[0][p] < accError->GetNumber()) && (seperr[1][p]/sep[1][p] < accError->GetNumber()));
		1979
		1980	if(debug)
		1981	printf("p=%d:\t%lf\t%lf\t%lf\t%lf\t%lf\n", p, volt[p], sep[0][p], seperr[0][p], sep[1][p], seperr[1][p]);
		1982	}
		1983	else if(nrfit > 4)
		1984	{
		1985	sep[0][p] = meanparam[sortindex[2]] - meanparam[sortindex[1]];
		1986	sep[1][p] = meanparam[sortindex[3]] - meanparam[sortindex[2]];
		1987	sep[2][p] = meanparam[sortindex[4]] - meanparam[sortindex[3]];
		1988	seperr[0][p] = TMath::Abs(meanparamerr[sortindex[2]]) + TMath::Abs(meanparamerr[sortindex[1]]);
		1989	seperr[1][p] = TMath::Abs(meanparamerr[sortindex[3]]) + TMath::Abs(meanparamerr[sortindex[2]]);
		1990	seperr[2][p] = TMath::Abs(meanparamerr[sortindex[4]]) + TMath::Abs(meanparamerr[sortindex[3]]);
		1991
		1992	errors = ((seperr[0][p]/sep[0][p] < accError->GetNumber()) && (seperr[1][p]/sep[1][p] < accError->GetNumber()) && (seperr[2][p]/sep[2][p] < accError->GetNumber()));
		1993
		1994	if(debug)
		1995	printf("p=%d:\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n", p, volt[p], sep[0][p], seperr[0][p], sep[1][p], seperr[1][p], sep[2][p], seperr[2][p]);
		1996	}
		1997
		1998	// Write out parameters to a file
		1999	fp = fopen(paramname, "a");
		2000
		2001	// Accept only the points with a small enough error
		2002	if( errors )
		2003	{
		2004	if(first == 1)
		2005	{
		2006	fprintf(fp, "%le\t%d\t", dtemp, nrfit);
		2007
		2008	for(int i = 0; i < nrfit; i++)
		2009	{
		2010	if(debug)
		2011	printf("Peak %d (%lfV): %lf\t%lf\n", i+1, dtemp, meanparam[sortindex[i]], meanparamerr[sortindex[i]]);
		2012	fprintf(fp, "%le\t%le\t", meanparam[sortindex[i]], meanparamerr[sortindex[i]]);
		2013	}
		2014	printf("\n");
		2015	fprintf(fp, "\n");
		2016	first = 0;
		2017	}
		2018
		2019	p++;
		2020	}
		2021	else
		2022	{
		2023	if(nrfit == 3)
		2024	printf("Point (at %.2lfV) rejected due to too large errors: %lf\n", volt[p], seperr[0][p]/sep[0][p]);
		2025	else if(nrfit == 4)
		2026	printf("Point (at %.2lfV) rejected due to too large errors: %lf, %lf\n", volt[p], seperr[0][p]/sep[0][p], seperr[1][p]/sep[1][p]);
		2027	else if(nrfit > 4)
		2028	printf("Point (at %.2lfV) rejected due to too large errors: %lf, %lf, %lf\n", volt[p], seperr[0][p]/sep[0][p], seperr[1][p]/sep[1][p], seperr[2][p]/sep[2][p]);
		2029	}
		2030
		2031	fclose(fp);
		2032	}
		2033
		2034	if(q == 1) break;
		2035
		2036	first = 1;
		2037	}
		2038
		2039	// Plot & fit breakdown voltage plots
		2040	if(q > 1)
		2041	{
		2042	remove_from_last((char*)files->At(0)->GetTitle(), '_', ctemp);
		2043	sprintf(paramname, "%s_breakdown.pdf", ctemp);
		2044	MakeBreakdownPlot(p, volt, volterr, sep[0], seperr[0], sep[1], seperr[1], sep[2], seperr[2], paramname, peaklimit-2);
		2045	}
		2046	}
		2047
		2048	// Plotting of PDF and CDF functions for the edge (with the added fit)
		2049	void TGAppMainFrame::EdgeDetection(TGraph pdf, TGraph cdf, char outname, TCanvas g1dCanvas, double pdfmax, int direction)
		2050	{
		2051	// double x, y;
		2052
		2053	pdf->Fit("gaus","Q");
		2054	pdf->GetFunction("gaus")->SetNpx(400);
		2055	/*
		2056	for(int i = 0; i < nrpoints; i++)
		2057	{
		2058	pdf->GetPoint(i, x, y);
		2059	pdf->SetPoint(i, x, (y/pdfmax) );
		2060	}
		2061	*/
		2062	gStyle->SetOptFit(1);
		2063
		2064	cdf->Draw("AL");
		2065	gPad->Update();
		2066	pdf->Draw("LP");
		2067
		2068	g1dCanvas->Modified();
		2069	g1dCanvas->Update();
		2070
		2071	TPaveStats stats = (TPaveStats)pdf->FindObject("stats");
		2072	if(!cleanPlots)
		2073	{
		2074	// stats->SetX1NDC(0.14); stats->SetX2NDC(0.28);
		2075	// stats->SetY1NDC(0.83); stats->SetY2NDC(0.96);
		2076	stats->SetX1NDC(0.86); stats->SetX2NDC(1.0);
		2077	stats->SetY1NDC(0.87); stats->SetY2NDC(1.0);
		2078	}
		2079	else
		2080	{
		2081	stats->SetX1NDC(1.1); stats->SetX2NDC(1.3);
		2082	stats->SetY1NDC(1.1); stats->SetY2NDC(1.3);
		2083	}
		2084
		2085	g1dCanvas->SetGridx(1);
		2086	g1dCanvas->SetGridy(1);
		2087	if(direction == 1)
		2088	cdf->GetXaxis()->SetTitle("X [#mum]");
		2089	else if(direction == 2)
		2090	cdf->GetXaxis()->SetTitle("Y [#mum]");
		2091	cdf->GetXaxis()->CenterTitle(kTRUE);
		2092	cdf->GetXaxis()->SetLabelSize(0.022);
		2093	cdf->GetYaxis()->SetTitle("Normalized ADC integral");
		2094	// cdf->GetYaxis()->SetTitle("Normalized ADC integral (CDF)");
		2095	// cdf->GetYaxis()->SetTitleColor(kBlue);
		2096	cdf->GetYaxis()->CenterTitle(kTRUE);
		2097	cdf->GetYaxis()->SetLabelSize(0.022);
		2098	cdf->GetYaxis()->SetRangeUser(0,1);
		2099	cdf->GetYaxis()->SetTitleSize(0.030);
		2100	// cdf->GetYaxis()->SetLabelColor(kBlue);
		2101	if(!cleanPlots)
		2102	cdf->SetTitle("SiPM edge detection");
		2103	else
		2104	cdf->SetTitle();
		2105	cdf->SetLineColor(kBlue);
		2106	pdf->SetLineWidth(2);
		2107	cdf->SetLineWidth(2);
		2108
		2109	/* TGaxis *axis = new TGaxis(gPad->GetUxmax(), 0, gPad->GetUxmax(), 1, 0, pdfmax, 510, "+L");
		2110	axis->Draw();
		2111	axis->SetTitle("Normalized ADC integral (PDF)");
		2112	axis->SetTitleSize(0.035);
		2113	axis->CenterTitle();
		2114	axis->SetTitleColor(kBlack);
		2115	axis->SetTitleFont(42);
		2116	axis->SetLabelSize(0.022);
		2117	axis->SetLabelColor(kBlack);*/
		2118
		2119	g1dCanvas->Modified();
		2120	g1dCanvas->Update();
		2121
		2122	g1dCanvas->SaveAs(outname);
		2123	}
		2124
		2125	// Integrate the spectrum
		2126	void TGAppMainFrame::IntegSpectrum(TList *files, int direction)
		2127	{
		2128	unsigned int nrfiles = fileList->GetNumberOfEntries();
		2129	char ctemp[256];
		2130	int j, k = 0, m = 0, n = 0;
		2131
		2132	TCanvas *gCanvas = new TCanvas("canv","canv",900,900);
		2133	TCanvas *g1dCanvas = new TCanvas("canv1d","canv1d",1200,900);
		2134	TTree header_data, meas_data;
		2135	double integralCount, integralAcc;
		2136	integralCount = new double[nrfiles];
		2137	integralAcc = new double[nrfiles];
		2138	// double xsurfmin, ysurfmin, zsurfmin;
		2139	double surfx, surfy, *surfz;
		2140	surfx = new double[nrfiles];
		2141	surfy = new double[nrfiles];
		2142	surfz = new double[nrfiles];
		2143	for(int i = 0; i < (int)nrfiles; i++) {integralCount[i] = 0; integralAcc[i] = 0; }
		2144
		2145	TGraph *gScan[2]; // graphs for PDF and CDF functions
		2146	double pdfmax = -1;
		2147	TGraph2D *gScan2D;
		2148	gScan2D = new TGraph2D();
		2149	int nrentries;
		2150	double minInteg, maxInteg;
		2151
		2152	char exportname[256];
		2153
		2154	if(files->GetSize() > 0)
		2155	{
		2156	for(int i = 0; i < (int)files->GetSize(); i++)
		2157	{
		2158	n++;
		2159	if(files->At(i))
		2160	{
		2161	sprintf(ctemp, "%s", files->At(i)->GetTitle());
		2162	inroot = new TFile(ctemp, "READ");
		2163
		2164	inroot->GetObject("header_data", header_data);
		2165	inroot->GetObject("meas_data", meas_data);
		2166
		2167	// Reading the header
		2168	header_data->SetBranchAddress("xpos", &evtheader.xpos);
		2169	header_data->GetEntry(0);
		2170	header_data->SetBranchAddress("ypos", &evtheader.ypos);
		2171	header_data->GetEntry(0);
		2172	header_data->SetBranchAddress("zpos", &evtheader.zpos);
		2173	header_data->GetEntry(0);
		2174
		2175	char rdc[256];
		2176	j = selectCh->GetNumber();
		2177	double rangetdc[2];
		2178	rangetdc[0] = tdcMinwindow->GetNumber();
		2179	rangetdc[1] = tdcMaxwindow->GetNumber();
		2180
		2181	k = 0;
		2182	m = 0;
		2183
		2184	// Reading the data
		2185	for(int e = 0; e < meas_data->GetEntries(); e++)
		2186	{
		2187	sprintf(rdc, "ADC%d", j);
		2188	meas_data->SetBranchAddress(rdc, &evtdata.adcdata[j]);
		2189	meas_data->GetEntry(e);
		2190
		2191	sprintf(rdc, "TDC%d", j);
		2192	meas_data->SetBranchAddress(rdc, &evtdata.tdcdata[j]);
		2193	meas_data->GetEntry(e);
		2194
		2195	// If our data point is inside the TDC window
		2196	if( ((double)evtdata.tdcdata[j]/tdctimeconversion >= rangetdc[0]) && ((double)evtdata.tdcdata[j]/tdctimeconversion <= rangetdc[1]) )
		2197	{
		2198	k++;
		2199	m += evtdata.adcdata[j];
		2200	}
		2201	}
		2202
		2203	/* if(n == 1) // these values can be used to set 0 value at first X, Y and Z positions
		2204	{
		2205	xsurfmin = evtheader.xpos;
		2206	ysurfmin = evtheader.ypos;
		2207	zsurfmin = evtheader.zpos;
		2208	}
		2209	surfx[i] = (double)(evtheader.xpos-xsurfmin)*lenconversion;
		2210	surfy[i] = (double)(evtheader.ypos-ysurfmin)*lenconversion;
		2211	surfz[i] = (double)(evtheader.zpos-zsurfmin)lenconversion;/
		2212	surfx[i] = (double)(evtheader.xpos*lenconversion);
		2213	surfy[i] = (double)(evtheader.ypos*lenconversion);
		2214	surfz[i] = (double)(evtheader.zpos*lenconversion);
		2215
		2216	/* surfx[i] = evtheader.xpos;
		2217	surfy[i] = evtheader.ypos;
		2218	surfz[i] = evtheader.zpos;
		2219	*/
		2220	integralCount[i] += ((double)m)/((double)k);
		2221
		2222	inroot->Close();
		2223	delete inroot;
		2224	}
		2225	}
		2226
		2227	nrentries = n;
		2228	printf("%d files were selected.\n", nrentries);
		2229
		2230	double curzval = surfz[0];
		2231	j = 0;
		2232	int acc = 0;
		2233	int zb;
		2234	for(int i = 0; i <= nrentries; i++)
		2235	{
		2236	if(acc == nrentries)
		2237	{
		2238	minInteg = TMath::MinElement(j, integralAcc);
		2239
		2240	for(int za = 0; za < j; za++)
		2241	integralAcc[za] = integralAcc[za] - minInteg;
		2242
		2243	maxInteg = TMath::MaxElement(j, integralAcc);
		2244
		2245	for(int za = 0; za < j; za++)
		2246	{
		2247	zb = i-j+za;
		2248	integralCount[zb] = integralAcc[za]/maxInteg;
		2249	if(debug)
		2250	printf("Integral check 2 (i=%d,j=%d,za=%d,z=%.2lf,zb=%d): %lf\t%lf\n", i, j, za, surfz[i-j], zb, integralCount[zb], integralAcc[za]/maxInteg);
		2251	}
		2252
		2253	// Plotting of PDF and CDF functions for the edge (with the added fit)
		2254	gScan[1] = new TGraph();
		2255	for(int za = 0; za < j; za++)
		2256	{
		2257	zb = i-j+za;
		2258	if(direction == 1)
		2259	gScan[1]->SetPoint(za, (double)surfx[zb], (double)integralAcc[za]/maxInteg);
		2260	else if(direction == 2)
		2261	gScan[1]->SetPoint(za, (double)surfy[zb], (double)integralAcc[za]/maxInteg);
		2262
		2263	if( ((integralAcc[za+1]-integralAcc[za])/maxInteg > pdfmax) && (za < j-1) )
		2264	pdfmax = (integralAcc[za+1]-integralAcc[za])/maxInteg;
		2265	}
		2266
		2267	pdfmax = (TMath::Ceil(pdfmax*10))/10.;
		2268
		2269	gScan[0] = new TGraph();
		2270	for(int za = j-1; za >= 0; za--)
		2271	{
		2272	zb = (i-1)-(j-1)+za;
		2273	if((integralAcc[za]-integralAcc[za-1])/(maxInteg) < 0)
		2274	{
		2275	if(direction == 1)
		2276	gScan[0]->SetPoint(za, (double)surfx[zb], 0);
		2277	else if(direction == 2)
		2278	gScan[0]->SetPoint(za, (double)surfy[zb], 0);
		2279	}
		2280	else
		2281	{
		2282	if(direction == 1)
		2283	gScan[0]->SetPoint(za, (double)surfx[zb], (integralAcc[za]-integralAcc[za-1])/(maxInteg));
		2284	else if(direction == 2)
		2285	gScan[0]->SetPoint(za, (double)surfy[zb], (integralAcc[za]-integralAcc[za-1])/(maxInteg));
		2286	// gScan[0]->SetPoint(za, (double)surfx[zb], (integralAcc[za]-integralAcc[za-1])/(pdfmax*maxInteg));
		2287	}
		2288	}
		2289
		2290	remove_from_last((char*)files->At(i-1)->GetTitle(), '_', ctemp);
		2291	sprintf(exportname, "%s_edge.pdf", ctemp);
		2292	EdgeDetection(gScan[0], gScan[1], exportname, g1dCanvas, pdfmax, direction);
		2293
		2294	// delete gScan[0];
		2295	// delete gScan[1];
		2296
		2297	i--;
		2298	pdfmax = 0;
		2299	break;
		2300	}
		2301	else
		2302	{
		2303	if(surfz[i] == curzval)
		2304	{
		2305	integralAcc[j] = integralCount[i];
		2306	if(debug)
		2307	printf("Integral check 1 (i=%d,j=%d,z=%.2lf): %lf\t%lf\n", i, j, surfz[i], integralCount[i], integralAcc[j]);
		2308	j++;
		2309	acc++;
		2310	}
		2311	else
		2312	{
		2313	minInteg = TMath::MinElement(j, integralAcc);
		2314
		2315	for(int za = 0; za < j; za++)
		2316	integralAcc[za] = integralAcc[za] - minInteg;
		2317
		2318	maxInteg = TMath::MaxElement(j, integralAcc);
		2319
		2320	for(int za = 0; za < j; za++)
		2321	{
		2322	zb = i-j+za;
		2323	integralCount[zb] = integralAcc[za]/maxInteg;
		2324	if(debug)
		2325	printf("Integral check 2 (i=%d,j=%d,za=%d,z=%.2lf,zb=%d): %lf\t%lf\n", i, j, za, surfz[i-j], zb, integralCount[zb], integralAcc[za]/maxInteg);
		2326	}
		2327
		2328	curzval = surfz[i];
		2329	i--;
		2330
		2331	// Plotting of PDF and CDF functions for the edge (with the added fit)
		2332	gScan[1] = new TGraph();
		2333	for(int za = 0; za < j; za++)
		2334	{
		2335	zb = i-(j-1)+za;
		2336	if(direction == 1)
		2337	gScan[1]->SetPoint(za, (double)surfx[zb], (double)integralAcc[za]/maxInteg);
		2338	else if(direction == 2)
		2339	gScan[1]->SetPoint(za, (double)surfy[zb], (double)integralAcc[za]/maxInteg);
		2340
		2341	if( ((integralAcc[za+1]-integralAcc[za])/maxInteg > pdfmax) && (za < j-1) )
		2342	pdfmax = (integralAcc[za+1]-integralAcc[za])/maxInteg;
		2343	}
		2344
		2345	pdfmax = (TMath::Ceil(pdfmax*10))/10.;
		2346
		2347	gScan[0] = new TGraph();
		2348	for(int za = j-1; za >= 0; za--)
		2349	{
		2350	zb = i-(j-1)+za;
		2351	if((integralAcc[za]-integralAcc[za-1])/(maxInteg) < 0)
		2352	{
		2353	if(direction == 1)
		2354	gScan[0]->SetPoint(za, (double)surfx[zb], 0);
		2355	else if(direction == 2)
		2356	gScan[0]->SetPoint(za, (double)surfy[zb], 0);
		2357	}
		2358	else
		2359	{
		2360	if(direction == 1)
		2361	gScan[0]->SetPoint(za, (double)surfx[zb], (integralAcc[za]-integralAcc[za-1])/(maxInteg));
		2362	else if(direction == 2)
		2363	gScan[0]->SetPoint(za, (double)surfy[zb], (integralAcc[za]-integralAcc[za-1])/(maxInteg));
		2364	// gScan[0]->SetPoint(za, (double)surfx[zb], (integralAcc[za]-integralAcc[za-1])/(pdfmax*maxInteg));
		2365	}
		2366	}
		2367
		2368	remove_from_last((char*)files->At(i)->GetTitle(), '_', ctemp);
		2369	sprintf(exportname, "%s_edge.pdf", ctemp);
		2370	EdgeDetection(gScan[0], gScan[1], exportname, g1dCanvas, pdfmax, direction);
		2371
		2372	delete gScan[0];
		2373	delete gScan[1];
		2374
		2375	j = 0;
		2376	pdfmax = 0;
		2377	}
		2378	}
		2379	}
		2380
		2381	// delete g1dCanvas;
		2382
		2383	double range[4];
		2384	if(direction == 1)
		2385	{
		2386	range[0] = TMath::MinElement(nrentries, surfx);
		2387	range[1] = TMath::MaxElement(nrentries, surfx);
		2388	}
		2389	else if(direction == 2)
		2390	{
		2391	range[0] = TMath::MinElement(nrentries, surfy);
		2392	range[1] = TMath::MaxElement(nrentries, surfy);
		2393	}
		2394	else
		2395	{
		2396	range[0] = TMath::MinElement(nrentries, surfx);
		2397	range[1] = TMath::MaxElement(nrentries, surfx);
		2398	}
		2399	range[2] = TMath::MinElement(nrentries, surfz);
		2400	range[3] = TMath::MaxElement(nrentries, surfz);
		2401
		2402	// Plotting of 2D edge plot
		2403	for(int i = 0; i < nrentries; i++)
		2404	{
		2405	if(direction == 1)
		2406	{
		2407	if(debug)
		2408	printf("%.2lf\t%.2lf\t%lf\n", surfx[i], surfz[i], integralCount[i]);
		2409	gScan2D->SetPoint(i, surfx[i], surfz[i], integralCount[i]);
		2410	}
		2411	else if(direction == 2)
		2412	{
		2413	if(debug)
		2414	printf("%.2lf\t%.2lf\t%lf\n", surfy[i], surfz[i], integralCount[i]);
		2415	gScan2D->SetPoint(i, surfy[i], surfz[i], integralCount[i]);
		2416	}
		2417	}
		2418
		2419	gCanvas->cd();
		2420	gStyle->SetPalette(1);
		2421	gScan2D->Draw("COLZ");
		2422
		2423	gCanvas->Modified();
		2424	gCanvas->Update();
		2425
		2426	if(direction == 1)
		2427	gScan2D->GetXaxis()->SetTitle("X [#mum]");
		2428	else if(direction == 2)
		2429	gScan2D->GetXaxis()->SetTitle("Y [#mum]");
		2430	gScan2D->GetXaxis()->CenterTitle(kTRUE);
		2431	gScan2D->GetXaxis()->SetLabelSize(0.022);
		2432	gScan2D->GetXaxis()->SetRangeUser(range[0], range[1]);
		2433	gScan2D->GetXaxis()->SetNoExponent();
		2434	gScan2D->GetYaxis()->SetTitle("Z [#mum]");
		2435	gScan2D->GetYaxis()->SetTitleOffset(1.3);
		2436	gScan2D->GetYaxis()->CenterTitle(kTRUE);
		2437	gScan2D->GetYaxis()->SetLabelSize(0.022);
		2438	gScan2D->GetYaxis()->SetRangeUser(range[2], range[3]);
		2439	TGaxis yax = (TGaxis)gScan2D->GetYaxis();
		2440	yax->SetMaxDigits(4);
		2441	if(!cleanPlots)
		2442	gScan2D->SetTitle("Laser focal point");
		2443	else
		2444	gScan2D->SetTitle();
		2445
		2446	gCanvas->Modified();
		2447	gCanvas->Update();
		2448
		2449	remove_from_last((char*)files->At(0)->GetTitle(), '_', ctemp);
		2450	sprintf(exportname, "%s", ctemp);
		2451	remove_from_last(exportname, '_', ctemp);
		2452	if(direction == 1)
		2453	sprintf(exportname, "%s_xdir_focalpoint.pdf", ctemp);
		2454	else if(direction == 2)
		2455	sprintf(exportname, "%s_ydir_focalpoint.pdf", ctemp);
		2456	gCanvas->SaveAs(exportname);
		2457	}
		2458	}
		2459
		2460	// Integrate the spectrum
		2461	void TGAppMainFrame::PhotonMu(TList *files)
		2462	{
		2463	unsigned int nrfiles = fileList->GetNumberOfEntries();
		2464	char ctemp[256];
		2465	int j, k = 0, m = 0, n = 0, k2 = 0, m2 = 0;
		2466
		2467	TCanvas *gCanvas;
		2468	TTree header_data, meas_data;
		2469	double integralCount, integralPedestal;
		2470	integralCount = new double[nrfiles];
		2471	integralPedestal = new double[nrfiles];
		2472	double *angle;
		2473	double *pdeval;
		2474	double *muval;
		2475	angle = new double[nrfiles];
		2476	pdeval = new double[nrfiles];
		2477	muval = new double[nrfiles];
		2478	for(int i = 0; i < (int)nrfiles; i++) {integralCount[i] = 0; integralPedestal[i] = 0; }
		2479
		2480	// TGraph *gScan[2]; // graph for angle dependence
		2481	int nrentries;
		2482
		2483	TSpectrum *spec;
		2484	TH1F *histtemp;
		2485	TH1 *histback;
		2486	TH1F *h2;
		2487	float *xpeaks;
		2488	TF1 *fit;
		2489	TF1 *fittingfunc;
		2490	double *fparam;
		2491	double meanparam;
		2492	int adcpedestal[2];
		2493	double paramsigma = 0;
		2494
		2495	if(files->GetSize() > 0)
		2496	{
		2497	for(int i = 0; i < (int)files->GetSize(); i++)
		2498	{
		2499	n++;
		2500	if(files->At(i))
		2501	{
		2502	// Find the pedestal peak and the first minimum after pedestal ----------------
		2503	DisplayHistogram( (char*)(files->At(i)->GetTitle()), 0);
		2504	histCanvas->GetCanvas()->Modified();
		2505	histCanvas->GetCanvas()->Update();
		2506
		2507	histtemp = (TH1F*)histCanvas->GetCanvas()->GetPrimitive(histname);
		2508	npeaks = 1;
		2509	double par[300];
		2510	spec = new TSpectrum(npeaks);
		2511	// Find spectrum background
		2512	histback = spec->Background(histtemp, (int)fitInter->GetNumber(), "same");
		2513	// Clone histogram and subtract background from it
		2514	h2 = (TH1F*)histtemp->Clone("h2");
		2515	h2->Add(histback, -1);
		2516	// Search for the peaks
		2517	int found = spec->Search(h2, fitSigma->GetNumber(), "goff", fitTresh->GetNumber() );
		2518	printf("Found %d candidates to fit.\n",found);
		2519	npeaks = found;
		2520
		2521	xpeaks = spec->GetPositionX();
		2522	for(j = 0; j < found; j++)
		2523	{
		2524	float xp = xpeaks[j];
		2525	int bin = h2->GetXaxis()->FindBin(xp);
		2526	float yp = h2->GetBinContent(bin);
		2527	par[3*j] = yp;
		2528	par[3*j+1] = xp;
		2529	par[3*j+2] = (double)fitSigma->GetNumber();
		2530	}
		2531
		2532	// Fit the histogram
		2533	fit = new TF1("fit", FindPeaks, 0, 400, 3*npeaks);
		2534	TVirtualFitter::Fitter(histtemp, 3*npeaks);
		2535	fit->SetParameters(par);
		2536	fit->SetNpx(300);
		2537	h2->Fit("fit","Q"); // for quiet mode, add Q
		2538	fittingfunc = h2->GetFunction("fit");
		2539	fparam = fittingfunc->GetParameters();
		2540
		2541	// Gather the parameters (mean peak value for now)
		2542	j = 1;
		2543
		2544	meanparam = fparam[j];
		2545	paramsigma = fparam[j+1];
		2546
		2547	/* while(1)
		2548	{
		2549	if( (fparam[j] < 1.E-30) \|\| (fparamerr[j] < 1.E-10) )
		2550	break;
		2551	else
		2552	{
		2553	if(fparam[j] > 0)
		2554	{
		2555	meanparam = fparam[j];
		2556	meanparamerr = fparamerr[j];
		2557	paramsigma = fparam[j+1];
		2558	nrfit++;
		2559	}
		2560	}
		2561
		2562	j+=3;
		2563	}
		2564	*/
		2565	histCanvas->GetCanvas()->Modified();
		2566	histCanvas->GetCanvas()->Update();
		2567
		2568	j = 0;
		2569	adcpedestal[0] = 0;
		2570	adcpedestal[1] = -1;
		2571	while(1)
		2572	{
		2573	int bin = histtemp->GetXaxis()->FindBin((int)(j+meanparam+paramsigma));
		2574
		2575	int yp = histtemp->GetBinContent(bin);
		2576	if(adcpedestal[1] == -1)
		2577	{
		2578	adcpedestal[0] = j+meanparam+paramsigma;
		2579	adcpedestal[1] = yp;
		2580	}
		2581	else
		2582	{
		2583	if(adcpedestal[1] >= yp)
		2584	{
		2585	adcpedestal[0] = j+meanparam+paramsigma;
		2586	adcpedestal[1] = yp;
		2587	}
		2588	else
		2589	break;
		2590	}
		2591
		2592	j++;
		2593	if(j > 50) break;
		2594	}
		2595
		2596	cout << "Pedestal ends with ADC value: " << adcpedestal[0] << endl;
		2597
		2598	// ----------------------------------------------------------------------------
		2599
		2600	sprintf(ctemp, "%s", files->At(i)->GetTitle());
		2601	inroot = new TFile(ctemp, "READ");
		2602
		2603	inroot->GetObject("header_data", header_data);
		2604	inroot->GetObject("meas_data", meas_data);
		2605
		2606	// Reading the header
		2607	if( header_data->FindBranch("angle") )
		2608	{
		2609	header_data->SetBranchAddress("angle", &evtheader.angle);
		2610	header_data->GetEntry(0);
		2611	}
		2612	else
		2613	{
		2614	printf("Error! Selected file has no angle header value. Please edit header to add the angle header value.\n");
		2615	break;
		2616	}
		2617
		2618	char rdc[256];
		2619	j = selectCh->GetNumber();
		2620	double rangetdc[2];
		2621	rangetdc[0] = tdcMinwindow->GetNumber();
		2622	rangetdc[1] = tdcMaxwindow->GetNumber();
		2623
		2624	k = 0;
		2625	k2 = 0;
		2626	m = 0;
		2627	m2 = 0;
		2628
		2629	// Reading the data
		2630	for(int e = 0; e < meas_data->GetEntries(); e++)
		2631	{
		2632	sprintf(rdc, "ADC%d", j);
		2633	meas_data->SetBranchAddress(rdc, &evtdata.adcdata[j]);
		2634	meas_data->GetEntry(e);
		2635
		2636	sprintf(rdc, "TDC%d", j);
		2637	meas_data->SetBranchAddress(rdc, &evtdata.tdcdata[j]);
		2638	meas_data->GetEntry(e);
		2639
		2640	// If our data point is inside the TDC window
		2641	if( ((double)evtdata.tdcdata[j]/tdctimeconversion >= rangetdc[0]) && ((double)evtdata.tdcdata[j]/tdctimeconversion <= rangetdc[1]) )
		2642	{
		2643	// Gather only the integral of the pedestal
		2644	if((double)evtdata.adcdata[j] < (double)adcpedestal[0]+0.5 )
		2645	{
		2646	k2++;
		2647	m2 += evtdata.adcdata[j];
		2648	}
		2649
		2650	// Gather the complete integral
		2651	k++;
		2652	m += evtdata.adcdata[j];
		2653	}
		2654	}
		2655
		2656	angle[i] = (double)(evtheader.angle); // angle in radians
		2657
		2658	// integralCount[i] += ((double)m)/((double)k);
		2659	integralCount[i] += (double)m;
		2660	cout << "Integral (" << k << " evts) = " << integralCount[i] << endl;
		2661
		2662	integralPedestal[i] += (double)m2;
		2663	cout << "Integral (" << k2 << " evts) = " << integralPedestal[i] << endl;
		2664
		2665	muval[i] = -TMath::Log((double)k2/(double)k);
		2666
		2667	pdeval[i] = muval[i]/(muval[0]TMath::Cos(angle[i]TMath::ACos(-1.)/180.));
		2668
		2669	inroot->Close();
		2670	delete inroot;
		2671	}
		2672	}
		2673
		2674	nrentries = n;
		2675	printf("%d files were selected.\n", nrentries);
		2676
		2677	cout << "angle\tmu\trelative PDE\n" << endl;
		2678	for(int i = 0; i < (int)files->GetSize(); i++)
		2679	{
		2680	// Relative PDE calculation
		2681	cout << angle[i] << "\t" << muval[i] << "\t" << pdeval[i] << endl;
		2682	}
		2683
		2684	// Plot mu and PDE angle dependance plots
		2685	gCanvas = new TCanvas("canv","canv",1200,900);
		2686	gCanvas->SetGrid();
		2687
		2688	TGraph *pde = new TGraph(nrentries, angle, pdeval);
		2689	pde->SetMarkerStyle(21);
		2690	pde->SetMarkerSize(1.0);
		2691	pde->SetMarkerColor(2);
		2692	pde->SetLineWidth(2);
		2693	pde->SetLineColor(2);
		2694	pde->GetXaxis()->SetLabelSize(0.030);
		2695	pde->GetXaxis()->CenterTitle();
		2696	pde->GetXaxis()->SetRange(-5,90);
		2697	pde->GetXaxis()->SetRangeUser(-5,90);
		2698	pde->GetYaxis()->SetTitleOffset(1.2);
		2699	pde->GetYaxis()->SetLabelSize(0.030);
		2700	pde->GetYaxis()->CenterTitle();
		2701	pde->GetYaxis()->SetRangeUser(0.3, 1.18);
		2702	pde->Draw("ALP");
		2703
		2704	pde->SetTitle(";Incidence angle (#circ);Relative PDE(#theta) / #mu(#theta)");
		2705
		2706	TGraph *mugr = new TGraph(nrentries, angle, muval);
		2707	mugr->SetMarkerStyle(20);
		2708	mugr->SetMarkerSize(1.0);
		2709	mugr->SetMarkerColor(4);
		2710	mugr->SetLineWidth(2);
		2711	mugr->SetLineColor(4);
		2712	mugr->Draw("SAME;LP");
		2713
		2714	gCanvas->Modified();
		2715	gCanvas->Update();
		2716	}
		2717	}
		2718
		2719	void TGAppMainFrame::RunMeas(void *ptr, int runCase, int zaxisscan, int &scanon)
		2720	{
		2721	printf("Start of Run, run case %d\n", runCase);
		2722	float progVal;
		2723
		2724	char ctemp[256];
		2725	char ctemp2[256];
		2726	char fname[256];
		2727	int itemp = 0;
		2728
		2729	remove_ext((char*)fileName->GetText(), ctemp);
		2730	// printf("Save name: %s\nNo extension: %s\n", fileName->GetText(), ctemp);
		2731
		2732	// Open file for writing
		2733	/* if(runCase == 0)
		2734	{
		2735	sprintf(fname, "rm %s_%s", ctemp, histExtAll);
		2736	retTemp = system(fname);
		2737	}*/ // deleting might not be necesary due to RECREATE in root file open
		2738
		2739	if( voltscanOn->IsOn() \|\| surfscanOn->IsOn() )
		2740	{
		2741	if(zaxisscan == 0)
		2742	{
		2743	if( (voltscanOn->IsOn()) && (vOutStep->GetNumber() > 0.) )
		2744	SeqNumber(runCase, (int)((vOutStop->GetNumber())-(vOutStart->GetNumber()))/(vOutStep->GetNumber()), ctemp2);
		2745	else if( surfscanOn->IsOn() )
		2746	{
		2747	if( xPosStep->GetNumber() == 0 )
		2748	itemp = 1;
		2749	else
		2750	itemp = (int)((xPosMax->GetNumber())-(xPosMin->GetNumber()))/(xPosStep->GetNumber());
		2751
		2752	if( yPosStep->GetNumber() == 0 )
		2753	itemp *= 1;
		2754	else
		2755	itemp *= (int)((yPosMax->GetNumber())-(yPosMin->GetNumber()))/(yPosStep->GetNumber());
		2756	SeqNumber(runCase, itemp, ctemp2);
		2757	}
		2758	sprintf(fname, "%s_%s%s", ctemp, ctemp2, histExt);
		2759	}
		2760	else if(zaxisscan == 1)
		2761	{
		2762	SeqNumber((int)zPos->GetNumber(), (int)zPosMax->GetNumber(), ctemp2);
		2763
		2764	if( (voltscanOn->IsOn()) && (vOutStep->GetNumber() > 0.) )
		2765	{
		2766	sprintf(fname, "%s_z%s_", ctemp, ctemp2);
		2767	SeqNumber(runCase, (int)((vOutStop->GetNumber())-(vOutStart->GetNumber()))/(vOutStep->GetNumber())+1, ctemp2);
		2768	strcat(fname, ctemp2);
		2769	strcat(fname, histExt);
		2770	}
		2771	else if( surfscanOn->IsOn() )
		2772	{
		2773	sprintf(fname, "%s_z%s_", ctemp, ctemp2);
		2774
		2775	if( xPosStep->GetNumber() == 0 )
		2776	itemp = 1;
		2777	else
		2778	itemp = (int)((xPosMax->GetNumber())-(xPosMin->GetNumber()))/(xPosStep->GetNumber())+1;
		2779
		2780	if( yPosStep->GetNumber() == 0 )
		2781	itemp *= 1;
		2782	else
		2783	itemp *= (int)((yPosMax->GetNumber())-(yPosMin->GetNumber()))/(yPosStep->GetNumber())+1;
		2784	SeqNumber(runCase, itemp, ctemp2);
		2785	strcat(fname, ctemp2);
		2786	strcat(fname, histExt);
		2787	}
		2788	else
		2789	sprintf(fname, "%s_z%s%s", ctemp, ctemp2, histExt);
		2790
		2791	/* if(runCase < 10)
		2792	sprintf(fname, "%s_z%d_0000%d%s", ctemp, (int)zPos->GetNumber(), runCase, histExt);
		2793	else if( (runCase >= 10) && (runCase < 100) )
		2794	sprintf(fname, "%s_z%d_000%d%s", ctemp, (int)zPos->GetNumber(), runCase, histExt);
		2795	else if( (runCase >= 100) && (runCase < 1000) )
		2796	sprintf(fname, "%s_z%d_00%d%s", ctemp, (int)zPos->GetNumber(), runCase, histExt);
		2797	else if( (runCase >= 1000) && (runCase < 10000) )
		2798	sprintf(fname, "%s_z%d_0%d%s", ctemp, (int)zPos->GetNumber(), runCase, histExt);
		2799	else if( (runCase >= 10000) && (runCase < 100000) )
		2800	sprintf(fname, "%s_z%d_0%d%s", ctemp, (int)zPos->GetNumber(), runCase, histExt);
		2801	*/ }
		2802	}
		2803	else if( !voltscanOn->IsOn() && !surfscanOn->IsOn() )
		2804	sprintf(fname, "%s%s", ctemp, histExt);
		2805	// printf("Rootfile: %s\n", fname);
		2806
		2807	// Check if set voltage is below the hard limit
		2808	if( vOut->GetNumber() > vHardlimit->GetNumber() )
		2809	{
		2810	printf("Voltage hard limit triggered (%lf > %lf)!\n", vOut->GetNumber(), vHardlimit->GetNumber() );
		2811	vOut->SetNumber( vHardlimit->GetNumber() );
		2812	}
		2813
		2814	outroot = new TFile(fname, "RECREATE");
		2815
		2816	TTree *header_data = new TTree("header_data", "Header information for the measurement.");
		2817	TTree *meas_data = new TTree("meas_data", "Saved ADC and TDC measurement data.");
		2818	TTree *scope_data = new TTree("scope_data", "Saved scope measurement data.");
		2819
		2820	// Branches for the header
		2821	header_data->Branch("nrch", &evtheader.nrch, "nrch/I");
		2822	header_data->Branch("timestamp", &evtheader.timestamp, "timestamp/I");
		2823	header_data->Branch("biasvolt", &evtheader.biasvolt, "biasvolt/D");
		2824	header_data->Branch("xpos", &evtheader.xpos, "xpos/I");
		2825	header_data->Branch("ypos", &evtheader.ypos, "ypos/I");
		2826	header_data->Branch("zpos", &evtheader.zpos, "zpos/I");
		2827	header_data->Branch("temperature", &evtheader.temperature, "temperature/D");
		2828	header_data->Branch("laserinfo", &evtheader.laserinfo, "laserinfo/C");
		2829
		2830	evtheader.nrch = (int)NCH->GetNumber()*2;
		2831	evtheader.timestamp = (int)time(NULL);
		2832	evtheader.biasvolt = (double)vOut->GetNumber();
		2833	evtheader.xpos = (int)xPos->GetNumber();
		2834	evtheader.ypos = (int)yPos->GetNumber();
		2835	evtheader.zpos = (int)zPos->GetNumber();
		2836	evtheader.temperature = (double)chtemp->GetNumber();
		2837	evtheader.angle = (double)incangle->GetNumber();
		2838	sprintf(evtheader.laserinfo, "%s", laserInfo->GetText());
		2839
		2840	char histtime[256];
		2841	GetTime(evtheader.timestamp, histtime);
		2842
		2843	printf("Save file header information:\n");
		2844	printf("- Number of channels: %d\n", evtheader.nrch);
		2845	printf("- Timestamp: %d (%s)\n", evtheader.timestamp, histtime);
		2846	printf("- Bias voltage: %lf\n", evtheader.biasvolt);
		2847	printf("- Table position (X,Y,Z): %d, %d, %d\n", evtheader.xpos, evtheader.ypos, evtheader.zpos);
		2848	printf("- Temperature: %lf\n", evtheader.temperature);
		2849	printf("- Laser and filter settings: %s\n", evtheader.laserinfo);
		2850
		2851	header_data->Fill();
		2852
		2853	// Branches for ADC and TDC data
		2854	for(int i = 0; i < evtheader.nrch/2; i++)
		2855	{
		2856	sprintf(ctemp, "ADC%d", i);
		2857	sprintf(fname, "ADC%d/I", i);
		2858	meas_data->Branch(ctemp, &evtdata.adcdata[i], fname);
		2859
		2860	sprintf(ctemp, "TDC%d", i);
		2861	sprintf(fname, "TDC%d/I", i);
		2862	meas_data->Branch(ctemp, &evtdata.tdcdata[i], fname);
		2863	}
		2864
		2865	// Initialize the scope before measurement
		2866	if( sCamaclink->IsDown() )
		2867	InitializeScope();
		2868
		2869	// Branch for scope measurement data
		2870	if(gScopeDaq->scopeUseType == 2) // only if we select waveform measurement
		2871	{
		2872	if(gScopeDaq->scopeMeasSel == 0)
		2873	scope_data->Branch("amp", &evtmeas.measdata, "amp/D");
		2874	else if(gScopeDaq->scopeMeasSel == 1)
		2875	scope_data->Branch("area", &evtmeas.measdata, "area/D");
		2876	else if(gScopeDaq->scopeMeasSel == 2)
		2877	scope_data->Branch("delay", &evtmeas.measdata, "delay/D");
		2878	else if(gScopeDaq->scopeMeasSel == 3)
		2879	scope_data->Branch("fall", &evtmeas.measdata, "fall/D");
		2880	else if(gScopeDaq->scopeMeasSel == 4)
		2881	scope_data->Branch("freq", &evtmeas.measdata, "freq/D");
		2882	else if(gScopeDaq->scopeMeasSel == 5)
		2883	scope_data->Branch("max", &evtmeas.measdata, "max/D");
		2884	else if(gScopeDaq->scopeMeasSel == 6)
		2885	scope_data->Branch("mean", &evtmeas.measdata, "mean/D");
		2886	else if(gScopeDaq->scopeMeasSel == 7)
		2887	scope_data->Branch("min", &evtmeas.measdata, "min/D");
		2888	else if(gScopeDaq->scopeMeasSel == 8)
		2889	scope_data->Branch("pk2p", &evtmeas.measdata, "pk2p/D");
		2890	else if(gScopeDaq->scopeMeasSel == 9)
		2891	scope_data->Branch("pwidth", &evtmeas.measdata, "pwidth/D");
		2892	else if(gScopeDaq->scopeMeasSel == 10)
		2893	scope_data->Branch("rise", &evtmeas.measdata, "rise/D");
		2894	}
		2895
		2896	int neve = (int) evtNum->GetNumber();
		2897	int allEvt, zProg;
		2898	zProg = 1;
		2899
		2900	#if WORKSTAT == 'I'
		2901	#else
		2902	// ONLY FOR TESTING!
		2903	TRandom *randNum = new TRandom();
		2904	randNum->SetSeed(0);
		2905	// ONLY FOR TESTING!
		2906	#endif
		2907
		2908	if (gDaq)
		2909	{
		2910	if(scanon == 0)
		2911	{
		2912	gDaq->init(evtheader.nrch);
		2913	scanon = 1;
		2914	}
		2915	gDaq->fStop=0;
		2916	// Start gathering
		2917	gDaq->start();
		2918
		2919	busyLabel->Enable();
		2920
		2921	for (int n=0;n<neve && !gDaq->fStop ;/n++/)
		2922	{
		2923	int nb = gDaq->event(gBuf,BSIZE);
		2924
		2925	#if WORKSTAT == 'I'
		2926	#else
		2927	// ONLY FOR TESTING!
		2928	for(int i=0; i < evtheader.nrch; i++)
		2929	{
		2930	if(i == 1)
		2931	gBuf[i] = randNum->Gaus(1500,300);
		2932	else if(i == 0)
		2933	gBuf[i] = randNum->Poisson(2500);
		2934	}
		2935	// ONLY FOR TESTING!
		2936	#endif
		2937	if (nb<=0) n--;
		2938
		2939	int nc=0;
		2940
		2941	while ( (nb>0) && (n<neve) )
		2942	{
		2943	for(int i = 0; i < evtheader.nrch; i++)
		2944	{
		2945	unsigned short adc = gBuf[i+nc]&0xFFFF;
		2946	if(i % 2 == 0) // TDC
		2947	evtdata.tdcdata[i/2] = (int)adc;
		2948	else if(i % 2 == 1) // ADC
		2949	evtdata.adcdata[i/2] = (int)adc;
		2950
		2951	// Start plotting the scope waveform
		2952	if( (gScopeDaq->scopeUseType == 1) && (sCamaclink->IsDown()) )
		2953	StartScopeAcq();
		2954	}
		2955	meas_data->Fill();
		2956
		2957	// Start making a scope measurement
		2958	if( (gScopeDaq->scopeUseType == 2) && (sCamaclink->IsDown()) )
		2959	{
		2960	StartScopeAcq();
		2961	evtmeas.measdata = gScopeDaq->measubuf;
		2962	}
		2963	scope_data->Fill();
		2964
		2965	n++;
		2966	nc += evtheader.nrch;
		2967	nb -= evtheader.nrch;
		2968	}
		2969
		2970	MyTimer();
		2971	allEvt = n;
		2972	if (gSystem->ProcessEvents()) printf("Run Interrupted\n");
		2973
		2974	if( (started) && (n == (neve*zProg)/10) )
		2975	{
		2976	progVal = (float)zProg*10;
		2977	curProgress->SetPosition(progVal);
		2978	zProg++;
		2979	}
		2980	}
		2981
		2982	printf("Number of gathered events: %d\n", allEvt);
		2983	measStart->SetText("Start acquisition");
		2984	started = kFALSE;
		2985
		2986	gDaq->stop();
		2987	}
		2988
		2989	busyLabel->Disable();
		2990	printf("End of Run neve=%d\n",neve);
		2991
		2992	header_data->Write();
		2993	meas_data->Write();
		2994	scope_data->Write();
		2995	delete header_data;
		2996	delete meas_data;
		2997	delete scope_data;
		2998
		2999	outroot->Close();
		3000	}
		3001
		3002	// Start the acquisition
		3003	void TGAppMainFrame::StartAcq()
		3004	{
		3005	// Variable that will initialize camac only once (for scans)
		3006	int scanon = 0;
		3007
		3008	// Determine the type of measurement to perform
		3009	int vscan = 0, pscan = 0, zscan = 0;
		3010	if(voltscanOn->IsOn()) vscan = 1;
		3011	if(surfscanOn->IsOn()) pscan = 1;
		3012	if(zscanOn->IsOn()) zscan = 1;
		3013
		3014	char cmd[256];
		3015	int i, j, k;
		3016	float progVal;
		3017	FILE *pfin;
		3018
		3019	// Variables for voltage scan
		3020	float currentVoltage, minVoltage, maxVoltage, stepVoltage;
		3021	int repetition;
		3022
		3023	// Variables for surface scan
		3024	int minXpos, maxXpos, stepXpos;
		3025	int minYpos, maxYpos, stepYpos;
		3026	int minZpos, maxZpos, stepZpos;
		3027	int repetX, repetY, repetZ;
		3028
		3029	// Voltage scan
		3030	if( (vscan == 1) && (pscan == 0) )
		3031	{
		3032	if(started)
		3033	{
		3034	printf("Stopping current voltage scan...\n");
		3035	gROOT->SetInterrupt();
		3036	measStart->SetText("Start acquisition");
		3037	started = kFALSE;
		3038
		3039	pfin = fopen("finish_sig.txt","w");
		3040	fprintf(pfin, "%s: Voltage scan stopped.", timeStamp->GetText());
		3041	fclose(pfin);
		3042	}
		3043	else if(!started)
		3044	{
		3045	measStart->SetText("Stop acquisition");
		3046	started = kTRUE;
		3047
		3048	printf("Running a voltage scan...\n");
		3049
		3050	minVoltage = vOutStart->GetNumber();
		3051	maxVoltage = vOutStop->GetNumber();
		3052	stepVoltage = vOutStep->GetNumber();
		3053
		3054	if(stepVoltage == 0.)
		3055	repetition = 1;
		3056	else
		3057	repetition = ((maxVoltage - minVoltage)/stepVoltage)+1;
		3058
		3059	for(i=0; i < repetition; i++)
		3060	{
		3061	progVal = (float)(100.00/repetition)*i;
		3062	curProgress->SetPosition(progVal);
		3063
		3064	fflush(stdout);
		3065	currentVoltage = minVoltage + stepVoltage*i;
		3066	sprintf(cmd, "%s/mpod/mpod_voltage.sh -o %d -v %f -s 1", rootdir, GetChannel(), currentVoltage);
		3067	#if WORKSTAT == 'I'
		3068	retTemp = system(cmd);
		3069	#else
		3070	printf("Cmd: %s\n",cmd);
		3071	#endif
		3072	fflush(stdout);
		3073
		3074	printf("Waiting for voltage change...\n");
		3075	sleep(3);
		3076	vOut->SetNumber(currentVoltage);
		3077	printf("Continuing...\n");
		3078
		3079	// Here comes function to start histogramming <<<<<<<<<<<<<<<<<<<<<<<<
		3080	RunMeas((void*)0, i, 0, scanon);
		3081	fflush(stdout);
		3082	}
		3083
		3084	// Set output back to off
		3085	fflush(stdout);
		3086	printf("Measurement finished, returning to starting voltage...\n");
		3087	sprintf(cmd, "%s/mpod/mpod_voltage.sh -o %d -v %f -s 1", rootdir, GetChannel(), minVoltage);
		3088	vOut->SetNumber(minVoltage);
		3089	#if WORKSTAT == 'I'
		3090	retTemp = system(cmd);
		3091	#else
		3092	printf("Cmd: %s\n",cmd);
		3093	#endif
		3094	fflush(stdout);
		3095
		3096	progVal = 100.00;
		3097	curProgress->SetPosition(progVal);
		3098	printf("\n");
		3099
		3100	pfin = fopen("finish_sig.txt","w");
		3101	fprintf(pfin, "%s: Voltage scan finished.", timeStamp->GetText());
		3102	fclose(pfin);
		3103	}
		3104	}
		3105	// Surface scan
		3106	else if( (pscan == 1) && (vscan == 0) )
		3107	{
		3108	minXpos = xPosMin->GetNumber();
		3109	maxXpos = xPosMax->GetNumber();
		3110	stepXpos = xPosStep->GetNumber();
		3111	minYpos = yPosMin->GetNumber();
		3112	maxYpos = yPosMax->GetNumber();
		3113	stepYpos = yPosStep->GetNumber();
		3114	minZpos = zPosMin->GetNumber();
		3115	maxZpos = zPosMax->GetNumber();
		3116	stepZpos = zPosStep->GetNumber();
		3117
		3118	if(zscan == 1)
		3119	{
		3120	if(stepZpos == 0.) repetZ = 1;
		3121	else repetZ = ((maxZpos - minZpos)/stepZpos)+1;
		3122	}
		3123	else
		3124	{
		3125	minZpos = zPos->GetNumber();
		3126	repetZ = 1;
		3127	}
		3128
		3129	if(stepXpos == 0.) repetX = 1;
		3130	else repetX = ((maxXpos - minXpos)/stepXpos)+1;
		3131	if(stepYpos == 0.) repetY = 1;
		3132	else repetY = ((maxYpos - minYpos)/stepYpos)+1;
		3133
		3134	for(k=0; k < repetZ; k++)
		3135	{
		3136	fflush(stdout);
		3137	// Y-axis change
		3138	sprintf(cmd, "sudo %s/MIKRO/mikro_ctrl -n 3 -v %d -s la && %s/MIKRO/mikro_ctrl -n 3 -c m", rootdir, minZpos + stepZpos*k, rootdir);
		3139	#if WORKSTAT == 'I'
		3140	retTemp = system(cmd);
		3141	#else
		3142	printf("Cmd: %s\n",cmd);
		3143	#endif
		3144	fflush(stdout);
		3145
		3146	int iloop =0;
		3147	do {
		3148	usleep(50);
		3149	sprintf(cmd, "sudo %s/MIKRO/mikro_ctrl -n 3 -p > %s/curpos.txt", rootdir, rootdir);
		3150	retTemp = system(cmd);
		3151
		3152	FILE* fpos;
		3153	int itemp;
		3154	sprintf(cmd, "%s/curpos.txt", rootdir);
		3155	fpos = fopen(cmd, "r");
		3156
		3157	if(fpos != NULL)
		3158	{
		3159	retTemp = fscanf(fpos, "%d\n", &itemp);
		3160	}
		3161
		3162	fclose(fpos);
		3163	printf(">>>>>>> Cur Z Pos = %d\n", itemp);
		3164
		3165
		3166	if( abs(itemp - (minZpos + stepZpos*k)) < 3 ) break;
		3167
		3168	iloop++;
		3169	} while(iloop < 10000);
		3170
		3171	printf("Next Z position...\n");
		3172	zPos->SetNumber(minZpos + stepZpos*k);
		3173	fflush(stdout);
		3174
		3175	for(j=0; j < repetY; j++)
		3176	{
		3177	fflush(stdout);
		3178	// Y-axis change
		3179	sprintf(cmd, "sudo %s/MIKRO/mikro_ctrl -n 2 -v %d -s la && %s/MIKRO/mikro_ctrl -n 2 -c m", rootdir, minYpos + stepYpos*j, rootdir);
		3180	#if WORKSTAT == 'I'
		3181	retTemp = system(cmd);
		3182	#else
		3183	printf("Cmd: %s\n",cmd);
		3184	#endif
		3185	fflush(stdout);
		3186
		3187	printf("Waiting for position change...\n");
		3188	//sleep(4);
		3189
		3190	int iloop =0;
		3191	do {
		3192	usleep(50);
		3193	sprintf(cmd, "sudo %s/MIKRO/mikro_ctrl -n 2 -p > %s/curpos.txt", rootdir, rootdir);
		3194	retTemp = system(cmd);
		3195
		3196	FILE* fpos;
		3197	int itemp;
		3198	sprintf(cmd, "%s/curpos.txt", rootdir);
		3199	fpos = fopen(cmd, "r");
		3200
		3201	if(fpos != NULL)
		3202	{
		3203	retTemp = fscanf(fpos, "%d\n", &itemp);
		3204	}
		3205
		3206	fclose(fpos);
		3207	printf(">>>>>>> Cur Y Pos = %d\n", itemp);
		3208
		3209
		3210	if( abs(itemp - (minYpos + stepYpos*j)) < 3 ) break;
		3211
		3212	iloop++;
		3213	} while(iloop < 10000);
		3214
		3215	printf("Next Y position...\n");
		3216	yPos->SetNumber(minYpos + stepYpos*j);
		3217	fflush(stdout);
		3218
		3219	for(i=0; i < repetX; i++)
		3220	{
		3221	progVal = (float)(100.00/(repetXrepetY))(j*repetX+i);
		3222	curProgress->SetPosition(progVal);
		3223
		3224	int jloop =0;
		3225	do {
		3226	usleep(100);
		3227
		3228	// X-axis change
		3229	sprintf(cmd, "sudo %s/MIKRO/mikro_ctrl -n 1 -v %d -s la && %s/MIKRO/mikro_ctrl -n 1 -c m", rootdir, minXpos + stepXpos*i, rootdir);
		3230	#if WORKSTAT == 'I'
		3231	retTemp = system(cmd);
		3232	#else
		3233	printf("Cmd: %s\n",cmd);
		3234	#endif
		3235	fflush(stdout);
		3236
		3237	printf("Next X position...\n");
		3238	fflush(stdout);
		3239
		3240	printf("Waiting for position change...\n");
		3241	// sleep(2);
		3242
		3243	int iloop =0;
		3244	do {
		3245	usleep(100);
		3246	sprintf(cmd, "sudo %s/MIKRO/mikro_ctrl -n 1 -p > %s/curpos.txt", rootdir, rootdir);
		3247	retTemp = system(cmd);
		3248
		3249	FILE* fpos;
		3250	int itemp;
		3251	sprintf(cmd, "%s/curpos.txt", rootdir);
		3252	fpos = fopen(cmd, "r");
		3253
		3254	if(fpos != NULL)
		3255	{
		3256	retTemp = fscanf(fpos, "%d\n", &itemp);
		3257	}
		3258
		3259	fclose(fpos);
		3260	printf(">>>>>>> Cur X Pos = %d\n", itemp);
		3261
		3262
		3263	if( abs(itemp - ( minXpos + stepXpos*i)) < 3 ) break;
		3264
		3265	iloop++;
		3266	} while(iloop < 100);
		3267
		3268	sprintf(cmd, "sudo %s/MIKRO/mikro_ctrl -n 1 -p > %s/curpos.txt", rootdir, rootdir);
		3269	retTemp = system(cmd);
		3270
		3271	FILE* fpos;
		3272	int itemp;
		3273	sprintf(cmd, "%s/curpos.txt", rootdir);
		3274	fpos = fopen(cmd, "r");
		3275
		3276	if(fpos != NULL)
		3277	{
		3278	retTemp = fscanf(fpos, "%d\n", &itemp);
		3279	}
		3280
		3281	fclose(fpos);
		3282
		3283	if( abs(itemp - ( minXpos + stepXpos*i)) < 3 ) break;
		3284
		3285	jloop++;
		3286	} while(jloop < 100);
		3287
		3288
		3289
		3290	xPos->SetNumber(minXpos + stepXpos*i);
		3291	printf("Continuing...\n");
		3292
		3293	// for (k=0;k<(NTDCCH+NADCCH);k++) gHisto1D[k]->Reset();
		3294	// for (k=0;k<(NTDCCH+NADCCH)/2;k++) gHisto2D[k]->Reset();
		3295
		3296	// Here comes function to start histogramming <<<<<<<<<<<<<<<<<<<<<<<<
		3297	RunMeas((void)0, (jrepetX + i), zscan , scanon);
		3298
		3299	fflush(stdout);
		3300	}
		3301
		3302	printf("\n");
		3303	}
		3304	}
		3305
		3306	fflush(stdout);
		3307	printf("Measurement finished, returning to starting position...\n");
		3308	// X-axis return
		3309	sprintf(cmd, "sudo %s/MIKRO/mikro_ctrl -n 1 -v %d -s la && %s/MIKRO/mikro_ctrl -n 1 -c m", rootdir, minXpos, rootdir);
		3310	#if WORKSTAT == 'I'
		3311	retTemp = system(cmd);
		3312	#else
		3313	printf("Cmd: %s\n",cmd);
		3314	#endif
		3315	fflush(stdout);
		3316
		3317	// Y-axis return
		3318	sprintf(cmd, "sudo %s/MIKRO/mikro_ctrl -n 2 -v %d -s la && %s/MIKRO/mikro_ctrl -n 2 -c m", rootdir, minYpos, rootdir);
		3319	#if WORKSTAT == 'I'
		3320	retTemp = system(cmd);
		3321	#else
		3322	printf("Cmd: %s\n",cmd);
		3323	#endif
		3324
		3325	// Z-axis return
		3326	sprintf(cmd, "sudo %s/MIKRO/mikro_ctrl -n 3 -v %d -s la && %s/MIKRO/mikro_ctrl -n 3 -c m", rootdir, minZpos, rootdir);
		3327	#if WORKSTAT == 'I'
		3328	retTemp = system(cmd);
		3329	#else
		3330	printf("Cmd: %s\n",cmd);
		3331	#endif
		3332	xPos->SetNumber(minXpos);
		3333	yPos->SetNumber(minYpos);
		3334	zPos->SetNumber(minZpos);
		3335
		3336	progVal = 100.00;
		3337	curProgress->SetPosition(progVal);
		3338	printf("\n");
		3339
		3340	pfin = fopen("finish_sig.txt","w");
		3341	fprintf(pfin, "%s: Surface scan finished.", timeStamp->GetText());
		3342	fclose(pfin);
		3343	}
		3344	// Normal single measurement
		3345	else if( (vscan == 0) && (pscan == 0) )
		3346	{
		3347	// Set the start button to stop and enable stopping of measurement
		3348	if(started)
		3349	{
		3350	printf("Stopping current single scan...\n");
		3351	gROOT->SetInterrupt();
		3352	// gDaq->fStop=1;
		3353	measStart->SetText("Start acquisition");
		3354	started = kFALSE;
		3355	}
		3356	else if(!started)
		3357	{
		3358	measStart->SetText("Stop acquisition");
		3359	started = kTRUE;
		3360
		3361	printf("Running a single scan...\n");
		3362	RunMeas((void*)0, 0, 0, scanon);
		3363	printf("Measurement finished...\n");
		3364	printf("\n");
		3365	}
		3366	}
		3367	}
		3368
		3369	// File browser for opening histograms
		3370	void TGAppMainFrame::SelectDirectory()
		3371	{
		3372	int i = fileList->GetNumberOfEntries();
		3373
		3374	TGFileInfo file_info;
		3375	const char *filetypes[] = {"Histograms",histExtAll,0,0};
		3376	file_info.fFileTypes = filetypes;
		3377	file_info.fIniDir = StrDup("./results");
		3378	file_info.fMultipleSelection = kTRUE;
		3379	new TGFileDialog(gClient->GetDefaultRoot(), fMain, kFDOpen, &file_info);
		3380
		3381	TList *files = file_info.fFileNamesList;
		3382	if(files)
		3383	{
		3384	TSystemFile *file;
		3385	TString fname;
		3386	TIter next(files);
		3387	while(file=(TSystemFile*)next())
		3388	{
		3389	fname = file->GetName();
		3390	fileList->AddEntry(fname.Data(), i);
		3391	i++;
		3392	}
		3393	}
		3394	fileList->Layout();
		3395	}
		3396
		3397	// File browser for selecting the save file
		3398	void TGAppMainFrame::SaveFile()
		3399	{
		3400	TGFileInfo file_info;
		3401	const char *filetypes[] = {"Histograms",histExtAll,0,0};
		3402	file_info.fFileTypes = filetypes;
		3403	file_info.fIniDir = StrDup("./results");
		3404	new TGFileDialog(gClient->GetDefaultRoot(), fMain, kFDSave, &file_info);
		3405
		3406	fileName->SetText(file_info.fFilename);
		3407	}
		3408
		3409	// Toggle multiple selection in filelist
		3410	void TGAppMainFrame::ListMultiSelect()
		3411	{
		3412	fileList->SetMultipleSelections((multiSelect->IsOn()));
		3413
		3414	if(multiSelectAll->IsDown())
		3415	multiSelectAll->SetState(kButtonUp);
		3416	}
		3417
		3418	// Select all entries in filelist
		3419	void TGAppMainFrame::ListSelectAll()
		3420	{
		3421	if(multiSelectAll->IsDown())
		3422	{
		3423	multiSelect->SetState(kButtonDown);
		3424	fileList->SetMultipleSelections((multiSelect->IsOn()));
		3425	for(int i = 0; i < fileList->GetNumberOfEntries(); i++)
		3426	fileList->Select(i,kTRUE);
		3427	}
		3428	else if(!multiSelectAll->IsDown())
		3429	{
		3430	multiSelect->SetState(kButtonUp);
		3431	fileList->SetMultipleSelections((multiSelect->IsOn()));
		3432	for(int i = 0; i < fileList->GetNumberOfEntries(); i++)
		3433	fileList->Select(i,kFALSE);
		3434	}
		3435	}
		3436
		3437	// Navigation buttons for the filelist (<<, >>) and double click
		3438	void TGAppMainFrame::FileListNavigation(int pn)
		3439	{
		3440	unsigned int nrfiles = fileList->GetNumberOfEntries();
		3441	int curSel;
		3442	TList *files;
		3443	if( nrfiles > 0 )
		3444	{
		3445	if(pn < -1)
		3446	{
		3447	if(multiSelect->IsOn())
		3448	{
		3449	// turn off multiple selection and select first file on list
		3450	fileList->SetMultipleSelections(kFALSE);
		3451	multiSelect->SetState(kButtonUp);
		3452	multiSelectAll->SetState(kButtonUp);
		3453
		3454	fileList->Select(0,kTRUE);
		3455	}
		3456	else
		3457	{
		3458	// if nothing is selected, curSel will be -1
		3459	curSel = fileList->GetSelected();
		3460	// go to next file on list
		3461	if(pn == -3)
		3462	{
		3463	if( (curSel == (int)(nrfiles-1)) \|\| (curSel == -1) )
		3464	fileList->Select(0);
		3465	else
		3466	fileList->Select(curSel+1);
		3467	}
		3468	// go to previous file on list
		3469	else if(pn == -2)
		3470	{
		3471	if( (curSel == 0) \|\| (curSel == -1) )
		3472	fileList->Select(nrfiles-1);
		3473	else
		3474	fileList->Select(curSel-1);
		3475	}
		3476	}
		3477	}
		3478
		3479	// check the newly selected file/files and return its name/their names
		3480	files = new TList();
		3481	fileList->GetSelectedEntries(files);
		3482	if(files)
		3483	{
		3484	for(int i = 0; i < (int)nrfiles; i++)
		3485	{
		3486	if(files->At(i))
		3487	{
		3488	if(debug)
		3489	printf("Filename: %s\n", files->At(i)->GetTitle());
		3490	if( fMenuHisttype->IsEntryChecked(M_ANALYSIS_HISTTYPE_1DADC) )
		3491	DisplayHistogram( (char*)(files->At(i)->GetTitle()), 0);
		3492	else if( fMenuHisttype->IsEntryChecked(M_ANALYSIS_HISTTYPE_1DTDC) )
		3493	DisplayHistogram( (char*)(files->At(i)->GetTitle()), 1);
		3494	else if( fMenuHisttype->IsEntryChecked(M_ANALYSIS_HISTTYPE_2D) )
		3495	DisplayHistogram( (char*)(files->At(i)->GetTitle()), 2);
		3496	}
		3497	}
		3498	}
		3499
		3500	// Still need to include drawing of histograms we move to!!!
		3501	}
		3502	}
		3503
		3504	// Open the header edit window when pressing on editHeader button
		3505	void TGAppMainFrame::HeaderEdit()
		3506	{
		3507	OpenWindow(2);
		3508	}
		3509
		3510	// Display the currently selected histogram in file list
		3511	void TGAppMainFrame::DisplayHistogram(char* histfile, int histtype)
		3512	{
		3513	if(debug)
		3514	printf("Selected file: %s\n", histfile);
		3515
		3516	TCanvas *gCanvas = histCanvas->GetCanvas();
		3517
		3518	inroot = new TFile(histfile, "READ");
		3519
		3520	TTree header_data, meas_data;
		3521	inroot->GetObject("header_data", header_data);
		3522	inroot->GetObject("meas_data", meas_data);
		3523
		3524	// Reading the header
		3525	header_data->SetBranchAddress("nrch", &evtheader.nrch);
		3526	header_data->GetEntry(0);
		3527	header_data->SetBranchAddress("timestamp", &evtheader.timestamp);
		3528	header_data->GetEntry(0);
		3529	header_data->SetBranchAddress("biasvolt", &evtheader.biasvolt);
		3530	header_data->GetEntry(0);
		3531	header_data->SetBranchAddress("xpos", &evtheader.xpos);
		3532	header_data->GetEntry(0);
		3533	header_data->SetBranchAddress("ypos", &evtheader.ypos);
		3534	header_data->GetEntry(0);
		3535	header_data->SetBranchAddress("zpos", &evtheader.zpos);
		3536	header_data->GetEntry(0);
		3537	header_data->SetBranchAddress("temperature", &evtheader.temperature);
		3538	header_data->GetEntry(0);
		3539	if( header_data->FindBranch("angle") )
		3540	{
		3541	header_data->SetBranchAddress("angle", &evtheader.angle);
		3542	header_data->GetEntry(0);
		3543	}
		3544	header_data->SetBranchAddress("laserinfo", &evtheader.laserinfo);
		3545	header_data->GetEntry(0);
		3546
		3547	char histtime[256];
		3548	GetTime(evtheader.timestamp, histtime);
		3549
		3550	// Displaying header information (debug and on the GUI)
		3551	if(debug)
		3552	{
		3553	printf("Opened file header information:\n");
		3554	printf("- Number of channels: %d\n", evtheader.nrch);
		3555	printf("- Timestamp: %d (%s)\n", evtheader.timestamp, histtime);
		3556	printf("- Bias voltage: %lf\n", evtheader.biasvolt);
		3557	printf("- Table position (X,Y,Z): %d, %d, %d\n", evtheader.xpos, evtheader.ypos, evtheader.zpos);
		3558	if(evtheader.temperature)
		3559	printf("- Temperature: %lf\n", evtheader.temperature);
		3560	if( header_data->FindBranch("angle") )
		3561	printf("- Incidence angle: %lf\n", evtheader.angle);
		3562	else
		3563	printf("- Incidence angle: No angle information!\n");
		3564	printf("- Laser and filter settings: %s\n", evtheader.laserinfo);
		3565	}
		3566
		3567	char ctemp[512];
		3568	disptime->SetText(histtime);
		3569	dispbias->SetNumber(evtheader.biasvolt);
		3570	sprintf(ctemp, "%d, %d, %d", evtheader.xpos, evtheader.ypos, evtheader.zpos);
		3571	disppos->SetText(ctemp);
		3572	if(evtheader.temperature)
		3573	disptemp->SetNumber(evtheader.temperature);
		3574	else
		3575	disptemp->SetNumber(0.0);
		3576	if( header_data->FindBranch("angle") )
		3577	dispangle->SetNumber(evtheader.angle);
		3578	else
		3579	dispangle->SetNumber(0.0);
		3580	displaser->SetText(evtheader.laserinfo);
		3581
		3582	int j;
		3583	char rdc[256];
		3584	char rdcsel[256];
		3585
		3586	j = selectCh->GetNumber();
		3587
		3588	printf("Found %d data points.\n", (int)meas_data->GetEntries());
		3589
		3590	gCanvas->cd();
		3591	double range[4];
		3592	range[0] = adcMinRange->GetNumber();
		3593	range[1] = adcMaxRange->GetNumber();
		3594	range[2] = tdcMinwindow->GetNumber();
		3595	range[3] = tdcMaxwindow->GetNumber();
		3596
		3597	if(histtype == 0)
		3598	{
		3599	if( range[0] == range[1] )
		3600	sprintf(rdc, "ADC%d>>%s", j, histname);
		3601	else
		3602	sprintf(rdc, "ADC%d>>%s(%d,%lf,%lf)", j, histname, (int)(range[1]-range[0]), range[0]-0.5, range[1]-0.5);
		3603
		3604	sprintf(rdcsel, "(TDC%d>%lf)&&(TDC%d<%lf)", j, range[2]tdctimeconversion, j, range[3]tdctimeconversion);
		3605	meas_data->Draw(rdc, rdcsel);
		3606
		3607	sprintf(rdc, "ADC%d, Vbias=%.3lf, TDC=(%.2lf,%.2lf);ADC;", j, evtheader.biasvolt, range[2], range[3]);
		3608	TH1F histtemp = (TH1F)gCanvas->GetPrimitive(histname);
		3609	if(!cleanPlots)
		3610	histtemp->SetTitle(rdc);
		3611	else
		3612	histtemp->SetTitle(";ADC;");
		3613	histtemp->GetXaxis()->SetLabelSize(0.025);
		3614	histtemp->GetXaxis()->CenterTitle(kTRUE);
		3615	histtemp->GetYaxis()->SetLabelSize(0.025);
		3616	if(cleanPlots)
		3617	{
		3618	TGaxis yax = (TGaxis)histtemp->GetYaxis();
		3619	yax->SetMaxDigits(4);
		3620	}
		3621
		3622	gCanvas->Modified();
		3623	gCanvas->Update();
		3624
		3625	if( yMinRange->GetNumber() != yMaxRange->GetNumber() )
		3626	{
		3627	if( (logscale->IsDown()) && (yMinRange->GetNumber() <= 0) )
		3628	{
		3629	histtemp->GetYaxis()->SetRangeUser(0.5, yMaxRange->GetNumber());
		3630	yMinRange->SetNumber(0.5);
		3631	logchange = 1;
		3632	}
		3633	else
		3634	{
		3635	gCanvas->SetLogy(kFALSE);
		3636	if(logchange == 1)
		3637	{
		3638	yMinRange->SetNumber(0.0);
		3639	logchange = 0;
		3640	}
		3641	histtemp->GetYaxis()->SetRangeUser(yMinRange->GetNumber(), yMaxRange->GetNumber());
		3642	}
		3643	}
		3644
		3645	TPaveStats stats = (TPaveStats)histtemp->FindObject("stats");
		3646	if(!cleanPlots)
		3647	{
		3648	stats->SetX1NDC(0.84); stats->SetX2NDC(0.97);
		3649	stats->SetY1NDC(0.87); stats->SetY2NDC(0.97);
		3650	}
		3651	else
		3652	{
		3653	stats->SetX1NDC(1.1); stats->SetX2NDC(1.3);
		3654	stats->SetY1NDC(1.1); stats->SetY2NDC(1.3);
		3655	}
		3656	}
		3657	else if(histtype == 1)
		3658	{
		3659	if( range[0] == range[1] )
		3660	sprintf(rdc, "(TDC%d/%lf)>>%s", j, tdctimeconversion, histname);
		3661	else
		3662	sprintf(rdc, "(TDC%d/%lf)>>%s(%d,%lf,%lf)", j, tdctimeconversion, histname, (int)((range[3]-range[2])*tdctimeconversion), range[2], range[3]);
		3663	sprintf(rdcsel, "(TDC%d>%lf)&&(TDC%d<%lf)", j, range[2]tdctimeconversion, j, range[3]tdctimeconversion);
		3664	meas_data->Draw(rdc, rdcsel);
		3665
		3666	sprintf(rdc, "TDC%d, Vbias=%.3lf, TDC=(%.2lf,%.2lf);Time (TDC channel) [ns];", j, evtheader.biasvolt, range[2], range[3]);
		3667	TH1F histtemp = (TH1F)gCanvas->GetPrimitive(histname);
		3668	if(!cleanPlots)
		3669	histtemp->SetTitle(rdc);
		3670	else
		3671	histtemp->SetTitle(";Time (TDC channel) [ns];");
		3672	histtemp->GetXaxis()->SetLabelSize(0.025);
		3673	histtemp->GetXaxis()->CenterTitle(kTRUE);
		3674	histtemp->GetYaxis()->SetLabelSize(0.025);
		3675	if(cleanPlots)
		3676	{
		3677	TGaxis yax = (TGaxis)histtemp->GetYaxis();
		3678	yax->SetMaxDigits(4);
		3679	}
		3680
		3681	gCanvas->Modified();
		3682	gCanvas->Update();
		3683
		3684	if( yMinRange->GetNumber() != yMaxRange->GetNumber() )
		3685	{
		3686	if( (logscale->IsDown()) && (yMinRange->GetNumber() <= 0) )
		3687	{
		3688	histtemp->GetYaxis()->SetRangeUser(0.5, yMaxRange->GetNumber());
		3689	yMinRange->SetNumber(0.5);
		3690	logchange = 1;
		3691	}
		3692	else
		3693	{
		3694	gCanvas->SetLogy(kFALSE);
		3695	if(logchange == 1)
		3696	{
		3697	yMinRange->SetNumber(0.0);
		3698	logchange = 0;
		3699	}
		3700	histtemp->GetYaxis()->SetRangeUser(yMinRange->GetNumber(), yMaxRange->GetNumber());
		3701	}
		3702	}
		3703
		3704	TPaveStats stats = (TPaveStats)histtemp->FindObject("stats");
		3705	if(!cleanPlots)
		3706	{
		3707	stats->SetX1NDC(0.84); stats->SetX2NDC(0.97);
		3708	stats->SetY1NDC(0.87); stats->SetY2NDC(0.97);
		3709	}
		3710	else
		3711	{
		3712	stats->SetX1NDC(1.1); stats->SetX2NDC(1.3);
		3713	stats->SetY1NDC(1.1); stats->SetY2NDC(1.3);
		3714	}
		3715	}
		3716	else if(histtype == 2)
		3717	{
		3718	if( ((range[0] == range[1]) && (range[2] == range[3])) \|\| (range[2] == range[3]) \|\| (range[0] == range[1]) )
		3719	sprintf(rdc, "(TDC%d/%lf):ADC%d>>%s", j, tdctimeconversion, j, histname);
		3720	else
		3721	sprintf(rdc, "(TDC%d/%lf):ADC%d>>%s(%d,%lf,%lf,%d,%lf,%lf)", j, tdctimeconversion, j, histname, (int)(range[1]-range[0])/2, range[0]-0.5, range[1]-0.5, (int)((range[3]-range[2])*tdctimeconversion)/2, range[2], range[3]);
		3722	meas_data->Draw(rdc,"","COLZ");
		3723
		3724	sprintf(rdc, "ADC/TDC%d, Vbias=%.3lf, TDC=(%.2lf,%.2lf);ADC;TDC", j, evtheader.biasvolt, range[2], range[3]);
		3725	TH2F histtemp = (TH2F)gCanvas->GetPrimitive(histname);
		3726	if(!cleanPlots)
		3727	histtemp->SetTitle(rdc);
		3728	else
		3729	histtemp->SetTitle(";ADC;Time (TDC channel) [ns]");
		3730	histtemp->GetXaxis()->SetLabelSize(0.025);
		3731	histtemp->GetXaxis()->CenterTitle(kTRUE);
		3732	histtemp->GetYaxis()->SetLabelSize(0.025);
		3733	histtemp->GetYaxis()->CenterTitle(kTRUE);
		3734	histtemp->GetYaxis()->SetTitleOffset(1.35);
		3735	if(cleanPlots)
		3736	{
		3737	TGaxis yax = (TGaxis)histtemp->GetYaxis();
		3738	yax->SetMaxDigits(4);
		3739	}
		3740
		3741	gCanvas->Modified();
		3742	gCanvas->Update();
		3743
		3744	TPaveStats stats = (TPaveStats)histtemp->FindObject("stats");
		3745	// stats->SetOptStat(0);
		3746	stats->SetX1NDC(1.1); stats->SetX2NDC(1.3);
		3747	stats->SetY1NDC(1.1); stats->SetY2NDC(1.3);
		3748
		3749	TPaletteAxis gpalette = (TPaletteAxis)histtemp->GetListOfFunctions()->FindObject("palette");
		3750	gpalette->SetLabelSize(0.022);
		3751	}
		3752
		3753	if(histtype < 2)
		3754	{
		3755	if( logscale->IsDown() )
		3756	gCanvas->SetLogy(kTRUE);
		3757	else if( !logscale->IsDown() )
		3758	gCanvas->SetLogy(kFALSE);
		3759	}
		3760	else
		3761	gCanvas->SetLogy(kFALSE);
		3762
		3763	gCanvas->Modified();
		3764	gCanvas->Update();
		3765
		3766	// If you close the opened file, the data can't be accessed by other functions
		3767	}
		3768
		3769	// Create a 2D surface plot and plot it
		3770	void TGAppMainFrame::MakeSurfPlot(TList *files)
		3771	{
		3772	unsigned int nrfiles = fileList->GetNumberOfEntries();
		3773	int j, k = 0, m = 0, n = 0;
		3774	char ctemp[256];
		3775	TCanvas *gCanvas = histCanvas->GetCanvas();
		3776	TTree header_data, meas_data;
		3777	double *integralCount;
		3778	double surfx, surfy;
		3779	double xsurfmin = 0, ysurfmin = 0;
		3780	integralCount = new double[nrfiles];
		3781	for(int i = 0; i < (int)nrfiles; i++) integralCount[i] = 0;
		3782	surfx = new double[nrfiles];
		3783	surfy = new double[nrfiles];
		3784	int nrentries;
		3785	TGraph2D *gScan2D;
		3786	gScan2D = new TGraph2D();
		3787
		3788	/* int zProg = 0;
		3789	float progVal;
		3790	curProgress->SetPosition(zProg);*/
		3791
		3792	char exportname[256];
		3793
		3794	if(multiSelect->IsOn())
		3795	{
		3796	printf("Creating a surface plot. Please wait...\n");
		3797	fileList->GetSelectedEntries(files);
		3798	if(files)
		3799	{
		3800	busyLabel->Enable();
		3801
		3802	for(int i = 0; i < (int)nrfiles; i++)
		3803	{
		3804	if(files->At(i))
		3805	{
		3806	n++;
		3807	// printf("Filename: %s\n", files->At(i)->GetTitle());
		3808
		3809	sprintf(ctemp, "%s", files->At(i)->GetTitle());
		3810	inroot = new TFile(ctemp, "READ");
		3811
		3812	inroot->GetObject("header_data", header_data);
		3813	inroot->GetObject("meas_data", meas_data);
		3814
		3815	// Reading the header
		3816	header_data->SetBranchAddress("xpos", &evtheader.xpos);
		3817	header_data->GetEntry(0);
		3818	header_data->SetBranchAddress("ypos", &evtheader.ypos);
		3819	header_data->GetEntry(0);
		3820
		3821	char rdc[256];
		3822	j = selectCh->GetNumber();
		3823	double rangetdc[2];
		3824	rangetdc[0] = tdcMinwindow->GetNumber();
		3825	rangetdc[1] = tdcMaxwindow->GetNumber();
		3826
		3827	k = 0;
		3828	m = 0;
		3829
		3830	// Reading the data
		3831	for(int i = 0; i < meas_data->GetEntries(); i++)
		3832	{
		3833	sprintf(rdc, "ADC%d", j);
		3834	meas_data->SetBranchAddress(rdc, &evtdata.adcdata[j]);
		3835	meas_data->GetEntry(i);
		3836
		3837	sprintf(rdc, "TDC%d", j);
		3838	meas_data->SetBranchAddress(rdc, &evtdata.tdcdata[j]);
		3839	meas_data->GetEntry(i);
		3840
		3841	// If our data point is inside the TDC window
		3842	if( ((double)evtdata.tdcdata[j]/tdctimeconversion >= rangetdc[0]) && ((double)evtdata.tdcdata[j]/tdctimeconversion <= rangetdc[1]) )
		3843	{
		3844	k++;
		3845	m += evtdata.adcdata[j];
		3846	}
		3847	}
		3848
		3849	integralCount[n-1] += ((double)m)/((double)k);
		3850	if(n == 1)
		3851	{
		3852	xsurfmin = evtheader.xpos;
		3853	ysurfmin = evtheader.ypos;
		3854	}
		3855	surfx[n-1] = (double)(evtheader.xpos-xsurfmin)*lenconversion;
		3856	surfy[n-1] = (double)(evtheader.ypos-ysurfmin)*lenconversion;
		3857
		3858	/* if( n == (((files->GetSize())*zProg)/20)+1 ) // divide by 20 because files->GetSize() gives a double value of the files selected
		3859	{
		3860	progVal = (float)n;
		3861	curProgress->SetPosition(progVal);
		3862	zProg++;
		3863	printf("Progress = %lf\n", progVal);
		3864	}*/
		3865
		3866	inroot->Close();
		3867	delete inroot;
		3868	}
		3869	}
		3870
		3871	busyLabel->Disable();
		3872
		3873	nrentries = n;
		3874	printf("%d files were selected.\n", nrentries);
		3875
		3876	for(int i = 0; i < nrentries; i++)
		3877	{
		3878	// printf("At position (%d,%d), the ADC integral is: %lf.\n", surfx[i], surfy[i], integralCount[i]);
		3879	gScan2D->SetPoint(i, surfx[i], surfy[i], integralCount[i]);
		3880	}
		3881	gCanvas->cd();
		3882	gScan2D->Draw("COLZ");
		3883
		3884	gCanvas->Modified();
		3885	gCanvas->Update();
		3886
		3887	gScan2D->GetXaxis()->SetTitle("X [#mum]");
		3888	gScan2D->GetXaxis()->CenterTitle(kTRUE);
		3889	gScan2D->GetXaxis()->SetLabelSize(0.022);
		3890	gScan2D->GetXaxis()->SetRangeUser(surfx[0], surfx[nrentries-1]);
		3891	// j = 500+(int)((surfx[nrentries-1]-surfx[0])/(surfx[1]-surfx[0]));
		3892	// if(j > 510) j = 510;
		3893	gScan2D->GetXaxis()->SetNdivisions(510, kTRUE);
		3894	gScan2D->GetYaxis()->SetTitle("Y [#mum]");
		3895	gScan2D->GetYaxis()->SetTitleOffset(1.3);
		3896	gScan2D->GetYaxis()->CenterTitle(kTRUE);
		3897	gScan2D->GetYaxis()->SetLabelSize(0.022);
		3898	gScan2D->GetYaxis()->SetRangeUser(surfy[0], surfy[nrentries-1]);
		3899	// j = 500+(int)((surfy[nrentries-1]-surfy[0])/(surfy[(int)((surfx[nrentries-1]-surfx[0])/(surfx[1]-surfx[0])+1)]-surfy[0]));
		3900	// if(j > 510) j = 510;
		3901	gScan2D->GetYaxis()->SetNdivisions(510, kTRUE);
		3902
		3903	TGaxis yax = (TGaxis)gScan2D->GetYaxis();
		3904	yax->SetMaxDigits(4);
		3905
		3906	if(!cleanPlots)
		3907	gScan2D->SetTitle("Surface scan");
		3908	else
		3909	gScan2D->SetTitle();
		3910
		3911	// TPaletteAxis gpalette = (TPaletteAxis)gScan2D->GetListOfFunctions()->FindObject("palette");
		3912	// gpalette->SetLabelSize(0.022);
		3913
		3914	gCanvas->Modified();
		3915	gCanvas->Update();
		3916
		3917	remove_from_last((char*)files->At(0)->GetTitle(), '_', ctemp);
		3918	sprintf(exportname, "%s_surfscan.pdf", ctemp);
		3919	gCanvas->SaveAs(exportname);
		3920	}
		3921	}
		3922	else
		3923	{
		3924	printf("To make a 2D surface scan plot, select multiple root files.\n");
		3925	change2Dsurf->SetDown(kFALSE);
		3926	fMenuHisttype->UnCheckEntry(M_ANALYSIS_HISTTYPE_SURF);
		3927	}
		3928
		3929	delete[] surfx;
		3930	delete[] surfy;
		3931	delete[] integralCount;
		3932	}
		3933
		3934	// Change histogram when changing the channel
		3935	void TGAppMainFrame::ChangeChannel()
		3936	{
		3937	unsigned int nrfiles = fileList->GetNumberOfEntries();
		3938	TList *files;
		3939
		3940	if( nrfiles > 0 )
		3941	{
		3942	// check the newly selected file/files and return its name/their names
		3943	files = new TList();
		3944	fileList->GetSelectedEntries(files);
		3945	if(files)
		3946	{
		3947	for(int i = 0; i < (int)nrfiles; i++)
		3948	{
		3949	if(files->At(i))
		3950	{
		3951	if(debug)
		3952	printf("Filename: %s\n", files->At(i)->GetTitle());
		3953	if( fMenuHisttype->IsEntryChecked(M_ANALYSIS_HISTTYPE_1DADC) )
		3954	DisplayHistogram( (char*)(files->At(i)->GetTitle()), 0);
		3955	else if( fMenuHisttype->IsEntryChecked(M_ANALYSIS_HISTTYPE_1DTDC) )
		3956	DisplayHistogram( (char*)(files->At(i)->GetTitle()), 1);
		3957	else if( fMenuHisttype->IsEntryChecked(M_ANALYSIS_HISTTYPE_2D) )
		3958	DisplayHistogram( (char*)(files->At(i)->GetTitle()), 2);
		3959	}
		3960	}
		3961	}
		3962	}
		3963	}
		3964
		3965	// Setting a predetermined X range
		3966	void TGAppMainFrame::SetHistRange()
		3967	{
		3968	unsigned int nrfiles = fileList->GetNumberOfEntries();
		3969
		3970	if(nrfiles > 0)
		3971	{
		3972	TList *files;
		3973	files = new TList();
		3974	fileList->GetSelectedEntries(files);
		3975	if(files)
		3976	{
		3977	for(int i = 0; i < (int)nrfiles; i++)
		3978	{
		3979	if(files->At(i))
		3980	{
		3981	if(debug)
		3982	printf("Filename: %s\n", files->At(i)->GetTitle());
		3983	if( fMenuHisttype->IsEntryChecked(M_ANALYSIS_HISTTYPE_1DADC) )
		3984	DisplayHistogram( (char*)(files->At(i)->GetTitle()), 0);
		3985	else if( fMenuHisttype->IsEntryChecked(M_ANALYSIS_HISTTYPE_1DTDC) )
		3986	DisplayHistogram( (char*)(files->At(i)->GetTitle()), 1);
		3987	else if( fMenuHisttype->IsEntryChecked(M_ANALYSIS_HISTTYPE_2D) )
		3988	DisplayHistogram( (char*)(files->At(i)->GetTitle()), 2);
		3989	}
		3990	}
		3991	}
		3992	}
		3993	}
		3994
		3995	// Changing the histogram type to display
		3996	void TGAppMainFrame::ChangeHisttype(int type)
		3997	{
		3998	TGTextButton *pressedB = new TGTextButton();
		3999	int menuID = 0;
		4000	unsigned int nrfiles = fileList->GetNumberOfEntries();
		4001
		4002	// ADC histogram
		4003	if(type == 0)
		4004	{
		4005	pressedB = changeADC;
		4006	menuID = M_ANALYSIS_HISTTYPE_1DADC;
		4007
		4008	changeTDC->SetDown(kFALSE);
		4009	changeADCTDC->SetDown(kFALSE);
		4010	change2Dsurf->SetDown(kFALSE);
		4011	fMenuHisttype->UnCheckEntry(M_ANALYSIS_HISTTYPE_1DTDC);
		4012	fMenuHisttype->UnCheckEntry(M_ANALYSIS_HISTTYPE_2D);
		4013	fMenuHisttype->UnCheckEntry(M_ANALYSIS_HISTTYPE_SURF);
		4014	}
		4015	// TDC histogram
		4016	else if(type == 1)
		4017	{
		4018	pressedB = changeTDC;
		4019	menuID = M_ANALYSIS_HISTTYPE_1DTDC;
		4020
		4021	changeADC->SetDown(kFALSE);
		4022	changeADCTDC->SetDown(kFALSE);
		4023	change2Dsurf->SetDown(kFALSE);
		4024	fMenuHisttype->UnCheckEntry(M_ANALYSIS_HISTTYPE_1DADC);
		4025	fMenuHisttype->UnCheckEntry(M_ANALYSIS_HISTTYPE_2D);
		4026	fMenuHisttype->UnCheckEntry(M_ANALYSIS_HISTTYPE_SURF);
		4027	}
		4028	// ADC vs. TDC histogram
		4029	else if(type == 2)
		4030	{
		4031	pressedB = changeADCTDC;
		4032	menuID = M_ANALYSIS_HISTTYPE_2D;
		4033
		4034	changeADC->SetDown(kFALSE);
		4035	changeTDC->SetDown(kFALSE);
		4036	change2Dsurf->SetDown(kFALSE);
		4037	fMenuHisttype->UnCheckEntry(M_ANALYSIS_HISTTYPE_1DADC);
		4038	fMenuHisttype->UnCheckEntry(M_ANALYSIS_HISTTYPE_1DTDC);
		4039	fMenuHisttype->UnCheckEntry(M_ANALYSIS_HISTTYPE_SURF);
		4040	}
		4041	// Surface scan plot
		4042	else if(type == 3)
		4043	{
		4044	pressedB = change2Dsurf;
		4045	menuID = M_ANALYSIS_HISTTYPE_SURF;
		4046
		4047	changeADC->SetDown(kFALSE);
		4048	changeTDC->SetDown(kFALSE);
		4049	changeADCTDC->SetDown(kFALSE);
		4050	fMenuHisttype->UnCheckEntry(M_ANALYSIS_HISTTYPE_1DADC);
		4051	fMenuHisttype->UnCheckEntry(M_ANALYSIS_HISTTYPE_1DTDC);
		4052	fMenuHisttype->UnCheckEntry(M_ANALYSIS_HISTTYPE_2D);
		4053	}
		4054
		4055	if( fMenuHisttype->IsEntryChecked(menuID) )
		4056	{
		4057	pressedB->SetDown(kFALSE);
		4058	fMenuHisttype->UnCheckEntry(menuID);
		4059	}
		4060	else if( !fMenuHisttype->IsEntryChecked(menuID) )
		4061	{
		4062	pressedB->SetDown(kTRUE);
		4063	fMenuHisttype->CheckEntry(menuID);
		4064	}
		4065
		4066	if(nrfiles > 0)
		4067	{
		4068	// Still need to add the switch!!!
		4069	TList *files;
		4070	files = new TList();
		4071	fileList->GetSelectedEntries(files);
		4072
		4073	if(type < 3)
		4074	DisplayHistogram( (char*)(files->At(0)->GetTitle()), type);
		4075	else if(type == 3)
		4076	MakeSurfPlot( files );
		4077	}
		4078	}
		4079
		4080	// Changing the histogram type to display
		4081	void TGAppMainFrame::HistogramExport()
		4082	{
		4083	unsigned int nrfiles = fileList->GetNumberOfEntries();
		4084	TList *files;
		4085	TCanvas *gCanvas = histCanvas->GetCanvas();
		4086
		4087	char exportname[256];
		4088	char ctemp[256];
		4089
		4090	if(nrfiles > 0)
		4091	{
		4092	files = new TList();
		4093	fileList->GetSelectedEntries(files);
		4094	if(files)
		4095	{
		4096	if( fMenuHisttype->IsEntryChecked(M_ANALYSIS_HISTTYPE_SURF) ) // for the surface scan, the plot from all selected files is already created
		4097	{
		4098	remove_from_last((char*)files->At(0)->GetTitle(), '_', ctemp);
		4099	sprintf(exportname, "%s_surfscan.pdf", ctemp);
		4100	gCanvas->SaveAs(exportname);
		4101	}
		4102	else
		4103	{
		4104	for(int i = 0; i < (int)nrfiles; i++)
		4105	{
		4106	if(files->At(i))
		4107	{
		4108	remove_ext((char*)files->At(i)->GetTitle(), ctemp);
		4109
		4110	if(debug)
		4111	printf("Filename: %s\n", files->At(i)->GetTitle());
		4112	if( fMenuHisttype->IsEntryChecked(M_ANALYSIS_HISTTYPE_1DADC) )
		4113	{
		4114	sprintf(exportname, "%s_adc%d.pdf", ctemp, (int)selectCh->GetNumber());
		4115	DisplayHistogram( (char*)(files->At(i)->GetTitle()), 0);
		4116	}
		4117	else if( fMenuHisttype->IsEntryChecked(M_ANALYSIS_HISTTYPE_1DTDC) )
		4118	{
		4119	sprintf(exportname, "%s_tdc%d.pdf", ctemp, (int)selectCh->GetNumber());
		4120	DisplayHistogram( (char*)(files->At(i)->GetTitle()), 1);
		4121	}
		4122	else if( fMenuHisttype->IsEntryChecked(M_ANALYSIS_HISTTYPE_2D) )
		4123	{
		4124	sprintf(exportname, "%s_adctdc%d.pdf", ctemp, (int)selectCh->GetNumber());
		4125	DisplayHistogram( (char*)(files->At(i)->GetTitle()), 2);
		4126	}
		4127
		4128	gCanvas->SaveAs(exportname);
		4129	}
		4130	}
		4131	}
		4132	}
		4133	}
		4134	}
		4135
		4136	//---------------------------------------------------------------
		4137	// Main window constructor definition (& layout)
		4138
		4139	TGAppMainFrame::TGAppMainFrame(const TGWindow *p, int w, int h)
		4140	{
		4141	gDaq = new daq();
		4142	gScopeDaq = new daqscope();
		4143
		4144	// Define the main window and menubar
		4145	fMain = new TGMainFrame(p, w, h, kVerticalFrame); // vertical frame split into menubar and main frame
		4146	fMenuBar = new TGMdiMenuBar(fMain, 10, 10); // just prepare menubar, draw it with InitMenu()
		4147	fMain->AddFrame(fMenuBar, new TGLayoutHints(kLHintsTop \| kLHintsExpandX));
		4148
		4149	// Define the main frame where opened subwindows will appear
		4150	fMainFrame = new TGMdiMainFrame(fMain, fMenuBar, 300, 300);
		4151	fMain->AddFrame(fMainFrame, new TGLayoutHints(kLHintsExpandX \| kLHintsExpandY));
		4152
		4153	// Initialize the menubar the initial measurement layout subwindows and display the main window
		4154	InitMenu();
		4155	MeasurementLayout();
		4156	fMain->SetWindowName(WINDOW_NAME);
		4157	fMain->MapSubwindows();
		4158	fMain->MapWindow();
		4159	fMain->Layout();
		4160	GetPosition();
		4161	GetVoltOut();
		4162	}
		4163
		4164	//---------------------------------------------------------------
		4165	// Event handler for menubar actions
		4166
		4167	void TGAppMainFrame::HandleMenu(Int_t id)
		4168	{
		4169	TList *files;
		4170
		4171	switch (id) {
		4172	case M_FILE_NEW:
		4173	// Clear any values and histogram
		4174	break;
		4175
		4176	case M_FILE_EXIT:
		4177	CloseWindow();
		4178	break;
		4179
		4180	case M_ANALYSIS_HISTTYPE_1DADC:
		4181	// Toggles the ADC button
		4182	ChangeHisttype(0);
		4183	break;
		4184
		4185	case M_ANALYSIS_HISTTYPE_1DTDC:
		4186	ChangeHisttype(1);
		4187	break;
		4188
		4189	case M_ANALYSIS_HISTTYPE_2D:
		4190	ChangeHisttype(2);
		4191	break;
		4192
		4193	case M_ANALYSIS_HISTTYPE_SURF:
		4194	ChangeHisttype(3);
		4195	break;
		4196
		4197	case M_ANALYSIS_FIT:
		4198	// Fit spectrum
		4199	files = new TList();
		4200	fileList->GetSelectedEntries(files);
		4201
		4202	if( fMenuHisttype->IsEntryChecked(M_ANALYSIS_HISTTYPE_1DADC) && (files->GetSize() > 0) )
		4203	FitSpectrum(files, 1);
		4204	break;
		4205
		4206	case M_ANALYSIS_FITSEL:
		4207	// Fit all spectra
		4208	files = new TList();
		4209	fileList->GetSelectedEntries(files);
		4210
		4211	if( (fMenuHisttype->IsEntryChecked(M_ANALYSIS_HISTTYPE_1DADC)) && (files->GetSize() > 1) )
		4212	FitSpectrum(files, files->GetSize());
		4213	break;
		4214
		4215	case M_ANALYSIS_INTEGX:
		4216	// Integrate the current spectra
		4217	files = new TList();
		4218	fileList->GetSelectedEntries(files);
		4219
		4220	IntegSpectrum(files, 1);
		4221	break;
		4222
		4223	case M_ANALYSIS_INTEGY:
		4224	// Integrate the current spectra
		4225	files = new TList();
		4226	fileList->GetSelectedEntries(files);
		4227
		4228	IntegSpectrum(files, 2);
		4229	break;
		4230
		4231	case M_ANALYSIS_PHOTMU:
		4232	// Integrate the current spectra and calculate mean of detected photons: mu = -log(Nped/Ntot)
		4233	files = new TList();
		4234	fileList->GetSelectedEntries(files);
		4235
		4236	PhotonMu(files);
		4237	break;
		4238
		4239	case M_TOOLS_FIELDPOINT:
		4240	OpenWindow(1);
		4241	break;
		4242
		4243	case M_WINDOW_HOR:
		4244	fMainFrame->TileHorizontal();
		4245	break;
		4246
		4247	case M_WINDOW_VERT:
		4248	fMainFrame->TileVertical();
		4249	break;
		4250
		4251	case M_HELP_ABOUT:
		4252	About();
		4253	break;
		4254
		4255	default:
		4256	fMainFrame->SetCurrent(id);
		4257	break;
		4258	}
		4259	}
		4260
		4261	//---------------------------------------------------------------
		4262	// Initialize the main window menu
		4263
		4264	void TGAppMainFrame::InitMenu()
		4265	{
		4266	fMenuBarItemLayout = new TGLayoutHints(kLHintsTop \| kLHintsLeft, 0, 4, 0, 0);
		4267
		4268	// Popup menu in menubar for File controls
		4269	fMenuFile = new TGPopupMenu(gClient->GetRoot()); // adds a new popup menu to the menubar
		4270	fMenuFile->AddEntry(new TGHotString("&New Measurement"), M_FILE_NEW);
		4271	fMenuFile->AddSeparator();
		4272	fMenuFile->AddEntry(new TGHotString("E&xit"), M_FILE_EXIT);
		4273
		4274	// Popup menu in menubar for Analysis controls
		4275	fMenuHisttype = new TGPopupMenu(gClient->GetRoot()); // adds a cascade menu that will be incorporated into analysis controls
		4276	fMenuHisttype->AddEntry(new TGHotString("1D &ADC histogram"), M_ANALYSIS_HISTTYPE_1DADC);
		4277	fMenuHisttype->AddEntry(new TGHotString("1D &TDC histogram"), M_ANALYSIS_HISTTYPE_1DTDC);
		4278	fMenuHisttype->AddEntry(new TGHotString("&2D ADC vs. TDC histogram"), M_ANALYSIS_HISTTYPE_2D);
		4279	fMenuHisttype->AddEntry(new TGHotString("2D &surface scan plot"), M_ANALYSIS_HISTTYPE_SURF);
		4280
		4281	fMenuAnalysis = new TGPopupMenu(gClient->GetRoot()); // adds a new popup menu to the menubar
		4282	fMenuAnalysis->AddPopup(new TGHotString("&Histogram type"), fMenuHisttype);
		4283
		4284	fMenuAnalysis->AddEntry(new TGHotString("&Fit spectrum"), M_ANALYSIS_FIT);
		4285	fMenuAnalysis->AddEntry(new TGHotString("Fit &all selected"), M_ANALYSIS_FITSEL);
		4286	fMenuAnalysis->AddEntry(new TGHotString("Integrate spectrum (&X direction)"), M_ANALYSIS_INTEGX);
		4287	fMenuAnalysis->AddEntry(new TGHotString("Integrate spectrum (&Y direction)"), M_ANALYSIS_INTEGY);
		4288	fMenuAnalysis->AddEntry(new TGHotString("Relative &PDE"), M_ANALYSIS_PHOTMU);
		4289
		4290	// Popup menu in menubar for External tools
		4291	fMenuTools = new TGPopupMenu(gClient->GetRoot()); // adds a new popup menu to the menubar
		4292	fMenuTools->AddEntry(new TGHotString("&Fieldpoint temperature sensor"), M_TOOLS_FIELDPOINT);
		4293
		4294	// Popup menu in menubar for Window controls
		4295	fMenuWindow = new TGPopupMenu(gClient->GetRoot()); // adds a new popup menu to the menubar
		4296	fMenuWindow->AddEntry(new TGHotString("Tile &Horizontally"), M_WINDOW_HOR);
		4297	fMenuWindow->AddEntry(new TGHotString("Tile &Vertically"), M_WINDOW_VERT);
		4298	fMenuWindow->AddPopup(new TGHotString("&Windows"), fMainFrame->GetWinListMenu());
		4299
		4300	// Popup menu in menubar for Help controls
		4301	fMenuHelp = new TGPopupMenu(gClient->GetRoot());
		4302	fMenuHelp->AddEntry(new TGHotString("&About"), M_HELP_ABOUT);
		4303
		4304	// Connect all menu items with actions - handled by HandleMenu()
		4305	fMenuFile->Connect("Activated(Int_t)", "TGAppMainFrame", this, "HandleMenu(Int_t)");
		4306	fMenuAnalysis->Connect("Activated(Int_t)", "TGAppMainFrame", this, "HandleMenu(Int_t)");
		4307	fMenuTools->Connect("Activated(Int_t)", "TGAppMainFrame", this, "HandleMenu(Int_t)");
		4308	fMenuWindow->Connect("Activated(Int_t)", "TGAppMainFrame", this, "HandleMenu(Int_t)");
		4309	fMenuHelp->Connect("Activated(Int_t)", "TGAppMainFrame", this, "HandleMenu(Int_t)");
		4310
		4311	// Draw the created popup menus on the menubar
		4312	fMenuBar->AddPopup(new TGHotString("&File"), fMenuFile, fMenuBarItemLayout);
		4313	fMenuBar->AddPopup(new TGHotString("&Analysis"),fMenuAnalysis,fMenuBarItemLayout);
		4314	fMenuBar->AddPopup(new TGHotString("&Tools"),fMenuTools,fMenuBarItemLayout);
		4315	fMenuBar->AddPopup(new TGHotString("&Windows"),fMenuWindow,fMenuBarItemLayout);
		4316	fMenuBar->AddPopup(new TGHotString("&Help"), fMenuHelp, fMenuBarItemLayout);
		4317
		4318	// Disable fieldpoint if we are not connected to the IJS network
		4319	#if IJSNET == 0
		4320	fMenuTools->DisableEntry(M_TOOLS_FIELDPOINT);
		4321	#endif
		4322	}
		4323
		4324	//---------------------------------------------------------------
		4325	// Set the measurement subwindow layout
		4326
		4327	void TGAppMainFrame::MeasurementLayout()
		4328	{
		4329	TGMdiFrame *mdiFrame;
		4330
		4331	// Generic horizontal and vertical frames
		4332	TGHorizontalFrame fH1, fH2, *fH3;
		4333	TGVerticalFrame *fV1;
		4334	TGGroupFrame *fG1;
		4335	TGLabel *lab;
		4336	TGCompositeFrame *fT1;
		4337
		4338	// Sizes of internal group and subwindow structures
		4339	int subwin[2];
		4340	int subgroup[2];
		4341
		4342	// Settings pane ---------------------------------------------------------------------------
		4343	subwin[0] = (winWidth/6)-5; subwin[1] = 3*((winHeight/5)-5)-10;
		4344	settingsPane = new TGMdiSubwindow(fMainFrame, subwin[0], subwin[1]);
		4345	mdiFrame = settingsPane->GetMdiFrame();
		4346
		4347	// Check button to toggle voltage scan
		4348	voltscanOn = new TGCheckButton(mdiFrame, "Voltage scan ON/OFF");
		4349	voltscanOn->Resize(50,22);
		4350	voltscanOn->SetState(kButtonUp);
		4351	mdiFrame->AddFrame(voltscanOn, f0centerx);
		4352
		4353	// Check button to toggle surface scan
		4354	surfscanOn = new TGCheckButton(mdiFrame, "Surface scan ON/OFF");
		4355	surfscanOn->Resize(50,22);
		4356	surfscanOn->SetState(kButtonUp);
		4357	mdiFrame->AddFrame(surfscanOn, f0centerx);
		4358
		4359	// Check button to toggle Z direction scan
		4360	zscanOn = new TGCheckButton(mdiFrame, "Z-axis scan ON/OFF");
		4361	zscanOn->Resize(50,22);
		4362	zscanOn->SetState(kButtonUp);
		4363	mdiFrame->AddFrame(zscanOn, f0centerx);
		4364
		4365	// Check button to toggle (open) the histogram window
		4366	// histogramOn = new TGCheckButton(mdiFrame, "Histogram display ON/OFF");
		4367	// histogramOn->Resize(50,22);
		4368	// histogramOn->SetState(kButtonUp);
		4369	// mdiFrame->AddFrame(histogramOn, f0centerx);
		4370
		4371	subgroup[0] = subwin[0]-10;
		4372	// Hard limit for maximum voltage we can set
		4373	fH1 = new TGHorizontalFrame(mdiFrame, subgroup[0], 30);
		4374	lab = new TGLabel(fH1, "Voltage limit:");
		4375	fH1->AddFrame(lab, f0center2d);
		4376	vHardlimit = new TGNumberEntry(fH1, 70.00, 4, 999, TGNumberFormat::kNESRealThree, TGNumberFormat::kNEAAnyNumber);
		4377	vHardlimit->Resize(80,22);
		4378	fH1->AddFrame(vHardlimit, f0center2d);
		4379	mdiFrame->AddFrame(fH1, f2);
		4380
		4381	// Number of used channels
		4382	fH1 = new TGHorizontalFrame(mdiFrame, subgroup[0], 30);
		4383	lab = new TGLabel(fH1, "Nr. of channels:");
		4384	fH1->AddFrame(lab, f0center2d);
		4385	NCH = new TGNumberEntry(fH1, 1, 6, 999, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative, TGNumberFormat::kNELLimitMinMax, 1, 8);
		4386	NCH->Resize(40,22);
		4387	fH1->AddFrame(NCH, f0center2d);
		4388	mdiFrame->AddFrame(fH1, f2);
		4389
		4390	// Check button to toggle plots with additional information or clean plots
		4391	cleanOn = new TGCheckButton(mdiFrame, "Clean plots ON/OFF");
		4392	cleanOn->Resize(50,22);
		4393	cleanOn->SetState(kButtonDown);
		4394	cleanPlots = 1;
		4395	mdiFrame->AddFrame(cleanOn, f0centerx);
		4396
		4397	// Button and textbox to enter the oscilloscope IP address
		4398	lab = new TGLabel(mdiFrame, "Scope IP:");
		4399	mdiFrame->AddFrame(lab, f0);
		4400	fH1 = new TGHorizontalFrame(mdiFrame, subgroup[0], 30);
		4401	oscIP = new TGTextEntry(fH1, "178.172.43.157");
		4402	oscIP->Resize(110,22);
		4403	fH1->AddFrame(oscIP, f0);
		4404	oscConnect = new TGTextButton(fH1, "Connect");
		4405	oscConnect->SetTextJustify(36);
		4406	oscConnect->SetWrapLength(-1);
		4407	oscConnect->Resize(60,22);
		4408	fH1->AddFrame(oscConnect, f0);
		4409	oscOn = 0;
		4410	mdiFrame->AddFrame(fH1, f2);
		4411
		4412	// Laser settings (freq., tune, ND filter)
		4413	lab = new TGLabel(mdiFrame, "Laser settings:");
		4414	mdiFrame->AddFrame(lab, f0);
		4415	fH1 = new TGHorizontalFrame(mdiFrame, subgroup[0], 30);
		4416	laserInfo = new TGTextEntry(fH1, "kHz, tune, ND");
		4417	fH1->AddFrame(laserInfo, f2);
		4418	mdiFrame->AddFrame(fH1, f2);
		4419
		4420	// Chamber temperature (will only be manually set until we can get it directly from the chamber)
		4421	fH1 = new TGHorizontalFrame(mdiFrame, subgroup[0], 30);
		4422	lab = new TGLabel(fH1, "Chamber temp.:");
		4423	fH1->AddFrame(lab, f0center2d);
		4424	chtemp = new TGNumberEntry(fH1, 25.0, 6, 999, TGNumberFormat::kNESRealOne, TGNumberFormat::kNEAAnyNumber, TGNumberFormat::kNELLimitMinMax, -70., 150.);
		4425	chtemp->Resize(60,22);
		4426	fH1->AddFrame(chtemp, f0center2d);
		4427	mdiFrame->AddFrame(fH1, f2);
		4428
		4429	// Incidence angle (will only be manually set until we can make it motorized)
		4430	fH1 = new TGHorizontalFrame(mdiFrame, subgroup[0], 30);
		4431	lab = new TGLabel(fH1, "Incid. angle:");
		4432	fH1->AddFrame(lab, f0center2d);
		4433	incangle = new TGNumberEntry(fH1, 0.0, 6, 999, TGNumberFormat::kNESRealOne, TGNumberFormat::kNEAAnyNumber, TGNumberFormat::kNELLimitMinMax, -180., 180.);
		4434	incangle->Resize(60,22);
		4435	fH1->AddFrame(incangle, f0center2d);
		4436	mdiFrame->AddFrame(fH1, f2);
		4437
		4438	mdiFrame->SetMdiHints(kMdiMinimize);
		4439	mdiFrame->SetWindowName("Settings pane");
		4440	mdiFrame->MapSubwindows();
		4441	mdiFrame->Layout();
		4442	mdiFrame->Move(0,0);
		4443	// Settings pane ---------------------------------------------------------------------------
		4444
		4445	// Main window -----------------------------------------------------------------------------
		4446	subwin[0] = 3((winWidth/6)-5); subwin[1] = 3((winHeight/5)-5)-10;
		4447	mainSubwindow = new TGMdiSubwindow(fMainFrame, subwin[0], subwin[1]);
		4448	mdiFrame = mainSubwindow->GetMdiFrame();
		4449
		4450	// Voltage and position tab
		4451	subgroup[0] = 2*subwin[0]/5-12;
		4452	subgroup[1] = (subwin[1]+15)/2+5;
		4453	setTab = new TGTab(mdiFrame, subgroup[0], subgroup[1]);
		4454
		4455	fT1 = setTab->AddTab("Voltage + Position");
		4456
		4457	fH1 = new TGHorizontalFrame(fT1, subwin[0], subgroup[1], kFixedHeight);
		4458	// Left pane (Bias voltage controls)
		4459	fV1 = new TGVerticalFrame(fH1, subgroup[0], subgroup[1], kFixedWidth \| kFixedHeight);
		4460	fG1 = new TGGroupFrame(fV1, "Bias voltage controls");
		4461
		4462	// Output voltage supply channel
		4463	fH2 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		4464	lab = new TGLabel(fH2, "Output channel:");
		4465	fH2->AddFrame(lab, f0center2d);
		4466	vOutCh = new TGComboBox(fH2, 200);
		4467	vOutCh->AddEntry("1", 0);
		4468	vOutCh->AddEntry("2", 1);
		4469	vOutCh->AddEntry("3", 2);
		4470	vOutCh->AddEntry("4", 3);
		4471	vOutCh->AddEntry("5", 4);
		4472	vOutCh->AddEntry("6", 5);
		4473	vOutCh->AddEntry("7", 6);
		4474	vOutCh->AddEntry("8", 7);
		4475	vOutCh->AddEntry("101", 8);
		4476	vOutCh->AddEntry("102", 9);
		4477	vOutCh->AddEntry("103", 10);
		4478	vOutCh->AddEntry("104", 11);
		4479	vOutCh->AddEntry("105", 12);
		4480	vOutCh->AddEntry("106", 13);
		4481	vOutCh->AddEntry("107", 14);
		4482	vOutCh->AddEntry("108", 15);
		4483	vOutCh->Resize(50,22);
		4484	vOutCh->Select(0);
		4485	fH2->AddFrame(vOutCh, f0center2d);
		4486	fG1->AddFrame(fH2, f2);
		4487
		4488	// Output voltage setting
		4489	fH2 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		4490	lab = new TGLabel(fH2, "Output voltage:");
		4491	fH2->AddFrame(lab, f0center2d);
		4492	vOut = new TGNumberEntry(fH2, 0.00, 4, 999, TGNumberFormat::kNESRealThree, TGNumberFormat::kNEAAnyNumber, TGNumberFormat::kNELLimitMinMax, 0, vHardlimit->GetNumber());
		4493	vOut->Resize(80,22);
		4494	fH2->AddFrame(vOut, f0center2d);
		4495	fG1->AddFrame(fH2, f2);
		4496
		4497	fH2 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		4498	vOutOnOff = new TGCheckButton(fH2, "Output ON/OFF");
		4499	vOutOnOff->Resize(subgroup[0]-10,22);
		4500	vOutOnOff->SetState(kButtonUp);
		4501	fH2->AddFrame(vOutOnOff, f0centerx);
		4502	fG1->AddFrame(fH2, f2);
		4503
		4504	// Set, get and reset voltage buttons
		4505	fH2 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		4506	fH3 = new TGHorizontalFrame(fH2, subgroup[0], 30);
		4507	vOutSet = new TGTextButton(fH3, "Set");
		4508	vOutSet->SetTextJustify(36);
		4509	vOutSet->SetWrapLength(-1);
		4510	vOutSet->Resize(60,22);
		4511	fH3->AddFrame(vOutSet, f0);
		4512	vOutGet = new TGTextButton(fH3, "Get");
		4513	vOutGet->SetTextJustify(36);
		4514	vOutGet->SetWrapLength(-1);
		4515	vOutGet->Resize(60,22);
		4516	fH3->AddFrame(vOutGet, f0);
		4517	vOutReset = new TGTextButton(fH3, "Reset");
		4518	vOutReset->SetTextJustify(36);
		4519	vOutReset->SetWrapLength(-1);
		4520	vOutReset->Resize(60,22);
		4521	fH3->AddFrame(vOutReset, f0);
		4522	fH2->AddFrame(fH3, f0centerx);
		4523	fG1->AddFrame(fH2, f2);
		4524
		4525	// Voltage scan controls
		4526	fH2 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		4527	lab = new TGLabel(fH2, "V (min):");
		4528	fH2->AddFrame(lab, f0center2d);
		4529	vOutStart = new TGNumberEntry(fH2, 0.00, 4, 999, TGNumberFormat::kNESRealThree, TGNumberFormat::kNEAAnyNumber);
		4530	vOutStart->Resize(80,22);
		4531	fH2->AddFrame(vOutStart, f0center2d);
		4532	fG1->AddFrame(fH2, f2);
		4533
		4534	fH2 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		4535	lab = new TGLabel(fH2, "V (max):");
		4536	fH2->AddFrame(lab, f0center2d);
		4537	vOutStop = new TGNumberEntry(fH2, 0.00, 4, 999, TGNumberFormat::kNESRealThree, TGNumberFormat::kNEAAnyNumber);
		4538	vOutStop->Resize(80,22);
		4539	fH2->AddFrame(vOutStop, f0center2d);
		4540	fG1->AddFrame(fH2, f2);
		4541
		4542	fH2 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		4543	lab = new TGLabel(fH2, "V (step):");
		4544	fH2->AddFrame(lab, f0center2d);
		4545	vOutStep = new TGNumberEntry(fH2, 0.00, 4, 999, TGNumberFormat::kNESRealThree, TGNumberFormat::kNEAAnyNumber);
		4546	vOutStep->Resize(80,22);
		4547	fH2->AddFrame(vOutStep, f0center2d);
		4548	fG1->AddFrame(fH2, f2);
		4549
		4550	fV1->AddFrame(fG1, f1);
		4551	// Left pane (Bias voltage controls)
		4552	fH1->AddFrame(fV1, f0);
		4553
		4554	// Right pane (Table position controls)
		4555	subgroup[0] = 3*subwin[0]/5-12;
		4556	fV1 = new TGVerticalFrame(fH1, subgroup[0], subgroup[1], kFixedWidth \| kFixedHeight);
		4557	fG1 = new TGGroupFrame(fV1, "Table position controls");
		4558
		4559	// X, Y and Z positions
		4560	fH2 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		4561	lab = new TGLabel(fH2, "X:");
		4562	fH2->AddFrame(lab, f0center2d);
		4563	xPos = new TGNumberEntry(fH2, 0, 6, 999, TGNumberFormat::kNESInteger, TGNumberFormat::kNEAAnyNumber, TGNumberFormat::kNELLimitMinMax, -100, 215000);
		4564	xPos->Resize(80,22);
		4565	fH2->AddFrame(xPos, f0center2d);
		4566
		4567	lab = new TGLabel(fH2, "Z (min):");
		4568	fH2->AddFrame(lab, f0center2d);
		4569	zPosMin = new TGNumberEntry(fH2, 0, 6, 999, TGNumberFormat::kNESInteger, TGNumberFormat::kNEAAnyNumber, TGNumberFormat::kNELLimitMinMax, -100, 375000);
		4570	zPosMin->Resize(80,22);
		4571	fH2->AddFrame(zPosMin, f0center2d);
		4572	fG1->AddFrame(fH2, f2);
		4573
		4574	fH2 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		4575	lab = new TGLabel(fH2, "Y:");
		4576	fH2->AddFrame(lab, f0center2d);
		4577	yPos = new TGNumberEntry(fH2, 0, 6, 999, TGNumberFormat::kNESInteger, TGNumberFormat::kNEAAnyNumber, TGNumberFormat::kNELLimitMinMax, -100, 215000);
		4578	yPos->Resize(80,22);
		4579	fH2->AddFrame(yPos, f0center2d);
		4580
		4581	lab = new TGLabel(fH2, "Z (max):");
		4582	fH2->AddFrame(lab, f0center2d);
		4583	zPosMax = new TGNumberEntry(fH2, 0, 6, 999, TGNumberFormat::kNESInteger, TGNumberFormat::kNEAAnyNumber, TGNumberFormat::kNELLimitMinMax, -100, 375000);
		4584	zPosMax->Resize(80,22);
		4585	fH2->AddFrame(zPosMax, f0center2d);
		4586	fG1->AddFrame(fH2, f2);
		4587
		4588	fH2 = new TGHorizontalFrame(fG1, subgroup[0] ,30);
		4589	lab = new TGLabel(fH2, "Z:");
		4590	fH2->AddFrame(lab, f0center2d);
		4591	zPos = new TGNumberEntry(fH2, 0, 6, 999, TGNumberFormat::kNESInteger, TGNumberFormat::kNEAAnyNumber, TGNumberFormat::kNELLimitMinMax, -100, 375000);
		4592	zPos->Resize(80,22);
		4593	fH2->AddFrame(zPos, f0center2d);
		4594
		4595	lab = new TGLabel(fH2, "Z (step):");
		4596	fH2->AddFrame(lab, f0center2d);
		4597	zPosStep = new TGNumberEntry(fH2, 0, 6, 999, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative);
		4598	zPosStep->Resize(80,22);
		4599	fH2->AddFrame(zPosStep, f0center2d);
		4600	fG1->AddFrame(fH2, f2);
		4601
		4602	// Set, Get and Home the table position
		4603	fH2 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		4604	fH3 = new TGHorizontalFrame(fH2, subgroup[0], 30);
		4605	positionSet = new TGTextButton(fH3, "Set");
		4606	positionSet->SetTextJustify(36);
		4607	positionSet->SetWrapLength(-1);
		4608	positionSet->Resize(60,22);
		4609	fH3->AddFrame(positionSet, f0);
		4610	positionGet = new TGTextButton(fH3, "Get");
		4611	positionGet->SetTextJustify(36);
		4612	positionGet->SetWrapLength(-1);
		4613	positionGet->Resize(60,22);
		4614	fH3->AddFrame(positionGet, f0);
		4615	positionHome = new TGTextButton(fH3, "Home");
		4616	positionHome->SetTextJustify(36);
		4617	positionHome->SetWrapLength(-1);
		4618	positionHome->Resize(60,22);
		4619	fH3->AddFrame(positionHome, f0);
		4620	fH2->AddFrame(fH3, f0centerx);
		4621	fG1->AddFrame(fH2, f2);
		4622
		4623	// Position scan controls
		4624	fH2 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		4625	lab = new TGLabel(fH2, "X (min):");
		4626	fH2->AddFrame(lab, f0center2d);
		4627	xPosMin = new TGNumberEntry(fH2, 0, 6, 999, TGNumberFormat::kNESInteger, TGNumberFormat::kNEAAnyNumber, TGNumberFormat::kNELLimitMinMax, -100, 215000);
		4628	xPosMin->Resize(80,22);
		4629	fH2->AddFrame(xPosMin, f0center2d);
		4630
		4631	lab = new TGLabel(fH2, "Y (min):");
		4632	fH2->AddFrame(lab, f0center2d);
		4633	yPosMin = new TGNumberEntry(fH2, 0, 6, 999, TGNumberFormat::kNESInteger, TGNumberFormat::kNEAAnyNumber, TGNumberFormat::kNELLimitMinMax, -100, 215000);
		4634	yPosMin->Resize(80,22);
		4635	fH2->AddFrame(yPosMin, f0center2d);
		4636	fG1->AddFrame(fH2, f2);
		4637
		4638	fH2 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		4639	lab = new TGLabel(fH2, "X (max):");
		4640	fH2->AddFrame(lab, f0center2d);
		4641	xPosMax = new TGNumberEntry(fH2, 0, 6, 999, TGNumberFormat::kNESInteger, TGNumberFormat::kNEAAnyNumber, TGNumberFormat::kNELLimitMinMax, -100, 215000);
		4642	xPosMax->Resize(80,22);
		4643	fH2->AddFrame(xPosMax, f0center2d);
		4644
		4645	lab = new TGLabel(fH2, "Y (max):");
		4646	fH2->AddFrame(lab, f0center2d);
		4647	yPosMax = new TGNumberEntry(fH2, 0, 6, 999, TGNumberFormat::kNESInteger, TGNumberFormat::kNEAAnyNumber, TGNumberFormat::kNELLimitMinMax, -100, 215000);
		4648	yPosMax->Resize(80,22);
		4649	fH2->AddFrame(yPosMax, f0center2d);
		4650	fG1->AddFrame(fH2, f2);
		4651
		4652	fH2 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		4653	lab = new TGLabel(fH2, "X (step):");
		4654	fH2->AddFrame(lab, f0center2d);
		4655	xPosStep = new TGNumberEntry(fH2, 0, 6, 999, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative);
		4656	xPosStep->Resize(80,22);
		4657	fH2->AddFrame(xPosStep, f0center2d);
		4658
		4659	lab = new TGLabel(fH2, "Y (step):");
		4660	fH2->AddFrame(lab, f0center2d);
		4661	yPosStep = new TGNumberEntry(fH2, 0, 6, 999, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative);
		4662	yPosStep->Resize(80,22);
		4663	fH2->AddFrame(yPosStep, f0center2d);
		4664	fG1->AddFrame(fH2, f2);
		4665
		4666	fV1->AddFrame(fG1, f1);
		4667	// Right pane (Table position controls)
		4668	fH1->AddFrame(fV1, f0);
		4669	fT1->AddFrame(fH1, f1);
		4670
		4671	// Waveform tab
		4672	fT1 = setTab->AddTab("Waveform analysis");
		4673	fH1 = new TGHorizontalFrame(fT1, subwin[0], subgroup[1], kFixedHeight);
		4674	subgroup[0] = 1*subwin[0]/2-12;
		4675	fV1 = new TGVerticalFrame(fH1, subgroup[0], subgroup[1]/3, kFixedWidth);
		4676
		4677	fG1 = new TGGroupFrame(fV1, "Acquisition channel");
		4678
		4679	// Selection of channels
		4680	fH2 = new TGHorizontalFrame(fG1, subgroup[0], 100);
		4681	sCH[0] = new TGCheckButton(fH2, "CH1");
		4682	sCH[0]->Resize(50,22);
		4683	sCH[0]->SetState(kButtonUp);
		4684	fH2->AddFrame(sCH[0], f0centerx);
		4685	sCH[1] = new TGCheckButton(fH2, "CH2");
		4686	sCH[1]->Resize(50,22);
		4687	sCH[1]->SetState(kButtonUp);
		4688	fH2->AddFrame(sCH[1], f0centerx);
		4689	sCH[2] = new TGCheckButton(fH2, "CH3");
		4690	sCH[2]->Resize(50,22);
		4691	sCH[2]->SetState(kButtonUp);
		4692	fH2->AddFrame(sCH[2], f0centerx);
		4693	sCH[3] = new TGCheckButton(fH2, "CH4");
		4694	sCH[3]->Resize(50,22);
		4695	sCH[3]->SetState(kButtonUp);
		4696	fH2->AddFrame(sCH[3], f0centerx);
		4697	fG1->AddFrame(fH2, f0centerx);
		4698
		4699	// Selection of MATH channels
		4700	fH2 = new TGHorizontalFrame(fG1, subgroup[0], 100);
		4701	sCH[4] = new TGCheckButton(fH2, "MATH1");
		4702	sCH[4]->Resize(50,22);
		4703	sCH[4]->SetState(kButtonUp);
		4704	fH2->AddFrame(sCH[4], f0centerx);
		4705	sCH[5] = new TGCheckButton(fH2, "MATH2");
		4706	sCH[5]->Resize(50,22);
		4707	sCH[5]->SetState(kButtonUp);
		4708	fH2->AddFrame(sCH[5], f0centerx);
		4709	sCH[6] = new TGCheckButton(fH2, "MATH3");
		4710	sCH[6]->Resize(50,22);
		4711	sCH[6]->SetState(kButtonUp);
		4712	fH2->AddFrame(sCH[6], f0centerx);
		4713	sCH[7] = new TGCheckButton(fH2, "MATH4");
		4714	sCH[7]->Resize(50,22);
		4715	sCH[7]->SetState(kButtonUp);
		4716	fH2->AddFrame(sCH[7], f0centerx);
		4717	fG1->AddFrame(fH2, f0centerx);
		4718
		4719	fV1->AddFrame(fG1, f2);
		4720
		4721	// Selection of measurement type
		4722	fH2 = new TGHorizontalFrame(fV1, subgroup[0], 30);
		4723	lab = new TGLabel(fH2, "Scope use type:");
		4724	fH2->AddFrame(lab, f0center2d);
		4725	sMeasType = new TGComboBox(fH2, 200);
		4726	sMeasType->AddEntry("No waveform analysis", 0);
		4727	sMeasType->AddEntry("Waveform acquisition", 1);
		4728	sMeasType->AddEntry("Measurement", 2);
		4729	sMeasType->Resize(150,22);
		4730	sMeasType->Select(0);
		4731	fH2->AddFrame(sMeasType, f0center2d);
		4732	fV1->AddFrame(fH2, f2);
		4733
		4734	// Link waveform analysis to CAMAC acquisition
		4735	sCamaclink = new TGCheckButton(fV1, "Link waveform to CAMAC acquisition");
		4736	sCamaclink->Resize(200,22);
		4737	sCamaclink->SetState(kButtonUp);
		4738	fV1->AddFrame(sCamaclink, f0centerx);
		4739
		4740	// Custom command interface for the scope
		4741	lab = new TGLabel(fV1, "Custom scope command:");
		4742	fV1->AddFrame(lab, new TGLayoutHints(kLHintsLeft \| kLHintsTop,2,2,10,2) );
		4743	fH2 = new TGHorizontalFrame(fV1, subgroup[0], 30);
		4744	scopeCommand = new TGTextEntry(fH2, "");
		4745	scopeCommand->Resize(subgroup[0]-45,22);
		4746	fH2->AddFrame(scopeCommand, f2);
		4747	sendScopeCustom = new TGTextButton(fH2, "Send");
		4748	sendScopeCustom->SetTextJustify(36);
		4749	sendScopeCustom->SetWrapLength(-1);
		4750	sendScopeCustom->Resize(80,22);
		4751	fH2->AddFrame(sendScopeCustom, f0centery);
		4752	fV1->AddFrame(fH2, f0);
		4753
		4754	// Return value for custom scope command
		4755	lab = new TGLabel(fV1, "Return:");
		4756	fV1->AddFrame(lab, new TGLayoutHints(kLHintsLeft \| kLHintsTop,2,2,10,2) );
		4757	scopeReturn = new TGTextEntry(fV1, "");
		4758	scopeReturn->Resize(subgroup[0],22);
		4759	fV1->AddFrame(scopeReturn, f2);
		4760
		4761	fH1->AddFrame(fV1, f0);
		4762
		4763	// Wave measurement type
		4764	fV1 = new TGVerticalFrame(fH1, subgroup[0], subgroup[1]/3, kFixedWidth);
		4765	fH2 = new TGHorizontalFrame(fV1, subgroup[0], 30);
		4766	lab = new TGLabel(fH2, "Meas. type:");
		4767	fH2->AddFrame(lab, f0center2d);
		4768	sMeasgroup = new TGComboBox(fH2, 200);
		4769	for(int i = 0; i < 11; i++)
		4770	sMeasgroup->AddEntry(allMeasNames[i], i);
		4771	sMeasgroup->Resize(150,22);
		4772	sMeasgroup->Select(4);
		4773	fH2->AddFrame(sMeasgroup, f0center2d);
		4774	fV1->AddFrame(fH2, f2);
		4775
		4776	// Initialize current acquisition settings
		4777	scopeInit = new TGTextButton(fV1, "Initialize scope");
		4778	scopeInit->SetTextJustify(36);
		4779	scopeInit->SetWrapLength(-1);
		4780	scopeInit->Resize(80,22);
		4781	fV1->AddFrame(scopeInit, f0centerx);
		4782
		4783	fH1->AddFrame(fV1, f0);
		4784	fT1->AddFrame(fH1, f1);
		4785
		4786	mdiFrame->AddFrame(setTab, f0);
		4787
		4788	// Bottom pane (File controls)
		4789	subgroup[0] = subwin[0]-20;
		4790	subgroup[1] = subwin[1]/3-30; //2(3((winWidth/6)-5))/5+10;
		4791	fH1 = new TGHorizontalFrame(mdiFrame, subgroup[0], subgroup[1] /1(3((winWidth/6)-5))/5+15/ , kFixedWidth \| kFixedHeight);
		4792	fG1 = new TGGroupFrame(fH1, "Event/Data file controls");
		4793
		4794	// Number of events
		4795	fH2 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		4796	lab = new TGLabel(fH2, "Number of events:");
		4797	fH2->AddFrame(lab, f0centery);
		4798	evtNum = new TGNumberEntry(fH2, 10000, 6, 999, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative);
		4799	evtNum->Resize(80,22);
		4800	fH2->AddFrame(evtNum, f0centery);
		4801	fG1->AddFrame(fH2, f2);
		4802
		4803	// Time stamp display
		4804	fH2 = new TGHorizontalFrame(fG1,600,200);
		4805	lab = new TGLabel(fH2, "Time stamp:");
		4806	fH2->AddFrame(lab, f0centery);
		4807	timeStamp = new TGTextEntry(fH2, "");
		4808	timeStamp->Resize(440,22);
		4809	timeStamp->SetState(kFALSE); // time stamp is read-only
		4810	fH2->AddFrame(timeStamp, f0centery);
		4811	fG1->AddFrame(fH2, f2);
		4812
		4813	// Save to file
		4814	fH2 = new TGHorizontalFrame(fG1,600,200);
		4815	lab = new TGLabel(fH2, "Save to file:");
		4816	fH2->AddFrame(lab, f0centery);
		4817	char *cTemp;
		4818	cTemp = new char[256];
		4819	sprintf(cTemp, "./results/test%s", histExt);
		4820	fileName = new TGTextEntry(fH2, cTemp);
		4821	delete[] cTemp;
		4822	fileName->Resize(400,22);
		4823	fileName->SetState(kFALSE);
		4824	fH2->AddFrame(fileName, f0centery);
		4825	saveFile = new TGTextButton(fH2, "...");
		4826	saveFile->SetTextJustify(36);
		4827	saveFile->SetWrapLength(-1);
		4828	saveFile->Resize(80,22);
		4829	fH2->AddFrame(saveFile, f0centery);
		4830	// mdiFrame->AddFrame(fH2, f0);
		4831	fG1->AddFrame(fH2, f2);
		4832	fH1->AddFrame(fG1, f1);
		4833	// Bottom pane (File controls)
		4834	mdiFrame->AddFrame(fH1, f0);
		4835
		4836	subgroup[0] = subwin[0]-70;
		4837	fH1 = new TGHorizontalFrame(mdiFrame, subgroup[0], 30);
		4838	fH2 = new TGHorizontalFrame(fH1, 3*subgroup[0]/4, 30, kFixedWidth);
		4839	measStart = new TGTextButton(fH2, "Start acquisition");
		4840	measStart->SetTextJustify(36);
		4841	measStart->SetWrapLength(-1);
		4842	measStart->Resize(80,22);
		4843	fH2->AddFrame(measStart, f0center2d);
		4844
		4845	ULong_t fcolor;
		4846	gClient->GetColorByName("red", fcolor);
		4847
		4848	busyLabel = new TGLabel(fH2, "Busy"); //, fTextGC->GetGC(), labelfont, kChildFrame);
		4849	busyLabel->SetTextJustify(36);
		4850	busyLabel->Resize(80,22);
		4851	busyLabel->Disable();
		4852	busyLabel->SetTextColor(fcolor);
		4853	fH2->AddFrame(busyLabel, f0center2d);
		4854
		4855	curProgress = new TGHProgressBar(fH2, TGProgressBar::kStandard, 150);
		4856	curProgress->ShowPosition();
		4857	curProgress->SetRange(0,100);
		4858	curProgress->SetBarColor("green");
		4859	fH2->AddFrame(curProgress, f0center2d);
		4860	fH1->AddFrame(fH2, f0centerx);
		4861	mdiFrame->AddFrame(fH1, f2);
		4862
		4863	mdiFrame->SetMdiHints(kMdiMinimize \| kMdiMaximize);
		4864	mdiFrame->SetWindowName("Main measurement window");
		4865	mdiFrame->MapSubwindows();
		4866	mdiFrame->Layout();
		4867	mdiFrame->Move((winWidth/6),0);
		4868	// Main window -----------------------------------------------------------------------------
		4869
		4870	// Histogram pane --------------------------------------------------------------------------
		4871	subwin[0] = 2((winWidth/6)-5); subwin[1] = (int)(2.5((winHeight/5)-5))-5;
		4872	histogramPane = new TGMdiSubwindow(fMainFrame, subwin[0], subwin[1]);
		4873	mdiFrame = histogramPane->GetMdiFrame();
		4874
		4875	histCanvas = new TRootEmbeddedCanvas("histCanvas",mdiFrame,900,900);
		4876	mdiFrame->AddFrame(histCanvas, f1);
		4877	TCanvas *gCanvas = histCanvas->GetCanvas();
		4878	gCanvas->SetGridx();
		4879	gCanvas->SetGridy();
		4880
		4881	mdiFrame->SetMdiHints(kMdiMinimize \| kMdiMaximize);
		4882	mdiFrame->SetWindowName("Histogram");
		4883	mdiFrame->MapSubwindows();
		4884	mdiFrame->Layout();
		4885	mdiFrame->Move(4*((winWidth/6)-5)+10,0);
		4886	// Histogram pane --------------------------------------------------------------------------
		4887
		4888	// Histogram file selection pane -----------------------------------------------------------
		4889	subwin[0] = 4((winWidth/6)-5); subwin[1] = 2((winHeight/5)-5)+15;
		4890	histogramPaneFile = new TGMdiSubwindow(fMainFrame, subwin[0]+5, subwin[1]);
		4891	mdiFrame = histogramPaneFile->GetMdiFrame();
		4892
		4893	// Open browser for file selection
		4894	subgroup[0] = subwin[0]-10;
		4895	fH1 = new TGHorizontalFrame(mdiFrame, subgroup[0], 30);
		4896	lab = new TGLabel(fH1, "File selection:");
		4897	fH1->AddFrame(lab, f0centery);
		4898
		4899	selectDir = new TGTextButton(fH1, "...");
		4900	selectDir->SetTextJustify(36);
		4901	selectDir->SetWrapLength(-1);
		4902	selectDir->Resize(80,22);
		4903	fH1->AddFrame(selectDir, f0centery);
		4904	mdiFrame->AddFrame(fH1, f2);
		4905
		4906	// List view of the opened files
		4907	fileList = new TGListBox(mdiFrame,1);
		4908	fileList->GetVScrollbar();
		4909	fileList->Resize(300, (3*subwin[1]/7)-10 );
		4910	mdiFrame->AddFrame(fileList, f2);
		4911
		4912	// Multiple file selection toggle, previous/next controls, clear list and edit header
		4913	fH1 = new TGHorizontalFrame(mdiFrame, subgroup[0], 30);
		4914	multiSelect = new TGCheckButton(fH1, "Multiple file select");
		4915	multiSelect->Resize(50,22);
		4916	multiSelect->SetState(kButtonUp);
		4917	fH1->AddFrame(multiSelect, f0);
		4918
		4919	multiSelectAll = new TGCheckButton(fH1, "Select all listed files");
		4920	multiSelectAll->Resize(50,22);
		4921	multiSelectAll->SetState(kButtonUp);
		4922	fH1->AddFrame(multiSelectAll, f0);
		4923
		4924	TGTextButton *clearList = new TGTextButton(fH1, "Clear list");
		4925	clearList->SetTextJustify(36);
		4926	clearList->SetWrapLength(-1);
		4927	clearList->Resize(80,22);
		4928	fH1->AddFrame(clearList, f0right);
		4929
		4930	TGTextButton *editHeader = new TGTextButton(fH1, "Edit header");
		4931	editHeader->SetTextJustify(36);
		4932	editHeader->SetWrapLength(-1);
		4933	editHeader->Resize(80,22);
		4934	fH1->AddFrame(editHeader, f0right);
		4935
		4936	nextFile = new TGTextButton(fH1, ">>");
		4937	nextFile->SetTextJustify(36);
		4938	nextFile->SetWrapLength(-1);
		4939	nextFile->Resize(80,22);
		4940	fH1->AddFrame(nextFile, f0right);
		4941
		4942	prevFile = new TGTextButton(fH1, "<<");
		4943	prevFile->SetTextJustify(36);
		4944	prevFile->SetWrapLength(-1);
		4945	prevFile->Resize(80,22);
		4946	fH1->AddFrame(prevFile, f0right);
		4947	mdiFrame->AddFrame(fH1, f2);
		4948
		4949	// Header information of opened file
		4950	fG1 = new TGGroupFrame(mdiFrame, "Opened file header information");
		4951	fH1 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		4952	lab = new TGLabel(fH1, "Time:");
		4953	fH1->AddFrame(lab, f0centery);
		4954	disptime = new TGTextEntry(fH1, "");
		4955	disptime->Resize(440,22);
		4956	disptime->SetState(kFALSE);
		4957	fH1->AddFrame(disptime, f0centery);
		4958	fG1->AddFrame(fH1, f2);
		4959
		4960	fH1 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		4961	lab = new TGLabel(fH1, "Bias voltage:");
		4962	fH1->AddFrame(lab, f0centery);
		4963	dispbias = new TGNumberEntry(fH1, 0.00, 4, 999, TGNumberFormat::kNESRealThree, TGNumberFormat::kNEAAnyNumber);
		4964	dispbias->Resize(80,22);
		4965	dispbias->SetState(kFALSE);
		4966	fH1->AddFrame(dispbias, f0centery);
		4967
		4968	lab = new TGLabel(fH1, "Position:");
		4969	fH1->AddFrame(lab, f0centery);
		4970	disppos = new TGTextEntry(fH1, "");
		4971	disppos->Resize(200,22);
		4972	disppos->SetState(kFALSE);
		4973	fH1->AddFrame(disppos, f0centery);
		4974
		4975	lab = new TGLabel(fH1, "Temperature:");
		4976	fH1->AddFrame(lab, f0centery);
		4977	disptemp = new TGNumberEntry(fH1, 0.0, 6, 999, TGNumberFormat::kNESRealOne, TGNumberFormat::kNEAAnyNumber);
		4978	disptemp->Resize(80,22);
		4979	disptemp->SetState(kFALSE);
		4980	fH1->AddFrame(disptemp, f0centery);
		4981
		4982	lab = new TGLabel(fH1, "Angle:");
		4983	fH1->AddFrame(lab, f0centery);
		4984	dispangle = new TGNumberEntry(fH1, 0.0, 6, 999, TGNumberFormat::kNESRealOne, TGNumberFormat::kNEAAnyNumber);
		4985	dispangle->Resize(80,22);
		4986	dispangle->SetState(kFALSE);
		4987	fH1->AddFrame(dispangle, f0centery);
		4988	fG1->AddFrame(fH1, f2);
		4989
		4990	fH1 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		4991	lab = new TGLabel(fH1, "Laser settings:");
		4992	fH1->AddFrame(lab, f0centery);
		4993	displaser = new TGTextEntry(fH1, "");
		4994	displaser->Resize(440,22);
		4995	displaser->SetState(kFALSE);
		4996	fH1->AddFrame(displaser, f0centery);
		4997	fG1->AddFrame(fH1, f2);
		4998	mdiFrame->AddFrame(fG1, f2);
		4999
		5000	mdiFrame->SetMdiHints(kMdiMinimize);
		5001	mdiFrame->SetWindowName("Histogram file selection");
		5002	mdiFrame->MapSubwindows();
		5003	mdiFrame->Layout();
		5004	mdiFrame->Move(0,3*((winHeight/5)-5)-5);
		5005	// Histogram file selection pane -----------------------------------------------------------
		5006
		5007	// Histogram controls pane -----------------------------------------------------------------
		5008	subwin[0] = 2((winWidth/6)-5); subwin[1] = (int)(2.5((winHeight/5)-5))+10;
		5009	histogramPaneCtr = new TGMdiSubwindow(fMainFrame, subwin[0], subwin[1]);
		5010	mdiFrame = histogramPaneCtr->GetMdiFrame();
		5011
		5012	// Control for histogram X range
		5013	subgroup[0] = subwin[0]-6;
		5014	fG1 = new TGGroupFrame(mdiFrame, "Histogram display");
		5015	fH1 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		5016	lab = new TGLabel(fH1, "ADC range (min, max):");
		5017	fH1->AddFrame(lab, f0centery);
		5018	adcMinRange = new TGNumberEntry(fH1, 0, 6, 999, TGNumberFormat::kNESInteger, TGNumberFormat::kNEAAnyNumber);
		5019	adcMinRange->Resize(80,22);
		5020	fH1->AddFrame(adcMinRange, f0centery);
		5021	adcMaxRange = new TGNumberEntry(fH1, 0, 6, 999, TGNumberFormat::kNESInteger, TGNumberFormat::kNEAAnyNumber);
		5022	adcMaxRange->Resize(80,22);
		5023	fH1->AddFrame(adcMaxRange, f0centery);
		5024	fG1->AddFrame(fH1, f2);
		5025
		5026	// TDC window for getting data
		5027	fH1 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		5028	lab = new TGLabel(fH1, "TDC range (min, max):");
		5029	fH1->AddFrame(lab, f0centery);
		5030	tdcMinwindow = new TGNumberEntry(fH1, 0.0, 6, 999, TGNumberFormat::kNESRealTwo, TGNumberFormat::kNEAAnyNumber);
		5031	tdcMinwindow->Resize(80,22);
		5032	fH1->AddFrame(tdcMinwindow, f0centery);
		5033	tdcMaxwindow = new TGNumberEntry(fH1, 221.8, 6, 999, TGNumberFormat::kNESRealTwo, TGNumberFormat::kNEAAnyNumber);
		5034	tdcMaxwindow->Resize(80,22);
		5035	fH1->AddFrame(tdcMaxwindow, f0centery);
		5036	fG1->AddFrame(fH1, f2);
		5037
		5038	// Y axis range settings
		5039	fH1 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		5040	lab = new TGLabel(fH1, "Y range (min, max):");
		5041	fH1->AddFrame(lab, f0centery);
		5042	yMinRange = new TGNumberEntry(fH1, 0, 6, 999, TGNumberFormat::kNESRealOne, TGNumberFormat::kNEAAnyNumber);
		5043	yMinRange->Resize(80,22);
		5044	fH1->AddFrame(yMinRange, f0centery);
		5045	yMaxRange = new TGNumberEntry(fH1, 0, 6, 999, TGNumberFormat::kNESRealOne, TGNumberFormat::kNEAAnyNumber);
		5046	yMaxRange->Resize(80,22);
		5047	fH1->AddFrame(yMaxRange, f0centery);
		5048	fG1->AddFrame(fH1, f2);
		5049
		5050	// Select the channel to display
		5051	fH1 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		5052	lab = new TGLabel(fH1, "Display channel:");
		5053	fH1->AddFrame(lab, f0centery);
		5054	selectCh = new TGNumberEntry(fH1, 0, 6, 999, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative, TGNumberFormat::kNELLimitMinMax, 0, (NCH->GetNumber())-1);
		5055	selectCh->Resize(40,22);
		5056	fH1->AddFrame(selectCh, f0centery);
		5057
		5058	changeADC = new TGTextButton(fH1, "ADC");
		5059	changeADC->AllowStayDown(kTRUE);
		5060	changeADC->SetDown(kTRUE);
		5061	fMenuHisttype->CheckEntry(M_ANALYSIS_HISTTYPE_1DADC);
		5062	changeADC->SetTextJustify(36);
		5063	changeADC->SetWrapLength(-1);
		5064	changeADC->Resize(60,22);
		5065	fH1->AddFrame(changeADC, f0centery);
		5066
		5067	changeTDC = new TGTextButton(fH1, "TDC");
		5068	changeTDC->AllowStayDown(kTRUE);
		5069	changeTDC->SetTextJustify(36);
		5070	changeTDC->SetWrapLength(-1);
		5071	changeTDC->Resize(60,22);
		5072	fH1->AddFrame(changeTDC, f0centery);
		5073
		5074	changeADCTDC = new TGTextButton(fH1, "ADC/TDC");
		5075	changeADCTDC->AllowStayDown(kTRUE);
		5076	changeADCTDC->SetTextJustify(36);
		5077	changeADCTDC->SetWrapLength(-1);
		5078	changeADCTDC->Resize(60,22);
		5079	fH1->AddFrame(changeADCTDC, f0centery);
		5080
		5081	change2Dsurf = new TGTextButton(fH1, "Surf 2D");
		5082	change2Dsurf->AllowStayDown(kTRUE);
		5083	change2Dsurf->SetTextJustify(36);
		5084	change2Dsurf->SetWrapLength(-1);
		5085	change2Dsurf->Resize(60,22);
		5086	fH1->AddFrame(change2Dsurf, f0);
		5087	fG1->AddFrame(fH1, f2);
		5088
		5089	logscale = new TGCheckButton(fG1, "Logarithmic scale ON/OFF");
		5090	logscale->Resize(50,22);
		5091	logscale->SetState(kButtonUp);
		5092	fG1->AddFrame(logscale, f0centerx);
		5093
		5094	// Export the selected files
		5095	fH1 = new TGHorizontalFrame(fG1, subgroup[0], 100);
		5096	fH2 = new TGHorizontalFrame(fH1, subgroup[0], 100);
		5097	lab = new TGLabel(fH2, "Export selected histograms:");
		5098	fH2->AddFrame(lab, f0centery);
		5099
		5100	exportHist = new TGTextButton(fH2, "Export");
		5101	exportHist->SetTextJustify(36);
		5102	exportHist->SetWrapLength(-1);
		5103	exportHist->Resize(80,22);
		5104	fH2->AddFrame(exportHist, f0centery);
		5105	fH1->AddFrame(fH2, f0centerx);
		5106	fG1->AddFrame(fH1, f2);
		5107	mdiFrame->AddFrame(fG1, f2);
		5108
		5109	// Fitting controls for ADC spectrum
		5110	fG1 = new TGGroupFrame(mdiFrame, "Fit Settings");
		5111	fH1 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		5112	fH2 = new TGHorizontalFrame(fH1, subgroup[0], 30);
		5113	lab = new TGLabel(fH2, "Peak sigma:");
		5114	fH2->AddFrame(lab, f0centery);
		5115	fitSigma = new TGNumberEntry(fH2, 1.2, 3, 999, TGNumberFormat::kNESRealThree, TGNumberFormat::kNEANonNegative);
		5116	fitSigma->Resize(60,22);
		5117	fH2->AddFrame(fitSigma, f0centery);
		5118
		5119	lab = new TGLabel(fH2, " Signal/Noise treshold:");
		5120	fH2->AddFrame(lab, f0centery);
		5121	fitTresh = new TGNumberEntry(fH2, 5.0E-3, 3, 999, TGNumberFormat::kNESReal, TGNumberFormat::kNEANonNegative);
		5122	fitTresh->Resize(60,22);
		5123	fH2->AddFrame(fitTresh, f0centery);
		5124	fH1->AddFrame(fH2, f0centerx);
		5125	fG1->AddFrame(fH1, f2);
		5126
		5127	fH1 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		5128	fH2 = new TGHorizontalFrame(fH1, subgroup[0], 30);
		5129	lab = new TGLabel(fH2, "Background interpolation:");
		5130	fH2->AddFrame(lab, f0centery);
		5131	fitInter = new TGNumberEntry(fH2, 7, 3, 999, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative);
		5132	fitInter->Resize(60,22);
		5133	fH2->AddFrame(fitInter, f0centery);
		5134	fH1->AddFrame(fH2, f0centerx);
		5135	fG1->AddFrame(fH1, f2);
		5136
		5137	fH1 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		5138	fH2 = new TGHorizontalFrame(fH1, subgroup[0], 30);
		5139	lab = new TGLabel(fH2, "Peak fit max. acceptable error:");
		5140	fH2->AddFrame(lab, f0centery);
		5141	accError = new TGNumberEntry(fH2, 0.15, 3, 999, TGNumberFormat::kNESRealTwo, TGNumberFormat::kNEANonNegative);
		5142	accError->Resize(60,22);
		5143	fH2->AddFrame(accError, f0centery);
		5144	fH1->AddFrame(fH2, f0centerx);
		5145	fG1->AddFrame(fH1, f2);
		5146
		5147	fH1 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		5148	fH2 = new TGHorizontalFrame(fH1, subgroup[0], 30);
		5149	lab = new TGLabel(fH2, "Peak min. limit:");
		5150	fH2->AddFrame(lab, f0centery);
		5151	minPeak = new TGNumberEntry(fH2, 4, 3, 999, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative, TGNumberFormat::kNELLimitMinMax, 2, 20);
		5152	minPeak->Resize(50,22);
		5153	fH2->AddFrame(minPeak, f0centery);
		5154
		5155	lab = new TGLabel(fH2, " Pedestal lower limit:");
		5156	fH2->AddFrame(lab, f0centery);
		5157	pedesLow = new TGNumberEntry(fH2, 0.00, 3, 999, TGNumberFormat::kNESRealTwo, TGNumberFormat::kNEANonNegative);
		5158	pedesLow->Resize(60,22);
		5159	fH2->AddFrame(pedesLow, f0centery);
		5160	fH1->AddFrame(fH2, f0centerx);
		5161	fG1->AddFrame(fH1, f2);
		5162
		5163	exfitplots = new TGCheckButton(fG1, "Export fitting plots ON/OFF");
		5164	exfitplots->Resize(50,22);
		5165	exfitplots->SetState(kButtonUp);
		5166	fG1->AddFrame(exfitplots, f0centerx);
		5167	mdiFrame->AddFrame(fG1, f2);
		5168
		5169	mdiFrame->SetMdiHints(kMdiMinimize);
		5170	mdiFrame->SetWindowName("Histogram controls");
		5171	mdiFrame->MapSubwindows();
		5172	mdiFrame->Layout();
		5173	mdiFrame->Move(4((winWidth/6)-5)+10,(int)(2.5((winHeight/5)-5)));
		5174	// Histogram controls pane -----------------------------------------------------------------
		5175
		5176	// Action connections
		5177	voltscanOn->Connect("Clicked()", "TGAppMainFrame", this, "EnableVoltScan()");
		5178	surfscanOn->Connect("Clicked()", "TGAppMainFrame", this, "EnableSurfScan()");
		5179	zscanOn->Connect("Clicked()", "TGAppMainFrame", this, "EnableZaxisScan()");
		5180	// histogramOn->Connect("Clicked()", "TGAppMainFrame", this, "HistogramToggle()");
		5181	vHardlimit->Connect("ValueSet(Long_t)", "TGAppMainFrame", this, "VoltageLimit()");
		5182	(vHardlimit->GetNumberEntry())->Connect("ReturnPressed()", "TGAppMainFrame", this, "VoltageLimit()");
		5183	NCH->Connect("ValueSet(Long_t)", "TGAppMainFrame", this, "ChannelLimit()");
		5184	(NCH->GetNumberEntry())->Connect("ReturnPressed()", "TGAppMainFrame", this, "ChannelLimit()");
		5185	cleanOn->Connect("Clicked()", "TGAppMainFrame", this, "CleanPlotToggle()");
		5186	oscConnect->Connect("Clicked()", "TGAppMainFrame", this, "ConnectToScope()");
		5187	vOutSet->Connect("Clicked()", "TGAppMainFrame", this, "SetVoltOut()");
		5188	vOutGet->Connect("Clicked()", "TGAppMainFrame", this, "GetVoltOut()");
		5189	vOutReset->Connect("Clicked()", "TGAppMainFrame", this, "ResetVoltOut()");
		5190	positionSet->Connect("Clicked()", "TGAppMainFrame", this, "SetPosition()");
		5191	positionGet->Connect("Clicked()", "TGAppMainFrame", this, "GetPosition()");
		5192	positionHome->Connect("Clicked()", "TGAppMainFrame", this, "HomePosition()");
		5193	saveFile->Connect("Clicked()", "TGAppMainFrame", this, "SaveFile()");
		5194	measStart->Connect("Clicked()", "TGAppMainFrame", this, "StartAcq()");
		5195	selectDir->Connect("Clicked()", "TGAppMainFrame", this, "SelectDirectory()");
		5196	multiSelect->Connect("Clicked()", "TGAppMainFrame", this, "ListMultiSelect()");
		5197	multiSelectAll->Connect("Clicked()", "TGAppMainFrame", this, "ListSelectAll()");
		5198	editHeader->Connect("Clicked()", "TGAppMainFrame", this, "HeaderEdit()");
		5199	prevFile->Connect("Clicked()", "TGAppMainFrame", this, "FileListNavigation(=-2)");
		5200	nextFile->Connect("Clicked()", "TGAppMainFrame", this, "FileListNavigation(=-3)");
		5201	fileList->Connect("DoubleClicked(Int_t)", "TGAppMainFrame", this, "FileListNavigation(Int_t)");
		5202	clearList->Connect("Clicked()", "TGListBox", fileList, "RemoveAll()");
		5203
		5204	adcMinRange->Connect("ValueSet(Long_t)", "TGAppMainFrame", this, "SetHistRange()");
		5205	(adcMinRange->GetNumberEntry())->Connect("ReturnPressed()", "TGAppMainFrame", this, "SetHistRange()");
		5206	adcMaxRange->Connect("ValueSet(Long_t)", "TGAppMainFrame", this, "SetHistRange()");
		5207	(adcMaxRange->GetNumberEntry())->Connect("ReturnPressed()", "TGAppMainFrame", this, "SetHistRange()");
		5208	yMinRange->Connect("ValueSet(Long_t)", "TGAppMainFrame", this, "SetHistRange()");
		5209	(yMinRange->GetNumberEntry())->Connect("ReturnPressed()", "TGAppMainFrame", this, "SetHistRange()");
		5210	yMaxRange->Connect("ValueSet(Long_t)", "TGAppMainFrame", this, "SetHistRange()");
		5211	(yMaxRange->GetNumberEntry())->Connect("ReturnPressed()", "TGAppMainFrame", this, "SetHistRange()");
		5212	tdcMinwindow->Connect("ValueSet(Long_t)", "TGAppMainFrame", this, "SetHistRange()");
		5213	(tdcMinwindow->GetNumberEntry())->Connect("ReturnPressed()", "TGAppMainFrame", this, "SetHistRange()");
		5214	tdcMaxwindow->Connect("ValueSet(Long_t)", "TGAppMainFrame", this, "SetHistRange()");
		5215	(tdcMaxwindow->GetNumberEntry())->Connect("ReturnPressed()", "TGAppMainFrame", this, "SetHistRange()");
		5216	changeADC->Connect("Clicked()", "TGAppMainFrame", this, "ChangeHisttype(=0)");
		5217	changeTDC->Connect("Clicked()", "TGAppMainFrame", this, "ChangeHisttype(=1)");
		5218	changeADCTDC->Connect("Clicked()", "TGAppMainFrame", this, "ChangeHisttype(=2)");
		5219	change2Dsurf->Connect("Clicked()", "TGAppMainFrame", this, "ChangeHisttype(=3)");
		5220	selectCh->Connect("ValueSet(Long_t)", "TGAppMainFrame", this, "ChangeChannel()");
		5221	(selectCh->GetNumberEntry())->Connect("ReturnPressed()", "TGAppMainFrame", this, "ChangeChannel()");
		5222	logscale->Connect("Clicked()", "TGAppMainFrame", this, "SetHistRange()");
		5223	exportHist->Connect("Clicked()", "TGAppMainFrame", this, "HistogramExport()");
		5224
		5225	scopeInit->Connect("Clicked()", "TGAppMainFrame", this, "InitializeScope()");
		5226	sendScopeCustom->Connect("Clicked()", "TGAppMainFrame", this, "CustomScopeCommand()");
		5227	sMeasType->Connect("Selected(Int_t)", "TGAppMainFrame", this, "SelectedMeasType(Int_t)");
		5228
		5229	started = kFALSE;
		5230
		5231	for(int i = 0; i < 8; i++) sCH[i]->SetEnabled(kFALSE);
		5232	sMeasType->SetEnabled(kFALSE);
		5233	sCamaclink->SetEnabled(kFALSE);
		5234	scopeCommand->SetEnabled(kFALSE);
		5235	sendScopeCustom->SetEnabled(kFALSE);
		5236	sMeasgroup->SetEnabled(kFALSE);
		5237	scopeInit->SetEnabled(kFALSE);
		5238
		5239	EnableVoltScan();
		5240	EnableSurfScan();
		5241	EnableZaxisScan();
		5242
		5243	// Testing canvas for scope waveforms
		5244	wCanvas = new TCanvas("wCanvas", "Waveform canvas", 600, 300);
		5245	}
		5246
		5247	//---------------------------------------------------------------
		5248	// Opening a new subwindow
		5249
		5250	void TGAppMainFrame::OpenWindow(int winid)
		5251	{
		5252	/* WinID:
		5253	* - 1 = fieldpoint temperature sensor
		5254	* - 2 = file header editor
		5255	*/
		5256
		5257	TGMdiFrame *mdiFrame;
		5258
		5259	// Generic horizontal and vertical frames
		5260	TGHorizontalFrame fH1, fH2;
		5261	TGGroupFrame *fG1;
		5262	TGLabel *lab;
		5263
		5264	int subwin[2];
		5265	int subgroup[2];
		5266
		5267	char ctemp[256];
		5268
		5269	// Fieldpoint pane -------------------------------------------------------------------------
		5270	if(winid == 1)
		5271	{
		5272	time_t rtime;
		5273	int yearrange[2];
		5274
		5275	subwin[0] = 3((winWidth/4)-5); subwin[1] = (int)(2((winHeight/3)-5))+10;
		5276	fieldpointPane = new TGMdiSubwindow(fMainFrame, subwin[0], subwin[1]);
		5277	mdiFrame = fieldpointPane->GetMdiFrame();
		5278
		5279	subgroup[0] = subwin[0]-10;
		5280	subgroup[1] = 7*subwin[1]/12;
		5281
		5282	// Display canvas for temperature sensor
		5283	displayCanvas = new TRootEmbeddedCanvas("displayCanvas",mdiFrame,subgroup[0],subgroup[1]);
		5284	mdiFrame->AddFrame(displayCanvas, f0centerx);
		5285	TCanvas *gCanvas = displayCanvas->GetCanvas();
		5286	gCanvas->SetGridx();
		5287	gCanvas->SetGridy();
		5288
		5289	fG1 = new TGGroupFrame(mdiFrame, "Temperature sensor settings");
		5290	// Channel selector
		5291	fH1 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		5292	lab = new TGLabel(fH1, "Fieldpoint channel:");
		5293	fH1->AddFrame(lab, f0centery);
		5294	tempCh = new TGComboBox(fH1, 200);
		5295	tempCh->AddEntry("0", 0);
		5296	tempCh->AddEntry("1", 1);
		5297	tempCh->AddEntry("2", 2);
		5298	tempCh->AddEntry("3", 3);
		5299	tempCh->AddEntry("4", 4);
		5300	tempCh->AddEntry("5", 5);
		5301	tempCh->AddEntry("6", 6);
		5302	tempCh->AddEntry("7", 7);
		5303	tempCh->Resize(50,22);
		5304	tempCh->Select(1);
		5305	fH1->AddFrame(tempCh, f0centery);
		5306	fG1->AddFrame(fH1, f2);
		5307
		5308	// Start and stop time ------------------------
		5309	time(&rtime);
		5310
		5311	lab = new TGLabel(fG1, "Start time:");
		5312	fG1->AddFrame(lab, f0);
		5313	fH1 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		5314	// Start day
		5315	lab = new TGLabel(fH1, "\tDay: ");
		5316	fH1->AddFrame(lab, f0centery);
		5317	tempDay[0] = new TGComboBox(fH1, 200);
		5318	for(int i = 0; i < 31; i++)
		5319	{
		5320	sprintf(ctemp, "%d", i+1);
		5321	tempDay[0]->AddEntry(ctemp, i);
		5322	}
		5323	tempDay[0]->Resize(50,22);
		5324	tempDay[0]->Select((int)(localtime(&rtime))->tm_mday-1);
		5325	fH1->AddFrame(tempDay[0], f0centery);
		5326
		5327	// Start month
		5328	lab = new TGLabel(fH1, " Month: ");
		5329	fH1->AddFrame(lab, f0centery);
		5330	tempMonth[0] = new TGComboBox(fH1, 200);
		5331	tempMonth[0]->AddEntry("January", 0);
		5332	tempMonth[0]->AddEntry("February", 1);
		5333	tempMonth[0]->AddEntry("March", 2);
		5334	tempMonth[0]->AddEntry("April", 3);
		5335	tempMonth[0]->AddEntry("May", 4);
		5336	tempMonth[0]->AddEntry("June", 5);
		5337	tempMonth[0]->AddEntry("July", 6);
		5338	tempMonth[0]->AddEntry("August", 7);
		5339	tempMonth[0]->AddEntry("September", 8);
		5340	tempMonth[0]->AddEntry("October", 9);
		5341	tempMonth[0]->AddEntry("November", 10);
		5342	tempMonth[0]->AddEntry("December", 11);
		5343	tempMonth[0]->Resize(80,22);
		5344	tempMonth[0]->Select((int)(localtime(&rtime))->tm_mon);
		5345	fH1->AddFrame(tempMonth[0], f0centery);
		5346
		5347	// Start year
		5348	yearrange[0] = 2010;
		5349	yearrange[1] = (int)(localtime(&rtime))->tm_year+1900;
		5350
		5351	lab = new TGLabel(fH1, " Year: ");
		5352	fH1->AddFrame(lab, f0centery);
		5353	tempYear[0] = new TGComboBox(fH1, 200);
		5354	for(int i = 0; i < (yearrange[1]-yearrange[0])+1; i++)
		5355	{
		5356	sprintf(ctemp, "%d", yearrange[1]-i);
		5357	tempYear[0]->AddEntry(ctemp, i);
		5358	}
		5359	tempYear[0]->Resize(60,22);
		5360	tempYear[0]->Select(0);
		5361	fH1->AddFrame(tempYear[0], f0centery);
		5362
		5363	// Start hour
		5364	lab = new TGLabel(fH1, " Hour: ");
		5365	fH1->AddFrame(lab, f0centery);
		5366	tempHour[0] = new TGComboBox(fH1, 200);
		5367	for(int i = 0; i < 24; i++)
		5368	{
		5369	if(i < 10)
		5370	sprintf(ctemp, "0%d", i);
		5371	else
		5372	sprintf(ctemp, "%d", i);
		5373	tempHour[0]->AddEntry(ctemp, i);
		5374	}
		5375	tempHour[0]->Resize(50,22);
		5376	tempHour[0]->Select(7);
		5377	fH1->AddFrame(tempHour[0], f0centery);
		5378
		5379	// Start minute
		5380	lab = new TGLabel(fH1, " Minute: ");
		5381	fH1->AddFrame(lab, f0centery);
		5382	tempMinute[0] = new TGComboBox(fH1, 200);
		5383	for(int i = 0; i < 60; i++)
		5384	{
		5385	if(i < 10)
		5386	sprintf(ctemp, "0%d", i);
		5387	else
		5388	sprintf(ctemp, "%d", i);
		5389	tempMinute[0]->AddEntry(ctemp, i);
		5390	}
		5391	tempMinute[0]->Resize(50,22);
		5392	tempMinute[0]->Select(0);
		5393	fH1->AddFrame(tempMinute[0], f0centery);
		5394
		5395	// Start second
		5396	lab = new TGLabel(fH1, " Second: ");
		5397	fH1->AddFrame(lab, f0centery);
		5398	tempSecond[0] = new TGComboBox(fH1, 200);
		5399	for(int i = 0; i < 60; i++)
		5400	{
		5401	if(i < 10)
		5402	sprintf(ctemp, "0%d", i);
		5403	else
		5404	sprintf(ctemp, "%d", i);
		5405	tempSecond[0]->AddEntry(ctemp, i);
		5406	}
		5407	tempSecond[0]->Resize(50,22);
		5408	tempSecond[0]->Select(0);
		5409	fH1->AddFrame(tempSecond[0], f0centery);
		5410
		5411	// Get start time from file
		5412	lab = new TGLabel(fH1, " ");
		5413	fH1->AddFrame(lab, f0centery);
		5414	tempFile[0] = new TGTextButton(fH1, "Get from file...");
		5415	tempFile[0]->SetTextJustify(36);
		5416	tempFile[0]->SetWrapLength(-1);
		5417	tempFile[0]->Resize(100,22);
		5418	fH1->AddFrame(tempFile[0], f0centery);
		5419
		5420	fG1->AddFrame(fH1, f2);
		5421
		5422	// Use the end time or not
		5423	tempEndOn = new TGCheckButton(fG1, "Draw to last time point (ON/OFF)");
		5424	tempEndOn->Resize(100,22);
		5425	tempEndOn->SetState(kButtonUp);
		5426	fG1->AddFrame(tempEndOn, f0);
		5427
		5428	lab = new TGLabel(fG1, "End time:");
		5429	fG1->AddFrame(lab, f0);
		5430	fH1 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		5431	// End day
		5432	lab = new TGLabel(fH1, "\tDay: ");
		5433	fH1->AddFrame(lab, f0centery);
		5434	tempDay[1] = new TGComboBox(fH1, 200);
		5435	for(int i = 0; i < 31; i++)
		5436	{
		5437	sprintf(ctemp, "%d", i+1);
		5438	tempDay[1]->AddEntry(ctemp, i);
		5439	}
		5440	tempDay[1]->Resize(50,22);
		5441	tempDay[1]->Select((int)(localtime(&rtime))->tm_mday-1);
		5442	fH1->AddFrame(tempDay[1], f0centery);
		5443
		5444	// End month
		5445	lab = new TGLabel(fH1, " Month: ");
		5446	fH1->AddFrame(lab, f0centery);
		5447	tempMonth[1] = new TGComboBox(fH1, 200);
		5448	tempMonth[1]->AddEntry("January", 0);
		5449	tempMonth[1]->AddEntry("February", 1);
		5450	tempMonth[1]->AddEntry("March", 2);
		5451	tempMonth[1]->AddEntry("April", 3);
		5452	tempMonth[1]->AddEntry("May", 4);
		5453	tempMonth[1]->AddEntry("June", 5);
		5454	tempMonth[1]->AddEntry("July", 6);
		5455	tempMonth[1]->AddEntry("August", 7);
		5456	tempMonth[1]->AddEntry("September", 8);
		5457	tempMonth[1]->AddEntry("October", 9);
		5458	tempMonth[1]->AddEntry("November", 10);
		5459	tempMonth[1]->AddEntry("December", 11);
		5460	tempMonth[1]->Resize(80,22);
		5461	tempMonth[1]->Select((int)(localtime(&rtime))->tm_mon);
		5462	fH1->AddFrame(tempMonth[1], f0centery);
		5463
		5464	// End year
		5465	time(&rtime);
		5466	yearrange[0] = 2010;
		5467	yearrange[1] = (int)(localtime(&rtime))->tm_year+1900;
		5468
		5469	lab = new TGLabel(fH1, " Year: ");
		5470	fH1->AddFrame(lab, f0centery);
		5471	tempYear[1] = new TGComboBox(fH1, 200);
		5472	for(int i = 0; i < (yearrange[1]-yearrange[0])+1; i++)
		5473	{
		5474	sprintf(ctemp, "%d", yearrange[1]-i);
		5475	tempYear[1]->AddEntry(ctemp, i);
		5476	}
		5477	tempYear[1]->Resize(60,22);
		5478	tempYear[1]->Select(0);
		5479	fH1->AddFrame(tempYear[1], f0centery);
		5480
		5481	// End hour
		5482	lab = new TGLabel(fH1, " Hour: ");
		5483	fH1->AddFrame(lab, f0centery);
		5484	tempHour[1] = new TGComboBox(fH1, 200);
		5485	for(int i = 0; i < 24; i++)
		5486	{
		5487	if(i < 10)
		5488	sprintf(ctemp, "0%d", i);
		5489	else
		5490	sprintf(ctemp, "%d", i);
		5491	tempHour[1]->AddEntry(ctemp, i);
		5492	}
		5493	tempHour[1]->Resize(50,22);
		5494	tempHour[1]->Select(18);
		5495	fH1->AddFrame(tempHour[1], f0centery);
		5496
		5497	// End minute
		5498	lab = new TGLabel(fH1, " Minute: ");
		5499	fH1->AddFrame(lab, f0centery);
		5500	tempMinute[1] = new TGComboBox(fH1, 200);
		5501	for(int i = 0; i < 60; i++)
		5502	{
		5503	if(i < 10)
		5504	sprintf(ctemp, "0%d", i);
		5505	else
		5506	sprintf(ctemp, "%d", i);
		5507	tempMinute[1]->AddEntry(ctemp, i);
		5508	}
		5509	tempMinute[1]->Resize(50,22);
		5510	tempMinute[1]->Select(0);
		5511	fH1->AddFrame(tempMinute[1], f0centery);
		5512
		5513	// End second
		5514	lab = new TGLabel(fH1, " Second: ");
		5515	fH1->AddFrame(lab, f0centery);
		5516	tempSecond[1] = new TGComboBox(fH1, 200);
		5517	for(int i = 0; i < 60; i++)
		5518	{
		5519	if(i < 10)
		5520	sprintf(ctemp, "0%d", i);
		5521	else
		5522	sprintf(ctemp, "%d", i);
		5523	tempSecond[1]->AddEntry(ctemp, i);
		5524	}
		5525	tempSecond[1]->Resize(50,22);
		5526	tempSecond[1]->Select(0);
		5527	fH1->AddFrame(tempSecond[1], f0centery);
		5528
		5529	// Get start time from file
		5530	lab = new TGLabel(fH1, " ");
		5531	fH1->AddFrame(lab, f0centery);
		5532	tempFile[1] = new TGTextButton(fH1, "Get from file...");
		5533	tempFile[1]->SetTextJustify(36);
		5534	tempFile[1]->SetWrapLength(-1);
		5535	tempFile[1]->Resize(100,22);
		5536	fH1->AddFrame(tempFile[1], f0centery);
		5537
		5538	fG1->AddFrame(fH1, f2);
		5539	// Start and stop time ------------------------
		5540
		5541	// Control buttons
		5542	fH2 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		5543	fH1 = new TGHorizontalFrame(fH2, subgroup[0], 30);
		5544	updateTemp = new TGTextButton(fH1, "Update");
		5545	updateTemp->SetTextJustify(36);
		5546	updateTemp->SetWrapLength(-1);
		5547	updateTemp->Resize(80,22);
		5548	fH1->AddFrame(updateTemp, f0);
		5549
		5550	exportTemp = new TGTextButton(fH1, "Export");
		5551	exportTemp->SetTextJustify(36);
		5552	exportTemp->SetWrapLength(-1);
		5553	exportTemp->Resize(80,22);
		5554	fH1->AddFrame(exportTemp, f0);
		5555
		5556	/* closeTemp = new TGTextButton(fH1, "Close");
		5557	closeTemp->SetTextJustify(36);
		5558	closeTemp->SetWrapLength(-1);
		5559	closeTemp->Resize(80,22);
		5560	fH1->AddFrame(closeTemp, f0);*/
		5561	fH2->AddFrame(fH1, f0centerx);
		5562
		5563	fG1->AddFrame(fH2, f2);
		5564
		5565	mdiFrame->AddFrame(fG1, f1);
		5566
		5567	mdiFrame->SetMdiHints(kMdiMinimize \| kMdiMaximize \| kMdiClose);
		5568	mdiFrame->SetWindowName("Fieldpoint FP RTD 122 temperature sensor");
		5569	mdiFrame->MapSubwindows();
		5570	mdiFrame->Layout();
		5571	mdiFrame->Move(1((winWidth/12)-5)+10,(int)(1((winHeight/12)-5)));
		5572
		5573	// Action connections
		5574	updateTemp->Connect("Clicked()", "TGAppMainFrame", this, "UpdateTempPlot()");
		5575	tempEndOn->Connect("Clicked()", "TGAppMainFrame", this, "TempEndToggle()");
		5576	exportTemp->Connect("Clicked()", "TGAppMainFrame", this, "ExportTempPlot()");
		5577	tempFile[0]->Connect("Clicked()", "TGAppMainFrame", this, "GetTempFile(=0)");
		5578	tempFile[1]->Connect("Clicked()", "TGAppMainFrame", this, "GetTempFile(=1)");
		5579	// closeTemp->Connect("Clicked()", "TGAppMainFrame", this, "UpdateTempPlot()");
		5580	}
		5581	// Fieldpoint pane -------------------------------------------------------------------------
		5582	//
		5583	// Header editor pane ----------------------------------------------------------------------
		5584	else if(winid == 2)
		5585	{
		5586	subwin[0] = 12((winWidth/16)-5); subwin[1] = (int)(1((winHeight/3)-10));
		5587	headerPane = new TGMdiSubwindow(fMainFrame, subwin[0], subwin[1]);
		5588	mdiFrame = headerPane->GetMdiFrame();
		5589
		5590	subgroup[0] = subwin[0]-10;
		5591	subgroup[1] = 7*subwin[1]/12;
		5592
		5593	// Changing header info (no timestamp change possible)
		5594	fG1 = new TGGroupFrame(mdiFrame, "Header edit information");
		5595	fH1 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		5596	biasedittick = new TGCheckButton(fH1, "Bias voltage edit: ");
		5597	biasedittick->Resize(80,22);
		5598	biasedittick->SetState(kButtonUp);
		5599	fH1->AddFrame(biasedittick, f0centerx);
		5600	biasedit = new TGNumberEntry(fH1, 0.00, 4, 999, TGNumberFormat::kNESRealThree, TGNumberFormat::kNEANonNegative);
		5601	biasedit->Resize(80,22);
		5602	biasedit->SetState(kFALSE);
		5603	fH1->AddFrame(biasedit, f0centery);
		5604	fG1->AddFrame(fH1, f0);
		5605
		5606	fH1 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		5607	posedittick = new TGCheckButton(fH1, "Table position edit (X, Y, Z): ");
		5608	posedittick->Resize(80,22);
		5609	posedittick->SetState(kButtonUp);
		5610	fH1->AddFrame(posedittick, f0centerx);
		5611	for(int i = 0; i < 3; i++)
		5612	{
		5613	posedit[i] = new TGNumberEntry(fH1, 0, 6, 999, TGNumberFormat::kNESInteger, TGNumberFormat::kNEAAnyNumber);
		5614	posedit[i]->Resize(80,22);
		5615	posedit[i]->SetState(kFALSE);
		5616	fH1->AddFrame(posedit[i], f0centery);
		5617	}
		5618	fG1->AddFrame(fH1, f0);
		5619
		5620	fH1 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		5621	tempedittick = new TGCheckButton(fH1, "Chamber temperature edit: ");
		5622	tempedittick->Resize(80,22);
		5623	tempedittick->SetState(kButtonUp);
		5624	fH1->AddFrame(tempedittick, f0centerx);
		5625	tempedit = new TGNumberEntry(fH1, 0.00, 6, 999, TGNumberFormat::kNESRealOne, TGNumberFormat::kNEAAnyNumber);
		5626	tempedit->Resize(80,22);
		5627	tempedit->SetState(kFALSE);
		5628	fH1->AddFrame(tempedit, f0centery);
		5629	fG1->AddFrame(fH1, f0);
		5630
		5631	fH1 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		5632	angleedittick = new TGCheckButton(fH1, "Incidence angle edit: ");
		5633	angleedittick->Resize(80,22);
		5634	angleedittick->SetState(kButtonUp);
		5635	fH1->AddFrame(angleedittick, f0centerx);
		5636	angleedit = new TGNumberEntry(fH1, 0.00, 6, 999, TGNumberFormat::kNESRealOne, TGNumberFormat::kNEAAnyNumber);
		5637	angleedit->Resize(80,22);
		5638	angleedit->SetState(kFALSE);
		5639	fH1->AddFrame(angleedit, f0centery);
		5640	fG1->AddFrame(fH1, f0);
		5641
		5642	fH1 = new TGHorizontalFrame(fG1, subgroup[0], 30);
		5643	laseredittick = new TGCheckButton(fH1, "Laser settings edit: ");
		5644	laseredittick->Resize(80,22);
		5645	laseredittick->SetState(kButtonUp);
		5646	fH1->AddFrame(laseredittick, f0centerx);
		5647	laseredit = new TGTextEntry(fH1, "");
		5648	laseredit->Resize(440,22);
		5649	laseredit->SetState(kFALSE);
		5650	fH1->AddFrame(laseredit, f0centery);
		5651	fG1->AddFrame(fH1, f0);
		5652
		5653	ULong_t fcolor;
		5654	gClient->GetColorByName("red", fcolor);
		5655
		5656	lab = new TGLabel(fG1, "Note: Tick checkbox in front of each header information you wish to change (for security, they are unticked by default).");
		5657	fG1->AddFrame(lab, f0centerx);
		5658	lab = new TGLabel(fG1, "Warning: Using button \"Edit header\" will edit headers in all files currently selected in the Histogram file selection window.");
		5659	lab->SetTextColor(fcolor);
		5660	fG1->AddFrame(lab, f0centerx);
		5661
		5662	mdiFrame->AddFrame(fG1, f2);
		5663
		5664	editHead = new TGTextButton(mdiFrame, "Edit header");
		5665	editHead->SetTextJustify(36);
		5666	editHead->SetWrapLength(-1);
		5667	editHead->Resize(80,22);
		5668	mdiFrame->AddFrame(editHead, f0centerx);
		5669
		5670	mdiFrame->SetMdiHints(kMdiMinimize \| kMdiMaximize \| kMdiClose);
		5671	mdiFrame->SetWindowName("Edit datafile header");
		5672	mdiFrame->MapSubwindows();
		5673	mdiFrame->Layout();
		5674	mdiFrame->Move(1((winWidth/12)-5)-30,(int)(1((winHeight/12)-5)));
		5675
		5676	// Action connections
		5677	biasedittick->Connect("Clicked()", "TGAppMainFrame", this, "EditTickToggle(=1)");
		5678	posedittick->Connect("Clicked()", "TGAppMainFrame", this, "EditTickToggle(=2)");
		5679	tempedittick->Connect("Clicked()", "TGAppMainFrame", this, "EditTickToggle(=3)");
		5680	angleedittick->Connect("Clicked()", "TGAppMainFrame", this, "EditTickToggle(=4)");
		5681	laseredittick->Connect("Clicked()", "TGAppMainFrame", this, "EditTickToggle(=5)");
		5682	editHead->Connect("Clicked()", "TGAppMainFrame", this, "headeredit()");
		5683	/* updateTemp->Connect("Clicked()", "TGAppMainFrame", this, "UpdateTempPlot()");
		5684	tempEndOn->Connect("Clicked()", "TGAppMainFrame", this, "TempEndToggle()");
		5685	exportTemp->Connect("Clicked()", "TGAppMainFrame", this, "ExportTempPlot()");
		5686	tempFile[0]->Connect("Clicked()", "TGAppMainFrame", this, "GetTempFile(=0)");
		5687	tempFile[1]->Connect("Clicked()", "TGAppMainFrame", this, "GetTempFile(=1)");
		5688	*/ }
		5689	// Header editor pane ----------------------------------------------------------------------
		5690	//
		5691	else
		5692	printf("Window not implemented yet.\n");
		5693	}
		5694
		5695	//---------------------------------------------------------------
		5696	// Closing the main application window and checking the about information
		5697
		5698	void TGAppMainFrame::CloseWindow()
		5699	{
		5700	gApplication->Terminate(0);
		5701	}
		5702
		5703	Bool_t TGAppMainFrame::About()
		5704	{
		5705	int ret = 0;
		5706
		5707	new TGMsgBox(gClient->GetRoot(), fMain,
		5708	fMain->GetWindowName(), "This is an application.",
		5709	kMBIconQuestion, kMBClose, &ret);
		5710
		5711	if(debug == 1)
		5712	if(ret == kMBClose)
		5713	printf("Closing the About window (%d).\n", ret);
		5714
		5715	return kFALSE;
		5716	}
		5717
		5718	//---------------------------------------------------------------
		5719	// Subwindow constructor definition (& layout) and close subwindow action
		5720
		5721	TGMdiSubwindow::TGMdiSubwindow(TGMdiMainFrame *main, int w, int h)
		5722	{
		5723	// Create a new subwindow
		5724	fMdiFrame = new TGMdiFrame(main, w, h);
		5725	fMdiFrame->Connect("CloseWindow()", "TGMdiSubwindow", this, "CloseWindow()"); // setting here to =0 -> will always ask before closing window
		5726	fMdiFrame->DontCallClose(); // only let this window close if Yes is pressed when closing window
		5727
		5728	}
		5729
		5730	Bool_t TGMdiSubwindow::CloseWindow()
		5731	{
		5732	/* int ret = 0;
		5733
		5734	new TGMsgBox(gClient->GetRoot(), fMdiFrame,
		5735	fMdiFrame->GetWindowName(), "Really want to close the window?",
		5736	kMBIconExclamation, kMBYes \| kMBNo, &ret);
		5737	if (ret == kMBYes) return fMdiFrame->CloseWindow();
		5738
		5739	return kFALSE;*/
		5740	return fMdiFrame->CloseWindow();
		5741	}
		5742
		5743	//---------------------------------------------------------------
		5744	// Main function
		5745
		5746	void windowed_test()
		5747	{
		5748	new TGAppMainFrame(gClient->GetRoot(), winWidth, winHeight);
		5749	}
		5750
		5751	//#ifdef STANDALONE
		5752	int main(int argc, char **argv)
		5753	{
		5754	TApplication theApp("MdiTest", &argc, argv);
		5755
		5756	windowed_test();
		5757
		5758	theApp.Run();
		5759
		5760	return 0;
		5761	}
		5762	//#endif

Subversion Repositories f9daq

(root)/lab/sipmscan/trunk_v0.9/windowed_test.C – Rev 145