1 | /********************************************************************\
|
---|
2 |
|
---|
3 | DAQReadout.cc
|
---|
4 |
|
---|
5 | Main DAQ routines.
|
---|
6 |
|
---|
7 | Sebastian Commichau, Oliver Grimm
|
---|
8 |
|
---|
9 | \********************************************************************/
|
---|
10 |
|
---|
11 | #include "DAQReadout.h"
|
---|
12 | #include "SlowData.h"
|
---|
13 |
|
---|
14 | #define TMPNAME "/tmp/__tmp__drsdaq__"
|
---|
15 |
|
---|
16 | static const char* daq_state_str[] = {"active", "stopped"};
|
---|
17 | static const char* daq_runtype_str[] = {"data", "pedestal", "test"};
|
---|
18 |
|
---|
19 | static const struct CL_Struct { const char *Name;
|
---|
20 | void (DAQReadout::*CommandPointer)();
|
---|
21 | bool NeedNotBusy;
|
---|
22 | const char *Parameters;
|
---|
23 | const char *Help;
|
---|
24 | } CommandList[] =
|
---|
25 | {{"board", &DAQReadout::cmd_board, true, "<i> [j] | <all>" ,"Address board i, boards i-j, all boards"},
|
---|
26 | {"status", &DAQReadout::cmd_status, false, "[daq|drs]", "Show DAQ/DRS status information"},
|
---|
27 | {"freq", &DAQReadout::cmd_freq, true, "<GHz> [reg]", "Set DRS sampling frequency (regulated)"},
|
---|
28 | {"calib", &DAQReadout::cmd_calib, true, "<t_f> <c_f> [dir]", "Response calibration"},
|
---|
29 | {"trigger", &DAQReadout::cmd_trigger, true, "<on|off>", "Hardware trigger on or off"},
|
---|
30 | {"delayed", &DAQReadout::cmd_delayed, true, "<on|off>", "Switch delayed start on or off"},
|
---|
31 | {"wmode", &DAQReadout::cmd_wmode, true, "<0|1>", "Set DRS wave mode"},
|
---|
32 | {"rmode", &DAQReadout::cmd_rmode, true, "<0|1>", "Set DRS readout mode"},
|
---|
33 | {"mode", &DAQReadout::cmd_mode, true, "<single|continuous>", "Set DRS single shot or continuous mode"},
|
---|
34 | {"read", &DAQReadout::cmd_read, false, "<brd chip chan> [res]", "Read current data (and restart if DAQ not active)"},
|
---|
35 | {"take", &DAQReadout::cmd_take, false, "<d|p|t> [n] [source]", "Start run (data, pedestal or test) with n events"},
|
---|
36 | {"events", &DAQReadout::cmd_events, false, "", "Number of events in current run"},
|
---|
37 | {"start", &DAQReadout::cmd_start, true, "", "Start domino wave"},
|
---|
38 | {"stop", &DAQReadout::cmd_stop, false, "", "Issue soft trigger and stop DAQ"},
|
---|
39 | {"test", &DAQReadout::cmd_test, true, "[2e]<blt32|blt64> [n]", "Test read access of VMEbus (n blocks)"},
|
---|
40 | {"regtest", &DAQReadout::cmd_regtest, true, "", "DRS register test"},
|
---|
41 | {"ramtest", &DAQReadout::cmd_ramtest, true, "", "DRS RAM integrity and speed test"},
|
---|
42 | {"led", &DAQReadout::cmd_led, true, "<on|off>", "Turn LED on or off"},
|
---|
43 | {"config", &DAQReadout::cmd_config, false, "", "Print drsdaq configuration"},
|
---|
44 | {"serial", &DAQReadout::cmd_serial, true, "<i> <n>", "Set serial# of board <i> to <n> (experts only)"},
|
---|
45 | {"disk", &DAQReadout::cmd_disk, false, "" ,"Remaining disk space"},
|
---|
46 | {"uptime", &DAQReadout::cmd_uptime, false, "", "Get DAQ uptime"},
|
---|
47 | {"exit", &DAQReadout::cmd_exit, false, "", "Exit program"},
|
---|
48 | {"fmode", &DAQReadout::cmd_fmode, false, "[off|active|targ]", "Set or get feedback mode"},
|
---|
49 | {"faverage", &DAQReadout::cmd_faverage, false, "[n]", "Set ot get number of averages for feedback"},
|
---|
50 | {"fgain", &DAQReadout::cmd_fgain, false, "[gain]", "Set ot get feedback gain"},
|
---|
51 | {"ftarget", &DAQReadout::cmd_ftarget, false, "[brd chip chan]", "Set or get target value (also 'all' supported)"},
|
---|
52 | {"fresponse", &DAQReadout::cmd_fresponse, false, "[voltage]", "Start response measurement with given voltage difference"},
|
---|
53 | {"fconfig", &DAQReadout::cmd_fconfig, false, "", "Print feedback configuration"},
|
---|
54 | {"help", &DAQReadout::cmd_help, false, "", "Print help"}};
|
---|
55 |
|
---|
56 |
|
---|
57 | // -----------------------------------------------
|
---|
58 | // ***** Constructor: Class initialisation *****
|
---|
59 | // -----------------------------------------------
|
---|
60 | //
|
---|
61 |
|
---|
62 | DAQReadout::DAQReadout(const char *Configfile) {
|
---|
63 |
|
---|
64 | time(&StartTime); // Start time of DAQ
|
---|
65 |
|
---|
66 | // Initialize status structure
|
---|
67 | daq_state = stopped;
|
---|
68 | daq_runtype = data;
|
---|
69 | Socket = -1;
|
---|
70 | Exit = false;
|
---|
71 | CalibrationRead = false;
|
---|
72 | NumEvents = 0;
|
---|
73 | NumEventsRequested = 100;
|
---|
74 | NumBoards = 0;
|
---|
75 | FirstBoard = 0;
|
---|
76 | LastBoard = -1;
|
---|
77 | CmdFromSocket = false;
|
---|
78 |
|
---|
79 | // Read configuration file
|
---|
80 | FILE *File;
|
---|
81 | if ((File = fopen(Configfile,"r")) == NULL) {
|
---|
82 | printf("Error: Could not open drsdaq configuration file '%s'\n", Configfile);
|
---|
83 | }
|
---|
84 | else {
|
---|
85 | printf("Reading drsdaq configuration file %s\n", Configfile);
|
---|
86 | ReadCard("LogFile", fLogFile, 's', File);
|
---|
87 | ReadCard("MaxLogLines", &fMaxLogLines, 'U', File);
|
---|
88 | ReadCard("RawDataPath", fRawDataPath, 's', File);
|
---|
89 | ReadCard("FirstSample", &fFirstSample, 'I', File);
|
---|
90 | ReadCard("Samples", &fSamples, 'U', File);
|
---|
91 | ReadCard("MinDiskSpaceMB", &fMinDiskSpaceMB, 'U', File);
|
---|
92 | ReadCard("MaxFileSizeMB", &fMaxFileSizeMB, 'I', File);
|
---|
93 | ReadCard("CCPort", &fCCPort, 'I', File);
|
---|
94 | ReadCard("FirstVMESlot", &fFirstVMESlot, 'I', File);
|
---|
95 | ReadCard("LastVMESlot", &fLastVMESlot, 'I', File);
|
---|
96 | ReadCard("HVFeedbackConfig", fHVFeedbackConfig, 's', File);
|
---|
97 | fclose(File);
|
---|
98 | }
|
---|
99 | if (fFirstSample < 0 || fFirstSample > kNumberOfBins || fSamples > kNumberOfBins) {
|
---|
100 | PrintMessage("Warning: Sample range in configuration beyond limits, setting to full range\n");
|
---|
101 | fFirstSample = kNumberOfBins;
|
---|
102 | fSamples = kNumberOfBins;
|
---|
103 | }
|
---|
104 |
|
---|
105 | // Truncate log file to given number of lines
|
---|
106 | char ShellCmd[MAX_COM_SIZE];
|
---|
107 | snprintf(ShellCmd, sizeof(ShellCmd), "tail --lines=%u %s >%s; cp %s %s; rm %s", fMaxLogLines, fLogFile, TMPNAME, TMPNAME, fLogFile, TMPNAME);
|
---|
108 | if (system(ShellCmd) != 0) printf("Warning: Could not truncate log file '%s' to %u lines\n", fLogFile, fMaxLogLines);
|
---|
109 |
|
---|
110 | // Open log file
|
---|
111 | if ((Logfile = fopen(fLogFile, "a")) == NULL) printf("Warning: Could not open log file '%s'\n", fLogFile);
|
---|
112 | PrintMessage(MsgToLog,"********** Logging started **********\n");
|
---|
113 |
|
---|
114 | // Print configuration
|
---|
115 | cmd_config();
|
---|
116 |
|
---|
117 | // Create DRS instance and perform initial scan
|
---|
118 | drs = new DRS();
|
---|
119 | drs->SetFirstVMESlot(fFirstVMESlot);
|
---|
120 | drs->SetLastVMESlot(fLastVMESlot);
|
---|
121 | drs->InitialScan();
|
---|
122 |
|
---|
123 | RHeader = new RunHeader;
|
---|
124 | EHeader = new EventHeader;
|
---|
125 | DRSFreq = new float [drs->GetNumberOfBoards()];
|
---|
126 |
|
---|
127 | // Scan for DRS boards
|
---|
128 | if (drs->GetNumberOfBoards()==0) PrintMessage("No DRS boards found - check VME crate and configuration file!\n");
|
---|
129 |
|
---|
130 | for (int i=0; i<drs->GetNumberOfBoards(); i++) {
|
---|
131 | PrintMessage("Init. mezz. board %2d on VME slot %2d %s, serial #%d, firmware revision %d\n",
|
---|
132 | i, (drs->GetBoard(i)->GetSlotNumber() >> 1)+2, ((drs->GetBoard(i)->GetSlotNumber() & 1) == 0) ? "upper" : "lower",
|
---|
133 | drs->GetBoard(i)->GetCMCSerialNumber(), drs->GetBoard(i)->GetFirmwareVersion());
|
---|
134 | NumBoards++;
|
---|
135 | LastBoard++;
|
---|
136 | drs->GetBoard(i)->Init();
|
---|
137 | drs->GetBoard(i)->SetRotation(false);
|
---|
138 | DRSFreq[i] = 0;
|
---|
139 | }
|
---|
140 | BStruct = new BoardStructure [NumBoards == 0 ? 1:drs->GetNumberOfBoards()];
|
---|
141 | WaveForm = new short [NumBoards == 0 ? 1:NumBoards][kNumberOfChips][kNumberOfChannels][kNumberOfBins];
|
---|
142 | TriggerCell = new int [NumBoards == 0 ? 1:NumBoards][kNumberOfChips] (); // Zero initialised
|
---|
143 |
|
---|
144 | // Create instance of HV feedback (must be called after CMC board detection)
|
---|
145 | HVFB = new HVFeedback(this, fHVFeedbackConfig);
|
---|
146 |
|
---|
147 | // Create instance of slow data class for DAQ
|
---|
148 | char Filename[MAX_PATH];
|
---|
149 | snprintf(Filename,sizeof(Filename),"%s/SlowData/", fRawDataPath);
|
---|
150 | SlowDataClass = new SlowData(this, "DAQ", Filename);
|
---|
151 | }
|
---|
152 |
|
---|
153 | // ------------------------
|
---|
154 | // ***** Destructor *****
|
---|
155 | // ------------------------
|
---|
156 |
|
---|
157 | DAQReadout::~DAQReadout() {
|
---|
158 | delete SlowDataClass;
|
---|
159 | delete RHeader; delete EHeader;
|
---|
160 | delete drs; delete HVFB;
|
---|
161 | delete[] DRSFreq; delete[] BStruct;
|
---|
162 | delete[] WaveForm; delete[] TriggerCell;
|
---|
163 |
|
---|
164 | PrintMessage(MsgToLog,"********** Logging ended **********\n\n");
|
---|
165 | if(Logfile) {
|
---|
166 | if(!fclose(Logfile)) printf("Closing logfile\n");
|
---|
167 | else perror("Error closing logfile");
|
---|
168 | }
|
---|
169 | }
|
---|
170 |
|
---|
171 | // --------------------------------
|
---|
172 | // ***** Command evaluation *****
|
---|
173 | // --------------------------------
|
---|
174 |
|
---|
175 | void DAQReadout::CommandControl(char *Command) {
|
---|
176 |
|
---|
177 | if (strlen(Command)==0) return; // Ignore empty commands
|
---|
178 |
|
---|
179 | if(Command[0]=='.') { // Shell command
|
---|
180 | system(&(Command[1]));
|
---|
181 | return;
|
---|
182 | }
|
---|
183 |
|
---|
184 | for(int i=0; i<MAX_NUM_TOKEN; i++) Param[i] = ""; // All pointers point initially to empty string
|
---|
185 | NParam = ParseInput(Command, Param);
|
---|
186 |
|
---|
187 | for(CmdNumber=0; CmdNumber<sizeof(CommandList)/sizeof(CL_Struct); CmdNumber++)
|
---|
188 | if (Match(Param[0], CommandList[CmdNumber].Name)) {
|
---|
189 | if(CommandList[CmdNumber].NeedNotBusy && daq_state==active) PrintMessage("DAQ is busy\n");
|
---|
190 | else if(CommandList[CmdNumber].NeedNotBusy && NumBoards==0) PrintMessage("No mezzanine boards available\n");
|
---|
191 | else (this->*CommandList[CmdNumber].CommandPointer)();
|
---|
192 | return;
|
---|
193 | }
|
---|
194 | PrintMessage("Unknown command '%s'\n",Param[0]);
|
---|
195 | return;
|
---|
196 | }
|
---|
197 |
|
---|
198 | // Get uptime
|
---|
199 | void DAQReadout::cmd_uptime() {
|
---|
200 | time_t ActualT;
|
---|
201 | time (&ActualT);
|
---|
202 | PrintMessage("%d:%02d:%02d\n", (int) difftime(ActualT, StartTime)/3600, ((int) difftime(ActualT, StartTime)/60)%60, (int) difftime(ActualT, StartTime)%60);
|
---|
203 | }
|
---|
204 |
|
---|
205 | // Print disk space
|
---|
206 | void DAQReadout::cmd_disk() {
|
---|
207 | PrintMessage("Free disk space (%s) [MB]: %lu\n", fRawDataPath, CheckDisk(fRawDataPath));
|
---|
208 | }
|
---|
209 |
|
---|
210 | // Print current number of events
|
---|
211 | void DAQReadout::cmd_events() {
|
---|
212 | if(daq_state != active) PrintMessage("DAQ not active.\n");
|
---|
213 | else PrintMessage("Current number of events: %d (of %d requested)\n", NumEvents, NumEventsRequested);
|
---|
214 | }
|
---|
215 |
|
---|
216 | // Print DAQ configuration
|
---|
217 | void DAQReadout::cmd_config() {
|
---|
218 | PrintMessage("LogFile: %s\tMaxLogLines: %u\tRawDataPath: %s\n"
|
---|
219 | "FirstSample: %d\tSamples: %u\n"
|
---|
220 | "MinDiskSpaceMB: %u\tMaxFileSizeMB: %d\tCCPort: %d\n"
|
---|
221 | "FirstVMESlot: %d\t\tLastVMESlot: %d\n"
|
---|
222 | "HVFeedbackConfig: %s\n",
|
---|
223 | fLogFile,fMaxLogLines,fRawDataPath,fFirstSample,fSamples,fMinDiskSpaceMB,
|
---|
224 | fMaxFileSizeMB,fCCPort,fFirstVMESlot,fLastVMESlot,fHVFeedbackConfig);
|
---|
225 | }
|
---|
226 |
|
---|
227 | // Start DAQ
|
---|
228 | void DAQReadout::cmd_take() {
|
---|
229 |
|
---|
230 | if(!Match(Param[1],"test")) {
|
---|
231 | if (daq_state==active || NumBoards==0) {
|
---|
232 | PrintMessage("DAQ is busy or no boards available.\n");
|
---|
233 | return;
|
---|
234 | }
|
---|
235 | if (!IsDRSFreqSet()) return;
|
---|
236 | if (!CalibrationRead && !ReadCalibration()) {
|
---|
237 | PrintMessage("Cannot start run if response calibration not read.\n");
|
---|
238 | return;
|
---|
239 | }
|
---|
240 | }
|
---|
241 |
|
---|
242 | if (Match(Param[1],"data")) {
|
---|
243 | HWTrigger(1);
|
---|
244 | daq_runtype = data;
|
---|
245 | }
|
---|
246 | else if (Match(Param[1],"pedestal")) {
|
---|
247 | HWTrigger(0);
|
---|
248 | daq_runtype = pedestal;
|
---|
249 | }
|
---|
250 | else if (Match(Param[1],"test")) {
|
---|
251 | daq_runtype = test;
|
---|
252 | }
|
---|
253 | else {
|
---|
254 | PrintUsage();
|
---|
255 | return;
|
---|
256 | }
|
---|
257 |
|
---|
258 | if (NParam==3) NumEventsRequested = atoi(Param[2]);
|
---|
259 | if (NParam==4) {
|
---|
260 | NumEventsRequested = atoi(Param[2]);
|
---|
261 | strncpy(RHeader->Description, Param[3], sizeof(RHeader->Description));
|
---|
262 | }
|
---|
263 | else snprintf(RHeader->Description,sizeof(RHeader->Description),"DUMMY");
|
---|
264 |
|
---|
265 | // Determine new run number using the file RUN_NUM_FILE
|
---|
266 | FILE *RunNumFile = fopen(RUN_NUM_FILE,"r+");
|
---|
267 | if(RunNumFile == NULL) {
|
---|
268 | PrintMessage("Error: Could not open file '%s' that contains the last run number (%s)\n",RUN_NUM_FILE,strerror(errno));
|
---|
269 | return;
|
---|
270 | }
|
---|
271 | if(fscanf(RunNumFile,"%u", &RunNumber) != 1 ) {
|
---|
272 | PrintMessage("Error: Could not read run number from file '%s'\n",RUN_NUM_FILE);
|
---|
273 | fclose(RunNumFile);
|
---|
274 | return;
|
---|
275 | }
|
---|
276 | RunNumber++;
|
---|
277 | rewind(RunNumFile);
|
---|
278 | if((fprintf(RunNumFile,"%.8u ",RunNumber) < 0) || (fclose(RunNumFile)!=0)) {
|
---|
279 | PrintMessage("Error: Could not write to or close run number file '%s'\n",RUN_NUM_FILE);
|
---|
280 | PrintMessage("*** This is a serious error because run numbers will get mixed. Fix it. DAQ will terminate.\n");
|
---|
281 | throw;
|
---|
282 | }
|
---|
283 |
|
---|
284 | // Create DAQ thread
|
---|
285 | if ((pthread_create(&thread_DAQ, NULL, (void * (*)(void *)) DAQ,(void *) this)) != 0)
|
---|
286 | PrintMessage("pthread_create failed with DAQ thread (%s)\n",strerror(errno));
|
---|
287 | else {
|
---|
288 | daq_state = active;
|
---|
289 | Stop = false;
|
---|
290 | pthread_detach(thread_DAQ);
|
---|
291 | }
|
---|
292 | }
|
---|
293 |
|
---|
294 | // Start DRS
|
---|
295 | void DAQReadout::cmd_start() {
|
---|
296 | if (IsDRSFreqSet()) {
|
---|
297 | StartDRS();
|
---|
298 | PrintMessage("Domino wave started\n");
|
---|
299 | }
|
---|
300 | }
|
---|
301 |
|
---|
302 | // RAM test
|
---|
303 | void DAQReadout::cmd_ramtest() {
|
---|
304 | for (int i=FirstBoard; i<=LastBoard; i++) {
|
---|
305 | PrintMessage("RAM integrity and speed test (board #%d):\n",i);
|
---|
306 | (drs->GetBoard(i))->RAMTest(3);
|
---|
307 | }
|
---|
308 | }
|
---|
309 |
|
---|
310 | // Register test
|
---|
311 | void DAQReadout::cmd_regtest() {
|
---|
312 | for (int i=FirstBoard; i<=LastBoard; i++) {
|
---|
313 | PrintMessage("Register test (board #%d):\n",i);
|
---|
314 | (drs->GetBoard(i))->RegisterTest();
|
---|
315 | }
|
---|
316 | }
|
---|
317 |
|
---|
318 | // Test VME transfer
|
---|
319 | void DAQReadout::cmd_test() {
|
---|
320 | int Type=-1, i;
|
---|
321 |
|
---|
322 | if (Match(Param[1], "2eblt64")) Type = 2;
|
---|
323 | else if (Match(Param[1], "blt32")) Type = 0;
|
---|
324 | else if (Match(Param[1], "blt64")) Type = 1;
|
---|
325 | else {
|
---|
326 | PrintMessage("Unknown type for testing.\n");
|
---|
327 | return;
|
---|
328 | }
|
---|
329 |
|
---|
330 | if (NumBoards) for (i=FirstBoard; i<=LastBoard; i++) {
|
---|
331 | PrintMessage("BLT test started (board #%d)\n",i);
|
---|
332 | (drs->GetBoard(i))->TestRead(Param[2][0] && atoi(Param[2])<=10000 && atoi(Param[2])>0 ? atoi(Param[2]):1, Type);
|
---|
333 | }
|
---|
334 | else PrintMessage("No DRS boards available\n");
|
---|
335 | }
|
---|
336 |
|
---|
337 | // Stop DAQ
|
---|
338 | void DAQReadout::cmd_stop() {
|
---|
339 | if(!daq_state==active && !IsDRSBusy()) PrintMessage("Nothing to stop\n");
|
---|
340 | if (daq_state==active) StopRun();
|
---|
341 | if (IsDRSBusy()) {
|
---|
342 | StopDRS();
|
---|
343 | PrintMessage("Domino wave stopped\n");
|
---|
344 | }
|
---|
345 | }
|
---|
346 |
|
---|
347 | // Read current data
|
---|
348 | // For socket transmission: all numbers must be separated by exactly one
|
---|
349 | // whitespace; the first number is the number of numbers that follow, the
|
---|
350 | // second number the sampling frequency in GHz, the third the conversion factor
|
---|
351 |
|
---|
352 | void DAQReadout::cmd_read() {
|
---|
353 | if(NumBoards==0) {
|
---|
354 | PrintMessage("No mezzanine boards available\n");
|
---|
355 | return;
|
---|
356 | }
|
---|
357 | if (NParam<4) {
|
---|
358 | PrintUsage();
|
---|
359 | return;
|
---|
360 | }
|
---|
361 | if (atoi(Param[1])>LastBoard || atoi(Param[1])<FirstBoard) {
|
---|
362 | PrintMessage("Error: Board number out of range\n");
|
---|
363 | return;
|
---|
364 | }
|
---|
365 | if (atoi(Param[3])<0 || atoi(Param[3])>=kNumberOfChannels) {
|
---|
366 | PrintMessage("Error: Channel number out of range\n");
|
---|
367 | return;
|
---|
368 | }
|
---|
369 | if (atoi(Param[2])<0 || atoi(Param[2])>=kNumberOfChips) {
|
---|
370 | PrintMessage("Error: Chip number out of range\n");
|
---|
371 | return;
|
---|
372 | }
|
---|
373 |
|
---|
374 | if(daq_state!=active) {
|
---|
375 | if (!CalibrationRead) ReadCalibration();
|
---|
376 | if(NParam==5) StopDRS();
|
---|
377 | ReadCalibratedDRSData();
|
---|
378 | if(NParam==5) StartDRS();
|
---|
379 | }
|
---|
380 | PrintMessage(CmdFromSocket ? MsgToSocket:MsgToConsole|MsgToLog, "==START== %d %.2f %.2f ",kNumberOfBins+2,DRSFreq[atoi(Param[1])],drs->GetBoard(atoi(Param[1]))->GetPrecision());
|
---|
381 | for (int k=0; k<kNumberOfBins; k++) PrintMessage(CmdFromSocket ? MsgToSocket:MsgToConsole|MsgToLog, "%.1f ", (float) WaveForm[atoi(Param[1])][atoi(Param[2])][atoi(Param[3])][k]);
|
---|
382 | PrintMessage(CmdFromSocket ? MsgToSocket:MsgToConsole|MsgToLog, "==END==");
|
---|
383 | PrintMessage(CmdFromSocket ? MsgToSocket:MsgToConsole|MsgToLog, "\n");
|
---|
384 | }
|
---|
385 |
|
---|
386 | // Set Domino mode
|
---|
387 | void DAQReadout::cmd_mode() {
|
---|
388 | if (Match(Param[1],"continuous")) SetDOMINOMode(1);
|
---|
389 | else if (Match(Param[1],"single")) SetDOMINOMode(0);
|
---|
390 | else PrintUsage();
|
---|
391 | }
|
---|
392 |
|
---|
393 | // Set Domino readout mode
|
---|
394 | void DAQReadout::cmd_rmode() {
|
---|
395 | if (Match(Param[1],"1")) SetDOMINOReadMode(1);
|
---|
396 | else if (Match(Param[1],"0")) SetDOMINOReadMode(0);
|
---|
397 | else PrintUsage();
|
---|
398 | }
|
---|
399 |
|
---|
400 | // Set Domino wave mode
|
---|
401 | void DAQReadout::cmd_wmode() {
|
---|
402 | if (Match(Param[1],"1")) SetDOMINOWaveMode(1);
|
---|
403 | else if (Match(Param[1],"0")) SetDOMINOWaveMode(0);
|
---|
404 | else PrintUsage();
|
---|
405 | }
|
---|
406 |
|
---|
407 | // Switch delayed start on/off
|
---|
408 | void DAQReadout::cmd_delayed() {
|
---|
409 | if (Match(Param[1],"on")) SetDelayedStart(1);
|
---|
410 | else if (Match(Param[1],"off")) SetDelayedStart(0);
|
---|
411 | else PrintUsage();
|
---|
412 | }
|
---|
413 |
|
---|
414 | // Set trigger mode
|
---|
415 | void DAQReadout::cmd_trigger() {
|
---|
416 | if (Match(Param[1],"on")) HWTrigger(1);
|
---|
417 | else if (Match(Param[1],"off")) HWTrigger(0);
|
---|
418 | else PrintUsage();
|
---|
419 | }
|
---|
420 |
|
---|
421 | // Set serial number of board
|
---|
422 | void DAQReadout::cmd_serial() {
|
---|
423 | if (NParam==4 && Match(Param[3], "expert")) {
|
---|
424 | if ((atoi(Param[1]) < FirstBoard) || (atoi(Param[1]) > LastBoard))
|
---|
425 | PrintMessage("Board number out of range (%d...%d)!\n",FirstBoard,LastBoard);
|
---|
426 | else if (atoi(Param[2]) < 100 || atoi(Param[2]) >= 1000)
|
---|
427 | PrintMessage("Serial number out of range (100...999)!\n");
|
---|
428 | else {
|
---|
429 | PrintMessage("Flashing EEPROM of board %d...\n", atoi(Param[1]));
|
---|
430 | (drs->GetBoard(atoi(Param[1])))->FlashEEPROM(atoi(Param[2]));
|
---|
431 | }
|
---|
432 | }
|
---|
433 | else PrintMessage("You are not allowed to change the serial number!\n");
|
---|
434 | }
|
---|
435 |
|
---|
436 | // Do internal calibration
|
---|
437 | void DAQReadout::cmd_calib() {
|
---|
438 | if (NParam==4 && atof(Param[1]) && atof(Param[2]))
|
---|
439 | CalibrateDRS((char *) Param[3],atof(Param[1]),atof(Param[2]));
|
---|
440 | else if (NParam==3 && atof(Param[1]) && atof(Param[2]))
|
---|
441 | CalibrateDRS(NULL,atof(Param[1]),atof(Param[2]));
|
---|
442 | else PrintUsage();
|
---|
443 | }
|
---|
444 |
|
---|
445 | // Set DRS sampling frequency
|
---|
446 | void DAQReadout::cmd_freq() {
|
---|
447 | if (NParam>=2 && atof(Param[1])) {
|
---|
448 | SetDRSFrequency(atof(Param[1]), NParam==2 ? false : true);
|
---|
449 | CalibrationRead = false;
|
---|
450 | }
|
---|
451 | else PrintUsage();
|
---|
452 | }
|
---|
453 |
|
---|
454 | // Set LED
|
---|
455 | void DAQReadout::cmd_led() {
|
---|
456 | if (Match(Param[1], "on") || Match(Param[1], "off"))
|
---|
457 | for (int i=FirstBoard; i<=LastBoard; i++)
|
---|
458 | (drs->GetBoard(i))->SetLED(Match(Param[1], "on") ? 1 : 0);
|
---|
459 | else PrintUsage();
|
---|
460 | }
|
---|
461 |
|
---|
462 | // Print status
|
---|
463 | void DAQReadout::cmd_status() {
|
---|
464 |
|
---|
465 | double freq;
|
---|
466 |
|
---|
467 | if(NParam==1 || Match(Param[1],"daq")) {
|
---|
468 | PrintMessage("********** DAQ STATUS **********\n"
|
---|
469 | " DAQ: %s\n"
|
---|
470 | " Run number: %d\n"
|
---|
471 | " Run type: %s\n"
|
---|
472 | " Event: %d\n"
|
---|
473 | " Requested events per run: %d\n"
|
---|
474 | " Storage directory: %s\n"
|
---|
475 | " Disk space: %lu MByte\n"
|
---|
476 | " Socket state: %s\n"
|
---|
477 | " Total number of CMC boards: %d\n"
|
---|
478 | " Active CMC boards: %d\n",
|
---|
479 | daq_state_str[daq_state], daq_state==active ? (int) RunNumber:-1,
|
---|
480 | daq_runtype_str[daq_runtype], NumEvents,
|
---|
481 | NumEventsRequested, fRawDataPath,
|
---|
482 | CheckDisk(fRawDataPath), Socket==-1 ? "disconnected":"connected",
|
---|
483 | NumBoards, LastBoard - FirstBoard + 1);
|
---|
484 |
|
---|
485 | for (int i=FirstBoard;i<=LastBoard;i++)
|
---|
486 | PrintMessage(" Frequency of board %d set: %s\n",i,(DRSFreq[i]!=0 ? "yes":"no"));
|
---|
487 | }
|
---|
488 |
|
---|
489 | if(NParam==1 || Match(Param[1],"drs")) {
|
---|
490 | PrintMessage("\n********** DRS STATUS **********\n");
|
---|
491 | if (NumBoards) {
|
---|
492 | for (int i=FirstBoard; i<=LastBoard; i++) {
|
---|
493 |
|
---|
494 | PrintMessage(" Mezz. board index: %d\n"
|
---|
495 | " Slot: %d %s\n",i,((drs->GetBoard(i))->GetSlotNumber() >> 1)+2,((drs->GetBoard(i))->GetSlotNumber() & 1)==0 ? "upper":"lower");
|
---|
496 | PrintMessage(" Chip version: DRS%d\n"
|
---|
497 | " Board version: %d\n"
|
---|
498 | " Serial number: %d\n"
|
---|
499 | " Firmware revision: %d\n"
|
---|
500 | " Temperature: %1.1lf C\n"
|
---|
501 | " Status reg.: 0X%08X\n",
|
---|
502 | (drs->GetBoard(i))->GetChipVersion(),
|
---|
503 | (drs->GetBoard(i))->GetCMCVersion(),
|
---|
504 | (drs->GetBoard(i))->GetCMCSerialNumber(),
|
---|
505 | (drs->GetBoard(i))->GetFirmwareVersion(),
|
---|
506 | (drs->GetBoard(i))->GetTemperature(),
|
---|
507 | (drs->GetBoard(i))->GetStatusReg());
|
---|
508 |
|
---|
509 |
|
---|
510 | if ((drs->GetBoard(i))->GetStatusReg() & BIT_RUNNING)
|
---|
511 | PrintMessage(" Domino wave running\n");
|
---|
512 | if ((drs->GetBoard(i))->GetStatusReg() & BIT_NEW_FREQ1)
|
---|
513 | PrintMessage(" New Freq1 ready\n");
|
---|
514 | if ((drs->GetBoard(i))->GetStatusReg() & BIT_NEW_FREQ2)
|
---|
515 | PrintMessage(" New Freq2 ready\n");
|
---|
516 |
|
---|
517 | PrintMessage(" Control reg.: 0X%08X\n", (drs->GetBoard(i))->GetCtrlReg());
|
---|
518 | if ((drs->GetBoard(i))->GetCtrlReg() & BIT_AUTOSTART)
|
---|
519 | PrintMessage(" AUTOSTART enabled\n");
|
---|
520 | if ((drs->GetBoard(i))->GetCtrlReg() & BIT_DMODE)
|
---|
521 | PrintMessage(" DMODE circular\n");
|
---|
522 | else
|
---|
523 | PrintMessage(" DMODE single shot\n");
|
---|
524 | if ((drs->GetBoard(i))->GetCtrlReg() & BIT_LED)
|
---|
525 | PrintMessage(" LED\n");
|
---|
526 | if ((drs->GetBoard(i))->GetCtrlReg() & BIT_TCAL_EN)
|
---|
527 | PrintMessage(" TCAL enabled\n");
|
---|
528 | if ((drs->GetBoard(i))->GetCtrlReg() & BIT_ZERO_SUPP)
|
---|
529 | PrintMessage(" ZERO_SUPP enabled\n");
|
---|
530 | if ((drs->GetBoard(i))->GetCtrlReg() & BIT_FREQ_AUTO_ADJ)
|
---|
531 | PrintMessage(" FREQ_AUTO_ADJ enabled\n");
|
---|
532 | if ((drs->GetBoard(i))->GetCtrlReg() & BIT_ENABLE_TRIGGER)
|
---|
533 | PrintMessage(" ENABLE_TRIGGER\n");
|
---|
534 | if ((drs->GetBoard(i))->GetCtrlReg() & BIT_LONG_START_PULSE)
|
---|
535 | PrintMessage(" LONG_START_PULSE\n");
|
---|
536 | if ((drs->GetBoard(i))->GetCtrlReg() & BIT_DELAYED_START)
|
---|
537 | PrintMessage(" DELAYED_START\n");
|
---|
538 | if ((drs->GetBoard(i))->GetCtrlReg() & BIT_ACAL_EN)
|
---|
539 | PrintMessage(" ACAL enabled\n");
|
---|
540 | PrintMessage(" Trigger bus: 0X%08X\n", (drs->GetBoard(i))->GetTriggerBus());
|
---|
541 | if ((drs->GetBoard(i))->IsBusy()) {
|
---|
542 | (drs->GetBoard(i))->ReadFrequency(0, &freq);
|
---|
543 | PrintMessage(" Frequency0: %1.4lf GHz\n", freq);
|
---|
544 | (drs->GetBoard(i))->ReadFrequency(1, &freq);
|
---|
545 | PrintMessage(" Frequency1: %1.4lf GHz\n", freq);
|
---|
546 | }
|
---|
547 | else PrintMessage(" Domino wave stopped\n");
|
---|
548 | }
|
---|
549 | }
|
---|
550 | else PrintMessage("No DRS boards available!\n\n");
|
---|
551 | }
|
---|
552 | }
|
---|
553 |
|
---|
554 | // Adress DRS boards
|
---|
555 | void DAQReadout::cmd_board() {
|
---|
556 | if (Match(Param[1],"all")) {
|
---|
557 | FirstBoard = 0;
|
---|
558 | LastBoard = drs->GetNumberOfBoards()-1;
|
---|
559 | }
|
---|
560 | else if (NParam==2 && atoi(Param[1])>=0 && atoi(Param[1])<NumBoards) {
|
---|
561 | FirstBoard = atoi(Param[1]);
|
---|
562 | LastBoard = FirstBoard;
|
---|
563 | }
|
---|
564 | else if (NParam==3 && atoi(Param[1])>=0 && atoi(Param[1])<NumBoards &&
|
---|
565 | atoi(Param[2])>0 && atoi(Param[2])<NumBoards) {
|
---|
566 | FirstBoard = atoi(Param[1]);
|
---|
567 | LastBoard = atoi(Param[2]);
|
---|
568 | }
|
---|
569 | else PrintMessage("Cannot address board(s), out of range.\n");
|
---|
570 | CalibrationRead = false;
|
---|
571 | }
|
---|
572 |
|
---|
573 | // Print help (only to console or socket, not to log file)
|
---|
574 | void DAQReadout::cmd_help() {
|
---|
575 | char Buffer[MAX_COM_SIZE];
|
---|
576 | for(unsigned int i=0; i<sizeof(CommandList)/sizeof(CL_Struct); i++) {
|
---|
577 | snprintf(Buffer, sizeof(Buffer), "%s %s", CommandList[i].Name, CommandList[i].Parameters);
|
---|
578 | PrintMessage(CmdFromSocket ? MsgToSocket:MsgToConsole,"%-28s%s\n", Buffer, CommandList[i].Help);
|
---|
579 | }
|
---|
580 | PrintMessage(CmdFromSocket ? MsgToSocket:MsgToConsole,".<command> Execute shell command\n\n"
|
---|
581 | "Items in <> are mandatory, in [] optional, | indicates mutual exclusive or.\n"
|
---|
582 | "Test data can also be written if no DRS boards are available.\n"
|
---|
583 | "Strings containing spaces have to be enclosed in \"double quotes\".\n");
|
---|
584 | }
|
---|
585 |
|
---|
586 | // Exit programm
|
---|
587 | void DAQReadout::cmd_exit() {
|
---|
588 | if (CmdFromSocket) {
|
---|
589 | PrintMessage("Exit command not allowed over socket.\n");
|
---|
590 | return;
|
---|
591 | }
|
---|
592 | if (daq_state==active) PrintMessage("Issue \"stop\" first to stop daq\n");
|
---|
593 | else {
|
---|
594 | Exit = true;
|
---|
595 | if(SocketThread != NULL) pthread_kill(*SocketThread, SIGUSR1);
|
---|
596 | }
|
---|
597 | }
|
---|
598 |
|
---|
599 | // Set/get mode of feedback
|
---|
600 | void DAQReadout::cmd_fmode() {
|
---|
601 | if(Match(Param[1],"off")) HVFB->SetFBMode(FB_Off);
|
---|
602 | if(Match(Param[1],"active")) HVFB->SetFBMode(FB_Active);
|
---|
603 | if(Match(Param[1],"targets")) HVFB->SetFBMode(FB_Targets);
|
---|
604 | HVFB->GetFBMode();
|
---|
605 | }
|
---|
606 |
|
---|
607 | // Set/get current number of events
|
---|
608 | void DAQReadout::cmd_faverage() {
|
---|
609 | if(NParam==1) PrintMessage("Current number of feedback events: %u (acting when %u events are reached)\n",
|
---|
610 | HVFB->GetCurrentCount(), HVFB->GetNumAverages());
|
---|
611 | else if(atoi(Param[1])>=0) HVFB->SetNumAverages(atoi(Param[1]));
|
---|
612 | else PrintUsage();
|
---|
613 | }
|
---|
614 |
|
---|
615 | // Set/get feedback gain
|
---|
616 | void DAQReadout::cmd_fgain() {
|
---|
617 | if(NParam==2) HVFB->SetGain(atof(Param[1]));
|
---|
618 | PrintMessage("Feedback gain is %.2f\n", HVFB->GetGain());
|
---|
619 | }
|
---|
620 |
|
---|
621 | // Set/get target value
|
---|
622 | void DAQReadout::cmd_ftarget() {
|
---|
623 | if(NParam==1) HVFB->GetTargets();
|
---|
624 | else if(NParam!=5) PrintUsage();
|
---|
625 | else for (int i=FirstBoard; i<=LastBoard; i++)
|
---|
626 | for (int j=0; j<kNumberOfChips; j++)
|
---|
627 | for (int k=0; k<kNumberOfChannels; k++)
|
---|
628 | if ((atoi(Param[1])==i || Match(Param[1],"all")) &&
|
---|
629 | (atoi(Param[2])==j || Match(Param[2],"all")) &&
|
---|
630 | (atoi(Param[3])==k || Match(Param[3],"all")))
|
---|
631 | HVFB->SetTarget(i,j,k,atof(Param[4]));
|
---|
632 | }
|
---|
633 |
|
---|
634 | // Start response measurement
|
---|
635 | void DAQReadout::cmd_fresponse() {
|
---|
636 | if(NParam==1) HVFB->GetResponse();
|
---|
637 | else if(atof(Param[1])) HVFB->MeasureResponse(atof(Param[1]));
|
---|
638 | else PrintUsage();
|
---|
639 | }
|
---|
640 |
|
---|
641 | // Print feedback configuration
|
---|
642 | void DAQReadout::cmd_fconfig() {
|
---|
643 | HVFB->PrintConfig();
|
---|
644 | }
|
---|
645 |
|
---|
646 | // ----------------------------------------------
|
---|
647 | // ***** Utility function for DRS control *****
|
---|
648 | // ----------------------------------------------
|
---|
649 |
|
---|
650 | // Start domino wave
|
---|
651 | void DAQReadout::StartDRS() {
|
---|
652 | for (int i=FirstBoard; i<=LastBoard; i++) drs->GetBoard(i)->StartDomino();
|
---|
653 | }
|
---|
654 |
|
---|
655 | // Stop domino wave
|
---|
656 | void DAQReadout::StopDRS() {
|
---|
657 | for (int i=FirstBoard; i<=LastBoard; i++) drs->GetBoard(i)->SoftTrigger();
|
---|
658 | }
|
---|
659 |
|
---|
660 | // Transfer data to memory
|
---|
661 | void DAQReadout::ReadCalibratedDRSData() {
|
---|
662 |
|
---|
663 | for (int i=FirstBoard; i<=LastBoard; i++) {
|
---|
664 | (drs->GetBoard(i))->TransferWaves(kNumberOfChannels*kNumberOfChips);
|
---|
665 | for (int j=0; j<kNumberOfChannels; j++) {
|
---|
666 | drs->GetBoard(i)->GetWave(0, j, WaveForm[i][0][j], true); // Chip #1
|
---|
667 | TriggerCell[i][0] = drs->GetBoard(i)->GetTriggerCell((unsigned int) 0);
|
---|
668 | drs->GetBoard(i)->GetWave(1, j, WaveForm[i][1][j], true); // Chip #2
|
---|
669 | TriggerCell[i][1] = drs->GetBoard(i)->GetTriggerCell((unsigned int) 1);
|
---|
670 | }
|
---|
671 | }
|
---|
672 | }
|
---|
673 |
|
---|
674 | // Read calibration file
|
---|
675 | bool DAQReadout::ReadCalibration() {
|
---|
676 |
|
---|
677 | char dir[MAX_COM_SIZE];
|
---|
678 |
|
---|
679 | getcwd(dir, sizeof(dir));
|
---|
680 | strcat(dir,"/calib");
|
---|
681 | for (int i=FirstBoard; i<=LastBoard; i++) {
|
---|
682 | (drs->GetBoard(i))->SetCalibrationDirectory(dir);
|
---|
683 | PrintMessage("Reading response calibration file for board %d from: \"%s\"\n", i, dir);
|
---|
684 | for (int Chip=0; Chip<kNumberOfChips; Chip++)
|
---|
685 | if (drs->GetBoard(i)->GetResponseCalibration()->ReadCalibration(Chip)==false) {
|
---|
686 | CalibrationRead = false;
|
---|
687 | return false;
|
---|
688 | }
|
---|
689 | }
|
---|
690 | CalibrationRead = true;
|
---|
691 | return true;
|
---|
692 | }
|
---|
693 |
|
---|
694 | // Check if calibration file has been read
|
---|
695 | bool DAQReadout::IsCalibrationRead() {
|
---|
696 |
|
---|
697 | for (int i=FirstBoard; i<=LastBoard; i++) {
|
---|
698 | for (int Chip=0; Chip<kNumberOfChips; Chip++)
|
---|
699 | if (!(drs->GetBoard(i)->GetResponseCalibration()->IsRead(Chip))) {
|
---|
700 | PrintMessage("Warning: Response calibration of board %d chip %d not yet read!\n",i,Chip);
|
---|
701 | return false;
|
---|
702 | }
|
---|
703 | }
|
---|
704 | return true;
|
---|
705 | }
|
---|
706 |
|
---|
707 | // Stop DAQ
|
---|
708 | void DAQReadout::StopRun() {
|
---|
709 |
|
---|
710 | if(daq_state != active) PrintMessage("DAQ is not active.\n");
|
---|
711 | else {
|
---|
712 | Stop = true;
|
---|
713 | PrintMessage("DAQ will stop.\n");
|
---|
714 | }
|
---|
715 | }
|
---|
716 |
|
---|
717 | // Set DOMINO mode
|
---|
718 | void DAQReadout::SetDOMINOMode(int mode) {
|
---|
719 |
|
---|
720 | if (NumBoards)
|
---|
721 | for (int i=FirstBoard; i<=LastBoard; i++) {
|
---|
722 | (drs->GetBoard(i))->SetDominoMode(mode==1 ? 1:0);
|
---|
723 | PrintMessage("Domino mode of board %d switched to %s.\n",i,mode==1 ? "continuous":"single shot");
|
---|
724 | }
|
---|
725 | else PrintMessage("No DRS boards available\n");
|
---|
726 | }
|
---|
727 |
|
---|
728 | // Set DOMINO readout mode
|
---|
729 | void DAQReadout::SetDOMINOReadMode(int mode) {
|
---|
730 |
|
---|
731 | if (NumBoards)
|
---|
732 | for (int i=FirstBoard; i<=LastBoard; i++) {
|
---|
733 | (drs->GetBoard(i))->SetReadoutMode(mode==1 ? 1:0);
|
---|
734 | PrintMessage("Start readout of board %d from %s.\n",i,mode==1 ? "first bin":"stop position");
|
---|
735 | }
|
---|
736 | else PrintMessage("No DRS boards available\n");
|
---|
737 | }
|
---|
738 |
|
---|
739 | // Set DOMINO wave mode
|
---|
740 | void DAQReadout::SetDOMINOWaveMode(int mode) {
|
---|
741 |
|
---|
742 | if (NumBoards)
|
---|
743 | for (int i=FirstBoard; i<=LastBoard; i++) {
|
---|
744 | (drs->GetBoard(i))->SetDominoActive(mode==1 ? 1:0);
|
---|
745 | PrintMessage("Domino wave of board %d is %s during readout\n",i,mode==1 ? "running":"stopped");
|
---|
746 | }
|
---|
747 | else PrintMessage("No DRS boards available\n");
|
---|
748 | }
|
---|
749 |
|
---|
750 | // Delayed start on/off
|
---|
751 | void DAQReadout::SetDelayedStart(int mode) {
|
---|
752 |
|
---|
753 | if (NumBoards)
|
---|
754 | for (int i=FirstBoard; i<=LastBoard; i++) {
|
---|
755 | (drs->GetBoard(i))->SetDelayedStart(mode==1 ? 1:0);
|
---|
756 | PrintMessage("Delayed start of board %d is %s\n",i,mode==1 ? "on":"off");
|
---|
757 | }
|
---|
758 | else PrintMessage("No DRS boards available\n");
|
---|
759 | }
|
---|
760 |
|
---|
761 | // Enable hardware trigger of all boards
|
---|
762 | void DAQReadout::HWTrigger(int mode) {
|
---|
763 |
|
---|
764 | if (NumBoards)
|
---|
765 | for (int i=FirstBoard; i<=LastBoard; i++) {
|
---|
766 | drs->GetBoard(i)->EnableTrigger(mode==1 ? 1:0);
|
---|
767 | PrintMessage("Hardware trigger of board %d %s\n",i,mode==1 ? "enabled":"disabled");
|
---|
768 | }
|
---|
769 | else PrintMessage("No DRS boards available\n");
|
---|
770 | }
|
---|
771 |
|
---|
772 | // Set DRS sampling frequency
|
---|
773 | void DAQReadout::SetDRSFrequency(double freq, bool Regulation) {
|
---|
774 |
|
---|
775 | double currentfreq;
|
---|
776 |
|
---|
777 | PrintMessage("Setting frequency %s regulation:\n",Regulation ? "with":"without");
|
---|
778 | for (int i=FirstBoard; i<=LastBoard; i++) {
|
---|
779 | drs->GetBoard(i)->SetDebug(1);
|
---|
780 |
|
---|
781 | if (Regulation ? drs->GetBoard(i)->RegulateFrequency(freq) : drs->GetBoard(i)->SetFrequency(freq)) {
|
---|
782 | drs->GetBoard(i)->ReadFrequency(0, ¤tfreq);
|
---|
783 | DRSFreq[i] = freq;
|
---|
784 | PrintMessage("Domino wave of board %d is running at %1.3lf GHz\n",i,currentfreq);
|
---|
785 | } else {
|
---|
786 | DRSFreq[i] = 0;
|
---|
787 | PrintMessage("Warning: Domino wave of board %d has changed but not reached the requested value\n",i);
|
---|
788 | }
|
---|
789 | }
|
---|
790 | }
|
---|
791 |
|
---|
792 | // Do internal calibration
|
---|
793 | void DAQReadout::CalibrateDRS(char *dir, double trigfreq, double calibfreq) {
|
---|
794 |
|
---|
795 | int i,j;
|
---|
796 | char str[MAX_COM_SIZE];
|
---|
797 | DIR *pdir;
|
---|
798 |
|
---|
799 | if (NumBoards) {
|
---|
800 | if(dir!=NULL) {
|
---|
801 | if ((pdir=opendir(str))==0){
|
---|
802 | PrintMessage("Error: target directory \"%s\" does not exist!\n",str);
|
---|
803 | return;
|
---|
804 | }
|
---|
805 | closedir(pdir);
|
---|
806 | snprintf(str,sizeof(str),"%s",dir);
|
---|
807 | PrintMessage("Target: \"%s\"\n",str);
|
---|
808 | }
|
---|
809 | else {
|
---|
810 | getcwd(str, sizeof(str));
|
---|
811 | strcat(str,"/calib");
|
---|
812 | PrintMessage("Taking default target: \"%s/\"\n",str);
|
---|
813 | }
|
---|
814 |
|
---|
815 | for (i=FirstBoard; i<=LastBoard; i++) {
|
---|
816 | drs->GetBoard(i)->Init();
|
---|
817 | drs->GetBoard(i)->SetFrequency(calibfreq);
|
---|
818 | drs->GetBoard(i)->SoftTrigger();
|
---|
819 |
|
---|
820 | PrintMessage("Creating calibration of board %d\n", drs->GetBoard(i)->GetCMCSerialNumber());
|
---|
821 |
|
---|
822 | drs->GetBoard(i)->EnableTcal(1);
|
---|
823 | PrintMessage("Tcal enabled");
|
---|
824 |
|
---|
825 | if (drs->GetBoard(i)->GetChipVersion() == 3)
|
---|
826 | drs->GetBoard(i)->GetResponseCalibration()->SetCalibrationParameters(1,21,0,20,0,0,0,0,0);
|
---|
827 | else
|
---|
828 | drs->GetBoard(i)->GetResponseCalibration()->SetCalibrationParameters(1,36,110,20,19,40,15,trigfreq,0);
|
---|
829 |
|
---|
830 | drs->GetBoard(i)->SetCalibrationDirectory(str);
|
---|
831 | PrintMessage("Storage directory \"%s\"\n",str);
|
---|
832 |
|
---|
833 | for (j=0;j<2;j++) {
|
---|
834 | drs->GetBoard(i)->GetResponseCalibration()->ResetCalibration();
|
---|
835 | PrintMessage("Calibration reset done.\n");
|
---|
836 |
|
---|
837 | while (!drs->GetBoard(i)->GetResponseCalibration()->RecordCalibrationPoints(j)) {}
|
---|
838 | PrintMessage("Record calibration points done.\n");
|
---|
839 | while (!drs->GetBoard(i)->GetResponseCalibration()->FitCalibrationPoints(j)) {}
|
---|
840 | PrintMessage("Calibration points fitted.\n");
|
---|
841 | while (!drs->GetBoard(i)->GetResponseCalibration()->OffsetCalibration(j)) {}
|
---|
842 | PrintMessage("Offset calibration done.\n");
|
---|
843 |
|
---|
844 | if (!drs->GetBoard(i)->GetResponseCalibration()->WriteCalibration(j))
|
---|
845 | break;
|
---|
846 | }
|
---|
847 | drs->GetBoard(i)->Init(); // Reset linear range -0.2 ... 0.8 V
|
---|
848 | } // Loop over boards
|
---|
849 | }
|
---|
850 | else PrintMessage("No DRS boards available\n");
|
---|
851 | }
|
---|
852 |
|
---|
853 | // Check if DRS is sampling
|
---|
854 | bool DAQReadout::IsDRSBusy() {
|
---|
855 |
|
---|
856 | for (int i=FirstBoard; i<=LastBoard; i++)
|
---|
857 | if ((drs->GetBoard(i))->IsBusy()) return true;
|
---|
858 | return false;
|
---|
859 | }
|
---|
860 |
|
---|
861 | // Check if DRS frequency is set
|
---|
862 | bool DAQReadout::IsDRSFreqSet() {
|
---|
863 |
|
---|
864 | for (int i=FirstBoard;i<=LastBoard;i++)
|
---|
865 | if (DRSFreq[i]==0) {
|
---|
866 | PrintMessage("DRS sampling frequency of board %d not set!\n",i);
|
---|
867 | return false;
|
---|
868 | }
|
---|
869 | return true;
|
---|
870 | }
|
---|
871 |
|
---|
872 | // Open new raw data file
|
---|
873 | bool DAQReadout::OpenRawFile() {
|
---|
874 |
|
---|
875 | time_t rawtime;
|
---|
876 | struct tm *timeinfo;
|
---|
877 | char RunDate[MAX_COM_SIZE], Buffer[MAX_COM_SIZE];
|
---|
878 |
|
---|
879 | // Write run date to status structure
|
---|
880 | time(&rawtime); timeinfo = localtime(&rawtime);
|
---|
881 | snprintf(RunDate,sizeof(RunDate), "%d%02d%02d",timeinfo->tm_year+1900,timeinfo->tm_mon + 1,timeinfo->tm_mday);
|
---|
882 |
|
---|
883 | // Create direcory if not existing (ignore error if already existing) and change to it
|
---|
884 | snprintf(Buffer, sizeof(Buffer), "%s/%s", fRawDataPath, RunDate);
|
---|
885 | if(mkdir(Buffer, S_IRWXU|S_IRWXG)==-1 && errno!=EEXIST) {
|
---|
886 | PrintMessage("\rError: Could not create direcory \"%s\" (%s)\n", Buffer, strerror(errno));
|
---|
887 | return false;
|
---|
888 | }
|
---|
889 |
|
---|
890 | // Generate filename
|
---|
891 | snprintf(FileName,sizeof(FileName),"%s/%s/%s_%.8u_%s_%c_%d.raw", fRawDataPath, RunDate,
|
---|
892 | RunDate,RunNumber,RHeader->Description,daq_runtype_str[daq_runtype][0],FileNumber);
|
---|
893 |
|
---|
894 | // Open file with rwx right for owner and group, never overwrite file
|
---|
895 | Rawfile = open(FileName,O_WRONLY|O_CREAT|O_EXCL, S_IRWXU|S_IRWXG);
|
---|
896 | if(Rawfile==-1) {
|
---|
897 | PrintMessage("\rError: Could not open file \"%s\" (%s)\n", FileName, strerror(errno));
|
---|
898 | return false;
|
---|
899 | }
|
---|
900 | return true;
|
---|
901 | }
|
---|
902 |
|
---|
903 | // Write run header and board structures (revision number is zero for svn modified working copy)
|
---|
904 | bool DAQReadout::WriteRunHeader() {
|
---|
905 |
|
---|
906 | struct timeval Time;
|
---|
907 |
|
---|
908 | RHeader->MagicNum = MAGICNUM_OPEN;
|
---|
909 | RHeader->DataFormat = DATA_FORMAT;
|
---|
910 | RHeader->SoftwareRevision = atoi(REVISION) * (strchr(REVISION, 'M')==NULL ? 1:-1);
|
---|
911 |
|
---|
912 | RHeader->RunHeaderSize = sizeof(RunHeader);
|
---|
913 | RHeader->EventHeaderSize = sizeof(EventHeader);
|
---|
914 | RHeader->BoardStructureSize = sizeof(BoardStructure);
|
---|
915 |
|
---|
916 | RHeader->Type = daq_runtype;
|
---|
917 | RHeader->RunNumber = RunNumber;
|
---|
918 | RHeader->FileNumber = FileNumber;
|
---|
919 |
|
---|
920 | gettimeofday(&Time, NULL);
|
---|
921 | RHeader->StartSecond = Time.tv_sec;
|
---|
922 | RHeader->StartMicrosecond = Time.tv_usec;
|
---|
923 |
|
---|
924 | RHeader->NBoards = NumBoards==0 && daq_runtype==test ? 1 : (LastBoard - FirstBoard) + 1;
|
---|
925 | RHeader->NChips = kNumberOfChips;
|
---|
926 | RHeader->NChannels = kNumberOfChannels;
|
---|
927 |
|
---|
928 | RHeader->Offset = fFirstSample;
|
---|
929 | RHeader->Samples = fSamples;
|
---|
930 |
|
---|
931 | if(write(Rawfile, RHeader, sizeof(RunHeader)) != sizeof(RunHeader)) {
|
---|
932 | PrintMessage("Error: Could not write run header, terminating run (%s)\n", strerror(errno));
|
---|
933 | return false;
|
---|
934 | }
|
---|
935 |
|
---|
936 | for (int i=FirstBoard; i<=LastBoard; i++) {
|
---|
937 | BStruct[i].SerialNo = drs->GetBoard(i)->GetCMCSerialNumber();
|
---|
938 | BStruct[i].BoardTemp = drs->GetBoard(i)->GetTemperature();
|
---|
939 | BStruct[i].NomFreq = DRSFreq[i];
|
---|
940 | BStruct[i].ScaleFactor = drs->GetBoard(i)->GetPrecision();
|
---|
941 | }
|
---|
942 |
|
---|
943 | // In case no boards are available, dummy data is written for one board structure
|
---|
944 | if (NumBoards == 0) {
|
---|
945 | BStruct[0].NomFreq = 1;
|
---|
946 | BStruct[0].ScaleFactor = 0.1;
|
---|
947 | }
|
---|
948 |
|
---|
949 | if(write(Rawfile, BStruct, sizeof(BoardStructure)*(LastBoard-FirstBoard+1+(NumBoards==0))) != (ssize_t) sizeof(BoardStructure)*(LastBoard-FirstBoard+1+(NumBoards==0))) {
|
---|
950 | PrintMessage("Error: Could not write (all) board structures, terminating run (%s)\n", strerror(errno));
|
---|
951 | return false;
|
---|
952 | }
|
---|
953 | return true;
|
---|
954 | }
|
---|
955 |
|
---|
956 | // Update run header before closing file
|
---|
957 | bool DAQReadout::UpdateRunHeader(unsigned int Events, bool Error) {
|
---|
958 |
|
---|
959 | struct timeval Time;
|
---|
960 |
|
---|
961 | RHeader->MagicNum = Error==false ? MAGICNUM_CLOSED:MAGICNUM_ERROR;
|
---|
962 | RHeader->Events = Events;
|
---|
963 |
|
---|
964 | gettimeofday(&Time, NULL);
|
---|
965 | RHeader->EndSecond = Time.tv_sec;
|
---|
966 | RHeader->EndMicrosecond = Time.tv_usec;
|
---|
967 |
|
---|
968 | if(lseek(Rawfile,0,SEEK_SET)==-1) {
|
---|
969 | PrintMessage("Error: Could not rewind file to write updated run header, terminating run (%s)\n", strerror(errno));
|
---|
970 | return false;
|
---|
971 | }
|
---|
972 |
|
---|
973 | if(write(Rawfile, RHeader, sizeof(RunHeader)) != sizeof(RunHeader)) {
|
---|
974 | PrintMessage("Error: Could not write updated run header, terminating run (%s)\n", strerror(errno));
|
---|
975 | return false;
|
---|
976 | }
|
---|
977 | return true;
|
---|
978 | }
|
---|
979 |
|
---|
980 | // Write event header
|
---|
981 | bool DAQReadout::WriteEventHeader() {
|
---|
982 |
|
---|
983 | struct timeval Time;
|
---|
984 |
|
---|
985 | gettimeofday(&Time, NULL);
|
---|
986 |
|
---|
987 | EHeader->EventNumber = NumEvents;
|
---|
988 | EHeader->TriggerType = (daq_runtype == data) ? 1 : 0;
|
---|
989 | EHeader->Second = Time.tv_sec;
|
---|
990 | EHeader->Microsecond = Time.tv_usec;
|
---|
991 | EHeader->EventSize = sizeof(short)*RHeader->NBoards*RHeader->NChips*RHeader->NChannels*RHeader->Samples +
|
---|
992 | sizeof(int)*RHeader->NBoards*RHeader->NChips;
|
---|
993 |
|
---|
994 | if(write(Rawfile, EHeader, sizeof(EventHeader)) != sizeof(EventHeader)) {
|
---|
995 | PrintMessage("Error: Could not write event header, terminating run (%s)\n", strerror(errno));
|
---|
996 | return false;
|
---|
997 | }
|
---|
998 | return true;
|
---|
999 | }
|
---|
1000 |
|
---|
1001 | // Write event data (It is required that at least three chunks can be written with writev(), therefore
|
---|
1002 | // IOV_MAX>=3 is checked at startup
|
---|
1003 | bool DAQReadout::WriteEventData() {
|
---|
1004 |
|
---|
1005 | unsigned int Start, Count = 0;
|
---|
1006 | ssize_t WriteResult, Size = 0;
|
---|
1007 | struct iovec DataPart[IOV_MAX];
|
---|
1008 |
|
---|
1009 | // First chunk: trigger cells
|
---|
1010 | DataPart[Count].iov_base = TriggerCell + FirstBoard*kNumberOfChips;
|
---|
1011 | DataPart[Count++].iov_len = RHeader->NBoards * kNumberOfChips * sizeof(int);
|
---|
1012 | Size += DataPart[Count-1].iov_len;
|
---|
1013 |
|
---|
1014 | // Remaining chunks: ADC data (two chucks per channel if wrap around of pipeline occurred)
|
---|
1015 | for (int i=FirstBoard; (i<=LastBoard + (NumBoards==0)); i++) {
|
---|
1016 | for (unsigned int k=0; k<RHeader->NChips; k++) {
|
---|
1017 | Start = (TriggerCell[i][k]-fFirstSample+kNumberOfBins) % kNumberOfBins; // Start bin for this chip
|
---|
1018 | for (unsigned int l=0; l<RHeader->NChannels; l++) {
|
---|
1019 | DataPart[Count].iov_base = &WaveForm[i][k][l][Start];
|
---|
1020 | DataPart[Count++].iov_len = (Start+fSamples<kNumberOfBins ? fSamples:(kNumberOfBins-Start)) * sizeof(short);
|
---|
1021 | Size += DataPart[Count-1].iov_len;
|
---|
1022 | // In case second part of waveform still missing, write now
|
---|
1023 | if(DataPart[Count-1].iov_len < fSamples * sizeof(short)) {
|
---|
1024 | DataPart[Count].iov_base = &WaveForm[i][k][l][0];
|
---|
1025 | DataPart[Count++].iov_len = (fSamples-(kNumberOfBins-Start)) * sizeof(short);
|
---|
1026 | Size += DataPart[Count-1].iov_len;
|
---|
1027 | }
|
---|
1028 |
|
---|
1029 | // Write to disk if either maximum size of DataPart[] array or last loop interation is reached
|
---|
1030 | // Possibly 2 chunks are entered in array in the previous lines of code, therefore IOV_MAX-1
|
---|
1031 | if (Count>=IOV_MAX-1 || (l==(RHeader->NChannels-1) && k==(RHeader->NChips-1) && i==(LastBoard+(NumBoards==0)))) {
|
---|
1032 | if ((WriteResult=writev(Rawfile, DataPart, Count)) != (int) Size) {
|
---|
1033 | if (WriteResult==-1) PrintMessage("Error: Could not write event data, terminating run (%s)\n", strerror(errno));
|
---|
1034 | else PrintMessage("Error: Could only write %u out of %u bytes of event data, terminating run\n", WriteResult,Count*DataPart[0].iov_len);
|
---|
1035 | return false;
|
---|
1036 | }
|
---|
1037 | Count = 0; Size = 0;
|
---|
1038 | }
|
---|
1039 | } // Channels
|
---|
1040 | } // Chips
|
---|
1041 | } // Boards
|
---|
1042 | return true;
|
---|
1043 | }
|
---|
1044 |
|
---|
1045 | // Print usage text for command
|
---|
1046 | void DAQReadout::PrintUsage() {
|
---|
1047 | PrintMessage("Usage: %s %s\n", CommandList[CmdNumber].Name, CommandList[CmdNumber].Parameters);
|
---|
1048 | }
|
---|
1049 |
|
---|
1050 | // Print message to selected target
|
---|
1051 | void DAQReadout::PrintMessage(int Target, const char *Format, ...) {
|
---|
1052 | va_list ArgumentPointer;
|
---|
1053 | va_start(ArgumentPointer, Format);
|
---|
1054 | PrintMessage(Target, Format, ArgumentPointer);
|
---|
1055 | va_end(ArgumentPointer);
|
---|
1056 | }
|
---|
1057 |
|
---|
1058 | // Print message to log file, and screen or socket (depending on command origin)
|
---|
1059 | void DAQReadout::PrintMessage(const char *Format, ...) {
|
---|
1060 | va_list ArgumentPointer;
|
---|
1061 | va_start(ArgumentPointer, Format);
|
---|
1062 | if(CmdFromSocket) PrintMessage(MsgToSocket|MsgToLog, Format, ArgumentPointer);
|
---|
1063 | else PrintMessage(MsgToConsole|MsgToLog, Format, ArgumentPointer);
|
---|
1064 | va_end(ArgumentPointer);
|
---|
1065 | }
|
---|
1066 |
|
---|
1067 | // Function doing the actual printing work
|
---|
1068 | void DAQReadout::PrintMessage(int Target, const char *Format, va_list ArgumentPointer) {
|
---|
1069 |
|
---|
1070 | char Textbuffer[MAX_COM_SIZE];
|
---|
1071 |
|
---|
1072 | memset(Textbuffer, 0, sizeof(Textbuffer));
|
---|
1073 | vsnprintf(Textbuffer, sizeof(Textbuffer), Format, ArgumentPointer);
|
---|
1074 |
|
---|
1075 | // Print to console
|
---|
1076 | if(Target & MsgToConsole) {
|
---|
1077 | if(strlen(Textbuffer)>0 && Textbuffer[strlen(Textbuffer)-1]=='\n') {
|
---|
1078 | printf("\r%s%s", Textbuffer, Prompt); // New prompt
|
---|
1079 | fflush(stdout);
|
---|
1080 | }
|
---|
1081 | else printf("%s", Textbuffer);
|
---|
1082 | }
|
---|
1083 | // Print to log file
|
---|
1084 | if((Target & MsgToLog) && Logfile!=NULL) {
|
---|
1085 | fprintf(Logfile, "%s", Textbuffer);
|
---|
1086 | fflush(Logfile);
|
---|
1087 | }
|
---|
1088 | // Print to socket
|
---|
1089 | if((Target & MsgToSocket) && Socket!=-1) write(Socket, Textbuffer, strlen(Textbuffer));
|
---|
1090 | }
|
---|
1091 |
|
---|
1092 |
|
---|
1093 | // ---------------------------------------
|
---|
1094 | // ***** Various utility functions *****
|
---|
1095 | // ---------------------------------------
|
---|
1096 |
|
---|
1097 | // Check if two strings match (min 1 character must match)
|
---|
1098 | bool Match(const char *str, const char *cmd) {
|
---|
1099 | return strncasecmp(str,cmd,strlen(str)==0 ? 1:strlen(str)) ? false:true;
|
---|
1100 | }
|
---|
1101 |
|
---|
1102 | // Return current available storage space in given directory
|
---|
1103 | int CheckDisk(char *Directory) {
|
---|
1104 | struct statfs FileSystemStats;
|
---|
1105 |
|
---|
1106 | statfs(Directory, &FileSystemStats);
|
---|
1107 | return FileSystemStats.f_bavail / 1024 * (FileSystemStats.f_bsize / 1024);
|
---|
1108 | }
|
---|
1109 |
|
---|
1110 | // Parse command line for white space and double-quote separated tokens
|
---|
1111 | int ParseInput(char* Command, const char *Param[]) {
|
---|
1112 | int Count=0;
|
---|
1113 |
|
---|
1114 | while(Count<MAX_NUM_TOKEN) {
|
---|
1115 | while (isspace(*Command)) Command++; // Ignore initial white spaces
|
---|
1116 | if(*Command=='\0') break;
|
---|
1117 | if (*Command == '\"') {
|
---|
1118 | Param[Count] = ++Command;
|
---|
1119 | while(*Command!='\"' && *Command!='\0') Command++;
|
---|
1120 | }
|
---|
1121 | else {
|
---|
1122 | Param[Count] = Command;
|
---|
1123 | while(!isspace(*Command) && *Command!='\0') Command++;
|
---|
1124 | }
|
---|
1125 | if(*Command != '\0') *Command++ = '\0';
|
---|
1126 | Count++;
|
---|
1127 | }
|
---|
1128 | return Count;
|
---|
1129 | }
|
---|
1130 |
|
---|
1131 | // ReadCard function (original version by F. Goebel)
|
---|
1132 | // Data is read into an array if MaxNum is larger than 1
|
---|
1133 | bool ReadCard(const char *card_flag, void *store, char Type, FILE *File, unsigned int MaxNum) {
|
---|
1134 |
|
---|
1135 | char *card_name, *card_val, Buffer[MAX_COM_SIZE];
|
---|
1136 | unsigned int Count=0;
|
---|
1137 |
|
---|
1138 | rewind(File);
|
---|
1139 |
|
---|
1140 | while (fgets(Buffer, sizeof(Buffer), File) != NULL) { // Read line by line
|
---|
1141 | card_name = strtok(Buffer," \t\n");
|
---|
1142 |
|
---|
1143 | // Ignore empty lines, comments, and skip if card name does not match
|
---|
1144 | if (card_name==NULL || card_name[0]=='#' || strcmp(card_name, card_flag)!=0) continue;
|
---|
1145 |
|
---|
1146 | // Read numbers of given type (if MaxNum>1 read array)
|
---|
1147 | while ((card_val=strtok(NULL," \t\n")) != NULL && Count++<MaxNum) {
|
---|
1148 | switch (Type) {
|
---|
1149 | case 'I': *(((int *&) store)++) = (int) strtol(card_val, NULL, 10);
|
---|
1150 | break;
|
---|
1151 | case 'i': *(((short *&) store)++) = (short) strtol(card_val, NULL, 10);
|
---|
1152 | break;
|
---|
1153 | case 'U': *(((unsigned int *&) store)++) = (unsigned int) strtoul(card_val, NULL, 10);
|
---|
1154 | break;
|
---|
1155 | case 'u': *(((unsigned short *&) store)++) = (unsigned short) strtoul(card_val, NULL, 10);
|
---|
1156 | break;
|
---|
1157 | case 'f': *(((float *&) store)++) = atof(card_val);
|
---|
1158 | break;
|
---|
1159 | case 'd': *(((double *&) store)++) = atof(card_val);
|
---|
1160 | break;
|
---|
1161 | case 's': sprintf((char *) store, "%s", card_val);
|
---|
1162 | break;
|
---|
1163 | case 'c': *((char *) store) = card_val[0];
|
---|
1164 | break;
|
---|
1165 | default: fprintf(stderr,"Warning: Unknown type '%c' for reading of configuration file\n", Type);
|
---|
1166 | return false;
|
---|
1167 | }
|
---|
1168 | }
|
---|
1169 | return true; // Finished reading data for card name
|
---|
1170 |
|
---|
1171 | }
|
---|
1172 | fprintf(stderr,"Warning: Configuration value %s not found\n", card_flag);
|
---|
1173 | return false;
|
---|
1174 | }
|
---|
1175 |
|
---|
1176 |
|
---|
1177 | /********************************************************************\
|
---|
1178 |
|
---|
1179 | DAQ Thread
|
---|
1180 |
|
---|
1181 | This thread takes data until the requested number of events is reached,
|
---|
1182 | until no more disk space is available or until data taking is stopped.
|
---|
1183 | No mutex mechanism is used since variables will never be written
|
---|
1184 | simultaneoously by two threads.
|
---|
1185 |
|
---|
1186 | \********************************************************************/
|
---|
1187 |
|
---|
1188 | void DAQ(DAQReadout *m) {
|
---|
1189 |
|
---|
1190 | struct timeval StartTime, StopTime;
|
---|
1191 | unsigned int EventsInFile;
|
---|
1192 | unsigned long long RunSize = 0;
|
---|
1193 | bool WriteError = false;
|
---|
1194 | off_t FileSize;
|
---|
1195 |
|
---|
1196 | m->NumEvents = 0;
|
---|
1197 | m->FileNumber = 0;
|
---|
1198 | m->HVFB->ClearAverages();
|
---|
1199 | gettimeofday(&StartTime, NULL);
|
---|
1200 | m->PrintMessage("\rStarting run #%d (%s) on \"%s\" with %u event(s)\n",m->RunNumber,daq_runtype_str[m->daq_runtype],m->RHeader->Description,m->NumEventsRequested);
|
---|
1201 |
|
---|
1202 | do {
|
---|
1203 | // Check if enough disk space is left
|
---|
1204 | if (CheckDisk(m->fRawDataPath) <= m->fMinDiskSpaceMB+m->fMaxFileSizeMB) {
|
---|
1205 | m->PrintMessage("\rError: Disk space after next file (max. %d MByte) below %d MByte\n",m->fMaxFileSizeMB,m->fMinDiskSpaceMB);
|
---|
1206 | break;
|
---|
1207 | }
|
---|
1208 |
|
---|
1209 | // Init run header, open raw file, write run header
|
---|
1210 | if (!m->OpenRawFile()) break;
|
---|
1211 | m->PrintMessage("\rData file \"%s\" opened.\n",m->FileName);
|
---|
1212 | EventsInFile = 0;
|
---|
1213 | FileSize = 0;
|
---|
1214 |
|
---|
1215 | WriteError |= !m->WriteRunHeader();
|
---|
1216 |
|
---|
1217 | if (m->daq_runtype != test) m->StartDRS();
|
---|
1218 |
|
---|
1219 | // Take data until finished, stopped or file too large
|
---|
1220 | while ((m->NumEvents<m->NumEventsRequested || m->NumEventsRequested==0) &&
|
---|
1221 | !m->Stop && FileSize/1024/1024<m->fMaxFileSizeMB && !WriteError) {
|
---|
1222 |
|
---|
1223 | if (m->daq_runtype == data) while (m->IsDRSBusy()); // Wait for hardware trigger (if DAQ stopped, DRS will not be busy anymore)
|
---|
1224 | else if (m->daq_runtype == pedestal) m->StopDRS(); // ..or for software trigger
|
---|
1225 |
|
---|
1226 | EventsInFile++; m->NumEvents++;
|
---|
1227 | WriteError |= !m->WriteEventHeader();
|
---|
1228 |
|
---|
1229 | // Read event data via VME or generate test data (for one board if no boards available)
|
---|
1230 | if (m->daq_runtype != test) {
|
---|
1231 | m->ReadCalibratedDRSData();
|
---|
1232 | m->StartDRS(); // Restart here: writing data is in parallel to waiting for next trigger
|
---|
1233 | }
|
---|
1234 | else {
|
---|
1235 | double Period = ((double) rand())/RAND_MAX*20;
|
---|
1236 | for (long unsigned int i=0; i<m->RHeader->NBoards*kNumberOfChips*kNumberOfChannels*kNumberOfBins; i++)
|
---|
1237 | *((short *) m->WaveForm+i) = (short) (sin(i/Period)*1000);
|
---|
1238 | }
|
---|
1239 |
|
---|
1240 | // Write data to disk and update file size
|
---|
1241 | WriteError |= !m->WriteEventData();
|
---|
1242 |
|
---|
1243 | if((FileSize = lseek(m->Rawfile, 0, SEEK_CUR)) == -1) {
|
---|
1244 | m->PrintMessage("Error: Could not determine file size, terminating run (%s)\n", strerror(errno));
|
---|
1245 | WriteError = true;
|
---|
1246 | }
|
---|
1247 |
|
---|
1248 | // Call feedback to process event
|
---|
1249 | m->HVFB->ProcessEvent();
|
---|
1250 | }
|
---|
1251 |
|
---|
1252 | // Write updated run header, close file
|
---|
1253 | RunSize += FileSize;
|
---|
1254 | WriteError |= !m->UpdateRunHeader(EventsInFile, WriteError);
|
---|
1255 | if(close(m->Rawfile)==-1) m->PrintMessage("Error: Could not close data file (%s)\n", strerror(errno));
|
---|
1256 | else m->PrintMessage("Data file closed (size %lu MByte).\n", FileSize/1024/1024);
|
---|
1257 |
|
---|
1258 | m->FileNumber += 1;
|
---|
1259 | } while(m->NumEvents<m->NumEventsRequested && !m->Stop && !WriteError);
|
---|
1260 |
|
---|
1261 | // Print run summary to slow data file and to screen
|
---|
1262 | m->StopDRS();
|
---|
1263 | if(!WriteError) {
|
---|
1264 | m->PrintMessage("\rRun #%d (%s) %s, %d events\n",m->RunNumber,daq_runtype_str[m->daq_runtype],(m->NumEvents == m->NumEventsRequested) ? "completed":"stopped",m->NumEvents);
|
---|
1265 | m->SlowDataClass->NewEntry("Runinfo");
|
---|
1266 | m->SlowDataClass->AddToEntry("%d %s %s %d %d",m->RunNumber,daq_runtype_str[m->daq_runtype],m->RHeader->Description,m->NumEvents,m->FileNumber);
|
---|
1267 | }
|
---|
1268 | else m->PrintMessage("\rRun #%d (%s) aborted due to error after %d events\n",m->RunNumber,daq_runtype_str[m->daq_runtype],m->NumEvents);
|
---|
1269 |
|
---|
1270 | // Print run statistics
|
---|
1271 | if (m->NumEvents>0 && !WriteError) {
|
---|
1272 | gettimeofday(&StopTime, NULL);
|
---|
1273 | float RunTime = StopTime.tv_sec-StartTime.tv_sec + (StopTime.tv_usec-StartTime.tv_usec)*1e-6;
|
---|
1274 | m->PrintMessage("Time for run %.2f seconds, trigger rate %.2f Hz.\n", RunTime, m->NumEvents/RunTime);
|
---|
1275 | m->PrintMessage("Run size %llu MByte, data rate %.1f MByte/s.\n", RunSize/1024/1024, RunSize/1024.0/1024/RunTime);
|
---|
1276 | }
|
---|
1277 |
|
---|
1278 | m->daq_state = stopped;
|
---|
1279 | }
|
---|