Subversion Repositories f9daq

Rev

Rev 167 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 167 Rev 172
1
#include "../include/sipmscan.h"
1
#include "../include/sipmscan.h"
2
#include "../include/workstation.h"
2
#include "../include/workstation.h"
3
 
3
 
4
#include <stdio.h>
4
#include <stdio.h>
5
#include <stdlib.h>
5
#include <stdlib.h>
6
 
6
 
7
int retTemp;
7
int retTemp;
8
 
8
 
9
// Additional functions -------------------------------------
9
// Additional functions -------------------------------------
10
 
10
 
11
// Display the currently selected histogram in the file list
11
// Display the currently selected histogram in the file list
12
void TGAppMainFrame::DisplayHistogram(char *histfile, int histtype, int opt)
12
void TGAppMainFrame::DisplayHistogram(char *histfile, int histtype, int opt)
13
{
13
{
14
   char histtime[256];
14
   char histtime[256];
15
   char ctemp[512];
15
   char ctemp[512];
16
 
16
 
17
   if(DBGSIG)
17
   if(DBGSIG)
18
      printf("DisplayHistogram(): Selected file: %s\n", histfile);
18
      printf("DisplayHistogram(): Selected file: %s\n", histfile);
19
 
19
 
20
   TCanvas *gCanvas = analysisCanvas->GetCanvas();
20
   TCanvas *gCanvas = analysisCanvas->GetCanvas();
21
 
21
 
22
   inroot = TFile::Open(histfile, "READ");
22
   inroot = TFile::Open(histfile, "READ");
23
 
23
 
24
   TTree *header_data, *meas_data;
24
   TTree *header_data, *meas_data;
25
   inroot->GetObject("header_data", header_data);
25
   inroot->GetObject("header_data", header_data);
26
   inroot->GetObject("meas_data", meas_data);
26
   inroot->GetObject("meas_data", meas_data);
27
 
27
 
28
   // Reading the header
28
   // Reading the header
29
   header_data->SetBranchAddress("nrch", &evtheader.nrch);
29
   header_data->SetBranchAddress("nrch", &evtheader.nrch);
30
   header_data->GetEntry(0);
30
   header_data->GetEntry(0);
31
   header_data->SetBranchAddress("timestamp", &evtheader.timestamp);
31
   header_data->SetBranchAddress("timestamp", &evtheader.timestamp);
32
   header_data->GetEntry(0);
32
   header_data->GetEntry(0);
33
   header_data->SetBranchAddress("biasvolt", &evtheader.biasvolt);
33
   header_data->SetBranchAddress("biasvolt", &evtheader.biasvolt);
34
   header_data->GetEntry(0);
34
   header_data->GetEntry(0);
35
   header_data->SetBranchAddress("xpos", &evtheader.xpos);
35
   header_data->SetBranchAddress("xpos", &evtheader.xpos);
36
   header_data->GetEntry(0);
36
   header_data->GetEntry(0);
37
   header_data->SetBranchAddress("ypos", &evtheader.ypos);
37
   header_data->SetBranchAddress("ypos", &evtheader.ypos);
38
   header_data->GetEntry(0);
38
   header_data->GetEntry(0);
39
   header_data->SetBranchAddress("zpos", &evtheader.zpos);
39
   header_data->SetBranchAddress("zpos", &evtheader.zpos);
40
   header_data->GetEntry(0);
40
   header_data->GetEntry(0);
41
   header_data->SetBranchAddress("temperature", &evtheader.temperature);
41
   header_data->SetBranchAddress("temperature", &evtheader.temperature);
42
   header_data->GetEntry(0);
42
   header_data->GetEntry(0);
43
   if( header_data->FindBranch("angle") )
43
   if( header_data->FindBranch("angle") )
44
   {
44
   {
45
      header_data->SetBranchAddress("angle", &evtheader.angle);
45
      header_data->SetBranchAddress("angle", &evtheader.angle);
46
      header_data->GetEntry(0);
46
      header_data->GetEntry(0);
47
   }
47
   }
48
   header_data->SetBranchAddress("laserinfo", &evtheader.laserinfo);
48
   header_data->SetBranchAddress("laserinfo", &evtheader.laserinfo);
49
   header_data->GetEntry(0);
49
   header_data->GetEntry(0);
50
 
50
 
51
   // Change timestamp to local time
51
   // Change timestamp to local time
52
   GetTime(evtheader.timestamp, histtime);
52
   GetTime(evtheader.timestamp, histtime);
53
 
53
 
54
   // Displaying header information debug
54
   // Displaying header information debug
55
   if(DBGSIG)
55
   if(DBGSIG)
56
   {
56
   {
57
      printf("DisplayHistogram(): Opened file header information:\n");
57
      printf("DisplayHistogram(): Opened file header information:\n");
58
      printf("- Number of channels (ADC and TDC are considered as separate channels): %d\n", evtheader.nrch);
58
      printf("- Number of channels (ADC and TDC are considered as separate channels): %d\n", evtheader.nrch);
59
      printf("- Timestamp: %d (%s)\n", evtheader.timestamp, histtime);
59
      printf("- Timestamp: %d (%s)\n", evtheader.timestamp, histtime);
60
      printf("- Bias voltage: %lf\n", evtheader.biasvolt);
60
      printf("- Bias voltage: %lf\n", evtheader.biasvolt);
61
      printf("- Table position (X,Y,Z): %d, %d, %d\n", evtheader.xpos, evtheader.ypos, evtheader.zpos);
61
      printf("- Table position (X,Y,Z): %d, %d, %d\n", evtheader.xpos, evtheader.ypos, evtheader.zpos);
62
      if(evtheader.temperature)
62
      if(evtheader.temperature)
63
         printf("- Temperature: %lf\n", evtheader.temperature);
63
         printf("- Temperature: %lf\n", evtheader.temperature);
64
      if( header_data->FindBranch("angle") )
64
      if( header_data->FindBranch("angle") )
65
         printf("- Incidence angle: %lf\n", evtheader.angle);
65
         printf("- Incidence angle: %lf\n", evtheader.angle);
66
      else
66
      else
67
         printf("- Incidence angle: No angle information!\n");
67
         printf("- Incidence angle: No angle information!\n");
68
      printf("- Laser and filter settings: %s\n", evtheader.laserinfo);
68
      printf("- Laser and filter settings: %s\n", evtheader.laserinfo);
69
   }
69
   }
70
 
70
 
71
   // Displaying header information on the GUI
71
   // Displaying header information on the GUI
72
   dispTime->widgetTE->SetText(histtime);
72
   dispTime->widgetTE->SetText(histtime);
73
   dispBias->widgetNE[0]->SetNumber(evtheader.biasvolt);
73
   dispBias->widgetNE[0]->SetNumber(evtheader.biasvolt);
74
   sprintf(ctemp, "%d, %d, %d", evtheader.xpos, evtheader.ypos, evtheader.zpos);
74
   sprintf(ctemp, "%d, %d, %d", evtheader.xpos, evtheader.ypos, evtheader.zpos);
75
   dispPos->widgetTE->SetText(ctemp);
75
   dispPos->widgetTE->SetText(ctemp);
76
   if(evtheader.temperature)
76
   if(evtheader.temperature)
77
      dispTemp->widgetNE[0]->SetNumber(evtheader.temperature);
77
      dispTemp->widgetNE[0]->SetNumber(evtheader.temperature);
78
   else
78
   else
79
      dispTemp->widgetNE[0]->SetNumber(0.0);
79
      dispTemp->widgetNE[0]->SetNumber(0.0);
80
   if( header_data->FindBranch("angle") )
80
   if( header_data->FindBranch("angle") )
81
      dispAngle->widgetNE[0]->SetNumber(evtheader.angle);
81
      dispAngle->widgetNE[0]->SetNumber(evtheader.angle);
82
   else
82
   else
83
      dispAngle->widgetNE[0]->SetNumber(0.0);
83
      dispAngle->widgetNE[0]->SetNumber(0.0);
84
   dispLaser->widgetTE->SetText(evtheader.laserinfo);
84
   dispLaser->widgetTE->SetText(evtheader.laserinfo);
85
 
85
 
86
   selectCh->widgetNE[0]->SetLimitValues(0, (evtheader.nrch/2)-1);
86
   selectCh->widgetNE[0]->SetLimitValues(0, (evtheader.nrch/2)-1);
87
 
87
 
88
   // Redraw the histograms
88
   // Redraw the histograms
89
   int j;
89
   int j;
90
   char rdc[256];
90
   char rdc[256];
91
   char rdcsel[256];
91
   char rdcsel[256];
92
 
92
 
93
   j = selectCh->widgetNE[0]->GetNumber();
93
   j = selectCh->widgetNE[0]->GetNumber();
94
 
94
 
95
   printf("Found %d data points.\n", (int)meas_data->GetEntries());
95
   printf("Found %d data points.\n", (int)meas_data->GetEntries());
96
 
96
 
97
   gCanvas->cd();
97
   gCanvas->cd();
98
   double range[4];
98
   double range[4];
99
   range[0] = adcRange->widgetNE[0]->GetNumber();
99
   range[0] = adcRange->widgetNE[0]->GetNumber();
100
   range[1] = adcRange->widgetNE[1]->GetNumber();
100
   range[1] = adcRange->widgetNE[1]->GetNumber();
101
   range[2] = tdcRange->widgetNE[0]->GetNumber();
101
   range[2] = tdcRange->widgetNE[0]->GetNumber();
102
   range[3] = tdcRange->widgetNE[1]->GetNumber();
102
   range[3] = tdcRange->widgetNE[1]->GetNumber();
103
 
103
 
104
   // ADC histogram
104
   // ADC histogram
105
   if(histtype == 0)
105
   if(histtype == 0)
106
   {
106
   {
107
      if( range[0] == range[1] )
107
      if( range[0] == range[1] )
108
         sprintf(rdc, "ADC%d>>%s", j, histname);
108
         sprintf(rdc, "ADC%d>>%s", j, histname);
109
      else
109
      else
110
         sprintf(rdc, "ADC%d>>%s(%d,%lf,%lf)", j, histname, (int)(range[1]-range[0]), range[0]-0.5, range[1]-0.5);
110
         sprintf(rdc, "ADC%d>>%s(%d,%lf,%lf)", j, histname, (int)(range[1]-range[0]), range[0]-0.5, range[1]-0.5);
111
 
111
 
112
      sprintf(rdcsel, "(TDC%d>%lf)&&(TDC%d<%lf)", j, range[2]*tdctimeconversion, j, range[3]*tdctimeconversion);
112
      sprintf(rdcsel, "(TDC%d>%lf)&&(TDC%d<%lf)", j, range[2]*tdctimeconversion, j, range[3]*tdctimeconversion);
113
      meas_data->Draw(rdc, rdcsel);
113
      meas_data->Draw(rdc, rdcsel);
114
 
114
 
115
      sprintf(rdc, "ADC%d, Vbias=%.3lf, TDC=(%.2lf,%.2lf);ADC;", j, evtheader.biasvolt, range[2], range[3]);
115
      sprintf(rdc, "ADC%d, Vbias=%.3lf, TDC=(%.2lf,%.2lf);ADC;", j, evtheader.biasvolt, range[2], range[3]);
116
      TH1F *histtemp = (TH1F*)gCanvas->GetPrimitive(histname);
116
      TH1F *histtemp = (TH1F*)gCanvas->GetPrimitive(histname);
117
      if(!cleanPlots)
117
      if(!cleanPlots)
118
         histtemp->SetTitle(rdc);
118
         histtemp->SetTitle(rdc);
119
      else
119
      else
120
         histtemp->SetTitle(";ADC;");
120
         histtemp->SetTitle(";ADC;");
121
      histtemp->GetXaxis()->SetLabelSize(0.025);
121
      histtemp->GetXaxis()->SetLabelSize(0.025);
122
      histtemp->GetXaxis()->CenterTitle(kTRUE);
122
      histtemp->GetXaxis()->CenterTitle(kTRUE);
123
      histtemp->GetYaxis()->SetLabelSize(0.025);
123
      histtemp->GetYaxis()->SetLabelSize(0.025);
124
      if(cleanPlots)
124
      if(cleanPlots)
125
      {
125
      {
126
         TGaxis *yax = (TGaxis*)histtemp->GetYaxis();
126
         TGaxis *yax = (TGaxis*)histtemp->GetYaxis();
127
         yax->SetMaxDigits(4);
127
         yax->SetMaxDigits(4);
128
      }
128
      }
129
 
129
 
130
      gCanvas->Modified();
130
      gCanvas->Modified();
131
      gCanvas->Update();
131
      gCanvas->Update();
132
 
132
 
133
      if( yRange->widgetNE[0]->GetNumber() != yRange->widgetNE[1]->GetNumber() )
133
      if( yRange->widgetNE[0]->GetNumber() != yRange->widgetNE[1]->GetNumber() )
134
      {
134
      {
135
         if( (histOpt->widgetChBox[0]->IsDown()) && (yRange->widgetNE[0]->GetNumber() <= 0) )
135
         if( (histOpt->widgetChBox[0]->IsDown()) && (yRange->widgetNE[0]->GetNumber() <= 0) )
136
         {
136
         {
137
            histtemp->GetYaxis()->SetRangeUser(0.5, yRange->widgetNE[1]->GetNumber());
137
            histtemp->GetYaxis()->SetRangeUser(0.5, yRange->widgetNE[1]->GetNumber());
138
            yRange->widgetNE[0]->SetNumber(0.5);
138
            yRange->widgetNE[0]->SetNumber(0.5);
139
            logChange = 1;
139
            logChange = 1;
140
         }
140
         }
141
         else
141
         else
142
         {
142
         {
143
            gCanvas->SetLogy(kFALSE);
143
            gCanvas->SetLogy(kFALSE);
144
            if(logChange == 1)
144
            if(logChange == 1)
145
            {
145
            {
146
               yRange->widgetNE[0]->SetNumber(0.0);
146
               yRange->widgetNE[0]->SetNumber(0.0);
147
               logChange = 0;
147
               logChange = 0;
148
            }
148
            }
149
            histtemp->GetYaxis()->SetRangeUser(yRange->widgetNE[0]->GetNumber(), yRange->widgetNE[1]->GetNumber());
149
            histtemp->GetYaxis()->SetRangeUser(yRange->widgetNE[0]->GetNumber(), yRange->widgetNE[1]->GetNumber());
150
         }
150
         }
151
      }
151
      }
152
 
152
 
153
      TPaveStats *stats = (TPaveStats*)histtemp->FindObject("stats");
153
      TPaveStats *stats = (TPaveStats*)histtemp->FindObject("stats");
154
      if(!cleanPlots)
154
      if(!cleanPlots)
155
      {
155
      {
156
         stats->SetX1NDC(0.84); stats->SetX2NDC(0.97);
156
         stats->SetX1NDC(0.84); stats->SetX2NDC(0.97);
157
         stats->SetY1NDC(0.87); stats->SetY2NDC(0.97);
157
         stats->SetY1NDC(0.87); stats->SetY2NDC(0.97);
158
      }
158
      }
159
      else
159
      else
160
      {
160
      {
161
         stats->SetX1NDC(1.1); stats->SetX2NDC(1.3);
161
         stats->SetX1NDC(1.1); stats->SetX2NDC(1.3);
162
         stats->SetY1NDC(1.1); stats->SetY2NDC(1.3);
162
         stats->SetY1NDC(1.1); stats->SetY2NDC(1.3);
163
      }
163
      }
164
   }
164
   }
165
   // TDC histogram
165
   // TDC histogram
166
   else if(histtype == 1)
166
   else if(histtype == 1)
167
   {
167
   {
168
      if( range[0] == range[1] )
168
      if( range[0] == range[1] )
169
         sprintf(rdc, "(TDC%d/%lf)>>%s", j, tdctimeconversion, histname);
169
         sprintf(rdc, "(TDC%d/%lf)>>%s", j, tdctimeconversion, histname);
170
      else
170
      else
171
         sprintf(rdc, "(TDC%d/%lf)>>%s(%d,%lf,%lf)", j, tdctimeconversion, histname, (int)((range[3]-range[2])*tdctimeconversion), range[2], range[3]);
171
         sprintf(rdc, "(TDC%d/%lf)>>%s(%d,%lf,%lf)", j, tdctimeconversion, histname, (int)((range[3]-range[2])*tdctimeconversion), range[2], range[3]);
172
 
172
 
173
      sprintf(rdcsel, "(TDC%d>%lf)&&(TDC%d<%lf)", j, range[2]*tdctimeconversion, j, range[3]*tdctimeconversion);
173
      sprintf(rdcsel, "(TDC%d>%lf)&&(TDC%d<%lf)", j, range[2]*tdctimeconversion, j, range[3]*tdctimeconversion);
174
      meas_data->Draw(rdc, rdcsel);
174
      meas_data->Draw(rdc, rdcsel);
175
 
175
 
176
      sprintf(rdc, "TDC%d, Vbias=%.3lf, TDC=(%.2lf,%.2lf);Time (TDC channel) [ns];", j, evtheader.biasvolt, range[2], range[3]);
176
      sprintf(rdc, "TDC%d, Vbias=%.3lf, TDC=(%.2lf,%.2lf);Time (TDC channel) [ns];", j, evtheader.biasvolt, range[2], range[3]);
177
      TH1F *histtemp = (TH1F*)gCanvas->GetPrimitive(histname);
177
      TH1F *histtemp = (TH1F*)gCanvas->GetPrimitive(histname);
178
      if(!cleanPlots)
178
      if(!cleanPlots)
179
         histtemp->SetTitle(rdc);
179
         histtemp->SetTitle(rdc);
180
      else
180
      else
181
         histtemp->SetTitle(";Time (TDC channel) [ns];");
181
         histtemp->SetTitle(";Time (TDC channel) [ns];");
182
      histtemp->GetXaxis()->SetLabelSize(0.025);
182
      histtemp->GetXaxis()->SetLabelSize(0.025);
183
      histtemp->GetXaxis()->CenterTitle(kTRUE);
183
      histtemp->GetXaxis()->CenterTitle(kTRUE);
184
      histtemp->GetYaxis()->SetLabelSize(0.025);
184
      histtemp->GetYaxis()->SetLabelSize(0.025);
185
      if(cleanPlots)
185
      if(cleanPlots)
186
      {
186
      {
187
         TGaxis *yax = (TGaxis*)histtemp->GetYaxis();
187
         TGaxis *yax = (TGaxis*)histtemp->GetYaxis();
188
         yax->SetMaxDigits(4);
188
         yax->SetMaxDigits(4);
189
      }
189
      }
190
 
190
 
191
      gCanvas->Modified();
191
      gCanvas->Modified();
192
      gCanvas->Update();
192
      gCanvas->Update();
193
 
193
 
194
      if( yRange->widgetNE[0]->GetNumber() != yRange->widgetNE[1]->GetNumber() )
194
      if( yRange->widgetNE[0]->GetNumber() != yRange->widgetNE[1]->GetNumber() )
195
      {
195
      {
196
         if( (histOpt->widgetChBox[0]->IsDown()) && (yRange->widgetNE[0]->GetNumber() <= 0) )
196
         if( (histOpt->widgetChBox[0]->IsDown()) && (yRange->widgetNE[0]->GetNumber() <= 0) )
197
         {
197
         {
198
            histtemp->GetYaxis()->SetRangeUser(0.5, yRange->widgetNE[1]->GetNumber());
198
            histtemp->GetYaxis()->SetRangeUser(0.5, yRange->widgetNE[1]->GetNumber());
199
            yRange->widgetNE[0]->SetNumber(0.5);
199
            yRange->widgetNE[0]->SetNumber(0.5);
200
            logChange = 1;
200
            logChange = 1;
201
         }
201
         }
202
         else
202
         else
203
         {
203
         {
204
            gCanvas->SetLogy(kFALSE);
204
            gCanvas->SetLogy(kFALSE);
205
            if(logChange == 1)
205
            if(logChange == 1)
206
            {
206
            {
207
               yRange->widgetNE[0]->SetNumber(0.0);
207
               yRange->widgetNE[0]->SetNumber(0.0);
208
               logChange = 0;
208
               logChange = 0;
209
            }
209
            }
210
            histtemp->GetYaxis()->SetRangeUser(yRange->widgetNE[0]->GetNumber(), yRange->widgetNE[1]->GetNumber());
210
            histtemp->GetYaxis()->SetRangeUser(yRange->widgetNE[0]->GetNumber(), yRange->widgetNE[1]->GetNumber());
211
         }
211
         }
212
      }
212
      }
213
 
213
 
214
      TPaveStats *stats = (TPaveStats*)histtemp->FindObject("stats");
214
      TPaveStats *stats = (TPaveStats*)histtemp->FindObject("stats");
215
      if(!cleanPlots)
215
      if(!cleanPlots)
216
      {
216
      {
217
         stats->SetX1NDC(0.84); stats->SetX2NDC(0.97);
217
         stats->SetX1NDC(0.84); stats->SetX2NDC(0.97);
218
         stats->SetY1NDC(0.87); stats->SetY2NDC(0.97);
218
         stats->SetY1NDC(0.87); stats->SetY2NDC(0.97);
219
      }
219
      }
220
      else
220
      else
221
      {
221
      {
222
         stats->SetX1NDC(1.1); stats->SetX2NDC(1.3);
222
         stats->SetX1NDC(1.1); stats->SetX2NDC(1.3);
223
         stats->SetY1NDC(1.1); stats->SetY2NDC(1.3);
223
         stats->SetY1NDC(1.1); stats->SetY2NDC(1.3);
224
      }
224
      }
225
   }
225
   }
226
   // ADC vs. TDC histogram
226
   // ADC vs. TDC histogram
227
   else if(histtype == 2)
227
   else if(histtype == 2)
228
   {
228
   {
229
      if( ((range[0] == range[1]) && (range[2] == range[3])) || (range[2] == range[3]) || (range[0] == range[1]) )
229
      if( ((range[0] == range[1]) && (range[2] == range[3])) || (range[2] == range[3]) || (range[0] == range[1]) )
230
         sprintf(rdc, "(TDC%d/%lf):ADC%d>>%s", j, tdctimeconversion, j, histname);
230
         sprintf(rdc, "(TDC%d/%lf):ADC%d>>%s", j, tdctimeconversion, j, histname);
231
      else
231
      else
232
         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]);
232
         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]);
233
      meas_data->Draw(rdc,"","COLZ");
233
      meas_data->Draw(rdc,"","COLZ");
234
 
234
 
235
      sprintf(rdc, "ADC/TDC%d, Vbias=%.3lf, TDC=(%.2lf,%.2lf);ADC;TDC", j, evtheader.biasvolt, range[2], range[3]);
235
      sprintf(rdc, "ADC/TDC%d, Vbias=%.3lf, TDC=(%.2lf,%.2lf);ADC;TDC", j, evtheader.biasvolt, range[2], range[3]);
236
      TH2F *histtemp = (TH2F*)gCanvas->GetPrimitive(histname);
236
      TH2F *histtemp = (TH2F*)gCanvas->GetPrimitive(histname);
237
      if(!cleanPlots)
237
      if(!cleanPlots)
238
         histtemp->SetTitle(rdc);
238
         histtemp->SetTitle(rdc);
239
      else
239
      else
240
         histtemp->SetTitle(";ADC;Time (TDC channel) [ns]");
240
         histtemp->SetTitle(";ADC;Time (TDC channel) [ns]");
241
      histtemp->GetXaxis()->SetLabelSize(0.025);
241
      histtemp->GetXaxis()->SetLabelSize(0.025);
242
      histtemp->GetXaxis()->CenterTitle(kTRUE);
242
      histtemp->GetXaxis()->CenterTitle(kTRUE);
243
      histtemp->GetYaxis()->SetLabelSize(0.025);
243
      histtemp->GetYaxis()->SetLabelSize(0.025);
244
      histtemp->GetYaxis()->CenterTitle(kTRUE);
244
      histtemp->GetYaxis()->CenterTitle(kTRUE);
245
      histtemp->GetYaxis()->SetTitleOffset(1.35);
245
      histtemp->GetYaxis()->SetTitleOffset(1.35);
246
      if(cleanPlots)
246
      if(cleanPlots)
247
      {
247
      {
248
         TGaxis *yax = (TGaxis*)histtemp->GetYaxis();
248
         TGaxis *yax = (TGaxis*)histtemp->GetYaxis();
249
         yax->SetMaxDigits(4);
249
         yax->SetMaxDigits(4);
250
      }
250
      }
251
 
251
 
252
      gCanvas->Modified();
252
      gCanvas->Modified();
253
      gCanvas->Update();
253
      gCanvas->Update();
254
 
254
 
255
      TPaveStats *stats = (TPaveStats*)histtemp->FindObject("stats");
255
      TPaveStats *stats = (TPaveStats*)histtemp->FindObject("stats");
256
      stats->SetX1NDC(1.1); stats->SetX2NDC(1.3);
256
      stats->SetX1NDC(1.1); stats->SetX2NDC(1.3);
257
      stats->SetY1NDC(1.1); stats->SetY2NDC(1.3);
257
      stats->SetY1NDC(1.1); stats->SetY2NDC(1.3);
258
 
258
 
259
      TPaletteAxis *gpalette = (TPaletteAxis*)histtemp->GetListOfFunctions()->FindObject("palette");
259
      TPaletteAxis *gpalette = (TPaletteAxis*)histtemp->GetListOfFunctions()->FindObject("palette");
260
      gpalette->SetLabelSize(0.022);
260
      gpalette->SetLabelSize(0.022);
261
   }
261
   }
262
 
262
 
263
   if(histtype < 2)
263
   if(histtype < 2)
264
   {
264
   {
265
      if( histOpt->widgetChBox[0]->IsDown() )
265
      if( histOpt->widgetChBox[0]->IsDown() )
266
         gCanvas->SetLogy(kTRUE);
266
         gCanvas->SetLogy(kTRUE);
267
      else if( !histOpt->widgetChBox[0]->IsDown() )
267
      else if( !histOpt->widgetChBox[0]->IsDown() )
268
         gCanvas->SetLogy(kFALSE);
268
         gCanvas->SetLogy(kFALSE);
269
   }
269
   }
270
   else
270
   else
271
      gCanvas->SetLogy(kFALSE);
271
      gCanvas->SetLogy(kFALSE);
272
 
272
 
273
   gCanvas->Modified();
273
   gCanvas->Modified();
274
   gCanvas->Update();
274
   gCanvas->Update();
275
 
275
 
276
   delete header_data;
276
   delete header_data;
277
   delete meas_data;
277
   delete meas_data;
278
 
278
 
279
   // Delete the opened file when we just display it in the analysis canvas (otherwise wait for histogram save)
279
   // Delete the opened file when we just display it in the analysis canvas (otherwise wait for histogram save)
280
   if(opt != 1)
280
   if(opt != 1)
281
      delete inroot;
281
      delete inroot;
282
 
282
 
283
   // If you close the opened file (delete inroot), the data can not be accessed by other functions (any time we wish to use the data directly from histogram, we need to call the DisplayHistogram function -> using different opt to determine what we need to do)
283
   // If you close the opened file (delete inroot), the data can not be accessed by other functions (any time we wish to use the data directly from histogram, we need to call the DisplayHistogram function -> using different opt to determine what we need to do)
284
}
284
}
285
 
285
 
286
// Start a measurement (acquisition from CAMAC)
286
// Start a measurement (acquisition from CAMAC)
287
void TGAppMainFrame::RunMeas(void *ptr, int runCase, int &scanon)
287
void TGAppMainFrame::RunMeas(void *ptr, int runCase, int &scanon)
288
{
288
{
289
   int vscan = 0, pscan = 0, zscan = 0, ascan = 0;
289
   int vscan = 0, pscan = 0, zscan = 0, ascan = 0;
290
   if(scansOn->widgetChBox[0]->IsDown()) vscan = 1;
290
   if(scansOn->widgetChBox[0]->IsDown()) vscan = 1;
291
   if(scansOn->widgetChBox[1]->IsDown()) pscan = 1;
291
   if(scansOn->widgetChBox[1]->IsDown()) pscan = 1;
292
   if(scansOn->widgetChBox[2]->IsDown()) zscan = 1;
292
   if(scansOn->widgetChBox[2]->IsDown()) zscan = 1;
293
   if(scansOn->widgetChBox[3]->IsDown()) ascan = 1;
293
   if(scansOn->widgetChBox[3]->IsDown()) ascan = 1;
294
 
294
 
295
   printf("Start of Run, run case %d\n", runCase);
295
   printf("Start of Run, run case %d\n", runCase);
296
 
296
 
297
   float progVal;
297
   float progVal;
298
 
298
 
299
   char ctemp[256];
299
   char ctemp[256];
300
   char ctemp2[256];
300
   char ctemp2[256];
301
   char fname[256];
301
   char fname[256];
302
   int itemp = 0;
302
   int itemp = 0;
303
   TH1F *liveHist;
303
   TH1F *liveHist;
304
 
304
 
305
   float minVoltage, maxVoltage, stepVoltage, diffVoltage;
305
   float minVoltage, maxVoltage, stepVoltage, diffVoltage;
306
   float minXpos, maxXpos, stepXpos, diffXpos;
306
   float minXpos, maxXpos, stepXpos, diffXpos;
307
   float minYpos, maxYpos, stepYpos, diffYpos;
307
   float minYpos, maxYpos, stepYpos, diffYpos;
308
   float minZpos, maxZpos, stepZpos, diffZpos;
308
   float minZpos, maxZpos, stepZpos, diffZpos;
309
   float minAlpha, maxAlpha, stepAlpha, diffAlpha;
309
   float minAlpha, maxAlpha, stepAlpha, diffAlpha;
310
 
310
 
311
   minVoltage = vOutStart->widgetNE[0]->GetNumber();
311
   minVoltage = vOutStart->widgetNE[0]->GetNumber();
312
   maxVoltage = vOutStop->widgetNE[0]->GetNumber();
312
   maxVoltage = vOutStop->widgetNE[0]->GetNumber();
313
   diffVoltage = abs(maxVoltage - minVoltage);
313
   diffVoltage = abs(maxVoltage - minVoltage);
314
   stepVoltage = abs(vOutStep->widgetNE[0]->GetNumber());
314
   stepVoltage = abs(vOutStep->widgetNE[0]->GetNumber());
315
   minXpos = xPosMin->widgetNE[0]->GetNumber();
315
   minXpos = xPosMin->widgetNE[0]->GetNumber();
316
   maxXpos = xPosMax->widgetNE[0]->GetNumber();
316
   maxXpos = xPosMax->widgetNE[0]->GetNumber();
317
   diffXpos = abs(maxXpos - minXpos);
317
   diffXpos = abs(maxXpos - minXpos);
318
   stepXpos = abs(xPosStep->widgetNE[0]->GetNumber());
318
   stepXpos = abs(xPosStep->widgetNE[0]->GetNumber());
319
   minYpos = yPosMin->widgetNE[0]->GetNumber();
319
   minYpos = yPosMin->widgetNE[0]->GetNumber();
320
   maxYpos = yPosMax->widgetNE[0]->GetNumber();
320
   maxYpos = yPosMax->widgetNE[0]->GetNumber();
321
   diffYpos = abs(maxYpos - minYpos);
321
   diffYpos = abs(maxYpos - minYpos);
322
   stepYpos = abs(yPosStep->widgetNE[0]->GetNumber());
322
   stepYpos = abs(yPosStep->widgetNE[0]->GetNumber());
323
   minZpos = zPosMin->widgetNE[0]->GetNumber();
323
   minZpos = zPosMin->widgetNE[0]->GetNumber();
324
   maxZpos = zPosMax->widgetNE[0]->GetNumber();
324
   maxZpos = zPosMax->widgetNE[0]->GetNumber();
325
   diffZpos = abs(maxZpos - minZpos);
325
   diffZpos = abs(maxZpos - minZpos);
326
   stepZpos = abs(zPosStep->widgetNE[0]->GetNumber());
326
   stepZpos = abs(zPosStep->widgetNE[0]->GetNumber());
327
   minAlpha = rotPosMin->widgetNE[0]->GetNumber();
327
   minAlpha = rotPosMin->widgetNE[0]->GetNumber();
328
   maxAlpha = rotPosMax->widgetNE[0]->GetNumber();
328
   maxAlpha = rotPosMax->widgetNE[0]->GetNumber();
329
   diffAlpha = abs(maxAlpha - minAlpha);
329
   diffAlpha = abs(maxAlpha - minAlpha);
330
   stepAlpha = abs(rotPosStep->widgetNE[0]->GetNumber());
330
   stepAlpha = abs(rotPosStep->widgetNE[0]->GetNumber());
331
 
331
 
332
   remove_ext((char*)fileName->widgetTE->GetText(), ctemp);
332
   remove_ext((char*)fileName->widgetTE->GetText(), ctemp);
333
 
333
 
334
   // TODO - angle scan + voltage scan
334
   // TODO - angle scan + voltage scan
335
   // Voltage or surface scan
335
   // Voltage or surface scan
336
   if( vscan || pscan || ascan )
336
   if( vscan || pscan || ascan )
337
   {
337
   {
338
      // No Z scan, No angle scan
338
      // No Z scan, No angle scan
339
      if(!zscan && !ascan)
339
      if(!zscan && !ascan)
340
      {
340
      {
341
         // When we have a voltage scan
341
         // When we have a voltage scan
342
         if( vscan && (stepVoltage > 0.) )
342
         if( vscan && (stepVoltage > 0.) )
343
            SeqNumber(runCase, (int)diffVoltage/stepVoltage, ctemp2);
343
            SeqNumber(runCase, (int)diffVoltage/stepVoltage, ctemp2);
344
         // With only a surface scan
344
         // With only a surface scan
345
         else if(pscan)
345
         else if(pscan)
346
         {
346
         {
347
            if( stepXpos == 0 )
347
            if( stepXpos == 0 )
348
               itemp = 1;
348
               itemp = 1;
349
            else
349
            else
350
               itemp = (int)diffXpos/stepXpos;
350
               itemp = (int)diffXpos/stepXpos;
351
 
351
 
352
            if( stepYpos == 0 )
352
            if( stepYpos == 0 )
353
               itemp *= 1;
353
               itemp *= 1;
354
            else
354
            else
355
               itemp *= (int)diffYpos/stepYpos;
355
               itemp *= (int)diffYpos/stepYpos;
356
            SeqNumber(runCase, itemp, ctemp2);
356
            SeqNumber(runCase, itemp, ctemp2);
357
         }
357
         }
358
         sprintf(fname, "%s_%s%s", ctemp, ctemp2, histext);
358
         sprintf(fname, "%s_%s%s", ctemp, ctemp2, histext);
359
      }
359
      }
360
      // With Z scan, No angle scan
360
      // With Z scan, No angle scan
361
      else if(zscan && !ascan)
361
      else if(zscan && !ascan)
362
      {
362
      {
363
         SeqNumber((int)zPos->widgetNE[0]->GetNumber(), maxZpos, ctemp2);
363
         SeqNumber((int)zPos->widgetNE[0]->GetNumber(), maxZpos, ctemp2);
364
 
364
 
365
         // Voltage scan is on
365
         // Voltage scan is on
366
         if( vscan && (stepVoltage > 0.) )
366
         if( vscan && (stepVoltage > 0.) )
367
         {
367
         {
368
            sprintf(fname, "%s_z%s_", ctemp, ctemp2);
368
            sprintf(fname, "%s_z%s_", ctemp, ctemp2);
369
            SeqNumber(runCase, (int)diffVoltage/stepVoltage+1, ctemp2);
369
            SeqNumber(runCase, (int)diffVoltage/stepVoltage+1, ctemp2);
370
            strcat(fname, ctemp2);
370
            strcat(fname, ctemp2);
371
            strcat(fname, histext);
371
            strcat(fname, histext);
372
         }
372
         }
373
         // Surface scan is on
373
         // Surface scan is on
374
         else if(pscan)
374
         else if(pscan)
375
         {
375
         {
376
            sprintf(fname, "%s_z%s_", ctemp, ctemp2);
376
            sprintf(fname, "%s_z%s_", ctemp, ctemp2);
377
 
377
 
378
            if( stepXpos == 0 )
378
            if( stepXpos == 0 )
379
               itemp = 1;
379
               itemp = 1;
380
            else
380
            else
381
               itemp = (int)diffXpos/stepXpos+1;
381
               itemp = (int)diffXpos/stepXpos+1;
382
 
382
 
383
            if( stepYpos == 0 )
383
            if( stepYpos == 0 )
384
               itemp *= 1;
384
               itemp *= 1;
385
            else
385
            else
386
               itemp *= (int)diffYpos/stepYpos+1;
386
               itemp *= (int)diffYpos/stepYpos+1;
387
            SeqNumber(runCase, itemp, ctemp2);
387
            SeqNumber(runCase, itemp, ctemp2);
388
            strcat(fname, ctemp2);
388
            strcat(fname, ctemp2);
389
            strcat(fname, histext);
389
            strcat(fname, histext);
390
         }
390
         }
391
         // Just Z scan
391
         // Just Z scan
392
         else
392
         else
393
            sprintf(fname, "%s_z%s%s", ctemp, ctemp2, histext);
393
            sprintf(fname, "%s_z%s%s", ctemp, ctemp2, histext);
394
      }
394
      }
395
      // No Z scan, With angle scan
395
      // No Z scan, With angle scan
396
      else if(!zscan && ascan)
396
      else if(!zscan && ascan)
397
      {
397
      {
398
         SeqNumber(runCase, (int)diffAlpha/stepAlpha, ctemp2);
398
         SeqNumber(runCase, (int)diffAlpha/stepAlpha, ctemp2);
399
 
399
 
400
         // Voltage scan is on
400
         // Voltage scan is on
401
         if( vscan && (stepVoltage > 0.) )
401
         if( vscan && (stepVoltage > 0.) )
402
         {
402
         {
403
            sprintf(fname, "%s_phi%s_", ctemp, ctemp2);
403
            sprintf(fname, "%s_phi%s_", ctemp, ctemp2);
404
            SeqNumber(runCase, (int)diffVoltage/stepVoltage+1, ctemp2);
404
            SeqNumber(runCase, (int)diffVoltage/stepVoltage+1, ctemp2);
405
            strcat(fname, ctemp2);
405
            strcat(fname, ctemp2);
406
            strcat(fname, histext);
406
            strcat(fname, histext);
407
         }
407
         }
408
         // Just angle scan
408
         // Just angle scan
409
         else
409
         else
410
            sprintf(fname, "%s_phi%s%s", ctemp, ctemp2, histext);
410
            sprintf(fname, "%s_phi%s%s", ctemp, ctemp2, histext);
411
      }
411
      }
412
   }
412
   }
413
   // All the rest
413
   // All the rest
414
   else if(!vscan && !pscan)
414
   else if(!vscan && !pscan)
415
      sprintf(fname, "%s%s", ctemp, histext);
415
      sprintf(fname, "%s%s", ctemp, histext);
416
 
416
 
417
   // Check if set voltage is below the hard limit
417
   // Check if set voltage is below the hard limit
418
   if( vOut->widgetNE[0]->GetNumber() > vHardlimit->widgetNE[0]->GetNumber() )
418
   if( vOut->widgetNE[0]->GetNumber() > vHardlimit->widgetNE[0]->GetNumber() )
419
   {
419
   {
420
      printf("Voltage hard limit triggered (%lf > %lf)!\n", vOut->widgetNE[0]->GetNumber(), vHardlimit->widgetNE[0]->GetNumber() );
420
      printf("Voltage hard limit triggered (%lf > %lf)!\n", vOut->widgetNE[0]->GetNumber(), vHardlimit->widgetNE[0]->GetNumber() );
421
      vOut->widgetNE[0]->SetNumber( vHardlimit->widgetNE[0]->GetNumber() );
421
      vOut->widgetNE[0]->SetNumber( vHardlimit->widgetNE[0]->GetNumber() );
422
   }
422
   }
423
 
423
 
424
   printf("Output file is (runCase = %d): %s\n", runCase, fname);
424
   printf("Output file is (runCase = %d): %s\n", runCase, fname);
425
 
425
 
426
   // Writing to output file
426
   // Writing to output file
427
   outroot = TFile::Open(fname, "RECREATE");
427
   outroot = TFile::Open(fname, "RECREATE");
428
 
428
 
429
   TTree *header_data = new TTree("header_data", "Header information for the measurement.");
429
   TTree *header_data = new TTree("header_data", "Header information for the measurement.");
430
   TTree *meas_data = new TTree("meas_data", "Saved ADC and TDC measurement data.");
430
   TTree *meas_data = new TTree("meas_data", "Saved ADC and TDC measurement data.");
431
   TTree *scope_data = new TTree("scope_data", "Saved scope measurement data.");
431
   TTree *scope_data = new TTree("scope_data", "Saved scope measurement data.");
432
 
432
 
433
   // Branches for the header
433
   // Branches for the header
434
   header_data->Branch("nrch", &evtheader.nrch, "nrch/I");
434
   header_data->Branch("nrch", &evtheader.nrch, "nrch/I");
435
   header_data->Branch("timestamp", &evtheader.timestamp, "timestamp/I");
435
   header_data->Branch("timestamp", &evtheader.timestamp, "timestamp/I");
436
   header_data->Branch("biasvolt", &evtheader.biasvolt, "biasvolt/D");
436
   header_data->Branch("biasvolt", &evtheader.biasvolt, "biasvolt/D");
437
   header_data->Branch("xpos", &evtheader.xpos, "xpos/I");
437
   header_data->Branch("xpos", &evtheader.xpos, "xpos/I");
438
   header_data->Branch("ypos", &evtheader.ypos, "ypos/I");
438
   header_data->Branch("ypos", &evtheader.ypos, "ypos/I");
439
   header_data->Branch("zpos", &evtheader.zpos, "zpos/I");
439
   header_data->Branch("zpos", &evtheader.zpos, "zpos/I");
440
   header_data->Branch("temperature", &evtheader.temperature, "temperature/D");
440
   header_data->Branch("temperature", &evtheader.temperature, "temperature/D");
441
   header_data->Branch("angle", &evtheader.angle, "angle/D");
441
   header_data->Branch("angle", &evtheader.angle, "angle/D");
442
   header_data->Branch("laserinfo", &evtheader.laserinfo, "laserinfo/C");
442
   header_data->Branch("laserinfo", &evtheader.laserinfo, "laserinfo/C");
443
 
443
 
444
   evtheader.nrch = (int)NCH->widgetNE[0]->GetNumber()*2;
444
   evtheader.nrch = (int)NCH->widgetNE[0]->GetNumber()*2;
445
   evtheader.timestamp = (int)time(NULL);
445
   evtheader.timestamp = (int)time(NULL);
446
   evtheader.biasvolt = (double)vOut->widgetNE[0]->GetNumber();
446
   evtheader.biasvolt = (double)vOut->widgetNE[0]->GetNumber();
447
   if(posUnits->widgetCB->GetSelected() == 0)
447
   if(posUnits->widgetCB->GetSelected() == 0)
448
   {
448
   {
449
      evtheader.xpos = (int)xPos->widgetNE[0]->GetNumber();
449
      evtheader.xpos = (int)xPos->widgetNE[0]->GetNumber();
450
      evtheader.ypos = (int)yPos->widgetNE[0]->GetNumber();
450
      evtheader.ypos = (int)yPos->widgetNE[0]->GetNumber();
451
      evtheader.zpos = (int)zPos->widgetNE[0]->GetNumber();
451
      evtheader.zpos = (int)zPos->widgetNE[0]->GetNumber();
452
   }
452
   }
453
   else if(posUnits->widgetCB->GetSelected() == 1)
453
   else if(posUnits->widgetCB->GetSelected() == 1)
454
   {
454
   {
455
      evtheader.xpos = (int)xPos->widgetNE[0]->GetNumber()/lenconversion;
455
      evtheader.xpos = (int)xPos->widgetNE[0]->GetNumber()/lenconversion;
456
      evtheader.ypos = (int)yPos->widgetNE[0]->GetNumber()/lenconversion;
456
      evtheader.ypos = (int)yPos->widgetNE[0]->GetNumber()/lenconversion;
457
      evtheader.zpos = (int)zPos->widgetNE[0]->GetNumber()/lenconversion;
457
      evtheader.zpos = (int)zPos->widgetNE[0]->GetNumber()/lenconversion;
458
   }
458
   }
459
   evtheader.temperature = (double)chtemp->widgetNE[0]->GetNumber();
459
   evtheader.temperature = (double)chtemp->widgetNE[0]->GetNumber();
460
   if(rotUnits->widgetCB->GetSelected() == 0)
460
   if(rotUnits->widgetCB->GetSelected() == 0)
461
      evtheader.angle = (double)rotPos->widgetNE[0]->GetNumber()*rotconversion;
461
      evtheader.angle = (double)rotPos->widgetNE[0]->GetNumber()*rotconversion;
462
   else if(rotUnits->widgetCB->GetSelected() == 1)
462
   else if(rotUnits->widgetCB->GetSelected() == 1)
463
      evtheader.angle = (double)rotPos->widgetNE[0]->GetNumber();
463
      evtheader.angle = (double)rotPos->widgetNE[0]->GetNumber();
464
   sprintf(evtheader.laserinfo, "%s", laserInfo->widgetTE->GetText());
464
   sprintf(evtheader.laserinfo, "%s", laserInfo->widgetTE->GetText());
465
 
465
 
466
   char histtime[256];
466
   char histtime[256];
467
   GetTime(evtheader.timestamp, histtime);
467
   GetTime(evtheader.timestamp, histtime);
468
 
468
 
469
   printf("Save file header information:\n");
469
   printf("Save file header information:\n");
470
   printf("- Number of channels: %d\n", evtheader.nrch);
470
   printf("- Number of channels: %d\n", evtheader.nrch);
471
   printf("- Timestamp: %d (%s)\n", evtheader.timestamp, histtime);
471
   printf("- Timestamp: %d (%s)\n", evtheader.timestamp, histtime);
472
   printf("- Bias voltage: %lf\n", evtheader.biasvolt);
472
   printf("- Bias voltage: %lf\n", evtheader.biasvolt);
473
   printf("- Table position (X,Y,Z): %d, %d, %d\n", evtheader.xpos, evtheader.ypos, evtheader.zpos);
473
   printf("- Table position (X,Y,Z): %d, %d, %d\n", evtheader.xpos, evtheader.ypos, evtheader.zpos);
474
   printf("- Temperature: %lf\n", evtheader.temperature);
474
   printf("- Temperature: %lf\n", evtheader.temperature);
475
   printf("- Incidence angle: %lf\n", evtheader.angle);
475
   printf("- Incidence angle: %lf\n", evtheader.angle);
476
   printf("- Laser and filter settings: %s\n", evtheader.laserinfo);
476
   printf("- Laser and filter settings: %s\n", evtheader.laserinfo);
477
 
477
 
478
   header_data->Fill();
478
   header_data->Fill();
479
 
479
 
480
   // Branches for ADC and TDC data
480
   // Branches for ADC and TDC data
481
   for(int i = 0; i < evtheader.nrch/2; i++)
481
   for(int i = 0; i < evtheader.nrch/2; i++)
482
   {
482
   {
483
      sprintf(ctemp, "ADC%d", i);
483
      sprintf(ctemp, "ADC%d", i);
484
      sprintf(fname, "ADC%d/I", i);
484
      sprintf(fname, "ADC%d/I", i);
485
      meas_data->Branch(ctemp, &evtdata.adcdata[i], fname);
485
      meas_data->Branch(ctemp, &evtdata.adcdata[i], fname);
486
 
486
 
487
      sprintf(ctemp, "TDC%d", i);
487
      sprintf(ctemp, "TDC%d", i);
488
      sprintf(fname, "TDC%d/I", i);
488
      sprintf(fname, "TDC%d/I", i);
489
      meas_data->Branch(ctemp, &evtdata.tdcdata[i], fname);
489
      meas_data->Branch(ctemp, &evtdata.tdcdata[i], fname);
490
   }
490
   }
491
 
491
 
492
   //TODO
492
   //TODO
493
   // Initialize the scope before measurement
493
   // Initialize the scope before measurement
494
/*   if( sCamaclink->IsDown() )
494
/*   if( sCamaclink->IsDown() )
495
      InitializeScope();*/
495
      InitializeScope();*/
496
 
496
 
497
   // Branch for scope measurement data
497
   // Branch for scope measurement data
498
/*   if(gScopeDaq->scopeUseType == 2) // only if we select waveform measurement
498
/*   if(gScopeDaq->scopeUseType == 2) // only if we select waveform measurement
499
   {
499
   {
500
      if(gScopeDaq->scopeMeasSel == 0)
500
      if(gScopeDaq->scopeMeasSel == 0)
501
         scope_data->Branch("amp", &evtmeas.measdata, "amp/D");
501
         scope_data->Branch("amp", &evtmeas.measdata, "amp/D");
502
      else if(gScopeDaq->scopeMeasSel == 1)
502
      else if(gScopeDaq->scopeMeasSel == 1)
503
         scope_data->Branch("area", &evtmeas.measdata, "area/D");
503
         scope_data->Branch("area", &evtmeas.measdata, "area/D");
504
      else if(gScopeDaq->scopeMeasSel == 2)
504
      else if(gScopeDaq->scopeMeasSel == 2)
505
         scope_data->Branch("delay", &evtmeas.measdata, "delay/D");
505
         scope_data->Branch("delay", &evtmeas.measdata, "delay/D");
506
      else if(gScopeDaq->scopeMeasSel == 3)
506
      else if(gScopeDaq->scopeMeasSel == 3)
507
         scope_data->Branch("fall", &evtmeas.measdata, "fall/D");
507
         scope_data->Branch("fall", &evtmeas.measdata, "fall/D");
508
      else if(gScopeDaq->scopeMeasSel == 4)
508
      else if(gScopeDaq->scopeMeasSel == 4)
509
         scope_data->Branch("freq", &evtmeas.measdata, "freq/D");
509
         scope_data->Branch("freq", &evtmeas.measdata, "freq/D");
510
      else if(gScopeDaq->scopeMeasSel == 5)
510
      else if(gScopeDaq->scopeMeasSel == 5)
511
         scope_data->Branch("max", &evtmeas.measdata, "max/D");
511
         scope_data->Branch("max", &evtmeas.measdata, "max/D");
512
      else if(gScopeDaq->scopeMeasSel == 6)
512
      else if(gScopeDaq->scopeMeasSel == 6)
513
         scope_data->Branch("mean", &evtmeas.measdata, "mean/D");
513
         scope_data->Branch("mean", &evtmeas.measdata, "mean/D");
514
      else if(gScopeDaq->scopeMeasSel == 7)
514
      else if(gScopeDaq->scopeMeasSel == 7)
515
         scope_data->Branch("min", &evtmeas.measdata, "min/D");
515
         scope_data->Branch("min", &evtmeas.measdata, "min/D");
516
      else if(gScopeDaq->scopeMeasSel == 8)
516
      else if(gScopeDaq->scopeMeasSel == 8)
517
         scope_data->Branch("pk2p", &evtmeas.measdata, "pk2p/D");
517
         scope_data->Branch("pk2p", &evtmeas.measdata, "pk2p/D");
518
      else if(gScopeDaq->scopeMeasSel == 9)
518
      else if(gScopeDaq->scopeMeasSel == 9)
519
         scope_data->Branch("pwidth", &evtmeas.measdata, "pwidth/D");
519
         scope_data->Branch("pwidth", &evtmeas.measdata, "pwidth/D");
520
      else if(gScopeDaq->scopeMeasSel == 10)
520
      else if(gScopeDaq->scopeMeasSel == 10)
521
         scope_data->Branch("rise", &evtmeas.measdata, "rise/D");
521
         scope_data->Branch("rise", &evtmeas.measdata, "rise/D");
522
   }*/
522
   }*/
523
 
523
 
524
   int neve  = (int) evtNum->widgetNE[0]->GetNumber();
524
   int neve  = (int) evtNum->widgetNE[0]->GetNumber();
525
   int allEvt, zProg;
525
   int allEvt, zProg;
526
   zProg = 1;
526
   zProg = 1;
527
 
527
 
528
#if WORKSTAT == 'I'
528
#if WORKSTAT == 'I'
529
#else
529
#else
530
// ONLY FOR TESTING!
530
// ONLY FOR TESTING!
531
   TRandom *randNum = new TRandom();
531
   TRandom *randNum = new TRandom();
532
   randNum->SetSeed(0);
532
   randNum->SetSeed(0);
533
// ONLY FOR TESTING!
533
// ONLY FOR TESTING!
534
#endif
534
#endif
535
 
535
 
536
   // Initialize the CAMAC
536
   // Initialize the CAMAC
537
   if (gDaq)
537
   if (gDaq)
538
   {
538
   {
539
      if(scanon == 0)
539
      if(scanon == 0)
540
      {
540
      {
541
         gDaq->init(evtheader.nrch);
541
         gDaq->init(evtheader.nrch);
542
         scanon = 1;
542
         scanon = 1;
543
      }
543
      }
544
      gDaq->fStop=0;
544
      gDaq->fStop=0;
545
 
545
 
546
      // Set the stopwatch
546
      // Set the stopwatch
547
      clock_t clkt1;
547
      clock_t clkt1;
548
 
548
 
549
      // Prepare histogram for live histogram update
549
      // Prepare histogram for live histogram update
550
      int liven;
550
      int liven;
551
      TCanvas *gCanvas;
551
      TCanvas *gCanvas;
552
      if(liveUpdate && (!vscan && !pscan && !zscan && !ascan))
552
      if(liveUpdate && (!vscan && !pscan && !zscan && !ascan))
553
      {
553
      {
554
         gCanvas = measCanvas->GetCanvas();
554
         gCanvas = measCanvas->GetCanvas();
555
         gCanvas->SetGrid();
555
         gCanvas->SetGrid();
556
         gCanvas->cd();
556
         gCanvas->cd();
557
         liveHist = new TH1F(histname,"",(int)TMath::Sqrt(neve),0,0);
557
         liveHist = new TH1F(histname,"",(int)TMath::Sqrt(neve),0,0);
558
         liven = 1;
558
         liven = 1;
559
      }
559
      }
560
 
560
 
561
      // Start gathering
561
      // Start gathering
562
      gDaq->start();
562
      gDaq->start();
563
 
563
 
564
      for (int n=0;n<neve && !gDaq->fStop ;/*n++*/)
564
      for (int n=0;n<neve && !gDaq->fStop ;/*n++*/)
565
      {
565
      {
566
         int nb = gDaq->event(gBuf,BSIZE);
566
         int nb = gDaq->event(gBuf,BSIZE);
567
 
567
 
568
#if WORKSTAT == 'I'
568
#if WORKSTAT == 'I'
569
#else
569
#else
570
// ONLY FOR TESTING!
570
// ONLY FOR TESTING!
571
         for(int i=0; i < evtheader.nrch; i++)
571
         for(int i=0; i < evtheader.nrch; i++)
572
         {
572
         {
573
            if(i == 1)
573
            if(i == 1)
574
               gBuf[i] = randNum->Gaus(1500,300);
574
               gBuf[i] = randNum->Gaus(1500,300);
575
            else if(i == 0)
575
            else if(i == 0)
576
               gBuf[i] = randNum->Poisson(2500);
576
               gBuf[i] = randNum->Poisson(2500);
577
         }
577
         }
578
// ONLY FOR TESTING!
578
// ONLY FOR TESTING!
579
#endif
579
#endif
580
         if (nb<=0) n--;
580
         if (nb<=0) n--;
581
 
581
 
582
         int nc=0;
582
         int nc=0;
583
 
583
 
584
         while ( (nb>0) && (n<neve) )
584
         while ( (nb>0) && (n<neve) )
585
         {
585
         {
586
            for(int i = 0; i < evtheader.nrch; i++)
586
            for(int i = 0; i < evtheader.nrch; i++)
587
            {
587
            {
588
               unsigned short adc = gBuf[i+nc]&0xFFFF;
588
               unsigned short adc = gBuf[i+nc]&0xFFFF;
589
               if(i % 2 == 0)           // TDC
589
               if(i % 2 == 0)           // TDC
590
                  evtdata.tdcdata[i/2] = (int)adc;
590
                  evtdata.tdcdata[i/2] = (int)adc;
591
               else if(i % 2 == 1)      // ADC
591
               else if(i % 2 == 1)      // ADC
592
                  evtdata.adcdata[i/2] = (int)adc;
592
                  evtdata.adcdata[i/2] = (int)adc;
593
 
593
 
594
               // Start plotting the scope waveform
594
               // Start plotting the scope waveform
595
/*             if( (gScopeDaq->scopeUseType == 1) && (sCamaclink->IsDown()) )
595
/*             if( (gScopeDaq->scopeUseType == 1) && (sCamaclink->IsDown()) )
596
                  StartScopeAcq();*/ // TODO
596
                  StartScopeAcq();*/ // TODO
597
            }
597
            }
598
            meas_data->Fill();
598
            meas_data->Fill();
599
            n++;
599
            n++;
600
sleep(1);
-
 
601
 
600
 
602
            // Start making a scope measurement
601
            // Start making a scope measurement
603
/*          if( (gScopeDaq->scopeUseType == 2) && (sCamaclink->IsDown()) )
602
/*          if( (gScopeDaq->scopeUseType == 2) && (sCamaclink->IsDown()) )
604
            {
603
            {
605
               StartScopeAcq();
604
               StartScopeAcq();
606
               evtmeas.measdata = gScopeDaq->measubuf;
605
               evtmeas.measdata = gScopeDaq->measubuf;
607
            }
606
            }
608
            scope_data->Fill();*/ // TODO
607
            scope_data->Fill();*/ // TODO
609
 
608
 
610
            // Start filling the histogram (only in normal single scan)
609
            // Start filling the histogram (only in normal single scan)
611
            if(liveUpdate && (!vscan && !pscan && !zscan && !ascan))
610
            if(liveUpdate && (!vscan && !pscan && !zscan && !ascan))
612
            {
611
            {
613
               liveHist->Fill(evtdata.adcdata[0]);
612
               liveHist->Fill(evtdata.adcdata[0]);
614
               if( n == (neve*liven)/10 )
613
               if( n == (neve*liven)/10 )
615
               {
614
               {
616
                  gCanvas->cd();
615
                  gCanvas->cd();
617
                  liveHist->Draw("");
616
                  liveHist->Draw("");
618
                  gCanvas->Modified();
617
                  gCanvas->Modified();
619
                  gCanvas->Update();
618
                  gCanvas->Update();
620
                  liven++;
619
                  liven++;
621
               }
620
               }
622
            }
621
            }
623
           
622
           
624
            nc += evtheader.nrch;
623
            nc += evtheader.nrch;
625
            nb -= evtheader.nrch;
624
            nb -= evtheader.nrch;
626
         }
625
         }
627
 
626
 
628
         MyTimer();
627
         MyTimer();
629
         allEvt = n;
628
         allEvt = n;
630
         if (gSystem->ProcessEvents()) printf("Run Interrupted\n");
629
         if (gSystem->ProcessEvents()) printf("Run Interrupted\n");
631
 
630
 
632
         if( acqStarted && (n == (neve*zProg)/10) && (!vscan && !pscan && !zscan && !ascan) )
631
         if( acqStarted && (n == (neve*zProg)/10) && (!vscan && !pscan && !zscan && !ascan) )
633
         {
632
         {
634
            // Progress the progress bar
633
            // Progress the progress bar
635
            progVal = (float)zProg*10;
634
            progVal = (float)zProg*10;
636
            measProgress->widgetPB->SetPosition(progVal);
635
            measProgress->widgetPB->SetPosition(progVal);
637
 
636
 
638
            // Calculate the remaining time
637
            // Calculate the remaining time
639
            TimeEstimate(clkt0, timet0, progVal, ctemp, 0);
638
            TimeEstimate(clkt0, timet0, progVal, ctemp, 0);
640
            printf("End time: %s\n", ctemp);
639
            printf("End time: %s\n", ctemp);
641
            measProgress->widgetTE->SetText(ctemp);
640
            measProgress->widgetTE->SetText(ctemp);
642
 
641
 
643
            gVirtualX->Update(1);
642
            gVirtualX->Update(1);
644
            zProg++;
643
            zProg++;
645
         }
644
         }
646
      }
645
      }
647
 
646
 
648
      printf("Number of gathered events: %d\n", allEvt);
647
      printf("Number of gathered events: %d\n", allEvt);
649
      measProgress->widgetTB[0]->SetText("Start acquisition");
648
      measProgress->widgetTB[0]->SetText("Start acquisition");
650
      acqStarted = false;
649
      acqStarted = false;
651
 
650
 
652
      gDaq->stop();
651
      gDaq->stop();
653
   }
652
   }
654
 
653
 
655
   printf("End of Run neve=%d\n",neve);
654
   printf("End of Run neve=%d\n",neve);
656
 
655
 
657
   header_data->Write();
656
   header_data->Write();
658
   meas_data->Write();
657
   meas_data->Write();
659
//   scope_data->Write(); // TODO
658
//   scope_data->Write(); // TODO
660
   delete header_data;
659
   delete header_data;
661
   delete meas_data;
660
   delete meas_data;
662
   delete scope_data;
661
   delete scope_data;
663
 
662
 
664
   // Remove the histogram
663
   // Remove the histogram
665
   if(liveUpdate && (!vscan && !pscan && !zscan && !ascan))
664
   if(liveUpdate && (!vscan && !pscan && !zscan && !ascan))
666
      delete liveHist;
665
      delete liveHist;
667
 
666
 
668
 
667
 
669
   outroot->Close();
668
   outroot->Close();
670
}
669
}
671
 
670
 
672
int TGAppMainFrame::MyTimer()
671
int TGAppMainFrame::MyTimer()
673
{
672
{
674
   char cmd[100];
673
   char cmd[100];
675
   GetTime(-1, cmd);
674
   GetTime(-1, cmd);
676
   if (timeStamp) timeStamp->widgetTE->SetText(cmd);
675
   if (timeStamp) timeStamp->widgetTE->SetText(cmd);
677
   return 0;
676
   return 0;
678
}
677
}
679
 
678
 
680
// Additional functions -------------------------------------
679
// Additional functions -------------------------------------
681
 
680
 
682
// Settings pane connections --------------------------------
681
// Settings pane connections --------------------------------
683
 
682
 
684
// Enable or disable scans
683
// Enable or disable scans
685
void TGAppMainFrame::EnableScan(int type)
684
void TGAppMainFrame::EnableScan(int type)
686
{
685
{
687
   // Voltage scan
686
   // Voltage scan
688
   if(type == 0)
687
   if(type == 0)
689
   {
688
   {
690
      if(scansOn->widgetChBox[type]->IsOn())
689
      if(scansOn->widgetChBox[type]->IsOn())
691
      {
690
      {
692
         vOutStart->widgetNE[0]->SetState(kTRUE);
691
         vOutStart->widgetNE[0]->SetState(kTRUE);
693
         vOutStop->widgetNE[0]->SetState(kTRUE);
692
         vOutStop->widgetNE[0]->SetState(kTRUE);
694
         vOutStep->widgetNE[0]->SetState(kTRUE);
693
         vOutStep->widgetNE[0]->SetState(kTRUE);
695
      }
694
      }
696
      else
695
      else
697
      {
696
      {
698
         vOutStart->widgetNE[0]->SetState(kFALSE);
697
         vOutStart->widgetNE[0]->SetState(kFALSE);
699
         vOutStop->widgetNE[0]->SetState(kFALSE);
698
         vOutStop->widgetNE[0]->SetState(kFALSE);
700
         vOutStep->widgetNE[0]->SetState(kFALSE);
699
         vOutStep->widgetNE[0]->SetState(kFALSE);
701
      }
700
      }
702
   }
701
   }
703
   // Surface (X, Y axis) scan
702
   // Surface (X, Y axis) scan
704
   else if(type == 1)
703
   else if(type == 1)
705
   {
704
   {
706
      if(scansOn->widgetChBox[type]->IsOn())
705
      if(scansOn->widgetChBox[type]->IsOn())
707
      {
706
      {
708
         xPosMin->widgetNE[0]->SetState(kTRUE);
707
         xPosMin->widgetNE[0]->SetState(kTRUE);
709
         xPosMax->widgetNE[0]->SetState(kTRUE);
708
         xPosMax->widgetNE[0]->SetState(kTRUE);
710
         xPosStep->widgetNE[0]->SetState(kTRUE);
709
         xPosStep->widgetNE[0]->SetState(kTRUE);
711
         yPosMin->widgetNE[0]->SetState(kTRUE);
710
         yPosMin->widgetNE[0]->SetState(kTRUE);
712
         yPosMax->widgetNE[0]->SetState(kTRUE);
711
         yPosMax->widgetNE[0]->SetState(kTRUE);
713
         yPosStep->widgetNE[0]->SetState(kTRUE);
712
         yPosStep->widgetNE[0]->SetState(kTRUE);
714
      }
713
      }
715
      else
714
      else
716
      {
715
      {
717
         xPosMin->widgetNE[0]->SetState(kFALSE);
716
         xPosMin->widgetNE[0]->SetState(kFALSE);
718
         xPosMax->widgetNE[0]->SetState(kFALSE);
717
         xPosMax->widgetNE[0]->SetState(kFALSE);
719
         xPosStep->widgetNE[0]->SetState(kFALSE);
718
         xPosStep->widgetNE[0]->SetState(kFALSE);
720
         yPosMin->widgetNE[0]->SetState(kFALSE);
719
         yPosMin->widgetNE[0]->SetState(kFALSE);
721
         yPosMax->widgetNE[0]->SetState(kFALSE);
720
         yPosMax->widgetNE[0]->SetState(kFALSE);
722
         yPosStep->widgetNE[0]->SetState(kFALSE);
721
         yPosStep->widgetNE[0]->SetState(kFALSE);
723
      }
722
      }
724
   }
723
   }
725
   // Z axis scan
724
   // Z axis scan
726
   else if(type == 2)
725
   else if(type == 2)
727
   {
726
   {
728
      if(scansOn->widgetChBox[type]->IsOn())
727
      if(scansOn->widgetChBox[type]->IsOn())
729
      {
728
      {
730
         zPosMin->widgetNE[0]->SetState(kTRUE);
729
         zPosMin->widgetNE[0]->SetState(kTRUE);
731
         zPosMax->widgetNE[0]->SetState(kTRUE);
730
         zPosMax->widgetNE[0]->SetState(kTRUE);
732
         zPosStep->widgetNE[0]->SetState(kTRUE);
731
         zPosStep->widgetNE[0]->SetState(kTRUE);
733
      }
732
      }
734
      else
733
      else
735
      {
734
      {
736
         zPosMin->widgetNE[0]->SetState(kFALSE);
735
         zPosMin->widgetNE[0]->SetState(kFALSE);
737
         zPosMax->widgetNE[0]->SetState(kFALSE);
736
         zPosMax->widgetNE[0]->SetState(kFALSE);
738
         zPosStep->widgetNE[0]->SetState(kFALSE);
737
         zPosStep->widgetNE[0]->SetState(kFALSE);
739
      }
738
      }
740
   }
739
   }
741
   // Incidence angle scan
740
   // Incidence angle scan
742
   else if(type == 3)
741
   else if(type == 3)
743
   {
742
   {
744
      if(scansOn->widgetChBox[type]->IsOn())
743
      if(scansOn->widgetChBox[type]->IsOn())
745
      {
744
      {
746
         rotPosMin->widgetNE[0]->SetState(kTRUE);
745
         rotPosMin->widgetNE[0]->SetState(kTRUE);
747
         rotPosMax->widgetNE[0]->SetState(kTRUE);
746
         rotPosMax->widgetNE[0]->SetState(kTRUE);
748
         rotPosStep->widgetNE[0]->SetState(kTRUE);
747
         rotPosStep->widgetNE[0]->SetState(kTRUE);
749
      }
748
      }
750
      else
749
      else
751
      {
750
      {
752
         rotPosMin->widgetNE[0]->SetState(kFALSE);
751
         rotPosMin->widgetNE[0]->SetState(kFALSE);
753
         rotPosMax->widgetNE[0]->SetState(kFALSE);
752
         rotPosMax->widgetNE[0]->SetState(kFALSE);
754
         rotPosStep->widgetNE[0]->SetState(kFALSE);
753
         rotPosStep->widgetNE[0]->SetState(kFALSE);
755
      }
754
      }
756
   }
755
   }
757
}
756
}
758
 
757
 
759
// Apply the upper voltage limit from settings pane to main window
758
// Apply the upper voltage limit from settings pane to main window
760
void TGAppMainFrame::VoltageLimit()
759
void TGAppMainFrame::VoltageLimit()
761
{
760
{
762
   vOut->widgetNE[0]->SetLimitValues(0, vHardlimit->widgetNE[0]->GetNumber() );
761
   vOut->widgetNE[0]->SetLimitValues(0, vHardlimit->widgetNE[0]->GetNumber() );
763
}
762
}
764
 
763
 
765
// Select the table position units to be used (1 = 0.3595 micron)
764
// Select the table position units to be used (1 = 0.3595 micron)
766
void TGAppMainFrame::ChangeUnits(int type)
765
void TGAppMainFrame::ChangeUnits(int type)
767
{
766
{
768
   int pos[12], poslim[3], chng = 0;
767
   int pos[12], poslim[3], chng = 0;
769
   double micro[12], microlim[3];
768
   double micro[12], microlim[3];
770
 
769
 
771
   TGNumberEntry *posEntries[12];
770
   TGNumberEntry *posEntries[12];
772
   posEntries[0] = (TGNumberEntry*)xPos->widgetNE[0];
771
   posEntries[0] = (TGNumberEntry*)xPos->widgetNE[0];
773
   posEntries[1] = (TGNumberEntry*)yPos->widgetNE[0];
772
   posEntries[1] = (TGNumberEntry*)yPos->widgetNE[0];
774
   posEntries[2] = (TGNumberEntry*)zPos->widgetNE[0];
773
   posEntries[2] = (TGNumberEntry*)zPos->widgetNE[0];
775
   posEntries[3] = (TGNumberEntry*)xPosMin->widgetNE[0];
774
   posEntries[3] = (TGNumberEntry*)xPosMin->widgetNE[0];
776
   posEntries[4] = (TGNumberEntry*)xPosMax->widgetNE[0];
775
   posEntries[4] = (TGNumberEntry*)xPosMax->widgetNE[0];
777
   posEntries[5] = (TGNumberEntry*)xPosStep->widgetNE[0];
776
   posEntries[5] = (TGNumberEntry*)xPosStep->widgetNE[0];
778
   posEntries[6] = (TGNumberEntry*)yPosMin->widgetNE[0];
777
   posEntries[6] = (TGNumberEntry*)yPosMin->widgetNE[0];
779
   posEntries[7] = (TGNumberEntry*)yPosMax->widgetNE[0];
778
   posEntries[7] = (TGNumberEntry*)yPosMax->widgetNE[0];
780
   posEntries[8] = (TGNumberEntry*)yPosStep->widgetNE[0];
779
   posEntries[8] = (TGNumberEntry*)yPosStep->widgetNE[0];
781
   posEntries[9] = (TGNumberEntry*)zPosMin->widgetNE[0];
780
   posEntries[9] = (TGNumberEntry*)zPosMin->widgetNE[0];
782
   posEntries[10] = (TGNumberEntry*)zPosMax->widgetNE[0];
781
   posEntries[10] = (TGNumberEntry*)zPosMax->widgetNE[0];
783
   posEntries[11] = (TGNumberEntry*)zPosStep->widgetNE[0];
782
   posEntries[11] = (TGNumberEntry*)zPosStep->widgetNE[0];
784
 
783
 
785
   // Table position values
784
   // Table position values
786
   if(type == 0)
785
   if(type == 0)
787
   {
786
   {
788
      // Check if we had microns before
787
      // Check if we had microns before
789
      if(posEntries[0]->GetNumStyle() == TGNumberFormat::kNESRealTwo)
788
      if(posEntries[0]->GetNumStyle() == TGNumberFormat::kNESRealTwo)
790
         chng = 1;
789
         chng = 1;
791
 
790
 
792
      // Change to table position values   
791
      // Change to table position values   
793
      if(chng == 1)
792
      if(chng == 1)
794
      {
793
      {
795
         for(int i = 0; i < 12; i++)
794
         for(int i = 0; i < 12; i++)
796
         {
795
         {
797
            if(posEntries[i]->GetNumber() == 0.0)
796
            if(posEntries[i]->GetNumber() == 0.0)
798
               pos[i] = 0;
797
               pos[i] = 0;
799
            else
798
            else
800
               pos[i] = (int)posEntries[i]->GetNumber()/lenconversion;
799
               pos[i] = (int)posEntries[i]->GetNumber()/lenconversion;
801
         }
800
         }
802
 
801
 
803
         poslim[0] = -100;
802
         poslim[0] = -100;
804
         poslim[1] = 215000;
803
         poslim[1] = 215000;
805
         poslim[2] = 375000;
804
         poslim[2] = 375000;
806
 
805
 
807
         for(int i = 0; i < 12; i++)
806
         for(int i = 0; i < 12; i++)
808
         {
807
         {
809
            posEntries[i]->SetNumStyle(TGNumberFormat::kNESInteger);
808
            posEntries[i]->SetNumStyle(TGNumberFormat::kNESInteger);
810
            if( (i > 8) || (i == 2) ) // limits for Z axis (longer table)
809
            if( (i > 8) || (i == 2) ) // limits for Z axis (longer table)
811
               posEntries[i]->SetLimits(TGNumberFormat::kNELLimitMinMax, poslim[0], poslim[2]);
810
               posEntries[i]->SetLimits(TGNumberFormat::kNELLimitMinMax, poslim[0], poslim[2]);
812
            else
811
            else
813
               posEntries[i]->SetLimits(TGNumberFormat::kNELLimitMinMax, poslim[0], poslim[1]);
812
               posEntries[i]->SetLimits(TGNumberFormat::kNELLimitMinMax, poslim[0], poslim[1]);
814
 
813
 
815
            posEntries[i]->SetNumber(pos[i]);
814
            posEntries[i]->SetNumber(pos[i]);
816
         }
815
         }
817
      }
816
      }
818
   }
817
   }
819
   // Microns
818
   // Microns
820
   else if(type == 1)
819
   else if(type == 1)
821
   {
820
   {
822
      // Check if we had table position values before
821
      // Check if we had table position values before
823
      if(posEntries[0]->GetNumStyle() == TGNumberFormat::kNESInteger)
822
      if(posEntries[0]->GetNumStyle() == TGNumberFormat::kNESInteger)
824
         chng = 1;
823
         chng = 1;
825
 
824
 
826
      // Change to microns   
825
      // Change to microns   
827
      if(chng == 1)
826
      if(chng == 1)
828
      {
827
      {
829
         for(int i = 0; i < 12; i++)
828
         for(int i = 0; i < 12; i++)
830
         {
829
         {
831
            if(posEntries[i]->GetNumber() == 0.0)
830
            if(posEntries[i]->GetNumber() == 0.0)
832
               micro[i] = 0.;
831
               micro[i] = 0.;
833
            else
832
            else
834
               micro[i] = (double)posEntries[i]->GetNumber()*lenconversion;
833
               micro[i] = (double)posEntries[i]->GetNumber()*lenconversion;
835
         }
834
         }
836
   
835
   
837
         microlim[0] = (double)-100*lenconversion;
836
         microlim[0] = (double)-100*lenconversion;
838
         microlim[1] = (double)215000*lenconversion;
837
         microlim[1] = (double)215000*lenconversion;
839
         microlim[2] = (double)375000*lenconversion;
838
         microlim[2] = (double)375000*lenconversion;
840
   
839
   
841
         for(int i = 0; i < 12; i++)
840
         for(int i = 0; i < 12; i++)
842
         {
841
         {
843
            posEntries[i]->SetNumStyle(TGNumberFormat::kNESRealTwo);
842
            posEntries[i]->SetNumStyle(TGNumberFormat::kNESRealTwo);
844
            if( (i > 8) || (i == 2) ) // limits for Z axis (longer table)
843
            if( (i > 8) || (i == 2) ) // limits for Z axis (longer table)
845
               posEntries[i]->SetLimits(TGNumberFormat::kNELLimitMinMax, microlim[0], microlim[2]);
844
               posEntries[i]->SetLimits(TGNumberFormat::kNELLimitMinMax, microlim[0], microlim[2]);
846
            else
845
            else
847
               posEntries[i]->SetLimits(TGNumberFormat::kNELLimitMinMax, microlim[0], microlim[1]);
846
               posEntries[i]->SetLimits(TGNumberFormat::kNELLimitMinMax, microlim[0], microlim[1]);
848
   
847
   
849
            posEntries[i]->SetNumber(micro[i]);
848
            posEntries[i]->SetNumber(micro[i]);
850
         }
849
         }
851
      }
850
      }
852
   }
851
   }
853
}
852
}
854
 
853
 
855
// Select the rotation units to be used (1 = 6.3281/3600 degrees)
854
// Select the rotation units to be used (1 = 6.3281/3600 degrees)
856
void TGAppMainFrame::ChangeUnitsRot(int type)
855
void TGAppMainFrame::ChangeUnitsRot(int type)
857
{
856
{
858
   int rot[4], rotlim[2], chng = 0;
857
   int rot[4], rotlim[2], chng = 0;
859
   double deg[4], deglim[2];
858
   double deg[4], deglim[2];
860
 
859
 
861
   TGNumberEntry *rotEntries[4];
860
   TGNumberEntry *rotEntries[4];
862
   rotEntries[0] = (TGNumberEntry*)rotPos->widgetNE[0];
861
   rotEntries[0] = (TGNumberEntry*)rotPos->widgetNE[0];
863
   rotEntries[1] = (TGNumberEntry*)rotPosMin->widgetNE[0];
862
   rotEntries[1] = (TGNumberEntry*)rotPosMin->widgetNE[0];
864
   rotEntries[2] = (TGNumberEntry*)rotPosMax->widgetNE[0];
863
   rotEntries[2] = (TGNumberEntry*)rotPosMax->widgetNE[0];
865
   rotEntries[3] = (TGNumberEntry*)rotPosStep->widgetNE[0];
864
   rotEntries[3] = (TGNumberEntry*)rotPosStep->widgetNE[0];
866
 
865
 
867
   // Rotation values
866
   // Rotation values
868
   if(type == 0)
867
   if(type == 0)
869
   {
868
   {
870
      // Check if we had degrees before
869
      // Check if we had degrees before
871
      if(rotEntries[0]->GetNumStyle() == TGNumberFormat::kNESRealTwo)
870
      if(rotEntries[0]->GetNumStyle() == TGNumberFormat::kNESRealTwo)
872
         chng = 1;
871
         chng = 1;
873
 
872
 
874
      // Change to rotation values   
873
      // Change to rotation values   
875
      if(chng == 1)
874
      if(chng == 1)
876
      {
875
      {
877
         for(int i = 0; i < 4; i++)
876
         for(int i = 0; i < 4; i++)
878
         {
877
         {
879
            if(rotEntries[i]->GetNumber() == 0.0)
878
            if(rotEntries[i]->GetNumber() == 0.0)
880
               rot[i] = 0;
879
               rot[i] = 0;
881
            else
880
            else
882
               rot[i] = (int)rotEntries[i]->GetNumber()/rotconversion;
881
               rot[i] = (int)rotEntries[i]->GetNumber()/rotconversion;
883
         }
882
         }
884
 
883
 
885
         rotlim[0] = (int)-180/rotconversion;
884
         rotlim[0] = (int)-180/rotconversion;
886
         rotlim[1] = (int)180/rotconversion;
885
         rotlim[1] = (int)180/rotconversion;
887
 
886
 
888
         for(int i = 0; i < 4; i++)
887
         for(int i = 0; i < 4; i++)
889
         {
888
         {
890
            rotEntries[i]->SetNumStyle(TGNumberFormat::kNESInteger);
889
            rotEntries[i]->SetNumStyle(TGNumberFormat::kNESInteger);
891
            rotEntries[i]->SetLimits(TGNumberFormat::kNELLimitMinMax, rotlim[0], rotlim[1]);
890
            rotEntries[i]->SetLimits(TGNumberFormat::kNELLimitMinMax, rotlim[0], rotlim[1]);
892
 
891
 
893
            rotEntries[i]->SetNumber(rot[i]);
892
            rotEntries[i]->SetNumber(rot[i]);
894
         }
893
         }
895
      }
894
      }
896
   }
895
   }
897
   // Degree
896
   // Degree
898
   else if(type == 1)
897
   else if(type == 1)
899
   {
898
   {
900
      // Check if we had table position values before
899
      // Check if we had table position values before
901
      if(rotEntries[0]->GetNumStyle() == TGNumberFormat::kNESInteger)
900
      if(rotEntries[0]->GetNumStyle() == TGNumberFormat::kNESInteger)
902
         chng = 1;
901
         chng = 1;
903
 
902
 
904
      // Change to degrees   
903
      // Change to degrees   
905
      if(chng == 1)
904
      if(chng == 1)
906
      {
905
      {
907
         for(int i = 0; i < 4; i++)
906
         for(int i = 0; i < 4; i++)
908
         {
907
         {
909
            if(rotEntries[i]->GetNumber() == 0)
908
            if(rotEntries[i]->GetNumber() == 0)
910
               deg[i] = 0.;
909
               deg[i] = 0.;
911
            else
910
            else
912
               deg[i] = (double)rotEntries[i]->GetNumber()*rotconversion;
911
               deg[i] = (double)rotEntries[i]->GetNumber()*rotconversion;
913
         }
912
         }
914
   
913
   
915
         deglim[0] = -180.;
914
         deglim[0] = -180.;
916
         deglim[1] = 180.;
915
         deglim[1] = 180.;
917
   
916
   
918
         for(int i = 0; i < 4; i++)
917
         for(int i = 0; i < 4; i++)
919
         {
918
         {
920
            rotEntries[i]->SetNumStyle(TGNumberFormat::kNESRealTwo);
919
            rotEntries[i]->SetNumStyle(TGNumberFormat::kNESRealTwo);
921
            rotEntries[i]->SetLimits(TGNumberFormat::kNELLimitMinMax, deglim[0], deglim[1]);
920
            rotEntries[i]->SetLimits(TGNumberFormat::kNELLimitMinMax, deglim[0], deglim[1]);
922
   
921
   
923
            rotEntries[i]->SetNumber(deg[i]);
922
            rotEntries[i]->SetNumber(deg[i]);
924
         }
923
         }
925
      }
924
      }
926
   }
925
   }
927
}
926
}
928
 
927
 
929
// Enable display canvas to have a live update of histogram
928
// Enable display canvas to have a live update of histogram
930
void TGAppMainFrame::EnableLiveUpdate()
929
void TGAppMainFrame::EnableLiveUpdate()
931
{
930
{
932
   liveUpdate = liveDisp->widgetChBox[0]->IsDown();
931
   liveUpdate = liveDisp->widgetChBox[0]->IsDown();
933
}
932
}
934
 
933
 
935
// Settings pane connections --------------------------------
934
// Settings pane connections --------------------------------
936
 
935
 
937
// Main measurement window connections ----------------------
936
// Main measurement window connections ----------------------
938
 
937
 
939
// Get the currently selected channel
938
// Get the currently selected channel
940
int TGAppMainFrame::GetChannel()
939
int TGAppMainFrame::GetChannel()
941
{
940
{
942
   int selectedOutput;
941
   int selectedOutput;
943
   if(vOutCh->widgetCB->GetSelected() < 8) selectedOutput = (vOutCh->widgetCB->GetSelected())+1;
942
   if(vOutCh->widgetCB->GetSelected() < 8) selectedOutput = (vOutCh->widgetCB->GetSelected())+1;
944
   else if( (vOutCh->widgetCB->GetSelected() >= 8) && (vOutCh->widgetCB->GetSelected() < 16) ) selectedOutput = (vOutCh->widgetCB->GetSelected())+93;
943
   else if( (vOutCh->widgetCB->GetSelected() >= 8) && (vOutCh->widgetCB->GetSelected() < 16) ) selectedOutput = (vOutCh->widgetCB->GetSelected())+93;
945
   else selectedOutput = 1;
944
   else selectedOutput = 1;
946
 
945
 
947
   return selectedOutput;
946
   return selectedOutput;
948
}
947
}
949
 
948
 
950
// Set, get or reset the output voltage
949
// Set, get or reset the output voltage
951
void TGAppMainFrame::VoltOut(int opt)
950
void TGAppMainFrame::VoltOut(int opt)
952
{
951
{
953
   char cmd[256];
952
   char cmd[256];
954
 
953
 
955
   // Set the selected voltage
954
   // Set the selected voltage
956
   if(opt == 0)
955
   if(opt == 0)
957
   {
956
   {
958
      int outOn;
957
      int outOn;
959
      float outputVoltage;
958
      float outputVoltage;
960
     
959
     
961
      outputVoltage = vOut->widgetNE[0]->GetNumber();
960
      outputVoltage = vOut->widgetNE[0]->GetNumber();
962
   
961
   
963
      if(vOutOpt->widgetChBox[1]->IsOn()) outOn = 1;
962
      if(vOutOpt->widgetChBox[1]->IsOn()) outOn = 1;
964
      else outOn = 0;
963
      else outOn = 0;
965
     
964
     
966
      fflush(stdout);
965
      fflush(stdout);
967
      sprintf(cmd, "%s/src/mpod/mpod_voltage.sh -o %d -v %f -s %d", rootdir, GetChannel(), outputVoltage, outOn);
966
      sprintf(cmd, "%s/src/mpod/mpod_voltage.sh -o %d -v %f -s %d", rootdir, GetChannel(), outputVoltage, outOn);
968
#if WORKSTAT == 'I'
967
#if WORKSTAT == 'I'
969
      retTemp = system(cmd);
968
      retTemp = system(cmd);
970
#else
969
#else
971
      printf("Cmd: %s\n",cmd);
970
      printf("Cmd: %s\n",cmd);
972
#endif
971
#endif
973
      fflush(stdout);
972
      fflush(stdout);
974
   }
973
   }
975
   // Get current voltage
974
   // Get current voltage
976
   else if(opt == 1)
975
   else if(opt == 1)
977
   {
976
   {
978
      fflush(stdout);
977
      fflush(stdout);
979
      sprintf(cmd, "%s/src/mpod/mpod_voltage.sh -o %d -g > %s/settings/curvolt.txt", rootdir, GetChannel(), rootdir);
978
      sprintf(cmd, "%s/src/mpod/mpod_voltage.sh -o %d -g > %s/settings/curvolt.txt", rootdir, GetChannel(), rootdir);
980
#if WORKSTAT == 'I'
979
#if WORKSTAT == 'I'
981
      retTemp = system(cmd);
980
      retTemp = system(cmd);
982
#else
981
#else
983
      printf("Cmd: %s\n",cmd);
982
      printf("Cmd: %s\n",cmd);
984
#endif
983
#endif
985
      fflush(stdout);
984
      fflush(stdout);
986
 
985
 
987
#if WORKSTAT == 'I'
986
#if WORKSTAT == 'I'
988
      FILE* fvolt;
987
      FILE* fvolt;
989
      double dtemp;
988
      double dtemp;
990
      char ctemp[24];
989
      char ctemp[24];
991
      sprintf(cmd, "%s/settings/curvolt.txt", rootdir);
990
      sprintf(cmd, "%s/settings/curvolt.txt", rootdir);
992
      fvolt = fopen(cmd, "r");
991
      fvolt = fopen(cmd, "r");
993
     
992
     
994
      if(fvolt != NULL)
993
      if(fvolt != NULL)
995
      {
994
      {
996
         sprintf(cmd, "WIENER-CRATE-MIB::outputVoltage.u%d = Opaque: Float: %s V\n", GetChannel()-1, "%lf" );
995
         sprintf(cmd, "WIENER-CRATE-MIB::outputVoltage.u%d = Opaque: Float: %s V\n", GetChannel()-1, "%lf" );
997
         retTemp = fscanf(fvolt, cmd, &dtemp);
996
         retTemp = fscanf(fvolt, cmd, &dtemp);
998
         vOut->widgetNE[0]->SetNumber(dtemp);
997
         vOut->widgetNE[0]->SetNumber(dtemp);
999
         sprintf(cmd, "WIENER-CRATE-MIB::outputSwitch.u%d = INTEGER: %s\n", GetChannel()-1, "%s" );
998
         sprintf(cmd, "WIENER-CRATE-MIB::outputSwitch.u%d = INTEGER: %s\n", GetChannel()-1, "%s" );
1000
         retTemp = fscanf(fvolt, cmd, ctemp);
999
         retTemp = fscanf(fvolt, cmd, ctemp);
1001
         if( strcmp(ctemp, "On(1)") == 0 )
1000
         if( strcmp(ctemp, "On(1)") == 0 )
1002
            vOutOpt->widgetChBox[1]->SetState(kButtonDown);
1001
            vOutOpt->widgetChBox[1]->SetState(kButtonDown);
1003
         else if( strcmp(ctemp, "Off(0)") == 0 )
1002
         else if( strcmp(ctemp, "Off(0)") == 0 )
1004
            vOutOpt->widgetChBox[1]->SetState(kButtonUp);
1003
            vOutOpt->widgetChBox[1]->SetState(kButtonUp);
1005
      }
1004
      }
1006
   
1005
   
1007
      fclose(fvolt);
1006
      fclose(fvolt);
1008
#endif
1007
#endif
1009
   }
1008
   }
1010
   // Reset output voltage (if stuck in interlock)
1009
   // Reset output voltage (if stuck in interlock)
1011
   else if(opt == 2)
1010
   else if(opt == 2)
1012
   {
1011
   {
1013
      vOut->widgetNE[0]->SetNumber(0.000);
1012
      vOut->widgetNE[0]->SetNumber(0.000);
1014
      vOutOpt->widgetChBox[1]->SetState(kButtonUp);
1013
      vOutOpt->widgetChBox[1]->SetState(kButtonUp);
1015
 
1014
 
1016
      fflush(stdout);
1015
      fflush(stdout);
1017
      sprintf(cmd, "%s/src/mpod/mpod_voltage.sh -r %d", rootdir, GetChannel());
1016
      sprintf(cmd, "%s/src/mpod/mpod_voltage.sh -r %d", rootdir, GetChannel());
1018
#if WORKSTAT == 'I'
1017
#if WORKSTAT == 'I'
1019
      retTemp = system(cmd);
1018
      retTemp = system(cmd);
1020
#else
1019
#else
1021
      printf("Cmd: %s\n",cmd);
1020
      printf("Cmd: %s\n",cmd);
1022
#endif
1021
#endif
1023
      fflush(stdout);
1022
      fflush(stdout);
1024
   }
1023
   }
1025
}
1024
}
1026
 
1025
 
1027
// Set output voltage polarity to negative
1026
// Set output voltage polarity to negative
1028
void TGAppMainFrame::NegativePolarity()
1027
void TGAppMainFrame::NegativePolarity()
1029
{
1028
{
1030
   double newHardlimit;
1029
   double newHardlimit;
1031
   int polar = 0;  // 0 = positive, 1 = negative
1030
   int polar = 0;  // 0 = positive, 1 = negative
1032
 
1031
 
1033
   if(vOutOpt->widgetChBox[0]->IsOn())
1032
   if(vOutOpt->widgetChBox[0]->IsOn())
1034
      polar = 1;
1033
      polar = 1;
1035
   else
1034
   else
1036
      polar = 0;
1035
      polar = 0;
1037
 
1036
 
1038
   // Set hard limit to the negative version of what it was before
1037
   // Set hard limit to the negative version of what it was before
1039
   if( (vHardlimit->widgetNE[0]->GetNumber() > 0.) && (polar == 1) )
1038
   if( (vHardlimit->widgetNE[0]->GetNumber() > 0.) && (polar == 1) )
1040
      newHardlimit = -(vHardlimit->widgetNE[0]->GetNumber());
1039
      newHardlimit = -(vHardlimit->widgetNE[0]->GetNumber());
1041
   else if( (vHardlimit->widgetNE[0]->GetNumber() < 0.) && (polar == 0) )
1040
   else if( (vHardlimit->widgetNE[0]->GetNumber() < 0.) && (polar == 0) )
1042
      newHardlimit = -(vHardlimit->widgetNE[0]->GetNumber());
1041
      newHardlimit = -(vHardlimit->widgetNE[0]->GetNumber());
1043
   else if(vHardlimit->widgetNE[0]->GetNumber() == 0.)
1042
   else if(vHardlimit->widgetNE[0]->GetNumber() == 0.)
1044
      newHardlimit = 0.;
1043
      newHardlimit = 0.;
1045
   else
1044
   else
1046
      newHardlimit = vHardlimit->widgetNE[0]->GetNumber();
1045
      newHardlimit = vHardlimit->widgetNE[0]->GetNumber();
1047
 
1046
 
1048
   // Apropriately set the limit to the output voltage number entry
1047
   // Apropriately set the limit to the output voltage number entry
1049
   vHardlimit->widgetNE[0]->SetNumber(newHardlimit);
1048
   vHardlimit->widgetNE[0]->SetNumber(newHardlimit);
1050
 
1049
 
1051
   if(polar == 1)
1050
   if(polar == 1)
1052
      vOut->widgetNE[0]->SetLimits(TGNumberFormat::kNELLimitMinMax, newHardlimit, 0.);
1051
      vOut->widgetNE[0]->SetLimits(TGNumberFormat::kNELLimitMinMax, newHardlimit, 0.);
1053
   else if(polar == 0)
1052
   else if(polar == 0)
1054
      vOut->widgetNE[0]->SetLimits(TGNumberFormat::kNELLimitMinMax, 0., newHardlimit);
1053
      vOut->widgetNE[0]->SetLimits(TGNumberFormat::kNELLimitMinMax, 0., newHardlimit);
1055
}
1054
}
1056
 
1055
 
1057
// Set, get, home or reset the table position
1056
// Set, get, home or reset the table position
1058
void TGAppMainFrame::PositionSet(int opt)
1057
void TGAppMainFrame::PositionSet(int opt)
1059
{
1058
{
1060
   char cmd[1024];
1059
   char cmd[1024];
1061
 
1060
 
1062
   // Set the selected table position
1061
   // Set the selected table position
1063
   if(opt == 0)
1062
   if(opt == 0)
1064
   {
1063
   {
1065
      int positX, positY, positZ;
1064
      int positX, positY, positZ;
1066
 
1065
 
1067
      if(posUnits->widgetCB->GetSelected() == 0)
1066
      if(posUnits->widgetCB->GetSelected() == 0)
1068
      {
1067
      {
1069
         positX = xPos->widgetNE[0]->GetNumber();
1068
         positX = xPos->widgetNE[0]->GetNumber();
1070
         positY = yPos->widgetNE[0]->GetNumber();
1069
         positY = yPos->widgetNE[0]->GetNumber();
1071
         positZ = zPos->widgetNE[0]->GetNumber();
1070
         positZ = zPos->widgetNE[0]->GetNumber();
1072
      }
1071
      }
1073
      else if(posUnits->widgetCB->GetSelected() == 1)
1072
      else if(posUnits->widgetCB->GetSelected() == 1)
1074
      {
1073
      {
1075
         positX = (int)xPos->widgetNE[0]->GetNumber()/lenconversion;
1074
         positX = (int)xPos->widgetNE[0]->GetNumber()/lenconversion;
1076
         positY = (int)yPos->widgetNE[0]->GetNumber()/lenconversion;
1075
         positY = (int)yPos->widgetNE[0]->GetNumber()/lenconversion;
1077
         positZ = (int)zPos->widgetNE[0]->GetNumber()/lenconversion;
1076
         positZ = (int)zPos->widgetNE[0]->GetNumber()/lenconversion;
1078
      }
1077
      }
1079
 
1078
 
1080
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 1 -v %d -s la && %s/src/MIKRO/mikro_ctrl -n 1 -c m", rootdir, positX, rootdir);
1079
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 1 -v %d -s la && %s/src/MIKRO/mikro_ctrl -n 1 -c m", rootdir, positX, rootdir);
1081
#if WORKSTAT == 'I'
1080
#if WORKSTAT == 'I'
1082
      retTemp = system(cmd);
1081
      retTemp = system(cmd);
1083
#else
1082
#else
1084
      printf("Cmd: %s\n",cmd);
1083
      printf("Cmd: %s\n",cmd);
1085
#endif
1084
#endif
1086
 
1085
 
1087
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 2 -v %d -s la && %s/src/MIKRO/mikro_ctrl -n 2 -c m", rootdir, positY, rootdir);
1086
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 2 -v %d -s la && %s/src/MIKRO/mikro_ctrl -n 2 -c m", rootdir, positY, rootdir);
1088
#if WORKSTAT == 'I'
1087
#if WORKSTAT == 'I'
1089
      retTemp = system(cmd);
1088
      retTemp = system(cmd);
1090
#else
1089
#else
1091
      printf("Cmd: %s\n",cmd);
1090
      printf("Cmd: %s\n",cmd);
1092
#endif
1091
#endif
1093
 
1092
 
1094
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 3 -v %d -s la && %s/src/MIKRO/mikro_ctrl -n 3 -c m", rootdir, positZ, rootdir);
1093
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 3 -v %d -s la && %s/src/MIKRO/mikro_ctrl -n 3 -c m", rootdir, positZ, rootdir);
1095
#if WORKSTAT == 'I'
1094
#if WORKSTAT == 'I'
1096
      retTemp = system(cmd);
1095
      retTemp = system(cmd);
1097
#else
1096
#else
1098
      printf("Cmd: %s\n",cmd);
1097
      printf("Cmd: %s\n",cmd);
1099
#endif
1098
#endif
1100
   }
1099
   }
1101
   // Get current table position
1100
   // Get current table position
1102
   else if(opt == 1)
1101
   else if(opt == 1)
1103
   {
1102
   {
1104
      fflush(stdout);
1103
      fflush(stdout);
1105
   
1104
   
1106
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 1 -p > %s/settings/curpos.txt", rootdir, rootdir);  // X-axis
1105
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 1 -p > %s/settings/curpos.txt", rootdir, rootdir);  // X-axis
1107
      fflush(stdout);
1106
      fflush(stdout);
1108
#if WORKSTAT == 'I'
1107
#if WORKSTAT == 'I'
1109
      retTemp = system(cmd);
1108
      retTemp = system(cmd);
1110
#else
1109
#else
1111
      printf("Cmd: %s\n",cmd);
1110
      printf("Cmd: %s\n",cmd);
1112
#endif
1111
#endif
1113
   
1112
   
1114
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 2 -p >> %s/settings/curpos.txt", rootdir, rootdir); // Y-axis
1113
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 2 -p >> %s/settings/curpos.txt", rootdir, rootdir); // Y-axis
1115
      fflush(stdout);
1114
      fflush(stdout);
1116
#if WORKSTAT == 'I'
1115
#if WORKSTAT == 'I'
1117
      retTemp = system(cmd);
1116
      retTemp = system(cmd);
1118
#else
1117
#else
1119
      printf("Cmd: %s\n",cmd);
1118
      printf("Cmd: %s\n",cmd);
1120
#endif
1119
#endif
1121
   
1120
   
1122
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 3 -p >> %s/settings/curpos.txt", rootdir, rootdir); // Z-axis
1121
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 3 -p >> %s/settings/curpos.txt", rootdir, rootdir); // Z-axis
1123
      fflush(stdout);
1122
      fflush(stdout);
1124
#if WORKSTAT == 'I'
1123
#if WORKSTAT == 'I'
1125
      retTemp = system(cmd);
1124
      retTemp = system(cmd);
1126
#else
1125
#else
1127
      printf("Cmd: %s\n",cmd);
1126
      printf("Cmd: %s\n",cmd);
1128
#endif
1127
#endif
1129
 
1128
 
1130
#if WORKSTAT == 'I'
1129
#if WORKSTAT == 'I'
1131
      FILE* fpos;
1130
      FILE* fpos;
1132
      int itemp;
1131
      int itemp;
1133
      sprintf(cmd, "%s/settings/curpos.txt", rootdir);
1132
      sprintf(cmd, "%s/settings/curpos.txt", rootdir);
1134
      fpos = fopen(cmd, "r");
1133
      fpos = fopen(cmd, "r");
1135
     
1134
     
1136
      if(fpos != NULL)
1135
      if(fpos != NULL)
1137
      {
1136
      {
1138
         if(posUnits->widgetCB->GetSelected() == 0)
1137
         if(posUnits->widgetCB->GetSelected() == 0)
1139
         {
1138
         {
1140
            retTemp = fscanf(fpos, "%d\n", &itemp);
1139
            retTemp = fscanf(fpos, "%d\n", &itemp);
1141
            xPos->widgetNE[0]->SetNumber(itemp);
1140
            xPos->widgetNE[0]->SetNumber(itemp);
1142
            retTemp = fscanf(fpos, "%d\n", &itemp);
1141
            retTemp = fscanf(fpos, "%d\n", &itemp);
1143
            yPos->widgetNE[0]->SetNumber(itemp);
1142
            yPos->widgetNE[0]->SetNumber(itemp);
1144
            retTemp = fscanf(fpos, "%d\n", &itemp);
1143
            retTemp = fscanf(fpos, "%d\n", &itemp);
1145
            zPos->widgetNE[0]->SetNumber(itemp);
1144
            zPos->widgetNE[0]->SetNumber(itemp);
1146
         }
1145
         }
1147
         else if(posUnits->widgetCB->GetSelected() == 1)
1146
         else if(posUnits->widgetCB->GetSelected() == 1)
1148
         {
1147
         {
1149
            retTemp = fscanf(fpos, "%d\n", &itemp);
1148
            retTemp = fscanf(fpos, "%d\n", &itemp);
1150
            xPos->widgetNE[0]->SetNumber((double)itemp*lenconversion);
1149
            xPos->widgetNE[0]->SetNumber((double)itemp*lenconversion);
1151
            retTemp = fscanf(fpos, "%d\n", &itemp);
1150
            retTemp = fscanf(fpos, "%d\n", &itemp);
1152
            yPos->widgetNE[0]->SetNumber((double)itemp*lenconversion);
1151
            yPos->widgetNE[0]->SetNumber((double)itemp*lenconversion);
1153
            retTemp = fscanf(fpos, "%d\n", &itemp);
1152
            retTemp = fscanf(fpos, "%d\n", &itemp);
1154
            zPos->widgetNE[0]->SetNumber((double)itemp*lenconversion);
1153
            zPos->widgetNE[0]->SetNumber((double)itemp*lenconversion);
1155
         }
1154
         }
1156
      }
1155
      }
1157
 
1156
 
1158
      fclose(fpos);
1157
      fclose(fpos);
1159
#endif
1158
#endif
1160
   }
1159
   }
1161
   // Home the table position
1160
   // Home the table position
1162
   else if(opt == 2)
1161
   else if(opt == 2)
1163
   {
1162
   {
1164
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 1 -h", rootdir);    // X-axis
1163
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 1 -h", rootdir);    // X-axis
1165
#if WORKSTAT == 'I'
1164
#if WORKSTAT == 'I'
1166
      retTemp = system(cmd);
1165
      retTemp = system(cmd);
1167
#else
1166
#else
1168
      printf("Cmd: %s\n",cmd);
1167
      printf("Cmd: %s\n",cmd);
1169
#endif
1168
#endif
1170
 
1169
 
1171
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 2 -h", rootdir);    // Y-axis
1170
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 2 -h", rootdir);    // Y-axis
1172
#if WORKSTAT == 'I'
1171
#if WORKSTAT == 'I'
1173
      retTemp = system(cmd);
1172
      retTemp = system(cmd);
1174
#else
1173
#else
1175
      printf("Cmd: %s\n",cmd);
1174
      printf("Cmd: %s\n",cmd);
1176
#endif
1175
#endif
1177
 
1176
 
1178
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 3 -h", rootdir);    // Z-axis
1177
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 3 -h", rootdir);    // Z-axis
1179
#if WORKSTAT == 'I'
1178
#if WORKSTAT == 'I'
1180
      retTemp = system(cmd);
1179
      retTemp = system(cmd);
1181
#else
1180
#else
1182
      printf("Cmd: %s\n",cmd);
1181
      printf("Cmd: %s\n",cmd);
1183
#endif
1182
#endif
1184
      PositionSet(1);
1183
      PositionSet(1);
1185
   }
1184
   }
1186
   // Reset the table position
1185
   // Reset the table position
1187
   else if(opt == 3)
1186
   else if(opt == 3)
1188
   {
1187
   {
1189
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 1 -r && sudo %s/src/MIKRO/mikro_ctrl -n 1 -i 3 && sudo %s/src/MIKRO/mikro_ctrl -n 1 -h", rootdir, rootdir, rootdir);        // X-axis
1188
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 1 -r && sudo %s/src/MIKRO/mikro_ctrl -n 1 -i 3 && sudo %s/src/MIKRO/mikro_ctrl -n 1 -h", rootdir, rootdir, rootdir);        // X-axis
1190
#if WORKSTAT == 'I'
1189
#if WORKSTAT == 'I'
1191
      printf("Positioning table reset, initialization and homing in progress. Please wait...\n");
1190
      printf("Positioning table reset, initialization and homing in progress. Please wait...\n");
1192
      retTemp = system(cmd);
1191
      retTemp = system(cmd);
1193
#else
1192
#else
1194
      printf("Cmd: %s\n",cmd);
1193
      printf("Cmd: %s\n",cmd);
1195
#endif
1194
#endif
1196
 
1195
 
1197
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 2 -r && sudo %s/src/MIKRO/mikro_ctrl -n 2 -i 3 && sudo %s/src/MIKRO/mikro_ctrl -n 2 -h", rootdir, rootdir, rootdir);        // Y-axis
1196
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 2 -r && sudo %s/src/MIKRO/mikro_ctrl -n 2 -i 3 && sudo %s/src/MIKRO/mikro_ctrl -n 2 -h", rootdir, rootdir, rootdir);        // Y-axis
1198
#if WORKSTAT == 'I'
1197
#if WORKSTAT == 'I'
1199
      retTemp = system(cmd);
1198
      retTemp = system(cmd);
1200
#else
1199
#else
1201
      printf("Cmd: %s\n",cmd);
1200
      printf("Cmd: %s\n",cmd);
1202
#endif
1201
#endif
1203
 
1202
 
1204
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 3 -r && sudo %s/src/MIKRO/mikro_ctrl -n 3 -i 3 && sudo %s/src/MIKRO/mikro_ctrl -n 3 -h", rootdir, rootdir, rootdir);        // Z-axis
1203
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 3 -r && sudo %s/src/MIKRO/mikro_ctrl -n 3 -i 3 && sudo %s/src/MIKRO/mikro_ctrl -n 3 -h", rootdir, rootdir, rootdir);        // Z-axis
1205
#if WORKSTAT == 'I'
1204
#if WORKSTAT == 'I'
1206
      retTemp = system(cmd);
1205
      retTemp = system(cmd);
1207
      printf("Positioning table reset, initialization and homing complete.\n");
1206
      printf("Positioning table reset, initialization and homing complete.\n");
-
 
1207
#else
-
 
1208
      printf("Cmd: %s\n",cmd);
-
 
1209
#endif
-
 
1210
      PositionSet(1);
-
 
1211
   }
-
 
1212
   // Abort any motion
-
 
1213
   else if(opt == 4)
-
 
1214
   {
-
 
1215
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 1 -c ab", rootdir); // X-axis
-
 
1216
#if WORKSTAT == 'I'
-
 
1217
      printf("Emergency stop of the current movement of all linear tables.\n");
-
 
1218
      retTemp = system(cmd);
-
 
1219
#else
-
 
1220
      printf("Cmd: %s\n",cmd);
-
 
1221
#endif
-
 
1222
 
-
 
1223
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 2 -c ab", rootdir); // Y-axis
-
 
1224
#if WORKSTAT == 'I'
-
 
1225
      retTemp = system(cmd);
-
 
1226
#else
-
 
1227
      printf("Cmd: %s\n",cmd);
-
 
1228
#endif
-
 
1229
 
-
 
1230
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 3 -c ab", rootdir); // Z-axis
-
 
1231
#if WORKSTAT == 'I'
-
 
1232
      retTemp = system(cmd);
1208
#else
1233
#else
1209
      printf("Cmd: %s\n",cmd);
1234
      printf("Cmd: %s\n",cmd);
1210
#endif
1235
#endif
1211
      PositionSet(1);
1236
      PositionSet(1);
1212
   }
1237
   }
1213
}
1238
}
1214
 
1239
 
1215
// Set, get, home or reset the rotation platform
1240
// Set, get, home or reset the rotation platform
1216
void TGAppMainFrame::RotationSet(int opt)
1241
void TGAppMainFrame::RotationSet(int opt)
1217
{
1242
{
1218
   char cmd[1024];
1243
   char cmd[1024];
1219
 
1244
 
1220
   // Set the selected rotation
1245
   // Set the selected rotation
1221
   if(opt == 0)
1246
   if(opt == 0)
1222
   {
1247
   {
1223
      int positAlpha;
1248
      int positAlpha;
1224
 
1249
 
1225
      if(rotUnits->widgetCB->GetSelected() == 0)
1250
      if(rotUnits->widgetCB->GetSelected() == 0)
1226
         positAlpha = rotPos->widgetNE[0]->GetNumber();
1251
         positAlpha = rotPos->widgetNE[0]->GetNumber();
1227
      else if(rotUnits->widgetCB->GetSelected() == 1)
1252
      else if(rotUnits->widgetCB->GetSelected() == 1)
1228
         positAlpha = rotPos->widgetNE[0]->GetNumber()/rotconversion;
1253
         positAlpha = rotPos->widgetNE[0]->GetNumber()/rotconversion;
1229
 
1254
 
1230
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 4 -v %d -s la && %s/src/MIKRO/mikro_ctrl -n 4 -c m", rootdir, positAlpha, rootdir);
1255
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 4 -v %d -s la && %s/src/MIKRO/mikro_ctrl -n 4 -c m", rootdir, positAlpha, rootdir);
1231
#if WORKSTAT == 'I'
1256
#if WORKSTAT == 'I'
1232
      retTemp = system(cmd);
1257
      retTemp = system(cmd);
1233
#else
1258
#else
1234
      printf("Cmd: %s\n",cmd);
1259
      printf("Cmd: %s\n",cmd);
1235
#endif
1260
#endif
1236
   }
1261
   }
1237
   // Get current rotation
1262
   // Get current rotation
1238
   else if(opt == 1)
1263
   else if(opt == 1)
1239
   {
1264
   {
1240
      fflush(stdout);
1265
      fflush(stdout);
1241
   
1266
   
1242
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 4 -p > %s/settings/currot.txt", rootdir, rootdir);
1267
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 4 -p > %s/settings/currot.txt", rootdir, rootdir);
1243
      fflush(stdout);
1268
      fflush(stdout);
1244
#if WORKSTAT == 'I'
1269
#if WORKSTAT == 'I'
1245
      retTemp = system(cmd);
1270
      retTemp = system(cmd);
1246
#else
1271
#else
1247
      printf("Cmd: %s\n",cmd);
1272
      printf("Cmd: %s\n",cmd);
1248
#endif
1273
#endif
1249
 
1274
 
1250
#if WORKSTAT == 'I'
1275
#if WORKSTAT == 'I'
1251
      FILE* frot;
1276
      FILE* frot;
1252
      int itemp;
1277
      int itemp;
1253
      sprintf(cmd, "%s/settings/currot.txt", rootdir);
1278
      sprintf(cmd, "%s/settings/currot.txt", rootdir);
1254
      frot = fopen(cmd, "r");
1279
      frot = fopen(cmd, "r");
1255
 
1280
 
1256
      if(frot != NULL)
1281
      if(frot != NULL)
1257
      {
1282
      {
1258
         retTemp = fscanf(frot, "%d\n", &itemp);
1283
         retTemp = fscanf(frot, "%d\n", &itemp);
1259
         if(rotUnits->widgetCB->GetSelected() == 0)
1284
         if(rotUnits->widgetCB->GetSelected() == 0)
1260
            rotPos->widgetNE[0]->SetNumber(itemp);
1285
            rotPos->widgetNE[0]->SetNumber(itemp);
1261
         else if(rotUnits->widgetCB->GetSelected() == 1)
1286
         else if(rotUnits->widgetCB->GetSelected() == 1)
1262
            rotPos->widgetNE[0]->SetNumber((double)itemp*rotconversion);
1287
            rotPos->widgetNE[0]->SetNumber((double)itemp*rotconversion);
1263
      }
1288
      }
1264
 
1289
 
1265
      fclose(frot);
1290
      fclose(frot);
1266
#endif
1291
#endif
1267
   }
1292
   }
1268
   // Home the rotation
1293
   // Home the rotation
1269
   else if(opt == 2)
1294
   else if(opt == 2)
1270
   {
1295
   {
1271
      // TODO: For now only set back to 0, not home!
1296
      // TODO: For now only set back to 0, not home!
1272
//      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 4 -h", rootdir);
1297
//      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 4 -h", rootdir);
1273
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 4 -v 0 -s la && %s/src/MIKRO/mikro_ctrl -n 4 -c m", rootdir, rootdir);
1298
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 4 -v 0 -s la && %s/src/MIKRO/mikro_ctrl -n 4 -c m", rootdir, rootdir);
1274
#if WORKSTAT == 'I'
1299
#if WORKSTAT == 'I'
1275
      retTemp = system(cmd);
1300
      retTemp = system(cmd);
1276
#else
1301
#else
1277
      printf("Cmd: %s\n",cmd);
1302
      printf("Cmd: %s\n",cmd);
1278
#endif
1303
#endif
1279
      RotationSet(1);
1304
      RotationSet(1);
1280
   }
1305
   }
1281
   // Reset the rotation
1306
   // Reset the rotation
1282
   else if(opt == 3)
1307
   else if(opt == 3)
1283
   {
1308
   {
1284
      // TODO: For now only set back to 0, not home!
1309
      // TODO: For now only set back to 0, not home!
1285
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 4 -r && sudo %s/src/MIKRO/mikro_ctrl -n 4 -i 2 && sudo %s/src/MIKRO/mikro_ctrl -n 4 -h", rootdir, rootdir, rootdir);
1310
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 4 -r && sudo %s/src/MIKRO/mikro_ctrl -n 4 -i 2 && sudo %s/src/MIKRO/mikro_ctrl -n 4 -h", rootdir, rootdir, rootdir);
1286
#if WORKSTAT == 'I'
1311
#if WORKSTAT == 'I'
1287
      printf("Rotation platform reset, initalization and homing in progress. Please wait...\n");
1312
      printf("Rotation platform reset, initalization and homing in progress. Please wait...\n");
1288
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 4 -v 0 -s la && %s/src/MIKRO/mikro_ctrl -n 4 -c m", rootdir, rootdir);
1313
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 4 -v 0 -s la && %s/src/MIKRO/mikro_ctrl -n 4 -c m", rootdir, rootdir);
1289
      retTemp = system(cmd);
1314
      retTemp = system(cmd);
1290
      sleep(15);        // wait for the motor to change position from wherever to 0
1315
      sleep(15);        // wait for the motor to change position from wherever to 0
1291
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 4 -r && sudo %s/src/MIKRO/mikro_ctrl -n 4 -i 2", rootdir, rootdir);
1316
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 4 -r && sudo %s/src/MIKRO/mikro_ctrl -n 4 -i 2", rootdir, rootdir);
1292
      retTemp = system(cmd);
1317
      retTemp = system(cmd);
1293
      printf("Rotation platform reset, initalization and homing complete.\n");
1318
      printf("Rotation platform reset, initalization and homing complete.\n");
-
 
1319
#else
-
 
1320
      printf("Cmd: %s\n",cmd);
-
 
1321
#endif
-
 
1322
      RotationSet(1);
-
 
1323
   }
-
 
1324
   // Abort any motion
-
 
1325
   else if(opt == 4)
-
 
1326
   {
-
 
1327
      sprintf(cmd, "sudo %s/src/MIKRO/mikro_ctrl -n 4 -c ab", rootdir);
-
 
1328
#if WORKSTAT == 'I'
-
 
1329
      printf("Emergency stop of the current movement of the rotation platform.\n");
-
 
1330
      retTemp = system(cmd);
1294
#else
1331
#else
1295
      printf("Cmd: %s\n",cmd);
1332
      printf("Cmd: %s\n",cmd);
1296
#endif
1333
#endif
1297
      RotationSet(1);
1334
      RotationSet(1);
1298
   }
1335
   }
1299
}
1336
}
1300
 
1337
 
1301
// File browser for selecting the save file
1338
// File browser for selecting the save file
1302
void TGAppMainFrame::SaveFile()
1339
void TGAppMainFrame::SaveFile()
1303
{
1340
{
-
 
1341
//   char *cTemp;
-
 
1342
 
1304
   TGFileInfo file_info;
1343
   TGFileInfo file_info;
1305
   const char *filetypes[] = {"Histograms",histextall,0,0};
1344
   const char *filetypes[] = {"Histograms",histextall,0,0};
1306
   char *cTemp;
-
 
1307
   file_info.fFileTypes = filetypes;
1345
   file_info.fFileTypes = filetypes;
1308
   cTemp = new char[1024];
1346
//   cTemp = new char[1024];
1309
   sprintf(cTemp, "%s/results", rootdir);
1347
//   sprintf(cTemp, "%s/results", rootdir);
1310
   file_info.fIniDir = StrDup(cTemp);
1348
//   file_info.fIniDir = StrDup(cTemp);
-
 
1349
   file_info.fIniDir = StrDup(currentMeasDir);
1311
   new TGFileDialog(gClient->GetDefaultRoot(), fMain, kFDSave, &file_info);
1350
   new TGFileDialog(gClient->GetDefaultRoot(), fMain, kFDSave, &file_info);
1312
   delete[] cTemp;
1351
//   delete[] cTemp;
1313
 
1352
 
1314
   if(file_info.fFilename != NULL)
1353
   if(file_info.fFilename != NULL)
-
 
1354
   {
1315
      fileName->widgetTE->SetText(file_info.fFilename);
1355
      fileName->widgetTE->SetText(file_info.fFilename);
-
 
1356
      remove_from_last(file_info.fFilename, '/', currentMeasDir);
-
 
1357
   }
1316
}
1358
}
1317
 
1359
 
1318
// Start the acquisition
1360
// Start the acquisition
1319
void TGAppMainFrame::StartAcq()
1361
void TGAppMainFrame::StartAcq()
1320
{
1362
{
1321
   // Variable that will initialize camac only once (for scans)
1363
   // Variable that will initialize camac only once (for scans)
1322
   int scanon = 0;
1364
   int scanon = 0;
1323
 
1365
 
1324
   // Determine the type of measurement to perform
1366
   // Determine the type of measurement to perform
1325
   int vscan = 0, pscan = 0, zscan = 0, ascan = 0;
1367
   int vscan = 0, pscan = 0, zscan = 0, ascan = 0;
1326
   if(scansOn->widgetChBox[0]->IsDown()) vscan = 1;
1368
   if(scansOn->widgetChBox[0]->IsDown()) vscan = 1;
1327
   if(scansOn->widgetChBox[1]->IsDown()) pscan = 1;
1369
   if(scansOn->widgetChBox[1]->IsDown()) pscan = 1;
1328
   if(scansOn->widgetChBox[2]->IsDown()) zscan = 1;
1370
   if(scansOn->widgetChBox[2]->IsDown()) zscan = 1;
1329
   if(scansOn->widgetChBox[3]->IsDown()) ascan = 1;
1371
   if(scansOn->widgetChBox[3]->IsDown()) ascan = 1;
1330
 
1372
 
1331
   char cmd[256];
1373
   char cmd[256];
1332
   int i, j, k;
1374
   int i, j, k;
1333
   float progVal;
1375
   float progVal;
1334
   FILE *pfin;
1376
   FILE *pfin;
1335
 
1377
 
1336
   // Variables for voltage scan
1378
   // Variables for voltage scan
1337
   float currentVoltage, minVoltage, maxVoltage, stepVoltage;
1379
   float currentVoltage, minVoltage, maxVoltage, stepVoltage;
1338
   int repetition;
1380
   int repetition;
1339
 
1381
 
1340
   // Variables for surface scan and Z axis scan
1382
   // Variables for surface scan and Z axis scan
1341
   float minXpos, maxXpos, stepXpos;
1383
   float minXpos, maxXpos, stepXpos;
1342
   float minYpos, maxYpos, stepYpos;
1384
   float minYpos, maxYpos, stepYpos;
1343
   float minZpos, maxZpos, stepZpos;
1385
   float minZpos, maxZpos, stepZpos;
1344
   int repetX, repetY, repetZ;
1386
   int repetX, repetY, repetZ;
1345
 
1387
 
1346
   // Variables for angle scan
1388
   // Variables for angle scan
1347
   float currentAlpha, minAlpha, maxAlpha, stepAlpha;
1389
   float currentAlpha, minAlpha, maxAlpha, stepAlpha;
1348
   int repetAlpha;
1390
   int repetAlpha;
1349
 
1391
 
1350
   // Only voltage scan
1392
   // Only voltage scan
1351
   if( (vscan == 1) && (pscan == 0) && (ascan == 0) )
1393
   if( (vscan == 1) && (pscan == 0) && (ascan == 0) )
1352
   { // TODO - include possibility to make voltage and angle scan at same time
1394
   { // TODO - include possibility to make voltage and angle scan at same time
1353
      // If already started, stop the acquisition
1395
      // If already started, stop the acquisition
1354
      if(acqStarted)
1396
      if(acqStarted)
1355
      {
1397
      {
1356
         printf("Stopping current voltage scan...\n");
1398
         printf("Stopping current voltage scan...\n");
1357
         gROOT->SetInterrupt();
1399
         gROOT->SetInterrupt();
1358
         measProgress->widgetTB[0]->SetText("Start acquisition");
1400
         measProgress->widgetTB[0]->SetText("Start acquisition");
1359
         acqStarted = false;
1401
         acqStarted = false;
1360
 
1402
 
1361
         // Write information to the finish_sig.txt value
1403
         // Write information to the finish_sig.txt value
1362
         sprintf(cmd, "%s/dbg/finish_sig.txt", rootdir);
1404
         sprintf(cmd, "%s/dbg/finish_sig.txt", rootdir);
1363
         pfin = fopen(cmd,"w");
1405
         pfin = fopen(cmd,"w");
1364
         fprintf(pfin, "%s: Voltage scan stopped.", timeStamp->widgetTE->GetText());
1406
         fprintf(pfin, "%s: Voltage scan stopped.", timeStamp->widgetTE->GetText());
1365
         fclose(pfin);
1407
         fclose(pfin);
1366
      }
1408
      }
1367
      // If stopped, start the acquisition
1409
      // If stopped, start the acquisition
1368
      else if(!acqStarted)
1410
      else if(!acqStarted)
1369
      {
1411
      {
1370
         printf("Running a voltage scan...\n");
1412
         printf("Running a voltage scan...\n");
1371
 
1413
 
1372
         // Check the steps
1414
         // Check the steps
1373
         minVoltage = vOutStart->widgetNE[0]->GetNumber();
1415
         minVoltage = vOutStart->widgetNE[0]->GetNumber();
1374
         maxVoltage = vOutStop->widgetNE[0]->GetNumber();
1416
         maxVoltage = vOutStop->widgetNE[0]->GetNumber();
1375
         stepVoltage = vOutStep->widgetNE[0]->GetNumber();
1417
         stepVoltage = vOutStep->widgetNE[0]->GetNumber();
1376
 
1418
 
1377
         if(stepVoltage == 0.)
1419
         if(stepVoltage == 0.)
1378
            repetition = 1;
1420
            repetition = 1;
1379
         else
1421
         else
1380
         {
1422
         {
1381
            // Example: min = 40, max = 70, step = 5 (in increasing steps)
1423
            // Example: min = 40, max = 70, step = 5 (in increasing steps)
1382
            if( (maxVoltage > minVoltage) && (stepVoltage > 0) )
1424
            if( (maxVoltage > minVoltage) && (stepVoltage > 0) )
1383
               repetition = ((maxVoltage - minVoltage)/stepVoltage)+1;
1425
               repetition = ((maxVoltage - minVoltage)/stepVoltage)+1;
1384
            // Example: min = 70, max = 40, step = -5 (in decreasing steps)
1426
            // Example: min = 70, max = 40, step = -5 (in decreasing steps)
1385
            else if( (maxVoltage < minVoltage) && (stepVoltage < 0) )
1427
            else if( (maxVoltage < minVoltage) && (stepVoltage < 0) )
1386
               repetition = ((minVoltage - maxVoltage)/stepVoltage)-1;
1428
               repetition = ((minVoltage - maxVoltage)/stepVoltage)-1;
1387
            // Example: min = 70, max = 70 (no scan)
1429
            // Example: min = 70, max = 70 (no scan)
1388
            else if( maxVoltage == minVoltage )
1430
            else if( maxVoltage == minVoltage )
1389
               repetition = 1;
1431
               repetition = 1;
1390
            // If step is not correctly set, stop the acqusition
1432
            // If step is not correctly set, stop the acqusition
1391
            else
1433
            else
1392
            {
1434
            {
1393
               // TODO
1435
               // TODO
1394
               printf("Stopping current voltage scan...\n");
1436
               printf("Stopping current voltage scan...\n");
1395
               gROOT->SetInterrupt();
1437
               gROOT->SetInterrupt();
1396
               measProgress->widgetTB[0]->SetText("Start acquisition");
1438
               measProgress->widgetTB[0]->SetText("Start acquisition");
1397
               acqStarted = false;
1439
               acqStarted = false;
1398
               repetition = 0;
1440
               repetition = 0;
1399
            }
1441
            }
1400
         }
1442
         }
1401
 
1443
 
1402
         if(DBGSIG) printf("StartAcq(): Voltage repetition (%lf,%lf,%lf) = %d\n", minVoltage, maxVoltage, stepVoltage, repetition);
1444
         if(DBGSIG) printf("StartAcq(): Voltage repetition (%lf,%lf,%lf) = %d\n", minVoltage, maxVoltage, stepVoltage, repetition);
1403
 
1445
 
1404
         i = 0;
1446
         i = 0;
1405
 
1447
 
1406
         // TODO - Setting button text and acqStarted do not work!
1448
         // TODO - Setting button text and acqStarted do not work!
1407
         measProgress->widgetTB[0]->SetText("Stop acquisition");
1449
         measProgress->widgetTB[0]->SetText("Stop acquisition");
1408
         acqStarted = true;
1450
         acqStarted = true;
1409
         progVal = 0.00;
1451
         progVal = 0.00;
1410
         measProgress->widgetPB->SetPosition(progVal);
1452
         measProgress->widgetPB->SetPosition(progVal);
1411
         gVirtualX->Update(1);
1453
         gVirtualX->Update(1);
1412
 
1454
 
1413
         clkt0 = clock();
1455
         clkt0 = clock();
1414
         timet0 = time(NULL);
1456
         timet0 = time(NULL);
1415
 
1457
 
1416
         while(1)
1458
         while(1)
1417
         {
1459
         {
1418
            if( (repetition > 0) && (i == repetition) ) break;
1460
            if( (repetition > 0) && (i == repetition) ) break;
1419
            else if( (repetition < 0) && (i == -repetition) ) break;
1461
            else if( (repetition < 0) && (i == -repetition) ) break;
1420
            else if( repetition == 0 ) break;
1462
            else if( repetition == 0 ) break;
1421
 
1463
 
1422
            progVal = (float)(100.00/abs(repetition))*i;
1464
            progVal = (float)(100.00/abs(repetition))*i;
1423
            measProgress->widgetPB->SetPosition(progVal);
1465
            measProgress->widgetPB->SetPosition(progVal);
1424
 
1466
 
1425
            TimeEstimate(clkt0, timet0, progVal, cmd, singlewait*abs(repetition));
1467
            TimeEstimate(clkt0, timet0, progVal, cmd, singlewait*abs(repetition));
1426
            measProgress->widgetTE->SetText(cmd);
1468
            measProgress->widgetTE->SetText(cmd);
1427
 
1469
 
1428
            gVirtualX->Update(1);
1470
            gVirtualX->Update(1);
1429
       
1471
       
1430
            fflush(stdout);
1472
            fflush(stdout);
1431
            currentVoltage = minVoltage + stepVoltage*i;
1473
            currentVoltage = minVoltage + stepVoltage*i;
1432
            sprintf(cmd, "%s/src/mpod/mpod_voltage.sh -o %d -v %f -s 1", rootdir, GetChannel(), currentVoltage);
1474
            sprintf(cmd, "%s/src/mpod/mpod_voltage.sh -o %d -v %f -s 1", rootdir, GetChannel(), currentVoltage);
1433
#if WORKSTAT == 'I'
1475
#if WORKSTAT == 'I'
1434
            retTemp = system(cmd);
1476
            retTemp = system(cmd);
1435
#else
1477
#else
1436
            printf("Cmd: %s\n",cmd);
1478
            printf("Cmd: %s\n",cmd);
1437
#endif
1479
#endif
1438
            fflush(stdout);
1480
            fflush(stdout);
1439
       
1481
       
1440
            printf("Waiting for voltage change...\n");
1482
            printf("Waiting for voltage change...\n");
1441
            sleep(singlewait);
1483
            sleep(singlewait);
1442
            vOut->widgetNE[0]->SetNumber(currentVoltage);
1484
            vOut->widgetNE[0]->SetNumber(currentVoltage);
1443
            gVirtualX->Update(1);
1485
            gVirtualX->Update(1);
1444
            printf("Continuing...\n");
1486
            printf("Continuing...\n");
1445
       
1487
       
1446
            // Here comes function to start histogramming <<<<<<<<<<<<<<<<<<<<<<<<
1488
            // Here comes function to start histogramming <<<<<<<<<<<<<<<<<<<<<<<<
1447
            RunMeas((void*)0, i, scanon); // TODO
1489
            RunMeas((void*)0, i, scanon); // TODO
1448
            fflush(stdout);
1490
            fflush(stdout);
1449
 
1491
 
1450
            i++;
1492
            i++;
1451
         }
1493
         }
1452
 
1494
 
1453
         // Set output back to off
1495
         // Set output back to off
1454
         fflush(stdout);
1496
         fflush(stdout);
1455
         printf("Measurement finished, returning to starting voltage...\n");
1497
         printf("Measurement finished, returning to starting voltage...\n");
1456
         sprintf(cmd, "%s/src/mpod/mpod_voltage.sh -o %d -v %f -s 1", rootdir, GetChannel(), minVoltage);
1498
         sprintf(cmd, "%s/src/mpod/mpod_voltage.sh -o %d -v %f -s 1", rootdir, GetChannel(), minVoltage);
1457
         vOut->widgetNE[0]->SetNumber(minVoltage);
1499
         vOut->widgetNE[0]->SetNumber(minVoltage);
1458
#if WORKSTAT == 'I'
1500
#if WORKSTAT == 'I'
1459
         retTemp = system(cmd);
1501
         retTemp = system(cmd);
1460
#else
1502
#else
1461
         printf("Cmd: %s\n",cmd);
1503
         printf("Cmd: %s\n",cmd);
1462
#endif
1504
#endif
1463
         fflush(stdout);
1505
         fflush(stdout);
1464
       
1506
       
1465
         progVal = 100.00;
1507
         progVal = 100.00;
1466
         measProgress->widgetPB->SetPosition(progVal);
1508
         measProgress->widgetPB->SetPosition(progVal);
1467
         printf("\n");
1509
         printf("\n");
1468
 
1510
 
1469
         sprintf(cmd, "%s/dbg/finish_sig.txt", rootdir);
1511
         sprintf(cmd, "%s/dbg/finish_sig.txt", rootdir);
1470
         pfin = fopen(cmd,"w");
1512
         pfin = fopen(cmd,"w");
1471
         fprintf(pfin, "%s: Voltage scan finished.", timeStamp->widgetTE->GetText());
1513
         fprintf(pfin, "%s: Voltage scan finished.", timeStamp->widgetTE->GetText());
1472
         fclose(pfin);
1514
         fclose(pfin);
1473
 
1515
 
1474
         measProgress->widgetTB[0]->SetText("Start acquisition");
1516
         measProgress->widgetTB[0]->SetText("Start acquisition");
1475
         acqStarted = false;
1517
         acqStarted = false;
1476
      }
1518
      }
1477
   }
1519
   }
1478
   // Surface scan
1520
   // Surface scan
1479
   else if( (pscan == 1) && (vscan == 0) && (ascan == 0) )
1521
   else if( (pscan == 1) && (vscan == 0) && (ascan == 0) )
1480
   {
1522
   {
1481
      // If already started, stop the acquisition
1523
      // If already started, stop the acquisition
1482
      if(acqStarted)
1524
      if(acqStarted)
1483
      {
1525
      {
1484
         printf("Stopping current surface scan...\n");
1526
         printf("Stopping current surface scan...\n");
1485
         gROOT->SetInterrupt();
1527
         gROOT->SetInterrupt();
1486
         measProgress->widgetTB[0]->SetText("Start acquisition");
1528
         measProgress->widgetTB[0]->SetText("Start acquisition");
1487
         acqStarted = false;
1529
         acqStarted = false;
1488
 
1530
 
1489
         // Write information to the finish_sig.txt value
1531
         // Write information to the finish_sig.txt value
1490
         sprintf(cmd, "%s/dbg/finish_sig.txt", rootdir);
1532
         sprintf(cmd, "%s/dbg/finish_sig.txt", rootdir);
1491
         pfin = fopen(cmd,"w");
1533
         pfin = fopen(cmd,"w");
1492
         fprintf(pfin, "%s: Surface scan stopped.", timeStamp->widgetTE->GetText());
1534
         fprintf(pfin, "%s: Surface scan stopped.", timeStamp->widgetTE->GetText());
1493
         fclose(pfin);
1535
         fclose(pfin);
1494
      }
1536
      }
1495
      // If stopped, start the acquisition
1537
      // If stopped, start the acquisition
1496
      else if(!acqStarted)
1538
      else if(!acqStarted)
1497
      {
1539
      {
1498
         printf("Running a surface scan...\n");
1540
         printf("Running a surface scan...\n");
1499
 
1541
 
1500
         minXpos = xPosMin->widgetNE[0]->GetNumber();
1542
         minXpos = xPosMin->widgetNE[0]->GetNumber();
1501
         maxXpos = xPosMax->widgetNE[0]->GetNumber();
1543
         maxXpos = xPosMax->widgetNE[0]->GetNumber();
1502
         stepXpos = xPosStep->widgetNE[0]->GetNumber();
1544
         stepXpos = xPosStep->widgetNE[0]->GetNumber();
1503
         minYpos = yPosMin->widgetNE[0]->GetNumber();
1545
         minYpos = yPosMin->widgetNE[0]->GetNumber();
1504
         maxYpos = yPosMax->widgetNE[0]->GetNumber();
1546
         maxYpos = yPosMax->widgetNE[0]->GetNumber();
1505
         stepYpos = yPosStep->widgetNE[0]->GetNumber();
1547
         stepYpos = yPosStep->widgetNE[0]->GetNumber();
1506
         minZpos = zPosMin->widgetNE[0]->GetNumber();
1548
         minZpos = zPosMin->widgetNE[0]->GetNumber();
1507
         maxZpos = zPosMax->widgetNE[0]->GetNumber();
1549
         maxZpos = zPosMax->widgetNE[0]->GetNumber();
1508
         stepZpos = zPosStep->widgetNE[0]->GetNumber();
1550
         stepZpos = zPosStep->widgetNE[0]->GetNumber();
1509
 
1551
 
1510
         // Setting repetition for Z axis scan
1552
         // Setting repetition for Z axis scan
1511
         if(zscan == 1)
1553
         if(zscan == 1)
1512
         {
1554
         {
1513
            if(stepZpos == 0.)
1555
            if(stepZpos == 0.)
1514
               repetZ = 1;
1556
               repetZ = 1;
1515
            else
1557
            else
1516
            {
1558
            {
1517
               // Example: min = 40, max = 70, step = 5 (in increasing steps)
1559
               // Example: min = 40, max = 70, step = 5 (in increasing steps)
1518
               if( (maxZpos > minZpos) && (stepZpos > 0) )
1560
               if( (maxZpos > minZpos) && (stepZpos > 0) )
1519
                  repetZ = ((maxZpos - minZpos)/stepZpos)+1;
1561
                  repetZ = ((maxZpos - minZpos)/stepZpos)+1;
1520
               // Example: min = 70, max = 40, step = -5 (in decreasing steps)
1562
               // Example: min = 70, max = 40, step = -5 (in decreasing steps)
1521
               else if( (maxZpos < minZpos) && (stepZpos < 0) )
1563